362 files changed, 138299 insertions, 0 deletions

diff --git a/ext/systemc/AUTHORS b/ext/systemc/AUTHORS
new file mode 100644
index 000000000..c19bf35aa
--- /dev/null
+++ b/ext/systemc/AUTHORS
@@ -0,0 +1,26 @@
+
+        Authors of SystemC
+        ------------------
+
+    John Aynsley                Doulos, Inc.
+    Bishnupriya Bhattacharya    Cadence Design Systems, Inc.
+    David Black                 Doulos, Inc.
+    Gene Bushuyev               Synopsys, Inc.
+    Jerome Cornet               STMicroelectronics
+    Ali Dasdan                  Synopsys, Inc.
+    Alan Fitch                  Doulos, Inc.
+    Abhijit Ghosh               Synopsys, Inc.
+    Andy Goodrich               Forte Design Systems, Inc.
+    Philipp A.Hartmann          OFFIS Institute for Information Technology
+    Ulrich Holtmann             Synopsys, Inc.
+    Martin Janssen              Synopsys, Inc.
+    Vijay Kumar                 CoWare, Inc.
+    Stan Y. Liao                Synopsys, Inc.
+    David Long                  Doulos, Inc.
+    Torsten Maehne              Université Pierre et Marie Curie, Paris
+    Eric Paire                  STMicroelectronics
+    Cesar Quiroz                CoWare, Inc.
+    Amit Rao                    Synopsys, Inc.
+    Harish Sarin                CoWare, Inc.
+    Stuart Swan                 Cadence Design Systems, Inc.
+    Dirk Vermeersch             CoWare, Inc.
diff --git a/ext/systemc/ChangeLog b/ext/systemc/ChangeLog
new file mode 100644
index 000000000..cdd59ddc0
--- /dev/null
+++ b/ext/systemc/ChangeLog
@@ -0,0 +1,51 @@
+See also docs/tlm/ChangeLog.
+
+2014-04-17  Philipp A. Hartmann <philipp.hartmann@offis.de>
+
+	* Combined SystemC 2.3.1 / TLM 2.0.3 officially released.
+
+2012-07-01  Andy Goodrich <acg@forteds.com>
+
+	* Combined SystemC 2.3.0 / TLM-2.0.2 officially released.
+
+2007-03-14  Andy Goodrich <acg@forteds.com>
+
+	* SystemC 2.2 released.
+
+2006-06-05  Andy Goodrich <acg@forteds.com>
+
+	* SystemC 2.2 Beta released to the public.
+
+2005-07-14  Andy Goodrich <acg@forteds.com>
+
+	* SystemC 2.1v1 released.
+
+2003-12-02  Andy Goodrich <acg@forteds.com>
+
+	* SystemC 2.1 Beta-7 released.
+
+2003-06-13  Andy Goodrich <acg@forteds.com>
+
+	* SystemC 2.1 Beta-1 released.
+
+2002-04-05  Martin Janssen  <martin.janssen@synopsys.com>
+
+	* SystemC 2.0.1 released.
+
+2001-10-05  Martin Janssen  <mjanssen@synopsys.com>
+
+	* SystemC 2.0 released.
+
+2001-09-05  Martin Janssen  <mjanssen@synopsys.com>
+
+	* SystemC 2.0 Beta-2 released.
+
+2001-07-13  Martin Janssen  <mjanssen@synopsys.com>
+
+	* SystemC 2.0 Beta-1 released.
+
+2001-02-23 Release 1.0.2 of SystemC
+2000-09-26 Release 1.0.1 of SystemC
+2000-03-28 Release 1.0 of SystemC
+2000-01-31 Release 0.91 of SystemC
+1999-09-27 Release 0.9 of SystemC
diff --git a/ext/systemc/INSTALL b/ext/systemc/INSTALL
new file mode 100644
index 000000000..a5231d489
--- /dev/null
+++ b/ext/systemc/INSTALL
@@ -0,0 +1,765 @@
+                INSTALL NOTES FOR SystemC Release 2.3
+                -------------------------------------
+
+Contents:
+
+        1. Installation Notes for Unix 
+
+        2. Installation Notes for Windows
+
+        3. SystemC Library Configuration Switches
+
+
+1. Installation Notes for Unix
+------------------------------
+
+
+System Requirements
+===================
+
+SystemC can be installed on the following UNIX, or UNIX-like platforms:
+
+  o Linux
+    * Architectures
+      - x86 (32-bit)
+      - x86_64 (64-bit)
+      - x86 (32-bit) application running on x86_64 (64-bit) kernel
+        (../configure --host=i686-linux-gnu)
+    * Compilers
+      - GNU C++ compiler
+      - Clang C++ compiler
+      - or compatible
+
+  o Mac OS X
+    * Architectures
+      - x86 (32-bit)
+      - x86_64 (64-bit)
+      - powerpc (32-bit)   [deprecated]
+      - powerpc64 (64-bit) [deprecated]
+    * Compilers
+      - GNU C++ compiler
+      - Clang C++ compiler
+      - or compatible
+
+  o Solaris
+    * Architectures
+      - SPARC (32-bit)
+    * Compilers
+      - GNU C++ compiler
+      - Sun/Solaris Studio
+
+  o BSD
+    * Architectures
+      - x86 (32-bit)
+      - x86_64 (64-bit)
+    * Compilers
+      - GNU C++ compiler
+      - Clang C++ compiler
+      - or compatible
+
+  o Windows
+    * Compatibility layer
+      - Cygwin
+      - MinGW / MSYS
+    * Architectures
+      - x86 (32-bit)
+      - x86_64 (64-bit)
+    * Compilers
+      - GNU C++ compiler
+      - or compatible
+
+Note: Not all combinations are equally well-tested and some combinations
+      may not work as expected.  Please report your findings by following
+      the instructions in the README file.
+
+The README file contains a list of detailed platforms, architectures,
+and compiler versions that have been used for testing this release.
+
+
+Sources for Compilers and Related Tools
+=======================================
+
+To build, install, and use SystemC on UNIX platforms, you need
+the following tools:
+
+  1. GNU C++ compiler, version 3.4 or later
+     or
+     Clang C++ compiler version 3.0 or later
+
+  2. GNU Make (gmake)
+
+GCC, Clang, and gmake are free software that you can
+obtain from the following sources:
+
+  GCC           http://www.gnu.org/software/gcc/gcc.html
+
+  Clang         http://clang.llvm.org/
+
+  gmake         http://www.gnu.org/software/make/make.html
+
+
+Basic SystemC Installation
+==========================
+
+To install SystemC on a UNIX system, do the following steps:
+
+  1. Change to the top level directory (systemc-2.3.1)
+
+  2. Create a temporary directory, e.g.,
+
+        > mkdir objdir
+
+  3. Change to the temporary directory, e.g.,
+
+        > cd objdir
+
+  4. Choose your compiler by setting the CXX environment variable
+     (the configure script tries to guess the default compiler, if
+      this step is omitted):
+
+     If you use a POSIX-compatible shell (e.g. bash):
+
+        > export CXX="<compiler>"
+
+     e.g. for GCC compilers
+
+        > export CXX=g++
+
+     The Clang compiler is usually named 'clang++', thus e.g.
+
+        > export CXX=clang++
+
+     When using a C shell (e.g. csh/tcsh), the syntax to set the
+     environment variable is different:
+
+        > setenv CXX g++
+
+     For the Sun/Solaris Studio compilers, use
+
+        > setenv CXX CC
+
+     You can also specify an absolute path to the compiler of your choice.
+
+     See also the Section "Compilation and Linking Options" below.
+
+
+  5. Configure the package for your system, e.g.,
+     (The configure script is explained below.)
+
+        > ../configure
+
+     While the 'configure' script is running, which takes a few moments, 
+     it prints messages to inform you of the features it is checking.
+     It also detects the platform.
+     
+     Note for System V users: 
+     If you are using `csh' on an older version of System V, you might 
+     need to use the `sh ../configure' command instead of '../configure'.
+     Otherwise, `csh' will attempt to `configure' itself.
+
+     SystemC 2.3 includes a fixed-point package that is always built.
+     When compiling your applications with fixed-point types, you still have
+     to use compiler flag -DSC_INCLUDE_FX. Note that compile times increase
+     significantly when using this compiler flag.
+
+     In case you want to install the package in another place than the
+     top level directory (systemc-2.3.1), configure the package e.g. as
+     follows:
+
+        > ../configure --prefix=/usr/local/systemc-2.3.1
+
+     Note: make sure you have created the target directory before installing
+           the package. Do _not_ use /usr/local as a prefix, unless you
+           follow the Unix/FHS directory layouts (see below).
+
+     A fine grained configuration of the installation directories can
+     be achieved via additional options, given to the configure script.
+
+     By default, the files are installed directly to the PREFIX directory
+     root and the library is installed to PREFIX/lib-<TARGETARCH>,
+     depending on the current target architecture.  This may be undesired
+     in cases where the package is meant to be installed in a system-wide
+     location as part of shared (default) library and include hierarchies
+     (e.g. /usr/local, /usr, /opt, ...).  To follow the Unix/FHS directory
+     standards, you can use the following options:
+
+       --with-unix-layout     use Unix directory layout for installation
+                              [default=no]
+         when "yes", the following (fine-grained) settings will be used:
+
+       --includedir=DIR       C++ header files      [PREFIX/include]
+       --libdir=DIR           object code libraries [EPREFIX/lib]
+       --docdir=DIR           documentation root    [DATAROOTDIR/doc/systemc]
+
+     The library destination itself can be further and separately configured
+     by using the following option:
+
+       --with-arch-suffix     add suffix to library installation directory
+                              [default=-<TARGETARCH>]
+
+     With this option, one can easily follow e.g. the "multi-arch"
+     conventions on some platforms:
+
+       ../configure --with-arch-suffix=32                # lib32
+       ../configure --with-arch-suffix=/x86_64-linux-gnu # lib/x86_64-linux-gnu
+
+
+
+     Several options are available to the configure script to modify
+     the compiler configuration and the selection of certain features:
+
+       --disable-shared        do not build shared library (libsystemc.so)
+       --enable-debug          include debugging symbols
+       --disable-optimize      disable compiler optimization
+       --disable-async-updates disable request_async_update support
+       --enable-pthreads       use POSIX threads for SystemC processes
+       --enable-phase-callbacks
+                               enable simulation phase callbacks (experimental)
+
+
+     See the section on the general usage of the configure script and
+     "../configure --help" for more information.
+
+     Note: If you change the configuration after having compiled the
+           package already, you should run a "gmake clean" before
+           recompiling.
+
+  6. Compile the package.
+
+        > gmake
+
+     Note: The explicit gmake targets "opt" and "debug", etc. have
+           been removed in this package.  Use the corresponding
+           options to the configure script instead.
+
+  7. At this point you may wish to verify the compiled package by
+     testing the example suite.
+
+        > gmake check
+
+     This will compile and run the examples in the subdirectory
+     examples.
+
+  8. Install the package.
+
+        > gmake install
+
+  9. You can now remove the temporary directory, .e.g,
+
+        > cd ..
+        > rm -rf objdir
+
+     Alternatively, you can keep the temporary directory to allow you to:
+
+     a) Experiment with the examples.
+
+     b) Later uninstall the package. To clean up the temporary 
+        directory, enter:
+
+            > gmake clean
+
+        To uninstall the package, enter:
+
+            > gmake uninstall
+
+
+Running the Examples
+====================
+
+Copies of the examples reside in the temporary directory - see
+instruction 7 above for details on building and running them.
+
+In addition, a copy of the example code resides in the directory
+examples at the highest level of the installation (or in the
+shared documentation install directory).
+
+Use the makefiles provided in  the 'examples' directory as templates 
+for makefiles you need for compiling your own examples.
+
+
+Using the Configure Script
+==========================
+ 
+The `configure' shell script tries to determine the correct values for
+various system-dependent variables used during compilation. It uses
+these values to create a `Makefile' in each directory of the package.
+It also creates one or more `.h' files containing system-dependent
+definitions if needed. Then, it creates the following files:
+
+  config.status         A shell script that you can run at another time to
+                        recreate the current configuration.
+
+  config.cache          A file in which the configure test results are
+                        saved to speed up reconfiguration.
+
+                        Data is appended to the config.cache file. 
+                        You can remove unwanted data.
+
+  config.log            A file in which compiler output is saved.
+                        This is used to debug the configure script.
+
+If you need to use other commands to successfully compile the package
+on your system, please try to determine if the configure script can be used 
+for these commands. Then, send either a diff file or instructions about
+the commands you used to the email address provided in the README file.
+This information will be used to improve the installation process in
+the next release.
+
+The `configure.ac' file is provided in case you want to change or regenerate
+the `configure' script, for example to use a newer version of `autoconf'. 
+The `configure.ac' file is used by the `autoconf' program to create the
+`configure' script.
+
+Note for (key) developers:
+
+  In case you have changed the `configure.ac' file or one of the
+  `Makefile.am' files:
+
+  - Use the `config/distclean' script to remove the generated `configure'
+    script, the generated `aclocal.m4' file and the generated `Makefile.in'
+    files.
+
+  - Use the `config/bootstrap' script to generate the `configure' script
+    and the necessary `Makefile.in' files. This script makes use of the
+    GNU auto-tools `aclocal', `automake', and `autoconf'.
+
+
+Compilation and Linking Options
+===============================
+
+Some systems require compilation or linking options that the `configure'
+script does not define. You can define the initial values for these
+options by setting them in your environment before running the
+`configure' script.
+
+Instead of passing the variables via the environment, it is preferred
+to pass the values as options to the configure script:
+
+  > ../configure CXX=g++-4.4 LIBS=-lposix
+
+
+Specifying the System Type
+==========================
+
+Some features cannot be automatically determined by `configure' unless
+it can detect the host type on which the package will run.
+If it prints a message that it cannot determine the host type, 
+use the `--host=TYPE' option to define it. TYPE can either be a 
+short system name, such as `sun4', or a canonical name with three fields:
+
+     CPU-COMPANY-SYSTEM
+
+See the `config.sub' file for details about the values of each field. If
+the `config.sub' file is not included in the package, the package does not
+need to know the host type.
+
+If you are building compiler tools for cross-compiling, you can also
+use the `--target=TYPE' option to select the type of system for which
+the code is produced and the `--build=TYPE' option to select the type of
+system on which you are compiling the package.
+
+
+Sharing Defaults
+================
+
+You can set the default values that `configure' scripts share by
+creating a site shell script called `config.site'. This file contains the
+default values for variables like `CC', `cache_file', and `prefix'.
+The `configure' script looks for the `config.site' file in the following 
+search precedence:
+
+  1. PREFIX/share/config.site
+
+  2. PREFIX/etc/config.site
+
+Alternatively, you can set the `CONFIG_SITE' environment variable to the
+site script path.
+
+Note: The `configure' script for some systems does not look for a site script.
+
+
+Operation Controls
+==================
+
+The `configure' script recognizes the following additional options to control
+its operation:
+
+`--cache-file=FILE'
+        Use and save the test results in FILE instead of
+        `./config.cache'. Set FILE to `/dev/null' to disable caching
+        when debugging `configure'.
+
+`--help'
+        Print a summary of `configure' options and exit.
+
+`--quiet'
+`--silent'
+`-q'
+        Do not print messages about checks being made.
+        To suppress all normal output, redirect it to `/dev/null'.
+        Error messages continue to print.
+
+`--srcdir=DIR'
+        Look for the package's source code in directory DIR.
+        Typically `configure' determines the directory automatically.
+
+`--version'
+        Print the version of `autoconf' used to generate the `configure'
+        script and exit.
+
+Other options that are rarely used are available in the `configure' script.
+Use the `--help' option to print a list.
+
+
+
+2. Installation Notes for Windows
+---------------------------------
+
+This release has been tested on Visual C++ versions 2005 through 2013,
+running on Windows 7.
+
+
+Note: This section covers the installation based on Microsoft Visual C++.
+      For Cygwin or MinGW-based installations, see Section 1.
+
+
+Note: If you experience spurious errors about missing files in the
+      downloaded archive, please make sure to either download the
+      ZIP archive from accellera.org or use a reliable archive software,
+      fully supporting modern tar archive versions.
+
+      Some paths in the SystemC archive are longer than the historical
+      99 character limit, and several Windows archivers (e.g. WinZip)
+      have been reported to trip over this.  The open source archiver
+      7-zip (http://7-zip.org) is known to work.
+
+
+Microsoft Visual C++ 2005 (compiler version 8.0) or later
+---------------------------------------------------------
+
+The download directory contains two subdirectories: 'msvc80' and
+'examples'.
+
+The 'msvc80' directory contains the project and workspace files to
+compile the 'systemc.lib' library. Double-click on the 'SystemC.sln'
+file to launch Visual C++ 2005 with the workspace file. The workspace file
+will have the proper switches set to compile for Visual C++ 2005.
+Select `Build SystemC' under the Build menu or press F7 to build
+`systemc.lib'.
+
+The `examples' directory contains the project and workspace files to
+compile the SystemC examples. Go to one of the examples subdirectories
+and double-click on the .vcproj file to launch Visual C++ with the
+workspace file. The workspace file will have the proper switches set
+to compile for Visual C++ 2005. Select 'Build <example>.exe' under the
+Build menu or press F7 to build the example executable.
+
+For convenience, a combined solution file 'SystemC-examples.sln' with
+all example projects can be found in the 'msvc80' directory.  A similar
+solution file for the TLM examples is located in 'examples/tlm/build-msvc'.
+
+The provided project files are prepared for both the 32-bit 'Win32' and
+64-bit 'x64' configurations.  Please refer to the Microsoft Visual Studio
+documentation for details about 64-bit builds.
+
+
+Creating SystemC Applications
+-----------------------------
+
+1. Start Visual Studio. From the Start Page select New Project and Win32 
+   Console Project. Type the project name and select a suitable location 
+   then click OK.
+
+2. Select the Application Settings page of the Win32 Application Wizard 
+   and make sure the 'Empty project' box is ticked. Click 'Finish' to 
+   complete the wizard.
+   
+3. Add new/existing C++ files to the project and edit code.
+
+4. Display the project Property Pages by selecting 'Properties...' from 
+   the Project menu. 
+   
+5. From the C/C++ tab, select the General properties and set 
+   'Detect 64-bit Portability Issues' to No
+
+6. From the C/C++ tab, select the Language properties and set 
+   'Enable Run-Time Type Info' to Yes
+
+7. From the C/C++ tab, select the Command Line properties and add /vmg
+   to the 'Additional Options:' box.
+
+8. From the Linker tab, select the Input properties and type 'systemc.lib' 
+   in the 'Additional Dependencies' box.
+
+9. Click OK
+
+
+Also make sure that the compiler and linker can find the SystemC header 
+and library files respectively. There are two ways to do this:
+
+To update the include file and library directory search paths for all
+projects:
+
+1. Select Tools -> Options... and the Projects -> VC++ Directories tab
+   
+2. Select show directories for: Library files
+
+3. Select the 'New' icon and browse to: C:\systemc-2.3.1\msvc80\systemc\debug
+
+4. Select show directories for: Include files
+
+5. Select the 'New' icon and browse to: C:\systemc-2.3.1\src
+
+To add the include file and library directory search paths for the current
+project only:
+
+1. Display the project Property Pages by selecting 'Properties...' from 
+   the Project menu. 
+
+2. From the C/C++ tab, select the General properties and type the path to the 
+   SystemC 'src' directory in the text entry field labeled
+  'Additional include directories' (e.g. the examples use '..\..\..\src').
+
+3. From the Linker tab, select the General properties and type the path to 
+   the SystemC library:   ...\systemc-2.3.1\msvc80\systemc\debug'systemc.lib' 
+   in the 'Additional Library Directories:' box.
+
+9. Click OK
+
+
+
+
+3. SystemC Library Configuration Switches
+-----------------------------------------
+
+In addition to the explicitly selectable feature given as options to
+the `configure' script (see 1.), some aspects of the library
+implementation can be controlled via
+
+ - preprocessor switches given during library build
+ - preprocessor switches added while building a SystemC application
+ - environment variables
+
+The currently supported switches are documented in this section.
+
+Preprocessor switches
+=====================
+
+Additional preprocessor switches for the library build can be passed
+to the configure script via the CXXFLAGS variable:
+
+  ../configure CXXFLAGS="-DSC_OVERRIDE_DEFAULT_STACK_SIZE=0x80000"
+
+In Visual C++, the preprocessor symbols can be added to the project
+configuration via the 'C/C++' tab under the 'Preprocessor' properties
+in the 'Preprocessor definitions' setting.
+
+
+ * SC_DEFAULT_WRITER_POLICY=<sc_writer_policy> -
+   Override default value for the signal writer policy
+
+   This setting allows deactivating the multiple writer checks for
+   sc_signals at (application) compile time.  This mechanism supersedes
+   the old environment variable SC_SIGNAL_WRITE_CHECK (see below).
+
+   Supported values:
+      SC_ONE_WRITER        (default)
+      SC_MANY_WRITERS      (allow multiple writers in different deltas)
+      SC_UNCHECKED_WRITERS (non-standard, disable all checks)
+
+   Note: Only effective when building an application.
+
+   Note: This setting needs to be consistently set across all
+         translation units of an application.
+
+
+ * SC_DISABLE_ASYNC_UPDATES -
+   Exclude the "async_request_update" support
+
+   Note: This option is usually set by the `configure` option
+     --disable-async-update, or
+     --enable-async-update=no
+
+   On non-Automake platforms (e.g. Visual C++), this preprocessor
+   symbol can be used to manually build the library with this feature.
+
+   Note: Only effective during library build.
+
+
+ * SC_DISABLE_VIRTUAL_BIND - 
+   Keep the "bind" function of sc_ports non-virtual
+
+   When this symbol is defined, the "bind" function in sc_ports is
+   kept non-virtual (although it is required to be 'virtual' since
+   IEEE 1666-2011).
+
+   Note: This symbol needs to be consistently defined in the library
+         and any application linking against the built library.
+
+
+ * SC_DISABLE_COPYRIGHT_MESSAGE -
+   Do not print the copyright message when starting the application
+
+   Note: This does not remove the copyright from the binary.
+         sc_core::sc_copyright() still works as expected.
+   Note: Only effective during library build.
+   See : Environment variable SC_COPYRIGHT_MESSAGE
+
+
+ * SC_ENABLE_IMMEDIATE_SELF_NOTIFICATIONS -
+   Allow a process to trigger itself immediately
+
+   Allow a method process to trigger itself immediately by using
+      next_trigger( ev ); // or a static sensitivity
+      ev.notify();
+
+   This behaviour has been disabled by default in IEEE 1666-2011 and
+   can be reenabled by this option.
+
+   Note: Only effective during library build.
+
+
+ * SC_ENABLE_EARLY_MAXTIME_CREATION -
+   Allow creation of sc_time objects with a value of sc_max_time()
+   before finalizing the time resolution
+
+   In IEEE 1666-2011, it is not allowed to create sc_time objects with
+   a non-SC_ZERO_TIME value before setting/changing the time resolution.
+
+   This preprocessor switch activates an extension to allow the
+   initialization of sc_time variables with sc_max_time() while
+   still accepting changes to the time resolution afterwards.
+
+     sc_time t = sc_max_time();
+     sc_set_time_resolution( 1, SC_NS ); // OK, with this extension
+
+   The time resolution will still be fixed, once you have explicitly or
+   implicitly relied on the physical value (i.e. the relation to seconds)
+   of any sc_time object.
+
+   Note: Only effective during library build.
+
+
+ * SC_ENABLE_SIMULATION_PHASE_CALLBACKS         (experimental)
+   SC_ENABLE_SIMULATION_PHASE_CALLBACKS_TRACING (experimental) -
+   Enable a generic simulation phase callback mechanism.
+
+   Note: This option is usually set by the `configure` option
+     --enable-phase-callbacks, or
+     --enable-phase-callbacks=tracing
+
+   See the RELEASENOTES for more information about this feature.
+
+   The *_TRACING variant of this flag enables the sc_trace
+   implementation use these callbacks, instead of hard-coded updates
+   from the main simulator loop.
+
+   Note: Setting tracing flag includes the generic phase callback
+         infrastructure automatically.
+   Note: Only effective during library build.
+
+
+ * SC_INCLUDE_DYNAMIC_PROCESSES -
+   Enable dynamic process support (sc_spawn, sc_bind)
+
+   To improve compilation times, the functions for spawing dynamic
+   processes are not included by default in an SystemC application.
+
+   Define this symbol before including the SystemC header in your
+   application, if you want to use dynamically spawned processes.
+
+   Note: Can be optionally set per translation unit in an application.
+
+   Note: Some TLM convenience sockets require this feature and define
+         the symbol for you if needed.
+
+
+ * SC_INCLUDE_FX -
+   Enable SystemC fix-point datatypes
+
+   To improve compilation times, the fixpoint datatypes are not enabled
+   by default in an SystemC application.
+
+   Define this symbol before including the SystemC header in your
+   application, if you want to use the SystemC fixpoint types.
+
+   Note: Is by default always defined during the library build to enable
+         later use of the fixpoint datatypes in an application.
+
+   Note: Can be optionally set per translation unit in an application.
+
+
+ * SC_INCLUDE_STRSTREAM -
+   Include (deprecated) <strstream> header from <systemc.h>
+
+   Pre-standard C++ compilers had support for an old stringstream
+   implementation called 'strstream'.  In the unlikely case that your
+   application still relies on this deprecated class and that <systemc.h>
+   includes this header for you automatically, you now need to define this
+   symbol when building your application.
+
+   Note: Only effective when building an application.
+
+
+ * SC_INCLUDE_WINDOWS_H -
+   Explicitly include <windows.h> header from <systemc> header
+
+   Previous versions of SystemC always included the full <windows.h>
+   header on all Windows platforms.  This adds unnecessary bloat to
+   many SystemC applications, reducing compilation times.
+
+   If you rely on the inclusion of the <windows.h> header in your
+   application, you can add this symbol to the list of preprocessor
+   switches for your compiler.
+
+   Note: Only effective when building an application.
+
+
+ * SC_OVERRIDE_DEFAULT_STACK_SIZE=<size> -
+   Define the default stack size used for SystemC (thread) processes
+
+   Note: Only effective during library build.
+
+
+ * SC_USE_SC_STRING_OLD / SC_USE_STD_STRING -
+   Define 'sc_string' symbol.
+
+   Pre-IEEE-1666 versions of SystemC included an 'sc_string' class for
+   string objects.  This class has been superseeded by 'std::string' these
+   days.
+
+   If your application still relies on 'sc_string' being available, set one
+   of the two supported preprocessor switches to provide it:
+
+   SC_USE_SC_STRING_OLD -
+     Uses old implementation `sc_string_old' to provide `sc_string':
+       typedef sc_string_old sc_string; 
+
+   SC_USE_STD_STRING -
+     Provide `sc_string' as an alias to `std::string':
+       typedef std::string sc_string;
+
+
+Influential environment variables
+=================================
+
+Currently, three environment variables are checked at library load time
+and influence the SystemC library's behaviour:
+
+ 1) SC_COPYRIGHT_MESSAGE=DISABLE -
+    Run-time alternative to SC_DISABLE_COPYRIGHT_MESSAGE (see above).
+
+ 2) SC_SIGNAL_WRITE_CHECK=DISABLE
+    Run-time alternative to SC_DEFAULT_WRITER_POLICY=SC_UNCHECKED_WRITERS
+    (see above)
+
+ 3) SC_DEPRECATION_WARNINGS=DISABLE
+    Do not issue warnings about using deprecated features as of
+    IEEE 1666-2011.
+
+Usually, it is not recommended to use any of these variables in new or
+on-going projects.  They have been added to simplify the transition of
+legacy code.
+
+
+// Taf!
diff --git a/ext/systemc/LICENSE b/ext/systemc/LICENSE
new file mode 100644
index 000000000..d64569567
--- /dev/null
+++ b/ext/systemc/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/ext/systemc/NEWS b/ext/systemc/NEWS
new file mode 100644
index 000000000..49aa2fdc7
--- /dev/null
+++ b/ext/systemc/NEWS
@@ -0,0 +1,107 @@
+* SystemC 2.3.1a
+  Relicensed under Apache License, Version 2.0.
+  No functional changes.
+
+* SystemC 2.3.1
+  Release of SystemC 2.3.1
+  - Bug fixes.
+  - Code cleanup.
+  - Some experimental new features.
+
+* SystemC 2.3.0
+  Release of SystemC 2.3.0
+  - Compliance to IEEE Std 1666-2011
+  - Per LRM, includes TLM-2.0.2
+  - Bug fixes.
+  - Code cleanup.
+
+* SystemC 2.2
+  Production release of SystemC 2.2
+  - Compliance to IEEE Std 1666-2005
+
+* SystemC 2.2 Beta
+  Beta release of SystemC 2.2
+  - Bug fixes.
+  - Code cleanup.
+  - Major new functionality
+    o Compliance with the IEEE 1666 SystemC Language reference module.
+  - Platforms and compilers supported (added since 2.1):
+    o Support for 64-bit Linux systems gcc-3.4.3.
+    o Linux with GNU C++ compiler version gcc-4.0.1.
+    o MacOS X with GNU C++ compiler version gcc-4.0.0.
+
+* SystemC 2.1 
+  Release of SystemC 2.1
+  - Bug fixes.
+  - Code cleanup.
+  - Major new functionality
+    o Dynamic process support, including synchronization primitives.
+    o Mixed concatenation and concatenation of long types.
+    o Event queue support.
+    o Exported interfaces: sc_export.
+    o New error reporting API.
+  - Platforms and compilers supported (added since 2.0.1 Production):
+    o Solaris 2.8 with Sun CC compiler version Forte 7 and gcc-3.2.3
+    o Linux (Redhat 9.0) with GNU C++ compiler version gcc-3.2.2
+    o Linux (Redhat 8.0) with GNU C++ compiler version gcc-2.95.3 and gcc-3.2.3
+    o MacOS X with GNU C++ compiler version gcc-3.1 and gcc-3.3.
+    o Windows NT 4.0 (SP6a) with VC++ 7.0 
+
+* SystemC 2.0.1 
+  Production release of SystemC 2.0.1
+  - Bug fixes.
+  - Code cleanup.
+  - Simple bus example included.
+  - Platforms supported (changed from 2.0 Production):
+    o Sun Solaris 2.7 and 2.8 with GNU C++ compiler version gcc-2.95.3
+    o Linux (Redhat 6.2) with GNU C++ compiler version gcc-2.95.3
+    o Linux (Redhat 7.2) with GNU C++ compiler version gcc-2.95.3
+    o HP-UX 11.00 with HP C++ compiler version A.03.33
+      (Note: +O1 is the highest safe optimization level)
+    o Windows NT 4.0 (SP6a) with VC++ 6.0 (SP5)
+  - First release of a regression test suite for SystemC.
+    The SystemC regression test suite is released separately.
+
+* SystemC 2.0
+  Production release of SystemC 2.0.
+  - All new SystemC 2.0 core language features.
+  - All SystemC 1.0.2 functionality (except obsoleted SystemC 0.9 features).
+  - No methodology-specific channels as in SystemC 1.2.1 beta.
+    (Note: starting with this release, the 2.0 Core Language Features
+     will be released separately from the methodology-specific libraries,
+     an example of which is the Master-Slave Library of 1.2.1 beta.
+     The release of the Master-Slave Library will follow this release.
+     You would be able to use the Master-Slave Library in conjunction with
+     this release). 
+  - Dynamic thread creation example provided.
+  - Directory structure changed from 1.0.2, but same as 2.0 beta-2.
+  - Build process changed from 1.0.2 but same as 2.0 beta-2.
+  - Bug fixes for 2.0 beta-2.
+  - Platforms supported (changed from 2.0 beta-2):
+    o Sun Solaris 2.7 and 2.8 with GNU C++ compiler version 2.95.2
+    o Sun Solaris 2.7 and 2.8 with SC6.1 and SC6.2
+    o Linux (Redhat 6.2) with GNU C++ compiler version 2.95.2
+    o HP-UX 11.00 with aCC C++ compiler versions A.03.31 and A.03.15
+      (Note: +O1 is the highest safe optimization level)
+    o Windows NT 4.0 (SP3 and higher) with VC++6.0
+
+* SystemC 2.0 Beta-2
+  Second beta release of SystemC 2.0.
+
+* SystemC 2.0 Beta-1
+  First beta release of SystemC 2.0.
+
+* SystemC 1.0.2
+  Bug fix release.
+
+* SystemC 1.0.1
+  Bug fix release.
+
+* SystemC 1.0
+  First release of new SystemC syntax and fixed-point package.
+
+* SystemC 0.91
+  Second release of SystemC.
+
+* SystemC 0.9
+  This is the first release of SystemC.
diff --git a/ext/systemc/NOTICE b/ext/systemc/NOTICE
new file mode 100644
index 000000000..b42be393f
--- /dev/null
+++ b/ext/systemc/NOTICE
@@ -0,0 +1,66 @@
+=========================================================================
+==  NOTICE file corresponding to section 4 d of the Apache License,    ==
+==  Version 2.0, in this case for the SystemC Class Library            ==
+==  Proof of Concept implementation                                    ==
+=========================================================================
+ 
+This product includes software developed by Accellera Systems Initiative
+8698 Elk Grove Bldv Suite 1, #114, Elk Grove, CA 95624, USA
+Copyright 2011-2016 Accellera Systems Initiative Inc. (Accellera) 
+All rights reserved.
+
+This product includes software developed by Cadence Design Systems Inc.
+2655 Seely Ave., San Jose, CA, USA
+Copyright 2006-2016 Cadence Design Systems Inc.
+All rights reserved.
+
+This product includes software developed by Circuitsutra Technologies Pvt Ltd.
+Regus, Ground Floor, Tapasya Corp Heights, Sector 126, Noida, 201303, UP, India
+Copyright 2011-2016 Circuitsutra Technologies Pvt Ltd.
+All rights reserved.
+
+This product includes software developed by Doulos
+Church Hatch, 22 Market Place, Ringwood, Hampshire, BH24 1AW, United Kingdom
+Copyright 2006-2016 Doulos
+All rights reserved.
+
+This product includes software developed by Fraunhofer-Gesellschaft 
+Postfach 20 07 33, 80007 Munich, Germany 
+Copyright 2014-2016 Fraunhofer-Gesellschaft
+All rights reserved.
+
+This product includes software developed by Intel Corp.
+2200 Mission College Blvd., Santa Clara, CA 95054-1549, USA
+Copyright 2007-2016 Intel Corp.
+All rights reserved. 
+
+This product includes software developed by Mentor Graphics Corporation
+8005 SW Boeckman Road, Wilsonville, OR 97070, USA
+Copyright 2006-2016 Mentor Graphics Corporation
+All rights reserved.
+
+This product includes software developed by OFFIS eV
+Escherweg 2, 26121 Oldenburg, Germany
+Copyright 2009-2016 OFFIS eV
+All rights reserved. 
+
+This product includes software developed by STMicroelectronics International NV
+39, Chemin de Champ-des-Filles, Plan-Les-Ouates, Geneva, Switzerland
+Copyright 2011-2016 STMicroelectronics International NV
+All rights reserved. 
+
+This product includes software developed by Synopsys, Inc.
+690 East Middlefield Road Mountain View, CA 94043, USA
+Copyright 1999-2016 Synopsys, Inc.
+All rights reserved. 
+
+This product includes software developed by Universite Pierre et Marie Curie
+b.c. 167, 4 place Jussieu, 75252 Paris, France
+Copyright 2011-2016 Universite Pierre et Marie Curie (UPMC) 
+All rights reserved. 
+
+This product includes software developed by XtremeEDA Corporation
+201-1339 Wellington St. West, Ottowa, Ontario K1Y3B8, Canada
+Copyright 2011-2016 XtremeEDA Corporation. All rights reserved.
+
+
diff --git a/ext/systemc/README.gem5.md b/ext/systemc/README.gem5.md
new file mode 100644
index 000000000..b966b7d65
--- /dev/null
+++ b/ext/systemc/README.gem5.md
@@ -0,0 +1,21 @@
+Overview
+========
+
+This subfolder (/ext/systemc)  is a custom redistribution of the Accellera
+SystemC 2.3.1 library [[1]][sysc]. This distribution replaces Accellera's
+Autoconf build system with a SCons build system, which is used by gem5.
+
+In the past it happened several times that some changes in gem5 broke the
+SystemC coupling. Recently Accelera has changed the licence for SystemC from
+their own licence to Apache2.0, which is compatible with gem5. However, SystemC
+usually relies on the Boost library. The repository contains all the source
+files from the Accellera distribution, but strips down the boost dependencies,
+shown here:[[3]][strip]. All references to the boost library are replaced by
+calls to the C++11 STL. This repository also contains the TLM 2.0
+protocol-checker from Doulos [[4]][doulos].
+
+
+[sysc]: http://accellera.org/downloads/standards/systemc
+[gem5]: http://www.gem5.org/Main_Page
+[doulos]: https://www.doulos.com/knowhow/systemc/tlm2/base_protocol_checker/
+[strip]: https://github.com/tud-ccc/systemc-scons/commit/913a7451939dc4d4bd752df7081064f9f870517a
diff --git a/ext/systemc/README.md b/ext/systemc/README.md
new file mode 100644
index 000000000..d4b084591
--- /dev/null
+++ b/ext/systemc/README.md
@@ -0,0 +1,43 @@
+Overview
+========
+
+This repository is a redistribution of the Accellera SystemC 2.3.1 library
+[[1]][sysc]. This distribution replaces Accellera's Autoconf build system with
+a SCons build system, which is very useful for integration of SystemC in other
+SCons based projects, e.g., gem5 [[2]][gem5].
+
+The repository contains all the source files from the Accellera distribution,
+but strips down the boost dependencies. All references to the boost library
+are replaced by calls to the C++11 STL. This repository also contains the
+TLM 2.0 protocl checker from Doulos [[3]][doulos].
+
+Build
+=====
+
+To build libsystemc-2.3.1.so, simply type scons. Optionally you can specify the
+number of jobs.
+
+```
+scons -j N
+```
+
+To build and link to SystemC from another SCons project, simply call the
+SConscript located in `src/`. Be sure to add `-std=c++11` to the `CXXFLAGS` of
+your environment and to export the environment as `'env'`. In case you build on
+OS X, you will need to add `-undefined dynamic lookup` to your `LINKFLAGS`.
+This is how a minimal SConstruct for your SystemC project could look:
+
+```python
+env = Environment()
+
+env.Append(CXXFLAGS=['-std=c++11'])
+if env['PLATFORM'] == 'darwin':
+    env.Append(LINKFLAGS=['-undefined', 'dynamic_lookup'])
+
+systemc = env.SConscript('<path_to_systemc>/src/SConscript', exports=['env'])
+env.Program('example', ['example.cc', systemc])
+```
+
+[sysc]: http://accellera.org/downloads/standards/systemc
+[gem5]: http://www.gem5.org/Main_Page
+[doulos]: https://www.doulos.com/knowhow/systemc/tlm2/base_protocol_checker/
diff --git a/ext/systemc/README.sysc b/ext/systemc/README.sysc
new file mode 100644
index 000000000..a2729db83
--- /dev/null
+++ b/ext/systemc/README.sysc
@@ -0,0 +1,132 @@
+                SystemC Class Library (Rel. 2.3.1)
+                ==================================
+
+This is the release of the SystemC 2.3.1 Class Library.
+This release includes TLM 2.0.3 (Transaction Level Modeling) code,
+as described in the IEEE 1666-2011 Language Reference Manual.
+
+-------------------------------------------------------------------------------
+                IMPORTANT
+
+1. This is the release of SystemC 2.3.1. This release contains bug fixes
+   for SystemC 2.3.0 as well as adding some minor and experimental features.
+
+2. This release is supported on the following platform combinations for
+   which it has been well tested:
+
+    o 64-bit Linux (x86_64)
+      (RedHat Enterprise Linux 5, 6; Scientific Linux 5, 6; Debian 7; Ubuntu 12)
+      - GNU C++ compiler versions gcc-3.4.6 through gcc-4.9.0;
+      - Clang C++ compiler versions clang-3.0 through clang-3.5
+
+    o 64-bit Linux (x86_64) with 32-bit compiler (--host=i686-linux-gnu)
+      (RedHat Enterprise Linux 5, 6; Debian 7; Ubuntu 12)
+      - GNU C++ compiler versions gcc-4.4.7 through gcc-4.9.0;
+      - Clang C++ compiler versions clang-3.0 through clang-3.5
+
+    o 32-bit Linux (x86)
+      (Scientific Linux 5, 6; Debian 6, 7; Ubuntu 12)
+      - GNU C++ compiler versions gcc-3.4.6 through gcc-4.9.0;
+      - Clang C++ compiler versions clang-3.0 through clang-3.4
+
+    o 64-bit Mac OS X (x86_64)
+      (10.6 Snow Leopard, 10.8 Mountain Lion, 10.9 Mavericks)
+      - Apple LLVM version 5.0 (based on LLVM 3.3svn);
+      - Apple GNU C++ compiler version gcc-4.2.1
+
+    o 32-bit Mac OS X (x86)
+      (10.6 Snow Leopard, 10.8 Mountain Lion)
+      - Apple LLVM version 5.0 (based on LLVM 3.3svn);
+      - Apple GNU C++ compiler version gcc-4.2.1
+
+    o 32-bit Mac OS X (powerpc)
+      (10.6 Snow Leopard, executed with Rosetta)
+      - Apple GNU C++ compiler version gcc-4.2.1
+
+    o 64-bit FreeBSD 9.0 (x86_64)
+      - GNU C++ compiler versions gcc-4.2.1 through gcc-4.8.2;
+      - Clang C++ compiler version clang-3.3
+
+    o 32-bit FreeBSD 9.0 (x86)
+      - GNU C++ compiler versions gcc-4.2.1 through gcc-4.8.2;
+      - Clang C++ compiler version clang-3.3
+
+    o 32-bit Solaris (SPARC)
+      (Sun Solaris 10, Oracle Solaris 11)
+      - GNU C++ compiler versions gcc-3.4.3 through gcc-4.8.1;
+      - Sun/Solaris Studio compiler versions 12, 12.1, 12.2, 12.3
+
+    o Windows 7 SP1 (WoW64)
+      - Microsoft Visual Studio 2005 SP1               (8.0) (Win32 and x64);
+      - Microsoft Visual Studio 2008 Express SP1       (9.0) (Win32);
+      - Microsoft Visual Studio 2010 Express SP1      (10.0) (Win32);
+      - Microsoft Visual Studio 2012 Express Update 4 (11.0) (Win32 and x64)
+      - Microsoft Visual Studio 2013 Express Update 1 (12.0) (Win32 and x64)
+
+    o Windows 7 SP1 (WoW64), (Cygwin 1.7.17)
+      - GNU C++ compiler versions gcc-3.4.4 through gcc-4.3.4 (x86)
+
+    o Windows 7 SP1 (WoW64), Msys 1.0.17(0.48/3/2)
+      - MinGW32 GNU C++ compiler versions 4.5.2 through 4.7.0 (x86);
+      - MinGW-w64 GNU C++ compiler version 4.8.1 (x86 and x86_64)
+
+
+  This release has not yet been tested or is known not to work as expected
+  on the following formerly supported platforms:
+
+    o GNU C++ compiler versions prior to 3.4.x (all platforms)
+    o HP-UX 11.00 or later with GNU C++ or HP C++ compiler
+    o Sun/Oracle Solaris with Sun Studio C++ compiler prior to 12.x
+    o Mac OS X prior 10.6 Snow Leopard with GNU C++ compiler
+    o Microsoft Visual C++ versions prior to 8.0 (2005)
+
+
+-------------------------------------------------------------------------------
+
+For details, see the separate RELEASENOTES file.
+
+
+Licensing and Copyright
+
+   See the separate LICENSE file to determine your rights
+   and responsiblities for using SystemC.
+
+User Documentation
+
+   You can find documentation for this release in the docs directory.
+
+Installation
+
+   See the separate INSTALL file that provides system
+   information and installation instructions.
+
+Release Notes
+
+   See the separate RELEASENOTES file that provides upto date
+   information about this release of SystemC.
+
+Additional information
+
+   SystemC has a web site at
+
+       http://www.accellera.org
+
+   Discussion forum: http://forums.accellera.org/forum/9-systemc/
+
+   You can post the bugs and suggestions of general interest to the forum.
+   When reporting bugs please specify the following information (if
+   applicable):
+
+     1) SystemC version 
+     2) platform, compiler, flags 
+     3) description of the problem 
+     4) steps to reproduce the problem 
+     5) compile/runtime warnings and errors 
+     6) code sample, not more than 100 lines to demonstrate the problem 
+
+   Note: All bugs will only be tested against the latest publicly available 
+         version of the product.
+
+   Note: All C++ compilers that SystemC supports have bugs of different
+         degree of severity. We cannot fix those bugs. Please report them
+         to the compiler vendor.
diff --git a/ext/systemc/RELEASENOTES b/ext/systemc/RELEASENOTES
new file mode 100644
index 000000000..2dd93b34c
--- /dev/null
+++ b/ext/systemc/RELEASENOTES
@@ -0,0 +1,685 @@
+                Release Notes for SystemC 2.3.1
+                ===============================
+
+        Andrew C. Goodrich,  Forte Design Systems
+        Philipp A. Hartmann, OFFIS Institute for Information Technology
+
+CONTENTS
+========
+
+  1) What's new in this release?
+
+  2) Bug fixes and enhancements
+
+  3) New features
+
+  4) Incompatibitilies with previous releases
+
+  5) Expanded dynamic process support
+
+  6) Experimental features
+
+  7) Known problems
+
+  8) Fixed-point library
+
+  9) TLM Release Notes
+
+
+1) What's new in this release?
+==============================
+
+This version of SystemC contains the "Proof of Concept" simulator
+for the IEEE 1666-2011 SystemC standard. Please consult the IEEE Std
+1666-2011 SystemC Language Reference Manual for details about the 
+current SystemC standard.
+
+TLM-2.0 is merged into the main SystemC release since 2.3.0.
+Please see section 9) below for more details related to TLM.
+
+Compared to the 2.3.0, this release has the following new items:
+
+  - New features, partly beyond the current IEEE 1666-2011 standard,
+    see section 3.
+
+  - Experimental features (disabled by default), see section 5.
+    Testing and feedback welcome via the Accellera SystemC forums
+    at http://forums.accellera.org/forum/9-systemc/.
+
+  - Bug fixes, see section 2.
+
+  - Expanded platform support, see the README.
+
+
+
+2) Bug fixes and enhancements
+=============================
+
+Following is the list of bug fixes and enhancements for this release:
+
+  - For fixes and enhancements of the embedded TLM-2.0 implementation,
+    please see section 9.
+
+  - Additional changes and cleanups leading to incompatibilities with
+    previous versions of SystemC are described in section 4.
+
+  - Fix nested SC_METHOD preemptions caused by resetting a method, which
+    throws an exception in a thread process.  The control now correctly
+    goes back to the throwing method.
+
+  - Handle the case of a suppressed multiple-writer error in sc_signal
+    (and related channels) consistently with SystemC 2.2.0 again.
+
+  - The 'sc_buffer<bool>' and 'sc_buffer<sc_logic>' channels now correctly
+    notify their (pos|neg)edge_events, if someone is waiting on them.
+
+  - Cleanup the renaming of the internal Boost namespaces.  The embedded
+    Boost implementation resides in the (renamed) top-level namespaces
+     - sc_boost
+     - sc_unnamed (for placeholders, part of IEEE 1666-2011)
+     - sc_mpl_    (internal ADL barrier)
+
+  - Minor fixes in sc_vector-related classes
+     - correctly determine instantiation context
+     - sc_vector_iter: addition/substraction operators fixed
+     - sc_vector_assembly: add swap, fix missing return statement in
+       assignment
+
+  - WIF tracing of 64-bit integers: fix widths and masks on some
+    64-bit platforms.
+
+  - Suppressed a warning in case of calling sc_start in case of pending
+    delta notifications without any pending (or resulting) process
+    activations afterwards (1666-2011 compatbility).
+
+  - Fix sc_string_old implementation to handle very long strings (>1024)
+    (known issue in <=2.3.0).  Note, that sc_string_old is no longer
+    included by default, see section 4.
+
+  - Add "risc_cpu" example to Automake build system ("make check").
+
+  - Add missing files to the MS Visual C++ SystemC.vcproj project file.
+
+  - Add a missing "break" statement to "scfx_utils.h" in the "SC_CSD"
+    format parsing logic.
+
+  - Fix several integer conversion warnings raised by some compilers
+    throughout the SystemC implementation.
+
+  - Fixed incorrect GCC i386/x86_64 function call stack alignment when
+    using the QuickThreads/WinFiber-based process implementations (16-byte
+    boundary).  This avoids segmentation faults in some cases where the
+    stricter stack requirement is implicitly assumed by the compiler.
+
+  - The default stack size for threads, SC_DEFAULT_STACK_SIZE, has been
+    increased on 64-bit platforms and is overridable at library build
+    time (see INSTALL).
+
+  - The sc_report implementation now correctly handles empty and NULL
+    message type arguments (avoiding a segmentation fault in these cases).
+    The sc_report default constructor is made private to follow IEEE 1666.
+
+  - Missing namespace qualifiers added to all reporting macros, namely
+     - SC_DEFAULT_*_ACTIONS
+     - SC_REPORT_INFO_VERB
+    to make them usable again while including <systemc> instead of
+    <systemc.h>
+
+  - VCD/WIF tracing: fix support for very long values
+
+    The sc_(un)signed and sc_fxnum(_fast) data types can potentially hold
+    longer values than 1000 bit, which used to be the fixed size of the
+    intermediate buffers in sc_(vcd,wif)_trace for these types.
+
+  - Cleanup systemc.h
+
+     - Drop any in-library dependencies on the old 'sc_string' class,
+       removing the need to provide the corresponding header externally
+       (see section 4).
+     - Drop explicit in-header dependencies on <windows.h> on Windows
+       platforms, removing the automatic inclusion from <systemc[.h]>
+       (see section 4).
+     - Drop inclusion of 'strstream' by default on some platforms
+       (see section 4)
+     - assume working C++ standard library on all platforms
+     - assume working argument-dependent lookup on MSVC
+       (which should be working since MSVC 2003 already)
+     - see section 4 and INSTALL file
+
+  - Improved compile/runtime check of the SystemC library config
+
+    Some preprocessor switches need to be consistent between the application
+    and the library (e.g. if sizes of classes are affected or other parts of
+    the ABI are affected).  These can now be checked at link-time.
+  
+    Secondly, some preprocessor switches need to be consistent between
+    different translation units of an application, which is checked at
+    runtime startup.
+
+  - sc_context: avoid reinterpret_cast from integer to pointer
+
+  - The SC_VERSION_ORIGINATOR has been renamed from "ASI" to "Accellera"
+    to follow the naming policies of the Accellera Systems Initiative.
+
+  - Cleanups of the VCD/WIF tracing implementation
+
+     - Removal of internal files from the public headers (see section 4)
+     - Report any information (infos, warnings, errors) via the SystemC
+       reporting mechanism instead of directl printing to std::cout/cerr
+     - Automatically unregister trace updates when closing a trace file
+       during the simulation
+
+  - Drop the 'register' storage class specifier, which has been
+    deprecated in the C++11 standard (and therefore might cause warnings
+    on some compilers).
+
+  - Expanded naming of traced objects in VCD traces to use 5 characters
+    rather than 3 to accommodate more signals (incomplete in 2.3.0).
+
+  - Fix sc_signed/sc_unsigned conversion bug on GCC 4.8 or later, coming
+    from its aggressive optimization in case of integer over/underflows 
+    (by avoiding the C++ undefined behaviour in the implementation).
+
+  - An output stream operator<< for sc_status is added to enable
+    pretty-printing of sc_status values (and bitwise combinations of
+    such values).
+
+  - Various minor code cleanups and compiler warning fixes
+     - removal of some workarounds for very old versions of some
+       compilers (e.g. MSVC < 8.0).
+     - removal of unused variables and macros
+     - some deduplication of redundant code paths
+
+
+3) New features
+===============
+
+Here is an overview of changes in 2.3.1 compared to 2.3.0.
+
+Note: These features partly add functionality beyond the current
+      IEEE Std. 1666-2011.
+
+
+  - Major rewrite of the Autoconf/Automake build system
+    - better control of the installation directories
+    - improved libtool library dependency detection, especially
+      in cross-compilation scenarios (--host=...)
+    - support for pkg-config for SystemC and TLM
+      (see http://www.freedesktop.org/wiki/Software/pkg-config/)
+    - accept arbitrary GCC-compatible compilers
+      (e.g. Clang, Intel compiler, compiler-wrappers like scan-build)
+    - avoid deprecation warnings, cleanup implementation
+    - less recursive build, silent rules by default
+    - improved "make check" test handling
+
+
+  - Updated MS Visual C++ project and solution files to include
+    support for Visual Studio 2012 and 64-bit builds on Windows
+    platforms.
+
+
+  - Improved conversion between the underlying integral time
+    representation and sc_time objects:
+
+    - Add a nested typedef "value_type" to sc_time to enable an
+      implementation-independent use of the underlying integral
+      time representation (see IEEE 1666-2011, 5.11.1).
+
+    - Adding an inverse to the 'sc_time::value()' function to
+      convert a plain value back to an sc_time object:
+        static sc_time sc_time::from_value( value_type t );
+
+    - Adding modulus operators (%, %=) to compute time offsets from
+      clock or quantum boundaries:
+
+        sc_time operator%(const sc_time& lhs, const sc_time& rhs);
+
+        sc_time& sc_time::operator%=();
+
+      Note: These operators are missing from IEEE 1666-2011, which
+            make e.g. the tlm_global_quantum implementation nearly
+            impossible within the limits of the SystemC standard.
+
+
+  - Add function to determine the current object hierarchy:
+
+      sc_object* sc_core::sc_get_current_object()
+
+    Returns a pointer to the sc_object instance (or NULL) that would
+    currently become the parent object of a newly created sc_object
+    instance (i.e. the current module during elaboration, and the
+    currently active process during simulation).
+
+
+  - Add compile-time configurable default signal writer policy
+    (see INSTALL).
+
+    Defining SC_DEFAULT_WRITER_POLICY to one of the sc_writer_policy
+    values before including systemc(.h) allows application-wide selection
+    of the default sc_writer_policy used for signals.
+
+    Defining SC_NO_WRITE_CHECK is equivalent to 
+      SC_DEFAULT WRITER_POLICY=SC_UNCHECKED_WRITERS
+
+    By default, the writer policy still disallows multiple
+    writers (SC_ONE_WRITER).
+
+
+  - Add an sc_signal initialization which does not create an event
+    via newly provided constructors to the signal classes:
+
+     sc_signal<T>::sc_signal( const char* name
+                            , const T&    initial_value );
+
+    (similarly for sc_buffer and sc_signal_resolved)
+
+    Compared to calling the "write()" function on a signal during
+    the elaboration, these constructors will set the initial value
+    of the signal without triggering an event at the beginning of the
+    simulation (and therefore may avoid triggering sensitive processes).
+
+
+  - Add a static function to sc_report_handler to query the current
+    report handler function:
+
+      static sc_report_handler_proc sc_report_handler::get_handler();
+
+    Additionally, sc_report_handler::set_handler() now returns the
+    previously set handler (c.f. sc_report_handler::set_actions).
+
+
+  - Improved conversion from bitvector element references to bool
+
+    As it is surprising to the user that a reference to an explicit
+    element of a sc_bv could not be used in a boolean context, a safe
+    conversion has been added to this release.
+
+    This enables the following coding style:
+
+      sc_bv<8> mybits;
+      // ...
+      if( mybits[0] ) // no longer a compiler error here!
+        /* do something */ ;
+
+    Note: For logic vectors, the bit-references still need to be
+          converted to bool explicitly (e.g. via the "to_bool()"
+          function.
+
+
+
+4) Incompatibilities with previous releases
+===========================================
+
+Here is a list of known incompatibilities between this release and
+2.3.0 (or earlier):
+
+  - The non-standard sc_time constructors
+      - sc_time( uint64, bool scale )
+      - sc_time( double, bool scale )
+    have been deprecated and issue a warning when being used.
+    Use the new 'sc_time::from_value' function instead (see section 3).
+
+  - The non-standard function 'sc_object::get_parent()' has been
+    deprecated, use 'sc_object::get_parent_object()' instead.
+
+  - The non-standard function 'sc_signal::get_new_value()' has been
+    deprecated (as required by IEEE 1666-2011).
+
+  - The non-standard implementation classes for the VCD and WIF tracing
+    (vcd_trace_file, wif_trace_file) are now hidden from an application
+    and no longer part of the public headers.
+    Use the IEEE 1666-2011 functions
+      - sc_trace
+      - sc_create_[vcd|wif]_trace_file
+      - sc_close_[vcd|wif]_trace_file
+      - sc_trace_file::set_time_unit
+    to set up the tracing in your application.
+
+  - The non-standard header 'src/sysc/communication/sc_reset.h' is
+    no longer part of the public headers.
+
+  - The 'sc_string_old' class is no longer available by default.
+    Define 'SC_USE_SC_STRING_OLD' before including "systemc.h",
+    see INSTALL.
+
+  - The implicit inclusion of the system-headers "windows.h" (on Windows)
+    and (deprecated) "strstream" have been removed.  See INSTALL.
+
+  - The incomplete implementation of old "W_*" watching macros and the
+    non-standard struct sc_watch have been removed.
+
+Here is a list of known incompatibilities between this release and 2.2.0:
+
+  - The order that processes (SC_METHODs and SC_THREADs) are dispatched 
+    for execution may be different than the order with SystemC 2.2.0 for
+    some SystemC programs. This is related to the new starvation policy 
+    support for the sc_start() function introduced with IEEE 1666_2011.
+
+  - The various bind() functions for ports and exports are "virtual" as
+    of IEEE 1666-2011.  This leads to an incompatibility with the
+    TLM 2.0.x release.  To use SystemC 2.3 together with TLM 2.0.{0,1},
+    define SC_DISABLE_VIRTUAL_BIND during the build of the simulator and
+    before including systemc.h (see INSTALL).
+
+
+5) Expanded Dynamic Process Support
+===================================
+
+This version implements the dynamic process extensions described in the
+IEEE Std 1666-2011 Language Reference Manual.
+
+Compared to SystemC 2.3.0, some bugs in corner cases of the
+specification have been fixed (see section 2).
+
+
+6) Experimental features
+========================
+
+In this section the experimental features of this release are listed.
+
+Note: These features are not enabled in the default library
+      configuration and need to be explicitly activated during at
+      library build time.  See INSTALL file.
+
+
+ - Extended Simulation Phase Callbacks
+
+   This release adds an optional mechanism to register callbacks
+   to several simulation phases.  This can be used to integrate
+   custom introspection techniques in a non-invasive manner.
+
+   New phases are added to the sc_status enumeration:
+
+       SC_END_OF_INITIALIZATION,
+       SC_END_OF_UPDATE,
+       SC_BEFORE_TIMESTEP
+
+   to enable a more fine-grained view to the SystemC simulation phases.
+
+   When the phase callback mechanism is activated (see the INSTALL file),
+   any sc_object can subscribe to a (set of) elaboration/simulation phases
+   for dynamic callbacks explicitly:
+
+     // trigger current object before updating the simulation time
+     this->register_simulation_phase_callback( SC_BEFORE_TIMESTEP );
+
+     // trigger current object before returning to "sc_start"
+     this->register_simulation_phase_callback( SC_PAUSED | SC_STOPPED );
+
+   Unsubscribing from any simulation phase is possible via the corresponding
+      unregister_simulation_phase_callback( phase_cb_mask )
+   function.
+
+   Both functions return the effective mask after the requested callback mask
+   update.  Therefore, querying the currently active mask can be achieved by
+   calling the (un)registration functions with an empty mask:
+
+     sc_object::phase_cb_mask current_cb_mask =
+       this->register_simulation_phase_callback( 0u );
+
+   To enable the external (un)registration of callbacks for a user-defined
+   sc_object class, the (un)registration functions can be made public by
+   adding the following using directives to a 'public:' section of the
+   class definition:
+
+     using sc_core::sc_object::register_simulation_phase_callback;
+     using sc_core::sc_object::unregister_simulation_phase_callback;
+
+   When the simulation passes a phase where dynamic callbacks are registered,
+   the subscribed objects are triggered via the function:
+
+     virtual void sc_object::simulation_phase_callback();
+
+   which should then be implemented by the subscribing object's class.
+
+   Within a simulation callback, the triggering phase can be determined
+   via the IEEE 1666-2011 'sc_get_status()' function:
+
+     void simulation_phase_callback() {
+       std::cout << sc_core::sc_get_status() << std::endl;
+     }
+
+   A related feature is the triggering of sc_trace updates via these
+   simulation phase callbacks instead of the hard-coded calls in various
+   places of the simulation loop.  This feature has to be enabled separately,
+   see INSTALL file.
+
+
+ - Allow creation of sc_max_time() objects before fixing the sc_time
+   resolution
+
+   Currently. IEEE 1666-2011 requires that any call to
+
+     sc_core::sc_set_time_resolution( double, sc_time_unit )
+
+   happens before the construction of the first non-SC_ZERO_TIME
+   sc_time object.
+
+   This can be inconvenient in cases, where an "uninitialized sc_time value"
+   is needed, which needs to be separate from SC_ZERO_TIME in some cases.
+
+   A relaxation of the strict sc_time construction rules wrt. to
+   the simulation time resolution can be optionally enabled via the
+   preprocessor switch SC_ENABLE_EARLY_MAXTIME_CREATION (see INSTALL).
+
+   When this option is enabled, the creation of time objects with the
+   values SC_ZERO_TIME and 'sc_max_time()' are allowed before fixing the
+   time resolution.  The resolution is still fixed once the actual
+   relationship between the internal time representation and the physical
+   time units (SC_FS, SC_PS, ...) is used or observed by the application.
+
+
+
+
+7) Known Problems
+=================
+
+  - When building the SystemC library with QuickThreads support, the
+    resulting shared library is marked as requiring an executable stack
+    by certain compilers/assemblers (or rather not marked as not needing
+    one).  As a result, some system security systems (like SELinux) might
+    refuse to load the library.  As a workaround for GNU (compatible)
+    assemblers, pass the assembler flags variable with the option
+      CCASFLAGS="-Wa,--noexecstack"
+    to the `configure' script call before building the SystemC library.
+
+
+  - IEEE 1666-2011 does not explicitly define the behaviour in the corner
+    cases of attempting to create sc_time objects smaller than the time
+    resolution or bigger than sc_max_time().  This implementation currently
+    truncates "small" sc_time objects to SC_ZERO_TIME, while "too big"
+    objects wrap-around sc_max_time() and lead to a value modulo the
+    maximum time.  In both cases, no warning is generated.
+
+
+  - The sign-extension of mixed-signedness logic expressions (&,|)
+    involving one sc_bigint<> operand and C++ builtin integral types
+    (int, short, etc.) is inconsistent between 32-bit and 64-bit
+    platforms in some cases. Convert both operands to sc_bigint<> first.
+
+
+  - The definition of sc_dt::(u)int64 differs from std::(u)int64_t types
+    on some platforms.  This may lead to problems with function overloads
+    and/or format-string placeholders.  As a workaround, convert these
+    values explicitly to the correct type before passing them to functions
+    expecting one of these types.  For sc_time, use the new nested type
+    sc_time::value_type to hold values of the underlying representation.
+
+
+  - Bit/logic-vector reductions (or_reduce, and_reduce, etc.) return an
+    'sc_logic_value_t' enum value, instead of a bool or sc_logic (as required
+    by IEEE 1666-2011).  Using the return value of these functions in a
+    boolean context, e.g.
+      if( lv.or_reduce() ) { /* ... */ }
+    might lead to wrong results in case of 'X' or 'Z' bits in the vector.
+    Avoid this by converting the result to an 'sc_logic' first and perform
+    a safe conversion to bool:
+      if( sc_logic( lv.or_reduce() ).to_bool() ) { /* ... */ }
+
+
+  - The use of the DEBUG_SYSTEMC macro does not work properly with certain
+    compilers (e.g., gcc 2.95.x) if it was not also specified when the
+    SystemC library was built. The problem is caused by the use of the
+    library compiled version of some inline methods. This problem does not
+    appear to be present in the gcc 3.3, Solaris, and aCC compilers.
+    The work-around is to specify DEBUG_SYSTEMC when the SystemC library
+    is built.
+
+
+  - On some recent compilers (e.g. Clang, Solaris Studio), warnings are
+    generated about the "hidden overloaded virtual function" bind of the
+    sc_port(_b) class templates in the 'specialized_signals' example.
+    These warnings are caused by the introduction of the virtual bind
+    implementation in IEEE 1666-2011.
+    As a workaround, check your compiler documentation how to suppress
+    the warning (e.g. 'CXXFLAGS=-Wno-overloaded-virtual') or mark
+    the SystemC include directory as "system directory" by using
+    '-isystem ${SYSTEMC_HOME}/include' (or equivalent) instead of
+    the usual '-I'.
+
+    This also affects the TLM-2.0 sockets, see Section 9.3.
+
+
+  - Some paths in this release are longer than the historical 99 character
+    limit of tar archives, and several Windows archivers (e.g. WinZip)
+    have been reported to trip over this.  The open source archiver 7-zip
+    (http://7-zip.org) is known to work.
+
+
+8) Fixed-point library
+======================
+
+SystemC contains a fixed-point datatypes package.
+
+Changes compared to SystemC 2.0.1
+
+  - support for explicit construction from "float" values
+
+  - removing a conversion ambiguity by marking some constructors of
+    sc_fxval[_fast] classes as 'explicit'
+
+Compile-time macro SC_INCLUDE_FX must be defined in order to build
+applications that use fixed point types. You can specify a compiler
+flag, e.g., g++ -DSC_INCLUDE_FX ... or use a define statement before
+you include systemc.h, e.g.:
+
+  #define SC_INCLUDE_FX
+  #include "systemc.h"
+
+Due to the large size of the fixed-point datatypes header files,
+compilation can take considerably more time.
+
+If you want to use the fixed-point data types only (i.e., not data-
+types sc_int, sc_uint, sc_bigint, sc_biguint), compilation time can be
+reduced by defining compile-time macro SC_FX_EXCLUDE_OTHER (in addition
+to SC_INCLUDE_FX).
+
+
+9) TLM Release Notes
+====================
+
+CONTENTS
+========
+
+  1) Supported SystemC versions
+  2) What's changed in this kit?
+  3) Known issues
+
+
+9.1) Supported SystemC versions
+===============================
+
+SystemC 2.2.0 and 2.3.x are supported and have been tested.
+SystemC 2.1.v1 is still supported in principle, but has not
+been tested extensively.
+
+
+9.2) What's changed in this kit?
+================================
+
+Compared to TLM 2.0.2 kit (part of SystemC 2.3.0), the following has changed:
+
+
+ - The tlm_utils headers have been cleaned up to include <tlm>,
+   instead of <tlm.h>
+
+
+ - The convenience sockets with base-protocol NB/B conversion support
+   now automatically define the required SC_INCLUDE_DYNAMIC_PROCESSES,
+   if not already provided by the user (since the B/NB conversion
+   depends on the SystemC dynamic process support).
+
+
+ - Improve the NB/B conversion in the simple_target_socket to avoid
+   the dynamic allocation (and deletion) of sc_event instances in the
+   use of the spawned helper processes for the converesion.
+
+
+ - Fix a bug in the same simple_target_socket NB/B conversion thread,
+   where the target socket may not detect the early completion of the
+   response phase via a "TLM_UPDATED" return value and a "TLM_END_RESP"
+   phase (base protocol violation).
+
+
+ - Fix the "get_base_interface()" implementation provided by the 
+   multi_passthrough_target_socket.  Prior to this release, a
+   dummy interface object has been used as a return value in case
+   of a hierarchical bind.  Return the first bound interface instead.
+
+
+ - Fixed missing initialization of some member variables in the
+   callback_binder_fw|bw implementations, that caused segfaults
+   in some cases.
+
+
+ - The implementation-defined tlm::circular_buffer class has been
+   updated with the following changes
+    - now provides a "clear()" member function to drop the current
+      contents,
+    - fix a segmentation fault due to freeing invalid memory in
+      "resize()", which could happen in some cases,
+    - work around a parsing error on some EDG-based C++ frontends.
+
+
+ - tlm_global_quantum: use sc_time::operator%
+
+   Instead of relying on a manual remainder calculation based on
+   sc_time::value and the non-standard backwards conversion, the new
+   sc_time::operator% is used to compute the remaining time in the
+   current quantum (see section 3).
+
+
+ - The internal tlm_array class (to hold payload extensions) has been
+   reimplemented based on std::vector (fixes copy constructor bug).
+
+
+ - The TLM_VERSION_ORIGINATOR has been renamed from "ASI" to "Accellera"
+   to follow the naming policies of the Accellera Systems Initiative.
+
+
+
+
+9.3) Known issues
+=================
+
+a. The tlm_simple_target_socket in tlm_utils does not obey the END_REQ rule
+   when only an nb_ call is registered, an b_ call is being handled in the
+   socket and there is an nb_ call coming in at the same time. In this case
+   the incoming nb_ call will be forwarded to the registered nb_ call without
+   checking whether the earlier b_ call has passed the END_REQ timing point.
+
+b. The implementation of the PEQ 'peq_with_get' in tlm_utils does not properly
+   distinguish between immediate notifications and delta notifications. In the
+   case that a immediate and delta notification happen at the same simulation
+   time both types of notifications emerge from the PEQ in the same evaluation
+   phase. This is wrong immediate notifications should overtake delta
+   notifications.
+
+c. On some recent compilers (e.g. Clang, Solaris Studio), warnings are generated
+   about the "hidden overloaded virtual function" bind of the sc_port(_b)
+   class templates when using the TLM-2.0 sockets.  These warnings are caused by
+   the introduction of the virtual bind implementation in IEEE 1666-2011.
+   As a workaround in your application, check your compiler documentation how to
+   suppress the warning (e.g. adding the flag -Wno-overloaded-virtual), or mark
+   the SystemC include directory as "system directory" by using
+   '-isystem ${SYSTEMC_HOME}/include' (or equivalent) instead of the usual '-I'.
diff --git a/ext/systemc/SConscript b/ext/systemc/SConscript
new file mode 100644
index 000000000..804f7abfc
--- /dev/null
+++ b/ext/systemc/SConscript
@@ -0,0 +1,64 @@
+# Copyright (c) 2017, TU Dresden
+# Copyright (c) 2017, University of Kaiserslautern
+# All rights reserved.
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+# Authors: Christian Menard
+#          Matthias Jung
+
+import os
+
+Import('main')
+
+main.Prepend(CPPPATH=Dir('./src'))
+main.Prepend(CPATH=Dir('./src'))
+
+main.Prepend(CXXFLAGS=['-DSC_INCLUDE_FX', '-pthread'])
+main.Prepend(CFLAGS=['-DSC_INCLUDE_FX', '-pthread'])
+
+conf = Configure(main)
+
+if main['PLATFORM'] == 'darwin':
+    main.Append(LINKFLAGS=['-undefined', 'dynamic_lookup'])
+
+s_file = None
+if conf.CheckDeclaration("__i386__"):
+    s_file = 'i386.s'
+if conf.CheckDeclaration("__x86_64__"):
+    s_file = 'iX86_64.s'
+conf.Finish()
+
+if s_file is None:
+    print 'Unsupported CPU architecture!'
+    Exit(1)
+
+systemc_files = Glob('src/sysc/kernel/*.cpp')
+systemc_files += ['src/sysc/qt/qt.c', 'src/sysc/qt/md/' + s_file]
+systemc_files += Glob('src/sysc/communication/*.cpp')
+systemc_files += Glob('src/sysc/tracing/*.cpp')
+systemc_files += Glob('src/sysc/utils/*.cpp')
+systemc_files += Glob('src/sysc/datatypes/bit/*.cpp')
+systemc_files += Glob('src/sysc/datatypes/fx/*.cpp')
+systemc_files += Glob('src/sysc/datatypes/int/*.cpp')
+systemc_files += Glob('src/sysc/datatypes/misc/*.cpp')
+
+main.Library('libsystemc', systemc_files)
+main.SharedLibrary('libsystemc', systemc_files)
+
diff --git a/ext/systemc/src/README_TLM.txt b/ext/systemc/src/README_TLM.txt
new file mode 100644
index 000000000..f8174e7a0
--- /dev/null
+++ b/ext/systemc/src/README_TLM.txt
@@ -0,0 +1,33 @@
+
+TLM-2.0 standard header files
+=============================
+	
+Dir: include/
+
+SubDirs: tlm_core/
+           tlm_1/
+           tlm_2/
+	 tlm_utils/
+
+Files: README.txt
+       tlm
+       tlm.h
+
+
+Comments
+========
+
+To use the TLM-2.0 interoperability standard, a user should only include the tlm
+or tlm.h header file. The same holds for the TLM-1.0 implementation that is
+included as part of this kit; only include tlm or tlm.h. These header files
+refer to all the header files within the tlm_core/ subdirectory, everything
+within tlm or tlm.h is contained in the tlm namespace.
+
+The tlm_utils subdirectory contains a set of additional definitions supported 
+by the TLM-2.0 standard, but which are not part of the interoperability
+requirements. It contains ease-of-use and convenience implementations for the 
+interoperability standard. All objects defined in the tlm_utils directory are 
+contained in the tlm_util namespace.
+
+See the README.txt files in the subdirectories for an explanation of the 
+internal organization of the header files.
diff --git a/ext/systemc/src/sysc/communication/sc_buffer.h b/ext/systemc/src/sysc/communication/sc_buffer.h
new file mode 100644
index 000000000..e91c1a7c9
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_buffer.h
@@ -0,0 +1,194 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_buffer.h -- The sc_buffer<T> primitive channel class.
+                 Like sc_signal<T>, but *every* write causes an event.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_BUFFER_H
+#define SC_BUFFER_H
+
+
+#include "sysc/communication/sc_signal.h"
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_buffer<T>
+//
+//  The sc_buffer<T> primitive channel class.
+// ----------------------------------------------------------------------------
+
+template< typename T, sc_writer_policy POL = SC_DEFAULT_WRITER_POLICY >
+class sc_buffer
+: public sc_signal<T,POL>
+{
+public:
+
+    // typedefs
+
+    typedef sc_buffer<T,POL> this_type;
+    typedef sc_signal<T,POL> base_type;
+
+public:
+
+    // constructors
+
+    sc_buffer()
+	: base_type( sc_gen_unique_name( "buffer" ) )
+	{}
+
+    explicit sc_buffer( const char* name_ )
+	: base_type( name_ )
+	{}
+
+    sc_buffer( const char* name_, const T& initial_value_ )
+      : base_type( name_, initial_value_ )
+    {}
+
+    // interface methods
+
+    // write the new value
+    virtual void write( const T& );
+
+
+    // other methods
+
+    this_type& operator = ( const T& a )
+	{ write( a ); return *this; }
+
+    this_type& operator = ( const sc_signal_in_if<T>& a )
+	{ write( a.read() ); return *this; }
+
+    this_type& operator = ( const this_type& a )
+	{ write( a.read() ); return *this; }
+
+    virtual const char* kind() const
+        { return "sc_buffer"; }
+
+protected:
+
+    virtual void update();
+
+private:
+
+    // disabled
+    sc_buffer( const this_type& );
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+// write the new value
+
+template< typename T, sc_writer_policy POL >
+inline
+void
+sc_buffer<T,POL>::write( const T& value_ )
+{
+    if( !base_type::policy_type::check_write(this,true) )
+      return;
+
+    this->m_new_val = value_;
+    this->request_update();
+}
+
+
+template< typename T, sc_writer_policy POL >
+inline
+void
+sc_buffer<T,POL>::update()
+{
+    base_type::policy_type::update();
+    base_type::do_update();
+}
+
+} // namespace sc_core
+
+#endif
+
+//$Log: sc_buffer.h,v $
+//Revision 1.7  2011/08/26 20:45:39  acg
+// Andy Goodrich: moved the modification log to the end of the file to
+// eliminate source line number skew when check-ins are done.
+//
+//Revision 1.6  2011/04/08 18:22:45  acg
+// Philipp A. Hartmann: use the context of the primitive channel to get
+// the change stamp value.
+//
+//Revision 1.5  2011/04/05 20:48:09  acg
+// Andy Goodrich: changes to make sure that event(), posedge() and negedge()
+// only return true if the clock has not moved.
+//
+//Revision 1.4  2011/04/05 06:15:18  acg
+// Philipp A. Hartmann: sc_writer_policy: ignore no-ops in delta check.
+//
+//Revision 1.3  2011/02/18 20:23:45  acg
+// Andy Goodrich: Copyright update.
+//
+//Revision 1.2  2010/12/07 19:50:36  acg
+// Andy Goodrich: addition of writer policies, courtesy of Philipp Hartmann.
+//
+//Revision 1.1.1.1  2006/12/15 20:20:04  acg
+//SystemC 2.3
+//
+//Revision 1.8  2006/03/13 20:19:43  acg
+// Andy Goodrich: changed sc_event instances into pointers to sc_event instances
+// that are allocated as needed. This saves considerable storage for large
+// numbers of signals, etc.
+//
+//Revision 1.7  2006/01/26 21:00:49  acg
+// Andy Goodrich: conversion to use sc_event::notify(SC_ZERO_TIME) instead of
+// sc_event::notify_delayed()
+//
+//Revision 1.6  2006/01/24 20:46:31  acg
+//Andy Goodrich: changes to eliminate use of deprecated features. For instance,
+//using notify(SC_ZERO_TIME) in place of notify_delayed().
+//
+//Revision 1.5  2006/01/19 19:18:25  acg
+//Andy Goodrich: eliminated check_writer in favor of inline code within the
+//write() method since we always execute the check_writer code even when
+//check writing is turned off.
+//
+//Revision 1.4  2006/01/19 00:30:57  acg
+//Andy Goodrich: Yet another implementation for disabling write checks on
+//signals. This version uses an environment variable, SC_SIGNAL_WRITE_CHECK,
+//that when set to DISABLE will turn off write checking.
+//
+//Revision 1.3  2006/01/13 18:47:20  acg
+//Reversed sense of multiwriter signal check. It now defaults to ON unless the
+//user defines SC_NO_WRITE_CHEK before inclusion of the file.
+//
+//Revision 1.2  2006/01/03 23:18:26  acg
+//Changed copyright to include 2006.
+//
+//Revision 1.1.1.1  2005/12/19 23:16:43  acg
+//First check in of SystemC 2.1 into its own archive.
+//
+//Revision 1.9  2005/06/10 22:43:55  acg
+//Added CVS change log annotation.
+//
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_clock.cpp b/ext/systemc/src/sysc/communication/sc_clock.cpp
new file mode 100644
index 000000000..158d54b7a
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_clock.cpp
@@ -0,0 +1,409 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_clock.cpp -- The clock channel.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+// using notify_delayed().
+//
+// Revision 1.4  2006/01/18 21:42:26  acg
+// Andy Goodrich: Changes for check writer support, and tightening up sc_clock
+// port usage.
+//
+// Revision 1.3  2006/01/13 18:47:41  acg
+// Added $Log command so that CVS comments are reproduced in the source.
+//
+
+#include "sysc/communication/sc_clock.h"
+#include "sysc/communication/sc_communication_ids.h"
+#include "sysc/kernel/sc_simcontext.h"
+#include "sysc/kernel/sc_process.h"
+#include "sysc/kernel/sc_spawn.h"
+#include "sysc/utils/sc_utils_ids.h"
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_clock
+//
+//  The clock channel.
+// ----------------------------------------------------------------------------
+
+// constructors
+
+sc_clock::sc_clock() : 
+    base_type( sc_gen_unique_name( "clock" ) ),
+    m_period(), m_duty_cycle(), m_start_time(), m_posedge_first(),
+    m_posedge_time(), m_negedge_time(),
+    m_next_posedge_event( (std::string(SC_KERNEL_EVENT_PREFIX) + 
+                          "_next_posedge_event").c_str()),
+    m_next_negedge_event( (std::string(SC_KERNEL_EVENT_PREFIX) + 
+                          "_next_negedge_event").c_str())
+
+{
+    init( sc_time::from_value(simcontext()->m_time_params->default_time_unit),
+	  0.5,
+	  SC_ZERO_TIME,
+	  true );
+
+    m_next_posedge_event.notify_internal( m_start_time );
+}
+
+sc_clock::sc_clock( const char* name_ ) :
+    base_type( name_ ),
+    m_period(), m_duty_cycle(), m_start_time(), m_posedge_first(),
+    m_posedge_time(), m_negedge_time(),
+    m_next_posedge_event( (std::string(SC_KERNEL_EVENT_PREFIX) + 
+			   std::string(name_) + "_next_posedge_event").c_str()),
+    m_next_negedge_event( (std::string(SC_KERNEL_EVENT_PREFIX) + 
+			   std::string(name_) + "_next_negedge_event").c_str())
+{
+    init( sc_time::from_value(simcontext()->m_time_params->default_time_unit),
+	  0.5,
+	  SC_ZERO_TIME,
+	  true );
+
+    m_next_posedge_event.notify_internal( m_start_time );
+}
+
+sc_clock::sc_clock( const char* name_,
+		    const sc_time& period_,
+		    double         duty_cycle_,
+		    const sc_time& start_time_,
+		    bool           posedge_first_ ) :
+    base_type( name_ ),
+    m_period(), m_duty_cycle(), m_start_time(), m_posedge_first(),
+    m_posedge_time(), m_negedge_time(),
+    m_next_posedge_event( (std::string(SC_KERNEL_EVENT_PREFIX) + 
+			   std::string(name_) + "_next_posedge_event").c_str()),
+    m_next_negedge_event( (std::string(SC_KERNEL_EVENT_PREFIX) + 
+			   std::string(name_) + "_next_negedge_event").c_str())
+{
+    init( period_,
+	  duty_cycle_,
+	  start_time_,
+	  posedge_first_ );
+
+    if( posedge_first_ ) {
+	// posedge first
+	m_next_posedge_event.notify_internal( m_start_time );
+    } else {
+	// negedge first
+	m_next_negedge_event.notify_internal( m_start_time );
+    }
+}
+
+sc_clock::sc_clock( const char* name_,
+		    double         period_v_,
+		    sc_time_unit   period_tu_,
+		    double         duty_cycle_ ) :
+    base_type( name_ ),
+    m_period(), m_duty_cycle(), m_start_time(), m_posedge_first(),
+    m_posedge_time(), m_negedge_time(),
+    m_next_posedge_event( (std::string(SC_KERNEL_EVENT_PREFIX) + 
+			   std::string(name_) + "_next_posedge_event").c_str()),
+    m_next_negedge_event( (std::string(SC_KERNEL_EVENT_PREFIX) + 
+			   std::string(name_) + "_next_negedge_event").c_str())
+{
+    init( sc_time( period_v_, period_tu_, simcontext() ),
+	  duty_cycle_,
+	  SC_ZERO_TIME,
+	  true );
+
+    // posedge first
+    m_next_posedge_event.notify_internal( m_start_time );
+}
+
+sc_clock::sc_clock( const char* name_,
+		    double         period_v_,
+		    sc_time_unit   period_tu_,
+		    double         duty_cycle_,
+		    double         start_time_v_,
+		    sc_time_unit   start_time_tu_,
+		    bool           posedge_first_ ) :
+    base_type( name_ ),
+    m_period(), m_duty_cycle(), m_start_time(), m_posedge_first(),
+    m_posedge_time(), m_negedge_time(),
+    m_next_posedge_event( (std::string(SC_KERNEL_EVENT_PREFIX) + 
+			   std::string(name_) + "_next_posedge_event").c_str()),
+    m_next_negedge_event( (std::string(SC_KERNEL_EVENT_PREFIX) + 
+			   std::string(name_) + "_next_negedge_event").c_str())
+{
+    init( sc_time( period_v_, period_tu_, simcontext() ),
+	  duty_cycle_,
+	  sc_time( start_time_v_, start_time_tu_, simcontext() ),
+	  posedge_first_ );
+
+    if( posedge_first_ ) {
+	// posedge first
+	m_next_posedge_event.notify_internal( m_start_time );
+    } else {
+	// negedge first
+	m_next_negedge_event.notify_internal( m_start_time );
+    }
+}
+
+// for backward compatibility with 1.0
+sc_clock::sc_clock( const char* name_,
+		    double         period_,      // in default time units
+		    double         duty_cycle_,
+		    double         start_time_,  // in default time units
+		    bool           posedge_first_ ) :
+    base_type( name_ ),
+    m_period(), m_duty_cycle(), m_start_time(), m_posedge_first(),
+    m_posedge_time(), m_negedge_time(),
+    m_next_posedge_event( (std::string(SC_KERNEL_EVENT_PREFIX) + 
+			   std::string(name_) + "_next_posedge_event").c_str()),
+    m_next_negedge_event( (std::string(SC_KERNEL_EVENT_PREFIX) + 
+			   std::string(name_) + "_next_negedge_event").c_str())
+{
+    static bool warn_sc_clock=true;
+    if ( warn_sc_clock )
+    {
+        warn_sc_clock = false;
+	SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_, 
+	   "\n    sc_clock(const char*, double, double, double, bool)\n"
+	   "    is deprecated use a form that includes sc_time or\n"
+	   "    sc_time_unit");
+    }
+
+    sc_time default_time =
+      sc_time::from_value( simcontext()->m_time_params->default_time_unit );
+
+    init( ( period_ * default_time ),
+	  duty_cycle_,
+	  ( start_time_ * default_time ),
+	  posedge_first_ );
+
+    if( posedge_first_ ) {
+	// posedge first
+	m_next_posedge_event.notify_internal( m_start_time );
+    } else {
+	// negedge first
+	m_next_negedge_event.notify_internal( m_start_time );
+    }
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_clock::before_end_of_elaboration"
+//
+// This callback is used to spawn the edge processes for this object instance.
+// The processes are created here rather than the constructor for the object
+// so that the processes are registered with the global simcontext rather
+// than the scope of the clock's parent.
+//------------------------------------------------------------------------------
+#if ( defined(_MSC_VER) && _MSC_VER < 1300 ) //VC++6.0 doesn't support sc_spawn with functor.
+#   define sc_clock_posedge_callback(ptr) sc_clock_posedge_callback
+
+#   define sc_clock_negedge_callback(ptr) sc_clock_negedge_callback
+
+#   define sc_spawn(a,b,c) { \
+        sc_process_handle result(new sc_spawn_object<a>(a(this),b,c)); \
+    }
+#endif // ( defined(_MSC_VER) && _MSC_VER < 1300 )
+
+void sc_clock::before_end_of_elaboration()
+{
+    std::string gen_base;
+    sc_spawn_options posedge_options;	// Options for posedge process.
+    sc_spawn_options negedge_options;	// Options for negedge process.
+
+    posedge_options.spawn_method();
+    posedge_options.dont_initialize();
+    posedge_options.set_sensitivity(&m_next_posedge_event);
+    gen_base = basename();
+    gen_base += "_posedge_action";
+    sc_spawn(sc_clock_posedge_callback(this),
+	sc_gen_unique_name( gen_base.c_str() ), &posedge_options);
+
+    negedge_options.spawn_method();
+    negedge_options.dont_initialize();
+    negedge_options.set_sensitivity(&m_next_negedge_event);
+    gen_base = basename();
+    gen_base += "_negedge_action";
+    sc_spawn( sc_clock_negedge_callback(this),
+    	sc_gen_unique_name( gen_base.c_str() ), &negedge_options );
+}
+
+//clear VC++6.0 macros
+#undef sc_clock_posedge_callback
+#undef sc_clock_negedge_callback
+#undef sc_spawn
+
+// destructor (does nothing)
+
+sc_clock::~sc_clock()
+{}
+
+void sc_clock::register_port( sc_port_base& /*port*/, const char* if_typename_ )
+{
+    std::string nm( if_typename_ );
+    if( nm == typeid( sc_signal_inout_if<bool> ).name() ) {
+	    SC_REPORT_ERROR(SC_ID_ATTEMPT_TO_BIND_CLOCK_TO_OUTPUT_, "");
+    }
+}
+
+void
+sc_clock::write( const bool& /* value */ )
+{
+    SC_REPORT_ERROR(SC_ID_ATTEMPT_TO_WRITE_TO_CLOCK_, "");
+}
+
+// interface methods
+
+// get the current time
+
+const sc_time&
+sc_clock::time_stamp()
+{
+    return sc_time_stamp();
+}
+
+
+// error reporting
+
+void
+sc_clock::report_error( const char* id, const char* add_msg ) const
+{
+    char msg[BUFSIZ];
+    if( add_msg != 0 ) {
+	std::sprintf( msg, "%s: clock '%s'", add_msg, name() );
+    } else {
+	std::sprintf( msg, "clock '%s'", name() );
+    }
+    SC_REPORT_ERROR( id, msg );
+}
+
+
+void
+sc_clock::init( const sc_time& period_,
+		double         duty_cycle_,
+		const sc_time& start_time_,
+		bool           posedge_first_ )
+{
+    if( period_ == SC_ZERO_TIME ) {
+	report_error( SC_ID_CLOCK_PERIOD_ZERO_,
+		      "increase the period" );
+    }
+    m_period = period_;
+    m_posedge_first = posedge_first_;
+
+    if( duty_cycle_ <= 0.0 || duty_cycle_ >= 1.0 ) {
+	m_duty_cycle = 0.5;
+    } else {
+	m_duty_cycle = duty_cycle_;
+    }
+
+    m_negedge_time = m_period * m_duty_cycle;
+    m_posedge_time = m_period - m_negedge_time;
+
+    if( m_negedge_time == SC_ZERO_TIME ) {
+	report_error( SC_ID_CLOCK_HIGH_TIME_ZERO_,
+		      "increase the period or increase the duty cycle" );
+    }
+    if( m_posedge_time == SC_ZERO_TIME ) {
+	report_error( SC_ID_CLOCK_LOW_TIME_ZERO_,
+		      "increase the period or decrease the duty cycle" );
+    }
+
+    if( posedge_first_ ) {
+	this->m_cur_val = false;
+	this->m_new_val = false;
+    } else {
+	this->m_cur_val = true;
+	this->m_new_val = true;
+    }
+
+    m_start_time = start_time_;
+
+}
+
+} // namespace sc_core
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Bishnupriya Bhattacharya, Cadence Design Systems,
+                               Andy Goodrich, Forte Design Systems,
+                               3 October, 2003
+  Description of Modification: sc_clock inherits from sc_signal<bool> only
+                               instead of sc_signal_in_if<bool> and sc_module.
+                               The 2 methods posedge_action() and
+                               negedge_action() are created using sc_spawn().
+                               boost::bind() is not required, instead a local
+                               bind function can be used since the signatures
+                               of the spawned functions are statically known.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_clock.cpp,v $
+// Revision 1.7  2011/08/26 20:45:39  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.6  2011/08/24 22:05:35  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.5  2011/08/15 16:43:24  acg
+//  Torsten Maehne: changes to remove unused argument warnings.
+//
+// Revision 1.4  2011/03/12 21:07:42  acg
+//  Andy Goodrich: changes to kernel generated event support.
+//
+// Revision 1.3  2011/03/06 15:55:08  acg
+//  Andy Goodrich: Changes for named events.
+//
+// Revision 1.2  2011/02/18 20:23:45  acg
+//  Andy Goodrich: Copyright update.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.8  2006/04/18 23:36:50  acg
+//  Andy Goodrich: made add_trace_internal public until I can figure out
+//  how to do a friend specification for sc_trace in an environment where
+//  there are partial template and full template specifications for its
+//  arguments.
+//
+// Revision 1.7  2006/04/17 16:38:42  acg
+//  Andy Goodrich: added more context to the deprecation message for the
+//  sc_clock constructor.
+//
+// Revision 1.6  2006/01/25 00:31:11  acg
+//  Andy Goodrich: Changed over to use a standard message id of
+//  SC_ID_IEEE_1666_DEPRECATION for all deprecation messages.
+//
+// Revision 1.5  2006/01/24 20:43:24  acg
+// Andy Goodrich: convert notify_delayed() calls into notify_internal() calls.
+// notify_internal() is an implementation dependent version of notify_delayed()
+// that is simpler, and does not trigger the deprecation warning one would get
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_clock.h b/ext/systemc/src/sysc/communication/sc_clock.h
new file mode 100644
index 000000000..634936ce6
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_clock.h
@@ -0,0 +1,275 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_clock.h -- The clock channel.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_CLOCK_H
+#define SC_CLOCK_H
+
+
+#include "sysc/kernel/sc_module.h"
+#include "sysc/communication/sc_signal.h"
+#include "sysc/tracing/sc_trace.h"
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_clock
+//
+//  The clock channel.
+// ----------------------------------------------------------------------------
+
+class sc_clock
+  : public sc_signal<bool,SC_ONE_WRITER>
+{
+  typedef sc_signal<bool,SC_ONE_WRITER> base_type;
+public:
+
+    friend class sc_clock_posedge_callback;
+    friend class sc_clock_negedge_callback;
+
+    // constructors
+
+    sc_clock();
+
+    explicit sc_clock( const char* name_ );
+
+    sc_clock( const char* name_,
+	      const sc_time& period_,
+	      double         duty_cycle_ = 0.5,
+	      const sc_time& start_time_ = SC_ZERO_TIME,
+	      bool           posedge_first_ = true );
+
+    sc_clock( const char* name_,
+	      double         period_v_,
+	      sc_time_unit   period_tu_,
+	      double         duty_cycle_ = 0.5 );
+
+    sc_clock( const char* name_,
+	      double         period_v_,
+	      sc_time_unit   period_tu_,
+	      double         duty_cycle_,
+	      double         start_time_v_,
+	      sc_time_unit   start_time_tu_,
+	      bool           posedge_first_ = true );
+
+    // for backward compatibility with 1.0
+    sc_clock( const char* name_,
+	      double         period_,            // in default time units
+	      double         duty_cycle_ = 0.5,
+	      double         start_time_ = 0.0,  // in default time units
+	      bool           posedge_first_ = true );
+
+    // destructor (does nothing)
+    virtual ~sc_clock();
+
+    virtual void register_port( sc_port_base&, const char* if_type );
+    virtual void write( const bool& );
+
+    // get the period
+    const sc_time& period() const
+	{ return m_period; }
+
+    // get the duty cycle
+    double duty_cycle() const
+	{ return m_duty_cycle; }
+
+
+    // get the current time / clock characteristics
+
+    bool posedge_first() const
+        { return m_posedge_first; }
+
+    sc_time start_time() const
+        { return m_start_time; }
+
+    static const sc_time& time_stamp();
+
+    virtual const char* kind() const
+        { return "sc_clock"; }
+
+
+#if 0 // @@@@#### REMOVE
+    // for backward compatibility with 1.0
+
+    sc_signal_in_if<bool>& signal()
+	{ return *this; }
+
+    const sc_signal_in_if<bool>& signal() const
+	{ return *this; }
+
+    static void start( const sc_time& duration )
+	{ sc_start( duration ); }
+
+    static void start( double v, sc_time_unit tu )
+	{ sc_start( sc_time(v, tu) ); }
+
+    static void start( double duration = -1 )
+	{ sc_start( duration ); }
+
+    static void stop()
+	{ sc_stop(); }
+#endif
+
+protected:
+
+    void before_end_of_elaboration();
+
+    // processes
+    void posedge_action();
+    void negedge_action();
+
+
+    // error reporting
+    void report_error( const char* id, const char* add_msg = 0 ) const;
+
+
+    void init( const sc_time&, double, const sc_time&, bool );
+
+    bool is_clock() const { return true; }
+
+protected:
+
+    sc_time  m_period;		// the period of this clock
+    double   m_duty_cycle;	// the duty cycle (fraction of period)
+    sc_time  m_start_time;	// the start time of the first edge
+    bool     m_posedge_first;   // true if first edge is positive
+    sc_time  m_posedge_time;	// time till next positive edge
+    sc_time  m_negedge_time;	// time till next negative edge
+
+    sc_event m_next_posedge_event;
+    sc_event m_next_negedge_event;
+
+private:
+
+    // disabled
+    sc_clock( const sc_clock& );
+    sc_clock& operator = ( const sc_clock& );
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+// processes
+
+inline
+void
+sc_clock::posedge_action()
+{
+    m_next_negedge_event.notify_internal( m_negedge_time );
+	m_new_val = true;
+	request_update();
+}
+
+inline
+void
+sc_clock::negedge_action()
+{
+    m_next_posedge_event.notify_internal( m_posedge_time );
+	m_new_val = false;
+	request_update();
+}
+
+
+// ----------------------------------------------------------------------------
+
+class sc_clock_posedge_callback {
+public:
+    sc_clock_posedge_callback(sc_clock* target_p) : m_target_p(target_p) {}
+    inline void operator () () { m_target_p->posedge_action(); }
+  protected:
+    sc_clock* m_target_p;
+};
+
+class sc_clock_negedge_callback {
+  public:
+    sc_clock_negedge_callback(sc_clock* target_p) : m_target_p(target_p) {}
+    inline void operator () () { m_target_p->negedge_action(); }
+  protected:
+    sc_clock* m_target_p;
+};
+
+
+} // namespace sc_core
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Bishnupriya Bhattacharya, Cadence Design Systems,
+                               3 October, 2003
+  Description of Modification: sc_clock inherits from sc_signal<bool> only
+                               instead of sc_signal_in_if<bool> and sc_module.
+    
+      Name, Affiliation, Date:
+  Description of Modification:
+    
+ *****************************************************************************/
+//$Log: sc_clock.h,v $
+//Revision 1.5  2011/08/26 20:45:39  acg
+// Andy Goodrich: moved the modification log to the end of the file to
+// eliminate source line number skew when check-ins are done.
+//
+//Revision 1.4  2011/08/24 22:05:35  acg
+// Torsten Maehne: initialization changes to remove warnings.
+//
+//Revision 1.3  2011/02/18 20:23:45  acg
+// Andy Goodrich: Copyright update.
+//
+//Revision 1.2  2011/01/20 16:52:15  acg
+// Andy Goodrich: changes for IEEE 1666 2011.
+//
+//Revision 1.1.1.1  2006/12/15 20:20:04  acg
+//SystemC 2.3
+//
+//Revision 1.5  2006/01/25 00:31:11  acg
+// Andy Goodrich: Changed over to use a standard message id of
+// SC_ID_IEEE_1666_DEPRECATION for all deprecation messages.
+//
+//Revision 1.4  2006/01/24 20:43:25  acg
+// Andy Goodrich: convert notify_delayed() calls into notify_internal() calls.
+// notify_internal() is an implementation dependent version of notify_delayed()
+// that is simpler, and does not trigger the deprecation warning one would get
+// using notify_delayed().
+//
+//Revision 1.3  2006/01/18 21:42:26  acg
+//Andy Goodrich: Changes for check writer support, and tightening up sc_clock
+//port usage.
+//
+//Revision 1.2  2006/01/03 23:18:26  acg
+//Changed copyright to include 2006.
+//
+//Revision 1.1.1.1  2005/12/19 23:16:43  acg
+//First check in of SystemC 2.1 into its own archive.
+//
+//Revision 1.14  2005/06/10 22:43:55  acg
+//Added CVS change log annotation.
+//
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_clock_ports.h b/ext/systemc/src/sysc/communication/sc_clock_ports.h
new file mode 100644
index 000000000..70ac80c1d
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_clock_ports.h
@@ -0,0 +1,72 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_clock_ports.h -- The clock ports.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_CLOCK_PORTS_H
+#define SC_CLOCK_PORTS_H
+
+
+#include "sysc/communication/sc_signal_ports.h"
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  The clock ports.
+//
+//  (Provided for backward compatibility reasons.)
+// ----------------------------------------------------------------------------
+
+typedef sc_in<bool>    sc_in_clk;
+typedef sc_inout<bool> sc_inout_clk;
+typedef sc_out<bool>   sc_out_clk;
+
+} // namespace sc_core
+
+//$Log: sc_clock_ports.h,v $
+//Revision 1.3  2011/08/26 20:45:39  acg
+// Andy Goodrich: moved the modification log to the end of the file to
+// eliminate source line number skew when check-ins are done.
+//
+//Revision 1.2  2011/02/18 20:23:45  acg
+// Andy Goodrich: Copyright update.
+//
+//Revision 1.1.1.1  2006/12/15 20:20:04  acg
+//SystemC 2.3
+//
+//Revision 1.2  2006/01/03 23:18:26  acg
+//Changed copyright to include 2006.
+//
+//Revision 1.1.1.1  2005/12/19 23:16:43  acg
+//First check in of SystemC 2.1 into its own archive.
+//
+//Revision 1.8  2005/06/10 22:43:55  acg
+//Added CVS change log annotation.
+//
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_communication_ids.h b/ext/systemc/src/sysc/communication/sc_communication_ids.h
new file mode 100644
index 000000000..fe9995775
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_communication_ids.h
@@ -0,0 +1,164 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_communication_ids.h -- Report ids for the communication code.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2002-01-17
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_COMMUNICATION_IDS_H
+#define SC_COMMUNICATION_IDS_H
+
+
+#include "sysc/utils/sc_report.h"
+
+
+// ----------------------------------------------------------------------------
+//  Report ids (communication)
+//
+//  Report ids in the range of 100-199.
+// ----------------------------------------------------------------------------
+
+#ifndef SC_DEFINE_MESSAGE
+#define SC_DEFINE_MESSAGE(id,unused1,unused2) \
+    namespace sc_core { extern const char id[]; }
+namespace sc_core {
+    extern const char SC_ID_REGISTER_ID_FAILED_[]; // in sc_report_handler.cpp
+} // namespace sc_core
+#endif
+
+SC_DEFINE_MESSAGE( SC_ID_PORT_OUTSIDE_MODULE_, 100,
+			"port specified outside of module" )
+SC_DEFINE_MESSAGE( SC_ID_CLOCK_PERIOD_ZERO_, 101,
+			"sc_clock period is zero" )              
+SC_DEFINE_MESSAGE( SC_ID_CLOCK_HIGH_TIME_ZERO_, 102,
+			"sc_clock high time is zero" )    
+SC_DEFINE_MESSAGE( SC_ID_CLOCK_LOW_TIME_ZERO_, 103,
+			"sc_clock low time is zero" )     
+SC_DEFINE_MESSAGE( SC_ID_MORE_THAN_ONE_FIFO_READER_, 104,
+			"sc_fifo<T> cannot have more than one reader" )
+SC_DEFINE_MESSAGE( SC_ID_MORE_THAN_ONE_FIFO_WRITER_, 105,
+			"sc_fifo<T> cannot have more than one writer" )
+SC_DEFINE_MESSAGE( SC_ID_INVALID_FIFO_SIZE_, 106,
+			"sc_fifo<T> must have a size of at least 1" )
+SC_DEFINE_MESSAGE( SC_ID_BIND_IF_TO_PORT_, 107,
+			"bind interface to port failed" ) 
+SC_DEFINE_MESSAGE( SC_ID_BIND_PORT_TO_PORT_, 108,
+			"bind parent port to port failed" )
+SC_DEFINE_MESSAGE( SC_ID_COMPLETE_BINDING_, 109,
+			"complete binding failed" )
+SC_DEFINE_MESSAGE( SC_ID_INSERT_PORT_, 110,
+			"insert port failed" )
+SC_DEFINE_MESSAGE( SC_ID_REMOVE_PORT_, 111,
+			"remove port failed" )
+SC_DEFINE_MESSAGE( SC_ID_GET_IF_, 112,
+			"get interface failed" )
+SC_DEFINE_MESSAGE( SC_ID_INSERT_PRIM_CHANNEL_, 113,
+			"insert primitive channel failed" )
+SC_DEFINE_MESSAGE( SC_ID_REMOVE_PRIM_CHANNEL_, 114, 
+			"remove primitive channel failed" ) 
+SC_DEFINE_MESSAGE( SC_ID_MORE_THAN_ONE_SIGNAL_DRIVER_, 115,
+			"sc_signal<T> cannot have more than one driver" )
+SC_DEFINE_MESSAGE( SC_ID_NO_DEFAULT_EVENT_,    116,
+			"channel doesn't have a default event" )
+SC_DEFINE_MESSAGE( SC_ID_RESOLVED_PORT_NOT_BOUND_, 117,
+			"resolved port not bound to resolved signal" )
+SC_DEFINE_MESSAGE( SC_ID_FIND_EVENT_, 118,
+			"find event failed" )
+SC_DEFINE_MESSAGE( SC_ID_INVALID_SEMAPHORE_VALUE_,  119,
+			"sc_semaphore requires an initial value >= 0" )
+SC_DEFINE_MESSAGE( SC_ID_SC_EXPORT_HAS_NO_INTERFACE_,  120,
+			"sc_export instance has no interface" )
+SC_DEFINE_MESSAGE( SC_ID_INSERT_EXPORT_,  121,
+    "insert sc_export failed" )
+SC_DEFINE_MESSAGE( SC_ID_SC_EXPORT_NOT_REGISTERED_,  123,
+    "remove sc_export failed, sc_export not registered" )
+SC_DEFINE_MESSAGE( SC_ID_SC_EXPORT_NOT_BOUND_AFTER_CONSTRUCTION_,  124,
+    "sc_export instance not bound to interface at end of construction" )
+SC_DEFINE_MESSAGE( SC_ID_ATTEMPT_TO_WRITE_TO_CLOCK_,  125,
+   "attempt to write the value of an sc_clock instance" )
+SC_DEFINE_MESSAGE( SC_ID_SC_EXPORT_ALREADY_BOUND_,  126,
+    "sc_export instance already bound" )
+SC_DEFINE_MESSAGE( SC_ID_OPERATION_ON_NON_SPECIALIZED_SIGNAL_,  127,
+    "attempted specalized signal operation on non-specialized signal" )
+SC_DEFINE_MESSAGE( SC_ID_ATTEMPT_TO_BIND_CLOCK_TO_OUTPUT_,  128,
+    "attempted to bind sc_clock instance to sc_inout or sc_out" )
+SC_DEFINE_MESSAGE( SC_ID_NO_ASYNC_UPDATE_,  129,
+    "this build has no asynchronous update support" )
+
+/* 
+$Log: sc_communication_ids.h,v $
+Revision 1.5  2011/08/26 20:45:39  acg
+ Andy Goodrich: moved the modification log to the end of the file to
+ eliminate source line number skew when check-ins are done.
+
+Revision 1.4  2011/04/19 02:36:26  acg
+ Philipp A. Hartmann: new aysnc_update and mutex support.
+
+Revision 1.3  2011/02/18 20:23:45  acg
+ Andy Goodrich: Copyright update.
+
+Revision 1.2  2011/02/14 17:50:16  acg
+ Andy Goodrich: testing for sc_port and sc_export instantiations during
+ end of elaboration and issuing appropriate error messages.
+
+Revision 1.1.1.1  2006/12/15 20:20:04  acg
+SystemC 2.3
+
+Revision 1.5  2006/01/25 00:31:11  acg
+ Andy Goodrich: Changed over to use a standard message id of
+ SC_ID_IEEE_1666_DEPRECATION for all deprecation messages.
+
+Revision 1.4  2006/01/24 20:46:31  acg
+Andy Goodrich: changes to eliminate use of deprecated features. For instance,
+using notify(SC_ZERO_TIME) in place of notify_delayed().
+
+Revision 1.3  2006/01/18 21:42:26  acg
+Andy Goodrich: Changes for check writer support, and tightening up sc_clock
+port usage.
+
+Revision 1.2  2006/01/03 23:18:26  acg
+Changed copyright to include 2006.
+
+Revision 1.1.1.1  2005/12/19 23:16:43  acg
+First check in of SystemC 2.1 into its own archive.
+
+Revision 1.12  2005/04/03 22:52:51  acg
+Namespace changes.
+
+Revision 1.11  2005/03/21 22:31:32  acg
+Changes to sc_core namespace.
+
+Revision 1.10  2004/10/28 00:21:48  acg
+Added check that sc_export instances are not bound twice.
+
+Revision 1.9  2004/09/27 21:02:54  acg
+Andy Goodrich - Forte Design Systems, Inc.
+   - Added a $Log comment so that CVS checkin comments will appear in
+     checked out source.
+
+*/
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_event_finder.cpp b/ext/systemc/src/sysc/communication/sc_event_finder.cpp
new file mode 100644
index 000000000..25d16a1f5
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_event_finder.cpp
@@ -0,0 +1,113 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_event_finder.cpp --
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+                   Stan Y. Liao, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#include "sysc/communication/sc_event_finder.h"
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_event_finder
+//
+//  Event finder base class.
+// ----------------------------------------------------------------------------
+
+// error reporting
+
+void
+sc_event_finder::report_error( const char* id, const char* add_msg ) const
+{
+    char msg[BUFSIZ];
+    if( add_msg != 0 ) {
+	std::sprintf( msg, "%s: port '%s' (%s)",
+		 add_msg, m_port.name(), m_port.kind() );
+    } else {
+	std::sprintf( msg, "port '%s' (%s)", m_port.name(), m_port.kind() );
+    }
+    SC_REPORT_ERROR( id, msg );
+}
+
+
+// constructor
+
+sc_event_finder::sc_event_finder( const sc_port_base& port_ )
+: m_port( port_ )
+{
+}
+
+
+// destructor (does nothing)
+
+sc_event_finder::~sc_event_finder()
+{}
+
+} // namespace sc_core
+
+// $Log: sc_event_finder.cpp,v $
+// Revision 1.3  2011/08/26 20:45:39  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.2  2011/02/18 20:23:45  acg
+//  Andy Goodrich: Copyright update.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.7  2006/02/02 23:42:37  acg
+//  Andy Goodrich: implemented a much better fix to the sc_event_finder
+//  proliferation problem. This new version allocates only a single event
+//  finder for each port for each type of event, e.g., pos(), neg(), and
+//  value_change(). The event finder persists as long as the port does,
+//  which is what the LRM dictates. Because only a single instance is
+//  allocated for each event type per port there is not a potential
+//  explosion of storage as was true in the 2.0.1/2.1 versions.
+//
+// Revision 1.6  2006/02/02 21:26:34  acg
+//  Andy Goodrich: pulled out the check I just stuck into the
+//  sc_event_finder::free_instances() method. It turns out the LRM says that
+//  sc_event_finder instances are valid as long as the sc_module hierarchy is
+//  valid, so we can't give the user a call to free the instances.
+//
+// Revision 1.5  2006/02/02 21:10:52  acg
+//  Andy Goodrich: added check for end of elaboration to the static method
+//  sc_event_finder::free_instances(). This will allow the method to be
+//  made public if that is desired.
+//
+// Revision 1.4  2006/02/02 20:43:09  acg
+//  Andy Goodrich: Added an existence linked list to sc_event_finder so that
+//  the dynamically allocated instances can be freed after port binding
+//  completes. This replaces the individual deletions in ~sc_bind_ef, as these
+//  caused an exception if an sc_event_finder instance was used more than
+//  once, due to a double freeing of the instance.
+//
+// Revision 1.3  2006/01/13 18:47:41  acg
+// Added $Log command so that CVS comments are reproduced in the source.
+//
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_event_finder.h b/ext/systemc/src/sysc/communication/sc_event_finder.h
new file mode 100644
index 000000000..15205553f
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_event_finder.h
@@ -0,0 +1,178 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_event_finder.h --
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+                   Stan Y. Liao, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_EVENT_FINDER
+#define SC_EVENT_FINDER
+
+
+#include "sysc/communication/sc_port.h"
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_event_finder
+//
+//  Event finder base class.
+// ----------------------------------------------------------------------------
+
+class sc_event_finder
+{
+  friend class sc_simcontext;
+
+public:
+
+    const sc_port_base& port() const
+        { return m_port; }
+
+    // destructor (does nothing)
+    virtual ~sc_event_finder();
+
+    virtual const sc_event& find_event( sc_interface* if_p = 0 ) const = 0;
+
+protected:
+    
+    // constructor
+    sc_event_finder( const sc_port_base& );
+
+    // error reporting
+    void report_error( const char* id, const char* add_msg = 0 ) const;
+
+
+private:
+    const  sc_port_base&    m_port;    // port providing the event.
+
+private:
+
+    // disabled
+    sc_event_finder();
+    sc_event_finder( const sc_event_finder& );
+    sc_event_finder& operator = ( const sc_event_finder& );
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_event_finder_t<IF>
+//
+//  Interface specific event finder class.
+// ----------------------------------------------------------------------------
+
+template <class IF>
+class sc_event_finder_t
+: public sc_event_finder
+{
+public:
+
+    // constructor
+
+    sc_event_finder_t( const sc_port_base& port_,
+		       const sc_event& (IF::*event_method_) () const )
+        : sc_event_finder( port_ ), m_event_method( event_method_ )
+        {}
+
+    // destructor (does nothing)
+
+    virtual ~sc_event_finder_t()
+        {}
+
+    virtual const sc_event& find_event( sc_interface* if_p = 0 ) const;
+
+private:
+
+    const sc_event& (IF::*m_event_method) () const;
+
+private:
+
+    // disabled
+    sc_event_finder_t();
+    sc_event_finder_t( const sc_event_finder_t<IF>& );
+    sc_event_finder_t<IF>& operator = ( const sc_event_finder_t<IF>& );
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+template <class IF>
+inline
+const sc_event&
+sc_event_finder_t<IF>::find_event( sc_interface* if_p ) const
+{
+    const IF* iface = ( if_p ) ? DCAST<const IF*>( if_p ) :
+		                 DCAST<const IF*>( port().get_interface() );
+    if( iface == 0 ) {
+		report_error( SC_ID_FIND_EVENT_, "port is not bound" );
+    }
+    return (CCAST<IF*>( iface )->*m_event_method) ();
+}
+
+} // namespace sc_core
+
+//$Log: sc_event_finder.h,v $
+//Revision 1.3  2011/08/26 20:45:39  acg
+// Andy Goodrich: moved the modification log to the end of the file to
+// eliminate source line number skew when check-ins are done.
+//
+//Revision 1.2  2011/02/18 20:23:45  acg
+// Andy Goodrich: Copyright update.
+//
+//Revision 1.1.1.1  2006/12/15 20:20:04  acg
+//SystemC 2.3
+//
+//Revision 1.4  2006/02/02 23:42:37  acg
+// Andy Goodrich: implemented a much better fix to the sc_event_finder
+// proliferation problem. This new version allocates only a single event
+// finder for each port for each type of event, e.g., pos(), neg(), and
+// value_change(). The event finder persists as long as the port does,
+// which is what the LRM dictates. Because only a single instance is
+// allocated for each event type per port there is not a potential
+// explosion of storage as was true in the 2.0.1/2.1 versions.
+//
+//Revision 1.3  2006/02/02 20:43:09  acg
+// Andy Goodrich: Added an existence linked list to sc_event_finder so that
+// the dynamically allocated instances can be freed after port binding
+// completes. This replaces the individual deletions in ~sc_bind_ef, as these
+// caused an exception if an sc_event_finder instance was used more than
+// once, due to a double freeing of the instance.
+//
+//Revision 1.2  2006/01/03 23:18:26  acg
+//Changed copyright to include 2006.
+//
+//Revision 1.1.1.1  2005/12/19 23:16:43  acg
+//First check in of SystemC 2.1 into its own archive.
+//
+//Revision 1.10  2005/09/15 23:01:51  acg
+//Added std:: prefix to appropriate methods and types to get around
+//issues with the Edison Front End.
+//
+//Revision 1.9  2005/06/10 22:43:55  acg
+//Added CVS change log annotation.
+//
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_event_queue.cpp b/ext/systemc/src/sysc/communication/sc_event_queue.cpp
new file mode 100644
index 000000000..7e1ebc864
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_event_queue.cpp
@@ -0,0 +1,146 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_event_queue.cpp -- Event Queue Support
+
+  Original Author: Stuart Swan, Cadence Inc.
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#include "sysc/communication/sc_event_queue.h"
+#include "sysc/kernel/sc_method_process.h"
+
+namespace sc_core {
+
+static int 
+sc_time_compare( const void* p1, const void* p2 )
+{
+    const sc_time* t1 = static_cast<const sc_time*>( p1 );
+    const sc_time* t2 = static_cast<const sc_time*>( p2 );
+
+    if( *t1 < *t2 ) {
+	return 1;
+    } else if( *t1 > *t2 ) {
+	return -1;
+    } else {
+	return 0;
+    }  
+}
+
+sc_event_queue::sc_event_queue( sc_module_name name_ )
+    : sc_module( name_ ),
+      m_ppq( 128, sc_time_compare ),
+      m_e( (std::string(SC_KERNEL_EVENT_PREFIX)+"_event").c_str() ),
+      m_change_stamp(0),
+      m_pending_delta(0)
+{
+    SC_METHOD( fire_event );
+    sensitive << m_e;
+    dont_initialize();
+}
+
+sc_event_queue::~sc_event_queue()
+{
+  while (m_ppq.size() > 0) {
+    delete m_ppq.extract_top();
+  }
+}
+
+void sc_event_queue::cancel_all()
+{
+    m_pending_delta = 0;
+    while( m_ppq.size() > 0 )
+	delete m_ppq.extract_top();
+    m_e.cancel();
+}
+
+void sc_event_queue::notify (const sc_time& when)
+{
+    m_change_stamp = simcontext()->change_stamp();
+    sc_time* t = new sc_time( when+sc_time_stamp() );
+    if ( m_ppq.size()==0 || *t < *m_ppq.top() ) {
+	m_e.notify( when );
+    }
+    m_ppq.insert( t );
+}
+    
+void sc_event_queue::fire_event()
+{
+    if ( m_ppq.empty() ) { // event has been cancelled
+        return;
+    }
+    sc_time* t = m_ppq.extract_top();
+    assert( *t==sc_time_stamp() );
+    delete t;
+
+    if ( m_ppq.size() > 0 ) {
+	m_e.notify( *m_ppq.top() - sc_time_stamp() );
+    }
+}
+
+} // namespace sc_core
+
+// $Log: sc_event_queue.cpp,v $
+// Revision 1.9  2011/08/26 22:45:53  acg
+//  Torsten Maehne: remove redundant initialization assignment.
+//
+// Revision 1.8  2011/08/26 21:44:58  acg
+//  Andy Goodrich: fix internal event naming.
+//
+// Revision 1.7  2011/08/26 20:45:39  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.6  2011/08/24 22:05:35  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.5  2011/04/08 18:22:46  acg
+//  Philipp A. Hartmann: use the context of the primitive channel to get
+//  the change stamp value.
+//
+// Revision 1.4  2011/04/05 20:48:09  acg
+//  Andy Goodrich: changes to make sure that event(), posedge() and negedge()
+//  only return true if the clock has not moved.
+//
+// Revision 1.3  2011/02/18 20:23:45  acg
+//  Andy Goodrich: Copyright update.
+//
+// Revision 1.2  2010/07/22 20:02:30  acg
+//  Andy Goodrich: bug fixes.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.5  2006/11/28 20:30:48  acg
+//  Andy Goodrich: updated from 2.2 source. sc_event_queue constructors
+//  collapsed into a single constructor with an optional argument to get
+//  the sc_module_name stack done correctly. Class name prefixing added
+//  to sc_semaphore calls to wait() to keep gcc 4.x happy.
+//
+// Revision 1.4  2006/01/26 21:00:50  acg
+//  Andy Goodrich: conversion to use sc_event::notify(SC_ZERO_TIME) instead of
+//  sc_event::notify_delayed()
+//
+// Revision 1.3  2006/01/13 18:47:42  acg
+// Added $Log command so that CVS comments are reproduced in the source.
+
+// taf
diff --git a/ext/systemc/src/sysc/communication/sc_event_queue.h b/ext/systemc/src/sysc/communication/sc_event_queue.h
new file mode 100644
index 000000000..4438de9ef
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_event_queue.h
@@ -0,0 +1,181 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_event_queue.h -- Event Queue Facility Definitions
+
+  Original Author: Ulli Holtmann, Synopsys, Inc.
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_EVENT_QUEUE_H
+#define SC_EVENT_QUEUE_H
+
+
+/*
+  Class sc_event_queue
+
+  A queue that can contain any number of pending notifications.
+  The queue has a similiar interface like an sc_event but has different
+  semantics: it can carry any number of pending notification. The
+  general rule is that _every_ call to notify() will cause a 
+  corresponding trigger at the specified wall-clock time that can be
+  observed (the only exception is when notifications are explicitly
+  cancelled). 
+
+  If multiple notifications are pending at the same wall-clock
+  time, then the event queue will trigger in different delta cycles
+  in order to ensure that sensitive processes can notice each
+  trigger. The first trigger happens in the earliest delta cycle
+  possible which is the same behavior as a normal timed event.
+  
+*/
+
+#include "sysc/communication/sc_interface.h"
+#include "sysc/kernel/sc_module.h"
+#include "sysc/kernel/sc_event.h"
+#include "sysc/communication/sc_port.h"
+
+namespace sc_core {
+
+
+// ---------------------------------------------------------------------------
+// sc_event_queue_if
+// ---------------------------------------------------------------------------
+
+class sc_event_queue_if : public virtual sc_interface
+{
+public:
+    virtual void notify (double when, sc_time_unit base) =0;
+    virtual void notify (const sc_time& when) =0;
+    virtual void cancel_all() =0;
+};
+
+// ---------------------------------------------------------------------------
+// sc_event_queue: a queue that can contain any number of pending 
+// delta, or timed events.
+// ---------------------------------------------------------------------------
+
+class sc_event_queue: 
+  public sc_event_queue_if,
+  public sc_module
+{
+ public:
+
+    SC_HAS_PROCESS( sc_event_queue );
+
+    sc_event_queue( sc_module_name name_ = sc_gen_unique_name("event_queue") );
+    ~sc_event_queue();
+
+    // API of sc_object
+    inline virtual const char* kind() const { return "sc_event_queue"; }
+
+    //
+    // API of sc_event_queue_if
+    //
+    inline virtual void notify (double when, sc_time_unit base);
+           virtual void notify (const sc_time& when);
+           virtual void cancel_all();
+
+    //
+    // API for using the event queue in processes
+    //
+
+    // get the default event
+    inline virtual const sc_event& default_event() const;
+
+/*
+    //
+    // Possible extensions:
+    //
+    
+    // Cancel an events at a specific time
+    void cancel (const sc_time& when);
+    void cancel (double when, sc_time_unit base);
+
+    // How many events are pending altogether?
+    unsigned pending() const;
+
+    // How many events are pending at the specific time?
+    unsigned pending(const sc_time& when) const;
+    unsigned pending(double when, sc_time_unit base) const;
+*/
+
+ private:
+    void fire_event();
+
+ private:
+    sc_ppq<sc_time*> m_ppq;
+    sc_event m_e;
+    sc_dt::uint64 m_change_stamp;
+    unsigned m_pending_delta;
+};
+
+inline
+void sc_event_queue::notify (double when, sc_time_unit base )
+{
+	notify( sc_time(when,base) );
+}
+    
+inline
+const sc_event& sc_event_queue::default_event() const
+{ 
+  return m_e; 
+}
+
+
+//
+// Using event queue as a port
+//
+typedef sc_port<sc_event_queue_if,1,SC_ONE_OR_MORE_BOUND> sc_event_queue_port;
+
+} // namespace sc_core
+
+// $Log: sc_event_queue.h,v $
+// Revision 1.5  2011/08/26 20:45:40  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.4  2011/04/05 20:48:09  acg
+//  Andy Goodrich: changes to make sure that event(), posedge() and negedge()
+//  only return true if the clock has not moved.
+//
+// Revision 1.3  2011/02/18 20:23:45  acg
+//  Andy Goodrich: Copyright update.
+//
+// Revision 1.2  2008/05/20 16:45:52  acg
+//  Andy Goodrich: changed which unique name generator is used from the
+//  global one to the one for sc_modules.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.4  2006/11/28 20:30:48  acg
+//  Andy Goodrich: updated from 2.2 source. sc_event_queue constructors
+//  collapsed into a single constructor with an optional argument to get
+//  the sc_module_name stack done correctly. Class name prefixing added
+//  to sc_semaphore calls to wait() to keep gcc 4.x happy.
+//
+// Revision 1.3  2006/01/13 18:47:42  acg
+// Added $Log command so that CVS comments are reproduced in the source.
+//
+
+#endif // SC_EVENT_QUEUE_H
diff --git a/ext/systemc/src/sysc/communication/sc_export.cpp b/ext/systemc/src/sysc/communication/sc_export.cpp
new file mode 100644
index 000000000..2da7a1533
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_export.cpp
@@ -0,0 +1,305 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_export.cpp -- 
+
+  Original Author: Bishnupriya Bhattachary, Cadence, Design Systems, 
+                   25 August, 2003
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#include "sysc/communication/sc_export.h"
+#include "sysc/kernel/sc_simcontext.h"
+#include "sysc/kernel/sc_module.h"
+#include "sysc/kernel/sc_object_int.h"
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_export_base
+//
+// ----------------------------------------------------------------------------
+
+sc_export_base::sc_export_base() : sc_object(sc_gen_unique_name("export"))
+{
+    simcontext()->get_export_registry()->insert(this);
+}
+    
+sc_export_base::sc_export_base(const char* name_) : sc_object(name_)
+{
+    simcontext()->get_export_registry()->insert(this);
+}
+    
+sc_export_base::~sc_export_base()
+{
+    simcontext()->get_export_registry()->remove(this);
+}
+
+// called by construction_done() (does nothing by default)
+
+void
+sc_export_base::before_end_of_elaboration()
+{
+}
+
+// called when construction is done
+
+void
+sc_export_base::construction_done()
+{
+    if ( get_interface() == 0 )
+    {
+      report_error( SC_ID_SC_EXPORT_NOT_BOUND_AFTER_CONSTRUCTION_, 0);
+    }
+
+    sc_module* parent = static_cast<sc_module*>( get_parent_object() );
+    sc_object::hierarchy_scope scope( parent );
+    before_end_of_elaboration();
+}
+
+// called by elaboration_done() (does nothing by default)
+
+void
+sc_export_base::end_of_elaboration()
+{}
+
+// called when elaboration is done
+
+void
+sc_export_base::elaboration_done()
+{
+    sc_module* parent = static_cast<sc_module*>( get_parent_object() );
+    sc_object::hierarchy_scope scope( parent );
+    end_of_elaboration();
+}
+
+// called by start_simulation (does nothing)
+
+void
+sc_export_base::start_of_simulation()
+{}
+
+// called before simulation starts
+
+void
+sc_export_base::start_simulation()
+{
+    sc_module* parent = static_cast<sc_module*>( get_parent_object() );
+    sc_object::hierarchy_scope scope( parent );
+    start_of_simulation();
+}
+
+// called by simulation_done (does nothing)
+
+void
+sc_export_base::end_of_simulation()
+{}
+
+// called after simulation ends
+
+void
+sc_export_base::simulation_done()
+{
+    sc_module* parent = static_cast<sc_module*>( get_parent_object() );
+    sc_object::hierarchy_scope scope( parent );
+    end_of_simulation();
+}
+
+void
+sc_export_base::report_error( const char* id, const char* add_msg ) const
+{
+    char msg[BUFSIZ];
+    if( add_msg != 0 ) {
+        std::sprintf( msg, "%s: export '%s' (%s)", add_msg, name(), kind() );
+    } else {
+        std::sprintf( msg, "export '%s' (%s)", name(), kind() );
+    }
+    SC_REPORT_ERROR( id, msg );
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_export_registry
+//
+//  Registry for all exports.
+//  FOR INTERNAL USE ONLY!
+// ----------------------------------------------------------------------------
+
+void
+sc_export_registry::insert( sc_export_base* export_ )
+{
+    if( sc_is_running() ) {
+	export_->report_error(SC_ID_INSERT_EXPORT_, "simulation running");
+    }
+
+    if( m_simc->elaboration_done()  ) {
+       export_->report_error(SC_ID_INSERT_EXPORT_, "elaboration done");
+    }
+
+
+#ifdef DEBUG_SYSTEMC
+    // check if port_ is already inserted
+    for( int i = size() - 1; i >= 0; -- i ) {
+	if( export_ == m_export_vec[i] ) {
+	    export_->report_error( SC_ID_INSERT_EXPORT_, 
+	                           "export already inserted ");
+	}
+    }
+#endif
+
+/* 
+    //TBD:  maybe we want to do this stuf for later
+
+    // append the port to the current module's vector of ports
+    sc_module* curr_module = m_simc->hierarchy_curr();
+    if( curr_module == 0 ) {
+	port_->report_error( SC_ID_PORT_OUTSIDE_MODULE_ );
+    }
+    curr_module->append_port( port_ );
+*/
+
+    // insert
+    m_export_vec.push_back( export_ );
+}
+
+void
+sc_export_registry::remove( sc_export_base* export_ )
+{
+    if (size()==0) return;
+    int i;
+    for( i = size() - 1; i >= 0; -- i ) {
+	if( export_ == m_export_vec[i] ) {
+	    break;
+	}
+    }
+    if( i == -1 ) {
+	export_->report_error( SC_ID_SC_EXPORT_NOT_REGISTERED_ );
+    }
+
+    // remove
+    m_export_vec[i] = m_export_vec[size() - 1];
+    m_export_vec.resize(size()-1);
+}
+
+// constructor
+
+sc_export_registry::sc_export_registry( sc_simcontext& simc_ )
+: m_construction_done(0),
+  m_export_vec(),
+  m_simc( &simc_ )
+{
+}
+
+
+// destructor
+
+sc_export_registry::~sc_export_registry()
+{
+}
+
+// called when construction is done
+
+bool
+sc_export_registry::construction_done()
+{
+    if( m_construction_done == size() )
+      // nothing has been updated
+      return true;
+
+    for( int i = size()-1; i >= m_construction_done; --i ) {
+	m_export_vec[i]->construction_done();
+    }
+
+    m_construction_done = size();
+    return false;
+}
+
+// called when elaboration is done
+
+void
+sc_export_registry::elaboration_done()
+{
+    for( int i = size() - 1; i >= 0; -- i ) {
+	m_export_vec[i]->elaboration_done();
+    }
+}
+
+// called before simulation begins
+
+void
+sc_export_registry::start_simulation()
+{
+    for( int i = size() - 1; i >= 0; -- i ) {
+	m_export_vec[i]->start_simulation();
+    }
+}
+
+void
+sc_export_registry::simulation_done()
+{
+    for( int i = size() - 1; i >= 0; -- i ) {
+	m_export_vec[i]->simulation_done();
+    }
+}
+
+} // namespace sc_core
+
+// $Log: sc_export.cpp,v $
+// Revision 1.8  2011/08/26 20:45:40  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.7  2011/08/24 22:05:36  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.6  2011/05/09 04:07:37  acg
+//  Philipp A. Hartmann:
+//    (1) Restore hierarchy in all phase callbacks.
+//    (2) Ensure calls to before_end_of_elaboration.
+//
+// Revision 1.5  2011/02/18 20:31:05  acg
+//  Philipp A. Hartmann: added error messages for calls that cannot be done
+//  after elaboration.
+//
+// Revision 1.4  2011/02/18 20:23:45  acg
+//  Andy Goodrich: Copyright update.
+//
+// Revision 1.3  2011/02/18 20:07:04  acg
+//  Philipp A. Hartmann: Patch to revert to sprintf from snprintf to keep
+//  some versions of MSVC happy.
+//
+// Revision 1.2  2011/02/14 17:50:16  acg
+//  Andy Goodrich: testing for sc_port and sc_export instantiations during
+//  end of elaboration and issuing appropriate error messages.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.4  2006/01/26 21:00:50  acg
+//  Andy Goodrich: conversion to use sc_event::notify(SC_ZERO_TIME) instead of
+//  sc_event::notify_delayed()
+//
+// Revision 1.3  2006/01/13 18:47:42  acg
+// Added $Log command so that CVS comments are reproduced in the source.
+//
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_export.h b/ext/systemc/src/sysc/communication/sc_export.h
new file mode 100644
index 000000000..81edc8cc2
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_export.h
@@ -0,0 +1,299 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_export.h -- Base classes of all export classes.
+
+  Original Author: Andy Goodrich, Forte Design Systems
+                   Bishnupriya Bhattacharya, Cadence Design Systems
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_EXPORT_H
+#define SC_EXPORT_H
+#include <typeinfo>
+
+#include "sysc/communication/sc_communication_ids.h"
+#include "sysc/communication/sc_interface.h"
+#include "sysc/kernel/sc_object.h"
+
+#if ! defined( SC_DISABLE_VIRTUAL_BIND )
+#  define SC_VIRTUAL_ virtual
+#else
+#  define SC_VIRTUAL_ /* non-virtual */
+#endif
+
+namespace sc_core {
+
+//=============================================================================
+//  CLASS : sc_export_base
+//
+//  Abstract base class for class sc_export<IF>.
+//=============================================================================
+
+class sc_export_base : public sc_object
+{
+    friend class sc_export_registry;
+public:
+
+    // typedefs
+    
+    typedef sc_export_base this_type;
+
+public:
+
+    virtual       sc_interface* get_interface() = 0;
+    virtual       const sc_interface* get_interface() const = 0;
+
+protected:
+    
+    // constructors
+
+    sc_export_base();
+    sc_export_base(const char* name);
+
+    // destructor
+
+    virtual ~sc_export_base();
+
+protected:
+
+    // called when construction is done 
+    virtual void before_end_of_elaboration();
+
+    // called when elaboration is done (does nothing by default)
+    virtual void end_of_elaboration();
+
+    // called before simulation starts (does nothing by default)
+    virtual void start_of_simulation();
+
+    // called after simulation ends (does nothing)
+    virtual void end_of_simulation();
+
+    virtual const char* if_typename() const = 0;
+ 
+    // error reporting
+    void report_error( const char* id, const char* add_msg = 0) const;
+
+private:
+
+    void construction_done();
+    void elaboration_done();
+    void start_simulation();
+    void simulation_done();
+
+    // disabled
+    sc_export_base(const this_type&);
+    this_type& operator = (const this_type& );
+
+};
+
+//=============================================================================
+//  CLASS : sc_export
+//
+//  Generic export class for other export classes. This
+//  class provides a binding point for access to an interface.
+//=============================================================================
+template<class IF>
+class sc_export : public sc_export_base
+{
+    typedef sc_export<IF> this_type;
+
+public: // constructors:
+    sc_export() : sc_export_base()
+    {
+	m_interface_p = 0;
+    }
+
+    explicit sc_export( const char* name_ ) : sc_export_base(name_)
+    {
+	m_interface_p = 0;
+    }
+
+public: // destructor:
+    virtual ~sc_export() 
+    {
+    }
+
+public: // interface access:
+
+    virtual sc_interface* get_interface() 
+    {
+	return m_interface_p;
+    }
+
+    virtual const sc_interface* get_interface() const
+    {
+        return m_interface_p;
+    }
+
+    const IF* operator -> () const {
+        if ( m_interface_p == 0 )
+        {
+            SC_REPORT_ERROR(SC_ID_SC_EXPORT_HAS_NO_INTERFACE_,name());
+        }
+        return m_interface_p;
+    }
+
+    IF* operator -> () {
+        if ( m_interface_p == 0 )
+        {
+            SC_REPORT_ERROR(SC_ID_SC_EXPORT_HAS_NO_INTERFACE_,name());
+        }
+        return m_interface_p;
+    }
+
+    operator IF& ()
+    {
+	if ( m_interface_p == 0 )
+	{
+	    SC_REPORT_ERROR(SC_ID_SC_EXPORT_HAS_NO_INTERFACE_,name());
+	}
+	return *m_interface_p;
+    }
+    operator const IF&() const
+        { return *const_cast<this_type*>(this); }
+
+
+public: // binding:
+    SC_VIRTUAL_ void bind( IF& interface_ )
+    {
+    	if ( m_interface_p )
+	{
+	    SC_REPORT_ERROR(SC_ID_SC_EXPORT_ALREADY_BOUND_,name());
+	}
+	else
+	{
+	    m_interface_p = &interface_;
+	}
+    }
+
+    void operator () ( IF& interface_ )
+    {
+        this->bind(interface_);
+    }
+
+public: // identification:
+    virtual const char* kind() const { return "sc_export"; }
+
+protected:
+  const char* if_typename() const {
+    return typeid( IF ).name();
+  }
+
+private: // disabled
+    sc_export( const this_type& );
+    this_type& operator = ( const this_type& );
+
+protected: // data fields:
+    IF* m_interface_p;		// Interface this port provides.
+};
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_export_registry
+//
+//  Registry for all exports.
+//  FOR INTERNAL USE ONLY!
+// ----------------------------------------------------------------------------
+
+class sc_export_registry
+{
+    friend class sc_simcontext;
+
+public:
+
+    void insert( sc_export_base* );
+    void remove( sc_export_base* );
+
+    int size() const
+        { return m_export_vec.size(); }
+
+private:
+
+    // constructor
+    explicit sc_export_registry( sc_simcontext& simc_ );
+
+    // destructor
+    ~sc_export_registry();
+
+    // called when construction is done
+    bool construction_done();
+
+    // called when elaboration is done
+    void elaboration_done();
+
+    // called before simulation starts
+    void start_simulation();
+
+    // called after simulation ends
+    void simulation_done();
+
+private:
+
+    int                          m_construction_done;
+    std::vector<sc_export_base*> m_export_vec;
+    sc_simcontext*               m_simc;
+
+private:
+
+    // disabled
+    sc_export_registry();
+    sc_export_registry( const sc_export_registry& );
+    sc_export_registry& operator = ( const sc_export_registry& );
+};
+
+} // namespace sc_core
+
+#undef SC_VIRTUAL_
+
+// $Log: sc_export.h,v $
+// Revision 1.7  2011/08/26 20:45:40  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.6  2011/05/09 04:07:37  acg
+//  Philipp A. Hartmann:
+//    (1) Restore hierarchy in all phase callbacks.
+//    (2) Ensure calls to before_end_of_elaboration.
+//
+// Revision 1.5  2011/04/02 00:02:14  acg
+//  Philipp A. Hartmann: add const overload for sc_export::operator IF&
+//
+// Revision 1.4  2011/02/18 20:23:45  acg
+//  Andy Goodrich: Copyright update.
+//
+// Revision 1.3  2011/02/14 17:50:16  acg
+//  Andy Goodrich: testing for sc_port and sc_export instantiations during
+//  end of elaboration and issuing appropriate error messages.
+//
+// Revision 1.2  2011/01/20 16:52:15  acg
+//  Andy Goodrich: changes for IEEE 1666 2011.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:47:42  acg
+// Added $Log command so that CVS comments are reproduced in the source.
+//
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_fifo.h b/ext/systemc/src/sysc/communication/sc_fifo.h
new file mode 100644
index 000000000..868c0304e
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_fifo.h
@@ -0,0 +1,479 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_fifo.h -- The sc_fifo<T> primitive channel class.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_FIFO_H
+#define SC_FIFO_H
+
+
+#include "sysc/communication/sc_communication_ids.h"
+#include "sysc/communication/sc_prim_channel.h"
+#include "sysc/communication/sc_fifo_ifs.h"
+#include "sysc/kernel/sc_event.h"
+#include "sysc/kernel/sc_simcontext.h"
+#include "sysc/tracing/sc_trace.h"
+#include <typeinfo>
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fifo<T>
+//
+//  The sc_fifo<T> primitive channel class.
+// ----------------------------------------------------------------------------
+
+template <class T>
+class sc_fifo
+: public sc_fifo_in_if<T>,
+  public sc_fifo_out_if<T>,
+  public sc_prim_channel
+{
+public:
+
+    // constructors
+
+    explicit sc_fifo( int size_ = 16 )
+	: sc_prim_channel( sc_gen_unique_name( "fifo" ) ),
+	  m_data_read_event(
+	      (std::string(SC_KERNEL_EVENT_PREFIX)+"_read_event").c_str()),
+	  m_data_written_event(
+	      (std::string(SC_KERNEL_EVENT_PREFIX)+"_write_event").c_str())
+	{ init( size_ ); }
+
+    explicit sc_fifo( const char* name_, int size_ = 16 )
+	: sc_prim_channel( name_ ),
+	  m_data_read_event(
+	      (std::string(SC_KERNEL_EVENT_PREFIX)+"_read_event").c_str()),
+	  m_data_written_event(
+	      (std::string(SC_KERNEL_EVENT_PREFIX)+"_write_event").c_str())
+	{ init( size_ ); }
+
+
+    // destructor
+
+    virtual ~sc_fifo()
+	{ delete [] m_buf; }
+
+
+    // interface methods
+
+    virtual void register_port( sc_port_base&, const char* );
+
+
+    // blocking read
+    virtual void read( T& );
+    virtual T read();
+
+    // non-blocking read
+    virtual bool nb_read( T& );
+
+
+    // get the number of available samples
+
+    virtual int num_available() const
+	{ return ( m_num_readable - m_num_read ); }
+
+
+    // get the data written event
+
+    virtual const sc_event& data_written_event() const
+	{ return m_data_written_event; }
+
+
+    // blocking write
+    virtual void write( const T& );
+
+    // non-blocking write
+    virtual bool nb_write( const T& );
+
+
+    // get the number of free spaces
+
+    virtual int num_free() const
+	{ return ( m_size - m_num_readable - m_num_written ); }
+
+
+    // get the data read event
+
+    virtual const sc_event& data_read_event() const
+	{ return m_data_read_event; }
+
+
+    // other methods
+
+    operator T ()
+	{ return read(); }
+
+
+    sc_fifo<T>& operator = ( const T& a )
+        { write( a ); return *this; }
+
+
+    void trace( sc_trace_file* tf ) const;
+
+
+    virtual void print( ::std::ostream& = ::std::cout ) const;
+    virtual void dump( ::std::ostream& = ::std::cout ) const;
+
+    virtual const char* kind() const
+        { return "sc_fifo"; }
+
+protected:
+
+    virtual void update();
+
+    // support methods
+
+    void init( int );
+
+    void buf_init( int );
+    bool buf_write( const T& );
+    bool buf_read( T& );
+
+protected:
+
+    int m_size;			// size of the buffer
+    T*  m_buf;			// the buffer
+    int m_free;			// number of free spaces
+    int m_ri;			// index of next read
+    int m_wi;			// index of next write
+
+    sc_port_base* m_reader;	// used for static design rule checking
+    sc_port_base* m_writer;	// used for static design rule checking
+
+    int m_num_readable;		// #samples readable
+    int m_num_read;		// #samples read during this delta cycle
+    int m_num_written;		// #samples written during this delta cycle
+
+    sc_event m_data_read_event;
+    sc_event m_data_written_event;
+
+private:
+
+    // disabled
+    sc_fifo( const sc_fifo<T>& );
+    sc_fifo& operator = ( const sc_fifo<T>& );
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+template <class T>
+inline
+void
+sc_fifo<T>::register_port( sc_port_base& port_,
+			    const char* if_typename_ )
+{
+    std::string nm( if_typename_ );
+    if( nm == typeid( sc_fifo_in_if<T> ).name() ||
+        nm == typeid( sc_fifo_blocking_in_if<T> ).name() 
+    ) {
+	// only one reader can be connected
+	if( m_reader != 0 ) {
+	    SC_REPORT_ERROR( SC_ID_MORE_THAN_ONE_FIFO_READER_, 0 );
+	}
+	m_reader = &port_;
+    } else if( nm == typeid( sc_fifo_out_if<T> ).name() ||
+               nm == typeid( sc_fifo_blocking_out_if<T> ).name()
+    ) {
+	// only one writer can be connected
+	if( m_writer != 0 ) {
+	    SC_REPORT_ERROR( SC_ID_MORE_THAN_ONE_FIFO_WRITER_, 0 );
+	}
+	m_writer = &port_;
+    }
+    else
+    {
+        SC_REPORT_ERROR( SC_ID_BIND_IF_TO_PORT_, 
+	                 "sc_fifo<T> port not recognized" );
+    }
+}
+
+
+// blocking read
+
+template <class T>
+inline
+void
+sc_fifo<T>::read( T& val_ )
+{
+    while( num_available() == 0 ) {
+	sc_core::wait( m_data_written_event );
+    }
+    m_num_read ++;
+    buf_read( val_ );
+    request_update();
+}
+
+template <class T>
+inline
+T
+sc_fifo<T>::read()
+{
+    T tmp;
+    read( tmp );
+    return tmp;
+}
+
+// non-blocking read
+
+template <class T>
+inline
+bool
+sc_fifo<T>::nb_read( T& val_ )
+{
+    if( num_available() == 0 ) {
+	return false;
+    }
+    m_num_read ++;
+    buf_read( val_ );
+    request_update();
+    return true;
+}
+
+
+// blocking write
+
+template <class T>
+inline
+void
+sc_fifo<T>::write( const T& val_ )
+{
+    while( num_free() == 0 ) {
+	sc_core::wait( m_data_read_event );
+    }
+    m_num_written ++;
+    buf_write( val_ );
+    request_update();
+}
+
+// non-blocking write
+
+template <class T>
+inline
+bool
+sc_fifo<T>::nb_write( const T& val_ )
+{
+    if( num_free() == 0 ) {
+	return false;
+    }
+    m_num_written ++;
+    buf_write( val_ );
+    request_update();
+    return true;
+}
+
+
+template <class T>
+inline
+void
+sc_fifo<T>::trace( sc_trace_file* tf ) const
+{
+#if defined(DEBUG_SYSTEMC)
+    char buf[32];
+    std::string nm = name();
+    for( int i = 0; i < m_size; ++ i ) {
+	std::sprintf( buf, "_%d", i );
+	sc_trace( tf, m_buf[i], nm + buf );
+    }
+#endif
+}
+
+
+template <class T>
+inline
+void
+sc_fifo<T>::print( ::std::ostream& os ) const
+{
+    if( m_free != m_size ) {
+        int i = m_ri;
+        do {
+            os << m_buf[i] << ::std::endl;
+            i = ( i + 1 ) % m_size;
+        } while( i != m_wi );
+    }
+}
+
+template <class T>
+inline
+void
+sc_fifo<T>::dump( ::std::ostream& os ) const
+{
+    os << "name = " << name() << ::std::endl;
+    if( m_free != m_size ) {
+        int i = m_ri;
+        int j = 0;
+        do {
+	    os << "value[" << i << "] = " << m_buf[i] << ::std::endl;
+	    i = ( i + 1 ) % m_size;
+	    j ++;
+        } while( i != m_wi );
+    }
+}
+
+
+template <class T>
+inline
+void
+sc_fifo<T>::update()
+{
+    if( m_num_read > 0 ) {
+	m_data_read_event.notify(SC_ZERO_TIME);
+    }
+
+    if( m_num_written > 0 ) {
+	m_data_written_event.notify(SC_ZERO_TIME);
+    }
+
+    m_num_readable = m_size - m_free;
+    m_num_read = 0;
+    m_num_written = 0;
+}
+
+
+// support methods
+
+template <class T>
+inline
+void
+sc_fifo<T>::init( int size_ )
+{
+    buf_init( size_ );
+
+    m_reader = 0;
+    m_writer = 0;
+
+    m_num_readable = 0;
+    m_num_read = 0;
+    m_num_written = 0;
+}
+
+
+template <class T>
+inline
+void
+sc_fifo<T>::buf_init( int size_ )
+{
+    if( size_ <= 0 ) {
+	SC_REPORT_ERROR( SC_ID_INVALID_FIFO_SIZE_, 0 );
+    }
+    m_size = size_;
+    m_buf = new T[m_size];
+    m_free = m_size;
+    m_ri = 0;
+    m_wi = 0;
+}
+
+template <class T>
+inline
+bool
+sc_fifo<T>::buf_write( const T& val_ )
+{
+    if( m_free == 0 ) {
+	return false;
+    }
+    m_buf[m_wi] = val_;
+    m_wi = ( m_wi + 1 ) % m_size;
+    m_free --;
+    return true;
+}
+
+template <class T>
+inline
+bool
+sc_fifo<T>::buf_read( T& val_ )
+{
+    if( m_free == m_size ) {
+	return false;
+    }
+    val_ = m_buf[m_ri];
+    m_buf[m_ri] = T(); // clear entry for boost::shared_ptr, et al.
+    m_ri = ( m_ri + 1 ) % m_size;
+    m_free ++;
+    return true;
+}
+
+
+// ----------------------------------------------------------------------------
+
+template <class T>
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_fifo<T>& a )
+{
+    a.print( os );
+    return os;
+}
+
+} // namespace sc_core
+
+//$Log: sc_fifo.h,v $
+//Revision 1.6  2011/08/26 20:45:40  acg
+// Andy Goodrich: moved the modification log to the end of the file to
+// eliminate source line number skew when check-ins are done.
+//
+//Revision 1.5  2011/03/23 16:17:22  acg
+// Andy Goodrich: hide the sc_events that are kernel related.
+//
+//Revision 1.4  2011/02/18 20:23:45  acg
+// Andy Goodrich: Copyright update.
+//
+//Revision 1.3  2009/10/14 19:05:40  acg
+// Andy Goodrich: added check for blocking interfaces in addition to the
+// combined blocking/nonblocking interface.
+//
+//Revision 1.2  2009/05/22 16:06:24  acg
+// Andy Goodrich: process control updates.
+//
+//Revision 1.1.1.1  2006/12/15 20:20:04  acg
+//SystemC 2.3
+//
+//Revision 1.4  2006/01/24 20:46:31  acg
+//Andy Goodrich: changes to eliminate use of deprecated features. For instance,
+//using notify(SC_ZERO_TIME) in place of notify_delayed().
+//
+//Revision 1.3  2006/01/13 20:41:59  acg
+//Andy Goodrich: Changes to add port registration to the things that are
+//checked when SC_NO_WRITE_CHECK is not defined.
+//
+//Revision 1.2  2006/01/03 23:18:26  acg
+//Changed copyright to include 2006.
+//
+//Revision 1.1.1.1  2005/12/19 23:16:43  acg
+//First check in of SystemC 2.1 into its own archive.
+//
+//Revision 1.12  2005/09/15 23:01:51  acg
+//Added std:: prefix to appropriate methods and types to get around
+//issues with the Edison Front End.
+//
+//Revision 1.11  2005/06/10 22:43:55  acg
+//Added CVS change log annotation.
+//
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_fifo_ifs.h b/ext/systemc/src/sysc/communication/sc_fifo_ifs.h
new file mode 100644
index 000000000..915fc9f0c
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_fifo_ifs.h
@@ -0,0 +1,209 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_fifo_ifs.h -- The sc_fifo<T> interface classes.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_FIFO_IFS_H
+#define SC_FIFO_IFS_H
+
+
+#include "sysc/communication/sc_interface.h"
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fifo_nonblocking_in_if<T>
+//
+//  The sc_fifo<T> input nonblocking interface class.
+// ----------------------------------------------------------------------------
+
+template <class T> 
+class sc_fifo_nonblocking_in_if 
+: virtual public sc_interface 
+{ 
+public: 
+
+    // non-blocking read 
+    virtual bool nb_read( T& ) = 0; 
+
+    // get the data written event 
+    virtual const sc_event& data_written_event() const = 0; 
+}; 
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fifo_blocking_in_if<T>
+//
+//  The sc_fifo<T> input blocking interface class.
+// ----------------------------------------------------------------------------
+
+template <class T> 
+class sc_fifo_blocking_in_if 
+: virtual public sc_interface 
+{ 
+public: 
+
+    // blocking read 
+    virtual void read( T& ) = 0; 
+    virtual T read() = 0; 
+}; 
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fifo_in_if<T>
+//
+//  The sc_fifo<T> input interface class.
+// ----------------------------------------------------------------------------
+
+template <class T> 
+class sc_fifo_in_if 
+: public sc_fifo_nonblocking_in_if<T>, 
+  public sc_fifo_blocking_in_if<T> 
+{ 
+public: 
+
+    // get the number of available samples 
+    virtual int num_available() const = 0; 
+
+protected: 
+
+    // constructor 
+
+    sc_fifo_in_if() 
+        {} 
+
+private: 
+
+    // disabled 
+    sc_fifo_in_if( const sc_fifo_in_if<T>& ); 
+    sc_fifo_in_if<T>& operator = ( const sc_fifo_in_if<T>& ); 
+}; 
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fifo_nonblocking_out_if<T>
+//
+//  The sc_fifo<T> nonblocking output interface class.
+// ----------------------------------------------------------------------------
+
+template <class T> 
+class sc_fifo_nonblocking_out_if 
+: virtual public sc_interface 
+{ 
+public: 
+
+    // non-blocking write 
+    virtual bool nb_write( const T& ) = 0; 
+
+    // get the data read event 
+    virtual const sc_event& data_read_event() const = 0; 
+}; 
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fifo_blocking_out_if<T>
+//
+//  The sc_fifo<T> blocking output interface class.
+// ----------------------------------------------------------------------------
+
+template <class T> 
+class sc_fifo_blocking_out_if 
+: virtual public sc_interface 
+{ 
+public: 
+
+    // blocking write 
+    virtual void write( const T& ) = 0; 
+
+}; 
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fifo_out_if<T>
+//
+//  The sc_fifo<T> output interface class.
+// ----------------------------------------------------------------------------
+
+template <class T> 
+class sc_fifo_out_if 
+: public sc_fifo_nonblocking_out_if<T>, 
+  public sc_fifo_blocking_out_if<T> 
+{ 
+public: 
+
+    // get the number of free spaces 
+    virtual int num_free() const = 0; 
+
+protected: 
+
+    // constructor 
+
+    sc_fifo_out_if() 
+        {} 
+
+private: 
+
+    // disabled 
+    sc_fifo_out_if( const sc_fifo_out_if<T>& ); 
+    sc_fifo_out_if<T>& operator = ( const sc_fifo_out_if<T>& ); 
+}; 
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Bishnupriya Bhattacharye, Cadence Design Systems,
+                               30 Jan, 2004
+  Description of Modification: Split up the interfaces into blocking and 
+                               non blocking parts
+    
+      Name, Affiliation, Date: 
+  Description of Modification: 
+
+ *****************************************************************************/
+//$Log: sc_fifo_ifs.h,v $
+//Revision 1.3  2011/08/26 20:45:40  acg
+// Andy Goodrich: moved the modification log to the end of the file to
+// eliminate source line number skew when check-ins are done.
+//
+//Revision 1.2  2011/02/18 20:23:45  acg
+// Andy Goodrich: Copyright update.
+//
+//Revision 1.1.1.1  2006/12/15 20:20:04  acg
+//SystemC 2.3
+//
+//Revision 1.2  2006/01/03 23:18:26  acg
+//Changed copyright to include 2006.
+//
+//Revision 1.1.1.1  2005/12/19 23:16:43  acg
+//First check in of SystemC 2.1 into its own archive.
+//
+//Revision 1.10  2005/06/10 22:43:55  acg
+//Added CVS change log annotation.
+//
+
+} // namespace sc_core
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_fifo_ports.h b/ext/systemc/src/sysc/communication/sc_fifo_ports.h
new file mode 100644
index 000000000..72727d4be
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_fifo_ports.h
@@ -0,0 +1,296 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_fifo_ports.h -- The sc_fifo<T> port classes.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_FIFO_PORTS_H
+#define SC_FIFO_PORTS_H
+
+
+#include "sysc/communication/sc_port.h"
+#include "sysc/communication/sc_fifo_ifs.h"
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fifo_in<T>
+//
+//  The sc_fifo<T> input port class.
+// ----------------------------------------------------------------------------
+
+template <class T>
+class sc_fifo_in
+: public sc_port<sc_fifo_in_if<T>,0,SC_ONE_OR_MORE_BOUND>
+{
+public:
+
+    // typedefs
+
+    typedef T                                       data_type;
+
+    typedef sc_fifo_in_if<data_type>                if_type;
+    typedef sc_port<if_type,0,SC_ONE_OR_MORE_BOUND> base_type;
+    typedef sc_fifo_in<data_type>                   this_type;
+
+    typedef if_type                                 in_if_type;
+    typedef sc_port_b<in_if_type>                   in_port_type;
+
+public:
+
+    // constructors
+
+    sc_fifo_in()
+	: base_type()
+	{}
+
+    explicit sc_fifo_in( const char* name_ )
+	: base_type( name_ )
+	{}
+
+    explicit sc_fifo_in( in_if_type& interface_ )
+	: base_type( interface_ )
+	{}
+
+    sc_fifo_in( const char* name_, in_if_type& interface_ )
+	: base_type( name_, interface_ )
+	{}
+
+    explicit sc_fifo_in( in_port_type& parent_ )
+	: base_type( parent_ )
+	{}
+
+    sc_fifo_in( const char* name_, in_port_type& parent_ )
+	: base_type( name_, parent_ )
+	{}
+
+    sc_fifo_in( this_type& parent_ )
+	: base_type( parent_ )
+	{}
+
+    sc_fifo_in( const char* name_, this_type& parent_ )
+	: base_type( name_, parent_ )
+	{}
+
+
+    // destructor (does nothing)
+
+    virtual ~sc_fifo_in()
+	{}
+
+
+    // interface access shortcut methods
+
+    // blocking read
+
+    void read( data_type& value_ )
+        { (*this)->read( value_ ); }
+
+    data_type read()
+        { return (*this)->read(); }
+
+
+    // non-blocking read
+
+    bool nb_read( data_type& value_ )
+        { return (*this)->nb_read( value_ ); }
+
+
+    // get the number of available samples
+
+    int num_available() const
+        { return (*this)->num_available(); }
+
+
+    // get the data written event
+
+    const sc_event& data_written_event() const
+	{ return (*this)->data_written_event(); }
+
+
+    // use for static sensitivity to data written event
+
+    sc_event_finder& data_written() const
+    {
+	return *new sc_event_finder_t<in_if_type>(
+	    *this, &in_if_type::data_written_event );
+    }
+
+    virtual const char* kind() const
+        { return "sc_fifo_in"; }
+
+private:
+
+    // disabled
+    sc_fifo_in( const this_type& );
+    this_type& operator = ( const this_type& );
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fifo_out<T>
+//
+//  The sc_fifo<T> output port class.
+// ----------------------------------------------------------------------------
+
+template <class T>
+class sc_fifo_out
+: public sc_port<sc_fifo_out_if<T>,0,SC_ONE_OR_MORE_BOUND>
+{
+public:
+
+    // typedefs
+
+    typedef T                                        data_type;
+
+    typedef sc_fifo_out_if<data_type>                if_type;
+    typedef sc_port<if_type,0,SC_ONE_OR_MORE_BOUND>  base_type;
+    typedef sc_fifo_out<data_type>                   this_type;
+
+    typedef if_type                                  out_if_type;
+    typedef sc_port_b<out_if_type>                   out_port_type;
+
+public:
+
+    // constructors
+
+    sc_fifo_out()
+	: base_type()
+	{}
+
+    explicit sc_fifo_out( const char* name_ )
+	: base_type( name_ )
+	{}
+
+    explicit sc_fifo_out( out_if_type& interface_ )
+	: base_type( interface_ )
+	{}
+
+    sc_fifo_out( const char* name_, out_if_type& interface_ )
+	: base_type( name_, interface_ )
+	{}
+
+    explicit sc_fifo_out( out_port_type& parent_ )
+	: base_type( parent_ )
+	{}
+
+    sc_fifo_out( const char* name_, out_port_type& parent_ )
+	: base_type( name_, parent_ )
+	{}
+
+    sc_fifo_out( this_type& parent_ )
+	: base_type( parent_ )
+	{}
+
+    sc_fifo_out( const char* name_, this_type& parent_ )
+	: base_type( name_, parent_ )
+	{}
+
+
+    // destructor (does nothing)
+
+    virtual ~sc_fifo_out()
+	{}
+
+
+    // interface access shortcut methods
+
+    // blocking write
+
+    void write( const data_type& value_ )
+        { (*this)->write( value_ ); }
+
+
+    // non-blocking write
+
+    bool nb_write( const data_type& value_ )
+        { return (*this)->nb_write( value_ ); }
+
+
+    // get the number of free spaces
+
+    int num_free() const
+        { return (*this)->num_free(); }
+
+
+    // get the data read event
+
+    const sc_event& data_read_event() const
+	{ return (*this)->data_read_event(); }
+
+
+    // use for static sensitivity to data read event
+
+    sc_event_finder& data_read() const
+    {
+	return *new sc_event_finder_t<out_if_type>(
+	    *this, &out_if_type::data_read_event );
+    }
+
+    virtual const char* kind() const
+        { return "sc_fifo_out"; }
+
+private:
+
+    // disabled
+    sc_fifo_out( const this_type& );
+    this_type& operator = ( const this_type& );
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+} // namespace sc_core
+
+//$Log: sc_fifo_ports.h,v $
+//Revision 1.3  2011/08/26 20:45:40  acg
+// Andy Goodrich: moved the modification log to the end of the file to
+// eliminate source line number skew when check-ins are done.
+//
+//Revision 1.2  2011/02/18 20:23:45  acg
+// Andy Goodrich: Copyright update.
+//
+//Revision 1.1.1.1  2006/12/15 20:20:04  acg
+//SystemC 2.3
+//
+//Revision 1.2  2006/01/03 23:18:26  acg
+//Changed copyright to include 2006.
+//
+//Revision 1.1.1.1  2005/12/19 23:16:43  acg
+//First check in of SystemC 2.1 into its own archive.
+//
+//Revision 1.10  2005/09/15 23:01:51  acg
+//Added std:: prefix to appropriate methods and types to get around
+//issues with the Edison Front End.
+//
+//Revision 1.9  2005/06/10 22:43:55  acg
+//Added CVS change log annotation.
+//
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_host_mutex.h b/ext/systemc/src/sysc/communication/sc_host_mutex.h
new file mode 100644
index 000000000..58f1c4c3a
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_host_mutex.h
@@ -0,0 +1,160 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_host_mutex.h -- A "real" mutex for the underlying host system
+
+  Original Author: Philipp A. Hartmann, OFFIS
+
+ CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_HOST_MUTEX_H_INCLUDED_
+#define SC_HOST_MUTEX_H_INCLUDED_
+
+#ifndef SC_INCLUDE_WINDOWS_H
+#  define SC_INCLUDE_WINDOWS_H // include Windows.h, if needed
+#endif
+#include "sysc/kernel/sc_cmnhdr.h"
+#include "sysc/communication/sc_mutex_if.h"
+
+#if defined(WIN32) || defined(_WIN32)
+
+#define SC_MTX_TYPE_ CRITICAL_SECTION
+
+#define SC_MTX_INIT_( Mutex ) \
+    InitializeCriticalSection( &(Mutex) )
+#define SC_MTX_LOCK_( Mutex ) \
+    EnterCriticalSection( &(Mutex) )
+#define SC_MTX_UNLOCK_( Mutex ) \
+    LeaveCriticalSection( &(Mutex) )
+#define SC_MTX_TRYLOCK_( Mutex ) \
+    ( TryEnterCriticalSection( &(Mutex) ) != 0 )
+#define SC_MTX_DESTROY_( Mutex ) \
+    DeleteCriticalSection( &(Mutex) )
+
+#else // use pthread mutex
+
+#include <pthread.h>
+#define SC_MTX_TYPE_ pthread_mutex_t
+
+#if defined(__hpux)
+#  define SC_PTHREAD_NULL_ cma_c_null
+#else // !defined(__hpux)
+#  define SC_PTHREAD_NULL_ NULL
+#endif
+
+#define SC_MTX_INIT_( Mutex ) \
+    pthread_mutex_init( &(Mutex), SC_PTHREAD_NULL_ )
+#define SC_MTX_LOCK_( Mutex ) \
+    pthread_mutex_lock( &(Mutex) )
+#define SC_MTX_UNLOCK_( Mutex ) \
+    pthread_mutex_unlock( &(Mutex) )
+
+#ifdef _XOPEN_SOURCE
+#   define SC_MTX_TRYLOCK_( Mutex ) \
+       ( pthread_mutex_trylock( &(Mutex) ) == 0 )
+#else // no try_lock available
+#   define SC_MTX_TRYLOCK_( Mutex ) \
+       ( false ) 
+#endif
+
+#define SC_MTX_DESTROY_( Mutex ) \
+    pthread_mutex_destroy( &(Mutex) )
+
+#endif
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_host_mutex
+//
+//   The sc_host_mutex class, wrapping an OS mutex on the simulation host
+// ----------------------------------------------------------------------------
+
+class sc_host_mutex : public sc_mutex_if
+{
+    typedef SC_MTX_TYPE_ underlying_type;
+public:
+
+    // constructors and destructor
+
+    sc_host_mutex()
+	{ SC_MTX_INIT_(m_mtx); }
+    virtual ~sc_host_mutex()
+	{ SC_MTX_DESTROY_(m_mtx); }
+
+
+    // interface methods
+
+    // blocks until mutex could be locked
+    virtual int lock()
+	{ SC_MTX_LOCK_(m_mtx); return 0; }
+
+    // returns -1 if mutex could not be locked
+    virtual int trylock()
+	{ return SC_MTX_TRYLOCK_(m_mtx) ? 0 : -1; }
+
+    // should return -1 if mutex was not locked by caller,
+    // but is not yet able to check this
+    virtual int unlock()
+	{ SC_MTX_UNLOCK_(m_mtx); return 0; }
+
+private:
+    underlying_type m_mtx;
+};
+
+} // namespace sc_core
+
+#undef SC_MTX_TYPE_
+#undef SC_MTX_INIT_
+#undef SC_MTX_DESTROY_
+#undef SC_MTX_LOCK_
+#undef SC_MTX_TRYLOCK_
+#undef SC_MTX_UNLOCK_
+#undef SC_PTHREAD_NULL_
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+ *****************************************************************************/
+//$Log: sc_host_mutex.h,v $
+//Revision 1.4  2011/08/30 21:53:23  acg
+// Jerome Cornet: include window.h for gnu c in windows case.
+//
+//Revision 1.3  2011/08/07 19:08:01  acg
+// Andy Goodrich: moved logs to end of file so line number synching works
+// better between versions.
+//
+//Revision 1.2  2011/06/25 17:08:38  acg
+// Andy Goodrich: Jerome Cornet's changes to use libtool to build the
+// library.
+//
+//Revision 1.1  2011/04/18 19:04:11  acg
+// Philipp A. Hartmann: first check in of file.
+//
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_interface.cpp b/ext/systemc/src/sysc/communication/sc_interface.cpp
new file mode 100644
index 000000000..eabe870e9
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_interface.cpp
@@ -0,0 +1,100 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_interface.cpp -- Abstract base class of all interface classes.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#include "sysc/communication/sc_interface.h"
+#include "sysc/communication/sc_communication_ids.h"
+#include "sysc/kernel/sc_event.h"
+
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_interface
+//
+//  Abstract base class of all interface classes.
+//  BEWARE: Direct inheritance from this class must be done virtual.
+// ----------------------------------------------------------------------------
+
+// register a port with this interface (does nothing by default)
+
+void
+sc_interface::register_port( sc_port_base&, const char* )
+{}
+
+
+// get the default event
+
+const sc_event&
+sc_interface::default_event() const
+{
+    SC_REPORT_WARNING( SC_ID_NO_DEFAULT_EVENT_, 0 );
+    return m_never_notified;
+}
+
+
+// destructor (does nothing)
+
+sc_interface::~sc_interface()
+{}
+
+
+// constructor (does nothing)
+
+sc_interface::sc_interface()
+{}
+
+
+// special event for never notified cases, note the special name to keep
+// it out of the named event structures.
+
+sc_event sc_interface::m_never_notified(SC_KERNEL_EVENT_PREFIX);
+
+} // namespace sc_core
+
+// $Log: sc_interface.cpp,v $
+// Revision 1.5  2011/08/26 20:45:40  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.4  2011/03/12 21:07:42  acg
+//  Andy Goodrich: changes to kernel generated event support.
+//
+// Revision 1.3  2011/03/06 15:55:08  acg
+//  Andy Goodrich: Changes for named events.
+//
+// Revision 1.2  2011/02/18 20:23:45  acg
+//  Andy Goodrich: Copyright update.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:47:42  acg
+// Added $Log command so that CVS comments are reproduced in the source.
+//
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_interface.h b/ext/systemc/src/sysc/communication/sc_interface.h
new file mode 100644
index 000000000..b21d3c27d
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_interface.h
@@ -0,0 +1,107 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_interface.h -- Abstract base class of all interface classes.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_INTERFACE_H
+#define SC_INTERFACE_H
+
+namespace sc_core {
+
+class sc_event;
+class sc_port_base;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_interface
+//
+//  Abstract base class of all interface classes.
+//  BEWARE: Direct inheritance from this class must be done virtual.
+// ----------------------------------------------------------------------------
+
+class sc_interface
+{
+public:
+
+    // register a port with this interface (does nothing by default)
+    virtual void register_port( sc_port_base& port_,
+				const char*    if_typename_ );
+
+    // get the default event
+    virtual const sc_event& default_event() const;
+
+    // destructor (does nothing)
+    virtual ~sc_interface();
+
+protected:
+
+    // constructor (does nothing)
+    sc_interface();
+
+private:
+
+    // disabled
+    sc_interface( const sc_interface& );
+    sc_interface& operator = ( const sc_interface& );
+
+private:
+
+    static sc_event m_never_notified;
+
+#if defined(__SUNPRO_CC) && (__SUNPRO_CC == 0x520)
+    // Workaround for a bug in the Sun WorkShop 6 update 2 compiler.
+    // An empty virtual base class can cause the optimizer to
+    // generate wrong code.
+    char dummy;
+#endif
+};
+
+} // namespace sc_core
+
+//$Log: sc_interface.h,v $
+//Revision 1.3  2011/08/26 20:45:40  acg
+// Andy Goodrich: moved the modification log to the end of the file to
+// eliminate source line number skew when check-ins are done.
+//
+//Revision 1.2  2011/02/18 20:23:45  acg
+// Andy Goodrich: Copyright update.
+//
+//Revision 1.1.1.1  2006/12/15 20:20:04  acg
+//SystemC 2.3
+//
+//Revision 1.2  2006/01/03 23:18:26  acg
+//Changed copyright to include 2006.
+//
+//Revision 1.1.1.1  2005/12/19 23:16:43  acg
+//First check in of SystemC 2.1 into its own archive.
+//
+//Revision 1.7  2005/06/10 22:43:55  acg
+//Added CVS change log annotation.
+//
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_mutex.cpp b/ext/systemc/src/sysc/communication/sc_mutex.cpp
new file mode 100644
index 000000000..d2c43244c
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_mutex.cpp
@@ -0,0 +1,140 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_mutex.cpp -- The sc_mutex primitive channel class.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#include "sysc/communication/sc_mutex.h"
+#include "sysc/kernel/sc_simcontext.h"
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_mutex
+//
+//  The sc_mutex primitive channel class.
+// ----------------------------------------------------------------------------
+
+// constructors
+
+sc_mutex::sc_mutex()
+: sc_object( sc_gen_unique_name( "mutex" ) ),
+  m_owner( 0 ),
+  m_free( (std::string(SC_KERNEL_EVENT_PREFIX)+"_free_event").c_str() )
+{}
+
+sc_mutex::sc_mutex( const char* name_ )
+: sc_object( name_ ),
+  m_owner( 0 ),
+  m_free( (std::string(SC_KERNEL_EVENT_PREFIX)+"_free_event").c_str() )
+{}
+
+
+// destructor
+
+sc_mutex::~sc_mutex()
+{}
+
+// interface methods
+
+// blocks until mutex could be locked
+
+int
+sc_mutex::lock()
+{
+    if ( m_owner == sc_get_current_process_b()) return 0;
+    while( in_use() ) {
+	sc_core::wait( m_free, sc_get_curr_simcontext() );
+    }
+    m_owner = sc_get_current_process_b();
+    return 0;
+}
+
+
+// returns -1 if mutex could not be locked
+
+int
+sc_mutex::trylock()
+{
+    if ( m_owner == sc_get_current_process_b()) return 0;
+    if( in_use() ) {
+	return -1;
+    }
+    m_owner = sc_get_current_process_b();
+    return 0;
+}
+
+
+// returns -1 if mutex was not locked by caller
+
+int
+sc_mutex::unlock()
+{
+    if( m_owner != sc_get_current_process_b() ) {
+	return -1;
+    }
+    m_owner = 0;
+    m_free.notify();
+    return 0;
+}
+
+} // namespace sc_core
+
+// $Log: sc_mutex.cpp,v $
+// Revision 1.7  2011/08/26 20:45:40  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.6  2011/03/28 13:02:29  acg
+//  Andy Goodrich: removed sc_event in sc_mutex class from the object
+//  hierarchy since it is considered a "kernel" event.
+//
+// Revision 1.5  2011/02/18 20:23:45  acg
+//  Andy Goodrich: Copyright update.
+//
+// Revision 1.4  2010/11/02 16:31:01  acg
+//  Andy Goodrich: changed object derivation to use sc_object rather than
+//  sc_prim_channel as the parent class.
+//
+// Revision 1.3  2008/11/13 15:29:46  acg
+//  David C. Black, ESLX, Inc: lock & trylock now allow owner to apply
+//  lock more than once without incident. Previous behavior locked up the
+//  owning process.
+//
+// Revision 1.2  2008/05/20 16:46:18  acg
+//  Andy Goodrich: added checks for multiple writers.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.4  2006/03/21 00:00:27  acg
+//   Andy Goodrich: changed name of sc_get_current_process_base() to be
+//   sc_get_current_process_b() since its returning an sc_process_b instance.
+//
+// Revision 1.3  2006/01/13 18:47:42  acg
+// Added $Log command so that CVS comments are reproduced in the source.
+//
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_mutex.h b/ext/systemc/src/sysc/communication/sc_mutex.h
new file mode 100644
index 000000000..e3cef36c3
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_mutex.h
@@ -0,0 +1,124 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_mutex.h -- The sc_mutex primitive channel class.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_MUTEX_H
+#define SC_MUTEX_H
+
+#include "sysc/kernel/sc_event.h"
+#include "sysc/kernel/sc_object.h"
+#include "sysc/kernel/sc_wait.h"
+#include "sysc/communication/sc_mutex_if.h"
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_mutex
+//
+//  The sc_mutex primitive channel class.
+// ----------------------------------------------------------------------------
+
+class sc_mutex
+: public sc_mutex_if,
+  public sc_object
+{
+public:
+
+    // constructors and destructor
+
+    sc_mutex();
+    explicit sc_mutex( const char* name_ );
+	virtual ~sc_mutex();
+
+
+    // interface methods
+
+    // blocks until mutex could be locked
+    virtual int lock();
+
+    // returns -1 if mutex could not be locked
+    virtual int trylock();
+
+    // returns -1 if mutex was not locked by caller
+    virtual int unlock();
+
+    virtual const char* kind() const
+        { return "sc_mutex"; }
+
+protected:
+
+    // support methods
+
+    bool in_use() const
+	{ return ( m_owner != 0 ); }
+
+protected:
+
+    sc_process_b* m_owner;
+    sc_event      m_free;
+
+private:
+
+    // disabled
+    sc_mutex( const sc_mutex& );
+    sc_mutex& operator = ( const sc_mutex& );
+};
+
+} // namespace sc_core
+
+//$Log: sc_mutex.h,v $
+//Revision 1.4  2011/08/26 20:45:41  acg
+// Andy Goodrich: moved the modification log to the end of the file to
+// eliminate source line number skew when check-ins are done.
+//
+//Revision 1.3  2011/02/18 20:23:45  acg
+// Andy Goodrich: Copyright update.
+//
+//Revision 1.2  2010/11/02 16:31:01  acg
+// Andy Goodrich: changed object derivation to use sc_object rather than
+// sc_prim_channel as the parent class.
+//
+//Revision 1.1.1.1  2006/12/15 20:20:04  acg
+//SystemC 2.3
+//
+//Revision 1.2  2006/01/03 23:18:26  acg
+//Changed copyright to include 2006.
+//
+//Revision 1.1.1.1  2005/12/19 23:16:43  acg
+//First check in of SystemC 2.1 into its own archive.
+//
+//Revision 1.10  2005/09/15 23:01:51  acg
+//Added std:: prefix to appropriate methods and types to get around
+//issues with the Edison Front End.
+//
+//Revision 1.9  2005/06/10 22:43:55  acg
+//Added CVS change log annotation.
+//
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_mutex_if.h b/ext/systemc/src/sysc/communication/sc_mutex_if.h
new file mode 100644
index 000000000..6fa934135
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_mutex_if.h
@@ -0,0 +1,146 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_mutex_if.h -- The sc_mutex_if interface class.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_MUTEX_IF_H
+#define SC_MUTEX_IF_H
+
+#include "sysc/communication/sc_interface.h"
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_mutex_if
+//
+//  The sc_mutex_if interface class.
+// ----------------------------------------------------------------------------
+
+class sc_mutex_if
+: virtual public sc_interface
+{
+public:
+
+    // the classical operations: lock(), trylock(), and unlock()
+
+    // blocks until mutex could be locked
+    virtual int lock() = 0;
+
+    // returns -1 if mutex could not be locked
+    virtual int trylock() = 0;
+
+    // returns -1 if mutex was not locked by caller
+    virtual int unlock() = 0;
+
+protected:
+
+    // constructor
+
+    sc_mutex_if()
+	{}
+
+private:
+
+    // disabled
+    sc_mutex_if( const sc_mutex_if& );
+    sc_mutex_if& operator = ( const sc_mutex_if& );
+};
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_scoped_lock
+//
+//  The sc_scoped_lock class to lock (and automatically release) a mutex.
+// ----------------------------------------------------------------------------
+
+//template< typename Lockable = sc_mutex_if >
+class sc_scoped_lock
+{
+public:
+    //typedef Lockable lockable_type;
+    typedef sc_mutex_if lockable_type;
+
+    explicit
+    sc_scoped_lock( lockable_type& mtx )
+      : m_ref(mtx)
+      , m_active(true)
+    {
+        m_ref.lock();
+    }
+
+    bool release()
+    {
+        if( m_active )
+        {
+            m_ref.unlock();
+            m_active = false;
+            return true;
+        }
+        return false;
+    }
+
+    ~sc_scoped_lock()
+    {
+        release();
+    }
+
+private:
+    // disabled
+    sc_scoped_lock( const sc_scoped_lock& );
+    sc_scoped_lock& operator=( const sc_scoped_lock& );
+
+    lockable_type& m_ref;
+    bool           m_active;
+};
+
+} // namespace sc_core
+
+//$Log: sc_mutex_if.h,v $
+//Revision 1.4  2011/08/26 20:45:41  acg
+// Andy Goodrich: moved the modification log to the end of the file to
+// eliminate source line number skew when check-ins are done.
+//
+//Revision 1.3  2011/04/19 02:36:26  acg
+// Philipp A. Hartmann: new aysnc_update and mutex support.
+//
+//Revision 1.2  2011/02/18 20:23:45  acg
+// Andy Goodrich: Copyright update.
+//
+//Revision 1.1.1.1  2006/12/15 20:20:04  acg
+//SystemC 2.3
+//
+//Revision 1.2  2006/01/03 23:18:26  acg
+//Changed copyright to include 2006.
+//
+//Revision 1.1.1.1  2005/12/19 23:16:43  acg
+//First check in of SystemC 2.1 into its own archive.
+//
+//Revision 1.8  2005/06/10 22:43:55  acg
+//Added CVS change log annotation.
+//
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_port.cpp b/ext/systemc/src/sysc/communication/sc_port.cpp
new file mode 100644
index 000000000..01291e6b5
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_port.cpp
@@ -0,0 +1,835 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_port.cpp -- Base classes of all port classes.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+ CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+#include "sysc/kernel/sc_simcontext.h"
+#include "sysc/kernel/sc_module.h"
+#include "sysc/kernel/sc_object_int.h"
+#include "sysc/kernel/sc_method_process.h"
+#include "sysc/kernel/sc_thread_process.h"
+#include "sysc/communication/sc_communication_ids.h"
+#include "sysc/utils/sc_utils_ids.h"
+#include "sysc/communication/sc_event_finder.h"
+#include "sysc/communication/sc_port.h"
+#include "sysc/communication/sc_signal_ifs.h"
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  STRUCT : sc_bind_elem
+// ----------------------------------------------------------------------------
+
+struct sc_bind_elem
+{
+    // constructors
+    sc_bind_elem();
+    explicit sc_bind_elem( sc_interface* interface_ );
+    explicit sc_bind_elem( sc_port_base* parent_ );
+
+    sc_interface* iface;
+    sc_port_base* parent;
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+// constructors
+
+sc_bind_elem::sc_bind_elem()
+: iface( 0 ),
+  parent( 0 )
+{}
+
+sc_bind_elem::sc_bind_elem( sc_interface* interface_ )
+: iface( interface_ ),
+  parent( 0 )
+{}
+
+sc_bind_elem::sc_bind_elem( sc_port_base* parent_ )
+: iface( 0 ),
+  parent( parent_ )
+{}
+
+
+// ----------------------------------------------------------------------------
+//  STRUCT : sc_bind_ef
+// ----------------------------------------------------------------------------
+
+struct sc_bind_ef
+{
+    // constructor
+    sc_bind_ef( sc_process_b* , sc_event_finder* );
+
+    // destructor
+    ~sc_bind_ef();
+
+    sc_process_b* handle;
+    sc_event_finder* event_finder;
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+// constructor
+
+sc_bind_ef::sc_bind_ef( sc_process_b* handle_,
+			sc_event_finder* event_finder_ )
+: handle( handle_ ),
+  event_finder( event_finder_ )
+{}
+
+
+// destructor
+
+sc_bind_ef::~sc_bind_ef()
+{
+}
+
+
+// ----------------------------------------------------------------------------
+//  STRUCT : sc_bind_info
+// ----------------------------------------------------------------------------
+
+struct sc_bind_info
+{
+    // constructor
+    explicit sc_bind_info( int max_size_, 
+	sc_port_policy policy_=SC_ONE_OR_MORE_BOUND );
+
+    // destructor
+    ~sc_bind_info();
+
+    int            max_size() const;
+    sc_port_policy policy() const; 
+    int            size() const;
+
+    int                        m_max_size;
+    sc_port_policy             m_policy;
+    std::vector<sc_bind_elem*> vec;
+    bool                       has_parent;
+    int                        last_add;
+    bool                       is_leaf;
+    bool                       complete;
+
+    std::vector<sc_bind_ef*>   thread_vec;
+    std::vector<sc_bind_ef*>   method_vec;
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+// constructor
+
+sc_bind_info::sc_bind_info( int max_size_, sc_port_policy policy_ )
+: m_max_size( max_size_ ),
+  m_policy( policy_ ),
+  vec(),
+  has_parent( false ),
+  last_add( -1 ),
+  is_leaf( true ),
+  complete( false ),
+  thread_vec(),
+  method_vec()
+{}
+
+
+// destructor
+
+sc_bind_info::~sc_bind_info()
+{
+    for( int i = size() - 1; i >= 0; -- i ) {
+	delete vec[i];
+    }
+}
+
+
+int
+sc_bind_info::max_size() const
+{
+    return m_max_size ? m_max_size : (int) vec.size();
+}
+
+sc_port_policy 
+sc_bind_info::policy() const
+{
+    return m_policy;
+}
+
+int
+sc_bind_info::size() const
+{
+    return vec.size();
+}
+
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_port_base
+//
+//  Abstract base class for class sc_port_b.
+// ----------------------------------------------------------------------------
+
+// This method exists to get around a problem in VCC 6.0 where you cannot
+// have  a friend class that is templated. So sc_port_b<IF> calls this class
+// instead of sc_process_b::add_static_event.
+
+void sc_port_base::add_static_event(
+    sc_method_handle process_p, const sc_event& event ) const
+{
+    process_p->add_static_event( event );
+}
+
+void sc_port_base::add_static_event(
+    sc_thread_handle process_p, const sc_event& event ) const
+{
+    process_p->add_static_event( event );
+}
+
+// return number of interfaces that will be bound, or are bound:
+
+int sc_port_base::bind_count()
+{
+    if ( m_bind_info )
+	return m_bind_info->size();
+    else 
+	return interface_count();
+}
+
+// error reporting
+
+void
+sc_port_base::report_error( const char* id, const char* add_msg ) const
+{
+    char msg[BUFSIZ];
+    if( add_msg != 0 ) {
+	std::sprintf( msg, "%s: port '%s' (%s)", add_msg, name(), kind() );
+    } else {
+	std::sprintf( msg, "port '%s' (%s)", name(), kind() );
+    }
+    SC_REPORT_ERROR( id, msg );
+}
+
+
+// constructors
+
+sc_port_base::sc_port_base( 
+    int max_size_, sc_port_policy policy 
+) : 
+    sc_object( sc_gen_unique_name( "port" ) ),
+    m_bind_info(NULL)
+{
+    simcontext()->get_port_registry()->insert( this );
+    m_bind_info = new sc_bind_info( max_size_, policy );
+}
+
+sc_port_base::sc_port_base( 
+    const char* name_, int max_size_, sc_port_policy policy 
+) : 
+    sc_object( name_ ),
+    m_bind_info(NULL)
+{
+    simcontext()->get_port_registry()->insert( this );
+    m_bind_info = new sc_bind_info( max_size_, policy );
+}
+
+
+// destructor
+
+sc_port_base::~sc_port_base()
+{
+    simcontext()->get_port_registry()->remove( this );
+    delete m_bind_info;
+}
+
+
+// bind interface to this port
+
+void
+sc_port_base::bind( sc_interface& interface_ )
+{
+    if( m_bind_info == 0 ) {
+	// cannot bind an interface after elaboration
+	report_error( SC_ID_BIND_IF_TO_PORT_, "simulation running" );
+    }
+
+    m_bind_info->vec.push_back( new sc_bind_elem( &interface_ ) );
+    
+    if( ! m_bind_info->has_parent ) {
+	// add (cache) the interface
+	add_interface( &interface_ );
+	m_bind_info->last_add ++;
+    }
+}
+
+
+// bind parent port to this port
+
+void
+sc_port_base::bind( this_type& parent_ )
+{
+    if( m_bind_info == 0 ) {
+	// cannot bind a parent port after elaboration
+	report_error( SC_ID_BIND_PORT_TO_PORT_, "simulation running" );
+    }
+
+    if( &parent_ == this ) {
+	report_error( SC_ID_BIND_PORT_TO_PORT_, "same port" );
+    }
+
+    // check if parent port is already bound to this port
+#if 0
+    for( int i = m_bind_info->size() - 1; i >= 0; -- i ) {
+	if( &parent_ == m_bind_info->vec[i]->parent ) {
+	    report_error( SC_ID_BIND_PORT_TO_PORT_, "already bound" );
+	}
+    }
+#endif // 
+
+    m_bind_info->vec.push_back( new sc_bind_elem( &parent_ ) );
+    m_bind_info->has_parent = true;
+    parent_.m_bind_info->is_leaf = false;
+}
+
+// called by construction_done (null by default)
+
+void sc_port_base::before_end_of_elaboration() 
+{}
+
+// called by elaboration_done (does nothing)
+
+void
+sc_port_base::end_of_elaboration()
+{}
+
+// called by sc_port_registry::start_simulation (does nothing by default)
+
+void sc_port_base::start_of_simulation()
+{}
+
+// called by sc_port_registry::simulation_done (does nothing by default)
+
+void sc_port_base::end_of_simulation()
+{}
+
+
+// called by class sc_module for positional binding
+
+int
+sc_port_base::pbind( sc_interface& interface_ )
+{
+    if( m_bind_info == 0 ) {
+	// cannot bind an interface after elaboration
+	report_error( SC_ID_BIND_IF_TO_PORT_, "simulation running" );
+    }
+    
+    if( m_bind_info->size() != 0 ) {
+	// first interface already bound
+	return 1;
+    }
+
+    return vbind( interface_ );
+}
+
+int
+sc_port_base::pbind( sc_port_base& parent_ )
+{
+    if( m_bind_info == 0 ) {
+	// cannot bind a parent port after elaboration
+	report_error( SC_ID_BIND_PORT_TO_PORT_, "simulation running" );
+    }
+    
+    if( m_bind_info->size() != 0 ) {
+	// first interface already bound
+	return 1;
+    }
+
+    return vbind( parent_ );
+}
+
+
+// called by the sc_sensitive* classes
+
+void
+sc_port_base::make_sensitive( sc_thread_handle handle_,
+			      sc_event_finder* event_finder_ ) const
+{
+    assert( m_bind_info != 0 );
+    m_bind_info->thread_vec.push_back( 
+	new sc_bind_ef( (sc_process_b*)handle_, event_finder_ ) );
+}
+
+void
+sc_port_base::make_sensitive( sc_method_handle handle_,
+			      sc_event_finder* event_finder_ ) const
+{
+    assert( m_bind_info != 0 );
+    m_bind_info->method_vec.push_back( 
+	new sc_bind_ef( (sc_process_b*)handle_, event_finder_ ) );
+}
+
+
+// support methods
+
+int
+sc_port_base::first_parent()
+{
+    for( int i = 0; i < m_bind_info->size(); ++ i ) {
+	if( m_bind_info->vec[i]->parent != 0 ) {
+	    return i;
+	}
+    }
+    return -1;
+}
+
+void
+sc_port_base::insert_parent( int i )
+{
+    std::vector<sc_bind_elem*>& vec = m_bind_info->vec;
+
+    this_type* parent = vec[i]->parent;
+
+
+    // IF OUR PARENT HAS NO BINDING THEN IGNORE IT:
+    //
+    // Note that the zeroing of the parent pointer must occur before this
+    // test
+
+    vec[i]->parent = 0;
+    if ( parent->m_bind_info->vec.size() == 0 ) return;
+
+    vec[i]->iface = parent->m_bind_info->vec[0]->iface;
+    int n = parent->m_bind_info->size() - 1;
+    if( n > 0 ) {
+	// resize the bind vector (by adding new elements)
+	for( int k = 0; k < n; ++ k ) {
+	    vec.push_back( new sc_bind_elem() );
+	}
+	// move elements in the bind vector
+	for( int k = m_bind_info->size() - n - 1; k > i; -- k ) {
+	    vec[k + n]->iface = vec[k]->iface;
+	    vec[k + n]->parent = vec[k]->parent;
+	}
+	// insert parent interfaces into the bind vector
+	for( int k = i + 1; k <= i + n; ++ k ) {
+	    vec[k]->iface = parent->m_bind_info->vec[k - i]->iface;
+	    vec[k]->parent = 0;
+	}
+    }
+}
+
+
+// called when elaboration is done
+
+void
+sc_port_base::complete_binding()
+{
+    char msg_buffer[128]; // For error message construction.
+
+    // IF BINDING HAS ALREADY BEEN COMPLETED IGNORE THIS CALL:
+
+    assert( m_bind_info != 0 );
+    if( m_bind_info->complete ) {
+        return;
+    }
+
+    // COMPLETE BINDING OF OUR PARENT PORTS SO THAT WE CAN USE THAT INFORMATION:
+
+    int i = first_parent();
+    while( i >= 0 ) {
+        m_bind_info->vec[i]->parent->complete_binding();
+        insert_parent( i );
+        i = first_parent();
+    }
+
+    // LOOP OVER BINDING INFORMATION TO COMPLETE THE BINDING PROCESS:
+
+    int size;
+    for( int j = 0; j < m_bind_info->size(); ++ j ) {
+        sc_interface* iface = m_bind_info->vec[j]->iface;
+
+	// if the interface is zero this was for an unbound port.
+	if ( iface == 0 ) continue;
+
+	// add (cache) the interface
+        if( j > m_bind_info->last_add ) {
+            add_interface( iface );
+        }
+        
+	// only register "leaf" ports (ports without children)
+        if( m_bind_info->is_leaf ) {
+            iface->register_port( *this, if_typename() );
+        }
+
+        // complete static sensitivity for methods
+        size = m_bind_info->method_vec.size();
+        for( int k = 0; k < size; ++ k ) {
+            sc_bind_ef* p = m_bind_info->method_vec[k];
+            const sc_event& event = ( p->event_finder != 0 )
+                                  ? p->event_finder->find_event(iface)
+                                  : iface->default_event();
+            p->handle->add_static_event( event );
+        }
+
+        // complete static sensitivity for threads
+        size = m_bind_info->thread_vec.size();
+        for( int k = 0; k < size; ++ k ) {
+            sc_bind_ef* p = m_bind_info->thread_vec[k];
+            const sc_event& event = ( p->event_finder != 0 )
+                                  ? p->event_finder->find_event(iface)
+                                  : iface->default_event();
+            p->handle->add_static_event( event );
+        }
+
+    }
+
+    // MAKE SURE THE PROPER NUMBER OF BINDINGS OCCURRED:
+    //
+    // Make sure there are enough bindings, and not too many.
+
+    int actual_binds = interface_count();
+
+    if ( actual_binds > m_bind_info->max_size() )
+    {
+	sprintf(msg_buffer, "%d binds exceeds maximum of %d allowed",
+	    actual_binds, m_bind_info->max_size() );
+	report_error( SC_ID_COMPLETE_BINDING_, msg_buffer );
+    }
+    switch ( m_bind_info->policy() )
+    {
+      case SC_ONE_OR_MORE_BOUND:
+        if ( actual_binds < 1 ) {
+            report_error( SC_ID_COMPLETE_BINDING_, "port not bound" );
+        }
+        break;
+      case SC_ALL_BOUND:
+        if ( actual_binds < m_bind_info->max_size() || actual_binds < 1 ) {
+	    sprintf(msg_buffer, "%d actual binds is less than required %d",
+	        actual_binds, m_bind_info->max_size() ); 
+            report_error( SC_ID_COMPLETE_BINDING_, msg_buffer );
+        }
+        break;
+      default:  // SC_ZERO_OR_MORE_BOUND:
+        break;
+    }
+
+
+    // CLEAN UP: FREE BINDING STORAGE:
+
+    size = m_bind_info->method_vec.size();
+    for( int k = 0; k < size; ++ k ) {
+        delete m_bind_info->method_vec[k];
+    }
+    m_bind_info->method_vec.resize(0);
+
+    size = m_bind_info->thread_vec.size();
+    for( int k = 0; k < size; ++ k ) {
+        delete m_bind_info->thread_vec[k];
+    }
+    m_bind_info->thread_vec.resize(0);
+
+    m_bind_info->complete = true;
+}
+
+void
+sc_port_base::construction_done()
+{
+    sc_module* parent = static_cast<sc_module*>( get_parent_object() );
+    sc_object::hierarchy_scope scope( parent );
+    before_end_of_elaboration();
+}
+
+void
+sc_port_base::elaboration_done()
+{
+    assert( m_bind_info != 0 && m_bind_info->complete );
+    delete m_bind_info;
+    m_bind_info = 0;
+
+    sc_module* parent = static_cast<sc_module*>( get_parent_object() );
+    sc_object::hierarchy_scope scope( parent );
+    end_of_elaboration();
+}
+
+void
+sc_port_base::start_simulation()
+{
+    sc_module* parent = static_cast<sc_module*>( get_parent_object() );
+    sc_object::hierarchy_scope scope( parent );
+    start_of_simulation();
+}
+
+void
+sc_port_base::simulation_done()
+{
+    sc_module* parent = static_cast<sc_module*>( get_parent_object() );
+    sc_object::hierarchy_scope scope( parent );
+    end_of_simulation();
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_port_registry
+//
+//  Registry for all ports.
+//  FOR INTERNAL USE ONLY!
+// ----------------------------------------------------------------------------
+
+void
+sc_port_registry::insert( sc_port_base* port_ )
+{
+    if( sc_is_running() ) {
+	port_->report_error( SC_ID_INSERT_PORT_, "simulation running" );
+    }
+
+    if( m_simc->elaboration_done()  ) {
+       port_->report_error( SC_ID_INSERT_PORT_, "elaboration done" );
+    }
+
+#if defined(DEBUG_SYSTEMC)
+    // check if port_ is already inserted
+    for( int i = size() - 1; i >= 0; -- i ) {
+	if( port_ == m_port_vec[i] ) {
+	    port_->report_error( SC_ID_INSERT_PORT_, "port already inserted" );
+	}
+    }
+#endif
+
+    // append the port to the current module's vector of ports
+    sc_module* curr_module = m_simc->hierarchy_curr();
+    if( curr_module == 0 ) {
+	port_->report_error( SC_ID_PORT_OUTSIDE_MODULE_ );
+    }
+    curr_module->append_port( port_ );
+
+    // insert
+    m_port_vec.push_back( port_ );
+}
+
+void
+sc_port_registry::remove( sc_port_base* port_ )
+{
+    int i;
+    for( i = size() - 1; i >= 0; -- i ) {
+	if( port_ == m_port_vec[i] ) {
+	    break;
+	}
+    }
+    if( i == -1 ) {
+	port_->report_error( SC_ID_REMOVE_PORT_, "port not registered" );
+    }
+
+    // remove
+    m_port_vec[i] = m_port_vec[size() - 1];
+    m_port_vec.resize(size()-1);
+}
+
+
+// constructor
+
+sc_port_registry::sc_port_registry( sc_simcontext& simc_ )
+: m_construction_done(0),
+  m_port_vec(),
+  m_simc( &simc_ )
+{
+}
+
+
+// destructor
+
+sc_port_registry::~sc_port_registry()
+{
+}
+
+// called when construction is done
+
+bool
+sc_port_registry::construction_done()
+{
+    if( size() == m_construction_done )
+        // nothing has been updated
+        return true;
+
+    for( int i = size()-1; i >= m_construction_done; --i ) {
+        m_port_vec[i]->construction_done();
+    }
+
+    m_construction_done = size();
+    return false;
+}
+
+// called when when elaboration is done
+
+void
+sc_port_registry::complete_binding()
+{
+    for( int i = size() - 1; i >= 0; -- i ) {
+        m_port_vec[i]->complete_binding();
+    }
+}
+
+
+// called when elaboration is done
+
+void
+sc_port_registry::elaboration_done()
+{
+    complete_binding();
+
+    for( int i = size() - 1; i >= 0; -- i ) {
+        m_port_vec[i]->elaboration_done();
+    }
+}
+
+// called before simulation begins
+
+void
+sc_port_registry::start_simulation()
+{
+    for( int i = size() - 1; i >= 0; -- i ) {
+        m_port_vec[i]->start_simulation();
+    }
+}
+
+// called after simulation ends
+
+void
+sc_port_registry::simulation_done()
+{
+    for( int i = size() - 1; i >= 0; -- i ) {
+        m_port_vec[i]->simulation_done();
+    }
+}
+
+// This is a static member function.
+
+void
+sc_port_registry::replace_port( sc_port_registry* /* registry */ )
+{
+}
+
+void sc_warn_port_constructor()
+{
+    static bool warn_port_constructor=true;
+    if ( warn_port_constructor )
+    {
+        warn_port_constructor = false;
+        SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_, 
+	    "interface and/or port binding in port constructors is deprecated" 
+	);
+    }
+}
+
+} // namespace sc_core
+
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Andy Goodrich, Forte Design Systems
+                               Bishnupriya Bhattacharya, Cadence Design Systems,
+                               25 August, 2003
+  Description of Modification: phase callbacks
+
+      Name, Affiliation, Date: Andy Goodrich, Forte Design Systems
+	  						   12 December, 2005
+  Description of Modification: multiport binding policy changes
+    
+ *****************************************************************************/
+
+
+// $Log: sc_port.cpp,v $
+// Revision 1.8  2011/08/24 22:05:36  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.7  2011/08/15 16:43:24  acg
+//  Torsten Maehne: changes to remove unused argument warnings.
+//
+// Revision 1.6  2011/08/07 19:08:01  acg
+//  Andy Goodrich: moved logs to end of file so line number synching works
+//  better between versions.
+//
+// Revision 1.5  2011/08/07 18:53:09  acg
+//  Philipp A. Hartmann: add virtual instances of the bind function for
+//  base classes to eliminate warning messages for clang platforms.
+//
+// Revision 1.4  2011/05/09 04:07:37  acg
+//  Philipp A. Hartmann:
+//    (1) Restore hierarchy in all phase callbacks.
+//    (2) Ensure calls to before_end_of_elaboration.
+//
+// Revision 1.3  2011/02/18 20:23:45  acg
+//  Andy Goodrich: Copyright update.
+//
+// Revision 1.2  2011/02/14 17:50:16  acg
+//  Andy Goodrich: testing for sc_port and sc_export instantiations during
+//  end of elaboration and issuing appropriate error messages.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.11  2006/08/29 23:34:59  acg
+//  Andy Goodrich: added bind_count() method to allow users to determine which
+//  ports are connected in before_end_of_elaboration().
+//
+// Revision 1.10  2006/05/08 17:52:47  acg
+//  Andy Goodrich:
+//    (1) added David Long's forward declarations for friend functions,
+//        methods, and operators to keep the Microsoft compiler happy.
+//    (2) Added delta_count() method to sc_prim_channel for use by
+//        sc_signal so that the friend declaration in sc_simcontext.h
+// 	   can be for a non-templated class (i.e., sc_prim_channel.)
+//
+// Revision 1.9  2006/02/02 20:43:09  acg
+//  Andy Goodrich: Added an existence linked list to sc_event_finder so that
+//  the dynamically allocated instances can be freed after port binding
+//  completes. This replaces the individual deletions in ~sc_bind_ef, as these
+//  caused an exception if an sc_event_finder instance was used more than
+//  once, due to a double freeing of the instance.
+//
+// Revision 1.7  2006/01/26 21:00:50  acg
+//  Andy Goodrich: conversion to use sc_event::notify(SC_ZERO_TIME) instead of
+//  sc_event::notify_delayed()
+//
+// Revision 1.6  2006/01/25 00:31:11  acg
+//  Andy Goodrich: Changed over to use a standard message id of
+//  SC_ID_IEEE_1666_DEPRECATION for all deprecation messages.
+//
+// Revision 1.5  2006/01/24 20:46:31  acg
+// Andy Goodrich: changes to eliminate use of deprecated features. For instance,
+// using notify(SC_ZERO_TIME) in place of notify_delayed().
+//
+// Revision 1.4  2006/01/13 20:41:59  acg
+// Andy Goodrich: Changes to add port registration to the things that are
+// checked when SC_NO_WRITE_CHECK is not defined.
+//
+// Revision 1.3  2006/01/13 18:47:42  acg
+// Added $Log command so that CVS comments are reproduced in the source.
+//
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_port.h b/ext/systemc/src/sysc/communication/sc_port.h
new file mode 100644
index 000000000..a126657e6
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_port.h
@@ -0,0 +1,732 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_port.h -- Base classes of all port classes.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_PORT_H
+#define SC_PORT_H
+
+
+#include "sysc/communication/sc_communication_ids.h"
+#include "sysc/communication/sc_interface.h"
+#include "sysc/kernel/sc_event.h"
+#include "sysc/kernel/sc_object.h"
+#include "sysc/kernel/sc_process.h"
+#include <typeinfo>
+
+#if ! defined( SC_DISABLE_VIRTUAL_BIND )
+#  define SC_VIRTUAL_ virtual
+#else
+#  define SC_VIRTUAL_ /* non-virtual */
+#endif
+
+namespace sc_core {
+
+class sc_event_finder;
+
+struct sc_bind_info;
+
+enum sc_port_policy 
+{ 
+    SC_ONE_OR_MORE_BOUND,   // Default 
+    SC_ZERO_OR_MORE_BOUND, 
+    SC_ALL_BOUND  
+}; 
+
+
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+//  BEWARE: Ports can only be created and bound during elaboration.
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_port_base
+//
+//  Abstract base class for class sc_port_b.
+// ----------------------------------------------------------------------------
+
+class sc_port_base
+: public sc_object
+{
+    friend class sc_module;
+    friend class sc_port_registry;
+    friend class sc_sensitive;
+    friend class sc_sensitive_pos;
+    friend class sc_sensitive_neg;
+
+public:
+
+    // typedefs
+
+    typedef sc_port_base this_type;
+
+public:
+
+    int bind_count();
+
+    // get the first interface without checking for nil
+    virtual       sc_interface* get_interface()       = 0;
+    virtual const sc_interface* get_interface() const = 0;
+
+    virtual const char* kind() const
+        { return "sc_port_base"; }
+
+protected:
+
+    // constructors
+    explicit sc_port_base( int max_size_, 
+	    sc_port_policy policy=SC_ONE_OR_MORE_BOUND );
+    sc_port_base( const char* name_, int max_size_, 
+		  sc_port_policy policy=SC_ONE_OR_MORE_BOUND );
+
+    // destructor
+    virtual ~sc_port_base();
+
+    // bind interface to this port
+    void bind( sc_interface& interface_ );
+
+    // bind parent port to this port
+    void bind( this_type& parent_ );
+
+    // called by pbind (for internal use only)
+    virtual int vbind( sc_interface& ) = 0;
+    virtual int vbind( sc_port_base& ) = 0;
+
+    // called by complete_binding (for internal use only)
+    virtual void add_interface( sc_interface* ) = 0;
+	virtual int interface_count() = 0;
+    virtual const char* if_typename() const = 0;
+
+    // called by construction_done (does nothing by default)
+    virtual void before_end_of_elaboration();
+
+    // called by elaboration_done (does nothing)
+    virtual void end_of_elaboration();
+
+    // called by start_simulation (does nothing by default)
+    virtual void start_of_simulation();
+
+    // called by simulation_done (does nothing by default)
+    virtual void end_of_simulation();
+
+    // error reporting
+    void report_error( const char* id, const char* add_msg = 0) const;
+
+protected:
+    // called by the sc_sensitive* classes
+    virtual void make_sensitive( sc_thread_handle, sc_event_finder* = 0 ) const;
+    virtual void make_sensitive( sc_method_handle, sc_event_finder* = 0 ) const;
+    void add_static_event(
+		sc_method_handle process_p, const sc_event& event) const;
+    void add_static_event(
+		sc_thread_handle process_p, const sc_event& event) const;
+
+private:
+
+    // called by class sc_module for positional binding
+    int pbind( sc_interface& );
+    int pbind( sc_port_base& );
+
+
+    // support methods
+    int first_parent();
+    void insert_parent( int );
+
+    // called when construction is done
+    void construction_done();
+
+    // called when elaboration is done
+    void complete_binding();
+    void elaboration_done();
+
+    // called before simulation starts
+    void start_simulation();
+
+    // called after simulation ends
+    void simulation_done();
+
+protected:
+
+    sc_bind_info* m_bind_info;
+
+private:
+
+    // disabled
+    sc_port_base();
+    sc_port_base( const this_type& );
+    this_type& operator = ( const this_type& );
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_port_registry
+//
+//  Registry for all ports.
+//  FOR INTERNAL USE ONLY!
+// ----------------------------------------------------------------------------
+
+class sc_port_registry
+{
+    friend class sc_simcontext;
+
+public:
+
+    void insert( sc_port_base* );
+    void remove( sc_port_base* );
+
+    int size() const
+        { return m_port_vec.size(); }
+
+private:
+
+    // constructor
+    explicit sc_port_registry( sc_simcontext& simc_ );
+
+    // destructor
+    ~sc_port_registry();
+
+    // called when by construction_done and elaboration done
+    void complete_binding();
+
+    // called when construction is done
+    bool construction_done();
+
+    // called when elaboration is done
+    void elaboration_done();
+
+    // called before simulation starts
+    void start_simulation();
+
+    // called after simulation ends
+    void simulation_done();
+
+    static void replace_port( sc_port_registry* );
+
+private:
+
+    int                         m_construction_done;
+    std::vector<sc_port_base*>  m_port_vec;
+    sc_simcontext*              m_simc;
+
+private:
+
+    // disabled
+    sc_port_registry();
+    sc_port_registry( const sc_port_registry& );
+    sc_port_registry& operator = ( const sc_port_registry& );
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_port_b
+//
+//  Abstract base class for class sc_port.
+// ----------------------------------------------------------------------------
+
+template <class IF>
+class sc_port_b
+: public sc_port_base
+{
+public:
+
+    friend class sc_sensitive;
+    friend class sc_sensitive_neg;
+    friend class sc_sensitive_pos;
+
+    // typedefs
+
+    typedef sc_port_base  base_type;
+    typedef sc_port_b<IF> this_type;
+    typedef this_type     port_type;
+
+public:
+
+    // bind an interface of type IF to this port
+
+    SC_VIRTUAL_ void bind( IF& interface_ )
+	{ base_type::bind( interface_ ); }
+
+    void operator () ( IF& interface_ )
+	{ this->bind( interface_ ); }
+
+
+    // bind a parent port with type IF to this port
+
+    SC_VIRTUAL_ void bind( port_type& parent_ )
+	{ base_type::bind( parent_ ); }
+
+    void operator () ( port_type& parent_ )
+	{ this->bind( parent_ ); }
+
+
+    // number of connected interfaces
+
+    int size() const
+	{ return m_interface_vec.size(); }
+
+
+    // allow to call methods provided by the first interface
+    IF* operator -> ();
+    const IF* operator -> () const;
+
+
+    // allow to call methods provided by interface at index
+    inline const IF* get_interface( int iface_i ) const;
+    inline IF* get_interface( int iface_i );
+    IF* operator [] ( int index_ )
+        { return get_interface( index_ ); }
+    const IF* operator [] ( int index_ ) const
+        { return get_interface( index_ ); }
+
+
+    // get the first interface without checking for nil
+
+    virtual sc_interface* get_interface()
+        { return m_interface; }
+
+    virtual const sc_interface* get_interface() const
+        { return m_interface; }
+
+protected:
+
+    // constructors
+
+    explicit sc_port_b( int max_size_, 
+	                sc_port_policy policy=SC_ONE_OR_MORE_BOUND ) :
+	base_type( max_size_, policy ), m_interface( 0 ), m_interface_vec()
+	{}
+
+    sc_port_b( const char* name_, int max_size_, 
+               sc_port_policy policy=SC_ONE_OR_MORE_BOUND ) :
+	base_type( name_, max_size_, policy ), m_interface( 0 ), 
+	m_interface_vec()
+	{}
+
+
+    // destructor (does nothing)
+
+    virtual ~sc_port_b()
+	{}
+
+
+    // called by pbind (for internal use only)
+    virtual int vbind( sc_interface& );
+    virtual int vbind( sc_port_base& );
+
+protected:
+
+    // called by the sc_sensitive* classes
+    virtual void make_sensitive( sc_thread_handle, sc_event_finder* = 0 ) const;
+    virtual void make_sensitive( sc_method_handle, sc_event_finder* = 0 ) const;
+
+private:
+
+    // called by complete_binding (for internal use only)
+    virtual void add_interface( sc_interface* );
+    virtual const char* if_typename() const;
+	virtual int interface_count();
+
+    // disabled
+    sc_port_b();
+    sc_port_b( const this_type& );
+    this_type& operator = ( const this_type& );
+
+private:
+
+    IF*              m_interface;	// first interface in interface vec
+    std::vector<IF*> m_interface_vec;
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_port
+//
+//  Generic port class and base class for other port classes.
+//  N is the maximum number of channels (with interface IF) that can be bound
+//  to this port. N <= 0 means no maximum.
+// ----------------------------------------------------------------------------
+
+extern void sc_warn_port_constructor();
+
+template <class IF, int N = 1, sc_port_policy P=SC_ONE_OR_MORE_BOUND>
+class sc_port
+: public sc_port_b<IF>
+{
+    // typdefs
+
+    typedef sc_port_b<IF> base_type;
+    typedef sc_port<IF,N,P> this_type;
+
+public:
+
+    // constructors
+
+    sc_port()
+	: base_type( N, P )
+	{}
+
+    explicit sc_port( const char* name_ )
+	: base_type( name_, N, P )
+	{}
+
+    explicit sc_port( IF& interface_ )
+	: base_type( N, P )
+	{ sc_warn_port_constructor(); base_type::bind( interface_ ); }
+
+    sc_port( const char* name_, IF& interface_ )
+	: base_type( name_, N, P )
+	{ sc_warn_port_constructor(); base_type::bind( interface_ ); }
+
+    explicit sc_port( base_type& parent_ )
+	: base_type( N, P )
+	{ sc_warn_port_constructor(); base_type::bind( parent_ ); }
+
+    sc_port( const char* name_, base_type& parent_ )
+	: base_type( name_, N, P )
+	{ sc_warn_port_constructor(); base_type::bind( parent_ ); }
+
+    sc_port( this_type& parent_ )
+	: base_type( N, P )
+	{ sc_warn_port_constructor(); base_type::bind( parent_ ); }
+
+    sc_port( const char* name_, this_type& parent_ )
+	: base_type( name_, N, P )
+	{ sc_warn_port_constructor(); base_type::bind( parent_ ); }
+
+
+    // destructor (does nothing)
+
+    virtual ~sc_port()
+	{}
+
+    virtual const char* kind() const
+        { return "sc_port"; }
+
+private:
+
+    // disabled
+    sc_port( const this_type& );
+    this_type& operator = ( const this_type& );
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_port_b
+//
+//  Abstract base class for class sc_port.
+// ----------------------------------------------------------------------------
+
+// allow to call methods provided by the first interface
+
+template <class IF>
+inline
+IF*
+sc_port_b<IF>::operator -> ()
+{
+    if( m_interface == 0 ) {
+	report_error( SC_ID_GET_IF_, "port is not bound" );
+    }
+    return m_interface;
+}
+
+template <class IF>
+inline
+const IF*
+sc_port_b<IF>::operator -> () const
+{
+    if( m_interface == 0 ) {
+	report_error( SC_ID_GET_IF_, "port is not bound" );
+    }
+    return m_interface;
+}
+
+
+// allow to call methods provided by interface at index
+//
+// note that we special-case index of zero, since the method may be
+// called before binding has occurred, and we need to return a zero
+// in that case not an error.
+
+template <class IF>
+inline
+IF*
+sc_port_b<IF>::get_interface( int index_ )
+{
+    if ( index_ == 0 ) {
+    	return m_interface;
+    }
+    else if( index_ < 0 || index_ >= size() ) {
+	report_error( SC_ID_GET_IF_, "index out of range" );
+    }
+    return m_interface_vec[index_];
+}
+
+template <class IF>
+inline
+const IF*
+sc_port_b<IF>::get_interface( int index_ ) const
+{
+    if ( index_ == 0 ) {
+    	return m_interface;
+    }
+    else if( index_ < 0 || index_ >= size() ) {
+	report_error( SC_ID_GET_IF_, "index out of range" );
+    }
+    return m_interface_vec[index_];
+}
+
+
+// called by pbind (for internal use only)
+
+template <class IF>
+inline
+int
+sc_port_b<IF>::vbind( sc_interface& interface_ )
+{
+    IF* iface = DCAST<IF*>( &interface_ );
+    if( iface == 0 ) {
+	// type mismatch
+	return 2;
+    }
+    base_type::bind( *iface );
+    return 0;
+}
+
+template <class IF>
+inline
+int
+sc_port_b<IF>::vbind( sc_port_base& parent_ )
+{
+    this_type* parent = DCAST<this_type*>( &parent_ );
+    if( parent == 0 ) {
+	// type mismatch
+	return 2;
+    }
+    base_type::bind( *parent );
+    return 0;
+}
+
+
+// called by complete_binding (for internal use only)
+
+template <class IF>
+inline
+void
+sc_port_b<IF>::add_interface( sc_interface* interface_ )
+{
+    IF* iface = DCAST<IF*>( interface_ );
+    assert( iface != 0 );
+
+    // make sure that the interface is not already bound:
+
+    int size = m_interface_vec.size();
+    for ( int i = 0; i < size; i++ )
+    {
+    	if ( iface == m_interface_vec[i] )
+	{
+	    report_error( SC_ID_BIND_IF_TO_PORT_, 
+	    	"interface already bound to port" );
+	}
+    }
+
+    // "bind" the interface and make sure our short cut for 0 is set up.
+
+    m_interface_vec.push_back( iface );
+    m_interface = m_interface_vec[0]; 
+}
+
+template <class IF>
+inline
+const char*
+sc_port_b<IF>::if_typename() const
+{
+    return typeid( IF ).name();
+}
+
+template <class IF>
+inline
+int
+sc_port_b<IF>::interface_count()
+{
+	return m_interface_vec.size();
+}
+
+template <class IF>
+void
+sc_port_b<IF>::make_sensitive( sc_thread_handle handle_p,
+                  sc_event_finder* event_finder_ ) const
+{
+    if ( m_bind_info == 0 )
+    {
+        int if_n = m_interface_vec.size();
+        for ( int if_i = 0; if_i < if_n; if_i++ )
+	{
+	    IF* iface_p = m_interface_vec[if_i];
+	    assert( iface_p != 0 );
+	    add_static_event( handle_p, iface_p->default_event() );
+	}
+    }
+    else
+    {
+        sc_port_base::make_sensitive( handle_p, event_finder_ );
+    }
+}
+
+template <class IF>
+void
+sc_port_b<IF>::make_sensitive( sc_method_handle handle_p,
+                  sc_event_finder* event_finder_ ) const
+{
+    if ( m_bind_info == 0 )
+    {
+        int if_n = m_interface_vec.size();
+        for ( int if_i = 0; if_i < if_n; if_i++ )
+	{
+	    IF* iface_p = m_interface_vec[if_i];
+	    assert( iface_p != 0 );
+	    add_static_event( handle_p, iface_p->default_event() );
+	}
+    }
+    else
+    {
+        sc_port_base::make_sensitive( handle_p, event_finder_ );
+    }
+}
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_port
+//
+//  Generic port class and base class for other port classes.
+//  N is the maximum number of channels (with interface IF) that can be bound
+//  to this port. N <= 0 means no maximum.
+// ----------------------------------------------------------------------------
+
+} // namespace sc_core
+
+#undef SC_VIRTUAL_
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Andy Goodrich, Forte,
+                               Bishnupriya Bhattacharya, Cadence Design Systems,
+                               25 August, 2003
+  Description of Modification: phase callbacks
+
+      Name, Affiliation, Date: Andy Goodrich, Forte Design Systems
+                               12 December, 2005
+  Description of Modification: multiport binding policy changes
+
+    
+ *****************************************************************************/
+
+/* 
+$Log: sc_port.h,v $
+Revision 1.10  2011/08/26 20:45:41  acg
+ Andy Goodrich: moved the modification log to the end of the file to
+ eliminate source line number skew when check-ins are done.
+
+Revision 1.9  2011/08/24 22:05:36  acg
+ Torsten Maehne: initialization changes to remove warnings.
+
+Revision 1.8  2011/08/07 19:08:01  acg
+ Andy Goodrich: moved logs to end of file so line number synching works
+ better between versions.
+
+Revision 1.7  2011/08/07 18:53:09  acg
+ Philipp A. Hartmann: add virtual instances of the bind function for
+ base classes to eliminate warning messages for clang platforms.
+
+Revision 1.6  2011/05/09 04:07:37  acg
+ Philipp A. Hartmann:
+   (1) Restore hierarchy in all phase callbacks.
+   (2) Ensure calls to before_end_of_elaboration.
+
+Revision 1.5  2011/03/30 16:46:10  acg
+ Andy Goodrich: added a signature and removed a virtual specification
+ to eliminate warnings with certain compilers.
+
+Revision 1.4  2011/02/18 20:23:45  acg
+ Andy Goodrich: Copyright update.
+
+Revision 1.3  2011/01/20 16:52:15  acg
+ Andy Goodrich: changes for IEEE 1666 2011.
+
+Revision 1.2  2010/08/03 18:01:11  acg
+ Andy Goodrich: formatting.
+
+Revision 1.1.1.1  2006/12/15 20:20:04  acg
+SystemC 2.3
+
+Revision 1.5  2006/08/29 23:35:00  acg
+ Andy Goodrich: added bind_count() method to allow users to determine which
+ ports are connected in before_end_of_elaboration().
+
+Revision 1.4  2006/05/08 17:52:47  acg
+ Andy Goodrich:
+   (1) added David Long's forward declarations for friend functions,
+       methods, and operators to keep the Microsoft compiler happy.
+   (2) Added delta_count() method to sc_prim_channel for use by
+       sc_signal so that the friend declaration in sc_simcontext.h
+	   can be for a non-templated class (i.e., sc_prim_channel.)
+
+Revision 1.3  2006/01/24 20:46:31  acg
+Andy Goodrich: changes to eliminate use of deprecated features. For instance,
+using notify(SC_ZERO_TIME) in place of notify_delayed().
+
+Revision 1.2  2006/01/03 23:18:26  acg
+Changed copyright to include 2006.
+
+Revision 1.1.1.1  2005/12/19 23:16:43  acg
+First check in of SystemC 2.1 into its own archive.
+
+Revision 1.10  2005/09/15 23:01:51  acg
+Added std:: prefix to appropriate methods and types to get around
+issues with the Edison Front End.
+
+Revision 1.9  2005/08/10 01:35:59  acg
+Changes for 64-bit support.
+
+Revision 1.8  2005/04/03 22:52:51  acg
+Namespace changes.
+
+Revision 1.7  2005/03/21 22:31:32  acg
+Changes to sc_core namespace.
+
+Revision 1.6  2004/09/27 21:02:54  acg
+Andy Goodrich - Forte Design Systems, Inc.
+   - Added a $Log comment so that CVS checkin comments will appear in
+     checked out source.
+
+*/
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_prim_channel.cpp b/ext/systemc/src/sysc/communication/sc_prim_channel.cpp
new file mode 100644
index 000000000..067884281
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_prim_channel.cpp
@@ -0,0 +1,429 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_prim_channel.cpp -- Abstract base class of all primitive channel
+                         classes.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#include "sysc/communication/sc_prim_channel.h"
+#include "sysc/communication/sc_communication_ids.h"
+#include "sysc/kernel/sc_simcontext.h"
+#include "sysc/kernel/sc_module.h"
+#include "sysc/kernel/sc_object_int.h"
+
+#ifndef SC_DISABLE_ASYNC_UPDATES
+#  include "sysc/communication/sc_host_mutex.h"
+#endif
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_prim_channel
+//
+//  Abstract base class of all primitive channel classes.
+// ----------------------------------------------------------------------------
+
+// constructors
+
+sc_prim_channel::sc_prim_channel()
+: sc_object( 0 ),
+  m_registry( simcontext()->get_prim_channel_registry() ),
+  m_update_next_p( 0 ) 
+{
+    m_registry->insert( *this );
+}
+
+sc_prim_channel::sc_prim_channel( const char* name_ )
+: sc_object( name_ ),
+  m_registry( simcontext()->get_prim_channel_registry() ),
+  m_update_next_p( 0 )
+{
+    m_registry->insert( *this );
+}
+
+
+// destructor
+
+sc_prim_channel::~sc_prim_channel()
+{
+    m_registry->remove( *this );
+}
+
+
+// the update method (does nothing by default)
+
+void
+sc_prim_channel::update()
+{}
+
+
+// called by construction_done (does nothing by default)
+
+void sc_prim_channel::before_end_of_elaboration() 
+{}
+
+// called when construction is done
+
+void
+sc_prim_channel::construction_done()
+{
+    sc_object::hierarchy_scope scope( get_parent_object() );
+    before_end_of_elaboration();
+}
+
+// called by elaboration_done (does nothing by default)
+
+void
+sc_prim_channel::end_of_elaboration()
+{}
+
+
+// called when elaboration is done
+
+void
+sc_prim_channel::elaboration_done()
+{
+    sc_object::hierarchy_scope scope( get_parent_object() );
+    end_of_elaboration();
+}
+
+// called by start_simulation (does nothing)
+
+void
+sc_prim_channel::start_of_simulation()
+{}
+
+// called before simulation begins
+
+void
+sc_prim_channel::start_simulation()
+{
+    sc_object::hierarchy_scope scope( get_parent_object() );
+    start_of_simulation();
+}
+
+// called by simulation_done (does nothing)
+
+void
+sc_prim_channel::end_of_simulation()
+{}
+
+// called after simulation ends
+
+void
+sc_prim_channel::simulation_done()
+{
+    sc_object::hierarchy_scope scope( get_parent_object() );
+    end_of_simulation();
+}
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_prim_channel_registry::async_update_list
+//
+//  Thread-safe list of pending external updates
+//  FOR INTERNAL USE ONLY!
+// ----------------------------------------------------------------------------
+
+class sc_prim_channel_registry::async_update_list
+{
+#ifndef SC_DISABLE_ASYNC_UPDATES
+public:
+
+    bool pending() const
+    {
+	return m_push_queue.size() != 0;
+    }
+
+    void append( sc_prim_channel& prim_channel_ )
+    {
+	sc_scoped_lock lock( m_mutex );
+	m_push_queue.push_back( &prim_channel_ );
+	// return releases the mutex
+    }
+
+    void accept_updates()
+    {
+	sc_assert( ! m_pop_queue.size() );
+	{
+	    sc_scoped_lock lock( m_mutex );
+	    m_push_queue.swap( m_pop_queue );
+	    // leaving the block releases the mutex
+	}
+
+	std::vector< sc_prim_channel* >::const_iterator
+	    it = m_pop_queue.begin(), end = m_pop_queue.end();
+	while( it!= end )
+	{
+	    // we use request_update instead of perform_update
+	    // to skip duplicates
+	    (*it++)->request_update();
+	}
+	m_pop_queue.clear();
+    }
+
+private:
+    sc_host_mutex                   m_mutex;
+    std::vector< sc_prim_channel* > m_push_queue;
+    std::vector< sc_prim_channel* > m_pop_queue;
+
+#endif // ! SC_DISABLE_ASYNC_UPDATES
+};
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_prim_channel_registry
+//
+//  Registry for all primitive channels.
+//  FOR INTERNAL USE ONLY!
+// ----------------------------------------------------------------------------
+
+void
+sc_prim_channel_registry::insert( sc_prim_channel& prim_channel_ )
+{
+    if( sc_is_running() ) {
+       SC_REPORT_ERROR( SC_ID_INSERT_PRIM_CHANNEL_, "simulation running" );
+    }
+
+    if( m_simc->elaboration_done() ) {
+
+	SC_REPORT_ERROR( SC_ID_INSERT_PRIM_CHANNEL_, "elaboration done" );
+    }
+
+#ifdef DEBUG_SYSTEMC
+    // check if prim_channel_ is already inserted
+    for( int i = 0; i < size(); ++ i ) {
+	if( &prim_channel_ == m_prim_channel_vec[i] ) {
+	    SC_REPORT_ERROR( SC_ID_INSERT_PRIM_CHANNEL_, "already inserted" );
+	}
+    }
+#endif
+
+    // insert
+    m_prim_channel_vec.push_back( &prim_channel_ );
+
+}
+
+void
+sc_prim_channel_registry::remove( sc_prim_channel& prim_channel_ )
+{
+    int i;
+    for( i = 0; i < size(); ++ i ) {
+	if( &prim_channel_ == m_prim_channel_vec[i] ) {
+	    break;
+	}
+    }
+    if( i == size() ) {
+	SC_REPORT_ERROR( SC_ID_REMOVE_PRIM_CHANNEL_, 0 );
+    }
+
+    // remove
+    m_prim_channel_vec[i] = m_prim_channel_vec[size() - 1];
+    m_prim_channel_vec.resize(size()-1);
+}
+
+bool
+sc_prim_channel_registry::pending_async_updates() const
+{
+#ifndef SC_DISABLE_ASYNC_UPDATES
+    return m_async_update_list_p->pending();
+#else
+    return false;
+#endif
+}
+
+void
+sc_prim_channel_registry::async_request_update( sc_prim_channel& prim_channel_ )
+{
+#ifndef SC_DISABLE_ASYNC_UPDATES
+    m_async_update_list_p->append( prim_channel_ );
+#else
+    SC_REPORT_ERROR( SC_ID_NO_ASYNC_UPDATE_, prim_channel_.name() );
+#endif
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_prim_channel_registry::perform_update"
+// |
+// | This method updates the values of the primitive channels in its update
+// | lists.
+// +----------------------------------------------------------------------------
+void
+sc_prim_channel_registry::perform_update()
+{
+    // Update the values for the primitive channels set external to the
+    // simulator.
+
+#ifndef SC_DISABLE_ASYNC_UPDATES
+    if( m_async_update_list_p->pending() )
+	m_async_update_list_p->accept_updates();
+#endif
+
+    sc_prim_channel* next_p; // Next update to perform.
+    sc_prim_channel* now_p;  // Update now performing.
+
+    // Update the values for the primitive channels in the simulator's list.
+
+    now_p = m_update_list_p;
+    m_update_list_p = (sc_prim_channel*)sc_prim_channel::list_end;
+    for ( ; now_p != (sc_prim_channel*)sc_prim_channel::list_end;
+	now_p = next_p )
+    {
+	next_p = now_p->m_update_next_p;
+	now_p->perform_update();
+    }
+}
+
+// constructor
+
+sc_prim_channel_registry::sc_prim_channel_registry( sc_simcontext& simc_ )
+  :  m_async_update_list_p(0)
+  ,  m_construction_done(0)
+  ,  m_prim_channel_vec()
+  ,  m_simc( &simc_ )
+  ,  m_update_list_p((sc_prim_channel*)sc_prim_channel::list_end)
+{
+#   ifndef SC_DISABLE_ASYNC_UPDATES
+        m_async_update_list_p = new async_update_list();
+#   endif
+}
+
+
+// destructor
+
+sc_prim_channel_registry::~sc_prim_channel_registry()
+{
+    delete m_async_update_list_p;
+}
+
+// called when construction is done
+
+bool
+sc_prim_channel_registry::construction_done()
+{
+    if( size() == m_construction_done )
+        // nothing has been updated
+        return true;
+
+    for( ; m_construction_done < size(); ++m_construction_done ) {
+        m_prim_channel_vec[m_construction_done]->construction_done();
+    }
+
+    return false;
+}
+
+
+// called when elaboration is done
+
+void
+sc_prim_channel_registry::elaboration_done()
+{
+    for( int i = 0; i < size(); ++ i ) {
+	m_prim_channel_vec[i]->elaboration_done();
+    }
+}
+
+// called before simulation begins
+
+void
+sc_prim_channel_registry::start_simulation()
+{
+    for( int i = 0; i < size(); ++ i ) {
+	m_prim_channel_vec[i]->start_simulation();
+    }
+}
+
+// called after simulation ends
+
+void
+sc_prim_channel_registry::simulation_done()
+{
+    for( int i = 0; i < size(); ++ i ) {
+	m_prim_channel_vec[i]->simulation_done();
+    }
+}
+
+} // namespace sc_core
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Andy Goodrich, Forte,
+                               Bishnupriya Bhattacharya, Cadence Design Systems,
+                               25 August, 2003
+
+  Description of Modification: phase callbacks
+    
+ *****************************************************************************/
+
+
+// $Log: sc_prim_channel.cpp,v $
+// Revision 1.11  2011/08/26 21:38:32  acg
+//  Philipp A. Hartmann: removed unused switch m_construction_done.
+//
+// Revision 1.10  2011/08/26 20:45:41  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.9  2011/08/24 22:05:36  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.8  2011/05/09 04:07:37  acg
+//  Philipp A. Hartmann:
+//    (1) Restore hierarchy in all phase callbacks.
+//    (2) Ensure calls to before_end_of_elaboration.
+//
+// Revision 1.7  2011/04/19 02:36:26  acg
+//  Philipp A. Hartmann: new aysnc_update and mutex support.
+//
+// Revision 1.6  2011/02/18 20:31:05  acg
+//  Philipp A. Hartmann: added error messages for calls that cannot be done
+//  after elaboration.
+//
+// Revision 1.5  2011/02/18 20:23:45  acg
+//  Andy Goodrich: Copyright update.
+//
+// Revision 1.4  2011/02/14 17:50:16  acg
+//  Andy Goodrich: testing for sc_port and sc_export instantiations during
+//  end of elaboration and issuing appropriate error messages.
+//
+// Revision 1.3  2010/12/07 20:36:49  acg
+//  Andy Goodrich: fix pointer that should have been initialized to zero.
+//
+// Revision 1.2  2010/12/07 19:50:36  acg
+//  Andy Goodrich: addition of writer policies, courtesy of Philipp Hartmann.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.4  2006/01/26 21:00:50  acg
+//  Andy Goodrich: conversion to use sc_event::notify(SC_ZERO_TIME) instead of
+//  sc_event::notify_delayed()
+//
+// Revision 1.3  2006/01/13 18:47:42  acg
+// Added $Log command so that CVS comments are reproduced in the source.
+//
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_prim_channel.h b/ext/systemc/src/sysc/communication/sc_prim_channel.h
new file mode 100644
index 000000000..4a52fe7cb
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_prim_channel.h
@@ -0,0 +1,420 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_prim_channel.h -- Abstract base class of all primitive channel classes.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+ CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_PRIM_CHANNEL_H
+#define SC_PRIM_CHANNEL_H
+
+#include "sysc/kernel/sc_object.h"
+#include "sysc/kernel/sc_wait.h"
+#include "sysc/kernel/sc_wait_cthread.h"
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_prim_channel
+//
+//  Abstract base class of all primitive channel classes.
+// ----------------------------------------------------------------------------
+
+class sc_prim_channel
+: public sc_object
+{
+    friend class sc_prim_channel_registry;
+
+public:
+    enum { list_end = 0xdb };
+public:
+    virtual const char* kind() const
+        { return "sc_prim_channel"; }
+
+    inline bool update_requested() 
+	{ return m_update_next_p != (sc_prim_channel*)list_end; }
+
+    // request the update method to be executed during the update phase
+    inline void request_update();
+
+    // request the update method to be executed during the update phase
+    // from a process external to the simulator.
+    void async_request_update();
+
+protected:
+
+    // constructors
+    sc_prim_channel();
+    explicit sc_prim_channel( const char* );
+
+    // destructor
+    virtual ~sc_prim_channel();
+
+    // the update method (does nothing by default)
+    virtual void update();
+
+    // called by construction_done (does nothing by default)
+    virtual void before_end_of_elaboration();
+
+    // called by elaboration_done (does nothing by default)
+    virtual void end_of_elaboration();
+
+    // called by start_simulation (does nothing by default)
+    virtual void start_of_simulation();
+
+    // called by simulation_done (does nothing by default)
+    virtual void end_of_simulation();
+
+protected:
+
+    // to avoid calling sc_get_curr_simcontext()
+
+    // static sensitivity for SC_THREADs and SC_CTHREADs
+
+    void wait()
+        { sc_core::wait( simcontext() ); }
+
+
+    // dynamic sensitivity for SC_THREADs and SC_CTHREADs
+
+    void wait( const sc_event& e )
+        { sc_core::wait( e, simcontext() ); }
+
+    void wait( const sc_event_or_list& el )
+	{ sc_core::wait( el, simcontext() ); }
+
+    void wait( const sc_event_and_list& el )
+	{ sc_core::wait( el, simcontext() ); }
+
+    void wait( const sc_time& t )
+        { sc_core::wait( t, simcontext() ); }
+
+    void wait( double v, sc_time_unit tu )
+        { sc_core::wait( sc_time( v, tu, simcontext() ), simcontext() ); }
+
+    void wait( const sc_time& t, const sc_event& e )
+        { sc_core::wait( t, e, simcontext() ); }
+
+    void wait( double v, sc_time_unit tu, const sc_event& e )
+        { sc_core::wait( sc_time( v, tu, simcontext() ), e, simcontext() ); }
+
+    void wait( const sc_time& t, const sc_event_or_list& el )
+        { sc_core::wait( t, el, simcontext() ); }
+
+    void wait( double v, sc_time_unit tu, const sc_event_or_list& el )
+        { sc_core::wait( sc_time( v, tu, simcontext() ), el, simcontext() ); }
+
+    void wait( const sc_time& t, const sc_event_and_list& el )
+        { sc_core::wait( t, el, simcontext() ); }
+
+    void wait( double v, sc_time_unit tu, const sc_event_and_list& el )
+        { sc_core::wait( sc_time( v, tu, simcontext() ), el, simcontext() ); }
+
+    void wait( int n )
+        { sc_core::wait( n, simcontext() ); }
+
+
+    // static sensitivity for SC_METHODs
+
+    void next_trigger()
+	{ sc_core::next_trigger( simcontext() ); }
+
+
+    // dynamic sensitivity for SC_METHODs
+
+    void next_trigger( const sc_event& e )
+        { sc_core::next_trigger( e, simcontext() ); }
+
+    void next_trigger( const sc_event_or_list& el )
+        { sc_core::next_trigger( el, simcontext() ); }
+
+    void next_trigger( const sc_event_and_list& el )
+        { sc_core::next_trigger( el, simcontext() ); }
+
+    void next_trigger( const sc_time& t )
+        { sc_core::next_trigger( t, simcontext() ); }
+
+    void next_trigger( double v, sc_time_unit tu )
+        {sc_core::next_trigger( sc_time( v, tu, simcontext() ), simcontext() );}
+
+    void next_trigger( const sc_time& t, const sc_event& e )
+        { sc_core::next_trigger( t, e, simcontext() ); }
+
+    void next_trigger( double v, sc_time_unit tu, const sc_event& e )
+        { sc_core::next_trigger( 
+	    sc_time( v, tu, simcontext() ), e, simcontext() ); }
+
+    void next_trigger( const sc_time& t, const sc_event_or_list& el )
+        { sc_core::next_trigger( t, el, simcontext() ); }
+
+    void next_trigger( double v, sc_time_unit tu, const sc_event_or_list& el )
+        { sc_core::next_trigger( 
+	    sc_time( v, tu, simcontext() ), el, simcontext() ); }
+
+    void next_trigger( const sc_time& t, const sc_event_and_list& el )
+        { sc_core::next_trigger( t, el, simcontext() ); }
+
+    void next_trigger( double v, sc_time_unit tu, const sc_event_and_list& el )
+        { sc_core::next_trigger( 
+	    sc_time( v, tu, simcontext() ), el, simcontext() ); }
+
+
+    // for SC_METHODs and SC_THREADs and SC_CTHREADs
+
+    bool timed_out()
+	{ return sc_core::timed_out( simcontext() ); }
+
+
+#if 0 // @@@@####
+    // delta count maintenance
+    sc_dt::uint64 delta_count()
+	{ return simcontext()->m_delta_count; }
+#endif
+
+private:
+
+    // called during the update phase of a delta cycle (if requested)
+    void perform_update();
+
+    // called when construction is done
+    void construction_done();
+
+    // called when elaboration is done
+    void elaboration_done();
+
+    // called before simulation starts
+    void start_simulation();
+
+    // called after simulation ends
+    void simulation_done();
+
+    // disabled
+    sc_prim_channel( const sc_prim_channel& );
+    sc_prim_channel& operator = ( const sc_prim_channel& );
+
+private:
+
+    sc_prim_channel_registry* m_registry;          // Update list manager.
+    sc_prim_channel*          m_update_next_p;     // Next entry in update list.
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_prim_channel_registry
+//
+//  Registry for all primitive channels.
+//  FOR INTERNAL USE ONLY!
+// ----------------------------------------------------------------------------
+
+class sc_prim_channel_registry
+{
+    friend class sc_simcontext;
+
+public:
+
+    void insert( sc_prim_channel& );
+    void remove( sc_prim_channel& );
+
+
+    int size() const
+        { return m_prim_channel_vec.size(); }
+
+    inline void request_update( sc_prim_channel& );
+    void async_request_update( sc_prim_channel& );
+
+    bool pending_updates() const
+    { 
+        return m_update_list_p != (sc_prim_channel*)sc_prim_channel::list_end 
+               || pending_async_updates();
+    }   
+
+    bool pending_async_updates() const;
+
+private:
+
+    // constructor
+    explicit sc_prim_channel_registry( sc_simcontext& simc_ );
+
+    // destructor
+    ~sc_prim_channel_registry();
+
+    // called during the update phase of a delta cycle
+    void perform_update();
+
+    // called when construction is done
+    bool construction_done();
+
+    // called when elaboration is done
+    void elaboration_done();
+
+    // called before simulation starts
+    void start_simulation();
+
+    // called after simulation ends
+    void simulation_done();
+
+    // disabled
+    sc_prim_channel_registry();
+    sc_prim_channel_registry( const sc_prim_channel_registry& );
+    sc_prim_channel_registry& operator = ( const sc_prim_channel_registry& );
+
+private:
+    class async_update_list;   
+
+    async_update_list*            m_async_update_list_p; // external updates.
+    int                           m_construction_done;   // # of constructs.
+    std::vector<sc_prim_channel*> m_prim_channel_vec;    // existing channels.
+    sc_simcontext*                m_simc;                // simulator context.
+    sc_prim_channel*              m_update_list_p;       // internal updates.
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_prim_channel_registry
+//
+//  Registry for all primitive channels.
+//  FOR INTERNAL USE ONLY!
+// ----------------------------------------------------------------------------
+
+inline
+void
+sc_prim_channel_registry::request_update( sc_prim_channel& prim_channel_ )
+{
+    prim_channel_.m_update_next_p = m_update_list_p;
+    m_update_list_p = &prim_channel_;
+}
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_prim_channel
+//
+//  Abstract base class of all primitive channel classes.
+// ----------------------------------------------------------------------------
+
+// request the update method (to be executed during the update phase)
+
+inline
+void
+sc_prim_channel::request_update()
+{
+    if( ! m_update_next_p ) {
+	m_registry->request_update( *this );
+    }
+}
+
+// request the update method from external to the simulator (to be executed 
+// during the update phase)
+
+inline
+void
+sc_prim_channel::async_request_update()
+{
+    m_registry->async_request_update(*this);
+}
+
+
+// called during the update phase of a delta cycle (if requested)
+
+inline
+void
+sc_prim_channel::perform_update()
+{
+    update();
+    m_update_next_p = 0;
+}
+
+
+} // namespace sc_core
+
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Andy Goodrich, Forte,
+                               Bishnupriya Bhattacharya, Cadence Design Systems,
+                               25 August, 2003
+  Description of Modification: phase callbacks
+    
+ *****************************************************************************/
+//$Log: sc_prim_channel.h,v $
+//Revision 1.10  2011/08/26 21:38:32  acg
+// Philipp A. Hartmann: removed unused switch m_construction_done.
+//
+//Revision 1.9  2011/08/07 19:08:01  acg
+// Andy Goodrich: moved logs to end of file so line number synching works
+// better between versions.
+//
+//Revision 1.8  2011/05/09 04:07:37  acg
+// Philipp A. Hartmann:
+//   (1) Restore hierarchy in all phase callbacks.
+//   (2) Ensure calls to before_end_of_elaboration.
+//
+//Revision 1.7  2011/05/05 17:44:01  acg
+// Philip A. Hartmann: change in the name of pending_async_updates.
+//
+//Revision 1.6  2011/04/19 15:03:48  acg
+// Philipp A. Hartmann: remove ASYNC_UPDATE preprocessor check from header.
+//
+//Revision 1.5  2011/04/19 02:36:26  acg
+// Philipp A. Hartmann: new aysnc_update and mutex support.
+//
+//Revision 1.4  2011/04/05 20:48:09  acg
+// Andy Goodrich: changes to make sure that event(), posedge() and negedge()
+// only return true if the clock has not moved.
+//
+//Revision 1.3  2011/02/18 20:23:45  acg
+// Andy Goodrich: Copyright update.
+//
+//Revision 1.2  2011/01/20 16:52:15  acg
+// Andy Goodrich: changes for IEEE 1666 2011.
+//
+//Revision 1.1.1.1  2006/12/15 20:20:04  acg
+//SystemC 2.3
+//
+//Revision 1.3  2006/05/08 17:52:47  acg
+// Andy Goodrich:
+//   (1) added David Long's forward declarations for friend functions,
+//       methods, and operators to keep the Microsoft compiler happy.
+//   (2) Added delta_count() method to sc_prim_channel for use by
+//       sc_signal so that the friend declaration in sc_simcontext.h
+//	   can be for a non-templated class (i.e., sc_prim_channel.)
+//
+//Revision 1.2  2006/01/03 23:18:26  acg
+//Changed copyright to include 2006.
+//
+//Revision 1.1.1.1  2005/12/19 23:16:43  acg
+//First check in of SystemC 2.1 into its own archive.
+//
+//Revision 1.10  2005/07/30 03:44:11  acg
+//Changes from 2.1.
+//
+//Revision 1.9  2005/06/10 22:43:55  acg
+//Added CVS change log annotation.
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_semaphore.cpp b/ext/systemc/src/sysc/communication/sc_semaphore.cpp
new file mode 100644
index 000000000..d90424431
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_semaphore.cpp
@@ -0,0 +1,148 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_semaphore.cpp -- The sc_semaphore primitive channel class.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#include "sysc/communication/sc_communication_ids.h"
+#include "sysc/communication/sc_semaphore.h"
+#include "sysc/kernel/sc_simcontext.h"
+#include "sysc/kernel/sc_wait.h"
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_semaphore
+//
+//  The sc_semaphore primitive channel class.
+// ----------------------------------------------------------------------------
+
+// error reporting
+
+void
+sc_semaphore::report_error( const char* id, const char* add_msg ) const
+{
+    char msg[BUFSIZ];
+    if( add_msg != 0 ) {
+	std::sprintf( msg, "%s: semaphore '%s'", add_msg, name() );
+    } else {
+	std::sprintf( msg, "semaphore '%s'", name() );
+    }
+    SC_REPORT_ERROR( id, msg );
+}
+
+
+// constructors
+
+sc_semaphore::sc_semaphore( int init_value_ )
+: sc_object( sc_gen_unique_name( "semaphore" ) ),
+  m_free( (std::string(SC_KERNEL_EVENT_PREFIX)+"_free_event").c_str() ),
+  m_value( init_value_ )
+{
+    if( m_value < 0 ) {
+	report_error( SC_ID_INVALID_SEMAPHORE_VALUE_ );
+    }
+}
+
+sc_semaphore::sc_semaphore( const char* name_, int init_value_ )
+: sc_object( name_ ), 
+  m_free( (std::string(SC_KERNEL_EVENT_PREFIX)+"_free_event").c_str() ),
+  m_value( init_value_ )
+{
+    if( m_value < 0 ) {
+	report_error( SC_ID_INVALID_SEMAPHORE_VALUE_ );
+    }
+}
+
+
+// interface methods
+
+// lock (take) the semaphore, block if not available
+
+int
+sc_semaphore::wait()
+{
+    while( in_use() ) {
+	sc_core::wait( m_free, sc_get_curr_simcontext() );
+    }
+    -- m_value;
+    return 0;
+}
+
+
+// lock (take) the semaphore, return -1 if not available
+
+int
+sc_semaphore::trywait()
+{
+    if( in_use() ) {
+	return -1;
+    }
+    -- m_value;
+    return 0;
+}
+
+
+// unlock (give) the semaphore
+
+int
+sc_semaphore::post()
+{
+    ++m_value;
+    m_free.notify();
+    return 0;
+}
+
+} // namespace sc_core
+
+// $Log: sc_semaphore.cpp,v $
+// Revision 1.5  2011/08/26 20:45:42  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.4  2011/03/23 16:17:22  acg
+//  Andy Goodrich: hide the sc_events that are kernel related.
+//
+// Revision 1.3  2011/02/18 20:23:45  acg
+//  Andy Goodrich: Copyright update.
+//
+// Revision 1.2  2010/11/02 16:31:01  acg
+//  Andy Goodrich: changed object derivation to use sc_object rather than
+//  sc_prim_channel as the parent class.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.6  2006/11/28 20:30:49  acg
+//  Andy Goodrich: updated from 2.2 source. sc_event_queue constructors
+//  collapsed into a single constructor with an optional argument to get
+//  the sc_module_name stack done correctly. Class name prefixing added
+//  to sc_semaphore calls to wait() to keep gcc 4.x happy.
+//
+// Revision 1.3  2006/01/13 18:47:42  acg
+// Added $Log command so that CVS comments are reproduced in the source.
+//
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_semaphore.h b/ext/systemc/src/sysc/communication/sc_semaphore.h
new file mode 100644
index 000000000..3ce991ebf
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_semaphore.h
@@ -0,0 +1,133 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_semaphore.h -- The sc_semaphore primitive channel class.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_SEMAPHORE_H
+#define SC_SEMAPHORE_H
+
+
+#include "sysc/kernel/sc_event.h"
+#include "sysc/kernel/sc_object.h"
+#include "sysc/communication/sc_semaphore_if.h"
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_semaphore
+//
+//  The sc_semaphore primitive channel class.
+// ----------------------------------------------------------------------------
+
+class sc_semaphore
+: public sc_semaphore_if,
+  public sc_object
+{
+public:
+
+    // constructors
+
+    explicit sc_semaphore( int init_value_ );
+    sc_semaphore( const char* name_, int init_value_ );
+
+
+    // interface methods
+
+    // lock (take) the semaphore, block if not available
+    virtual int wait();
+
+    // lock (take) the semaphore, return -1 if not available
+    virtual int trywait();
+
+    // unlock (give) the semaphore
+    virtual int post();
+
+    // get the value of the semaphore
+    virtual int get_value() const
+	{ return m_value; }
+
+    virtual const char* kind() const
+        { return "sc_semaphore"; }
+
+protected:
+
+    // support methods
+
+    bool in_use() const
+	{ return ( m_value <= 0 ); }
+
+
+    // error reporting
+    void report_error( const char* id, const char* add_msg = 0 ) const;
+
+protected:
+
+    sc_event m_free;        // event to block on when m_value is negative
+    int      m_value;       // current value of the semaphore
+
+private:
+
+    // disabled
+    sc_semaphore( const sc_semaphore& );
+    sc_semaphore& operator = ( const sc_semaphore& );
+};
+
+} // namespace sc_core
+
+//$Log: sc_semaphore.h,v $
+//Revision 1.4  2011/08/26 20:45:42  acg
+// Andy Goodrich: moved the modification log to the end of the file to
+// eliminate source line number skew when check-ins are done.
+//
+//Revision 1.3  2011/02/18 20:23:45  acg
+// Andy Goodrich: Copyright update.
+//
+//Revision 1.2  2010/11/02 16:31:01  acg
+// Andy Goodrich: changed object derivation to use sc_object rather than
+// sc_prim_channel as the parent class.
+//
+//Revision 1.1.1.1  2006/12/15 20:20:04  acg
+//SystemC 2.3
+//
+//Revision 1.4  2006/11/28 20:30:49  acg
+// Andy Goodrich: updated from 2.2 source. sc_event_queue constructors
+// collapsed into a single constructor with an optional argument to get
+// the sc_module_name stack done correctly. Class name prefixing added
+// to sc_semaphore calls to wait() to keep gcc 4.x happy.
+//
+//Revision 1.2  2006/01/03 23:18:26  acg
+//Changed copyright to include 2006.
+//
+//Revision 1.1.1.1  2005/12/19 23:16:43  acg
+//First check in of SystemC 2.1 into its own archive.
+//
+//Revision 1.9  2005/06/10 22:43:55  acg
+//Added CVS change log annotation.
+//
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_semaphore_if.h b/ext/systemc/src/sysc/communication/sc_semaphore_if.h
new file mode 100644
index 000000000..b0839e40a
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_semaphore_if.h
@@ -0,0 +1,100 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_semaphore_if.h -- The sc_semaphore_if interface class.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_SEMAPHORE_IF_H
+#define SC_SEMAPHORE_IF_H
+
+#include "sysc/communication/sc_interface.h"
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_semaphore_if
+//
+//  The sc_semaphore_if interface class.
+// ----------------------------------------------------------------------------
+
+class sc_semaphore_if
+: virtual public sc_interface
+{
+public:
+
+    // the classical operations: wait(), trywait(), and post()
+
+    // lock (take) the semaphore, block if not available
+    virtual int wait() = 0;
+
+    // lock (take) the semaphore, return -1 if not available
+    virtual int trywait() = 0;
+
+    // unlock (give) the semaphore
+    virtual int post() = 0;
+
+    // get the value of the semphore
+    virtual int get_value() const = 0;
+
+protected:
+
+    // constructor
+
+    sc_semaphore_if()
+	{}
+
+private:
+
+    // disabled
+    sc_semaphore_if( const sc_semaphore_if& );
+    sc_semaphore_if& operator = ( const sc_semaphore_if& );
+};
+
+} // namespace sc_core
+
+//$Log: sc_semaphore_if.h,v $
+//Revision 1.3  2011/08/26 20:45:42  acg
+// Andy Goodrich: moved the modification log to the end of the file to
+// eliminate source line number skew when check-ins are done.
+//
+//Revision 1.2  2011/02/18 20:23:45  acg
+// Andy Goodrich: Copyright update.
+//
+//Revision 1.1.1.1  2006/12/15 20:20:04  acg
+//SystemC 2.3
+//
+//Revision 1.2  2006/01/03 23:18:26  acg
+//Changed copyright to include 2006.
+//
+//Revision 1.1.1.1  2005/12/19 23:16:43  acg
+//First check in of SystemC 2.1 into its own archive.
+//
+//Revision 1.8  2005/06/10 22:43:55  acg
+//Added CVS change log annotation.
+//
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_signal.cpp b/ext/systemc/src/sysc/communication/sc_signal.cpp
new file mode 100644
index 000000000..3b2df8a7c
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_signal.cpp
@@ -0,0 +1,456 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_signal.cpp -- The sc_signal<T> primitive channel class.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#include "sysc/communication/sc_communication_ids.h"
+#include "sysc/utils/sc_utils_ids.h"
+#include "sysc/communication/sc_signal.h"
+#include "sysc/datatypes/int/sc_signed.h"
+#include "sysc/datatypes/int/sc_unsigned.h"
+#include "sysc/datatypes/bit/sc_lv_base.h"
+#include "sysc/kernel/sc_reset.h"
+
+#include <sstream>
+
+using sc_dt::sc_lv_base;
+using sc_dt::sc_signed;
+using sc_dt::sc_unsigned;
+using sc_dt::int64;
+using sc_dt::uint64;
+
+namespace sc_core {
+
+// to avoid code bloat in sc_signal<T>
+
+void
+sc_signal_invalid_writer( sc_object* target, sc_object* first_writer,
+                          sc_object* second_writer, bool check_delta )
+{
+    if ( second_writer )
+    {   
+        std::stringstream msg;
+
+        msg
+            << "\n signal "
+               "`" << target->name() << "' "
+               "(" << target->kind() << ")"
+            << "\n first driver "
+               "`" << first_writer->name() << "' "
+              " (" << first_writer->kind() << ")"
+            << "\n second driver "
+               "`" << second_writer->name() << "' "
+               "(" << second_writer->kind() << ")";
+
+        if( check_delta )
+        {
+            msg << "\n first conflicting write in delta cycle "
+                << sc_delta_count();
+        }
+        SC_REPORT_ERROR( SC_ID_MORE_THAN_ONE_SIGNAL_DRIVER_,
+                         msg.str().c_str() );
+    }
+}
+
+bool
+sc_writer_policy_check_port::
+  check_port( sc_object* target, sc_port_base * port_, bool is_output )
+{
+    if ( is_output && sc_get_curr_simcontext()->write_check() )
+    {
+        // an out or inout port; only one can be connected
+        if( m_output != 0) {
+            sc_signal_invalid_writer( target, m_output, port_, false );
+            return false;
+        } else {
+            m_output = port_;
+        }
+    }
+    return true;
+}
+
+void sc_deprecated_get_data_ref()
+{
+    static bool warn_get_data_ref_deprecated=true;
+    if ( warn_get_data_ref_deprecated )
+    {
+        warn_get_data_ref_deprecated=false;
+	SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
+	    "get_data_ref() is deprecated, use read() instead" );
+    }
+}
+
+void sc_deprecated_get_new_value()
+{
+    static bool warn_new_value=true;
+    if ( warn_new_value )
+    {
+        warn_new_value=false;
+	SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
+	    "sc_signal<T>::get_new_value() is deprecated");
+    }
+}
+
+void sc_deprecated_trace()
+{
+    static bool warn_trace_deprecated=true;
+    if ( warn_trace_deprecated )
+    {
+        warn_trace_deprecated=false;
+	SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
+	    "sc_signal<T>::trace() is deprecated");
+    }
+}
+
+sc_event*
+sc_lazy_kernel_event( sc_event** ev, const char* name )
+{
+    if ( !*ev ) {
+        std::string kernel_name = SC_KERNEL_EVENT_PREFIX "_";
+        kernel_name.append( name );
+        *ev = new sc_event( kernel_name.c_str() );
+    }
+    return *ev;
+
+}
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+template< sc_writer_policy POL >
+void
+sc_signal<bool,POL>::register_port( sc_port_base& port_,
+                                    const char* if_typename_ )
+{
+    bool is_output = std::string( if_typename_ ) == typeid(if_type).name();
+    if( !policy_type::check_port( this, &port_, is_output ) )
+       ((void)0); // fallback? error has been suppressed ...
+}
+
+
+// write the new value
+
+template< sc_writer_policy POL >
+void
+sc_signal<bool,POL>::write( const bool& value_ )
+{
+    bool value_changed = !( m_cur_val == value_ );
+    if ( !policy_type::check_write(this, value_changed) )
+        return;
+    m_new_val = value_;
+    if( value_changed ) {
+        request_update();
+    }
+}
+
+template< sc_writer_policy POL >
+inline
+void
+sc_signal<bool,POL>::print( ::std::ostream& os ) const
+{
+    os << m_cur_val;
+}
+
+template< sc_writer_policy POL >
+void
+sc_signal<bool,POL>::dump( ::std::ostream& os ) const
+{
+    os << "     name = " << name() << ::std::endl;
+    os << "    value = " << m_cur_val << ::std::endl;
+    os << "new value = " << m_new_val << ::std::endl;
+}
+
+
+template< sc_writer_policy POL >
+void
+sc_signal<bool,POL>::update()
+{
+    policy_type::update();
+    if( !( m_new_val == m_cur_val ) ) {
+        do_update();
+    }
+}
+
+template< sc_writer_policy POL >
+void
+sc_signal<bool,POL>::do_update()
+{
+    // order of execution below is important, the notify_processes() call
+    // must come after the update of m_cur_val for things to work properly!
+
+    m_cur_val = m_new_val;
+
+    if ( m_reset_p ) m_reset_p->notify_processes();
+
+    if ( m_change_event_p ) m_change_event_p->notify_next_delta();
+
+    sc_event* event_p = this->m_cur_val
+                      ? m_posedge_event_p : m_negedge_event_p;
+    if ( event_p ) event_p->notify_next_delta();
+
+    m_change_stamp = simcontext()->change_stamp();
+}
+
+// (edge) event methods
+
+template< sc_writer_policy POL >
+const sc_event&
+sc_signal<bool,POL>::value_changed_event() const
+{
+    return *sc_lazy_kernel_event(&m_change_event_p,"value_changed_event");
+}
+
+template< sc_writer_policy POL >
+const sc_event&
+sc_signal<bool,POL>::posedge_event() const
+{
+    return *sc_lazy_kernel_event(&m_posedge_event_p,"posedge_event");
+}
+
+template< sc_writer_policy POL >
+const sc_event&
+sc_signal<bool,POL>::negedge_event() const
+{
+    return *sc_lazy_kernel_event(&m_negedge_event_p,"negedge_event");
+}
+
+
+// reset support:
+
+template< sc_writer_policy POL >
+sc_reset*
+sc_signal<bool,POL>::is_reset() const
+{
+    sc_reset* result_p;
+    if ( !m_reset_p ) m_reset_p = new sc_reset( this );
+    result_p = m_reset_p;
+    return result_p;
+}
+
+// destructor
+
+template< sc_writer_policy POL >
+sc_signal<bool,POL>::~sc_signal()
+{
+    delete m_change_event_p;
+    delete m_negedge_event_p;
+    delete m_posedge_event_p;
+    delete m_reset_p;
+}
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+template< sc_writer_policy POL >
+void
+sc_signal<sc_dt::sc_logic,POL>::register_port( sc_port_base& port_,
+                                               const char* if_typename_ )
+{
+    bool is_output = std::string( if_typename_ ) == typeid(if_type).name();
+    if( !policy_type::check_port( this, &port_, is_output ) )
+       ((void)0); // fallback? error has been suppressed ...
+}
+
+
+// write the new value
+
+template< sc_writer_policy POL >
+inline
+void
+sc_signal<sc_dt::sc_logic,POL>::write( const sc_dt::sc_logic& value_ )
+{
+    bool value_changed = !( m_cur_val == value_ );
+    if ( !policy_type::check_write(this, value_changed) )
+        return;
+
+    m_new_val = value_;
+    if( value_changed ) {
+        request_update();
+    }
+}
+
+template< sc_writer_policy POL >
+inline
+void
+sc_signal<sc_dt::sc_logic,POL>::print( ::std::ostream& os ) const
+{
+    os << m_cur_val;
+}
+
+template< sc_writer_policy POL >
+void
+sc_signal<sc_dt::sc_logic,POL>::dump( ::std::ostream& os ) const
+{
+    os << "     name = " << name() << ::std::endl;
+    os << "    value = " << m_cur_val << ::std::endl;
+    os << "new value = " << m_new_val << ::std::endl;
+}
+
+
+template< sc_writer_policy POL >
+void
+sc_signal<sc_dt::sc_logic,POL>::update()
+{
+    policy_type::update();
+    if( !( m_new_val == m_cur_val ) ) {
+        do_update();
+    }
+}
+
+template< sc_writer_policy POL >
+void
+sc_signal<sc_dt::sc_logic,POL>::do_update()
+{
+    m_cur_val = m_new_val;
+
+    if ( m_change_event_p ) m_change_event_p->notify_next_delta();
+
+    if( m_posedge_event_p && (this->m_cur_val == sc_dt::SC_LOGIC_1) ) {
+        m_posedge_event_p->notify_next_delta();
+    }
+    else if( m_negedge_event_p && (this->m_cur_val == sc_dt::SC_LOGIC_0) ) {
+        m_negedge_event_p->notify_next_delta();
+    }
+
+    m_change_stamp = simcontext()->change_stamp();
+}
+
+// (edge) event methods
+
+template< sc_writer_policy POL >
+const sc_event&
+sc_signal<sc_dt::sc_logic,POL>::value_changed_event() const
+{
+    return *sc_lazy_kernel_event(&m_change_event_p,"value_changed_event");
+}
+
+template< sc_writer_policy POL >
+const sc_event&
+sc_signal<sc_dt::sc_logic,POL>::posedge_event() const
+{
+    return *sc_lazy_kernel_event(&m_posedge_event_p,"posedge_event");
+}
+
+template< sc_writer_policy POL >
+const sc_event&
+sc_signal<sc_dt::sc_logic,POL>::negedge_event() const
+{
+    return *sc_lazy_kernel_event(&m_negedge_event_p,"negedge_event");
+}
+
+
+// template instantiations for writer policies
+
+template class sc_signal<bool,SC_ONE_WRITER>;
+template class sc_signal<bool,SC_MANY_WRITERS>;
+template class sc_signal<bool,SC_UNCHECKED_WRITERS>;
+
+template class sc_signal<sc_dt::sc_logic,SC_ONE_WRITER>;
+template class sc_signal<sc_dt::sc_logic,SC_MANY_WRITERS>;
+template class sc_signal<sc_dt::sc_logic,SC_UNCHECKED_WRITERS>;
+
+} // namespace sc_core
+
+/* 
+$Log: sc_signal.cpp,v $
+Revision 1.9  2011/08/26 20:45:42  acg
+ Andy Goodrich: moved the modification log to the end of the file to
+ eliminate source line number skew when check-ins are done.
+
+Revision 1.8  2011/02/18 20:23:45  acg
+ Andy Goodrich: Copyright update.
+
+Revision 1.7  2011/02/18 20:08:14  acg
+ Philipp A. Hartmann: addition of include for sstream for MSVC.
+
+Revision 1.6  2011/01/25 20:50:37  acg
+ Andy Goodrich: changes for IEEE 1666 2011.
+
+Revision 1.5  2010/12/07 19:50:36  acg
+ Andy Goodrich: addition of writer policies, courtesy of Philipp Hartmann.
+
+Revision 1.3  2007/04/09 21:59:49  acg
+ Andy Goodrich: fixed multiple write notification bug where writes
+ done outside the simulator were being treated as multiple writes.
+
+Revision 1.2  2007/04/02 17:24:01  acg
+ Andy Goodrich: added check for null writer pointers in sc_signal invalid
+ writer method.
+
+Revision 1.1.1.1  2006/12/15 20:20:04  acg
+SystemC 2.3
+
+Revision 1.7  2006/04/11 23:11:57  acg
+  Andy Goodrich: Changes for reset support that only includes
+  sc_cthread_process instances.
+
+Revision 1.6  2006/03/13 20:19:44  acg
+ Andy Goodrich: changed sc_event instances into pointers to sc_event instances
+ that are allocated as needed. This saves considerable storage for large
+ numbers of signals, etc.
+
+Revision 1.5  2006/01/25 00:31:11  acg
+ Andy Goodrich: Changed over to use a standard message id of
+ SC_ID_IEEE_1666_DEPRECATION for all deprecation messages.
+
+Revision 1.4  2006/01/24 20:46:32  acg
+Andy Goodrich: changes to eliminate use of deprecated features. For instance,
+using notify(SC_ZERO_TIME) in place of notify_delayed().
+
+Revision 1.3  2006/01/18 21:42:26  acg
+Andy Goodrich: Changes for check writer support, and tightening up sc_clock
+port usage.
+
+Revision 1.2  2006/01/03 23:18:26  acg
+Changed copyright to include 2006.
+
+Revision 1.1.1.1  2005/12/19 23:16:43  acg
+First check in of SystemC 2.1 into its own archive.
+
+Revision 1.14  2005/09/15 23:01:51  acg
+Added std:: prefix to appropriate methods and types to get around
+issues with the Edison Front End.
+
+Revision 1.13  2005/05/08 19:04:06  acg
+Fix bug in concat_set(int64,off). Other changes from 2.1 examples usage.
+
+Revision 1.12  2005/04/04 00:15:51  acg
+Changes for directory name change to sys from systemc.
+Changes for sc_string going to std::string.
+Changes for sc_pvector going to std::vector.
+Changes for reference pools for bit and part selections.
+Changes for const sc_concatref support.
+
+Revision 1.10  2005/03/21 22:31:32  acg
+Changes to sc_core namespace.
+
+Revision 1.9  2004/09/27 21:02:54  acg
+Andy Goodrich - Forte Design Systems, Inc.
+   - Added a $Log comment so that CVS checkin comments will appear in
+     checked out source.
+
+*/
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_signal.h b/ext/systemc/src/sysc/communication/sc_signal.h
new file mode 100644
index 000000000..2a72ef55e
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_signal.h
@@ -0,0 +1,741 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_signal.h -- The sc_signal<T> primitive channel class.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_SIGNAL_H
+#define SC_SIGNAL_H
+
+#include "sysc/communication/sc_port.h"
+#include "sysc/communication/sc_prim_channel.h"
+#include "sysc/communication/sc_signal_ifs.h"
+#include "sysc/communication/sc_writer_policy.h"
+#include "sysc/kernel/sc_event.h"
+#include "sysc/kernel/sc_process.h"
+#include "sysc/kernel/sc_simcontext.h"
+#include "sysc/datatypes/bit/sc_logic.h"
+#include "sysc/tracing/sc_trace.h"
+#include <typeinfo>
+
+namespace sc_core {
+
+// to avoid code bloat in sc_signal<T>
+
+extern void sc_deprecated_get_data_ref();
+extern void sc_deprecated_get_new_value();
+extern void sc_deprecated_trace();
+extern sc_event * sc_lazy_kernel_event( sc_event**, const char* name );
+
+inline
+bool
+sc_writer_policy_check_write::check_write( sc_object* target, bool )
+{
+  sc_object* writer_p = sc_get_curr_simcontext()->get_current_writer();
+  if( SC_UNLIKELY_(m_writer_p == 0) ) {
+       m_writer_p = writer_p;
+  } else if( SC_UNLIKELY_(m_writer_p != writer_p && writer_p != 0) ) {
+       sc_signal_invalid_writer( target, m_writer_p, writer_p, m_check_delta );
+       // error has been suppressed, ignore check as well
+       // return false;
+  }
+  return true;
+}
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signal<T>
+//
+//  The sc_signal<T> primitive channel class.
+// ----------------------------------------------------------------------------
+
+template< class T, sc_writer_policy POL /* = SC_DEFAULT_WRITER_POLICY */ >
+class sc_signal
+  : public    sc_signal_inout_if<T>
+  , public    sc_prim_channel
+  , protected sc_writer_policy_check<POL>
+{
+protected:
+    typedef sc_signal_inout_if<T>       if_type;
+    typedef sc_signal<T,POL>            this_type;
+    typedef sc_writer_policy_check<POL> policy_type;
+
+public: // constructors and destructor:
+
+    sc_signal()
+	: sc_prim_channel( sc_gen_unique_name( "signal" ) ),
+	  m_change_event_p( 0 ), m_cur_val( T() ), 
+	  m_change_stamp( ~sc_dt::UINT64_ONE ), m_new_val( T() )
+	{}
+
+    explicit sc_signal( const char* name_)
+	: sc_prim_channel( name_ ),
+	  m_change_event_p( 0 ), m_cur_val( T() ), 
+	  m_change_stamp( ~sc_dt::UINT64_ONE ), m_new_val( T() )
+    {}
+
+    sc_signal( const char* name_, const T& initial_value_ )
+      : sc_prim_channel( name_ )
+      , m_change_event_p( 0 )
+      , m_cur_val( initial_value_ )
+      , m_change_stamp( ~sc_dt::UINT64_ONE )
+      , m_new_val( initial_value_ )
+    {}
+
+    virtual ~sc_signal()
+	{
+	    delete m_change_event_p;
+	}
+
+
+    // interface methods
+
+    virtual void register_port( sc_port_base&, const char* );
+
+    virtual sc_writer_policy get_writer_policy() const
+      { return POL; }
+
+    // get the default event
+    virtual const sc_event& default_event() const
+      { return value_changed_event(); }
+
+    // get the value changed event
+    virtual const sc_event& value_changed_event() const
+    {
+        return *sc_lazy_kernel_event( &m_change_event_p
+                                    , "value_changed_event");
+    }
+
+
+    // read the current value
+    virtual const T& read() const
+	{ return m_cur_val; }
+
+    // get a reference to the current value (for tracing)
+    virtual const T& get_data_ref() const
+        { sc_deprecated_get_data_ref(); return m_cur_val; }
+
+
+    // was there an event?
+    virtual bool event() const
+        { return simcontext()->event_occurred(m_change_stamp); }
+
+    // write the new value
+    virtual void write( const T& );
+
+
+    // other methods
+
+    operator const T& () const
+	{ return read(); }
+
+
+    this_type& operator = ( const T& a )
+	{ write( a ); return *this; }
+
+    this_type& operator = ( const sc_signal_in_if<T>& a )
+	{ write( a.read() ); return *this; }
+
+    this_type& operator = ( const this_type& a )
+	{ write( a.read() ); return *this; }
+
+
+    const T& get_new_value() const
+        { sc_deprecated_get_new_value(); return m_new_val; }
+
+
+    void trace( sc_trace_file* tf ) const
+	{ 
+	    sc_deprecated_trace();
+#           ifdef DEBUG_SYSTEMC
+	        sc_trace( tf, read(), name() ); 
+#           else
+                if ( tf ) {}
+#	    endif
+	}
+
+
+    virtual void print( ::std::ostream& = ::std::cout ) const;
+    virtual void dump( ::std::ostream& = ::std::cout ) const;
+
+    virtual const char* kind() const
+        { return "sc_signal"; }
+
+protected:
+
+    virtual void update();
+            void do_update();
+
+protected:
+
+    mutable sc_event*  m_change_event_p;
+    T                  m_cur_val;
+    sc_dt::uint64      m_change_stamp;   // delta of last event
+    T                  m_new_val;
+
+private:
+
+    // disabled
+    sc_signal( const this_type& );
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+
+template< class T, sc_writer_policy POL >
+inline
+void
+sc_signal<T,POL>::register_port( sc_port_base& port_
+                               , const char* if_typename_ )
+{
+
+    bool is_output = std::string( if_typename_ ) == typeid(if_type).name();
+    if( !policy_type::check_port( this, &port_, is_output ) )
+       ((void)0); // fallback? error has been suppressed ...
+}
+
+
+// write the new value
+
+template< class T, sc_writer_policy POL >
+inline
+void
+sc_signal<T,POL>::write( const T& value_ )
+{
+    bool value_changed = !( m_cur_val == value_ );
+    if ( !policy_type::check_write(this, value_changed) )
+        return;
+
+    m_new_val = value_;
+    if( value_changed ) {
+        request_update();
+    }
+}
+
+
+template< class T, sc_writer_policy POL >
+inline
+void
+sc_signal<T,POL>::print( ::std::ostream& os ) const
+{
+    os << m_cur_val;
+}
+
+template< class T, sc_writer_policy POL >
+void
+sc_signal<T,POL>::dump( ::std::ostream& os ) const
+{
+    os << "     name = " << name() << ::std::endl;
+    os << "    value = " << m_cur_val << ::std::endl;
+    os << "new value = " << m_new_val << ::std::endl;
+}
+
+
+template< class T, sc_writer_policy POL >
+void
+sc_signal<T,POL>::update()
+{
+    policy_type::update();
+    if( !( m_new_val == m_cur_val ) ) {
+        do_update();
+    }
+}
+
+template< class T, sc_writer_policy POL >
+void
+sc_signal<T,POL>::do_update()
+{
+    m_cur_val = m_new_val;
+    if ( m_change_event_p ) m_change_event_p->notify_next_delta();
+    m_change_stamp = simcontext()->change_stamp();
+}
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signal<bool>
+//
+//  Specialization of sc_signal<T> for type bool.
+// ----------------------------------------------------------------------------
+
+class sc_reset;
+
+template< sc_writer_policy POL >
+class sc_signal<bool,POL>
+  : public    sc_signal_inout_if<bool>
+  , public    sc_prim_channel
+  , protected sc_writer_policy_check<POL>
+{
+protected:
+    typedef sc_signal_inout_if<bool>    if_type;
+    typedef sc_signal<bool,POL>         this_type;
+    typedef sc_writer_policy_check<POL> policy_type;
+
+public: // constructors and destructor:
+
+    sc_signal()
+	: sc_prim_channel( sc_gen_unique_name( "signal" ) ),
+	  m_change_event_p( 0 ),
+          m_cur_val( false ),
+          m_change_stamp( ~sc_dt::UINT64_ONE ),
+	  m_negedge_event_p( 0 ),
+          m_new_val( false ),
+	  m_posedge_event_p( 0 ),
+          m_reset_p( 0 )
+	{}
+
+    explicit sc_signal( const char* name_ )
+	: sc_prim_channel( name_ ),
+	  m_change_event_p( 0 ),
+          m_cur_val( false ),
+          m_change_stamp( ~sc_dt::UINT64_ONE ),
+	  m_negedge_event_p( 0 ),
+          m_new_val( false ),
+	  m_posedge_event_p( 0 ),
+          m_reset_p( 0 )
+	{}
+
+    sc_signal( const char* name_, bool initial_value_ )
+      : sc_prim_channel( name_ )
+      , m_change_event_p( 0 )
+      , m_cur_val( initial_value_ )
+      , m_change_stamp( ~sc_dt::UINT64_ONE )
+      , m_negedge_event_p( 0 )
+      , m_new_val( initial_value_ )
+      , m_posedge_event_p( 0 )
+      , m_reset_p( 0 )
+    {}
+
+    virtual ~sc_signal();
+
+
+    // interface methods
+
+    virtual void register_port( sc_port_base&, const char* );
+
+    virtual sc_writer_policy get_writer_policy() const
+        { return POL; }
+
+    // get the default event
+    virtual const sc_event& default_event() const
+        { return value_changed_event(); }
+
+    // get the value changed event
+    virtual const sc_event& value_changed_event() const;
+
+    // get the positive edge event
+    virtual const sc_event& posedge_event() const;
+
+    // get the negative edge event
+    virtual const sc_event& negedge_event() const;
+
+
+    // read the current value
+    virtual const bool& read() const
+	{ return m_cur_val; }
+
+    // get a reference to the current value (for tracing)
+    virtual const bool& get_data_ref() const
+        { sc_deprecated_get_data_ref(); return m_cur_val; }
+
+
+    // was there a value changed event?
+    virtual bool event() const
+        { return simcontext()->event_occurred(m_change_stamp); }
+
+    // was there a positive edge event?
+    virtual bool posedge() const
+	{ return ( event() && m_cur_val ); }
+
+    // was there a negative edge event?
+    virtual bool negedge() const
+	{ return ( event() && ! m_cur_val ); }
+
+    // write the new value
+    virtual void write( const bool& );
+
+    // other methods
+
+    operator const bool& () const
+	{ return read(); }
+
+
+    this_type& operator = ( const bool& a )
+	{ write( a ); return *this; }
+
+    this_type& operator = ( const sc_signal_in_if<bool>& a )
+	{ write( a.read() ); return *this; }
+
+    this_type& operator = ( const this_type& a )
+	{ write( a.read() ); return *this; }
+
+
+    const bool& get_new_value() const
+	{ sc_deprecated_get_new_value(); return m_new_val; }
+
+
+    void trace( sc_trace_file* tf ) const
+	{
+	    sc_deprecated_trace();
+#           ifdef DEBUG_SYSTEMC
+	        sc_trace( tf, read(), name() ); 
+#           else
+                if ( tf ) {}
+#           endif
+	}
+
+
+    virtual void print( ::std::ostream& = ::std::cout ) const;
+    virtual void dump( ::std::ostream& = ::std::cout ) const;
+
+    virtual const char* kind() const
+        { return "sc_signal"; }
+
+protected:
+
+    virtual void update();
+            void do_update();
+
+    virtual bool is_clock() const { return false; }
+
+protected:
+    mutable sc_event* m_change_event_p;  // value change event if present.
+    bool              m_cur_val;         // current value of object.
+    sc_dt::uint64     m_change_stamp;    // delta of last event
+    mutable sc_event* m_negedge_event_p; // negative edge event if present.
+    bool              m_new_val;         // next value of object.
+    mutable sc_event* m_posedge_event_p; // positive edge event if present.
+    mutable sc_reset* m_reset_p;         // reset mechanism if present.
+
+private:
+
+    // reset creation
+    virtual sc_reset* is_reset() const;
+
+    // disabled
+    sc_signal( const this_type& );
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signal<sc_dt::sc_logic>
+//
+//  Specialization of sc_signal<T> for type sc_dt::sc_logic.
+// ----------------------------------------------------------------------------
+
+template< sc_writer_policy POL >
+class sc_signal<sc_dt::sc_logic,POL>
+  : public    sc_signal_inout_if<sc_dt::sc_logic>
+  , public    sc_prim_channel
+  , protected sc_writer_policy_check<POL>
+{
+protected:
+    typedef sc_signal_inout_if<sc_dt::sc_logic> if_type;
+    typedef sc_signal<sc_dt::sc_logic,POL>      this_type;
+    typedef sc_writer_policy_check<POL>         policy_type;
+
+public: // constructors and destructor:
+
+    sc_signal()
+	: sc_prim_channel( sc_gen_unique_name( "signal" ) ),
+	  m_change_event_p( 0 ),
+	  m_cur_val(),
+          m_change_stamp( ~sc_dt::UINT64_ONE ),
+	  m_negedge_event_p( 0 ),
+	  m_new_val(),
+	  m_posedge_event_p( 0 )
+	{}
+
+    explicit sc_signal( const char* name_ )
+	: sc_prim_channel( name_ ),
+	  m_change_event_p( 0 ),
+	  m_cur_val(),
+          m_change_stamp( ~sc_dt::UINT64_ONE ),
+	  m_negedge_event_p( 0 ),
+	  m_new_val(),
+	  m_posedge_event_p( 0 )
+	{}
+
+    sc_signal( const char* name_, sc_dt::sc_logic initial_value_ )
+      : sc_prim_channel( name_ )
+      , m_change_event_p( 0 )
+      , m_cur_val( initial_value_ )
+      , m_change_stamp( ~sc_dt::UINT64_ONE )
+      , m_negedge_event_p( 0 )
+      , m_new_val( initial_value_ )
+      , m_posedge_event_p( 0 )
+    {}
+
+    virtual ~sc_signal()
+	{
+	    delete m_change_event_p;
+	    delete m_negedge_event_p;
+	    delete m_posedge_event_p;
+	}
+
+
+    // interface methods
+
+    virtual void register_port( sc_port_base&, const char* );
+
+    virtual sc_writer_policy get_writer_policy() const
+        { return POL; }
+
+    // get the default event
+    virtual const sc_event& default_event() const
+        { return value_changed_event(); }
+
+    // get the value changed event
+    virtual const sc_event& value_changed_event() const;
+
+    // get the positive edge event
+    virtual const sc_event& posedge_event() const;
+
+    // get the negative edge event
+    virtual const sc_event& negedge_event() const;
+
+
+    // read the current value
+    virtual const sc_dt::sc_logic& read() const
+	{ return m_cur_val; }
+
+    // get a reference to the current value (for tracing)
+    virtual const sc_dt::sc_logic& get_data_ref() const
+        { sc_deprecated_get_data_ref(); return m_cur_val; }
+
+
+    // was there an event?
+    virtual bool event() const
+        { return simcontext()->event_occurred(m_change_stamp); }
+
+    // was there a positive edge event?
+    virtual bool posedge() const
+	{ return ( event() && m_cur_val == sc_dt::SC_LOGIC_1 ); }
+
+    // was there a negative edge event?
+    virtual bool negedge() const
+	{ return ( event() && m_cur_val == sc_dt::SC_LOGIC_0 ); }
+
+
+    // write the new value
+    virtual void write( const sc_dt::sc_logic& );
+
+
+    // other methods
+
+    operator const sc_dt::sc_logic& () const
+	{ return read(); }
+
+
+    this_type& operator = ( const sc_dt::sc_logic& a )
+	{ write( a ); return *this; }
+
+    this_type& operator = ( const sc_signal_in_if<sc_dt::sc_logic>& a )
+	{ write( a.read() ); return *this; }
+
+    this_type& operator = (const this_type& a)
+	{ write( a.read() ); return *this; }
+
+
+    const sc_dt::sc_logic& get_new_value() const
+        { sc_deprecated_get_new_value();  return m_new_val; }
+
+
+    void trace( sc_trace_file* tf ) const
+	{
+	    sc_deprecated_trace();
+#           ifdef DEBUG_SYSTEMC
+	        sc_trace( tf, read(), name() ); 
+#           else
+                if ( tf ) {}
+#           endif
+	}
+
+    virtual void print( ::std::ostream& = ::std::cout ) const;
+    virtual void dump( ::std::ostream& = ::std::cout ) const;
+
+    virtual const char* kind() const
+        { return "sc_signal"; }
+
+protected:
+
+    virtual void update();
+            void do_update();
+
+protected:
+
+    mutable sc_event* m_change_event_p;  // value change event if present.
+    sc_dt::sc_logic   m_cur_val;         // current value of object.
+    sc_dt::uint64     m_change_stamp;    // delta of last event
+    mutable sc_event* m_negedge_event_p; // negative edge event if present.
+    sc_dt::sc_logic   m_new_val;         // next value of object.
+    mutable sc_event* m_posedge_event_p; // positive edge event if present.
+
+private:
+
+    // disabled
+    sc_signal( const this_type& );
+};
+
+// ----------------------------------------------------------------------------
+
+template< typename T, sc_writer_policy POL >
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_signal<T,POL>& a )
+{
+    return ( os << a.read() );
+}
+
+
+
+} // namespace sc_core
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+    
+ *****************************************************************************/
+//$Log: sc_signal.h,v $
+//Revision 1.16  2011/08/26 20:45:42  acg
+// Andy Goodrich: moved the modification log to the end of the file to
+// eliminate source line number skew when check-ins are done.
+//
+//Revision 1.15  2011/08/15 16:43:24  acg
+// Torsten Maehne: changes to remove unused argument warnings.
+//
+//Revision 1.14  2011/06/25 17:08:38  acg
+// Andy Goodrich: Jerome Cornet's changes to use libtool to build the
+// library.
+//
+//Revision 1.13  2011/04/13 02:59:09  acg
+// Andy Goodrich: made events internal to signals into kernel events.
+//
+//Revision 1.12  2011/04/08 18:22:46  acg
+// Philipp A. Hartmann: use the context of the primitive channel to get
+// the change stamp value.
+//
+//Revision 1.11  2011/04/05 20:48:09  acg
+// Andy Goodrich: changes to make sure that event(), posedge() and negedge()
+// only return true if the clock has not moved.
+//
+//Revision 1.10  2011/04/05 07:10:55  acg
+// Andy Goodrich: added line that I dropped in sc_signal<sc_dt::sc_logic>.
+//
+//Revision 1.9  2011/04/05 06:15:18  acg
+// Philipp A. Hartmann: sc_writer_policy: ignore no-ops in delta check.
+//
+//Revision 1.8  2011/03/23 16:17:22  acg
+// Andy Goodrich: hide the sc_events that are kernel related.
+//
+//Revision 1.7  2011/03/06 15:55:08  acg
+// Andy Goodrich: Changes for named events.
+//
+//Revision 1.6  2011/02/18 20:23:45  acg
+// Andy Goodrich: Copyright update.
+//
+//Revision 1.5  2011/02/07 19:16:50  acg
+// Andy Goodrich: changes for handling multiple writers.
+//
+//Revision 1.4  2011/01/25 20:50:37  acg
+// Andy Goodrich: changes for IEEE 1666 2011.
+//
+//Revision 1.3  2010/12/07 19:50:37  acg
+// Andy Goodrich: addition of writer policies, courtesy of Philipp Hartmann.
+//
+//Revision 1.1.1.1  2006/12/15 20:20:04  acg
+//SystemC 2.3
+//
+//Revision 1.14  2006/05/08 17:52:47  acg
+// Andy Goodrich:
+//   (1) added David Long's forward declarations for friend functions,
+//       methods, and operators to keep the Microsoft compiler happy.
+//   (2) Added delta_count() method to sc_prim_channel for use by
+//       sc_signal so that the friend declaration in sc_simcontext.h
+//	   can be for a non-templated class (i.e., sc_prim_channel.)
+//
+//Revision 1.12  2006/04/11 23:11:57  acg
+//  Andy Goodrich: Changes for reset support that only includes
+//  sc_cthread_process instances.
+//
+//Revision 1.11  2006/03/13 20:19:44  acg
+// Andy Goodrich: changed sc_event instances into pointers to sc_event instances
+// that are allocated as needed. This saves considerable storage for large
+// numbers of signals, etc.
+//
+//Revision 1.10  2006/01/26 21:00:50  acg
+// Andy Goodrich: conversion to use sc_event::notify(SC_ZERO_TIME) instead of
+// sc_event::notify_delayed()
+//
+//Revision 1.9  2006/01/24 20:45:41  acg
+//Andy Goodrich: converted notify_delayed() calls into notify_next_delta() calls
+//to eliminate deprecation warnings. notify_next_delta() is an implemenation-
+//dependent method of sc_event. It is simpler than notify_delayed(), and should
+//speed up simulation speeds.
+//
+//Revision 1.8  2006/01/19 19:18:25  acg
+//Andy Goodrich: eliminated check_writer in favor of inline code within the
+//write() method since we always execute the check_writer code even when
+//check writing is turned off.
+//
+//Revision 1.7  2006/01/19 00:30:57  acg
+//Andy Goodrich: Yet another implementation for disabling write checks on
+//signals. This version uses an environment variable, SC_SIGNAL_WRITE_CHECK,
+//that when set to DISABLE will turn off write checking.
+//
+//Revision 1.6  2006/01/18 21:42:26  acg
+//Andy Goodrich: Changes for check writer support, and tightening up sc_clock
+//port usage.
+//
+//Revision 1.5  2006/01/13 20:41:59  acg
+//Andy Goodrich: Changes to add port registration to the things that are
+//checked when SC_NO_WRITE_CHECK is not defined.
+//
+//Revision 1.4  2006/01/13 18:47:20  acg
+//Reversed sense of multiwriter signal check. It now defaults to ON unless the
+//user defines SC_NO_WRITE_CHEK before inclusion of the file.
+//
+//Revision 1.3  2006/01/03 23:18:26  acg
+//Changed copyright to include 2006.
+//
+//Revision 1.2  2005/12/20 21:58:18  acg
+//Removed Makefile.in, changed the event() methods to use sc_simcontext::event_occurred.
+//
+//Revision 1.1.1.1  2005/12/19 23:16:43  acg
+//First check in of SystemC 2.1 into its own archive.
+//
+//Revision 1.19  2005/09/15 23:01:51  acg
+//Added std:: prefix to appropriate methods and types to get around
+//issues with the Edison Front End.
+//
+//Revision 1.18  2005/06/10 22:43:55  acg
+//Added CVS change log annotation.
+//
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_signal_ifs.h b/ext/systemc/src/sysc/communication/sc_signal_ifs.h
new file mode 100644
index 000000000..ad703aaa7
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_signal_ifs.h
@@ -0,0 +1,305 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_signal_ifs.h -- The sc_signal<T> interface classes.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_SIGNAL_IFS_H
+#define SC_SIGNAL_IFS_H
+
+
+#include "sysc/communication/sc_interface.h"
+#include "sysc/communication/sc_writer_policy.h"
+
+
+namespace sc_dt
+{
+    class sc_logic;
+}
+
+namespace sc_core {
+
+class sc_signal_bool_deval;
+class sc_signal_logic_deval;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signal_in_if<T>
+//
+//  The sc_signal<T> input interface class.
+// ----------------------------------------------------------------------------
+
+template <class T>
+class sc_signal_in_if
+: virtual public sc_interface
+{
+public:
+
+    // get the value changed event
+    virtual const sc_event& value_changed_event() const = 0;
+
+
+    // read the current value
+    virtual const T& read() const = 0;
+
+    // get a reference to the current value (for tracing)
+    virtual const T& get_data_ref() const = 0;
+
+
+    // was there a value changed event?
+    virtual bool event() const = 0;
+
+protected:
+
+    // constructor
+
+    sc_signal_in_if()
+	{}
+
+private:
+
+    // disabled
+    sc_signal_in_if( const sc_signal_in_if<T>& );
+    sc_signal_in_if<T>& operator = ( const sc_signal_in_if<T>& );
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signal_in_if<bool>
+//
+//  Specialization of sc_signal_in_if<T> for type bool.
+// ----------------------------------------------------------------------------
+
+class sc_reset;
+
+template <>
+class sc_signal_in_if<bool>
+: virtual public sc_interface
+{
+    friend class sc_reset;
+public:
+
+    // get the value changed event
+    virtual const sc_event& value_changed_event() const = 0;
+
+    // get the positive edge event
+    virtual const sc_event& posedge_event() const = 0;
+
+    // get the negative edge event
+    virtual const sc_event& negedge_event() const = 0;
+
+
+    // read the current value
+    virtual const bool& read() const = 0;
+
+    // get a reference to the current value (for tracing)
+    virtual const bool& get_data_ref() const = 0;
+
+
+    // was there a value changed event?
+    virtual bool event() const = 0;
+
+    // was there a positive edge event?
+    virtual bool posedge() const = 0;
+
+    // was there a negative edge event?
+    virtual bool negedge() const = 0;
+
+protected:
+
+    // constructor
+
+    sc_signal_in_if()
+	{}
+
+private:
+
+    // disabled
+    sc_signal_in_if( const sc_signal_in_if<bool>& );
+    sc_signal_in_if<bool>& operator = ( const sc_signal_in_if<bool>& );
+
+    // designate this object as a reset signal
+    virtual sc_reset* is_reset() const
+      { return NULL; }
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signal_in_if<sc_dt::sc_logic>
+//
+//  Specialization of sc_signal_in_if<T> for type sc_dt::sc_logic.
+// ----------------------------------------------------------------------------
+
+template <>
+class sc_signal_in_if<sc_dt::sc_logic>
+: virtual public sc_interface
+{
+public:
+
+    // get the value changed event
+    virtual const sc_event& value_changed_event() const = 0;
+
+    // get the positive edge event
+    virtual const sc_event& posedge_event() const = 0;
+
+    // get the negative edge event
+    virtual const sc_event& negedge_event() const = 0;
+
+
+    // read the current value
+    virtual const sc_dt::sc_logic& read() const = 0;
+
+    // get a reference to the current value (for tracing)
+    virtual const sc_dt::sc_logic& get_data_ref() const = 0;
+
+
+    // was there a value changed event?
+    virtual bool event() const = 0;
+
+    // was there a positive edge event?
+    virtual bool posedge() const = 0;
+
+    // was there a negative edge event?
+    virtual bool negedge() const = 0;
+
+
+protected:
+
+    // constructor
+
+    sc_signal_in_if()
+	{}
+
+private:
+
+    // disabled
+    sc_signal_in_if( const sc_signal_in_if<sc_dt::sc_logic>& );
+    sc_signal_in_if<sc_dt::sc_logic>& operator = (
+	const sc_signal_in_if<sc_dt::sc_logic>& );
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signal_write_if<T>
+//
+//  The standard output interface class.
+// ----------------------------------------------------------------------------
+template< typename T >
+class sc_signal_write_if : public virtual sc_interface
+{
+public:
+    sc_signal_write_if() {}
+    // write the new value
+    virtual void write( const T& ) = 0;
+    virtual sc_writer_policy get_writer_policy() const
+        { return SC_DEFAULT_WRITER_POLICY; }
+private:
+    // disabled
+    sc_signal_write_if( const sc_signal_write_if<T>& );
+    sc_signal_write_if<T>& operator = ( const sc_signal_write_if<T>& );
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signal_inout_if<T>
+//
+//  The sc_signal<T> input/output interface class.
+// ----------------------------------------------------------------------------
+
+template <class T>
+class sc_signal_inout_if
+: public sc_signal_in_if<T>, public sc_signal_write_if<T>
+{
+
+protected:
+
+    // constructor
+
+    sc_signal_inout_if()
+	{}
+
+private:
+
+    // disabled
+    sc_signal_inout_if( const sc_signal_inout_if<T>& );
+    sc_signal_inout_if<T>& operator = ( const sc_signal_inout_if<T>& );
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signal_out_if<T>
+//
+//  The sc_signal<T> output interface class.
+// ----------------------------------------------------------------------------
+
+// sc_signal_out_if can also be read from, hence no difference with
+// sc_signal_inout_if.
+
+#define sc_signal_out_if sc_signal_inout_if
+
+} // namespace sc_core
+
+//$Log: sc_signal_ifs.h,v $
+//Revision 1.4  2011/08/26 20:45:43  acg
+// Andy Goodrich: moved the modification log to the end of the file to
+// eliminate source line number skew when check-ins are done.
+//
+//Revision 1.3  2011/02/18 20:23:45  acg
+// Andy Goodrich: Copyright update.
+//
+//Revision 1.2  2010/12/07 19:50:37  acg
+// Andy Goodrich: addition of writer policies, courtesy of Philipp Hartmann.
+//
+//Revision 1.1.1.1  2006/12/15 20:20:04  acg
+//SystemC 2.3
+//
+//Revision 1.4  2006/08/29 23:35:00  acg
+// Andy Goodrich: added bind_count() method to allow users to determine which
+// ports are connected in before_end_of_elaboration().
+//
+//Revision 1.3  2006/04/11 23:11:57  acg
+//  Andy Goodrich: Changes for reset support that only includes
+//  sc_cthread_process instances.
+//
+//Revision 1.2  2006/01/03 23:18:26  acg
+//Changed copyright to include 2006.
+//
+//Revision 1.1.1.1  2005/12/19 23:16:43  acg
+//First check in of SystemC 2.1 into its own archive.
+//
+//Revision 1.10  2005/09/15 23:01:51  acg
+//Added std:: prefix to appropriate methods and types to get around
+//issues with the Edison Front End.
+//
+//Revision 1.9  2005/06/29 18:12:12  acg
+//Added $log.
+//
+//Revision 1.8  2005/06/10 22:43:55  acg
+//Added CVS change log annotation.
+//
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_signal_ports.cpp b/ext/systemc/src/sysc/communication/sc_signal_ports.cpp
new file mode 100644
index 000000000..d3a182e54
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_signal_ports.cpp
@@ -0,0 +1,441 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_signal_ports.cpp -- The sc_signal<T> port classes.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-08-20
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#include "sysc/communication/sc_signal_ports.h"
+#include "sysc/datatypes/int/sc_signed.h"
+#include "sysc/datatypes/int/sc_unsigned.h"
+#include "sysc/datatypes/bit/sc_lv_base.h"
+#include "sysc/utils/sc_utils_ids.h"
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_in<bool>
+//
+//  Specialization of sc_in<T> for type bool.
+// ----------------------------------------------------------------------------
+
+// called when elaboration is done
+
+void
+sc_in<bool>::end_of_elaboration()
+{
+    if( m_traces != 0 ) {
+	for( int i = 0; i < (int)m_traces->size(); ++ i ) {
+	    sc_trace_params* p = (*m_traces)[i];
+	    in_if_type* iface = DCAST<in_if_type*>( get_interface() );
+	    sc_trace( p->tf, iface->read(), p->name );
+	}
+	remove_traces();
+    }
+}
+
+// called by sc_trace
+
+void
+sc_in<bool>::add_trace_internal(sc_trace_file* tf_, 
+	const std::string& name_) const
+{
+    if( tf_ != 0 ) {
+	if( m_traces == 0 ) {
+	    m_traces = new sc_trace_params_vec;
+	}
+	m_traces->push_back( new sc_trace_params( tf_, name_ ) );
+    }
+}
+
+void
+sc_in<bool>::add_trace(sc_trace_file* tf_, 
+	const std::string& name_) const
+{
+    sc_deprecated_add_trace();
+	add_trace_internal(tf_, name_);
+}
+
+void
+sc_in<bool>::remove_traces() const
+{
+    if( m_traces != 0 ) {
+	for( int i = m_traces->size() - 1; i >= 0; -- i ) {
+	    delete (*m_traces)[i];
+	}
+	delete m_traces;
+	m_traces = 0;
+    }
+}
+
+
+// called by pbind (for internal use only)
+
+int
+sc_in<bool>::vbind( sc_interface& interface_ )
+{
+    return sc_port_b<if_type>::vbind( interface_ );
+}
+
+int
+sc_in<bool>::vbind( sc_port_base& parent_ )
+{
+    in_port_type* in_parent = DCAST<in_port_type*>( &parent_ );
+    if( in_parent != 0 ) {
+	sc_port_base::bind( *in_parent );
+	return 0;
+    }
+    inout_port_type* inout_parent = DCAST<inout_port_type*>( &parent_ );
+    if( inout_parent != 0 ) {
+	sc_port_base::bind( *inout_parent );
+	return 0;
+    }
+    // type mismatch
+    return 2;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_in<sc_logic>
+//
+//  Specialization of sc_in<T> for type sc_logic.
+// ----------------------------------------------------------------------------
+
+// called when elaboration is done
+
+void
+sc_in<sc_dt::sc_logic>::end_of_elaboration()
+{
+    if( m_traces != 0 ) {
+	for( int i = 0; i < (int)m_traces->size(); ++ i ) {
+	    sc_trace_params* p = (*m_traces)[i];
+	    in_if_type* iface = DCAST<in_if_type*>( get_interface() );
+	    sc_trace( p->tf, iface->read(), p->name );
+	}
+	remove_traces();
+    }
+}
+
+
+// called by sc_trace
+
+void
+sc_in<sc_dt::sc_logic>::add_trace_internal( sc_trace_file* tf_, 
+    const std::string& name_ ) const
+{
+    if( tf_ != 0 ) {
+	if( m_traces == 0 ) {
+	    m_traces = new sc_trace_params_vec;
+	}
+	m_traces->push_back( new sc_trace_params( tf_, name_ ) );
+    }
+}
+
+void
+sc_in<sc_dt::sc_logic>::add_trace( sc_trace_file* tf_, 
+    const std::string& name_ ) const
+{
+    sc_deprecated_add_trace();
+    add_trace_internal(tf_, name_);
+}
+
+void
+sc_in<sc_dt::sc_logic>::remove_traces() const
+{
+    if( m_traces != 0 ) {
+	for( int i = m_traces->size() - 1; i >= 0; -- i ) {
+	    delete (*m_traces)[i];
+	}
+	delete m_traces;
+	m_traces = 0;
+    }
+}
+
+
+// called by pbind (for internal use only)
+
+int
+sc_in<sc_dt::sc_logic>::vbind( sc_interface& interface_ )
+{
+    return sc_port_b<if_type>::vbind( interface_ );
+}
+
+int
+sc_in<sc_dt::sc_logic>::vbind( sc_port_base& parent_ )
+{
+    in_port_type* in_parent = DCAST<in_port_type*>( &parent_ );
+    if( in_parent != 0 ) {
+	sc_port_base::bind( *in_parent );
+	return 0;
+    }
+    inout_port_type* inout_parent = DCAST<inout_port_type*>( &parent_ );
+    if( inout_parent != 0 ) {
+	sc_port_base::bind( *inout_parent );
+	return 0;
+    }
+    // type mismatch
+    return 2;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_inout<bool>
+//
+//  Specialization of sc_inout<T> for type bool.
+// ----------------------------------------------------------------------------
+
+// destructor
+
+sc_inout<bool>::~sc_inout()
+{
+    delete m_change_finder_p;
+    delete m_neg_finder_p;
+    delete m_pos_finder_p;
+    delete m_init_val;
+    remove_traces();
+}
+
+
+// set initial value (can also be called when port is not bound yet)
+
+void
+sc_inout<bool>::initialize( const data_type& value_ )
+{
+    inout_if_type* iface = DCAST<inout_if_type*>( get_interface() );
+    if( iface != 0 ) {
+	iface->write( value_ );
+    } else {
+	if( m_init_val == 0 ) {
+	    m_init_val = new data_type;
+	}
+	*m_init_val = value_;
+    }
+}
+
+
+// called when elaboration is done
+
+void
+sc_inout<bool>::end_of_elaboration()
+{
+    if( m_init_val != 0 ) {
+	write( *m_init_val );
+	delete m_init_val;
+	m_init_val = 0;
+    }
+    if( m_traces != 0 ) {
+	for( int i = 0; i < (int)m_traces->size(); ++ i ) {
+	    sc_trace_params* p = (*m_traces)[i];
+	    in_if_type* iface = DCAST<in_if_type*>( get_interface() );
+	    sc_trace( p->tf, iface->read(), p->name );
+	}
+	remove_traces();
+    }
+}
+
+
+// called by sc_trace
+
+void
+sc_inout<bool>::add_trace_internal( sc_trace_file* tf_, 
+    const std::string& name_ ) const
+{
+    if( tf_ != 0 ) {
+	if( m_traces == 0 ) {
+	    m_traces = new sc_trace_params_vec;
+	}
+	m_traces->push_back( new sc_trace_params( tf_, name_ ) );
+    }
+}
+
+void
+sc_inout<bool>::add_trace( sc_trace_file* tf_, 
+    const std::string& name_ ) const
+{
+    sc_deprecated_add_trace();
+    add_trace_internal(tf_, name_);
+}
+
+void
+sc_inout<bool>::remove_traces() const
+{
+    if( m_traces != 0 ) {
+	for( int i = m_traces->size() - 1; i >= 0; -- i ) {
+	    delete (*m_traces)[i];
+	}
+	delete m_traces;
+	m_traces = 0;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_inout<sc_dt::sc_logic>
+//
+//  Specialization of sc_inout<T> for type sc_dt::sc_logic.
+// ----------------------------------------------------------------------------
+
+// destructor
+
+sc_inout<sc_dt::sc_logic>::~sc_inout()
+{
+    delete m_change_finder_p;
+    delete m_neg_finder_p;
+    delete m_pos_finder_p;
+    delete m_init_val;
+    remove_traces();
+}
+
+
+// set initial value (can also be called when port is not bound yet)
+
+void
+sc_inout<sc_dt::sc_logic>::initialize( const data_type& value_ )
+{
+    inout_if_type* iface = DCAST<inout_if_type*>( get_interface() );
+    if( iface != 0 ) {
+	iface->write( value_ );
+    } else {
+	if( m_init_val == 0 ) {
+	    m_init_val = new data_type;
+	}
+	*m_init_val = value_;
+    }
+}
+
+
+// called when elaboration is done
+
+void
+sc_inout<sc_dt::sc_logic>::end_of_elaboration()
+{
+    if( m_init_val != 0 ) {
+	write( *m_init_val );
+	delete m_init_val;
+	m_init_val = 0;
+    }
+    if( m_traces != 0 ) {
+	for( int i = 0; i < (int)m_traces->size(); ++ i ) {
+	    sc_trace_params* p = (*m_traces)[i];
+	    in_if_type* iface = DCAST<in_if_type*>( get_interface() );
+	    sc_trace( p->tf, iface->read(), p->name );
+	}
+	remove_traces();
+    }
+}
+
+
+// called by sc_trace
+
+void
+sc_inout<sc_dt::sc_logic>::add_trace_internal( sc_trace_file* tf_,
+			       const std::string& name_ ) const
+{
+    if( tf_ != 0 ) {
+	if( m_traces == 0 ) {
+	    m_traces = new sc_trace_params_vec;
+	}
+	m_traces->push_back( new sc_trace_params( tf_, name_ ) );
+    }
+}
+
+
+void
+sc_inout<sc_dt::sc_logic>::add_trace( sc_trace_file* tf_,
+			       const std::string& name_ ) const
+{
+    sc_deprecated_add_trace();
+    add_trace_internal(tf_, name_);
+}
+
+void
+sc_inout<sc_dt::sc_logic>::remove_traces() const
+{
+    if( m_traces != 0 ) {
+	for( int i = m_traces->size() - 1; i >= 0; -- i ) {
+	    delete (*m_traces)[i];
+	}
+	delete m_traces;
+	m_traces = 0;
+    }
+}
+
+void sc_deprecated_add_trace()
+{
+    static bool warn_add_trace_deprecated=true;
+    if ( warn_add_trace_deprecated )
+    {
+        warn_add_trace_deprecated=false;
+	SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
+	    "sc_signal<T>::addtrace() is deprecated");
+    }
+}
+} // namespace sc_core
+
+// $Log: sc_signal_ports.cpp,v $
+// Revision 1.3  2011/08/26 20:45:43  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.2  2011/02/18 20:23:45  acg
+//  Andy Goodrich: Copyright update.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.8  2006/05/08 17:52:47  acg
+//  Andy Goodrich:
+//    (1) added David Long's forward declarations for friend functions,
+//        methods, and operators to keep the Microsoft compiler happy.
+//    (2) Added delta_count() method to sc_prim_channel for use by
+//        sc_signal so that the friend declaration in sc_simcontext.h
+// 	   can be for a non-templated class (i.e., sc_prim_channel.)
+//
+// Revision 1.7  2006/04/18 18:01:26  acg
+//  Andy Goodrich: added an add_trace_internal() method to the various port
+//  classes so that sc_trace has something to call that won't emit an
+//  IEEE 1666 deprecation message.
+//
+// Revision 1.6  2006/02/02 23:42:37  acg
+//  Andy Goodrich: implemented a much better fix to the sc_event_finder
+//  proliferation problem. This new version allocates only a single event
+//  finder for each port for each type of event, e.g., pos(), neg(), and
+//  value_change(). The event finder persists as long as the port does,
+//  which is what the LRM dictates. Because only a single instance is
+//  allocated for each event type per port there is not a potential
+//  explosion of storage as was true in the 2.0.1/2.1 versions.
+//
+// Revision 1.5  2006/01/25 00:31:11  acg
+//  Andy Goodrich: Changed over to use a standard message id of
+//  SC_ID_IEEE_1666_DEPRECATION for all deprecation messages.
+//
+// Revision 1.4  2006/01/24 20:46:32  acg
+// Andy Goodrich: changes to eliminate use of deprecated features. For instance,
+// using notify(SC_ZERO_TIME) in place of notify_delayed().
+//
+// Revision 1.3  2006/01/13 18:47:42  acg
+// Added $Log command so that CVS comments are reproduced in the source.
+//
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_signal_ports.h b/ext/systemc/src/sysc/communication/sc_signal_ports.h
new file mode 100644
index 000000000..22c83c583
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_signal_ports.h
@@ -0,0 +1,1931 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_signal_ports.h -- The sc_signal<T> port classes.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG APPEARS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_SIGNAL_PORTS_H
+#define SC_SIGNAL_PORTS_H
+
+
+#include "sysc/communication/sc_event_finder.h"
+#include "sysc/communication/sc_port.h"
+#include "sysc/communication/sc_signal_ifs.h"
+#include "sysc/datatypes/bit/sc_logic.h"
+#include "sysc/tracing/sc_trace.h"
+
+#if ! defined( SC_DISABLE_VIRTUAL_BIND )
+#  define SC_VIRTUAL_ virtual
+#else
+#  define SC_VIRTUAL_ /* non-virtual */
+#endif
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  STRUCT : sc_trace_params
+//
+//  Struct for storing the trace file and object name of an sc_trace call.
+//  FOR INTERNAL USE ONLY!
+// ----------------------------------------------------------------------------
+
+extern void sc_deprecated_add_trace();
+
+struct sc_trace_params
+{
+    sc_trace_file*        tf;
+    std::string      name;
+
+    sc_trace_params( sc_trace_file* tf_, const std::string& name_ )
+	: tf( tf_ ), name( name_ )
+	{}
+};
+
+
+typedef std::vector<sc_trace_params*> sc_trace_params_vec;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_in<T>
+//
+//  The sc_signal<T> input port class.
+// ----------------------------------------------------------------------------
+
+template <class T>
+class sc_in
+: public sc_port<sc_signal_in_if<T>,1,SC_ONE_OR_MORE_BOUND>
+{
+public:
+
+    // typedefs
+
+    typedef T                                             data_type;
+
+    typedef sc_signal_in_if<data_type>                    if_type;
+    typedef sc_port<if_type,1,SC_ONE_OR_MORE_BOUND>       base_type;
+    typedef sc_in<data_type>                              this_type;
+    typedef typename base_type::port_type                 base_port_type;
+
+    typedef if_type                                       in_if_type;
+    typedef base_type                                     in_port_type;
+    typedef sc_signal_inout_if<data_type>                 inout_if_type;
+    typedef sc_port<inout_if_type,1,SC_ONE_OR_MORE_BOUND> inout_port_type;
+
+public:
+
+    // constructors
+
+    sc_in()
+	: base_type(), m_traces( 0 ),
+	  m_change_finder_p(0)
+	{}
+
+    explicit sc_in( const char* name_ )
+	: base_type( name_ ), m_traces( 0 ),
+	  m_change_finder_p(0)
+	{}
+
+    explicit sc_in( const in_if_type& interface_ )
+        : base_type( CCAST<in_if_type&>( interface_ ) ), m_traces( 0 ),
+	  m_change_finder_p(0)
+        {}
+
+    sc_in( const char* name_, const in_if_type& interface_ )
+	: base_type( name_, CCAST<in_if_type&>( interface_ ) ), m_traces( 0 ),
+	  m_change_finder_p(0)
+	{}
+
+    explicit sc_in( in_port_type& parent_ )
+	: base_type( parent_ ), m_traces( 0 ),
+	  m_change_finder_p(0)
+	{}
+
+    sc_in( const char* name_, in_port_type& parent_ )
+	: base_type( name_, parent_ ), m_traces( 0 ),
+	  m_change_finder_p(0)
+	{}
+
+    explicit sc_in( inout_port_type& parent_ )
+	: base_type(), m_traces( 0 ),
+	  m_change_finder_p(0)
+	{ sc_port_base::bind( parent_ ); }
+
+    sc_in( const char* name_, inout_port_type& parent_ )
+	: base_type( name_ ), m_traces( 0 ),
+	  m_change_finder_p(0)
+	{ sc_port_base::bind( parent_ ); }
+
+    sc_in( this_type& parent_ )
+	: base_type( parent_ ), m_traces( 0 ),
+	  m_change_finder_p(0)
+	{}
+
+    sc_in( const char* name_, this_type& parent_ )
+	: base_type( name_, parent_ ), m_traces( 0 ),
+	  m_change_finder_p(0)
+	{}
+
+
+    // destructor
+
+    virtual ~sc_in()
+	{
+	    remove_traces();
+	    delete m_change_finder_p;
+	}
+
+
+    // bind to in interface
+
+    SC_VIRTUAL_ void bind( const in_if_type& interface_ )
+	{ sc_port_base::bind( CCAST<in_if_type&>( interface_ ) ); }
+
+    SC_VIRTUAL_ void bind( in_if_type& interface_ )
+	{ this->bind( CCAST<const in_if_type&>( interface_ ) ); }
+
+    void operator () ( const in_if_type& interface_ )
+	{ this->bind( interface_ ); }
+
+
+    // bind to parent in port
+
+    SC_VIRTUAL_ void bind( in_port_type& parent_ )
+        { sc_port_base::bind( parent_ ); }
+
+    void operator () ( in_port_type& parent_ )
+        { this->bind( parent_ ); }
+
+
+    // bind to parent inout port
+
+    SC_VIRTUAL_ void bind( inout_port_type& parent_ )
+	{ sc_port_base::bind( parent_ ); }
+
+    void operator () ( inout_port_type& parent_ )
+	{ this->bind( parent_ ); }
+
+
+    // interface access shortcut methods
+
+    // get the default event
+
+    const sc_event& default_event() const
+	{ return (*this)->default_event(); }
+
+
+    // get the value changed event
+
+    const sc_event& value_changed_event() const
+	{ return (*this)->value_changed_event(); }
+
+
+    // read the current value
+
+    const data_type& read() const
+	{ return (*this)->read(); }
+
+    operator const data_type& () const
+	{ return (*this)->read(); }
+
+
+    // was there a value changed event?
+
+    bool event() const
+	{ return (*this)->event(); }
+
+
+    // (other) event finder method(s)
+
+    sc_event_finder& value_changed() const
+    {
+        if ( !m_change_finder_p )
+	{
+	    m_change_finder_p = new sc_event_finder_t<in_if_type>(
+	        *this, &in_if_type::value_changed_event );
+	}
+	return *m_change_finder_p;
+    }
+
+
+    // called when elaboration is done
+    /*  WHEN DEFINING THIS METHOD IN A DERIVED CLASS, */
+    /*  MAKE SURE THAT THIS METHOD IS CALLED AS WELL. */
+
+    virtual void end_of_elaboration();
+
+    virtual const char* kind() const
+        { return "sc_in"; }
+
+
+    void add_trace( sc_trace_file*, const std::string& ) const;
+
+    // called by sc_trace
+    void add_trace_internal( sc_trace_file*, const std::string& ) const;
+
+protected:
+
+    void remove_traces() const;
+
+    mutable sc_trace_params_vec* m_traces;
+
+protected:
+
+    // called by pbind (for internal use only)
+    virtual int vbind( sc_interface& );
+    virtual int vbind( sc_port_base& );
+
+    // implement virtual base_type port-binding function
+    //  - avoids warnings on some compilers
+    //  - should only be called, when using sc_port_b explicitly
+    //  - errors are detected during elaboration
+
+    SC_VIRTUAL_ void bind( base_port_type& parent_ )
+        { sc_port_base::bind( parent_ ); }
+
+
+private:
+  mutable sc_event_finder* m_change_finder_p;
+
+private:
+
+    // disabled
+    sc_in( const this_type& );
+    this_type& operator = ( const this_type& );
+
+#ifdef __GNUC__
+    // Needed to circumvent a problem in the g++-2.95.2 compiler:
+    // This unused variable forces the compiler to instantiate
+    // an object of T template so an implicit conversion from
+    // read() to a C++ intrinsic data type will work.
+    static data_type dummy;
+#endif
+};
+
+template<typename T>
+::std::ostream& operator << ( ::std::ostream& os, const sc_in<T>& a )
+{
+    return os << a->read();
+}
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+
+// called when elaboration is done
+
+template <class T>
+inline
+void
+sc_in<T>::end_of_elaboration()
+{
+    if( m_traces != 0 ) {
+	for( int i = 0; i < (int)m_traces->size(); ++ i ) {
+	    sc_trace_params* p = (*m_traces)[i];
+	    in_if_type* iface = DCAST<in_if_type*>( this->get_interface() );
+	    sc_trace( p->tf, iface->read(), p->name );
+	}
+	remove_traces();
+    }
+}
+
+
+// called by sc_trace
+
+template <class T>
+inline
+void
+sc_in<T>::add_trace_internal( sc_trace_file* tf_, const std::string& name_ ) 
+const
+{
+    if( tf_ != 0 ) {
+	if( m_traces == 0 ) {
+	    m_traces = new sc_trace_params_vec;
+	}
+	m_traces->push_back( new sc_trace_params( tf_, name_ ) );
+    }
+}
+
+template <class T>
+inline
+void
+sc_in<T>::add_trace( sc_trace_file* tf_, const std::string& name_ ) 
+const
+{
+    sc_deprecated_add_trace();
+    add_trace_internal(tf_, name_);
+}
+
+template <class T>
+inline
+void
+sc_in<T>::remove_traces() const
+{
+    if( m_traces != 0 ) {
+	for( int i = (int)m_traces->size() - 1; i >= 0; -- i ) {
+	    delete (*m_traces)[i];
+	}
+	delete m_traces;
+	m_traces = 0;
+    }
+}
+
+
+// called by pbind (for internal use only)
+
+template <class T>
+inline
+int
+sc_in<T>::vbind( sc_interface& interface_ )
+{
+    return sc_port_b<if_type>::vbind( interface_ );
+}
+
+template <class T>
+inline
+int
+sc_in<T>::vbind( sc_port_base& parent_ )
+{
+    in_port_type* in_parent = DCAST<in_port_type*>( &parent_ );
+    if( in_parent != 0 ) {
+	sc_port_base::bind( *in_parent );
+	return 0;
+    }
+    inout_port_type* inout_parent = DCAST<inout_port_type*>( &parent_ );
+    if( inout_parent != 0 ) {
+	sc_port_base::bind( *inout_parent );
+	return 0;
+    }
+    // type mismatch
+    return 2;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_in<bool>
+//
+//  Specialization of sc_in<T> for type bool.
+// ----------------------------------------------------------------------------
+
+template <>
+class sc_in<bool> : 
+    public sc_port<sc_signal_in_if<bool>,1,SC_ONE_OR_MORE_BOUND>
+{
+public:
+
+    // typedefs
+
+    typedef bool                                           data_type;
+
+    typedef sc_signal_in_if<data_type>                     if_type;
+    typedef sc_port<if_type,1,SC_ONE_OR_MORE_BOUND>        base_type;
+    typedef sc_in<data_type>                               this_type;
+    typedef /* typename */ base_type::port_type            base_port_type;
+
+    typedef if_type                                        in_if_type;
+    typedef base_type                                      in_port_type;
+    typedef sc_signal_inout_if<data_type>                  inout_if_type;
+    typedef sc_port<inout_if_type,1,SC_ONE_OR_MORE_BOUND>  inout_port_type;
+
+public:
+
+    // constructors
+
+    sc_in()
+	: base_type(), m_traces( 0 ), m_change_finder_p(0), 
+	  m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+    explicit sc_in( const char* name_ )
+	: base_type( name_ ), m_traces( 0 ), m_change_finder_p(0), 
+	  m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+    explicit sc_in( const in_if_type& interface_ )
+	: base_type( CCAST<in_if_type&>( interface_ ) ), m_traces( 0 ), 
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+    sc_in( const char* name_, const in_if_type& interface_ )
+	: base_type( name_, CCAST<in_if_type&>( interface_ ) ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+    explicit sc_in( in_port_type& parent_ )
+	: base_type( parent_ ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+    sc_in( const char* name_, in_port_type& parent_ )
+	: base_type( name_, parent_ ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+    explicit sc_in( inout_port_type& parent_ )
+	: base_type(), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{ sc_port_base::bind( parent_ ); }
+
+    sc_in( const char* name_, inout_port_type& parent_ )
+	: base_type( name_ ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{ sc_port_base::bind( parent_ ); }
+
+    sc_in( this_type& parent_ )
+	: base_type( parent_ ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+#if defined(TESTING)
+    sc_in( const this_type& parent_ )
+	: base_type( *(in_if_type*)parent_.get_interface() ) , m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+#endif 
+
+    sc_in( const char* name_, this_type& parent_ )
+	: base_type( name_, parent_ ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+
+    // destructor
+
+    virtual ~sc_in()
+	{
+	    remove_traces();
+	    delete m_change_finder_p;
+	    delete m_neg_finder_p;
+	    delete m_pos_finder_p;
+	}
+
+
+    // bind to in interface
+
+    SC_VIRTUAL_ void bind( const in_if_type& interface_ )
+	{ sc_port_base::bind( CCAST<in_if_type&>( interface_ ) ); }
+
+    SC_VIRTUAL_ void bind( in_if_type& interface_ )
+	{ this->bind( CCAST<const in_if_type&>( interface_ ) ); }
+
+    void operator () ( const in_if_type& interface_ )
+	{ this->bind( interface_ ); }
+
+
+    // bind to parent in port
+
+    SC_VIRTUAL_ void bind( in_port_type& parent_ )
+        { sc_port_base::bind( parent_ ); }
+
+    void operator () ( in_port_type& parent_ )
+        { this->bind( parent_ ); }
+
+
+    // bind to parent inout port
+
+    SC_VIRTUAL_ void bind( inout_port_type& parent_ )
+	{ sc_port_base::bind( parent_ ); }
+
+    void operator () ( inout_port_type& parent_ )
+	{ this->bind( parent_ ); }
+
+
+    // interface access shortcut methods
+
+    // get the default event
+
+    const sc_event& default_event() const
+	{ return (*this)->default_event(); }
+
+
+    // get the value changed event
+
+    const sc_event& value_changed_event() const
+	{ return (*this)->value_changed_event(); }
+
+    // get the positive edge event
+
+    const sc_event& posedge_event() const
+	{ return (*this)->posedge_event(); }
+
+    // get the negative edge event
+
+    const sc_event& negedge_event() const
+	{ return (*this)->negedge_event(); }
+
+
+    // read the current value
+
+    const data_type& read() const
+	{ return (*this)->read(); }
+
+    operator const data_type& () const
+	{ return (*this)->read(); }
+
+
+    // use for positive edge sensitivity
+
+    sc_event_finder& pos() const
+    {
+        if ( !m_pos_finder_p )
+	{
+	    m_pos_finder_p = new sc_event_finder_t<in_if_type>(
+	        *this, &in_if_type::posedge_event );
+	} 
+	return *m_pos_finder_p;
+    }
+
+    // use for negative edge sensitivity
+
+    sc_event_finder& neg() const
+    {
+        if ( !m_neg_finder_p )
+	{
+	    m_neg_finder_p = new sc_event_finder_t<in_if_type>(
+	        *this, &in_if_type::negedge_event );
+	} 
+	return *m_neg_finder_p;
+    }
+
+
+    // was there a value changed event?
+
+    bool event() const
+	{ return (*this)->event(); }
+
+    // was there a positive edge event?
+
+    bool posedge() const
+        { return (*this)->posedge(); }
+
+    // was there a negative edge event?
+
+    bool negedge() const
+        { return (*this)->negedge(); }
+
+    // (other) event finder method(s)
+
+    sc_event_finder& value_changed() const
+    {
+        if ( !m_change_finder_p )
+	{
+	    m_change_finder_p = new sc_event_finder_t<in_if_type>(
+	        *this, &in_if_type::value_changed_event );
+	}
+	return *m_change_finder_p;
+    }
+
+
+    // called when elaboration is done
+    /*  WHEN DEFINING THIS METHOD IN A DERIVED CLASS, */
+    /*  MAKE SURE THAT THIS METHOD IS CALLED AS WELL. */
+
+    virtual void end_of_elaboration();
+
+    virtual const char* kind() const
+        { return "sc_in"; }
+
+
+    void add_trace( sc_trace_file*, const std::string& ) const;
+
+    // called by sc_trace
+    void add_trace_internal( sc_trace_file*, const std::string& ) const;
+
+protected:
+
+    void remove_traces() const;
+
+    mutable sc_trace_params_vec* m_traces;
+
+protected:
+
+    // called by pbind (for internal use only)
+    virtual int vbind( sc_interface& );
+    virtual int vbind( sc_port_base& );
+
+    // implement virtual base_type port-binding function
+    //  - avoids warnings on some compilers
+    //  - should only be called, when using sc_port_b explicitly
+    //  - errors are detected during elaboration
+
+    SC_VIRTUAL_ void bind( base_port_type& parent_ )
+        { sc_port_base::bind( parent_ ); }
+
+private:
+  mutable sc_event_finder* m_change_finder_p;
+  mutable sc_event_finder* m_neg_finder_p;
+  mutable sc_event_finder* m_pos_finder_p;
+
+private:
+
+    // disabled
+#if defined(TESTING)
+#else
+    sc_in( const this_type& );
+#endif 
+    this_type& operator = ( const this_type& );
+
+#ifdef __GNUC__
+    // Needed to circumvent a problem in the g++-2.95.2 compiler:
+    // This unused variable forces the compiler to instantiate
+    // an object of T template so an implicit conversion from
+    // read() to a C++ intrinsic data type will work.
+    static data_type dummy;
+#endif
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_in<sc_dt::sc_logic>
+//
+//  Specialization of sc_in<T> for type sc_dt::sc_logic.
+// ----------------------------------------------------------------------------
+
+template <>
+class sc_in<sc_dt::sc_logic>
+: public sc_port<sc_signal_in_if<sc_dt::sc_logic>,1,SC_ONE_OR_MORE_BOUND>
+{
+public:
+
+    // typedefs
+
+    typedef sc_dt::sc_logic                               data_type;
+
+    typedef sc_signal_in_if<data_type>                    if_type;
+    typedef sc_port<if_type,1,SC_ONE_OR_MORE_BOUND>       base_type;
+    typedef sc_in<data_type>                              this_type;
+    typedef /* typename */ base_type::port_type           base_port_type;
+
+    typedef if_type                                       in_if_type;
+    typedef base_type                                     in_port_type;
+    typedef sc_signal_inout_if<data_type>                 inout_if_type;
+    typedef sc_port<inout_if_type,1,SC_ONE_OR_MORE_BOUND> inout_port_type;
+
+public:
+
+    // constructors
+
+    sc_in()
+	: base_type(), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+    explicit sc_in( const char* name_ )
+	: base_type( name_ ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+    explicit sc_in( const in_if_type& interface_ )
+	: base_type( CCAST<in_if_type&>( interface_ ) ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+    sc_in( const char* name_, const in_if_type& interface_ )
+	: base_type( name_, CCAST<in_if_type&>( interface_ ) ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+    explicit sc_in( in_port_type& parent_ )
+	: base_type( parent_ ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+    sc_in( const char* name_, in_port_type& parent_ )
+	: base_type( name_, parent_ ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+    explicit sc_in( inout_port_type& parent_ )
+	: base_type(), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{ sc_port_base::bind( parent_ ); }
+
+    sc_in( const char* name_, inout_port_type& parent_ )
+	: base_type( name_ ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{ sc_port_base::bind( parent_ ); }
+
+    sc_in( this_type& parent_ )
+	: base_type( parent_ ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+    sc_in( const char* name_, this_type& parent_ )
+	: base_type( name_, parent_ ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+
+    // destructor
+
+    virtual ~sc_in()
+	{
+	    remove_traces();
+	    delete m_change_finder_p;
+	    delete m_neg_finder_p;
+	    delete m_pos_finder_p;
+	}
+
+
+    // bind to in interface
+
+    SC_VIRTUAL_ void bind( const in_if_type& interface_ )
+	{ sc_port_base::bind( CCAST<in_if_type&>( interface_ ) ); }
+
+    SC_VIRTUAL_ void bind( in_if_type& interface_ )
+	{ this->bind( CCAST<const in_if_type&>( interface_ ) ); }
+
+    void operator () ( const in_if_type& interface_ )
+	{ this->bind( interface_ ); }
+
+
+    // bind to parent in port
+
+    SC_VIRTUAL_ void bind( in_port_type& parent_ )
+        { sc_port_base::bind( parent_ ); }
+
+    void operator () ( in_port_type& parent_ )
+        { this->bind( parent_ ); }
+
+
+    // bind to parent inout port
+
+    SC_VIRTUAL_ void bind( inout_port_type& parent_ )
+	{ sc_port_base::bind( parent_ ); }
+
+    void operator () ( inout_port_type& parent_ )
+	{ this->bind( parent_ ); }
+
+
+    // interface access shortcut methods
+
+    // get the default event
+
+    const sc_event& default_event() const
+	{ return (*this)->default_event(); }
+
+
+    // get the value changed event
+
+    const sc_event& value_changed_event() const
+	{ return (*this)->value_changed_event(); }
+
+    // get the positive edge event
+
+    const sc_event& posedge_event() const
+	{ return (*this)->posedge_event(); }
+
+    // get the negative edge event
+
+    const sc_event& negedge_event() const
+	{ return (*this)->negedge_event(); }
+
+
+    // read the current value
+
+    const data_type& read() const
+	{ return (*this)->read(); }
+
+    operator const data_type& () const
+	{ return (*this)->read(); }
+
+
+    // use for positive edge sensitivity
+
+    sc_event_finder& pos() const
+    {
+        if ( !m_pos_finder_p )
+	{
+	    m_pos_finder_p = new sc_event_finder_t<in_if_type>(
+	        *this, &in_if_type::posedge_event );
+	} 
+	return *m_pos_finder_p;
+    }
+
+    // use for negative edge sensitivity
+
+    sc_event_finder& neg() const
+    {
+        if ( !m_neg_finder_p )
+	{
+	    m_neg_finder_p = new sc_event_finder_t<in_if_type>(
+	        *this, &in_if_type::negedge_event );
+	} 
+	return *m_neg_finder_p;
+    }
+
+
+    // was there a value changed event?
+
+    bool event() const
+	{ return (*this)->event(); }
+
+    // was there a positive edge event?
+
+    bool posedge() const
+        { return (*this)->posedge(); }
+
+    // was there a negative edge event?
+
+    bool negedge() const
+        { return (*this)->negedge(); }
+
+    // (other) event finder method(s)
+
+    sc_event_finder& value_changed() const
+    {
+        if ( !m_change_finder_p )
+	{
+	    m_change_finder_p = new sc_event_finder_t<in_if_type>(
+	        *this, &in_if_type::value_changed_event );
+	}
+	return *m_change_finder_p;
+    }
+
+
+    // called when elaboration is done
+    /*  WHEN DEFINING THIS METHOD IN A DERIVED CLASS, */
+    /*  MAKE SURE THAT THIS METHOD IS CALLED AS WELL. */
+
+    virtual void end_of_elaboration();
+
+    virtual const char* kind() const
+        { return "sc_in"; }
+
+
+    void add_trace( sc_trace_file*, const std::string& ) const;
+
+    // called by sc_trace
+    void add_trace_internal( sc_trace_file*, const std::string& ) const;
+
+protected:
+
+    void remove_traces() const;
+
+    mutable sc_trace_params_vec* m_traces;
+
+protected:
+
+    // called by pbind (for internal use only)
+    virtual int vbind( sc_interface& );
+    virtual int vbind( sc_port_base& );
+
+    // implement virtual base_type port-binding function
+    //  - avoids warnings on some compilers
+    //  - should only be called, when using sc_port_b explicitly
+    //  - errors are detected during elaboration
+
+    SC_VIRTUAL_ void bind( base_port_type& parent_ )
+        { sc_port_base::bind( parent_ ); }
+
+private:
+  mutable sc_event_finder* m_change_finder_p;
+  mutable sc_event_finder* m_neg_finder_p;
+  mutable sc_event_finder* m_pos_finder_p;
+
+private:
+
+    // disabled
+    sc_in( const this_type& );
+    this_type& operator = ( const this_type& );
+
+#ifdef __GNUC__
+    // Needed to circumvent a problem in the g++-2.95.2 compiler:
+    // This unused variable forces the compiler to instantiate
+    // an object of T template so an implicit conversion from
+    // read() to a C++ intrinsic data type will work.
+    static data_type dummy;
+#endif
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_inout<T>
+//
+//  The sc_signal<T> input/output port class.
+// ----------------------------------------------------------------------------
+
+template <class T>
+class sc_inout
+: public sc_port<sc_signal_inout_if<T>,1,SC_ONE_OR_MORE_BOUND>
+{
+public:
+
+    // typedefs
+
+    typedef T                                          data_type;
+
+    typedef sc_signal_inout_if<data_type>              if_type;
+    typedef sc_port<if_type,1,SC_ONE_OR_MORE_BOUND>    base_type;
+    typedef sc_inout<data_type>                        this_type;
+
+    typedef sc_signal_in_if<data_type>                 in_if_type;
+    typedef sc_port<in_if_type,1,SC_ONE_OR_MORE_BOUND> in_port_type;
+    typedef if_type                                    inout_if_type;
+    typedef base_type                                  inout_port_type;
+
+public:
+
+    // constructors
+
+    sc_inout()
+	: base_type(), m_init_val( 0 ), m_traces( 0 ),
+	  m_change_finder_p(0)
+	{}
+
+    explicit sc_inout( const char* name_ )
+	: base_type( name_ ), m_init_val( 0 ), m_traces( 0 ),
+	  m_change_finder_p(0)
+	{}
+
+    explicit sc_inout( inout_if_type& interface_ )
+	: base_type( interface_ ), m_init_val( 0 ), m_traces( 0 ),
+	  m_change_finder_p(0)
+	{}
+
+    sc_inout( const char* name_, inout_if_type& interface_ )
+	: base_type( name_, interface_ ), m_init_val( 0 ), m_traces( 0 ),
+	  m_change_finder_p(0)
+	{}
+
+    explicit sc_inout( inout_port_type& parent_ )
+	: base_type( parent_ ), m_init_val( 0 ), m_traces( 0 ),
+	  m_change_finder_p(0)
+	{}
+
+    sc_inout( const char* name_, inout_port_type& parent_ )
+	: base_type( name_, parent_ ), m_init_val( 0 ), m_traces( 0 ),
+	  m_change_finder_p(0)
+	{}
+
+    sc_inout( this_type& parent_ )
+	: base_type( parent_ ), m_init_val( 0 ), m_traces( 0 ),
+	  m_change_finder_p(0)
+	{}
+
+    sc_inout( const char* name_, this_type& parent_ )
+	: base_type( name_, parent_ ), m_init_val( 0 ), m_traces( 0 ),
+	  m_change_finder_p(0)
+	{}
+
+
+    // destructor
+
+    virtual ~sc_inout();
+
+
+    // interface access shortcut methods
+
+    // get the default event
+
+    const sc_event& default_event() const
+	{ return (*this)->default_event(); }
+
+
+    // get the value changed event
+
+    const sc_event& value_changed_event() const
+	{ return (*this)->value_changed_event(); }
+
+
+    // read the current value
+
+    const data_type& read() const
+	{ return (*this)->read(); }
+
+    operator const data_type& () const
+	{ return (*this)->read(); }
+
+
+    // was there a value changed event?
+
+    bool event() const
+	{ return (*this)->event(); }
+
+
+    // write the new value
+
+    void write( const data_type& value_ )
+	{ (*this)->write( value_ ); }
+
+    this_type& operator = ( const data_type& value_ )
+	{ (*this)->write( value_ ); return *this; }
+
+    this_type& operator = ( const in_if_type& interface_ )
+	{ (*this)->write( interface_.read() ); return *this; }
+
+    this_type& operator = ( const in_port_type& port_ )
+	{ (*this)->write( port_->read() ); return *this; }
+
+    this_type& operator = ( const inout_port_type& port_ )
+	{ (*this)->write( port_->read() ); return *this; }
+
+    this_type& operator = ( const this_type& port_ )
+	{ (*this)->write( port_->read() ); return *this; }
+
+
+    // set initial value (can also be called when port is not bound yet)
+
+    void initialize( const data_type& value_ );
+
+    void initialize( const in_if_type& interface_ )
+	{ initialize( interface_.read() ); }
+
+
+    // called when elaboration is done
+    /*  WHEN DEFINING THIS METHOD IN A DERIVED CLASS, */
+    /*  MAKE SURE THAT THIS METHOD IS CALLED AS WELL. */
+
+    virtual void end_of_elaboration();
+
+
+    // (other) event finder method(s)
+
+    sc_event_finder& value_changed() const
+    {
+        if ( !m_change_finder_p )
+	{
+	    m_change_finder_p = new sc_event_finder_t<in_if_type>(
+	        *this, &in_if_type::value_changed_event );
+	}
+	return *m_change_finder_p;
+    }
+
+    virtual const char* kind() const
+        { return "sc_inout"; }
+
+protected:
+
+    data_type* m_init_val;
+
+public:
+
+    // called by sc_trace
+    void add_trace_internal( sc_trace_file*, const std::string& ) const;
+
+    void add_trace( sc_trace_file*, const std::string& ) const;
+
+protected:
+
+    void remove_traces() const;
+
+    mutable sc_trace_params_vec* m_traces;
+
+private:
+  mutable sc_event_finder* m_change_finder_p;
+
+private:
+
+    // disabled
+    sc_inout( const this_type& );
+
+#ifdef __GNUC__
+    // Needed to circumvent a problem in the g++-2.95.2 compiler:
+    // This unused variable forces the compiler to instantiate
+    // an object of T template so an implicit conversion from
+    // read() to a C++ intrinsic data type will work.
+    static data_type dummy;
+#endif
+};
+
+template<typename T>
+::std::ostream& operator << ( ::std::ostream& os, const sc_inout<T>& a )
+{
+    return os << a->read();
+}
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+
+// destructor
+
+template <class T>
+inline
+sc_inout<T>::~sc_inout()
+{
+    delete m_change_finder_p;
+    delete m_init_val;
+    remove_traces();
+}
+
+
+// set initial value (can also be called when port is not bound yet)
+
+template <class T>
+inline
+void
+sc_inout<T>::initialize( const data_type& value_ )
+{
+    inout_if_type* iface = DCAST<inout_if_type*>( this->get_interface() );
+    if( iface != 0 ) {
+	iface->write( value_ );
+    } else {
+	if( m_init_val == 0 ) {
+	    m_init_val = new data_type;
+	}
+	*m_init_val = value_;
+    }
+}
+
+
+// called when elaboration is done
+
+template <class T>
+inline
+void
+sc_inout<T>::end_of_elaboration()
+{
+    if( m_init_val != 0 ) {
+	write( *m_init_val );
+	delete m_init_val;
+	m_init_val = 0;
+    }
+    if( m_traces != 0 ) {
+	for( int i = 0; i < (int)m_traces->size(); ++ i ) {
+	    sc_trace_params* p = (*m_traces)[i];
+	    in_if_type* iface = DCAST<in_if_type*>( this->get_interface() );
+	    sc_trace( p->tf, iface->read(), p->name );
+	}
+	remove_traces();
+    }
+}
+
+
+// called by sc_trace
+
+template <class T>
+inline
+void
+sc_inout<T>::add_trace_internal( sc_trace_file* tf_, const std::string& name_) 
+const
+{
+    if( tf_ != 0 ) {
+	    if( m_traces == 0 ) {
+	        m_traces = new sc_trace_params_vec;
+	    }
+	    m_traces->push_back( new sc_trace_params( tf_, name_ ) );
+    }
+}
+
+template <class T>
+inline
+void
+sc_inout<T>::add_trace( sc_trace_file* tf_, const std::string& name_) const
+{
+    sc_deprecated_add_trace();
+    add_trace_internal(tf_, name_);
+}
+
+template <class T>
+inline
+void
+sc_inout<T>::remove_traces() const
+{
+    if( m_traces != 0 ) {
+		for( int i = m_traces->size() - 1; i >= 0; -- i ) {
+	        delete (*m_traces)[i];
+		}
+		delete m_traces;
+		m_traces = 0;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_inout<bool>
+//
+//  Specialization of sc_inout<T> for type bool.
+// ----------------------------------------------------------------------------
+
+template <>
+class sc_inout<bool> : 
+    public sc_port<sc_signal_inout_if<bool>,1,SC_ONE_OR_MORE_BOUND>
+{
+public:
+
+    // typedefs
+
+    typedef bool                                       data_type;
+
+    typedef sc_signal_inout_if<data_type>              if_type;
+    typedef sc_port<if_type,1,SC_ONE_OR_MORE_BOUND>    base_type;
+    typedef sc_inout<data_type>                        this_type;
+
+    typedef sc_signal_in_if<data_type>                 in_if_type;
+    typedef sc_port<in_if_type,1,SC_ONE_OR_MORE_BOUND> in_port_type;
+    typedef if_type                                    inout_if_type;
+    typedef base_type                                  inout_port_type;
+
+public:
+
+    // constructors
+
+    sc_inout()
+	: base_type(), m_init_val( 0 ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+    explicit sc_inout( const char* name_ )
+	: base_type( name_ ), m_init_val( 0 ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+    explicit sc_inout( inout_if_type& interface_ )
+	: base_type( interface_ ), m_init_val( 0 ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+    sc_inout( const char* name_, inout_if_type& interface_ )
+	: base_type( name_, interface_ ), m_init_val( 0 ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+    explicit sc_inout( inout_port_type& parent_ )
+	: base_type( parent_ ), m_init_val( 0 ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+    sc_inout( const char* name_, inout_port_type& parent_ )
+	: base_type( name_, parent_ ), m_init_val( 0 ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+    sc_inout( this_type& parent_ )
+	: base_type( parent_ ), m_init_val( 0 ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+    sc_inout( const char* name_, this_type& parent_ )
+	: base_type( name_, parent_ ), m_init_val( 0 ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+
+    // destructor
+
+    virtual ~sc_inout();
+
+
+    // interface access shortcut methods
+
+    // get the default event
+
+    const sc_event& default_event() const
+	{ return (*this)->default_event(); }
+
+
+    // get the value changed event
+
+    const sc_event& value_changed_event() const
+	{ return (*this)->value_changed_event(); }
+
+    // get the positive edge event
+
+    const sc_event& posedge_event() const
+	{ return (*this)->posedge_event(); }
+
+    // get the negative edge event
+
+    const sc_event& negedge_event() const
+	{ return (*this)->negedge_event(); }
+
+
+    // read the current value
+
+    const data_type& read() const
+	{ return (*this)->read(); }
+
+    operator const data_type& () const
+	{ return (*this)->read(); }
+
+
+    // use for positive edge sensitivity
+
+    sc_event_finder& pos() const
+    {
+        if ( !m_pos_finder_p )
+	{
+	    m_pos_finder_p = new sc_event_finder_t<in_if_type>(
+	        *this, &in_if_type::posedge_event );
+	} 
+	return *m_pos_finder_p;
+    }
+
+    // use for negative edge sensitivity
+
+    sc_event_finder& neg() const
+    {
+        if ( !m_neg_finder_p )
+	{
+	    m_neg_finder_p = new sc_event_finder_t<in_if_type>(
+	        *this, &in_if_type::negedge_event );
+	} 
+	return *m_neg_finder_p;
+    }
+
+
+    // was there a value changed event?
+
+    bool event() const
+	{ return (*this)->event(); }
+
+    // was there a positive edge event?
+
+    bool posedge() const
+        { return (*this)->posedge(); }
+
+    // was there a negative edge event?
+
+    bool negedge() const
+        { return (*this)->negedge(); }
+
+    // write the new value
+
+    void write( const data_type& value_ )
+	{ (*this)->write( value_ ); }
+
+    this_type& operator = ( const data_type& value_ )
+	{ (*this)->write( value_ ); return *this; }
+
+    this_type& operator = ( const in_if_type& interface_ )
+	{ (*this)->write( interface_.read() ); return *this; }
+
+    this_type& operator = ( const in_port_type& port_ )
+	{ (*this)->write( port_->read() ); return *this; }
+
+    this_type& operator = ( const inout_port_type& port_ )
+	{ (*this)->write( port_->read() ); return *this; }
+
+    this_type& operator = ( const this_type& port_ )
+	{ (*this)->write( port_->read() ); return *this; }
+
+
+    // set initial value (can also be called when port is not bound yet)
+
+    void initialize( const data_type& value_ );
+
+    void initialize( const in_if_type& interface_ )
+	{ initialize( interface_.read() ); }
+
+
+    // called when elaboration is done
+    /*  WHEN DEFINING THIS METHOD IN A DERIVED CLASS, */
+    /*  MAKE SURE THAT THIS METHOD IS CALLED AS WELL. */
+
+    virtual void end_of_elaboration();
+
+
+    // (other) event finder method(s)
+
+    sc_event_finder& value_changed() const
+    {
+        if ( !m_change_finder_p )
+	{
+	    m_change_finder_p = new sc_event_finder_t<in_if_type>(
+	        *this, &in_if_type::value_changed_event );
+	}
+	return *m_change_finder_p;
+    }
+
+    virtual const char* kind() const
+        { return "sc_inout"; }
+
+protected:
+
+    data_type* m_init_val;
+
+public:
+
+    // called by sc_trace
+    void add_trace_internal( sc_trace_file*, const std::string& ) const;
+
+    void add_trace( sc_trace_file*, const std::string& ) const;
+
+protected:
+
+    void remove_traces() const;
+
+    mutable sc_trace_params_vec* m_traces;
+
+private:
+  mutable sc_event_finder* m_change_finder_p;
+  mutable sc_event_finder* m_neg_finder_p;
+  mutable sc_event_finder* m_pos_finder_p;
+
+private:
+
+    // disabled
+    sc_inout( const this_type& );
+
+#ifdef __GNUC__
+    // Needed to circumvent a problem in the g++-2.95.2 compiler:
+    // This unused variable forces the compiler to instantiate
+    // an object of T template so an implicit conversion from
+    // read() to a C++ intrinsic data type will work.
+    static data_type dummy;
+#endif
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_inout<sc_dt::sc_logic>
+//
+//  Specialization of sc_inout<T> for type sc_dt::sc_logic.
+// ----------------------------------------------------------------------------
+
+template <>
+class sc_inout<sc_dt::sc_logic>
+: public sc_port<sc_signal_inout_if<sc_dt::sc_logic>,1,SC_ONE_OR_MORE_BOUND>
+{
+public:
+
+    // typedefs
+
+    typedef sc_dt::sc_logic                            data_type;
+
+    typedef sc_signal_inout_if<data_type>              if_type;
+    typedef sc_port<if_type,1,SC_ONE_OR_MORE_BOUND>    base_type;
+    typedef sc_inout<data_type>                        this_type;
+
+    typedef sc_signal_in_if<data_type>                 in_if_type;
+    typedef sc_port<in_if_type,1,SC_ONE_OR_MORE_BOUND> in_port_type;
+    typedef if_type                                    inout_if_type;
+    typedef base_type                                  inout_port_type;
+
+public:
+
+    // constructors
+
+    sc_inout()
+	: base_type(), m_init_val( 0 ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+    explicit sc_inout( const char* name_ )
+	: base_type( name_ ), m_init_val( 0 ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+    explicit sc_inout( inout_if_type& interface_ )
+	: base_type( interface_ ), m_init_val( 0 ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+    sc_inout( const char* name_, inout_if_type& interface_ )
+	: base_type( name_, interface_ ), m_init_val( 0 ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+    explicit sc_inout( inout_port_type& parent_ )
+	: base_type( parent_ ), m_init_val( 0 ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+    sc_inout( const char* name_, inout_port_type& parent_ )
+	: base_type( name_, parent_ ), m_init_val( 0 ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+    sc_inout( this_type& parent_ )
+	: base_type( parent_ ), m_init_val( 0 ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+    sc_inout( const char* name_, this_type& parent_ )
+	: base_type( name_, parent_ ), m_init_val( 0 ), m_traces( 0 ),
+	  m_change_finder_p(0), m_neg_finder_p(0), m_pos_finder_p(0)
+	{}
+
+
+    // destructor
+
+    virtual ~sc_inout();
+
+
+    // interface access shortcut methods
+
+    // get the default event
+
+    const sc_event& default_event() const
+	{ return (*this)->default_event(); }
+
+
+    // get the value changed event
+
+    const sc_event& value_changed_event() const
+	{ return (*this)->value_changed_event(); }
+
+    // get the positive edge event
+
+    const sc_event& posedge_event() const
+	{ return (*this)->posedge_event(); }
+
+    // get the negative edge event
+
+    const sc_event& negedge_event() const
+	{ return (*this)->negedge_event(); }
+
+
+    // read the current value
+
+    const data_type& read() const
+	{ return (*this)->read(); }
+
+    operator const data_type& () const
+	{ return (*this)->read(); }
+
+
+    // use for positive edge sensitivity
+
+    sc_event_finder& pos() const
+    {
+        if ( !m_pos_finder_p )
+	{
+	    m_pos_finder_p = new sc_event_finder_t<in_if_type>(
+	        *this, &in_if_type::posedge_event );
+	} 
+	return *m_pos_finder_p;
+    }
+
+    // use for negative edge sensitivity
+
+    sc_event_finder& neg() const
+    {
+        if ( !m_neg_finder_p )
+	{
+	    m_neg_finder_p = new sc_event_finder_t<in_if_type>(
+	        *this, &in_if_type::negedge_event );
+	} 
+	return *m_neg_finder_p;
+    }
+
+
+    // was there a value changed event?
+
+    bool event() const
+	{ return (*this)->event(); }
+
+    // was there a positive edge event?
+
+    bool posedge() const
+        { return (*this)->posedge(); }
+
+    // was there a negative edge event?
+
+    bool negedge() const
+        { return (*this)->negedge(); }
+
+    // write the new value
+
+    void write( const data_type& value_ )
+	{ (*this)->write( value_ ); }
+
+    this_type& operator = ( const data_type& value_ )
+	{ (*this)->write( value_ ); return *this; }
+
+    this_type& operator = ( const in_if_type& interface_ )
+	{ (*this)->write( interface_.read() ); return *this; }
+
+    this_type& operator = ( const in_port_type& port_ )
+	{ (*this)->write( port_->read() ); return *this; }
+
+    this_type& operator = ( const inout_port_type& port_ )
+	{ (*this)->write( port_->read() ); return *this; }
+
+    this_type& operator = ( const this_type& port_ )
+	{ (*this)->write( port_->read() ); return *this; }
+
+
+    // set initial value (can also be called when port is not bound yet)
+
+    void initialize( const data_type& value_ );
+
+    void initialize( const in_if_type& interface_ )
+	{ initialize( interface_.read() ); }
+
+
+    // called when elaboration is done
+    /*  WHEN DEFINING THIS METHOD IN A DERIVED CLASS, */
+    /*  MAKE SURE THAT THIS METHOD IS CALLED AS WELL. */
+
+    virtual void end_of_elaboration();
+
+
+    // (other) event finder method(s)
+
+    sc_event_finder& value_changed() const
+    {
+        if ( !m_change_finder_p )
+	{
+	    m_change_finder_p = new sc_event_finder_t<in_if_type>(
+	        *this, &in_if_type::value_changed_event );
+	}
+        return *m_change_finder_p;
+    }
+
+    virtual const char* kind() const
+        { return "sc_inout"; }
+
+protected:
+
+    data_type* m_init_val;
+
+public:
+
+    // called by sc_trace
+    void add_trace_internal( sc_trace_file*, const std::string& ) const;
+
+    void add_trace( sc_trace_file*, const std::string& ) const;
+
+protected:
+
+    void remove_traces() const;
+
+    mutable sc_trace_params_vec* m_traces;
+
+private:
+  mutable sc_event_finder* m_change_finder_p;
+  mutable sc_event_finder* m_neg_finder_p;
+  mutable sc_event_finder* m_pos_finder_p;
+
+private:
+
+    // disabled
+    sc_inout( const this_type& );
+
+#ifdef __GNUC__
+    // Needed to circumvent a problem in the g++-2.95.2 compiler:
+    // This unused variable forces the compiler to instantiate
+    // an object of T template so an implicit conversion from
+    // read() to a C++ intrinsic data type will work.
+    static data_type dummy;
+#endif
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_out<T>
+//
+//  The sc_signal<T> output port class.
+// ----------------------------------------------------------------------------
+
+// sc_out can also read from its port, hence no difference with sc_inout.
+// For debugging reasons, a class is provided instead of a define.
+
+template <class T>
+class sc_out
+: public sc_inout<T>
+{
+public:
+
+    // typedefs
+
+    typedef T                                   data_type;
+
+    typedef sc_out<data_type>                   this_type;
+    typedef sc_inout<data_type>                 base_type;
+
+    typedef typename base_type::in_if_type      in_if_type;
+    typedef typename base_type::in_port_type    in_port_type;
+    typedef typename base_type::inout_if_type   inout_if_type;
+    typedef typename base_type::inout_port_type inout_port_type;
+
+public:
+
+    // constructors
+
+    sc_out()
+	: base_type()
+	{}
+
+    explicit sc_out( const char* name_ )
+	: base_type( name_ )
+	{}
+
+    explicit sc_out( inout_if_type& interface_ )
+	: base_type( interface_ )
+	{}
+
+    sc_out( const char* name_, inout_if_type& interface_ )
+	: base_type( name_, interface_ )
+	{}
+
+    explicit sc_out( inout_port_type& parent_ )
+	: base_type( parent_ )
+	{}
+
+    sc_out( const char* name_, inout_port_type& parent_ )
+	: base_type( name_, parent_ )
+	{}
+
+    sc_out( this_type& parent_ )
+	: base_type( parent_ )
+	{}
+
+    sc_out( const char* name_, this_type& parent_ )
+	: base_type( name_, parent_ )
+	{}
+
+
+    // destructor (does nothing)
+
+    virtual ~sc_out()
+	{}
+
+
+    // write the new value
+
+    this_type& operator = ( const data_type& value_ )
+	{ (*this)->write( value_ ); return *this; }
+
+    this_type& operator = ( const in_if_type& interface_ )
+	{ (*this)->write( interface_.read() ); return *this; }
+
+    this_type& operator = ( const in_port_type& port_ )
+	{ (*this)->write( port_->read() ); return *this; }
+
+    this_type& operator = ( const inout_port_type& port_ )
+	{ (*this)->write( port_->read() ); return *this; }
+
+    this_type& operator = ( const this_type& port_ )
+	{ (*this)->write( port_->read() ); return *this; }
+
+    virtual const char* kind() const
+        { return "sc_out"; }
+
+private:
+
+    // disabled
+    sc_out( const this_type& );
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+
+// ----------------------------------------------------------------------------
+//  FUNCTION : sc_trace
+// ----------------------------------------------------------------------------
+
+template <class T>
+inline
+void
+sc_trace(sc_trace_file* tf, const sc_in<T>& port, const std::string& name)
+{
+    const sc_signal_in_if<T>* iface = 0;
+    if (sc_get_curr_simcontext()->elaboration_done() )
+    {
+	iface = DCAST<const sc_signal_in_if<T>*>( port.get_interface() );
+    }
+
+    if ( iface )
+	sc_trace( tf, iface->read(), name );
+    else
+	port.add_trace_internal( tf, name );
+}
+
+template <class T>
+inline
+void
+sc_trace( sc_trace_file* tf, const sc_inout<T>& port, 
+    const std::string& name )
+{
+    const sc_signal_in_if<T>* iface = 0;
+    if (sc_get_curr_simcontext()->elaboration_done() )
+    {
+	iface =DCAST<const sc_signal_in_if<T>*>( port.get_interface() );
+    }
+
+    if ( iface )
+	sc_trace( tf, iface->read(), name );
+    else
+	port.add_trace_internal( tf, name );
+}
+
+} // namespace sc_core
+
+#undef SC_VIRTUAL_
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:  Jason Elbaum, Motorola, Inc., 2001-11-12
+  Description of Modification:  Added a static, private, otherwise
+                                unused data member to the sc_in
+                                and sc_inout classes to address
+                                a bug in the GNU compiler *only*.
+                                This works around a bug in g++ 2.95.2
+                                regarding implicit casting from a
+                                templated class to a C++ intrinsic type.
+
+ *****************************************************************************/
+//$Log: sc_signal_ports.h,v $
+//Revision 1.10  2011/08/29 18:04:32  acg
+// Philipp A. Hartmann: miscellaneous clean ups.
+//
+//Revision 1.9  2011/08/26 20:45:43  acg
+// Andy Goodrich: moved the modification log to the end of the file to
+// eliminate source line number skew when check-ins are done.
+//
+//Revision 1.8  2011/08/07 19:08:01  acg
+// Andy Goodrich: moved logs to end of file so line number synching works
+// better between versions.
+//
+//Revision 1.7  2011/08/07 18:53:09  acg
+// Philipp A. Hartmann: add virtual instances of the bind function for
+// base classes to eliminate warning messages for clang platforms.
+//
+//Revision 1.6  2011/04/02 00:03:23  acg
+// Andy Goodrich: catch the other bind()'s that I missed in Philipp's update.
+//
+//Revision 1.5  2011/04/01 22:33:31  acg
+// Philipp A. Harmann: Use const interface signature to implement non-const
+// interface signature for virtual bind(...).
+//
+//Revision 1.4  2011/03/30 16:46:10  acg
+// Andy Goodrich: added a signature and removed a virtual specification
+// to eliminate warnings with certain compilers.
+//
+//Revision 1.3  2011/02/18 20:23:45  acg
+// Andy Goodrich: Copyright update.
+//
+//Revision 1.2  2011/01/20 16:52:15  acg
+// Andy Goodrich: changes for IEEE 1666 2011.
+//
+//Revision 1.1.1.1  2006/12/15 20:20:04  acg
+//SystemC 2.3
+//
+//Revision 1.11  2006/04/18 23:36:50  acg
+// Andy Goodrich: made add_trace_internal public until I can figure out
+// how to do a friend specification for sc_trace in an environment where
+// there are partial template and full template specifications for its
+// arguments.
+//
+//Revision 1.10  2006/04/18 18:01:26  acg
+// Andy Goodrich: added an add_trace_internal() method to the various port
+// classes so that sc_trace has something to call that won't emit an
+// IEEE 1666 deprecation message.
+//
+//Revision 1.9  2006/03/13 20:19:44  acg
+// Andy Goodrich: changed sc_event instances into pointers to sc_event instances
+// that are allocated as needed. This saves considerable storage for large
+// numbers of signals, etc.
+//
+//Revision 1.8  2006/02/02 23:42:37  acg
+// Andy Goodrich: implemented a much better fix to the sc_event_finder
+// proliferation problem. This new version allocates only a single event
+// finder for each port for each type of event, e.g., pos(), neg(), and
+// value_change(). The event finder persists as long as the port does,
+// which is what the LRM dictates. Because only a single instance is
+// allocated for each event type per port there is not a potential
+// explosion of storage as was true in the 2.0.1/2.1 versions.
+//
+//Revision 1.7  2006/02/02 21:38:12  acg
+// Andy Goodrich: fix to the comment log.
+//
+//Revision 1.4  2006/01/24 20:46:32  acg
+//Andy Goodrich: changes to eliminate use of deprecated features. For instance,
+//using notify(SC_ZERO_TIME) in place of notify_delayed().
+//
+//Revision 1.3  2006/01/13 18:47:42  acg
+//Added $Log command so that CVS comments are reproduced in the source.
+//
+//Revision 1.2  2006/01/03 23:18:26  acg
+//Changed copyright to include 2006.
+//
+//Revision 1.1.1.1  2005/12/19 23:16:43  acg
+//First check in of SystemC 2.1 into its own archive.
+//
+//Revision 1.18  2005/09/15 23:01:52  acg
+//Added std:: prefix to appropriate methods and types to get around
+//issues with the Edison Front End.
+//
+//Revision 1.17  2005/06/10 22:43:55  acg
+//Added CVS change log annotation.
+//
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_signal_resolved.cpp b/ext/systemc/src/sysc/communication/sc_signal_resolved.cpp
new file mode 100644
index 000000000..2b0aeca0b
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_signal_resolved.cpp
@@ -0,0 +1,152 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_signal_resolved.cpp -- The resolved signal class.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#include "sysc/kernel/sc_simcontext.h"
+#include "sysc/kernel/sc_process_handle.h"
+#include "sysc/communication/sc_signal_resolved.h"
+
+namespace sc_core {
+
+// Note that we assume that two drivers driving the resolved signal to a 1 or
+// 0 is O.K. This might not be true for all technologies, but is certainly
+// true for CMOS, the predominant technology in use today.
+
+const sc_dt::sc_logic_value_t
+sc_logic_resolution_tbl[4][4] =
+{   //    0      1      Z      X
+    { sc_dt::Log_0, sc_dt::Log_X, sc_dt::Log_0, sc_dt::Log_X }, // 0
+    { sc_dt::Log_X, sc_dt::Log_1, sc_dt::Log_1, sc_dt::Log_X }, // 1
+    { sc_dt::Log_0, sc_dt::Log_1, sc_dt::Log_Z, sc_dt::Log_X }, // Z
+    { sc_dt::Log_X, sc_dt::Log_X, sc_dt::Log_X, sc_dt::Log_X }  // X
+};
+
+
+// ----------------------------------------------------------------------------
+//  FUNCTION : sc_logic_resolve
+//
+//  Resolution function for sc_dt::sc_logic.
+// ----------------------------------------------------------------------------
+
+// resolves sc_dt::sc_logic values and returns the resolved value
+
+static void
+sc_logic_resolve( sc_dt::sc_logic& result_,
+                  const std::vector<sc_dt::sc_logic>& values_ )
+{
+    int sz = values_.size();
+
+    assert( sz != 0 );
+
+    if( sz == 1 ) {
+	result_ = values_[0];
+	return;
+    }
+
+    sc_dt::sc_logic_value_t res = values_[0].value();
+    for( int i = sz - 1; i > 0 && res != sc_dt::Log_X; -- i ) {
+       res = sc_logic_resolution_tbl[res][values_[i].value()];
+    }
+    result_ = res;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signal_resolved
+//
+//  The resolved signal class.
+// ----------------------------------------------------------------------------
+
+// write the new value
+
+void
+sc_signal_resolved::write( const data_type& value_ )
+{
+    sc_process_b* cur_proc = sc_get_current_process_b();
+
+    bool value_changed = false;
+    bool found = false;
+    
+    for( int i = m_proc_vec.size() - 1; i >= 0; -- i ) {
+	if( cur_proc == m_proc_vec[i] ) {
+	    if( value_ != m_val_vec[i] ) {
+		m_val_vec[i] = value_;
+		value_changed = true;
+	    }
+	    found = true;
+	    break;
+	}
+    }
+    
+    if( ! found ) {
+	m_proc_vec.push_back( cur_proc );
+	m_val_vec.push_back( value_ );
+	value_changed = true;
+    }
+    
+    if( value_changed ) {
+	request_update();
+    }
+}
+
+
+void
+sc_signal_resolved::update()
+{
+    sc_logic_resolve( m_new_val, m_val_vec );
+    base_type::update();
+}
+
+
+} // namespace sc_core
+
+// $Log: sc_signal_resolved.cpp,v $
+// Revision 1.5  2011/08/26 20:45:44  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.4  2011/02/18 20:23:45  acg
+//  Andy Goodrich: Copyright update.
+//
+// Revision 1.3  2011/02/07 19:16:50  acg
+//  Andy Goodrich: changes for handling multiple writers.
+//
+// Revision 1.2  2011/01/20 16:52:15  acg
+//  Andy Goodrich: changes for IEEE 1666 2011.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.4  2006/03/21 00:00:27  acg
+//   Andy Goodrich: changed name of sc_get_current_process_base() to be
+//   sc_get_current_process_b() since its returning an sc_process_b instance.
+//
+// Revision 1.3  2006/01/13 18:47:42  acg
+// Added $Log command so that CVS comments are reproduced in the source.
+//
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_signal_resolved.h b/ext/systemc/src/sysc/communication/sc_signal_resolved.h
new file mode 100644
index 000000000..f5e8c714e
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_signal_resolved.h
@@ -0,0 +1,153 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_signal_resolved.h -- The resolved signal class.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#ifndef SC_SIGNAL_RESOLVED_H
+#define SC_SIGNAL_RESOLVED_H
+
+
+#include "sysc/communication/sc_signal.h"
+
+namespace sc_core {
+
+class sc_process_b;
+
+extern const sc_dt::sc_logic_value_t sc_logic_resolution_tbl[4][4];
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signal_resolved
+//
+//  The resolved signal class.
+// ----------------------------------------------------------------------------
+
+class sc_signal_resolved
+: public sc_signal<sc_dt::sc_logic,SC_MANY_WRITERS>
+{
+public:
+
+    // typedefs
+
+    typedef sc_signal_resolved                         this_type;
+    typedef sc_signal<sc_dt::sc_logic,SC_MANY_WRITERS> base_type;
+    typedef sc_dt::sc_logic                            data_type;
+
+public:
+
+    // constructors
+
+    sc_signal_resolved() :
+        base_type( sc_gen_unique_name( "signal_resolved" ) ), m_proc_vec(), 
+	m_val_vec()
+        {}
+
+    explicit sc_signal_resolved( const char* name_ ): 
+        base_type( name_ ), m_proc_vec(), m_val_vec()
+	{}
+
+    sc_signal_resolved( const char* name_, const data_type & initial_value_ )
+      : base_type( name_, initial_value_ )
+      , m_proc_vec()
+      , m_val_vec()
+    {}
+
+    // interface methods
+
+    virtual void register_port( sc_port_base&, const char* )
+	{}
+
+
+    // write the new value
+    virtual void write( const data_type& );
+
+
+    // other methods
+
+    this_type& operator = ( const data_type& a )
+        { write( a ); return *this; }
+
+    this_type& operator = ( const this_type& a )
+        { write( a.read() ); return *this; }
+
+    virtual const char* kind() const
+        { return "sc_signal_resolved"; }
+
+protected:
+
+    virtual void update();
+
+protected:
+
+    std::vector<sc_process_b*> m_proc_vec; // processes writing this signal
+    std::vector<data_type>     m_val_vec;  // new values written this signal
+
+private:
+
+    // disabled
+    sc_signal_resolved( const this_type& );
+};
+
+} // namespace sc_core
+
+//$Log: sc_signal_resolved.h,v $
+//Revision 1.6  2011/08/26 20:45:44  acg
+// Andy Goodrich: moved the modification log to the end of the file to
+// eliminate source line number skew when check-ins are done.
+//
+//Revision 1.5  2011/08/24 22:05:36  acg
+// Torsten Maehne: initialization changes to remove warnings.
+//
+//Revision 1.4  2011/04/19 02:36:26  acg
+// Philipp A. Hartmann: new aysnc_update and mutex support.
+//
+//Revision 1.3  2011/02/18 20:23:45  acg
+// Andy Goodrich: Copyright update.
+//
+//Revision 1.2  2011/01/20 16:52:15  acg
+// Andy Goodrich: changes for IEEE 1666 2011.
+//
+//Revision 1.1.1.1  2006/12/15 20:20:04  acg
+//SystemC 2.3
+//
+//Revision 1.2  2006/01/03 23:18:26  acg
+//Changed copyright to include 2006.
+//
+//Revision 1.1.1.1  2005/12/19 23:16:43  acg
+//First check in of SystemC 2.1 into its own archive.
+//
+//Revision 1.10  2005/09/15 23:01:52  acg
+//Added std:: prefix to appropriate methods and types to get around
+//issues with the Edison Front End.
+//
+//Revision 1.9  2005/06/10 22:43:55  acg
+//Added CVS change log annotation.
+//
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_signal_resolved_ports.cpp b/ext/systemc/src/sysc/communication/sc_signal_resolved_ports.cpp
new file mode 100644
index 000000000..17da6396a
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_signal_resolved_ports.cpp
@@ -0,0 +1,107 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_signal_resolved_ports.cpp -- The sc_signal_resolved port classes.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-08-20
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#include <cstdio>
+
+#include "sysc/kernel/sc_simcontext.h"
+#include "sysc/kernel/sc_process_handle.h"
+#include "sysc/communication/sc_communication_ids.h"
+#include "sysc/communication/sc_signal_resolved.h"
+#include "sysc/communication/sc_signal_resolved_ports.h"
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_in_resolved
+//
+//  The sc_signal_resolved input port class.
+// ----------------------------------------------------------------------------
+
+// called when elaboration is done
+
+void
+sc_in_resolved::end_of_elaboration()
+{
+    base_type::end_of_elaboration();
+    // check if bound channel is a resolved signal
+    if( DCAST<sc_signal_resolved*>( get_interface() ) == 0 ) {
+	char msg[BUFSIZ];
+	std::sprintf( msg, "%s (%s)", name(), kind() );
+	SC_REPORT_ERROR( SC_ID_RESOLVED_PORT_NOT_BOUND_, msg );
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_inout_resolved
+//
+//  The sc_signal_resolved input/output port class.
+// ----------------------------------------------------------------------------
+
+// called when elaboration is done
+
+void
+sc_inout_resolved::end_of_elaboration()
+{
+    base_type::end_of_elaboration();
+    // check if bound channel is a resolved signal
+    if( DCAST<sc_signal_resolved*>( get_interface() ) == 0 ) {
+	char msg[BUFSIZ];
+	std::sprintf( msg, "%s (%s)", name(), kind() );
+	SC_REPORT_ERROR( SC_ID_RESOLVED_PORT_NOT_BOUND_, msg );
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_out_resolved
+//
+//  The sc_signal_resolved output port class.
+// ----------------------------------------------------------------------------
+
+} // namespace sc_core
+
+// $Log: sc_signal_resolved_ports.cpp,v $
+// Revision 1.4  2011/08/26 20:45:44  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.3  2011/02/18 20:23:45  acg
+//  Andy Goodrich: Copyright update.
+//
+// Revision 1.2  2011/02/07 19:16:50  acg
+//  Andy Goodrich: changes for handling multiple writers.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:47:42  acg
+// Added $Log command so that CVS comments are reproduced in the source.
+//
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_signal_resolved_ports.h b/ext/systemc/src/sysc/communication/sc_signal_resolved_ports.h
new file mode 100644
index 000000000..6b0d777d7
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_signal_resolved_ports.h
@@ -0,0 +1,349 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_signal_resolved_ports.h -- The sc_signal_resolved port classes.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-08-20
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_SIGNAL_RESOLVED_PORTS_H
+#define SC_SIGNAL_RESOLVED_PORTS_H
+
+
+#include "sysc/communication/sc_signal_ports.h"
+#include "sysc/datatypes/bit/sc_logic.h"
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_in_resolved
+//
+//  The sc_signal_resolved input port class.
+// ----------------------------------------------------------------------------
+
+class sc_in_resolved
+    : public sc_in<sc_dt::sc_logic>
+{
+public:
+
+    // typedefs
+
+    typedef sc_dt::sc_logic            data_type;
+
+    typedef sc_in_resolved             this_type;
+    typedef sc_in<data_type>           base_type;
+
+    typedef base_type::in_if_type      in_if_type;
+    typedef base_type::in_port_type    in_port_type;
+    typedef base_type::inout_port_type inout_port_type;
+
+public:
+
+    // constructors
+
+    sc_in_resolved()
+	: base_type()
+	{}
+
+    explicit sc_in_resolved( const char* name_ )
+	: base_type( name_ )
+	{}
+
+    explicit sc_in_resolved( const in_if_type& interface_ )
+	: base_type( interface_ )
+	{}
+
+    sc_in_resolved( const char* name_, const in_if_type& interface_ )
+	: base_type( name_, interface_ )
+	{}
+
+    explicit sc_in_resolved( in_port_type& parent_ )
+	: base_type( parent_ )
+	{}
+
+    sc_in_resolved( const char* name_, in_port_type& parent_ )
+	: base_type( name_, parent_ )
+	{}
+
+    explicit sc_in_resolved( inout_port_type& parent_ )
+	: base_type( parent_ )
+	{}
+
+    sc_in_resolved( const char* name_, inout_port_type& parent_ )
+	: base_type( name_, parent_ )
+	{}
+
+    sc_in_resolved( this_type& parent_ )
+	: base_type( parent_ )
+	{}
+
+    sc_in_resolved( const char* name_, this_type& parent_ )
+	: base_type( name_, parent_ )
+	{}
+
+
+    // destructor (does nothing)
+
+    virtual ~sc_in_resolved()
+	{}
+
+
+    // called when elaboration is done
+    /*  WHEN DEFINING THIS METHOD IN A DERIVED CLASS, */
+    /*  MAKE SURE THAT THIS METHOD IS CALLED AS WELL. */
+
+    virtual void end_of_elaboration();
+
+    virtual const char* kind() const
+        { return "sc_in_resolved"; }
+
+private:
+
+    // disabled
+    sc_in_resolved( const this_type& );
+    this_type& operator = ( const this_type& );
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_inout_resolved
+//
+//  The sc_signal_resolved input/output port class.
+// ----------------------------------------------------------------------------
+
+class sc_inout_resolved
+    : public sc_inout<sc_dt::sc_logic>
+{
+public:
+
+    // typedefs
+
+    typedef sc_dt::sc_logic            data_type;
+
+    typedef sc_inout_resolved          this_type;
+    typedef sc_inout<data_type>        base_type;
+
+    typedef base_type::in_if_type      in_if_type;
+    typedef base_type::in_port_type    in_port_type;
+    typedef base_type::inout_if_type   inout_if_type;
+    typedef base_type::inout_port_type inout_port_type;
+
+public:
+
+    // constructors
+
+    sc_inout_resolved()
+	: base_type()
+	{}
+
+    explicit sc_inout_resolved( const char* name_ )
+	: base_type( name_ )
+	{}
+
+    explicit sc_inout_resolved( inout_if_type& interface_ )
+	: base_type( interface_ )
+	{}
+
+    sc_inout_resolved( const char* name_, inout_if_type& interface_ )
+	: base_type( name_, interface_ )
+	{}
+
+    explicit sc_inout_resolved( inout_port_type& parent_ )
+	: base_type( parent_ )
+	{}
+
+    sc_inout_resolved( const char* name_, inout_port_type& parent_ )
+	: base_type( name_, parent_ )
+	{}
+
+    sc_inout_resolved( this_type& parent_ )
+	: base_type( parent_ )
+	{}
+
+    sc_inout_resolved( const char* name_, this_type& parent_ )
+	: base_type( name_, parent_ )
+	{}
+
+
+    // destructor (does nothing)
+
+    virtual ~sc_inout_resolved()
+	{}
+
+
+    // write the new value
+
+    this_type& operator = ( const data_type& value_ )
+	{ (*this)->write( value_ ); return *this; }
+
+    this_type& operator = ( const in_if_type& interface_ )
+	{ (*this)->write( interface_.read() ); return *this; }
+
+    this_type& operator = ( const in_port_type& port_ )
+	{ (*this)->write( port_->read() ); return *this; }
+
+    this_type& operator = ( const inout_port_type& port_ )
+	{ (*this)->write( port_->read() ); return *this; }
+
+    this_type& operator = ( const this_type& port_ )
+	{ (*this)->write( port_->read() ); return *this; }
+
+
+    // called when elaboration is done
+    /*  WHEN DEFINING THIS METHOD IN A DERIVED CLASS, */
+    /*  MAKE SURE THAT THIS METHOD IS CALLED AS WELL. */
+
+    virtual void end_of_elaboration();
+
+    virtual const char* kind() const
+        { return "sc_inout_resolved"; }
+
+private:
+
+    // disabled
+    sc_inout_resolved( const this_type& );
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_out_resolved
+//
+//  The sc_signal_resolved output port class.
+// ----------------------------------------------------------------------------
+
+// sc_out_resolved can also read from its port, hence no difference with
+// sc_inout_resolved. For debugging reasons, a class is provided instead
+// of a typedef.
+
+class sc_out_resolved
+    : public sc_inout_resolved
+{
+public:
+
+    // typedefs
+
+    typedef sc_out_resolved            this_type;
+    typedef sc_inout_resolved          base_type;
+
+    typedef base_type::data_type       data_type;
+
+    typedef base_type::in_if_type      in_if_type;
+    typedef base_type::in_port_type    in_port_type;
+    typedef base_type::inout_if_type   inout_if_type;
+    typedef base_type::inout_port_type inout_port_type;
+
+public:
+
+    // constructors
+
+    sc_out_resolved()
+	: base_type()
+	{}
+
+    explicit sc_out_resolved( const char* name_ )
+	: base_type( name_ )
+	{}
+
+    explicit sc_out_resolved( inout_if_type& interface_ )
+	: base_type( interface_ )
+	{}
+
+    sc_out_resolved( const char* name_, inout_if_type& interface_ )
+	: base_type( name_, interface_ )
+	{}
+
+    explicit sc_out_resolved( inout_port_type& parent_ )
+	: base_type( parent_ )
+	{}
+
+    sc_out_resolved( const char* name_, inout_port_type& parent_ )
+	: base_type( name_, parent_ )
+	{}
+
+    sc_out_resolved( this_type& parent_ )
+	: base_type( parent_ )
+	{}
+
+    sc_out_resolved( const char* name_, this_type& parent_ )
+	: base_type( name_, parent_ )
+	{}
+
+
+    // destructor (does nothing)
+
+    virtual ~sc_out_resolved()
+	{}
+
+
+    // write the new value
+
+    this_type& operator = ( const data_type& value_ )
+	{ (*this)->write( value_ ); return *this; }
+
+    this_type& operator = ( const in_if_type& interface_ )
+	{ (*this)->write( interface_.read() ); return *this; }
+
+    this_type& operator = ( const in_port_type& port_ )
+	{ (*this)->write( port_->read() ); return *this; }
+
+    this_type& operator = ( const inout_port_type& port_ )
+	{ (*this)->write( port_->read() ); return *this; }
+
+    this_type& operator = ( const this_type& port_ )
+	{ (*this)->write( port_->read() ); return *this; }
+
+    virtual const char* kind() const
+        { return "sc_out_resolved"; }
+
+private:
+
+    // disabled
+    sc_out_resolved( const this_type& );
+};
+
+} // namespace sc_core
+
+//$Log: sc_signal_resolved_ports.h,v $
+//Revision 1.3  2011/08/26 20:45:44  acg
+// Andy Goodrich: moved the modification log to the end of the file to
+// eliminate source line number skew when check-ins are done.
+//
+//Revision 1.2  2011/02/18 20:23:45  acg
+// Andy Goodrich: Copyright update.
+//
+//Revision 1.1.1.1  2006/12/15 20:20:04  acg
+//SystemC 2.3
+//
+//Revision 1.2  2006/01/03 23:18:26  acg
+//Changed copyright to include 2006.
+//
+//Revision 1.1.1.1  2005/12/19 23:16:43  acg
+//First check in of SystemC 2.1 into its own archive.
+//
+//Revision 1.9  2005/06/10 22:43:55  acg
+//Added CVS change log annotation.
+//
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_signal_rv.h b/ext/systemc/src/sysc/communication/sc_signal_rv.h
new file mode 100644
index 000000000..0d870e78e
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_signal_rv.h
@@ -0,0 +1,255 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_signal_rv.h -- The resolved vector signal class.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_SIGNAL_RV_H
+#define SC_SIGNAL_RV_H
+
+#include "sysc/communication/sc_signal.h"
+#include "sysc/datatypes/bit/sc_lv.h"
+
+namespace sc_core {
+
+class sc_process_b;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS sc_lv_resolve<W>
+//
+//  Resolution function for sc_dt::sc_lv<W>.
+// ----------------------------------------------------------------------------
+
+extern const sc_dt::sc_logic_value_t sc_logic_resolution_tbl[4][4];
+
+
+template <int W>
+class sc_lv_resolve
+{
+public:
+
+    // resolves sc_dt::sc_lv<W> values and returns the resolved value
+    static void resolve(sc_dt::sc_lv<W>&, const std::vector<sc_dt::sc_lv<W>*>&);
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+// resolves sc_dt::sc_lv<W> values and returns the resolved value
+
+template <int W>
+inline
+void
+sc_lv_resolve<W>::resolve( sc_dt::sc_lv<W>& result_,
+			   const std::vector<sc_dt::sc_lv<W>*>& values_ )
+{
+    int sz = values_.size();
+
+    assert( sz != 0 );
+
+    if( sz == 1 ) {
+	result_ = *values_[0];
+	return;
+    }
+
+    for( int j = result_.length() - 1; j >= 0; -- j ) {
+	sc_dt::sc_logic_value_t res = (*values_[0])[j].value();
+	for( int i = sz - 1; i > 0 && res != 3; -- i ) {
+	    res = sc_logic_resolution_tbl[res][(*values_[i])[j].value()];
+	}
+	result_[j] = res;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signal_rv<W>
+//
+//  The resolved vector signal class.
+// ----------------------------------------------------------------------------
+
+template <int W>
+class sc_signal_rv
+: public sc_signal<sc_dt::sc_lv<W>, SC_MANY_WRITERS>
+{
+public:
+
+    // typedefs
+
+    typedef sc_signal_rv<W>                             this_type;
+    typedef sc_signal<sc_dt::sc_lv<W>, SC_MANY_WRITERS> base_type;
+    typedef sc_dt::sc_lv<W>                             data_type;
+
+public:
+
+    // constructors
+
+    sc_signal_rv()
+        : base_type( sc_gen_unique_name( "signal_rv" ) )
+	{}
+
+    explicit sc_signal_rv( const char* name_ )
+        : base_type( name_ )
+	{}
+
+
+    // destructor
+    virtual ~sc_signal_rv();
+
+
+    // interface methods
+
+    virtual void register_port( sc_port_base&, const char* )
+	{}
+
+
+    // write the new value
+    virtual void write( const data_type& );
+
+
+    // other methods
+
+    this_type& operator = ( const data_type& a )
+        { write( a ); return *this; }
+
+    this_type& operator = ( const this_type& a )
+        { write( a.read() ); return *this; }
+
+    virtual const char* kind() const
+        { return "sc_signal_rv"; }
+
+protected:
+
+    virtual void update();
+
+protected:
+
+    std::vector<sc_process_b*> m_proc_vec; // processes writing this signal
+    std::vector<data_type*>       m_val_vec;  // new values written this signal
+
+private:
+
+    // disabled
+    sc_signal_rv( const this_type& );
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+
+// destructor
+
+template <int W>
+inline
+sc_signal_rv<W>::~sc_signal_rv()
+{
+    for( int i = m_val_vec.size() - 1; i >= 0; -- i ) {
+	delete m_val_vec[i];
+    }
+}
+
+
+// write the new value
+
+template <int W>
+inline
+void
+sc_signal_rv<W>::write( const data_type& value_ )
+{
+    sc_process_b* cur_proc = sc_get_current_process_b();
+
+    bool value_changed = false;
+    bool found = false;
+    
+    for( int i = m_proc_vec.size() - 1; i >= 0; -- i ) {
+	if( cur_proc == m_proc_vec[i] ) {
+	    if( value_ != *m_val_vec[i] ) {
+		*m_val_vec[i] = value_;
+		value_changed = true;
+	    }
+	    found = true;
+	    break;
+	}
+    }
+    
+    if( ! found ) {
+	m_proc_vec.push_back( cur_proc );
+	m_val_vec.push_back( new data_type( value_ ) );
+	value_changed = true;
+    }
+    
+    if( value_changed ) {
+	this->request_update();
+    }
+}
+
+
+template <int W>
+inline
+void
+sc_signal_rv<W>::update()
+{
+    sc_lv_resolve<W>::resolve( this->m_new_val, m_val_vec );
+    base_type::update();
+}
+
+} // namespace sc_core
+
+//$Log: sc_signal_rv.h,v $
+//Revision 1.4  2011/08/26 20:45:44  acg
+// Andy Goodrich: moved the modification log to the end of the file to
+// eliminate source line number skew when check-ins are done.
+//
+//Revision 1.3  2011/04/19 02:36:26  acg
+// Philipp A. Hartmann: new aysnc_update and mutex support.
+//
+//Revision 1.2  2011/02/18 20:23:45  acg
+// Andy Goodrich: Copyright update.
+//
+//Revision 1.1.1.1  2006/12/15 20:20:04  acg
+//SystemC 2.3
+//
+//Revision 1.3  2006/03/21 00:00:27  acg
+//  Andy Goodrich: changed name of sc_get_current_process_base() to be
+//  sc_get_current_process_b() since its returning an sc_process_b instance.
+//
+//Revision 1.2  2006/01/03 23:18:26  acg
+//Changed copyright to include 2006.
+//
+//Revision 1.1.1.1  2005/12/19 23:16:43  acg
+//First check in of SystemC 2.1 into its own archive.
+//
+//Revision 1.10  2005/09/15 23:01:52  acg
+//Added std:: prefix to appropriate methods and types to get around
+//issues with the Edison Front End.
+//
+//Revision 1.9  2005/06/10 22:43:55  acg
+//Added CVS change log annotation.
+//
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_signal_rv_ports.h b/ext/systemc/src/sysc/communication/sc_signal_rv_ports.h
new file mode 100644
index 000000000..ee6d17b25
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_signal_rv_ports.h
@@ -0,0 +1,401 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_signal_rv_ports.h -- The resolved vector signal ports.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_SIGNAL_RV_PORTS_H
+#define SC_SIGNAL_RV_PORTS_H
+
+
+#include <cstdio>
+
+#include "sysc/communication/sc_communication_ids.h"
+#include "sysc/communication/sc_signal_ports.h"
+#include "sysc/communication/sc_signal_rv.h"
+#include "sysc/datatypes/bit/sc_lv.h"
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_in_rv<W>
+//
+//  The sc_signal_rv<W> input port class.
+// ----------------------------------------------------------------------------
+
+template <int W>
+class sc_in_rv
+    : public sc_in<sc_dt::sc_lv<W> >
+{
+public:
+
+    // typedefs
+
+    typedef sc_dt::sc_lv<W>                     data_type;
+
+    typedef sc_in_rv<W>                         this_type;
+    typedef sc_in<data_type>                    base_type;
+
+    typedef typename base_type::in_if_type      in_if_type;
+    typedef typename base_type::in_port_type    in_port_type;
+    typedef typename base_type::inout_port_type inout_port_type;
+
+public:
+
+    // constructors
+
+    sc_in_rv()
+	: base_type()
+	{}
+
+    explicit sc_in_rv( const char* name_ )
+	: base_type( name_ )
+	{}
+
+    explicit sc_in_rv( const in_if_type& interface_ )
+	: base_type( interface_ )
+	{}
+
+    sc_in_rv( const char* name_, const in_if_type& interface_ )
+	: base_type( name_, interface_ )
+	{}
+
+    explicit sc_in_rv( in_port_type& parent_ )
+	: base_type( parent_ )
+	{}
+
+    sc_in_rv( const char* name_, in_port_type& parent_ )
+	: base_type( name_, parent_ )
+	{}
+
+    explicit sc_in_rv( inout_port_type& parent_ )
+	: base_type( parent_ )
+	{}
+
+    sc_in_rv( const char* name_, inout_port_type& parent_ )
+	: base_type( name_, parent_ )
+	{}
+
+    sc_in_rv( this_type& parent_ )
+	: base_type( parent_ )
+	{}
+
+    sc_in_rv( const char* name_, this_type& parent_ )
+	: base_type( name_, parent_ )
+	{}
+
+
+    // destructor (does nothing)
+
+    virtual ~sc_in_rv()
+	{}
+
+
+    // called when elaboration is done
+    /*  WHEN DEFINING THIS METHOD IN A DERIVED CLASS, */
+    /*  MAKE SURE THAT THIS METHOD IS CALLED AS WELL. */
+
+    virtual void end_of_elaboration();
+
+    virtual const char* kind() const
+        { return "sc_in_rv"; }
+
+private:
+
+    // disabled
+    sc_in_rv( const this_type& );
+    this_type& operator = ( const this_type& );
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+
+// called when elaboration is done
+
+template <int W>
+void
+sc_in_rv<W>::end_of_elaboration()
+{
+    base_type::end_of_elaboration();
+    // check if bound channel is a resolved signal
+    if( DCAST<sc_signal_rv<W>*>( this->get_interface() ) == 0 ) {
+	char msg[BUFSIZ];
+	std::sprintf( msg, "%s (%s)", this->name(), kind() );
+	SC_REPORT_ERROR( SC_ID_RESOLVED_PORT_NOT_BOUND_, msg );
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_inout_rv<W>
+//
+//  The sc_signal_rv<W> input/output port class.
+// ----------------------------------------------------------------------------
+
+template <int W>
+class sc_inout_rv
+    : public sc_inout<sc_dt::sc_lv<W> >
+{
+public:
+
+    // typedefs
+
+    typedef sc_dt::sc_lv<W>                     data_type;
+
+    typedef sc_inout_rv<W>                      this_type;
+    typedef sc_inout<data_type>                 base_type;
+
+    typedef typename base_type::in_if_type      in_if_type;
+    typedef typename base_type::in_port_type    in_port_type;
+    typedef typename base_type::inout_if_type   inout_if_type;
+    typedef typename base_type::inout_port_type inout_port_type;
+
+public:
+
+    // constructors
+
+    sc_inout_rv()
+	: base_type()
+	{}
+
+    explicit sc_inout_rv( const char* name_ )
+	: base_type( name_ )
+	{}
+
+    explicit sc_inout_rv( inout_if_type& interface_ )
+	: base_type( interface_ )
+	{}
+
+    sc_inout_rv( const char* name_, inout_if_type& interface_ )
+	: base_type( name_, interface_ )
+	{}
+
+    explicit sc_inout_rv( inout_port_type& parent_ )
+	: base_type( parent_ )
+	{}
+
+    sc_inout_rv( const char* name_, inout_port_type& parent_ )
+	: base_type( name_, parent_ )
+	{}
+
+    sc_inout_rv( this_type& parent_ )
+	: base_type( parent_ )
+	{}
+
+    sc_inout_rv( const char* name_, this_type& parent_ )
+	: base_type( name_, parent_ )
+	{}
+
+
+    // destructor (does nothing)
+
+    virtual ~sc_inout_rv()
+	{}
+
+
+    // write the new value
+
+    this_type& operator = ( const data_type& value_ )
+	{ (*this)->write( value_ ); return *this; }
+
+    this_type& operator = ( const in_if_type& interface_ )
+	{ (*this)->write( interface_.read() ); return *this; }
+
+    this_type& operator = ( const in_port_type& port_ )
+	{ (*this)->write( port_->read() ); return *this; }
+
+    this_type& operator = ( const inout_port_type& port_ )
+	{ (*this)->write( port_->read() ); return *this; }
+
+    this_type& operator = ( const this_type& port_ )
+	{ (*this)->write( port_->read() ); return *this; }
+
+
+    // called when elaboration is done
+    /*  WHEN DEFINING THIS METHOD IN A DERIVED CLASS, */
+    /*  MAKE SURE THAT THIS METHOD IS CALLED AS WELL. */
+
+    virtual void end_of_elaboration();
+
+    virtual const char* kind() const
+        { return "sc_inout_rv"; }
+
+private:
+
+    // disabled
+    sc_inout_rv( const this_type& );
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+
+// called when elaboration is done
+
+template <int W>
+void
+sc_inout_rv<W>::end_of_elaboration()
+{
+    base_type::end_of_elaboration();
+    // check if bound channel is a resolved signal
+    if( DCAST<sc_signal_rv<W>*>( this->get_interface() ) == 0 ) {
+	char msg[BUFSIZ];
+	std::sprintf( msg, "%s (%s)", this->name(), kind() );
+	SC_REPORT_ERROR( SC_ID_RESOLVED_PORT_NOT_BOUND_, msg );
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_out_rv<W>
+//
+//  The sc_signal_rv<W> output port class.
+// ----------------------------------------------------------------------------
+
+// sc_out_rv can also read from its port, hence no difference with
+// sc_inout_rv. For debugging reasons, a class is provided instead
+// of a define.
+
+template <int W>
+class sc_out_rv
+    : public sc_inout_rv<W>
+{
+public:
+
+    // typedefs
+
+    typedef sc_out_rv<W>                        this_type;
+    typedef sc_inout_rv<W>                      base_type;
+
+    typedef typename base_type::data_type       data_type;
+
+    typedef typename base_type::in_if_type      in_if_type;
+    typedef typename base_type::in_port_type    in_port_type;
+    typedef typename base_type::inout_if_type   inout_if_type;
+    typedef typename base_type::inout_port_type inout_port_type;
+
+public:
+
+    // constructors
+
+    sc_out_rv()
+	: base_type()
+	{}
+
+    explicit sc_out_rv( const char* name_ )
+	: base_type( name_ )
+	{}
+
+    explicit sc_out_rv( inout_if_type& interface_ )
+	: base_type( interface_ )
+	{}
+
+    sc_out_rv( const char* name_, inout_if_type& interface_ )
+	: base_type( name_, interface_ )
+	{}
+
+    explicit sc_out_rv( inout_port_type& parent_ )
+	: base_type( parent_ )
+	{}
+
+    sc_out_rv( const char* name_, inout_port_type& parent_ )
+	: base_type( name_, parent_ )
+	{}
+
+    sc_out_rv( this_type& parent_ )
+	: base_type( parent_ )
+	{}
+
+    sc_out_rv( const char* name_, this_type& parent_ )
+	: base_type( name_, parent_ )
+	{}
+
+
+    // destructor (does nothing)
+
+    virtual ~sc_out_rv()
+	{}
+
+
+    // write the new value
+
+    this_type& operator = ( const data_type& value_ )
+	{ (*this)->write( value_ ); return *this; }
+
+    this_type& operator = ( const in_if_type& interface_ )
+	{ (*this)->write( interface_.read() ); return *this; }
+
+    this_type& operator = ( const in_port_type& port_ )
+	{ (*this)->write( port_->read() ); return *this; }
+
+    this_type& operator = ( const inout_port_type& port_ )
+	{ (*this)->write( port_->read() ); return *this; }
+
+    this_type& operator = ( const this_type& port_ )
+	{ (*this)->write( port_->read() ); return *this; }
+
+    virtual const char* kind() const
+        { return "sc_out_rv"; }
+
+private:
+
+    // disabled
+    sc_out_rv( const this_type& );
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+} // namespace sc_core
+
+//$Log: sc_signal_rv_ports.h,v $
+//Revision 1.3  2011/08/26 20:45:44  acg
+// Andy Goodrich: moved the modification log to the end of the file to
+// eliminate source line number skew when check-ins are done.
+//
+//Revision 1.2  2011/02/18 20:23:45  acg
+// Andy Goodrich: Copyright update.
+//
+//Revision 1.1.1.1  2006/12/15 20:20:04  acg
+//SystemC 2.3
+//
+//Revision 1.2  2006/01/03 23:18:27  acg
+//Changed copyright to include 2006.
+//
+//Revision 1.1.1.1  2005/12/19 23:16:43  acg
+//First check in of SystemC 2.1 into its own archive.
+//
+//Revision 1.11  2005/09/15 23:01:52  acg
+//Added std:: prefix to appropriate methods and types to get around
+//issues with the Edison Front End.
+//
+//Revision 1.10  2005/06/10 22:43:56  acg
+//Added CVS change log annotation.
+//
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/communication/sc_writer_policy.h b/ext/systemc/src/sysc/communication/sc_writer_policy.h
new file mode 100644
index 000000000..93b80f861
--- /dev/null
+++ b/ext/systemc/src/sysc/communication/sc_writer_policy.h
@@ -0,0 +1,143 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_writer_policy.h -- The sc_signal<T> writer policy definition
+
+  Original Author: Philipp A: Hartmann, OFFIS
+
+  CHANGE LOG IS AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#ifndef SC_WRITER_POLICY_H_INCLUDED_
+#define SC_WRITER_POLICY_H_INCLUDED_
+
+#if !defined(SC_DEFAULT_WRITER_POLICY)
+#  if defined(SC_NO_WRITE_CHECK)
+#    define SC_DEFAULT_WRITER_POLICY SC_UNCHECKED_WRITERS
+#  else
+#    define SC_DEFAULT_WRITER_POLICY SC_ONE_WRITER
+#  endif
+#endif
+
+namespace sc_core {
+
+class sc_object;
+class sc_port_base;
+extern
+void
+sc_signal_invalid_writer( sc_object* target, sc_object* first_writer,
+                          sc_object* second_writer, bool check_delta );
+
+// SIGNAL WRITING POLICIES
+//
+// Note: if you add a new policy to the enum below you will need to add
+// an additional overload of sc_reset::reset_signal_is() for the sc_signal<bool>
+// instance. That will require changes to sysc/kernel/sc_reset.cpp and 
+// sysc/kernel/sc_reset.h
+
+enum sc_writer_policy
+{
+  SC_ONE_WRITER        = 0, ///< unique writer (from a unique port)
+  SC_MANY_WRITERS      = 1, ///< allow multiple writers (with different ports)
+  SC_UNCHECKED_WRITERS = 3  ///< even allow delta cycle conflicts (non-standard)
+};
+
+// signal forward declaration
+template< typename T, sc_writer_policy POL = SC_DEFAULT_WRITER_POLICY >
+class sc_signal;
+
+template< sc_writer_policy >
+struct sc_writer_policy_check;
+
+struct sc_writer_policy_nocheck_write
+{
+  bool check_write( sc_object* /* target */, bool /* value_changed */ )
+    { return true; }
+  void update(){}
+};
+
+struct sc_writer_policy_check_write
+{
+  bool check_write( sc_object* target, bool value_changed );
+  void update(){}
+protected:
+  sc_writer_policy_check_write( bool check_delta = false )
+    : m_check_delta( check_delta ), m_writer_p(NULL) {}
+  const bool         m_check_delta;
+  sc_object*         m_writer_p;
+};
+
+struct sc_writer_policy_check_delta
+    : sc_writer_policy_check_write
+{
+
+  sc_writer_policy_check_delta()
+    : sc_writer_policy_check_write(true) {}
+
+  bool check_write( sc_object* target, bool value_changed )
+  {
+      if( value_changed )
+          return sc_writer_policy_check_write::check_write( target, true );
+      return true;
+  }
+
+  void update(){ m_writer_p = NULL; }
+};
+
+struct sc_writer_policy_nocheck_port
+{
+  bool check_port( sc_object*, sc_port_base*, bool )
+    { return true; }
+};
+
+struct sc_writer_policy_check_port
+{
+  bool check_port( sc_object* target, sc_port_base* port, bool is_output );
+
+protected:
+  sc_writer_policy_check_port() : m_output(0) {}
+  sc_port_base* m_output;
+};
+
+template<>
+struct sc_writer_policy_check<SC_ONE_WRITER>
+  : sc_writer_policy_check_port
+  , sc_writer_policy_check_write
+{};
+
+template<>
+struct sc_writer_policy_check<SC_MANY_WRITERS>
+  : sc_writer_policy_nocheck_port
+  , sc_writer_policy_check_delta
+{};
+
+template<>
+struct sc_writer_policy_check<SC_UNCHECKED_WRITERS>
+  : sc_writer_policy_nocheck_port
+  , sc_writer_policy_nocheck_write
+{};
+
+} // namespace sc_core
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/bit/sc_bit.cpp b/ext/systemc/src/sysc/datatypes/bit/sc_bit.cpp
new file mode 100644
index 000000000..5401eaead
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/bit/sc_bit.cpp
@@ -0,0 +1,138 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_bit.cpp -- Bit class.
+
+  Original Author: Gene Bushuyev, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_bit.cpp,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.6  2006/04/12 20:17:52  acg
+//  Andy Goodrich: enabled deprecation message for sc_bit.
+//
+// Revision 1.5  2006/01/25 00:31:15  acg
+//  Andy Goodrich: Changed over to use a standard message id of
+//  SC_ID_IEEE_1666_DEPRECATION for all deprecation messages.
+//
+// Revision 1.4  2006/01/24 20:50:55  acg
+// Andy Goodrich: added warnings indicating that sc_bit is deprecated and that
+// the C bool data type should be used in its place.
+//
+// Revision 1.3  2006/01/13 18:53:53  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include "sysc/datatypes/bit/sc_bit.h"
+#include "sysc/datatypes/bit/sc_bit_ids.h"
+#include "sysc/utils/sc_utils_ids.h"
+#include "sysc/datatypes/bit/sc_logic.h"
+
+#include <cstdio>
+
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_bit
+//
+//  Bit class.
+//  Note: VSIA compatibility indicated.
+// ----------------------------------------------------------------------------
+
+// support methods
+
+void
+sc_bit::invalid_value( char c )
+{
+    char msg[BUFSIZ];
+    std::sprintf( msg, "sc_bit( '%c' )", c );
+    SC_REPORT_ERROR( sc_core::SC_ID_VALUE_NOT_VALID_, msg );
+}
+
+void
+sc_bit::invalid_value( int i )
+{
+    char msg[BUFSIZ];
+    std::sprintf( msg, "sc_bit( %d )", i );
+    SC_REPORT_ERROR( sc_core::SC_ID_VALUE_NOT_VALID_, msg );
+}
+
+
+// constructors
+
+sc_bit::sc_bit( const sc_logic& a )  // non-VSIA
+    : m_val( a.to_bool() )
+{
+   sc_deprecated_sc_bit();
+}
+
+
+// assignment operators
+
+sc_bit&
+sc_bit::operator = ( const sc_logic& b )  // non-VSIA
+{
+    return ( *this = sc_bit( b ) );
+}
+
+
+// other methods
+
+void
+sc_bit::scan( ::std::istream& is )
+{
+    bool b;
+    is >> b;
+    *this = b;
+}
+
+void sc_deprecated_sc_bit()
+{
+    static bool warn_sc_bit_deprecated=true;
+    if ( warn_sc_bit_deprecated )
+    {
+        warn_sc_bit_deprecated=false;
+	SC_REPORT_INFO(sc_core::SC_ID_IEEE_1666_DEPRECATION_,
+	    "sc_bit is deprecated, use bool instead");
+    }
+}
+
+} // namespace sc_dt
+
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/bit/sc_bit.h b/ext/systemc/src/sysc/datatypes/bit/sc_bit.h
new file mode 100644
index 000000000..2703971b6
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/bit/sc_bit.h
@@ -0,0 +1,407 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_bit.h -- Bit class.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_bit.h,v $
+// Revision 1.2  2011/08/07 18:54:19  acg
+//  Philipp A. Hartmann: remove friend function declarations that implement
+//  code, and clean up how bit and logic operators are defined in general.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.6  2006/05/08 17:49:59  acg
+//   Andy Goodrich: Added David Long's declarations for friend operators,
+//   functions, and methods, to keep the Microsoft compiler happy.
+//
+// Revision 1.5  2006/04/12 20:17:52  acg
+//  Andy Goodrich: enabled deprecation message for sc_bit.
+//
+// Revision 1.4  2006/01/24 20:50:55  acg
+// Andy Goodrich: added warnings indicating that sc_bit is deprecated and that
+// the C bool data type should be used in its place.
+//
+// Revision 1.3  2006/01/13 18:53:53  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SC_BIT_H
+#define SC_BIT_H
+
+
+#include "sysc/datatypes/int/sc_nbdefs.h"
+#include "sysc/utils/sc_iostream.h"
+
+
+namespace sc_dt
+{
+
+// classes defined in this module
+class sc_bit;
+
+// forward class declarations
+class sc_logic;
+
+extern void sc_deprecated_sc_bit();
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_bit
+//
+//  Bit class.
+//  Note: VSIA compatibility indicated.
+// ----------------------------------------------------------------------------
+
+class sc_bit
+{
+    // support methods
+
+    static void invalid_value( char );
+    static void invalid_value( int );
+
+    static bool to_value( char c )
+	{
+	    if( c != '0' && c != '1' ) {
+		invalid_value( c );
+	    }
+	    return ( c == '0' ? false : true );
+	}
+
+    static bool to_value( int i )
+	{
+	    if( i != 0 && i != 1 ) {
+		invalid_value( i );
+	    }
+	    return ( i == 0 ? false : true );
+	}
+    static bool to_value( bool b )
+       { return b; }
+
+#define DEFN_TO_VALUE_T(tp)              \
+    static bool to_value( tp i )         \
+       { return to_value( (int) i); }
+
+    DEFN_TO_VALUE_T(unsigned)
+    DEFN_TO_VALUE_T(long)
+    DEFN_TO_VALUE_T(unsigned long)
+    DEFN_TO_VALUE_T(int64)
+    DEFN_TO_VALUE_T(uint64)
+
+#undef DEFN_TO_VALUE_T
+
+public:
+
+    // constructors
+    // MANDATORY
+
+    sc_bit()
+	: m_val( false )
+	{
+	    sc_deprecated_sc_bit();
+	}
+
+#define DEFN_CTOR_T(tp)              \
+    explicit sc_bit( tp a )          \
+       : m_val( to_value(a) )       \
+       { sc_deprecated_sc_bit(); }
+
+    DEFN_CTOR_T(bool)
+    DEFN_CTOR_T(char)
+    DEFN_CTOR_T(int)
+    DEFN_CTOR_T(unsigned)
+    DEFN_CTOR_T(long)
+    DEFN_CTOR_T(unsigned long)
+    DEFN_CTOR_T(int64)
+    DEFN_CTOR_T(uint64)
+
+#undef DEFN_CTOR_T
+
+    explicit sc_bit( const sc_logic& a );  // non-VSIA
+
+
+    // copy constructor
+    // MANDATORY
+
+    sc_bit( const sc_bit& a )
+	: m_val( a.m_val )
+	{}
+
+
+    // destructor
+    // MANDATORY
+
+    ~sc_bit()
+	{}
+
+
+    // assignment operators
+    // MANDATORY
+
+    sc_bit& operator = ( const sc_bit& b )
+	{ m_val = b.m_val; return *this; }
+
+#define DEFN_ASN_OP_T(op,tp) \
+    sc_bit& operator op( tp b ) \
+       { return ( *this op sc_bit( b ) ); }
+#define DEFN_ASN_OP(op) \
+    DEFN_ASN_OP_T(op,int) \
+    DEFN_ASN_OP_T(op,bool) \
+    DEFN_ASN_OP_T(op,char)
+
+    DEFN_ASN_OP(=)
+    DEFN_ASN_OP_T(=,int64)
+    DEFN_ASN_OP_T(=,uint64)
+    DEFN_ASN_OP_T(=,long)
+    DEFN_ASN_OP_T(=,unsigned long)
+
+    sc_bit& operator = ( const sc_logic& b );  // non-VSIA
+
+
+    // bitwise assignment operators
+
+    sc_bit& operator &= ( const sc_bit& b )
+	{ m_val = ( m_val && b.m_val ); return *this; }
+
+    sc_bit& operator |= ( const sc_bit& b )
+	{ m_val = ( m_val || b.m_val ); return *this; }
+
+    sc_bit& operator ^= ( const sc_bit& b )
+	{ m_val = ( m_val != b.m_val ); return *this; }
+
+    DEFN_ASN_OP(&=)
+    DEFN_ASN_OP(|=)
+    DEFN_ASN_OP(^=)
+
+#undef DEFN_ASN_OP_T
+#undef DEFN_ASN_OP
+
+    // conversions
+    // MANDATORY
+
+    // implicit conversion to bool
+
+    operator bool () const
+	{ return m_val; }
+
+    bool operator ! () const  // non-VSIA
+	{ return ! m_val; }
+
+
+    // explicit conversions
+
+    bool to_bool() const  // non-VSIA
+	{ return m_val; }
+
+    char to_char() const
+	{ return ( m_val ? '1' : '0' ); }
+
+
+    // relational operators and functions
+
+    // MANDATORY
+
+    friend bool operator == ( const sc_bit& a, const sc_bit& b );
+    friend bool operator != ( const sc_bit& a, const sc_bit& b );
+
+    // bitwise operators and functions
+
+    // bitwise complement
+
+    // MANDATORY
+
+    friend const sc_bit operator ~ ( const sc_bit& a );
+
+    // RECOMMENDED
+
+    sc_bit& b_not()
+        { m_val = ( ! m_val ); return *this; }
+
+    // binary bit-wise operations
+
+    friend const sc_bit operator | ( const sc_bit& a, const sc_bit& b );
+    friend const sc_bit operator & ( const sc_bit& a, const sc_bit& b );
+    friend const sc_bit operator ^ ( const sc_bit& a, const sc_bit& b );
+
+    // other methods
+
+    void print( ::std::ostream& os = ::std::cout ) const
+       { os << to_bool(); }
+
+    void scan( ::std::istream& = ::std::cin );
+
+private:
+    bool m_val;
+};
+
+// ----------------------------------------------------------------------------
+// relational operators and functions
+
+#define DEFN_BIN_FUN_T(ret,fun,tp)          \
+    inline ret fun( const sc_bit& a, tp b ) \
+       { return fun(a, sc_bit(b) ); }      \
+    inline ret fun( tp b, const sc_bit& a ) \
+       { return fun( sc_bit(a), b ); }
+
+#define DEFN_BIN_FUN(ret,fun) \
+      DEFN_BIN_FUN_T(ret,fun,bool) \
+      DEFN_BIN_FUN_T(ret,fun,char) \
+      DEFN_BIN_FUN_T(ret,fun,int)
+
+// MANDATORY
+
+inline bool operator == ( const sc_bit& a, const sc_bit& b )
+    { return ( a.m_val == b.m_val ); }
+
+inline bool operator != ( const sc_bit& a, const sc_bit& b )
+    { return ( a.m_val != b.m_val ); }
+
+DEFN_BIN_FUN(bool,operator==)
+DEFN_BIN_FUN(bool,operator!=)
+
+// OPTIONAL
+
+inline bool equal( const sc_bit& a, const sc_bit& b )
+    { return ( a == b ); }
+
+inline bool not_equal( const sc_bit& a, const sc_bit& b )
+    { return ( a != b ); }
+
+DEFN_BIN_FUN(bool,equal)
+DEFN_BIN_FUN(bool,not_equal)
+
+// ----------------------------------------------------------------------------
+// bitwise operators and functions
+
+// bitwise complement
+
+    // MANDATORY
+
+    inline const sc_bit operator ~ ( const sc_bit& a )
+       { return sc_bit( ! a.m_val ); }
+
+
+    // OPTIONAL
+
+    inline const sc_bit b_not( const sc_bit& a )
+       { return ( ~ a ); }
+
+
+    // RECOMMENDED
+
+    inline void b_not( sc_bit& r, const sc_bit& a )
+       { r = ( ~ a ); }
+
+    // binary bit-wise operations
+
+    // MANDATORY
+
+    inline const sc_bit operator & ( const sc_bit& a, const sc_bit& b )
+        { return sc_bit( a.m_val && b.m_val ); }
+
+    inline const sc_bit operator | ( const sc_bit& a, const sc_bit& b )
+        { return sc_bit( a.m_val || b.m_val ); }
+
+    inline const sc_bit operator ^ ( const sc_bit& a, const sc_bit& b )
+        { return sc_bit( a.m_val != b.m_val ); }
+
+    DEFN_BIN_FUN(const sc_bit,operator&)
+    DEFN_BIN_FUN(const sc_bit,operator|)
+    DEFN_BIN_FUN(const sc_bit,operator^)
+
+    // OPTIONAL
+
+    inline const sc_bit b_and ( const sc_bit& a, const sc_bit& b )
+        { return a & b; }
+
+    inline const sc_bit b_or ( const sc_bit& a, const sc_bit& b )
+        { return a | b; }
+
+    inline const sc_bit b_xor ( const sc_bit& a, const sc_bit& b )
+        { return a ^ b; }
+
+    DEFN_BIN_FUN(const sc_bit,b_and)
+    DEFN_BIN_FUN(const sc_bit,b_or)
+    DEFN_BIN_FUN(const sc_bit,b_xor)
+
+    // RECOMMENDED
+
+#define DEFN_TRN_FUN_T(fun,tp)                                     \
+    inline void fun( sc_bit& r, const sc_bit& a, tp b )            \
+        { r = fun( a, sc_bit(b) ); }                               \
+    inline void fun( sc_bit& r, tp a, const sc_bit& b )            \
+        { r = fun( sc_bit(a), b ); }
+
+#define DEFN_TRN_FUN(fun) \
+    inline void fun( sc_bit& r, const sc_bit& a, const sc_bit& b ) \
+        { r = fun( a , b ); }                                      \
+    DEFN_TRN_FUN_T(fun,int)                                        \
+    DEFN_TRN_FUN_T(fun,bool)                                       \
+    DEFN_TRN_FUN_T(fun,char)
+
+    DEFN_TRN_FUN( b_and )
+    DEFN_TRN_FUN( b_or )
+    DEFN_TRN_FUN( b_xor )
+
+#undef DEFN_BIN_FUN_T
+#undef DEFN_BIN_FUN
+#undef DEFN_TRN_FUN_T
+#undef DEFN_TRN_FUN
+
+
+// ----------------------------------------------------------------------------
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_bit& a )
+{
+    a.print( os );
+    return os;
+}
+
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_bit& a )
+{
+    a.scan( is );
+    return is;
+}
+
+} // namespace sc_dt
+
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/bit/sc_bit_ids.h b/ext/systemc/src/sysc/datatypes/bit/sc_bit_ids.h
new file mode 100644
index 000000000..0e77e9078
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/bit/sc_bit_ids.h
@@ -0,0 +1,106 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_bit_ids.h -- Report ids for the datatypes/bit code.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2002-01-17
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+    
+ *****************************************************************************/
+
+// $Log: sc_bit_ids.h,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.5  2006/01/25 00:31:15  acg
+//  Andy Goodrich: Changed over to use a standard message id of
+//  SC_ID_IEEE_1666_DEPRECATION for all deprecation messages.
+//
+// Revision 1.4  2006/01/24 20:50:55  acg
+// Andy Goodrich: added warnings indicating that sc_bit is deprecated and that
+// the C bool data type should be used in its place.
+//
+// Revision 1.3  2006/01/13 18:53:53  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SC_BIT_IDS_H
+#define SC_BIT_IDS_H
+
+
+#include "sysc/utils/sc_report.h"
+
+
+// ----------------------------------------------------------------------------
+//  Report ids (datatypes/bit)
+//
+//  Report ids in the range of 200-299.
+// ----------------------------------------------------------------------------
+
+#ifndef SC_DEFINE_MESSAGE
+#define SC_DEFINE_MESSAGE(id,unused1,unused2) \
+    namespace sc_core { extern const char id[]; }
+namespace sc_core {
+    extern const char SC_ID_REGISTER_ID_FAILED_[]; // in sc_report_handler.cpp
+}
+#endif
+
+
+SC_DEFINE_MESSAGE( SC_ID_LENGTH_MISMATCH_, 200,
+		"length mismatch in bit/logic vector assignment" )
+SC_DEFINE_MESSAGE( SC_ID_INCOMPATIBLE_TYPES_, 201,
+		"incompatible types" )
+SC_DEFINE_MESSAGE( SC_ID_CANNOT_CONVERT_, 202,
+		"cannot perform conversion" )
+SC_DEFINE_MESSAGE( SC_ID_INCOMPATIBLE_VECTORS_, 203,
+		"incompatible vectors" )
+SC_DEFINE_MESSAGE( SC_ID_VALUE_NOT_VALID_, 204,
+		"value is not valid" )
+SC_DEFINE_MESSAGE( SC_ID_ZERO_LENGTH_,     205,
+		"zero length" )
+SC_DEFINE_MESSAGE( SC_ID_VECTOR_CONTAINS_LOGIC_VALUE_, 206,
+		"vector contains 4-value logic" )  
+SC_DEFINE_MESSAGE( SC_ID_SC_BV_CANNOT_CONTAIN_X_AND_Z_, 207,
+		"sc_bv cannot contain values X and Z" )
+SC_DEFINE_MESSAGE( SC_ID_VECTOR_TOO_LONG_,  208,
+		"vector is too long: truncated" )  
+SC_DEFINE_MESSAGE( SC_ID_VECTOR_TOO_SHORT_, 209,
+		"vector is too short: 0-padded" )  
+SC_DEFINE_MESSAGE( SC_ID_WRONG_VALUE_, 210,
+		"wrong value" )
+SC_DEFINE_MESSAGE( SC_ID_LOGIC_Z_TO_BOOL_, 211,
+		"sc_logic value 'Z' cannot be converted to bool" )
+SC_DEFINE_MESSAGE( SC_ID_LOGIC_X_TO_BOOL_, 212,
+		"sc_logic value 'X' cannot be converted to bool" )
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/bit/sc_bit_proxies.h b/ext/systemc/src/sysc/datatypes/bit/sc_bit_proxies.h
new file mode 100644
index 000000000..59d997181
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/bit/sc_bit_proxies.h
@@ -0,0 +1,3884 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_bit_proxies.h -- Proxy classes for vector data types.
+
+  Original Author: Gene Bushuyev, Synopsys, Inc.
+
+ CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_BIT_PROXIES_H
+#define SC_BIT_PROXIES_H
+
+
+#include "sysc/datatypes/bit/sc_bit_ids.h"
+#include "sysc/datatypes/bit/sc_proxy.h"
+
+
+namespace sc_dt
+{
+
+// classes defined in this module
+template <class X> class sc_bitref_r;
+template <class X> class sc_bitref;
+template <class X> class sc_subref_r;
+template <class X> class sc_subref;
+template <class X, class Y> class sc_concref_r;
+template <class X, class Y> class sc_concref;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_bitref_r<T>
+//
+//  Proxy class for sc_proxy bit selection (r-value only).
+// ----------------------------------------------------------------------------
+
+template <class T>
+class sc_bitref_r
+{
+    friend class sc_bv_base;
+    friend class sc_lv_base;
+
+public:
+
+    // typedefs
+
+    typedef typename T::traits_type          traits_type;
+    typedef typename traits_type::bit_type   bit_type;
+
+    // constructor
+
+    sc_bitref_r( const T& obj_, int index_ )
+	: m_obj( CCAST<T&>( obj_ ) ), m_index( index_ )
+	{}
+
+
+    // copy constructor
+
+    sc_bitref_r( const sc_bitref_r<T>& a )
+	: m_obj( a.m_obj ), m_index( a.m_index )
+	{}
+
+    // cloning
+
+    sc_bitref_r<T>* clone() const
+	{ return new sc_bitref_r<T>( *this ); }
+
+
+    // bitwise operators and functions
+
+    // bitwise complement
+
+    const bit_type operator ~ () const
+        { return bit_type( sc_logic::not_table[value()] ); }
+
+
+    // implicit conversion to bit_type
+
+    operator const bit_type() const
+        { return bit_type( m_obj.get_bit( m_index ) ); }
+
+
+    // explicit conversions
+
+    sc_logic_value_t value() const
+	{ return m_obj.get_bit( m_index ); }
+
+
+    bool is_01() const
+	{ return sc_logic( value() ).is_01(); }
+
+    bool to_bool() const
+	{ return sc_logic( value() ).to_bool(); }
+
+    char to_char() const
+	{ return sc_logic( value() ).to_char(); }
+
+
+    // common methods
+
+    int length() const
+	{ return 1; }
+
+    int size() const
+	{ return ( (length() - 1) / SC_DIGIT_SIZE + 1 ); }
+
+    sc_logic_value_t get_bit( int n ) const;
+
+    sc_digit get_word( int i ) const;
+    sc_digit get_cword( int i ) const;
+
+
+    // other methods
+
+    void print( ::std::ostream& os = ::std::cout ) const
+	{ os << to_char(); }
+
+protected:
+
+    T&  m_obj;
+    int m_index;
+
+private:
+
+    // disabled
+    sc_bitref_r();
+    sc_bitref_r<T>& operator = ( const sc_bitref_r<T>& );
+};
+
+
+// bitwise operators and functions
+
+// bitwise and
+
+template <class T1, class T2>
+inline
+const sc_logic
+operator & ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b );
+
+
+// bitwise or
+
+template <class T1, class T2>
+inline
+const sc_logic
+operator | ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b );
+
+
+// bitwise xor
+
+template <class T1, class T2>
+inline
+const sc_logic
+operator ^ ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b );
+
+
+// relational operators and functions
+
+template <class T1, class T2>
+inline
+bool
+operator == ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b );
+
+template <class T1, class T2>
+inline
+bool
+operator != ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b );
+
+
+// r-value concatenation operators and functions
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >
+operator , ( sc_bitref_r<T1>, sc_bitref_r<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >
+operator , ( sc_bitref_r<T1>, sc_subref_r<T2> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >
+operator , ( sc_bitref_r<T1>, sc_concref_r<T2,T3> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,T2>
+operator , ( sc_bitref_r<T1>, const sc_proxy<T2>& );
+
+template <class T>
+inline
+sc_concref_r<sc_bitref_r<T>,sc_lv_base>
+operator , ( sc_bitref_r<T>, const char* );
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_bitref_r<T> >
+operator , ( const char*, sc_bitref_r<T> );
+
+template <class T>
+inline
+sc_concref_r<sc_bitref_r<T>,sc_lv_base>
+operator , ( sc_bitref_r<T>, const sc_logic& );
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_bitref_r<T> >
+operator , ( const sc_logic&, sc_bitref_r<T> );
+
+template <class T>
+inline
+sc_concref_r<sc_bitref_r<T>,sc_lv_base>
+operator , ( sc_bitref_r<T>, bool );
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_bitref_r<T> >
+operator , ( bool, sc_bitref_r<T> );
+
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >
+concat( sc_bitref_r<T1>, sc_bitref_r<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >
+concat( sc_bitref_r<T1>, sc_subref_r<T2> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >
+concat( sc_bitref_r<T1>, sc_concref_r<T2,T3> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,T2>
+concat( sc_bitref_r<T1>, const sc_proxy<T2>& );
+
+template <class T>
+inline
+sc_concref_r<sc_bitref_r<T>,sc_lv_base>
+concat( sc_bitref_r<T>, const char* );
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_bitref_r<T> >
+concat( const char*, sc_bitref_r<T> );
+
+template <class T>
+inline
+sc_concref_r<sc_bitref_r<T>,sc_lv_base>
+concat( sc_bitref_r<T>, const sc_logic& );
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_bitref_r<T> >
+concat( const sc_logic&, sc_bitref_r<T> );
+
+template <class T>
+inline
+sc_concref_r<sc_bitref_r<T>,sc_lv_base>
+concat( sc_bitref_r<T>, bool );
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_bitref_r<T> >
+concat( bool, sc_bitref_r<T> );
+
+
+#ifdef SC_DT_MIXED_COMMA_OPERATORS
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >
+operator , ( sc_bitref_r<T1>, sc_bitref<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >
+operator , ( sc_bitref<T1>, sc_bitref_r<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >
+operator , ( sc_bitref_r<T1>, sc_subref<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >
+operator , ( sc_bitref<T1>, sc_subref_r<T2> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >
+operator , ( sc_bitref_r<T1>, sc_concref<T2,T3> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >
+operator , ( sc_bitref<T1>, sc_concref_r<T2,T3> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,T2>
+operator , ( sc_bitref<T1>, const sc_proxy<T2>& );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,T2>
+operator , ( sc_bitref_r<T1>, sc_proxy<T2>& );
+
+template <class T>
+inline
+sc_concref_r<sc_bitref_r<T>,sc_lv_base>
+operator , ( sc_bitref<T>, const char* );
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_bitref_r<T> >
+operator , ( const char*, sc_bitref<T> );
+
+template <class T>
+inline
+sc_concref_r<sc_bitref_r<T>,sc_lv_base>
+operator , ( sc_bitref<T>, const sc_logic& );
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_bitref_r<T> >
+operator , ( const sc_logic&, sc_bitref<T> );
+
+template <class T>
+inline
+sc_concref_r<sc_bitref_r<T>,sc_lv_base>
+operator , ( sc_bitref<T>, bool );
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_bitref_r<T> >
+operator , ( bool, sc_bitref<T> );
+
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >
+concat( sc_bitref_r<T1>, sc_bitref<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >
+concat( sc_bitref<T1>, sc_bitref_r<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >
+concat( sc_bitref_r<T1>, sc_subref<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >
+concat( sc_bitref<T1>, sc_subref_r<T2> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >
+concat( sc_bitref_r<T1>, sc_concref<T2,T3> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >
+concat( sc_bitref<T1>, sc_concref_r<T2,T3> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,T2>
+concat( sc_bitref<T1>, const sc_proxy<T2>& );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,T2>
+concat( sc_bitref_r<T1>, sc_proxy<T2>& );
+
+template <class T>
+inline
+sc_concref_r<sc_bitref_r<T>,sc_lv_base>
+concat( sc_bitref<T>, const char* );
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_bitref_r<T> >
+concat( const char*, sc_bitref<T> );
+
+template <class T>
+inline
+sc_concref_r<sc_bitref_r<T>,sc_lv_base>
+concat( sc_bitref<T>, const sc_logic& );
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_bitref_r<T> >
+concat( const sc_logic&, sc_bitref<T> );
+
+template <class T>
+inline
+sc_concref_r<sc_bitref_r<T>,sc_lv_base>
+concat( sc_bitref<T>, bool );
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_bitref_r<T> >
+concat( bool, sc_bitref<T> );
+
+#endif
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_bitref<X>
+//
+//  Proxy class for sc_proxy bit selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+template <class X>
+class sc_bitref
+    : public sc_bitref_r<X>
+{
+    friend class sc_bv_base;
+    friend class sc_lv_base;
+
+public:
+
+    // constructor
+
+    sc_bitref( X& obj_, int index_ )
+	: sc_bitref_r<X>( obj_, index_ )
+	{}
+
+
+    // copy constructor
+
+    sc_bitref( const sc_bitref<X>& a )
+	: sc_bitref_r<X>( a )
+	{}
+
+
+    // cloning
+
+    sc_bitref<X>* clone() const
+	{ return new sc_bitref<X>( *this ); }
+
+
+    // assignment operators
+
+    sc_bitref<X>& operator = ( const sc_bitref_r<X>& a );
+    sc_bitref<X>& operator = ( const sc_bitref<X>& a );
+
+    sc_bitref<X>& operator = ( const sc_logic& a )
+	{ this->m_obj.set_bit( this->m_index, a.value() ); return *this; }
+
+    sc_bitref<X>& operator = ( sc_logic_value_t v )
+	{ *this = sc_logic( v ); return *this; }
+
+    sc_bitref<X>& operator = ( bool a )
+	{ *this = sc_logic( a ); return *this; }
+
+    sc_bitref<X>& operator = ( char a )
+	{ *this = sc_logic( a ); return *this; }
+
+    sc_bitref<X>& operator = ( int a )
+	{ *this = sc_logic( a ); return *this; }
+
+    sc_bitref<X>& operator = ( const sc_bit& a )
+	{ *this = sc_logic( a ); return *this; }
+
+
+    // bitwise assignment operators
+
+    sc_bitref<X>& operator &= ( const sc_bitref_r<X>& a );
+    sc_bitref<X>& operator &= ( const sc_logic& a );
+
+    sc_bitref<X>& operator &= ( sc_logic_value_t v )
+	{ *this &= sc_logic( v ); return *this; }
+
+    sc_bitref<X>& operator &= ( bool a )
+	{ *this &= sc_logic( a ); return *this; }
+
+    sc_bitref<X>& operator &= ( char a )
+	{ *this &= sc_logic( a ); return *this; }
+
+    sc_bitref<X>& operator &= ( int a )
+	{ *this &= sc_logic( a ); return *this; }
+
+
+    sc_bitref<X>& operator |= ( const sc_bitref_r<X>& a );
+    sc_bitref<X>& operator |= ( const sc_logic& a );
+
+    sc_bitref<X>& operator |= ( sc_logic_value_t v )
+	{ *this |= sc_logic( v ); return *this; }
+
+    sc_bitref<X>& operator |= ( bool a )
+	{ *this |= sc_logic( a ); return *this; }
+
+    sc_bitref<X>& operator |= ( char a )
+	{ *this |= sc_logic( a ); return *this; }
+
+    sc_bitref<X>& operator |= ( int a )
+	{ *this |= sc_logic( a ); return *this; }
+
+
+    sc_bitref<X>& operator ^= ( const sc_bitref_r<X>& a );
+    sc_bitref<X>& operator ^= ( const sc_logic& a );
+
+    sc_bitref<X>& operator ^= ( sc_logic_value_t v )
+	{ *this ^= sc_logic( v ); return *this; }
+
+    sc_bitref<X>& operator ^= ( bool a )
+	{ *this ^= sc_logic( a ); return *this; }
+
+    sc_bitref<X>& operator ^= ( char a )
+	{ *this ^= sc_logic( a ); return *this; }
+
+    sc_bitref<X>& operator ^= ( int a )
+	{ *this ^= sc_logic( a ); return *this; }
+
+
+    // bitwise operators and functions
+
+    // bitwise complement
+
+    sc_bitref<X>& b_not();
+
+
+    // common methods
+
+    void set_bit( int n, sc_logic_value_t value );
+
+    void set_word( int i, sc_digit w );
+    void set_cword( int i, sc_digit w );
+
+    void clean_tail()
+	{ this->m_obj.clean_tail(); }
+
+
+    // other methods
+
+    void scan( ::std::istream& is = ::std::cin );
+
+private:
+
+    // disabled
+    sc_bitref();
+};
+
+
+// l-value concatenation operators and functions
+
+template <class T1, class T2>
+inline
+sc_concref<sc_bitref<T1>,sc_bitref<T2> >
+operator , ( sc_bitref<T1>, sc_bitref<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref<sc_bitref<T1>,sc_subref<T2> >
+operator , ( sc_bitref<T1>, sc_subref<T2> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref<sc_bitref<T1>,sc_concref<T2,T3> >
+operator , ( sc_bitref<T1>, sc_concref<T2,T3> );
+
+template <class T1, class T2>
+inline
+sc_concref<sc_bitref<T1>,T2>
+operator , ( sc_bitref<T1>, sc_proxy<T2>& );
+
+
+template <class T1, class T2>
+inline
+sc_concref<sc_bitref<T1>,sc_bitref<T2> >
+concat( sc_bitref<T1>, sc_bitref<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref<sc_bitref<T1>,sc_subref<T2> >
+concat( sc_bitref<T1>, sc_subref<T2> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref<sc_bitref<T1>,sc_concref<T2,T3> >
+concat( sc_bitref<T1>, sc_concref<T2,T3> );
+
+template <class T1, class T2>
+inline
+sc_concref<sc_bitref<T1>,T2>
+concat( sc_bitref<T1>, sc_proxy<T2>& );
+
+
+template <class T>
+::std::istream&
+operator >> ( ::std::istream&, sc_bitref<T> );
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_subref_r<X>
+//
+//  Proxy class for sc_proxy part selection (r-value only).
+// ----------------------------------------------------------------------------
+
+template <class X>
+class sc_subref_r
+    : public sc_proxy<sc_subref_r<X> >
+{
+    void check_bounds();
+
+public:
+
+    // constructor
+
+    sc_subref_r( const X& obj_, int hi_, int lo_ )
+	: m_obj( CCAST<X&>( obj_ ) ), m_hi( hi_ ), m_lo( lo_ ), m_len( 0 )
+	{ check_bounds(); }
+
+
+    // copy constructor
+
+    sc_subref_r( const sc_subref_r<X>& a )
+	: m_obj( a.m_obj ), m_hi( a.m_hi ), m_lo( a.m_lo ), m_len( a.m_len )
+	{}
+
+
+    // cloning
+
+    sc_subref_r<X>* clone() const
+	{ return new sc_subref_r<X>( *this ); }
+
+
+    // common methods
+
+    int length() const
+	{ return m_len; }
+
+    int size() const
+	{ return ( (length() - 1) / SC_DIGIT_SIZE + 1 ); }
+
+    sc_logic_value_t get_bit( int n ) const;
+    void set_bit( int n, sc_logic_value_t value );
+
+    sc_digit get_word( int i )const;
+    void set_word( int i, sc_digit w );
+
+    sc_digit get_cword( int i ) const;
+    void set_cword( int i, sc_digit w );
+
+    void clean_tail()
+	{ m_obj.clean_tail(); }
+
+
+    // other methods
+
+    bool is_01() const;
+
+    bool reversed() const
+	{ return m_lo > m_hi; }
+
+protected:
+
+    X&  m_obj;
+    int m_hi;
+    int m_lo;
+    int m_len;
+
+private:
+
+    // disabled
+    sc_subref_r();
+    sc_subref_r<X>& operator = ( const sc_subref_r<X>& );
+};
+
+
+// r-value concatenation operators and functions
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >
+operator , ( sc_subref_r<T1>, sc_bitref_r<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >
+operator , ( sc_subref_r<T1>, sc_subref_r<T2> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >
+operator , ( sc_subref_r<T1>, sc_concref_r<T2,T3> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,T2>
+operator , ( sc_subref_r<T1>, const sc_proxy<T2>& );
+
+template <class T>
+inline
+sc_concref_r<sc_subref_r<T>,sc_lv_base>
+operator , ( sc_subref_r<T>, const char* );
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_subref_r<T> >
+operator , ( const char*, sc_subref_r<T> );
+
+template <class T>
+inline
+sc_concref_r<sc_subref_r<T>,sc_lv_base>
+operator , ( sc_subref_r<T>, const sc_logic& );
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_subref_r<T> >
+operator , ( const sc_logic&, sc_subref_r<T> );
+
+template <class T>
+inline
+sc_concref_r<sc_subref_r<T>,sc_bv_base>
+operator , ( sc_subref_r<T>, bool );
+
+template <class T>
+inline
+sc_concref_r<sc_bv_base,sc_subref_r<T> >
+operator , ( bool, sc_subref_r<T> );
+
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >
+concat( sc_subref_r<T1>, sc_bitref_r<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >
+concat( sc_subref_r<T1>, sc_subref_r<T2> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >
+concat( sc_subref_r<T1>, sc_concref_r<T2,T3> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,T2>
+concat( sc_subref_r<T1>, const sc_proxy<T2>& );
+
+template <class T>
+inline
+sc_concref_r<sc_subref_r<T>,sc_lv_base>
+concat( sc_subref_r<T>, const char* );
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_subref_r<T> >
+concat( const char*, sc_subref_r<T> );
+
+template <class T>
+inline
+sc_concref_r<sc_subref_r<T>,sc_lv_base>
+concat( sc_subref_r<T>, const sc_logic& );
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_subref_r<T> >
+concat( const sc_logic&, sc_subref_r<T> );
+
+template <class T>
+inline
+sc_concref_r<sc_subref_r<T>,sc_bv_base>
+concat( sc_subref_r<T>, bool );
+
+template <class T>
+inline
+sc_concref_r<sc_bv_base,sc_subref_r<T> >
+concat( bool, sc_subref_r<T> );
+
+
+#ifdef SC_DT_MIXED_COMMA_OPERATORS
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >
+operator , ( sc_subref_r<T1>, sc_bitref<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >
+operator , ( sc_subref<T1>, sc_bitref_r<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >
+operator , ( sc_subref_r<T1>, sc_subref<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >
+operator , ( sc_subref<T1>, sc_subref_r<T2> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >
+operator , ( sc_subref_r<T1>, sc_concref<T2,T3> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >
+operator , ( sc_subref<T1>, sc_concref_r<T2,T3> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,T2>
+operator , ( sc_subref<T1>, const sc_proxy<T2>& );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,T2>
+operator , ( sc_subref_r<T1>, sc_proxy<T2>& );
+
+template <class T>
+inline
+sc_concref_r<sc_subref_r<T>,sc_lv_base>
+operator , ( sc_subref<T>, const char* );
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_subref_r<T> >
+operator , ( const char*, sc_subref<T> );
+
+template <class T>
+inline
+sc_concref_r<sc_subref_r<T>,sc_lv_base>
+operator , ( sc_subref<T>, const sc_logic& );
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_subref_r<T> >
+operator , ( const sc_logic&, sc_subref<T> );
+
+template <class T>
+inline
+sc_concref_r<sc_subref_r<T>,sc_bv_base>
+operator , ( sc_subref<T>, bool );
+
+template <class T>
+inline
+sc_concref_r<sc_bv_base,sc_subref_r<T> >
+operator , ( bool, sc_subref<T> );
+
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >
+concat( sc_subref_r<T1>, sc_bitref<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >
+concat( sc_subref<T1>, sc_bitref_r<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >
+concat( sc_subref_r<T1>, sc_subref<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >
+concat( sc_subref<T1>, sc_subref_r<T2> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >
+concat( sc_subref_r<T1>, sc_concref<T2,T3> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >
+concat( sc_subref<T1>, sc_concref_r<T2,T3> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,T2>
+concat( sc_subref<T1>, const sc_proxy<T2>& );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,T2>
+concat( sc_subref_r<T1>, sc_proxy<T2>& );
+
+template <class T>
+inline
+sc_concref_r<sc_subref_r<T>,sc_lv_base>
+concat( sc_subref<T>, const char* );
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_subref_r<T> >
+concat( const char*, sc_subref<T> );
+
+template <class T>
+inline
+sc_concref_r<sc_subref_r<T>,sc_lv_base>
+concat( sc_subref<T>, const sc_logic& );
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_subref_r<T> >
+concat( const sc_logic&, sc_subref<T> );
+
+template <class T>
+inline
+sc_concref_r<sc_subref_r<T>,sc_bv_base>
+concat( sc_subref<T>, bool );
+
+template <class T>
+inline
+sc_concref_r<sc_bv_base,sc_subref_r<T> >
+concat( bool, sc_subref<T> );
+
+#endif
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_subref<X>
+//
+//  Proxy class for sc_proxy part selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+template <class X>
+class sc_subref
+    : public sc_subref_r<X>
+{
+public:
+
+    // typedefs
+
+    typedef sc_subref_r<X> base_type;
+
+
+    // constructor
+
+    sc_subref( X& obj_, int hi_, int lo_ )
+	: sc_subref_r<X>( obj_, hi_, lo_ )
+	{}
+
+
+    // copy constructor
+
+    sc_subref( const sc_subref<X>& a )
+	: sc_subref_r<X>( a )
+	{}
+
+
+    // cloning
+
+    sc_subref<X>* clone() const
+	{ return new sc_subref<X>( *this ); }
+
+
+    // assignment operators
+
+    template <class Y>
+    sc_subref<X>& operator = ( const sc_proxy<Y>& a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_subref<X>& operator = ( const sc_subref_r<X>& a );
+    sc_subref<X>& operator = ( const sc_subref<X>& a );
+
+    sc_subref<X>& operator = ( const char* a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_subref<X>& operator = ( const bool* a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_subref<X>& operator = ( const sc_logic* a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_subref<X>& operator = ( const sc_unsigned& a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_subref<X>& operator = ( const sc_signed& a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_subref<X>& operator = ( const sc_uint_base& a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_subref<X>& operator = ( const sc_int_base& a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_subref<X>& operator = ( unsigned long a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_subref<X>& operator = ( long a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_subref<X>& operator = ( unsigned int a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_subref<X>& operator = ( int a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_subref<X>& operator = ( uint64 a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_subref<X>& operator = ( int64 a )
+	{ base_type::assign_( a ); return *this; }
+
+
+    // other methods
+
+    void scan( ::std::istream& = ::std::cin );
+
+private:
+
+    // disabled
+    sc_subref();
+};
+
+
+// l-value concatenation operators and functions
+
+template <class T1, class T2>
+inline
+sc_concref<sc_subref<T1>,sc_bitref<T2> >
+operator , ( sc_subref<T1>, sc_bitref<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref<sc_subref<T1>,sc_subref<T2> >
+operator , ( sc_subref<T1>, sc_subref<T2> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref<sc_subref<T1>,sc_concref<T2,T3> >
+operator , ( sc_subref<T1>, sc_concref<T2,T3> );
+
+template <class T1, class T2>
+inline
+sc_concref<sc_subref<T1>,T2>
+operator , ( sc_subref<T1>, sc_proxy<T2>& );
+
+
+template <class T1, class T2>
+inline
+sc_concref<sc_subref<T1>,sc_bitref<T2> >
+concat( sc_subref<T1>, sc_bitref<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref<sc_subref<T1>,sc_subref<T2> >
+concat( sc_subref<T1>, sc_subref<T2> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref<sc_subref<T1>,sc_concref<T2,T3> >
+concat( sc_subref<T1>, sc_concref<T2,T3> );
+
+template <class T1, class T2>
+inline
+sc_concref<sc_subref<T1>,T2>
+concat( sc_subref<T1>, sc_proxy<T2>& );
+
+
+template <class T>
+inline
+::std::istream&
+operator >> ( ::std::istream&, sc_subref<T> );
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_concref_r<X,Y>
+//
+//  Proxy class for sc_proxy concatenation (r-value only).
+// ----------------------------------------------------------------------------
+
+template <class X, class Y>
+class sc_concref_r
+    : public sc_proxy<sc_concref_r<X,Y> >
+{
+public:
+
+    // constructor
+
+    sc_concref_r( const X& left_, const Y& right_, int delete_ = 0 )
+	: m_left( CCAST<X&>( left_ ) ), m_right( CCAST<Y&>( right_ ) ),
+	  m_delete( delete_ ), m_refs( *new int( 1 ) )
+	{}
+
+
+    // copy constructor
+
+    sc_concref_r( const sc_concref_r<X,Y>& a )
+	: m_left( a.m_left ), m_right( a.m_right ),
+	  m_delete( a.m_delete ), m_refs( a.m_refs )
+	{ ++ m_refs; }
+
+
+    // destructor
+
+    virtual ~sc_concref_r();
+
+
+    // cloning
+
+    sc_concref_r<X,Y>* clone() const
+	{ return new sc_concref_r<X,Y>( *this ); }
+
+
+    // common methods
+
+    int length() const
+	{ return ( m_left.length() + m_right.length() ); }
+
+    int size() const
+	{ return ( (length() - 1) / SC_DIGIT_SIZE + 1 ); }
+
+    sc_logic_value_t get_bit( int n ) const;
+    void set_bit( int n, sc_logic_value_t value );
+
+    sc_digit get_word( int i ) const;
+    void set_word( int i, sc_digit w );
+
+    sc_digit get_cword( int i ) const;
+    void set_cword( int i, sc_digit w );
+
+    void clean_tail()
+	{ m_left.clean_tail(); m_right.clean_tail(); }
+
+
+    // other methods
+
+    bool is_01() const
+	{ return ( m_left.is_01() && m_right.is_01() ); }
+
+protected:
+
+    X&           m_left;
+    Y&           m_right;
+    mutable int  m_delete;
+    int&         m_refs;
+
+private:
+
+    // disabled
+    sc_concref_r();
+    sc_concref_r<X,Y>& operator = ( const sc_concref_r<X,Y>& );
+};
+
+
+// r-value concatenation operators and functions
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >
+operator , ( sc_concref_r<T1,T2>, sc_bitref_r<T3> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >
+operator , ( sc_concref_r<T1,T2>, sc_subref_r<T3> );
+
+template <class T1, class T2, class T3, class T4>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >
+operator , ( sc_concref_r<T1,T2>, sc_concref_r<T3,T4> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,T3>
+operator , ( sc_concref_r<T1,T2>, const sc_proxy<T3>& );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
+operator , ( sc_concref_r<T1,T2>, const char* );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
+operator , ( const char*, sc_concref_r<T1,T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
+operator , ( sc_concref_r<T1,T2>, const sc_logic& );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
+operator , ( const sc_logic&, sc_concref_r<T1,T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_bv_base>
+operator , ( sc_concref_r<T1,T2>, bool );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bv_base,sc_concref_r<T1,T2> >
+operator , ( bool, sc_concref_r<T1,T2> );
+
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >
+concat( sc_concref_r<T1,T2>, sc_bitref_r<T3> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >
+concat( sc_concref_r<T1,T2>, sc_subref_r<T3> );
+
+template <class T1, class T2, class T3, class T4>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >
+concat( sc_concref_r<T1,T2>, sc_concref_r<T3,T4> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,T3>
+concat( sc_concref_r<T1,T2>, const sc_proxy<T3>& );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
+concat( sc_concref_r<T1,T2>, const char* );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
+concat( const char*, sc_concref_r<T1,T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
+concat( sc_concref_r<T1,T2>, const sc_logic& );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
+concat( const sc_logic&, sc_concref_r<T1,T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_bv_base>
+concat( sc_concref_r<T1,T2>, bool );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bv_base,sc_concref_r<T1,T2> >
+concat( bool, sc_concref_r<T1,T2> );
+
+
+#ifdef SC_DT_MIXED_COMMA_OPERATORS
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >
+operator , ( sc_concref_r<T1,T2>, sc_bitref<T3> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >
+operator , ( sc_concref<T1,T2>, sc_bitref_r<T3> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >
+operator , ( sc_concref_r<T1,T2>, sc_subref<T3> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >
+operator , ( sc_concref<T1,T2>, sc_subref_r<T3> );
+
+template <class T1, class T2, class T3, class T4>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >
+operator , ( sc_concref_r<T1,T2>, sc_concref<T3,T4> );
+
+template <class T1, class T2, class T3, class T4>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >
+operator , ( sc_concref<T1,T2>, sc_concref_r<T3,T4> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,T3>
+operator , ( sc_concref<T1,T2>, const sc_proxy<T3>& );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,T3>
+operator , ( sc_concref_r<T1,T2>, sc_proxy<T3>& );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
+operator , ( sc_concref<T1,T2>, const char* );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
+operator , ( const char*, sc_concref<T1,T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
+operator , ( sc_concref<T1,T2>, const sc_logic& );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
+operator , ( const sc_logic&, sc_concref<T1,T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_bv_base>
+operator , ( sc_concref<T1,T2>, bool );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bv_base,sc_concref_r<T1,T2> >
+operator , ( bool, sc_concref<T1,T2> );
+
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >
+concat( sc_concref_r<T1,T2>, sc_bitref<T3> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >
+concat( sc_concref<T1,T2>, sc_bitref_r<T3> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >
+concat( sc_concref_r<T1,T2>, sc_subref<T3> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >
+concat( sc_concref<T1,T2>, sc_subref_r<T3> );
+
+template <class T1, class T2, class T3, class T4>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >
+concat( sc_concref_r<T1,T2>, sc_concref<T3,T4> );
+
+template <class T1, class T2, class T3, class T4>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >
+concat( sc_concref<T1,T2>, sc_concref_r<T3,T4> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,T3>
+concat( sc_concref<T1,T2>, const sc_proxy<T3>& );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,T3>
+concat( sc_concref_r<T1,T2>, sc_proxy<T3>& );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
+concat( sc_concref<T1,T2>, const char* );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
+concat( const char*, sc_concref<T1,T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
+concat( sc_concref<T1,T2>, const sc_logic& );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
+concat( const sc_logic&, sc_concref<T1,T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_bv_base>
+concat( sc_concref<T1,T2>, bool );
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bv_base,sc_concref_r<T1,T2> >
+concat( bool, sc_concref<T1,T2> );
+
+#endif
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_concref<X,Y>
+//
+//  Proxy class for sc_proxy concatenation (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+template <class X, class Y>
+class sc_concref
+    : public sc_concref_r<X,Y>
+{
+public:
+
+    // typedefs
+
+    typedef sc_concref_r<X,Y> base_type;
+
+
+    // constructor
+
+    sc_concref( X& left_, Y& right_, int delete_ = 0 )
+	: sc_concref_r<X,Y>( left_, right_, delete_ )
+	{}
+
+
+    // copy constructor
+
+    sc_concref( const sc_concref<X,Y>& a )
+	: sc_concref_r<X,Y>( a )
+	{}
+
+
+    // cloning
+
+    sc_concref<X,Y>* clone() const
+	{ return new sc_concref<X,Y>( *this ); }
+
+
+    // assignment operators
+
+    template <class Z>
+    sc_concref<X,Y>& operator = ( const sc_proxy<Z>& a )
+        { base_type::assign_( a ); return *this; }
+
+    sc_concref<X,Y>& operator = ( const sc_concref<X,Y>& a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_concref<X,Y>& operator = ( const char* a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_concref<X,Y>& operator = ( const bool* a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_concref<X,Y>& operator = ( const sc_logic* a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_concref<X,Y>& operator = ( const sc_unsigned& a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_concref<X,Y>& operator = ( const sc_signed& a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_concref<X,Y>& operator = ( const sc_uint_base& a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_concref<X,Y>& operator = ( const sc_int_base& a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_concref<X,Y>& operator = ( unsigned long a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_concref<X,Y>& operator = ( long a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_concref<X,Y>& operator = ( unsigned int a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_concref<X,Y>& operator = ( int a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_concref<X,Y>& operator = ( uint64 a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_concref<X,Y>& operator = ( int64 a )
+	{ base_type::assign_( a ); return *this; }
+
+
+    // other methods
+
+    void scan( ::std::istream& = ::std::cin );
+
+private:
+
+    // disabled
+    sc_concref();
+};
+
+
+// l-value concatenation operators and functions
+
+template <class T1, class T2, class T3>
+inline
+sc_concref<sc_concref<T1,T2>,sc_bitref<T3> >
+operator , ( sc_concref<T1,T2>, sc_bitref<T3> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref<sc_concref<T1,T2>,sc_subref<T3> >
+operator , ( sc_concref<T1,T2>, sc_subref<T3> );
+
+template <class T1, class T2, class T3, class T4>
+inline
+sc_concref<sc_concref<T1,T2>,sc_concref<T3,T4> >
+operator , ( sc_concref<T1,T2>, sc_concref<T3,T4> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref<sc_concref<T1,T2>,T3>
+operator , ( sc_concref<T1,T2>, sc_proxy<T3>& );
+
+
+template <class T1, class T2, class T3>
+inline
+sc_concref<sc_concref<T1,T2>,sc_bitref<T3> >
+concat( sc_concref<T1,T2>, sc_bitref<T3> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref<sc_concref<T1,T2>,sc_subref<T3> >
+concat( sc_concref<T1,T2>, sc_subref<T3> );
+
+template <class T1, class T2, class T3, class T4>
+inline
+sc_concref<sc_concref<T1,T2>,sc_concref<T3,T4> >
+concat( sc_concref<T1,T2>, sc_concref<T3,T4> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref<sc_concref<T1,T2>,T3>
+concat( sc_concref<T1,T2>, sc_proxy<T3>& );
+
+
+template <class T1, class T2>
+inline
+::std::istream&
+operator >> ( ::std::istream&, sc_concref<T1,T2> );
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_proxy<T>
+//
+//  Base class template for bit/logic vector classes.
+//  (Barton/Nackmann implementation)
+// ----------------------------------------------------------------------------
+
+// r-value concatenation operators and functions
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,sc_bitref_r<T2> >
+operator , ( const sc_proxy<T1>&, sc_bitref_r<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,sc_subref_r<T2> >
+operator , ( const sc_proxy<T1>&, sc_subref_r<T2> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<T1,sc_concref_r<T2,T3> >
+operator , ( const sc_proxy<T1>&, sc_concref_r<T2,T3> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,T2>
+operator , ( const sc_proxy<T1>&, const sc_proxy<T2>& );
+
+template <class T>
+inline
+sc_concref_r<T,sc_lv_base>
+operator , ( const sc_proxy<T>&, const char* );
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,T>
+operator , ( const char*, const sc_proxy<T>& );
+
+template <class T>
+inline
+sc_concref_r<T,sc_lv_base>
+operator , ( const sc_proxy<T>&, const sc_logic& );
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,T>
+operator , ( const sc_logic&, const sc_proxy<T>& );
+
+template <class T>
+inline
+sc_concref_r<T,sc_bv_base>
+operator , ( const sc_proxy<T>&, bool );
+
+template <class T>
+inline
+sc_concref_r<sc_bv_base,T>
+operator , ( bool, const sc_proxy<T>& );
+
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,sc_bitref_r<T2> >
+concat( const sc_proxy<T1>&, sc_bitref_r<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,sc_subref_r<T2> >
+concat( const sc_proxy<T1>&, sc_subref_r<T2> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<T1,sc_concref_r<T2,T3> >
+concat( const sc_proxy<T1>&, sc_concref_r<T2,T3> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,T2>
+concat( const sc_proxy<T1>&, const sc_proxy<T2>& );
+
+template <class T>
+inline
+sc_concref_r<T,sc_lv_base>
+concat( const sc_proxy<T>&, const char* );
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,T>
+concat( const char*, const sc_proxy<T>& );
+
+template <class T>
+inline
+sc_concref_r<T,sc_lv_base>
+concat( const sc_proxy<T>&, const sc_logic& );
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,T>
+concat( const sc_logic&, const sc_proxy<T>& );
+
+template <class T>
+inline
+sc_concref_r<T,sc_bv_base>
+concat( const sc_proxy<T>&, bool );
+
+template <class T>
+inline
+sc_concref_r<sc_bv_base,T>
+concat( bool, const sc_proxy<T>& );
+
+
+#ifdef SC_DT_MIXED_COMMA_OPERATORS
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,sc_bitref_r<T2> >
+operator , ( const sc_proxy<T1>&, sc_bitref<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,sc_bitref_r<T2> >
+operator , ( sc_proxy<T1>&, sc_bitref_r<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,sc_subref_r<T2> >
+operator , ( const sc_proxy<T1>&, sc_subref<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,sc_subref_r<T2> >
+operator , ( sc_proxy<T1>&, sc_subref_r<T2> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<T1,sc_concref_r<T2,T3> >
+operator , ( const sc_proxy<T1>&, sc_concref<T2,T3> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<T1,sc_concref_r<T2,T3> >
+operator , ( sc_proxy<T1>&, sc_concref_r<T2,T3> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,T2>
+operator , ( const sc_proxy<T1>&, sc_proxy<T2>& );
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,T2>
+operator , ( sc_proxy<T1>&, const sc_proxy<T2>& );
+
+template <class T>
+inline
+sc_concref_r<T,sc_lv_base>
+operator , ( sc_proxy<T>&, const char* );
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,T>
+operator , ( const char*, sc_proxy<T>& );
+
+template <class T>
+inline
+sc_concref_r<T,sc_lv_base>
+operator , ( sc_proxy<T>&, const sc_logic& );
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,T>
+operator , ( const sc_logic&, sc_proxy<T>& );
+
+template <class T>
+inline
+sc_concref_r<T,sc_bv_base>
+operator , ( sc_proxy<T>&, bool );
+
+template <class T>
+inline
+sc_concref_r<sc_bv_base,T>
+operator , ( bool, sc_proxy<T>& );
+
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,sc_bitref_r<T2> >
+concat( const sc_proxy<T1>&, sc_bitref<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,sc_bitref_r<T2> >
+concat( sc_proxy<T1>&, sc_bitref_r<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,sc_subref_r<T2> >
+concat( const sc_proxy<T1>&, sc_subref<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,sc_subref_r<T2> >
+concat( sc_proxy<T1>&, sc_subref_r<T2> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<T1,sc_concref_r<T2,T3> >
+concat( const sc_proxy<T1>&, sc_concref<T2,T3> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<T1,sc_concref_r<T2,T3> >
+concat( sc_proxy<T1>&, sc_concref_r<T2,T3> );
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,T2>
+concat( const sc_proxy<T1>&, sc_proxy<T2>& );
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,T2>
+concat( sc_proxy<T1>&, const sc_proxy<T2>& );
+
+template <class T>
+inline
+sc_concref_r<T,sc_lv_base>
+concat( sc_proxy<T>&, const char* );
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,T>
+concat( const char*, sc_proxy<T>& );
+
+template <class T>
+inline
+sc_concref_r<T,sc_lv_base>
+concat( sc_proxy<T>&, const sc_logic& );
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,T>
+concat( const sc_logic&, sc_proxy<T>& );
+
+template <class T>
+inline
+sc_concref_r<T,sc_bv_base>
+concat( sc_proxy<T>&, bool );
+
+template <class T>
+inline
+sc_concref_r<sc_bv_base,T>
+concat( bool, sc_proxy<T>& );
+
+#endif
+
+
+// l-value concatenation operators and functions
+
+template <class T1, class T2>
+inline
+sc_concref<T1,sc_bitref<T2> >
+operator , ( sc_proxy<T1>&, sc_bitref<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref<T1,sc_subref<T2> >
+operator , ( sc_proxy<T1>&, sc_subref<T2> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref<T1,sc_concref<T2,T3> >
+operator , ( sc_proxy<T1>&, sc_concref<T2,T3> );
+
+template <class T1, class T2>
+inline
+sc_concref<T1,T2>
+operator , ( sc_proxy<T1>&, sc_proxy<T2>& );
+
+
+template <class T1, class T2>
+inline
+sc_concref<T1,sc_bitref<T2> >
+concat( sc_proxy<T1>&, sc_bitref<T2> );
+
+template <class T1, class T2>
+inline
+sc_concref<T1,sc_subref<T2> >
+concat( sc_proxy<T1>&, sc_subref<T2> );
+
+template <class T1, class T2, class T3>
+inline
+sc_concref<T1,sc_concref<T2,T3> >
+concat( sc_proxy<T1>&, sc_concref<T2,T3> );
+
+template <class T1, class T2>
+inline
+sc_concref<T1,T2>
+concat( sc_proxy<T1>&, sc_proxy<T2>& );
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_bitref_r<T>
+//
+//  Proxy class for sc_proxy bit selection (r-value only).
+// ----------------------------------------------------------------------------
+
+// bitwise operators and functions
+
+// bitwise and
+
+template <class T1, class T2>
+inline
+const sc_logic
+operator & ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b )
+{
+    return sc_logic( sc_logic::and_table[a.value()][b.value()] );
+}
+
+
+// bitwise or
+
+template <class T1, class T2>
+inline
+const sc_logic
+operator | ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b )
+{
+    return sc_logic( sc_logic::or_table[a.value()][b.value()] );
+}
+
+
+// bitwise xor
+
+template <class T1, class T2>
+inline
+const sc_logic
+operator ^ ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b )
+{
+    return sc_logic( sc_logic::xor_table[a.value()][b.value()] );
+}
+
+
+// relational operators and functions
+
+template <class T1, class T2>
+inline
+bool
+operator == ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b )
+{
+    return ( (int) a.value() == b.value() );
+}
+
+template <class T1, class T2>
+inline
+bool
+operator != ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b )
+{
+    return ( (int) a.value() != b.value() );
+}
+
+
+// common methods
+
+template <class T>
+inline
+sc_logic_value_t
+sc_bitref_r<T>::get_bit( int n ) const
+{
+    if( n == 0 ) {
+	return m_obj.get_bit( m_index );
+    } else {
+	SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_ , 0 );
+        // never reached
+	return Log_0;
+    }
+}
+
+
+template <class T>
+inline
+sc_digit
+sc_bitref_r<T>::get_word( int n ) const
+{
+    if( n == 0 ) {
+	return ( get_bit( n ) & SC_DIGIT_ONE );
+    } else {
+	SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 );
+	// never reached
+	return 0;
+    }
+}
+
+template <class T>
+inline
+sc_digit
+sc_bitref_r<T>::get_cword( int n ) const
+{
+    if( n == 0 ) {
+	return ( (get_bit( n ) & SC_DIGIT_TWO) >> 1 );
+    } else {
+	SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 );
+	// never reached
+	return 0;
+    }
+}
+
+
+// r-value concatenation operators and functions
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >
+operator , ( sc_bitref_r<T1> a, sc_bitref_r<T2> b )
+{
+    return sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >
+operator , ( sc_bitref_r<T1> a, sc_subref_r<T2> b )
+{
+    return sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >
+operator , ( sc_bitref_r<T1> a, sc_concref_r<T2,T3> b )
+{
+    return sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,T2>
+operator , ( sc_bitref_r<T1> a, const sc_proxy<T2>& b )
+{
+    return sc_concref_r<sc_bitref_r<T1>,T2>(
+	*a.clone(), b.back_cast(), 1 );
+}
+
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >
+concat( sc_bitref_r<T1> a, sc_bitref_r<T2> b )
+{
+    return sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >
+concat( sc_bitref_r<T1> a, sc_subref_r<T2> b )
+{
+    return sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >
+concat( sc_bitref_r<T1> a, sc_concref_r<T2,T3> b )
+{
+    return sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,T2>
+concat( sc_bitref_r<T1> a, const sc_proxy<T2>& b )
+{
+    return sc_concref_r<sc_bitref_r<T1>,T2>(
+	*a.clone(), b.back_cast(), 1 );
+}
+
+
+#ifdef SC_DT_MIXED_COMMA_OPERATORS
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >
+operator , ( sc_bitref_r<T1> a, sc_bitref<T2> b )
+{
+    return sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >
+operator , ( sc_bitref<T1> a, sc_bitref_r<T2> b )
+{
+    return sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >
+operator , ( sc_bitref_r<T1> a, sc_subref<T2> b )
+{
+    return sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >
+operator , ( sc_bitref<T1> a, sc_subref_r<T2> b )
+{
+    return sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >
+operator , ( sc_bitref_r<T1> a, sc_concref<T2,T3> b )
+{
+    return sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >
+operator , ( sc_bitref<T1> a, sc_concref_r<T2,T3> b )
+{
+    return sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,T2>
+operator , ( sc_bitref<T1> a, const sc_proxy<T2>& b )
+{
+    return sc_concref_r<sc_bitref_r<T1>,T2>(
+	*a.clone(), b.back_cast(), 1 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,T2>
+operator , ( sc_bitref_r<T1> a, sc_proxy<T2>& b )
+{
+    return sc_concref_r<sc_bitref_r<T1>,T2>(
+	*a.clone(), b.back_cast(), 1 );
+}
+
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >
+concat( sc_bitref_r<T1> a, sc_bitref<T2> b )
+{
+    return sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >
+concat( sc_bitref<T1> a, sc_bitref_r<T2> b )
+{
+    return sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >
+concat( sc_bitref_r<T1> a, sc_subref<T2> b )
+{
+    return sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >
+concat( sc_bitref<T1> a, sc_subref_r<T2> b )
+{
+    return sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >
+concat( sc_bitref_r<T1> a, sc_concref<T2,T3> b )
+{
+    return sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >
+concat( sc_bitref<T1> a, sc_concref_r<T2,T3> b )
+{
+    return sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,T2>
+concat( sc_bitref<T1> a, const sc_proxy<T2>& b )
+{
+    return sc_concref_r<sc_bitref_r<T1>,T2>(
+	*a.clone(), b.back_cast(), 1 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bitref_r<T1>,T2>
+concat( sc_bitref_r<T1> a, sc_proxy<T2>& b )
+{
+    return sc_concref_r<sc_bitref_r<T1>,T2>(
+	*a.clone(), b.back_cast(), 1 );
+}
+
+#endif
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_bitref<X>
+//
+//  Proxy class for sc_proxy bit selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+// assignment operators
+
+template <class X>
+inline
+sc_bitref<X>&
+sc_bitref<X>::operator = ( const sc_bitref_r<X>& a )
+{
+    this->m_obj.set_bit( this->m_index, a.value() );
+	return *this;
+}
+
+template <class X>
+inline
+sc_bitref<X>&
+sc_bitref<X>::operator = ( const sc_bitref<X>& a )
+{
+    if( &a != this ) {
+	this->m_obj.set_bit( this->m_index, a.value() );
+    }
+    return *this;
+}
+
+
+// bitwise assignment operators
+
+template <class X>
+inline
+sc_bitref<X>&
+sc_bitref<X>::operator &= ( const sc_bitref_r<X>& a )
+{
+    if( &a != this ) {
+	this->m_obj.set_bit( this->m_index,
+			     sc_logic::and_table[this->value()][a.value()] );
+    }
+    return *this;
+}
+
+template <class X>
+inline
+sc_bitref<X>&
+sc_bitref<X>::operator &= ( const sc_logic& a )
+{
+    this->m_obj.set_bit( this->m_index,
+			 sc_logic::and_table[this->value()][a.value()] );
+    return *this;
+}
+
+
+template <class X>
+inline
+sc_bitref<X>&
+sc_bitref<X>::operator |= ( const sc_bitref_r<X>& a )
+{
+    if( &a != this ) {
+	this->m_obj.set_bit( this->m_index,
+			     sc_logic::or_table[this->value()][a.value()] );
+    }
+    return *this;
+}
+
+template <class X>
+inline
+sc_bitref<X>&
+sc_bitref<X>::operator |= ( const sc_logic& a )
+{
+    this->m_obj.set_bit( this->m_index,
+			 sc_logic::or_table[this->value()][a.value()] );
+    return *this;
+}
+
+
+template <class X>
+inline
+sc_bitref<X>&
+sc_bitref<X>::operator ^= ( const sc_bitref_r<X>& a )
+{
+    if( &a != this ) {
+	this->m_obj.set_bit( this->m_index,
+			     sc_logic::xor_table[this->value()][a.value()] );
+    }
+    return *this;
+}
+
+template <class X>
+inline
+sc_bitref<X>&
+sc_bitref<X>::operator ^= ( const sc_logic& a )
+{
+    this->m_obj.set_bit( this->m_index,
+			 sc_logic::xor_table[this->value()][a.value()] );
+    return *this;
+}
+
+
+// bitwise operators and functions
+
+// bitwise complement
+
+template <class X>
+inline
+sc_bitref<X>&
+sc_bitref<X>::b_not()
+{
+    this->m_obj.set_bit( this->m_index,
+			 sc_logic::not_table[this->value()] );
+    return *this;
+}
+
+
+// common methods
+
+template <class X>
+inline
+void
+sc_bitref<X>::set_bit( int n, sc_logic_value_t value )
+{
+    if( n == 0 ) {
+	this->m_obj.set_bit( this->m_index, value );
+    } else {
+	SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 );
+    }
+}
+
+template <class X>
+inline
+void
+sc_bitref<X>::set_word( int n, sc_digit w )
+{
+    unsigned int bi = this->m_index % (8*sizeof(sc_digit));
+    sc_digit     temp;
+    unsigned int wi = this->m_index / (8*sizeof(sc_digit));
+    if( n == 0 ) {
+        temp = this->m_obj.get_word(wi);
+        temp = (temp & ~(1 << bi)) | ((w&1) << bi);
+        this->m_obj.set_word(wi, temp);
+    } else {
+        SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 );
+    }
+
+}
+
+template <class X>
+inline
+void
+sc_bitref<X>::set_cword( int n, sc_digit w )
+{
+    unsigned int bi = this->m_index % (8*sizeof(sc_digit));
+    sc_digit     temp;
+    unsigned int wi = this->m_index / (8*sizeof(sc_digit));
+    if( n == 0 ) {
+        temp = this->m_obj.get_cword(wi);
+        temp = (temp & ~(1 << bi)) | ((w&1) << bi);
+        this->m_obj.set_cword(wi, temp);
+    } else {
+        SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 );
+    }
+}
+
+// other methods
+
+template <class X>
+inline
+void
+sc_bitref<X>::scan( ::std::istream& is )
+{
+    char c;
+    is >> c;
+    *this = c;
+}
+
+
+// l-value concatenation operators and functions
+
+template <class T1, class T2>
+inline
+sc_concref<sc_bitref<T1>,sc_bitref<T2> >
+operator , ( sc_bitref<T1> a, sc_bitref<T2> b )
+{
+    return sc_concref<sc_bitref<T1>,sc_bitref<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref<sc_bitref<T1>,sc_subref<T2> >
+operator , ( sc_bitref<T1> a, sc_subref<T2> b )
+{
+    return sc_concref<sc_bitref<T1>,sc_subref<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref<sc_bitref<T1>,sc_concref<T2,T3> >
+operator , ( sc_bitref<T1> a, sc_concref<T2,T3> b )
+{
+    return sc_concref<sc_bitref<T1>,sc_concref<T2,T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref<sc_bitref<T1>,T2>
+operator , ( sc_bitref<T1> a, sc_proxy<T2>& b )
+{
+    return sc_concref<sc_bitref<T1>,T2>(
+	*a.clone(), b.back_cast(), 1 );
+}
+
+
+template <class T1, class T2>
+inline
+sc_concref<sc_bitref<T1>,sc_bitref<T2> >
+concat( sc_bitref<T1> a, sc_bitref<T2> b )
+{
+    return sc_concref<sc_bitref<T1>,sc_bitref<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref<sc_bitref<T1>,sc_subref<T2> >
+concat( sc_bitref<T1> a, sc_subref<T2> b )
+{
+    return sc_concref<sc_bitref<T1>,sc_subref<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref<sc_bitref<T1>,sc_concref<T2,T3> >
+concat( sc_bitref<T1> a, sc_concref<T2,T3> b )
+{
+    return sc_concref<sc_bitref<T1>,sc_concref<T2,T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref<sc_bitref<T1>,T2>
+concat( sc_bitref<T1> a, sc_proxy<T2>& b )
+{
+    return sc_concref<sc_bitref<T1>,T2>(
+	*a.clone(), b.back_cast(), 1 );
+}
+
+
+template <class X>
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_bitref<X> a )
+{
+    a.scan( is );
+    return is;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_subref_r<X>
+//
+//  Proxy class for sc_proxy part selection (r-value only).
+// ----------------------------------------------------------------------------
+
+template <class X>
+inline
+void
+sc_subref_r<X>::check_bounds()
+{
+    int len = m_obj.length();
+    if( m_hi < 0 || m_hi >= len || m_lo < 0 || m_lo >= len ) {
+	SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 );
+    }
+    if( reversed() ) {
+	m_len = m_lo - m_hi + 1;
+    } else {
+	m_len = m_hi - m_lo + 1;
+    }
+}
+
+
+// common methods
+
+template <class X>
+inline
+sc_logic_value_t
+sc_subref_r<X>::get_bit( int n ) const
+{
+    if( reversed() ) {
+	return m_obj.get_bit( m_lo - n );
+    } else {
+	return m_obj.get_bit( m_lo + n );
+    }
+}
+
+template <class X>
+inline
+void
+sc_subref_r<X>::set_bit( int n, sc_logic_value_t value )
+{
+    if( reversed() ) {
+	m_obj.set_bit( m_lo - n, value );
+    } else {
+	m_obj.set_bit( m_lo + n, value );
+    }
+}
+
+
+template <class X>
+inline
+sc_digit
+sc_subref_r<X>::get_word( int i ) const
+{
+    int n1 = 0;
+    int n2 = 0;
+    sc_digit result = 0;
+    int k = 0;
+    if( reversed() ) {
+	n1 = m_lo - i * SC_DIGIT_SIZE;
+	n2 = sc_max( n1 - SC_DIGIT_SIZE, m_hi - 1 );
+	for( int n = n1; n > n2; n -- ) {
+	    result |= (m_obj[n].value() & SC_DIGIT_ONE) << k ++;
+	}
+    } else {
+	n1 = m_lo + i * SC_DIGIT_SIZE;
+	n2 = sc_min( n1 + SC_DIGIT_SIZE, m_hi + 1 );
+	for( int n = n1; n < n2; n ++ ) {
+	    result |= (m_obj[n].value() & SC_DIGIT_ONE) << k ++;
+	}
+    }
+    return result;
+}
+
+template <class X>
+inline
+void
+sc_subref_r<X>::set_word( int i, sc_digit w )
+{
+    int n1 = 0;
+    int n2 = 0;
+    int k = 0;
+    if( reversed() ) {
+	n1 = m_lo - i * SC_DIGIT_SIZE;
+	n2 = sc_max( n1 - SC_DIGIT_SIZE, m_hi - 1 );
+	for( int n = n1; n > n2; n -- ) {
+	    m_obj.set_bit( n, sc_logic_value_t( 
+	                              ( (w >> k ++) & SC_DIGIT_ONE ) |
+				      ( m_obj[n].value() & SC_DIGIT_TWO ) ) );
+	}
+    } else {
+	n1 = m_lo + i * SC_DIGIT_SIZE;
+	n2 = sc_min( n1 + SC_DIGIT_SIZE, m_hi + 1 );
+	for( int n = n1; n < n2; n ++ ) {
+	    m_obj.set_bit( n, sc_logic_value_t( 
+	                                ( (w >> k ++) & SC_DIGIT_ONE ) |
+					( m_obj[n].value() & SC_DIGIT_TWO ) ) );
+	}
+    }
+}
+
+
+template <class X>
+inline
+sc_digit
+sc_subref_r<X>::get_cword( int i ) const
+{
+    int n1 = 0;
+    int n2 = 0;
+    sc_digit result = 0;
+    int k = 0;
+    if( reversed() ) {
+	n1 = m_lo - i * SC_DIGIT_SIZE;
+	n2 = sc_max( n1 - SC_DIGIT_SIZE, m_hi - 1 );
+	for( int n = n1; n > n2; n -- ) {
+	    result |= ((m_obj[n].value() & SC_DIGIT_TWO) >> 1) << k ++;
+	}
+    } else {
+	n1 = m_lo + i * SC_DIGIT_SIZE;
+	n2 = sc_min( n1 + SC_DIGIT_SIZE, m_hi + 1 );
+	for( int n = n1; n < n2; n ++ ) {
+	    result |= ((m_obj[n].value() & SC_DIGIT_TWO) >> 1) << k ++;
+	}
+    }
+    return result;
+}
+
+template <class X>
+inline
+void
+sc_subref_r<X>::set_cword( int i, sc_digit w )
+{
+    int n1 = 0;
+    int n2 = 0;
+    int k = 0;
+    if( reversed() ) {
+	n1 = m_lo - i * SC_DIGIT_SIZE;
+	n2 = sc_max( n1 - SC_DIGIT_SIZE, m_hi - 1 );
+	for( int n = n1; n > n2; n -- ) {
+	    m_obj.set_bit( n, sc_logic_value_t( 
+	                             ( ((w >> k ++) & SC_DIGIT_ONE) << 1 ) |
+				     ( m_obj[n].value() & SC_DIGIT_ONE ) ) );
+	}
+    } else {
+	n1 = m_lo + i * SC_DIGIT_SIZE;
+	n2 = sc_min( n1 + SC_DIGIT_SIZE, m_hi + 1 );
+	for( int n = n1; n < n2; n ++ ) {
+	    m_obj.set_bit( n, sc_logic_value_t( 
+	                                ( ((w >> k ++) & SC_DIGIT_ONE) << 1 ) |
+					( m_obj[n].value() & SC_DIGIT_ONE ) ) );
+	}
+    }
+}
+
+
+// other methods
+
+template <class X>
+inline
+bool
+sc_subref_r<X>::is_01() const
+{
+    int sz = size();
+    for( int i = 0; i < sz; ++ i ) {
+	if( get_cword( i ) != SC_DIGIT_ZERO ) {
+	    return false;
+	}
+    }
+    return true;
+}
+
+
+// r-value concatenation operators and functions
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >
+operator , ( sc_subref_r<T1> a, sc_bitref_r<T2> b )
+{
+    return sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >
+operator , ( sc_subref_r<T1> a, sc_subref_r<T2> b )
+{
+    return sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >
+operator , ( sc_subref_r<T1> a, sc_concref_r<T2,T3> b )
+{
+    return sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,T2>
+operator , ( sc_subref_r<T1> a, const sc_proxy<T2>& b )
+{
+    return sc_concref_r<sc_subref_r<T1>,T2>(
+	*a.clone(), b.back_cast(), 1 );
+}
+
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >
+concat( sc_subref_r<T1> a, sc_bitref_r<T2> b )
+{
+    return sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >
+concat( sc_subref_r<T1> a, sc_subref_r<T2> b )
+{
+    return sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >
+concat( sc_subref_r<T1> a, sc_concref_r<T2,T3> b )
+{
+    return sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,T2>
+concat( sc_subref_r<T1> a, const sc_proxy<T2>& b )
+{
+    return sc_concref_r<sc_subref_r<T1>,T2>(
+	*a.clone(), b.back_cast(), 1 );
+}
+
+
+#ifdef SC_DT_MIXED_COMMA_OPERATORS
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >
+operator , ( sc_subref_r<T1> a, sc_bitref<T2> b )
+{
+    return sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >
+operator , ( sc_subref<T1> a, sc_bitref_r<T2> b )
+{
+    return sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >
+operator , ( sc_subref_r<T1> a, sc_subref<T2> b )
+{
+    return sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >
+operator , ( sc_subref<T1> a, sc_subref_r<T2> b )
+{
+    return sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >
+operator , ( sc_subref_r<T1> a, sc_concref<T2,T3> b )
+{
+    return sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >
+operator , ( sc_subref<T1> a, sc_concref_r<T2,T3> b )
+{
+    return sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,T2>
+operator , ( sc_subref<T1> a, const sc_proxy<T2>& b )
+{
+    return sc_concref_r<sc_subref_r<T1>,T2>(
+	*a.clone(), b.back_cast(), 1 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,T2>
+operator , ( sc_subref_r<T1> a, sc_proxy<T2>& b )
+{
+    return sc_concref_r<sc_subref_r<T1>,T2>(
+	*a.clone(), b.back_cast(), 1 );
+}
+
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >
+concat( sc_subref_r<T1> a, sc_bitref<T2> b )
+{
+    return sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >
+concat( sc_subref<T1> a, sc_bitref_r<T2> b )
+{
+    return sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >
+concat( sc_subref_r<T1> a, sc_subref<T2> b )
+{
+    return sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >
+concat( sc_subref<T1> a, sc_subref_r<T2> b )
+{
+    return sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >
+concat( sc_subref_r<T1> a, sc_concref<T2,T3> b )
+{
+    return sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >
+concat( sc_subref<T1> a, sc_concref_r<T2,T3> b )
+{
+    return sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,T2>
+concat( sc_subref<T1> a, const sc_proxy<T2>& b )
+{
+    return sc_concref_r<sc_subref_r<T1>,T2>(
+	*a.clone(), b.back_cast(), 1 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_subref_r<T1>,T2>
+concat( sc_subref_r<T1> a, sc_proxy<T2>& b )
+{
+    return sc_concref_r<sc_subref_r<T1>,T2>(
+	*a.clone(), b.back_cast(), 1 );
+}
+
+#endif
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_subref<X>
+//
+//  Proxy class for sc_proxy part selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+// assignment operators
+
+// sc_subref<X>::operator = ( const sc_subref_r<X>& ) in sc_lv_base.h
+// sc_subref<X>::operator = ( const sc_subref<X>& )   in sc_lv_base.h
+
+
+// other methods
+
+template <class T>
+inline
+void
+sc_subref<T>::scan( ::std::istream& is )
+{
+    std::string s;
+    is >> s;
+    *this = s.c_str();
+}
+
+
+// l-value concatenation operators and functions
+
+template <class T1, class T2>
+inline
+sc_concref<sc_subref<T1>,sc_bitref<T2> >
+operator , ( sc_subref<T1> a, sc_bitref<T2> b )
+{
+    return sc_concref<sc_subref<T1>,sc_bitref<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref<sc_subref<T1>,sc_subref<T2> >
+operator , ( sc_subref<T1> a, sc_subref<T2> b )
+{
+    return sc_concref<sc_subref<T1>,sc_subref<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref<sc_subref<T1>,sc_concref<T2,T3> >
+operator , ( sc_subref<T1> a, sc_concref<T2,T3> b )
+{
+    return sc_concref<sc_subref<T1>,sc_concref<T2,T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref<sc_subref<T1>,T2>
+operator , ( sc_subref<T1> a, sc_proxy<T2>& b )
+{
+    return sc_concref<sc_subref<T1>,T2>(
+	*a.clone(), b.back_cast(), 1 );
+}
+
+
+template <class T1, class T2>
+inline
+sc_concref<sc_subref<T1>,sc_bitref<T2> >
+concat( sc_subref<T1> a, sc_bitref<T2> b )
+{
+    return sc_concref<sc_subref<T1>,sc_bitref<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref<sc_subref<T1>,sc_subref<T2> >
+concat( sc_subref<T1> a, sc_subref<T2> b )
+{
+    return sc_concref<sc_subref<T1>,sc_subref<T2> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref<sc_subref<T1>,sc_concref<T2,T3> >
+concat( sc_subref<T1> a, sc_concref<T2,T3> b )
+{
+    return sc_concref<sc_subref<T1>,sc_concref<T2,T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref<sc_subref<T1>,T2>
+concat( sc_subref<T1> a, sc_proxy<T2>& b )
+{
+    return sc_concref<sc_subref<T1>,T2>(
+	*a.clone(), b.back_cast(), 1 );
+}
+
+
+template <class X>
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_subref<X> a )
+{
+    a.scan( is );
+    return is;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_concref_r<X,Y>
+//
+//  Proxy class for sc_proxy concatenation (r-value only).
+// ----------------------------------------------------------------------------
+
+// destructor
+
+template <class X, class Y>
+inline
+sc_concref_r<X,Y>::~sc_concref_r()
+{
+    if( -- m_refs == 0 ) {
+	delete &m_refs;
+	if( m_delete == 0 ) {
+	    return;
+	}
+	if( m_delete & 1 ) {
+	    delete &m_left;
+	}
+	if( m_delete & 2 ) {
+	    delete &m_right;
+	}
+    }
+}
+
+
+// common methods
+
+template <class X, class Y>
+inline
+sc_logic_value_t
+sc_concref_r<X,Y>::get_bit( int n ) const
+{
+    int r_len = m_right.length();
+    if( n < r_len ) {
+	return m_right.get_bit( n );
+    } else if( n < r_len + m_left.length() ) {
+	return m_left.get_bit( n - r_len );
+    } else {
+	SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 );
+	// never reached
+	return Log_0;
+    }
+}
+
+template <class X, class Y>
+inline
+void
+sc_concref_r<X,Y>::set_bit( int n, sc_logic_value_t v )
+{
+    int r_len = m_right.length();
+    if( n < r_len ) {
+	m_right.set_bit( n, v );
+    } else if( n < r_len + m_left.length() ) {
+	m_left.set_bit( n - r_len, v );
+    } else {
+	SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 );
+    }
+}
+
+
+template <class X, class Y>
+inline
+sc_digit
+sc_concref_r<X,Y>::get_word( int i ) const
+{
+    if( i < 0 || i >= size() ) {
+	SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 );
+    }
+    // 0 <= i < size()
+    Y& r = m_right;
+    int r_len = r.length();
+    int border = r_len / SC_DIGIT_SIZE;
+    if( i < border ) {
+	return r.get_word( i );
+    }
+    // border <= i < size()
+    X& l = m_left;
+    int shift = r_len % SC_DIGIT_SIZE;
+    int j = i - border;
+    if( shift == 0 ) {
+	return l.get_word( j );
+    }
+    // border <= i < size() && shift != 0
+    int nshift = SC_DIGIT_SIZE - shift;
+    if( i == border ) {
+	sc_digit rl_mask = ~SC_DIGIT_ZERO >> nshift;
+	return ( (r.get_word( i ) & rl_mask) | (l.get_word( 0 ) << shift) );
+    }
+    // border < i < size() && shift != 0
+    if ( j < l.size() )
+	return ( (l.get_word( j - 1 ) >> nshift) | (l.get_word( j ) << shift) );
+    else
+	return (l.get_word( j - 1 ) >> nshift);
+}
+
+template <class X, class Y>
+inline
+void
+sc_concref_r<X,Y>::set_word( int i, sc_digit w )
+{
+    if( i < 0 || i >= size() ) {
+	SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 );
+    }
+    // 0 <= i < size()
+    Y& r = m_right;
+    int r_len = r.length();
+    int border = r_len / SC_DIGIT_SIZE;
+    if( i < border ) {
+	r.set_word( i, w );
+	return;
+    }
+    // border <= i < size()
+    X& l = m_left;
+    int shift = r_len % SC_DIGIT_SIZE;
+    int j = i - border;
+    if( shift == 0 ) {
+	l.set_word( j, w );
+	return;
+    }
+    // border <= i < size() && shift != 0
+    int nshift = SC_DIGIT_SIZE - shift;
+    sc_digit lh_mask = ~SC_DIGIT_ZERO << nshift;
+    if( i == border ) {
+	sc_digit rl_mask = ~SC_DIGIT_ZERO >> nshift;
+	r.set_word( i, w & rl_mask );
+	l.set_word( 0, (l.get_word( 0 ) & lh_mask) | (w >> shift) );
+	return;
+    }
+    // border < i < size() && shift != 0
+    sc_digit ll_mask = ~SC_DIGIT_ZERO >> shift;
+    l.set_word( j - 1, (l.get_word( j - 1 ) & ll_mask) | (w << nshift) );
+    if ( j < l.size() )
+	l.set_word( j, (l.get_word( j ) & lh_mask) | (w >> shift) );
+}
+
+
+template <class X, class Y>
+inline
+sc_digit
+sc_concref_r<X,Y>::get_cword( int i ) const
+{
+    if( i < 0 || i >= size() ) {
+	SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 );
+    }
+    // 0 <= i < size()
+    Y& r = m_right;
+    int r_len = r.length();
+    int border = r_len / SC_DIGIT_SIZE;
+    if( i < border ) {
+	return r.get_cword( i );
+    }
+    // border <= i < size()
+    X& l = m_left;
+    int shift = r_len % SC_DIGIT_SIZE;
+    int j = i - border;
+    if( shift == 0 ) {
+	return l.get_cword( j );
+    }
+    // border <= i < size() && shift != 0
+    int nshift = SC_DIGIT_SIZE - shift;
+    if( i == border ) {
+	sc_digit rl_mask = ~SC_DIGIT_ZERO >> nshift;
+	return ( (r.get_cword( i ) & rl_mask) | (l.get_cword( 0 ) << shift) );
+    }
+    // border < i < size() && shift != 0
+    if ( j < l.size() )
+	return ( (l.get_cword(j - 1) >> nshift) | (l.get_cword(j) << shift) );
+    else
+	return (l.get_cword( j - 1 ) >> nshift);
+}
+
+template <class X, class Y>
+inline
+void
+sc_concref_r<X,Y>::set_cword( int i, sc_digit w )
+{
+    if( i < 0 || i >= size() ) {
+	SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 );
+    }
+    // 0 <= i < size()
+    Y& r = m_right;
+    int r_len = r.length();
+    int border = r_len / SC_DIGIT_SIZE;
+    if( i < border ) {
+	r.set_cword( i, w );
+	return;
+    }
+    // border <= i < size()
+    X& l = m_left;
+    int shift = r_len % SC_DIGIT_SIZE;
+    int j = i - border;
+    if( shift == 0 ) {
+	l.set_cword( j, w );
+	return;
+    }
+    // border <= i < size() && shift != 0
+    int nshift = SC_DIGIT_SIZE - shift;
+    sc_digit lh_mask = ~SC_DIGIT_ZERO << nshift;
+    if( i == border ) {
+	sc_digit rl_mask = ~SC_DIGIT_ZERO >> nshift;
+	r.set_cword( i, w & rl_mask );
+	l.set_cword( 0, (l.get_cword( 0 ) & lh_mask) | (w >> shift) );
+	return;
+    }
+    // border < i < size() && shift != 0
+    sc_digit ll_mask = ~SC_DIGIT_ZERO >> shift;
+    l.set_cword( j - 1, (l.get_cword( j - 1 ) & ll_mask) | (w << nshift) );
+    if ( j < l.size() )
+	l.set_cword( j, (l.get_cword( j ) & lh_mask) | (w >> shift) );
+}
+
+
+// r-value concatenation operators and functions
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >
+operator , ( sc_concref_r<T1,T2> a, sc_bitref_r<T3> b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >
+operator , ( sc_concref_r<T1,T2> a, sc_subref_r<T3> b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3, class T4>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >
+operator , ( sc_concref_r<T1,T2> a, sc_concref_r<T3,T4> b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,T3>
+operator , ( sc_concref_r<T1,T2> a, const sc_proxy<T3>& b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,T3>(
+	*a.clone(), b.back_cast(), 1 );
+}
+
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >
+concat( sc_concref_r<T1,T2> a, sc_bitref_r<T3> b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >
+concat( sc_concref_r<T1,T2> a, sc_subref_r<T3> b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3, class T4>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >
+concat( sc_concref_r<T1,T2> a, sc_concref_r<T3,T4> b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,T3>
+concat( sc_concref_r<T1,T2> a, const sc_proxy<T3>& b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,T3>(
+	*a.clone(), b.back_cast(), 1 );
+}
+
+
+#ifdef SC_DT_MIXED_COMMA_OPERATORS
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >
+operator , ( sc_concref_r<T1,T2> a, sc_bitref<T3> b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >
+operator , ( sc_concref<T1,T2> a, sc_bitref_r<T3> b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >
+operator , ( sc_concref_r<T1,T2> a, sc_subref<T3> b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >
+operator , ( sc_concref<T1,T2> a, sc_subref_r<T3> b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3, class T4>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >
+operator , ( sc_concref_r<T1,T2> a, sc_concref<T3,T4> b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3, class T4>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >
+operator , ( sc_concref<T1,T2> a, sc_concref_r<T3,T4> b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,T3>
+operator , ( sc_concref<T1,T2> a, const sc_proxy<T3>& b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,T3>(
+	*a.clone(), b.back_cast(), 1 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,T3>
+operator , ( sc_concref_r<T1,T2> a, sc_proxy<T3>& b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,T3>(
+	*a.clone(), b.back_cast(), 1 );
+}
+
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >
+concat( sc_concref_r<T1,T2> a, sc_bitref<T3> b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >
+concat( sc_concref<T1,T2> a, sc_bitref_r<T3> b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >
+concat( sc_concref_r<T1,T2> a, sc_subref<T3> b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >
+concat( sc_concref<T1,T2> a, sc_subref_r<T3> b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3, class T4>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >
+concat( sc_concref_r<T1,T2> a, sc_concref<T3,T4> b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3, class T4>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >
+concat( sc_concref<T1,T2> a, sc_concref_r<T3,T4> b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,T3>
+concat( sc_concref<T1,T2> a, const sc_proxy<T3>& b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,T3>(
+	*a.clone(), b.back_cast(), 1 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,T3>
+concat( sc_concref_r<T1,T2> a, sc_proxy<T3>& b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,T3>(
+	*a.clone(), b.back_cast(), 1 );
+}
+
+#endif
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_concref<X,Y>
+//
+//  Proxy class for sc_proxy concatenation (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+// other methods
+
+template <class T1, class T2>
+inline
+void
+sc_concref<T1,T2>::scan( ::std::istream& is )
+{
+    std::string s;
+    is >> s;
+    *this = s.c_str();
+}
+
+
+// l-value concatenation operators and functions
+
+template <class T1, class T2, class T3>
+inline
+sc_concref<sc_concref<T1,T2>,sc_bitref<T3> >
+operator , ( sc_concref<T1,T2> a, sc_bitref<T3> b )
+{
+    return sc_concref<sc_concref<T1,T2>,sc_bitref<T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref<sc_concref<T1,T2>,sc_subref<T3> >
+operator , ( sc_concref<T1,T2> a, sc_subref<T3> b )
+{
+    return sc_concref<sc_concref<T1,T2>,sc_subref<T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3, class T4>
+inline
+sc_concref<sc_concref<T1,T2>,sc_concref<T3,T4> >
+operator , ( sc_concref<T1,T2> a, sc_concref<T3,T4> b )
+{
+    return sc_concref<sc_concref<T1,T2>,sc_concref<T3,T4> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref<sc_concref<T1,T2>,T3>
+operator , ( sc_concref<T1,T2> a, sc_proxy<T3>& b )
+{
+    return sc_concref<sc_concref<T1,T2>,T3>(
+	*a.clone(), b.back_cast(), 1 );
+}
+
+
+template <class T1, class T2, class T3>
+inline
+sc_concref<sc_concref<T1,T2>,sc_bitref<T3> >
+concat( sc_concref<T1,T2> a, sc_bitref<T3> b )
+{
+    return sc_concref<sc_concref<T1,T2>,sc_bitref<T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref<sc_concref<T1,T2>,sc_subref<T3> >
+concat( sc_concref<T1,T2> a, sc_subref<T3> b )
+{
+    return sc_concref<sc_concref<T1,T2>,sc_subref<T3> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3, class T4>
+inline
+sc_concref<sc_concref<T1,T2>,sc_concref<T3,T4> >
+concat( sc_concref<T1,T2> a, sc_concref<T3,T4> b )
+{
+    return sc_concref<sc_concref<T1,T2>,sc_concref<T3,T4> >(
+	*a.clone(), *b.clone(), 3 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref<sc_concref<T1,T2>,T3>
+concat( sc_concref<T1,T2> a, sc_proxy<T3>& b )
+{
+    return sc_concref<sc_concref<T1,T2>,T3>(
+	*a.clone(), b.back_cast(), 1 );
+}
+
+
+template <class X, class Y>
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_concref<X,Y> a )
+{
+    a.scan( is );
+    return is;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_proxy<T>
+//
+//  Base class template for bit/logic vector classes.
+//  (Barton/Nackmann implementation)
+// ----------------------------------------------------------------------------
+
+// r-value concatenation operators and functions
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,sc_bitref_r<T2> >
+operator , ( const sc_proxy<T1>& a, sc_bitref_r<T2> b )
+{
+    return sc_concref_r<T1,sc_bitref_r<T2> >(
+	a.back_cast(), *b.clone(), 2 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,sc_subref_r<T2> >
+operator , ( const sc_proxy<T1>& a, sc_subref_r<T2> b )
+{
+    return sc_concref_r<T1,sc_subref_r<T2> >(
+	a.back_cast(), *b.clone(), 2 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<T1,sc_concref_r<T2,T3> >
+operator , ( const sc_proxy<T1>& a, sc_concref_r<T2,T3> b )
+{
+    return sc_concref_r<T1,sc_concref_r<T2,T3> >(
+	a.back_cast(), *b.clone(), 2 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,T2>
+operator , ( const sc_proxy<T1>& a, const sc_proxy<T2>& b )
+{
+    return sc_concref_r<T1,T2>(
+	a.back_cast(), b.back_cast() );
+}
+
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,sc_bitref_r<T2> >
+concat( const sc_proxy<T1>& a, sc_bitref_r<T2> b )
+{
+    return sc_concref_r<T1,sc_bitref_r<T2> >(
+	a.back_cast(), *b.clone(), 2 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,sc_subref_r<T2> >
+concat( const sc_proxy<T1>& a, sc_subref_r<T2> b )
+{
+    return sc_concref_r<T1,sc_subref_r<T2> >(
+	a.back_cast(), *b.clone(), 2 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<T1,sc_concref_r<T2,T3> >
+concat( const sc_proxy<T1>& a, sc_concref_r<T2,T3> b )
+{
+    return sc_concref_r<T1,sc_concref_r<T2,T3> >(
+	a.back_cast(), *b.clone(), 2 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,T2>
+concat( const sc_proxy<T1>& a, const sc_proxy<T2>& b )
+{
+    return sc_concref_r<T1,T2>(
+	a.back_cast(), b.back_cast() );
+}
+
+
+#ifdef SC_DT_MIXED_COMMA_OPERATORS
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,sc_bitref_r<T2> >
+operator , ( const sc_proxy<T1>& a, sc_bitref<T2> b )
+{
+    return sc_concref_r<T1,sc_bitref_r<T2> >(
+	a.back_cast(), *b.clone(), 2 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,sc_bitref_r<T2> >
+operator , ( sc_proxy<T1>& a, sc_bitref_r<T2> b )
+{
+    return sc_concref_r<T1,sc_bitref_r<T2> >(
+	a.back_cast(), *b.clone(), 2 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,sc_subref_r<T2> >
+operator , ( const sc_proxy<T1>& a, sc_subref<T2> b )
+{
+    return sc_concref_r<T1,sc_subref_r<T2> >(
+	a.back_cast(), *b.clone(), 2 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,sc_subref_r<T2> >
+operator , ( sc_proxy<T1>& a, sc_subref_r<T2> b )
+{
+    return sc_concref_r<T1,sc_subref_r<T2> >(
+	a.back_cast(), *b.clone(), 2 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<T1,sc_concref_r<T2,T3> >
+operator , ( const sc_proxy<T1>& a, sc_concref<T2,T3> b )
+{
+    return sc_concref_r<T1,sc_concref_r<T2,T3> >(
+	a.back_cast(), *b.clone(), 2 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<T1,sc_concref_r<T2,T3> >
+operator , ( sc_proxy<T1>& a, sc_concref_r<T2,T3> b )
+{
+    return sc_concref_r<T1,sc_concref_r<T2,T3> >(
+	a.back_cast(), *b.clone(), 2 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,T2>
+operator , ( const sc_proxy<T1>& a, sc_proxy<T2>& b )
+{
+    return sc_concref_r<T1,T2>(
+	a.back_cast(), b.back_cast() );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,T2>
+operator , ( sc_proxy<T1>& a, const sc_proxy<T2>& b )
+{
+    return sc_concref_r<T1,T2>(
+	a.back_cast(), b.back_cast() );
+}
+
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,sc_bitref_r<T2> >
+concat( const sc_proxy<T1>& a, sc_bitref<T2> b )
+{
+    return sc_concref_r<T1,sc_bitref_r<T2> >(
+	a.back_cast(), *b.clone(), 2 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,sc_bitref_r<T2> >
+concat( sc_proxy<T1>& a, sc_bitref_r<T2> b )
+{
+    return sc_concref_r<T1,sc_bitref_r<T2> >(
+	a.back_cast(), *b.clone(), 2 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,sc_subref_r<T2> >
+concat( const sc_proxy<T1>& a, sc_subref<T2> b )
+{
+    return sc_concref_r<T1,sc_subref_r<T2> >(
+	a.back_cast(), *b.clone(), 2 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,sc_subref_r<T2> >
+concat( sc_proxy<T1>& a, sc_subref_r<T2> b )
+{
+    return sc_concref_r<T1,sc_subref_r<T2> >(
+	a.back_cast(), *b.clone(), 2 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<T1,sc_concref_r<T2,T3> >
+concat( const sc_proxy<T1>& a, sc_concref<T2,T3> b )
+{
+    return sc_concref_r<T1,sc_concref_r<T2,T3> >(
+	a.back_cast(), *b.clone(), 2 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref_r<T1,sc_concref_r<T2,T3> >
+concat( sc_proxy<T1>& a, sc_concref_r<T2,T3> b )
+{
+    return sc_concref_r<T1,sc_concref_r<T2,T3> >(
+	a.back_cast(), *b.clone(), 2 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,T2>
+concat( const sc_proxy<T1>& a, sc_proxy<T2>& b )
+{
+    return sc_concref_r<T1,T2>(
+	a.back_cast(), b.back_cast() );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<T1,T2>
+concat( sc_proxy<T1>& a, const sc_proxy<T2>& b )
+{
+    return sc_concref_r<T1,T2>(
+	a.back_cast(), b.back_cast() );
+}
+
+#endif
+
+
+// l-value concatenation operators and functions
+
+template <class T1, class T2>
+inline
+sc_concref<T1,sc_bitref<T2> >
+operator , ( sc_proxy<T1>& a, sc_bitref<T2> b )
+{
+    return sc_concref<T1,sc_bitref<T2> >(
+	a.back_cast(), *b.clone(), 2 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref<T1,sc_subref<T2> >
+operator , ( sc_proxy<T1>& a, sc_subref<T2> b )
+{
+    return sc_concref<T1,sc_subref<T2> >(
+	a.back_cast(), *b.clone(), 2 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref<T1,sc_concref<T2,T3> >
+operator , ( sc_proxy<T1>& a, sc_concref<T2,T3> b )
+{
+    return sc_concref<T1,sc_concref<T2,T3> >(
+	a.back_cast(), *b.clone(), 2 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref<T1,T2>
+operator , ( sc_proxy<T1>& a, sc_proxy<T2>& b )
+{
+    return sc_concref<T1,T2>(
+	a.back_cast(), b.back_cast() );
+}
+
+
+template <class T1, class T2>
+inline
+sc_concref<T1,sc_bitref<T2> >
+concat( sc_proxy<T1>& a, sc_bitref<T2> b )
+{
+    return sc_concref<T1,sc_bitref<T2> >(
+	a.back_cast(), *b.clone(), 2 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref<T1,sc_subref<T2> >
+concat( sc_proxy<T1>& a, sc_subref<T2> b )
+{
+    return sc_concref<T1,sc_subref<T2> >(
+	a.back_cast(), *b.clone(), 2 );
+}
+
+template <class T1, class T2, class T3>
+inline
+sc_concref<T1,sc_concref<T2,T3> >
+concat( sc_proxy<T1>& a, sc_concref<T2,T3> b )
+{
+    return sc_concref<T1,sc_concref<T2,T3> >(
+	a.back_cast(), *b.clone(), 2 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref<T1,T2>
+concat( sc_proxy<T1>& a, sc_proxy<T2>& b )
+{
+    return sc_concref<T1,T2>(
+	a.back_cast(), b.back_cast() );
+}
+
+} // namespace sc_dt
+
+// $Log: sc_bit_proxies.h,v $
+// Revision 1.10  2011/09/05 21:19:53  acg
+//  Philipp A. Hartmann: added parentheses to expressions to eliminate
+//  compiler warnings.
+//
+// Revision 1.9  2011/09/01 15:03:42  acg
+//  Philipp A. Hartmann: add parentheses to eliminate compiler warnings.
+//
+// Revision 1.8  2011/08/29 18:04:32  acg
+//  Philipp A. Hartmann: miscellaneous clean ups.
+//
+// Revision 1.7  2011/08/24 22:05:40  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.6  2010/02/22 14:25:43  acg
+//  Andy Goodrich: removed 'mutable' directive from references, since it
+//  is not a legal C++ construct.
+//
+// Revision 1.5  2009/02/28 00:26:14  acg
+//  Andy Goodrich: bug fixes.
+//
+// Revision 1.4  2007/03/14 17:48:37  acg
+//  Andy Goodrich: fixed bug.
+//
+// Revision 1.3  2007/01/18 19:29:18  acg
+//  Andy Goodrich: fixed bug in concatenations of bit selects on sc_lv and
+//  sc_bv types. The offending code was in sc_bitref<X>::set_word and
+//  sc_bitref<X>::get_word. These methods were not writing the bit they
+//  represented, but rather writing an entire word whose index was the
+//  index of the bit they represented. This not only did not write the
+//  correct bit, but clobbered a word that might not even be in the
+//  variable the reference was for.
+//
+// Revision 1.2  2007/01/17 22:45:08  acg
+//  Andy Goodrich: fixed sc_bitref<X>::set_bit().
+//
+// Revision 1.1.1.1  2006/12/15 20:31:36  acg
+// SystemC 2.2
+//
+// Revision 1.3  2006/01/13 18:53:53  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+
+#endif
diff --git a/ext/systemc/src/sysc/datatypes/bit/sc_bv.h b/ext/systemc/src/sysc/datatypes/bit/sc_bv.h
new file mode 100644
index 000000000..de4221c7f
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/bit/sc_bv.h
@@ -0,0 +1,201 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_bv.h -- Arbitrary size bit vector class.
+
+  Original Author: Gene Bushuyev, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_bv.h,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:53  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SC_BV_H
+#define SC_BV_H
+
+
+#include "sysc/datatypes/bit/sc_bv_base.h"
+
+
+namespace sc_dt
+{
+
+// classes defined in this module
+template <int W> class sc_bv;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_bv<W>
+//
+//  Arbitrary size bit vector class.
+// ----------------------------------------------------------------------------
+
+template <int W>
+class sc_bv
+    : public sc_bv_base
+{
+public:
+
+    // constructors
+
+    sc_bv()
+	:sc_bv_base( W )
+	{}
+
+    explicit sc_bv( bool init_value )
+	: sc_bv_base( init_value, W )
+	{}
+
+    explicit sc_bv( char init_value )
+	: sc_bv_base( (init_value != '0'), W )
+	{}
+
+    sc_bv( const char* a )
+	: sc_bv_base( W )
+	{ sc_bv_base::operator = ( a ); }
+
+    sc_bv( const bool* a )
+	: sc_bv_base( W )
+	{ sc_bv_base::operator = ( a ); }
+
+    sc_bv( const sc_logic* a )
+	: sc_bv_base( W )
+	{ sc_bv_base::operator = ( a ); }
+
+    sc_bv( const sc_unsigned& a )
+	: sc_bv_base( W )
+	{ sc_bv_base::operator = ( a ); }
+
+    sc_bv( const sc_signed& a )
+	: sc_bv_base( W )
+	{ sc_bv_base::operator = ( a ); }
+
+    sc_bv( const sc_uint_base& a )
+	: sc_bv_base( W )
+	{ sc_bv_base::operator = ( a ); }
+
+    sc_bv( const sc_int_base& a )
+	: sc_bv_base( W )
+	{ sc_bv_base::operator = ( a ); }
+
+    sc_bv( unsigned long a )
+	: sc_bv_base( W )
+	{ sc_bv_base::operator = ( a ); }
+
+    sc_bv( long a )
+	: sc_bv_base( W )
+	{ sc_bv_base::operator = ( a ); }
+
+    sc_bv( unsigned int a )
+	: sc_bv_base( W )
+	{ sc_bv_base::operator = ( a ); }
+
+    sc_bv( int a )
+	: sc_bv_base( W )
+	{ sc_bv_base::operator = ( a ); }
+
+    sc_bv( uint64 a )
+	: sc_bv_base( W )
+	{ sc_bv_base::operator = ( a ); }
+
+    sc_bv( int64 a )
+	: sc_bv_base( W )
+	{ sc_bv_base::operator = ( a ); }
+
+    template <class X>
+    sc_bv( const sc_proxy<X>& a )
+	: sc_bv_base( W )
+	{ sc_bv_base::operator = ( a ); }
+
+    sc_bv( const sc_bv<W>& a )
+	: sc_bv_base( a )
+	{}
+
+
+    // assignment operators
+
+    template <class X>
+    sc_bv<W>& operator = ( const sc_proxy<X>& a )
+	{ sc_bv_base::operator = ( a ); return *this; }
+
+    sc_bv<W>& operator = ( const sc_bv<W>& a )
+	{ sc_bv_base::operator = ( a ); return *this; }
+
+    sc_bv<W>& operator = ( const char* a )
+	{ sc_bv_base::operator = ( a ); return *this; }
+
+    sc_bv<W>& operator = ( const bool* a )
+	{ sc_bv_base::operator = ( a ); return *this; }
+
+    sc_bv<W>& operator = ( const sc_logic* a )
+	{ sc_bv_base::operator = ( a ); return *this; }
+
+    sc_bv<W>& operator = ( const sc_unsigned& a )
+	{ sc_bv_base::operator = ( a ); return *this; }
+
+    sc_bv<W>& operator = ( const sc_signed& a )
+	{ sc_bv_base::operator = ( a ); return *this; }
+
+    sc_bv<W>& operator = ( const sc_uint_base& a )
+	{ sc_bv_base::operator = ( a ); return *this; }
+
+    sc_bv<W>& operator = ( const sc_int_base& a )
+	{ sc_bv_base::operator = ( a ); return *this; }
+
+    sc_bv<W>& operator = ( unsigned long a )
+	{ sc_bv_base::operator = ( a ); return *this; }
+
+    sc_bv<W>& operator = ( long a )
+	{ sc_bv_base::operator = ( a ); return *this; }
+
+    sc_bv<W>& operator = ( unsigned int a )
+	{ sc_bv_base::operator = ( a ); return *this; }
+
+    sc_bv<W>& operator = ( int a )
+	{ sc_bv_base::operator = ( a ); return *this; }
+
+    sc_bv<W>& operator = ( uint64 a )
+	{ sc_bv_base::operator = ( a ); return *this; }
+
+    sc_bv<W>& operator = ( int64 a )
+	{ sc_bv_base::operator = ( a ); return *this; }
+};
+
+} // namespace sc_dt
+
+
+#endif
diff --git a/ext/systemc/src/sysc/datatypes/bit/sc_bv_base.cpp b/ext/systemc/src/sysc/datatypes/bit/sc_bv_base.cpp
new file mode 100644
index 000000000..b6ffaa32b
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/bit/sc_bv_base.cpp
@@ -0,0 +1,388 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_bv_base.cpp -- Arbitrary size bit vector class.
+
+  Original Author: Gene Bushuyev, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_bv_base.cpp,v $
+// Revision 1.2  2011/08/24 22:05:40  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.4  2006/04/11 23:12:26  acg
+//   Andy Goodrich: Fixed bug in parsing of extended string constants like
+//   0bus1110011.
+//
+// Revision 1.3  2006/01/13 18:53:53  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include <string.h>
+
+#include "sysc/datatypes/bit/sc_bit_ids.h"
+#include "sysc/datatypes/bit/sc_bv_base.h"
+#include "sysc/datatypes/fx/sc_fix.h"
+#include "sysc/datatypes/fx/sc_ufix.h"
+
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_bv_base
+//
+//  Arbitrary size bit vector base class.
+// ----------------------------------------------------------------------------
+
+void
+sc_bv_base::init( int length_, bool init_value )
+{
+    // check the length
+    if( length_ <= 0 ) {
+	SC_REPORT_ERROR( sc_core::SC_ID_ZERO_LENGTH_, 0 );
+    }
+    // allocate memory for the data and control words
+    m_len = length_;
+    m_size = (m_len - 1) / SC_DIGIT_SIZE + 1;
+    m_data = new sc_digit[m_size];
+    // initialize the bits to 'init_value'
+    sc_digit dw = init_value ? ~SC_DIGIT_ZERO : SC_DIGIT_ZERO;
+    int sz = m_size;
+    for( int i = 0; i < sz; ++ i ) {
+	m_data[i] = dw;
+    }
+    clean_tail();
+}
+
+
+void
+sc_bv_base::assign_from_string( const std::string& s )
+{
+    // s must have been converted to bin
+    int len = m_len;
+    int s_len = s.length() - 1;
+    int min_len = sc_min( len, s_len );
+    int i = 0;
+    for( ; i < min_len; ++ i ) {
+	char c = s[s_len - i - 1];
+	if( c != '0' && c != '1' ) {
+	    SC_REPORT_ERROR( sc_core::SC_ID_CANNOT_CONVERT_,
+	        "string can contain only '0' and '1' characters" );
+	}
+	set_bit( i, sc_logic_value_t( c - '0' ) );
+    }
+    // if formatted, fill the rest with sign(s), otherwise fill with zeros
+    sc_logic_value_t fill = (s[s_len] == 'F' ? sc_logic_value_t( s[0] - '0' )
+		                             : sc_logic_value_t( 0 ));
+    for( ; i < len; ++ i ) {
+	set_bit( i, fill );
+    }
+}
+
+
+// constructors
+
+sc_bv_base::sc_bv_base( const char* a )
+    : m_len( 0 ), m_size( 0 ), m_data( 0 )
+{
+    std::string s = convert_to_bin( a );
+    init( s.length() -  1 );
+    assign_from_string( s );
+}
+
+sc_bv_base::sc_bv_base( const char* a, int length_ )
+    : m_len( 0 ), m_size( 0 ), m_data( 0 )
+{
+    init( length_ );
+    assign_from_string( convert_to_bin( a ) );
+}
+
+sc_bv_base::sc_bv_base( const sc_bv_base& a )
+    : sc_proxy<sc_bv_base>(),
+      m_len( a.m_len ),
+      m_size( a.m_size ),
+      m_data( new sc_digit[m_size] )
+{
+    // copy the bits
+    int sz = m_size;
+    for( int i = 0; i < sz; ++ i ) {
+	m_data[i] = a.m_data[i];
+    }
+}
+
+
+// assignment operators
+
+sc_bv_base&
+sc_bv_base::operator = ( const char* a )
+{
+    assign_from_string( convert_to_bin( a ) );
+    return *this;
+}
+
+
+#if 0
+
+// bitwise complement
+
+sc_bv_base&
+sc_bv_base::b_not()
+{
+    int sz = m_size;
+    for( int i = 0; i < sz; ++ i ) {
+	m_data[i] = ~m_data[i];
+    }
+    clean_tail();
+    return *this;
+}
+
+
+// bitwise left shift
+
+sc_bv_base&
+sc_bv_base::operator <<= ( int n )
+{
+    if( n < 0 ) {
+	char msg[BUFSIZ];
+	std::sprintf( msg,
+		 "left shift operation is only allowed with positive "
+		 "shift values, shift value = %d", n );
+	SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
+    }
+    int sz = m_size;
+    if( n >= m_len ) {
+	for( int i = 0; i < sz; ++ i ) {
+	    m_data[i] = SC_DIGIT_ZERO;
+	}
+	// clean_tail();
+	return *this;
+    }
+    int wn = n / SC_DIGIT_SIZE;
+    int bn = n % SC_DIGIT_SIZE;
+    if( wn != 0 ) {
+	// shift words
+	int i = sz - 1;
+	for( ; i >= wn; -- i ) {
+	    m_data[i] = m_data[i - wn];
+	}
+	for( ; i >= 0; -- i ) {
+	    m_data[i] = SC_DIGIT_ZERO;
+	}
+    }
+    if( bn != 0 ) {
+	// shift bits
+	for( int i = sz - 1; i >= 1; -- i ) {
+	    m_data[i] <<= bn;
+	    m_data[i] |= m_data[i - 1] >> (SC_DIGIT_SIZE - bn);
+	}
+	m_data[0] <<= bn;
+    }
+    clean_tail();
+    return *this;
+}
+
+
+// bitwise right shift
+
+sc_bv_base&
+sc_bv_base::operator >>= ( int n )
+{
+    if( n < 0 ) {
+	char msg[BUFSIZ];
+	std::sprintf( msg,
+		 "right shift operation is only allowed with positive "
+		 "shift values, shift value = %d", n );
+	SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
+    }
+    int sz = m_size;
+    if( n >= m_len ) {
+	for( int i = 0; i < sz; ++ i ) {
+	    m_data[i] = SC_DIGIT_ZERO;
+	}
+	// clean_tail();
+	return *this;
+    }
+    int wn = n / SC_DIGIT_SIZE;
+    int bn = n % SC_DIGIT_SIZE;
+    if( wn != 0 ) {
+	// shift words
+	int i = 0;
+	for( ; i < (sz - wn); ++ i ) {
+	    m_data[i] = m_data[i + wn];
+	}
+	for( ; i < sz; ++ i ) {
+	    m_data[i] = SC_DIGIT_ZERO;
+	}
+    }
+    if( bn != 0 ) {
+	// shift bits
+	for( int i = 0; i < (sz - 1); ++ i ) {
+	    m_data[i] >>= bn;
+	    m_data[i] |= m_data[i + 1] << (SC_DIGIT_SIZE - bn);
+	}
+	m_data[sz - 1] >>= bn;
+    }
+    clean_tail();
+    return *this;
+}
+
+
+// bitwise left rotate
+
+sc_bv_base&
+sc_bv_base::lrotate( int n )
+{
+    if( n < 0 ) {
+	char msg[BUFSIZ];
+	std::sprintf( msg,
+		 "left rotate operation is only allowed with positive "
+		 "rotate values, rotate value = %d", n );
+	SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
+    }
+    int len = m_len;
+    n %= len;
+    *this = (*this << n) | (*this >> (len - n));
+    return *this;
+}
+
+
+// bitwise right rotate
+
+sc_bv_base&
+sc_bv_base::rrotate( int n )
+{
+    if( n < 0 ) {
+	char msg[BUFSIZ];
+	std::sprintf( msg,
+		 "right rotate operation is only allowed with positive "
+		 "rotate values, rotate value = %d", n );
+	SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
+    }
+    int len = m_len;
+    n %= len;
+    *this = (*this >> n) | (*this << (len - n));
+    return *this;
+}
+
+#endif
+
+
+// ----------------------------------------------------------------------------
+
+// convert formatted string to binary string
+
+const std::string
+convert_to_bin( const char* s )
+{
+    // Beware: logic character strings cannot start with '0x' or '0X',
+    //         because this is seen as a hexadecimal encoding prefix!
+
+    if( s == 0 ) {
+	SC_REPORT_ERROR(sc_core::SC_ID_CANNOT_CONVERT_, 
+	    "character string is zero" );
+    }
+    if( *s == 0 ) {
+	SC_REPORT_ERROR(sc_core::SC_ID_CANNOT_CONVERT_, 
+	    "character string is empty");
+    }
+
+    int n = strlen( s );
+    int i = 0;
+    if( s[0] == '-' || s[0] == '+' ) {
+	++ i;
+    }
+    if( n > (i + 2) && s[i] == '0' )
+    {
+        if (s[i+1] == 'b' || s[i+1] == 'B' )
+	{
+	    if ( s[i+2] == '0' || s[i+2] == '1' )
+	    {
+		std::string str( &s[2] );
+	        str += "F";
+	        return str;
+	    }
+	}
+        if ( s[i+1] == 'b' || s[i+1] == 'B' ||
+	     s[i+1] == 'c' || s[i+1] == 'C' ||
+	     s[i+1] == 'd' || s[i+1] == 'D' ||
+	     s[i+1] == 'o' || s[i+1] == 'O' ||
+	     s[i+1] == 'x' || s[i+1] == 'X') 
+        {
+	    try {
+		// worst case length = n * 4
+		sc_fix a( s, n * 4, n * 4, SC_TRN, SC_WRAP, 0, SC_ON );
+		std::string str = a.to_bin();
+		str += "F"; // mark the string as formatted
+		// get rid of prefix (0b) and redundant leading bits
+		const char* p = str.c_str() + 2;
+		while( p[1] && p[0] == p[1] ) {
+		    ++ p;
+		}
+		return std::string( p );
+	    } catch( sc_core::sc_report ) {
+		char msg[BUFSIZ];
+		std::sprintf( msg, "character string '%s' is not valid", s );
+		SC_REPORT_ERROR( sc_core::SC_ID_CANNOT_CONVERT_, msg );
+		// never reached
+		return std::string();
+	    }
+	}
+
+    }
+
+    // bin by default
+
+    std::string str( s );
+    str += "U"; // mark the string as unformatted
+    return str;
+}
+
+// convert binary string to formatted string
+
+const std::string
+convert_to_fmt( const std::string& s, sc_numrep numrep, bool w_prefix )
+{
+    int n = s.length();
+    std::string str("0bus");
+    // str += "0bus";
+    str += s;
+    sc_ufix a( str.c_str(), n, n, SC_TRN, SC_WRAP, 0, SC_ON );
+    return a.to_string( numrep, w_prefix );
+}
+
+} // namespace sc_dt
diff --git a/ext/systemc/src/sysc/datatypes/bit/sc_bv_base.h b/ext/systemc/src/sysc/datatypes/bit/sc_bv_base.h
new file mode 100644
index 000000000..279001da5
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/bit/sc_bv_base.h
@@ -0,0 +1,339 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_bv_base.h -- Arbitrary size bit vector class.
+
+  Original Author: Gene Bushuyev, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_bv_base.h,v $
+// Revision 1.3  2011/08/26 22:32:00  acg
+//  Torsten Maehne: added parentheses to make opearator ordering more obvious.
+//
+// Revision 1.2  2011/08/15 16:43:24  acg
+//  Torsten Maehne: changes to remove unused argument warnings.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:53  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SC_BV_BASE_H
+#define SC_BV_BASE_H
+
+
+#include "sysc/datatypes/bit/sc_bit_ids.h"
+#include "sysc/datatypes/bit/sc_bit_proxies.h"
+#include "sysc/datatypes/bit/sc_proxy.h"
+#include "sysc/datatypes/int/sc_length_param.h"
+
+
+namespace sc_dt
+{
+
+// classes defined in this module
+class sc_bv_base;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_bv_base
+//
+//  Arbitrary size bit vector base class.
+// ----------------------------------------------------------------------------
+
+class sc_bv_base
+    : public sc_proxy<sc_bv_base>
+{
+    friend class sc_lv_base;
+
+
+    void init( int length_, bool init_value = false );
+
+    void assign_from_string( const std::string& );
+  
+public:
+
+    // typedefs
+
+    typedef sc_proxy<sc_bv_base> base_type;
+
+
+    // constructors
+
+    explicit sc_bv_base( int length_ = sc_length_param().len() )
+	: m_len( 0 ), m_size( 0 ), m_data( 0 )
+	{ init( length_ ); }
+
+    explicit sc_bv_base( bool a,
+			 int length_ = sc_length_param().len() )
+	: m_len( 0 ), m_size( 0 ), m_data( 0 )
+	{ init( length_, a ); }
+
+    sc_bv_base( const char* a );
+
+    sc_bv_base( const char* a, int length_ );
+
+    template <class X>
+    sc_bv_base( const sc_proxy<X>& a )
+	: m_len( 0 ), m_size( 0 ), m_data( 0 )
+	{ init( a.back_cast().length() ); base_type::assign_( a ); }
+
+    sc_bv_base( const sc_bv_base& a );
+
+#ifdef SC_DT_DEPRECATED
+
+    explicit sc_bv_base( const sc_unsigned& a )
+	: m_len( 0 ), m_size( 0 ), m_data( 0 )
+	{ init( a.length() ); base_type::assign_( a ); }
+
+    explicit sc_bv_base( const sc_signed& a )
+	: m_len( 0 ), m_size( 0 ), m_data( 0 )
+	{ init( a.length() ); base_type::assign_( a ); }
+
+    explicit sc_bv_base( const sc_uint_base& a)
+	: m_len( 0 ), m_size( 0 ), m_data( 0 )
+	{ init( a.length() ); base_type::assign_( a ); }
+
+    explicit sc_bv_base( const sc_int_base& a)
+	: m_len( 0 ), m_size( 0 ), m_data( 0 )
+	{ init( a.length() ); base_type::assign_( a ); }
+
+#endif
+
+
+    // destructor
+
+    virtual ~sc_bv_base()
+	{ delete [] m_data; }
+
+
+    // assignment operators
+
+    template <class X>
+    sc_bv_base& operator = ( const sc_proxy<X>& a )
+	{ assign_p_( *this, a ); return *this; }
+
+    sc_bv_base& operator = ( const sc_bv_base& a )
+	{ assign_p_( *this, a ); return *this; }
+
+    sc_bv_base& operator = ( const char* a );
+
+    sc_bv_base& operator = ( const bool* a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_bv_base& operator = ( const sc_logic* a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_bv_base& operator = ( const sc_unsigned& a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_bv_base& operator = ( const sc_signed& a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_bv_base& operator = ( const sc_uint_base& a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_bv_base& operator = ( const sc_int_base& a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_bv_base& operator = ( unsigned long a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_bv_base& operator = ( long a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_bv_base& operator = ( unsigned int a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_bv_base& operator = ( int a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_bv_base& operator = ( uint64 a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_bv_base& operator = ( int64 a )
+	{ base_type::assign_( a ); return *this; }
+
+
+#if 0
+
+    // bitwise complement
+
+    sc_bv_base& b_not();
+
+    const sc_bv_base operator ~ () const
+	{ sc_bv_base a( *this ); return a.b_not(); }
+
+
+    // bitwise left shift
+
+    sc_bv_base& operator <<= ( int n );
+
+    const sc_bv_base operator << ( int n ) const
+	{ sc_bv_base a( *this ); return ( a <<= n ); }
+
+
+    // bitwise right shift
+
+    sc_bv_base& operator >>= ( int n );
+
+    const sc_bv_base operator >> ( int n ) const
+	{ sc_bv_base a( *this ); return ( a >>= n ); }
+
+
+    // bitwise left rotate
+
+    sc_bv_base& lrotate( int n );
+
+
+    // bitwise right rotate
+
+    sc_bv_base& rrotate( int n );
+
+#endif
+
+
+    // common methods
+
+    int length() const
+	{ return m_len; }
+
+    int size() const
+	{ return m_size; }
+
+    sc_logic_value_t get_bit( int i ) const;
+    void set_bit( int i, sc_logic_value_t value );
+
+    sc_digit get_word( int i ) const
+	{ return m_data[i]; }
+
+    void set_word( int i, sc_digit w )
+	{ m_data[i] = w; }
+
+    sc_digit get_cword( int /*i*/ ) const
+	{ return SC_DIGIT_ZERO; }
+
+    void set_cword( int i, sc_digit w );
+
+    void clean_tail();
+
+
+    // other methods
+
+    bool is_01() const
+	{ return true; }
+
+protected:
+
+    int     m_len;  // length in bits
+    int     m_size; // size of data array
+    sc_digit* m_data; // data array
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+#if 0
+
+// bitwise left rotate
+
+inline
+const sc_bv_base
+lrotate( const sc_bv_base& x, int n )
+{
+    sc_bv_base a( x );
+    return a.lrotate( n );
+}
+
+
+// bitwise right rotate
+
+inline
+const sc_bv_base
+rrotate( const sc_bv_base& x, int n )
+{
+    sc_bv_base a( x );
+    return a.rrotate( n );
+}
+
+#endif
+
+
+// common methods
+
+inline
+sc_logic_value_t
+sc_bv_base::get_bit( int i ) const
+{
+    int wi = i / SC_DIGIT_SIZE;
+    int bi = i % SC_DIGIT_SIZE;
+    return sc_logic_value_t( (m_data[wi] >> bi) & SC_DIGIT_ONE );
+}
+
+inline
+void
+sc_bv_base::set_bit( int i, sc_logic_value_t value )
+{
+    int wi = i / SC_DIGIT_SIZE;
+    int bi = i % SC_DIGIT_SIZE;
+    sc_digit mask = SC_DIGIT_ONE << bi;
+    m_data[wi] |= mask; // set bit to 1
+    m_data[wi] &= value << bi | ~mask;
+}
+
+
+inline
+void
+sc_bv_base::set_cword( int /*i*/, sc_digit w )
+{
+    if( w ) {
+	SC_REPORT_WARNING( sc_core::SC_ID_SC_BV_CANNOT_CONTAIN_X_AND_Z_, 0 );
+    }
+}
+
+
+inline
+void
+sc_bv_base::clean_tail()
+{
+    int wi = m_size - 1;
+    int bi = m_len % SC_DIGIT_SIZE;
+	if ( bi != 0 ) m_data[wi] &= ~SC_DIGIT_ZERO >> (SC_DIGIT_SIZE - bi);
+}
+
+} // namespace sc_dt
+
+
+#endif
diff --git a/ext/systemc/src/sysc/datatypes/bit/sc_logic.cpp b/ext/systemc/src/sysc/datatypes/bit/sc_logic.cpp
new file mode 100644
index 000000000..15525f5c5
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/bit/sc_logic.cpp
@@ -0,0 +1,175 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_logic.cpp -- C++ implementation of logic type. Behaves
+                  pretty much the same way as HDLs logic type.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_logic.cpp,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:53  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include "sysc/datatypes/bit/sc_bit_ids.h"
+#include "sysc/datatypes/bit/sc_logic.h"
+
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_logic
+//
+//  Four-valued logic type.
+// ----------------------------------------------------------------------------
+
+// support methods
+
+void
+sc_logic::invalid_value( sc_logic_value_t v )
+{
+    char msg[BUFSIZ];
+    std::sprintf( msg, "sc_logic( %d )", v );
+    SC_REPORT_ERROR( sc_core::SC_ID_VALUE_NOT_VALID_, msg );
+}
+
+void
+sc_logic::invalid_value( char c )
+{
+    char msg[BUFSIZ];
+    std::sprintf( msg, "sc_logic( '%c' )", c );
+    SC_REPORT_ERROR( sc_core::SC_ID_VALUE_NOT_VALID_, msg );
+}
+
+void
+sc_logic::invalid_value( int i )
+{
+    char msg[BUFSIZ];
+    std::sprintf( msg, "sc_logic( %d )", i );
+    SC_REPORT_ERROR( sc_core::SC_ID_VALUE_NOT_VALID_, msg );
+}
+
+
+void
+sc_logic::invalid_01() const
+{
+    if( (int) m_val == Log_Z ) {
+	SC_REPORT_WARNING( sc_core::SC_ID_LOGIC_Z_TO_BOOL_, 0 );
+    } else {
+	SC_REPORT_WARNING( sc_core::SC_ID_LOGIC_X_TO_BOOL_, 0 );
+    }
+}
+
+
+// conversion tables
+
+const sc_logic_value_t sc_logic::char_to_logic[128] =
+{
+    Log_0, Log_1, Log_Z, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_0, Log_1, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_X, Log_X, Log_Z, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_X, Log_X, Log_Z, Log_X, Log_X, Log_X, Log_X, Log_X
+};
+
+const char sc_logic::logic_to_char[4] = { '0', '1', 'Z', 'X' };
+
+const sc_logic_value_t sc_logic::and_table[4][4] =
+{
+    { Log_0, Log_0, Log_0, Log_0 },
+    { Log_0, Log_1, Log_X, Log_X },
+    { Log_0, Log_X, Log_X, Log_X },
+    { Log_0, Log_X, Log_X, Log_X }
+};
+
+const sc_logic_value_t sc_logic::or_table[4][4] =
+{
+    { Log_0, Log_1, Log_X, Log_X },
+    { Log_1, Log_1, Log_1, Log_1 },
+    { Log_X, Log_1, Log_X, Log_X },
+    { Log_X, Log_1, Log_X, Log_X }
+};
+
+const sc_logic_value_t sc_logic::xor_table[4][4] =
+{
+    { Log_0, Log_1, Log_X, Log_X },
+    { Log_1, Log_0, Log_X, Log_X },
+    { Log_X, Log_X, Log_X, Log_X },
+    { Log_X, Log_X, Log_X, Log_X }
+};
+
+const sc_logic_value_t sc_logic::not_table[4] =
+    { Log_1, Log_0, Log_X, Log_X  };
+
+
+// other methods
+
+void
+sc_logic::scan( ::std::istream& is )
+{
+    char c;
+    is >> c;
+    *this = c;
+}
+
+
+// #ifdef SC_DT_DEPRECATED
+const sc_logic sc_logic_0( Log_0 );
+const sc_logic sc_logic_1( Log_1 );
+const sc_logic sc_logic_Z( Log_Z );
+const sc_logic sc_logic_X( Log_X );
+// #endif
+
+const sc_logic SC_LOGIC_0( Log_0 );
+const sc_logic SC_LOGIC_1( Log_1 );
+const sc_logic SC_LOGIC_Z( Log_Z );
+const sc_logic SC_LOGIC_X( Log_X );
+
+} // namespace sc_dt
diff --git a/ext/systemc/src/sysc/datatypes/bit/sc_logic.h b/ext/systemc/src/sysc/datatypes/bit/sc_logic.h
new file mode 100644
index 000000000..6008e3e2e
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/bit/sc_logic.h
@@ -0,0 +1,384 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_logic.h -- C++ implementation of logic type. Behaves
+                pretty much the same way as HDLs except with 4 values.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_logic.h,v $
+// Revision 1.3  2011/08/07 18:54:19  acg
+//  Philipp A. Hartmann: remove friend function declarations that implement
+//  code, and clean up how bit and logic operators are defined in general.
+//
+// Revision 1.2  2011/01/25 20:50:37  acg
+//  Andy Goodrich: changes for IEEE 1666 2011.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.5  2006/12/02 21:00:57  acg
+//  Andy Goodrich: fixes for concatenation support.
+//
+// Revision 1.4  2006/05/08 17:49:59  acg
+//   Andy Goodrich: Added David Long's declarations for friend operators,
+//   functions, and methods, to keep the Microsoft compiler happy.
+//
+// Revision 1.3  2006/01/13 18:53:53  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SC_LOGIC_H
+#define SC_LOGIC_H
+
+
+#include <cstdio>
+
+#include "sysc/utils/sc_iostream.h"
+#include "sysc/kernel/sc_macros.h"
+#include "sysc/utils/sc_mempool.h"
+#include "sysc/datatypes/bit/sc_bit.h"
+
+
+namespace sc_dt
+{
+
+// classes defined in this module
+class sc_logic;
+
+
+// ----------------------------------------------------------------------------
+//  ENUM : sc_logic_value_t
+//
+//  Enumeration of values for sc_logic.
+// ----------------------------------------------------------------------------
+
+enum sc_logic_value_t
+{
+    Log_0 = 0,
+    Log_1,
+    Log_Z,
+    Log_X
+};
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_logic
+//
+//  Four-valued logic type.
+// ----------------------------------------------------------------------------
+
+class sc_logic
+{
+private:
+
+    // support methods
+
+    static void invalid_value( sc_logic_value_t );
+    static void invalid_value( char );
+    static void invalid_value( int );
+
+    static sc_logic_value_t to_value( sc_logic_value_t v )
+	{
+	    if( v < Log_0 || v > Log_X ) {
+		invalid_value( v );
+	    }
+	    return v;
+	}
+
+    static sc_logic_value_t to_value( bool b )
+	{ return ( b ? Log_1 : Log_0 ); }
+
+    static sc_logic_value_t to_value( char c )
+	{
+	    sc_logic_value_t v;
+	    unsigned int index = (int)c;
+	    if ( index > 127 )
+	    {
+	        invalid_value(c);
+		v = Log_X;
+	    }
+	    else
+	    {
+		v = char_to_logic[index];
+		if( v < Log_0 || v > Log_X ) {
+		    invalid_value( c );
+		}
+	    }
+	    return v;
+	}
+
+    static sc_logic_value_t to_value( int i )
+	{
+	    if( i < 0 || i > 3 ) {
+		invalid_value( i );
+	    }
+	    return sc_logic_value_t( i );
+	}
+
+
+    void invalid_01() const;
+
+public:
+
+    // conversion tables
+
+    static const sc_logic_value_t char_to_logic[128];
+    static const char logic_to_char[4];
+    static const sc_logic_value_t and_table[4][4];
+    static const sc_logic_value_t or_table[4][4];
+    static const sc_logic_value_t xor_table[4][4];
+    static const sc_logic_value_t not_table[4];
+
+
+    // constructors
+
+    sc_logic()
+	: m_val( Log_X )
+	{}
+
+    sc_logic( const sc_logic& a )
+	: m_val( a.m_val )
+	{}
+
+    sc_logic( sc_logic_value_t v )
+	: m_val( to_value( v ) )
+	{}
+
+    explicit sc_logic( bool a )
+	: m_val( to_value( a ) )
+	{}
+
+    explicit sc_logic( char a )
+	: m_val( to_value( a ) )
+	{}
+
+    explicit sc_logic( int a )
+	: m_val( to_value( a ) )
+	{}
+
+    explicit sc_logic( const sc_bit& a )
+	: m_val( to_value( a.to_bool() ) )
+	{}
+
+
+    // destructor
+
+    ~sc_logic()
+	{}
+
+
+    // (bitwise) assignment operators
+
+#define DEFN_ASN_OP_T(op,tp)                       \
+    sc_logic& operator op ( tp v )                 \
+        { *this op sc_logic( v ); return *this; }
+
+#define DEFN_ASN_OP(op)                            \
+    DEFN_ASN_OP_T(op, sc_logic_value_t)            \
+    DEFN_ASN_OP_T(op, bool)                        \
+    DEFN_ASN_OP_T(op, char)                        \
+    DEFN_ASN_OP_T(op, int )                        \
+    DEFN_ASN_OP_T(op, const sc_bit& )
+
+    sc_logic& operator = ( const sc_logic& a )
+        { m_val = a.m_val; return *this; }
+
+    sc_logic& operator &= ( const sc_logic& b )
+        { m_val = and_table[m_val][b.m_val]; return *this; }
+
+    sc_logic& operator |= ( const sc_logic& b )
+        { m_val = or_table[m_val][b.m_val]; return *this; }
+
+    sc_logic& operator ^= ( const sc_logic& b )
+        { m_val = xor_table[m_val][b.m_val]; return *this; }
+
+    DEFN_ASN_OP(=)
+    DEFN_ASN_OP(&=)
+    DEFN_ASN_OP(|=)
+    DEFN_ASN_OP(^=)
+
+#undef DEFN_ASN_OP_T
+#undef DEFN_ASN_OP
+
+
+    // bitwise operators and functions
+
+
+    friend const sc_logic operator & ( const sc_logic&, const sc_logic& );
+    friend const sc_logic operator | ( const sc_logic&, const sc_logic& );
+    friend const sc_logic operator ^ ( const sc_logic&, const sc_logic& );
+
+    // relational operators
+
+    friend bool operator == ( const sc_logic&, const sc_logic& );
+    friend bool operator != ( const sc_logic&, const sc_logic& );
+
+    // bitwise complement
+
+    const sc_logic operator ~ () const
+	{ return sc_logic( not_table[m_val] ); }
+
+    sc_logic& b_not()
+	{ m_val = not_table[m_val]; return *this; }
+
+
+    // explicit conversions
+
+    sc_logic_value_t value() const
+	{ return m_val; }
+
+
+    bool is_01() const
+	{ return ( (int) m_val == Log_0 || (int) m_val == Log_1 ); }
+
+    bool to_bool() const
+	{ if( ! is_01() ) { invalid_01(); } return ( (int) m_val != Log_0 ); }
+
+    char to_char() const
+	{ return logic_to_char[m_val]; }
+
+
+    // other methods
+
+    void print( ::std::ostream& os = ::std::cout ) const
+	{ os << to_char(); }
+
+    void scan( ::std::istream& is = ::std::cin );
+
+
+    // memory (de)allocation
+
+    static void* operator new( std::size_t, void* p ) // placement new
+	{ return p; }
+
+    static void* operator new( std::size_t sz )
+	{ return sc_core::sc_mempool::allocate( sz ); }
+
+    static void operator delete( void* p, std::size_t sz )
+	{ sc_core::sc_mempool::release( p, sz ); }
+
+    static void* operator new [] ( std::size_t sz )
+	{ return sc_core::sc_mempool::allocate( sz ); }
+
+    static void operator delete [] ( void* p, std::size_t sz )
+	{ sc_core::sc_mempool::release( p, sz ); }
+
+private:
+
+    sc_logic_value_t m_val;
+
+private:
+
+    // disabled
+    explicit sc_logic( const char* );
+    sc_logic& operator = ( const char* );
+};
+
+// ----------------------------------------------------------------------------
+
+// bitwise operators
+
+inline const sc_logic operator & ( const sc_logic& a, const sc_logic& b )
+       { return sc_logic( sc_logic::and_table[a.m_val][b.m_val] ); }
+
+inline const sc_logic operator | ( const sc_logic& a, const sc_logic& b )
+       { return sc_logic( sc_logic::or_table[a.m_val][b.m_val] ); }
+
+inline const sc_logic operator ^ ( const sc_logic& a, const sc_logic& b )
+       { return sc_logic( sc_logic::xor_table[a.m_val][b.m_val] ); }
+
+#define DEFN_BIN_OP_T(ret,op,tp)                       \
+    inline ret operator op ( const sc_logic& a, tp b ) \
+        { return ( a op sc_logic( b ) ); }             \
+    inline ret operator op ( tp a, const sc_logic& b ) \
+        { return ( sc_logic( a ) op b ); }
+
+#define DEFN_BIN_OP(ret,op)                            \
+    DEFN_BIN_OP_T(ret,op,sc_logic_value_t)             \
+    DEFN_BIN_OP_T(ret,op,bool)                         \
+    DEFN_BIN_OP_T(ret,op,char)                         \
+    DEFN_BIN_OP_T(ret,op,int)
+
+DEFN_BIN_OP(const sc_logic,&)
+DEFN_BIN_OP(const sc_logic,|)
+DEFN_BIN_OP(const sc_logic,^)
+
+// relational operators and functions
+
+inline bool operator == ( const sc_logic& a, const sc_logic& b )
+       { return ( (int) a.m_val == b.m_val ); }
+
+inline bool operator != ( const sc_logic& a, const sc_logic& b )
+       { return ( (int) a.m_val != b.m_val ); }
+
+DEFN_BIN_OP(bool,==)
+DEFN_BIN_OP(bool,!=)
+
+#undef DEFN_BIN_OP_T
+#undef DEFN_BIN_OP
+
+// ----------------------------------------------------------------------------
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_logic& a )
+{
+    a.print( os );
+    return os;
+}
+
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_logic& a )
+{
+    a.scan( is );
+    return is;
+}
+
+
+extern const sc_logic SC_LOGIC_0;
+extern const sc_logic SC_LOGIC_1;
+extern const sc_logic SC_LOGIC_Z;
+extern const sc_logic SC_LOGIC_X;
+
+// #ifdef SC_DT_DEPRECATED
+extern const sc_logic sc_logic_0;
+extern const sc_logic sc_logic_1;
+extern const sc_logic sc_logic_Z;
+extern const sc_logic sc_logic_X;
+// #endif
+
+} // namespace sc_dt
+
+#endif
diff --git a/ext/systemc/src/sysc/datatypes/bit/sc_lv.h b/ext/systemc/src/sysc/datatypes/bit/sc_lv.h
new file mode 100644
index 000000000..8eae23b73
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/bit/sc_lv.h
@@ -0,0 +1,205 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_lv.h -- Arbitrary size logic vector class.
+
+  Original Author: Gene Bushuyev, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_lv.h,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:53  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SC_LV_H
+#define SC_LV_H
+
+
+#include "sysc/datatypes/bit/sc_lv_base.h"
+
+
+namespace sc_dt
+{
+
+// classes defined in this module
+template <int W> class sc_lv;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_lv<W>
+//
+//  Arbitrary size logic vector class.
+// ----------------------------------------------------------------------------
+
+template <int W>
+class sc_lv
+    : public sc_lv_base
+{
+public:
+
+    // constructors
+
+    sc_lv()
+	: sc_lv_base( W )
+	{}
+
+    explicit sc_lv( const sc_logic& init_value )
+	: sc_lv_base( init_value, W )
+	{}
+
+    explicit sc_lv( bool init_value )
+	: sc_lv_base( sc_logic( init_value ), W )
+	{}
+
+    explicit sc_lv( char init_value )
+	: sc_lv_base( sc_logic( init_value ), W )
+	{}
+
+    sc_lv( const char* a )
+	: sc_lv_base( W )
+	{ sc_lv_base::operator = ( a ); }
+
+    sc_lv( const bool* a )
+	: sc_lv_base( W )
+	{ sc_lv_base::operator = ( a ); }
+
+    sc_lv( const sc_logic* a )
+	: sc_lv_base( W )
+	{ sc_lv_base::operator = ( a ); }
+
+    sc_lv( const sc_unsigned& a )
+	: sc_lv_base( W )
+	{ sc_lv_base::operator = ( a ); }
+
+    sc_lv( const sc_signed& a )
+	: sc_lv_base( W )
+	{ sc_lv_base::operator = ( a ); }
+
+    sc_lv( const sc_uint_base& a )
+	: sc_lv_base( W )
+	{ sc_lv_base::operator = ( a ); }
+
+    sc_lv( const sc_int_base& a )
+	: sc_lv_base( W )
+	{ sc_lv_base::operator = ( a ); }
+
+    sc_lv( unsigned long a )
+	: sc_lv_base( W )
+	{ sc_lv_base::operator = ( a ); }
+
+    sc_lv( long a )
+	: sc_lv_base( W )
+	{ sc_lv_base::operator = ( a ); }
+
+    sc_lv( unsigned int a )
+	: sc_lv_base( W )
+	{ sc_lv_base::operator = ( a ); }
+
+    sc_lv( int a )
+	: sc_lv_base( W )
+	{ sc_lv_base::operator = ( a ); }
+
+    sc_lv( uint64 a )
+	: sc_lv_base( W )
+	{ sc_lv_base::operator = ( a ); }
+
+    sc_lv( int64 a )
+	: sc_lv_base( W )
+	{ sc_lv_base::operator = ( a ); }
+
+    template <class X>
+    sc_lv( const sc_proxy<X>& a )
+	: sc_lv_base( W )
+	{ sc_lv_base::operator = ( a ); }
+
+    sc_lv( const sc_lv<W>& a )
+	: sc_lv_base( a )
+	{}
+
+
+    // assignment operators
+
+    template <class X>
+    sc_lv<W>& operator = ( const sc_proxy<X>& a )
+	{ sc_lv_base::operator = ( a ); return *this; }
+
+    sc_lv<W>& operator = ( const sc_lv<W>& a )
+	{ sc_lv_base::operator = ( a ); return *this; }
+
+    sc_lv<W>& operator = ( const char* a )
+	{ sc_lv_base::operator = ( a ); return *this; }
+
+    sc_lv<W>& operator = ( const bool* a )
+	{ sc_lv_base::operator = ( a ); return *this; }
+
+    sc_lv<W>& operator = ( const sc_logic* a )
+	{ sc_lv_base::operator = ( a ); return *this; }
+
+    sc_lv<W>& operator = ( const sc_unsigned& a )
+	{ sc_lv_base::operator = ( a ); return *this; }
+
+    sc_lv<W>& operator = ( const sc_signed& a )
+	{ sc_lv_base::operator = ( a ); return *this; }
+
+    sc_lv<W>& operator = ( const sc_uint_base& a )
+	{ sc_lv_base::operator = ( a ); return *this; }
+
+    sc_lv<W>& operator = ( const sc_int_base& a )
+	{ sc_lv_base::operator = ( a ); return *this; }
+
+    sc_lv<W>& operator = ( unsigned long a )
+	{ sc_lv_base::operator = ( a ); return *this; }
+
+    sc_lv<W>& operator = ( long a )
+	{ sc_lv_base::operator = ( a ); return *this; }
+
+    sc_lv<W>& operator = ( unsigned int a )
+	{ sc_lv_base::operator = ( a ); return *this; }
+
+    sc_lv<W>& operator = ( int a )
+	{ sc_lv_base::operator = ( a ); return *this; }
+
+    sc_lv<W>& operator = ( uint64 a )
+	{ sc_lv_base::operator = ( a ); return *this; }
+
+    sc_lv<W>& operator = ( int64 a )
+	{ sc_lv_base::operator = ( a ); return *this; }
+};
+
+} // namespace sc_dt
+
+
+#endif
diff --git a/ext/systemc/src/sysc/datatypes/bit/sc_lv_base.cpp b/ext/systemc/src/sysc/datatypes/bit/sc_lv_base.cpp
new file mode 100644
index 000000000..617d74d03
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/bit/sc_lv_base.cpp
@@ -0,0 +1,173 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_lv_base.cpp -- Arbitrary size logic vector class.
+
+  Original Author: Gene Bushuyev, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_lv_base.cpp,v $
+// Revision 1.2  2011/08/24 22:05:40  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:53  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include "sysc/datatypes/bit/sc_bit_ids.h"
+#include "sysc/datatypes/bit/sc_lv_base.h"
+
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_lv_base
+//
+//  Arbitrary size logic vector base class.
+// ----------------------------------------------------------------------------
+
+static const sc_digit data_array[] =
+    { SC_DIGIT_ZERO, ~SC_DIGIT_ZERO, SC_DIGIT_ZERO, ~SC_DIGIT_ZERO };
+
+static const sc_digit ctrl_array[] =
+    { SC_DIGIT_ZERO, SC_DIGIT_ZERO, ~SC_DIGIT_ZERO, ~SC_DIGIT_ZERO };
+
+
+void
+sc_lv_base::init( int length_, const sc_logic& init_value )
+{
+    // check the length
+    if( length_ <= 0 ) {
+	SC_REPORT_ERROR( sc_core::SC_ID_ZERO_LENGTH_, 0 );
+    }
+    // allocate memory for the data and control words
+    m_len = length_;
+    m_size = (m_len - 1) / SC_DIGIT_SIZE + 1;
+    m_data = new sc_digit[m_size * 2];
+    m_ctrl = m_data + m_size;
+    // initialize the bits to 'init_value'
+    sc_digit dw = data_array[init_value.value()];
+    sc_digit cw = ctrl_array[init_value.value()];
+    int sz = m_size;
+    for( int i = 0; i < sz; ++ i ) {
+	m_data[i] = dw;
+	m_ctrl[i] = cw;
+    }
+    clean_tail();
+}
+
+
+void
+sc_lv_base::assign_from_string( const std::string& s )
+{
+    // s must have been converted to bin
+    int len = m_len;
+    int s_len = s.length() - 1;
+    int min_len = sc_min( len, s_len );
+    int i = 0;
+    for( ; i < min_len; ++ i ) {
+	char c = s[s_len - i - 1];
+	set_bit( i, sc_logic::char_to_logic[(int)c] );
+    }
+    // if formatted, fill the rest with sign(s), otherwise fill with zeros
+    sc_logic_value_t fill = (s[s_len] == 'F' ? sc_logic_value_t( s[0] - '0' )
+		                             : sc_logic_value_t( 0 ));
+    for( ; i < len; ++ i ) {
+	set_bit( i, fill );
+    }
+}
+
+
+// constructors
+
+sc_lv_base::sc_lv_base( const char* a )
+    : m_len( 0 ), m_size( 0 ), m_data( 0 ), m_ctrl( 0 )
+{
+    std::string s = convert_to_bin( a );
+    init( s.length() - 1 );
+    assign_from_string( s );
+}
+
+sc_lv_base::sc_lv_base( const char* a, int length_ )
+    : m_len( 0 ), m_size( 0 ), m_data( 0 ), m_ctrl( 0 )
+{
+    init( length_ );
+    assign_from_string( convert_to_bin( a ) );
+}
+
+sc_lv_base::sc_lv_base( const sc_lv_base& a )
+    : sc_proxy<sc_lv_base>(),
+      m_len( a.m_len ),
+      m_size( a.m_size ),
+      m_data( new sc_digit[m_size * 2] ),
+      m_ctrl( m_data + m_size )
+{
+    // copy the bits
+    int sz = m_size;
+    for( int i = 0; i < sz; ++ i ) {
+	m_data[i] = a.m_data[i];
+	m_ctrl[i] = a.m_ctrl[i];
+    }
+}
+
+
+// assignment operators
+
+sc_lv_base&
+sc_lv_base::operator = ( const char* a )
+{
+    assign_from_string( convert_to_bin( a ) );
+    return *this;
+}
+
+
+// returns true if logic vector contains only 0's and 1's
+
+bool
+sc_lv_base::is_01() const
+{
+    int sz = m_size;
+    for( int i = 0; i < sz; ++ i ) {
+	if( m_ctrl[i] != 0 ) {
+	    return false;
+	}
+    }
+    return true;
+}
+
+} // namespace sc_dt
diff --git a/ext/systemc/src/sysc/datatypes/bit/sc_lv_base.h b/ext/systemc/src/sysc/datatypes/bit/sc_lv_base.h
new file mode 100644
index 000000000..313afa56e
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/bit/sc_lv_base.h
@@ -0,0 +1,1827 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_lv_base.h -- Arbitrary size logic vector class.
+
+  Original Author: Gene Bushuyev, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+	Andy Goodrich, Forte Design Systems
+	  Fixed bug in clean_tail for sizes that are modulo 32, which caused
+	  zeroing of values.
+
+ *****************************************************************************/
+
+// $Log: sc_lv_base.h,v $
+// Revision 1.4  2011/08/26 22:32:00  acg
+//  Torsten Maehne: added parentheses to make opearator ordering more obvious.
+//
+// Revision 1.3  2010/01/27 19:41:29  acg
+//  Andy Goodrich: fix 8 instances of sc_concref constructor invocations
+//  that failed to indicate that their arguments should be freed when the
+//  object was freed.
+//
+// Revision 1.2  2009/02/28 00:26:14  acg
+//  Andy Goodrich: bug fixes.
+//
+// Revision 1.2  2007/03/14 17:47:49  acg
+//  Andy Goodrich: Formatting.
+//
+// Revision 1.1.1.1  2006/12/15 20:31:36  acg
+// SystemC 2.2
+//
+// Revision 1.3  2006/01/13 18:53:53  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SC_LV_BASE_H
+#define SC_LV_BASE_H
+
+
+#include "sysc/datatypes/bit/sc_bit_ids.h"
+#include "sysc/datatypes/bit/sc_bv_base.h"
+#include "sysc/datatypes/bit/sc_logic.h"
+#include "sysc/datatypes/int/sc_length_param.h"
+
+
+namespace sc_dt
+{
+
+// classes defined in this module
+class sc_lv_base;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_lv_base
+//
+//  Arbitrary size logic vector base class.
+// ----------------------------------------------------------------------------
+
+class sc_lv_base
+    : public sc_proxy<sc_lv_base>
+{
+    friend class sc_bv_base;
+
+
+    void init( int length_, const sc_logic& init_value = SC_LOGIC_X );
+
+    void assign_from_string( const std::string& );
+
+public:
+
+    // typedefs
+
+    typedef sc_proxy<sc_lv_base> base_type;
+
+
+    // constructors
+
+    explicit sc_lv_base( int length_ = sc_length_param().len() )
+	: m_len( 0 ), m_size( 0 ), m_data( 0 ), m_ctrl( 0 )
+	{ init( length_ ); }
+
+    explicit sc_lv_base( const sc_logic& a,
+			 int length_ = sc_length_param().len()  )
+	: m_len( 0 ), m_size( 0 ), m_data( 0 ), m_ctrl( 0 )
+	{ init( length_, a ); }
+
+    sc_lv_base( const char* a );
+
+    sc_lv_base( const char* a, int length_ );
+
+    template <class X>
+    sc_lv_base( const sc_proxy<X>& a )
+	: m_len( 0 ), m_size( 0 ), m_data( 0 ), m_ctrl( 0 )
+	{ init( a.back_cast().length() ); base_type::assign_( a ); }
+
+    sc_lv_base( const sc_lv_base& a );
+
+#ifdef SC_DT_DEPRECATED
+
+    explicit sc_lv_base( const sc_unsigned& a )
+	: m_len( 0 ), m_size( 0 ), m_data( 0 ), m_ctrl( 0 )
+	{ init( a.length() ); base_type::assign_( a ); }
+
+    explicit sc_lv_base( const sc_signed& a )
+	: m_len( 0 ), m_size( 0 ), m_data( 0 ), m_ctrl( 0 )
+	{ init( a.length() ); base_type::assign_( a ); }
+
+    explicit sc_lv_base( const sc_uint_base& a )
+	: m_len( 0 ), m_size( 0 ), m_data( 0 ), m_ctrl( 0 )
+	{ init( a.length() ); base_type::assign_( a ); }
+
+    explicit sc_lv_base( const sc_int_base& a )
+	: m_len( 0 ), m_size( 0 ), m_data( 0 ), m_ctrl( 0 )
+	{ init( a.length() ); base_type::assign_( a ); }
+
+#endif
+
+
+    // destructor
+
+    virtual ~sc_lv_base()
+	{ delete [] m_data; }
+
+
+    // assignment operators
+
+    template <class X>
+    sc_lv_base& operator = ( const sc_proxy<X>& a )
+	{ assign_p_( *this, a ); return *this; }
+
+    sc_lv_base& operator = ( const sc_lv_base& a )
+	{ assign_p_( *this, a ); return *this; }
+
+    sc_lv_base& operator = ( const char* a );
+
+    sc_lv_base& operator = ( const bool* a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_lv_base& operator = ( const sc_logic* a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_lv_base& operator = ( const sc_unsigned& a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_lv_base& operator = ( const sc_signed& a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_lv_base& operator = ( const sc_uint_base& a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_lv_base& operator = ( const sc_int_base& a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_lv_base& operator = ( unsigned long a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_lv_base& operator = ( long a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_lv_base& operator = ( unsigned int a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_lv_base& operator = ( int a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_lv_base& operator = ( uint64 a )
+	{ base_type::assign_( a ); return *this; }
+
+    sc_lv_base& operator = ( int64 a )
+	{ base_type::assign_( a ); return *this; }
+
+
+#if 0
+
+    // bitwise complement
+
+    sc_lv_base& b_not()
+	{ return sc_proxy<sc_lv_base>::b_not(); }
+
+    const sc_lv_base operator ~ () const
+	{ sc_lv_base a( *this ); return a.b_not(); }
+
+
+    // bitwise left shift
+
+    sc_lv_base& operator <<= ( int n )
+	{ return sc_proxy<sc_lv_base>::operator <<= ( n ); }
+
+    const sc_lv_base operator << ( int n ) const
+	{ sc_lv_base a( *this ); return ( a <<= n ); }
+
+
+    // bitwise right shift
+
+    sc_lv_base& operator >>= ( int n )
+	{ return sc_proxy<sc_lv_base>::operator >>= ( n ); }
+
+    const sc_lv_base operator >> ( int n ) const
+	{ sc_lv_base a( *this ); return ( a >>= n ); }
+
+
+    // bitwise left rotate
+
+    sc_lv_base& lrotate( int n )
+	{ return sc_proxy<sc_lv_base>::lrotate( n ); }
+
+
+    // bitwise right rotate
+
+    sc_lv_base& rrotate( int n )
+	{ return sc_proxy<sc_lv_base>::rrotate( n ); }
+
+#endif
+
+
+    // common methods
+
+    int length() const
+	{ return m_len; }
+
+    int size() const
+	{ return m_size; }
+
+    sc_logic_value_t get_bit( int i ) const;
+    void set_bit( int i, sc_logic_value_t value );
+
+    sc_digit get_word( int wi ) const
+	{ return m_data[wi]; }
+
+	// note the test for out of range access here. this is necessary 
+	// because of the hair-brained way concatenations are set up.
+	// an extend_sign on a concatenation uses the whole length of 
+	// the concatenation to determine how many words to set.
+    void set_word( int wi, sc_digit w )
+	{ assert ( wi < m_size ); m_data[wi] = w; }
+	 
+
+    sc_digit get_cword( int wi ) const
+	{ return m_ctrl[wi]; }
+
+    void set_cword( int wi, sc_digit w )
+	{ assert ( wi < m_size ); m_ctrl[wi] = w; }
+
+    void clean_tail();
+
+
+    // other methods
+
+    bool is_01() const;
+
+protected:
+
+    int     m_len;   // length in bits
+    int     m_size;  // size of the data array
+    sc_digit* m_data;  // data array
+    sc_digit* m_ctrl;  // dito (control part)
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+#if 0
+
+// bitwise left rotate
+
+inline
+const sc_lv_base
+lrotate( const sc_lv_base& x, int n )
+{
+    sc_lv_base a( x );
+    return a.lrotate( n );
+}
+
+
+// bitwise right rotate
+
+inline
+const sc_lv_base
+rrotate( const sc_lv_base& x, int n )
+{
+    sc_lv_base a( x );
+    return a.rrotate( n );
+}
+
+#endif
+
+
+inline
+sc_logic_value_t
+sc_lv_base::get_bit( int i ) const
+{
+    int wi = i / SC_DIGIT_SIZE;
+    int bi = i % SC_DIGIT_SIZE;
+    return sc_logic_value_t( ((m_data[wi] >> bi) & SC_DIGIT_ONE) |
+			     (((m_ctrl[wi] >> bi) << 1) & SC_DIGIT_TWO) );
+}
+
+inline
+void
+sc_lv_base::set_bit( int i, sc_logic_value_t value )
+{
+    int wi = i / SC_DIGIT_SIZE; // word index
+    int bi = i % SC_DIGIT_SIZE; // bit index
+    sc_digit mask = SC_DIGIT_ONE << bi;
+    m_data[wi] |= mask; // set bit to 1
+    m_ctrl[wi] |= mask; // set bit to 1
+    m_data[wi] &= value << bi | ~mask;
+    m_ctrl[wi] &= value >> 1 << bi | ~mask;
+}
+
+
+inline
+void
+sc_lv_base::clean_tail()
+{
+    int wi = m_size - 1;
+    int bi = m_len % SC_DIGIT_SIZE;
+    sc_digit mask = ~SC_DIGIT_ZERO >> (SC_DIGIT_SIZE - bi);
+	if ( mask )
+	{
+		m_data[wi] &= mask;
+		m_ctrl[wi] &= mask;
+	}
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_proxy
+//
+//  Base class template for bit/logic vector classes.
+//  (Barton/Nackmann implementation)
+// ----------------------------------------------------------------------------
+
+// bitwise operators and functions
+
+// bitwise complement
+
+template <class X>
+inline
+const sc_lv_base
+sc_proxy<X>::operator ~ () const
+{
+    sc_lv_base a( back_cast() );
+    return a.b_not();
+}
+
+
+// bitwise and
+
+template <class X, class Y>
+inline
+X&
+operator &= ( sc_proxy<X>& px, const sc_proxy<Y>& py )
+{
+    X& x = px.back_cast();
+    sc_lv_base a( x.length() );
+    a = py.back_cast();
+    return b_and_assign_( x, a );
+}
+
+
+#define DEFN_BITWISE_AND_ASN_OP_T(tp)                                         \
+template <class X>                                                            \
+inline                                                                        \
+X&                                                                            \
+sc_proxy<X>::operator &= ( tp b )                                             \
+{                                                                             \
+    X& x = back_cast();                                                       \
+    sc_lv_base a( x.length() );                                               \
+    a = b;                                                                    \
+    return b_and_assign_( x, a );                                             \
+}
+
+DEFN_BITWISE_AND_ASN_OP_T(const char*)
+DEFN_BITWISE_AND_ASN_OP_T(const bool*)
+DEFN_BITWISE_AND_ASN_OP_T(const sc_logic*)
+DEFN_BITWISE_AND_ASN_OP_T(const sc_unsigned&)
+DEFN_BITWISE_AND_ASN_OP_T(const sc_signed&)
+DEFN_BITWISE_AND_ASN_OP_T(unsigned long)
+DEFN_BITWISE_AND_ASN_OP_T(long)
+DEFN_BITWISE_AND_ASN_OP_T(uint64)
+DEFN_BITWISE_AND_ASN_OP_T(int64)
+
+#undef DEFN_BITWISE_AND_ASN_OP_T
+
+
+template <class X, class Y>
+inline
+const sc_lv_base
+operator & ( const sc_proxy<X>& px, const sc_proxy<Y>& py )
+{
+    sc_lv_base a( px.back_cast() );
+    return ( a &= py.back_cast() );
+}
+
+
+#define DEFN_BITWISE_AND_OP_T_A(tp)                                           \
+template <class X>                                                            \
+inline                                                                        \
+const sc_lv_base                                                              \
+sc_proxy<X>::operator & ( tp b ) const                                        \
+{                                                                             \
+    sc_lv_base a( back_cast() );                                              \
+    return ( a &= b );                                                        \
+}
+
+DEFN_BITWISE_AND_OP_T_A(const char*)
+DEFN_BITWISE_AND_OP_T_A(const bool*)
+DEFN_BITWISE_AND_OP_T_A(const sc_logic*)
+DEFN_BITWISE_AND_OP_T_A(const sc_unsigned&)
+DEFN_BITWISE_AND_OP_T_A(const sc_signed&)
+DEFN_BITWISE_AND_OP_T_A(const sc_uint_base&)
+DEFN_BITWISE_AND_OP_T_A(const sc_int_base&)
+DEFN_BITWISE_AND_OP_T_A(unsigned long)
+DEFN_BITWISE_AND_OP_T_A(long)
+DEFN_BITWISE_AND_OP_T_A(unsigned int)
+DEFN_BITWISE_AND_OP_T_A(int)
+DEFN_BITWISE_AND_OP_T_A(uint64)
+DEFN_BITWISE_AND_OP_T_A(int64)
+
+#undef DEFN_BITWISE_AND_OP_T_A
+
+
+#define DEFN_BITWISE_AND_OP_T_B(tp)                                           \
+template <class X>                                                            \
+inline                                                                        \
+const sc_lv_base                                                              \
+operator & ( tp b, const sc_proxy<X>& px )                                    \
+{                                                                             \
+    return ( px & b );                                                        \
+}
+
+DEFN_BITWISE_AND_OP_T_B(const char*)
+DEFN_BITWISE_AND_OP_T_B(const bool*)
+DEFN_BITWISE_AND_OP_T_B(const sc_logic*)
+DEFN_BITWISE_AND_OP_T_B(const sc_unsigned&)
+DEFN_BITWISE_AND_OP_T_B(const sc_signed&)
+DEFN_BITWISE_AND_OP_T_B(const sc_uint_base&)
+DEFN_BITWISE_AND_OP_T_B(const sc_int_base&)
+DEFN_BITWISE_AND_OP_T_B(unsigned long)
+DEFN_BITWISE_AND_OP_T_B(long)
+DEFN_BITWISE_AND_OP_T_B(unsigned int)
+DEFN_BITWISE_AND_OP_T_B(int)
+DEFN_BITWISE_AND_OP_T_B(uint64)
+DEFN_BITWISE_AND_OP_T_B(int64)
+
+#undef DEFN_BITWISE_AND_OP_T_B
+
+
+// bitwise or
+
+template <class X, class Y>
+inline
+X&
+operator |= ( sc_proxy<X>& px, const sc_proxy<Y>& py )
+{
+    X& x = px.back_cast();
+    sc_lv_base a( x.length() );
+    a = py.back_cast();
+    return b_or_assign_( x, a );
+}
+
+
+#define DEFN_BITWISE_OR_ASN_OP_T(tp)                                          \
+template <class X>                                                            \
+inline                                                                        \
+X&                                                                            \
+sc_proxy<X>::operator |= ( tp b )                                             \
+{                                                                             \
+    X& x = back_cast();                                                       \
+    sc_lv_base a( x.length() );                                               \
+    a = b;                                                                    \
+    return b_or_assign_( x, a );                                              \
+}
+
+DEFN_BITWISE_OR_ASN_OP_T(const char*)
+DEFN_BITWISE_OR_ASN_OP_T(const bool*)
+DEFN_BITWISE_OR_ASN_OP_T(const sc_logic*)
+DEFN_BITWISE_OR_ASN_OP_T(const sc_unsigned&)
+DEFN_BITWISE_OR_ASN_OP_T(const sc_signed&)
+DEFN_BITWISE_OR_ASN_OP_T(unsigned long)
+DEFN_BITWISE_OR_ASN_OP_T(long)
+DEFN_BITWISE_OR_ASN_OP_T(uint64)
+DEFN_BITWISE_OR_ASN_OP_T(int64)
+
+#undef DEFN_BITWISE_OR_ASN_OP_T
+
+
+template <class X, class Y>
+inline
+const sc_lv_base
+operator | ( const sc_proxy<X>& px, const sc_proxy<Y>& py )
+{
+    sc_lv_base a( px.back_cast() );
+    return ( a |= py.back_cast() );
+}
+
+
+#define DEFN_BITWISE_OR_OP_T_A(tp)                                            \
+template <class X>                                                            \
+inline                                                                        \
+const sc_lv_base                                                              \
+sc_proxy<X>::operator | ( tp b ) const                                        \
+{                                                                             \
+    sc_lv_base a( back_cast() );                                              \
+    return ( a |= b );                                                        \
+}
+
+DEFN_BITWISE_OR_OP_T_A(const char*)
+DEFN_BITWISE_OR_OP_T_A(const bool*)
+DEFN_BITWISE_OR_OP_T_A(const sc_logic*)
+DEFN_BITWISE_OR_OP_T_A(const sc_unsigned&)
+DEFN_BITWISE_OR_OP_T_A(const sc_signed&)
+DEFN_BITWISE_OR_OP_T_A(const sc_uint_base&)
+DEFN_BITWISE_OR_OP_T_A(const sc_int_base&)
+DEFN_BITWISE_OR_OP_T_A(unsigned long)
+DEFN_BITWISE_OR_OP_T_A(long)
+DEFN_BITWISE_OR_OP_T_A(unsigned int)
+DEFN_BITWISE_OR_OP_T_A(int)
+DEFN_BITWISE_OR_OP_T_A(uint64)
+DEFN_BITWISE_OR_OP_T_A(int64)
+
+#undef DEFN_BITWISE_OR_OP_T_A
+
+
+#define DEFN_BITWISE_OR_OP_T_B(tp)                                           \
+template <class X>                                                            \
+inline                                                                        \
+const sc_lv_base                                                              \
+operator | ( tp b, const sc_proxy<X>& px )                                    \
+{                                                                             \
+    return ( px | b );                                                        \
+}
+
+DEFN_BITWISE_OR_OP_T_B(const char*)
+DEFN_BITWISE_OR_OP_T_B(const bool*)
+DEFN_BITWISE_OR_OP_T_B(const sc_logic*)
+DEFN_BITWISE_OR_OP_T_B(const sc_unsigned&)
+DEFN_BITWISE_OR_OP_T_B(const sc_signed&)
+DEFN_BITWISE_OR_OP_T_B(const sc_uint_base&)
+DEFN_BITWISE_OR_OP_T_B(const sc_int_base&)
+DEFN_BITWISE_OR_OP_T_B(unsigned long)
+DEFN_BITWISE_OR_OP_T_B(long)
+DEFN_BITWISE_OR_OP_T_B(unsigned int)
+DEFN_BITWISE_OR_OP_T_B(int)
+DEFN_BITWISE_OR_OP_T_B(uint64)
+DEFN_BITWISE_OR_OP_T_B(int64)
+
+#undef DEFN_BITWISE_OR_OP_T_B
+
+
+// bitwise xor
+
+template <class X, class Y>
+inline
+X&
+operator ^= ( sc_proxy<X>& px, const sc_proxy<Y>& py )
+{
+    X& x = px.back_cast();
+    sc_lv_base a( x.length() );
+    a = py.back_cast();
+    return b_xor_assign_( x, a );
+}
+
+
+#define DEFN_BITWISE_XOR_ASN_OP_T(tp)                                         \
+template <class X>                                                            \
+inline                                                                        \
+X&                                                                            \
+sc_proxy<X>::operator ^= ( tp b )                                             \
+{                                                                             \
+    X& x = back_cast();                                                       \
+    sc_lv_base a( x.length() );                                               \
+    a = b;                                                                    \
+    return b_xor_assign_( x, a );                                             \
+}
+
+DEFN_BITWISE_XOR_ASN_OP_T(const char*)
+DEFN_BITWISE_XOR_ASN_OP_T(const bool*)
+DEFN_BITWISE_XOR_ASN_OP_T(const sc_logic*)
+DEFN_BITWISE_XOR_ASN_OP_T(const sc_unsigned&)
+DEFN_BITWISE_XOR_ASN_OP_T(const sc_signed&)
+DEFN_BITWISE_XOR_ASN_OP_T(unsigned long)
+DEFN_BITWISE_XOR_ASN_OP_T(long)
+DEFN_BITWISE_XOR_ASN_OP_T(uint64)
+DEFN_BITWISE_XOR_ASN_OP_T(int64)
+
+#undef DEFN_BITWISE_XOR_ASN_OP_T
+
+
+template <class X, class Y>
+inline
+const sc_lv_base
+operator ^ ( const sc_proxy<X>& px, const sc_proxy<Y>& py )
+{
+    sc_lv_base a( px.back_cast() );
+    return ( a ^= py.back_cast() );
+}
+
+
+#define DEFN_BITWISE_XOR_OP_T_A(tp)                                           \
+template <class X>                                                            \
+inline                                                                        \
+const sc_lv_base                                                              \
+sc_proxy<X>::operator ^ ( tp b ) const                                        \
+{                                                                             \
+    sc_lv_base a( back_cast() );                                              \
+    return ( a ^= b );                                                        \
+}
+
+DEFN_BITWISE_XOR_OP_T_A(const char*)
+DEFN_BITWISE_XOR_OP_T_A(const bool*)
+DEFN_BITWISE_XOR_OP_T_A(const sc_logic*)
+DEFN_BITWISE_XOR_OP_T_A(const sc_unsigned&)
+DEFN_BITWISE_XOR_OP_T_A(const sc_signed&)
+DEFN_BITWISE_XOR_OP_T_A(const sc_uint_base&)
+DEFN_BITWISE_XOR_OP_T_A(const sc_int_base&)
+DEFN_BITWISE_XOR_OP_T_A(unsigned long)
+DEFN_BITWISE_XOR_OP_T_A(long)
+DEFN_BITWISE_XOR_OP_T_A(unsigned int)
+DEFN_BITWISE_XOR_OP_T_A(int)
+DEFN_BITWISE_XOR_OP_T_A(uint64)
+DEFN_BITWISE_XOR_OP_T_A(int64)
+
+#undef DEFN_BITWISE_XOR_OP_T_A
+
+
+#define DEFN_BITWISE_XOR_OP_T_B(tp)                                           \
+template <class X>                                                            \
+inline                                                                        \
+const sc_lv_base                                                              \
+operator ^ ( tp b, const sc_proxy<X>& px )                                    \
+{                                                                             \
+    return ( px ^ b );                                                        \
+}
+
+DEFN_BITWISE_XOR_OP_T_B(const char*)
+DEFN_BITWISE_XOR_OP_T_B(const bool*)
+DEFN_BITWISE_XOR_OP_T_B(const sc_logic*)
+DEFN_BITWISE_XOR_OP_T_B(const sc_unsigned&)
+DEFN_BITWISE_XOR_OP_T_B(const sc_signed&)
+DEFN_BITWISE_XOR_OP_T_B(const sc_uint_base&)
+DEFN_BITWISE_XOR_OP_T_B(const sc_int_base&)
+DEFN_BITWISE_XOR_OP_T_B(unsigned long)
+DEFN_BITWISE_XOR_OP_T_B(long)
+DEFN_BITWISE_XOR_OP_T_B(unsigned int)
+DEFN_BITWISE_XOR_OP_T_B(int)
+DEFN_BITWISE_XOR_OP_T_B(uint64)
+DEFN_BITWISE_XOR_OP_T_B(int64)
+
+#undef DEFN_BITWISE_XOR_OP_T_B
+
+
+// bitwise left shift
+
+template <class X>
+inline
+const sc_lv_base
+sc_proxy<X>::operator << ( int n ) const
+{
+    sc_lv_base a( back_cast().length()+n );
+	a = back_cast();
+    return ( a <<= n );
+}
+
+
+// bitwise right shift
+
+template <class X>
+inline
+const sc_lv_base
+sc_proxy<X>::operator >> ( int n ) const
+{
+    sc_lv_base a( back_cast() );
+    return ( a >>= n );
+}
+
+
+// bitwise left rotate
+
+template <class X>
+inline
+X&
+sc_proxy<X>::lrotate( int n )
+{
+    X& x = back_cast();
+    if( n < 0 ) {
+	char msg[BUFSIZ];
+	std::sprintf( msg,
+		 "left rotate operation is only allowed with positive "
+		 "rotate values, rotate value = %d", n );
+	SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
+    }
+    int len = x.length();
+    n %= len;
+    // x = (x << n) | (x >> (len - n));
+    sc_lv_base a( x << n );
+    sc_lv_base b( x >> (len - n) );
+    int sz = x.size();
+    for( int i = 0; i < sz; ++ i ) {
+	x.set_word( i, a.get_word( i ) | b.get_word( i ) );
+	x.set_cword( i, a.get_cword( i ) | b.get_cword( i ) );
+    }
+    x.clean_tail();
+    return x;
+}
+
+template <class X>
+inline
+const sc_lv_base
+lrotate( const sc_proxy<X>& x, int n )
+{
+    sc_lv_base a( x.back_cast() );
+    return a.lrotate( n );
+}
+
+
+// bitwise right rotate
+
+template <class X>
+inline
+X&
+sc_proxy<X>::rrotate( int n )
+{
+    X& x = back_cast();
+    if( n < 0 ) {
+	char msg[BUFSIZ];
+	std::sprintf( msg,
+		 "right rotate operation is only allowed with positive "
+		 "rotate values, rotate value = %d", n );
+	SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
+    }
+    int len = x.length();
+    n %= len;
+    // x = (x >> n) | (x << (len - n));
+    sc_lv_base a( x >> n );
+    sc_lv_base b( x << (len - n) );
+    int sz = x.size();
+    for( int i = 0; i < sz; ++ i ) {
+	x.set_word( i, a.get_word( i ) | b.get_word( i ) );
+	x.set_cword( i, a.get_cword( i ) | b.get_cword( i ) );
+    }
+    x.clean_tail();
+    return x;
+}
+
+template <class X>
+inline
+const sc_lv_base
+rrotate( const sc_proxy<X>& x, int n )
+{
+    sc_lv_base a( x.back_cast() );
+    return a.rrotate( n );
+}
+
+
+// bitwise reverse
+
+template <class X>
+inline
+const sc_lv_base
+reverse( const sc_proxy<X>& x )
+{
+    sc_lv_base a( x.back_cast() );
+    return a.reverse();
+}
+
+
+// relational operators
+
+template <class X, class Y>
+inline
+bool
+operator == ( const sc_proxy<X>& px, const sc_proxy<Y>& py )
+{
+    const X& x = px.back_cast();
+    const Y& y = py.back_cast();
+    int x_len = x.length();
+    int y_len = y.length();
+    if( x_len != y_len ) {
+	return false;
+    }
+    int sz = x.size();
+    for( int i = 0; i < sz; ++ i ) {
+	if( x.get_word( i ) != y.get_word( i ) ||
+	    x.get_cword( i ) != y.get_cword( i ) ) {
+	    return false;
+	}
+    }
+    return true;
+}
+
+
+#define DEFN_REL_OP_T(tp)                                                     \
+template <class X>                                                            \
+inline                                                                        \
+bool                                                                          \
+sc_proxy<X>::operator == ( tp b ) const                                       \
+{                                                                             \
+    const X& x = back_cast();                                                 \
+    sc_lv_base y( x.length() );                                               \
+    y = b;                                                                    \
+    return ( x == y );                                                        \
+}
+
+DEFN_REL_OP_T(const char*)
+DEFN_REL_OP_T(const bool*)
+DEFN_REL_OP_T(const sc_logic*)
+DEFN_REL_OP_T(const sc_unsigned&)
+DEFN_REL_OP_T(const sc_signed&)
+DEFN_REL_OP_T(const sc_uint_base&)
+DEFN_REL_OP_T(const sc_int_base&)
+DEFN_REL_OP_T(unsigned long)
+DEFN_REL_OP_T(long)
+DEFN_REL_OP_T(unsigned int)
+DEFN_REL_OP_T(int)
+DEFN_REL_OP_T(uint64)
+DEFN_REL_OP_T(int64)
+
+#undef DEFN_REL_OP_T
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_bitref_r<X>
+//
+//  Proxy class for sc_proxy bit selection (r-value only).
+// ----------------------------------------------------------------------------
+
+// r-value concatenation operators and functions
+
+template <class T>
+inline
+sc_concref_r<sc_bitref_r<T>,sc_lv_base>
+operator , ( sc_bitref_r<T> a, const char* b )
+{
+    return sc_concref_r<sc_bitref_r<T>,sc_lv_base>(
+	*a.clone(), *new sc_lv_base( b ), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_bitref_r<T> >
+operator , ( const char* a, sc_bitref_r<T> b )
+{
+    return sc_concref_r<sc_lv_base,sc_bitref_r<T> >(
+	*new sc_lv_base( a ), *b.clone(), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_bitref_r<T>,sc_lv_base>
+operator , ( sc_bitref_r<T> a, const sc_logic& b )
+{
+    return sc_concref_r<sc_bitref_r<T>,sc_lv_base>(
+	*a.clone(), *new sc_lv_base( b, 1 ), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_bitref_r<T> >
+operator , ( const sc_logic& a, sc_bitref_r<T> b )
+{
+    return sc_concref_r<sc_lv_base,sc_bitref_r<T> >(
+	*new sc_lv_base( a, 1 ), *b.clone(), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_bitref_r<T>,sc_bv_base>
+operator , ( sc_bitref_r<T> a, bool b )
+{
+    return sc_concref_r<sc_bitref_r<T>,sc_bv_base>
+        ( *a.clone(), *new sc_bv_base( b, 1 ), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_bv_base,sc_bitref_r<T> >
+operator , ( bool a, sc_bitref_r<T> b )
+{
+    return sc_concref_r<sc_bv_base,sc_bitref_r<T> >
+        ( *new sc_bv_base( a, 1 ), *b.clone(), 3 );
+}
+
+
+template <class T>
+inline
+sc_concref_r<sc_bitref_r<T>,sc_lv_base>
+concat( sc_bitref_r<T> a, const char* b )
+{
+    return sc_concref_r<sc_bitref_r<T>,sc_lv_base>(
+	*a.clone(), *new sc_lv_base( b ), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_bitref_r<T> >
+concat( const char* a, sc_bitref_r<T> b )
+{
+    return sc_concref_r<sc_lv_base,sc_bitref_r<T> >(
+	*new sc_lv_base( a ), *b.clone(), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_bitref_r<T>,sc_lv_base>
+concat( sc_bitref_r<T> a, const sc_logic& b )
+{
+    return sc_concref_r<sc_bitref_r<T>,sc_lv_base>(
+	*a.clone(), *new sc_lv_base( b, 1 ), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_bitref_r<T> >
+concat( const sc_logic& a, sc_bitref_r<T> b )
+{
+    return sc_concref_r<sc_lv_base,sc_bitref_r<T> >(
+	*new sc_lv_base( a, 1 ), *b.clone(), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_bitref_r<T>,sc_bv_base>
+concat( sc_bitref_r<T> a, bool b )
+{
+    return sc_concref_r<sc_bitref_r<T>,sc_bv_base>
+        ( *a.clone(), *new sc_bv_base( b, 1 ), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_bv_base,sc_bitref_r<T> >
+concat( bool a, sc_bitref_r<T> b )
+{
+    return sc_concref_r<sc_bv_base,sc_bitref_r<T> >
+        ( *new sc_bv_base( a, 1 ), *b.clone(), 3 );
+}
+
+
+#ifdef SC_DT_MIXED_COMMA_OPERATORS
+
+template <class T>
+inline
+sc_concref_r<sc_bitref_r<T>,sc_lv_base>
+operator , ( sc_bitref<T> a, const char* b )
+{
+    return sc_concref_r<sc_bitref_r<T>,sc_lv_base>(
+	*a.clone(), *new sc_lv_base( b ), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_bitref_r<T> >
+operator , ( const char* a, sc_bitref<T> b )
+{
+    return sc_concref_r<sc_lv_base,sc_bitref_r<T> >(
+	*new sc_lv_base( a ), *b.clone(), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_bitref_r<T>,sc_lv_base>
+operator , ( sc_bitref<T> a, const sc_logic& b )
+{
+    return sc_concref_r<sc_bitref_r<T>,sc_lv_base>(
+	*a.clone(), *new sc_lv_base( b, 1 ), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_bitref_r<T> >
+operator , ( const sc_logic& a, sc_bitref<T> b )
+{
+    return sc_concref_r<sc_lv_base,sc_bitref_r<T> >(
+	*new sc_lv_base( a, 1 ), *b.clone(), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_bitref_r<T>,sc_bv_base>
+operator , ( sc_bitref<T> a, bool b )
+{
+    return sc_concref_r<sc_bitref_r<T>,sc_bv_base>
+        ( *a.clone(), *new sc_bv_base( b, 1 ), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_bv_base,sc_bitref_r<T> >
+operator , ( bool a, sc_bitref<T> b )
+{
+    return sc_concref_r<sc_bv_base,sc_bitref_r<T> >
+        ( *new sc_bv_base( a, 1 ), *b.clone(), 3 );
+}
+
+
+template <class T>
+inline
+sc_concref_r<sc_bitref_r<T>,sc_lv_base>
+concat( sc_bitref<T> a, const char* b )
+{
+    return sc_concref_r<sc_bitref_r<T>,sc_lv_base>(
+	*a.clone(), *new sc_lv_base( b ), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_bitref_r<T> >
+concat( const char* a, sc_bitref<T> b )
+{
+    return sc_concref_r<sc_lv_base,sc_bitref_r<T> >(
+	*new sc_lv_base( a ), *b.clone(), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_bitref_r<T>,sc_lv_base>
+concat( sc_bitref<T> a, const sc_logic& b )
+{
+    return sc_concref_r<sc_bitref_r<T>,sc_lv_base>(
+	*a.clone(), *new sc_lv_base( b, 1 ), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_bitref_r<T> >
+concat( const sc_logic& a, sc_bitref<T> b )
+{
+    return sc_concref_r<sc_lv_base,sc_bitref_r<T> >(
+	*new sc_lv_base( a, 1 ), *b.clone(), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_bitref_r<T>,sc_bv_base>
+concat( sc_bitref<T> a, bool b )
+{
+    return sc_concref_r<sc_bitref_r<T>,sc_bv_base>
+        ( *a.clone(), *new sc_bv_base( b, 1 ), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_bv_base,sc_bitref_r<T> >
+concat( bool a, sc_bitref<T> b )
+{
+    return sc_concref_r<sc_bv_base,sc_bitref_r<T> >
+        ( *new sc_bv_base( a, 1 ), *b.clone(), 3 );
+}
+
+#endif
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_subref_r<X>
+//
+//  Proxy class for sc_proxy part selection (r-value only).
+// ----------------------------------------------------------------------------
+
+// r-value concatenation operators and functions
+
+template <class T>
+inline
+sc_concref_r<sc_subref_r<T>,sc_lv_base>
+operator , ( sc_subref_r<T> a, const char* b )
+{
+    return sc_concref_r<sc_subref_r<T>,sc_lv_base>(
+	*a.clone(), *new sc_lv_base( b ), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_subref_r<T> >
+operator , ( const char* a, sc_subref_r<T> b )
+{
+    return sc_concref_r<sc_lv_base,sc_subref_r<T> >(
+	*new sc_lv_base( a ), *b.clone(), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_subref_r<T>,sc_lv_base>
+operator , ( sc_subref_r<T> a, const sc_logic& b )
+{
+    return sc_concref_r<sc_subref_r<T>,sc_lv_base>(
+	*a.clone(), *new sc_lv_base( b, 1 ), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_subref_r<T> >
+operator , ( const sc_logic& a, sc_subref_r<T> b )
+{
+    return sc_concref_r<sc_lv_base,sc_subref_r<T> >(
+	*new sc_lv_base( a, 1 ), *b.clone(), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_subref_r<T>,sc_bv_base>
+operator , ( sc_subref_r<T> a, bool b )
+{
+    return sc_concref_r<sc_subref_r<T>,sc_bv_base>
+        ( *a.clone(), *new sc_bv_base( b, 1 ), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_bv_base,sc_subref_r<T> >
+operator , ( bool a, sc_subref_r<T> b )
+{
+    return sc_concref_r<sc_bv_base,sc_subref_r<T> >
+        ( *new sc_bv_base( a, 1 ), *b.clone(), 3 );
+}
+
+
+template <class T>
+inline
+sc_concref_r<sc_subref_r<T>,sc_lv_base>
+concat( sc_subref_r<T> a, const char* b )
+{
+    return sc_concref_r<sc_subref_r<T>,sc_lv_base>(
+	*a.clone(), *new sc_lv_base( b ), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_subref_r<T> >
+concat( const char* a, sc_subref_r<T> b )
+{
+    return sc_concref_r<sc_lv_base,sc_subref_r<T> >(
+	*new sc_lv_base( a ), *b.clone(), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_subref_r<T>,sc_lv_base>
+concat( sc_subref_r<T> a, const sc_logic& b )
+{
+    return sc_concref_r<sc_subref_r<T>,sc_lv_base>(
+	*a.clone(), *new sc_lv_base( b, 1 ), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_subref_r<T> >
+concat( const sc_logic& a, sc_subref_r<T> b )
+{
+    return sc_concref_r<sc_lv_base,sc_subref_r<T> >(
+	*new sc_lv_base( a, 1 ), *b.clone(), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_subref_r<T>,sc_bv_base>
+concat( sc_subref_r<T> a, bool b )
+{
+    return sc_concref_r<sc_subref_r<T>,sc_bv_base>
+        ( *a.clone(), *new sc_bv_base( b, 1 ), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_bv_base,sc_subref_r<T> >
+concat( bool a, sc_subref_r<T> b )
+{
+    return sc_concref_r<sc_bv_base,sc_subref_r<T> >
+        ( *new sc_bv_base( a, 1 ), *b.clone(), 3 );
+}
+
+
+#ifdef SC_DT_MIXED_COMMA_OPERATORS
+
+template <class T>
+inline
+sc_concref_r<sc_subref_r<T>,sc_lv_base>
+operator , ( sc_subref<T> a, const char* b )
+{
+    return sc_concref_r<sc_subref_r<T>,sc_lv_base>(
+	*a.clone(), *new sc_lv_base( b ), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_subref_r<T> >
+operator , ( const char* a, sc_subref<T> b )
+{
+    return sc_concref_r<sc_lv_base,sc_subref_r<T> >(
+	*new sc_lv_base( a ), *b.clone(), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_subref_r<T>,sc_lv_base>
+operator , ( sc_subref<T> a, const sc_logic& b )
+{
+    return sc_concref_r<sc_subref_r<T>,sc_lv_base>(
+	*a.clone(), *new sc_lv_base( b, 1 ), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_subref_r<T> >
+operator , ( const sc_logic& a, sc_subref<T> b )
+{
+    return sc_concref_r<sc_lv_base,sc_subref_r<T> >(
+	*new sc_lv_base( a, 1 ), *b.clone(), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_subref_r<T>,sc_bv_base>
+operator , ( sc_subref<T> a, bool b )
+{
+    return sc_concref_r<sc_subref_r<T>,sc_bv_base>
+        ( *a.clone(), *new sc_bv_base( b, 1 ), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_bv_base,sc_subref_r<T> >
+operator , ( bool a, sc_subref<T> b )
+{
+    return sc_concref_r<sc_bv_base,sc_subref_r<T> >
+        ( *new sc_bv_base( a, 1 ), *b.clone(), 3 );
+}
+
+
+template <class T>
+inline
+sc_concref_r<sc_subref_r<T>,sc_lv_base>
+concat( sc_subref<T> a, const char* b )
+{
+    return sc_concref_r<sc_subref_r<T>,sc_lv_base>(
+	*a.clone(), *new sc_lv_base( b ), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_subref_r<T> >
+concat( const char* a, sc_subref<T> b )
+{
+    return sc_concref_r<sc_lv_base,sc_subref_r<T> >(
+	*new sc_lv_base( a ), *b.clone(), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_subref_r<T>,sc_lv_base>
+concat( sc_subref<T> a, const sc_logic& b )
+{
+    return sc_concref_r<sc_subref_r<T>,sc_lv_base>(
+	*a.clone(), *new sc_lv_base( b, 1 ), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,sc_subref_r<T> >
+concat( const sc_logic& a, sc_subref<T> b )
+{
+    return sc_concref_r<sc_lv_base,sc_subref_r<T> >(
+	*new sc_lv_base( a, 1 ), *b.clone(), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_subref_r<T>,sc_bv_base>
+concat( sc_subref<T> a, bool b )
+{
+    return sc_concref_r<sc_subref_r<T>,sc_bv_base>
+        ( *a.clone(), *new sc_bv_base( b, 1 ), 3 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_bv_base,sc_subref_r<T> >
+concat( bool a, sc_subref<T> b )
+{
+    return sc_concref_r<sc_bv_base,sc_subref_r<T> >
+        ( *new sc_bv_base( a, 1 ), *b.clone(), 3 );
+}
+
+#endif
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_subref<X>
+//
+//  Proxy class for sc_proxy part selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+template <class X>
+inline
+sc_subref<X>&
+sc_subref<X>::operator = ( const sc_subref_r<X>& b )
+{
+    sc_lv_base t( b ); // (partial) self assignment protection
+    int len = sc_min( this->length(), t.length() );
+    if( ! this->reversed() ) {
+        for( int i = len - 1; i >= 0; -- i ) {
+            this->m_obj.set_bit( this->m_lo + i, t[i].value() );
+        }
+    } else {
+        for( int i = len - 1; i >= 0; -- i ) {
+            this->m_obj.set_bit( this->m_lo - i, t[i].value() );
+        }
+    }
+    return *this;
+}
+
+template <class X>
+inline
+sc_subref<X>&
+sc_subref<X>::operator = ( const sc_subref<X>& b )
+{
+    sc_lv_base t( b ); // (partial) self assignment protection
+    int len = sc_min( this->length(), t.length() );
+    if( ! this->reversed() ) {
+        for( int i = len - 1; i >= 0; -- i ) {
+            this->m_obj.set_bit( this->m_lo + i, t[i].value() );
+        }
+    } else {
+        for( int i = len - 1; i >= 0; -- i ) {
+            this->m_obj.set_bit( this->m_lo - i, t[i].value() );
+        }
+    }
+    return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_concref_r<X,Y>
+//
+//  Proxy class for sc_proxy concatenation (r-value only).
+// ----------------------------------------------------------------------------
+
+// r-value concatenation operators and functions
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
+operator , ( sc_concref_r<T1,T2> a, const char* b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>(
+	*a.clone(), *new sc_lv_base( b ), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
+operator , ( const char* a, sc_concref_r<T1,T2> b )
+{
+    return sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >(
+	*new sc_lv_base( a ), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
+operator , ( sc_concref_r<T1,T2> a, const sc_logic& b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>(
+	*a.clone(), *new sc_lv_base( b, 1 ), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
+operator , ( const sc_logic& a, sc_concref_r<T1,T2> b )
+{
+    return sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >(
+	*new sc_lv_base( a, 1 ), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_bv_base>
+operator , ( sc_concref_r<T1,T2> a, bool b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_bv_base>
+        ( *a.clone(), *new sc_bv_base( b, 1 ), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bv_base,sc_concref_r<T1,T2> >
+operator , ( bool a, sc_concref_r<T1,T2> b )
+{
+    return sc_concref_r<sc_bv_base,sc_concref_r<T1,T2> >
+        ( *new sc_bv_base( a, 1 ), *b.clone(), 3 );
+}
+
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
+concat( sc_concref_r<T1,T2> a, const char* b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
+        ( *a.clone(), *new sc_lv_base( b ), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
+concat( const char* a, sc_concref_r<T1,T2> b )
+{
+    return sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
+        ( *new sc_lv_base( a ), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
+concat( sc_concref_r<T1,T2> a, const sc_logic& b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
+        ( *a.clone(), *new sc_lv_base( b, 1 ), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
+concat( const sc_logic& a, sc_concref_r<T1,T2> b )
+{
+    return sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
+        ( *new sc_lv_base( a, 1 ), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_bv_base>
+concat( sc_concref_r<T1,T2> a, bool b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_bv_base>
+        ( *a.clone(), *new sc_bv_base( b, 1 ), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bv_base,sc_concref_r<T1,T2> >
+concat( bool a, sc_concref_r<T1,T2> b )
+{
+    return sc_concref_r<sc_bv_base,sc_concref_r<T1,T2> >
+        ( *new sc_bv_base( a, 1 ), *b.clone(), 3 );
+}
+
+
+#ifdef SC_DT_MIXED_COMMA_OPERATORS
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
+operator , ( sc_concref<T1,T2> a, const char* b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
+        ( *a.clone(), *new sc_lv_base( b ), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
+operator , ( const char* a, sc_concref<T1,T2> b )
+{
+    return sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
+        ( *new sc_lv_base( a ), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
+operator , ( sc_concref<T1,T2> a, const sc_logic& b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
+        ( *a.clone(), *new sc_lv_base( b, 1 ), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
+operator , ( const sc_logic& a, sc_concref<T1,T2> b )
+{
+    return sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
+        ( *new sc_lv_base( a, 1 ), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_bv_base>
+operator , ( sc_concref<T1,T2> a, bool b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_bv_base>
+        ( *a.clone(), *new sc_bv_base( b, 1 ), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bv_base,sc_concref_r<T1,T2> >
+operator , ( bool a, sc_concref<T1,T2> b )
+{
+    return sc_concref_r<sc_bv_base,sc_concref_r<T1,T2> >
+        ( *new sc_bv_base( a, 1 ), *b.clone(), 3 );
+}
+
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
+concat( sc_concref<T1,T2> a, const char* b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
+        ( *a.clone(), *new sc_lv_base( b ), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
+concat( const char* a, sc_concref<T1,T2> b )
+{
+    return sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
+        ( *new sc_lv_base( a ), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
+concat( sc_concref<T1,T2> a, const sc_logic& b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
+        ( *a.clone(), *new sc_lv_base( b, 1 ), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
+concat( const sc_logic& a, sc_concref<T1,T2> b )
+{
+    return sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
+        ( *new sc_lv_base( a, 1 ), *b.clone(), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_concref_r<T1,T2>,sc_bv_base>
+concat( sc_concref<T1,T2> a, bool b )
+{
+    return sc_concref_r<sc_concref_r<T1,T2>,sc_bv_base>
+        ( *a.clone(), *new sc_bv_base( b, 1 ), 3 );
+}
+
+template <class T1, class T2>
+inline
+sc_concref_r<sc_bv_base,sc_concref_r<T1,T2> >
+concat( bool a, sc_concref<T1,T2> b )
+{
+    return sc_concref_r<sc_bv_base,sc_concref_r<T1,T2> >
+        ( *new sc_bv_base( a, 1 ), *b.clone(), 3 );
+}
+
+#endif
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_proxy<T>
+//
+//  Base class template for bit/logic vector classes.
+//  (Barton/Nackmann implementation)
+// ----------------------------------------------------------------------------
+
+// r-value concatenation operators and functions
+
+template <class T>
+inline
+sc_concref_r<T,sc_lv_base>
+operator , ( const sc_proxy<T>& a, const char* b )
+{
+    return sc_concref_r<T,sc_lv_base>
+      ( a.back_cast(), *new sc_lv_base( b ), 2 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,T>
+operator , ( const char* a, const sc_proxy<T>& b )
+{
+    return sc_concref_r<sc_lv_base,T>
+      ( *new sc_lv_base( a ), b.back_cast(), 1 );
+}
+
+template <class T>
+inline
+sc_concref_r<T,sc_lv_base>
+operator , ( const sc_proxy<T>& a, const sc_logic& b )
+{
+    return sc_concref_r<T,sc_lv_base>
+      ( a.back_cast(), *new sc_lv_base( b, 1 ), 2 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,T>
+operator , ( const sc_logic& a, const sc_proxy<T>& b )
+{
+    return sc_concref_r<sc_lv_base,T>
+      ( *new sc_lv_base( a, 1 ), b.back_cast(), 1 );
+}
+
+template <class T>
+inline
+sc_concref_r<T,sc_bv_base>
+operator , ( const sc_proxy<T>& a, bool b )
+{
+    return sc_concref_r<T,sc_bv_base>
+        ( a.back_cast(), *new sc_bv_base( b, 1 ), 2 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_bv_base,T>
+operator , ( bool a, const sc_proxy<T>& b )
+{
+    return sc_concref_r<sc_bv_base,T>
+      ( *new sc_bv_base( a, 1 ), b.back_cast(), 1 );
+}
+
+
+template <class T>
+inline
+sc_concref_r<T,sc_lv_base>
+concat( const sc_proxy<T>& a, const char* b )
+{
+    return sc_concref_r<T,sc_lv_base>
+      ( a.back_cast(), *new sc_lv_base( b ), 2 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,T>
+concat( const char* a, const sc_proxy<T>& b )
+{
+    return sc_concref_r<sc_lv_base,T>
+      ( *new sc_lv_base( a ), b.back_cast(), 1 );
+}
+
+template <class T>
+inline
+sc_concref_r<T,sc_lv_base>
+concat( const sc_proxy<T>& a, const sc_logic& b )
+{
+    return sc_concref_r<T,sc_lv_base>
+      ( a.back_cast(), *new sc_lv_base( b, 1 ), 2 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,T>
+concat( const sc_logic& a, const sc_proxy<T>& b )
+{
+    return sc_concref_r<sc_lv_base,T>
+      ( *new sc_lv_base( a, 1 ), b.back_cast(), 1 );
+}
+
+template <class T>
+inline
+sc_concref_r<T,sc_bv_base>
+concat( const sc_proxy<T>& a, bool b )
+{
+    return sc_concref_r<T,sc_bv_base>
+      ( a.back_cast(), *new sc_bv_base( b, 1 ), 2 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_bv_base,T>
+concat( bool a, const sc_proxy<T>& b )
+{
+    return sc_concref_r<sc_bv_base,T>
+      ( *new sc_bv_base( a, 1 ), b.back_cast(), 1 );
+}
+
+
+#ifdef SC_DT_MIXED_COMMA_OPERATORS
+
+template <class T>
+inline
+sc_concref_r<T,sc_lv_base>
+operator , ( sc_proxy<T>& a, const char* b )
+{
+    return sc_concref_r<T,sc_lv_base>
+      ( a.back_cast(), *new sc_lv_base( b ), 2 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,T>
+operator , ( const char* a, sc_proxy<T>& b )
+{
+    return sc_concref_r<sc_lv_base,T>
+        ( *new sc_lv_base( a ), b.back_cast(), 1 );
+}
+
+template <class T>
+inline
+sc_concref_r<T,sc_lv_base>
+operator , ( sc_proxy<T>& a, const sc_logic& b )
+{
+    return sc_concref_r<T,sc_lv_base>
+        ( a.back_cast(), *new sc_lv_base( b, 1 ), 2 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,T>
+operator , ( const sc_logic& a, sc_proxy<T>& b )
+{
+    return sc_concref_r<sc_lv_base,T>
+        ( *new sc_lv_base( a, 1 ), b.back_cast(), 1 );
+}
+
+template <class T>
+inline
+sc_concref_r<T,sc_bv_base>
+operator , ( sc_proxy<T>& a, bool b )
+{
+    return sc_concref_r<T,sc_bv_base>
+        ( a.back_cast(), *new sc_bv_base( b, 1 ), 2 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_bv_base,T>
+operator , ( bool a, sc_proxy<T>& b )
+{
+    return sc_concref_r<sc_bv_base,T>
+        ( *new sc_bv_base( a, 1 ), b.back_cast(), 1 );
+}
+
+
+template <class T>
+inline
+sc_concref_r<T,sc_lv_base>
+concat( sc_proxy<T>& a, const char* b )
+{
+    return sc_concref_r<T,sc_lv_base>
+        ( a.back_cast(), *new sc_lv_base( b ), 2 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,T>
+concat( const char* a, sc_proxy<T>& b )
+{
+    return sc_concref_r<sc_lv_base,T>
+        ( *new sc_lv_base( a ), b.back_cast(), 1 );
+}
+
+template <class T>
+inline
+sc_concref_r<T,sc_lv_base>
+concat( sc_proxy<T>& a, const sc_logic& b )
+{
+    return sc_concref_r<T,sc_lv_base>
+        ( a.back_cast(), *new sc_lv_base( b, 1 ), 2 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_lv_base,T>
+concat( const sc_logic& a, sc_proxy<T>& b )
+{
+    return sc_concref_r<sc_lv_base,T>
+        ( *new sc_lv_base( a, 1 ), b.back_cast(), 1 );
+}
+
+template <class T>
+inline
+sc_concref_r<T,sc_bv_base>
+concat( sc_proxy<T>& a, bool b )
+{
+    return sc_concref_r<T,sc_bv_base>
+        ( a.back_cast(), *new sc_bv_base( b, 1 ), 2 );
+}
+
+template <class T>
+inline
+sc_concref_r<sc_bv_base,T>
+concat( bool a, sc_proxy<T>& b )
+{
+    return sc_concref_r<sc_bv_base,T>
+        ( *new sc_bv_base( a, 1 ), b.back_cast(), 1 );
+}
+
+#endif
+
+} // namespace sc_dt
+
+
+#endif
diff --git a/ext/systemc/src/sysc/datatypes/bit/sc_proxy.h b/ext/systemc/src/sysc/datatypes/bit/sc_proxy.h
new file mode 100644
index 000000000..7c67b447d
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/bit/sc_proxy.h
@@ -0,0 +1,1609 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_proxy.h -- Proxy base class for vector data types.
+
+                This class is created for several purposes:
+                1) hiding operators from the global namespace that would be
+		   otherwise found by Koenig lookup
+                2) avoiding repeating the same operations in every class
+		   including proxies that could also be achieved by common
+		   base class, but this method allows
+                3) improve performance by using non-virtual functions
+
+  Original Author: Gene Bushuyev, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_proxy.h,v $
+// Revision 1.3  2010/12/07 20:09:07  acg
+// Andy Goodrich: Fix for returning enough data
+//
+// Revision 1.2  2009/02/28 00:26:14  acg
+//  Andy Goodrich: bug fixes.
+//
+// Revision 1.1.1.1  2006/12/15 20:31:36  acg
+// SystemC 2.2
+//
+// Revision 1.3  2006/01/13 18:53:53  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SC_PROXY_H
+#define SC_PROXY_H
+
+
+#include "sysc/kernel/sc_cmnhdr.h"
+#include "sysc/utils/sc_iostream.h"
+#include "sysc/datatypes/int/sc_signed.h"
+#include "sysc/datatypes/int/sc_unsigned.h"
+#include "sysc/datatypes/int/sc_int_base.h"
+#include "sysc/datatypes/int/sc_uint_base.h"
+#include "sysc/datatypes/bit/sc_bit.h"
+#include "sysc/datatypes/bit/sc_bit_ids.h"
+#include "sysc/datatypes/bit/sc_logic.h"
+#include "sysc/kernel/sc_macros.h"
+
+
+namespace sc_dt
+{
+
+// classes defined in this module
+template <class X> class sc_proxy;
+
+// forward class declarations
+class sc_bv_base;
+class sc_lv_base;
+template <class X> class sc_bitref_r;
+template <class X> class sc_bitref;
+template <class X> class sc_subref_r;
+template <class X> class sc_subref;
+template <class X, class Y> class sc_concref_r;
+template <class X, class Y> class sc_concref;
+
+
+const int SC_DIGIT_SIZE = BITS_PER_BYTE * sizeof( sc_digit );
+
+const sc_digit SC_DIGIT_ZERO = (sc_digit)0;
+const sc_digit SC_DIGIT_ONE  = (sc_digit)1;
+const sc_digit SC_DIGIT_TWO  = (sc_digit)2;
+
+
+// assignment functions; forward declarations
+
+template <class X, class Y>
+inline
+void
+assign_p_( sc_proxy<X>& px, const sc_proxy<Y>& py );
+
+// Vector types that are not derived from sc_proxy must have a length()
+// function and an operator []. 
+
+template <class X, class T>
+inline
+void
+assign_v_( sc_proxy<X>& px, const T& a );
+
+
+// other functions; forward declarations
+
+const std::string convert_to_bin( const char* s );
+const std::string convert_to_fmt( const std::string& s, sc_numrep numrep, bool );
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_proxy_traits
+//
+// Template traits helper to select the correct bit/value/vector_types for
+// sc_proxy-based vector classes.
+//
+// All types derived from/based on a bit-vector contain typedef to a plain bool,
+// all others point to the sc_logic_value_t/sc_logic/sc_lv_base types.
+// ----------------------------------------------------------------------------
+
+template<typename X> struct sc_proxy_traits;
+
+template<> struct sc_proxy_traits<sc_bv_base>
+{
+    typedef sc_proxy_traits<sc_bv_base> traits_type;
+    typedef bool                        value_type;
+    typedef bool                        bit_type;
+    typedef sc_bv_base                  vector_type;
+    typedef traits_type                 type;
+};
+
+template<> struct sc_proxy_traits<sc_lv_base>
+{
+    typedef sc_proxy_traits<sc_lv_base> traits_type;
+    typedef sc_logic_value_t            value_type;
+    typedef sc_logic                    bit_type;
+    typedef sc_lv_base                  vector_type;
+    typedef traits_type                 type;
+};
+
+
+template<typename X> struct sc_proxy_traits<sc_bitref_r<X> >
+  : sc_proxy_traits<X> {};
+
+template<typename X> struct sc_proxy_traits<sc_bitref<X> >
+  : sc_proxy_traits<X> {};
+
+
+template<typename X> struct sc_proxy_traits<sc_subref_r<X> >
+  : sc_proxy_traits<X> {};
+
+template<typename X> struct sc_proxy_traits<sc_subref<X> >
+  : sc_proxy_traits<X> {};
+
+
+template<typename X> struct sc_proxy_traits<sc_proxy<X> >
+  : sc_proxy_traits<X> {};
+
+
+template< typename X, typename Y > struct sc_mixed_proxy_traits_helper
+  : sc_proxy_traits<sc_lv_base> {}; // logic vector by default
+
+template<typename X> struct sc_mixed_proxy_traits_helper<X,X>
+  : X {};
+
+
+template<typename X, typename Y> struct sc_proxy_traits< sc_concref_r<X,Y> >
+  : sc_mixed_proxy_traits_helper< typename X::traits_type::type
+                                , typename Y::traits_type::type >
+{};
+
+template<typename X, typename Y> struct sc_proxy_traits<sc_concref<X,Y> >
+  : sc_mixed_proxy_traits_helper< typename X::traits_type::type
+                                , typename Y::traits_type::type >
+{};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_proxy
+//
+//  Base class template for bit/logic vector classes.
+//  (Barton/Nackmann implementation)
+// ----------------------------------------------------------------------------
+
+template <class X>
+class sc_proxy // #### : public sc_value_base
+{
+public:
+    typedef typename sc_proxy_traits<X>::type traits_type;
+    typedef typename traits_type::bit_type    bit_type;
+
+    // virtual destructor
+
+    virtual ~sc_proxy() {}
+
+
+    // casts
+
+    X& back_cast()
+	{ return SCAST<X&>( *this ); }
+
+    const X& back_cast() const
+	{ return SCAST<const X&>( *this ); }
+
+
+    // assignment operators
+
+    template <class Y>
+    X& assign_( const sc_proxy<Y>& a )
+	{ assign_p_( *this, a ); return back_cast(); }
+
+    X& assign_( const char* a );
+    X& assign_( const bool* a );
+    X& assign_( const sc_logic* a );
+
+    X& assign_( const sc_unsigned& a )
+	{ assign_v_( *this, a ); return back_cast(); }
+
+    X& assign_( const sc_signed& a )
+	{ assign_v_( *this, a ); return back_cast(); }
+
+    X& assign_( const sc_uint_base& a )
+	{ return assign_( (uint64) a ); }
+
+    X& assign_( const sc_int_base& a )
+	{ return assign_( (int64) a ); }
+
+    X& assign_( unsigned int a );
+    X& assign_( int a );
+
+    X& assign_( unsigned long a );
+
+    X& assign_( long a );
+
+    X& assign_( uint64 a );
+    X& assign_( int64 a );
+
+
+    // bitwise operators and functions
+
+    // bitwise complement
+
+    X& b_not();
+
+    const sc_lv_base operator ~ () const;
+
+
+    // bitwise and
+
+    X& operator &= ( const char* b );
+    X& operator &= ( const bool* b );
+    X& operator &= ( const sc_logic* b );
+    X& operator &= ( const sc_unsigned& b );
+    X& operator &= ( const sc_signed& b );
+
+    X& operator &= ( const sc_uint_base& b )
+	{ return operator &= ( (uint64) b ); }
+
+    X& operator &= ( const sc_int_base& b )
+	{ return operator &= ( (int64) b ); }
+
+    X& operator &= ( unsigned long b );
+    X& operator &= ( long b );
+
+    X& operator &= ( unsigned int b )
+	{ return operator &= ( (unsigned long) b ); }
+
+    X& operator &= ( int b )
+	{ return operator &= ( (long) b ); }
+
+    X& operator &= ( uint64 b );
+    X& operator &= ( int64 b );
+
+
+    const sc_lv_base operator & ( const char* b ) const;
+    const sc_lv_base operator & ( const bool* b ) const;
+    const sc_lv_base operator & ( const sc_logic* b ) const;
+    const sc_lv_base operator & ( const sc_unsigned& b ) const;
+    const sc_lv_base operator & ( const sc_signed& b ) const;
+    const sc_lv_base operator & ( const sc_uint_base& b ) const;
+    const sc_lv_base operator & ( const sc_int_base& b ) const;
+    const sc_lv_base operator & ( unsigned long b ) const;
+    const sc_lv_base operator & ( long b ) const;
+    const sc_lv_base operator & ( unsigned int b ) const;
+    const sc_lv_base operator & ( int b ) const;
+    const sc_lv_base operator & ( uint64 b ) const;
+    const sc_lv_base operator & ( int64 b ) const;
+
+
+    // bitwise or
+
+    X& operator |= ( const char* b );
+    X& operator |= ( const bool* b );
+    X& operator |= ( const sc_logic* b );
+    X& operator |= ( const sc_unsigned& b );
+    X& operator |= ( const sc_signed& b );
+
+    X& operator |= ( const sc_uint_base& b )
+	{ return operator |= ( (uint64) b ); }
+
+    X& operator |= ( const sc_int_base& b )
+	{ return operator |= ( (int64) b ); }
+
+    X& operator |= ( unsigned long b );
+    X& operator |= ( long b );
+
+    X& operator |= ( unsigned int b )
+	{ return operator |= ( (unsigned long) b ); }
+
+    X& operator |= ( int b )
+	{ return operator |= ( (long) b ); }
+
+    X& operator |= ( uint64 b );
+    X& operator |= ( int64 b );
+
+
+    const sc_lv_base operator | ( const char* b ) const;
+    const sc_lv_base operator | ( const bool* b ) const;
+    const sc_lv_base operator | ( const sc_logic* b ) const;
+    const sc_lv_base operator | ( const sc_unsigned& b ) const;
+    const sc_lv_base operator | ( const sc_signed& b ) const;
+    const sc_lv_base operator | ( const sc_uint_base& b ) const;
+    const sc_lv_base operator | ( const sc_int_base& b ) const;
+    const sc_lv_base operator | ( unsigned long b ) const;
+    const sc_lv_base operator | ( long b ) const;
+    const sc_lv_base operator | ( unsigned int b ) const;
+    const sc_lv_base operator | ( int b ) const;
+    const sc_lv_base operator | ( uint64 b ) const;
+    const sc_lv_base operator | ( int64 b ) const;
+
+
+    // bitwise xor
+
+    X& operator ^= ( const char* b );
+    X& operator ^= ( const bool* b );
+    X& operator ^= ( const sc_logic* b );
+    X& operator ^= ( const sc_unsigned& b );
+    X& operator ^= ( const sc_signed& b );
+
+    X& operator ^= ( const sc_uint_base& b )
+	{ return operator ^= ( (uint64) b ); }
+
+    X& operator ^= ( const sc_int_base& b )
+	{ return operator ^= ( (int64) b ); }
+
+    X& operator ^= ( unsigned long b );
+    X& operator ^= ( long b );
+
+    X& operator ^= ( unsigned int b )
+	{ return operator ^= ( (unsigned long) b ); }
+
+    X& operator ^= ( int b )
+	{ return operator ^= ( (long) b ); }
+
+    X& operator ^= ( uint64 b );
+    X& operator ^= ( int64 b );
+
+
+    const sc_lv_base operator ^ ( const char* b ) const;
+    const sc_lv_base operator ^ ( const bool* b ) const;
+    const sc_lv_base operator ^ ( const sc_logic* b ) const;
+    const sc_lv_base operator ^ ( const sc_unsigned& b ) const;
+    const sc_lv_base operator ^ ( const sc_signed& b ) const;
+    const sc_lv_base operator ^ ( const sc_uint_base& b ) const;
+    const sc_lv_base operator ^ ( const sc_int_base& b ) const;
+    const sc_lv_base operator ^ ( unsigned long b ) const;
+    const sc_lv_base operator ^ ( long b ) const;
+    const sc_lv_base operator ^ ( unsigned int b ) const;
+    const sc_lv_base operator ^ ( int b ) const;
+    const sc_lv_base operator ^ ( uint64 b ) const;
+    const sc_lv_base operator ^ ( int64 b ) const;
+
+
+    // bitwise left shift
+
+    X& operator <<= ( int n );
+
+    const sc_lv_base operator << ( int n ) const;
+
+
+    // bitwise right shift
+
+    X& operator >>= ( int n );
+
+    const sc_lv_base operator >> ( int n ) const;
+
+
+    // bitwise left rotate
+
+    X& lrotate( int n );
+
+
+    // bitwise right rotate
+
+    X& rrotate( int n );
+
+
+    // bitwise reverse
+
+    X& reverse();
+
+
+    // bit selection
+
+    sc_bitref<X> operator [] ( int i )
+	{ return sc_bitref<X>( back_cast(), i ); }
+
+    sc_bitref_r<X> operator [] ( int i ) const
+	{ return sc_bitref_r<X>( back_cast(), i ); }
+
+    sc_bitref<X> bit( int i )
+	{ return sc_bitref<X>( back_cast(), i ); }
+
+    sc_bitref_r<X> bit( int i ) const
+	{ return sc_bitref_r<X>( back_cast(), i ); }
+
+
+    // part selection
+
+    sc_subref<X> operator () ( int hi, int lo )
+	{ return sc_subref<X>( back_cast(), hi, lo ); }
+
+    sc_subref_r<X> operator () ( int hi, int lo ) const
+	{ return sc_subref_r<X>( back_cast(), hi, lo ); }
+
+    sc_subref<X> range( int hi, int lo )
+	{ return sc_subref<X>( back_cast(), hi, lo ); }
+
+    sc_subref_r<X> range( int hi, int lo ) const
+	{ return sc_subref_r<X>( back_cast(), hi, lo ); }
+
+
+    // reduce functions
+
+    sc_logic_value_t and_reduce() const;
+
+    sc_logic_value_t nand_reduce() const
+	{ return sc_logic::not_table[and_reduce()]; }
+
+    sc_logic_value_t or_reduce() const;
+
+    sc_logic_value_t nor_reduce() const
+	{ return sc_logic::not_table[or_reduce()]; }
+
+    sc_logic_value_t xor_reduce() const;
+
+    sc_logic_value_t xnor_reduce() const
+	{ return sc_logic::not_table[xor_reduce()]; }
+
+
+    // relational operators
+
+    bool operator == ( const char* b ) const;
+    bool operator == ( const bool* b ) const;
+    bool operator == ( const sc_logic* b ) const;
+    bool operator == ( const sc_unsigned& b ) const;
+    bool operator == ( const sc_signed& b ) const;
+    bool operator == ( const sc_uint_base& b ) const;
+    bool operator == ( const sc_int_base& b ) const;
+    bool operator == ( unsigned long b ) const;
+    bool operator == ( long b ) const;
+    bool operator == ( unsigned int b ) const;
+    bool operator == ( int b ) const;
+    bool operator == ( uint64 b ) const;
+    bool operator == ( int64 b ) const;
+
+
+    // explicit conversions to character string
+
+    const std::string to_string() const;
+    const std::string to_string( sc_numrep ) const;
+    const std::string to_string( sc_numrep, bool ) const;
+
+
+    // explicit conversions
+
+    inline int64 to_int64() const
+	{ return to_anything_signed(); }
+    inline uint64 to_uint64() const;
+    int to_int() const
+	{ return (int)to_anything_signed(); }
+
+    unsigned int to_uint() const
+	{ return (unsigned int)to_anything_unsigned(); }
+
+    long to_long() const
+	{ return (long)to_anything_signed(); }
+
+    unsigned long to_ulong() const
+	{ return (unsigned long)to_anything_unsigned(); }
+
+#ifdef SC_DT_DEPRECATED
+
+    int to_signed() const
+	{ return to_int(); }
+
+    sc_digit to_unsigned() const
+	{ return to_uint(); }
+
+#endif
+
+
+    // other methods
+
+    void print( ::std::ostream& os = ::std::cout ) const
+	{ 
+	    // the test below will force printing in binary if decimal is 
+	    // specified.
+	    if ( sc_io_base(os, SC_DEC) == SC_DEC )
+	        os << to_string();
+	    else
+	        os << to_string(sc_io_base(os,SC_BIN),sc_io_show_base(os)); 
+	}
+
+    void scan( ::std::istream& is = ::std::cin );
+
+protected:
+
+    void check_bounds( int n ) const;  // check if bit n accessible
+    void check_wbounds( int n ) const; // check if word n accessible
+
+    sc_digit to_anything_unsigned() const;
+    int64 to_anything_signed() const;
+};
+
+
+// ----------------------------------------------------------------------------
+
+// bitwise operators and functions
+
+// bitwise and
+
+template <class X, class Y>
+inline
+X&
+operator &= ( sc_proxy<X>& px, const sc_proxy<Y>& py );
+
+
+template <class X, class Y>
+inline
+const sc_lv_base
+operator & ( const sc_proxy<X>& px, const sc_proxy<Y>& py );
+
+
+#define DECL_BITWISE_AND_OP_T(tp)                                             \
+template <class X>                                                            \
+inline                                                                        \
+const sc_lv_base                                                              \
+operator & ( tp b, const sc_proxy<X>& px );
+
+DECL_BITWISE_AND_OP_T(const char*)
+DECL_BITWISE_AND_OP_T(const bool*)
+DECL_BITWISE_AND_OP_T(const sc_logic*)
+DECL_BITWISE_AND_OP_T(const sc_unsigned&)
+DECL_BITWISE_AND_OP_T(const sc_signed&)
+DECL_BITWISE_AND_OP_T(const sc_uint_base&)
+DECL_BITWISE_AND_OP_T(const sc_int_base&)
+DECL_BITWISE_AND_OP_T(unsigned long)
+DECL_BITWISE_AND_OP_T(long)
+DECL_BITWISE_AND_OP_T(unsigned int)
+DECL_BITWISE_AND_OP_T(int)
+DECL_BITWISE_AND_OP_T(uint64)
+DECL_BITWISE_AND_OP_T(int64)
+
+#undef DECL_BITWISE_AND_OP_T
+
+
+// bitwise or
+
+template <class X, class Y>
+inline
+X&
+operator |= ( sc_proxy<X>& px, const sc_proxy<Y>& py );
+
+
+template <class X, class Y>
+inline
+const sc_lv_base
+operator | ( const sc_proxy<X>& px, const sc_proxy<Y>& py );
+
+
+#define DECL_BITWISE_OR_OP_T(tp)                                              \
+template <class X>                                                            \
+inline                                                                        \
+const sc_lv_base                                                              \
+operator | ( tp a, const sc_proxy<X>& px );
+
+DECL_BITWISE_OR_OP_T(const char*)
+DECL_BITWISE_OR_OP_T(const bool*)
+DECL_BITWISE_OR_OP_T(const sc_logic*)
+DECL_BITWISE_OR_OP_T(const sc_unsigned&)
+DECL_BITWISE_OR_OP_T(const sc_signed&)
+DECL_BITWISE_OR_OP_T(const sc_uint_base&)
+DECL_BITWISE_OR_OP_T(const sc_int_base&)
+DECL_BITWISE_OR_OP_T(unsigned long)
+DECL_BITWISE_OR_OP_T(long)
+DECL_BITWISE_OR_OP_T(unsigned int)
+DECL_BITWISE_OR_OP_T(int)
+DECL_BITWISE_OR_OP_T(uint64)
+DECL_BITWISE_OR_OP_T(int64)
+
+#undef DECL_BITWISE_OR_OP_T
+
+
+// bitwise xor
+
+template <class X, class Y>
+inline
+X&
+operator ^= ( sc_proxy<X>& px, const sc_proxy<Y>& py );
+
+
+template <class X, class Y>
+inline
+const sc_lv_base
+operator ^ ( const sc_proxy<X>& px, const sc_proxy<Y>& py );
+
+
+#define DECL_BITWISE_XOR_OP_T(tp)                                             \
+template <class X>                                                            \
+inline                                                                        \
+const sc_lv_base                                                              \
+operator ^ ( tp a, const sc_proxy<X>& px );
+
+DECL_BITWISE_XOR_OP_T(const char*)
+DECL_BITWISE_XOR_OP_T(const bool*)
+DECL_BITWISE_XOR_OP_T(const sc_logic*)
+DECL_BITWISE_XOR_OP_T(const sc_unsigned&)
+DECL_BITWISE_XOR_OP_T(const sc_signed&)
+DECL_BITWISE_XOR_OP_T(const sc_uint_base&)
+DECL_BITWISE_XOR_OP_T(const sc_int_base&)
+DECL_BITWISE_XOR_OP_T(unsigned long)
+DECL_BITWISE_XOR_OP_T(long)
+DECL_BITWISE_XOR_OP_T(unsigned int)
+DECL_BITWISE_XOR_OP_T(int)
+DECL_BITWISE_XOR_OP_T(uint64)
+DECL_BITWISE_XOR_OP_T(int64)
+
+#undef DECL_BITWISE_XOR_OP_T
+
+
+// relational operators
+
+template <class X, class Y>
+inline
+bool
+operator == ( const sc_proxy<X>& px, const sc_proxy<Y>& py );
+
+template <class X, class Y>
+inline
+bool
+operator != ( const sc_proxy<X>& px, const sc_proxy<Y>& py );
+
+
+#define DECL_REL_OP_T(tp)                                                     \
+template <class X>                                                            \
+inline                                                                        \
+bool                                                                          \
+operator == ( tp b, const sc_proxy<X>& px );                                  \
+                                                                              \
+template <class X>                                                            \
+inline                                                                        \
+bool                                                                          \
+operator != ( const sc_proxy<X>& px, tp b );                                  \
+                                                                              \
+template <class X>                                                            \
+inline                                                                        \
+bool                                                                          \
+operator != ( tp b, const sc_proxy<X>& px );
+
+DECL_REL_OP_T(const char*)
+DECL_REL_OP_T(const bool*)
+DECL_REL_OP_T(const sc_logic*)
+DECL_REL_OP_T(const sc_unsigned&)
+DECL_REL_OP_T(const sc_signed&)
+DECL_REL_OP_T(const sc_uint_base&)
+DECL_REL_OP_T(const sc_int_base&)
+DECL_REL_OP_T(unsigned long)
+DECL_REL_OP_T(long)
+DECL_REL_OP_T(unsigned int)
+DECL_REL_OP_T(int)
+DECL_REL_OP_T(uint64)
+DECL_REL_OP_T(int64)
+
+#undef DECL_REL_OP_T
+
+
+// l-value concatenation
+
+// Due to the fact that temporary objects cannot be passed to non-const
+// references, we have to enumerate, use call by value, and use dynamic
+// memory allocation (and deallocation).
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+template <class X>
+inline
+void
+get_words_( const X& x, int wi, sc_digit& x_dw, sc_digit& x_cw )
+{
+    x_dw = x.get_word( wi );
+    x_cw = x.get_cword( wi );
+}
+
+template <class X>
+inline
+void
+set_words_( X& x, int wi, sc_digit x_dw, sc_digit x_cw )
+{
+    x.set_word( wi, x_dw );
+    x.set_cword( wi, x_cw );
+}
+
+template <class X>
+inline
+void
+extend_sign_w_( X& x, int wi, bool sign )
+{
+    int sz = x.size();
+    unsigned int sgn = (sign ? ~SC_DIGIT_ZERO : SC_DIGIT_ZERO);
+    for( int i = wi; i < sz; ++ i ) {
+	set_words_( x, i, sgn, SC_DIGIT_ZERO );
+    }
+}
+
+
+// assignment functions
+
+template <class X, class Y>
+inline
+void
+assign_p_( sc_proxy<X>& px, const sc_proxy<Y>& py )
+{
+    if( (void*) &px != (void*) &py ) {
+	X& x = px.back_cast();
+	const Y& y = py.back_cast();
+	int sz = x.size();
+	int min_sz = sc_min( sz, y.size() );
+	int i = 0;
+	for( ; i < min_sz; ++ i ) {
+	    set_words_( x, i, y.get_word( i ), y.get_cword( i ) );
+	}
+	// extend with zeros
+	extend_sign_w_( x, i, false );
+	x.clean_tail();
+    }
+}
+
+// Vector types that are not derived from sc_proxy, sc_int_base,
+// sc_uint_base, sc_signed, or sc_unsigned, must have a length()
+// function and an operator []. The vector argument type must support
+// accessing bits that are beyond the msb. The vector argument type
+// decides what to do there (e.g. sign extension or zero padding).
+
+template <class X, class T>
+inline
+void
+assign_v_( sc_proxy<X>& px, const T& a )
+{
+    X& x = px.back_cast();
+    int i;
+    int len_x = x.length();
+    int len_a = a.length();
+    if ( len_a > len_x ) len_a = len_x;
+    for( i = 0 ; i < len_a; ++ i ) {
+        x.set_bit( i, sc_logic_value_t( (bool) a[i] ) );
+    }
+    for( ; i < len_x; ++ i ) {
+        x.set_bit( i, sc_logic_value_t( false ) );
+    }
+}
+
+template <class X>
+inline
+void
+assign_v_( sc_proxy<X>& px, const sc_int_base& a )
+{
+    X& x = px.back_cast();
+	int i;
+    bool sign = a < 0;
+    int len_x = x.length();
+    int len_a = a.length();
+    if ( len_a > len_x ) len_a = len_x;
+    for( i = 0 ; i < len_a; ++ i ) {
+        x.set_bit( i, sc_logic_value_t( (bool) a[i] ) );
+    }
+    for( ; i < len_x; ++ i ) {
+        x.set_bit( i, sc_logic_value_t( sign ) );
+    }
+}
+
+template <class X>
+inline
+void
+assign_v_( sc_proxy<X>& px, const sc_signed& a )
+{
+    X& x = px.back_cast();
+	int i;
+    bool sign = a < 0;
+    int len_x = x.length();
+    int len_a = a.length();
+    if ( len_a > len_x ) len_a = len_x;
+    for( i = 0 ; i < len_a; ++ i ) {
+        x.set_bit( i, sc_logic_value_t( (bool) a[i] ) );
+    }
+    for( ; i < len_x; ++ i ) {
+        x.set_bit( i, sc_logic_value_t( sign ) );
+    }
+}
+
+template <class X>
+inline
+void
+assign_v_( sc_proxy<X>& px, const sc_uint_base& a )
+{
+    X& x = px.back_cast();
+	int i;
+    int len_x = x.length();
+    int len_a = a.length();
+    if ( len_a > len_x ) len_a = len_x;
+    for( i = 0 ; i < len_a; ++ i ) {
+        x.set_bit( i, sc_logic_value_t( (bool) a[i] ) );
+    }
+    for( ; i < len_x; ++ i ) {
+        x.set_bit( i, sc_logic_value_t( false ) );
+    }
+}
+
+template <class X>
+inline
+void
+assign_v_( sc_proxy<X>& px, const sc_unsigned& a )
+{
+    X& x = px.back_cast();
+	int i;
+    int len_x = x.length();
+    int len_a = a.length();
+    if ( len_a > len_x ) len_a = len_x;
+    for( i = 0 ; i < len_a; ++ i ) {
+        x.set_bit( i, sc_logic_value_t( (bool) a[i] ) );
+    }
+    for( ; i < len_x; ++ i ) {
+        x.set_bit( i, sc_logic_value_t( false ) );
+    }
+}
+
+
+// assignment operators
+
+template <class X>
+inline
+X&
+sc_proxy<X>::assign_( const char* a )
+{
+    X& x = back_cast();
+    std::string s = convert_to_bin( a );
+    int len = x.length();
+    int s_len = s.length() - 1;
+    int min_len = sc_min( len, s_len );
+    int i = 0;
+    for( ; i < min_len; ++ i ) {
+	char c = s[s_len - i - 1];
+	x.set_bit( i, sc_logic::char_to_logic[(int)c] );
+    }
+    // if formatted, fill the rest with sign(s), otherwise fill with zeros
+    sc_logic_value_t fill = (s[s_len] == 'F' ? sc_logic_value_t( s[0] - '0' )
+		                             : sc_logic_value_t( 0 ));
+    for( ; i < len; ++ i ) {
+	x.set_bit( i, fill );
+    }
+    return x;
+}
+
+template <class X>
+inline
+X&
+sc_proxy<X>::assign_( const bool* a )
+{
+    // the length of 'a' must be larger than or equal to the length of 'this'
+    X& x = back_cast();
+    int len = x.length();
+    for( int i = 0; i < len; ++ i ) {
+	x.set_bit( i, sc_logic_value_t( a[i] ) );
+    }
+    return x;
+}
+
+template <class X>
+inline
+X&
+sc_proxy<X>::assign_( const sc_logic* a )
+{
+    // the length of 'a' must be larger than or equal to the length of 'this'
+    X& x = back_cast();
+    int len = x.length();
+    for( int i = 0; i < len; ++ i ) {
+	x.set_bit( i, a[i].value() );
+    }
+    return x;
+}
+
+template <class X>
+inline
+X&
+sc_proxy<X>::assign_( unsigned int a )
+{
+    X& x = back_cast();
+    set_words_( x, 0, (sc_digit)a, SC_DIGIT_ZERO );
+    // extend with zeros
+    extend_sign_w_( x, 1, false );
+    x.clean_tail();
+    return x;
+}
+
+template <class X>
+inline
+X&
+sc_proxy<X>::assign_( int a )
+{
+    X& x = back_cast();
+    set_words_( x, 0, (sc_digit) a, SC_DIGIT_ZERO );
+    // extend with sign(a)
+    extend_sign_w_( x, 1, (a < 0) );
+    x.clean_tail();
+    return x;
+}
+
+#if defined(SC_LONG_64)
+	template <class X>
+	inline
+	X&
+	sc_proxy<X>::assign_( unsigned long a )
+	{
+		X& x = back_cast();
+		set_words_( x, 0, ((sc_digit) a & ~SC_DIGIT_ZERO), SC_DIGIT_ZERO );
+		if( x.size() > 1 ) {
+			set_words_( x, 1,
+				((sc_digit) (a >> SC_DIGIT_SIZE) & ~SC_DIGIT_ZERO),
+					SC_DIGIT_ZERO );
+		// extend with zeros
+		extend_sign_w_( x, 2, false );
+		}
+		x.clean_tail();
+		return x;
+	}
+
+	template <class X>
+	inline
+	X&
+	sc_proxy<X>::assign_( long a )
+	{
+		X& x = back_cast();
+		set_words_( x, 0, ((sc_digit) a & ~SC_DIGIT_ZERO), SC_DIGIT_ZERO );
+		if( x.size() > 1 ) {
+			set_words_( x, 1,
+				((sc_digit) ((uint64) a >> SC_DIGIT_SIZE) & ~SC_DIGIT_ZERO),
+				SC_DIGIT_ZERO );
+		// extend with sign(a)
+		extend_sign_w_( x, 2, (a < 0) );
+		}
+		x.clean_tail();
+		return x;
+	}
+
+#else
+    template <class X>
+    inline
+    X&
+    sc_proxy<X>::assign_( unsigned long a )
+    {
+        X& x = back_cast();
+        set_words_( x, 0, (sc_digit)a, SC_DIGIT_ZERO );
+        // extend with zeros
+        extend_sign_w_( x, 1, false );
+        x.clean_tail();
+        return x;
+    }
+
+    template <class X>
+    inline
+    X&
+    sc_proxy<X>::assign_( long a )
+    {
+        X& x = back_cast();
+        set_words_( x, 0, (sc_digit) a, SC_DIGIT_ZERO );
+        // extend with sign(a)
+        extend_sign_w_( x, 1, (a < 0) );
+        x.clean_tail();
+        return x;
+    }
+#endif
+template <class X>
+inline
+X&
+sc_proxy<X>::assign_( uint64 a )
+{
+    X& x = back_cast();
+    set_words_( x, 0, ((sc_digit) a & ~SC_DIGIT_ZERO), SC_DIGIT_ZERO );
+    if( x.size() > 1 ) {
+	set_words_( x, 1,
+		    ((sc_digit) (a >> SC_DIGIT_SIZE) & ~SC_DIGIT_ZERO),
+		    SC_DIGIT_ZERO );
+	// extend with zeros
+	extend_sign_w_( x, 2, false );
+    }
+    x.clean_tail();
+    return x;
+}
+
+template <class X>
+inline
+X&
+sc_proxy<X>::assign_( int64 a )
+{
+    X& x = back_cast();
+    set_words_( x, 0, ((sc_digit) a & ~SC_DIGIT_ZERO), SC_DIGIT_ZERO );
+    if( x.size() > 1 ) {
+	set_words_( x, 1,
+		    ((sc_digit) ((uint64) a >> SC_DIGIT_SIZE) & ~SC_DIGIT_ZERO),
+		    SC_DIGIT_ZERO );
+	// extend with sign(a)
+	extend_sign_w_( x, 2, (a < 0) );
+    }
+    x.clean_tail();
+    return x;
+}
+
+
+// bitwise operators and functions
+
+// bitwise complement
+
+template <class X>
+inline
+X&
+sc_proxy<X>::b_not()
+{
+    X& x = back_cast();
+    int sz = x.size();
+    for( int i = 0; i < sz; ++ i ) {
+	sc_digit x_dw, x_cw;
+	get_words_( x, i, x_dw, x_cw );
+	x.set_word( i, x_cw | ~x_dw );
+    }
+    x.clean_tail();
+    return x;
+}
+
+
+// bitwise and
+
+template <class X, class Y>
+inline
+X&
+b_and_assign_( sc_proxy<X>& px, const sc_proxy<Y>& py )
+{
+    X& x = px.back_cast();
+    const Y& y = py.back_cast();
+    assert( x.length() == y.length() );
+    int sz = x.size();
+    for( int i = 0; i < sz; ++ i ) {
+	sc_digit x_dw, x_cw, y_dw, y_cw;
+	get_words_( x, i, x_dw, x_cw );
+	get_words_( y, i, y_dw, y_cw );
+	sc_digit cw = (x_dw & y_cw) | (x_cw & y_dw) | (x_cw & y_cw);
+	sc_digit dw = cw | (x_dw & y_dw);
+	set_words_( x, i, dw, cw );
+    }
+    // tail cleaning not needed
+    return x;
+}
+
+
+// bitwise or
+
+template <class X, class Y>
+inline
+X&
+b_or_assign_( sc_proxy<X>& px, const sc_proxy<Y>& py )
+{
+    X& x = px.back_cast();
+    const Y& y = py.back_cast();
+    assert( x.length() == y.length() );
+    int sz = x.size();
+    for( int i = 0; i < sz; ++ i ) {
+	sc_digit x_dw, x_cw, y_dw, y_cw;
+	get_words_( x, i, x_dw, x_cw );
+	get_words_( y, i, y_dw, y_cw );
+	sc_digit cw = (x_cw & y_cw) | (x_cw & ~y_dw) | (~x_dw & y_cw);
+	sc_digit dw = cw | x_dw | y_dw;
+	set_words_( x, i, dw, cw );
+    }
+    // tail cleaning not needed
+    return x;
+}
+
+
+// bitwise xor
+
+template <class X, class Y>
+inline
+X&
+b_xor_assign_( sc_proxy<X>& a, const sc_proxy<Y>& b )
+{
+    X& x = a.back_cast();
+    const Y& y = b.back_cast();
+    assert( x.length() == y.length() );
+    int sz = x.size();
+    for( int i = 0; i < sz; ++ i ) {
+	sc_digit x_dw, x_cw, y_dw, y_cw;
+	get_words_( x, i, x_dw, x_cw );
+	get_words_( y, i, y_dw, y_cw );
+	sc_digit cw = x_cw | y_cw;
+	sc_digit dw = cw | (x_dw ^ y_dw);
+	set_words_( x, i, dw, cw );
+    }
+    // tail cleaning not needed
+    return x;
+}
+
+
+// bitwise left shift
+
+template <class X>
+inline
+X&
+sc_proxy<X>::operator <<= ( int n )
+{
+    X& x = back_cast();
+    if( n < 0 ) {
+	char msg[BUFSIZ];
+	std::sprintf( msg,
+		 "left shift operation is only allowed with positive "
+		 "shift values, shift value = %d", n );
+	SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
+    }
+    if( n >= x.length() ) {
+	extend_sign_w_( x, 0, false );
+	// no tail cleaning needed
+	return x;
+    }
+    int sz = x.size();
+    int wn = n / SC_DIGIT_SIZE;
+    int bn = n % SC_DIGIT_SIZE;
+    if( wn != 0 ) {
+	// shift words
+	int i = sz - 1;
+	for( ; i >= wn; -- i ) {
+	    set_words_( x, i, x.get_word( i - wn ), x.get_cword( i - wn ) );
+	}
+	for( ; i >= 0; -- i ) {
+	    set_words_( x, i, SC_DIGIT_ZERO, SC_DIGIT_ZERO );
+	}
+    }
+    if( bn != 0 ) {
+	// shift bits
+	for( int i = sz - 1; i >= 1; -- i ) {
+	    sc_digit x_dw, x_cw;
+	    get_words_( x, i, x_dw, x_cw );
+	    x_dw <<= bn;
+	    x_dw |= x.get_word( i - 1 ) >> (SC_DIGIT_SIZE - bn);
+	    x_cw <<= bn;
+	    x_cw |= x.get_cword( i - 1 ) >> (SC_DIGIT_SIZE - bn);
+	    set_words_( x, i, x_dw, x_cw );
+	}
+	sc_digit x_dw, x_cw;
+	get_words_( x, 0, x_dw, x_cw );
+	x_dw <<= bn;
+	x_cw <<= bn;
+	set_words_( x, 0, x_dw, x_cw );
+    }
+    x.clean_tail();
+    return x;
+}
+
+
+// bitwise right shift
+
+
+template <class X>
+inline
+X&
+sc_proxy<X>::operator >>= ( int n )
+{
+    X& x = back_cast();
+    if( n < 0 ) {
+	char msg[BUFSIZ];
+	std::sprintf( msg,
+		 "right shift operation is only allowed with positive "
+		 "shift values, shift value = %d", n );
+	SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
+    }
+    if( n >= x.length() ) {
+	extend_sign_w_( x, 0, false );
+	// no tail cleaning needed
+	return x;
+    }
+    int sz = x.size();
+    int wn = n / SC_DIGIT_SIZE;
+    int bn = n % SC_DIGIT_SIZE;
+    if( wn != 0 ) {
+	// shift words
+	int i = 0;
+	for( ; i < (sz - wn); ++ i ) {
+	    set_words_( x, i, x.get_word( i + wn ), x.get_cword( i + wn ) );
+	}
+	for( ; i < sz; ++ i ) {
+	    set_words_( x, i, SC_DIGIT_ZERO, SC_DIGIT_ZERO );
+	}
+    }
+    if( bn != 0 ) {
+	// shift bits
+	for( int i = 0; i < (sz - 1); ++ i ) {
+	    sc_digit x_dw, x_cw;
+	    get_words_( x, i, x_dw, x_cw );
+	    x_dw >>= bn;
+	    x_dw |= x.get_word( i + 1 ) << (SC_DIGIT_SIZE - bn);
+	    x_cw >>= bn;
+	    x_cw |= x.get_cword( i + 1 ) << (SC_DIGIT_SIZE - bn);
+	    set_words_( x, i, x_dw, x_cw );
+	}
+	sc_digit x_dw, x_cw;
+	get_words_( x, sz - 1, x_dw, x_cw );
+	x_dw >>= bn;
+	x_cw >>= bn;
+	set_words_( x, sz - 1, x_dw, x_cw );
+    }
+    x.clean_tail();
+    return x;
+}
+
+
+// bitwise left rotate
+
+template <class X>
+inline
+const sc_lv_base
+lrotate( const sc_proxy<X>& x, int n );
+
+
+// bitwise right rotate
+
+template <class X>
+inline
+const sc_lv_base
+rrotate( const sc_proxy<X>& x, int n );
+
+
+// bitwise reverse
+
+template <class X>
+inline
+X&
+sc_proxy<X>::reverse()
+{
+    X& x = back_cast();
+    int len = x.length();
+    int half_len = len / 2;
+    for( int i = 0, j = len - 1; i < half_len; ++ i, --j ) {
+	sc_logic_value_t t = x.get_bit( i );
+	x.set_bit( i, x.get_bit( j ) );
+	x.set_bit( j, t );
+    }
+    return x;
+}
+
+template <class X>
+inline
+const sc_lv_base
+reverse( const sc_proxy<X>& a );
+
+
+// reduce functions
+
+template <class X>
+inline
+sc_logic_value_t
+sc_proxy<X>::and_reduce() const
+{
+    const X& x = back_cast();
+    sc_logic_value_t result = sc_logic_value_t( 1 );
+    int len = x.length();
+    for( int i = 0; i < len; ++ i ) {
+	result = sc_logic::and_table[result][x.get_bit( i )];
+    }
+    return result;
+}
+
+template <class X>
+inline
+sc_logic_value_t
+sc_proxy<X>::or_reduce() const
+{
+    const X& x = back_cast();
+    sc_logic_value_t result = sc_logic_value_t( 0 );
+    int len = x.length();
+    for( int i = 0; i < len; ++ i ) {
+	result = sc_logic::or_table[result][x.get_bit( i )];
+    }
+    return result;
+}
+
+template <class X>
+inline
+sc_logic_value_t
+sc_proxy<X>::xor_reduce() const
+{
+    const X& x = back_cast();
+    sc_logic_value_t result = sc_logic_value_t( 0 );
+    int len = x.length();
+    for( int i = 0; i < len; ++ i ) {
+	result = sc_logic::xor_table[result][x.get_bit( i )];
+    }
+    return result;
+}
+
+
+// relational operators
+
+template <class X, class Y>
+inline
+bool
+operator != ( const sc_proxy<X>& px, const sc_proxy<Y>& py )
+{
+    return !( px == py );
+}
+
+
+#define DEFN_REL_OP_T(tp)                                                     \
+template <class X>                                                            \
+inline                                                                        \
+bool                                                                          \
+operator == ( tp b, const sc_proxy<X>& px )                                   \
+{                                                                             \
+    return ( px == b );                                                       \
+}                                                                             \
+                                                                              \
+template <class X>                                                            \
+inline                                                                        \
+bool                                                                          \
+operator != ( const sc_proxy<X>& px, tp b )                                   \
+{                                                                             \
+    return !( px == b );                                                      \
+}                                                                             \
+                                                                              \
+template <class X>                                                            \
+inline                                                                        \
+bool                                                                          \
+operator != ( tp b, const sc_proxy<X>& px )                                   \
+{                                                                             \
+    return !( px == b );                                                      \
+}
+
+DEFN_REL_OP_T(const char*)
+DEFN_REL_OP_T(const bool*)
+DEFN_REL_OP_T(const sc_logic*)
+DEFN_REL_OP_T(const sc_unsigned&)
+DEFN_REL_OP_T(const sc_signed&)
+DEFN_REL_OP_T(const sc_uint_base&)
+DEFN_REL_OP_T(const sc_int_base&)
+DEFN_REL_OP_T(unsigned long)
+DEFN_REL_OP_T(long)
+DEFN_REL_OP_T(unsigned int)
+DEFN_REL_OP_T(int)
+DEFN_REL_OP_T(uint64)
+DEFN_REL_OP_T(int64)
+
+#undef DEFN_REL_OP_T
+
+
+// explicit conversions to character string
+
+template <class X>
+inline
+const std::string
+sc_proxy<X>::to_string() const
+{
+    const X& x = back_cast();
+    int len = x.length();
+    std::string s; // ( len + 1 );
+    for( int i = 0; i < len; ++ i ) {
+	s += sc_logic::logic_to_char[x.get_bit( len - i - 1 )];
+    }
+    return s;
+}
+
+template <class X>
+inline
+const std::string
+sc_proxy<X>::to_string( sc_numrep numrep ) const
+{
+    return convert_to_fmt( to_string(), numrep, true );
+}
+
+template <class X>
+inline
+const std::string
+sc_proxy<X>::to_string( sc_numrep numrep, bool w_prefix ) const
+{
+    return convert_to_fmt( to_string(), numrep, w_prefix );
+}
+
+
+// other methods
+
+template <class X>
+inline
+void
+sc_proxy<X>::scan( ::std::istream& is )
+{
+    std::string s;
+    is >> s;
+    back_cast() = s.c_str();
+}
+
+
+template <class X>
+inline
+void
+sc_proxy<X>::check_bounds( int n ) const  // check if bit n accessible
+{
+    if( n < 0 || n >= back_cast().length() ) {
+	SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 );
+    }
+}
+
+template <class X>
+inline
+void
+sc_proxy<X>::check_wbounds( int n ) const  // check if word n accessible
+{
+    if( n < 0 || n >= back_cast().size() ) {
+	SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, 0 );
+    }
+}
+
+
+template <class X>
+inline
+sc_digit
+sc_proxy<X>::to_anything_unsigned() const
+{
+    // only 0 word is returned
+    // can't convert logic values other than 0 and 1
+    const X& x = back_cast();
+    int len = x.length();
+    if( x.get_cword( 0 ) != SC_DIGIT_ZERO ) {
+	SC_REPORT_WARNING( sc_core::SC_ID_VECTOR_CONTAINS_LOGIC_VALUE_, 0 );
+    }
+    sc_digit w = x.get_word( 0 );
+    if( len >= SC_DIGIT_SIZE ) {
+	return w;
+    }
+    return ( w & (~SC_DIGIT_ZERO >> (SC_DIGIT_SIZE - len)) );
+}
+
+template <class X>
+inline
+uint64 
+sc_proxy<X>::to_uint64() const
+{
+    // words 1 and 0 returned.
+    // can't convert logic values other than 0 and 1
+    const X& x = back_cast();
+    int len = x.length();
+    if( x.get_cword( 0 ) != SC_DIGIT_ZERO ) {
+	SC_REPORT_WARNING( sc_core::SC_ID_VECTOR_CONTAINS_LOGIC_VALUE_, 0 );
+    }
+    uint64 w = x.get_word( 0 );
+    if( len > SC_DIGIT_SIZE ) 
+    {
+	if( x.get_cword( 1 ) != SC_DIGIT_ZERO ) {
+	    SC_REPORT_WARNING( sc_core::SC_ID_VECTOR_CONTAINS_LOGIC_VALUE_, 0 );
+	}
+	uint64 w1 = x.get_word( 1 );
+        w = w | (w1 << SC_DIGIT_SIZE);	
+	return w;
+    }
+    else if( len == SC_DIGIT_SIZE ) 
+    {
+	return w;
+    }
+    else
+    {
+	return ( w & (~SC_DIGIT_ZERO >> (SC_DIGIT_SIZE - len)) );
+    }
+}
+
+template <class X>
+inline
+int64
+sc_proxy<X>::to_anything_signed() const
+{
+    const X& x = back_cast();
+    int len = x.length();
+    int64 w = 0;
+
+    if( len > SC_DIGIT_SIZE ) 
+    {
+	if( x.get_cword( 1 ) != SC_DIGIT_ZERO ) 
+	    SC_REPORT_WARNING( sc_core::SC_ID_VECTOR_CONTAINS_LOGIC_VALUE_, 0 );
+	w = x.get_word(1);
+    }
+    if( x.get_cword( 0 ) != SC_DIGIT_ZERO ) 
+	SC_REPORT_WARNING( sc_core::SC_ID_VECTOR_CONTAINS_LOGIC_VALUE_, 0 );
+    w = (w << SC_DIGIT_SIZE) | x.get_word( 0 );
+    if( len >= 64 ) {
+	return w;
+    }
+
+    uint64 zero = 0;
+    sc_logic_value_t sgn = x.get_bit( len - 1 );
+    if( sgn == 0 ) {
+	return (int64)( w & (~zero >> (64 - len)) );
+    } else {
+	return (int64)( w | (~zero << len) );
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+
+// functional notation for the reduce methods
+
+template <class X>
+inline
+sc_logic_value_t
+and_reduce( const sc_proxy<X>& a )
+{
+    return a.and_reduce();
+}
+
+template <class X>
+inline
+sc_logic_value_t
+nand_reduce( const sc_proxy<X>& a )
+{
+    return a.nand_reduce();
+}
+
+template <class X>
+inline
+sc_logic_value_t
+or_reduce( const sc_proxy<X>& a )
+{
+    return a.or_reduce();
+}
+
+template <class X>
+inline
+sc_logic_value_t
+nor_reduce( const sc_proxy<X>& a )
+{
+    return a.nor_reduce();
+}
+
+template <class X>
+inline
+sc_logic_value_t
+xor_reduce( const sc_proxy<X>& a )
+{
+    return a.xor_reduce();
+}
+
+template <class X>
+inline
+sc_logic_value_t
+xnor_reduce( const sc_proxy<X>& a )
+{
+    return a.xnor_reduce();
+}
+
+
+// ----------------------------------------------------------------------------
+
+template <class X>
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_proxy<X>& a )
+{
+    a.print( os );
+    return os;
+}
+
+template <class X>
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_proxy<X>& a )
+{
+    a.scan( is );
+    return is;
+}
+
+} // namespace sc_dt
+
+
+#endif
diff --git a/ext/systemc/src/sysc/datatypes/fx/fx.h b/ext/systemc/src/sysc/datatypes/fx/fx.h
new file mode 100644
index 000000000..9c35014fa
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/fx.h
@@ -0,0 +1,61 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  fx.h - Master include file for the fixed-point types.
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: fx.h,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:57  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef FX_H
+#define FX_H
+
+
+#include "sysc/datatypes/fx/sc_fixed.h"
+#include "sysc/datatypes/fx/sc_fxcast_switch.h"
+#include "sysc/datatypes/fx/sc_fxtype_params.h"
+#include "sysc/datatypes/fx/sc_ufixed.h"
+
+#include "sysc/datatypes/fx/scfx_other_defs.h"
+
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/sc_context.h b/ext/systemc/src/sysc/datatypes/fx/sc_context.h
new file mode 100644
index 000000000..1e313a486
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/sc_context.h
@@ -0,0 +1,316 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_context.h - 
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_context.h,v $
+// Revision 1.2  2011/08/24 22:05:43  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.5  2006/05/26 20:36:52  acg
+//  Andy Goodrich: added a using for sc_core::default_ptr_hash_fn to keep HP
+//  aCC happy.
+//
+// Revision 1.4  2006/03/21 00:00:31  acg
+//   Andy Goodrich: changed name of sc_get_current_process_base() to be
+//   sc_get_current_process_b() since its returning an sc_process_b instance.
+//
+// Revision 1.3  2006/01/13 18:53:57  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SC_CONTEXT_H
+#define SC_CONTEXT_H
+
+
+#include "sysc/datatypes/fx/sc_fx_ids.h"
+#include "sysc/kernel/sc_simcontext.h"
+#include "sysc/utils/sc_hash.h"
+
+
+namespace sc_core {
+	class sc_process_b;
+}
+
+using sc_core::default_ptr_hash_fn; // To keep HP aCC happy.
+
+namespace sc_dt
+{
+
+// classes defined in this module
+class sc_without_context;
+template <class T> class sc_global;
+template <class T> class sc_context;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_without_context
+//
+//  Empty class that is used for its type only.
+// ----------------------------------------------------------------------------
+
+class sc_without_context {};
+
+
+// ----------------------------------------------------------------------------
+//  TEMPLATE CLASS : sc_global
+//
+//  Template global variable class; singleton; co-routine safe.
+// ----------------------------------------------------------------------------
+
+template <class T>
+class sc_global
+{
+
+    sc_global();
+
+    void update();
+
+public:
+
+    static sc_global<T>* instance();
+
+    const T*& value_ptr();
+
+private:
+    static sc_global<T>* m_instance;
+
+    sc_core::sc_phash<void*,const T*> m_map;
+    void*                             m_proc; // context (current process or NULL)
+    const T*                          m_value_ptr;
+
+};
+
+
+// ----------------------------------------------------------------------------
+//  ENUM : sc_context_begin
+//
+//  Enumeration of context begin options.
+// ----------------------------------------------------------------------------
+
+enum sc_context_begin
+{
+    SC_NOW,
+    SC_LATER
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_context
+//
+//  Template context class; co-routine safe.
+// ----------------------------------------------------------------------------
+
+template <class T>
+class sc_context
+{
+    // disabled
+    sc_context( const sc_context<T>& );
+    void* operator new( std::size_t );
+
+public:
+
+    explicit sc_context( const T&, sc_context_begin = SC_NOW );
+    ~sc_context();
+
+    void begin();
+    void end();
+
+    static const T& default_value();
+    const T& value() const;
+
+private:
+
+    const T   m_value;
+    const T*& m_def_value_ptr;
+    const T*  m_old_value_ptr;
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+// ----------------------------------------------------------------------------
+//  TEMPLATE CLASS : sc_global
+//
+//  Template global variable class; singleton; co-routine safe.
+// ----------------------------------------------------------------------------
+
+template <class T>
+sc_global<T>* sc_global<T>::m_instance = 0;
+
+template <class T>
+inline
+sc_global<T>::sc_global()
+  : m_map()
+  // use &m_instance as unique "non-process" key (NULL denotes 'sc_main' context)
+  , m_proc( &m_instance )
+  , m_value_ptr( 0 )
+{}
+
+
+template <class T>
+inline
+void
+sc_global<T>::update()
+{
+    void* p = sc_core::sc_get_current_process_b();
+    if( p != m_proc )
+    {
+        const T* vp = m_map[p];
+        if( vp == 0 )
+        {
+            vp = new T( sc_without_context() );
+            m_map.insert( p, vp );
+        }
+        m_proc = p;
+        m_value_ptr = vp;
+    }
+}
+
+
+template <class T>
+inline
+sc_global<T>*
+sc_global<T>::instance()
+{
+    if( m_instance == 0 )
+    {
+        m_instance = new sc_global<T>;
+    }
+    return m_instance;
+}
+
+
+template <class T>
+inline
+const T*&
+sc_global<T>::value_ptr()
+{
+    update();
+    return m_value_ptr;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_context
+//
+//  Template context class; co-routine safe.
+// ----------------------------------------------------------------------------
+
+template <class T>
+inline
+sc_context<T>::sc_context( const T& value_, sc_context_begin begin )
+: m_value( value_ ),
+  m_def_value_ptr( sc_global<T>::instance()->value_ptr() ),
+  m_old_value_ptr( 0 )
+{
+    if( begin == SC_NOW )
+    {
+	m_old_value_ptr = m_def_value_ptr;
+	m_def_value_ptr = &m_value;
+    }
+}
+
+template <class T>
+inline
+sc_context<T>::~sc_context()
+{
+    if( m_old_value_ptr != 0 )
+    {
+        m_def_value_ptr = m_old_value_ptr;
+	m_old_value_ptr = 0;
+    }
+}
+
+
+template <class T>
+inline
+void
+sc_context<T>::begin()
+{
+    if( m_old_value_ptr == 0 )
+    {
+	m_old_value_ptr = m_def_value_ptr;
+	m_def_value_ptr = &m_value;
+    }
+    else
+    {
+        SC_REPORT_ERROR( sc_core::SC_ID_CONTEXT_BEGIN_FAILED_, 0 );
+    }
+}
+
+template <class T>
+inline
+void
+sc_context<T>::end()
+{
+    if( m_old_value_ptr != 0 )
+    {
+        m_def_value_ptr = m_old_value_ptr;
+	m_old_value_ptr = 0;
+    }
+    else
+    {
+        SC_REPORT_ERROR( sc_core::SC_ID_CONTEXT_END_FAILED_, 0 );
+    }
+}
+
+
+template <class T>
+inline
+const T&
+sc_context<T>::default_value()
+{
+    return *sc_global<T>::instance()->value_ptr();
+}
+
+template <class T>
+inline
+const T&
+sc_context<T>::value() const
+{
+    return m_value;
+}
+
+} // namespace sc_dt
+
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/sc_fix.h b/ext/systemc/src/sysc/datatypes/fx/sc_fix.h
new file mode 100644
index 000000000..80df65a2c
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/sc_fix.h
@@ -0,0 +1,1938 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_fix.h - 
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_fix.h,v $
+// Revision 1.2  2011/01/19 18:57:40  acg
+//  Andy Goodrich: changes for IEEE_1666_2011.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:57  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SC_FIX_H
+#define SC_FIX_H
+
+
+#include "sysc/datatypes/fx/sc_fxnum.h"
+
+
+namespace sc_dt
+{
+
+// classes defined in this module
+class sc_fix;
+class sc_fix_fast;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fix
+//
+//  "Unconstrained" signed fixed-point class; arbitrary precision.
+// ----------------------------------------------------------------------------
+
+class sc_fix : public sc_fxnum
+{
+
+public:
+
+    // constructors
+
+    explicit sc_fix( sc_fxnum_observer* = 0 );
+             sc_fix( int, int,
+		     sc_fxnum_observer* = 0 );
+             sc_fix( sc_q_mode, sc_o_mode,
+		     sc_fxnum_observer* = 0 );
+             sc_fix( sc_q_mode, sc_o_mode, int,
+		     sc_fxnum_observer* = 0 );
+             sc_fix( int, int, sc_q_mode, sc_o_mode,
+		     sc_fxnum_observer* = 0 );
+             sc_fix( int, int, sc_q_mode, sc_o_mode, int,
+		     sc_fxnum_observer* = 0 );
+    explicit sc_fix( const sc_fxcast_switch&,
+		     sc_fxnum_observer* = 0 );
+             sc_fix( int, int,
+		     const sc_fxcast_switch&,
+		     sc_fxnum_observer* = 0 );
+             sc_fix( sc_q_mode, sc_o_mode,
+		     const sc_fxcast_switch&,
+		     sc_fxnum_observer* = 0 );
+             sc_fix( sc_q_mode, sc_o_mode, int,
+		     const sc_fxcast_switch&,
+		     sc_fxnum_observer* = 0 );
+             sc_fix( int, int, sc_q_mode, sc_o_mode,
+		     const sc_fxcast_switch&,
+		     sc_fxnum_observer* = 0 );
+             sc_fix( int, int, sc_q_mode, sc_o_mode, int,
+		     const sc_fxcast_switch&,
+		     sc_fxnum_observer* = 0 );
+    explicit sc_fix( const sc_fxtype_params&,
+		     sc_fxnum_observer* = 0 );
+             sc_fix( const sc_fxtype_params&,
+		     const sc_fxcast_switch&,
+		     sc_fxnum_observer* = 0 );
+
+#define DECL_CTORS_T(tp)                                                      \
+             sc_fix( tp,                                                      \
+	             int, int,                                                \
+	             sc_fxnum_observer* = 0 );                                \
+             sc_fix( tp,                                                      \
+	             sc_q_mode, sc_o_mode,                                    \
+	             sc_fxnum_observer* = 0 );                                \
+             sc_fix( tp,                                                      \
+	             sc_q_mode, sc_o_mode, int,                               \
+	             sc_fxnum_observer* = 0 );                                \
+             sc_fix( tp,                                                      \
+	             int, int, sc_q_mode, sc_o_mode,                          \
+	             sc_fxnum_observer* = 0 );                                \
+             sc_fix( tp,                                                      \
+	             int, int, sc_q_mode, sc_o_mode, int,                     \
+	             sc_fxnum_observer* = 0 );                                \
+             sc_fix( tp,                                                      \
+	             const sc_fxcast_switch&,                                 \
+	             sc_fxnum_observer* = 0 );                                \
+             sc_fix( tp,                                                      \
+	             int, int,                                                \
+	             const sc_fxcast_switch&,                                 \
+	             sc_fxnum_observer* = 0 );                                \
+             sc_fix( tp,                                                      \
+	             sc_q_mode, sc_o_mode,                                    \
+	             const sc_fxcast_switch&,                                 \
+	             sc_fxnum_observer* = 0 );                                \
+             sc_fix( tp,                                                      \
+	             sc_q_mode, sc_o_mode, int,                               \
+	             const sc_fxcast_switch&,                                 \
+	             sc_fxnum_observer* = 0 );                                \
+             sc_fix( tp,                                                      \
+	             int, int, sc_q_mode, sc_o_mode,                          \
+	             const sc_fxcast_switch&,                                 \
+	             sc_fxnum_observer* = 0 );                                \
+             sc_fix( tp,                                                      \
+	             int, int, sc_q_mode, sc_o_mode, int,                     \
+	             const sc_fxcast_switch&,                                 \
+	             sc_fxnum_observer* = 0 );                                \
+             sc_fix( tp,                                                      \
+	             const sc_fxtype_params&,                                 \
+	             sc_fxnum_observer* = 0 );                                \
+             sc_fix( tp,                                                      \
+	             const sc_fxtype_params&,                                 \
+	             const sc_fxcast_switch&,                                 \
+	             sc_fxnum_observer* = 0 );
+
+#define DECL_CTORS_T_A(tp)                                                    \
+             sc_fix( tp,                                                      \
+	             sc_fxnum_observer* = 0 );                                \
+    DECL_CTORS_T(tp)
+
+#define DECL_CTORS_T_B(tp)                                                    \
+    explicit sc_fix( tp,                                                      \
+	             sc_fxnum_observer* = 0 );                                \
+    DECL_CTORS_T(tp)
+
+    DECL_CTORS_T_A(int)
+    DECL_CTORS_T_A(unsigned int)
+    DECL_CTORS_T_A(long)
+    DECL_CTORS_T_A(unsigned long)
+    DECL_CTORS_T_A(float)
+    DECL_CTORS_T_A(double)
+    DECL_CTORS_T_A(const char*)
+    DECL_CTORS_T_A(const sc_fxval&)
+    DECL_CTORS_T_A(const sc_fxval_fast&)
+    DECL_CTORS_T_A(const sc_fxnum&)
+    DECL_CTORS_T_A(const sc_fxnum_fast&)
+#ifndef SC_FX_EXCLUDE_OTHER
+    DECL_CTORS_T_B(int64)
+    DECL_CTORS_T_B(uint64)
+    DECL_CTORS_T_B(const sc_int_base&)
+    DECL_CTORS_T_B(const sc_uint_base&)
+    DECL_CTORS_T_B(const sc_signed&)
+    DECL_CTORS_T_B(const sc_unsigned&)
+#endif
+
+#undef DECL_CTORS_T
+#undef DECL_CTORS_T_A
+#undef DECL_CTORS_T_B
+
+    // copy constructor
+
+    sc_fix( const sc_fix& );
+
+
+    // unary bitwise operators
+
+    const sc_fix operator ~ () const;
+
+
+    // unary bitwise functions
+
+    friend void b_not( sc_fix&, const sc_fix& );
+
+
+    // binary bitwise operators
+
+    friend const sc_fix operator & ( const sc_fix&, const sc_fix& );
+    friend const sc_fix operator & ( const sc_fix&, const sc_fix_fast& );
+    friend const sc_fix operator & ( const sc_fix_fast&, const sc_fix& );
+    friend const sc_fix operator | ( const sc_fix&, const sc_fix& );
+    friend const sc_fix operator | ( const sc_fix&, const sc_fix_fast& );
+    friend const sc_fix operator | ( const sc_fix_fast&, const sc_fix& );
+    friend const sc_fix operator ^ ( const sc_fix&, const sc_fix& );
+    friend const sc_fix operator ^ ( const sc_fix&, const sc_fix_fast& );
+    friend const sc_fix operator ^ ( const sc_fix_fast&, const sc_fix& );
+
+
+    // binary bitwise functions
+
+    friend void b_and( sc_fix&, const sc_fix&, const sc_fix& );
+    friend void b_and( sc_fix&, const sc_fix&, const sc_fix_fast& );
+    friend void b_and( sc_fix&, const sc_fix_fast&, const sc_fix& );
+    friend void b_or ( sc_fix&, const sc_fix&, const sc_fix& );
+    friend void b_or ( sc_fix&, const sc_fix&, const sc_fix_fast& );
+    friend void b_or ( sc_fix&, const sc_fix_fast&, const sc_fix& );
+    friend void b_xor( sc_fix&, const sc_fix&, const sc_fix& );
+    friend void b_xor( sc_fix&, const sc_fix&, const sc_fix_fast& );
+    friend void b_xor( sc_fix&, const sc_fix_fast&, const sc_fix& );
+
+
+    // assignment operators
+
+    sc_fix& operator = ( const sc_fix& );
+
+#define DECL_ASN_OP_T(op,tp)                                                  \
+    sc_fix& operator op ( tp );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_ASN_OP_OTHER(op)                                                 \
+    DECL_ASN_OP_T(op,int64)                                                   \
+    DECL_ASN_OP_T(op,uint64)                                                  \
+    DECL_ASN_OP_T(op,const sc_int_base&)                                      \
+    DECL_ASN_OP_T(op,const sc_uint_base&)                                     \
+    DECL_ASN_OP_T(op,const sc_signed&)                                        \
+    DECL_ASN_OP_T(op,const sc_unsigned&)
+#else
+#define DECL_ASN_OP_OTHER(op)
+#endif
+
+#define DECL_ASN_OP(op)                                                       \
+    DECL_ASN_OP_T(op,int)                                                     \
+    DECL_ASN_OP_T(op,unsigned int)                                            \
+    DECL_ASN_OP_T(op,long)                                                    \
+    DECL_ASN_OP_T(op,unsigned long)                                           \
+    DECL_ASN_OP_T(op,float)                                                  \
+    DECL_ASN_OP_T(op,double)                                                  \
+    DECL_ASN_OP_T(op,const char*)                                             \
+    DECL_ASN_OP_T(op,const sc_fxval&)                                         \
+    DECL_ASN_OP_T(op,const sc_fxval_fast&)                                    \
+    DECL_ASN_OP_T(op,const sc_fxnum&)                                         \
+    DECL_ASN_OP_T(op,const sc_fxnum_fast&)                                    \
+    DECL_ASN_OP_OTHER(op)
+
+    DECL_ASN_OP(=)
+
+    DECL_ASN_OP(*=)
+    DECL_ASN_OP(/=)
+    DECL_ASN_OP(+=)
+    DECL_ASN_OP(-=)
+
+    DECL_ASN_OP_T(<<=,int)
+    DECL_ASN_OP_T(>>=,int)
+
+    DECL_ASN_OP_T(&=,const sc_fix&)
+    DECL_ASN_OP_T(&=,const sc_fix_fast&)
+    DECL_ASN_OP_T(|=,const sc_fix&)
+    DECL_ASN_OP_T(|=,const sc_fix_fast&)
+    DECL_ASN_OP_T(^=,const sc_fix&)
+    DECL_ASN_OP_T(^=,const sc_fix_fast&)
+
+#undef DECL_ASN_OP_T
+#undef DECL_ASN_OP_OTHER
+#undef DECL_ASN_OP
+
+
+    // auto-increment and auto-decrement
+
+    const sc_fxval operator ++ ( int );
+    const sc_fxval operator -- ( int );
+
+    sc_fix& operator ++ ();
+    sc_fix& operator -- ();
+
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fix_fast
+//
+//  "Unconstrained" signed fixed-point class; limited precision.
+// ----------------------------------------------------------------------------
+
+class sc_fix_fast : public sc_fxnum_fast
+{
+
+public:
+
+    // constructors
+
+    explicit sc_fix_fast( sc_fxnum_fast_observer* = 0 );
+             sc_fix_fast( int, int,
+			  sc_fxnum_fast_observer* = 0 );
+             sc_fix_fast( sc_q_mode, sc_o_mode,
+			  sc_fxnum_fast_observer* = 0 );
+             sc_fix_fast( sc_q_mode, sc_o_mode, int,
+			  sc_fxnum_fast_observer* = 0 );
+             sc_fix_fast( int, int, sc_q_mode, sc_o_mode,
+			  sc_fxnum_fast_observer* = 0 );
+             sc_fix_fast( int, int, sc_q_mode, sc_o_mode, int,
+			  sc_fxnum_fast_observer* = 0 );
+    explicit sc_fix_fast( const sc_fxcast_switch&,
+			  sc_fxnum_fast_observer* = 0 );
+             sc_fix_fast( int, int,
+			  const sc_fxcast_switch&,
+			  sc_fxnum_fast_observer* = 0 );
+             sc_fix_fast( sc_q_mode, sc_o_mode,
+			  const sc_fxcast_switch&,
+			  sc_fxnum_fast_observer* = 0 );
+             sc_fix_fast( sc_q_mode, sc_o_mode, int,
+			  const sc_fxcast_switch&,
+			  sc_fxnum_fast_observer* = 0 );
+             sc_fix_fast( int, int, sc_q_mode, sc_o_mode,
+			  const sc_fxcast_switch&,
+			  sc_fxnum_fast_observer* = 0 );
+             sc_fix_fast( int, int, sc_q_mode, sc_o_mode, int,
+			  const sc_fxcast_switch&,
+			  sc_fxnum_fast_observer* = 0 );
+    explicit sc_fix_fast( const sc_fxtype_params&,
+			  sc_fxnum_fast_observer* = 0 );
+             sc_fix_fast( const sc_fxtype_params&,
+			  const sc_fxcast_switch&,
+			  sc_fxnum_fast_observer* = 0 );
+
+#define DECL_CTORS_T(tp)                                                      \
+             sc_fix_fast( tp,                                                 \
+		          int, int,                                           \
+		          sc_fxnum_fast_observer* = 0 );                      \
+             sc_fix_fast( tp,                                                 \
+		          sc_q_mode, sc_o_mode,                               \
+		          sc_fxnum_fast_observer* = 0 );                      \
+             sc_fix_fast( tp,                                                 \
+		          sc_q_mode, sc_o_mode, int,                          \
+		          sc_fxnum_fast_observer* = 0 );                      \
+             sc_fix_fast( tp,                                                 \
+		          int, int, sc_q_mode, sc_o_mode,                     \
+		          sc_fxnum_fast_observer* = 0 );                      \
+             sc_fix_fast( tp,                                                 \
+		          int, int, sc_q_mode, sc_o_mode, int,                \
+		          sc_fxnum_fast_observer* = 0 );                      \
+             sc_fix_fast( tp,                                                 \
+		          const sc_fxcast_switch&,                            \
+		          sc_fxnum_fast_observer* = 0 );                      \
+             sc_fix_fast( tp,                                                 \
+		          int, int,                                           \
+		          const sc_fxcast_switch&,                            \
+		          sc_fxnum_fast_observer* = 0 );                      \
+             sc_fix_fast( tp,                                                 \
+		          sc_q_mode, sc_o_mode,                               \
+		          const sc_fxcast_switch&,                            \
+		          sc_fxnum_fast_observer* = 0 );                      \
+             sc_fix_fast( tp,                                                 \
+		          sc_q_mode, sc_o_mode, int,                          \
+		          const sc_fxcast_switch&,                            \
+		          sc_fxnum_fast_observer* = 0 );                      \
+             sc_fix_fast( tp,                                                 \
+		          int, int, sc_q_mode, sc_o_mode,                     \
+		          const sc_fxcast_switch&,                            \
+		          sc_fxnum_fast_observer* = 0 );                      \
+             sc_fix_fast( tp,                                                 \
+		          int, int, sc_q_mode, sc_o_mode, int,                \
+		          const sc_fxcast_switch&,                            \
+		          sc_fxnum_fast_observer* = 0 );                      \
+             sc_fix_fast( tp,                                                 \
+		          const sc_fxtype_params&,                            \
+		          sc_fxnum_fast_observer* = 0 );                      \
+             sc_fix_fast( tp,                                                 \
+		          const sc_fxtype_params&,                            \
+		          const sc_fxcast_switch&,                            \
+		          sc_fxnum_fast_observer* = 0 );
+
+#define DECL_CTORS_T_A(tp)                                                    \
+             sc_fix_fast( tp,                                                 \
+		          sc_fxnum_fast_observer* = 0 );                      \
+    DECL_CTORS_T(tp)
+
+#define DECL_CTORS_T_B(tp)                                                    \
+    explicit sc_fix_fast( tp,                                                 \
+		          sc_fxnum_fast_observer* = 0 );                      \
+    DECL_CTORS_T(tp)
+
+    DECL_CTORS_T_A(int)
+    DECL_CTORS_T_A(unsigned int)
+    DECL_CTORS_T_A(long)
+    DECL_CTORS_T_A(unsigned long)
+    DECL_CTORS_T_A(float)
+    DECL_CTORS_T_A(double)
+    DECL_CTORS_T_A(const char*)
+    DECL_CTORS_T_A(const sc_fxval&)
+    DECL_CTORS_T_A(const sc_fxval_fast&)
+    DECL_CTORS_T_A(const sc_fxnum&)
+    DECL_CTORS_T_A(const sc_fxnum_fast&)
+#ifndef SC_FX_EXCLUDE_OTHER
+    DECL_CTORS_T_B(int64)
+    DECL_CTORS_T_B(uint64)
+    DECL_CTORS_T_B(const sc_int_base&)
+    DECL_CTORS_T_B(const sc_uint_base&)
+    DECL_CTORS_T_B(const sc_signed&)
+    DECL_CTORS_T_B(const sc_unsigned&)
+#endif
+
+#undef DECL_CTORS_T
+#undef DECL_CTORS_T_A
+#undef DECL_CTORS_T_B
+
+    // copy constructor
+
+    sc_fix_fast( const sc_fix_fast& );
+
+
+    // unary bitwise operators
+
+    const sc_fix_fast operator ~ () const;
+
+
+    // unary bitwise functions
+
+    friend void b_not( sc_fix_fast&, const sc_fix_fast& );
+
+
+    // binary bitwise operators
+
+    friend const sc_fix_fast operator & ( const sc_fix_fast&,
+					  const sc_fix_fast& );
+    friend const sc_fix_fast operator ^ ( const sc_fix_fast&,
+					  const sc_fix_fast& );
+    friend const sc_fix_fast operator | ( const sc_fix_fast&,
+					  const sc_fix_fast& );
+
+
+    // binary bitwise functions
+
+    friend void b_and( sc_fix_fast&, const sc_fix_fast&, const sc_fix_fast& );
+    friend void b_or ( sc_fix_fast&, const sc_fix_fast&, const sc_fix_fast& );
+    friend void b_xor( sc_fix_fast&, const sc_fix_fast&, const sc_fix_fast& );
+
+
+    // assignment operators
+
+    sc_fix_fast& operator = ( const sc_fix_fast& );
+
+#define DECL_ASN_OP_T(op,tp)                                                  \
+    sc_fix_fast& operator op ( tp );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_ASN_OP_OTHER(op)                                                 \
+    DECL_ASN_OP_T(op,int64)                                                   \
+    DECL_ASN_OP_T(op,uint64)                                                  \
+    DECL_ASN_OP_T(op,const sc_int_base&)                                      \
+    DECL_ASN_OP_T(op,const sc_uint_base&)                                     \
+    DECL_ASN_OP_T(op,const sc_signed&)                                        \
+    DECL_ASN_OP_T(op,const sc_unsigned&)
+#else
+#define DECL_ASN_OP_OTHER(op)
+#endif
+
+#define DECL_ASN_OP(op)                                                       \
+    DECL_ASN_OP_T(op,int)                                                     \
+    DECL_ASN_OP_T(op,unsigned int)                                            \
+    DECL_ASN_OP_T(op,long)                                                    \
+    DECL_ASN_OP_T(op,unsigned long)                                           \
+    DECL_ASN_OP_T(op,float)                                                  \
+    DECL_ASN_OP_T(op,double)                                                  \
+    DECL_ASN_OP_T(op,const char*)                                             \
+    DECL_ASN_OP_T(op,const sc_fxval&)                                         \
+    DECL_ASN_OP_T(op,const sc_fxval_fast&)                                    \
+    DECL_ASN_OP_T(op,const sc_fxnum&)                                         \
+    DECL_ASN_OP_T(op,const sc_fxnum_fast&)                                    \
+    DECL_ASN_OP_OTHER(op)
+
+    DECL_ASN_OP(=)
+
+    DECL_ASN_OP(*=)
+    DECL_ASN_OP(/=)
+    DECL_ASN_OP(+=)
+    DECL_ASN_OP(-=)
+
+    DECL_ASN_OP_T(<<=,int)
+    DECL_ASN_OP_T(>>=,int)
+
+    DECL_ASN_OP_T(&=,const sc_fix&)
+    DECL_ASN_OP_T(&=,const sc_fix_fast&)
+    DECL_ASN_OP_T(|=,const sc_fix&)
+    DECL_ASN_OP_T(|=,const sc_fix_fast&)
+    DECL_ASN_OP_T(^=,const sc_fix&)
+    DECL_ASN_OP_T(^=,const sc_fix_fast&)
+
+#undef DECL_ASN_OP_T
+#undef DECL_ASN_OP_OTHER
+#undef DECL_ASN_OP
+
+
+    // auto-increment and auto-decrement
+
+    const sc_fxval_fast operator ++ ( int );
+    const sc_fxval_fast operator -- ( int );
+
+    sc_fix_fast& operator ++ ();
+    sc_fix_fast& operator -- ();
+
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fix
+//
+//  "Unconstrained" signed fixed-point class; arbitrary precision.
+// ----------------------------------------------------------------------------
+
+// constructors
+
+inline
+sc_fix::sc_fix( sc_fxnum_observer* observer_ )
+: sc_fxnum( sc_fxtype_params(),
+	    SC_TC_,
+	    sc_fxcast_switch(),
+	    observer_ )
+{}
+
+inline
+sc_fix::sc_fix( int wl_, int iwl_,
+		sc_fxnum_observer* observer_ )
+: sc_fxnum( sc_fxtype_params( wl_, iwl_ ),
+	    SC_TC_,
+	    sc_fxcast_switch(),
+	    observer_ )
+{}
+
+inline
+sc_fix::sc_fix( sc_q_mode qm, sc_o_mode om,
+		sc_fxnum_observer* observer_ )
+: sc_fxnum( sc_fxtype_params( qm, om ),
+	    SC_TC_,
+	    sc_fxcast_switch(),
+	    observer_ )
+{}
+
+inline
+sc_fix::sc_fix( sc_q_mode qm, sc_o_mode om, int nb,
+		sc_fxnum_observer* observer_ )
+: sc_fxnum( sc_fxtype_params( qm, om, nb ),
+	    SC_TC_,
+	    sc_fxcast_switch(),
+	    observer_ )
+{}
+
+inline
+sc_fix::sc_fix( int wl_, int iwl_, sc_q_mode qm, sc_o_mode om,
+		sc_fxnum_observer* observer_ )
+: sc_fxnum( sc_fxtype_params( wl_, iwl_, qm, om ),
+	    SC_TC_,
+	    sc_fxcast_switch(),
+	    observer_ )
+{}
+
+inline
+sc_fix::sc_fix( int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb,
+		sc_fxnum_observer* observer_ )
+: sc_fxnum( sc_fxtype_params( wl_, iwl_, qm, om, nb ),
+	    SC_TC_,
+	    sc_fxcast_switch(),
+	    observer_ )
+{}
+
+inline
+sc_fix::sc_fix( const sc_fxcast_switch& cast_sw,
+		sc_fxnum_observer* observer_ )
+: sc_fxnum( sc_fxtype_params(),
+	    SC_TC_,
+	    cast_sw,
+	    observer_ )
+{}
+
+inline
+sc_fix::sc_fix( int wl_, int iwl_,
+		const sc_fxcast_switch& cast_sw,
+		sc_fxnum_observer* observer_ )
+: sc_fxnum( sc_fxtype_params( wl_, iwl_ ),
+	    SC_TC_,
+	    cast_sw,
+	    observer_ )
+{}
+
+inline
+sc_fix::sc_fix( sc_q_mode qm, sc_o_mode om,
+		const sc_fxcast_switch& cast_sw,
+		sc_fxnum_observer* observer_ )
+: sc_fxnum( sc_fxtype_params( qm, om ),
+	    SC_TC_,
+	    cast_sw,
+	    observer_ )
+{}
+
+inline
+sc_fix::sc_fix( sc_q_mode qm, sc_o_mode om, int nb,
+		const sc_fxcast_switch& cast_sw,
+		sc_fxnum_observer* observer_ )
+: sc_fxnum( sc_fxtype_params( qm, om, nb ),
+	    SC_TC_,
+	    cast_sw,
+	    observer_ )
+{}
+
+inline
+sc_fix::sc_fix( int wl_, int iwl_, sc_q_mode qm, sc_o_mode om,
+		const sc_fxcast_switch& cast_sw,
+		sc_fxnum_observer* observer_ )
+: sc_fxnum( sc_fxtype_params( wl_, iwl_, qm, om ),
+	    SC_TC_,
+	    cast_sw,
+	    observer_ )
+{}
+
+inline
+sc_fix::sc_fix( int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb,
+		const sc_fxcast_switch& cast_sw,
+		sc_fxnum_observer* observer_ )
+: sc_fxnum( sc_fxtype_params( wl_, iwl_, qm, om, nb ),
+	    SC_TC_,
+	    cast_sw,
+	    observer_ )
+{}
+
+inline
+sc_fix::sc_fix( const sc_fxtype_params& type_params,
+		sc_fxnum_observer* observer_ )
+: sc_fxnum( type_params,
+	    SC_TC_,
+	    sc_fxcast_switch(),
+	    observer_ )
+{}
+
+inline
+sc_fix::sc_fix( const sc_fxtype_params& type_params,
+		const sc_fxcast_switch& cast_sw,
+		sc_fxnum_observer* observer_ )
+: sc_fxnum( type_params,
+	    SC_TC_,
+	    cast_sw,
+	    observer_ )
+{}
+
+#define DEFN_CTORS_T_A(tp)                                                    \
+inline                                                                        \
+sc_fix::sc_fix( tp a,                                                         \
+		sc_fxnum_observer* observer_ )                                \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params(),                                               \
+	    SC_TC_,                                                           \
+	    sc_fxcast_switch(),                                               \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix::sc_fix( tp a,                                                         \
+		int wl_, int iwl_,                                            \
+		sc_fxnum_observer* observer_ )                                \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( wl_, iwl_ ),                                    \
+	    SC_TC_,                                                           \
+	    sc_fxcast_switch(),                                               \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix::sc_fix( tp a,                                                         \
+		sc_q_mode qm, sc_o_mode om,                                   \
+		sc_fxnum_observer* observer_ )                                \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( qm, om ),                                       \
+	    SC_TC_,                                                           \
+	    sc_fxcast_switch(),                                               \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix::sc_fix( tp a,                                                         \
+		sc_q_mode qm, sc_o_mode om, int nb,                           \
+		sc_fxnum_observer* observer_ )                                \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( qm, om, nb ),                                   \
+	    SC_TC_,                                                           \
+	    sc_fxcast_switch(),                                               \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix::sc_fix( tp a,                                                         \
+		int wl_, int iwl_, sc_q_mode qm, sc_o_mode om,                \
+		sc_fxnum_observer* observer_ )                                \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( wl_, iwl_, qm, om ),                            \
+	    SC_TC_,                                                           \
+	    sc_fxcast_switch(),                                               \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix::sc_fix( tp a,                                                         \
+		int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb,        \
+		sc_fxnum_observer* observer_ )                                \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( wl_, iwl_, qm, om, nb ),                        \
+	    SC_TC_,                                                           \
+	    sc_fxcast_switch(),                                               \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix::sc_fix( tp a,                                                         \
+		const sc_fxcast_switch& cast_sw,                              \
+		sc_fxnum_observer* observer_ )                                \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params(),                                               \
+	    SC_TC_,                                                           \
+	    cast_sw,                                                          \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix::sc_fix( tp a,                                                         \
+		int wl_, int iwl_,                                            \
+		const sc_fxcast_switch& cast_sw,                              \
+		sc_fxnum_observer* observer_ )                                \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( wl_, iwl_ ),                                    \
+	    SC_TC_,                                                           \
+	    cast_sw,                                                          \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix::sc_fix( tp a,                                                         \
+		sc_q_mode qm, sc_o_mode om,                                   \
+		const sc_fxcast_switch& cast_sw,                              \
+		sc_fxnum_observer* observer_ )                                \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( qm, om ),                                       \
+	    SC_TC_,                                                           \
+	    cast_sw,                                                          \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix::sc_fix( tp a,                                                         \
+		sc_q_mode qm, sc_o_mode om, int nb,                           \
+		const sc_fxcast_switch& cast_sw,                              \
+		sc_fxnum_observer* observer_ )                                \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( qm, om, nb ),                                   \
+	    SC_TC_,                                                           \
+	    cast_sw,                                                          \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix::sc_fix( tp a,                                                         \
+		int wl_, int iwl_, sc_q_mode qm, sc_o_mode om,                \
+		const sc_fxcast_switch& cast_sw,                              \
+		sc_fxnum_observer* observer_ )                                \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( wl_, iwl_, qm, om ),                            \
+	    SC_TC_,                                                           \
+	    cast_sw,                                                          \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix::sc_fix( tp a,                                                         \
+		int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb,        \
+		const sc_fxcast_switch& cast_sw,                              \
+		sc_fxnum_observer* observer_ )                                \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( wl_, iwl_, qm, om, nb ),                        \
+	    SC_TC_,                                                           \
+	    cast_sw,                                                          \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix::sc_fix( tp a,                                                         \
+		const sc_fxtype_params& type_params,                          \
+		sc_fxnum_observer* observer_ )                                \
+: sc_fxnum( a,                                                                \
+	    type_params,                                                      \
+	    SC_TC_,                                                           \
+	    sc_fxcast_switch(),                                               \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix::sc_fix( tp a,                                                         \
+		const sc_fxtype_params& type_params,                          \
+		const sc_fxcast_switch& cast_sw,                              \
+		sc_fxnum_observer* observer_ )                                \
+: sc_fxnum( a,                                                                \
+	    type_params,                                                      \
+	    SC_TC_,                                                           \
+	    cast_sw,                                                          \
+	    observer_ )                                                       \
+{}
+
+#define DEFN_CTORS_T_B(tp)                                                    \
+inline                                                                        \
+sc_fix::sc_fix( tp a,                                                         \
+		sc_fxnum_observer* observer_ )                                \
+: sc_fxnum( a,                                                                \
+	    a.type_params(),                                                  \
+	    SC_TC_,                                                           \
+	    sc_fxcast_switch(),                                               \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix::sc_fix( tp a,                                                         \
+		int wl_, int iwl_,                                            \
+		sc_fxnum_observer* observer_ )                                \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( a.type_params(), wl_, iwl_ ),                   \
+	    SC_TC_,                                                           \
+	    sc_fxcast_switch(),                                               \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix::sc_fix( tp a,                                                         \
+		sc_q_mode qm, sc_o_mode om,                                   \
+		sc_fxnum_observer* observer_ )                                \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( a.type_params(), qm, om ),                      \
+	    SC_TC_,                                                           \
+	    sc_fxcast_switch(),                                               \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix::sc_fix( tp a,                                                         \
+		sc_q_mode qm, sc_o_mode om, int nb,                           \
+		sc_fxnum_observer* observer_ )                                \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( a.type_params(), qm, om, nb ),                  \
+	    SC_TC_,                                                           \
+	    sc_fxcast_switch(),                                               \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix::sc_fix( tp a,                                                         \
+		int wl_, int iwl_, sc_q_mode qm, sc_o_mode om,                \
+		sc_fxnum_observer* observer_ )                                \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( wl_, iwl_, qm, om ),                            \
+	    SC_TC_,                                                           \
+	    sc_fxcast_switch(),                                               \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix::sc_fix( tp a,                                                         \
+		int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb,        \
+		sc_fxnum_observer* observer_ )                                \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( wl_, iwl_, qm, om, nb ),                        \
+	    SC_TC_,                                                           \
+	    sc_fxcast_switch(),                                               \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix::sc_fix( tp a,                                                         \
+		const sc_fxcast_switch& cast_sw,                              \
+		sc_fxnum_observer* observer_ )                                \
+: sc_fxnum( a,                                                                \
+	    a.type_params(),                                                  \
+	    SC_TC_,                                                           \
+	    cast_sw,                                                          \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix::sc_fix( tp a,                                                         \
+		int wl_, int iwl_,                                            \
+		const sc_fxcast_switch& cast_sw,                              \
+		sc_fxnum_observer* observer_ )                                \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( a.type_params(), wl_, iwl_ ),                   \
+	    SC_TC_,                                                           \
+	    cast_sw,                                                          \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix::sc_fix( tp a,                                                         \
+		sc_q_mode qm, sc_o_mode om,                                   \
+		const sc_fxcast_switch& cast_sw,                              \
+		sc_fxnum_observer* observer_ )                                \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( a.type_params(), qm, om ),                      \
+	    SC_TC_,                                                           \
+	    cast_sw,                                                          \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix::sc_fix( tp a,                                                         \
+		sc_q_mode qm, sc_o_mode om, int nb,                           \
+		const sc_fxcast_switch& cast_sw,                              \
+		sc_fxnum_observer* observer_ )                                \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( a.type_params(), qm, om, nb ),                  \
+	    SC_TC_,                                                           \
+	    cast_sw,                                                          \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix::sc_fix( tp a,                                                         \
+		int wl_, int iwl_, sc_q_mode qm, sc_o_mode om,                \
+		const sc_fxcast_switch& cast_sw,                              \
+		sc_fxnum_observer* observer_ )                                \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( wl_, iwl_, qm, om ),                            \
+	    SC_TC_,                                                           \
+	    cast_sw,                                                          \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix::sc_fix( tp a,                                                         \
+		int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb,        \
+		const sc_fxcast_switch& cast_sw,                              \
+		sc_fxnum_observer* observer_ )                                \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( wl_, iwl_, qm, om, nb ),                        \
+	    SC_TC_,                                                           \
+	    cast_sw,                                                          \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix::sc_fix( tp a,                                                         \
+		const sc_fxtype_params& type_params,                          \
+		sc_fxnum_observer* observer_ )                                \
+: sc_fxnum( a,                                                                \
+	    type_params,                                                      \
+	    SC_TC_,                                                           \
+	    sc_fxcast_switch(),                                               \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix::sc_fix( tp a,                                                         \
+		const sc_fxtype_params& type_params,                          \
+		const sc_fxcast_switch& cast_sw,                              \
+		sc_fxnum_observer* observer_ )                                \
+: sc_fxnum( a,                                                                \
+	    type_params,                                                      \
+	    SC_TC_,                                                           \
+	    cast_sw,                                                          \
+	    observer_ )                                                       \
+{}
+
+DEFN_CTORS_T_A(int)
+DEFN_CTORS_T_A(unsigned int)
+DEFN_CTORS_T_A(long)
+DEFN_CTORS_T_A(unsigned long)
+DEFN_CTORS_T_A(float)
+DEFN_CTORS_T_A(double)
+DEFN_CTORS_T_A(const char*)
+DEFN_CTORS_T_A(const sc_fxval&)
+DEFN_CTORS_T_A(const sc_fxval_fast&)
+DEFN_CTORS_T_B(const sc_fxnum&)
+DEFN_CTORS_T_B(const sc_fxnum_fast&)
+#ifndef SC_FX_EXCLUDE_OTHER
+DEFN_CTORS_T_A(int64)
+DEFN_CTORS_T_A(uint64)
+DEFN_CTORS_T_A(const sc_int_base&)
+DEFN_CTORS_T_A(const sc_uint_base&)
+DEFN_CTORS_T_A(const sc_signed&)
+DEFN_CTORS_T_A(const sc_unsigned&)
+#endif
+
+#undef DEFN_CTORS_T_A
+#undef DEFN_CTORS_T_B
+
+// copy constructor
+
+inline
+sc_fix::sc_fix( const sc_fix& a )
+: sc_fxnum( a,
+	    a.type_params(),
+	    SC_TC_,
+	    sc_fxcast_switch(),
+	    0 )
+{}
+
+
+// unary bitwise operators
+
+inline
+const sc_fix
+sc_fix::operator ~ () const
+{
+    SC_FXNUM_OBSERVER_READ_( *this )
+    int iwl_c = iwl();
+    int wl_c = wl();
+    sc_fix c( wl_c, iwl_c );
+    for( int i = iwl_c - wl_c; i < iwl_c; ++ i )
+	c.set_bit( i, ! get_bit( i ) );
+    return sc_fix( c, wl_c, iwl_c );
+}
+
+
+// unary bitwise functions
+
+inline
+void
+b_not( sc_fix& c, const sc_fix& a )
+{
+    SC_FXNUM_OBSERVER_READ_( a )
+    int iwl_c = c.iwl();
+    for( int i = iwl_c - c.wl(); i < iwl_c; ++ i )
+	c.set_bit( i, ! a.get_bit( i ) );
+    c.cast();
+    SC_FXNUM_OBSERVER_WRITE_( c )
+}
+
+
+// binary bitwise operators
+
+#define DEFN_BIN_OP_T(op,op2,tp1,tp2)                                         \
+inline                                                                        \
+const sc_fix                                                                  \
+operator op ( const tp1& a, const tp2& b )                                    \
+{                                                                             \
+    a.observer_read();                                                        \
+    b.observer_read();                                                        \
+    int iwl_a = a.iwl();                                                      \
+    int iwl_b = b.iwl();                                                      \
+    int iwl_c = sc_max( iwl_a, iwl_b );                              \
+    int fwl_c = sc_max( a.wl() - iwl_a, b.wl() - iwl_b );            \
+    sc_fix c( iwl_c + fwl_c, iwl_c );                                         \
+    for( int i = -fwl_c; i < iwl_c; ++ i )                                    \
+	c.set_bit( i, a.get_bit( i ) op2 b.get_bit( i ) );                    \
+    return sc_fix( c, iwl_c + fwl_c, iwl_c );                                 \
+}
+
+DEFN_BIN_OP_T(&,&&,sc_fix,sc_fix)
+DEFN_BIN_OP_T(&,&&,sc_fix,sc_fix_fast)
+DEFN_BIN_OP_T(&,&&,sc_fix_fast,sc_fix)
+
+DEFN_BIN_OP_T(|,||,sc_fix,sc_fix)
+DEFN_BIN_OP_T(|,||,sc_fix,sc_fix_fast)
+DEFN_BIN_OP_T(|,||,sc_fix_fast,sc_fix)
+
+DEFN_BIN_OP_T(^,!=,sc_fix,sc_fix)
+DEFN_BIN_OP_T(^,!=,sc_fix,sc_fix_fast)
+DEFN_BIN_OP_T(^,!=,sc_fix_fast,sc_fix)
+
+#undef DEFN_BIN_OP_T
+
+
+// binary bitwise functions
+
+#define DEFN_BIN_FNC_T(fnc,op2,tp1,tp2)                                       \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fix& c, const tp1& a, const tp2& b )                                 \
+{                                                                             \
+    a.observer_read();                                                        \
+    b.observer_read();                                                        \
+    int iwl_c = c.iwl();                                                      \
+    for( int i = iwl_c - c.wl(); i < iwl_c; ++ i )                            \
+	c.set_bit( i, a.get_bit( i ) op2 b.get_bit( i ) );                    \
+    c.cast();                                                                 \
+    SC_FXNUM_OBSERVER_WRITE_( c )                                             \
+}
+
+DEFN_BIN_FNC_T(b_and,&&,sc_fix,sc_fix)
+DEFN_BIN_FNC_T(b_and,&&,sc_fix,sc_fix_fast)
+DEFN_BIN_FNC_T(b_and,&&,sc_fix_fast,sc_fix)
+
+DEFN_BIN_FNC_T(b_or,||,sc_fix,sc_fix)
+DEFN_BIN_FNC_T(b_or,||,sc_fix,sc_fix_fast)
+DEFN_BIN_FNC_T(b_or,||,sc_fix_fast,sc_fix)
+
+DEFN_BIN_FNC_T(b_xor,!=,sc_fix,sc_fix)
+DEFN_BIN_FNC_T(b_xor,!=,sc_fix,sc_fix_fast)
+DEFN_BIN_FNC_T(b_xor,!=,sc_fix_fast,sc_fix)
+
+#undef DEFN_BIN_FNC_T
+
+
+// assignment operators
+
+inline
+sc_fix&
+sc_fix::operator = ( const sc_fix& a )
+{
+    sc_fxnum::operator = ( a );
+    return *this;
+}
+
+#define DEFN_ASN_OP_T(op,tp)                                                  \
+inline                                                                        \
+sc_fix&                                                                       \
+sc_fix::operator op ( tp a )                                                  \
+{                                                                             \
+    sc_fxnum::operator op( a );                                               \
+    return *this;                                                             \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_ASN_OP_OTHER(op)                                                 \
+DEFN_ASN_OP_T(op,int64)                                                       \
+DEFN_ASN_OP_T(op,uint64)                                                      \
+DEFN_ASN_OP_T(op,const sc_int_base&)                                          \
+DEFN_ASN_OP_T(op,const sc_uint_base&)                                         \
+DEFN_ASN_OP_T(op,const sc_signed&)                                            \
+DEFN_ASN_OP_T(op,const sc_unsigned&)
+#else
+#define DEFN_ASN_OP_OTHER(op)
+#endif
+
+#define DEFN_ASN_OP(op)                                                       \
+DEFN_ASN_OP_T(op,int)                                                         \
+DEFN_ASN_OP_T(op,unsigned int)                                                \
+DEFN_ASN_OP_T(op,long)                                                        \
+DEFN_ASN_OP_T(op,unsigned long)                                               \
+DEFN_ASN_OP_T(op,float)                                                      \
+DEFN_ASN_OP_T(op,double)                                                      \
+DEFN_ASN_OP_T(op,const char*)                                                 \
+DEFN_ASN_OP_T(op,const sc_fxval&)                                             \
+DEFN_ASN_OP_T(op,const sc_fxval_fast&)                                        \
+DEFN_ASN_OP_T(op,const sc_fxnum&)                                             \
+DEFN_ASN_OP_T(op,const sc_fxnum_fast&)                                        \
+DEFN_ASN_OP_OTHER(op)
+
+DEFN_ASN_OP(=)
+
+DEFN_ASN_OP(*=)
+DEFN_ASN_OP(/=)
+DEFN_ASN_OP(+=)
+DEFN_ASN_OP(-=)
+
+DEFN_ASN_OP_T(<<=,int)
+DEFN_ASN_OP_T(>>=,int)
+
+#undef DEFN_ASN_OP_T
+#undef DEFN_ASN_OP_OTHER
+#undef DEFN_ASN_OP
+
+
+#define DEFN_ASN_OP_T(op,op2,tp)                                              \
+inline                                                                        \
+sc_fix&                                                                       \
+sc_fix::operator op ( const tp& b )                                           \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( *this )                                          \
+    b.observer_read();                                                        \
+    int iwl_c = iwl();                                                        \
+    for( int i = iwl_c - wl(); i < iwl_c; ++ i )                              \
+	set_bit( i, get_bit( i ) op2 b.get_bit( i ) );                        \
+    cast();                                                                   \
+    SC_FXNUM_OBSERVER_WRITE_( *this )                                         \
+    return *this;                                                             \
+}
+
+DEFN_ASN_OP_T(&=,&&,sc_fix)
+DEFN_ASN_OP_T(&=,&&,sc_fix_fast)
+DEFN_ASN_OP_T(|=,||,sc_fix)
+DEFN_ASN_OP_T(|=,||,sc_fix_fast)
+DEFN_ASN_OP_T(^=,!=,sc_fix)
+DEFN_ASN_OP_T(^=,!=,sc_fix_fast)
+
+#undef DEFN_ASN_OP_T
+
+
+// auto-increment and auto-decrement
+
+inline
+const sc_fxval
+sc_fix::operator ++ ( int )
+{
+    return sc_fxval( sc_fxnum::operator ++ ( 0 ) );
+}
+
+inline
+const sc_fxval
+sc_fix::operator -- ( int )
+{
+    return sc_fxval( sc_fxnum::operator -- ( 0 ) );
+}
+
+inline
+sc_fix&
+sc_fix::operator ++ ()
+{
+    sc_fxnum::operator ++ ();
+    return *this;
+}
+
+inline
+sc_fix&
+sc_fix::operator -- ()
+{
+    sc_fxnum::operator -- ();
+    return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fix_fast
+//
+//  "Unconstrained" signed fixed-point class; limited precision.
+// ----------------------------------------------------------------------------
+
+// constructors
+
+inline
+sc_fix_fast::sc_fix_fast( sc_fxnum_fast_observer* observer_ )
+: sc_fxnum_fast( sc_fxtype_params(),
+		 SC_TC_,
+		 sc_fxcast_switch(),
+		 observer_ )
+{}
+
+inline
+sc_fix_fast::sc_fix_fast( int wl_, int iwl_,
+			  sc_fxnum_fast_observer* observer_ )
+: sc_fxnum_fast( sc_fxtype_params( wl_, iwl_ ),
+		 SC_TC_,
+		 sc_fxcast_switch(),
+		 observer_ )
+{}
+
+inline
+sc_fix_fast::sc_fix_fast( sc_q_mode qm, sc_o_mode om,
+			  sc_fxnum_fast_observer* observer_ )
+: sc_fxnum_fast( sc_fxtype_params( qm, om ),
+		 SC_TC_,
+		 sc_fxcast_switch(),
+		 observer_ )
+{}
+
+inline
+sc_fix_fast::sc_fix_fast( sc_q_mode qm, sc_o_mode om, int nb,
+			  sc_fxnum_fast_observer* observer_ )
+: sc_fxnum_fast( sc_fxtype_params( qm, om, nb ),
+		 SC_TC_,
+		 sc_fxcast_switch(),
+		 observer_ )
+{}
+
+inline
+sc_fix_fast::sc_fix_fast( int wl_, int iwl_, sc_q_mode qm, sc_o_mode om,
+			  sc_fxnum_fast_observer* observer_ )
+: sc_fxnum_fast( sc_fxtype_params( wl_, iwl_, qm, om ),
+		 SC_TC_,
+		 sc_fxcast_switch(),
+		 observer_ )
+{}
+
+inline
+sc_fix_fast::sc_fix_fast( int wl_, int iwl_,
+			  sc_q_mode qm, sc_o_mode om, int nb,
+			  sc_fxnum_fast_observer* observer_ )
+: sc_fxnum_fast( sc_fxtype_params( wl_, iwl_, qm, om, nb ),
+		 SC_TC_,
+		 sc_fxcast_switch(),
+		 observer_ )
+{}
+
+inline
+sc_fix_fast::sc_fix_fast( const sc_fxcast_switch& cast_sw,
+			  sc_fxnum_fast_observer* observer_ )
+: sc_fxnum_fast( sc_fxtype_params(),
+		 SC_TC_,
+		 cast_sw,
+		 observer_ )
+{}
+
+inline
+sc_fix_fast::sc_fix_fast( int wl_, int iwl_,
+			  const sc_fxcast_switch& cast_sw,
+			  sc_fxnum_fast_observer* observer_ )
+: sc_fxnum_fast( sc_fxtype_params( wl_, iwl_ ),
+		 SC_TC_,
+		 cast_sw,
+		 observer_ )
+{}
+
+inline
+sc_fix_fast::sc_fix_fast( sc_q_mode qm, sc_o_mode om,
+			  const sc_fxcast_switch& cast_sw,
+			  sc_fxnum_fast_observer* observer_ )
+: sc_fxnum_fast( sc_fxtype_params( qm, om ),
+		 SC_TC_,
+		 cast_sw,
+		 observer_ )
+{}
+
+inline
+sc_fix_fast::sc_fix_fast( sc_q_mode qm, sc_o_mode om, int nb,
+			  const sc_fxcast_switch& cast_sw,
+			  sc_fxnum_fast_observer* observer_ )
+: sc_fxnum_fast( sc_fxtype_params( qm, om, nb ),
+		 SC_TC_,
+		 cast_sw,
+		 observer_ )
+{}
+
+inline
+sc_fix_fast::sc_fix_fast( int wl_, int iwl_, sc_q_mode qm, sc_o_mode om,
+			  const sc_fxcast_switch& cast_sw,
+			  sc_fxnum_fast_observer* observer_ )
+: sc_fxnum_fast( sc_fxtype_params( wl_, iwl_, qm, om ),
+		 SC_TC_,
+		 cast_sw,
+		 observer_ )
+{}
+
+inline
+sc_fix_fast::sc_fix_fast( int wl_, int iwl_,
+			  sc_q_mode qm, sc_o_mode om, int nb,
+			  const sc_fxcast_switch& cast_sw,
+			  sc_fxnum_fast_observer* observer_ )
+: sc_fxnum_fast( sc_fxtype_params( wl_, iwl_, qm, om, nb ),
+		 SC_TC_,
+		 cast_sw,
+		 observer_ )
+{}
+
+inline
+sc_fix_fast::sc_fix_fast( const sc_fxtype_params& type_params,
+			  sc_fxnum_fast_observer* observer_ )
+: sc_fxnum_fast( type_params,
+		 SC_TC_,
+		 sc_fxcast_switch(),
+		 observer_ )
+{}
+
+inline
+sc_fix_fast::sc_fix_fast( const sc_fxtype_params& type_params,
+			  const sc_fxcast_switch& cast_sw,
+			  sc_fxnum_fast_observer* observer_ )
+: sc_fxnum_fast( type_params,
+		 SC_TC_,
+		 cast_sw,
+		 observer_ )
+{}
+
+#define DEFN_CTORS_T_A(tp)                                                    \
+inline                                                                        \
+sc_fix_fast::sc_fix_fast( tp a,                                               \
+			  sc_fxnum_fast_observer* observer_ )                 \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params(),                                          \
+		 SC_TC_,                                                      \
+		 sc_fxcast_switch(),                                          \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix_fast::sc_fix_fast( tp a,                                               \
+			  int wl_, int iwl_,                                  \
+			  sc_fxnum_fast_observer* observer_ )                 \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( wl_, iwl_ ),                               \
+		 SC_TC_,                                                      \
+		 sc_fxcast_switch(),                                          \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix_fast::sc_fix_fast( tp a,                                               \
+			  sc_q_mode qm, sc_o_mode om,                         \
+			  sc_fxnum_fast_observer* observer_ )                 \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( qm, om ),                                  \
+		 SC_TC_,                                                      \
+		 sc_fxcast_switch(),                                          \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix_fast::sc_fix_fast( tp a,                                               \
+			  sc_q_mode qm, sc_o_mode om, int nb,                 \
+			  sc_fxnum_fast_observer* observer_ )                 \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( qm, om, nb ),                              \
+		 SC_TC_,                                                      \
+		 sc_fxcast_switch(),                                          \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix_fast::sc_fix_fast( tp a,                                               \
+			  int wl_, int iwl_, sc_q_mode qm, sc_o_mode om,      \
+			  sc_fxnum_fast_observer* observer_ )                 \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( wl_, iwl_, qm, om ),                       \
+		 SC_TC_,                                                      \
+		 sc_fxcast_switch(),                                          \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix_fast::sc_fix_fast( tp a,                                               \
+			  int wl_, int iwl_,                                  \
+			  sc_q_mode qm, sc_o_mode om, int nb,                 \
+			  sc_fxnum_fast_observer* observer_ )                 \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( wl_, iwl_, qm, om, nb ),                   \
+		 SC_TC_,                                                      \
+		 sc_fxcast_switch(),                                          \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix_fast::sc_fix_fast( tp a,                                               \
+			  const sc_fxcast_switch& cast_sw,                    \
+			  sc_fxnum_fast_observer* observer_ )                 \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params(),                                          \
+		 SC_TC_,                                                      \
+		 cast_sw,                                                     \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix_fast::sc_fix_fast( tp a,                                               \
+			  int wl_, int iwl_,                                  \
+			  const sc_fxcast_switch& cast_sw,                    \
+			  sc_fxnum_fast_observer* observer_ )                 \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( wl_, iwl_ ),                               \
+		 SC_TC_,                                                      \
+		 cast_sw,                                                     \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix_fast::sc_fix_fast( tp a,                                               \
+			  sc_q_mode qm, sc_o_mode om,                         \
+			  const sc_fxcast_switch& cast_sw,                    \
+			  sc_fxnum_fast_observer* observer_ )                 \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( qm, om ),                                  \
+		 SC_TC_,                                                      \
+		 cast_sw,                                                     \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix_fast::sc_fix_fast( tp a,                                               \
+			  sc_q_mode qm, sc_o_mode om, int nb,                 \
+			  const sc_fxcast_switch& cast_sw,                    \
+			  sc_fxnum_fast_observer* observer_ )                 \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( qm, om, nb ),                              \
+		 SC_TC_,                                                      \
+		 cast_sw,                                                     \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix_fast::sc_fix_fast( tp a,                                               \
+			  int wl_, int iwl_, sc_q_mode qm, sc_o_mode om,      \
+			  const sc_fxcast_switch& cast_sw,                    \
+			  sc_fxnum_fast_observer* observer_ )                 \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( wl_, iwl_, qm, om ),                       \
+		 SC_TC_,                                                      \
+		 cast_sw,                                                     \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix_fast::sc_fix_fast( tp a,                                               \
+			  int wl_, int iwl_,                                  \
+			  sc_q_mode qm, sc_o_mode om, int nb,                 \
+			  const sc_fxcast_switch& cast_sw,                    \
+			  sc_fxnum_fast_observer* observer_ )                 \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( wl_, iwl_, qm, om, nb ),                   \
+		 SC_TC_,                                                      \
+		 cast_sw,                                                     \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix_fast::sc_fix_fast( tp a,                                               \
+			  const sc_fxtype_params& type_params,                \
+			  sc_fxnum_fast_observer* observer_ )                 \
+: sc_fxnum_fast( a,                                                           \
+		 type_params,                                                 \
+		 SC_TC_,                                                      \
+		 sc_fxcast_switch(),                                          \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix_fast::sc_fix_fast( tp a,                                               \
+			  const sc_fxtype_params& type_params,                \
+			  const sc_fxcast_switch& cast_sw,                    \
+			  sc_fxnum_fast_observer* observer_ )                 \
+: sc_fxnum_fast( a,                                                           \
+		 type_params,                                                 \
+		 SC_TC_,                                                      \
+		 cast_sw,                                                     \
+		 observer_ )                                                  \
+{}
+
+#define DEFN_CTORS_T_B(tp)                                                    \
+inline                                                                        \
+sc_fix_fast::sc_fix_fast( tp a,                                               \
+			  sc_fxnum_fast_observer* observer_ )                 \
+: sc_fxnum_fast( a,                                                           \
+		 a.type_params(),                                             \
+		 SC_TC_,                                                      \
+		 sc_fxcast_switch(),                                          \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix_fast::sc_fix_fast( tp a,                                               \
+			  int wl_, int iwl_,                                  \
+			  sc_fxnum_fast_observer* observer_ )                 \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( a.type_params(), wl_, iwl_ ),              \
+		 SC_TC_,                                                      \
+		 sc_fxcast_switch(),                                          \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix_fast::sc_fix_fast( tp a,                                               \
+			  sc_q_mode qm, sc_o_mode om,                         \
+			  sc_fxnum_fast_observer* observer_ )                 \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( a.type_params(), qm, om ),                 \
+		 SC_TC_,                                                      \
+		 sc_fxcast_switch(),                                          \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix_fast::sc_fix_fast( tp a,                                               \
+			  sc_q_mode qm, sc_o_mode om, int nb,                 \
+			  sc_fxnum_fast_observer* observer_ )                 \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( a.type_params(), qm, om, nb ),             \
+		 SC_TC_,                                                      \
+		 sc_fxcast_switch(),                                          \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix_fast::sc_fix_fast( tp a,                                               \
+			  int wl_, int iwl_, sc_q_mode qm, sc_o_mode om,      \
+			  sc_fxnum_fast_observer* observer_ )                 \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( wl_, iwl_, qm, om ),                       \
+		 SC_TC_,                                                      \
+		 sc_fxcast_switch(),                                          \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix_fast::sc_fix_fast( tp a,                                               \
+			  int wl_, int iwl_,                                  \
+			  sc_q_mode qm, sc_o_mode om, int nb,                 \
+			  sc_fxnum_fast_observer* observer_ )                 \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( wl_, iwl_, qm, om, nb ),                   \
+		 SC_TC_,                                                      \
+		 sc_fxcast_switch(),                                          \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix_fast::sc_fix_fast( tp a,                                               \
+			  const sc_fxcast_switch& cast_sw,                    \
+			  sc_fxnum_fast_observer* observer_ )                 \
+: sc_fxnum_fast( a,                                                           \
+		 a.type_params(),                                             \
+		 SC_TC_,                                                      \
+		 cast_sw,                                                     \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix_fast::sc_fix_fast( tp a,                                               \
+			  int wl_, int iwl_,                                  \
+			  const sc_fxcast_switch& cast_sw,                    \
+			  sc_fxnum_fast_observer* observer_ )                 \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( a.type_params(), wl_, iwl_ ),              \
+		 SC_TC_,                                                      \
+		 cast_sw,                                                     \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix_fast::sc_fix_fast( tp a,                                               \
+			  sc_q_mode qm, sc_o_mode om,                         \
+			  const sc_fxcast_switch& cast_sw,                    \
+			  sc_fxnum_fast_observer* observer_ )                 \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( a.type_params(), qm, om ),                 \
+		 SC_TC_,                                                      \
+		 cast_sw,                                                     \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix_fast::sc_fix_fast( tp a,                                               \
+			  sc_q_mode qm, sc_o_mode om, int nb,                 \
+			  const sc_fxcast_switch& cast_sw,                    \
+			  sc_fxnum_fast_observer* observer_ )                 \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( a.type_params(), qm, om, nb ),             \
+		 SC_TC_,                                                      \
+		 cast_sw,                                                     \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix_fast::sc_fix_fast( tp a,                                               \
+			  int wl_, int iwl_, sc_q_mode qm, sc_o_mode om,      \
+			  const sc_fxcast_switch& cast_sw,                    \
+			  sc_fxnum_fast_observer* observer_ )                 \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( wl_, iwl_, qm, om ),                       \
+		 SC_TC_,                                                      \
+		 cast_sw,                                                     \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix_fast::sc_fix_fast( tp a,                                               \
+			  int wl_, int iwl_,                                  \
+			  sc_q_mode qm, sc_o_mode om, int nb,                 \
+			  const sc_fxcast_switch& cast_sw,                    \
+			  sc_fxnum_fast_observer* observer_ )                 \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( wl_, iwl_, qm, om, nb ),                   \
+		 SC_TC_,                                                      \
+		 cast_sw,                                                     \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix_fast::sc_fix_fast( tp a,                                               \
+			  const sc_fxtype_params& type_params,                \
+			  sc_fxnum_fast_observer* observer_ )                 \
+: sc_fxnum_fast( a,                                                           \
+		 type_params,                                                 \
+		 SC_TC_,                                                      \
+		 sc_fxcast_switch(),                                          \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_fix_fast::sc_fix_fast( tp a,                                               \
+			  const sc_fxtype_params& type_params,                \
+			  const sc_fxcast_switch& cast_sw,                    \
+			  sc_fxnum_fast_observer* observer_ )                 \
+: sc_fxnum_fast( a,                                                           \
+		 type_params,                                                 \
+		 SC_TC_,                                                      \
+		 cast_sw,                                                     \
+		 observer_ )                                                  \
+{}
+
+DEFN_CTORS_T_A(int)
+DEFN_CTORS_T_A(unsigned int)
+DEFN_CTORS_T_A(long)
+DEFN_CTORS_T_A(unsigned long)
+DEFN_CTORS_T_A(float)
+DEFN_CTORS_T_A(double)
+DEFN_CTORS_T_A(const char*)
+DEFN_CTORS_T_A(const sc_fxval&)
+DEFN_CTORS_T_A(const sc_fxval_fast&)
+DEFN_CTORS_T_B(const sc_fxnum&)
+DEFN_CTORS_T_B(const sc_fxnum_fast&)
+#ifndef SC_FX_EXCLUDE_OTHER
+DEFN_CTORS_T_A(int64)
+DEFN_CTORS_T_A(uint64)
+DEFN_CTORS_T_A(const sc_int_base&)
+DEFN_CTORS_T_A(const sc_uint_base&)
+DEFN_CTORS_T_A(const sc_signed&)
+DEFN_CTORS_T_A(const sc_unsigned&)
+#endif
+
+#undef DEFN_CTORS_T_A
+#undef DEFN_CTORS_T_B
+
+// copy constructor
+
+inline
+sc_fix_fast::sc_fix_fast( const sc_fix_fast& a )
+: sc_fxnum_fast( a,
+		 a.type_params(),
+		 SC_TC_,
+		 sc_fxcast_switch(),
+		 0 )
+{}
+
+
+// unary bitwise operators
+
+inline
+const sc_fix_fast
+sc_fix_fast::operator ~ () const
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )
+    int iwl_c = iwl();
+    int wl_c = wl();
+    sc_fix_fast c( wl_c, iwl_c );
+    for( int i = iwl_c - wl_c; i < iwl_c; ++ i )
+	c.set_bit( i, ! get_bit( i ) );
+    return sc_fix_fast( c, wl_c, iwl_c );
+}
+
+
+// unary bitwise functions
+
+inline
+void
+b_not( sc_fix_fast& c, const sc_fix_fast& a )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( a )
+    int iwl_c = c.iwl();
+    for( int i = iwl_c - c.wl(); i < iwl_c; ++ i )
+	c.set_bit( i, ! a.get_bit( i ) );
+    c.cast();
+    SC_FXNUM_FAST_OBSERVER_WRITE_( c )
+}
+
+
+// binary bitwise operators
+
+#define DEFN_BIN_OP_T(op,op2,tp1,tp2)                                         \
+inline                                                                        \
+const sc_fix_fast                                                             \
+operator op ( const tp1& a, const tp2& b )                                    \
+{                                                                             \
+    a.observer_read();                                                        \
+    b.observer_read();                                                        \
+    int iwl_a = a.iwl();                                                      \
+    int iwl_b = b.iwl();                                                      \
+    int iwl_c = sc_max( iwl_a, iwl_b );                              \
+    int fwl_c = sc_max( a.wl() - iwl_a, b.wl() - iwl_b );            \
+    sc_fix_fast c( iwl_c + fwl_c, iwl_c );                                    \
+    for( int i = -fwl_c; i < iwl_c; ++ i )                                    \
+	c.set_bit( i, a.get_bit( i ) op2 b.get_bit( i ) );                    \
+    return sc_fix_fast( c, iwl_c + fwl_c, iwl_c );                            \
+}
+
+DEFN_BIN_OP_T(&,&&,sc_fix_fast,sc_fix_fast)
+DEFN_BIN_OP_T(|,||,sc_fix_fast,sc_fix_fast)
+DEFN_BIN_OP_T(^,!=,sc_fix_fast,sc_fix_fast)
+
+#undef DEFN_BIN_OP_T
+
+
+// binary bitwise functions
+
+#define DEFN_BIN_FNC_T(fnc,op2,tp1,tp2)                                       \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fix_fast& c, const tp1& a, const tp2& b )                            \
+{                                                                             \
+    a.observer_read();                                                        \
+    b.observer_read();                                                        \
+    int iwl_c = c.iwl();                                                      \
+    for( int i = iwl_c - c.wl(); i < iwl_c; ++ i )                            \
+	c.set_bit( i, a.get_bit( i ) op2 b.get_bit( i ) );                    \
+    c.cast();                                                                 \
+    SC_FXNUM_FAST_OBSERVER_WRITE_( c )                                        \
+}
+
+DEFN_BIN_FNC_T(b_and,&&,sc_fix_fast,sc_fix_fast)
+DEFN_BIN_FNC_T(b_or,||,sc_fix_fast,sc_fix_fast)
+DEFN_BIN_FNC_T(b_xor,!=,sc_fix_fast,sc_fix_fast)
+
+#undef DEFN_BIN_FNC_T
+
+
+// assignment operators
+
+inline
+sc_fix_fast&
+sc_fix_fast::operator = ( const sc_fix_fast& a )
+{
+    sc_fxnum_fast::operator = ( a );
+    return *this;
+}
+
+#define DEFN_ASN_OP_T(op,tp)                                                  \
+inline                                                                        \
+sc_fix_fast&                                                                  \
+sc_fix_fast::operator op ( tp a )                                             \
+{                                                                             \
+    sc_fxnum_fast::operator op( a );                                          \
+    return *this;                                                             \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_ASN_OP_OTHER(op)                                                 \
+DEFN_ASN_OP_T(op,int64)                                                       \
+DEFN_ASN_OP_T(op,uint64)                                                      \
+DEFN_ASN_OP_T(op,const sc_int_base&)                                          \
+DEFN_ASN_OP_T(op,const sc_uint_base&)                                         \
+DEFN_ASN_OP_T(op,const sc_signed&)                                            \
+DEFN_ASN_OP_T(op,const sc_unsigned&)
+#else
+#define DEFN_ASN_OP_OTHER(op)
+#endif
+
+#define DEFN_ASN_OP(op)                                                       \
+DEFN_ASN_OP_T(op,int)                                                         \
+DEFN_ASN_OP_T(op,unsigned int)                                                \
+DEFN_ASN_OP_T(op,long)                                                        \
+DEFN_ASN_OP_T(op,unsigned long)                                               \
+DEFN_ASN_OP_T(op,float)                                                      \
+DEFN_ASN_OP_T(op,double)                                                      \
+DEFN_ASN_OP_T(op,const char*)                                                 \
+DEFN_ASN_OP_T(op,const sc_fxval&)                                             \
+DEFN_ASN_OP_T(op,const sc_fxval_fast&)                                        \
+DEFN_ASN_OP_T(op,const sc_fxnum&)                                             \
+DEFN_ASN_OP_T(op,const sc_fxnum_fast&)                                        \
+DEFN_ASN_OP_OTHER(op)
+
+DEFN_ASN_OP(=)
+
+DEFN_ASN_OP(*=)
+DEFN_ASN_OP(/=)
+DEFN_ASN_OP(+=)
+DEFN_ASN_OP(-=)
+
+DEFN_ASN_OP_T(<<=,int)
+DEFN_ASN_OP_T(>>=,int)
+
+#undef DEFN_ASN_OP_T
+#undef DEFN_ASN_OP_OTHER
+#undef DEFN_ASN_OP
+
+
+#define DEFN_ASN_OP_T(op,op2,tp)                                              \
+inline                                                                        \
+sc_fix_fast&                                                                  \
+sc_fix_fast::operator op ( const tp& b )                                      \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )                                     \
+    b.observer_read();                                                        \
+    int iwl_c = iwl();                                                        \
+    for( int i = iwl_c - wl(); i < iwl_c; ++ i )                              \
+	set_bit( i, get_bit( i ) op2 b.get_bit( i ) );                        \
+    cast();                                                                   \
+    SC_FXNUM_FAST_OBSERVER_WRITE_( *this )                                    \
+    return *this;                                                             \
+}
+
+DEFN_ASN_OP_T(&=,&&,sc_fix)
+DEFN_ASN_OP_T(&=,&&,sc_fix_fast)
+DEFN_ASN_OP_T(|=,||,sc_fix)
+DEFN_ASN_OP_T(|=,||,sc_fix_fast)
+DEFN_ASN_OP_T(^=,!=,sc_fix)
+DEFN_ASN_OP_T(^=,!=,sc_fix_fast)
+
+#undef DEFN_ASN_OP_T
+
+
+// auto-increment and auto-decrement
+
+inline
+const sc_fxval_fast
+sc_fix_fast::operator ++ ( int )
+{
+    return sc_fxval_fast( sc_fxnum_fast::operator ++ ( 0 ) );
+}
+
+inline
+const sc_fxval_fast
+sc_fix_fast::operator -- ( int )
+{
+    return sc_fxval_fast( sc_fxnum_fast::operator -- ( 0 ) );
+}
+
+inline
+sc_fix_fast&
+sc_fix_fast::operator ++ ()
+{
+    sc_fxnum_fast::operator ++ ();
+    return *this;
+}
+
+inline
+sc_fix_fast&
+sc_fix_fast::operator -- ()
+{
+    sc_fxnum_fast::operator -- ();
+    return *this;
+}
+
+} // namespace sc_dt
+
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/sc_fixed.h b/ext/systemc/src/sysc/datatypes/fx/sc_fixed.h
new file mode 100644
index 000000000..b885da1f9
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/sc_fixed.h
@@ -0,0 +1,660 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_fixed.h - 
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_fixed.h,v $
+// Revision 1.2  2011/01/19 18:57:40  acg
+//  Andy Goodrich: changes for IEEE_1666_2011.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:57  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SC_FIXED_H
+#define SC_FIXED_H
+
+
+#include "sysc/datatypes/fx/sc_fix.h"
+
+
+namespace sc_dt
+{
+
+// classes defined in this module
+template <int W, int I, sc_q_mode Q, sc_o_mode O, int N> class sc_fixed;
+template <int W, int I, sc_q_mode Q, sc_o_mode O, int N> class sc_fixed_fast;
+
+
+// ----------------------------------------------------------------------------
+//  TEMPLATE CLASS : sc_fixed
+//
+//  "Constrained" signed fixed-point class; arbitrary precision.
+// ----------------------------------------------------------------------------
+
+template <int W, int I,
+	  sc_q_mode Q = SC_DEFAULT_Q_MODE_,
+	  sc_o_mode O = SC_DEFAULT_O_MODE_, int N = SC_DEFAULT_N_BITS_>
+class sc_fixed : public sc_fix
+{
+
+public:
+
+    // constructors
+
+    explicit sc_fixed( sc_fxnum_observer* = 0 );
+    explicit sc_fixed( const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
+
+#define DECL_CTORS_T_A(tp)                                                    \
+             sc_fixed( tp, sc_fxnum_observer* = 0 );                          \
+             sc_fixed( tp, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
+
+#define DECL_CTORS_T_B(tp)                                                    \
+    explicit sc_fixed( tp, sc_fxnum_observer* = 0 );                          \
+             sc_fixed( tp, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
+
+    DECL_CTORS_T_A(int)
+    DECL_CTORS_T_A(unsigned int)
+    DECL_CTORS_T_A(long)
+    DECL_CTORS_T_A(unsigned long)
+    DECL_CTORS_T_A(float)
+    DECL_CTORS_T_A(double)
+    DECL_CTORS_T_A(const char*)
+    DECL_CTORS_T_A(const sc_fxval&)
+    DECL_CTORS_T_A(const sc_fxval_fast&)
+    DECL_CTORS_T_A(const sc_fxnum&)
+    DECL_CTORS_T_A(const sc_fxnum_fast&)
+#ifndef SC_FX_EXCLUDE_OTHER
+    DECL_CTORS_T_B(int64)
+    DECL_CTORS_T_B(uint64)
+    DECL_CTORS_T_B(const sc_int_base&)
+    DECL_CTORS_T_B(const sc_uint_base&)
+    DECL_CTORS_T_B(const sc_signed&)
+    DECL_CTORS_T_B(const sc_unsigned&)
+#endif
+
+#undef DECL_CTORS_T_A
+#undef DECL_CTORS_T_B
+
+    // copy constructor
+
+    sc_fixed( const sc_fixed<W,I,Q,O,N>& );
+
+
+    // assignment operators
+
+    sc_fixed& operator = ( const sc_fixed<W,I,Q,O,N>& );
+
+#define DECL_ASN_OP_T(op,tp)                                                  \
+    sc_fixed& operator op ( tp );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_ASN_OP_OTHER(op)                                                 \
+    DECL_ASN_OP_T(op,int64)                                                   \
+    DECL_ASN_OP_T(op,uint64)                                                  \
+    DECL_ASN_OP_T(op,const sc_int_base&)                                      \
+    DECL_ASN_OP_T(op,const sc_uint_base&)                                     \
+    DECL_ASN_OP_T(op,const sc_signed&)                                        \
+    DECL_ASN_OP_T(op,const sc_unsigned&)
+#else
+#define DECL_ASN_OP_OTHER(op)
+#endif
+
+#define DECL_ASN_OP(op)                                                       \
+    DECL_ASN_OP_T(op,int)                                                     \
+    DECL_ASN_OP_T(op,unsigned int)                                            \
+    DECL_ASN_OP_T(op,long)                                                    \
+    DECL_ASN_OP_T(op,unsigned long)                                           \
+    DECL_ASN_OP_T(op,float)                                                  \
+    DECL_ASN_OP_T(op,double)                                                  \
+    DECL_ASN_OP_T(op,const char*)                                             \
+    DECL_ASN_OP_T(op,const sc_fxval&)                                         \
+    DECL_ASN_OP_T(op,const sc_fxval_fast&)                                    \
+    DECL_ASN_OP_T(op,const sc_fxnum&)                                         \
+    DECL_ASN_OP_T(op,const sc_fxnum_fast&)                                    \
+    DECL_ASN_OP_OTHER(op)
+
+    DECL_ASN_OP(=)
+
+    DECL_ASN_OP(*=)
+    DECL_ASN_OP(/=)
+    DECL_ASN_OP(+=)
+    DECL_ASN_OP(-=)
+
+    DECL_ASN_OP_T(<<=,int)
+    DECL_ASN_OP_T(>>=,int)
+
+    DECL_ASN_OP_T(&=,const sc_fix&)
+    DECL_ASN_OP_T(&=,const sc_fix_fast&)
+    DECL_ASN_OP_T(|=,const sc_fix&)
+    DECL_ASN_OP_T(|=,const sc_fix_fast&)
+    DECL_ASN_OP_T(^=,const sc_fix&)
+    DECL_ASN_OP_T(^=,const sc_fix_fast&)
+
+#undef DECL_ASN_OP_T
+#undef DECL_ASN_OP_OTHER
+#undef DECL_ASN_OP
+
+
+    // auto-increment and auto-decrement
+
+    const sc_fxval operator ++ ( int );
+    const sc_fxval operator -- ( int );
+
+    sc_fixed& operator ++ ();
+    sc_fixed& operator -- ();
+
+};
+
+
+// ----------------------------------------------------------------------------
+//  TEMPLATE CLASS : sc_fixed_fast
+//
+//  "Constrained" signed fixed-point class; limited precision.
+// ----------------------------------------------------------------------------
+
+template <int W, int I,
+	  sc_q_mode Q = SC_DEFAULT_Q_MODE_,
+	  sc_o_mode O = SC_DEFAULT_O_MODE_, int N = SC_DEFAULT_N_BITS_>
+class sc_fixed_fast : public sc_fix_fast
+{
+
+public:
+
+    // constructors
+
+    explicit sc_fixed_fast( sc_fxnum_fast_observer* = 0 );
+    explicit sc_fixed_fast( const sc_fxcast_switch&,
+			    sc_fxnum_fast_observer* = 0 );
+
+#define DECL_CTORS_T_A(tp)                                                    \
+             sc_fixed_fast( tp, sc_fxnum_fast_observer* = 0 );                \
+             sc_fixed_fast( tp, const sc_fxcast_switch&,                      \
+                            sc_fxnum_fast_observer* = 0 );
+
+#define DECL_CTORS_T_B(tp)                                                    \
+    explicit sc_fixed_fast( tp, sc_fxnum_fast_observer* = 0 );                \
+             sc_fixed_fast( tp, const sc_fxcast_switch&,                      \
+                            sc_fxnum_fast_observer* = 0 );
+
+    DECL_CTORS_T_A(int)
+    DECL_CTORS_T_A(unsigned int)
+    DECL_CTORS_T_A(long)
+    DECL_CTORS_T_A(unsigned long)
+    DECL_CTORS_T_A(float)
+    DECL_CTORS_T_A(double)
+    DECL_CTORS_T_A(const char*)
+    DECL_CTORS_T_A(const sc_fxval&)
+    DECL_CTORS_T_A(const sc_fxval_fast&)
+    DECL_CTORS_T_A(const sc_fxnum&)
+    DECL_CTORS_T_A(const sc_fxnum_fast&)
+#ifndef SC_FX_EXCLUDE_OTHER
+    DECL_CTORS_T_B(int64)
+    DECL_CTORS_T_B(uint64)
+    DECL_CTORS_T_B(const sc_int_base&)
+    DECL_CTORS_T_B(const sc_uint_base&)
+    DECL_CTORS_T_B(const sc_signed&)
+    DECL_CTORS_T_B(const sc_unsigned&)
+#endif
+
+#undef DECL_CTORS_T_A
+#undef DECL_CTORS_T_B
+
+    // copy constructor
+
+    sc_fixed_fast( const sc_fixed_fast<W,I,Q,O,N>& );
+
+
+    // assignment operators
+
+    sc_fixed_fast& operator = ( const sc_fixed_fast<W,I,Q,O,N>& );
+
+#define DECL_ASN_OP_T(op,tp)                                                  \
+    sc_fixed_fast& operator op ( tp );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_ASN_OP_OTHER(op)                                                 \
+    DECL_ASN_OP_T(op,int64)                                                   \
+    DECL_ASN_OP_T(op,uint64)                                                  \
+    DECL_ASN_OP_T(op,const sc_int_base&)                                      \
+    DECL_ASN_OP_T(op,const sc_uint_base&)                                     \
+    DECL_ASN_OP_T(op,const sc_signed&)                                        \
+    DECL_ASN_OP_T(op,const sc_unsigned&)
+#else
+#define DECL_ASN_OP_OTHER(op)
+#endif
+
+#define DECL_ASN_OP(op)                                                       \
+    DECL_ASN_OP_T(op,int)                                                     \
+    DECL_ASN_OP_T(op,unsigned int)                                            \
+    DECL_ASN_OP_T(op,long)                                                    \
+    DECL_ASN_OP_T(op,unsigned long)                                           \
+    DECL_ASN_OP_T(op,float)                                                  \
+    DECL_ASN_OP_T(op,double)                                                  \
+    DECL_ASN_OP_T(op,const char*)                                             \
+    DECL_ASN_OP_T(op,const sc_fxval&)                                         \
+    DECL_ASN_OP_T(op,const sc_fxval_fast&)                                    \
+    DECL_ASN_OP_T(op,const sc_fxnum&)                                         \
+    DECL_ASN_OP_T(op,const sc_fxnum_fast&)                                    \
+    DECL_ASN_OP_OTHER(op)
+
+    DECL_ASN_OP(=)
+
+    DECL_ASN_OP(*=)
+    DECL_ASN_OP(/=)
+    DECL_ASN_OP(+=)
+    DECL_ASN_OP(-=)
+
+    DECL_ASN_OP_T(<<=,int)
+    DECL_ASN_OP_T(>>=,int)
+
+    DECL_ASN_OP_T(&=,const sc_fix&)
+    DECL_ASN_OP_T(&=,const sc_fix_fast&)
+    DECL_ASN_OP_T(|=,const sc_fix&)
+    DECL_ASN_OP_T(|=,const sc_fix_fast&)
+    DECL_ASN_OP_T(^=,const sc_fix&)
+    DECL_ASN_OP_T(^=,const sc_fix_fast&)
+
+#undef DECL_ASN_OP_T
+#undef DECL_ASN_OP_OTHER
+#undef DECL_ASN_OP
+
+
+    // auto-increment and auto-decrement
+
+    const sc_fxval_fast operator ++ ( int );
+    const sc_fxval_fast operator -- ( int );
+
+    sc_fixed_fast& operator ++ ();
+    sc_fixed_fast& operator -- ();
+
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+// ----------------------------------------------------------------------------
+//  TEMPLATE CLASS : sc_fixed
+//
+//  "Constrained" signed fixed-point class; arbitrary precision.
+// ----------------------------------------------------------------------------
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+sc_fixed<W,I,Q,O,N>::sc_fixed( sc_fxnum_observer* observer_ )
+: sc_fix( W, I, Q, O, N, observer_ )
+{}
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+sc_fixed<W,I,Q,O,N>::sc_fixed( const sc_fxcast_switch& cast_sw,
+			       sc_fxnum_observer* observer_ )
+: sc_fix( W, I, Q, O, N, cast_sw, observer_ )
+{}
+
+#define DEFN_CTORS_T(tp)                                                      \
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>                       \
+inline                                                                        \
+sc_fixed<W,I,Q,O,N>::sc_fixed( tp a,                                          \
+			       sc_fxnum_observer* observer_ )                 \
+: sc_fix( a, W, I, Q, O, N, observer_ )                                       \
+{}                                                                            \
+                                                                              \
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>                       \
+inline                                                                        \
+sc_fixed<W,I,Q,O,N>::sc_fixed( tp a,                                          \
+			       const sc_fxcast_switch& cast_sw,               \
+			       sc_fxnum_observer* observer_ )                 \
+: sc_fix( a, W, I, Q, O, N, cast_sw, observer_ )                              \
+{}
+
+DEFN_CTORS_T(int)
+DEFN_CTORS_T(unsigned int)
+DEFN_CTORS_T(long)
+DEFN_CTORS_T(unsigned long)
+DEFN_CTORS_T(float)
+DEFN_CTORS_T(double)
+DEFN_CTORS_T(const char*)
+DEFN_CTORS_T(const sc_fxval&)
+DEFN_CTORS_T(const sc_fxval_fast&)
+DEFN_CTORS_T(const sc_fxnum&)
+DEFN_CTORS_T(const sc_fxnum_fast&)
+#ifndef SC_FX_EXCLUDE_OTHER
+DEFN_CTORS_T(int64)
+DEFN_CTORS_T(uint64)
+DEFN_CTORS_T(const sc_int_base&)
+DEFN_CTORS_T(const sc_uint_base&)
+DEFN_CTORS_T(const sc_signed&)
+DEFN_CTORS_T(const sc_unsigned&)
+#endif
+
+#undef DEFN_CTORS_T
+
+// copy constructor
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+sc_fixed<W,I,Q,O,N>::sc_fixed( const sc_fixed<W,I,Q,O,N>& a )
+: sc_fix( a, W, I, Q, O, N )
+{}
+
+
+// assignment operators
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+sc_fixed<W,I,Q,O,N>&
+sc_fixed<W,I,Q,O,N>::operator = ( const sc_fixed<W,I,Q,O,N>& a )
+{
+    sc_fix::operator = ( a );
+    return *this;
+}
+
+#define DEFN_ASN_OP_T(op,tp)                                                  \
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>                       \
+inline                                                                        \
+sc_fixed<W,I,Q,O,N>&                                                          \
+sc_fixed<W,I,Q,O,N>::operator op ( tp a )                                     \
+{                                                                             \
+    sc_fix::operator op ( a );                                                \
+    return *this;                                                             \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_ASN_OP_OTHER(op)                                                 \
+DEFN_ASN_OP_T(op,int64)                                                       \
+DEFN_ASN_OP_T(op,uint64)                                                      \
+DEFN_ASN_OP_T(op,const sc_int_base&)                                          \
+DEFN_ASN_OP_T(op,const sc_uint_base&)                                         \
+DEFN_ASN_OP_T(op,const sc_signed&)                                            \
+DEFN_ASN_OP_T(op,const sc_unsigned&)
+#else
+#define DEFN_ASN_OP_OTHER(op)
+#endif
+
+#define DEFN_ASN_OP(op)                                                       \
+DEFN_ASN_OP_T(op,int)                                                         \
+DEFN_ASN_OP_T(op,unsigned int)                                                \
+DEFN_ASN_OP_T(op,long)                                                        \
+DEFN_ASN_OP_T(op,unsigned long)                                               \
+DEFN_ASN_OP_T(op,float)                                                      \
+DEFN_ASN_OP_T(op,double)                                                      \
+DEFN_ASN_OP_T(op,const char*)                                                 \
+DEFN_ASN_OP_T(op,const sc_fxval&)                                             \
+DEFN_ASN_OP_T(op,const sc_fxval_fast&)                                        \
+DEFN_ASN_OP_T(op,const sc_fxnum&)                                             \
+DEFN_ASN_OP_T(op,const sc_fxnum_fast&)                                        \
+DEFN_ASN_OP_OTHER(op)
+
+DEFN_ASN_OP(=)
+
+DEFN_ASN_OP(*=)
+DEFN_ASN_OP(/=)
+DEFN_ASN_OP(+=)
+DEFN_ASN_OP(-=)
+
+DEFN_ASN_OP_T(<<=,int)
+DEFN_ASN_OP_T(>>=,int)
+
+DEFN_ASN_OP_T(&=,const sc_fix&)
+DEFN_ASN_OP_T(&=,const sc_fix_fast&)
+DEFN_ASN_OP_T(|=,const sc_fix&)
+DEFN_ASN_OP_T(|=,const sc_fix_fast&)
+DEFN_ASN_OP_T(^=,const sc_fix&)
+DEFN_ASN_OP_T(^=,const sc_fix_fast&)
+
+#undef DEFN_ASN_OP_T
+#undef DEFN_ASN_OP_OTHER
+#undef DEFN_ASN_OP
+
+
+// auto-increment and auto-decrement
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+const sc_fxval
+sc_fixed<W,I,Q,O,N>::operator ++ ( int )
+{
+    return sc_fxval( sc_fix::operator ++ ( 0 ) );
+}
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+const sc_fxval
+sc_fixed<W,I,Q,O,N>::operator -- ( int )
+{
+    return sc_fxval( sc_fix::operator -- ( 0 ) );
+}
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+sc_fixed<W,I,Q,O,N>&
+sc_fixed<W,I,Q,O,N>::operator ++ ()
+{
+    sc_fix::operator ++ ();
+    return *this;
+}
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+sc_fixed<W,I,Q,O,N>&
+sc_fixed<W,I,Q,O,N>::operator -- ()
+{
+    sc_fix::operator -- ();
+    return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+//  TEMPLATE CLASS : sc_fixed_fast
+//
+//  "Constrained" signed fixed-point class; limited precision.
+// ----------------------------------------------------------------------------
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( sc_fxnum_fast_observer* observer_ )
+: sc_fix_fast( W, I, Q, O, N, observer_ )
+{}
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( const sc_fxcast_switch& cast_sw,
+					 sc_fxnum_fast_observer* observer_ )
+: sc_fix_fast( W, I, Q, O, N, cast_sw, observer_ )
+{}
+
+#define DEFN_CTORS_T(tp)                                                      \
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>                       \
+inline                                                                        \
+sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( tp a,                                \
+					 sc_fxnum_fast_observer* observer_ )  \
+: sc_fix_fast( a, W, I, Q, O, N, observer_ )                                  \
+{}                                                                            \
+                                                                              \
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>                       \
+inline                                                                        \
+sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( tp a,                                \
+					 const sc_fxcast_switch& cast_sw,     \
+					 sc_fxnum_fast_observer* observer_ )  \
+: sc_fix_fast( a, W, I, Q, O, N, cast_sw, observer_ )                         \
+{}
+
+DEFN_CTORS_T(int)
+DEFN_CTORS_T(unsigned int)
+DEFN_CTORS_T(long)
+DEFN_CTORS_T(unsigned long)
+DEFN_CTORS_T(float)
+DEFN_CTORS_T(double)
+DEFN_CTORS_T(const char*)
+DEFN_CTORS_T(const sc_fxval&)
+DEFN_CTORS_T(const sc_fxval_fast&)
+DEFN_CTORS_T(const sc_fxnum&)
+DEFN_CTORS_T(const sc_fxnum_fast&)
+#ifndef SC_FX_EXCLUDE_OTHER
+DEFN_CTORS_T(int64)
+DEFN_CTORS_T(uint64)
+DEFN_CTORS_T(const sc_int_base&)
+DEFN_CTORS_T(const sc_uint_base&)
+DEFN_CTORS_T(const sc_signed&)
+DEFN_CTORS_T(const sc_unsigned&)
+#endif
+
+#undef DEFN_CTORS_T
+
+// copy constructor
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( const sc_fixed_fast<W,I,Q,O,N>& a )
+: sc_fix_fast( a, W, I, Q, O, N )
+{}
+
+
+// assignment operators
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+sc_fixed_fast<W,I,Q,O,N>&
+sc_fixed_fast<W,I,Q,O,N>::operator = ( const sc_fixed_fast<W,I,Q,O,N>& a )
+{
+    sc_fix_fast::operator = ( a );
+    return *this;
+}
+
+#define DEFN_ASN_OP_T(op,tp)                                                  \
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>                       \
+inline                                                                        \
+sc_fixed_fast<W,I,Q,O,N>&                                                     \
+sc_fixed_fast<W,I,Q,O,N>::operator op ( tp a )                                \
+{                                                                             \
+    sc_fix_fast::operator op ( a );                                           \
+    return *this;                                                             \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_ASN_OP_OTHER(op)                                                 \
+DEFN_ASN_OP_T(op,int64)                                                       \
+DEFN_ASN_OP_T(op,uint64)                                                      \
+DEFN_ASN_OP_T(op,const sc_int_base&)                                          \
+DEFN_ASN_OP_T(op,const sc_uint_base&)                                         \
+DEFN_ASN_OP_T(op,const sc_signed&)                                            \
+DEFN_ASN_OP_T(op,const sc_unsigned&)
+#else
+#define DEFN_ASN_OP_OTHER(op)
+#endif
+
+#define DEFN_ASN_OP(op)                                                       \
+DEFN_ASN_OP_T(op,int)                                                         \
+DEFN_ASN_OP_T(op,unsigned int)                                                \
+DEFN_ASN_OP_T(op,long)                                                        \
+DEFN_ASN_OP_T(op,unsigned long)                                               \
+DEFN_ASN_OP_T(op,float)                                                      \
+DEFN_ASN_OP_T(op,double)                                                      \
+DEFN_ASN_OP_T(op,const char*)                                                 \
+DEFN_ASN_OP_T(op,const sc_fxval&)                                             \
+DEFN_ASN_OP_T(op,const sc_fxval_fast&)                                        \
+DEFN_ASN_OP_T(op,const sc_fxnum&)                                             \
+DEFN_ASN_OP_T(op,const sc_fxnum_fast&)                                        \
+DEFN_ASN_OP_OTHER(op)
+
+DEFN_ASN_OP(=)
+
+DEFN_ASN_OP(*=)
+DEFN_ASN_OP(/=)
+DEFN_ASN_OP(+=)
+DEFN_ASN_OP(-=)
+
+DEFN_ASN_OP_T(<<=,int)
+DEFN_ASN_OP_T(>>=,int)
+
+DEFN_ASN_OP_T(&=,const sc_fix&)
+DEFN_ASN_OP_T(&=,const sc_fix_fast&)
+DEFN_ASN_OP_T(|=,const sc_fix&)
+DEFN_ASN_OP_T(|=,const sc_fix_fast&)
+DEFN_ASN_OP_T(^=,const sc_fix&)
+DEFN_ASN_OP_T(^=,const sc_fix_fast&)
+
+#undef DEFN_ASN_OP_T
+#undef DEFN_ASN_OP_OTHER
+#undef DEFN_ASN_OP
+
+
+// auto-increment and auto-decrement
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+const sc_fxval_fast
+sc_fixed_fast<W,I,Q,O,N>::operator ++ ( int )
+{
+    return sc_fxval_fast( sc_fix_fast::operator ++ ( 0 ) );
+}
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+const sc_fxval_fast
+sc_fixed_fast<W,I,Q,O,N>::operator -- ( int )
+{
+    return sc_fxval_fast( sc_fix_fast::operator -- ( 0 ) );
+}
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+sc_fixed_fast<W,I,Q,O,N>&
+sc_fixed_fast<W,I,Q,O,N>::operator ++ ()
+{
+    sc_fix_fast::operator ++ ();
+    return *this;
+}
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+sc_fixed_fast<W,I,Q,O,N>&
+sc_fixed_fast<W,I,Q,O,N>::operator -- ()
+{
+    sc_fix_fast::operator -- ();
+    return *this;
+}
+
+} // namespace sc_dt
+
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/sc_fx_ids.h b/ext/systemc/src/sysc/datatypes/fx/sc_fx_ids.h
new file mode 100644
index 000000000..b40c2dc48
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/sc_fx_ids.h
@@ -0,0 +1,96 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_fx_ids.h -- Report ids for the datatypes/fx code.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2002-01-17
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+    
+ *****************************************************************************/
+
+// $Log: sc_fx_ids.h,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:57  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SC_FX_IDS_H
+#define SC_FX_IDS_H
+
+
+#include "sysc/utils/sc_report.h"
+
+
+// ----------------------------------------------------------------------------
+//  Report ids (datatypes/fx)
+//
+//  Report ids in the range of 300-399.
+// ----------------------------------------------------------------------------
+
+#ifndef SC_DEFINE_MESSAGE
+#define SC_DEFINE_MESSAGE(id,unused1,unused2) \
+    namespace sc_core { extern const char id[]; }
+namespace sc_core {
+    extern const char SC_ID_REGISTER_ID_FAILED_[]; // in sc_report_handler.cpp
+}
+#endif
+
+
+SC_DEFINE_MESSAGE( SC_ID_INVALID_WL_, 300,
+	"total wordlength <= 0 is not valid" )
+SC_DEFINE_MESSAGE( SC_ID_INVALID_N_BITS_, 301,
+	"number of bits < 0 is not valid" )
+SC_DEFINE_MESSAGE( SC_ID_INVALID_DIV_WL_, 302,
+	"division wordlength <= 0 is not valid" )
+SC_DEFINE_MESSAGE( SC_ID_INVALID_CTE_WL_, 303,
+	"constant wordlength <= 0 is not valid" )
+SC_DEFINE_MESSAGE( SC_ID_INVALID_MAX_WL_, 304,
+	"maximum wordlength <= 0 and != -1 is not valid" )
+SC_DEFINE_MESSAGE( SC_ID_INVALID_FX_VALUE_, 305,
+    "invalid fixed-point value" )
+SC_DEFINE_MESSAGE( SC_ID_INVALID_O_MODE_, 306,
+	"invalid overflow mode" )
+SC_DEFINE_MESSAGE( SC_ID_OUT_OF_RANGE_, 307,
+	"index out of range" )
+SC_DEFINE_MESSAGE( SC_ID_CONTEXT_BEGIN_FAILED_, 308,
+	"context begin failed" )  
+SC_DEFINE_MESSAGE( SC_ID_CONTEXT_END_FAILED_, 309, 
+	"context end failed" )
+SC_DEFINE_MESSAGE( SC_ID_WRAP_SM_NOT_DEFINED_, 310, 
+	"SC_WRAP_SM not defined for unsigned numbers" )
+
+
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/sc_fxcast_switch.cpp b/ext/systemc/src/sysc/datatypes/fx/sc_fxcast_switch.cpp
new file mode 100644
index 000000000..c5c5a939c
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/sc_fxcast_switch.cpp
@@ -0,0 +1,88 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_fxcast_switch.cpp - 
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Gene Bushuyev, Synopsys, Inc.
+  Description of Modification: - fix explicit instantiation syntax.
+    
+      Name, Affiliation, Date:
+  Description of Modification: 
+
+ *****************************************************************************/
+
+
+// $Log: sc_fxcast_switch.cpp,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:57  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include "sysc/datatypes/fx/sc_fxcast_switch.h"
+
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxcast_switch
+//
+//  Fixed-point cast switch class.
+// ----------------------------------------------------------------------------
+
+const std::string
+sc_fxcast_switch::to_string() const
+{
+    return sc_dt::to_string( m_sw );
+}
+
+
+void
+sc_fxcast_switch::print( ::std::ostream& os ) const
+{
+    os << sc_dt::to_string( m_sw );
+}
+
+void
+sc_fxcast_switch::dump( ::std::ostream& os ) const
+{
+    os << "sc_fxcast_switch" << ::std::endl;
+    os << "(" << ::std::endl;
+    os << "sw = " << sc_dt::to_string( m_sw ) << ::std::endl;
+    os << ")" << ::std::endl;
+}
+
+} // namespace sc_dt
+
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/sc_fxcast_switch.h b/ext/systemc/src/sysc/datatypes/fx/sc_fxcast_switch.h
new file mode 100644
index 000000000..6bfbd25a4
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/sc_fxcast_switch.h
@@ -0,0 +1,174 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_fxcast_switch.h - 
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_fxcast_switch.h,v $
+// Revision 1.2  2011/08/24 22:05:43  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:57  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SC_FXCAST_SWITCH_H
+#define SC_FXCAST_SWITCH_H
+
+
+#include "sysc/datatypes/fx/sc_context.h"
+
+
+namespace sc_dt
+{
+
+// classes defined in this module
+class sc_fxcast_switch;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxcast_switch
+//
+//  Fixed-point cast switch class.
+// ----------------------------------------------------------------------------
+
+class sc_fxcast_switch
+{
+
+public:
+
+             sc_fxcast_switch();
+             sc_fxcast_switch( sc_switch );
+             sc_fxcast_switch( const sc_fxcast_switch& );
+    explicit sc_fxcast_switch( sc_without_context );
+
+    sc_fxcast_switch& operator = ( const sc_fxcast_switch& );
+
+    friend bool operator == ( const sc_fxcast_switch&,
+			      const sc_fxcast_switch& );
+    friend bool operator != ( const sc_fxcast_switch&,
+			      const sc_fxcast_switch& );
+
+    const std::string to_string() const;
+
+    void print( ::std::ostream& = ::std::cout ) const;
+    void dump( ::std::ostream& = ::std::cout ) const;
+
+private:
+
+    sc_switch m_sw;
+
+};
+
+
+// ----------------------------------------------------------------------------
+//  TYPEDEF : sc_fxcast_context
+//
+//  Context type for the fixed-point cast switch parameter.
+// ----------------------------------------------------------------------------
+
+typedef sc_context<sc_fxcast_switch> sc_fxcast_context;
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+inline
+sc_fxcast_switch::sc_fxcast_switch() 
+: m_sw()
+{
+    *this = sc_fxcast_context::default_value();
+}
+
+inline
+sc_fxcast_switch::sc_fxcast_switch( sc_switch sw_ )
+: m_sw( sw_ )
+{}
+
+inline
+sc_fxcast_switch::sc_fxcast_switch( const sc_fxcast_switch& a )
+: m_sw( a.m_sw )
+{}
+
+inline
+sc_fxcast_switch::sc_fxcast_switch( sc_without_context )
+: m_sw( SC_DEFAULT_CAST_SWITCH_ )
+{}
+
+
+inline
+sc_fxcast_switch&
+sc_fxcast_switch::operator = ( const sc_fxcast_switch& a )
+{
+    if( &a != this )
+    {
+        m_sw = a.m_sw;
+    }
+    return *this;
+}
+
+
+inline
+bool
+operator == ( const sc_fxcast_switch& a, const sc_fxcast_switch& b )
+{
+    return ( a.m_sw == b.m_sw );
+}
+
+
+inline
+bool
+operator != ( const sc_fxcast_switch& a, const sc_fxcast_switch& b )
+{
+    return ( a.m_sw != b.m_sw );
+}
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_fxcast_switch& a )
+{
+    a.print( os );
+    return os;
+}
+
+} // namespace sc_dt
+
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/sc_fxdefs.cpp b/ext/systemc/src/sysc/datatypes/fx/sc_fxdefs.cpp
new file mode 100644
index 000000000..66ade2076
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/sc_fxdefs.cpp
@@ -0,0 +1,175 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_fxdefs.cpp - 
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_fxdefs.cpp,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:57  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include "sysc/datatypes/fx/sc_fxdefs.h"
+
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  ENUM : sc_enc
+//
+//  Enumeration of sign encodings.
+// ----------------------------------------------------------------------------
+
+const std::string
+to_string( sc_enc enc )
+{
+    switch( enc )
+    {
+        case SC_TC_:
+            return std::string( "SC_TC_" );
+        case SC_US_:
+            return std::string( "SC_US_" );
+	default:
+	    return std::string( "unknown" );
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  ENUM : sc_q_mode
+//
+//  Enumeration of quantization modes.
+// ----------------------------------------------------------------------------
+
+const std::string
+to_string( sc_q_mode q_mode )
+{
+    switch( q_mode )
+    {
+        case SC_RND:
+            return std::string( "SC_RND" );
+        case SC_RND_ZERO:
+            return std::string( "SC_RND_ZERO" );
+        case SC_RND_MIN_INF:
+            return std::string( "SC_RND_MIN_INF" );
+        case SC_RND_INF:
+            return std::string( "SC_RND_INF" );
+        case SC_RND_CONV:
+            return std::string( "SC_RND_CONV" );
+        case SC_TRN:
+            return std::string( "SC_TRN" );
+        case SC_TRN_ZERO:
+            return std::string( "SC_TRN_ZERO" );
+	default:
+	    return std::string( "unknown" );
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  ENUM : sc_o_mode
+//
+//  Enumeration of overflow modes.
+// ----------------------------------------------------------------------------
+
+const std::string
+to_string( sc_o_mode o_mode )
+{
+    switch( o_mode )
+    {
+        case SC_SAT:
+            return std::string( "SC_SAT" );
+        case SC_SAT_ZERO:
+            return std::string( "SC_SAT_ZERO" );
+        case SC_SAT_SYM:
+            return std::string( "SC_SAT_SYM" );
+        case SC_WRAP:
+            return std::string( "SC_WRAP" );
+        case SC_WRAP_SM:
+            return std::string( "SC_WRAP_SM" );
+	default:
+	    return std::string( "unknown" );
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  ENUM : sc_switch
+//
+//  Enumeration of switch states.
+// ----------------------------------------------------------------------------
+
+const std::string
+to_string( sc_switch sw )
+{
+    switch( sw ) {
+        case SC_OFF:
+            return std::string( "SC_OFF" );
+        case SC_ON:
+            return std::string( "SC_ON" );
+	default:
+	    return std::string( "unknown" );
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  ENUM : sc_fmt
+//
+//  Enumeration of formats for character string conversion.
+// ----------------------------------------------------------------------------
+
+const std::string
+to_string( sc_fmt fmt )
+{
+    switch( fmt ) {
+        case SC_F:
+            return std::string( "SC_F" );
+        case SC_E:
+            return std::string( "SC_E" );
+	default:
+	    return std::string( "unknown" );
+    }
+}
+
+} // namespace sc_dt
+
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/sc_fxdefs.h b/ext/systemc/src/sysc/datatypes/fx/sc_fxdefs.h
new file mode 100644
index 000000000..1ac1bb707
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/sc_fxdefs.h
@@ -0,0 +1,308 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_fxdefs.h - 
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_fxdefs.h,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:57  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SC_FXDEFS_H
+#define SC_FXDEFS_H
+
+
+#include "sysc/utils/sc_machine.h"
+#include "sysc/datatypes/fx/sc_fx_ids.h"
+#include "sysc/datatypes/int/sc_nbutils.h"
+
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  ENUM : sc_enc
+//
+//  Enumeration of sign encodings.
+// ----------------------------------------------------------------------------
+
+enum sc_enc
+{
+    SC_TC_,	// two's complement
+    SC_US_	// unsigned
+};
+
+
+const std::string to_string( sc_enc );
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, sc_enc enc )
+{
+    return os << to_string( enc );
+}
+
+
+// ----------------------------------------------------------------------------
+//  ENUM : sc_q_mode
+//
+//  Enumeration of quantization modes.
+// ----------------------------------------------------------------------------
+
+enum sc_q_mode
+{
+    SC_RND,		// rounding to plus infinity
+    SC_RND_ZERO,	// rounding to zero
+    SC_RND_MIN_INF,	// rounding to minus infinity
+    SC_RND_INF,		// rounding to infinity
+    SC_RND_CONV,	// convergent rounding
+    SC_TRN,		// truncation
+    SC_TRN_ZERO		// truncation to zero
+};
+
+
+const std::string to_string( sc_q_mode );
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, sc_q_mode q_mode )
+{
+    return os << to_string( q_mode );
+}
+
+
+// ----------------------------------------------------------------------------
+//  ENUM : sc_o_mode
+//
+//  Enumeration of overflow modes.
+// ----------------------------------------------------------------------------
+
+enum sc_o_mode
+{
+    SC_SAT,		// saturation
+    SC_SAT_ZERO,	// saturation to zero
+    SC_SAT_SYM,		// symmetrical saturation
+    SC_WRAP,		// wrap-around (*)
+    SC_WRAP_SM		// sign magnitude wrap-around (*)
+};
+
+// (*) uses the number of saturated bits argument, see the documentation.
+
+
+const std::string to_string( sc_o_mode );
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, sc_o_mode o_mode )
+{
+    return os << to_string( o_mode );
+}
+
+
+// ----------------------------------------------------------------------------
+//  ENUM : sc_switch
+//
+//  Enumeration of switch states.
+// ----------------------------------------------------------------------------
+
+enum sc_switch
+{
+    SC_OFF,
+    SC_ON
+};
+
+
+const std::string to_string( sc_switch );
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, sc_switch sw )
+{
+    return os << to_string( sw );
+}
+
+
+// ----------------------------------------------------------------------------
+//  ENUM : sc_fmt
+//
+//  Enumeration of formats for character string conversion.
+// ----------------------------------------------------------------------------
+
+enum sc_fmt
+{
+    SC_F,	// fixed
+    SC_E	// scientific
+};
+
+
+const std::string to_string( sc_fmt );
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, sc_fmt fmt )
+{
+    return os << to_string( fmt );
+}
+
+
+// ----------------------------------------------------------------------------
+//  Built-in & default fixed-point type parameter values.
+// ----------------------------------------------------------------------------
+
+const int       SC_BUILTIN_WL_     = 32;
+const int       SC_BUILTIN_IWL_    = 32;
+const sc_q_mode SC_BUILTIN_Q_MODE_ = SC_TRN;
+const sc_o_mode SC_BUILTIN_O_MODE_ = SC_WRAP;
+const int       SC_BUILTIN_N_BITS_ = 0;
+
+
+const int       SC_DEFAULT_WL_     = SC_BUILTIN_WL_;
+const int       SC_DEFAULT_IWL_    = SC_BUILTIN_IWL_;
+const sc_q_mode SC_DEFAULT_Q_MODE_ = SC_BUILTIN_Q_MODE_;
+const sc_o_mode SC_DEFAULT_O_MODE_ = SC_BUILTIN_O_MODE_;
+const int       SC_DEFAULT_N_BITS_ = SC_BUILTIN_N_BITS_;
+
+
+// ----------------------------------------------------------------------------
+//  Built-in & default fixed-point cast switch parameter values.
+// ----------------------------------------------------------------------------
+
+const sc_switch SC_BUILTIN_CAST_SWITCH_ = SC_ON;
+
+
+const sc_switch SC_DEFAULT_CAST_SWITCH_ = SC_BUILTIN_CAST_SWITCH_;
+
+
+// ----------------------------------------------------------------------------
+//  Built-in & default fixed-point value type parameter values.
+// ----------------------------------------------------------------------------
+
+const int SC_BUILTIN_DIV_WL_ = 64;
+const int SC_BUILTIN_CTE_WL_ = 64;
+const int SC_BUILTIN_MAX_WL_ = 1024;
+
+
+#if defined( SC_FXDIV_WL ) && ( SC_FXDIV_WL > 0 )
+const int SC_DEFAULT_DIV_WL_ = SC_FXDIV_WL;
+#else
+const int SC_DEFAULT_DIV_WL_ = SC_BUILTIN_DIV_WL_;
+#endif
+
+#if defined( SC_FXCTE_WL ) && ( SC_FXCTE_WL > 0 )
+const int SC_DEFAULT_CTE_WL_ = SC_FXCTE_WL;
+#else
+const int SC_DEFAULT_CTE_WL_ = SC_BUILTIN_CTE_WL_;
+#endif
+
+#if defined( SC_FXMAX_WL ) && ( SC_FXMAX_WL > 0 || SC_FXMAX_WL == -1 )
+const int SC_DEFAULT_MAX_WL_ = SC_FXMAX_WL;
+#else
+const int SC_DEFAULT_MAX_WL_ = SC_BUILTIN_MAX_WL_;
+#endif
+
+
+// ----------------------------------------------------------------------------
+//  Dedicated error reporting and checking.
+// ----------------------------------------------------------------------------
+
+#ifdef DEBUG_SYSTEMC
+#define SC_ASSERT_(cnd,msg)                                                   \
+{                                                                             \
+    if( ! (cnd) )                                                             \
+        SC_REPORT_ERROR( sc_core::SC_ID_INTERNAL_ERROR_, msg );                        \
+}
+#else
+#define SC_ASSERT_(cnd,msg)
+#endif
+
+#define SC_ERROR_IF_(cnd,id)                                                  \
+{                                                                             \
+    if( cnd )                                                                 \
+        SC_REPORT_ERROR( id, 0 );                                             \
+}
+
+
+#define SC_CHECK_WL_(wl)                                                      \
+    SC_ERROR_IF_( (wl) <= 0, sc_core::SC_ID_INVALID_WL_ )
+
+#define SC_CHECK_N_BITS_(n_bits)                                              \
+    SC_ERROR_IF_( (n_bits) < 0, sc_core::SC_ID_INVALID_N_BITS_ )
+
+#define SC_CHECK_DIV_WL_(div_wl)                                              \
+    SC_ERROR_IF_( (div_wl) <= 0, sc_core::SC_ID_INVALID_DIV_WL_ )
+
+#define SC_CHECK_CTE_WL_(cte_wl)                                              \
+    SC_ERROR_IF_( (cte_wl) <= 0, sc_core::SC_ID_INVALID_CTE_WL_ )
+
+#define SC_CHECK_MAX_WL_(max_wl)                                              \
+    SC_ERROR_IF_( (max_wl) <= 0 && (max_wl) != -1,                            \
+	    sc_core::SC_ID_INVALID_MAX_WL_ )
+
+
+// ----------------------------------------------------------------------------
+//  Generic observer macros.
+// ----------------------------------------------------------------------------
+
+#define SC_OBSERVER_(object,observer_type,event)                              \
+{                                                                             \
+    if( (object).observer() != 0 )                                            \
+    {                                                                         \
+	observer_type observer = (object).lock_observer();                    \
+	observer->event( (object) );                                          \
+	(object).unlock_observer( observer );                                 \
+    }                                                                         \
+}
+
+#define SC_OBSERVER_DEFAULT_(observer_type)                                   \
+{                                                                             \
+    if( m_observer == 0 && observer_type ## ::default_observer != 0 )         \
+        m_observer = (* ## observer_type ## ::default_observer)();            \
+}
+
+} // namespace sc_dt
+
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/sc_fxnum.cpp b/ext/systemc/src/sysc/datatypes/fx/sc_fxnum.cpp
new file mode 100644
index 000000000..520c41854
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/sc_fxnum.cpp
@@ -0,0 +1,958 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_fxnum.cpp - 
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_fxnum.cpp,v $
+// Revision 1.3  2011/01/19 18:57:40  acg
+//  Andy Goodrich: changes for IEEE_1666_2011.
+//
+// Revision 1.2  2010/12/07 20:09:08  acg
+// Andy Goodrich: Philipp Hartmann's constructor disambiguation fix
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:57  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include <math.h>
+
+#include "sysc/datatypes/fx/sc_fxnum.h"
+
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum_bitref
+//
+//  Proxy class for bit-selection in class sc_fxnum, behaves like sc_bit.
+// ----------------------------------------------------------------------------
+
+bool
+sc_fxnum_bitref::get() const
+{
+    return m_num.get_bit( m_idx );
+}
+
+void
+sc_fxnum_bitref::set( bool high )
+{
+    m_num.set_bit( m_idx, high );
+}
+
+
+// print or dump content
+
+void
+sc_fxnum_bitref::print( ::std::ostream& os ) const
+{
+    os << get();
+}
+
+void
+sc_fxnum_bitref::scan( ::std::istream& is )
+{
+    bool b;
+    is >> b;
+    *this = b;
+}
+
+void
+sc_fxnum_bitref::dump( ::std::ostream& os ) const
+{
+    os << "sc_fxnum_bitref" << ::std::endl;
+    os << "(" << ::std::endl;
+    os << "num = ";
+    m_num.dump( os );
+    os << "idx = " << m_idx << ::std::endl;
+    os << ")" << ::std::endl;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum_fast_bitref
+//
+//  Proxy class for bit-selection in class sc_fxnum_fast, behaves like sc_bit.
+// ----------------------------------------------------------------------------
+
+bool
+sc_fxnum_fast_bitref::get() const
+{
+    return m_num.get_bit( m_idx );
+}
+
+void
+sc_fxnum_fast_bitref::set( bool high )
+{
+    m_num.set_bit( m_idx, high );
+}
+
+
+// print or dump content
+
+void
+sc_fxnum_fast_bitref::print( ::std::ostream& os ) const
+{
+    os << get();
+}
+
+void
+sc_fxnum_fast_bitref::scan( ::std::istream& is )
+{
+    bool b;
+    is >> b;
+    *this = b;
+}
+
+void
+sc_fxnum_fast_bitref::dump( ::std::ostream& os ) const
+{
+    os << "sc_fxnum_fast_bitref" << ::std::endl;
+    os << "(" << ::std::endl;
+    os << "num = ";
+    m_num.dump( os );
+    os << "idx = " << m_idx << ::std::endl;
+    os << ")" << ::std::endl;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum_subref
+//
+//  Proxy class for part-selection in class sc_fxnum,
+//  behaves like sc_bv_base.
+// ----------------------------------------------------------------------------
+
+bool
+sc_fxnum_subref::get() const
+{
+    return m_num.get_slice( m_from, m_to, m_bv );
+}
+
+bool
+sc_fxnum_subref::set()
+{
+    return m_num.set_slice( m_from, m_to, m_bv );
+}
+
+
+// print or dump content
+
+void
+sc_fxnum_subref::print( ::std::ostream& os ) const
+{
+    get();
+    m_bv.print( os );
+}
+
+void
+sc_fxnum_subref::scan( ::std::istream& is )
+{
+    m_bv.scan( is );
+    set();
+}
+
+void
+sc_fxnum_subref::dump( ::std::ostream& os ) const
+{
+    os << "sc_fxnum_subref" << ::std::endl;
+    os << "(" << ::std::endl;
+    os << "num  = ";
+    m_num.dump( os );
+    os << "from = " << m_from << ::std::endl;
+    os << "to   = " << m_to << ::std::endl;
+    os << ")" << ::std::endl;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum_fast_subref
+//
+//  Proxy class for part-selection in class sc_fxnum_fast,
+//  behaves like sc_bv_base.
+// ----------------------------------------------------------------------------
+
+bool
+sc_fxnum_fast_subref::get() const
+{
+    return m_num.get_slice( m_from, m_to, m_bv );
+}
+
+bool
+sc_fxnum_fast_subref::set()
+{
+    return m_num.set_slice( m_from, m_to, m_bv );
+}
+
+
+// print or dump content
+
+void
+sc_fxnum_fast_subref::print( ::std::ostream& os ) const
+{
+    get();
+    m_bv.print( os );
+}
+
+void
+sc_fxnum_fast_subref::scan( ::std::istream& is )
+{
+    m_bv.scan( is );
+    set();
+}
+
+void
+sc_fxnum_fast_subref::dump( ::std::ostream& os ) const
+{
+    os << "sc_fxnum_fast_subref" << ::std::endl;
+    os << "(" << ::std::endl;
+    os << "num  = ";
+    m_num.dump( os );
+    os << "from = " << m_from << ::std::endl;
+    os << "to   = " << m_to << ::std::endl;
+    os << ")" << ::std::endl;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum
+//
+//  Base class for the fixed-point types; arbitrary precision.
+// ----------------------------------------------------------------------------
+
+// explicit conversion to character string
+
+const std::string
+sc_fxnum::to_string() const
+{
+    return std::string( m_rep->to_string( SC_DEC, -1, SC_F, &m_params ) );
+}
+
+const std::string
+sc_fxnum::to_string( sc_numrep numrep ) const
+{
+    return std::string( m_rep->to_string( numrep, -1, SC_F, &m_params ) );
+}
+
+const std::string
+sc_fxnum::to_string( sc_numrep numrep, bool w_prefix ) const
+{
+    return std::string( m_rep->to_string( numrep, (w_prefix ? 1 : 0),
+					SC_F, &m_params ) );
+}
+
+const std::string
+sc_fxnum::to_string( sc_fmt fmt ) const
+{
+    return std::string( m_rep->to_string( SC_DEC, -1, fmt, &m_params ) );
+}
+
+const std::string
+sc_fxnum::to_string( sc_numrep numrep, sc_fmt fmt ) const
+{
+    return std::string( m_rep->to_string( numrep, -1, fmt, &m_params ) );
+}
+
+const std::string
+sc_fxnum::to_string( sc_numrep numrep, bool w_prefix, sc_fmt fmt ) const
+{
+    return std::string( m_rep->to_string( numrep, (w_prefix ? 1 : 0),
+					fmt, &m_params ) );
+}
+
+
+const std::string
+sc_fxnum::to_dec() const
+{
+    return std::string( m_rep->to_string( SC_DEC, -1, SC_F, &m_params ) );
+}
+
+const std::string
+sc_fxnum::to_bin() const
+{
+    return std::string( m_rep->to_string( SC_BIN, -1, SC_F, &m_params ) );
+}
+
+const std::string
+sc_fxnum::to_oct() const
+{
+    return std::string( m_rep->to_string( SC_OCT, -1, SC_F, &m_params ) );
+}
+
+const std::string
+sc_fxnum::to_hex() const
+{
+    return std::string( m_rep->to_string( SC_HEX, -1, SC_F, &m_params ) );
+}
+
+
+// print or dump content
+
+void
+sc_fxnum::print( ::std::ostream& os ) const
+{
+    os << m_rep->to_string( SC_DEC, -1, SC_F, &m_params );
+}
+
+void
+sc_fxnum::scan( ::std::istream& is )
+{
+    std::string s;
+    is >> s;
+    *this = s.c_str();
+}
+
+void
+sc_fxnum::dump( ::std::ostream& os ) const
+{
+    os << "sc_fxnum" << ::std::endl;
+    os << "(" << ::std::endl;
+    os << "rep      = ";
+    m_rep->dump( os );
+    os << "params   = ";
+    m_params.dump( os );
+    os << "q_flag   = " << m_q_flag << ::std::endl;
+    os << "o_flag   = " << m_o_flag << ::std::endl;
+    // TO BE COMPLETED
+    // os << "observer = ";
+    // if( m_observer != 0 )
+    //     m_observer->dump( os );
+    // else
+    //     os << "0" << ::std::endl;
+    os << ")" << ::std::endl;
+}
+
+
+sc_fxnum_observer*
+sc_fxnum::lock_observer() const
+{
+    SC_ASSERT_( m_observer != 0, "lock observer failed" );
+    sc_fxnum_observer* tmp = m_observer;
+    m_observer = 0;
+    return tmp;
+}
+
+void
+sc_fxnum::unlock_observer( sc_fxnum_observer* observer_ ) const
+{
+    SC_ASSERT_( observer_ != 0, "unlock observer failed" );
+    m_observer = observer_;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum_fast
+//
+//  Base class for the fixed-point types; limited precision.
+// ----------------------------------------------------------------------------
+
+static
+void
+quantization( double& c, const scfx_params& params, bool& q_flag )
+{
+    int fwl = params.wl() - params.iwl();
+    double scale = scfx_pow2( fwl );
+    double val = scale * c;
+    double int_part;
+    double frac_part = modf( val, &int_part );
+
+    q_flag = ( frac_part != 0.0 );
+
+    if( q_flag )
+    {
+        val = int_part;
+
+	switch( params.q_mode() )
+	{
+            case SC_TRN:			// truncation
+	    {
+	        if( c < 0.0 )
+		    val -= 1.0;
+		break;
+	    }
+            case SC_RND:			// rounding to plus infinity
+	    {
+		if( frac_part >= 0.5 )
+		    val += 1.0;
+		else if( frac_part < -0.5 )
+		    val -= 1.0;
+		break;
+	    }
+            case SC_TRN_ZERO:			// truncation to zero
+	    {
+	        break;
+	    }
+            case SC_RND_INF:			// rounding to infinity
+	    {
+		if( frac_part >= 0.5 )
+		    val += 1.0;
+		else if( frac_part <= -0.5 )
+		    val -= 1.0;
+		break;
+	    }
+            case SC_RND_CONV:			// convergent rounding
+	    {
+		if( frac_part > 0.5 ||
+		    ( frac_part == 0.5 && fmod( int_part, 2.0 ) != 0.0 ) )
+		    val += 1.0;
+		else if( frac_part < -0.5 ||
+			 ( frac_part == -0.5 && fmod( int_part, 2.0 ) != 0.0 ) )
+		    val -= 1.0;
+		break;
+	    }
+            case SC_RND_ZERO:			// rounding to zero
+	    {
+		if( frac_part > 0.5 )
+		    val += 1.0;
+		else if( frac_part < -0.5 )
+		    val -= 1.0;
+		break;
+	    }
+            case SC_RND_MIN_INF:		// rounding to minus infinity
+	    {
+		if( frac_part > 0.5 )
+		    val += 1.0;
+		else if( frac_part <= -0.5 )
+		    val -= 1.0;
+		break;
+	    }
+            default:
+	        ;
+	}
+    }
+
+    val /= scale;
+    c = val;
+}
+
+static
+void
+overflow( double& c, const scfx_params& params, bool& o_flag )
+{
+    int iwl = params.iwl();
+    int fwl = params.wl() - iwl;
+    double full_circle = scfx_pow2( iwl );
+    double resolution = scfx_pow2( -fwl );
+    double low, high;
+    if( params.enc() == SC_TC_ )
+    {
+	high = full_circle / 2.0 - resolution;
+	if( params.o_mode() == SC_SAT_SYM )
+	    low = - high;
+	else
+	    low = - full_circle / 2.0;
+    }
+    else
+    {
+	low = 0.0;
+	high = full_circle - resolution;
+    }
+    double val = c;
+    sc_fxval_fast c2(c);
+
+    bool under = ( val < low );
+    bool over = ( val > high );
+
+    o_flag = ( under || over );
+
+    if( o_flag )
+    {
+        switch( params.o_mode() )
+	{
+            case SC_WRAP:			// wrap-around
+	    {
+		int n_bits = params.n_bits();
+
+	        if( n_bits == 0 )
+		{
+		    // wrap-around all 'wl' bits
+		    val -= floor( val / full_circle ) * full_circle;
+		    if( val > high )
+			val -= full_circle;
+		}
+		else if( n_bits < params.wl() )
+		{
+		    double X = scfx_pow2( iwl - n_bits );
+
+		    // wrap-around least significant 'wl - n_bits' bits
+		    val -= floor( val / X ) * X;
+		    if( val > ( X - resolution ) )
+			val -= X;
+		    
+		    // saturate most significant 'n_bits' bits
+		    if( under )
+		        val += low;
+		    else
+		    {
+		        if( params.enc() == SC_TC_ )
+			    val += full_circle / 2.0 - X;
+			else
+			    val += full_circle - X;
+		    }
+		}
+		else
+		{
+		    // saturate all 'wl' bits
+		    if( under )
+			val = low;
+		    else
+			val = high;
+		}
+		break;
+	    }
+            case SC_SAT:			// saturation
+            case SC_SAT_SYM:			// symmetrical saturation
+	    {
+	        if( under )
+		    val = low;
+		else
+		    val = high;
+		break;
+	    }
+            case SC_SAT_ZERO:			// saturation to zero
+	    {
+	        val = 0.0;
+		break;
+	    }
+            case SC_WRAP_SM:			// sign magnitude wrap-around
+	    {
+		SC_ERROR_IF_( params.enc() == SC_US_,
+			      sc_core::SC_ID_WRAP_SM_NOT_DEFINED_ );
+	
+		int n_bits = params.n_bits();
+
+		if( n_bits == 0 )
+		{
+		    // invert conditionally
+		    if( c2.get_bit( iwl ) != c2.get_bit( iwl - 1 ) )
+			val = -val - resolution;
+
+		    // wrap-around all 'wl' bits
+		    val -= floor( val / full_circle ) * full_circle;
+		    if( val > high )
+			val -= full_circle;
+		}
+		else if( n_bits == 1 )
+		{
+		    // invert conditionally
+		    if( c2.is_neg() != c2.get_bit( iwl - 1 ) )
+			val = -val - resolution;
+
+		    // wrap-around all 'wl' bits
+		    val -= floor( val / full_circle ) * full_circle;
+		    if( val > high )
+			val -= full_circle;
+		}
+		else if( n_bits < params.wl() )
+		{
+		    // invert conditionally
+		    if( c2.is_neg() == c2.get_bit( iwl - n_bits ) )
+			val = -val - resolution;
+		    
+		    double X = scfx_pow2( iwl - n_bits );
+
+		    // wrap-around least significant 'wl - n_bits' bits
+		    val -= floor( val / X ) * X;
+		    if( val > ( X - resolution ) )
+			val -= X;
+
+		    // saturate most significant 'n_bits' bits
+		    if( under )
+		        val += low;
+		    else
+			val += full_circle / 2.0 - X;
+		} else {
+		    // saturate all 'wl' bits
+		    if( under )
+			val = low;
+		    else
+			val = high;
+		}
+	        break;
+	    }
+            default:
+	        ;
+	}
+
+	c = val;
+    }
+}
+
+
+void
+sc_fxnum_fast::cast()
+{
+    scfx_ieee_double id( m_val );
+    SC_ERROR_IF_( id.is_nan() || id.is_inf(), sc_core::SC_ID_INVALID_FX_VALUE_);
+
+    if( m_params.cast_switch() == SC_ON )
+    {
+        m_q_flag = false;
+	m_o_flag = false;
+
+	// check for special cases
+
+	if( id.is_zero() )
+	{
+	    if( id.negative() != 0 )
+	        m_val = -m_val;
+	    return;
+	}
+
+	// perform casting
+
+	sc_dt::quantization( m_val, m_params, m_q_flag );
+	sc_dt::overflow( m_val, m_params, m_o_flag );
+
+	// check for special case: -0
+
+	id = m_val;
+	if( id.is_zero() && id.negative() != 0 ) {
+	    m_val = -m_val;
+	}
+
+	// check for special case: NaN of Inf
+
+	if( id.is_nan() || id.is_inf() ) {
+	    m_val = 0.0;
+	}
+    }
+}
+
+
+// defined in sc_fxval.cpp;
+extern
+const char*
+to_string( const scfx_ieee_double&,
+	   sc_numrep,
+	   int,
+	   sc_fmt,
+	   const scfx_params* = 0 );
+
+
+// explicit conversion to character string
+
+const std::string
+sc_fxnum_fast::to_string() const
+{
+    return std::string( sc_dt::to_string( m_val, SC_DEC, -1, SC_F, &m_params ) );
+}
+
+const std::string
+sc_fxnum_fast::to_string( sc_numrep numrep ) const
+{
+    return std::string( sc_dt::to_string( m_val, numrep, -1, SC_F, &m_params ) );
+}
+
+const std::string
+sc_fxnum_fast::to_string( sc_numrep numrep, bool w_prefix ) const
+{
+    return std::string( sc_dt::to_string( m_val, numrep, (w_prefix ? 1 : 0),
+					SC_F, &m_params ) );
+}
+
+const std::string
+sc_fxnum_fast::to_string( sc_fmt fmt ) const
+{
+    return std::string( sc_dt::to_string( m_val, SC_DEC, -1, fmt, &m_params ) );
+}
+
+const std::string
+sc_fxnum_fast::to_string( sc_numrep numrep, sc_fmt fmt ) const
+{
+    return std::string( sc_dt::to_string( m_val, numrep, -1, fmt, &m_params ) );
+}
+
+const std::string
+sc_fxnum_fast::to_string( sc_numrep numrep, bool w_prefix, sc_fmt fmt ) const
+{
+    return std::string( sc_dt::to_string( m_val, numrep, (w_prefix ? 1 : 0),
+					fmt, &m_params ) );
+}
+
+
+const std::string
+sc_fxnum_fast::to_dec() const
+{
+    return std::string( sc_dt::to_string( m_val, SC_DEC, -1, SC_F, &m_params ) );
+}
+
+const std::string
+sc_fxnum_fast::to_bin() const
+{
+    return std::string( sc_dt::to_string( m_val, SC_BIN, -1, SC_F, &m_params ) );
+}
+
+const std::string
+sc_fxnum_fast::to_oct() const
+{
+    return std::string( sc_dt::to_string( m_val, SC_OCT, -1, SC_F, &m_params ) );
+}
+
+const std::string
+sc_fxnum_fast::to_hex() const
+{
+    return std::string( sc_dt::to_string( m_val, SC_HEX, -1, SC_F, &m_params ) );
+}
+
+
+// print or dump content
+
+void
+sc_fxnum_fast::print( ::std::ostream& os ) const
+{
+    os << sc_dt::to_string( m_val, SC_DEC, -1, SC_F, &m_params );
+}
+
+void
+sc_fxnum_fast::scan( ::std::istream& is )
+{
+    std::string s;
+    is >> s;
+    *this = s.c_str();
+}
+
+void
+sc_fxnum_fast::dump( ::std::ostream& os ) const
+{
+    os << "sc_fxnum_fast" << ::std::endl;
+    os << "(" << ::std::endl;
+    os << "val      = " << m_val << ::std::endl;
+    os << "params   = ";
+    m_params.dump( os );
+    os << "q_flag   = " << m_q_flag << ::std::endl;
+    os << "o_flag   = " << m_o_flag << ::std::endl;
+    // TO BE COMPLETED
+    // os << "observer = ";
+    // if( m_observer != 0 )
+    //     m_observer->dump( os );
+    // else
+    //     os << "0" << ::std::endl;
+    os << ")" << ::std::endl;
+}
+
+
+// internal use only;
+bool
+sc_fxnum_fast::get_bit( int i ) const
+{
+    scfx_ieee_double id( m_val );
+    if( id.is_zero() || id.is_nan() || id.is_inf() )
+        return false;
+
+    // convert to two's complement
+
+    unsigned int m0 = id.mantissa0();
+    unsigned int m1 = id.mantissa1();
+
+    if( id.is_normal() )
+        m0 += 1U << 20;
+
+    if( id.negative() != 0 )
+    {
+	m0 = ~ m0;
+	m1 = ~ m1;
+	unsigned int tmp = m1;
+	m1 += 1U;
+	if( m1 <= tmp )
+	    m0 += 1U;
+    }
+
+    // get the right bit
+
+    int j = i - id.exponent();
+    if( ( j += 20 ) >= 32 )
+        return ( ( m0 & 1U << 31 ) != 0 );
+    else if( j >= 0 )
+        return ( ( m0 & 1U << j ) != 0 );
+    else if( ( j += 32 ) >= 0 )
+        return ( ( m1 & 1U << j ) != 0 );
+    else
+        return false;
+}
+
+
+bool
+sc_fxnum_fast::set_bit( int i, bool high )
+{
+    scfx_ieee_double id( m_val );
+    if( id.is_nan() || id.is_inf() )
+        return false;
+
+    if( high )
+    {
+	if( get_bit( i ) )
+	    return true;
+
+	if( m_params.enc() == SC_TC_ && i == m_params.iwl() - 1 )
+	    m_val -= scfx_pow2( i );
+	else
+	    m_val += scfx_pow2( i );
+    }
+    else
+    {
+	if( ! get_bit( i ) )
+	    return true;
+
+	if( m_params.enc() == SC_TC_ && i == m_params.iwl() - 1 )
+	    m_val += scfx_pow2( i );
+	else
+	    m_val -= scfx_pow2( i );
+    }
+
+    return true;
+}
+
+
+bool
+sc_fxnum_fast::get_slice( int i, int j, sc_bv_base& bv ) const
+{
+    scfx_ieee_double id( m_val );
+    if( id.is_nan() || id.is_inf() )
+	return false;
+
+    // convert to two's complement
+
+    unsigned int m0 = id.mantissa0();
+    unsigned int m1 = id.mantissa1();
+
+    if( id.is_normal() )
+        m0 += 1U << 20;
+
+    if( id.negative() != 0 )
+    {
+	m0 = ~ m0;
+	m1 = ~ m1;
+	unsigned int tmp = m1;
+	m1 += 1U;
+	if( m1 <= tmp )
+	    m0 += 1U;
+    }
+
+    // get the bits
+
+    int l = j;
+    for( int k = 0; k < bv.length(); ++ k )
+    {
+	bool b = false;
+
+        int n = l - id.exponent();
+        if( ( n += 20 ) >= 32 )
+	    b = ( ( m0 & 1U << 31 ) != 0 );
+	else if( n >= 0 )
+	    b = ( ( m0 & 1U << n ) != 0 );
+	else if( ( n += 32 ) >= 0 )
+	    b = ( ( m1 & 1U << n ) != 0 );
+
+	bv[k] = b;
+
+	if( i >= j )
+	    ++ l;
+	else
+	    -- l;
+    }
+
+    return true;
+}
+
+bool
+sc_fxnum_fast::set_slice( int i, int j, const sc_bv_base& bv )
+{
+    scfx_ieee_double id( m_val );
+    if( id.is_nan() || id.is_inf() )
+        return false;
+
+    // set the bits
+
+    int l = j;
+    for( int k = 0; k < bv.length(); ++ k )
+    {
+	if( bv[k].to_bool() )
+	{
+	    if( ! get_bit( l ) )
+	    {
+		if( m_params.enc() == SC_TC_ && l == m_params.iwl() - 1 )
+		    m_val -= scfx_pow2( l );
+		else
+		    m_val += scfx_pow2( l );
+	    }
+	}
+	else
+	{
+	    if( get_bit( l ) )
+	    {
+		if( m_params.enc() == SC_TC_ && l == m_params.iwl() - 1 )
+		    m_val += scfx_pow2( l );
+		else
+		    m_val -= scfx_pow2( l );
+	    }
+	}
+
+
+	if( i >= j )
+	    ++ l;
+	else
+	    -- l;
+    }
+
+    return true;
+}
+
+
+sc_fxnum_fast_observer*
+sc_fxnum_fast::lock_observer() const
+{
+    SC_ASSERT_( m_observer != 0, "lock observer failed" );
+    sc_fxnum_fast_observer* tmp = m_observer;
+    m_observer = 0;
+    return tmp;
+}
+
+void
+sc_fxnum_fast::unlock_observer( sc_fxnum_fast_observer* observer_ ) const
+{
+    SC_ASSERT_( observer_ != 0, "unlock observer failed" );
+    m_observer = observer_;
+}
+
+} // namespace sc_dt
+
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/sc_fxnum.h b/ext/systemc/src/sysc/datatypes/fx/sc_fxnum.h
new file mode 100644
index 000000000..ed3750811
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/sc_fxnum.h
@@ -0,0 +1,5102 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_fxnum.h - 
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_fxnum.h,v $
+// Revision 1.5  2011/08/29 18:04:32  acg
+//  Philipp A. Hartmann: miscellaneous clean ups.
+//
+// Revision 1.4  2011/08/24 22:05:43  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.3  2011/01/19 18:57:40  acg
+//  Andy Goodrich: changes for IEEE_1666_2011.
+//
+// Revision 1.2  2009/03/09 17:26:46  acg
+//  Andy Goodrich: removed ; from namespace { }
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SC_FXNUM_H
+#define SC_FXNUM_H
+
+
+#include "sysc/datatypes/bit/sc_lv_base.h"
+#include "sysc/datatypes/fx/sc_fxval.h"
+#include "sysc/datatypes/fx/scfx_params.h"
+#include "sysc/datatypes/fx/sc_fxnum_observer.h"
+
+
+namespace sc_core {
+	class vcd_sc_fxnum_trace;
+	class vcd_sc_fxnum_fast_trace;
+	class wif_sc_fxnum_trace;
+	class wif_sc_fxnum_fast_trace;
+}
+
+
+namespace sc_dt
+{
+
+// classes defined in this module
+class sc_fxnum_bitref;
+class sc_fxnum_fast_bitref;
+class sc_fxnum_subref;
+class sc_fxnum_fast_subref;
+class sc_fxnum;
+class sc_fxnum_fast;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum_bitref
+//
+//  Proxy class for bit-selection in class sc_fxnum, behaves like sc_bit.
+// ----------------------------------------------------------------------------
+
+class sc_fxnum_bitref
+{
+    friend class sc_fxnum;
+    friend class sc_fxnum_fast_bitref;
+
+
+    bool get() const;
+    void set( bool );
+
+
+    // constructor
+
+    sc_fxnum_bitref( sc_fxnum&, int );
+
+public:
+
+    // copy constructor
+
+    sc_fxnum_bitref( const sc_fxnum_bitref& );
+
+
+    // assignment operators
+
+#define DECL_ASN_OP_T(op,tp)                                                  \
+    sc_fxnum_bitref& operator op ( tp );
+
+#define DECL_ASN_OP(op)                                                       \
+    DECL_ASN_OP_T(op,const sc_fxnum_bitref&)                                  \
+    DECL_ASN_OP_T(op,const sc_fxnum_fast_bitref&)                             \
+    DECL_ASN_OP_T(op,const sc_bit&)                                           \
+    DECL_ASN_OP_T(op,bool)
+
+    DECL_ASN_OP(=)
+
+    DECL_ASN_OP(&=)
+    DECL_ASN_OP(|=)
+    DECL_ASN_OP(^=)
+
+#undef DECL_ASN_OP_T
+#undef DECL_ASN_OP
+
+
+    // implicit conversion
+
+    operator bool() const;
+
+
+    // print or dump content
+
+    void print( ::std::ostream& = ::std::cout ) const;
+    void scan( ::std::istream& = ::std::cin );
+    void dump( ::std::ostream& = ::std::cout ) const;
+
+private:
+
+    sc_fxnum& m_num;
+    int       m_idx;
+
+private:
+
+    // disabled
+    sc_fxnum_bitref();
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum_fast_bitref
+//
+//  Proxy class for bit-selection in class sc_fxnum_fast, behaves like sc_bit.
+// ----------------------------------------------------------------------------
+
+class sc_fxnum_fast_bitref
+{
+    friend class sc_fxnum_fast;
+    friend class sc_fxnum_bitref;
+
+
+    bool get() const;
+    void set( bool );
+
+
+    // constructor
+
+    sc_fxnum_fast_bitref( sc_fxnum_fast&, int );
+
+public:
+
+    // copy constructor
+
+    sc_fxnum_fast_bitref( const sc_fxnum_fast_bitref& );
+
+
+    // assignment operators
+
+#define DECL_ASN_OP_T(op,tp)                                                  \
+    sc_fxnum_fast_bitref& operator op ( tp );
+
+#define DECL_ASN_OP(op)                                                       \
+    DECL_ASN_OP_T(op,const sc_fxnum_bitref&)                                  \
+    DECL_ASN_OP_T(op,const sc_fxnum_fast_bitref&)                             \
+    DECL_ASN_OP_T(op,const sc_bit&)                                           \
+    DECL_ASN_OP_T(op,bool)
+
+    DECL_ASN_OP(=)
+
+    DECL_ASN_OP(&=)
+    DECL_ASN_OP(|=)
+    DECL_ASN_OP(^=)
+
+#undef DECL_ASN_OP_T
+#undef DECL_ASN_OP
+
+
+    // implicit conversion
+
+    operator bool() const;
+
+
+    // print or dump content
+
+    void print( ::std::ostream& = ::std::cout ) const;
+    void scan( ::std::istream& = ::std::cin );
+    void dump( ::std::ostream& = ::std::cout ) const;
+
+private:
+
+    sc_fxnum_fast& m_num;
+    int            m_idx;
+
+private:
+
+    // disabled
+    sc_fxnum_fast_bitref();
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum_subref
+//
+//  Proxy class for part-selection in class sc_fxnum,
+//  behaves like sc_bv_base.
+// ----------------------------------------------------------------------------
+
+class sc_fxnum_subref
+{
+    friend class sc_fxnum;
+    friend class sc_fxnum_fast_subref;
+
+    bool get() const;
+    bool set();
+
+
+    // constructor
+
+    sc_fxnum_subref( sc_fxnum&, int, int );
+
+public:
+
+    // copy constructor
+
+    sc_fxnum_subref( const sc_fxnum_subref& );
+
+
+    // destructor
+
+    ~sc_fxnum_subref();
+
+
+    // assignment operators
+
+#define DECL_ASN_OP_T(tp)                                                     \
+    sc_fxnum_subref& operator = ( tp );
+
+    DECL_ASN_OP_T(const sc_fxnum_subref&)
+    DECL_ASN_OP_T(const sc_fxnum_fast_subref&)
+    DECL_ASN_OP_T(const sc_bv_base&)
+    DECL_ASN_OP_T(const sc_lv_base&)
+    DECL_ASN_OP_T(const char*)
+    DECL_ASN_OP_T(const bool*)
+    DECL_ASN_OP_T(const sc_signed&)
+    DECL_ASN_OP_T(const sc_unsigned&)
+    DECL_ASN_OP_T(const sc_int_base&)
+    DECL_ASN_OP_T(const sc_uint_base&)
+    DECL_ASN_OP_T(int64)
+    DECL_ASN_OP_T(uint64)
+    DECL_ASN_OP_T(int)
+    DECL_ASN_OP_T(unsigned int)
+    DECL_ASN_OP_T(long)
+    DECL_ASN_OP_T(unsigned long)
+    DECL_ASN_OP_T(char)
+
+#undef DECL_ASN_OP_T
+
+#define DECL_ASN_OP_T_A(op,tp)                                                \
+    sc_fxnum_subref& operator op ## = ( tp );
+
+#define DECL_ASN_OP_A(op)                                                     \
+    DECL_ASN_OP_T_A(op,const sc_fxnum_subref&)                                \
+    DECL_ASN_OP_T_A(op,const sc_fxnum_fast_subref&)                           \
+    DECL_ASN_OP_T_A(op,const sc_bv_base&)                                     \
+    DECL_ASN_OP_T_A(op,const sc_lv_base&)
+
+    DECL_ASN_OP_A(&)
+    DECL_ASN_OP_A(|)
+    DECL_ASN_OP_A(^)
+
+#undef DECL_ASN_OP_T_A
+#undef DECL_ASN_OP_A
+
+
+    // relational operators
+
+#define DECL_REL_OP_T(op,tp)                                                  \
+    friend bool operator op ( const sc_fxnum_subref&, tp );                   \
+    friend bool operator op ( tp, const sc_fxnum_subref& );
+
+#define DECL_REL_OP(op)                                                       \
+    friend bool operator op ( const sc_fxnum_subref&,                         \
+			      const sc_fxnum_subref& );                       \
+    friend bool operator op ( const sc_fxnum_subref&,                         \
+			      const sc_fxnum_fast_subref& );                  \
+    DECL_REL_OP_T(op,const sc_bv_base&)                                       \
+    DECL_REL_OP_T(op,const sc_lv_base&)                                       \
+    DECL_REL_OP_T(op,const char*)                                             \
+    DECL_REL_OP_T(op,const bool*)                                             \
+    DECL_REL_OP_T(op,const sc_signed&)                                        \
+    DECL_REL_OP_T(op,const sc_unsigned&)                                      \
+    DECL_REL_OP_T(op,int)                                                     \
+    DECL_REL_OP_T(op,unsigned int)                                            \
+    DECL_REL_OP_T(op,long)                                                    \
+    DECL_REL_OP_T(op,unsigned long)
+
+    DECL_REL_OP(==)
+    DECL_REL_OP(!=)
+
+#undef DECL_REL_OP_T
+#undef DECL_REL_OP
+
+
+    // reduce functions
+
+    bool and_reduce() const;
+    bool nand_reduce() const;
+    bool or_reduce() const;
+    bool nor_reduce() const;
+    bool xor_reduce() const;
+    bool xnor_reduce() const;
+
+
+    // query parameter
+
+    int length() const;
+
+
+    // explicit conversions
+
+    int           to_int() const;
+    unsigned int  to_uint() const;
+    long          to_long() const;
+    unsigned long to_ulong() const;
+    int64         to_int64() const;
+    uint64        to_uint64() const;
+
+#ifdef SC_DT_DEPRECATED
+    int           to_signed() const;
+    unsigned int  to_unsigned() const;
+#endif
+
+    const std::string to_string() const;
+    const std::string to_string( sc_numrep ) const;
+    const std::string to_string( sc_numrep, bool ) const;
+
+
+    // implicit conversion
+
+    operator sc_bv_base() const;
+
+
+    // print or dump content
+
+    void print( ::std::ostream& = ::std::cout ) const;
+    void scan( ::std::istream& = ::std::cin );
+    void dump( ::std::ostream& = ::std::cout ) const;
+
+private:
+
+    sc_fxnum& m_num;
+    int       m_from;
+    int       m_to;
+
+    sc_bv_base& m_bv;
+
+private:
+
+    // disabled
+    sc_fxnum_subref();
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum_fast_subref
+//
+//  Proxy class for part-selection in class sc_fxnum_fast,
+//  behaves like sc_bv_base.
+// ----------------------------------------------------------------------------
+
+class sc_fxnum_fast_subref
+{
+    friend class sc_fxnum_fast;
+    friend class sc_fxnum_subref;
+
+    bool get() const;
+    bool set();
+
+
+    // constructor
+
+    sc_fxnum_fast_subref( sc_fxnum_fast&, int, int );
+
+public:
+
+    // copy constructor
+
+    sc_fxnum_fast_subref( const sc_fxnum_fast_subref& );
+
+
+    // destructor
+
+    ~sc_fxnum_fast_subref();
+
+
+    // assignment operators
+
+#define DECL_ASN_OP_T(tp)                                                     \
+    sc_fxnum_fast_subref& operator = ( tp );
+
+    DECL_ASN_OP_T(const sc_fxnum_subref&)
+    DECL_ASN_OP_T(const sc_fxnum_fast_subref&)
+    DECL_ASN_OP_T(const sc_bv_base&)
+    DECL_ASN_OP_T(const sc_lv_base&)
+    DECL_ASN_OP_T(const char*)
+    DECL_ASN_OP_T(const bool*)
+    DECL_ASN_OP_T(const sc_signed&)
+    DECL_ASN_OP_T(const sc_unsigned&)
+    DECL_ASN_OP_T(const sc_int_base&)
+    DECL_ASN_OP_T(const sc_uint_base&)
+    DECL_ASN_OP_T(int64)
+    DECL_ASN_OP_T(uint64)
+    DECL_ASN_OP_T(int)
+    DECL_ASN_OP_T(unsigned int)
+    DECL_ASN_OP_T(long)
+    DECL_ASN_OP_T(unsigned long)
+    DECL_ASN_OP_T(char)
+
+#undef DECL_ASN_OP_T
+
+#define DECL_ASN_OP_T_A(op,tp)                                                \
+    sc_fxnum_fast_subref& operator op ## = ( tp );
+
+#define DECL_ASN_OP_A(op)                                                     \
+    DECL_ASN_OP_T_A(op,const sc_fxnum_subref&)                                \
+    DECL_ASN_OP_T_A(op,const sc_fxnum_fast_subref&)                           \
+    DECL_ASN_OP_T_A(op,const sc_bv_base&)                                     \
+    DECL_ASN_OP_T_A(op,const sc_lv_base&)
+
+    DECL_ASN_OP_A(&)
+    DECL_ASN_OP_A(|)
+    DECL_ASN_OP_A(^)
+
+#undef DECL_ASN_OP_T_A
+#undef DECL_ASN_OP_A
+
+
+    // relational operators
+
+#define DECL_REL_OP_T(op,tp)                                                  \
+    friend bool operator op ( const sc_fxnum_fast_subref&, tp );              \
+    friend bool operator op ( tp, const sc_fxnum_fast_subref& );
+
+#define DECL_REL_OP(op)                                                       \
+    friend bool operator op ( const sc_fxnum_fast_subref&,                    \
+			      const sc_fxnum_fast_subref& );                  \
+    friend bool operator op ( const sc_fxnum_fast_subref&,                    \
+			      const sc_fxnum_subref& );                       \
+    DECL_REL_OP_T(op,const sc_bv_base&)                                       \
+    DECL_REL_OP_T(op,const sc_lv_base&)                                       \
+    DECL_REL_OP_T(op,const char*)                                             \
+    DECL_REL_OP_T(op,const bool*)                                             \
+    DECL_REL_OP_T(op,const sc_signed&)                                        \
+    DECL_REL_OP_T(op,const sc_unsigned&)                                      \
+    DECL_REL_OP_T(op,int)                                                     \
+    DECL_REL_OP_T(op,unsigned int)                                            \
+    DECL_REL_OP_T(op,long)                                                    \
+    DECL_REL_OP_T(op,unsigned long)
+
+    DECL_REL_OP(==)
+    DECL_REL_OP(!=)
+
+#undef DECL_REL_OP_T
+#undef DECL_REL_OP
+
+
+    // reduce functions
+
+    bool and_reduce() const;
+    bool nand_reduce() const;
+    bool or_reduce() const;
+    bool nor_reduce() const;
+    bool xor_reduce() const;
+    bool xnor_reduce() const;
+
+
+    // query parameter
+
+    int length() const;
+
+
+    // explicit conversions
+
+    int           to_int() const;
+    unsigned int  to_uint() const;
+    long          to_long() const;
+    unsigned long to_ulong() const;
+    int64         to_int64() const;
+    uint64        to_uint64() const;
+
+#ifdef SC_DT_DEPRECATED
+    int           to_signed() const;
+    unsigned int  to_unsigned() const;
+#endif
+
+    const std::string to_string() const;
+    const std::string to_string( sc_numrep ) const;
+    const std::string to_string( sc_numrep, bool ) const;
+
+
+    // implicit conversion
+
+    operator sc_bv_base() const;
+
+
+    // print or dump content
+
+    void print( ::std::ostream& = ::std::cout ) const;
+    void scan( ::std::istream& = ::std::cin );
+    void dump( ::std::ostream& = ::std::cout ) const;
+
+private:
+
+    sc_fxnum_fast& m_num;
+    int            m_from;
+    int            m_to;
+
+    sc_bv_base& m_bv;
+
+private:
+
+    // disabled
+    sc_fxnum_fast_subref();
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum
+//
+//  Base class for the fixed-point types; arbitrary precision.
+// ----------------------------------------------------------------------------
+
+class sc_fxnum
+{
+    friend class sc_fxval;
+
+    friend class sc_fxnum_bitref;
+    friend class sc_fxnum_subref;
+    friend class sc_fxnum_fast_bitref;
+    friend class sc_fxnum_fast_subref;
+
+    friend class sc_core::vcd_sc_fxnum_trace;
+    friend class sc_core::wif_sc_fxnum_trace;
+
+protected:
+
+    sc_fxnum_observer* observer() const;
+
+
+    void cast();
+
+
+    // constructors
+
+    sc_fxnum( const sc_fxtype_params&,
+	      sc_enc,
+	      const sc_fxcast_switch&,
+	      sc_fxnum_observer* );
+
+#define DECL_CTOR_T(tp)                                                       \
+    sc_fxnum( tp,                                                             \
+	      const sc_fxtype_params&,                                        \
+	      sc_enc,                                                         \
+	      const sc_fxcast_switch&,                                        \
+	      sc_fxnum_observer* );
+
+    DECL_CTOR_T(int)
+    DECL_CTOR_T(unsigned int)
+    DECL_CTOR_T(long)
+    DECL_CTOR_T(unsigned long)
+    DECL_CTOR_T(float)
+    DECL_CTOR_T(double)
+    DECL_CTOR_T(const char*)
+    DECL_CTOR_T(const sc_fxval&)
+    DECL_CTOR_T(const sc_fxval_fast&)
+    DECL_CTOR_T(const sc_fxnum&)
+    DECL_CTOR_T(const sc_fxnum_fast&)
+#ifndef SC_FX_EXCLUDE_OTHER
+    DECL_CTOR_T(int64)
+    DECL_CTOR_T(uint64)
+    DECL_CTOR_T(const sc_int_base&)
+    DECL_CTOR_T(const sc_uint_base&)
+    DECL_CTOR_T(const sc_signed&)
+    DECL_CTOR_T(const sc_unsigned&)
+#endif
+
+#undef DECL_CTOR_T
+
+    ~sc_fxnum();
+
+
+    // internal use only;
+    const scfx_rep* get_rep() const;
+
+public:
+
+    // unary operators
+
+    const sc_fxval operator - () const;
+    const sc_fxval operator + () const;
+
+
+    // unary functions
+
+    friend void neg( sc_fxval&, const sc_fxnum& );
+    friend void neg( sc_fxnum&, const sc_fxnum& );
+
+
+    // binary operators
+
+#define DECL_BIN_OP_T(op,tp)                                                  \
+    friend const sc_fxval operator op ( const sc_fxnum&, tp );                \
+    friend const sc_fxval operator op ( tp, const sc_fxnum& );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_BIN_OP_OTHER(op)                                                 \
+    DECL_BIN_OP_T(op,int64)                                                   \
+    DECL_BIN_OP_T(op,uint64)                                                  \
+    DECL_BIN_OP_T(op,const sc_int_base&)                                      \
+    DECL_BIN_OP_T(op,const sc_uint_base&)                                     \
+    DECL_BIN_OP_T(op,const sc_signed&)                                        \
+    DECL_BIN_OP_T(op,const sc_unsigned&)
+#else
+#define DECL_BIN_OP_OTHER(op)
+#endif
+
+#define DECL_BIN_OP(op,dummy)                                                 \
+    friend const sc_fxval operator op ( const sc_fxnum&, const sc_fxnum& );   \
+    DECL_BIN_OP_T(op,int)                                                     \
+    DECL_BIN_OP_T(op,unsigned int)                                            \
+    DECL_BIN_OP_T(op,long)                                                    \
+    DECL_BIN_OP_T(op,unsigned long)                                           \
+    DECL_BIN_OP_T(op,float)                                                  \
+    DECL_BIN_OP_T(op,double)                                                  \
+    DECL_BIN_OP_T(op,const char*)                                             \
+    DECL_BIN_OP_T(op,const sc_fxval&)                                         \
+    DECL_BIN_OP_T(op,const sc_fxval_fast&)                                    \
+    DECL_BIN_OP_T(op,const sc_fxnum_fast&)                                    \
+    DECL_BIN_OP_OTHER(op)
+
+    DECL_BIN_OP(*,mult)
+    DECL_BIN_OP(+,add)
+    DECL_BIN_OP(-,sub)
+// don't use macros
+//    DECL_BIN_OP(/,div)
+    friend const sc_fxval operator / ( const sc_fxnum&, const sc_fxnum& );
+    DECL_BIN_OP_T(/,int)
+    DECL_BIN_OP_T(/,unsigned int)
+    DECL_BIN_OP_T(/,long)
+    DECL_BIN_OP_T(/,unsigned long)
+    DECL_BIN_OP_T(/,float)
+    DECL_BIN_OP_T(/,double)
+    DECL_BIN_OP_T(/,const char*)
+    DECL_BIN_OP_T(/,const sc_fxval&)
+    DECL_BIN_OP_T(/,const sc_fxval_fast&)
+    DECL_BIN_OP_T(/,const sc_fxnum_fast&)
+//    DECL_BIN_OP_OTHER(op)
+#ifndef SC_FX_EXCLUDE_OTHER
+    DECL_BIN_OP_T(/,int64)
+    DECL_BIN_OP_T(/,uint64)
+    DECL_BIN_OP_T(/,const sc_int_base&)
+    DECL_BIN_OP_T(/,const sc_uint_base&)
+    DECL_BIN_OP_T(/,const sc_signed&)
+    DECL_BIN_OP_T(/,const sc_unsigned&)
+#endif
+
+#undef DECL_BIN_OP_T
+#undef DECL_BIN_OP_OTHER
+#undef DECL_BIN_OP
+
+    friend const sc_fxval operator << ( const sc_fxnum&, int );
+    friend const sc_fxval operator >> ( const sc_fxnum&, int );
+
+
+    // binary functions
+
+#define DECL_BIN_FNC_T(fnc,tp)                                                \
+    friend void fnc ( sc_fxval&, const sc_fxnum&, tp );                       \
+    friend void fnc ( sc_fxval&, tp, const sc_fxnum& );                       \
+    friend void fnc ( sc_fxnum&, const sc_fxnum&, tp );                       \
+    friend void fnc ( sc_fxnum&, tp, const sc_fxnum& );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_BIN_FNC_OTHER(fnc)                                               \
+    DECL_BIN_FNC_T(fnc,int64)                                                 \
+    DECL_BIN_FNC_T(fnc,uint64)                                                \
+    DECL_BIN_FNC_T(fnc,const sc_int_base&)                                    \
+    DECL_BIN_FNC_T(fnc,const sc_uint_base&)                                   \
+    DECL_BIN_FNC_T(fnc,const sc_signed&)                                      \
+    DECL_BIN_FNC_T(fnc,const sc_unsigned&)
+#else
+#define DECL_BIN_FNC_OTHER(fnc)
+#endif
+
+#define DECL_BIN_FNC(fnc)                                                     \
+    friend void fnc ( sc_fxval&, const sc_fxnum&, const sc_fxnum& );          \
+    friend void fnc ( sc_fxnum&, const sc_fxnum&, const sc_fxnum& );          \
+    DECL_BIN_FNC_T(fnc,int)                                                   \
+    DECL_BIN_FNC_T(fnc,unsigned int)                                          \
+    DECL_BIN_FNC_T(fnc,long)                                                  \
+    DECL_BIN_FNC_T(fnc,unsigned long)                                         \
+    DECL_BIN_FNC_T(fnc,float)                                                \
+    DECL_BIN_FNC_T(fnc,double)                                                \
+    DECL_BIN_FNC_T(fnc,const char*)                                           \
+    DECL_BIN_FNC_T(fnc,const sc_fxval&)                                       \
+    DECL_BIN_FNC_T(fnc,const sc_fxval_fast&)                                  \
+    DECL_BIN_FNC_T(fnc,const sc_fxnum_fast&)                                  \
+    DECL_BIN_FNC_OTHER(fnc)
+
+    DECL_BIN_FNC(mult)
+    DECL_BIN_FNC(div)
+    DECL_BIN_FNC(add)
+    DECL_BIN_FNC(sub)
+
+#undef DECL_BIN_FNC_T
+#undef DECL_BIN_FNC_OTHER
+#undef DECL_BIN_FNC
+
+    friend void lshift( sc_fxval&, const sc_fxnum&, int );
+    friend void rshift( sc_fxval&, const sc_fxnum&, int );
+    friend void lshift( sc_fxnum&, const sc_fxnum&, int );
+    friend void rshift( sc_fxnum&, const sc_fxnum&, int );
+
+
+    // relational (including equality) operators
+
+#define DECL_REL_OP_T(op,tp)                                                  \
+    friend bool operator op ( const sc_fxnum&, tp );                          \
+    friend bool operator op ( tp, const sc_fxnum& );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_REL_OP_OTHER(op)                                                 \
+    DECL_REL_OP_T(op,int64)                                                   \
+    DECL_REL_OP_T(op,uint64)                                                  \
+    DECL_REL_OP_T(op,const sc_int_base&)                                      \
+    DECL_REL_OP_T(op,const sc_uint_base&)                                     \
+    DECL_REL_OP_T(op,const sc_signed&)                                        \
+    DECL_REL_OP_T(op,const sc_unsigned&)
+#else
+#define DECL_REL_OP_OTHER(op)
+#endif
+
+#define DECL_REL_OP(op)                                                       \
+    friend bool operator op ( const sc_fxnum&, const sc_fxnum& );             \
+    DECL_REL_OP_T(op,int)                                                     \
+    DECL_REL_OP_T(op,unsigned int)                                            \
+    DECL_REL_OP_T(op,long)                                                    \
+    DECL_REL_OP_T(op,unsigned long)                                           \
+    DECL_REL_OP_T(op,float)                                                  \
+    DECL_REL_OP_T(op,double)                                                  \
+    DECL_REL_OP_T(op,const char*)                                             \
+    DECL_REL_OP_T(op,const sc_fxval&)                                         \
+    DECL_REL_OP_T(op,const sc_fxval_fast&)                                    \
+    DECL_REL_OP_T(op,const sc_fxnum_fast&)                                    \
+    DECL_REL_OP_OTHER(op)
+
+    DECL_REL_OP(<)
+    DECL_REL_OP(<=)
+    DECL_REL_OP(>)
+    DECL_REL_OP(>=)
+    DECL_REL_OP(==)
+    DECL_REL_OP(!=)
+
+#undef DECL_REL_OP_T
+#undef DECL_REL_OP_OTHER
+#undef DECL_REL_OP
+
+
+    // assignment operators
+
+#define DECL_ASN_OP_T(op,tp)                                                  \
+    sc_fxnum& operator op( tp );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_ASN_OP_OTHER(op)                                                 \
+    DECL_ASN_OP_T(op,int64)                                                   \
+    DECL_ASN_OP_T(op,uint64)                                                  \
+    DECL_ASN_OP_T(op,const sc_int_base&)                                      \
+    DECL_ASN_OP_T(op,const sc_uint_base&)                                     \
+    DECL_ASN_OP_T(op,const sc_signed&)                                        \
+    DECL_ASN_OP_T(op,const sc_unsigned&)
+#else
+#define DECL_ASN_OP_OTHER(op)
+#endif
+
+#define DECL_ASN_OP(op)                                                       \
+    DECL_ASN_OP_T(op,int)                                                     \
+    DECL_ASN_OP_T(op,unsigned int)                                            \
+    DECL_ASN_OP_T(op,long)                                                    \
+    DECL_ASN_OP_T(op,unsigned long)                                           \
+    DECL_ASN_OP_T(op,float)                                                  \
+    DECL_ASN_OP_T(op,double)                                                  \
+    DECL_ASN_OP_T(op,const char*)                                             \
+    DECL_ASN_OP_T(op,const sc_fxval&)                                         \
+    DECL_ASN_OP_T(op,const sc_fxval_fast&)                                    \
+    DECL_ASN_OP_T(op,const sc_fxnum&)                                         \
+    DECL_ASN_OP_T(op,const sc_fxnum_fast&)                                    \
+    DECL_ASN_OP_OTHER(op)
+
+    DECL_ASN_OP(=)
+
+    DECL_ASN_OP(*=)
+    DECL_ASN_OP(/=)
+    DECL_ASN_OP(+=)
+    DECL_ASN_OP(-=)
+
+    DECL_ASN_OP_T(<<=,int)
+    DECL_ASN_OP_T(>>=,int)
+
+#undef DECL_ASN_OP_T
+#undef DECL_ASN_OP_OTHER
+#undef DECL_ASN_OP
+
+
+    // auto-increment and auto-decrement
+
+    const sc_fxval operator ++ ( int );
+    const sc_fxval operator -- ( int );
+
+    sc_fxnum& operator ++ ();
+    sc_fxnum& operator -- ();
+
+
+    // bit selection
+
+    const sc_fxnum_bitref operator [] ( int ) const;
+    sc_fxnum_bitref       operator [] ( int );
+
+    const sc_fxnum_bitref bit( int ) const;
+    sc_fxnum_bitref       bit( int );
+
+
+    // part selection
+
+    const sc_fxnum_subref operator () ( int, int ) const;
+    sc_fxnum_subref       operator () ( int, int );
+
+    const sc_fxnum_subref range( int, int ) const;
+    sc_fxnum_subref       range( int, int );
+
+
+    const sc_fxnum_subref operator () () const;
+    sc_fxnum_subref       operator () ();
+
+    const sc_fxnum_subref range() const;
+    sc_fxnum_subref       range();
+
+
+    // implicit conversion
+
+    operator double() const;		// necessary evil!
+
+
+    // explicit conversion to primitive types
+
+    short          to_short() const;
+    unsigned short to_ushort() const;
+    int            to_int() const;
+    unsigned int   to_uint() const;
+    long           to_long() const;
+    unsigned long  to_ulong() const;
+    int64          to_int64() const;
+    uint64         to_uint64() const;
+    float          to_float() const;
+    double         to_double() const;
+
+
+    // explicit conversion to character string
+
+    const std::string to_string() const;
+    const std::string to_string( sc_numrep ) const;
+    const std::string to_string( sc_numrep, bool ) const;
+    const std::string to_string( sc_fmt ) const;
+    const std::string to_string( sc_numrep, sc_fmt ) const;
+    const std::string to_string( sc_numrep, bool, sc_fmt ) const;
+
+    const std::string to_dec() const;
+    const std::string to_bin() const;
+    const std::string to_oct() const;
+    const std::string to_hex() const;
+
+
+    // query value
+
+    bool is_neg() const;
+    bool is_zero() const;
+
+    // internal use only;
+    bool is_normal() const;
+
+    bool quantization_flag() const;
+    bool overflow_flag() const;
+
+    const sc_fxval value() const;
+
+
+    // query parameters
+
+    int       wl() const;
+    int       iwl() const;
+    sc_q_mode q_mode() const;
+    sc_o_mode o_mode() const;
+    int       n_bits() const;
+
+    const sc_fxtype_params& type_params() const;
+
+    const sc_fxcast_switch& cast_switch() const;
+
+
+    // print or dump content
+
+    void print( ::std::ostream& = ::std::cout ) const;
+    void scan( ::std::istream& = ::std::cin );
+    void dump( ::std::ostream& = ::std::cout ) const;
+
+
+    // internal use only;
+    void observer_read() const;
+
+
+    // internal use only;
+    bool get_bit( int ) const;
+
+protected:
+
+    bool set_bit( int, bool );
+
+
+    bool get_slice( int, int, sc_bv_base& ) const;
+    bool set_slice( int, int, const sc_bv_base& );
+
+
+    sc_fxnum_observer* lock_observer() const;
+    void unlock_observer( sc_fxnum_observer* ) const;
+
+private:
+
+    scfx_rep*                  m_rep;
+
+    scfx_params                m_params;
+    bool                       m_q_flag;
+    bool                       m_o_flag;
+
+    mutable sc_fxnum_observer* m_observer;
+
+private:
+
+    // disabled
+    sc_fxnum();
+    sc_fxnum( const sc_fxnum& );
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum_fast
+//
+//  Base class for the fixed-point types; limited precision.
+// ----------------------------------------------------------------------------
+
+class sc_fxnum_fast
+{
+    friend class sc_fxval_fast;
+
+    friend class sc_fxnum_bitref;
+    friend class sc_fxnum_subref;
+    friend class sc_fxnum_fast_bitref;
+    friend class sc_fxnum_fast_subref;
+
+    friend class sc_core::vcd_sc_fxnum_fast_trace;
+    friend class sc_core::wif_sc_fxnum_fast_trace;
+
+protected:
+
+    sc_fxnum_fast_observer* observer() const;
+
+
+    void cast();
+
+
+    // constructors
+
+    sc_fxnum_fast( const sc_fxtype_params&,
+		   sc_enc,
+		   const sc_fxcast_switch&,
+		   sc_fxnum_fast_observer* );
+
+#define DECL_CTOR_T(tp)                                                       \
+    sc_fxnum_fast( tp,                                                        \
+	           const sc_fxtype_params&,                                   \
+	           sc_enc,                                                    \
+	           const sc_fxcast_switch&,                                   \
+	           sc_fxnum_fast_observer* );
+
+    DECL_CTOR_T(int)
+    DECL_CTOR_T(unsigned int)
+    DECL_CTOR_T(long)
+    DECL_CTOR_T(unsigned long)
+    DECL_CTOR_T(float)
+    DECL_CTOR_T(double)
+    DECL_CTOR_T(const char*)
+    DECL_CTOR_T(const sc_fxval&)
+    DECL_CTOR_T(const sc_fxval_fast&)
+    DECL_CTOR_T(const sc_fxnum&)
+    DECL_CTOR_T(const sc_fxnum_fast&)
+#ifndef SC_FX_EXCLUDE_OTHER
+    DECL_CTOR_T(int64)
+    DECL_CTOR_T(uint64)
+    DECL_CTOR_T(const sc_int_base&)
+    DECL_CTOR_T(const sc_uint_base&)
+    DECL_CTOR_T(const sc_signed&)
+    DECL_CTOR_T(const sc_unsigned&)
+#endif
+
+#undef DECL_CTOR_T
+
+    ~sc_fxnum_fast();
+
+
+    // internal use only;
+    double get_val() const;
+
+public:
+
+    // unary operators
+
+    const sc_fxval_fast operator - () const;
+    const sc_fxval_fast operator + () const;
+
+
+    // unary functions
+
+    friend void neg( sc_fxval_fast&, const sc_fxnum_fast& );
+    friend void neg( sc_fxnum_fast&, const sc_fxnum_fast& );
+
+
+    // binary operators
+
+#define DECL_BIN_OP_T(op,tp)                                                  \
+    friend const sc_fxval_fast operator op ( const sc_fxnum_fast&, tp );      \
+    friend const sc_fxval_fast operator op ( tp, const sc_fxnum_fast& );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_BIN_OP_OTHER(op)                                                 \
+    DECL_BIN_OP_T(op,int64)                                                   \
+    DECL_BIN_OP_T(op,uint64)                                                  \
+    DECL_BIN_OP_T(op,const sc_int_base&)                                      \
+    DECL_BIN_OP_T(op,const sc_uint_base&)                                     \
+    DECL_BIN_OP_T(op,const sc_signed&)                                        \
+    DECL_BIN_OP_T(op,const sc_unsigned&)
+#else
+#define DECL_BIN_OP_OTHER(op)
+#endif
+
+#define DECL_BIN_OP(op,dummy)                                                 \
+    friend const sc_fxval_fast operator op ( const sc_fxnum_fast&,            \
+					     const sc_fxnum_fast& );          \
+    DECL_BIN_OP_T(op,int)                                                     \
+    DECL_BIN_OP_T(op,unsigned int)                                            \
+    DECL_BIN_OP_T(op,long)                                                    \
+    DECL_BIN_OP_T(op,unsigned long)                                           \
+    DECL_BIN_OP_T(op,float)                                                  \
+    DECL_BIN_OP_T(op,double)                                                  \
+    DECL_BIN_OP_T(op,const char*)                                             \
+    DECL_BIN_OP_T(op,const sc_fxval_fast&)                                    \
+    DECL_BIN_OP_OTHER(op)
+
+    DECL_BIN_OP(*,mult)
+    DECL_BIN_OP(+,add)
+    DECL_BIN_OP(-,sub)
+//    DECL_BIN_OP(/,div)
+    friend const sc_fxval_fast operator / ( const sc_fxnum_fast&,
+					     const sc_fxnum_fast& );
+    DECL_BIN_OP_T(/,int)
+    DECL_BIN_OP_T(/,unsigned int)
+    DECL_BIN_OP_T(/,long)
+    DECL_BIN_OP_T(/,unsigned long)
+    DECL_BIN_OP_T(/,float)
+    DECL_BIN_OP_T(/,double)
+    DECL_BIN_OP_T(/,const char*)
+    DECL_BIN_OP_T(/,const sc_fxval_fast&)
+//    DECL_BIN_OP_OTHER(op)
+#ifndef SC_FX_EXCLUDE_OTHER
+    DECL_BIN_OP_T(/,int64)                                                   \
+    DECL_BIN_OP_T(/,uint64)                                                  \
+    DECL_BIN_OP_T(/,const sc_int_base&)                                      \
+    DECL_BIN_OP_T(/,const sc_uint_base&)                                     \
+    DECL_BIN_OP_T(/,const sc_signed&)                                        \
+    DECL_BIN_OP_T(/,const sc_unsigned&)
+#endif
+
+#undef DECL_BIN_OP_T
+#undef DECL_BIN_OP_OTHER
+#undef DECL_BIN_OP
+
+    friend const sc_fxval_fast operator << ( const sc_fxnum_fast&, int );
+    friend const sc_fxval_fast operator >> ( const sc_fxnum_fast&, int );
+
+
+    // binary functions
+
+#define DECL_BIN_FNC_T(fnc,tp)                                                \
+    friend void fnc ( sc_fxval_fast&, const sc_fxnum_fast&, tp );             \
+    friend void fnc ( sc_fxval_fast&, tp, const sc_fxnum_fast& );             \
+    friend void fnc ( sc_fxnum_fast&, const sc_fxnum_fast&, tp );             \
+    friend void fnc ( sc_fxnum_fast&, tp, const sc_fxnum_fast& );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_BIN_FNC_OTHER(fnc)                                               \
+    DECL_BIN_FNC_T(fnc,int64)                                                 \
+    DECL_BIN_FNC_T(fnc,uint64)                                                \
+    DECL_BIN_FNC_T(fnc,const sc_int_base&)                                    \
+    DECL_BIN_FNC_T(fnc,const sc_uint_base&)                                   \
+    DECL_BIN_FNC_T(fnc,const sc_signed&)                                      \
+    DECL_BIN_FNC_T(fnc,const sc_unsigned&)
+#else
+#define DECL_BIN_FNC_OTHER(fnc)
+#endif
+
+#define DECL_BIN_FNC(fnc)                                                     \
+    friend void fnc ( sc_fxval_fast&, const sc_fxnum_fast&,                   \
+		                      const sc_fxnum_fast& );                 \
+    friend void fnc ( sc_fxnum_fast&, const sc_fxnum_fast&,                   \
+		                      const sc_fxnum_fast& );                 \
+    DECL_BIN_FNC_T(fnc,int)                                                   \
+    DECL_BIN_FNC_T(fnc,unsigned int)                                          \
+    DECL_BIN_FNC_T(fnc,long)                                                  \
+    DECL_BIN_FNC_T(fnc,unsigned long)                                         \
+    DECL_BIN_FNC_T(fnc,float)                                                \
+    DECL_BIN_FNC_T(fnc,double)                                                \
+    DECL_BIN_FNC_T(fnc,const char*)                                           \
+    DECL_BIN_FNC_T(fnc,const sc_fxval&)                                       \
+    DECL_BIN_FNC_T(fnc,const sc_fxval_fast&)                                  \
+    DECL_BIN_FNC_T(fnc,const sc_fxnum&)                                       \
+    DECL_BIN_FNC_OTHER(fnc)
+
+    DECL_BIN_FNC(mult)
+    DECL_BIN_FNC(div)
+    DECL_BIN_FNC(add)
+    DECL_BIN_FNC(sub)
+
+#undef DECL_BIN_FNC_T
+#undef DECL_BIN_FNC_OTHER
+#undef DECL_BIN_FNC
+
+    friend void lshift( sc_fxval_fast&, const sc_fxnum_fast&, int );
+    friend void rshift( sc_fxval_fast&, const sc_fxnum_fast&, int );
+    friend void lshift( sc_fxnum_fast&, const sc_fxnum_fast&, int );
+    friend void rshift( sc_fxnum_fast&, const sc_fxnum_fast&, int );
+
+
+    // relational (including equality) operators
+
+#define DECL_REL_OP_T(op,tp)                                                  \
+    friend bool operator op ( const sc_fxnum_fast&, tp );                     \
+    friend bool operator op ( tp, const sc_fxnum_fast& );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_REL_OP_OTHER(op)                                                 \
+    DECL_REL_OP_T(op,int64)                                                   \
+    DECL_REL_OP_T(op,uint64)                                                  \
+    DECL_REL_OP_T(op,const sc_int_base&)                                      \
+    DECL_REL_OP_T(op,const sc_uint_base&)                                     \
+    DECL_REL_OP_T(op,const sc_signed&)                                        \
+    DECL_REL_OP_T(op,const sc_unsigned&)
+#else
+#define DECL_REL_OP_OTHER(op)
+#endif
+
+#define DECL_REL_OP(op)                                                       \
+    friend bool operator op ( const sc_fxnum_fast&, const sc_fxnum_fast& );   \
+    DECL_REL_OP_T(op,int)                                                     \
+    DECL_REL_OP_T(op,unsigned int)                                            \
+    DECL_REL_OP_T(op,long)                                                    \
+    DECL_REL_OP_T(op,unsigned long)                                           \
+    DECL_REL_OP_T(op,float)                                                  \
+    DECL_REL_OP_T(op,double)                                                  \
+    DECL_REL_OP_T(op,const char*)                                             \
+    DECL_REL_OP_T(op,const sc_fxval_fast&)                                    \
+    DECL_REL_OP_OTHER(op)
+
+    DECL_REL_OP(<)
+    DECL_REL_OP(<=)
+    DECL_REL_OP(>)
+    DECL_REL_OP(>=)
+    DECL_REL_OP(==)
+    DECL_REL_OP(!=)
+
+#undef DECL_REL_OP_T
+#undef DECL_REL_OP_OTHER
+#undef DECL_REL_OP
+
+
+    // assignment operators
+
+#define DECL_ASN_OP_T(op,tp)                                                  \
+    sc_fxnum_fast& operator op( tp );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_ASN_OP_OTHER(op)                                                 \
+    DECL_ASN_OP_T(op,int64)                                                   \
+    DECL_ASN_OP_T(op,uint64)                                                  \
+    DECL_ASN_OP_T(op,const sc_int_base&)                                      \
+    DECL_ASN_OP_T(op,const sc_uint_base&)                                     \
+    DECL_ASN_OP_T(op,const sc_signed&)                                        \
+    DECL_ASN_OP_T(op,const sc_unsigned&)
+#else
+#define DECL_ASN_OP_OTHER(op)
+#endif
+
+#define DECL_ASN_OP(op)                                                       \
+    DECL_ASN_OP_T(op,int)                                                     \
+    DECL_ASN_OP_T(op,unsigned int)                                            \
+    DECL_ASN_OP_T(op,long)                                                    \
+    DECL_ASN_OP_T(op,unsigned long)                                           \
+    DECL_ASN_OP_T(op,float)                                                  \
+    DECL_ASN_OP_T(op,double)                                                  \
+    DECL_ASN_OP_T(op,const char*)                                             \
+    DECL_ASN_OP_T(op,const sc_fxval&)                                         \
+    DECL_ASN_OP_T(op,const sc_fxval_fast&)                                    \
+    DECL_ASN_OP_T(op,const sc_fxnum&)                                         \
+    DECL_ASN_OP_T(op,const sc_fxnum_fast&)                                    \
+    DECL_ASN_OP_OTHER(op)
+
+    DECL_ASN_OP(=)
+
+    DECL_ASN_OP(*=)
+    DECL_ASN_OP(/=)
+    DECL_ASN_OP(+=)
+    DECL_ASN_OP(-=)
+
+    DECL_ASN_OP_T(<<=,int)
+    DECL_ASN_OP_T(>>=,int)
+
+#undef DECL_ASN_OP_T
+#undef DECL_ASN_OP_OTHER
+#undef DECL_ASN_OP
+
+
+    // auto-increment and auto-decrement
+
+    const sc_fxval_fast operator ++ ( int );
+    const sc_fxval_fast operator -- ( int );
+
+    sc_fxnum_fast& operator ++ ();
+    sc_fxnum_fast& operator -- ();
+
+
+    // bit selection
+
+    const sc_fxnum_fast_bitref operator [] ( int ) const;
+    sc_fxnum_fast_bitref       operator [] ( int );
+
+    const sc_fxnum_fast_bitref bit( int ) const;
+    sc_fxnum_fast_bitref       bit( int );
+
+
+    // part selection
+
+    const sc_fxnum_fast_subref operator () ( int, int ) const;
+    sc_fxnum_fast_subref       operator () ( int, int );
+
+    const sc_fxnum_fast_subref range( int, int ) const;
+    sc_fxnum_fast_subref       range( int, int );
+
+
+    const sc_fxnum_fast_subref operator () () const;
+    sc_fxnum_fast_subref       operator () ();
+
+    const sc_fxnum_fast_subref range() const;
+    sc_fxnum_fast_subref       range();
+
+
+    // implicit conversion
+
+    operator double() const;		// necessary evil!
+
+
+    // explicit conversion to primitive types
+
+    short          to_short() const;
+    unsigned short to_ushort() const;
+    int            to_int() const;
+    unsigned int   to_uint() const;
+    long           to_long() const;
+    unsigned long  to_ulong() const;
+    int64          to_int64() const;
+    uint64         to_uint64() const;
+    float          to_float() const;
+    double         to_double() const;
+
+
+    // explicit conversion to character string
+
+    const std::string to_string() const;
+    const std::string to_string( sc_numrep ) const;
+    const std::string to_string( sc_numrep, bool ) const;
+    const std::string to_string( sc_fmt ) const;
+    const std::string to_string( sc_numrep, sc_fmt ) const;
+    const std::string to_string( sc_numrep, bool, sc_fmt ) const;
+
+    const std::string to_dec() const;
+    const std::string to_bin() const;
+    const std::string to_oct() const;
+    const std::string to_hex() const;
+
+
+    // query value
+
+    bool is_neg() const;
+    bool is_zero() const;
+
+    // internal use only;
+    bool is_normal() const;
+
+    bool quantization_flag() const;
+    bool overflow_flag() const;
+
+    const sc_fxval_fast value() const;
+
+
+    // query parameters
+
+    int       wl() const;
+    int       iwl() const;
+    sc_q_mode q_mode() const;
+    sc_o_mode o_mode() const;
+    int       n_bits() const;
+
+    const sc_fxtype_params& type_params() const;
+
+    const sc_fxcast_switch& cast_switch() const;
+
+
+    // print or dump content
+
+    void print( ::std::ostream& = ::std::cout ) const;
+    void scan( ::std::istream& = ::std::cin );
+    void dump( ::std::ostream& = ::std::cout ) const;
+
+
+    // internal use only;
+    void observer_read() const;
+
+
+    // internal use only;
+    bool get_bit( int ) const;
+
+protected:
+
+    bool set_bit( int, bool );
+
+
+    bool get_slice( int, int, sc_bv_base& ) const;
+    bool set_slice( int, int, const sc_bv_base& );
+
+
+    sc_fxnum_fast_observer* lock_observer() const;
+    void unlock_observer( sc_fxnum_fast_observer* ) const;
+
+private:
+
+    double                          m_val;
+
+    scfx_params                     m_params;
+    bool                            m_q_flag;
+    bool                            m_o_flag;
+
+    mutable sc_fxnum_fast_observer* m_observer;
+
+private:
+
+    // disabled
+    sc_fxnum_fast();
+    sc_fxnum_fast( const sc_fxnum_fast& );
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum_bitref
+//
+//  Proxy class for bit-selection in class sc_fxnum, behaves like sc_bit.
+// ----------------------------------------------------------------------------
+
+// constructor
+
+inline
+sc_fxnum_bitref::sc_fxnum_bitref( sc_fxnum& num_, int idx_ )
+    : m_num( num_ ), m_idx( idx_ )
+{}
+
+
+// copy constructor
+
+inline
+sc_fxnum_bitref::sc_fxnum_bitref( const sc_fxnum_bitref& a )
+    : m_num( a.m_num ), m_idx( a.m_idx )
+{}
+
+
+// assignment operators
+
+inline
+sc_fxnum_bitref&
+sc_fxnum_bitref::operator = ( const sc_fxnum_bitref& a )
+{
+    if( &a != this )
+    {
+	SC_FXNUM_OBSERVER_READ_( a.m_num )
+	set( a.get() );
+	SC_FXNUM_OBSERVER_WRITE_( m_num )
+    }
+    return *this;
+}
+
+inline
+sc_fxnum_bitref&
+sc_fxnum_bitref::operator = ( const sc_fxnum_fast_bitref& a )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( a.m_num )
+    set( a.get() );
+    SC_FXNUM_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+inline
+sc_fxnum_bitref&
+sc_fxnum_bitref::operator = ( const sc_bit& a )
+{
+    set( static_cast<bool>( a ) );
+    SC_FXNUM_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+inline
+sc_fxnum_bitref&
+sc_fxnum_bitref::operator = ( bool a )
+{
+    set( a );
+    SC_FXNUM_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+
+inline
+sc_fxnum_bitref&
+sc_fxnum_bitref::operator &= ( const sc_fxnum_bitref& b )
+{
+    SC_FXNUM_OBSERVER_READ_( m_num )
+    SC_FXNUM_OBSERVER_READ_( b.m_num )
+    set( get() && b.get() );
+    SC_FXNUM_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+inline
+sc_fxnum_bitref&
+sc_fxnum_bitref::operator &= ( const sc_fxnum_fast_bitref& b )
+{
+    SC_FXNUM_OBSERVER_READ_( m_num )
+    SC_FXNUM_FAST_OBSERVER_READ_( b.m_num )
+    set( get() && b.get() );
+    SC_FXNUM_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+inline
+sc_fxnum_bitref&
+sc_fxnum_bitref::operator &= ( const sc_bit& b )
+{
+    SC_FXNUM_OBSERVER_READ_( m_num )
+    set( get() && static_cast<bool>( b ) );
+    SC_FXNUM_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+inline
+sc_fxnum_bitref&
+sc_fxnum_bitref::operator &= ( bool b )
+{
+    SC_FXNUM_OBSERVER_READ_( m_num )
+    set( get() && b );
+    SC_FXNUM_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+
+inline
+sc_fxnum_bitref&
+sc_fxnum_bitref::operator |= ( const sc_fxnum_bitref& b )
+{
+    SC_FXNUM_OBSERVER_READ_( m_num )
+    SC_FXNUM_OBSERVER_READ_( b.m_num )
+    set( get() || b.get() );
+    SC_FXNUM_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+inline
+sc_fxnum_bitref&
+sc_fxnum_bitref::operator |= ( const sc_fxnum_fast_bitref& b )
+{
+    SC_FXNUM_OBSERVER_READ_( m_num )
+    SC_FXNUM_FAST_OBSERVER_READ_( b.m_num )
+    set( get() || b.get() );
+    SC_FXNUM_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+inline
+sc_fxnum_bitref&
+sc_fxnum_bitref::operator |= ( const sc_bit& b )
+{
+    SC_FXNUM_OBSERVER_READ_( m_num )
+    set( get() || static_cast<bool>( b ) );
+    SC_FXNUM_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+inline
+sc_fxnum_bitref&
+sc_fxnum_bitref::operator |= ( bool b )
+{
+    SC_FXNUM_OBSERVER_READ_( m_num )
+    set( get() || b );
+    SC_FXNUM_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+
+inline
+sc_fxnum_bitref&
+sc_fxnum_bitref::operator ^= ( const sc_fxnum_bitref& b )
+{
+    SC_FXNUM_OBSERVER_READ_( m_num )
+    SC_FXNUM_OBSERVER_READ_( b.m_num )
+    set( get() != b.get() );
+    SC_FXNUM_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+inline
+sc_fxnum_bitref&
+sc_fxnum_bitref::operator ^= ( const sc_fxnum_fast_bitref& b )
+{
+    SC_FXNUM_OBSERVER_READ_( m_num )
+    SC_FXNUM_FAST_OBSERVER_READ_( b.m_num )
+    set( get() != b.get() );
+    SC_FXNUM_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+inline
+sc_fxnum_bitref&
+sc_fxnum_bitref::operator ^= ( const sc_bit& b )
+{
+    SC_FXNUM_OBSERVER_READ_( m_num )
+    set( get() != static_cast<bool>( b ) );
+    SC_FXNUM_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+inline
+sc_fxnum_bitref&
+sc_fxnum_bitref::operator ^= ( bool b )
+{
+    SC_FXNUM_OBSERVER_READ_( m_num )
+    set( get() != b );
+    SC_FXNUM_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+
+// implicit conversion
+
+inline
+sc_fxnum_bitref::operator bool() const
+{
+    SC_FXNUM_OBSERVER_READ_( m_num )
+    return get();
+}
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_fxnum_bitref& a )
+{
+    a.print( os );
+    return os;
+}
+
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_fxnum_bitref& a )
+{
+    a.scan( is );
+    return is;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum_fast_bitref
+//
+//  Proxy class for bit-selection in class sc_fxnum_fast, behaves like sc_bit.
+// ----------------------------------------------------------------------------
+
+// constructor
+
+inline
+sc_fxnum_fast_bitref::sc_fxnum_fast_bitref( sc_fxnum_fast& num_, int idx_ )
+    : m_num( num_ ), m_idx( idx_ )
+{}
+
+
+// copy constructor
+
+inline
+sc_fxnum_fast_bitref::sc_fxnum_fast_bitref( const sc_fxnum_fast_bitref& a )
+    : m_num( a.m_num ), m_idx( a.m_idx )
+{}
+
+
+// assignment operators
+
+inline
+sc_fxnum_fast_bitref&
+sc_fxnum_fast_bitref::operator = ( const sc_fxnum_bitref& a )
+{
+    SC_FXNUM_OBSERVER_READ_( a.m_num )
+    set( a.get() );
+    SC_FXNUM_FAST_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+inline
+sc_fxnum_fast_bitref&
+sc_fxnum_fast_bitref::operator = ( const sc_fxnum_fast_bitref& a )
+{
+    if( &a != this )
+    {
+	SC_FXNUM_FAST_OBSERVER_READ_( a.m_num )
+	set( a.get() );
+	SC_FXNUM_FAST_OBSERVER_WRITE_( m_num )
+    }
+    return *this;
+}
+
+inline
+sc_fxnum_fast_bitref&
+sc_fxnum_fast_bitref::operator = ( const sc_bit& a )
+{
+    set( static_cast<bool>( a ) );
+    SC_FXNUM_FAST_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+inline
+sc_fxnum_fast_bitref&
+sc_fxnum_fast_bitref::operator = ( bool a )
+{
+    set( a );
+    SC_FXNUM_FAST_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+
+inline
+sc_fxnum_fast_bitref&
+sc_fxnum_fast_bitref::operator &= ( const sc_fxnum_bitref& b )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( m_num )
+    SC_FXNUM_OBSERVER_READ_( b.m_num )
+    set( get() && b.get() );
+    SC_FXNUM_FAST_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+inline
+sc_fxnum_fast_bitref&
+sc_fxnum_fast_bitref::operator &= ( const sc_fxnum_fast_bitref& b )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( m_num )
+    SC_FXNUM_FAST_OBSERVER_READ_( b.m_num )
+    set( get() && b.get() );
+    SC_FXNUM_FAST_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+inline
+sc_fxnum_fast_bitref&
+sc_fxnum_fast_bitref::operator &= ( const sc_bit& b )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( m_num )
+    set( get() && static_cast<bool>( b ) );
+    SC_FXNUM_FAST_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+inline
+sc_fxnum_fast_bitref&
+sc_fxnum_fast_bitref::operator &= ( bool b )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( m_num )
+    set( get() && b );
+    SC_FXNUM_FAST_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+
+inline
+sc_fxnum_fast_bitref&
+sc_fxnum_fast_bitref::operator |= ( const sc_fxnum_bitref& b )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( m_num )
+    SC_FXNUM_OBSERVER_READ_( b.m_num )
+    set( get() || b.get() );
+    SC_FXNUM_FAST_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+inline
+sc_fxnum_fast_bitref&
+sc_fxnum_fast_bitref::operator |= ( const sc_fxnum_fast_bitref& b )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( m_num )
+    SC_FXNUM_FAST_OBSERVER_READ_( b.m_num )
+    set( get() || b.get() );
+    SC_FXNUM_FAST_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+inline
+sc_fxnum_fast_bitref&
+sc_fxnum_fast_bitref::operator |= ( const sc_bit& b )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( m_num )
+    set( get() || static_cast<bool>( b ) );
+    SC_FXNUM_FAST_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+inline
+sc_fxnum_fast_bitref&
+sc_fxnum_fast_bitref::operator |= ( bool b )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( m_num )
+    set( get() || b );
+    SC_FXNUM_FAST_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+
+inline
+sc_fxnum_fast_bitref&
+sc_fxnum_fast_bitref::operator ^= ( const sc_fxnum_bitref& b )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( m_num )
+    SC_FXNUM_OBSERVER_READ_( b.m_num )
+    set( get() != b.get() );
+    SC_FXNUM_FAST_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+inline
+sc_fxnum_fast_bitref&
+sc_fxnum_fast_bitref::operator ^= ( const sc_fxnum_fast_bitref& b )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( m_num )
+    SC_FXNUM_FAST_OBSERVER_READ_( b.m_num )
+    set( get() != b.get() );
+    SC_FXNUM_FAST_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+inline
+sc_fxnum_fast_bitref&
+sc_fxnum_fast_bitref::operator ^= ( const sc_bit& b )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( m_num )
+    set( get() != static_cast<bool>( b ) );
+    SC_FXNUM_FAST_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+inline
+sc_fxnum_fast_bitref&
+sc_fxnum_fast_bitref::operator ^= ( bool b )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( m_num )
+    set( get() != b );
+    SC_FXNUM_FAST_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+
+// implicit conversion
+
+inline
+sc_fxnum_fast_bitref::operator bool() const
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( m_num )
+    return get();
+}
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_fxnum_fast_bitref& a )
+{
+    a.print( os );
+    return os;
+}
+
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_fxnum_fast_bitref& a )
+{
+    a.scan( is );
+    return is;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum_subref
+//
+//  Proxy class for part-selection in class sc_fxnum,
+//  behaves like sc_bv_base.
+// ----------------------------------------------------------------------------
+
+// constructor
+
+inline
+sc_fxnum_subref::sc_fxnum_subref( sc_fxnum& num_, int from_, int to_ )
+    : m_num( num_ ), m_from( from_ ), m_to( to_ ),
+      m_bv( *new sc_bv_base( sc_max( m_from, m_to ) -
+			     sc_min( m_from, m_to ) + 1 ) )
+{}
+
+
+// copy constructor
+
+inline
+sc_fxnum_subref::sc_fxnum_subref( const sc_fxnum_subref& a )
+    : m_num( a.m_num ), m_from( a.m_from ), m_to( a.m_to ),
+      m_bv( *new sc_bv_base( a.m_bv ) )
+{}
+
+
+// destructor
+
+inline
+sc_fxnum_subref::~sc_fxnum_subref()
+{
+    delete &m_bv;
+}
+
+
+// assignment operators
+
+inline
+sc_fxnum_subref&
+sc_fxnum_subref::operator = ( const sc_fxnum_subref& a )
+{
+    if( &a != this )
+    {
+	m_bv = static_cast<sc_bv_base>( a );
+	set();
+	SC_FXNUM_OBSERVER_WRITE_( m_num )
+    }
+    return *this;
+}
+
+inline
+sc_fxnum_subref&
+sc_fxnum_subref::operator = ( const sc_fxnum_fast_subref& a )
+{
+    m_bv = static_cast<sc_bv_base>( a );
+    set();
+    SC_FXNUM_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+#define DEFN_ASN_OP_T(tp)                                                     \
+inline                                                                        \
+sc_fxnum_subref&                                                              \
+sc_fxnum_subref::operator = ( tp a )                                          \
+{                                                                             \
+    m_bv = a;                                                                 \
+    set();                                                                    \
+    SC_FXNUM_OBSERVER_WRITE_( m_num )                                         \
+    return *this;                                                             \
+}
+
+DEFN_ASN_OP_T(const sc_bv_base&)
+DEFN_ASN_OP_T(const sc_lv_base&)
+DEFN_ASN_OP_T(const char*)
+DEFN_ASN_OP_T(const bool*)
+DEFN_ASN_OP_T(const sc_signed&)
+DEFN_ASN_OP_T(const sc_unsigned&)
+DEFN_ASN_OP_T(const sc_int_base&)
+DEFN_ASN_OP_T(const sc_uint_base&)
+DEFN_ASN_OP_T(int64)
+DEFN_ASN_OP_T(uint64)
+DEFN_ASN_OP_T(int)
+DEFN_ASN_OP_T(unsigned int)
+DEFN_ASN_OP_T(long)
+DEFN_ASN_OP_T(unsigned long)
+DEFN_ASN_OP_T(char)
+
+#undef DEFN_ASN_OP_T
+
+
+#define DEFN_ASN_OP_T(op,tp)                                                  \
+inline                                                                        \
+sc_fxnum_subref&                                                              \
+sc_fxnum_subref::operator op ## = ( tp a )                                    \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( m_num )                                          \
+    get();                                                                    \
+    m_bv = m_bv op a;                                                         \
+    set();                                                                    \
+    SC_FXNUM_OBSERVER_WRITE_( m_num )                                         \
+    return *this;                                                             \
+}
+
+#define DEFN_ASN_OP(op)                                                       \
+inline                                                                        \
+sc_fxnum_subref&                                                              \
+sc_fxnum_subref::operator op ## = ( const sc_fxnum_subref& a )                \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( m_num )                                          \
+    get();                                                                    \
+    m_bv = m_bv op static_cast<sc_bv_base>( a );                              \
+    set();                                                                    \
+    SC_FXNUM_OBSERVER_WRITE_( m_num )                                         \
+    return *this;                                                             \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+sc_fxnum_subref&                                                              \
+sc_fxnum_subref::operator op ## = ( const sc_fxnum_fast_subref& a )           \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( m_num )                                          \
+    get();                                                                    \
+    m_bv = m_bv op static_cast<sc_bv_base>( a );                              \
+    set();                                                                    \
+    SC_FXNUM_OBSERVER_WRITE_( m_num )                                         \
+    return *this;                                                             \
+}                                                                             \
+                                                                              \
+DEFN_ASN_OP_T(op,const sc_bv_base&)                                           \
+DEFN_ASN_OP_T(op,const sc_lv_base&)
+
+DEFN_ASN_OP(&)
+DEFN_ASN_OP(|)
+DEFN_ASN_OP(^)
+
+#undef DEFN_ASN_OP_T
+#undef DEFN_ASN_OP
+
+
+// relational operators
+
+#define DEFN_REL_OP_T(op,tp)                                                  \
+inline                                                                        \
+bool                                                                          \
+operator op ( const sc_fxnum_subref& a, tp b )                                \
+{                                                                             \
+    return ( static_cast<sc_bv_base>( a ) op b );                             \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+bool                                                                          \
+operator op ( tp a, const sc_fxnum_subref& b )                                \
+{                                                                             \
+    return ( static_cast<sc_bv_base>( b ) op a );                             \
+}
+
+#define DEFN_REL_OP(op)                                                       \
+inline                                                                        \
+bool                                                                          \
+operator op ( const sc_fxnum_subref& a, const sc_fxnum_subref& b )            \
+{                                                                             \
+    return ( static_cast<sc_bv_base>( a ) op static_cast<sc_bv_base>( b ) );  \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+bool                                                                          \
+operator op ( const sc_fxnum_subref& a, const sc_fxnum_fast_subref& b )       \
+{                                                                             \
+    return ( static_cast<sc_bv_base>( a ) op static_cast<sc_bv_base>( b ) );  \
+}                                                                             \
+                                                                              \
+DEFN_REL_OP_T(op,const sc_bv_base&)                                           \
+DEFN_REL_OP_T(op,const sc_lv_base&)                                           \
+DEFN_REL_OP_T(op,const char*)                                                 \
+DEFN_REL_OP_T(op,const bool*)                                                 \
+DEFN_REL_OP_T(op,const sc_signed&)                                            \
+DEFN_REL_OP_T(op,const sc_unsigned&)                                          \
+DEFN_REL_OP_T(op,int)                                                         \
+DEFN_REL_OP_T(op,unsigned int)                                                \
+DEFN_REL_OP_T(op,long)                                                        \
+DEFN_REL_OP_T(op,unsigned long)
+
+DEFN_REL_OP(==)
+DEFN_REL_OP(!=)
+
+#undef DEFN_REL_OP_T
+#undef DEFN_REL_OP
+
+
+// reduce functions
+
+#define DEFN_RED_FNC(fnc)                                                     \
+inline                                                                        \
+bool                                                                          \
+sc_fxnum_subref::fnc() const                                                  \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( m_num )                                          \
+    get();                                                                    \
+    return static_cast<bool>( m_bv.fnc() );                                   \
+}
+
+DEFN_RED_FNC(and_reduce)
+DEFN_RED_FNC(nand_reduce)
+DEFN_RED_FNC(or_reduce)
+DEFN_RED_FNC(nor_reduce)
+DEFN_RED_FNC(xor_reduce)
+DEFN_RED_FNC(xnor_reduce)
+
+#undef DEFN_RED_FNC
+
+
+// query parameter
+
+inline
+int
+sc_fxnum_subref::length() const
+{
+    return m_bv.length();
+}
+
+
+// explicit conversions
+
+inline
+int
+sc_fxnum_subref::to_int() const
+{
+    SC_FXNUM_OBSERVER_READ_( m_num )
+    get();
+    return m_bv.to_int();
+}
+
+inline
+int64
+sc_fxnum_subref::to_int64() const
+{
+    SC_FXNUM_OBSERVER_READ_( m_num )
+    get();
+    return m_bv.to_int64();
+}
+
+inline
+unsigned int
+sc_fxnum_subref::to_uint() const
+{
+    SC_FXNUM_OBSERVER_READ_( m_num )
+    get();
+    return m_bv.to_uint();
+}
+
+inline
+uint64
+sc_fxnum_subref::to_uint64() const
+{
+    SC_FXNUM_OBSERVER_READ_( m_num )
+    get();
+    return m_bv.to_uint64();
+}
+
+inline
+long
+sc_fxnum_subref::to_long() const
+{
+    SC_FXNUM_OBSERVER_READ_( m_num )
+    get();
+    return m_bv.to_long();
+}
+
+inline
+unsigned long
+sc_fxnum_subref::to_ulong() const
+{
+    SC_FXNUM_OBSERVER_READ_( m_num )
+    get();
+    return m_bv.to_ulong();
+}
+
+
+#ifdef SC_DT_DEPRECATED
+
+inline
+int
+sc_fxnum_subref::to_signed() const
+{
+    return to_int();
+}
+
+inline
+unsigned int
+sc_fxnum_subref::to_unsigned() const
+{
+    return to_uint();
+}
+
+#endif
+
+
+inline
+const std::string
+sc_fxnum_subref::to_string() const
+{
+    get();
+    return m_bv.to_string();
+}
+
+inline
+const std::string
+sc_fxnum_subref::to_string( sc_numrep numrep ) const
+{
+    get();
+    return m_bv.to_string( numrep );
+}
+
+inline
+const std::string
+sc_fxnum_subref::to_string( sc_numrep numrep, bool w_prefix ) const
+{
+    get();
+    return m_bv.to_string( numrep, w_prefix );
+}
+
+
+// implicit conversion
+
+inline
+sc_fxnum_subref::operator sc_bv_base () const
+{
+    SC_FXNUM_OBSERVER_READ_( m_num )
+    get();
+    return m_bv;
+}
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_fxnum_subref& a )
+{
+    a.print( os );
+    return os;
+}
+
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_fxnum_subref& a )
+{
+    a.scan( is );
+    return is;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum_fast_subref
+//
+//  Proxy class for part-selection in class sc_fxnum_fast,
+//  behaves like sc_bv_base.
+// ----------------------------------------------------------------------------
+
+// constructor
+
+inline
+sc_fxnum_fast_subref::sc_fxnum_fast_subref( sc_fxnum_fast& num_,
+					    int from_, int to_ )
+    : m_num( num_ ), m_from( from_ ), m_to( to_ ),
+      m_bv( *new sc_bv_base( sc_max( m_from, m_to ) -
+			     sc_min( m_from, m_to ) + 1 ) )
+{}
+
+
+// copy constructor
+
+inline
+sc_fxnum_fast_subref::sc_fxnum_fast_subref( const sc_fxnum_fast_subref& a )
+    : m_num( a.m_num ), m_from( a.m_from ), m_to( a.m_to ),
+      m_bv( *new sc_bv_base( a.m_bv ) )
+{}
+
+
+// destructor
+
+inline
+sc_fxnum_fast_subref::~sc_fxnum_fast_subref()
+{
+    delete &m_bv;
+}
+
+
+// assignment operators
+
+inline
+sc_fxnum_fast_subref&
+sc_fxnum_fast_subref::operator = ( const sc_fxnum_subref& a )
+{
+    m_bv = static_cast<sc_bv_base>( a );
+    set();
+    SC_FXNUM_FAST_OBSERVER_WRITE_( m_num )
+    return *this;
+}
+
+inline
+sc_fxnum_fast_subref&
+sc_fxnum_fast_subref::operator = ( const sc_fxnum_fast_subref& a )
+{
+    if( &a != this )
+    {
+	m_bv = static_cast<sc_bv_base>( a );
+	set();
+	SC_FXNUM_FAST_OBSERVER_WRITE_( m_num )
+    }
+    return *this;
+}
+
+#define DEFN_ASN_OP_T(tp)                                                     \
+inline                                                                        \
+sc_fxnum_fast_subref&                                                         \
+sc_fxnum_fast_subref::operator = ( tp a )                                     \
+{                                                                             \
+    m_bv = a;                                                                 \
+    set();                                                                    \
+    SC_FXNUM_FAST_OBSERVER_WRITE_( m_num )                                    \
+    return *this;                                                             \
+}
+
+DEFN_ASN_OP_T(const sc_bv_base&)
+DEFN_ASN_OP_T(const sc_lv_base&)
+DEFN_ASN_OP_T(const char*)
+DEFN_ASN_OP_T(const bool*)
+DEFN_ASN_OP_T(const sc_signed&)
+DEFN_ASN_OP_T(const sc_unsigned&)
+DEFN_ASN_OP_T(const sc_int_base&)
+DEFN_ASN_OP_T(const sc_uint_base&)
+DEFN_ASN_OP_T(int64)
+DEFN_ASN_OP_T(uint64)
+DEFN_ASN_OP_T(int)
+DEFN_ASN_OP_T(unsigned int)
+DEFN_ASN_OP_T(long)
+DEFN_ASN_OP_T(unsigned long)
+DEFN_ASN_OP_T(char)
+
+#undef DEFN_ASN_OP_T
+
+
+#define DEFN_ASN_OP_T(op,tp)                                                  \
+inline                                                                        \
+sc_fxnum_fast_subref&                                                         \
+sc_fxnum_fast_subref::operator op ## = ( tp a )                               \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( m_num )                                     \
+    get();                                                                    \
+    m_bv = m_bv op a;                                                         \
+    set();                                                                    \
+    SC_FXNUM_FAST_OBSERVER_WRITE_( m_num )                                    \
+    return *this;                                                             \
+}
+
+#define DEFN_ASN_OP(op)                                                       \
+inline                                                                        \
+sc_fxnum_fast_subref&                                                         \
+sc_fxnum_fast_subref::operator op ## = ( const sc_fxnum_subref& a )           \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( m_num )                                     \
+    get();                                                                    \
+    m_bv = m_bv op static_cast<sc_bv_base>( a );                              \
+    set();                                                                    \
+    SC_FXNUM_FAST_OBSERVER_WRITE_( m_num )                                    \
+    return *this;                                                             \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+sc_fxnum_fast_subref&                                                         \
+sc_fxnum_fast_subref::operator op ## = ( const sc_fxnum_fast_subref& a )      \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( m_num )                                     \
+    get();                                                                    \
+    m_bv = m_bv op static_cast<sc_bv_base>( a );                              \
+    set();                                                                    \
+    SC_FXNUM_FAST_OBSERVER_WRITE_( m_num )                                    \
+    return *this;                                                             \
+}                                                                             \
+                                                                              \
+DEFN_ASN_OP_T(op,const sc_bv_base&)                                           \
+DEFN_ASN_OP_T(op,const sc_lv_base&)
+
+DEFN_ASN_OP(&)
+DEFN_ASN_OP(|)
+DEFN_ASN_OP(^)
+
+#undef DEFN_ASN_OP_T
+#undef DEFN_ASN_OP
+
+
+// relational operators
+
+#define DEFN_REL_OP_T(op,tp)                                                  \
+inline                                                                        \
+bool                                                                          \
+operator op ( const sc_fxnum_fast_subref& a, tp b )                           \
+{                                                                             \
+    return ( static_cast<sc_bv_base>( a ) op b );                             \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+bool                                                                          \
+operator op ( tp a, const sc_fxnum_fast_subref& b )                           \
+{                                                                             \
+    return ( static_cast<sc_bv_base>( b ) op a );                             \
+}
+
+#define DEFN_REL_OP(op)                                                       \
+inline                                                                        \
+bool                                                                          \
+operator op ( const sc_fxnum_fast_subref& a, const sc_fxnum_fast_subref& b )  \
+{                                                                             \
+    return ( static_cast<sc_bv_base>( a ) op static_cast<sc_bv_base>( b ) );  \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+bool                                                                          \
+operator op ( const sc_fxnum_fast_subref& a, const sc_fxnum_subref& b )       \
+{                                                                             \
+    return ( static_cast<sc_bv_base>( a ) op static_cast<sc_bv_base>( b ) );  \
+}                                                                             \
+                                                                              \
+DEFN_REL_OP_T(op,const sc_bv_base&)                                           \
+DEFN_REL_OP_T(op,const sc_lv_base&)                                           \
+DEFN_REL_OP_T(op,const char*)                                                 \
+DEFN_REL_OP_T(op,const bool*)                                                 \
+DEFN_REL_OP_T(op,const sc_signed&)                                            \
+DEFN_REL_OP_T(op,const sc_unsigned&)                                          \
+DEFN_REL_OP_T(op,int)                                                         \
+DEFN_REL_OP_T(op,unsigned int)                                                \
+DEFN_REL_OP_T(op,long)                                                        \
+DEFN_REL_OP_T(op,unsigned long)
+
+DEFN_REL_OP(==)
+DEFN_REL_OP(!=)
+
+#undef DEFN_REL_OP_T
+#undef DEFN_REL_OP
+
+
+// reduce functions
+
+#define DEFN_RED_FNC(fnc)                                                     \
+inline                                                                        \
+bool                                                                          \
+sc_fxnum_fast_subref::fnc() const                                             \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( m_num )                                     \
+    get();                                                                    \
+    return static_cast<bool>( m_bv.fnc() );                                   \
+}
+
+DEFN_RED_FNC(and_reduce)
+DEFN_RED_FNC(nand_reduce)
+DEFN_RED_FNC(or_reduce)
+DEFN_RED_FNC(nor_reduce)
+DEFN_RED_FNC(xor_reduce)
+DEFN_RED_FNC(xnor_reduce)
+
+#undef DEFN_RED_FNC
+
+
+// query parameter
+
+inline
+int
+sc_fxnum_fast_subref::length() const
+{
+    return m_bv.length();
+}
+
+
+// explicit conversions
+
+inline
+int
+sc_fxnum_fast_subref::to_int() const
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( m_num )
+    get();
+    return m_bv.to_int();
+}
+
+inline
+int64
+sc_fxnum_fast_subref::to_int64() const
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( m_num )
+    get();
+    return m_bv.to_int64();
+}
+
+inline
+unsigned int
+sc_fxnum_fast_subref::to_uint() const
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( m_num )
+    get();
+    return m_bv.to_uint();
+}
+
+inline
+uint64
+sc_fxnum_fast_subref::to_uint64() const
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( m_num )
+    get();
+    return m_bv.to_uint64();
+}
+
+inline
+long
+sc_fxnum_fast_subref::to_long() const
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( m_num )
+    get();
+    return m_bv.to_long();
+}
+
+inline
+unsigned long
+sc_fxnum_fast_subref::to_ulong() const
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( m_num )
+    get();
+    return m_bv.to_ulong();
+}
+
+
+#ifdef SC_DT_DEPRECATED
+
+inline
+int
+sc_fxnum_fast_subref::to_signed() const
+{
+    return to_int();
+}
+
+inline
+unsigned int
+sc_fxnum_fast_subref::to_unsigned() const
+{
+    return to_uint();
+}
+
+#endif
+
+
+inline
+const std::string
+sc_fxnum_fast_subref::to_string() const
+{
+    get();
+    return m_bv.to_string();
+}
+
+inline
+const std::string
+sc_fxnum_fast_subref::to_string( sc_numrep numrep ) const
+{
+    get();
+    return m_bv.to_string( numrep );
+}
+
+inline
+const std::string
+sc_fxnum_fast_subref::to_string( sc_numrep numrep, bool w_prefix ) const
+{
+    get();
+    return m_bv.to_string( numrep, w_prefix );
+}
+
+
+// implicit conversion
+
+inline
+sc_fxnum_fast_subref::operator sc_bv_base () const
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( m_num )
+    get();
+    return m_bv;
+}
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_fxnum_fast_subref& a )
+{
+    a.print( os );
+    return os;
+}
+
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_fxnum_fast_subref& a )
+{
+    a.scan( is );
+    return is;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum
+//
+//  Base class for the fixed-point types; arbitrary precision.
+// ----------------------------------------------------------------------------
+
+inline
+sc_fxnum_observer*
+sc_fxnum::observer() const
+{
+    return m_observer;
+}
+
+
+inline
+void
+sc_fxnum::cast()
+{
+    SC_ERROR_IF_( ! m_rep->is_normal(), sc_core::SC_ID_INVALID_FX_VALUE_ );
+
+    if( m_params.cast_switch() == SC_ON )
+	m_rep->cast( m_params, m_q_flag, m_o_flag );
+}
+
+
+// constructors
+
+inline
+sc_fxnum::sc_fxnum( const sc_fxtype_params& type_params_,
+		    sc_enc enc_,
+		    const sc_fxcast_switch& cast_sw,
+		    sc_fxnum_observer* observer_ )
+: m_rep( new scfx_rep ),
+  m_params( type_params_, enc_, cast_sw ),
+  m_q_flag( false ),
+  m_o_flag( false ),
+  m_observer( observer_ )
+{
+    SC_FXNUM_OBSERVER_DEFAULT_
+    SC_FXNUM_OBSERVER_CONSTRUCT_( *this )
+}
+
+#define DEFN_CTOR_T(tp,arg)                                                   \
+inline                                                                        \
+sc_fxnum::sc_fxnum( tp a,                                                     \
+		    const sc_fxtype_params& type_params_,                     \
+		    sc_enc enc_,                                              \
+		    const sc_fxcast_switch& cast_sw,                          \
+		    sc_fxnum_observer* observer_ )                            \
+: m_rep( new scfx_rep( arg ) ),                                               \
+  m_params( type_params_, enc_, cast_sw ),                                    \
+  m_q_flag( false ),                                                          \
+  m_o_flag( false ),                                                          \
+  m_observer( observer_ )                                                     \
+{                                                                             \
+    SC_FXNUM_OBSERVER_DEFAULT_                                                \
+    cast();                                                                   \
+    SC_FXNUM_OBSERVER_CONSTRUCT_( *this )                                     \
+    SC_FXNUM_OBSERVER_WRITE_( *this )                                         \
+}
+
+#define DEFN_CTOR_T_A(tp) DEFN_CTOR_T(tp,a)
+#define DEFN_CTOR_T_B(tp) DEFN_CTOR_T(tp,*a.m_rep)
+#define DEFN_CTOR_T_C(tp) DEFN_CTOR_T(tp,a.to_double())
+#define DEFN_CTOR_T_D(tp) DEFN_CTOR_T(tp,a.value())
+
+DEFN_CTOR_T_A(int)
+DEFN_CTOR_T_A(unsigned int)
+DEFN_CTOR_T_A(long)
+DEFN_CTOR_T_A(unsigned long)
+DEFN_CTOR_T_A(float)
+DEFN_CTOR_T_A(double)
+DEFN_CTOR_T_A(const char*)
+DEFN_CTOR_T_B(const sc_fxval&)
+DEFN_CTOR_T_C(const sc_fxval_fast&)
+DEFN_CTOR_T_B(const sc_fxnum&)
+DEFN_CTOR_T_C(const sc_fxnum_fast&)
+#ifndef SC_FX_EXCLUDE_OTHER
+DEFN_CTOR_T_A(int64)
+DEFN_CTOR_T_A(uint64)
+DEFN_CTOR_T_D(const sc_int_base&)
+DEFN_CTOR_T_D(const sc_uint_base&)
+DEFN_CTOR_T_A(const sc_signed&)
+DEFN_CTOR_T_A(const sc_unsigned&)
+#endif
+
+#undef DEFN_CTOR_T
+#undef DEFN_CTOR_T_A
+#undef DEFN_CTOR_T_B
+#undef DEFN_CTOR_T_C
+#undef DEFN_CTOR_T_D
+
+
+inline
+sc_fxnum::~sc_fxnum()
+{
+    SC_FXNUM_OBSERVER_DESTRUCT_( *this )
+    delete m_rep;
+}
+
+
+// internal use only;
+inline
+const scfx_rep*
+sc_fxnum::get_rep() const
+{
+    SC_FXNUM_OBSERVER_READ_( *this )
+    return m_rep;
+}
+
+
+// unary operators
+
+inline
+const sc_fxval
+sc_fxnum::operator - () const
+{
+    SC_FXNUM_OBSERVER_READ_( *this )
+    return sc_fxval( sc_dt::neg_scfx_rep( *m_rep ) );
+}
+
+inline
+const sc_fxval
+sc_fxnum::operator + () const
+{
+    SC_FXNUM_OBSERVER_READ_( *this )
+    return sc_fxval( new scfx_rep( *m_rep ) );
+}
+
+
+// unary functions
+
+inline
+void
+neg( sc_fxval& c, const sc_fxnum& a )
+{
+    SC_FXNUM_OBSERVER_READ_( a )
+    c.set_rep( sc_dt::neg_scfx_rep( *a.m_rep ) );
+}
+
+inline
+void
+neg( sc_fxnum& c, const sc_fxnum& a )
+{
+    SC_FXNUM_OBSERVER_READ_( a )
+    delete c.m_rep;
+    c.m_rep = sc_dt::neg_scfx_rep( *a.m_rep );
+    c.cast();
+    SC_FXNUM_OBSERVER_WRITE_( c )
+}
+
+
+// binary operators
+
+#define DEFN_BIN_OP_T(op,fnc,tp)                                              \
+inline                                                                        \
+const sc_fxval                                                                \
+operator op ( const sc_fxnum& a, tp b )                                       \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( a )                                              \
+    sc_fxval tmp( b );                                                        \
+    return sc_fxval( sc_dt::fnc ## _scfx_rep( *a.m_rep, *tmp.get_rep() ) );  \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+const sc_fxval                                                                \
+operator op ( tp a, const sc_fxnum& b )                                       \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( b )                                              \
+    sc_fxval tmp( a );                                                        \
+    return sc_fxval( sc_dt::fnc ## _scfx_rep( *tmp.get_rep(), *b.m_rep ) );  \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_BIN_OP_OTHER(op,fnc)                                             \
+DEFN_BIN_OP_T(op,fnc,int64)                                                   \
+DEFN_BIN_OP_T(op,fnc,uint64)                                                  \
+DEFN_BIN_OP_T(op,fnc,const sc_int_base&)                                      \
+DEFN_BIN_OP_T(op,fnc,const sc_uint_base&)                                     \
+DEFN_BIN_OP_T(op,fnc,const sc_signed&)                                        \
+DEFN_BIN_OP_T(op,fnc,const sc_unsigned&)
+#else
+#define DEFN_BIN_OP_OTHER(op,fnc)
+#endif
+
+#define DEFN_BIN_OP(op,fnc)                                                   \
+inline                                                                        \
+const sc_fxval                                                                \
+operator op ( const sc_fxnum& a, const sc_fxnum& b )                          \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( a )                                              \
+    SC_FXNUM_OBSERVER_READ_( b )                                              \
+    return sc_fxval( sc_dt::fnc ## _scfx_rep( *a.m_rep, *b.m_rep ) );        \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+const sc_fxval                                                                \
+operator op ( const sc_fxnum& a, const sc_fxval& b )                          \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( a )                                              \
+    return sc_fxval( sc_dt::fnc ## _scfx_rep( *a.m_rep, *b.get_rep() ) );    \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+const sc_fxval                                                                \
+operator op ( const sc_fxval& a, const sc_fxnum& b )                          \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( b )                                              \
+    return sc_fxval( sc_dt::fnc ## _scfx_rep( *a.get_rep(), *b.m_rep ) );    \
+}                                                                             \
+                                                                              \
+DEFN_BIN_OP_T(op,fnc,int)                                                     \
+DEFN_BIN_OP_T(op,fnc,unsigned int)                                            \
+DEFN_BIN_OP_T(op,fnc,long)                                                    \
+DEFN_BIN_OP_T(op,fnc,unsigned long)                                           \
+DEFN_BIN_OP_T(op,fnc,float)                                                  \
+DEFN_BIN_OP_T(op,fnc,double)                                                  \
+DEFN_BIN_OP_T(op,fnc,const char*)                                             \
+DEFN_BIN_OP_T(op,fnc,const sc_fxval_fast&)                                    \
+DEFN_BIN_OP_T(op,fnc,const sc_fxnum_fast&)                                    \
+DEFN_BIN_OP_OTHER(op,fnc)
+
+DEFN_BIN_OP(*,mult)
+DEFN_BIN_OP(+,add)
+DEFN_BIN_OP(-,sub)
+// don't use macros
+//DEFN_BIN_OP(/,div)
+inline
+const sc_fxval
+operator / ( const sc_fxnum& a, const sc_fxnum& b )
+{
+    SC_FXNUM_OBSERVER_READ_( a )
+    SC_FXNUM_OBSERVER_READ_( b )
+    return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *b.m_rep ) );
+}
+
+inline
+const sc_fxval
+operator / ( const sc_fxnum& a, const sc_fxval& b )
+{
+    SC_FXNUM_OBSERVER_READ_( a )
+    return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *b.get_rep() ) );
+}
+
+inline
+const sc_fxval
+operator / ( const sc_fxval& a, const sc_fxnum& b )
+{
+    SC_FXNUM_OBSERVER_READ_( b )
+    return sc_fxval( sc_dt::div_scfx_rep( *a.get_rep(), *b.m_rep ) );
+}
+
+DEFN_BIN_OP_T(/,div,int)
+DEFN_BIN_OP_T(/,div,unsigned int)
+DEFN_BIN_OP_T(/,div,long)
+DEFN_BIN_OP_T(/,div,unsigned long)
+DEFN_BIN_OP_T(/,div,float)
+DEFN_BIN_OP_T(/,div,double)
+DEFN_BIN_OP_T(/,div,const char*)
+DEFN_BIN_OP_T(/,div,const sc_fxval_fast&)
+DEFN_BIN_OP_T(/,div,const sc_fxnum_fast&)
+//DEFN_BIN_OP_OTHER(/,div)
+#ifndef SC_FX_EXCLUDE_OTHER
+DEFN_BIN_OP_T(/,div,int64)
+DEFN_BIN_OP_T(/,div,uint64)
+DEFN_BIN_OP_T(/,div,const sc_int_base&)
+DEFN_BIN_OP_T(/,div,const sc_uint_base&)
+DEFN_BIN_OP_T(/,div,const sc_signed&)
+DEFN_BIN_OP_T(/,div,const sc_unsigned&)
+#endif
+
+#undef DEFN_BIN_OP_T
+#undef DEFN_BIN_OP_OTHER
+#undef DEFN_BIN_OP
+
+
+inline
+const sc_fxval
+operator << ( const sc_fxnum& a, int b )
+{
+    SC_FXNUM_OBSERVER_READ_( a )
+    return sc_fxval( sc_dt::lsh_scfx_rep( *a.m_rep, b ) );
+}
+
+inline
+const sc_fxval
+operator >> ( const sc_fxnum& a, int b )
+{
+    SC_FXNUM_OBSERVER_READ_( a )
+    return sc_fxval( sc_dt::rsh_scfx_rep( *a.m_rep, b ) );
+}
+
+
+// binary functions
+
+#define DEFN_BIN_FNC_T(fnc,tp)                                                \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxval& c, const sc_fxnum& a, tp b )                                  \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( a )                                              \
+    sc_fxval tmp( b );                                                        \
+    c.set_rep( sc_dt::fnc ## _scfx_rep( *a.m_rep, *tmp.get_rep() ) );        \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxval& c, tp a, const sc_fxnum& b )                                  \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( b )                                              \
+    sc_fxval tmp( a );                                                        \
+    c.set_rep( sc_dt::fnc ## _scfx_rep( *tmp.get_rep(), *b.m_rep ) );        \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxnum& c, const sc_fxnum& a, tp b )                                  \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( a )                                              \
+    sc_fxval tmp( b );                                                        \
+    delete c.m_rep;                                                           \
+    c.m_rep = sc_dt::fnc ## _scfx_rep( *a.m_rep, *tmp.get_rep() );           \
+    c.cast();                                                                 \
+    SC_FXNUM_OBSERVER_WRITE_( c )                                             \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxnum& c, tp a, const sc_fxnum& b )                                  \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( b )                                              \
+    sc_fxval tmp( a );                                                        \
+    delete c.m_rep;                                                           \
+    c.m_rep = sc_dt::fnc ## _scfx_rep( *tmp.get_rep(), *b.m_rep );           \
+    c.cast();                                                                 \
+    SC_FXNUM_OBSERVER_WRITE_( c )                                             \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_BIN_FNC_OTHER(fnc)                                               \
+DEFN_BIN_FNC_T(fnc,int64)                                                     \
+DEFN_BIN_FNC_T(fnc,uint64)                                                    \
+DEFN_BIN_FNC_T(fnc,const sc_int_base&)                                        \
+DEFN_BIN_FNC_T(fnc,const sc_uint_base&)                                       \
+DEFN_BIN_FNC_T(fnc,const sc_signed&)                                          \
+DEFN_BIN_FNC_T(fnc,const sc_unsigned&)
+#else
+#define DEFN_BIN_FNC_OTHER(fnc)
+#endif
+
+#define DEFN_BIN_FNC(fnc)                                                     \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxval& c, const sc_fxnum& a, const sc_fxnum& b )                     \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( a )                                              \
+    SC_FXNUM_OBSERVER_READ_( b )                                              \
+    c.set_rep( sc_dt::fnc ## _scfx_rep( *a.m_rep, *b.m_rep ) );              \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxnum& c, const sc_fxnum& a, const sc_fxnum& b )                     \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( a )                                              \
+    SC_FXNUM_OBSERVER_READ_( b )                                              \
+    delete c.m_rep;                                                           \
+    c.m_rep = sc_dt::fnc ## _scfx_rep( *a.m_rep, *b.m_rep );                 \
+    c.cast();                                                                 \
+    SC_FXNUM_OBSERVER_WRITE_( c )                                             \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxval& c, const sc_fxnum& a, const sc_fxval& b )                     \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( a )                                              \
+    c.set_rep( sc_dt::fnc ## _scfx_rep( *a.m_rep, *b.get_rep() ) );          \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxval& c, const sc_fxval& a, const sc_fxnum& b )                     \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( b )                                              \
+    c.set_rep( sc_dt::fnc ## _scfx_rep( *a.get_rep(), *b.m_rep ) );          \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxnum& c, const sc_fxnum& a, const sc_fxval& b )                     \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( a )                                              \
+    delete c.m_rep;                                                           \
+    c.m_rep = sc_dt::fnc ## _scfx_rep( *a.m_rep, *b.get_rep() );             \
+    c.cast();                                                                 \
+    SC_FXNUM_OBSERVER_WRITE_( c )                                             \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxnum& c, const sc_fxval& a, const sc_fxnum& b )                     \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( b )                                              \
+    delete c.m_rep;                                                           \
+    c.m_rep = sc_dt::fnc ## _scfx_rep( *a.get_rep(), *b.m_rep );             \
+    c.cast();                                                                 \
+    SC_FXNUM_OBSERVER_WRITE_( c )                                             \
+}                                                                             \
+                                                                              \
+DEFN_BIN_FNC_T(fnc,int)                                                       \
+DEFN_BIN_FNC_T(fnc,unsigned int)                                              \
+DEFN_BIN_FNC_T(fnc,long)                                                      \
+DEFN_BIN_FNC_T(fnc,unsigned long)                                             \
+DEFN_BIN_FNC_T(fnc,float)                                                    \
+DEFN_BIN_FNC_T(fnc,double)                                                    \
+DEFN_BIN_FNC_T(fnc,const char*)                                               \
+DEFN_BIN_FNC_T(fnc,const sc_fxval_fast&)                                      \
+DEFN_BIN_FNC_T(fnc,const sc_fxnum_fast&)                                      \
+DEFN_BIN_FNC_OTHER(fnc)
+
+DEFN_BIN_FNC(mult)
+DEFN_BIN_FNC(div)
+DEFN_BIN_FNC(add)
+DEFN_BIN_FNC(sub)
+
+#undef DEFN_BIN_FNC_T
+#undef DEFN_BIN_FNC_OTHER
+#undef DEFN_BIN_FNC
+
+
+inline
+void
+lshift( sc_fxval& c, const sc_fxnum& a, int b )
+{
+    SC_FXNUM_OBSERVER_READ_( a )
+    c.set_rep( sc_dt::lsh_scfx_rep( *a.m_rep, b ) );
+}
+
+inline
+void
+rshift( sc_fxval& c, const sc_fxnum& a, int b )
+{
+    SC_FXNUM_OBSERVER_READ_( a )
+    c.set_rep( sc_dt::rsh_scfx_rep( *a.m_rep, b ) );
+}
+
+inline
+void
+lshift( sc_fxnum& c, const sc_fxnum& a, int b )
+{
+    SC_FXNUM_OBSERVER_READ_( a )
+    delete c.m_rep;
+    c.m_rep = sc_dt::lsh_scfx_rep( *a.m_rep, b );
+    c.cast();
+    SC_FXNUM_OBSERVER_WRITE_( c )
+}
+
+inline
+void
+rshift( sc_fxnum& c, const sc_fxnum& a, int b )
+{
+    SC_FXNUM_OBSERVER_READ_( a )
+    delete c.m_rep;
+    c.m_rep = sc_dt::rsh_scfx_rep( *a.m_rep, b );
+    c.cast();
+    SC_FXNUM_OBSERVER_WRITE_( c )
+}
+
+
+// relational (including equality) operators
+
+#define DEFN_REL_OP_T(op,ret,tp)                                              \
+inline                                                                        \
+bool                                                                          \
+operator op ( const sc_fxnum& a, tp b )                                       \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( a )                                              \
+    sc_fxval tmp( b );                                                        \
+    int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() );            \
+    return ( ret );                                                           \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+bool                                                                          \
+operator op ( tp a, const sc_fxnum& b )                                       \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( b )                                              \
+    sc_fxval tmp( a );                                                        \
+    int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep );            \
+    return ( ret );                                                           \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_REL_OP_OTHER(op,ret)                                             \
+DEFN_REL_OP_T(op,ret,int64)                                                   \
+DEFN_REL_OP_T(op,ret,uint64)                                                  \
+DEFN_REL_OP_T(op,ret,const sc_int_base&)                                      \
+DEFN_REL_OP_T(op,ret,const sc_uint_base&)                                     \
+DEFN_REL_OP_T(op,ret,const sc_signed&)                                        \
+DEFN_REL_OP_T(op,ret,const sc_unsigned&)
+#else
+#define DEFN_REL_OP_OTHER(op,ret)
+#endif
+
+#define DEFN_REL_OP(op,ret)                                                   \
+inline                                                                        \
+bool                                                                          \
+operator op ( const sc_fxnum& a, const sc_fxnum& b )                          \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( a )                                              \
+    SC_FXNUM_OBSERVER_READ_( b )                                              \
+    int result = sc_dt::cmp_scfx_rep( *a.m_rep, *b.m_rep );                  \
+    return ( ret );                                                           \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+bool                                                                          \
+operator op ( const sc_fxnum& a, const sc_fxval& b )                          \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( a )                                              \
+    int result = sc_dt::cmp_scfx_rep( *a.m_rep, *b.get_rep() );              \
+    return ( ret );                                                           \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+bool                                                                          \
+operator op ( const sc_fxval& a, const sc_fxnum& b )                          \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( b )                                              \
+    int result = sc_dt::cmp_scfx_rep( *a.get_rep(), *b.m_rep );              \
+    return ( ret );                                                           \
+}                                                                             \
+                                                                              \
+DEFN_REL_OP_T(op,ret,int)                                                     \
+DEFN_REL_OP_T(op,ret,unsigned int)                                            \
+DEFN_REL_OP_T(op,ret,long)                                                    \
+DEFN_REL_OP_T(op,ret,unsigned long)                                           \
+DEFN_REL_OP_T(op,ret,float)                                                  \
+DEFN_REL_OP_T(op,ret,double)                                                  \
+DEFN_REL_OP_T(op,ret,const char*)                                             \
+DEFN_REL_OP_T(op,ret,const sc_fxval_fast&)                                    \
+DEFN_REL_OP_T(op,ret,const sc_fxnum_fast&)                                    \
+DEFN_REL_OP_OTHER(op,ret)
+
+DEFN_REL_OP(<,result < 0)
+DEFN_REL_OP(<=,result <= 0)
+DEFN_REL_OP(>,result > 0 && result != 2)
+DEFN_REL_OP(>=,result >= 0 && result != 2)
+DEFN_REL_OP(==,result == 0)
+DEFN_REL_OP(!=,result != 0)
+
+#undef DEFN_REL_OP_T
+#undef DEFN_REL_OP_OTHER
+#undef DEFN_REL_OP
+
+
+// assignment operators
+
+inline
+sc_fxnum&
+sc_fxnum::operator = ( const sc_fxnum& a )
+{
+    if( &a != this )
+    {
+        SC_FXNUM_OBSERVER_READ_( a )
+	*m_rep = *a.m_rep;
+	cast();
+	SC_FXNUM_OBSERVER_WRITE_( *this )
+    }
+    return *this;
+}
+
+inline
+sc_fxnum&
+sc_fxnum::operator = ( const sc_fxval& a )
+{
+    *m_rep = *a.get_rep();
+    cast();
+    SC_FXNUM_OBSERVER_WRITE_( *this )
+    return *this;
+}
+
+#define DEFN_ASN_OP_T(tp)                                                     \
+inline                                                                        \
+sc_fxnum&                                                                     \
+sc_fxnum::operator = ( tp a )                                                 \
+{                                                                             \
+    sc_fxval tmp( a );                                                        \
+    *m_rep = *tmp.get_rep();                                                  \
+    cast();                                                                   \
+    SC_FXNUM_OBSERVER_WRITE_( *this )                                         \
+    return *this;                                                             \
+}
+
+DEFN_ASN_OP_T(int)
+DEFN_ASN_OP_T(unsigned int)
+DEFN_ASN_OP_T(long)
+DEFN_ASN_OP_T(unsigned long)
+DEFN_ASN_OP_T(float)
+DEFN_ASN_OP_T(double)
+DEFN_ASN_OP_T(const char*)
+DEFN_ASN_OP_T(const sc_fxval_fast&)
+DEFN_ASN_OP_T(const sc_fxnum_fast&)
+#ifndef SC_FX_EXCLUDE_OTHER
+DEFN_ASN_OP_T(int64)
+DEFN_ASN_OP_T(uint64)
+DEFN_ASN_OP_T(const sc_int_base&)
+DEFN_ASN_OP_T(const sc_uint_base&)
+DEFN_ASN_OP_T(const sc_signed&)
+DEFN_ASN_OP_T(const sc_unsigned&)
+#endif
+
+#undef DEFN_ASN_OP_T
+
+
+#define DEFN_ASN_OP_T(op,fnc,tp)                                              \
+inline                                                                        \
+sc_fxnum&                                                                     \
+sc_fxnum::operator op ( tp b )                                                \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( *this )                                          \
+    sc_fxval tmp( b );                                                        \
+    scfx_rep* new_rep = sc_dt::fnc ## _scfx_rep( *m_rep, *tmp.get_rep() );   \
+    delete m_rep;                                                             \
+    m_rep = new_rep;                                                          \
+    cast();                                                                   \
+    SC_FXNUM_OBSERVER_WRITE_( *this )                                         \
+    return *this;                                                             \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_ASN_OP_OTHER(op,fnc)                                             \
+DEFN_ASN_OP_T(op,fnc,int64)                                                   \
+DEFN_ASN_OP_T(op,fnc,uint64)                                                  \
+DEFN_ASN_OP_T(op,fnc,const sc_int_base&)                                      \
+DEFN_ASN_OP_T(op,fnc,const sc_uint_base&)                                     \
+DEFN_ASN_OP_T(op,fnc,const sc_signed&)                                        \
+DEFN_ASN_OP_T(op,fnc,const sc_unsigned&)
+#else
+#define DEFN_ASN_OP_OTHER(op,fnc)
+#endif
+
+#define DEFN_ASN_OP(op,fnc)                                                   \
+inline                                                                        \
+sc_fxnum&                                                                     \
+sc_fxnum::operator op ( const sc_fxnum& b )                                   \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( *this )                                          \
+    SC_FXNUM_OBSERVER_READ_( b )                                              \
+    scfx_rep* new_rep = sc_dt::fnc ## _scfx_rep( *m_rep, *b.m_rep );         \
+    delete m_rep;                                                             \
+    m_rep = new_rep;                                                          \
+    cast();                                                                   \
+    SC_FXNUM_OBSERVER_WRITE_( *this )                                         \
+    return *this;                                                             \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+sc_fxnum&                                                                     \
+sc_fxnum::operator op ( const sc_fxval& b )                                   \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( *this )                                          \
+    scfx_rep* new_rep = sc_dt::fnc ## _scfx_rep( *m_rep, *b.get_rep() );     \
+    delete m_rep;                                                             \
+    m_rep = new_rep;                                                          \
+    cast();                                                                   \
+    SC_FXNUM_OBSERVER_WRITE_( *this )                                         \
+    return *this;                                                             \
+}                                                                             \
+                                                                              \
+DEFN_ASN_OP_T(op,fnc,int)                                                     \
+DEFN_ASN_OP_T(op,fnc,unsigned int)                                            \
+DEFN_ASN_OP_T(op,fnc,long)                                                    \
+DEFN_ASN_OP_T(op,fnc,unsigned long)                                           \
+DEFN_ASN_OP_T(op,fnc,float)                                                  \
+DEFN_ASN_OP_T(op,fnc,double)                                                  \
+DEFN_ASN_OP_T(op,fnc,const char*)                                             \
+DEFN_ASN_OP_T(op,fnc,const sc_fxval_fast&)                                    \
+DEFN_ASN_OP_T(op,fnc,const sc_fxnum_fast&)                                    \
+DEFN_ASN_OP_OTHER(op,fnc)
+
+DEFN_ASN_OP(*=,mult)
+DEFN_ASN_OP(/=,div)
+DEFN_ASN_OP(+=,add)
+DEFN_ASN_OP(-=,sub)
+
+#undef DEFN_ASN_OP_T
+#undef DEFN_ASN_OP_OTHER
+#undef DEFN_ASN_OP
+
+
+inline
+sc_fxnum&
+sc_fxnum::operator <<= ( int b )
+{
+    SC_FXNUM_OBSERVER_READ_( *this )
+    m_rep->lshift( b );
+    cast();
+    SC_FXNUM_OBSERVER_WRITE_( *this )
+    return *this;
+}
+
+inline
+sc_fxnum&
+sc_fxnum::operator >>= ( int b )
+{
+    SC_FXNUM_OBSERVER_READ_( *this )
+    m_rep->rshift( b );
+    cast();
+    SC_FXNUM_OBSERVER_WRITE_( *this )
+    return *this;
+}
+
+
+// auto-increment and auto-decrement
+
+inline
+const sc_fxval
+sc_fxnum::operator ++ ( int )
+{
+    sc_fxval c( *this );
+    (*this) += 1;
+    return c;
+}
+
+inline
+const sc_fxval
+sc_fxnum::operator -- ( int )
+{
+    sc_fxval c( *this );
+    (*this) -= 1;
+    return c;
+}
+
+inline
+sc_fxnum&
+sc_fxnum::operator ++ ()
+{
+    (*this) += 1;
+    return *this;
+}
+
+inline
+sc_fxnum&
+sc_fxnum::operator -- ()
+{
+    (*this) -= 1;
+    return *this;
+}
+
+
+// bit selection
+
+inline
+const sc_fxnum_bitref
+sc_fxnum::operator [] ( int i ) const
+{
+    SC_ERROR_IF_( i < 0 || i >= m_params.wl(), sc_core::SC_ID_OUT_OF_RANGE_ );
+    return sc_fxnum_bitref( const_cast<sc_fxnum&>( *this ),
+			    i - m_params.fwl() );
+}
+
+inline
+sc_fxnum_bitref
+sc_fxnum::operator [] ( int i )
+{
+    SC_ERROR_IF_( i < 0 || i >= m_params.wl(), sc_core::SC_ID_OUT_OF_RANGE_ );
+    return sc_fxnum_bitref( *this, i - m_params.fwl() );
+}
+
+inline
+const sc_fxnum_bitref
+sc_fxnum::bit( int i ) const
+{
+    SC_ERROR_IF_( i < 0 || i >= m_params.wl(), sc_core::SC_ID_OUT_OF_RANGE_ );
+    return sc_fxnum_bitref( const_cast<sc_fxnum&>( *this ),
+			    i - m_params.fwl() );
+}
+
+inline
+sc_fxnum_bitref
+sc_fxnum::bit( int i )
+{
+    SC_ERROR_IF_( i < 0 || i >= m_params.wl(), sc_core::SC_ID_OUT_OF_RANGE_ );
+    return sc_fxnum_bitref( *this, i - m_params.fwl() );
+}
+
+
+// part selection
+
+inline
+const sc_fxnum_subref
+sc_fxnum::operator () ( int i, int j ) const
+{
+    SC_ERROR_IF_( i < 0 || i >= m_params.wl(), sc_core::SC_ID_OUT_OF_RANGE_ );
+    SC_ERROR_IF_( j < 0 || j >= m_params.wl(), sc_core::SC_ID_OUT_OF_RANGE_ );
+
+    return sc_fxnum_subref( const_cast<sc_fxnum&>( *this ),
+			    i - m_params.fwl(), j - m_params.fwl() );
+}
+
+inline
+sc_fxnum_subref
+sc_fxnum::operator () ( int i, int j )
+{
+    SC_ERROR_IF_( i < 0 || i >= m_params.wl(), sc_core::SC_ID_OUT_OF_RANGE_ );
+    SC_ERROR_IF_( j < 0 || j >= m_params.wl(), sc_core::SC_ID_OUT_OF_RANGE_ );
+
+    return sc_fxnum_subref( *this, i - m_params.fwl(), j - m_params.fwl() );
+}
+
+inline
+const sc_fxnum_subref
+sc_fxnum::range( int i, int j ) const
+{
+    SC_ERROR_IF_( i < 0 || i >= m_params.wl(), sc_core::SC_ID_OUT_OF_RANGE_ );
+    SC_ERROR_IF_( j < 0 || j >= m_params.wl(), sc_core::SC_ID_OUT_OF_RANGE_ );
+
+    return sc_fxnum_subref( const_cast<sc_fxnum&>( *this ),
+			    i - m_params.fwl(), j - m_params.fwl() );
+}
+
+inline
+sc_fxnum_subref
+sc_fxnum::range( int i, int j )
+{
+    SC_ERROR_IF_( i < 0 || i >= m_params.wl(), sc_core::SC_ID_OUT_OF_RANGE_ );
+    SC_ERROR_IF_( j < 0 || j >= m_params.wl(), sc_core::SC_ID_OUT_OF_RANGE_ );
+
+    return sc_fxnum_subref( *this, i - m_params.fwl(), j - m_params.fwl() );
+}
+
+
+inline
+const sc_fxnum_subref
+sc_fxnum::operator () () const
+{
+    return this->operator () ( m_params.wl() - 1, 0 );
+}
+
+inline
+sc_fxnum_subref
+sc_fxnum::operator () ()
+{
+    return this->operator () ( m_params.wl() - 1, 0 );
+}
+
+inline
+const sc_fxnum_subref
+sc_fxnum::range() const
+{
+    return this->range( m_params.wl() - 1, 0 );
+}
+
+inline
+sc_fxnum_subref
+sc_fxnum::range()
+{
+    return this->range( m_params.wl() - 1, 0 );
+}
+
+
+// implicit conversion
+
+inline
+sc_fxnum::operator double() const
+{
+    SC_FXNUM_OBSERVER_READ_( *this )
+    return m_rep->to_double();
+}
+
+
+// explicit conversion to primitive types
+
+inline
+short
+sc_fxnum::to_short() const
+{
+    SC_FXNUM_OBSERVER_READ_( *this )
+    return static_cast<short>( m_rep->to_double() );
+}
+
+inline
+unsigned short
+sc_fxnum::to_ushort() const
+{
+    SC_FXNUM_OBSERVER_READ_( *this )
+    return static_cast<unsigned short>( m_rep->to_double() );
+}
+
+inline
+int
+sc_fxnum::to_int() const
+{
+    SC_FXNUM_OBSERVER_READ_( *this )
+    return static_cast<int>( m_rep->to_double() );
+}
+
+inline
+int64
+sc_fxnum::to_int64() const
+{
+    SC_FXNUM_OBSERVER_READ_( *this )
+    return static_cast<int64>( m_rep->to_double() );
+}
+
+inline
+unsigned int
+sc_fxnum::to_uint() const
+{
+    SC_FXNUM_OBSERVER_READ_( *this )
+    return static_cast<unsigned int>( m_rep->to_double() );
+}
+
+inline
+uint64
+sc_fxnum::to_uint64() const
+{
+    SC_FXNUM_OBSERVER_READ_( *this )
+    return static_cast<uint64>( m_rep->to_double() );
+}
+
+inline
+long
+sc_fxnum::to_long() const
+{
+    SC_FXNUM_OBSERVER_READ_( *this )
+    return static_cast<long>( m_rep->to_double() );
+}
+
+inline
+unsigned long
+sc_fxnum::to_ulong() const
+{
+    SC_FXNUM_OBSERVER_READ_( *this )
+    return static_cast<unsigned long>( m_rep->to_double() );
+}
+
+inline
+float
+sc_fxnum::to_float() const
+{
+    SC_FXNUM_OBSERVER_READ_( *this )
+    return static_cast<float>( m_rep->to_double() );
+}
+
+inline
+double
+sc_fxnum::to_double() const
+{
+    SC_FXNUM_OBSERVER_READ_( *this )
+    return m_rep->to_double();
+}
+
+
+// query value
+
+inline
+bool
+sc_fxnum::is_neg() const
+{
+    SC_FXNUM_OBSERVER_READ_( *this )
+    return m_rep->is_neg();
+}
+
+inline
+bool
+sc_fxnum::is_zero() const
+{
+    SC_FXNUM_OBSERVER_READ_( *this )
+    return m_rep->is_zero();
+}
+
+// internal use only;
+inline
+bool
+sc_fxnum::is_normal() const
+{
+    SC_FXNUM_OBSERVER_READ_( *this )
+    return m_rep->is_normal();
+}
+
+inline
+bool
+sc_fxnum::quantization_flag() const
+{
+    return m_q_flag;
+}
+
+inline
+bool
+sc_fxnum::overflow_flag() const
+{
+    return m_o_flag;
+}
+
+
+inline
+const sc_fxval
+sc_fxnum::value() const
+{
+    SC_FXNUM_OBSERVER_READ_( *this )
+    return sc_fxval( new scfx_rep( *m_rep ) );
+}
+
+
+// query parameters
+
+inline
+int
+sc_fxnum::wl() const
+{
+    return m_params.wl();
+}
+
+inline
+int
+sc_fxnum::iwl() const
+{
+    return m_params.iwl();
+}
+
+inline
+sc_q_mode
+sc_fxnum::q_mode() const
+{
+    return m_params.q_mode();
+}
+
+inline
+sc_o_mode
+sc_fxnum::o_mode() const
+{
+    return m_params.o_mode();
+}
+
+inline
+int
+sc_fxnum::n_bits() const
+{
+    return m_params.n_bits();
+}
+
+
+inline
+const sc_fxtype_params&
+sc_fxnum::type_params() const
+{
+    return m_params.type_params();
+}
+
+
+inline
+const sc_fxcast_switch&
+sc_fxnum::cast_switch() const
+{
+    return m_params.cast_switch();
+}
+
+
+// internal use only;
+inline
+void
+sc_fxnum::observer_read() const
+{
+    SC_FXNUM_OBSERVER_READ_( *this );
+}
+
+
+// internal use only;
+inline
+bool
+sc_fxnum::get_bit( int i ) const
+{
+    return m_rep->get_bit( i );
+}
+
+
+// protected methods and friend functions
+
+inline
+bool
+sc_fxnum::set_bit( int i, bool high )
+{
+    if( high )
+        return m_rep->set( i, m_params );
+    else
+        return m_rep->clear( i, m_params );
+}
+
+
+inline
+bool
+sc_fxnum::get_slice( int i, int j, sc_bv_base& bv ) const
+{
+    return m_rep->get_slice( i, j, m_params, bv );
+}
+
+inline
+bool
+sc_fxnum::set_slice( int i, int j, const sc_bv_base& bv )
+{
+    return m_rep->set_slice( i, j, m_params, bv );
+}
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_fxnum& a )
+{
+    a.print( os );
+    return os;
+}
+
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_fxnum& a )
+{
+    a.scan( is );
+    return is;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum_fast
+//
+//  Base class for the fixed-point types; limited precision.
+// ----------------------------------------------------------------------------
+
+inline
+sc_fxnum_fast_observer*
+sc_fxnum_fast::observer() const
+{
+    return m_observer;
+}
+
+
+// constructors
+
+inline
+sc_fxnum_fast::sc_fxnum_fast( const sc_fxtype_params& type_params_,
+			      sc_enc enc_,
+			      const sc_fxcast_switch& cast_sw,
+			      sc_fxnum_fast_observer* observer_ )
+: m_val( 0.0 ),
+  m_params( type_params_, enc_, cast_sw ),
+  m_q_flag( false ),
+  m_o_flag( false ),
+  m_observer( observer_ )
+{
+    SC_FXNUM_FAST_OBSERVER_DEFAULT_
+    SC_FXNUM_FAST_OBSERVER_CONSTRUCT_(*this)
+}
+
+inline
+sc_fxnum_fast::sc_fxnum_fast( const sc_fxnum_fast& a,
+			      const sc_fxtype_params& type_params_,
+			      sc_enc enc_,
+			      const sc_fxcast_switch& cast_sw,
+			      sc_fxnum_fast_observer* observer_ )
+: m_val( a.m_val ),
+  m_params( type_params_, enc_, cast_sw ),
+  m_q_flag( false ),
+  m_o_flag( false ),
+  m_observer( observer_ )
+{
+    SC_FXNUM_FAST_OBSERVER_DEFAULT_
+    SC_FXNUM_FAST_OBSERVER_READ_( a )
+    cast();
+    SC_FXNUM_FAST_OBSERVER_CONSTRUCT_( *this )
+    SC_FXNUM_FAST_OBSERVER_WRITE_( *this )
+}
+
+#define DEFN_CTOR_T(tp,arg)                                                   \
+inline                                                                        \
+sc_fxnum_fast::sc_fxnum_fast( tp a,                                           \
+		              const sc_fxtype_params& type_params_,           \
+		              sc_enc enc_,                                    \
+		              const sc_fxcast_switch& cast_sw,                \
+		              sc_fxnum_fast_observer* observer_ )             \
+: m_val( arg ),                                                               \
+  m_params( type_params_, enc_, cast_sw ),                                    \
+  m_q_flag( false ),                                                          \
+  m_o_flag( false ),                                                          \
+  m_observer( observer_ )                                                     \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_DEFAULT_                                           \
+    cast();                                                                   \
+    SC_FXNUM_FAST_OBSERVER_CONSTRUCT_(*this)                                  \
+    SC_FXNUM_FAST_OBSERVER_WRITE_( *this )                                    \
+}
+
+#define DEFN_CTOR_T_A(tp) DEFN_CTOR_T(tp,static_cast<double>( a ))
+#define DEFN_CTOR_T_B(tp) DEFN_CTOR_T(tp,sc_fxval_fast::from_string( a ))
+#define DEFN_CTOR_T_C(tp) DEFN_CTOR_T(tp,a.to_double())
+
+DEFN_CTOR_T_A(int)
+DEFN_CTOR_T_A(unsigned int)
+DEFN_CTOR_T_A(long)
+DEFN_CTOR_T_A(unsigned long)
+DEFN_CTOR_T_A(float)
+DEFN_CTOR_T_A(double)
+DEFN_CTOR_T_B(const char*)
+DEFN_CTOR_T_C(const sc_fxval&)
+DEFN_CTOR_T_C(const sc_fxval_fast&)
+DEFN_CTOR_T_C(const sc_fxnum&)
+#ifndef SC_FX_EXCLUDE_OTHER
+DEFN_CTOR_T_A(int64)
+DEFN_CTOR_T_A(uint64)
+DEFN_CTOR_T_C(const sc_int_base&)
+DEFN_CTOR_T_C(const sc_uint_base&)
+DEFN_CTOR_T_C(const sc_signed&)
+DEFN_CTOR_T_C(const sc_unsigned&)
+#endif
+
+#undef DEFN_CTOR_T
+#undef DEFN_CTOR_T_A
+#undef DEFN_CTOR_T_B
+#undef DEFN_CTOR_T_C
+#undef DEFN_CTOR_T_D
+#undef DEFN_CTOR_T_E
+
+
+inline
+sc_fxnum_fast::~sc_fxnum_fast()
+{
+    SC_FXNUM_FAST_OBSERVER_DESTRUCT_( *this )
+}
+
+
+// internal use only;
+inline
+double
+sc_fxnum_fast::get_val() const
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )
+    return m_val;
+}
+
+
+// unary operators
+
+inline
+const sc_fxval_fast
+sc_fxnum_fast::operator - () const
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )
+    return sc_fxval_fast( - m_val );
+}
+
+inline
+const sc_fxval_fast
+sc_fxnum_fast::operator + () const
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )
+    return sc_fxval_fast( m_val );
+}
+
+
+// unary functions
+
+inline
+void
+neg( sc_fxval_fast& c, const sc_fxnum_fast& a )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( a )
+    c.set_val( - a.m_val );
+}
+
+inline
+void
+neg( sc_fxnum_fast& c, const sc_fxnum_fast& a )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( a )
+    c.m_val = - a.m_val;
+    c.cast();
+    SC_FXNUM_FAST_OBSERVER_WRITE_( c )
+}
+
+
+// binary operators
+
+#define DEFN_BIN_OP_T(op,tp)                                                  \
+inline                                                                        \
+const sc_fxval_fast                                                           \
+operator op ( const sc_fxnum_fast& a, tp b )                                  \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( a )                                         \
+    sc_fxval_fast tmp( b );                                                   \
+    return sc_fxval_fast( a.m_val op tmp.get_val() );                         \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+const sc_fxval_fast                                                           \
+operator op ( tp a, const sc_fxnum_fast& b )                                  \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( b )                                         \
+    sc_fxval_fast tmp( a );                                                   \
+    return sc_fxval_fast( tmp.get_val() op b.m_val );                         \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_BIN_OP_OTHER(op)                                                 \
+DEFN_BIN_OP_T(op,int64)                                                       \
+DEFN_BIN_OP_T(op,uint64)                                                      \
+DEFN_BIN_OP_T(op,const sc_int_base&)                                          \
+DEFN_BIN_OP_T(op,const sc_uint_base&)                                         \
+DEFN_BIN_OP_T(op,const sc_signed&)                                            \
+DEFN_BIN_OP_T(op,const sc_unsigned&)
+#else
+#define DEFN_BIN_OP_OTHER(op)
+#endif
+
+#define DEFN_BIN_OP(op,dummy)                                                 \
+inline                                                                        \
+const sc_fxval_fast                                                           \
+operator op ( const sc_fxnum_fast& a, const sc_fxnum_fast& b )                \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( a )                                         \
+    SC_FXNUM_FAST_OBSERVER_READ_( b )                                         \
+    return sc_fxval_fast( a.m_val op b.m_val );                               \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+const sc_fxval_fast                                                           \
+operator op ( const sc_fxnum_fast& a, const sc_fxval_fast& b )                \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( a )                                         \
+    return sc_fxval_fast( a.m_val op b.get_val() );                           \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+const sc_fxval_fast                                                           \
+operator op ( const sc_fxval_fast& a, const sc_fxnum_fast& b )                \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( b )                                         \
+    return sc_fxval_fast( a.get_val() op b.m_val );                           \
+}                                                                             \
+                                                                              \
+DEFN_BIN_OP_T(op,int)                                                         \
+DEFN_BIN_OP_T(op,unsigned int)                                                \
+DEFN_BIN_OP_T(op,long)                                                        \
+DEFN_BIN_OP_T(op,unsigned long)                                               \
+DEFN_BIN_OP_T(op,float)                                                      \
+DEFN_BIN_OP_T(op,double)                                                      \
+DEFN_BIN_OP_T(op,const char*)                                                 \
+DEFN_BIN_OP_OTHER(op)
+
+DEFN_BIN_OP(*,mult)
+DEFN_BIN_OP(+,add)
+DEFN_BIN_OP(-,sub)
+//DEFN_BIN_OP(/,div)
+inline
+const sc_fxval_fast
+operator / ( const sc_fxnum_fast& a, const sc_fxnum_fast& b )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( a )
+    SC_FXNUM_FAST_OBSERVER_READ_( b )
+    return sc_fxval_fast( a.m_val / b.m_val );
+}
+
+inline
+const sc_fxval_fast
+operator / ( const sc_fxnum_fast& a, const sc_fxval_fast& b )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( a )
+    return sc_fxval_fast( a.m_val / b.get_val() );
+}
+
+inline
+const sc_fxval_fast
+operator / ( const sc_fxval_fast& a, const sc_fxnum_fast& b )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( b )
+    return sc_fxval_fast( a.get_val() / b.m_val );
+}
+
+DEFN_BIN_OP_T(/,int)
+DEFN_BIN_OP_T(/,unsigned int)
+DEFN_BIN_OP_T(/,long)
+DEFN_BIN_OP_T(/,unsigned long)
+DEFN_BIN_OP_T(/,float)
+DEFN_BIN_OP_T(/,double)
+DEFN_BIN_OP_T(/,const char*)
+//DEFN_BIN_OP_OTHER(/)
+#ifndef SC_FX_EXCLUDE_OTHER
+DEFN_BIN_OP_T(/,int64)
+DEFN_BIN_OP_T(/,uint64)
+DEFN_BIN_OP_T(/,const sc_int_base&)
+DEFN_BIN_OP_T(/,const sc_uint_base&)
+DEFN_BIN_OP_T(/,const sc_signed&)
+DEFN_BIN_OP_T(/,const sc_unsigned&)
+#endif
+
+#undef DEFN_BIN_OP_T
+#undef DEFN_BIN_OP_OTHER
+#undef DEFN_BIN_OP
+
+
+inline
+const sc_fxval_fast
+operator << ( const sc_fxnum_fast& a, int b )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( a )
+    return sc_fxval_fast( a.m_val * scfx_pow2( b ) );
+}
+
+inline
+const sc_fxval_fast
+operator >> ( const sc_fxnum_fast& a, int b )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( a )
+    return sc_fxval_fast( a.m_val * scfx_pow2( -b ) );
+}
+
+
+// binary functions
+
+#define DEFN_BIN_FNC_T(fnc,op,tp)                                             \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxval_fast& c, const sc_fxnum_fast& a, tp b )                        \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( a )                                         \
+    sc_fxval_fast tmp( b );                                                   \
+    c.set_val( a.m_val op tmp.get_val() );                                    \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxval_fast& c, tp a, const sc_fxnum_fast& b )                        \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( b )                                         \
+    sc_fxval_fast tmp( a );                                                   \
+    c.set_val( tmp.get_val() op b.m_val );                                    \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxnum_fast& c, const sc_fxnum_fast& a, tp b )                        \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( a )                                         \
+    sc_fxval_fast tmp( b );                                                   \
+    c.m_val = a.m_val op tmp.get_val();                                       \
+    c.cast();                                                                 \
+    SC_FXNUM_FAST_OBSERVER_WRITE_( c )                                        \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxnum_fast& c, tp a, const sc_fxnum_fast& b )                        \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( b )                                         \
+    sc_fxval_fast tmp( a );                                                   \
+    c.m_val = tmp.get_val() op b.m_val;                                       \
+    c.cast();                                                                 \
+    SC_FXNUM_FAST_OBSERVER_WRITE_( c )                                        \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_BIN_FNC_OTHER(fnc,op)                                            \
+DEFN_BIN_FNC_T(fnc,op,int64)                                                  \
+DEFN_BIN_FNC_T(fnc,op,uint64)                                                 \
+DEFN_BIN_FNC_T(fnc,op,const sc_int_base&)                                     \
+DEFN_BIN_FNC_T(fnc,op,const sc_uint_base&)                                    \
+DEFN_BIN_FNC_T(fnc,op,const sc_signed&)                                       \
+DEFN_BIN_FNC_T(fnc,op,const sc_unsigned&)
+#else
+#define DEFN_BIN_FNC_OTHER(fnc,op)
+#endif
+
+#define DEFN_BIN_FNC(fnc,op)                                                  \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_fxnum_fast& b )      \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( a )                                         \
+    SC_FXNUM_FAST_OBSERVER_READ_( b )                                         \
+    c.set_val( a.m_val op b.m_val );                                          \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_fxnum_fast& b )      \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( a )                                         \
+    SC_FXNUM_FAST_OBSERVER_READ_( b )                                         \
+    c.m_val = a.m_val op b.m_val;                                             \
+    c.cast();                                                                 \
+    SC_FXNUM_FAST_OBSERVER_WRITE_( c )                                        \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_fxval_fast& b )      \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( a )                                         \
+    c.set_val( a.m_val op b.get_val() );                                      \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_fxnum_fast& b )      \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( b )                                         \
+    c.set_val( a.get_val() op b.m_val );                                      \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_fxval_fast& b )      \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( a )                                         \
+    c.m_val = a.m_val op b.get_val();                                         \
+    c.cast();                                                                 \
+    SC_FXNUM_FAST_OBSERVER_WRITE_( c )                                        \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxnum_fast& c, const sc_fxval_fast& a, const sc_fxnum_fast& b )      \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( b )                                         \
+    c.m_val = a.get_val() op b.m_val;                                         \
+    c.cast();                                                                 \
+    SC_FXNUM_FAST_OBSERVER_WRITE_( c )                                        \
+}                                                                             \
+                                                                              \
+DEFN_BIN_FNC_T(fnc,op,int)                                                    \
+DEFN_BIN_FNC_T(fnc,op,unsigned int)                                           \
+DEFN_BIN_FNC_T(fnc,op,long)                                                   \
+DEFN_BIN_FNC_T(fnc,op,unsigned long)                                          \
+DEFN_BIN_FNC_T(fnc,op,float)                                                 \
+DEFN_BIN_FNC_T(fnc,op,double)                                                 \
+DEFN_BIN_FNC_T(fnc,op,const char*)                                            \
+DEFN_BIN_FNC_T(fnc,op,const sc_fxval&)                                        \
+DEFN_BIN_FNC_T(fnc,op,const sc_fxnum&)                                        \
+DEFN_BIN_FNC_OTHER(fnc,op)
+
+DEFN_BIN_FNC(mult,*)
+DEFN_BIN_FNC(div,/)
+DEFN_BIN_FNC(add,+)
+DEFN_BIN_FNC(sub,-)
+
+#undef DEFN_BIN_FNC_T
+#undef DEFN_BIN_FNC_OTHER
+#undef DEFN_BIN_FNC
+
+
+inline
+void
+lshift( sc_fxval_fast& c, const sc_fxnum_fast& a, int b )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( a )
+    c.set_val( a.m_val * scfx_pow2( b ) );
+}
+
+inline
+void
+rshift( sc_fxval_fast& c, const sc_fxnum_fast& a, int b )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( a )
+    c.set_val( a.m_val * scfx_pow2( -b ) );
+}
+
+inline
+void
+lshift( sc_fxnum_fast& c, const sc_fxnum_fast& a, int b )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( a )
+    c.m_val = a.m_val * scfx_pow2( b );
+    c.cast();
+    SC_FXNUM_FAST_OBSERVER_WRITE_( c )
+}
+
+inline
+void
+rshift( sc_fxnum_fast& c, const sc_fxnum_fast& a, int b )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( a )
+    c.m_val = a.m_val * scfx_pow2( -b );
+    c.cast();
+    SC_FXNUM_FAST_OBSERVER_WRITE_( c )
+}
+
+
+// relational (including equality) operators
+
+#define DEFN_REL_OP_T(op,tp)                                                  \
+inline                                                                        \
+bool                                                                          \
+operator op ( const sc_fxnum_fast& a, tp b )                                  \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( a )                                         \
+    sc_fxval_fast tmp( b );                                                   \
+    return ( a.m_val op tmp.get_val() );                                      \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+bool                                                                          \
+operator op ( tp a, const sc_fxnum_fast& b )                                  \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( b )                                         \
+    sc_fxval_fast tmp( a );                                                   \
+    return ( tmp.get_val() op b.m_val );                                      \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_REL_OP_OTHER(op)                                                 \
+DEFN_REL_OP_T(op,int64)                                                       \
+DEFN_REL_OP_T(op,uint64)                                                      \
+DEFN_REL_OP_T(op,const sc_int_base&)                                          \
+DEFN_REL_OP_T(op,const sc_uint_base&)                                         \
+DEFN_REL_OP_T(op,const sc_signed&)                                            \
+DEFN_REL_OP_T(op,const sc_unsigned&)
+#else
+#define DEFN_REL_OP_OTHER(op)
+#endif
+
+#define DEFN_REL_OP(op)                                                       \
+inline                                                                        \
+bool                                                                          \
+operator op ( const sc_fxnum_fast& a, const sc_fxnum_fast& b )                \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( a )                                         \
+    SC_FXNUM_FAST_OBSERVER_READ_( b )                                         \
+    return ( a.m_val op b.m_val );                                            \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+bool                                                                          \
+operator op ( const sc_fxnum_fast& a, const sc_fxval_fast& b )                \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( a )                                         \
+    return ( a.m_val op b.get_val() );                                        \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+bool                                                                          \
+operator op ( const sc_fxval_fast& a, const sc_fxnum_fast& b )                \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( b )                                         \
+    return ( a.get_val() op b.m_val );                                        \
+}                                                                             \
+                                                                              \
+DEFN_REL_OP_T(op,int)                                                         \
+DEFN_REL_OP_T(op,unsigned int)                                                \
+DEFN_REL_OP_T(op,long)                                                        \
+DEFN_REL_OP_T(op,unsigned long)                                               \
+DEFN_REL_OP_T(op,float)                                                      \
+DEFN_REL_OP_T(op,double)                                                      \
+DEFN_REL_OP_T(op,const char*)                                                 \
+DEFN_REL_OP_OTHER(op)
+
+DEFN_REL_OP(<)
+DEFN_REL_OP(<=)
+DEFN_REL_OP(>)
+DEFN_REL_OP(>=)
+DEFN_REL_OP(==)
+DEFN_REL_OP(!=)
+
+#undef DEFN_REL_OP_T
+#undef DEFN_REL_OP_OTHER
+#undef DEFN_REL_OP
+
+
+// assignment operators
+
+inline
+sc_fxnum_fast&
+sc_fxnum_fast::operator = ( const sc_fxnum_fast& a )
+{
+    if( &a != this )
+    {
+	SC_FXNUM_FAST_OBSERVER_READ_( a )
+	m_val = a.m_val;
+	cast();
+	SC_FXNUM_FAST_OBSERVER_WRITE_( *this )
+    }
+    return *this;
+}
+
+inline
+sc_fxnum_fast&
+sc_fxnum_fast::operator = ( const sc_fxval_fast& a )
+{
+    m_val = a.get_val();
+    cast();
+    SC_FXNUM_FAST_OBSERVER_WRITE_( *this )
+    return *this;
+}
+
+#define DEFN_ASN_OP_T(tp)                                                     \
+inline                                                                        \
+sc_fxnum_fast&                                                                \
+sc_fxnum_fast::operator = ( tp a )                                            \
+{                                                                             \
+    sc_fxval_fast tmp( a );                                                   \
+    m_val = tmp.get_val();                                                    \
+    cast();                                                                   \
+    SC_FXNUM_FAST_OBSERVER_WRITE_( *this )                                    \
+    return *this;                                                             \
+}
+
+DEFN_ASN_OP_T(int)
+DEFN_ASN_OP_T(unsigned int)
+DEFN_ASN_OP_T(long)
+DEFN_ASN_OP_T(unsigned long)
+DEFN_ASN_OP_T(float)
+DEFN_ASN_OP_T(double)
+DEFN_ASN_OP_T(const char*)
+DEFN_ASN_OP_T(const sc_fxval&)
+DEFN_ASN_OP_T(const sc_fxnum&)
+#ifndef SC_FX_EXCLUDE_OTHER
+DEFN_ASN_OP_T(int64)
+DEFN_ASN_OP_T(uint64)
+DEFN_ASN_OP_T(const sc_int_base&)
+DEFN_ASN_OP_T(const sc_uint_base&)
+DEFN_ASN_OP_T(const sc_signed&)
+DEFN_ASN_OP_T(const sc_unsigned&)
+#endif
+
+#undef DEFN_ASN_OP_T
+
+
+#define DEFN_ASN_OP_T(op,tp)                                                  \
+inline                                                                        \
+sc_fxnum_fast&                                                                \
+sc_fxnum_fast::operator op ( tp b )                                           \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )                                     \
+    sc_fxval_fast tmp( b );                                                   \
+    m_val op tmp.get_val();                                                   \
+    cast();                                                                   \
+    SC_FXNUM_FAST_OBSERVER_WRITE_( *this )                                    \
+    return *this;                                                             \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_ASN_OP_OTHER(op)                                                 \
+DEFN_ASN_OP_T(op,int64)                                                       \
+DEFN_ASN_OP_T(op,uint64)                                                      \
+DEFN_ASN_OP_T(op,const sc_int_base&)                                          \
+DEFN_ASN_OP_T(op,const sc_uint_base&)                                         \
+DEFN_ASN_OP_T(op,const sc_signed&)                                            \
+DEFN_ASN_OP_T(op,const sc_unsigned&)
+#else
+#define DEFN_ASN_OP_OTHER(op)
+#endif
+
+#define DEFN_ASN_OP(op)                                                       \
+inline                                                                        \
+sc_fxnum_fast&                                                                \
+sc_fxnum_fast::operator op ( const sc_fxnum_fast& b )                         \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )                                     \
+    SC_FXNUM_FAST_OBSERVER_READ_( b )                                         \
+    m_val op b.m_val;                                                         \
+    cast();                                                                   \
+    SC_FXNUM_FAST_OBSERVER_WRITE_( *this )                                    \
+    return *this;                                                             \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+sc_fxnum_fast&                                                                \
+sc_fxnum_fast::operator op ( const sc_fxval_fast& b )                         \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )                                     \
+    m_val op b.get_val();                                                     \
+    cast();                                                                   \
+    SC_FXNUM_FAST_OBSERVER_WRITE_( *this )                                    \
+    return *this;                                                             \
+}                                                                             \
+                                                                              \
+DEFN_ASN_OP_T(op,int)                                                         \
+DEFN_ASN_OP_T(op,unsigned int)                                                \
+DEFN_ASN_OP_T(op,long)                                                        \
+DEFN_ASN_OP_T(op,unsigned long)                                               \
+DEFN_ASN_OP_T(op,float)                                                      \
+DEFN_ASN_OP_T(op,double)                                                      \
+DEFN_ASN_OP_T(op,const char*)                                                 \
+DEFN_ASN_OP_T(op,const sc_fxval&)                                             \
+DEFN_ASN_OP_T(op,const sc_fxnum&)                                             \
+DEFN_ASN_OP_OTHER(op)
+
+DEFN_ASN_OP(*=)
+DEFN_ASN_OP(/=)
+DEFN_ASN_OP(+=)
+DEFN_ASN_OP(-=)
+
+#undef DEFN_ASN_OP_T
+#undef DEFN_ASN_OP_OTHER
+#undef DEFN_ASN_OP
+
+
+inline
+sc_fxnum_fast&
+sc_fxnum_fast::operator <<= ( int b )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )
+    m_val *= scfx_pow2( b );
+    cast();
+    SC_FXNUM_FAST_OBSERVER_WRITE_( *this )
+    return *this;
+}
+
+inline
+sc_fxnum_fast&
+sc_fxnum_fast::operator >>= ( int b )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )
+    m_val *= scfx_pow2( -b );
+    cast();
+    SC_FXNUM_FAST_OBSERVER_WRITE_( *this )
+    return *this;
+}
+
+
+// auto-increment and auto-decrement
+
+inline
+const sc_fxval_fast
+sc_fxnum_fast::operator ++ ( int )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )
+    double c = m_val;
+    m_val = m_val + 1;
+    cast();
+    SC_FXNUM_FAST_OBSERVER_WRITE_( *this )
+    return sc_fxval_fast( c );
+}
+
+inline
+const sc_fxval_fast
+sc_fxnum_fast::operator -- ( int )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )
+    double c = m_val;
+    m_val = m_val - 1;
+    cast();
+    SC_FXNUM_FAST_OBSERVER_WRITE_( *this )
+    return sc_fxval_fast( c );
+}
+
+inline
+sc_fxnum_fast&
+sc_fxnum_fast::operator ++ ()
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )
+    m_val = m_val + 1;
+    cast();
+    SC_FXNUM_FAST_OBSERVER_WRITE_( *this )
+    return *this;
+}
+
+inline
+sc_fxnum_fast&
+sc_fxnum_fast::operator -- ()
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )
+    m_val = m_val - 1;
+    cast();
+    SC_FXNUM_FAST_OBSERVER_WRITE_( *this )
+    return *this;
+}
+
+
+// bit selection
+
+inline
+const sc_fxnum_fast_bitref
+sc_fxnum_fast::operator [] ( int i ) const
+{
+    SC_ERROR_IF_( i < 0 || i >= m_params.wl(), sc_core::SC_ID_OUT_OF_RANGE_ );
+    return sc_fxnum_fast_bitref( const_cast<sc_fxnum_fast&>( *this ),
+				 i - m_params.fwl() );
+}
+
+inline
+sc_fxnum_fast_bitref
+sc_fxnum_fast::operator [] ( int i )
+{
+    SC_ERROR_IF_( i < 0 || i >= m_params.wl(), sc_core::SC_ID_OUT_OF_RANGE_ );
+    return sc_fxnum_fast_bitref( *this, i - m_params.fwl() );
+}
+
+inline
+const sc_fxnum_fast_bitref
+sc_fxnum_fast::bit( int i ) const
+{
+    SC_ERROR_IF_( i < 0 || i >= m_params.wl(), sc_core::SC_ID_OUT_OF_RANGE_ );
+    return sc_fxnum_fast_bitref( const_cast<sc_fxnum_fast&>( *this ),
+				 i - m_params.fwl() );
+}
+
+inline
+sc_fxnum_fast_bitref
+sc_fxnum_fast::bit( int i )
+{
+    SC_ERROR_IF_( i < 0 || i >= m_params.wl(), sc_core::SC_ID_OUT_OF_RANGE_ );
+    return sc_fxnum_fast_bitref( *this, i - m_params.fwl() );
+}
+
+
+// part selection
+
+inline
+const sc_fxnum_fast_subref
+sc_fxnum_fast::operator () ( int i, int j ) const
+{
+    SC_ERROR_IF_( i < 0 || i >= m_params.wl(), sc_core::SC_ID_OUT_OF_RANGE_ );
+    SC_ERROR_IF_( j < 0 || j >= m_params.wl(), sc_core::SC_ID_OUT_OF_RANGE_ );
+
+    return sc_fxnum_fast_subref( const_cast<sc_fxnum_fast&>( *this ),
+				 i - m_params.fwl(), j - m_params.fwl() );
+}
+
+inline
+sc_fxnum_fast_subref
+sc_fxnum_fast::operator () ( int i, int j )
+{
+    SC_ERROR_IF_( i < 0 || i >= m_params.wl(), sc_core::SC_ID_OUT_OF_RANGE_ );
+    SC_ERROR_IF_( j < 0 || j >= m_params.wl(), sc_core::SC_ID_OUT_OF_RANGE_ );
+
+    return sc_fxnum_fast_subref( *this,
+				 i - m_params.fwl(), j - m_params.fwl() );
+}
+
+inline
+const sc_fxnum_fast_subref
+sc_fxnum_fast::range( int i, int j ) const
+{
+    SC_ERROR_IF_( i < 0 || i >= m_params.wl(), sc_core::SC_ID_OUT_OF_RANGE_ );
+    SC_ERROR_IF_( j < 0 || j >= m_params.wl(), sc_core::SC_ID_OUT_OF_RANGE_ );
+
+    return sc_fxnum_fast_subref( const_cast<sc_fxnum_fast&>( *this ),
+				 i - m_params.fwl(), j - m_params.fwl() );
+}
+
+inline
+sc_fxnum_fast_subref
+sc_fxnum_fast::range( int i, int j )
+{
+    SC_ERROR_IF_( i < 0 || i >= m_params.wl(), sc_core::SC_ID_OUT_OF_RANGE_ );
+    SC_ERROR_IF_( j < 0 || j >= m_params.wl(), sc_core::SC_ID_OUT_OF_RANGE_ );
+
+    return sc_fxnum_fast_subref( *this,
+				 i - m_params.fwl(), j - m_params.fwl() );
+}
+
+inline
+const sc_fxnum_fast_subref
+sc_fxnum_fast::operator () () const
+{
+    return this->operator () ( m_params.wl() - 1, 0 );
+}
+
+inline
+sc_fxnum_fast_subref
+sc_fxnum_fast::operator () ()
+{
+    return this->operator () ( m_params.wl() - 1, 0 );
+}
+
+inline
+const sc_fxnum_fast_subref
+sc_fxnum_fast::range() const
+{
+    return this->range( m_params.wl() - 1, 0 );
+}
+
+inline
+sc_fxnum_fast_subref
+sc_fxnum_fast::range()
+{
+    return this->range( m_params.wl() - 1, 0 );
+}
+
+
+// implicit conversion
+
+inline
+sc_fxnum_fast::operator double() const
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )
+    return m_val;
+}
+
+
+// explicit conversion to primitive types
+
+inline
+short
+sc_fxnum_fast::to_short() const
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )
+    return static_cast<short>( m_val );
+}
+
+inline
+unsigned short
+sc_fxnum_fast::to_ushort() const
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )
+    return static_cast<unsigned short>( m_val );
+}
+
+inline
+int
+sc_fxnum_fast::to_int() const
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )
+    return static_cast<int>( m_val );
+}
+
+inline
+int64
+sc_fxnum_fast::to_int64() const
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )
+    return static_cast<int64>( m_val );
+}
+
+inline
+unsigned int
+sc_fxnum_fast::to_uint() const
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )
+    return static_cast<unsigned int>( m_val );
+}
+
+inline
+uint64
+sc_fxnum_fast::to_uint64() const
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )
+    return static_cast<uint64>( m_val );
+}
+
+inline
+long
+sc_fxnum_fast::to_long() const
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )
+    return static_cast<long>( m_val );
+}
+
+inline
+unsigned long
+sc_fxnum_fast::to_ulong() const
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )
+    return static_cast<unsigned long>( m_val );
+}
+
+inline
+float
+sc_fxnum_fast::to_float() const
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )
+    return static_cast<float>( m_val );
+}
+
+inline
+double
+sc_fxnum_fast::to_double() const
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )
+    return m_val;
+}
+
+
+// query value
+
+inline
+bool
+sc_fxnum_fast::is_neg() const
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )
+    scfx_ieee_double id( m_val );
+    return ( id.negative() != 0 );
+}
+
+inline
+bool
+sc_fxnum_fast::is_zero() const
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )
+    scfx_ieee_double id( m_val );
+    return id.is_zero();
+}
+
+// internal use only;
+inline
+bool
+sc_fxnum_fast::is_normal() const
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )
+    scfx_ieee_double id( m_val );
+    return ( id.is_normal() || id.is_subnormal() || id.is_zero() );
+}
+
+
+inline
+bool
+sc_fxnum_fast::quantization_flag() const
+{
+    return m_q_flag;
+}
+
+inline
+bool
+sc_fxnum_fast::overflow_flag() const
+{
+    return m_o_flag;
+}
+
+
+inline
+const sc_fxval_fast
+sc_fxnum_fast::value() const
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )
+    return sc_fxval_fast( m_val );
+}
+
+
+// query parameters
+
+inline
+int
+sc_fxnum_fast::wl() const
+{
+    return m_params.wl();
+}
+
+inline
+int
+sc_fxnum_fast::iwl() const
+{
+    return m_params.iwl();
+}
+
+inline
+sc_q_mode
+sc_fxnum_fast::q_mode() const
+{
+    return m_params.q_mode();
+}
+
+inline
+sc_o_mode
+sc_fxnum_fast::o_mode() const
+{
+    return m_params.o_mode();
+}
+
+inline
+int
+sc_fxnum_fast::n_bits() const
+{
+    return m_params.n_bits();
+}
+
+
+inline
+const sc_fxtype_params&
+sc_fxnum_fast::type_params() const
+{
+    return m_params.type_params();
+}
+
+
+inline
+const sc_fxcast_switch&
+sc_fxnum_fast::cast_switch() const
+{
+    return m_params.cast_switch();
+}
+
+
+// internal use only;
+inline
+void
+sc_fxnum_fast::observer_read() const
+{
+    SC_FXNUM_OBSERVER_READ_( *this );
+}
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_fxnum_fast& a )
+{
+    a.print( os );
+    return os;
+}
+
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_fxnum_fast& a )
+{
+    a.scan( is );
+    return is;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxval
+//
+//  Fixed-point value type; arbitrary precision.
+// ----------------------------------------------------------------------------
+
+// public constructors
+
+inline
+sc_fxval::sc_fxval( const sc_fxnum& a,
+		    sc_fxval_observer* observer_ )
+: m_rep( new scfx_rep( *a.get_rep() ) ),
+  m_observer( observer_ )
+{
+    SC_FXVAL_OBSERVER_DEFAULT_
+    SC_FXVAL_OBSERVER_CONSTRUCT_( *this )
+    SC_FXVAL_OBSERVER_WRITE_( *this )
+}
+
+inline
+sc_fxval::sc_fxval( const sc_fxnum_fast& a,
+		    sc_fxval_observer* observer_ )
+: m_rep( new scfx_rep( a.to_double() ) ),
+  m_observer( observer_ )
+{
+    SC_FXVAL_OBSERVER_DEFAULT_
+    SC_FXVAL_OBSERVER_CONSTRUCT_( *this )
+    SC_FXVAL_OBSERVER_WRITE_( *this )
+}
+
+
+// binary operators
+
+#define DEFN_BIN_OP_T(op,fnc,tp)                                              \
+inline                                                                        \
+const sc_fxval                                                                \
+operator op ( const sc_fxval& a, tp b )                                       \
+{                                                                             \
+    SC_FXVAL_OBSERVER_READ_( a )                                              \
+    sc_fxval tmp( b );                                                        \
+    return sc_fxval( sc_dt::fnc ## _scfx_rep( *a.m_rep, *tmp.m_rep ) );      \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+const sc_fxval                                                                \
+operator op ( tp a, const sc_fxval& b )                                       \
+{                                                                             \
+    SC_FXVAL_OBSERVER_READ_( b )                                              \
+    sc_fxval tmp( a );                                                        \
+    return sc_fxval( sc_dt::fnc ## _scfx_rep( *tmp.m_rep, *b.m_rep ) );      \
+}
+
+#define DEFN_BIN_OP(op,fnc)                                                   \
+DEFN_BIN_OP_T(op,fnc,const sc_fxnum_fast&)
+
+DEFN_BIN_OP(*,mult)
+DEFN_BIN_OP(+,add)
+DEFN_BIN_OP(-,sub)
+//DEFN_BIN_OP(/,div)
+DEFN_BIN_OP_T(/,div,const sc_fxnum_fast&)
+
+#undef DEFN_BIN_OP_T
+#undef DEFN_BIN_OP
+
+
+// binary functions
+
+#define DEFN_BIN_FNC_T(fnc,tp)                                                \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxval& c, const sc_fxval& a, tp b )                                  \
+{                                                                             \
+    SC_FXVAL_OBSERVER_READ_( a )                                              \
+    sc_fxval tmp( b );                                                        \
+    delete c.m_rep;                                                           \
+    c.m_rep = sc_dt::fnc ## _scfx_rep( *a.m_rep, *tmp.m_rep );               \
+    SC_FXVAL_OBSERVER_WRITE_( c )                                             \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxval& c, tp a, const sc_fxval& b )                                  \
+{                                                                             \
+    SC_FXVAL_OBSERVER_READ_( b )                                              \
+    sc_fxval tmp( a );                                                        \
+    delete c.m_rep;                                                           \
+    c.m_rep = sc_dt::fnc ## _scfx_rep( *tmp.m_rep, *b.m_rep );               \
+    SC_FXVAL_OBSERVER_WRITE_( c )                                             \
+}
+
+#define DEFN_BIN_FNC(fnc)                                                     \
+DEFN_BIN_FNC_T(fnc,const sc_fxnum_fast&)
+
+DEFN_BIN_FNC(mult)
+DEFN_BIN_FNC(div)
+DEFN_BIN_FNC(add)
+DEFN_BIN_FNC(sub)
+
+#undef DEFN_BIN_FNC_T
+#undef DEFN_BIN_FNC
+
+
+// relational (including equality) operators
+
+#define DEFN_REL_OP_T(op,ret,tp)                                              \
+inline                                                                        \
+bool                                                                          \
+operator op ( const sc_fxval& a, tp b )                                       \
+{                                                                             \
+    SC_FXVAL_OBSERVER_READ_( a )                                              \
+    sc_fxval tmp( b );                                                        \
+    int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep );                \
+    return ( ret );                                                           \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+bool                                                                          \
+operator op ( tp a, const sc_fxval& b )                                       \
+{                                                                             \
+    SC_FXVAL_OBSERVER_READ_( b )                                              \
+    sc_fxval tmp( a );                                                        \
+    int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep );                \
+    return ( ret );                                                           \
+}
+
+
+#define DEFN_REL_OP(op,ret)                                                   \
+DEFN_REL_OP_T(op,ret,const sc_fxnum_fast&)
+
+DEFN_REL_OP(<,result < 0)
+DEFN_REL_OP(<=,result <= 0)
+DEFN_REL_OP(>,result > 0 && result != 2)
+DEFN_REL_OP(>=,result >= 0 && result != 2)
+DEFN_REL_OP(==,result == 0)
+DEFN_REL_OP(!=,result != 0)
+
+#undef DEFN_REL_OP_T
+#undef DEFN_REL_OP
+
+
+// assignment operators
+
+inline
+sc_fxval&
+sc_fxval::operator = ( const sc_fxnum& a )
+{
+    *m_rep = *a.get_rep();
+    SC_FXVAL_OBSERVER_WRITE_( *this )
+    return *this;
+}
+
+#define DEFN_ASN_OP_T(tp)                                                     \
+inline                                                                        \
+sc_fxval&                                                                     \
+sc_fxval::operator = ( tp b )                                                 \
+{                                                                             \
+    sc_fxval tmp( b );                                                        \
+    *m_rep = *tmp.m_rep;                                                      \
+    SC_FXVAL_OBSERVER_WRITE_( *this )                                         \
+    return *this;                                                             \
+}
+
+DEFN_ASN_OP_T(const sc_fxnum_fast&)
+
+#undef DEFN_ASN_OP_T
+
+
+#define DEFN_ASN_OP_T(op,fnc,tp)                                              \
+inline                                                                        \
+sc_fxval&                                                                     \
+sc_fxval::operator op ( tp b )                                                \
+{                                                                             \
+    SC_FXVAL_OBSERVER_READ_( *this )                                          \
+    sc_fxval tmp( b );                                                        \
+    scfx_rep* new_rep = sc_dt::fnc ## _scfx_rep( *m_rep, *tmp.m_rep );       \
+    delete m_rep;                                                             \
+    m_rep = new_rep;                                                          \
+    SC_FXVAL_OBSERVER_WRITE_( *this )                                         \
+    return *this;                                                             \
+}
+
+#define DEFN_ASN_OP(op,fnc)                                                   \
+inline                                                                        \
+sc_fxval&                                                                     \
+sc_fxval::operator op ( const sc_fxnum& b )                                   \
+{                                                                             \
+    SC_FXVAL_OBSERVER_READ_( *this )                                          \
+    scfx_rep* new_rep = sc_dt::fnc ## _scfx_rep( *m_rep, *b.get_rep() );     \
+    delete m_rep;                                                             \
+    m_rep = new_rep;                                                          \
+    SC_FXVAL_OBSERVER_WRITE_( *this )                                         \
+    return *this;                                                             \
+}                                                                             \
+                                                                              \
+DEFN_ASN_OP_T(op,fnc,const sc_fxnum_fast&)
+
+DEFN_ASN_OP(*=,mult)
+DEFN_ASN_OP(/=,div)
+DEFN_ASN_OP(+=,add)
+DEFN_ASN_OP(-=,sub)
+
+#undef DEFN_ASN_OP_T
+#undef DEFN_ASN_OP
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxval_fast
+//
+//  Fixed-point value types; limited precision.
+// ----------------------------------------------------------------------------
+
+// public constructors
+
+inline
+sc_fxval_fast::sc_fxval_fast( const sc_fxnum& a,
+			      sc_fxval_fast_observer* observer_ )
+: m_val( a.to_double() ),
+  m_observer( observer_ )
+{
+    SC_FXVAL_FAST_OBSERVER_DEFAULT_
+    SC_FXVAL_FAST_OBSERVER_CONSTRUCT_( *this )
+    SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
+}
+
+inline
+sc_fxval_fast::sc_fxval_fast( const sc_fxnum_fast& a,
+			      sc_fxval_fast_observer* observer_ )
+: m_val( a.get_val() ),
+  m_observer( observer_ )
+{
+    SC_FXVAL_FAST_OBSERVER_DEFAULT_
+    SC_FXVAL_FAST_OBSERVER_CONSTRUCT_( *this )
+    SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
+}
+
+
+// binary functions
+
+#define DEFN_BIN_FNC_T(fnc,op,tp)                                             \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxval_fast& c, const sc_fxval_fast& a, tp b )                        \
+{                                                                             \
+    SC_FXVAL_FAST_OBSERVER_READ_( a )                                         \
+    sc_fxval_fast tmp( b );                                                   \
+    c.m_val = a.m_val op tmp.m_val;                                           \
+    SC_FXVAL_FAST_OBSERVER_WRITE_( c )                                        \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxval_fast& c, tp a, const sc_fxval_fast& b )                        \
+{                                                                             \
+    SC_FXVAL_FAST_OBSERVER_READ_( b )                                         \
+    sc_fxval_fast tmp( a );                                                   \
+    c.m_val = tmp.m_val op b.m_val;                                           \
+    SC_FXVAL_FAST_OBSERVER_WRITE_( c )                                        \
+}
+
+#define DEFN_BIN_FNC(fnc,op)                                                  \
+DEFN_BIN_FNC_T(fnc,op,const sc_fxval&)                                        \
+DEFN_BIN_FNC_T(fnc,op,const sc_fxnum&)
+
+DEFN_BIN_FNC(mult,*)
+DEFN_BIN_FNC(div,/)
+DEFN_BIN_FNC(add,+)
+DEFN_BIN_FNC(sub,-)
+
+#undef DEFN_BIN_FNC_T
+#undef DEFN_BIN_FNC
+
+
+// assignment operators
+
+inline
+sc_fxval_fast&
+sc_fxval_fast::operator = ( const sc_fxnum_fast& a )
+{
+    m_val = a.get_val();
+    SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
+    return *this;
+}
+
+#define DEFN_ASN_OP_T(tp)                                                     \
+inline                                                                        \
+sc_fxval_fast&                                                                \
+sc_fxval_fast::operator = ( tp a )                                            \
+{                                                                             \
+    sc_fxval_fast tmp( a );                                                   \
+    m_val = tmp.m_val;                                                        \
+    SC_FXVAL_FAST_OBSERVER_WRITE_( *this )                                    \
+    return *this;                                                             \
+}
+
+DEFN_ASN_OP_T(const sc_fxnum&)
+
+#undef DEFN_ASN_OP_T
+
+
+#define DEFN_ASN_OP_T(op,tp)                                                  \
+inline                                                                        \
+sc_fxval_fast&                                                                \
+sc_fxval_fast::operator op ( tp b )                                           \
+{                                                                             \
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )                                     \
+    sc_fxval_fast tmp( b );                                                   \
+    m_val op tmp.m_val;                                                       \
+    SC_FXVAL_FAST_OBSERVER_WRITE_( *this )                                    \
+    return *this;                                                             \
+}
+
+#define DEFN_ASN_OP(op)                                                       \
+inline                                                                        \
+sc_fxval_fast&                                                                \
+sc_fxval_fast::operator op ( const sc_fxnum_fast& b )                         \
+{                                                                             \
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )                                     \
+    m_val op b.get_val();                                                     \
+    SC_FXVAL_FAST_OBSERVER_WRITE_( *this )                                    \
+    return *this;                                                             \
+}                                                                             \
+                                                                              \
+DEFN_ASN_OP_T(op,const sc_fxnum&)
+
+DEFN_ASN_OP(*=)
+DEFN_ASN_OP(/=)
+DEFN_ASN_OP(+=)
+DEFN_ASN_OP(-=)
+
+#undef DEFN_ASN_OP_T
+#undef DEFN_ASN_OP
+
+} // namespace sc_dt
+
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/sc_fxnum_observer.cpp b/ext/systemc/src/sysc/datatypes/fx/sc_fxnum_observer.cpp
new file mode 100644
index 000000000..709a3c50b
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/sc_fxnum_observer.cpp
@@ -0,0 +1,74 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_fxnum_observer.cpp - 
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_fxnum_observer.cpp,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include "sysc/datatypes/fx/sc_fxnum_observer.h"
+
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum_observer
+//
+//  Abstract base class for fixed-point types observers; arbitrary precision.
+// ----------------------------------------------------------------------------
+
+sc_fxnum_observer* (*sc_fxnum_observer::default_observer) () = 0;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum_fast_observer
+//
+//  Abstract base class for fixed-point types observers; limited precision.
+// ----------------------------------------------------------------------------
+
+sc_fxnum_fast_observer* (*sc_fxnum_fast_observer::default_observer) () = 0;
+
+} // namespace sc_dt
+
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/sc_fxnum_observer.h b/ext/systemc/src/sysc/datatypes/fx/sc_fxnum_observer.h
new file mode 100644
index 000000000..2769df31b
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/sc_fxnum_observer.h
@@ -0,0 +1,219 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_fxnum_observer.h - 
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_fxnum_observer.h,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SC_FXNUM_OBSERVER_H
+#define SC_FXNUM_OBSERVER_H
+
+
+#include "sysc/datatypes/fx/sc_fxdefs.h"
+
+
+namespace sc_dt
+{
+
+// classes defined in this module
+class sc_fxnum_observer;
+class sc_fxnum_fast_observer;
+
+// forward class declarations
+class sc_fxnum;
+class sc_fxnum_fast;
+
+
+#ifdef SC_ENABLE_OBSERVERS
+
+#define SC_FXNUM_OBSERVER_CONSTRUCT_(object)                                  \
+    SC_OBSERVER_(object,sc_fxnum_observer*,construct)
+#define SC_FXNUM_OBSERVER_DESTRUCT_(object)                                   \
+    SC_OBSERVER_(object,sc_fxnum_observer*,destruct)
+#define SC_FXNUM_OBSERVER_READ_(object)                                       \
+    SC_OBSERVER_(object,sc_fxnum_observer*,read)
+#define SC_FXNUM_OBSERVER_WRITE_(object)                                      \
+    SC_OBSERVER_(object,sc_fxnum_observer*,write)
+#define SC_FXNUM_OBSERVER_DEFAULT_                                            \
+    SC_OBSERVER_DEFAULT_(sc_fxnum_observer)
+
+#define SC_FXNUM_FAST_OBSERVER_CONSTRUCT_(object)                             \
+    SC_OBSERVER_(object,sc_fxnum_fast_observer*,construct)
+#define SC_FXNUM_FAST_OBSERVER_DESTRUCT_(object)                              \
+    SC_OBSERVER_(object,sc_fxnum_fast_observer*,destruct)
+#define SC_FXNUM_FAST_OBSERVER_READ_(object)                                  \
+    SC_OBSERVER_(object,sc_fxnum_fast_observer*,read)
+#define SC_FXNUM_FAST_OBSERVER_WRITE_(object)                                 \
+    SC_OBSERVER_(object,sc_fxnum_fast_observer*,write)
+#define SC_FXNUM_FAST_OBSERVER_DEFAULT_                                       \
+    SC_OBSERVER_DEFAULT_(sc_fxnum_fast_observer)
+
+#else
+
+#define SC_FXNUM_OBSERVER_CONSTRUCT_(object)
+#define SC_FXNUM_OBSERVER_DESTRUCT_(object)
+#define SC_FXNUM_OBSERVER_READ_(object)
+#define SC_FXNUM_OBSERVER_WRITE_(object)
+#define SC_FXNUM_OBSERVER_DEFAULT_
+
+#define SC_FXNUM_FAST_OBSERVER_CONSTRUCT_(object)
+#define SC_FXNUM_FAST_OBSERVER_DESTRUCT_(object)
+#define SC_FXNUM_FAST_OBSERVER_READ_(object)
+#define SC_FXNUM_FAST_OBSERVER_WRITE_(object)
+#define SC_FXNUM_FAST_OBSERVER_DEFAULT_
+
+#endif
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum_observer
+//
+//  Abstract base class for fixed-point types observers; arbitrary precision.
+// ----------------------------------------------------------------------------
+
+class sc_fxnum_observer
+{
+
+protected:
+    
+    sc_fxnum_observer() {}
+    virtual ~sc_fxnum_observer() {}
+
+public:
+
+    virtual void construct( const sc_fxnum& );
+    virtual void  destruct( const sc_fxnum& );
+    virtual void      read( const sc_fxnum& );
+    virtual void     write( const sc_fxnum& );
+
+    static sc_fxnum_observer* (*default_observer) ();
+
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum_fast_observer
+//
+//  Abstract base class for fixed-point types observers; limited precision.
+// ----------------------------------------------------------------------------
+
+class sc_fxnum_fast_observer
+{
+
+protected:
+    
+    sc_fxnum_fast_observer() {}
+    virtual ~sc_fxnum_fast_observer() {}
+
+public:
+
+    virtual void construct( const sc_fxnum_fast& );
+    virtual void  destruct( const sc_fxnum_fast& );
+    virtual void      read( const sc_fxnum_fast& );
+    virtual void     write( const sc_fxnum_fast& );
+
+    static sc_fxnum_fast_observer* (*default_observer) ();
+
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum_observer
+//
+//  Abstract base class for fixed-point types observers; arbitrary precision.
+// ----------------------------------------------------------------------------
+
+inline
+void
+sc_fxnum_observer::construct( const sc_fxnum& )
+{}
+
+inline
+void
+sc_fxnum_observer::destruct( const sc_fxnum& )
+{}
+
+inline
+void
+sc_fxnum_observer::read( const sc_fxnum& )
+{}
+
+inline
+void
+sc_fxnum_observer::write( const sc_fxnum& )
+{}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum_fast_observer
+//
+//  Abstract base class for fixed-point types observers; limited precision.
+// ----------------------------------------------------------------------------
+
+inline
+void
+sc_fxnum_fast_observer::construct( const sc_fxnum_fast& )
+{}
+
+inline
+void
+sc_fxnum_fast_observer::destruct( const sc_fxnum_fast& )
+{}
+
+inline
+void
+sc_fxnum_fast_observer::read( const sc_fxnum_fast& )
+{}
+
+inline
+void
+sc_fxnum_fast_observer::write( const sc_fxnum_fast& )
+{}
+
+} // namespace sc_dt
+
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/sc_fxtype_params.cpp b/ext/systemc/src/sysc/datatypes/fx/sc_fxtype_params.cpp
new file mode 100644
index 000000000..60c18a2b5
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/sc_fxtype_params.cpp
@@ -0,0 +1,108 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_fxtype_params.cpp - 
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_fxtype_params.cpp,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include "sysc/datatypes/fx/sc_fxtype_params.h"
+
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxtype_params
+//
+//  Fixed-point type parameters class.
+// ----------------------------------------------------------------------------
+
+const std::string
+sc_fxtype_params::to_string() const
+{
+    std::string s;
+
+    char buf[BUFSIZ];
+
+    s += "(";
+    std::sprintf( buf, "%d", m_wl );
+    s += buf;
+    s += ",";
+    std::sprintf( buf, "%d", m_iwl );
+    s += buf;
+    s += ",";
+    s += sc_dt::to_string( m_q_mode );
+    s += ",";
+    s += sc_dt::to_string( m_o_mode );
+    s += ",";
+    std::sprintf( buf, "%d", m_n_bits );
+    s += buf;
+    s += ")";
+
+    return s;
+}
+
+
+void
+sc_fxtype_params::print( ::std::ostream& os ) const
+{
+    os << to_string();
+}
+
+void
+sc_fxtype_params::dump( ::std::ostream& os ) const
+{
+    os << "sc_fxtype_params" << ::std::endl;
+    os << "(" << ::std::endl;
+    os << "wl     = " << m_wl << ::std::endl;
+    os << "iwl    = " << m_iwl << ::std::endl;
+    os << "q_mode = " << m_q_mode << ::std::endl;
+    os << "o_mode = " << m_o_mode << ::std::endl;
+    os << "n_bits = " << m_n_bits << ::std::endl;
+    os << ")" << ::std::endl;
+}
+
+} // namespace sc_dt
+
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/sc_fxtype_params.h b/ext/systemc/src/sysc/datatypes/fx/sc_fxtype_params.h
new file mode 100644
index 000000000..a59ba293b
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/sc_fxtype_params.h
@@ -0,0 +1,342 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_fxtype_params.h - 
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_fxtype_params.h,v $
+// Revision 1.2  2011/08/24 22:05:43  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SC_FXTYPE_PARAMS_H
+#define SC_FXTYPE_PARAMS_H
+
+
+#include "sysc/datatypes/fx/sc_context.h"
+
+
+namespace sc_dt
+{
+
+// classes defined in this module
+class sc_fxtype_params;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxtype_params
+//
+//  Fixed-point type parameters class.
+// ----------------------------------------------------------------------------
+
+class sc_fxtype_params
+{
+public:
+
+             sc_fxtype_params();
+             sc_fxtype_params( int, int );
+             sc_fxtype_params(           sc_q_mode, sc_o_mode, int = 0 );
+             sc_fxtype_params( int, int, sc_q_mode, sc_o_mode, int = 0 );
+             sc_fxtype_params( const sc_fxtype_params& );
+	     sc_fxtype_params( const sc_fxtype_params&,
+			       int, int );
+	     sc_fxtype_params( const sc_fxtype_params&,
+			                 sc_q_mode, sc_o_mode, int = 0 );
+    explicit sc_fxtype_params( sc_without_context );
+
+    sc_fxtype_params& operator = ( const sc_fxtype_params& );
+
+    friend bool operator == ( const sc_fxtype_params&,
+                              const sc_fxtype_params& );
+    friend bool operator != ( const sc_fxtype_params&,
+			      const sc_fxtype_params& );
+
+    int wl() const;
+    void wl( int );
+
+    int iwl() const;
+    void iwl( int );
+
+    sc_q_mode q_mode() const;
+    void q_mode( sc_q_mode );
+
+    sc_o_mode o_mode() const;
+    void o_mode( sc_o_mode );
+
+    int n_bits() const;
+    void n_bits( int );
+
+    const std::string to_string() const;
+
+    void print( ::std::ostream& = ::std::cout ) const;
+    void dump( ::std::ostream& = ::std::cout ) const;
+
+private:
+
+    int       m_wl;
+    int       m_iwl;
+    sc_q_mode m_q_mode;
+    sc_o_mode m_o_mode;
+    int       m_n_bits;
+};
+
+
+// ----------------------------------------------------------------------------
+//  TYPEDEF : sc_fxtype_context
+//
+//  Context type for the fixed-point type parameters.
+// ----------------------------------------------------------------------------
+
+typedef sc_context<sc_fxtype_params> sc_fxtype_context;
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+inline
+sc_fxtype_params::sc_fxtype_params() 
+: m_wl(), m_iwl(), m_q_mode(), m_o_mode(), m_n_bits()
+{
+    *this = sc_fxtype_context::default_value();
+}
+
+inline
+sc_fxtype_params::sc_fxtype_params( int wl_, int iwl_ )
+: m_wl(), m_iwl(), m_q_mode(), m_o_mode(), m_n_bits()
+{
+    *this = sc_fxtype_context::default_value();
+
+    SC_CHECK_WL_( wl_ );
+    m_wl  = wl_;
+    m_iwl = iwl_;
+}
+
+inline
+sc_fxtype_params::sc_fxtype_params( sc_q_mode q_mode_,
+                                    sc_o_mode o_mode_, int n_bits_ )
+: m_wl(), m_iwl(), m_q_mode(), m_o_mode(), m_n_bits()
+{
+    *this = sc_fxtype_context::default_value();
+
+    SC_CHECK_N_BITS_( n_bits_ );
+    m_q_mode = q_mode_;
+    m_o_mode = o_mode_;
+    m_n_bits = n_bits_;
+}
+
+inline
+sc_fxtype_params::sc_fxtype_params( int wl_, int iwl_,
+                                    sc_q_mode q_mode_,
+                                    sc_o_mode o_mode_, int n_bits_ )
+: m_wl(), m_iwl(), m_q_mode(), m_o_mode(), m_n_bits()
+{
+    SC_CHECK_WL_( wl_ );
+    SC_CHECK_N_BITS_( n_bits_ );
+    m_wl     = wl_;
+    m_iwl    = iwl_;
+    m_q_mode = q_mode_;
+    m_o_mode = o_mode_;
+    m_n_bits = n_bits_;
+}
+
+inline
+sc_fxtype_params::sc_fxtype_params( const sc_fxtype_params& a )
+: m_wl( a.m_wl ), m_iwl( a.m_iwl ),
+  m_q_mode( a.m_q_mode ),
+  m_o_mode( a.m_o_mode ), m_n_bits( a.m_n_bits )
+{}
+
+inline
+sc_fxtype_params::sc_fxtype_params( const sc_fxtype_params& a,
+				    int wl_, int iwl_ )
+: m_wl( wl_ ), m_iwl( iwl_ ),
+  m_q_mode( a.m_q_mode ),
+  m_o_mode( a.m_o_mode ), m_n_bits( a.m_n_bits )
+{}
+
+inline
+sc_fxtype_params::sc_fxtype_params( const sc_fxtype_params& a,
+				    sc_q_mode q_mode_,
+				    sc_o_mode o_mode_, int n_bits_ )
+: m_wl( a.m_wl ), m_iwl( a.m_iwl ),
+  m_q_mode( q_mode_ ),
+  m_o_mode( o_mode_ ), m_n_bits( n_bits_ )
+{}
+
+inline
+sc_fxtype_params::sc_fxtype_params( sc_without_context )
+: m_wl    ( SC_DEFAULT_WL_ ),
+  m_iwl   ( SC_DEFAULT_IWL_ ),
+  m_q_mode( SC_DEFAULT_Q_MODE_ ),
+  m_o_mode( SC_DEFAULT_O_MODE_ ),
+  m_n_bits( SC_DEFAULT_N_BITS_ )
+{}
+
+
+inline
+sc_fxtype_params&
+sc_fxtype_params::operator = ( const sc_fxtype_params& a )
+{
+    if( &a != this )
+    {
+        m_wl     = a.m_wl;
+	m_iwl    = a.m_iwl;
+	m_q_mode = a.m_q_mode;
+	m_o_mode = a.m_o_mode;
+	m_n_bits = a.m_n_bits;
+    }
+    return *this;
+}
+
+
+inline
+bool
+operator == ( const sc_fxtype_params& a, const sc_fxtype_params& b )
+{
+    return ( a.m_wl     == b.m_wl     &&
+	     a.m_iwl    == b.m_iwl    &&
+	     a.m_q_mode == b.m_q_mode &&
+	     a.m_o_mode == b.m_o_mode &&
+	     a.m_n_bits == b.m_n_bits );
+}
+
+inline
+bool
+operator != ( const sc_fxtype_params& a, const sc_fxtype_params& b )
+{
+    return ( a.m_wl     != b.m_wl     ||
+	     a.m_iwl    != b.m_iwl    ||
+	     a.m_q_mode != b.m_q_mode ||
+	     a.m_o_mode != b.m_o_mode ||
+	     a.m_n_bits != b.m_n_bits );
+}
+
+
+inline
+int
+sc_fxtype_params::wl() const
+{
+    return m_wl;
+}
+
+inline
+void
+sc_fxtype_params::wl( int wl_ )
+{
+    SC_CHECK_WL_( wl_ );
+    m_wl = wl_;
+}
+
+
+inline
+int
+sc_fxtype_params::iwl() const
+{
+    return m_iwl;
+}
+
+inline
+void
+sc_fxtype_params::iwl( int iwl_ )
+{
+    m_iwl = iwl_;
+}
+
+
+inline
+sc_q_mode
+sc_fxtype_params::q_mode() const
+{
+    return m_q_mode;
+}
+
+inline
+void
+sc_fxtype_params::q_mode( sc_q_mode q_mode_ )
+{
+    m_q_mode = q_mode_;
+}
+
+
+inline
+sc_o_mode
+sc_fxtype_params::o_mode() const
+{
+    return m_o_mode;
+}
+
+inline
+void
+sc_fxtype_params::o_mode( sc_o_mode o_mode_ )
+{
+    m_o_mode = o_mode_;
+}
+
+
+inline
+int
+sc_fxtype_params::n_bits() const
+{
+    return m_n_bits;
+}
+
+inline
+void
+sc_fxtype_params::n_bits( int n_bits_ )
+{
+    SC_CHECK_N_BITS_( n_bits_ );
+    m_n_bits = n_bits_;
+}
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_fxtype_params& a )
+{
+    a.print( os );
+    return os;
+}
+
+} // namespace sc_dt
+
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/sc_fxval.cpp b/ext/systemc/src/sysc/datatypes/fx/sc_fxval.cpp
new file mode 100644
index 000000000..3ba5fbacd
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/sc_fxval.cpp
@@ -0,0 +1,884 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_fxval.cpp - 
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_fxval.cpp,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include <ctype.h>
+#include <stdlib.h>
+#include <math.h>
+#include <float.h>
+
+#include "sysc/datatypes/fx/sc_fxval.h"
+
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxval
+//
+//  Fixed-point value type; arbitrary precision.
+// ----------------------------------------------------------------------------
+
+// explicit conversion to character string
+
+const std::string
+sc_fxval::to_string() const
+{
+    return std::string( m_rep->to_string( SC_DEC, -1, SC_E ) );
+}
+
+const std::string
+sc_fxval::to_string( sc_numrep numrep ) const
+{
+    return std::string( m_rep->to_string( numrep, -1, SC_E ) );
+}
+
+const std::string
+sc_fxval::to_string( sc_numrep numrep, bool w_prefix ) const
+{
+    return std::string( m_rep->to_string( numrep, (w_prefix ? 1 : 0), SC_E ) );
+}
+
+const std::string
+sc_fxval::to_string( sc_fmt fmt ) const
+{
+    return std::string( m_rep->to_string( SC_DEC, -1, fmt ) );
+}
+
+const std::string
+sc_fxval::to_string( sc_numrep numrep, sc_fmt fmt ) const
+{
+    return std::string( m_rep->to_string( numrep, -1, fmt ) );
+}
+
+const std::string
+sc_fxval::to_string( sc_numrep numrep, bool w_prefix, sc_fmt fmt ) const
+{
+    return std::string( m_rep->to_string( numrep, (w_prefix ? 1 : 0), fmt ) );
+}
+
+
+const std::string
+sc_fxval::to_dec() const
+{
+    return std::string( m_rep->to_string( SC_DEC, -1, SC_E ) );
+}
+
+const std::string
+sc_fxval::to_bin() const
+{
+    return std::string( m_rep->to_string( SC_BIN, -1, SC_E ) );
+}
+
+const std::string
+sc_fxval::to_oct() const
+{
+    return std::string( m_rep->to_string( SC_OCT, -1, SC_E ) );
+}
+
+const std::string
+sc_fxval::to_hex() const
+{
+    return std::string( m_rep->to_string( SC_HEX, -1, SC_E ) );
+}
+
+
+// print or dump content
+
+void
+sc_fxval::print( ::std::ostream& os ) const
+{
+    m_rep->print( os );
+}
+
+void
+sc_fxval::scan( ::std::istream& is )
+{
+    std::string s;
+    is >> s;
+    *this = s.c_str();
+}
+
+void
+sc_fxval::dump( ::std::ostream& os ) const
+{
+    os << "sc_fxval" << ::std::endl;
+    os << "(" << ::std::endl;
+    os << "rep = ";
+    m_rep->dump( os );
+    // TO BE COMPLETED
+    // os << "r_flag   = " << m_r_flag << ::std::endl;
+    // os << "observer = ";
+    // if( m_observer != 0 )
+    //     m_observer->dump( os );
+    // else
+    //     os << "0" << ::std::endl;
+    os << ")" << ::std::endl;
+}
+
+
+// protected methods and friend functions
+
+sc_fxval_observer*
+sc_fxval::lock_observer() const
+{
+    SC_ASSERT_( m_observer != 0, "lock observer failed" );
+    sc_fxval_observer* tmp = m_observer;
+    m_observer = 0;
+    return tmp;
+}
+
+void
+sc_fxval::unlock_observer( sc_fxval_observer* observer_ ) const
+{
+    SC_ASSERT_( observer_ != 0, "unlock observer failed" );
+    m_observer = observer_;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxval_fast
+//
+//  Fixed-point value types; limited precision.
+// ----------------------------------------------------------------------------
+
+static
+void
+print_dec( scfx_string& s, scfx_ieee_double id, int w_prefix, sc_fmt fmt )
+{
+    if( id.negative() != 0 )
+    {
+	id.negative( 0 );
+	s += '-';
+    }
+
+    if( w_prefix == 1 ) {
+	scfx_print_prefix( s, SC_DEC );
+    }
+
+    if( id.is_zero() )
+    {
+	s += '0';
+	return;
+    }
+
+    // split 'id' into its integer and fractional part
+
+    double int_part;
+    double frac_part = modf( static_cast<double>( id ), &int_part );
+
+    int i;
+
+    // print integer part
+
+    int int_digits = 0;
+    int int_zeros  = 0;
+    
+    if( int_part != 0.0 )
+    {
+	int_digits = (int) ceil( log10( int_part + 1.0 ) );
+
+	int len = s.length();
+	s.append( int_digits );
+
+	bool zero_digits = ( frac_part == 0.0 && fmt != SC_F );
+
+	for( i = int_digits + len - 1; i >= len; i-- )
+	{
+	    unsigned int remainder = (unsigned int) fmod( int_part, 10.0 );
+	    s[i] = static_cast<char>( '0' + remainder );
+	    
+	    if( zero_digits )
+	    {
+		if( remainder == 0 )
+		    int_zeros ++;
+		else
+		    zero_digits = false;
+	    }
+
+	    int_part /= 10.0;
+	}
+
+	// discard trailing zeros from int_part
+	s.discard( int_zeros );
+
+	if( s[len] == '0' )
+	{
+	    // int_digits was overestimated by one
+	    s.remove( len );
+	    -- int_digits;
+	}
+    }
+
+    // print fractional part
+
+    int frac_digits = 0;
+    int frac_zeros  = 0;
+
+    if( frac_part != 0.0 )
+    {
+	s += '.';
+
+	bool zero_digits = ( int_digits == 0 && fmt != SC_F );
+
+	frac_zeros = (int) floor( - log10( frac_part + DBL_EPSILON ) );
+
+	frac_part *= pow( 10.0, frac_zeros );
+	
+	frac_digits = frac_zeros;
+	if( ! zero_digits )
+	{
+	    for( i = 0; i < frac_zeros; i ++ )
+		s += '0';
+	    frac_zeros = 0;
+	}
+
+	while( frac_part != 0.0 )
+	{
+	    frac_part *= 10.0;
+	    int n = static_cast<int>( frac_part );
+	
+	    if( zero_digits )
+	    {
+		if( n == 0 )
+		    frac_zeros ++;
+		else
+		    zero_digits = false;
+	    }
+	
+	    if( ! zero_digits )
+		s += static_cast<char>( '0' + n );
+
+	    frac_part -= n;
+	    frac_digits ++;
+	}
+    }
+
+    // print exponent
+    
+    if( fmt != SC_F )
+    {
+        if( frac_digits == 0 )
+	    scfx_print_exp( s, int_zeros );
+	else if( int_digits == 0 )
+	    scfx_print_exp( s, - frac_zeros );
+    }
+}
+
+
+static
+void
+print_other( scfx_string& s, const scfx_ieee_double& id, sc_numrep numrep,
+	     int w_prefix, sc_fmt fmt, const scfx_params* params )
+{
+    scfx_ieee_double id2 = id;
+
+    sc_numrep numrep2 = numrep;
+
+    bool numrep_is_sm = ( numrep == SC_BIN_SM ||
+			  numrep == SC_OCT_SM ||
+			  numrep == SC_HEX_SM );
+
+    if( numrep_is_sm )
+    {
+	if( id2.negative() != 0 )
+	{
+	    s += '-';
+	    id2.negative( 0 );
+	}
+	switch( numrep )
+	{
+	    case SC_BIN_SM:
+		numrep2 = SC_BIN_US;
+		break;
+	    case SC_OCT_SM:
+		numrep2 = SC_OCT_US;
+		break;
+	    case SC_HEX_SM:
+		numrep2 = SC_HEX_US;
+		break;
+	    default:
+		;
+	}
+    }
+
+    if( w_prefix != 0 ) {
+	scfx_print_prefix( s, numrep );
+    }
+
+    numrep = numrep2;
+
+    sc_fxval_fast a( id2 );
+
+    int msb, lsb;
+
+    if( params != 0 )
+    {
+	msb = params->iwl() - 1;
+	lsb = params->iwl() - params->wl();
+
+	if( params->enc() == SC_TC_ &&
+	    ( numrep == SC_BIN_US ||
+	      numrep == SC_OCT_US ||
+	      numrep == SC_HEX_US ) &&
+	    ! numrep_is_sm &&
+	    params->wl() > 1 )
+	    -- msb;
+	else if( params->enc() == SC_US_ &&
+	    ( numrep == SC_BIN ||
+	      numrep == SC_OCT ||
+	      numrep == SC_HEX ||
+	      numrep == SC_CSD ) )
+	    ++ msb;
+    }
+    else
+    {
+	if( a.is_zero() )
+	{
+	    msb = 0;
+	    lsb = 0;
+	}
+	else
+	{
+	    msb = id2.exponent() + 1;
+	    while( a.get_bit( msb ) == a.get_bit( msb - 1 ) )
+		-- msb;
+
+	    if( numrep == SC_BIN_US ||
+		numrep == SC_OCT_US ||
+		numrep == SC_HEX_US )
+		-- msb;
+
+	    lsb = id2.exponent() - 52;
+	    while( ! a.get_bit( lsb ) )
+		++ lsb;
+	}
+    }
+
+    int step;
+
+    switch( numrep )
+    {
+	case SC_BIN:
+	case SC_BIN_US:
+	case SC_CSD:
+	    step = 1;
+	   break;
+	case SC_OCT:
+	case SC_OCT_US:
+	    step = 3;
+	    break;
+	case SC_HEX:
+	case SC_HEX_US:
+	    step = 4;
+	    break;
+	default:
+	    step = 0;
+    }
+
+    msb = (int) ceil( double( msb + 1 ) / step ) * step - 1;
+
+    lsb = (int) floor( double( lsb ) / step ) * step;
+
+    if( msb < 0 )
+    {
+	s += '.';
+	if( fmt == SC_F )
+	{
+	    int sign = ( id2.negative() != 0 ) ? ( 1 << step ) - 1 : 0;
+	    for( int i = ( msb + 1 ) / step; i < 0; i ++ )
+	    {
+		if( sign < 10 )
+		    s += static_cast<char>( sign + '0' );
+		else
+		    s += static_cast<char>( sign + 'a' - 10 );
+	    }
+	}
+    }
+
+    int i = msb;
+    while( i >= lsb )
+    {
+        int value = 0;
+        for( int j = step - 1; j >= 0; -- j )
+	{
+            value += static_cast<int>( a.get_bit( i ) ) << j;
+            -- i;
+        }
+        if( value < 10 )
+            s += static_cast<char>( value + '0' );
+	else
+            s += static_cast<char>( value + 'a' - 10 );
+	if( i == -1 )
+	    s += '.';
+    }
+
+    if( lsb > 0 && fmt == SC_F )
+    {
+	for( int i = lsb / step; i > 0; i -- )
+	    s += '0';
+    }
+
+    if( s[s.length() - 1] == '.' )
+	s.discard( 1 );
+
+    if( fmt != SC_F )
+    {
+	if( msb < 0 )
+	    scfx_print_exp( s, ( msb + 1 ) / step );
+	else if( lsb > 0 )
+	    scfx_print_exp( s, lsb / step );
+    }
+
+    if( numrep == SC_CSD )
+	scfx_tc2csd( s, w_prefix );
+}
+
+
+const char*
+to_string( const scfx_ieee_double& id, sc_numrep numrep, int w_prefix,
+	   sc_fmt fmt, const scfx_params* params = 0 )
+{
+    static scfx_string s;
+
+    s.clear();
+
+    if( id.is_nan() )
+        scfx_print_nan( s );
+    else if( id.is_inf() )
+        scfx_print_inf( s, static_cast<bool>( id.negative() ) );
+    else if( id.negative() && ! id.is_zero() &&
+	     ( numrep == SC_BIN_US ||
+	       numrep == SC_OCT_US ||
+	       numrep == SC_HEX_US ) )
+        s += "negative";
+    else if( numrep == SC_DEC )
+        sc_dt::print_dec( s, id, w_prefix, fmt );
+    else
+        sc_dt::print_other( s, id, numrep, w_prefix, fmt, params );
+
+    return s;
+}
+
+
+// explicit conversion to character string
+
+const std::string
+sc_fxval_fast::to_string() const
+{
+    return std::string( sc_dt::to_string( m_val, SC_DEC, -1, SC_E ) );
+}
+
+const std::string
+sc_fxval_fast::to_string( sc_numrep numrep ) const
+{
+    return std::string( sc_dt::to_string( m_val, numrep, -1, SC_E ) );
+}
+
+const std::string
+sc_fxval_fast::to_string( sc_numrep numrep, bool w_prefix ) const
+{
+    return std::string( sc_dt::to_string( m_val, numrep, (w_prefix ? 1 : 0),
+					SC_E ) );
+}
+
+const std::string
+sc_fxval_fast::to_string( sc_fmt fmt ) const
+{
+    return std::string( sc_dt::to_string( m_val, SC_DEC, -1, fmt ) );
+}
+
+const std::string
+sc_fxval_fast::to_string( sc_numrep numrep, sc_fmt fmt ) const
+{
+    return std::string( sc_dt::to_string( m_val, numrep, -1, fmt ) );
+}
+
+const std::string
+sc_fxval_fast::to_string( sc_numrep numrep, bool w_prefix, sc_fmt fmt ) const
+{
+    return std::string( sc_dt::to_string( m_val, numrep, (w_prefix ? 1 : 0),
+					fmt ) );
+}
+
+
+const std::string
+sc_fxval_fast::to_dec() const
+{
+    return std::string( sc_dt::to_string( m_val, SC_DEC, -1, SC_E ) );
+}
+
+const std::string
+sc_fxval_fast::to_bin() const
+{
+    return std::string( sc_dt::to_string( m_val, SC_BIN, -1, SC_E ) );
+}
+
+const std::string
+sc_fxval_fast::to_oct() const
+{
+    return std::string( sc_dt::to_string( m_val, SC_OCT, -1, SC_E ) );
+}
+
+const std::string
+sc_fxval_fast::to_hex() const
+{
+    return std::string( sc_dt::to_string( m_val, SC_HEX, -1, SC_E ) );
+}
+
+
+// print or dump content
+
+void
+sc_fxval_fast::print( ::std::ostream& os ) const
+{
+    os << sc_dt::to_string( m_val, SC_DEC, -1, SC_E );
+}
+
+void
+sc_fxval_fast::scan( ::std::istream& is )
+{
+    std::string s;
+    is >> s;
+    *this = s.c_str();
+}
+
+void
+sc_fxval_fast::dump( ::std::ostream& os ) const
+{
+    os << "sc_fxval_fast" << ::std::endl;
+    os << "(" << ::std::endl;
+    os << "val = " << m_val << ::std::endl;
+    // TO BE COMPLETED
+    // os << "r_flag   = " << m_r_flag << ::std::endl;
+    // os << "observer = ";
+    // if( m_observer != 0 )
+    //     m_observer->dump( os );
+    // else
+    //     os << "0" << ::std::endl;
+    os << ")" << ::std::endl;
+}
+
+
+// internal use only;
+bool
+sc_fxval_fast::get_bit( int i ) const
+{
+    scfx_ieee_double id( m_val );
+    if( id.is_zero() || id.is_nan() || id.is_inf() )
+        return false;
+
+    // convert to two's complement
+
+    unsigned int m0 = id.mantissa0();
+    unsigned int m1 = id.mantissa1();
+
+    if( id.is_normal() )
+        m0 += 1U << 20;
+
+    if( id.negative() != 0 )
+    {
+	m0 = ~ m0;
+	m1 = ~ m1;
+	unsigned int tmp = m1;
+	m1 += 1U;
+	if( m1 <= tmp )
+	    m0 += 1U;
+    }
+
+    // get the right bit
+
+    int j = i - id.exponent();
+    if( ( j += 20 ) >= 32 )
+        return ( ( m0 & 1U << 31 ) != 0 );
+    else if( j >= 0 )
+        return ( ( m0 & 1U << j ) != 0 );
+    else if( ( j += 32 ) >= 0 )
+        return ( ( m1 & 1U << j ) != 0 );
+    else
+        return false;
+}
+
+
+// protected methods and friend functions
+
+sc_fxval_fast_observer*
+sc_fxval_fast::lock_observer() const
+{
+    SC_ASSERT_( m_observer != 0, "lock observer failed" );
+    sc_fxval_fast_observer* tmp = m_observer;
+    m_observer = 0;
+    return tmp;
+}
+
+void
+sc_fxval_fast::unlock_observer( sc_fxval_fast_observer* observer_ ) const
+{
+    SC_ASSERT_( observer_ != 0, "unlock observer failed" );
+    m_observer = observer_;
+}
+
+
+#define SCFX_FAIL_IF_(cnd)                                                    \
+{                                                                             \
+    if( ( cnd ) )                                                             \
+        return static_cast<double>( scfx_ieee_double::nan() );                \
+}
+
+double
+sc_fxval_fast::from_string( const char* s )
+{
+    SCFX_FAIL_IF_( s == 0 || *s == 0 );
+
+    scfx_string s2;
+    s2 += s;
+    s2 += '\0';
+
+    bool sign_char;
+    int sign = scfx_parse_sign( s, sign_char );
+
+    sc_numrep numrep = scfx_parse_prefix( s );
+
+    int base = 0;
+
+    switch( numrep )
+    {
+	case SC_DEC:
+	{
+	    base = 10;
+	    if( scfx_is_nan( s ) )  // special case: NaN
+		return static_cast<double>( scfx_ieee_double::nan() );
+	    if( scfx_is_inf( s ) )  // special case: Infinity
+		return static_cast<double>( scfx_ieee_double::inf( sign ) );
+	    break;
+	}
+	case SC_BIN:
+	case SC_BIN_US:
+	{
+	    SCFX_FAIL_IF_( sign_char );
+	    base = 2;
+	    break;
+	}
+	
+	case SC_BIN_SM:
+	{
+	    base = 2;
+	    break;
+	}
+	case SC_OCT:
+	case SC_OCT_US:
+	{
+	    SCFX_FAIL_IF_( sign_char );
+	    base = 8;
+	    break;
+	}
+	case SC_OCT_SM:
+	{
+	    base = 8;
+	    break;
+	}
+	case SC_HEX:
+	case SC_HEX_US:
+	{
+	    SCFX_FAIL_IF_( sign_char );
+	    base = 16;
+	    break;
+	}
+	case SC_HEX_SM:
+	{
+	    base = 16;
+	    break;
+	}
+	case SC_CSD:
+	{
+	    SCFX_FAIL_IF_( sign_char );
+	    base = 2;
+	    scfx_csd2tc( s2 );
+	    s = (const char*) s2 + 4;
+	    numrep = SC_BIN;
+	    break;
+	}
+       default:;// Martin, what is default???
+    }
+
+    //
+    // find end of mantissa and count the digits and points
+    //
+
+    const char *end = s;
+    bool based_point = false;
+    int int_digits = 0;
+    int frac_digits = 0;
+
+    while( *end )
+    {
+	if( scfx_exp_start( end ) )
+	    break;
+	
+	if( *end == '.' )
+	{
+	    SCFX_FAIL_IF_( based_point );
+	    based_point = true;
+	}
+	else
+	{
+	    SCFX_FAIL_IF_( ! scfx_is_digit( *end, numrep ) );
+	    if( based_point )
+		frac_digits ++;
+	    else
+		int_digits ++;
+	}
+
+	end ++;
+    }
+
+    SCFX_FAIL_IF_( int_digits == 0 && frac_digits == 0 );
+
+    // [ exponent ]
+    
+    int exponent = 0;
+
+    if( *end )
+    {
+	for( const char *e = end + 2; *e; e ++ )
+	    SCFX_FAIL_IF_( ! scfx_is_digit( *e, SC_DEC ) );
+	exponent = atoi( end + 1 );
+    }
+
+    //
+    // convert the mantissa
+    //
+
+    double integer = 0.0;
+
+    if( int_digits != 0 )
+    {
+
+	bool first_digit = true;
+
+	for( ; s < end; s ++ )
+	{
+	    if( *s == '.' )
+		break;
+	    
+	    if( first_digit )
+	    {
+		integer = scfx_to_digit( *s, numrep );
+		switch( numrep )
+		{
+		    case SC_BIN:
+		    case SC_OCT:
+		    case SC_HEX:
+		    {
+			if( integer >= ( base >> 1 ) )
+			    integer -= base;  // two's complement
+			break;
+		    }
+		    default:
+			;
+		}
+		first_digit = false;
+	    }
+            else
+	    {
+		integer *= base;
+		integer += scfx_to_digit( *s, numrep );
+	    }
+	}
+    }
+
+    // [ . fraction ]
+
+    double fraction = 0.0;
+    
+    if( frac_digits != 0 )
+    {
+	s ++;  // skip '.'
+
+	bool first_digit = ( int_digits == 0 );
+
+	double scale = 1.0;
+
+	for( ; s < end; s ++ )
+	{
+	    scale /= base;
+	    
+	    if( first_digit )
+	    {
+		fraction = scfx_to_digit( *s, numrep );
+		switch( numrep )
+		{
+		    case SC_BIN:
+		    case SC_OCT:
+		    case SC_HEX:
+		    {
+			if( fraction >= ( base >> 1 ) )
+			    fraction -= base;  // two's complement
+			break;
+		    }
+		    default:
+			;
+		}
+		fraction *= scale;
+		first_digit = false;
+	    }
+	    else
+		fraction += scfx_to_digit( *s, numrep ) * scale;
+	}
+    }
+
+    double exp = ( exponent != 0 ) ? pow( (double) base, (double) exponent )
+	                           : 1;
+
+    return ( sign * ( integer + fraction ) * exp );
+}
+
+#undef SCFX_FAIL_IF_
+
+} // namespace sc_dt
+
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/sc_fxval.h b/ext/systemc/src/sysc/datatypes/fx/sc_fxval.h
new file mode 100644
index 000000000..1f199875c
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/sc_fxval.h
@@ -0,0 +1,2269 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_fxval.h - 
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_fxval.h,v $
+// Revision 1.3  2011/01/19 18:57:40  acg
+//  Andy Goodrich: changes for IEEE_1666_2011.
+//
+// Revision 1.2  2010/12/07 20:09:08  acg
+// Andy Goodrich: Philipp Hartmann's constructor disambiguation fix
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SC_FXVAL_H
+#define SC_FXVAL_H
+
+
+#include "sysc/datatypes/fx/scfx_rep.h"
+#ifndef SC_FX_EXCLUDE_OTHER
+#include "sysc/datatypes/int/sc_int_base.h"
+#include "sysc/datatypes/int/sc_uint_base.h"
+#include "sysc/datatypes/int/sc_signed.h"
+#include "sysc/datatypes/int/sc_unsigned.h"
+#endif
+#include "sysc/datatypes/fx/sc_fxval_observer.h"
+
+#ifdef SC_FXVAL_IMPLICIT_CONV
+#   define SCFX_EXPLICIT_ // nothing
+#else
+#   define SCFX_EXPLICIT_ explicit
+#endif
+#ifdef SC_FXVAL_IMPLICIT_OTHER
+#  define SCFX_EXPLICIT_OTHER_
+#else
+#  define SCFX_EXPLICIT_OTHER_ explicit
+#endif
+
+namespace sc_dt
+{
+
+// classes defined in this module
+class sc_fxval;
+class sc_fxval_fast;
+
+// forward class declarations
+class sc_fxnum;
+class sc_fxnum_fast;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxval
+//
+//  Fixed-point value type; arbitrary precision.
+// ----------------------------------------------------------------------------
+
+class sc_fxval
+{
+
+    friend class sc_fxnum;
+
+protected:
+
+    sc_fxval_observer* observer() const;
+
+public:
+
+    // internal use only;
+    explicit sc_fxval( scfx_rep* );
+
+
+    explicit       sc_fxval( sc_fxval_observer* = 0 );
+    SCFX_EXPLICIT_ sc_fxval( int, sc_fxval_observer* = 0 );
+    SCFX_EXPLICIT_ sc_fxval( unsigned int, sc_fxval_observer* = 0 );
+    SCFX_EXPLICIT_ sc_fxval( long, sc_fxval_observer* = 0 );
+    SCFX_EXPLICIT_ sc_fxval( unsigned long, sc_fxval_observer* = 0 );
+    SCFX_EXPLICIT_ sc_fxval( float, sc_fxval_observer* = 0 );
+    SCFX_EXPLICIT_ sc_fxval( double, sc_fxval_observer* = 0 );
+    SCFX_EXPLICIT_ sc_fxval( const char*, sc_fxval_observer* = 0 );
+                   sc_fxval( const sc_fxval&, sc_fxval_observer* = 0 );
+                   sc_fxval( const sc_fxval_fast&, sc_fxval_observer* = 0 );
+                   sc_fxval( const sc_fxnum&, sc_fxval_observer* = 0 );
+                   sc_fxval( const sc_fxnum_fast&, sc_fxval_observer* = 0 );
+#ifndef SC_FX_EXCLUDE_OTHER
+    SCFX_EXPLICIT_OTHER_ sc_fxval( int64, sc_fxval_observer* = 0 );
+    SCFX_EXPLICIT_OTHER_ sc_fxval( uint64, sc_fxval_observer* = 0 );
+    SCFX_EXPLICIT_OTHER_ sc_fxval( const sc_int_base&, sc_fxval_observer* = 0 );
+    SCFX_EXPLICIT_OTHER_ sc_fxval( const sc_uint_base&, sc_fxval_observer* = 0 );
+    SCFX_EXPLICIT_OTHER_ sc_fxval( const sc_signed&, sc_fxval_observer* = 0 );
+    SCFX_EXPLICIT_OTHER_ sc_fxval( const sc_unsigned&, sc_fxval_observer* = 0 );
+#endif
+
+    ~sc_fxval();
+
+
+    // internal use only;
+    const scfx_rep* get_rep() const;
+    void            set_rep( scfx_rep* );
+
+
+    // unary operators
+
+    const sc_fxval  operator - () const;
+    const sc_fxval& operator + () const;
+
+
+    // unary functions
+
+    friend void neg( sc_fxval&, const sc_fxval& );
+
+
+    // binary operators
+
+#define DECL_BIN_OP_T(op,tp)                                                  \
+    friend const sc_fxval operator op ( const sc_fxval&, tp );                \
+    friend const sc_fxval operator op ( tp, const sc_fxval& );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_BIN_OP_OTHER(op)                                                 \
+    DECL_BIN_OP_T(op,int64)                                                   \
+    DECL_BIN_OP_T(op,uint64)                                                  \
+    DECL_BIN_OP_T(op,const sc_int_base&)                                      \
+    DECL_BIN_OP_T(op,const sc_uint_base&)                                     \
+    DECL_BIN_OP_T(op,const sc_signed&)                                        \
+    DECL_BIN_OP_T(op,const sc_unsigned&)
+#else
+#define DECL_BIN_OP_OTHER(op)
+#endif
+
+#define DECL_BIN_OP(op,dummy)                                                 \
+    friend const sc_fxval operator op ( const sc_fxval&, const sc_fxval& );   \
+    DECL_BIN_OP_T(op,int)                                                     \
+    DECL_BIN_OP_T(op,unsigned int)                                            \
+    DECL_BIN_OP_T(op,long)                                                    \
+    DECL_BIN_OP_T(op,unsigned long)                                           \
+    DECL_BIN_OP_T(op,float)                                                  \
+    DECL_BIN_OP_T(op,double)                                                  \
+    DECL_BIN_OP_T(op,const char*)                                             \
+    DECL_BIN_OP_T(op,const sc_fxval_fast&)                                    \
+    DECL_BIN_OP_T(op,const sc_fxnum_fast&)                                    \
+    DECL_BIN_OP_OTHER(op)
+
+    DECL_BIN_OP(*,mult)
+    DECL_BIN_OP(+,add)
+    DECL_BIN_OP(-,sub)
+// declaration below doesn't compile with BCB5 (E2206)
+//    DECL_BIN_OP(/,div)
+// previous macro expanded
+    friend const sc_fxval operator / ( const sc_fxval&, const sc_fxval& );
+    DECL_BIN_OP_T(/,int)
+    DECL_BIN_OP_T(/,unsigned int)
+    DECL_BIN_OP_T(/,long)
+    DECL_BIN_OP_T(/,unsigned long)
+    DECL_BIN_OP_T(/,float)
+    DECL_BIN_OP_T(/,double)
+    DECL_BIN_OP_T(/,const char*)
+    DECL_BIN_OP_T(/,const sc_fxval_fast&)
+    DECL_BIN_OP_T(/,const sc_fxnum_fast&)
+//    DECL_BIN_OP_OTHER(/)
+#ifndef SC_FX_EXCLUDE_OTHER
+    DECL_BIN_OP_T(/,int64)                                                   \
+    DECL_BIN_OP_T(/,uint64)                                                  \
+    DECL_BIN_OP_T(/,const sc_int_base&)                                      \
+    DECL_BIN_OP_T(/,const sc_uint_base&)                                     \
+    DECL_BIN_OP_T(/,const sc_signed&)                                        \
+    DECL_BIN_OP_T(/,const sc_unsigned&)
+#endif
+
+
+#undef DECL_BIN_OP_T
+#undef DECL_BIN_OP_OTHER
+#undef DECL_BIN_OP
+
+    friend const sc_fxval operator << ( const sc_fxval&, int );
+    friend const sc_fxval operator >> ( const sc_fxval&, int );
+
+
+    // binary functions
+
+#define DECL_BIN_FNC_T(fnc,tp)                                                \
+    friend void fnc ( sc_fxval&, const sc_fxval&, tp );                       \
+    friend void fnc ( sc_fxval&, tp, const sc_fxval& );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_BIN_FNC_OTHER(fnc)                                               \
+    DECL_BIN_FNC_T(fnc,int64)                                                 \
+    DECL_BIN_FNC_T(fnc,uint64)                                                \
+    DECL_BIN_FNC_T(fnc,const sc_int_base&)                                    \
+    DECL_BIN_FNC_T(fnc,const sc_uint_base&)                                   \
+    DECL_BIN_FNC_T(fnc,const sc_signed&)                                      \
+    DECL_BIN_FNC_T(fnc,const sc_unsigned&)
+#else
+#define DECL_BIN_FNC_OTHER(fnc)
+#endif
+
+#define DECL_BIN_FNC(fnc)                                                     \
+    friend void fnc ( sc_fxval&, const sc_fxval&, const sc_fxval& );          \
+    DECL_BIN_FNC_T(fnc,int)                                                   \
+    DECL_BIN_FNC_T(fnc,unsigned int)                                          \
+    DECL_BIN_FNC_T(fnc,long)                                                  \
+    DECL_BIN_FNC_T(fnc,unsigned long)                                         \
+    DECL_BIN_FNC_T(fnc,float)                                                \
+    DECL_BIN_FNC_T(fnc,double)                                                \
+    DECL_BIN_FNC_T(fnc,const char*)                                           \
+    DECL_BIN_FNC_T(fnc,const sc_fxval_fast&)                                  \
+    DECL_BIN_FNC_T(fnc,const sc_fxnum_fast&)                                  \
+    DECL_BIN_FNC_OTHER(fnc)
+
+    DECL_BIN_FNC(mult)
+    DECL_BIN_FNC(div)
+    DECL_BIN_FNC(add)
+    DECL_BIN_FNC(sub)
+
+#undef DECL_BIN_FNC_T
+#undef DECL_BIN_FNC_OTHER
+#undef DECL_BIN_FNC
+
+    friend void lshift( sc_fxval&, const sc_fxval&, int );
+    friend void rshift( sc_fxval&, const sc_fxval&, int );
+
+
+    // relational (including equality) operators
+
+#define DECL_REL_OP_T(op,tp)                                                  \
+    friend bool operator op ( const sc_fxval&, tp );                          \
+    friend bool operator op ( tp, const sc_fxval& );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_REL_OP_OTHER(op)                                                 \
+    DECL_REL_OP_T(op,int64)                                                   \
+    DECL_REL_OP_T(op,uint64)                                                  \
+    DECL_REL_OP_T(op,const sc_int_base&)                                      \
+    DECL_REL_OP_T(op,const sc_uint_base&)                                     \
+    DECL_REL_OP_T(op,const sc_signed&)                                        \
+    DECL_REL_OP_T(op,const sc_unsigned&)
+#else
+#define DECL_REL_OP_OTHER(op)
+#endif
+
+#define DECL_REL_OP(op)                                                       \
+    friend bool operator op ( const sc_fxval&, const sc_fxval& );             \
+    DECL_REL_OP_T(op,int)                                                     \
+    DECL_REL_OP_T(op,unsigned int)                                            \
+    DECL_REL_OP_T(op,long)                                                    \
+    DECL_REL_OP_T(op,unsigned long)                                           \
+    DECL_REL_OP_T(op,float)                                                  \
+    DECL_REL_OP_T(op,double)                                                  \
+    DECL_REL_OP_T(op,const char*)                                             \
+    DECL_REL_OP_T(op,const sc_fxval_fast&)                                    \
+    DECL_REL_OP_T(op,const sc_fxnum_fast&)                                    \
+    DECL_REL_OP_OTHER(op)
+
+    DECL_REL_OP(<)
+    DECL_REL_OP(<=)
+    DECL_REL_OP(>)
+    DECL_REL_OP(>=)
+    DECL_REL_OP(==)
+    DECL_REL_OP(!=)
+
+#undef DECL_REL_OP_T
+#undef DECL_REL_OP_OTHER
+#undef DECL_REL_OP
+
+
+    // assignment operators
+
+#define DECL_ASN_OP_T(op,tp)                                                  \
+    sc_fxval& operator op( tp );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_ASN_OP_OTHER(op)                                                 \
+    DECL_ASN_OP_T(op,int64)                                                   \
+    DECL_ASN_OP_T(op,uint64)                                                  \
+    DECL_ASN_OP_T(op,const sc_int_base&)                                      \
+    DECL_ASN_OP_T(op,const sc_uint_base&)                                     \
+    DECL_ASN_OP_T(op,const sc_signed&)                                        \
+    DECL_ASN_OP_T(op,const sc_unsigned&)
+#else
+#define DECL_ASN_OP_OTHER(op)
+#endif
+
+#define DECL_ASN_OP(op)                                                       \
+    DECL_ASN_OP_T(op,int)                                                     \
+    DECL_ASN_OP_T(op,unsigned int)                                            \
+    DECL_ASN_OP_T(op,long)                                                    \
+    DECL_ASN_OP_T(op,unsigned long)                                           \
+    DECL_ASN_OP_T(op,float)                                                  \
+    DECL_ASN_OP_T(op,double)                                                  \
+    DECL_ASN_OP_T(op,const char*)                                             \
+    DECL_ASN_OP_T(op,const sc_fxval&)                                         \
+    DECL_ASN_OP_T(op,const sc_fxval_fast&)                                    \
+    DECL_ASN_OP_T(op,const sc_fxnum&)                                         \
+    DECL_ASN_OP_T(op,const sc_fxnum_fast&)                                    \
+    DECL_ASN_OP_OTHER(op)
+
+    DECL_ASN_OP(=)
+
+    DECL_ASN_OP(*=)
+    DECL_ASN_OP(/=)
+    DECL_ASN_OP(+=)
+    DECL_ASN_OP(-=)
+
+    DECL_ASN_OP_T(<<=,int)
+    DECL_ASN_OP_T(>>=,int)
+
+#undef DECL_ASN_OP_T
+#undef DECL_ASN_OP_OTHER
+#undef DECL_ASN_OP
+
+
+    // auto-increment and auto-decrement
+
+    const sc_fxval operator ++ ( int );
+    const sc_fxval operator -- ( int );
+
+    sc_fxval& operator ++ ();
+    sc_fxval& operator -- ();
+
+
+    // implicit conversion
+
+    operator double() const;            // necessary evil!
+
+
+    // explicit conversion to primitive types
+
+    short          to_short() const;
+    unsigned short to_ushort() const;
+    int            to_int() const;
+    unsigned int   to_uint() const;
+    long           to_long() const;
+    unsigned long  to_ulong() const;
+    int64          to_int64() const;
+    uint64         to_uint64() const;
+    float          to_float() const;
+    double         to_double() const;
+
+
+    // explicit conversion to character string
+
+    const std::string to_string() const;
+    const std::string to_string( sc_numrep ) const;
+    const std::string to_string( sc_numrep, bool ) const;
+    const std::string to_string( sc_fmt ) const;
+    const std::string to_string( sc_numrep, sc_fmt ) const;
+    const std::string to_string( sc_numrep, bool, sc_fmt ) const;
+
+    const std::string to_dec() const;
+    const std::string to_bin() const;
+    const std::string to_oct() const;
+    const std::string to_hex() const;
+
+
+    // query value
+
+    bool is_neg() const;
+    bool is_zero() const;
+    bool is_nan() const;
+    bool is_inf() const;
+    bool is_normal() const;
+    
+    bool rounding_flag() const;
+
+
+    // print or dump content
+
+    void print( ::std::ostream& = ::std::cout ) const;
+    void scan( ::std::istream& = ::std::cin );
+    void dump( ::std::ostream& = ::std::cout ) const;
+
+
+    // internal use only;
+    bool get_bit( int ) const;
+
+protected:
+
+    sc_fxval_observer* lock_observer() const;
+    void unlock_observer( sc_fxval_observer* ) const;
+
+
+    void get_type( int&, int&, sc_enc& ) const;
+
+    const sc_fxval quantization( const scfx_params&, bool& ) const;
+    const sc_fxval     overflow( const scfx_params&, bool& ) const;
+
+private:
+
+    scfx_rep*                  m_rep;
+
+    mutable sc_fxval_observer* m_observer;
+
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxval_fast
+//
+//  Fixed-point value type; limited precision.
+// ----------------------------------------------------------------------------
+
+class sc_fxval_fast
+{
+
+    friend class sc_fxnum_fast;
+
+protected:
+
+    sc_fxval_fast_observer* observer() const;
+
+public:
+
+    explicit       sc_fxval_fast( sc_fxval_fast_observer* = 0 );
+    SCFX_EXPLICIT_ sc_fxval_fast( int, sc_fxval_fast_observer* = 0 );
+    SCFX_EXPLICIT_ sc_fxval_fast( unsigned int, sc_fxval_fast_observer* = 0 );
+    SCFX_EXPLICIT_ sc_fxval_fast( long, sc_fxval_fast_observer* = 0 );
+    SCFX_EXPLICIT_ sc_fxval_fast( unsigned long, sc_fxval_fast_observer* = 0 );
+    SCFX_EXPLICIT_ sc_fxval_fast( float, sc_fxval_fast_observer* = 0 );
+    SCFX_EXPLICIT_ sc_fxval_fast( double, sc_fxval_fast_observer* = 0 );
+    SCFX_EXPLICIT_ sc_fxval_fast( const char*, sc_fxval_fast_observer* = 0 );
+    sc_fxval_fast( const sc_fxval&, sc_fxval_fast_observer* = 0 );
+    sc_fxval_fast( const sc_fxval_fast&, sc_fxval_fast_observer* = 0 );
+    sc_fxval_fast( const sc_fxnum&, sc_fxval_fast_observer* = 0 );
+    sc_fxval_fast( const sc_fxnum_fast&, sc_fxval_fast_observer* = 0 );
+#ifndef SC_FX_EXCLUDE_OTHER
+    SCFX_EXPLICIT_OTHER_ sc_fxval_fast( int64, sc_fxval_fast_observer* = 0 );
+    SCFX_EXPLICIT_OTHER_ sc_fxval_fast( uint64, sc_fxval_fast_observer* = 0 );
+    SCFX_EXPLICIT_OTHER_ sc_fxval_fast( const sc_int_base&, sc_fxval_fast_observer* = 0 );
+    SCFX_EXPLICIT_OTHER_ sc_fxval_fast( const sc_uint_base&, sc_fxval_fast_observer* = 0 );
+    SCFX_EXPLICIT_OTHER_ sc_fxval_fast( const sc_signed&, sc_fxval_fast_observer* = 0 );
+    SCFX_EXPLICIT_OTHER_ sc_fxval_fast( const sc_unsigned&, sc_fxval_fast_observer* = 0 );
+#endif
+
+    ~sc_fxval_fast();
+
+    // internal use only;
+    double get_val() const;
+    void set_val( double );
+
+
+    // unary operators
+
+    const sc_fxval_fast  operator - () const;
+    const sc_fxval_fast& operator + () const;
+
+
+    // unary functions
+
+    friend void neg( sc_fxval_fast&, const sc_fxval_fast& );
+
+
+    // binary operators
+
+#define DECL_BIN_OP_T(op,tp)                                                  \
+    friend const sc_fxval_fast operator op ( const sc_fxval_fast&, tp );      \
+    friend const sc_fxval_fast operator op ( tp, const sc_fxval_fast& );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_BIN_OP_OTHER(op)                                                 \
+    DECL_BIN_OP_T(op,int64)                                                   \
+    DECL_BIN_OP_T(op,uint64)                                                  \
+    DECL_BIN_OP_T(op,const sc_int_base&)                                      \
+    DECL_BIN_OP_T(op,const sc_uint_base&)                                     \
+    DECL_BIN_OP_T(op,const sc_signed&)                                        \
+    DECL_BIN_OP_T(op,const sc_unsigned&)
+#else
+#define DECL_BIN_OP_OTHER(op)
+#endif
+
+#define DECL_BIN_OP(op,dummy)                                                 \
+    friend const sc_fxval_fast operator op ( const sc_fxval_fast&,            \
+					     const sc_fxval_fast& );          \
+    DECL_BIN_OP_T(op,int)                                                     \
+    DECL_BIN_OP_T(op,unsigned int)                                            \
+    DECL_BIN_OP_T(op,long)                                                    \
+    DECL_BIN_OP_T(op,unsigned long)                                           \
+    DECL_BIN_OP_T(op,float)                                                  \
+    DECL_BIN_OP_T(op,double)                                                  \
+    DECL_BIN_OP_T(op,const char*)                                             \
+    DECL_BIN_OP_OTHER(op)
+
+    DECL_BIN_OP(*,mult)
+    DECL_BIN_OP(+,add)
+    DECL_BIN_OP(-,sub)
+// don't use macro
+//    DECL_BIN_OP(/,div)
+    friend const sc_fxval_fast operator / ( const sc_fxval_fast&,
+					     const sc_fxval_fast& );
+    DECL_BIN_OP_T(/,int)
+    DECL_BIN_OP_T(/,unsigned int)
+    DECL_BIN_OP_T(/,long)
+    DECL_BIN_OP_T(/,unsigned long)
+    DECL_BIN_OP_T(/,float)
+    DECL_BIN_OP_T(/,double)
+    DECL_BIN_OP_T(/,const char*)
+//    DECL_BIN_OP_OTHER(/)
+#ifndef SC_FX_EXCLUDE_OTHER
+    DECL_BIN_OP_T(/,int64)                                                   \
+    DECL_BIN_OP_T(/,uint64)                                                  \
+    DECL_BIN_OP_T(/,const sc_int_base&)                                      \
+    DECL_BIN_OP_T(/,const sc_uint_base&)                                     \
+    DECL_BIN_OP_T(/,const sc_signed&)                                        \
+    DECL_BIN_OP_T(/,const sc_unsigned&)
+#endif
+
+#undef DECL_BIN_OP_T
+#undef DECL_BIN_OP_OTHER
+#undef DECL_BIN_OP
+
+    friend const sc_fxval_fast operator << ( const sc_fxval_fast&, int );
+    friend const sc_fxval_fast operator >> ( const sc_fxval_fast&, int );
+
+
+    // binary functions
+
+#define DECL_BIN_FNC_T(fnc,tp)                                                \
+    friend void fnc ( sc_fxval_fast&, const sc_fxval_fast&, tp );             \
+    friend void fnc ( sc_fxval_fast&, tp, const sc_fxval_fast& );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_BIN_FNC_OTHER(fnc)                                               \
+    DECL_BIN_FNC_T(fnc,int64)                                                 \
+    DECL_BIN_FNC_T(fnc,uint64)                                                \
+    DECL_BIN_FNC_T(fnc,const sc_int_base&)                                    \
+    DECL_BIN_FNC_T(fnc,const sc_uint_base&)                                   \
+    DECL_BIN_FNC_T(fnc,const sc_signed&)                                      \
+    DECL_BIN_FNC_T(fnc,const sc_unsigned&)
+#else
+#define DECL_BIN_FNC_OTHER(fnc)
+#endif
+
+#define DECL_BIN_FNC(fnc)                                                     \
+    friend void fnc ( sc_fxval_fast&, const sc_fxval_fast&,                   \
+                      const sc_fxval_fast& );                                 \
+    DECL_BIN_FNC_T(fnc,int)                                                   \
+    DECL_BIN_FNC_T(fnc,unsigned int)                                          \
+    DECL_BIN_FNC_T(fnc,long)                                                  \
+    DECL_BIN_FNC_T(fnc,unsigned long)                                         \
+    DECL_BIN_FNC_T(fnc,float)                                                \
+    DECL_BIN_FNC_T(fnc,double)                                                \
+    DECL_BIN_FNC_T(fnc,const char*)                                           \
+    DECL_BIN_FNC_T(fnc,const sc_fxval&)                                       \
+    DECL_BIN_FNC_T(fnc,const sc_fxnum&)                                       \
+    DECL_BIN_FNC_OTHER(fnc)
+
+    DECL_BIN_FNC(mult)
+    DECL_BIN_FNC(div)
+    DECL_BIN_FNC(add)
+    DECL_BIN_FNC(sub)
+
+#undef DECL_BIN_FNC_T
+#undef DECL_BIN_FNC_OTHER
+#undef DECL_BIN_FNC
+
+    friend void lshift( sc_fxval_fast&, const sc_fxval_fast&, int );
+    friend void rshift( sc_fxval_fast&, const sc_fxval_fast&, int );
+
+
+    // relational (including equality) operators
+
+#define DECL_REL_OP_T(op,tp)                                                  \
+    friend bool operator op ( const sc_fxval_fast&, tp );                     \
+    friend bool operator op ( tp, const sc_fxval_fast& );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_REL_OP_OTHER(op)                                                 \
+    DECL_REL_OP_T(op,int64)                                                   \
+    DECL_REL_OP_T(op,uint64)                                                  \
+    DECL_REL_OP_T(op,const sc_int_base&)                                      \
+    DECL_REL_OP_T(op,const sc_uint_base&)                                     \
+    DECL_REL_OP_T(op,const sc_signed&)                                        \
+    DECL_REL_OP_T(op,const sc_unsigned&)
+#else
+#define DECL_REL_OP_OTHER(op)
+#endif
+
+#define DECL_REL_OP(op)                                                       \
+    friend bool operator op ( const sc_fxval_fast&, const sc_fxval_fast& );   \
+    DECL_REL_OP_T(op,int)                                                     \
+    DECL_REL_OP_T(op,unsigned int)                                            \
+    DECL_REL_OP_T(op,long)                                                    \
+    DECL_REL_OP_T(op,unsigned long)                                           \
+    DECL_REL_OP_T(op,float)                                                  \
+    DECL_REL_OP_T(op,double)                                                  \
+    DECL_REL_OP_T(op,const char*)                                             \
+    DECL_REL_OP_OTHER(op)
+
+    DECL_REL_OP(<)
+    DECL_REL_OP(<=)
+    DECL_REL_OP(>)
+    DECL_REL_OP(>=)
+    DECL_REL_OP(==)
+    DECL_REL_OP(!=)
+
+#undef DECL_REL_OP_T
+#undef DECL_REL_OP_OTHER
+#undef DECL_REL_OP
+
+
+    // assignment operators
+
+#define DECL_ASN_OP_T(op,tp)                                                  \
+    sc_fxval_fast& operator op( tp );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_ASN_OP_OTHER(op)                                                 \
+    DECL_ASN_OP_T(op,int64)                                                   \
+    DECL_ASN_OP_T(op,uint64)                                                  \
+    DECL_ASN_OP_T(op,const sc_int_base&)                                      \
+    DECL_ASN_OP_T(op,const sc_uint_base&)                                     \
+    DECL_ASN_OP_T(op,const sc_signed&)                                        \
+    DECL_ASN_OP_T(op,const sc_unsigned&)
+#else
+#define DECL_ASN_OP_OTHER(op)
+#endif
+
+#define DECL_ASN_OP(op)                                                       \
+    DECL_ASN_OP_T(op,int)                                                     \
+    DECL_ASN_OP_T(op,unsigned int)                                            \
+    DECL_ASN_OP_T(op,long)                                                    \
+    DECL_ASN_OP_T(op,unsigned long)                                           \
+    DECL_ASN_OP_T(op,float)                                                  \
+    DECL_ASN_OP_T(op,double)                                                  \
+    DECL_ASN_OP_T(op,const char*)                                             \
+    DECL_ASN_OP_T(op,const sc_fxval&)                                         \
+    DECL_ASN_OP_T(op,const sc_fxval_fast&)                                    \
+    DECL_ASN_OP_T(op,const sc_fxnum&)                                         \
+    DECL_ASN_OP_T(op,const sc_fxnum_fast&)                                    \
+    DECL_ASN_OP_OTHER(op)
+
+    DECL_ASN_OP(=)
+
+    DECL_ASN_OP(*=)
+    DECL_ASN_OP(/=)
+    DECL_ASN_OP(+=)
+    DECL_ASN_OP(-=)
+
+    DECL_ASN_OP_T(<<=,int)
+    DECL_ASN_OP_T(>>=,int)
+
+#undef DECL_ASN_OP_T
+#undef DECL_ASN_OP_OTHER
+#undef DECL_ASN_OP
+
+
+    // auto-increment and auto-decrement
+
+    const sc_fxval_fast operator ++ ( int );
+    const sc_fxval_fast operator -- ( int );
+
+    sc_fxval_fast& operator ++ ();
+    sc_fxval_fast& operator -- ();
+
+
+    // implicit conversion
+
+    operator double() const;            // necessary evil!
+
+
+    // explicit conversion to primitive types
+
+    short          to_short() const;
+    unsigned short to_ushort() const;
+    int            to_int() const;
+    unsigned int   to_uint() const;
+    long           to_long() const;
+    unsigned long  to_ulong() const;
+    int64          to_int64() const;
+    uint64         to_uint64() const;
+    float          to_float() const;
+    double         to_double() const;
+
+
+    // explicit conversion to character string
+
+    const std::string to_string() const;
+    const std::string to_string( sc_numrep ) const;
+    const std::string to_string( sc_numrep, bool ) const;
+    const std::string to_string( sc_fmt ) const;
+    const std::string to_string( sc_numrep, sc_fmt ) const;
+    const std::string to_string( sc_numrep, bool, sc_fmt ) const;
+
+    const std::string to_dec() const;
+    const std::string to_bin() const;
+    const std::string to_oct() const;
+    const std::string to_hex() const;
+
+
+    // query value
+
+    bool is_neg() const;
+    bool is_zero() const;
+    bool is_nan() const;
+    bool is_inf() const;
+    bool is_normal() const;
+
+    bool rounding_flag() const;
+
+
+    // print or dump content
+
+    void print( ::std::ostream& = ::std::cout ) const;
+    void scan( ::std::istream& = ::std::cin );
+    void dump( ::std::ostream& = ::std::cout ) const;
+
+
+    // internal use only;
+    bool get_bit( int ) const;
+
+protected:
+
+    sc_fxval_fast_observer* lock_observer() const;
+    void unlock_observer( sc_fxval_fast_observer* ) const;
+
+
+    static double from_string( const char* );
+
+private:
+
+    double                          m_val;
+
+    mutable sc_fxval_fast_observer* m_observer;
+
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxval
+//
+//  Fixed-point value type; arbitrary precision.
+// ----------------------------------------------------------------------------
+
+// protected method
+
+inline
+sc_fxval_observer*
+sc_fxval::observer() const
+{
+    return m_observer;
+}
+
+
+// internal use only;
+inline
+sc_fxval::sc_fxval( scfx_rep* a )
+: m_rep( a != 0 ? a : new scfx_rep ),
+  m_observer( 0 )
+{}
+
+
+// public constructors
+
+inline
+sc_fxval::sc_fxval( sc_fxval_observer* observer_ )
+: m_rep( new scfx_rep ),
+  m_observer( observer_ )
+{
+    SC_FXVAL_OBSERVER_DEFAULT_
+    SC_FXVAL_OBSERVER_CONSTRUCT_( *this )
+}
+
+inline
+sc_fxval::sc_fxval( const sc_fxval& a,
+		    sc_fxval_observer* observer_ )
+: m_rep( new scfx_rep( *a.m_rep ) ),
+  m_observer( observer_ )
+{
+    SC_FXVAL_OBSERVER_DEFAULT_
+    SC_FXVAL_OBSERVER_READ_( a )
+    SC_FXVAL_OBSERVER_CONSTRUCT_( *this )
+    SC_FXVAL_OBSERVER_WRITE_( *this )
+}
+
+#define DEFN_CTOR_T(tp,arg)                                                   \
+inline                                                                        \
+sc_fxval::sc_fxval( tp a,                                                     \
+                    sc_fxval_observer* observer_ )                            \
+: m_rep( new scfx_rep( arg ) ),                                               \
+  m_observer( observer_ )                                                     \
+{                                                                             \
+    SC_FXVAL_OBSERVER_DEFAULT_                                                \
+    SC_FXVAL_OBSERVER_CONSTRUCT_( *this )                                     \
+    SC_FXVAL_OBSERVER_WRITE_( *this )                                         \
+}
+
+#define DEFN_CTOR_T_A(tp) DEFN_CTOR_T(tp,a)
+#define DEFN_CTOR_T_B(tp) DEFN_CTOR_T(tp,a.to_double())
+#define DEFN_CTOR_T_C(tp) DEFN_CTOR_T(tp,a.value())
+
+DEFN_CTOR_T_A(int)
+DEFN_CTOR_T_A(unsigned int)
+DEFN_CTOR_T_A(long)
+DEFN_CTOR_T_A(unsigned long)
+DEFN_CTOR_T_A(float)
+DEFN_CTOR_T_A(double)
+DEFN_CTOR_T_A(const char*)
+DEFN_CTOR_T_B(const sc_fxval_fast&)
+#ifndef SC_FX_EXCLUDE_OTHER
+DEFN_CTOR_T_A(int64)
+DEFN_CTOR_T_A(uint64)
+DEFN_CTOR_T_C(const sc_int_base&)
+DEFN_CTOR_T_C(const sc_uint_base&)
+DEFN_CTOR_T_A(const sc_signed&)
+DEFN_CTOR_T_A(const sc_unsigned&)
+#endif
+
+#undef DEFN_CTOR_T
+#undef DEFN_CTOR_T_A
+#undef DEFN_CTOR_T_B
+#undef DEFN_CTOR_T_C
+
+
+inline
+sc_fxval::~sc_fxval()
+{
+    SC_FXVAL_OBSERVER_DESTRUCT_( *this )
+    delete m_rep;
+}
+
+
+// internal use only;
+inline
+const scfx_rep*
+sc_fxval::get_rep() const
+{
+    SC_FXVAL_OBSERVER_READ_( *this )
+    return m_rep;
+}
+
+// internal use only;
+inline
+void
+sc_fxval::set_rep( scfx_rep* rep_ )
+{
+    delete m_rep;
+    m_rep = rep_;
+    SC_FXVAL_OBSERVER_WRITE_( *this )
+}
+
+
+// unary operators
+
+inline
+const sc_fxval
+sc_fxval::operator - () const
+{
+    SC_FXVAL_OBSERVER_READ_( *this )
+    return sc_fxval( sc_dt::neg_scfx_rep( *m_rep ) );
+}
+
+inline
+const sc_fxval&
+sc_fxval::operator + () const
+{
+    // SC_FXVAL_OBSERVER_READ_( *this )
+    return *this;
+}
+
+
+// unary functions
+
+inline
+void
+neg( sc_fxval& c, const sc_fxval& a )
+{
+    SC_FXVAL_OBSERVER_READ_( a )
+    delete c.m_rep;
+    c.m_rep = sc_dt::neg_scfx_rep( *a.m_rep );
+    SC_FXVAL_OBSERVER_WRITE_( c )
+}
+
+
+// binary operators
+
+#define DEFN_BIN_OP_T(op,fnc,tp)                                              \
+inline                                                                        \
+const sc_fxval                                                                \
+operator op ( const sc_fxval& a, tp b )                                       \
+{                                                                             \
+    SC_FXVAL_OBSERVER_READ_( a )                                              \
+    sc_fxval tmp( b );                                                        \
+    return sc_fxval( sc_dt::fnc ## _scfx_rep( *a.m_rep, *tmp.m_rep ) );      \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+const sc_fxval                                                                \
+operator op ( tp a, const sc_fxval& b )                                       \
+{                                                                             \
+    SC_FXVAL_OBSERVER_READ_( b )                                              \
+    sc_fxval tmp( a );                                                        \
+    return sc_fxval( sc_dt::fnc ## _scfx_rep( *tmp.m_rep, *b.m_rep ) );      \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_BIN_OP_OTHER(op,fnc)                                             \
+DEFN_BIN_OP_T(op,fnc,int64)                                                   \
+DEFN_BIN_OP_T(op,fnc,uint64)                                                  \
+DEFN_BIN_OP_T(op,fnc,const sc_int_base&)                                      \
+DEFN_BIN_OP_T(op,fnc,const sc_uint_base&)                                     \
+DEFN_BIN_OP_T(op,fnc,const sc_signed&)                                        \
+DEFN_BIN_OP_T(op,fnc,const sc_unsigned&)
+#else
+#define DEFN_BIN_OP_OTHER(op,fnc)
+#endif
+
+#define DEFN_BIN_OP(op,fnc)                                                   \
+inline                                                                        \
+const sc_fxval                                                                \
+operator op ( const sc_fxval& a, const sc_fxval& b )                          \
+{                                                                             \
+    SC_FXVAL_OBSERVER_READ_( a )                                              \
+    SC_FXVAL_OBSERVER_READ_( b )                                              \
+    return sc_fxval( sc_dt::fnc ## _scfx_rep( *a.m_rep, *b.m_rep ) );        \
+}                                                                             \
+                                                                              \
+DEFN_BIN_OP_T(op,fnc,int)                                                     \
+DEFN_BIN_OP_T(op,fnc,unsigned int)                                            \
+DEFN_BIN_OP_T(op,fnc,long)                                                    \
+DEFN_BIN_OP_T(op,fnc,unsigned long)                                           \
+DEFN_BIN_OP_T(op,fnc,float)                                                  \
+DEFN_BIN_OP_T(op,fnc,double)                                                  \
+DEFN_BIN_OP_T(op,fnc,const char*)                                             \
+DEFN_BIN_OP_T(op,fnc,const sc_fxval_fast&)                                    \
+DEFN_BIN_OP_OTHER(op,fnc)
+
+DEFN_BIN_OP(*,mult)
+DEFN_BIN_OP(+,add)
+DEFN_BIN_OP(-,sub)
+// don't use macro
+//DEFN_BIN_OP(/,div)
+inline
+const sc_fxval
+operator / ( const sc_fxval& a, const sc_fxval& b )
+{
+    SC_FXVAL_OBSERVER_READ_( a )
+    SC_FXVAL_OBSERVER_READ_( b )
+    return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *b.m_rep ) );
+}
+
+DEFN_BIN_OP_T(/,div,int)
+DEFN_BIN_OP_T(/,div,unsigned int)
+DEFN_BIN_OP_T(/,div,long)
+DEFN_BIN_OP_T(/,div,unsigned long)
+DEFN_BIN_OP_T(/,div,float)
+DEFN_BIN_OP_T(/,div,double)
+DEFN_BIN_OP_T(/,div,const char*)
+DEFN_BIN_OP_T(/,div,const sc_fxval_fast&)
+//DEFN_BIN_OP_OTHER(/,div)
+#ifndef SC_FX_EXCLUDE_OTHER
+DEFN_BIN_OP_T(/,div,int64)                                                   \
+DEFN_BIN_OP_T(/,div,uint64)                                                  \
+DEFN_BIN_OP_T(/,div,const sc_int_base&)                                      \
+DEFN_BIN_OP_T(/,div,const sc_uint_base&)                                     \
+DEFN_BIN_OP_T(/,div,const sc_signed&)                                        \
+DEFN_BIN_OP_T(/,div,const sc_unsigned&)
+#endif
+
+#undef DEFN_BIN_OP_T
+#undef DEFN_BIN_OP_OTHER
+#undef DEFN_BIN_OP
+
+
+inline
+const sc_fxval
+operator << ( const sc_fxval& a, int b )
+{
+    SC_FXVAL_OBSERVER_READ_( a )
+    return sc_fxval( sc_dt::lsh_scfx_rep( *a.m_rep, b ) );
+}
+
+inline
+const sc_fxval
+operator >> ( const sc_fxval& a, int b )
+{
+    SC_FXVAL_OBSERVER_READ_( a )
+    return sc_fxval( sc_dt::rsh_scfx_rep( *a.m_rep, b ) );
+}
+
+
+// binary functions
+
+#define DEFN_BIN_FNC_T(fnc,tp)                                                \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxval& c, const sc_fxval& a, tp b )                                  \
+{                                                                             \
+    SC_FXVAL_OBSERVER_READ_( a )                                              \
+    sc_fxval tmp( b );                                                        \
+    delete c.m_rep;                                                           \
+    c.m_rep = sc_dt::fnc ## _scfx_rep( *a.m_rep, *tmp.m_rep );               \
+    SC_FXVAL_OBSERVER_WRITE_( c )                                             \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxval& c, tp a, const sc_fxval& b )                                  \
+{                                                                             \
+    SC_FXVAL_OBSERVER_READ_( b )                                              \
+    sc_fxval tmp( a );                                                        \
+    delete c.m_rep;                                                           \
+    c.m_rep = sc_dt::fnc ## _scfx_rep( *tmp.m_rep, *b.m_rep );               \
+    SC_FXVAL_OBSERVER_WRITE_( c )                                             \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_BIN_FNC_OTHER(fnc)                                               \
+DEFN_BIN_FNC_T(fnc,int64)                                                     \
+DEFN_BIN_FNC_T(fnc,uint64)                                                    \
+DEFN_BIN_FNC_T(fnc,const sc_int_base&)                                        \
+DEFN_BIN_FNC_T(fnc,const sc_uint_base&)                                       \
+DEFN_BIN_FNC_T(fnc,const sc_signed&)                                          \
+DEFN_BIN_FNC_T(fnc,const sc_unsigned&)
+#else
+#define DEFN_BIN_FNC_OTHER(fnc)
+#endif
+
+#define DEFN_BIN_FNC(fnc)                                                     \
+inline                                                                        \
+void                                                                          \
+fnc( sc_fxval& c, const sc_fxval& a, const sc_fxval& b )                      \
+{                                                                             \
+    SC_FXVAL_OBSERVER_READ_( a )                                              \
+    SC_FXVAL_OBSERVER_READ_( b )                                              \
+    delete c.m_rep;                                                           \
+    c.m_rep = sc_dt::fnc ## _scfx_rep( *a.m_rep, *b.m_rep );                 \
+    SC_FXVAL_OBSERVER_WRITE_( c )                                             \
+}                                                                             \
+                                                                              \
+DEFN_BIN_FNC_T(fnc,int)                                                       \
+DEFN_BIN_FNC_T(fnc,unsigned int)                                              \
+DEFN_BIN_FNC_T(fnc,long)                                                      \
+DEFN_BIN_FNC_T(fnc,unsigned long)                                             \
+DEFN_BIN_FNC_T(fnc,float)                                                    \
+DEFN_BIN_FNC_T(fnc,double)                                                    \
+DEFN_BIN_FNC_T(fnc,const char*)                                               \
+DEFN_BIN_FNC_T(fnc,const sc_fxval_fast&)                                      \
+DEFN_BIN_FNC_OTHER(fnc)
+
+DEFN_BIN_FNC(mult)
+DEFN_BIN_FNC(div)
+DEFN_BIN_FNC(add)
+DEFN_BIN_FNC(sub)
+
+#undef DEFN_BIN_FNC_T
+#undef DEFN_BIN_FNC_OTHER
+#undef DEFN_BIN_FNC
+
+
+inline
+void
+lshift( sc_fxval& c, const sc_fxval& a, int b )
+{
+    SC_FXVAL_OBSERVER_READ_( a )
+    delete c.m_rep;
+    c.m_rep = sc_dt::lsh_scfx_rep( *a.m_rep, b );
+    SC_FXVAL_OBSERVER_WRITE_( c )
+}
+
+inline
+void
+rshift( sc_fxval& c, const sc_fxval& a, int b )
+{
+    SC_FXVAL_OBSERVER_READ_( a )
+    delete c.m_rep;
+    c.m_rep = sc_dt::rsh_scfx_rep( *a.m_rep, b );
+    SC_FXVAL_OBSERVER_WRITE_( c )
+}
+
+
+// relational (including equality) operators
+
+#define DEFN_REL_OP_T(op,ret,tp)                                              \
+inline                                                                        \
+bool                                                                          \
+operator op ( const sc_fxval& a, tp b )                                       \
+{                                                                             \
+    SC_FXVAL_OBSERVER_READ_( a )                                              \
+    sc_fxval tmp( b );                                                        \
+    int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep );                \
+    return ( ret );                                                           \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+bool                                                                          \
+operator op ( tp a, const sc_fxval& b )                                       \
+{                                                                             \
+    SC_FXVAL_OBSERVER_READ_( b )                                              \
+    sc_fxval tmp( a );                                                        \
+    int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep );                \
+    return ( ret );                                                           \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_REL_OP_OTHER(op,ret)                                             \
+DEFN_REL_OP_T(op,ret,int64)                                                   \
+DEFN_REL_OP_T(op,ret,uint64)                                                  \
+DEFN_REL_OP_T(op,ret,const sc_int_base&)                                      \
+DEFN_REL_OP_T(op,ret,const sc_uint_base&)                                     \
+DEFN_REL_OP_T(op,ret,const sc_signed&)                                        \
+DEFN_REL_OP_T(op,ret,const sc_unsigned&)
+#else
+#define DEFN_REL_OP_OTHER(op,ret)
+#endif
+
+#define DEFN_REL_OP(op,ret)                                                   \
+inline                                                                        \
+bool                                                                          \
+operator op ( const sc_fxval& a, const sc_fxval& b)                           \
+{                                                                             \
+    SC_FXVAL_OBSERVER_READ_( a )                                              \
+    SC_FXVAL_OBSERVER_READ_( b )                                              \
+    int result = sc_dt::cmp_scfx_rep( *a.m_rep, *b.m_rep );                  \
+    return ( ret );                                                           \
+}                                                                             \
+                                                                              \
+DEFN_REL_OP_T(op,ret,int)                                                     \
+DEFN_REL_OP_T(op,ret,unsigned int)                                            \
+DEFN_REL_OP_T(op,ret,long)                                                    \
+DEFN_REL_OP_T(op,ret,unsigned long)                                           \
+DEFN_REL_OP_T(op,ret,float)                                                  \
+DEFN_REL_OP_T(op,ret,double)                                                  \
+DEFN_REL_OP_T(op,ret,const char*)                                             \
+DEFN_REL_OP_T(op,ret,const sc_fxval_fast&)                                    \
+DEFN_REL_OP_OTHER(op,ret)
+
+DEFN_REL_OP(<,result < 0)
+DEFN_REL_OP(<=,result <= 0)
+DEFN_REL_OP(>,result > 0 && result != 2)
+DEFN_REL_OP(>=,result >= 0 && result != 2)
+DEFN_REL_OP(==,result == 0)
+DEFN_REL_OP(!=,result != 0)
+
+#undef DEFN_REL_OP_T
+#undef DEFN_REL_OP_OTHER
+#undef DEFN_REL_OP
+
+
+// assignment operators
+
+inline
+sc_fxval&
+sc_fxval::operator = ( const sc_fxval& a )
+{
+    if( &a != this )
+    {
+	SC_FXVAL_OBSERVER_READ_( a )
+	*m_rep = *a.m_rep;
+	SC_FXVAL_OBSERVER_WRITE_( *this )
+    }
+    return *this;
+}
+
+#define DEFN_ASN_OP_T(tp)                                                     \
+inline                                                                        \
+sc_fxval&                                                                     \
+sc_fxval::operator = ( tp b )                                                 \
+{                                                                             \
+    sc_fxval tmp( b );                                                        \
+    *m_rep = *tmp.m_rep;                                                      \
+    SC_FXVAL_OBSERVER_WRITE_( *this )                                         \
+    return *this;                                                             \
+}
+
+DEFN_ASN_OP_T(int)
+DEFN_ASN_OP_T(unsigned int)
+DEFN_ASN_OP_T(long)
+DEFN_ASN_OP_T(unsigned long)
+DEFN_ASN_OP_T(float)
+DEFN_ASN_OP_T(double)
+DEFN_ASN_OP_T(const char*)
+DEFN_ASN_OP_T(const sc_fxval_fast&)
+#ifndef SC_FX_EXCLUDE_OTHER
+DEFN_ASN_OP_T(int64)
+DEFN_ASN_OP_T(uint64)
+DEFN_ASN_OP_T(const sc_int_base&)
+DEFN_ASN_OP_T(const sc_uint_base&)
+DEFN_ASN_OP_T(const sc_signed&)
+DEFN_ASN_OP_T(const sc_unsigned&)
+#endif
+
+#undef DEFN_ASN_OP_T
+
+
+#define DEFN_ASN_OP_T(op,fnc,tp)                                              \
+inline                                                                        \
+sc_fxval&                                                                     \
+sc_fxval::operator op ( tp b )                                                \
+{                                                                             \
+    SC_FXVAL_OBSERVER_READ_( *this )                                          \
+    sc_fxval tmp( b );                                                        \
+    scfx_rep* new_rep = sc_dt::fnc ## _scfx_rep( *m_rep, *tmp.m_rep );       \
+    delete m_rep;                                                             \
+    m_rep = new_rep;                                                          \
+    SC_FXVAL_OBSERVER_WRITE_( *this )                                         \
+    return *this;                                                             \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_ASN_OP_OTHER(op,fnc)                                             \
+DEFN_ASN_OP_T(op,fnc,int64)                                                   \
+DEFN_ASN_OP_T(op,fnc,uint64)                                                  \
+DEFN_ASN_OP_T(op,fnc,const sc_int_base&)                                      \
+DEFN_ASN_OP_T(op,fnc,const sc_uint_base&)                                     \
+DEFN_ASN_OP_T(op,fnc,const sc_signed&)                                        \
+DEFN_ASN_OP_T(op,fnc,const sc_unsigned&)
+#else
+#define DEFN_ASN_OP_OTHER(op,fnc)
+#endif
+
+#define DEFN_ASN_OP(op,fnc)                                                   \
+inline                                                                        \
+sc_fxval&                                                                     \
+sc_fxval::operator op ( const sc_fxval& b )                                   \
+{                                                                             \
+    SC_FXVAL_OBSERVER_READ_( *this )                                          \
+    SC_FXVAL_OBSERVER_READ_( b )                                              \
+    scfx_rep* new_rep = sc_dt::fnc ## _scfx_rep( *m_rep, *b.m_rep );         \
+    delete m_rep;                                                             \
+    m_rep = new_rep;                                                          \
+    SC_FXVAL_OBSERVER_WRITE_( *this )                                         \
+    return *this;                                                             \
+}                                                                             \
+                                                                              \
+DEFN_ASN_OP_T(op,fnc,int)                                                     \
+DEFN_ASN_OP_T(op,fnc,unsigned int)                                            \
+DEFN_ASN_OP_T(op,fnc,long)                                                    \
+DEFN_ASN_OP_T(op,fnc,unsigned long)                                           \
+DEFN_ASN_OP_T(op,fnc,float)                                                  \
+DEFN_ASN_OP_T(op,fnc,double)                                                  \
+DEFN_ASN_OP_T(op,fnc,const char*)                                             \
+DEFN_ASN_OP_T(op,fnc,const sc_fxval_fast&)                                    \
+DEFN_ASN_OP_OTHER(op,fnc)
+
+DEFN_ASN_OP(*=,mult)
+DEFN_ASN_OP(/=,div)
+DEFN_ASN_OP(+=,add)
+DEFN_ASN_OP(-=,sub)
+
+#undef DEFN_ASN_OP_T
+#undef DEFN_ASN_OP_OTHER
+#undef DEFN_ASN_OP
+
+
+inline
+sc_fxval&
+sc_fxval::operator <<= ( int b )
+{
+    SC_FXVAL_OBSERVER_READ_( *this )
+    m_rep->lshift( b );
+    SC_FXVAL_OBSERVER_WRITE_( *this )
+    return *this;
+}
+
+inline
+sc_fxval&
+sc_fxval::operator >>= ( int b )
+{
+    SC_FXVAL_OBSERVER_READ_( *this )
+    m_rep->rshift( b );
+    SC_FXVAL_OBSERVER_WRITE_( *this )
+    return *this;
+}
+
+
+// auto-increment and auto-decrement
+
+inline
+const sc_fxval
+sc_fxval::operator ++ ( int )
+{
+    sc_fxval c = *this;
+    (*this) += 1;
+    return c;
+}
+
+inline
+const sc_fxval
+sc_fxval::operator -- ( int )
+{
+    sc_fxval c = *this;
+    (*this) -= 1;
+    return c;
+}
+
+inline
+sc_fxval&
+sc_fxval::operator ++ ()
+{
+    (*this) += 1;
+    return *this;
+}
+
+inline
+sc_fxval&
+sc_fxval::operator -- ()
+{
+    (*this) -= 1;
+    return *this;
+}
+
+
+// implicit conversion
+
+inline
+sc_fxval::operator double() const
+{
+    SC_FXVAL_OBSERVER_READ_( *this )
+    return m_rep->to_double();
+}
+
+
+// explicit conversion to primitive types
+
+inline
+short
+sc_fxval::to_short() const
+{
+    SC_FXVAL_OBSERVER_READ_( *this )
+    return static_cast<short>( m_rep->to_double() );
+}
+
+inline
+unsigned short
+sc_fxval::to_ushort() const
+{
+    SC_FXVAL_OBSERVER_READ_( *this )
+    return static_cast<unsigned short>( m_rep->to_double() );
+}
+
+inline
+int
+sc_fxval::to_int() const
+{
+    SC_FXVAL_OBSERVER_READ_( *this )
+    return static_cast<int>( m_rep->to_double() );
+}
+
+inline
+int64
+sc_fxval::to_int64() const
+{
+    SC_FXVAL_OBSERVER_READ_( *this )
+    return static_cast<int64>( m_rep->to_double() );
+}
+
+inline
+uint64
+sc_fxval::to_uint64() const
+{
+    SC_FXVAL_OBSERVER_READ_( *this )
+    return static_cast<uint64>( m_rep->to_double() );
+}
+
+inline
+long
+sc_fxval::to_long() const
+{
+    SC_FXVAL_OBSERVER_READ_( *this )
+    return static_cast<long>( m_rep->to_double() );
+}
+
+inline
+unsigned int
+sc_fxval::to_uint() const
+{
+    SC_FXVAL_OBSERVER_READ_( *this )
+    return static_cast<unsigned int>( m_rep->to_double() );
+}
+
+inline
+unsigned long
+sc_fxval::to_ulong() const
+{
+    SC_FXVAL_OBSERVER_READ_( *this )
+    return static_cast<unsigned long>( m_rep->to_double() );
+}
+
+inline
+float
+sc_fxval::to_float() const
+{
+    SC_FXVAL_OBSERVER_READ_( *this )
+    return static_cast<float>( m_rep->to_double() );
+}
+
+inline
+double
+sc_fxval::to_double() const
+{
+    SC_FXVAL_OBSERVER_READ_( *this )
+    return m_rep->to_double();
+}
+
+
+// query value
+
+inline
+bool
+sc_fxval::is_neg() const
+{
+    SC_FXVAL_OBSERVER_READ_( *this )
+    return m_rep->is_neg();
+}
+
+inline
+bool
+sc_fxval::is_zero() const
+{
+    SC_FXVAL_OBSERVER_READ_( *this )
+    return m_rep->is_zero();
+}
+
+inline
+bool
+sc_fxval::is_nan() const
+{
+    SC_FXVAL_OBSERVER_READ_( *this )
+    return m_rep->is_nan();
+}
+
+inline
+bool
+sc_fxval::is_inf() const
+{
+    SC_FXVAL_OBSERVER_READ_( *this )
+    return m_rep->is_inf();
+}
+
+inline
+bool
+sc_fxval::is_normal() const
+{
+    SC_FXVAL_OBSERVER_READ_( *this )
+    return m_rep->is_normal();
+}
+
+
+inline
+bool
+sc_fxval::rounding_flag() const
+{
+    return m_rep->rounding_flag();
+}
+
+
+// internal use only;
+inline
+bool
+sc_fxval::get_bit( int i ) const
+{
+    return m_rep->get_bit( i );
+}
+
+
+// protected methods and friend functions
+
+inline
+void
+sc_fxval::get_type( int& wl, int& iwl, sc_enc& enc ) const
+{
+    m_rep->get_type( wl, iwl, enc );
+}
+
+
+inline
+const sc_fxval
+sc_fxval::quantization( const scfx_params& params, bool& q_flag ) const
+{
+    return sc_fxval( sc_dt::quantization_scfx_rep( *m_rep, params, q_flag ) );
+}
+
+inline
+const sc_fxval
+sc_fxval::overflow( const scfx_params& params, bool& o_flag ) const
+{
+    return sc_fxval( sc_dt::overflow_scfx_rep( *m_rep, params, o_flag ) );
+}
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_fxval& a )
+{
+    a.print( os );
+    return os;
+}
+
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_fxval& a )
+{
+    a.scan( is );
+    return is;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxval_fast
+//
+//  Fixed-point value type; limited precision.
+// ----------------------------------------------------------------------------
+
+// protected method
+
+inline
+sc_fxval_fast_observer*
+sc_fxval_fast::observer() const
+{
+    return m_observer;
+}
+
+
+// public constructors
+
+inline
+sc_fxval_fast::sc_fxval_fast( sc_fxval_fast_observer* observer_ )
+: m_val( 0.0 ),
+  m_observer( observer_ )
+{
+    SC_FXVAL_FAST_OBSERVER_DEFAULT_
+    SC_FXVAL_FAST_OBSERVER_CONSTRUCT_( *this )
+}
+
+inline
+sc_fxval_fast::sc_fxval_fast( const sc_fxval_fast& a,
+			      sc_fxval_fast_observer* observer_ )
+: m_val( a.m_val ),
+  m_observer( observer_ )
+{
+    SC_FXVAL_FAST_OBSERVER_DEFAULT_
+    SC_FXVAL_FAST_OBSERVER_READ_( a )
+    SC_FXVAL_FAST_OBSERVER_CONSTRUCT_( *this )
+    SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
+}
+
+#define DEFN_CTOR_T(tp,arg)                                                   \
+inline                                                                        \
+sc_fxval_fast::sc_fxval_fast( tp a,                                           \
+                              sc_fxval_fast_observer* observer_ )             \
+: m_val( arg ),                                                               \
+  m_observer( observer_ )                                                     \
+{                                                                             \
+    SC_FXVAL_FAST_OBSERVER_DEFAULT_                                           \
+    SC_FXVAL_FAST_OBSERVER_CONSTRUCT_( *this )                                \
+    SC_FXVAL_FAST_OBSERVER_WRITE_( *this )                                    \
+}
+
+#define DEFN_CTOR_T_A(tp) DEFN_CTOR_T(tp,static_cast<double>( a ))
+#define DEFN_CTOR_T_B(tp) DEFN_CTOR_T(tp,from_string( a ))
+#define DEFN_CTOR_T_C(tp) DEFN_CTOR_T(tp,a.to_double())
+
+DEFN_CTOR_T_A(int)
+DEFN_CTOR_T_A(unsigned int)
+DEFN_CTOR_T_A(long)
+DEFN_CTOR_T_A(unsigned long)
+DEFN_CTOR_T_A(float)
+DEFN_CTOR_T_A(double)
+DEFN_CTOR_T_B(const char*)
+DEFN_CTOR_T_C(const sc_fxval&)
+#ifndef SC_FX_EXCLUDE_OTHER
+DEFN_CTOR_T_A(int64)
+DEFN_CTOR_T_A(uint64)
+DEFN_CTOR_T_C(const sc_int_base&)
+DEFN_CTOR_T_C(const sc_uint_base&)
+DEFN_CTOR_T_C(const sc_signed&)
+DEFN_CTOR_T_C(const sc_unsigned&)
+#endif
+
+#undef DEFN_CTOR_T
+#undef DEFN_CTOR_T_A
+#undef DEFN_CTOR_T_B
+#undef DEFN_CTOR_T_C
+#undef DEFN_CTOR_T_D
+#undef DEFN_CTOR_T_E
+
+
+inline
+sc_fxval_fast::~sc_fxval_fast()
+{
+    SC_FXVAL_FAST_OBSERVER_DESTRUCT_( *this )
+}
+
+
+// internal use only;
+inline
+double
+sc_fxval_fast::get_val() const
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )
+    return m_val;
+}
+
+// internal use only;
+inline
+void
+sc_fxval_fast::set_val( double val_ )
+{
+    m_val = val_;
+    SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
+}
+
+
+// unary operators
+
+inline
+const sc_fxval_fast
+sc_fxval_fast::operator - () const
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )
+    return sc_fxval_fast( - m_val );
+}
+
+inline
+const sc_fxval_fast&
+sc_fxval_fast::operator + () const
+{
+    // SC_FXVAL_FAST_OBSERVER_READ_( *this )
+    return *this;
+}
+
+
+// unary functions
+
+inline
+void
+neg( sc_fxval_fast& c, const sc_fxval_fast& a )
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( a )
+    c.m_val = - a.m_val;
+    SC_FXVAL_FAST_OBSERVER_WRITE_( c )
+}
+
+
+// binary operators
+
+#define DEFN_BIN_OP_T(op,tp)                                                  \
+inline                                                                        \
+const sc_fxval_fast                                                           \
+operator op ( const sc_fxval_fast& a, tp b )                                  \
+{                                                                             \
+    SC_FXVAL_FAST_OBSERVER_READ_( a )                                         \
+    sc_fxval_fast tmp( b );                                                   \
+    return sc_fxval_fast( a.m_val op tmp.m_val );                             \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+const sc_fxval_fast                                                           \
+operator op ( tp a, const sc_fxval_fast& b )                                  \
+{                                                                             \
+    SC_FXVAL_FAST_OBSERVER_READ_( b )                                         \
+    sc_fxval_fast tmp( a );                                                   \
+    return sc_fxval_fast( tmp.m_val op b.m_val );                             \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_BIN_OP_OTHER(op)                                                 \
+DEFN_BIN_OP_T(op,int64)                                                       \
+DEFN_BIN_OP_T(op,uint64)                                                      \
+DEFN_BIN_OP_T(op,const sc_int_base&)                                          \
+DEFN_BIN_OP_T(op,const sc_uint_base&)                                         \
+DEFN_BIN_OP_T(op,const sc_signed&)                                            \
+DEFN_BIN_OP_T(op,const sc_unsigned&)
+#else
+#define DEFN_BIN_OP_OTHER(op)
+#endif
+
+#define DEFN_BIN_OP(op,dummy)                                                 \
+inline                                                                        \
+const sc_fxval_fast                                                           \
+operator op ( const sc_fxval_fast& a, const sc_fxval_fast& b )                \
+{                                                                             \
+    SC_FXVAL_FAST_OBSERVER_READ_( a )                                         \
+    SC_FXVAL_FAST_OBSERVER_READ_( b )                                         \
+    return sc_fxval_fast( a.m_val op b.m_val );                               \
+}                                                                             \
+                                                                              \
+DEFN_BIN_OP_T(op,int)                                                         \
+DEFN_BIN_OP_T(op,unsigned int)                                                \
+DEFN_BIN_OP_T(op,long)                                                        \
+DEFN_BIN_OP_T(op,unsigned long)                                               \
+DEFN_BIN_OP_T(op,float)                                                      \
+DEFN_BIN_OP_T(op,double)                                                      \
+DEFN_BIN_OP_T(op,const char*)                                                 \
+DEFN_BIN_OP_OTHER(op)
+
+DEFN_BIN_OP(*,mult)
+DEFN_BIN_OP(+,add)
+DEFN_BIN_OP(-,sub)
+//DEFN_BIN_OP(/,div)
+inline
+const sc_fxval_fast
+operator / ( const sc_fxval_fast& a, const sc_fxval_fast& b )
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( a )
+    SC_FXVAL_FAST_OBSERVER_READ_( b )
+    return sc_fxval_fast( a.m_val / b.m_val );
+}
+
+DEFN_BIN_OP_T(/,int)
+DEFN_BIN_OP_T(/,unsigned int)
+DEFN_BIN_OP_T(/,long)
+DEFN_BIN_OP_T(/,unsigned long)
+DEFN_BIN_OP_T(/,float)
+DEFN_BIN_OP_T(/,double)
+DEFN_BIN_OP_T(/,const char*)
+//DEFN_BIN_OP_OTHER(/)
+#ifndef SC_FX_EXCLUDE_OTHER
+DEFN_BIN_OP_T(/,int64)
+DEFN_BIN_OP_T(/,uint64)
+DEFN_BIN_OP_T(/,const sc_int_base&)
+DEFN_BIN_OP_T(/,const sc_uint_base&)
+DEFN_BIN_OP_T(/,const sc_signed&)
+DEFN_BIN_OP_T(/,const sc_unsigned&)
+#endif
+
+
+#undef DEFN_BIN_OP_T
+#undef DEFN_BIN_OP_OTHER
+#undef DEFN_BIN_OP
+
+
+inline
+const sc_fxval_fast
+operator << ( const sc_fxval_fast& a, int b )
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( a )
+    return sc_fxval_fast( a.m_val * scfx_pow2( b ) );
+}
+
+inline
+const sc_fxval_fast
+operator >> ( const sc_fxval_fast& a, int b )
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( a )
+    return sc_fxval_fast( a.m_val * scfx_pow2( -b ) );
+}
+
+
+// binary functions
+
+#define DEFN_BIN_FNC_T(fnc,op,tp)                                             \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxval_fast& c, const sc_fxval_fast& a, tp b )                        \
+{                                                                             \
+    SC_FXVAL_FAST_OBSERVER_READ_( a )                                         \
+    sc_fxval_fast tmp( b );                                                   \
+    c.m_val = a.m_val op tmp.m_val;                                           \
+    SC_FXVAL_FAST_OBSERVER_WRITE_( c )                                        \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxval_fast& c, tp a, const sc_fxval_fast& b )                        \
+{                                                                             \
+    SC_FXVAL_FAST_OBSERVER_READ_( b )                                         \
+    sc_fxval_fast tmp( a );                                                   \
+    c.m_val = tmp.m_val op b.m_val;                                           \
+    SC_FXVAL_FAST_OBSERVER_WRITE_( c )                                        \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_BIN_FNC_OTHER(fnc,op)                                            \
+DEFN_BIN_FNC_T(fnc,op,int64)                                                  \
+DEFN_BIN_FNC_T(fnc,op,uint64)                                                 \
+DEFN_BIN_FNC_T(fnc,op,const sc_int_base&)                                     \
+DEFN_BIN_FNC_T(fnc,op,const sc_uint_base&)                                    \
+DEFN_BIN_FNC_T(fnc,op,const sc_signed&)                                       \
+DEFN_BIN_FNC_T(fnc,op,const sc_unsigned&)
+#else
+#define DEFN_BIN_FNC_OTHER(fnc,op)
+#endif
+
+#define DEFN_BIN_FNC(fnc,op)                                                  \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_fxval_fast& b )      \
+{                                                                             \
+    SC_FXVAL_FAST_OBSERVER_READ_( a )                                         \
+    SC_FXVAL_FAST_OBSERVER_READ_( b )                                         \
+    c.m_val = a.m_val op b.m_val;                                             \
+    SC_FXVAL_FAST_OBSERVER_WRITE_( c )                                        \
+}                                                                             \
+                                                                              \
+DEFN_BIN_FNC_T(fnc,op,int)                                                    \
+DEFN_BIN_FNC_T(fnc,op,unsigned int)                                           \
+DEFN_BIN_FNC_T(fnc,op,long)                                                   \
+DEFN_BIN_FNC_T(fnc,op,unsigned long)                                          \
+DEFN_BIN_FNC_T(fnc,op,float)                                                 \
+DEFN_BIN_FNC_T(fnc,op,double)                                                 \
+DEFN_BIN_FNC_T(fnc,op,const char*)                                            \
+DEFN_BIN_FNC_OTHER(fnc,op)
+
+DEFN_BIN_FNC(mult,*)
+DEFN_BIN_FNC(div,/)
+DEFN_BIN_FNC(add,+)
+DEFN_BIN_FNC(sub,-)
+
+#undef DEFN_BIN_FNC_T
+#undef DEFN_BIN_FNC_OTHER
+#undef DEFN_BIN_FNC
+
+
+inline
+void
+lshift( sc_fxval_fast& c, const sc_fxval_fast& a, int b )
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( a )
+    c.m_val = a.m_val * scfx_pow2( b );
+    SC_FXVAL_FAST_OBSERVER_WRITE_( c )
+}
+
+inline
+void
+rshift( sc_fxval_fast& c, const sc_fxval_fast& a, int b )
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( a )
+    c.m_val = a.m_val * scfx_pow2( -b );
+    SC_FXVAL_FAST_OBSERVER_WRITE_( c )
+}
+
+
+// relational (including equality) operators
+
+#define DEFN_REL_OP_T(op,tp)                                                  \
+inline                                                                        \
+bool                                                                          \
+operator op ( const sc_fxval_fast& a, tp b )                                  \
+{                                                                             \
+    SC_FXVAL_FAST_OBSERVER_READ_( a )                                         \
+    sc_fxval_fast tmp( b );                                                   \
+    return ( a.m_val op tmp.m_val );                                          \
+}                                                                             \
+                                                                              \
+inline                                                                        \
+bool                                                                          \
+operator op ( tp a, const sc_fxval_fast& b )                                  \
+{                                                                             \
+    SC_FXVAL_FAST_OBSERVER_READ_( b )                                         \
+    sc_fxval_fast tmp( a );                                                   \
+    return ( tmp.m_val op b.m_val );                                          \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_REL_OP_OTHER(op)                                                 \
+DEFN_REL_OP_T(op,int64)                                                       \
+DEFN_REL_OP_T(op,uint64)                                                      \
+DEFN_REL_OP_T(op,const sc_int_base&)                                          \
+DEFN_REL_OP_T(op,const sc_uint_base&)                                         \
+DEFN_REL_OP_T(op,const sc_signed&)                                            \
+DEFN_REL_OP_T(op,const sc_unsigned&)
+#else
+#define DEFN_REL_OP_OTHER(op)
+#endif
+
+#define DEFN_REL_OP(op)                                                       \
+inline                                                                        \
+bool                                                                          \
+operator op ( const sc_fxval_fast& a, const sc_fxval_fast& b )                \
+{                                                                             \
+    SC_FXVAL_FAST_OBSERVER_READ_( a )                                         \
+    SC_FXVAL_FAST_OBSERVER_READ_( b )                                         \
+    return ( a.m_val op b.m_val );                                            \
+}                                                                             \
+                                                                              \
+DEFN_REL_OP_T(op,int)                                                         \
+DEFN_REL_OP_T(op,unsigned int)                                                \
+DEFN_REL_OP_T(op,long)                                                        \
+DEFN_REL_OP_T(op,unsigned long)                                               \
+DEFN_REL_OP_T(op,float)                                                      \
+DEFN_REL_OP_T(op,double)                                                      \
+DEFN_REL_OP_T(op,const char*)                                                 \
+DEFN_REL_OP_OTHER(op)
+
+DEFN_REL_OP(<)
+DEFN_REL_OP(<=)
+DEFN_REL_OP(>)
+DEFN_REL_OP(>=)
+DEFN_REL_OP(==)
+DEFN_REL_OP(!=)
+
+#undef DEFN_REL_OP_T
+#undef DEFN_REL_OP_OTHER
+#undef DEFN_REL_OP
+
+
+// assignment operators
+
+inline
+sc_fxval_fast&
+sc_fxval_fast::operator = ( const sc_fxval_fast& a )
+{
+    if( &a != this )
+    {
+	SC_FXVAL_FAST_OBSERVER_READ_( a )
+	m_val = a.m_val;
+	SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
+    }
+    return *this;
+}
+
+#define DEFN_ASN_OP_T(tp)                                                     \
+inline                                                                        \
+sc_fxval_fast&                                                                \
+sc_fxval_fast::operator = ( tp a )                                            \
+{                                                                             \
+    sc_fxval_fast tmp( a );                                                   \
+    m_val = tmp.m_val;                                                        \
+    SC_FXVAL_FAST_OBSERVER_WRITE_( *this )                                    \
+    return *this;                                                             \
+}
+
+DEFN_ASN_OP_T(int)
+DEFN_ASN_OP_T(unsigned int)
+DEFN_ASN_OP_T(long)
+DEFN_ASN_OP_T(unsigned long)
+DEFN_ASN_OP_T(float)
+DEFN_ASN_OP_T(double)
+DEFN_ASN_OP_T(const char*)
+DEFN_ASN_OP_T(const sc_fxval&)
+#ifndef SC_FX_EXCLUDE_OTHER
+DEFN_ASN_OP_T(int64)
+DEFN_ASN_OP_T(uint64)
+DEFN_ASN_OP_T(const sc_int_base&)
+DEFN_ASN_OP_T(const sc_uint_base&)
+DEFN_ASN_OP_T(const sc_signed&)
+DEFN_ASN_OP_T(const sc_unsigned&)
+#endif
+
+#undef DEFN_ASN_OP_T
+
+
+#define DEFN_ASN_OP_T(op,tp)                                                  \
+inline                                                                        \
+sc_fxval_fast&                                                                \
+sc_fxval_fast::operator op ( tp b )                                           \
+{                                                                             \
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )                                     \
+    sc_fxval_fast tmp( b );                                                   \
+    m_val op tmp.m_val;                                                       \
+    SC_FXVAL_FAST_OBSERVER_WRITE_( *this )                                    \
+    return *this;                                                             \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_ASN_OP_OTHER(op)                                                 \
+DEFN_ASN_OP_T(op,int64)                                                       \
+DEFN_ASN_OP_T(op,uint64)                                                      \
+DEFN_ASN_OP_T(op,const sc_int_base&)                                          \
+DEFN_ASN_OP_T(op,const sc_uint_base&)                                         \
+DEFN_ASN_OP_T(op,const sc_signed&)                                            \
+DEFN_ASN_OP_T(op,const sc_unsigned&)
+#else
+#define DEFN_ASN_OP_OTHER(op)
+#endif
+
+#define DEFN_ASN_OP(op)                                                       \
+inline                                                                        \
+sc_fxval_fast&                                                                \
+sc_fxval_fast::operator op ( const sc_fxval_fast& b )                         \
+{                                                                             \
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )                                     \
+    SC_FXVAL_FAST_OBSERVER_READ_( b )                                         \
+    m_val op b.m_val;                                                         \
+    SC_FXVAL_FAST_OBSERVER_WRITE_( *this )                                    \
+    return *this;                                                             \
+}                                                                             \
+                                                                              \
+DEFN_ASN_OP_T(op,int)                                                         \
+DEFN_ASN_OP_T(op,unsigned int)                                                \
+DEFN_ASN_OP_T(op,long)                                                        \
+DEFN_ASN_OP_T(op,unsigned long)                                               \
+DEFN_ASN_OP_T(op,float)                                                      \
+DEFN_ASN_OP_T(op,double)                                                      \
+DEFN_ASN_OP_T(op,const char*)                                                 \
+DEFN_ASN_OP_T(op,const sc_fxval&)                                             \
+DEFN_ASN_OP_OTHER(op)
+
+DEFN_ASN_OP(*=)
+DEFN_ASN_OP(/=)
+DEFN_ASN_OP(+=)
+DEFN_ASN_OP(-=)
+
+#undef DEFN_ASN_OP_T
+#undef DEFN_ASN_OP_OTHER
+#undef DEFN_ASN_OP
+
+
+inline
+sc_fxval_fast&
+sc_fxval_fast::operator <<= ( int b )
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )
+    m_val *= scfx_pow2( b );
+    SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
+    return *this;
+}
+
+inline
+sc_fxval_fast&
+sc_fxval_fast::operator >>= ( int b )
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )
+    m_val *= scfx_pow2( -b );
+    SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
+    return *this;
+}
+
+
+// auto-increment and auto-decrement
+
+inline
+const sc_fxval_fast
+sc_fxval_fast::operator ++ ( int )
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )
+    double c = m_val;
+    m_val = m_val + 1;
+    SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
+    return sc_fxval_fast( c );
+}
+
+inline
+const sc_fxval_fast
+sc_fxval_fast::operator -- ( int )
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )
+    double c = m_val;
+    m_val = m_val - 1;
+    SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
+    return sc_fxval_fast( c );
+}
+
+inline
+sc_fxval_fast&
+sc_fxval_fast::operator ++ ()
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )
+    m_val = m_val + 1;
+    SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
+    return *this;
+}
+
+inline
+sc_fxval_fast&
+sc_fxval_fast::operator -- ()
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )
+    m_val = m_val - 1;
+    SC_FXVAL_FAST_OBSERVER_WRITE_( *this )
+    return *this;
+}
+
+
+// implicit conversion
+
+inline
+sc_fxval_fast::operator double() const
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )
+    return m_val;
+}
+
+
+// explicit conversion to primitive types
+
+inline
+short
+sc_fxval_fast::to_short() const
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )
+    return static_cast<short>( m_val );
+}
+
+inline
+unsigned short
+sc_fxval_fast::to_ushort() const
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )
+    return static_cast<unsigned short>( m_val );
+}
+
+inline
+int64
+sc_fxval_fast::to_int64() const
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )
+    return static_cast<int64>( m_val );
+}
+
+inline
+int
+sc_fxval_fast::to_int() const
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )
+    return static_cast<int>( m_val );
+}
+
+inline
+unsigned int
+sc_fxval_fast::to_uint() const
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )
+    return static_cast<unsigned int>( m_val );
+}
+
+inline
+uint64
+sc_fxval_fast::to_uint64() const
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )
+    return static_cast<uint64>( m_val );
+}
+
+inline
+long
+sc_fxval_fast::to_long() const
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )
+    return static_cast<long>( m_val );
+}
+
+inline
+unsigned long
+sc_fxval_fast::to_ulong() const
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )
+    return static_cast<unsigned long>( m_val );
+}
+
+inline
+float
+sc_fxval_fast::to_float() const
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )
+    return static_cast<float>( m_val );
+}
+
+inline
+double
+sc_fxval_fast::to_double() const
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )
+    return m_val;
+}
+
+
+// query value
+
+inline
+bool
+sc_fxval_fast::is_neg() const
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )
+    scfx_ieee_double id( m_val );
+    return ( id.negative() != 0 );
+}
+
+inline
+bool
+sc_fxval_fast::is_zero() const
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )
+    scfx_ieee_double id( m_val );
+    return id.is_zero();
+}
+
+inline
+bool
+sc_fxval_fast::is_nan() const
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )
+    scfx_ieee_double id( m_val );
+    return id.is_nan();
+}
+
+inline
+bool
+sc_fxval_fast::is_inf() const
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )
+    scfx_ieee_double id( m_val );
+    return id.is_inf();
+}
+
+inline
+bool
+sc_fxval_fast::is_normal() const
+{
+    SC_FXVAL_FAST_OBSERVER_READ_( *this )
+    scfx_ieee_double id( m_val );
+    return ( id.is_normal() || id.is_subnormal() || id.is_zero() );
+}
+
+
+inline
+bool
+sc_fxval_fast::rounding_flag() const
+{
+    // does not apply to sc_fxval_fast; included for API compatibility
+    return false;
+}
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_fxval_fast& a )
+{
+    a.print( os );
+    return os;
+}
+
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_fxval_fast& a )
+{
+    a.scan( is );
+    return is;
+}
+
+} // namespace sc_dt
+
+#undef SCFX_EXPLICIT_
+#undef SCFX_EXPLICIT_OTHER_
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/sc_fxval_observer.cpp b/ext/systemc/src/sysc/datatypes/fx/sc_fxval_observer.cpp
new file mode 100644
index 000000000..ae651cc14
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/sc_fxval_observer.cpp
@@ -0,0 +1,76 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_fxval_observer.cpp - 
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_fxval_observer.cpp,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include "sysc/datatypes/fx/sc_fxval_observer.h"
+
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxval_observer
+//
+//  Abstract base class for fixed-point value type observers;
+//  arbitrary precision.
+// ----------------------------------------------------------------------------
+
+sc_fxval_observer* (*sc_fxval_observer::default_observer) () = 0;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxval_fast_observer
+//
+//  Abstract base class for fixed-point value type observers;
+//  limited precision.
+// ----------------------------------------------------------------------------
+
+sc_fxval_fast_observer* (*sc_fxval_fast_observer::default_observer) () = 0;
+
+} // namespace sc_dt
+
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/sc_fxval_observer.h b/ext/systemc/src/sysc/datatypes/fx/sc_fxval_observer.h
new file mode 100644
index 000000000..e34d85c1b
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/sc_fxval_observer.h
@@ -0,0 +1,223 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_fxval_observer.h - 
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_fxval_observer.h,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SC_FXVAL_OBSERVER_H
+#define SC_FXVAL_OBSERVER_H
+
+
+#include "sysc/datatypes/fx/sc_fxdefs.h"
+
+
+namespace sc_dt
+{
+
+// classes defined in this module
+class sc_fxval_observer;
+class sc_fxval_fast_observer;
+
+// forward class declarations
+class sc_fxval;
+class sc_fxval_fast;
+
+
+#ifdef SC_ENABLE_OBSERVERS
+
+#define SC_FXVAL_OBSERVER_CONSTRUCT_(object)                                  \
+    SC_OBSERVER_(object,sc_fxval_observer*,construct)
+#define SC_FXVAL_OBSERVER_DESTRUCT_(object)                                   \
+    SC_OBSERVER_(object,sc_fxval_observer*,destruct)
+#define SC_FXVAL_OBSERVER_READ_(object)                                       \
+    SC_OBSERVER_(object,sc_fxval_observer*,read)
+#define SC_FXVAL_OBSERVER_WRITE_(object)                                      \
+    SC_OBSERVER_(object,sc_fxval_observer*,write)
+#define SC_FXVAL_OBSERVER_DEFAULT_                                            \
+    SC_OBSERVER_DEFAULT_(sc_fxval_observer)
+
+#define SC_FXVAL_FAST_OBSERVER_CONSTRUCT_(object)                             \
+    SC_OBSERVER_(object,sc_fxval_fast_observer*,construct)
+#define SC_FXVAL_FAST_OBSERVER_DESTRUCT_(object)                              \
+    SC_OBSERVER_(object,sc_fxval_fast_observer*,destruct)
+#define SC_FXVAL_FAST_OBSERVER_READ_(object)                                  \
+    SC_OBSERVER_(object,sc_fxval_fast_observer*,read)
+#define SC_FXVAL_FAST_OBSERVER_WRITE_(object)                                 \
+    SC_OBSERVER_(object,sc_fxval_fast_observer*,write)
+#define SC_FXVAL_FAST_OBSERVER_DEFAULT_                                       \
+    SC_OBSERVER_DEFAULT_(sc_fxval_fast_observer)
+
+#else
+
+#define SC_FXVAL_OBSERVER_CONSTRUCT_(object)
+#define SC_FXVAL_OBSERVER_DESTRUCT_(object)
+#define SC_FXVAL_OBSERVER_READ_(object)
+#define SC_FXVAL_OBSERVER_WRITE_(object)
+#define SC_FXVAL_OBSERVER_DEFAULT_
+
+#define SC_FXVAL_FAST_OBSERVER_CONSTRUCT_(object)
+#define SC_FXVAL_FAST_OBSERVER_DESTRUCT_(object)
+#define SC_FXVAL_FAST_OBSERVER_READ_(object)
+#define SC_FXVAL_FAST_OBSERVER_WRITE_(object)
+#define SC_FXVAL_FAST_OBSERVER_DEFAULT_
+
+#endif
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxval_observer
+//
+//  Abstract base class for fixed-point value type observers;
+//  arbitrary precision.
+// ----------------------------------------------------------------------------
+
+class sc_fxval_observer
+{
+
+protected:
+    
+    sc_fxval_observer() {}
+    virtual ~sc_fxval_observer() {}
+
+public:
+
+    virtual void construct( const sc_fxval& );
+    virtual void  destruct( const sc_fxval& );
+    virtual void      read( const sc_fxval& );
+    virtual void     write( const sc_fxval& );
+
+    static sc_fxval_observer* (*default_observer) ();
+
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxval_fast_observer
+//
+//  Abstract base class for fixed-point value type observers;
+//  limited precision.
+// ----------------------------------------------------------------------------
+
+class sc_fxval_fast_observer
+{
+
+protected:
+    
+    sc_fxval_fast_observer() {}
+    virtual ~sc_fxval_fast_observer() {}
+
+public:
+
+    virtual void construct( const sc_fxval_fast& );
+    virtual void  destruct( const sc_fxval_fast& );
+    virtual void      read( const sc_fxval_fast& );
+    virtual void     write( const sc_fxval_fast& );
+
+    static sc_fxval_fast_observer* (*default_observer) ();
+
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxval_observer
+//
+//  Abstract base class for fixed-point value type observers;
+//  arbitrary precision.
+// ----------------------------------------------------------------------------
+
+inline
+void
+sc_fxval_observer::construct( const sc_fxval& )
+{}
+
+inline
+void
+sc_fxval_observer::destruct( const sc_fxval& )
+{}
+
+inline
+void
+sc_fxval_observer::read( const sc_fxval& )
+{}
+
+inline
+void
+sc_fxval_observer::write( const sc_fxval& )
+{}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxval_fast_observer
+//
+//  Abstract base class for fixed-point value type observers;
+//  limited precision.
+// ----------------------------------------------------------------------------
+
+inline
+void
+sc_fxval_fast_observer::construct( const sc_fxval_fast& )
+{}
+
+inline
+void
+sc_fxval_fast_observer::destruct( const sc_fxval_fast& )
+{}
+
+inline
+void
+sc_fxval_fast_observer::read( const sc_fxval_fast& )
+{}
+
+inline
+void
+sc_fxval_fast_observer::write( const sc_fxval_fast& )
+{}
+
+} // namespace sc_dt
+
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/sc_ufix.h b/ext/systemc/src/sysc/datatypes/fx/sc_ufix.h
new file mode 100644
index 000000000..b8d9acaa1
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/sc_ufix.h
@@ -0,0 +1,1941 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_ufix.h - 
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_ufix.h,v $
+// Revision 1.2  2011/01/20 22:52:30  acg
+//  Andy Goodrich: Add float constructors.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SC_UFIX_H
+#define SC_UFIX_H
+
+
+#include "sysc/datatypes/fx/sc_fxnum.h"
+
+
+namespace sc_dt
+{
+
+// classes defined in this module
+class sc_ufix;
+class sc_ufix_fast;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_ufix
+//
+//  "Unconstrained" unsigned fixed-point class; arbitrary precision.
+// ----------------------------------------------------------------------------
+
+class sc_ufix : public sc_fxnum
+{
+
+public:
+
+    // constructors
+
+    explicit sc_ufix( sc_fxnum_observer* = 0 );
+             sc_ufix( int, int,
+		      sc_fxnum_observer* = 0 );
+             sc_ufix( sc_q_mode, sc_o_mode,
+		      sc_fxnum_observer* = 0 );
+             sc_ufix( sc_q_mode, sc_o_mode, int,
+		      sc_fxnum_observer* = 0 );
+             sc_ufix( int, int, sc_q_mode, sc_o_mode,
+		      sc_fxnum_observer* = 0 );
+             sc_ufix( int, int, sc_q_mode, sc_o_mode, int,
+		      sc_fxnum_observer* = 0 );
+    explicit sc_ufix( const sc_fxcast_switch&,
+		      sc_fxnum_observer* = 0 );
+             sc_ufix( int, int,
+		      const sc_fxcast_switch&,
+		      sc_fxnum_observer* = 0 );
+             sc_ufix( sc_q_mode, sc_o_mode,
+		      const sc_fxcast_switch&,
+		      sc_fxnum_observer* = 0 );
+             sc_ufix( sc_q_mode, sc_o_mode, int,
+		      const sc_fxcast_switch&,
+		      sc_fxnum_observer* = 0 );
+             sc_ufix( int, int, sc_q_mode, sc_o_mode,
+		      const sc_fxcast_switch&,
+		      sc_fxnum_observer* = 0 );
+             sc_ufix( int, int, sc_q_mode, sc_o_mode, int,
+		      const sc_fxcast_switch&,
+		      sc_fxnum_observer* = 0 );
+    explicit sc_ufix( const sc_fxtype_params&,
+		      sc_fxnum_observer* = 0 );
+             sc_ufix( const sc_fxtype_params&,
+		      const sc_fxcast_switch&,
+		      sc_fxnum_observer* = 0 );
+
+#define DECL_CTORS_T(tp)                                                      \
+             sc_ufix( tp,                                                     \
+		      int, int,                                               \
+		      sc_fxnum_observer* = 0 );                               \
+             sc_ufix( tp,                                                     \
+		      sc_q_mode, sc_o_mode,                                   \
+		      sc_fxnum_observer* = 0 );                               \
+             sc_ufix( tp,                                                     \
+		      sc_q_mode, sc_o_mode, int,                              \
+		      sc_fxnum_observer* = 0 );                               \
+             sc_ufix( tp,                                                     \
+		      int, int, sc_q_mode, sc_o_mode,                         \
+		      sc_fxnum_observer* = 0 );                               \
+             sc_ufix( tp,                                                     \
+		      int, int, sc_q_mode, sc_o_mode, int,                    \
+		      sc_fxnum_observer* = 0 );                               \
+             sc_ufix( tp,                                                     \
+		      const sc_fxcast_switch&,                                \
+		      sc_fxnum_observer* = 0 );                               \
+             sc_ufix( tp,                                                     \
+		      int, int,                                               \
+		      const sc_fxcast_switch&,                                \
+		      sc_fxnum_observer* = 0 );                               \
+             sc_ufix( tp,                                                     \
+		      sc_q_mode, sc_o_mode,                                   \
+		      const sc_fxcast_switch&,                                \
+		      sc_fxnum_observer* = 0 );                               \
+             sc_ufix( tp,                                                     \
+		      sc_q_mode, sc_o_mode, int,                              \
+		      const sc_fxcast_switch&,                                \
+		      sc_fxnum_observer* = 0 );                               \
+             sc_ufix( tp,                                                     \
+		      int, int, sc_q_mode, sc_o_mode,                         \
+		      const sc_fxcast_switch&,                                \
+		      sc_fxnum_observer* = 0 );                               \
+             sc_ufix( tp,                                                     \
+		      int, int, sc_q_mode, sc_o_mode, int,                    \
+		      const sc_fxcast_switch&,                                \
+		      sc_fxnum_observer* = 0 );                               \
+             sc_ufix( tp,                                                     \
+		      const sc_fxtype_params&,                                \
+		      sc_fxnum_observer* = 0 );                               \
+             sc_ufix( tp,                                                     \
+		      const sc_fxtype_params&,                                \
+		      const sc_fxcast_switch&,                                \
+		      sc_fxnum_observer* = 0 );
+
+#define DECL_CTORS_T_A(tp)                                                    \
+             sc_ufix( tp,                                                     \
+	              sc_fxnum_observer* = 0 );                               \
+    DECL_CTORS_T(tp)
+
+#define DECL_CTORS_T_B(tp)                                                    \
+    explicit sc_ufix( tp,                                                     \
+	              sc_fxnum_observer* = 0 );                               \
+    DECL_CTORS_T(tp)
+
+    DECL_CTORS_T_A(int)
+    DECL_CTORS_T_A(unsigned int)
+    DECL_CTORS_T_A(long)
+    DECL_CTORS_T_A(unsigned long)
+    DECL_CTORS_T_A(float)
+    DECL_CTORS_T_A(double)
+    DECL_CTORS_T_A(const char*)
+    DECL_CTORS_T_A(const sc_fxval&)
+    DECL_CTORS_T_A(const sc_fxval_fast&)
+    DECL_CTORS_T_A(const sc_fxnum&)
+    DECL_CTORS_T_A(const sc_fxnum_fast&)
+#ifndef SC_FX_EXCLUDE_OTHER
+    DECL_CTORS_T_B(int64)
+    DECL_CTORS_T_B(uint64)
+    DECL_CTORS_T_B(const sc_int_base&)
+    DECL_CTORS_T_B(const sc_uint_base&)
+    DECL_CTORS_T_B(const sc_signed&)
+    DECL_CTORS_T_B(const sc_unsigned&)
+#endif
+
+#undef DECL_CTORS_T
+#undef DECL_CTORS_T_A
+#undef DECL_CTORS_T_B
+
+    // copy constructor
+
+    sc_ufix( const sc_ufix& );
+
+
+    // unary bitwise operators
+
+    const sc_ufix operator ~ () const;
+
+
+    // unary bitwise functions
+
+    friend void b_not( sc_ufix&, const sc_ufix& );
+
+
+    // binary bitwise operators
+
+    friend const sc_ufix operator & ( const sc_ufix&, const sc_ufix& );
+    friend const sc_ufix operator & ( const sc_ufix&, const sc_ufix_fast& );
+    friend const sc_ufix operator & ( const sc_ufix_fast&, const sc_ufix& );
+    friend const sc_ufix operator | ( const sc_ufix&, const sc_ufix& );
+    friend const sc_ufix operator | ( const sc_ufix&, const sc_ufix_fast& );
+    friend const sc_ufix operator | ( const sc_ufix_fast&, const sc_ufix& );
+    friend const sc_ufix operator ^ ( const sc_ufix&, const sc_ufix& );
+    friend const sc_ufix operator ^ ( const sc_ufix&, const sc_ufix_fast& );
+    friend const sc_ufix operator ^ ( const sc_ufix_fast&, const sc_ufix& );
+
+
+    // binary bitwise functions
+
+    friend void b_and( sc_ufix&, const sc_ufix&, const sc_ufix& );
+    friend void b_and( sc_ufix&, const sc_ufix&, const sc_ufix_fast& );
+    friend void b_and( sc_ufix&, const sc_ufix_fast&, const sc_ufix& );
+    friend void b_or ( sc_ufix&, const sc_ufix&, const sc_ufix& );
+    friend void b_or ( sc_ufix&, const sc_ufix&, const sc_ufix_fast& );
+    friend void b_or ( sc_ufix&, const sc_ufix_fast&, const sc_ufix& );
+    friend void b_xor( sc_ufix&, const sc_ufix&, const sc_ufix& );
+    friend void b_xor( sc_ufix&, const sc_ufix&, const sc_ufix_fast& );
+    friend void b_xor( sc_ufix&, const sc_ufix_fast&, const sc_ufix& );
+
+
+    // assignment operators
+
+    sc_ufix& operator = ( const sc_ufix& );
+
+#define DECL_ASN_OP_T(op,tp)                                                  \
+    sc_ufix& operator op ( tp );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_ASN_OP_OTHER(op)                                                 \
+    DECL_ASN_OP_T(op,int64)                                                   \
+    DECL_ASN_OP_T(op,uint64)                                                  \
+    DECL_ASN_OP_T(op,const sc_int_base&)                                      \
+    DECL_ASN_OP_T(op,const sc_uint_base&)                                     \
+    DECL_ASN_OP_T(op,const sc_signed&)                                        \
+    DECL_ASN_OP_T(op,const sc_unsigned&)
+#else
+#define DECL_ASN_OP_OTHER(op)
+#endif
+
+#define DECL_ASN_OP(op)                                                       \
+    DECL_ASN_OP_T(op,int)                                                     \
+    DECL_ASN_OP_T(op,unsigned int)                                            \
+    DECL_ASN_OP_T(op,long)                                                    \
+    DECL_ASN_OP_T(op,unsigned long)                                           \
+    DECL_ASN_OP_T(op,float)                                                  \
+    DECL_ASN_OP_T(op,double)                                                  \
+    DECL_ASN_OP_T(op,const char*)                                             \
+    DECL_ASN_OP_T(op,const sc_fxval&)                                         \
+    DECL_ASN_OP_T(op,const sc_fxval_fast&)                                    \
+    DECL_ASN_OP_T(op,const sc_fxnum&)                                         \
+    DECL_ASN_OP_T(op,const sc_fxnum_fast&)                                    \
+    DECL_ASN_OP_OTHER(op)
+
+    DECL_ASN_OP(=)
+
+    DECL_ASN_OP(*=)
+    DECL_ASN_OP(/=)
+    DECL_ASN_OP(+=)
+    DECL_ASN_OP(-=)
+
+    DECL_ASN_OP_T(<<=,int)
+    DECL_ASN_OP_T(>>=,int)
+
+    DECL_ASN_OP_T(&=,const sc_ufix&)
+    DECL_ASN_OP_T(&=,const sc_ufix_fast&)
+    DECL_ASN_OP_T(|=,const sc_ufix&)
+    DECL_ASN_OP_T(|=,const sc_ufix_fast&)
+    DECL_ASN_OP_T(^=,const sc_ufix&)
+    DECL_ASN_OP_T(^=,const sc_ufix_fast&)
+
+#undef DECL_ASN_OP_T
+#undef DECL_ASN_OP_OTHER
+#undef DECL_ASN_OP
+
+
+    // auto-increment and auto-decrement
+
+    const sc_fxval operator ++ ( int );
+    const sc_fxval operator -- ( int );
+
+    sc_ufix& operator ++ ();
+    sc_ufix& operator -- ();
+
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_ufix_fast
+//
+//  "Unconstrained" unsigned fixed-point class; limited precision.
+// ----------------------------------------------------------------------------
+
+class sc_ufix_fast : public sc_fxnum_fast
+{
+
+public:
+
+    // constructors
+
+    explicit sc_ufix_fast( sc_fxnum_fast_observer* = 0 );
+             sc_ufix_fast( int, int,
+			   sc_fxnum_fast_observer* = 0 );
+             sc_ufix_fast( sc_q_mode, sc_o_mode,
+			   sc_fxnum_fast_observer* = 0 );
+             sc_ufix_fast( sc_q_mode, sc_o_mode, int,
+			   sc_fxnum_fast_observer* = 0 );
+             sc_ufix_fast( int, int, sc_q_mode, sc_o_mode,
+			   sc_fxnum_fast_observer* = 0 );
+             sc_ufix_fast( int, int, sc_q_mode, sc_o_mode, int,
+			   sc_fxnum_fast_observer* = 0 );
+    explicit sc_ufix_fast( const sc_fxcast_switch&,
+			   sc_fxnum_fast_observer* = 0 );
+             sc_ufix_fast( int, int,
+			   const sc_fxcast_switch&,
+			   sc_fxnum_fast_observer* = 0 );
+             sc_ufix_fast( sc_q_mode, sc_o_mode,
+			   const sc_fxcast_switch&,
+			   sc_fxnum_fast_observer* = 0 );
+             sc_ufix_fast( sc_q_mode, sc_o_mode, int,
+			   const sc_fxcast_switch&,
+			   sc_fxnum_fast_observer* = 0 );
+             sc_ufix_fast( int, int, sc_q_mode, sc_o_mode,
+			   const sc_fxcast_switch&,
+			   sc_fxnum_fast_observer* = 0 );
+             sc_ufix_fast( int, int, sc_q_mode, sc_o_mode, int,
+			   const sc_fxcast_switch&,
+			   sc_fxnum_fast_observer* = 0 );
+    explicit sc_ufix_fast( const sc_fxtype_params&,
+			   sc_fxnum_fast_observer* = 0 );
+             sc_ufix_fast( const sc_fxtype_params&,
+			   const sc_fxcast_switch&,
+			   sc_fxnum_fast_observer* = 0 );
+
+#define DECL_CTORS_T(tp)                                                      \
+             sc_ufix_fast( tp,                                                \
+			   int, int,                                          \
+			   sc_fxnum_fast_observer* = 0 );                     \
+             sc_ufix_fast( tp,                                                \
+			   sc_q_mode, sc_o_mode,                              \
+			   sc_fxnum_fast_observer* = 0 );                     \
+             sc_ufix_fast( tp,                                                \
+			   sc_q_mode, sc_o_mode, int,                         \
+			   sc_fxnum_fast_observer* = 0 );                     \
+             sc_ufix_fast( tp,                                                \
+			   int, int, sc_q_mode, sc_o_mode,                    \
+			   sc_fxnum_fast_observer* = 0 );                     \
+             sc_ufix_fast( tp,                                                \
+			   int, int, sc_q_mode, sc_o_mode, int,               \
+			   sc_fxnum_fast_observer* = 0 );                     \
+             sc_ufix_fast( tp,                                                \
+			   const sc_fxcast_switch&,                           \
+			   sc_fxnum_fast_observer* = 0 );                     \
+             sc_ufix_fast( tp,                                                \
+			   int, int,                                          \
+			   const sc_fxcast_switch&,                           \
+			   sc_fxnum_fast_observer* = 0 );                     \
+             sc_ufix_fast( tp,                                                \
+			   sc_q_mode, sc_o_mode,                              \
+			   const sc_fxcast_switch&,                           \
+			   sc_fxnum_fast_observer* = 0 );                     \
+             sc_ufix_fast( tp,                                                \
+			   sc_q_mode, sc_o_mode, int,                         \
+			   const sc_fxcast_switch&,                           \
+			   sc_fxnum_fast_observer* = 0 );                     \
+             sc_ufix_fast( tp,                                                \
+			   int, int, sc_q_mode, sc_o_mode,                    \
+			   const sc_fxcast_switch&,                           \
+			   sc_fxnum_fast_observer* = 0 );                     \
+             sc_ufix_fast( tp,                                                \
+			   int, int, sc_q_mode, sc_o_mode, int,               \
+			   const sc_fxcast_switch&,                           \
+			   sc_fxnum_fast_observer* = 0 );                     \
+             sc_ufix_fast( tp,                                                \
+			   const sc_fxtype_params&,                           \
+			   sc_fxnum_fast_observer* = 0 );                     \
+             sc_ufix_fast( tp,                                                \
+			   const sc_fxtype_params&,                           \
+			   const sc_fxcast_switch&,                           \
+			   sc_fxnum_fast_observer* = 0 );
+
+#define DECL_CTORS_T_A(tp)                                                    \
+             sc_ufix_fast( tp,                                                \
+		           sc_fxnum_fast_observer* = 0 );                     \
+    DECL_CTORS_T(tp)
+
+#define DECL_CTORS_T_B(tp)                                                    \
+    explicit sc_ufix_fast( tp,                                                \
+		           sc_fxnum_fast_observer* = 0 );                     \
+    DECL_CTORS_T(tp)
+
+    DECL_CTORS_T_A(int)
+    DECL_CTORS_T_A(unsigned int)
+    DECL_CTORS_T_A(long)
+    DECL_CTORS_T_A(unsigned long)
+    DECL_CTORS_T_A(float)
+    DECL_CTORS_T_A(double)
+    DECL_CTORS_T_A(const char*)
+    DECL_CTORS_T_A(const sc_fxval&)
+    DECL_CTORS_T_A(const sc_fxval_fast&)
+    DECL_CTORS_T_A(const sc_fxnum&)
+    DECL_CTORS_T_A(const sc_fxnum_fast&)
+#ifndef SC_FX_EXCLUDE_OTHER
+    DECL_CTORS_T_B(int64)
+    DECL_CTORS_T_B(uint64)
+    DECL_CTORS_T_B(const sc_int_base&)
+    DECL_CTORS_T_B(const sc_uint_base&)
+    DECL_CTORS_T_B(const sc_signed&)
+    DECL_CTORS_T_B(const sc_unsigned&)
+#endif
+
+#undef DECL_CTORS_T
+#undef DECL_CTORS_T_A
+#undef DECL_CTORS_T_B
+
+    // copy constructor
+
+    sc_ufix_fast( const sc_ufix_fast& );
+
+
+    // unary bitwise operators
+
+    const sc_ufix_fast operator ~ () const;
+
+
+    // unary bitwise functions
+
+    friend void b_not( sc_ufix_fast&, const sc_ufix_fast& );
+
+
+    // binary bitwise operators
+
+    friend const sc_ufix_fast operator & ( const sc_ufix_fast&,
+					   const sc_ufix_fast& );
+    friend const sc_ufix_fast operator ^ ( const sc_ufix_fast&,
+					   const sc_ufix_fast& );
+    friend const sc_ufix_fast operator | ( const sc_ufix_fast&,
+					   const sc_ufix_fast& );
+
+
+    // binary bitwise functions
+
+    friend void b_and( sc_ufix_fast&, const sc_ufix_fast&,
+		                      const sc_ufix_fast& );
+    friend void b_or ( sc_ufix_fast&, const sc_ufix_fast&,
+		                      const sc_ufix_fast& );
+    friend void b_xor( sc_ufix_fast&, const sc_ufix_fast&,
+		                      const sc_ufix_fast& );
+
+
+    // assignment operators
+
+    sc_ufix_fast& operator = ( const sc_ufix_fast& );
+
+#define DECL_ASN_OP_T(op,tp)                                                  \
+    sc_ufix_fast& operator op ( tp );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_ASN_OP_OTHER(op)                                                 \
+    DECL_ASN_OP_T(op,int64)                                                   \
+    DECL_ASN_OP_T(op,uint64)                                                  \
+    DECL_ASN_OP_T(op,const sc_int_base&)                                      \
+    DECL_ASN_OP_T(op,const sc_uint_base&)                                     \
+    DECL_ASN_OP_T(op,const sc_signed&)                                        \
+    DECL_ASN_OP_T(op,const sc_unsigned&)
+#else
+#define DECL_ASN_OP_OTHER(op)
+#endif
+
+#define DECL_ASN_OP(op)                                                       \
+    DECL_ASN_OP_T(op,int)                                                     \
+    DECL_ASN_OP_T(op,unsigned int)                                            \
+    DECL_ASN_OP_T(op,long)                                                    \
+    DECL_ASN_OP_T(op,unsigned long)                                           \
+    DECL_ASN_OP_T(op,float)                                                  \
+    DECL_ASN_OP_T(op,double)                                                  \
+    DECL_ASN_OP_T(op,const char*)                                             \
+    DECL_ASN_OP_T(op,const sc_fxval&)                                         \
+    DECL_ASN_OP_T(op,const sc_fxval_fast&)                                    \
+    DECL_ASN_OP_T(op,const sc_fxnum&)                                         \
+    DECL_ASN_OP_T(op,const sc_fxnum_fast&)                                    \
+    DECL_ASN_OP_OTHER(op)
+
+    DECL_ASN_OP(=)
+
+    DECL_ASN_OP(*=)
+    DECL_ASN_OP(/=)
+    DECL_ASN_OP(+=)
+    DECL_ASN_OP(-=)
+
+    DECL_ASN_OP_T(<<=,int)
+    DECL_ASN_OP_T(>>=,int)
+
+    DECL_ASN_OP_T(&=,const sc_ufix&)
+    DECL_ASN_OP_T(&=,const sc_ufix_fast&)
+    DECL_ASN_OP_T(|=,const sc_ufix&)
+    DECL_ASN_OP_T(|=,const sc_ufix_fast&)
+    DECL_ASN_OP_T(^=,const sc_ufix&)
+    DECL_ASN_OP_T(^=,const sc_ufix_fast&)
+
+#undef DECL_ASN_OP_T
+#undef DECL_ASN_OP_OTHER
+#undef DECL_ASN_OP
+
+
+    // auto-increment and auto-decrement
+
+    const sc_fxval_fast operator ++ ( int );
+    const sc_fxval_fast operator -- ( int );
+
+    sc_ufix_fast& operator ++ ();
+    sc_ufix_fast& operator -- ();
+
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_ufix
+//
+//  "Unconstrained" unsigned fixed-point class; arbitrary precision.
+// ----------------------------------------------------------------------------
+
+// constructors
+
+inline
+sc_ufix::sc_ufix( sc_fxnum_observer* observer_ )
+: sc_fxnum( sc_fxtype_params(),
+	    SC_US_,
+	    sc_fxcast_switch(),
+	    observer_ )
+{}
+
+inline
+sc_ufix::sc_ufix( int wl_, int iwl_,
+		  sc_fxnum_observer* observer_ )
+: sc_fxnum( sc_fxtype_params( wl_, iwl_ ),
+	    SC_US_,
+	    sc_fxcast_switch(),
+	    observer_ )
+{}
+
+inline
+sc_ufix::sc_ufix( sc_q_mode qm, sc_o_mode om,
+		  sc_fxnum_observer* observer_ )
+: sc_fxnum( sc_fxtype_params( qm, om ),
+	    SC_US_,
+	    sc_fxcast_switch(),
+	    observer_ )
+{}
+
+inline
+sc_ufix::sc_ufix( sc_q_mode qm, sc_o_mode om, int nb,
+		  sc_fxnum_observer* observer_ )
+: sc_fxnum( sc_fxtype_params( qm, om, nb ),
+	    SC_US_,
+	    sc_fxcast_switch(),
+	    observer_ )
+{}
+
+inline
+sc_ufix::sc_ufix( int wl_, int iwl_, sc_q_mode qm, sc_o_mode om,
+		  sc_fxnum_observer* observer_ )
+: sc_fxnum( sc_fxtype_params( wl_, iwl_, qm, om ),
+	    SC_US_,
+	    sc_fxcast_switch(),
+	    observer_ )
+{}
+
+inline
+sc_ufix::sc_ufix( int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb,
+		  sc_fxnum_observer* observer_ )
+: sc_fxnum( sc_fxtype_params( wl_, iwl_, qm, om, nb ),
+	    SC_US_,
+	    sc_fxcast_switch(),
+	    observer_ )
+{}
+
+inline
+sc_ufix::sc_ufix( const sc_fxcast_switch& cast_sw,
+		  sc_fxnum_observer* observer_ )
+: sc_fxnum( sc_fxtype_params(),
+	    SC_US_,
+	    cast_sw,
+	    observer_ )
+{}
+
+inline
+sc_ufix::sc_ufix( int wl_, int iwl_,
+		  const sc_fxcast_switch& cast_sw,
+		  sc_fxnum_observer* observer_ )
+: sc_fxnum( sc_fxtype_params( wl_, iwl_ ),
+	    SC_US_,
+	    cast_sw,
+	    observer_ )
+{}
+
+inline
+sc_ufix::sc_ufix( sc_q_mode qm, sc_o_mode om,
+		  const sc_fxcast_switch& cast_sw,
+		  sc_fxnum_observer* observer_ )
+: sc_fxnum( sc_fxtype_params( qm, om ),
+	    SC_US_,
+	    cast_sw,
+	    observer_ )
+{}
+
+inline
+sc_ufix::sc_ufix( sc_q_mode qm, sc_o_mode om, int nb,
+		  const sc_fxcast_switch& cast_sw,
+		  sc_fxnum_observer* observer_ )
+: sc_fxnum( sc_fxtype_params( qm, om, nb ),
+	    SC_US_,
+	    cast_sw,
+	    observer_ )
+{}
+
+inline
+sc_ufix::sc_ufix( int wl_, int iwl_, sc_q_mode qm, sc_o_mode om,
+		  const sc_fxcast_switch& cast_sw,
+		  sc_fxnum_observer* observer_ )
+: sc_fxnum( sc_fxtype_params( wl_, iwl_, qm, om ),
+	    SC_US_,
+	    cast_sw,
+	    observer_ )
+{}
+
+inline
+sc_ufix::sc_ufix( int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb,
+		  const sc_fxcast_switch& cast_sw,
+		  sc_fxnum_observer* observer_ )
+: sc_fxnum( sc_fxtype_params( wl_, iwl_, qm, om, nb ),
+	    SC_US_,
+	    cast_sw,
+	    observer_ )
+{}
+
+inline
+sc_ufix::sc_ufix( const sc_fxtype_params& type_params,
+		  sc_fxnum_observer* observer_ )
+: sc_fxnum( type_params,
+	    SC_US_,
+	    sc_fxcast_switch(),
+	    observer_ )
+{}
+
+inline
+sc_ufix::sc_ufix( const sc_fxtype_params& type_params,
+		  const sc_fxcast_switch& cast_sw,
+		  sc_fxnum_observer* observer_ )
+: sc_fxnum( type_params,
+	    SC_US_,
+	    cast_sw,
+	    observer_ )
+{}
+
+#define DEFN_CTORS_T_A(tp)                                                    \
+inline                                                                        \
+sc_ufix::sc_ufix( tp a,                                                       \
+		  sc_fxnum_observer* observer_ )                              \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params(),                                               \
+	    SC_US_,                                                           \
+	    sc_fxcast_switch(),                                               \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix::sc_ufix( tp a,                                                       \
+		  int wl_, int iwl_,                                          \
+		  sc_fxnum_observer* observer_ )                              \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( wl_, iwl_ ),                                    \
+	    SC_US_,                                                           \
+	    sc_fxcast_switch(),                                               \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix::sc_ufix( tp a,                                                       \
+		  sc_q_mode qm, sc_o_mode om,                                 \
+		  sc_fxnum_observer* observer_ )                              \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( qm, om ),                                       \
+	    SC_US_,                                                           \
+	    sc_fxcast_switch(),                                               \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix::sc_ufix( tp a,                                                       \
+		  sc_q_mode qm, sc_o_mode om, int nb,                         \
+		  sc_fxnum_observer* observer_ )                              \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( qm, om, nb ),                                   \
+	    SC_US_,                                                           \
+	    sc_fxcast_switch(),                                               \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix::sc_ufix( tp a,                                                       \
+		  int wl_, int iwl_, sc_q_mode qm, sc_o_mode om,              \
+		  sc_fxnum_observer* observer_ )                              \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( wl_, iwl_, qm, om ),                            \
+	    SC_US_,                                                           \
+	    sc_fxcast_switch(),                                               \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix::sc_ufix( tp a,                                                       \
+		  int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb,      \
+		  sc_fxnum_observer* observer_ )                              \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( wl_, iwl_, qm, om, nb ),                        \
+	    SC_US_,                                                           \
+	    sc_fxcast_switch(),                                               \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix::sc_ufix( tp a,                                                       \
+		  const sc_fxcast_switch& cast_sw,                            \
+		  sc_fxnum_observer* observer_ )                              \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params(),                                               \
+	    SC_US_,                                                           \
+	    cast_sw,                                                          \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix::sc_ufix( tp a,                                                       \
+		  int wl_, int iwl_,                                          \
+		  const sc_fxcast_switch& cast_sw,                            \
+		  sc_fxnum_observer* observer_ )                              \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( wl_, iwl_ ),                                    \
+	    SC_US_,                                                           \
+	    cast_sw,                                                          \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix::sc_ufix( tp a,                                                       \
+		  sc_q_mode qm, sc_o_mode om,                                 \
+		  const sc_fxcast_switch& cast_sw,                            \
+		  sc_fxnum_observer* observer_ )                              \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( qm, om ),                                       \
+	    SC_US_,                                                           \
+	    cast_sw,                                                          \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix::sc_ufix( tp a,                                                       \
+		  sc_q_mode qm, sc_o_mode om, int nb,                         \
+		  const sc_fxcast_switch& cast_sw,                            \
+		  sc_fxnum_observer* observer_ )                              \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( qm, om, nb ),                                   \
+	    SC_US_,                                                           \
+	    cast_sw,                                                          \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix::sc_ufix( tp a,                                                       \
+		  int wl_, int iwl_, sc_q_mode qm, sc_o_mode om,              \
+		  const sc_fxcast_switch& cast_sw,                            \
+		  sc_fxnum_observer* observer_ )                              \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( wl_, iwl_, qm, om ),                            \
+	    SC_US_,                                                           \
+	    cast_sw,                                                          \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix::sc_ufix( tp a,                                                       \
+		  int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb,      \
+		  const sc_fxcast_switch& cast_sw,                            \
+		  sc_fxnum_observer* observer_ )                              \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( wl_, iwl_, qm, om, nb ),                        \
+	    SC_US_,                                                           \
+	    cast_sw,                                                          \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix::sc_ufix( tp a,                                                       \
+		  const sc_fxtype_params& type_params,                        \
+		  sc_fxnum_observer* observer_ )                              \
+: sc_fxnum( a,                                                                \
+	    type_params,                                                      \
+	    SC_US_,                                                           \
+	    sc_fxcast_switch(),                                               \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix::sc_ufix( tp a,                                                       \
+		  const sc_fxtype_params& type_params,                        \
+		  const sc_fxcast_switch& cast_sw,                            \
+		  sc_fxnum_observer* observer_ )                              \
+: sc_fxnum( a,                                                                \
+	    type_params,                                                      \
+	    SC_US_,                                                           \
+	    cast_sw,                                                          \
+	    observer_ )                                                       \
+{}
+
+#define DEFN_CTORS_T_B(tp)                                                    \
+inline                                                                        \
+sc_ufix::sc_ufix( tp a,                                                       \
+		  sc_fxnum_observer* observer_ )                              \
+: sc_fxnum( a,                                                                \
+	    a.type_params(),                                                  \
+	    SC_US_,                                                           \
+	    sc_fxcast_switch(),                                               \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix::sc_ufix( tp a,                                                       \
+		  int wl_, int iwl_,                                          \
+		  sc_fxnum_observer* observer_ )                              \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( a.type_params(), wl_, iwl_ ),                   \
+	    SC_US_,                                                           \
+	    sc_fxcast_switch(),                                               \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix::sc_ufix( tp a,                                                       \
+		  sc_q_mode qm, sc_o_mode om,                                 \
+		  sc_fxnum_observer* observer_ )                              \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( a.type_params(), qm, om ),                      \
+	    SC_US_,                                                           \
+	    sc_fxcast_switch(),                                               \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix::sc_ufix( tp a,                                                       \
+		  sc_q_mode qm, sc_o_mode om, int nb,                         \
+		  sc_fxnum_observer* observer_ )                              \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( a.type_params(), qm, om, nb ),                  \
+	    SC_US_,                                                           \
+	    sc_fxcast_switch(),                                               \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix::sc_ufix( tp a,                                                       \
+		  int wl_, int iwl_, sc_q_mode qm, sc_o_mode om,              \
+		  sc_fxnum_observer* observer_ )                              \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( wl_, iwl_, qm, om ),                            \
+	    SC_US_,                                                           \
+	    sc_fxcast_switch(),                                               \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix::sc_ufix( tp a,                                                       \
+		  int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb,      \
+		  sc_fxnum_observer* observer_ )                              \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( wl_, iwl_, qm, om, nb ),                        \
+	    SC_US_,                                                           \
+	    sc_fxcast_switch(),                                               \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix::sc_ufix( tp a,                                                       \
+		  const sc_fxcast_switch& cast_sw,                            \
+		  sc_fxnum_observer* observer_ )                              \
+: sc_fxnum( a,                                                                \
+	    a.type_params(),                                                  \
+	    SC_US_,                                                           \
+	    cast_sw,                                                          \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix::sc_ufix( tp a,                                                       \
+		  int wl_, int iwl_,                                          \
+		  const sc_fxcast_switch& cast_sw,                            \
+		  sc_fxnum_observer* observer_ )                              \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( a.type_params(), wl_, iwl_ ),                   \
+	    SC_US_,                                                           \
+	    cast_sw,                                                          \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix::sc_ufix( tp a,                                                       \
+		  sc_q_mode qm, sc_o_mode om,                                 \
+		  const sc_fxcast_switch& cast_sw,                            \
+		  sc_fxnum_observer* observer_ )                              \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( a.type_params(), qm, om ),                      \
+	    SC_US_,                                                           \
+	    cast_sw,                                                          \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix::sc_ufix( tp a,                                                       \
+		  sc_q_mode qm, sc_o_mode om, int nb,                         \
+		  const sc_fxcast_switch& cast_sw,                            \
+		  sc_fxnum_observer* observer_ )                              \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( a.type_params(), qm, om, nb ),                  \
+	    SC_US_,                                                           \
+	    cast_sw,                                                          \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix::sc_ufix( tp a,                                                       \
+		  int wl_, int iwl_, sc_q_mode qm, sc_o_mode om,              \
+		  const sc_fxcast_switch& cast_sw,                            \
+		  sc_fxnum_observer* observer_ )                              \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( wl_, iwl_, qm, om ),                            \
+	    SC_US_,                                                           \
+	    cast_sw,                                                          \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix::sc_ufix( tp a,                                                       \
+		  int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb,      \
+		  const sc_fxcast_switch& cast_sw,                            \
+		  sc_fxnum_observer* observer_ )                              \
+: sc_fxnum( a,                                                                \
+	    sc_fxtype_params( wl_, iwl_, qm, om, nb ),                        \
+	    SC_US_,                                                           \
+	    cast_sw,                                                          \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix::sc_ufix( tp a,                                                       \
+		  const sc_fxtype_params& type_params,                        \
+		  sc_fxnum_observer* observer_ )                              \
+: sc_fxnum( a,                                                                \
+	    type_params,                                                      \
+	    SC_US_,                                                           \
+	    sc_fxcast_switch(),                                               \
+	    observer_ )                                                       \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix::sc_ufix( tp a,                                                       \
+		  const sc_fxtype_params& type_params,                        \
+		  const sc_fxcast_switch& cast_sw,                            \
+		  sc_fxnum_observer* observer_ )                              \
+: sc_fxnum( a,                                                                \
+	    type_params,                                                      \
+	    SC_US_,                                                           \
+	    cast_sw,                                                          \
+	    observer_ )                                                       \
+{}
+
+DEFN_CTORS_T_A(int)
+DEFN_CTORS_T_A(unsigned int)
+DEFN_CTORS_T_A(long)
+DEFN_CTORS_T_A(unsigned long)
+DEFN_CTORS_T_A(float)
+DEFN_CTORS_T_A(double)
+DEFN_CTORS_T_A(const char*)
+DEFN_CTORS_T_A(const sc_fxval&)
+DEFN_CTORS_T_A(const sc_fxval_fast&)
+DEFN_CTORS_T_B(const sc_fxnum&)
+DEFN_CTORS_T_B(const sc_fxnum_fast&)
+#ifndef SC_FX_EXCLUDE_OTHER
+DEFN_CTORS_T_A(int64)
+DEFN_CTORS_T_A(uint64)
+DEFN_CTORS_T_A(const sc_int_base&)
+DEFN_CTORS_T_A(const sc_uint_base&)
+DEFN_CTORS_T_A(const sc_signed&)
+DEFN_CTORS_T_A(const sc_unsigned&)
+#endif
+
+#undef DEFN_CTORS_T_A
+#undef DEFN_CTORS_T_B
+
+// copy constructor
+
+inline
+sc_ufix::sc_ufix( const sc_ufix& a )
+: sc_fxnum( a,
+	    a.type_params(),
+	    SC_US_,
+	    sc_fxcast_switch(),
+	    0 )
+{}
+
+
+// unary bitwise operators
+
+inline
+const sc_ufix
+sc_ufix::operator ~ () const
+{
+    SC_FXNUM_OBSERVER_READ_( *this )
+    int iwl_c = iwl();
+    int wl_c = wl();
+    sc_ufix c( wl_c, iwl_c );
+    for( int i = iwl_c - wl_c; i < iwl_c; ++ i )
+	c.set_bit( i, ! get_bit( i ) );
+    return sc_ufix( c, wl_c, iwl_c );
+}
+
+
+// unary bitwise functions
+
+inline
+void
+b_not( sc_ufix& c, const sc_ufix& a )
+{
+    SC_FXNUM_OBSERVER_READ_( a )
+    int iwl_c = c.iwl();
+    for( int i = iwl_c - c.wl(); i < iwl_c; ++ i )
+	c.set_bit( i, ! a.get_bit( i ) );
+    c.cast();
+    SC_FXNUM_OBSERVER_WRITE_( c )
+}
+
+
+// binary bitwise operators
+
+#define DEFN_BIN_OP_T(op,op2,tp1,tp2)                                         \
+inline                                                                        \
+const sc_ufix                                                                 \
+operator op ( const tp1& a, const tp2& b )                                    \
+{                                                                             \
+    a.observer_read();                                                        \
+    b.observer_read();                                                        \
+    int iwl_a = a.iwl();                                                      \
+    int iwl_b = b.iwl();                                                      \
+    int iwl_c = sc_max( iwl_a, iwl_b );                                       \
+    int fwl_c = sc_max( a.wl() - iwl_a, b.wl() - iwl_b );                     \
+    sc_ufix c( iwl_c + fwl_c, iwl_c );                                        \
+    for( int i = -fwl_c; i < iwl_c; ++ i )                                    \
+	c.set_bit( i, a.get_bit( i ) op2 b.get_bit( i ) );                    \
+    return sc_ufix( c, iwl_c + fwl_c, iwl_c );                                \
+}
+
+DEFN_BIN_OP_T(&,&&,sc_ufix,sc_ufix)
+DEFN_BIN_OP_T(&,&&,sc_ufix,sc_ufix_fast)
+DEFN_BIN_OP_T(&,&&,sc_ufix_fast,sc_ufix)
+
+DEFN_BIN_OP_T(|,||,sc_ufix,sc_ufix)
+DEFN_BIN_OP_T(|,||,sc_ufix,sc_ufix_fast)
+DEFN_BIN_OP_T(|,||,sc_ufix_fast,sc_ufix)
+
+DEFN_BIN_OP_T(^,!=,sc_ufix,sc_ufix)
+DEFN_BIN_OP_T(^,!=,sc_ufix,sc_ufix_fast)
+DEFN_BIN_OP_T(^,!=,sc_ufix_fast,sc_ufix)
+
+#undef DEFN_BIN_OP_T
+
+
+// binary bitwise functions
+
+#define DEFN_BIN_FNC_T(fnc,op2,tp1,tp2)                                       \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_ufix& c, const tp1& a, const tp2& b )                                \
+{                                                                             \
+    a.observer_read();                                                        \
+    b.observer_read();                                                        \
+    int iwl_c = c.iwl();                                                      \
+    for( int i = iwl_c - c.wl(); i < iwl_c; ++ i )                            \
+	c.set_bit( i, a.get_bit( i ) op2 b.get_bit( i ) );                    \
+    c.cast();                                                                 \
+    SC_FXNUM_OBSERVER_WRITE_( c )                                             \
+}
+
+DEFN_BIN_FNC_T(b_and,&&,sc_ufix,sc_ufix)
+DEFN_BIN_FNC_T(b_and,&&,sc_ufix,sc_ufix_fast)
+DEFN_BIN_FNC_T(b_and,&&,sc_ufix_fast,sc_ufix)
+
+DEFN_BIN_FNC_T(b_or,||,sc_ufix,sc_ufix)
+DEFN_BIN_FNC_T(b_or,||,sc_ufix,sc_ufix_fast)
+DEFN_BIN_FNC_T(b_or,||,sc_ufix_fast,sc_ufix)
+
+DEFN_BIN_FNC_T(b_xor,!=,sc_ufix,sc_ufix)
+DEFN_BIN_FNC_T(b_xor,!=,sc_ufix,sc_ufix_fast)
+DEFN_BIN_FNC_T(b_xor,!=,sc_ufix_fast,sc_ufix)
+
+#undef DEFN_BIN_FNC_T
+
+
+// assignment operators
+
+inline
+sc_ufix&
+sc_ufix::operator = ( const sc_ufix& a )
+{
+    sc_fxnum::operator = ( a );
+    return *this;
+}
+
+#define DEFN_ASN_OP_T(op,tp)                                                  \
+inline                                                                        \
+sc_ufix&                                                                      \
+sc_ufix::operator op ( tp a )                                                 \
+{                                                                             \
+    sc_fxnum::operator op( a );                                               \
+    return *this;                                                             \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_ASN_OP_OTHER(op)                                                 \
+DEFN_ASN_OP_T(op,int64)                                                       \
+DEFN_ASN_OP_T(op,uint64)                                                      \
+DEFN_ASN_OP_T(op,const sc_int_base&)                                          \
+DEFN_ASN_OP_T(op,const sc_uint_base&)                                         \
+DEFN_ASN_OP_T(op,const sc_signed&)                                            \
+DEFN_ASN_OP_T(op,const sc_unsigned&)
+#else
+#define DEFN_ASN_OP_OTHER(op)
+#endif
+
+#define DEFN_ASN_OP(op)                                                       \
+DEFN_ASN_OP_T(op,int)                                                         \
+DEFN_ASN_OP_T(op,unsigned int)                                                \
+DEFN_ASN_OP_T(op,long)                                                        \
+DEFN_ASN_OP_T(op,unsigned long)                                               \
+DEFN_ASN_OP_T(op,float)                                                      \
+DEFN_ASN_OP_T(op,double)                                                      \
+DEFN_ASN_OP_T(op,const char*)                                                 \
+DEFN_ASN_OP_T(op,const sc_fxval&)                                             \
+DEFN_ASN_OP_T(op,const sc_fxval_fast&)                                        \
+DEFN_ASN_OP_T(op,const sc_fxnum&)                                             \
+DEFN_ASN_OP_T(op,const sc_fxnum_fast&)                                        \
+DEFN_ASN_OP_OTHER(op)
+
+DEFN_ASN_OP(=)
+
+DEFN_ASN_OP(*=)
+DEFN_ASN_OP(/=)
+DEFN_ASN_OP(+=)
+DEFN_ASN_OP(-=)
+
+DEFN_ASN_OP_T(<<=,int)
+DEFN_ASN_OP_T(>>=,int)
+
+#undef DEFN_ASN_OP_T
+#undef DEFN_ASN_OP_OTHER
+#undef DEFN_ASN_OP
+
+
+#define DEFN_ASN_OP_T(op,op2,tp)                                              \
+inline                                                                        \
+sc_ufix&                                                                      \
+sc_ufix::operator op ( const tp& b )                                          \
+{                                                                             \
+    SC_FXNUM_OBSERVER_READ_( *this )                                          \
+    b.observer_read();                                                        \
+    int iwl_c = iwl();                                                        \
+    for( int i = iwl_c - wl(); i < iwl_c; ++ i )                              \
+	set_bit( i, get_bit( i ) op2 b.get_bit( i ) );                        \
+    cast();                                                                   \
+    SC_FXNUM_OBSERVER_WRITE_( *this )                                         \
+    return *this;                                                             \
+}
+
+DEFN_ASN_OP_T(&=,&&,sc_ufix)
+DEFN_ASN_OP_T(&=,&&,sc_ufix_fast)
+DEFN_ASN_OP_T(|=,||,sc_ufix)
+DEFN_ASN_OP_T(|=,||,sc_ufix_fast)
+DEFN_ASN_OP_T(^=,!=,sc_ufix)
+DEFN_ASN_OP_T(^=,!=,sc_ufix_fast)
+
+#undef DEFN_ASN_OP_T
+
+
+// auto-increment and auto-decrement
+
+inline
+const sc_fxval
+sc_ufix::operator ++ ( int )
+{
+    return sc_fxval( sc_fxnum::operator ++ ( 0 ) );
+}
+
+inline
+const sc_fxval
+sc_ufix::operator -- ( int )
+{
+    return sc_fxval( sc_fxnum::operator -- ( 0 ) );
+}
+
+inline
+sc_ufix&
+sc_ufix::operator ++ ()
+{
+    sc_fxnum::operator ++ ();
+    return *this;
+}
+
+inline
+sc_ufix&
+sc_ufix::operator -- ()
+{
+    sc_fxnum::operator -- ();
+    return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_ufix_fast
+//
+//  "Unconstrained" unsigned fixed-point class; limited precision.
+// ----------------------------------------------------------------------------
+
+// constructors
+
+inline
+sc_ufix_fast::sc_ufix_fast( sc_fxnum_fast_observer* observer_ )
+: sc_fxnum_fast( sc_fxtype_params(),
+		 SC_US_,
+		 sc_fxcast_switch(),
+		 observer_ )
+{}
+
+inline
+sc_ufix_fast::sc_ufix_fast( int wl_, int iwl_,
+			    sc_fxnum_fast_observer* observer_ )
+: sc_fxnum_fast( sc_fxtype_params( wl_, iwl_ ),
+		 SC_US_,
+		 sc_fxcast_switch(),
+		 observer_ )
+{}
+
+inline
+sc_ufix_fast::sc_ufix_fast( sc_q_mode qm, sc_o_mode om,
+			    sc_fxnum_fast_observer* observer_ )
+: sc_fxnum_fast( sc_fxtype_params( qm, om ),
+		 SC_US_,
+		 sc_fxcast_switch(),
+		 observer_ )
+{}
+
+inline
+sc_ufix_fast::sc_ufix_fast( sc_q_mode qm, sc_o_mode om, int nb,
+			    sc_fxnum_fast_observer* observer_ )
+: sc_fxnum_fast( sc_fxtype_params( qm, om, nb ),
+		 SC_US_,
+		 sc_fxcast_switch(),
+		 observer_ )
+{}
+
+inline
+sc_ufix_fast::sc_ufix_fast( int wl_, int iwl_, sc_q_mode qm, sc_o_mode om,
+			    sc_fxnum_fast_observer* observer_ )
+: sc_fxnum_fast( sc_fxtype_params( wl_, iwl_, qm, om ),
+		 SC_US_,
+		 sc_fxcast_switch(),
+		 observer_ )
+{}
+
+inline
+sc_ufix_fast::sc_ufix_fast( int wl_, int iwl_,
+			    sc_q_mode qm, sc_o_mode om, int nb,
+			    sc_fxnum_fast_observer* observer_ )
+: sc_fxnum_fast( sc_fxtype_params( wl_, iwl_, qm, om, nb ),
+		 SC_US_,
+		 sc_fxcast_switch(),
+		 observer_ )
+{}
+
+inline
+sc_ufix_fast::sc_ufix_fast( const sc_fxcast_switch& cast_sw,
+			    sc_fxnum_fast_observer* observer_ )
+: sc_fxnum_fast( sc_fxtype_params(),
+		 SC_US_,
+		 cast_sw,
+		 observer_ )
+{}
+
+inline
+sc_ufix_fast::sc_ufix_fast( int wl_, int iwl_,
+			    const sc_fxcast_switch& cast_sw,
+			    sc_fxnum_fast_observer* observer_ )
+: sc_fxnum_fast( sc_fxtype_params( wl_, iwl_ ),
+		 SC_US_,
+		 cast_sw,
+		 observer_ )
+{}
+
+inline
+sc_ufix_fast::sc_ufix_fast( sc_q_mode qm, sc_o_mode om,
+			    const sc_fxcast_switch& cast_sw,
+			    sc_fxnum_fast_observer* observer_ )
+: sc_fxnum_fast( sc_fxtype_params( qm, om ),
+		 SC_US_,
+		 cast_sw,
+		 observer_ )
+{}
+
+inline
+sc_ufix_fast::sc_ufix_fast( sc_q_mode qm, sc_o_mode om, int nb,
+			    const sc_fxcast_switch& cast_sw,
+			    sc_fxnum_fast_observer* observer_ )
+: sc_fxnum_fast( sc_fxtype_params( qm, om, nb ),
+		 SC_US_,
+		 cast_sw,
+		 observer_ )
+{}
+
+inline
+sc_ufix_fast::sc_ufix_fast( int wl_, int iwl_, sc_q_mode qm, sc_o_mode om,
+			    const sc_fxcast_switch& cast_sw,
+			    sc_fxnum_fast_observer* observer_ )
+: sc_fxnum_fast( sc_fxtype_params( wl_, iwl_, qm, om ),
+		 SC_US_,
+		 cast_sw,
+		 observer_ )
+{}
+
+inline
+sc_ufix_fast::sc_ufix_fast( int wl_, int iwl_,
+			    sc_q_mode qm, sc_o_mode om, int nb,
+			    const sc_fxcast_switch& cast_sw,
+			    sc_fxnum_fast_observer* observer_ )
+: sc_fxnum_fast( sc_fxtype_params( wl_, iwl_, qm, om, nb ),
+		 SC_US_,
+		 cast_sw,
+		 observer_ )
+{}
+
+inline
+sc_ufix_fast::sc_ufix_fast( const sc_fxtype_params& type_params,
+			    sc_fxnum_fast_observer* observer_ )
+: sc_fxnum_fast( type_params,
+		 SC_US_,
+		 sc_fxcast_switch(),
+		 observer_ )
+{}
+
+inline
+sc_ufix_fast::sc_ufix_fast( const sc_fxtype_params& type_params,
+			    const sc_fxcast_switch& cast_sw,
+			    sc_fxnum_fast_observer* observer_ )
+: sc_fxnum_fast( type_params,
+		 SC_US_,
+		 cast_sw,
+		 observer_ )
+{}
+
+#define DEFN_CTORS_T_A(tp)                                                    \
+inline                                                                        \
+sc_ufix_fast::sc_ufix_fast( tp a,                                             \
+			    sc_fxnum_fast_observer* observer_ )               \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params(),                                          \
+		 SC_US_,                                                      \
+		 sc_fxcast_switch(),                                          \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix_fast::sc_ufix_fast( tp a,                                             \
+			    int wl_, int iwl_,                                \
+			    sc_fxnum_fast_observer* observer_ )               \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( wl_, iwl_ ),                               \
+		 SC_US_,                                                      \
+		 sc_fxcast_switch(),                                          \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix_fast::sc_ufix_fast( tp a,                                             \
+			    sc_q_mode qm, sc_o_mode om,                       \
+			    sc_fxnum_fast_observer* observer_ )               \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( qm, om ),                                  \
+		 SC_US_,                                                      \
+		 sc_fxcast_switch(),                                          \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix_fast::sc_ufix_fast( tp a,                                             \
+			    sc_q_mode qm, sc_o_mode om, int nb,               \
+			    sc_fxnum_fast_observer* observer_ )               \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( qm, om, nb ),                              \
+		 SC_US_,                                                      \
+		 sc_fxcast_switch(),                                          \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix_fast::sc_ufix_fast( tp a,                                             \
+			    int wl_, int iwl_, sc_q_mode qm, sc_o_mode om,    \
+			    sc_fxnum_fast_observer* observer_ )               \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( wl_, iwl_, qm, om ),                       \
+		 SC_US_,                                                      \
+		 sc_fxcast_switch(),                                          \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix_fast::sc_ufix_fast( tp a,                                             \
+			    int wl_, int iwl_,                                \
+			    sc_q_mode qm, sc_o_mode om, int nb,               \
+			    sc_fxnum_fast_observer* observer_ )               \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( wl_, iwl_, qm, om, nb ),                   \
+		 SC_US_,                                                      \
+		 sc_fxcast_switch(),                                          \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix_fast::sc_ufix_fast( tp a,                                             \
+			    const sc_fxcast_switch& cast_sw,                  \
+			    sc_fxnum_fast_observer* observer_ )               \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params(),                                          \
+		 SC_US_,                                                      \
+		 cast_sw,                                                     \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix_fast::sc_ufix_fast( tp a,                                             \
+			    int wl_, int iwl_,                                \
+			    const sc_fxcast_switch& cast_sw,                  \
+			    sc_fxnum_fast_observer* observer_ )               \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( wl_, iwl_ ),                               \
+		 SC_US_,                                                      \
+		 cast_sw,                                                     \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix_fast::sc_ufix_fast( tp a,                                             \
+			    sc_q_mode qm, sc_o_mode om,                       \
+			    const sc_fxcast_switch& cast_sw,                  \
+			    sc_fxnum_fast_observer* observer_ )               \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( qm, om ),                                  \
+		 SC_US_,                                                      \
+		 cast_sw,                                                     \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix_fast::sc_ufix_fast( tp a,                                             \
+			    sc_q_mode qm, sc_o_mode om, int nb,               \
+			    const sc_fxcast_switch& cast_sw,                  \
+			    sc_fxnum_fast_observer* observer_ )               \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( qm, om, nb ),                              \
+		 SC_US_,                                                      \
+		 cast_sw,                                                     \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix_fast::sc_ufix_fast( tp a,                                             \
+			    int wl_, int iwl_, sc_q_mode qm, sc_o_mode om,    \
+			    const sc_fxcast_switch& cast_sw,                  \
+			    sc_fxnum_fast_observer* observer_ )               \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( wl_, iwl_, qm, om ),                       \
+		 SC_US_,                                                      \
+		 cast_sw,                                                     \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix_fast::sc_ufix_fast( tp a,                                             \
+			    int wl_, int iwl_,                                \
+			    sc_q_mode qm, sc_o_mode om, int nb,               \
+			    const sc_fxcast_switch& cast_sw,                  \
+			    sc_fxnum_fast_observer* observer_ )               \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( wl_, iwl_, qm, om, nb ),                   \
+		 SC_US_,                                                      \
+		 cast_sw,                                                     \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix_fast::sc_ufix_fast( tp a,                                             \
+			    const sc_fxtype_params& type_params,              \
+			    sc_fxnum_fast_observer* observer_ )               \
+: sc_fxnum_fast( a,                                                           \
+		 type_params,                                                 \
+		 SC_US_,                                                      \
+		 sc_fxcast_switch(),                                          \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix_fast::sc_ufix_fast( tp a,                                             \
+			    const sc_fxtype_params& type_params,              \
+			    const sc_fxcast_switch& cast_sw,                  \
+			    sc_fxnum_fast_observer* observer_ )               \
+: sc_fxnum_fast( a,                                                           \
+		 type_params,                                                 \
+		 SC_US_,                                                      \
+		 cast_sw,                                                     \
+		 observer_ )                                                  \
+{}
+
+#define DEFN_CTORS_T_B(tp)                                                    \
+inline                                                                        \
+sc_ufix_fast::sc_ufix_fast( tp a,                                             \
+			    sc_fxnum_fast_observer* observer_ )               \
+: sc_fxnum_fast( a,                                                           \
+		 a.type_params(),                                             \
+		 SC_US_,                                                      \
+		 sc_fxcast_switch(),                                          \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix_fast::sc_ufix_fast( tp a,                                             \
+			    int wl_, int iwl_,                                \
+			    sc_fxnum_fast_observer* observer_ )               \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( a.type_params(), wl_, iwl_ ),              \
+		 SC_US_,                                                      \
+		 sc_fxcast_switch(),                                          \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix_fast::sc_ufix_fast( tp a,                                             \
+			    sc_q_mode qm, sc_o_mode om,                       \
+			    sc_fxnum_fast_observer* observer_ )               \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( a.type_params(), qm, om ),                 \
+		 SC_US_,                                                      \
+		 sc_fxcast_switch(),                                          \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix_fast::sc_ufix_fast( tp a,                                             \
+			    sc_q_mode qm, sc_o_mode om, int nb,               \
+			    sc_fxnum_fast_observer* observer_ )               \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( a.type_params(), qm, om, nb ),             \
+		 SC_US_,                                                      \
+		 sc_fxcast_switch(),                                          \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix_fast::sc_ufix_fast( tp a,                                             \
+			    int wl_, int iwl_, sc_q_mode qm, sc_o_mode om,    \
+			    sc_fxnum_fast_observer* observer_ )               \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( wl_, iwl_, qm, om ),                       \
+		 SC_US_,                                                      \
+		 sc_fxcast_switch(),                                          \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix_fast::sc_ufix_fast( tp a,                                             \
+			    int wl_, int iwl_,                                \
+			    sc_q_mode qm, sc_o_mode om, int nb,               \
+			    sc_fxnum_fast_observer* observer_ )               \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( wl_, iwl_, qm, om, nb ),                   \
+		 SC_US_,                                                      \
+		 sc_fxcast_switch(),                                          \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix_fast::sc_ufix_fast( tp a,                                             \
+			    const sc_fxcast_switch& cast_sw,                  \
+			    sc_fxnum_fast_observer* observer_ )               \
+: sc_fxnum_fast( a,                                                           \
+		 a.type_params(),                                             \
+		 SC_US_,                                                      \
+		 cast_sw,                                                     \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix_fast::sc_ufix_fast( tp a,                                             \
+			    int wl_, int iwl_,                                \
+			    const sc_fxcast_switch& cast_sw,                  \
+			    sc_fxnum_fast_observer* observer_ )               \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( a.type_params(), wl_, iwl_ ),              \
+		 SC_US_,                                                      \
+		 cast_sw,                                                     \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix_fast::sc_ufix_fast( tp a,                                             \
+			    sc_q_mode qm, sc_o_mode om,                       \
+			    const sc_fxcast_switch& cast_sw,                  \
+			    sc_fxnum_fast_observer* observer_ )               \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( a.type_params(), qm, om ),                 \
+		 SC_US_,                                                      \
+		 cast_sw,                                                     \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix_fast::sc_ufix_fast( tp a,                                             \
+			    sc_q_mode qm, sc_o_mode om, int nb,               \
+			    const sc_fxcast_switch& cast_sw,                  \
+			    sc_fxnum_fast_observer* observer_ )               \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( a.type_params(), qm, om, nb ),             \
+		 SC_US_,                                                      \
+		 cast_sw,                                                     \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix_fast::sc_ufix_fast( tp a,                                             \
+			    int wl_, int iwl_, sc_q_mode qm, sc_o_mode om,    \
+			    const sc_fxcast_switch& cast_sw,                  \
+			    sc_fxnum_fast_observer* observer_ )               \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( wl_, iwl_, qm, om ),                       \
+		 SC_US_,                                                      \
+		 cast_sw,                                                     \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix_fast::sc_ufix_fast( tp a,                                             \
+			    int wl_, int iwl_,                                \
+			    sc_q_mode qm, sc_o_mode om, int nb,               \
+			    const sc_fxcast_switch& cast_sw,                  \
+			    sc_fxnum_fast_observer* observer_ )               \
+: sc_fxnum_fast( a,                                                           \
+		 sc_fxtype_params( wl_, iwl_, qm, om, nb ),                   \
+		 SC_US_,                                                      \
+		 cast_sw,                                                     \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix_fast::sc_ufix_fast( tp a,                                             \
+			    const sc_fxtype_params& type_params,              \
+			    sc_fxnum_fast_observer* observer_ )               \
+: sc_fxnum_fast( a,                                                           \
+		 type_params,                                                 \
+		 SC_US_,                                                      \
+		 sc_fxcast_switch(),                                          \
+		 observer_ )                                                  \
+{}                                                                            \
+                                                                              \
+inline                                                                        \
+sc_ufix_fast::sc_ufix_fast( tp a,                                             \
+			    const sc_fxtype_params& type_params,              \
+			    const sc_fxcast_switch& cast_sw,                  \
+			    sc_fxnum_fast_observer* observer_ )               \
+: sc_fxnum_fast( a,                                                           \
+		 type_params,                                                 \
+		 SC_US_,                                                      \
+		 cast_sw,                                                     \
+		 observer_ )                                                  \
+{}
+
+DEFN_CTORS_T_A(int)
+DEFN_CTORS_T_A(unsigned int)
+DEFN_CTORS_T_A(long)
+DEFN_CTORS_T_A(unsigned long)
+DEFN_CTORS_T_A(float)
+DEFN_CTORS_T_A(double)
+DEFN_CTORS_T_A(const char*)
+DEFN_CTORS_T_A(const sc_fxval&)
+DEFN_CTORS_T_A(const sc_fxval_fast&)
+DEFN_CTORS_T_B(const sc_fxnum&)
+DEFN_CTORS_T_B(const sc_fxnum_fast&)
+#ifndef SC_FX_EXCLUDE_OTHER
+DEFN_CTORS_T_A(int64)
+DEFN_CTORS_T_A(uint64)
+DEFN_CTORS_T_A(const sc_int_base&)
+DEFN_CTORS_T_A(const sc_uint_base&)
+DEFN_CTORS_T_A(const sc_signed&)
+DEFN_CTORS_T_A(const sc_unsigned&)
+#endif
+
+#undef DEFN_CTORS_T_A
+#undef DEFN_CTORS_T_B
+
+// copy constructor
+
+inline
+sc_ufix_fast::sc_ufix_fast( const sc_ufix_fast& a )
+: sc_fxnum_fast( a,
+		 a.type_params(),
+		 SC_US_,
+		 sc_fxcast_switch(),
+		 0 )
+{}
+
+
+// unary bitwise operators
+
+inline
+const sc_ufix_fast
+sc_ufix_fast::operator ~ () const
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )
+    int iwl_c = iwl();
+    int wl_c = wl();
+    sc_ufix_fast c( wl_c, iwl_c );
+    for( int i = iwl_c - wl_c; i < iwl_c; ++ i )
+	c.set_bit( i, ! get_bit( i ) );
+    return sc_ufix_fast( c, wl_c, iwl_c );
+}
+
+
+// unary bitwise functions
+
+inline
+void
+b_not( sc_ufix_fast& c, const sc_ufix_fast& a )
+{
+    SC_FXNUM_FAST_OBSERVER_READ_( a )
+    int iwl_c = c.iwl();
+    for( int i = iwl_c - c.wl(); i < iwl_c; ++ i )
+	c.set_bit( i, ! a.get_bit( i ) );
+    c.cast();
+    SC_FXNUM_FAST_OBSERVER_WRITE_( c )
+}
+
+
+// binary bitwise operators
+
+#define DEFN_BIN_OP_T(op,op2,tp1,tp2)                                         \
+inline                                                                        \
+const sc_ufix_fast                                                            \
+operator op ( const tp1& a, const tp2& b )                                    \
+{                                                                             \
+    a.observer_read();                                                        \
+    b.observer_read();                                                        \
+    int iwl_a = a.iwl();                                                      \
+    int iwl_b = b.iwl();                                                      \
+    int iwl_c = sc_max( iwl_a, iwl_b );                                       \
+    int fwl_c = sc_max( a.wl() - iwl_a, b.wl() - iwl_b );                     \
+    sc_ufix_fast c( iwl_c + fwl_c, iwl_c );                                   \
+    for( int i = -fwl_c; i < iwl_c; ++ i )                                    \
+	c.set_bit( i, a.get_bit( i ) op2 b.get_bit( i ) );                    \
+    return sc_ufix_fast( c, iwl_c + fwl_c, iwl_c );                           \
+}
+
+DEFN_BIN_OP_T(&,&&,sc_ufix_fast,sc_ufix_fast)
+DEFN_BIN_OP_T(|,||,sc_ufix_fast,sc_ufix_fast)
+DEFN_BIN_OP_T(^,!=,sc_ufix_fast,sc_ufix_fast)
+
+#undef DEFN_BIN_OP_T
+
+
+// binary bitwise functions
+
+#define DEFN_BIN_FNC_T(fnc,op2,tp1,tp2)                                       \
+inline                                                                        \
+void                                                                          \
+fnc ( sc_ufix_fast& c, const tp1& a, const tp2& b )                           \
+{                                                                             \
+    a.observer_read();                                                        \
+    b.observer_read();                                                        \
+    int iwl_c = c.iwl();                                                      \
+    for( int i = iwl_c - c.wl(); i < iwl_c; ++ i )                            \
+	c.set_bit( i, a.get_bit( i ) op2 b.get_bit( i ) );                    \
+    c.cast();                                                                 \
+    SC_FXNUM_FAST_OBSERVER_WRITE_( c )                                        \
+}
+
+DEFN_BIN_FNC_T(b_and,&&,sc_ufix_fast,sc_ufix_fast)
+DEFN_BIN_FNC_T(b_or,||,sc_ufix_fast,sc_ufix_fast)
+DEFN_BIN_FNC_T(b_xor,!=,sc_ufix_fast,sc_ufix_fast)
+
+#undef DEFN_BIN_FNC_T
+
+
+// assignment operators
+
+inline
+sc_ufix_fast&
+sc_ufix_fast::operator = ( const sc_ufix_fast& a )
+{
+    sc_fxnum_fast::operator = ( a );
+    return *this;
+}
+
+#define DEFN_ASN_OP_T(op,tp)                                                  \
+inline                                                                        \
+sc_ufix_fast&                                                                 \
+sc_ufix_fast::operator op ( tp a )                                            \
+{                                                                             \
+    sc_fxnum_fast::operator op( a );                                          \
+    return *this;                                                             \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_ASN_OP_OTHER(op)                                                 \
+DEFN_ASN_OP_T(op,int64)                                                       \
+DEFN_ASN_OP_T(op,uint64)                                                      \
+DEFN_ASN_OP_T(op,const sc_int_base&)                                          \
+DEFN_ASN_OP_T(op,const sc_uint_base&)                                         \
+DEFN_ASN_OP_T(op,const sc_signed&)                                            \
+DEFN_ASN_OP_T(op,const sc_unsigned&)
+#else
+#define DEFN_ASN_OP_OTHER(op)
+#endif
+
+#define DEFN_ASN_OP(op)                                                       \
+DEFN_ASN_OP_T(op,int)                                                         \
+DEFN_ASN_OP_T(op,unsigned int)                                                \
+DEFN_ASN_OP_T(op,long)                                                        \
+DEFN_ASN_OP_T(op,unsigned long)                                               \
+DEFN_ASN_OP_T(op,float)                                                      \
+DEFN_ASN_OP_T(op,double)                                                      \
+DEFN_ASN_OP_T(op,const char*)                                                 \
+DEFN_ASN_OP_T(op,const sc_fxval&)                                             \
+DEFN_ASN_OP_T(op,const sc_fxval_fast&)                                        \
+DEFN_ASN_OP_T(op,const sc_fxnum&)                                             \
+DEFN_ASN_OP_T(op,const sc_fxnum_fast&)                                        \
+DEFN_ASN_OP_OTHER(op)
+
+DEFN_ASN_OP(=)
+
+DEFN_ASN_OP(*=)
+DEFN_ASN_OP(/=)
+DEFN_ASN_OP(+=)
+DEFN_ASN_OP(-=)
+
+DEFN_ASN_OP_T(<<=,int)
+DEFN_ASN_OP_T(>>=,int)
+
+#undef DEFN_ASN_OP_T
+#undef DEFN_ASN_OP_OTHER
+#undef DEFN_ASN_OP
+
+
+#define DEFN_ASN_OP_T(op,op2,tp)                                              \
+inline                                                                        \
+sc_ufix_fast&                                                                 \
+sc_ufix_fast::operator op ( const tp& b )                                     \
+{                                                                             \
+    SC_FXNUM_FAST_OBSERVER_READ_( *this )                                     \
+    b.observer_read();                                                        \
+    int iwl_c = iwl();                                                        \
+    for( int i = iwl_c - wl(); i < iwl_c; ++ i )                              \
+	set_bit( i, get_bit( i ) op2 b.get_bit( i ) );                        \
+    cast();                                                                   \
+    SC_FXNUM_FAST_OBSERVER_WRITE_( *this )                                    \
+    return *this;                                                             \
+}
+
+DEFN_ASN_OP_T(&=,&&,sc_ufix)
+DEFN_ASN_OP_T(&=,&&,sc_ufix_fast)
+DEFN_ASN_OP_T(|=,||,sc_ufix)
+DEFN_ASN_OP_T(|=,||,sc_ufix_fast)
+DEFN_ASN_OP_T(^=,!=,sc_ufix)
+DEFN_ASN_OP_T(^=,!=,sc_ufix_fast)
+
+#undef DEFN_ASN_OP_T
+
+
+// auto-increment and auto-decrement
+
+inline
+const sc_fxval_fast
+sc_ufix_fast::operator ++ ( int )
+{
+    return sc_fxval_fast( sc_fxnum_fast::operator ++ ( 0 ) );
+}
+
+inline
+const sc_fxval_fast
+sc_ufix_fast::operator -- ( int )
+{
+    return sc_fxval_fast( sc_fxnum_fast::operator -- ( 0 ) );
+}
+
+inline
+sc_ufix_fast&
+sc_ufix_fast::operator ++ ()
+{
+    sc_fxnum_fast::operator ++ ();
+    return *this;
+}
+
+inline
+sc_ufix_fast&
+sc_ufix_fast::operator -- ()
+{
+    sc_fxnum_fast::operator -- ();
+    return *this;
+}
+
+} // namespace sc_dt
+
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/sc_ufixed.h b/ext/systemc/src/sysc/datatypes/fx/sc_ufixed.h
new file mode 100644
index 000000000..266e4b7bb
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/sc_ufixed.h
@@ -0,0 +1,660 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_ufixed.h - 
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_ufixed.h,v $
+// Revision 1.2  2011/01/19 18:57:40  acg
+//  Andy Goodrich: changes for IEEE_1666_2011.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SC_UFIXED_H
+#define SC_UFIXED_H
+
+
+#include "sysc/datatypes/fx/sc_ufix.h"
+
+
+namespace sc_dt
+{
+
+// classes defined in this module
+template <int W, int I, sc_q_mode Q, sc_o_mode O, int N> class sc_ufixed;
+template <int W, int I, sc_q_mode Q, sc_o_mode O, int N> class sc_ufixed_fast;
+
+
+// ----------------------------------------------------------------------------
+//  TEMPLATE CLASS : sc_ufixed
+//
+//  "Constrained" unsigned fixed-point class; arbitrary precision.
+// ----------------------------------------------------------------------------
+
+template <int W, int I,
+	  sc_q_mode Q = SC_DEFAULT_Q_MODE_,
+	  sc_o_mode O = SC_DEFAULT_O_MODE_, int N = SC_DEFAULT_N_BITS_>
+class sc_ufixed : public sc_ufix
+{
+
+public:
+
+    // constructors
+
+    explicit sc_ufixed( sc_fxnum_observer* = 0 );
+    explicit sc_ufixed( const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
+
+#define DECL_CTORS_T_A(tp)                                                    \
+             sc_ufixed( tp, sc_fxnum_observer* = 0 );                         \
+             sc_ufixed( tp, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
+
+#define DECL_CTORS_T_B(tp)                                                    \
+    explicit sc_ufixed( tp, sc_fxnum_observer* = 0 );                         \
+             sc_ufixed( tp, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
+
+    DECL_CTORS_T_A(int)
+    DECL_CTORS_T_A(unsigned int)
+    DECL_CTORS_T_A(long)
+    DECL_CTORS_T_A(unsigned long)
+    DECL_CTORS_T_A(float)
+    DECL_CTORS_T_A(double)
+    DECL_CTORS_T_A(const char*)
+    DECL_CTORS_T_A(const sc_fxval&)
+    DECL_CTORS_T_A(const sc_fxval_fast&)
+    DECL_CTORS_T_A(const sc_fxnum&)
+    DECL_CTORS_T_A(const sc_fxnum_fast&)
+#ifndef SC_FX_EXCLUDE_OTHER
+    DECL_CTORS_T_B(int64)
+    DECL_CTORS_T_B(uint64)
+    DECL_CTORS_T_B(const sc_int_base&)
+    DECL_CTORS_T_B(const sc_uint_base&)
+    DECL_CTORS_T_B(const sc_signed&)
+    DECL_CTORS_T_B(const sc_unsigned&)
+#endif
+
+#undef DECL_CTORS_T_A
+#undef DECL_CTORS_T_B
+
+    // copy constructor
+
+    sc_ufixed( const sc_ufixed<W,I,Q,O,N>& );
+
+
+    // assignment operators
+
+    sc_ufixed& operator = ( const sc_ufixed<W,I,Q,O,N>& );
+
+#define DECL_ASN_OP_T(op,tp)                                                  \
+    sc_ufixed& operator op ( tp );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_ASN_OP_OTHER(op)                                                 \
+    DECL_ASN_OP_T(op,int64)                                                   \
+    DECL_ASN_OP_T(op,uint64)                                                  \
+    DECL_ASN_OP_T(op,const sc_int_base&)                                      \
+    DECL_ASN_OP_T(op,const sc_uint_base&)                                     \
+    DECL_ASN_OP_T(op,const sc_signed&)                                        \
+    DECL_ASN_OP_T(op,const sc_unsigned&)
+#else
+#define DECL_ASN_OP_OTHER(op)
+#endif
+
+#define DECL_ASN_OP(op)                                                       \
+    DECL_ASN_OP_T(op,int)                                                     \
+    DECL_ASN_OP_T(op,unsigned int)                                            \
+    DECL_ASN_OP_T(op,long)                                                    \
+    DECL_ASN_OP_T(op,unsigned long)                                           \
+    DECL_ASN_OP_T(op,float)                                                  \
+    DECL_ASN_OP_T(op,double)                                                  \
+    DECL_ASN_OP_T(op,const char*)                                             \
+    DECL_ASN_OP_T(op,const sc_fxval&)                                         \
+    DECL_ASN_OP_T(op,const sc_fxval_fast&)                                    \
+    DECL_ASN_OP_T(op,const sc_fxnum&)                                         \
+    DECL_ASN_OP_T(op,const sc_fxnum_fast&)                                    \
+    DECL_ASN_OP_OTHER(op)
+
+    DECL_ASN_OP(=)
+
+    DECL_ASN_OP(*=)
+    DECL_ASN_OP(/=)
+    DECL_ASN_OP(+=)
+    DECL_ASN_OP(-=)
+
+    DECL_ASN_OP_T(<<=,int)
+    DECL_ASN_OP_T(>>=,int)
+
+    DECL_ASN_OP_T(&=,const sc_ufix&)
+    DECL_ASN_OP_T(&=,const sc_ufix_fast&)
+    DECL_ASN_OP_T(|=,const sc_ufix&)
+    DECL_ASN_OP_T(|=,const sc_ufix_fast&)
+    DECL_ASN_OP_T(^=,const sc_ufix&)
+    DECL_ASN_OP_T(^=,const sc_ufix_fast&)
+
+#undef DECL_ASN_OP_T
+#undef DECL_ASN_OP_OTHER
+#undef DECL_ASN_OP
+
+
+    // auto-increment and auto-decrement
+
+    const sc_fxval operator ++ ( int );
+    const sc_fxval operator -- ( int );
+
+    sc_ufixed& operator ++ ();
+    sc_ufixed& operator -- ();
+
+};
+
+
+// ----------------------------------------------------------------------------
+//  TEMPLATE CLASS : sc_ufixed_fast
+//
+//  "Constrained" unsigned fixed-point class; limited precision.
+// ----------------------------------------------------------------------------
+
+template <int W, int I,
+	  sc_q_mode Q = SC_DEFAULT_Q_MODE_,
+	  sc_o_mode O = SC_DEFAULT_O_MODE_, int N = SC_DEFAULT_N_BITS_>
+class sc_ufixed_fast : public sc_ufix_fast
+{
+
+public:
+
+    // constructors
+
+    explicit sc_ufixed_fast( sc_fxnum_fast_observer* = 0 );
+    explicit sc_ufixed_fast( const sc_fxcast_switch&,
+			     sc_fxnum_fast_observer* = 0 );
+
+#define DECL_CTORS_T_A(tp)                                                    \
+             sc_ufixed_fast( tp, sc_fxnum_fast_observer* = 0 );               \
+             sc_ufixed_fast( tp, const sc_fxcast_switch&,                     \
+                             sc_fxnum_fast_observer* = 0 );
+
+#define DECL_CTORS_T_B(tp)                                                    \
+    explicit sc_ufixed_fast( tp, sc_fxnum_fast_observer* = 0 );               \
+             sc_ufixed_fast( tp, const sc_fxcast_switch&,                     \
+			     sc_fxnum_fast_observer* = 0 );
+
+    DECL_CTORS_T_A(int)
+    DECL_CTORS_T_A(unsigned int)
+    DECL_CTORS_T_A(long)
+    DECL_CTORS_T_A(unsigned long)
+    DECL_CTORS_T_A(float)
+    DECL_CTORS_T_A(double)
+    DECL_CTORS_T_A(const char*)
+    DECL_CTORS_T_A(const sc_fxval&)
+    DECL_CTORS_T_A(const sc_fxval_fast&)
+    DECL_CTORS_T_A(const sc_fxnum&)
+    DECL_CTORS_T_A(const sc_fxnum_fast&)
+#ifndef SC_FX_EXCLUDE_OTHER
+    DECL_CTORS_T_B(int64)
+    DECL_CTORS_T_B(uint64)
+    DECL_CTORS_T_B(const sc_int_base&)
+    DECL_CTORS_T_B(const sc_uint_base&)
+    DECL_CTORS_T_B(const sc_signed&)
+    DECL_CTORS_T_B(const sc_unsigned&)
+#endif
+
+#undef DECL_CTORS_T_A
+#undef DECL_CTORS_T_B
+
+    // copy constructor
+
+    sc_ufixed_fast( const sc_ufixed_fast<W,I,Q,O,N>& );
+
+
+    // assignment operators
+
+    sc_ufixed_fast& operator = ( const sc_ufixed_fast<W,I,Q,O,N>& );
+
+#define DECL_ASN_OP_T(op,tp)                                                  \
+    sc_ufixed_fast& operator op ( tp );
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DECL_ASN_OP_OTHER(op)                                                 \
+    DECL_ASN_OP_T(op,int64)                                                   \
+    DECL_ASN_OP_T(op,uint64)                                                  \
+    DECL_ASN_OP_T(op,const sc_int_base&)                                      \
+    DECL_ASN_OP_T(op,const sc_uint_base&)                                     \
+    DECL_ASN_OP_T(op,const sc_signed&)                                        \
+    DECL_ASN_OP_T(op,const sc_unsigned&)
+#else
+#define DECL_ASN_OP_OTHER(op)
+#endif
+
+#define DECL_ASN_OP(op)                                                       \
+    DECL_ASN_OP_T(op,int)                                                     \
+    DECL_ASN_OP_T(op,unsigned int)                                            \
+    DECL_ASN_OP_T(op,long)                                                    \
+    DECL_ASN_OP_T(op,unsigned long)                                           \
+    DECL_ASN_OP_T(op,float)                                                  \
+    DECL_ASN_OP_T(op,double)                                                  \
+    DECL_ASN_OP_T(op,const char*)                                             \
+    DECL_ASN_OP_T(op,const sc_fxval&)                                         \
+    DECL_ASN_OP_T(op,const sc_fxval_fast&)                                    \
+    DECL_ASN_OP_T(op,const sc_fxnum&)                                         \
+    DECL_ASN_OP_T(op,const sc_fxnum_fast&)                                    \
+    DECL_ASN_OP_OTHER(op)
+
+    DECL_ASN_OP(=)
+
+    DECL_ASN_OP(*=)
+    DECL_ASN_OP(/=)
+    DECL_ASN_OP(+=)
+    DECL_ASN_OP(-=)
+
+    DECL_ASN_OP_T(<<=,int)
+    DECL_ASN_OP_T(>>=,int)
+
+    DECL_ASN_OP_T(&=,const sc_ufix&)
+    DECL_ASN_OP_T(&=,const sc_ufix_fast&)
+    DECL_ASN_OP_T(|=,const sc_ufix&)
+    DECL_ASN_OP_T(|=,const sc_ufix_fast&)
+    DECL_ASN_OP_T(^=,const sc_ufix&)
+    DECL_ASN_OP_T(^=,const sc_ufix_fast&)
+
+#undef DECL_ASN_OP_T
+#undef DECL_ASN_OP_OTHER
+#undef DECL_ASN_OP
+
+
+    // auto-increment and auto-decrement
+
+    const sc_fxval_fast operator ++ ( int );
+    const sc_fxval_fast operator -- ( int );
+
+    sc_ufixed_fast& operator ++ ();
+    sc_ufixed_fast& operator -- ();
+
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+// ----------------------------------------------------------------------------
+//  TEMPLATE CLASS : sc_ufixed
+//
+//  "Constrained" unsigned fixed-point class; arbitrary precision.
+// ----------------------------------------------------------------------------
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+sc_ufixed<W,I,Q,O,N>::sc_ufixed( sc_fxnum_observer* observer_ )
+: sc_ufix( W, I, Q, O, N, observer_ )
+{}
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+sc_ufixed<W,I,Q,O,N>::sc_ufixed( const sc_fxcast_switch& cast_sw,
+				 sc_fxnum_observer* observer_ )
+: sc_ufix( W, I, Q, O, N, cast_sw, observer_ )
+{}
+
+#define DEFN_CTORS_T(tp)                                                      \
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>                       \
+inline                                                                        \
+sc_ufixed<W,I,Q,O,N>::sc_ufixed( tp a,                                        \
+				 sc_fxnum_observer* observer_ )               \
+: sc_ufix( a, W, I, Q, O, N, observer_ )                                      \
+{}                                                                            \
+                                                                              \
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>                       \
+inline                                                                        \
+sc_ufixed<W,I,Q,O,N>::sc_ufixed( tp a,                                        \
+				 const sc_fxcast_switch& cast_sw,             \
+				 sc_fxnum_observer* observer_ )               \
+: sc_ufix( a, W, I, Q, O, N, cast_sw, observer_ )                             \
+{}
+
+DEFN_CTORS_T(int)
+DEFN_CTORS_T(unsigned int)
+DEFN_CTORS_T(long)
+DEFN_CTORS_T(unsigned long)
+DEFN_CTORS_T(float)
+DEFN_CTORS_T(double)
+DEFN_CTORS_T(const char*)
+DEFN_CTORS_T(const sc_fxval&)
+DEFN_CTORS_T(const sc_fxval_fast&)
+DEFN_CTORS_T(const sc_fxnum&)
+DEFN_CTORS_T(const sc_fxnum_fast&)
+#ifndef SC_FX_EXCLUDE_OTHER
+DEFN_CTORS_T(int64)
+DEFN_CTORS_T(uint64)
+DEFN_CTORS_T(const sc_int_base&)
+DEFN_CTORS_T(const sc_uint_base&)
+DEFN_CTORS_T(const sc_signed&)
+DEFN_CTORS_T(const sc_unsigned&)
+#endif
+
+#undef DEFN_CTORS_T
+
+// copy constructor
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+sc_ufixed<W,I,Q,O,N>::sc_ufixed( const sc_ufixed<W,I,Q,O,N>& a )
+: sc_ufix( a, W, I, Q, O, N )
+{}
+
+
+// assignment operators
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+sc_ufixed<W,I,Q,O,N>&
+sc_ufixed<W,I,Q,O,N>::operator = ( const sc_ufixed<W,I,Q,O,N>& a )
+{
+    sc_ufix::operator = ( a );
+    return *this;
+}
+
+#define DEFN_ASN_OP_T(op,tp)                                                  \
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>                       \
+inline                                                                        \
+sc_ufixed<W,I,Q,O,N>&                                                         \
+sc_ufixed<W,I,Q,O,N>::operator op ( tp a )                                    \
+{                                                                             \
+    sc_ufix::operator op ( a );                                               \
+    return *this;                                                             \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_ASN_OP_OTHER(op)                                                 \
+DEFN_ASN_OP_T(op,int64)                                                       \
+DEFN_ASN_OP_T(op,uint64)                                                      \
+DEFN_ASN_OP_T(op,const sc_int_base&)                                          \
+DEFN_ASN_OP_T(op,const sc_uint_base&)                                         \
+DEFN_ASN_OP_T(op,const sc_signed&)                                            \
+DEFN_ASN_OP_T(op,const sc_unsigned&)
+#else
+#define DEFN_ASN_OP_OTHER(op)
+#endif
+
+#define DEFN_ASN_OP(op)                                                       \
+DEFN_ASN_OP_T(op,int)                                                         \
+DEFN_ASN_OP_T(op,unsigned int)                                                \
+DEFN_ASN_OP_T(op,long)                                                        \
+DEFN_ASN_OP_T(op,unsigned long)                                               \
+DEFN_ASN_OP_T(op,float)                                                      \
+DEFN_ASN_OP_T(op,double)                                                      \
+DEFN_ASN_OP_T(op,const char*)                                                 \
+DEFN_ASN_OP_T(op,const sc_fxval&)                                             \
+DEFN_ASN_OP_T(op,const sc_fxval_fast&)                                        \
+DEFN_ASN_OP_T(op,const sc_fxnum&)                                             \
+DEFN_ASN_OP_T(op,const sc_fxnum_fast&)                                        \
+DEFN_ASN_OP_OTHER(op)
+
+DEFN_ASN_OP(=)
+
+DEFN_ASN_OP(*=)
+DEFN_ASN_OP(/=)
+DEFN_ASN_OP(+=)
+DEFN_ASN_OP(-=)
+
+DEFN_ASN_OP_T(<<=,int)
+DEFN_ASN_OP_T(>>=,int)
+
+DEFN_ASN_OP_T(&=,const sc_ufix&)
+DEFN_ASN_OP_T(&=,const sc_ufix_fast&)
+DEFN_ASN_OP_T(|=,const sc_ufix&)
+DEFN_ASN_OP_T(|=,const sc_ufix_fast&)
+DEFN_ASN_OP_T(^=,const sc_ufix&)
+DEFN_ASN_OP_T(^=,const sc_ufix_fast&)
+
+#undef DEFN_ASN_OP_T
+#undef DEFN_ASN_OP_OTHER
+#undef DEFN_ASN_OP
+
+
+// auto-increment and auto-decrement
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+const sc_fxval
+sc_ufixed<W,I,Q,O,N>::operator ++ ( int )
+{
+    return sc_fxval( sc_ufix::operator ++ ( 0 ) );
+}
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+const sc_fxval
+sc_ufixed<W,I,Q,O,N>::operator -- ( int )
+{
+    return sc_fxval( sc_ufix::operator -- ( 0 ) );
+}
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+sc_ufixed<W,I,Q,O,N>&
+sc_ufixed<W,I,Q,O,N>::operator ++ ()
+{
+    sc_ufix::operator ++ ();
+    return *this;
+}
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+sc_ufixed<W,I,Q,O,N>&
+sc_ufixed<W,I,Q,O,N>::operator -- ()
+{
+    sc_ufix::operator -- ();
+    return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+//  TEMPLATE CLASS : sc_ufixed_fast
+//
+//  "Constrained" unsigned fixed-point class; limited precision.
+// ----------------------------------------------------------------------------
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+sc_ufixed_fast<W,I,Q,O,N>::sc_ufixed_fast( sc_fxnum_fast_observer* observer_ )
+: sc_ufix_fast( W, I, Q, O, N, observer_ )
+{}
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+sc_ufixed_fast<W,I,Q,O,N>::sc_ufixed_fast( const sc_fxcast_switch& cast_sw,
+					   sc_fxnum_fast_observer* observer_ )
+: sc_ufix_fast( W, I, Q, O, N, cast_sw, observer_ )
+{}
+
+#define DEFN_CTORS_T(tp)                                                      \
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>                       \
+inline                                                                        \
+sc_ufixed_fast<W,I,Q,O,N>::sc_ufixed_fast( tp a,                              \
+					   sc_fxnum_fast_observer* observer_ )\
+: sc_ufix_fast( a, W, I, Q, O, N, observer_ )                                 \
+{}                                                                            \
+                                                                              \
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>                       \
+inline                                                                        \
+sc_ufixed_fast<W,I,Q,O,N>::sc_ufixed_fast( tp a,                              \
+					   const sc_fxcast_switch& cast_sw,   \
+					   sc_fxnum_fast_observer* observer_ )\
+: sc_ufix_fast( a, W, I, Q, O, N, cast_sw, observer_ )                        \
+{}
+
+DEFN_CTORS_T(int)
+DEFN_CTORS_T(unsigned int)
+DEFN_CTORS_T(long)
+DEFN_CTORS_T(unsigned long)
+DEFN_CTORS_T(float)
+DEFN_CTORS_T(double)
+DEFN_CTORS_T(const char*)
+DEFN_CTORS_T(const sc_fxval&)
+DEFN_CTORS_T(const sc_fxval_fast&)
+DEFN_CTORS_T(const sc_fxnum&)
+DEFN_CTORS_T(const sc_fxnum_fast&)
+#ifndef SC_FX_EXCLUDE_OTHER
+DEFN_CTORS_T(int64)
+DEFN_CTORS_T(uint64)
+DEFN_CTORS_T(const sc_int_base&)
+DEFN_CTORS_T(const sc_uint_base&)
+DEFN_CTORS_T(const sc_signed&)
+DEFN_CTORS_T(const sc_unsigned&)
+#endif
+
+#undef DEFN_CTORS_T
+
+// copy constructor
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+sc_ufixed_fast<W,I,Q,O,N>::sc_ufixed_fast( const sc_ufixed_fast<W,I,Q,O,N>& a )
+: sc_ufix_fast( a, W, I, Q, O, N )
+{}
+
+
+// assignment operators
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+sc_ufixed_fast<W,I,Q,O,N>&
+sc_ufixed_fast<W,I,Q,O,N>::operator = ( const sc_ufixed_fast<W,I,Q,O,N>& a )
+{
+    sc_ufix_fast::operator = ( a );
+    return *this;
+}
+
+#define DEFN_ASN_OP_T(op,tp)                                                  \
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>                       \
+inline                                                                        \
+sc_ufixed_fast<W,I,Q,O,N>&                                                    \
+sc_ufixed_fast<W,I,Q,O,N>::operator op ( tp a )                               \
+{                                                                             \
+    sc_ufix_fast::operator op ( a );                                          \
+    return *this;                                                             \
+}
+
+#ifndef SC_FX_EXCLUDE_OTHER
+#define DEFN_ASN_OP_OTHER(op)                                                 \
+DEFN_ASN_OP_T(op,int64)                                                       \
+DEFN_ASN_OP_T(op,uint64)                                                      \
+DEFN_ASN_OP_T(op,const sc_int_base&)                                          \
+DEFN_ASN_OP_T(op,const sc_uint_base&)                                         \
+DEFN_ASN_OP_T(op,const sc_signed&)                                            \
+DEFN_ASN_OP_T(op,const sc_unsigned&)
+#else
+#define DEFN_ASN_OP_OTHER(op)
+#endif
+
+#define DEFN_ASN_OP(op)                                                       \
+DEFN_ASN_OP_T(op,int)                                                         \
+DEFN_ASN_OP_T(op,unsigned int)                                                \
+DEFN_ASN_OP_T(op,long)                                                        \
+DEFN_ASN_OP_T(op,unsigned long)                                               \
+DEFN_ASN_OP_T(op,float)                                                      \
+DEFN_ASN_OP_T(op,double)                                                      \
+DEFN_ASN_OP_T(op,const char*)                                                 \
+DEFN_ASN_OP_T(op,const sc_fxval&)                                             \
+DEFN_ASN_OP_T(op,const sc_fxval_fast&)                                        \
+DEFN_ASN_OP_T(op,const sc_fxnum&)                                             \
+DEFN_ASN_OP_T(op,const sc_fxnum_fast&)                                        \
+DEFN_ASN_OP_OTHER(op)
+
+DEFN_ASN_OP(=)
+
+DEFN_ASN_OP(*=)
+DEFN_ASN_OP(/=)
+DEFN_ASN_OP(+=)
+DEFN_ASN_OP(-=)
+
+DEFN_ASN_OP_T(<<=,int)
+DEFN_ASN_OP_T(>>=,int)
+
+DEFN_ASN_OP_T(&=,const sc_ufix&)
+DEFN_ASN_OP_T(&=,const sc_ufix_fast&)
+DEFN_ASN_OP_T(|=,const sc_ufix&)
+DEFN_ASN_OP_T(|=,const sc_ufix_fast&)
+DEFN_ASN_OP_T(^=,const sc_ufix&)
+DEFN_ASN_OP_T(^=,const sc_ufix_fast&)
+
+#undef DEFN_ASN_OP_T
+#undef DEFN_ASN_OP_OTHER
+#undef DEFN_ASN_OP
+
+
+// auto-increment and auto-decrement
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+const sc_fxval_fast
+sc_ufixed_fast<W,I,Q,O,N>::operator ++ ( int )
+{
+    return sc_fxval_fast( sc_ufix_fast::operator ++ ( 0 ) );
+}
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+const sc_fxval_fast
+sc_ufixed_fast<W,I,Q,O,N>::operator -- ( int )
+{
+    return sc_fxval_fast( sc_ufix_fast::operator -- ( 0 ) );
+}
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+sc_ufixed_fast<W,I,Q,O,N>&
+sc_ufixed_fast<W,I,Q,O,N>::operator ++ ()
+{
+    sc_ufix_fast::operator ++ ();
+    return *this;
+}
+
+template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
+inline
+sc_ufixed_fast<W,I,Q,O,N>&
+sc_ufixed_fast<W,I,Q,O,N>::operator -- ()
+{
+    sc_ufix_fast::operator -- ();
+    return *this;
+}
+
+} // namespace sc_dt
+
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/scfx_ieee.h b/ext/systemc/src/sysc/datatypes/fx/scfx_ieee.h
new file mode 100644
index 000000000..b2da95432
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/scfx_ieee.h
@@ -0,0 +1,701 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  scfx_ieee.h - 
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: scfx_ieee.h,v $
+// Revision 1.3  2011/08/24 22:05:43  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.2  2011/08/07 18:55:24  acg
+//  Philipp A. Hartmann: added guard for __clang__ to get the clang platform
+//  working.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SCFX_IEEE_H
+#define SCFX_IEEE_H
+
+
+#include "sysc/datatypes/fx/sc_fxdefs.h"
+
+
+namespace sc_dt
+{
+
+// classes defined in this module
+union ieee_double;
+class scfx_ieee_double;
+union ieee_float;
+class scfx_ieee_float;
+
+#define SCFX_MASK_(Size) \
+   ((1u << (Size))-1u)
+
+// ----------------------------------------------------------------------------
+//  UNION : ieee_double
+//
+//  IEEE 754 double-precision format.
+// ----------------------------------------------------------------------------
+
+union ieee_double
+{
+
+    double d;
+
+    struct
+    {
+#if defined( SC_BIG_ENDIAN )
+        unsigned negative:1;
+        unsigned exponent:11;
+        unsigned mantissa0:20;
+        unsigned mantissa1:32;
+#elif defined( SC_LITTLE_ENDIAN )
+        unsigned mantissa1:32;
+        unsigned mantissa0:20;
+        unsigned exponent:11;
+        unsigned negative:1;
+#endif
+    } s;
+
+};
+
+
+const unsigned int SCFX_IEEE_DOUBLE_BIAS   =  1023U;
+
+const int          SCFX_IEEE_DOUBLE_E_MAX  =  1023;
+const int          SCFX_IEEE_DOUBLE_E_MIN  = -1022;
+
+const unsigned int SCFX_IEEE_DOUBLE_M_SIZE  =    52;
+const unsigned int SCFX_IEEE_DOUBLE_M0_SIZE =    20;
+const unsigned int SCFX_IEEE_DOUBLE_M1_SIZE =    32;
+const unsigned int SCFX_IEEE_DOUBLE_E_SIZE  =    11;
+
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : scfx_ieee_double
+//
+//  Convenient interface to union ieee_double.
+// ----------------------------------------------------------------------------
+
+class scfx_ieee_double
+{
+
+    ieee_double m_id;
+
+public:
+    
+    scfx_ieee_double();
+    scfx_ieee_double( double );
+    scfx_ieee_double( const scfx_ieee_double& );
+    
+    scfx_ieee_double& operator = ( double );
+    scfx_ieee_double& operator = ( const scfx_ieee_double& );
+    
+    operator double() const;
+
+    unsigned int negative() const;
+    void negative( unsigned int );
+    int exponent() const;
+    void exponent( int );
+    unsigned int mantissa0() const;
+    void mantissa0( unsigned int );
+    unsigned int mantissa1() const;
+    void mantissa1( unsigned int );
+
+    bool is_zero() const;
+    bool is_subnormal() const;
+    bool is_normal() const;
+    bool is_inf() const;
+    bool is_nan() const;
+
+    void set_inf();
+    void set_nan();
+
+    int msb() const;            // most significant non-zero bit
+    int lsb() const;            // least significant non-zero bit
+
+    static const scfx_ieee_double nan();
+    static const scfx_ieee_double inf( int );
+
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+    
+inline
+scfx_ieee_double::scfx_ieee_double() : m_id()
+{
+    m_id.d = 0.0;
+}
+
+inline
+scfx_ieee_double::scfx_ieee_double( double d ) : m_id()
+{
+    m_id.d = d;
+}
+
+inline
+scfx_ieee_double::scfx_ieee_double( const scfx_ieee_double& a ) : m_id(a.m_id)
+{
+    // m_id.d = a.m_id.d;
+}
+    
+
+inline
+scfx_ieee_double&
+scfx_ieee_double::operator = ( double d )
+{
+    m_id.d = d;
+    return *this;
+}
+
+inline
+scfx_ieee_double&
+scfx_ieee_double::operator = ( const scfx_ieee_double& a )
+{
+    m_id.d = a.m_id.d;
+    return *this;
+}
+    
+
+inline
+scfx_ieee_double::operator double() const
+{
+    return m_id.d;
+}
+
+
+inline
+unsigned int
+scfx_ieee_double::negative() const
+{
+    return m_id.s.negative;
+}
+
+inline
+void
+scfx_ieee_double::negative( unsigned int a )
+{
+    m_id.s.negative = a & SCFX_MASK_(1);
+}
+
+inline
+int
+scfx_ieee_double::exponent() const
+{
+    return m_id.s.exponent - SCFX_IEEE_DOUBLE_BIAS;
+}
+
+inline
+void
+scfx_ieee_double::exponent( int a )
+{
+    m_id.s.exponent = (SCFX_IEEE_DOUBLE_BIAS + a)
+                      & SCFX_MASK_(SCFX_IEEE_DOUBLE_E_SIZE);
+}
+
+inline
+unsigned int
+scfx_ieee_double::mantissa0() const
+{
+    return m_id.s.mantissa0;
+}
+
+inline
+void
+scfx_ieee_double::mantissa0( unsigned int a )
+{
+    m_id.s.mantissa0 = a & SCFX_MASK_(SCFX_IEEE_DOUBLE_M0_SIZE);
+}
+
+inline
+unsigned int
+scfx_ieee_double::mantissa1() const
+{
+    return m_id.s.mantissa1;
+}
+
+inline
+void
+scfx_ieee_double::mantissa1( unsigned int a )
+{
+    m_id.s.mantissa1 = a; // & SCFX_MASK_(SCFX_IEEE_DOUBLE_M1_SIZE);
+}
+
+
+inline
+bool
+scfx_ieee_double::is_zero() const
+{
+    return ( exponent() == SCFX_IEEE_DOUBLE_E_MIN - 1 &&
+             mantissa0() == 0U && mantissa1() == 0U );
+}
+
+inline
+bool
+scfx_ieee_double::is_subnormal() const
+{
+    return ( exponent() == SCFX_IEEE_DOUBLE_E_MIN - 1 &&
+             ( mantissa0() != 0U || mantissa1() != 0U ) );
+}
+
+inline
+bool
+scfx_ieee_double::is_normal() const
+{
+    return ( exponent() >= SCFX_IEEE_DOUBLE_E_MIN &&
+             exponent() <= SCFX_IEEE_DOUBLE_E_MAX );
+}
+
+inline
+bool
+scfx_ieee_double::is_inf() const
+{
+    return ( exponent() == SCFX_IEEE_DOUBLE_E_MAX + 1 &&
+             mantissa0() == 0U && mantissa1() == 0U );
+}
+
+inline
+bool
+scfx_ieee_double::is_nan() const
+{
+    return ( exponent() == SCFX_IEEE_DOUBLE_E_MAX + 1 &&
+             ( mantissa0() != 0U || mantissa1() != 0U ) );
+}
+
+
+inline
+void
+scfx_ieee_double::set_inf()
+{
+    exponent( SCFX_IEEE_DOUBLE_E_MAX + 1 );
+    mantissa0( 0U );
+    mantissa1( 0U );
+}
+
+inline
+void
+scfx_ieee_double::set_nan()
+{
+    exponent( SCFX_IEEE_DOUBLE_E_MAX + 1 );
+    mantissa0( (unsigned int) -1 );
+    mantissa1( (unsigned int) -1 );
+}
+
+
+#define MSB_STATEMENT(x,n) if( x >> n ) { x >>= n; i += n; }
+
+inline
+int
+scfx_ieee_double::msb() const
+{
+    unsigned int m0 = mantissa0();
+    unsigned int m1 = mantissa1();
+    if( m0 != 0 )
+    {
+        int i = 0;
+        MSB_STATEMENT(m0,16);
+        MSB_STATEMENT(m0,8);
+        MSB_STATEMENT(m0,4);
+        MSB_STATEMENT(m0,2);
+        MSB_STATEMENT(m0,1);
+        return ( i - 20 );
+    }
+    else if( m1 != 0 )
+    {
+        int i = 0;
+        MSB_STATEMENT(m1,16);
+        MSB_STATEMENT(m1,8);
+        MSB_STATEMENT(m1,4);
+        MSB_STATEMENT(m1,2);
+        MSB_STATEMENT(m1,1);
+        return ( i - 52 );
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+#undef MSB_STATEMENT
+
+#define LSB_STATEMENT(x,n) if( x << n ) { x <<= n; i -= n; }
+
+inline
+int
+scfx_ieee_double::lsb() const
+{
+    unsigned int m0 = mantissa0();
+    unsigned int m1 = mantissa1();
+    if( m1 != 0 )
+    {
+        int i = 31;
+        LSB_STATEMENT(m1,16);
+        LSB_STATEMENT(m1,8);
+        LSB_STATEMENT(m1,4);
+        LSB_STATEMENT(m1,2);
+        LSB_STATEMENT(m1,1);
+        return ( i - 52 );
+    }
+    else if( m0 != 0 )
+    {
+        int i = 31;
+        LSB_STATEMENT(m0,16);
+        LSB_STATEMENT(m0,8);
+        LSB_STATEMENT(m0,4);
+        LSB_STATEMENT(m0,2);
+        LSB_STATEMENT(m0,1);
+        return ( i - 20 );
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+#undef LSB_STATEMENT
+
+
+inline
+const scfx_ieee_double
+scfx_ieee_double::nan()
+{
+    scfx_ieee_double id;
+    id.set_nan();
+    return id;
+}
+
+inline
+const scfx_ieee_double
+scfx_ieee_double::inf( int sign )
+{
+    scfx_ieee_double id( sign );
+    id.set_inf();
+    return id;
+}
+
+
+// ----------------------------------------------------------------------------
+//  UNION : ieee_float
+//
+//  IEEE 754 single-precision format.
+// ----------------------------------------------------------------------------
+    
+union ieee_float
+{
+
+    float f;
+
+    struct
+    {
+#if defined( SC_BIG_ENDIAN )
+        unsigned negative:1;
+        unsigned exponent:8;
+        unsigned mantissa:23;
+#elif defined( SC_LITTLE_ENDIAN )
+        unsigned mantissa:23;
+        unsigned exponent:8;
+        unsigned negative:1;
+#endif
+    } s;
+
+};
+
+
+const unsigned int SCFX_IEEE_FLOAT_BIAS   =  127U;
+
+const int          SCFX_IEEE_FLOAT_E_MAX  =  127;
+const int          SCFX_IEEE_FLOAT_E_MIN  = -126;
+
+const unsigned int SCFX_IEEE_FLOAT_M_SIZE =   23;
+const unsigned int SCFX_IEEE_FLOAT_E_SIZE =    8;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : scfx_ieee_float
+//
+// Convenient wrapper to union ieee_float.
+// ----------------------------------------------------------------------------
+
+class scfx_ieee_float
+{
+
+    ieee_float m_if;
+
+public:
+
+    scfx_ieee_float();
+    scfx_ieee_float( float );
+    scfx_ieee_float( const scfx_ieee_float& );
+
+    scfx_ieee_float& operator = ( float );
+    scfx_ieee_float& operator = ( const scfx_ieee_float& );
+
+    operator float() const;
+
+    unsigned int negative() const;
+    void negative( unsigned int );
+    int exponent() const;
+    void exponent( int );
+    unsigned int mantissa() const;
+    void mantissa( unsigned int );
+
+    bool is_zero() const;
+    bool is_subnormal() const;
+    bool is_normal() const;
+    bool is_inf() const;
+    bool is_nan() const;
+
+    void set_inf();
+    void set_nan();
+
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+    
+inline
+scfx_ieee_float::scfx_ieee_float() : m_if()
+{
+    m_if.f = 0.0;
+}
+
+inline
+scfx_ieee_float::scfx_ieee_float( float f ) : m_if()
+{
+    m_if.f = f;
+}
+
+inline
+scfx_ieee_float::scfx_ieee_float( const scfx_ieee_float& a ) : m_if(a.m_if)
+{
+    // m_if.f = a.m_if.f;
+}
+
+
+inline
+scfx_ieee_float&
+scfx_ieee_float::operator = ( float f )
+{
+    m_if.f = f;
+    return *this;
+}
+
+inline
+scfx_ieee_float&
+scfx_ieee_float::operator = ( const scfx_ieee_float& a )
+{
+    m_if.f = a.m_if.f;
+    return *this;
+}
+    
+
+inline
+scfx_ieee_float::operator float() const
+{
+    return m_if.f;
+}
+
+
+inline
+unsigned int
+scfx_ieee_float::negative() const
+{
+    return m_if.s.negative;
+}
+
+inline
+void
+scfx_ieee_float::negative( unsigned int a )
+{
+    m_if.s.negative = a & SCFX_MASK_(1);
+}
+
+inline
+int
+scfx_ieee_float::exponent() const
+{
+    return m_if.s.exponent - SCFX_IEEE_FLOAT_BIAS;
+}
+
+inline
+void
+scfx_ieee_float::exponent( int a )
+{
+    m_if.s.exponent = (SCFX_IEEE_FLOAT_BIAS + a)
+                      & SCFX_MASK_(SCFX_IEEE_FLOAT_E_SIZE);
+}
+
+inline
+unsigned int
+scfx_ieee_float::mantissa() const
+{
+    return m_if.s.mantissa;
+}
+
+inline
+void
+scfx_ieee_float::mantissa( unsigned int a )
+{
+    m_if.s.mantissa = a & SCFX_MASK_(SCFX_IEEE_FLOAT_M_SIZE);
+}
+
+
+inline
+bool
+scfx_ieee_float::is_zero() const
+{
+    return ( exponent() == SCFX_IEEE_FLOAT_E_MIN - 1 && mantissa() == 0U );
+}
+
+inline
+bool
+scfx_ieee_float::is_subnormal() const
+{
+    return ( exponent() == SCFX_IEEE_FLOAT_E_MIN - 1 && mantissa() != 0U );
+}
+
+inline
+bool
+scfx_ieee_float::is_normal() const
+{
+    return ( exponent() >= SCFX_IEEE_FLOAT_E_MIN &&
+             exponent() <= SCFX_IEEE_FLOAT_E_MAX );
+}
+
+inline
+bool
+scfx_ieee_float::is_inf() const
+{
+    return ( exponent() == SCFX_IEEE_FLOAT_E_MAX + 1 && mantissa() == 0U );
+}
+
+inline
+bool
+scfx_ieee_float::is_nan() const
+{
+    return ( exponent() == SCFX_IEEE_FLOAT_E_MAX + 1 && mantissa() != 0U );
+}
+
+
+inline
+void
+scfx_ieee_float::set_inf()
+{
+    exponent( SCFX_IEEE_FLOAT_E_MAX + 1 );
+    mantissa( 0U );
+}
+
+inline
+void
+scfx_ieee_float::set_nan()
+{
+    exponent( SCFX_IEEE_FLOAT_E_MAX + 1 );
+    mantissa( (unsigned int) -1 );
+}
+
+
+// ----------------------------------------------------------------------------
+//  FUNCTION : scfx_pow2
+//
+//  Computes 2.0**exp in double-precision.
+// ----------------------------------------------------------------------------
+
+inline
+double scfx_pow2( int exp )
+{
+    scfx_ieee_double r;
+    if( exp < SCFX_IEEE_DOUBLE_E_MIN )
+    {
+        r = 0.0;
+        // handle subnormal case
+        exp -= SCFX_IEEE_DOUBLE_E_MIN;
+        if( ( exp += 20 ) >= 0 )
+	{
+            r.mantissa0( 1U << exp );
+        }
+	else if( ( exp += 32 ) >= 0 )
+	{
+            r.mantissa1( 1U << exp );
+        }
+    }
+    else if( exp > SCFX_IEEE_DOUBLE_E_MAX )
+    {
+        r.set_inf();
+    }
+    else
+    {
+        r = 1.0;
+        r.exponent( exp );
+    }
+    return r;
+}
+
+
+// ----------------------------------------------------------------------------
+//  FUNCTION : uint64_to_double
+//
+//  Platform independent conversion from double uint64 to double.
+//  Needed because VC++6 doesn't support this conversion.
+// ----------------------------------------------------------------------------
+
+inline
+double
+uint64_to_double( uint64 a )
+{
+#if defined( _MSC_VER ) || defined( __clang__ )
+    // conversion from uint64 to double not implemented; use int64
+    double tmp = static_cast<double>( static_cast<int64>( a ) );
+    return ( tmp >= 0 ) ? tmp : tmp + sc_dt::scfx_pow2( 64 );
+#else
+    return static_cast<double>( a );
+#endif
+}
+
+} // namespace sc_dt
+
+#undef SCFX_MASK_
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/scfx_mant.cpp b/ext/systemc/src/sysc/datatypes/fx/scfx_mant.cpp
new file mode 100644
index 000000000..fc29764f6
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/scfx_mant.cpp
@@ -0,0 +1,125 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  scfx_mant.cpp - 
+
+  Original Author: Robert Graulich, Synopsys, Inc.
+                   Martin Janssen,  Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: scfx_mant.cpp,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include "sysc/datatypes/fx/scfx_mant.h"
+
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  word memory management
+// ----------------------------------------------------------------------------
+
+class word_list { // Entry in free_words bucket.
+  public:
+    word_list* m_next_p;
+};
+
+static inline
+int
+next_pow2_index( std::size_t size )
+{
+    int index = scfx_find_msb( size );
+    // If this was a power of 2 we are one bucket too low.
+    if( ~ (1 << index) & size ) index ++;
+    // If this is a 64-bit machine and we are using 32-bit words go down
+	// one slot size, as all the slots are 2x in size.
+    if ( index != 0 && ( sizeof(word_list) != sizeof(word) ) ) 
+	{
+		index -= 1;
+	}
+    return index;
+}
+
+static word_list* free_words[32] = { 0 };
+    
+word*
+scfx_mant::alloc_word( std::size_t size )
+{
+    const int ALLOC_SIZE = 128;
+
+    int slot_index = next_pow2_index( size );
+
+    int alloc_size = ( 1 << slot_index );
+
+    word_list*& slot = free_words[slot_index];
+
+    if( ! slot )
+    {
+        slot = new word_list[ALLOC_SIZE * alloc_size];
+	int i;
+	for( i = 0; i < alloc_size*(ALLOC_SIZE-1) ; i+=alloc_size )
+	{
+	    slot[i].m_next_p = &slot[i+alloc_size];
+	}
+	slot[i].m_next_p = 0;
+    }
+
+    word* result = (word*)slot;
+    free_words[slot_index] = slot[0].m_next_p;
+    return result;
+}
+
+void
+scfx_mant::free_word( word* array, std::size_t size )
+{
+    if( array && size )
+    {
+        int slot_index = next_pow2_index( size );
+	word_list* wl_p = (word_list*)array;
+
+	wl_p->m_next_p = free_words[slot_index];
+	free_words[slot_index] = wl_p;
+    }
+}
+
+} // namespace sc_dt
+
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/scfx_mant.h b/ext/systemc/src/sysc/datatypes/fx/scfx_mant.h
new file mode 100644
index 000000000..84d9b0bd8
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/scfx_mant.h
@@ -0,0 +1,490 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  scfx_mant.h - 
+
+  Original Author: Robert Graulich, Synopsys, Inc.
+                   Martin Janssen,  Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: scfx_mant.h,v $
+// Revision 1.2  2011/08/24 22:05:43  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SCFX_MANT_H
+#define SCFX_MANT_H
+
+
+#include "sysc/datatypes/fx/scfx_ieee.h"
+#include "sysc/datatypes/fx/scfx_utils.h"
+#include "sysc/kernel/sc_macros.h"
+
+
+namespace sc_dt
+{
+
+// classes defined in this module
+class scfx_mant;
+class scfx_mant_ref;
+
+
+typedef unsigned int  word;       // Using int because of 64-bit machines.
+typedef unsigned short half_word;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : scfx_mant
+//
+//  Mantissa class.
+// ----------------------------------------------------------------------------
+
+class scfx_mant
+{
+
+    word* m_array;
+    int   m_size;
+
+public:
+
+    explicit scfx_mant( std::size_t );
+             scfx_mant( const scfx_mant& );
+
+    scfx_mant& operator = ( const scfx_mant& );
+
+    ~scfx_mant();
+
+    void clear();
+
+    void resize_to( int, int = 0 );
+
+    int size() const;
+
+    word  operator [] ( int ) const;
+    word& operator [] ( int );
+
+    half_word  half_at( int ) const;
+    half_word& half_at( int );
+
+    half_word* half_addr( int = 0 ) const;
+
+private:
+
+    static word* alloc( std::size_t );
+    static void free( word*, std::size_t );
+
+    static word* alloc_word( std::size_t size );
+    static void free_word( word* array, std::size_t size );
+
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+inline
+int
+scfx_mant::size() const
+{
+    return m_size;
+}
+
+
+inline
+word*
+scfx_mant::alloc( std::size_t size )
+{
+#if defined( SC_BIG_ENDIAN )
+    return alloc_word( size ) + ( size - 1 );
+#elif defined( SC_LITTLE_ENDIAN )
+    return alloc_word( size );
+#endif
+}
+
+inline
+void
+scfx_mant::free( word* mant, std::size_t size )
+{
+#if defined( SC_BIG_ENDIAN )
+    free_word( mant - ( size - 1 ), size );
+#elif defined( SC_LITTLE_ENDIAN )
+    free_word( mant, size );
+#endif
+}
+
+inline
+word
+scfx_mant::operator[]( int i ) const
+{
+    SC_ASSERT_( i >= 0 && i < m_size, "mantissa index out of range" );
+#if defined( SC_BIG_ENDIAN )
+    return m_array[-i];
+#elif defined( SC_LITTLE_ENDIAN )
+    return m_array[i];
+#endif
+}
+
+inline
+word&
+scfx_mant::operator[]( int i )
+{
+    SC_ASSERT_( i >= 0 && i < m_size, "mantissa index out of range" );
+#if defined( SC_BIG_ENDIAN )
+    return m_array[-i];
+#elif defined( SC_LITTLE_ENDIAN )
+    return m_array[i];
+#endif
+}
+
+inline
+scfx_mant::scfx_mant( std::size_t size )
+: m_array(0), m_size(size)
+{
+    m_array = alloc( size );
+}
+
+inline
+scfx_mant::scfx_mant( const scfx_mant& rhs )
+: m_array(0), m_size(rhs.m_size)
+{
+    m_array = alloc( m_size );
+    for( int i = 0; i < m_size; i ++ )
+    {
+        (*this)[i] = rhs[i];
+    }
+}
+
+inline
+scfx_mant&
+scfx_mant::operator = ( const scfx_mant& rhs )
+{
+    if( &rhs != this )
+    {
+        if( m_size != rhs.m_size )
+	{
+	    free( m_array, m_size );
+	    m_array = alloc( m_size = rhs.m_size );
+	}
+
+	for( int i = 0; i < m_size; i ++ )
+	{
+	    (*this)[i] = rhs[i];
+	}
+    }
+    return *this;
+}
+
+inline
+scfx_mant::~scfx_mant()
+{
+    if( m_array != 0 )
+    {
+        free( m_array, m_size );
+    }
+}
+
+inline
+void
+scfx_mant::clear()
+{
+    for( int i = 0; i < m_size; i ++ )
+    {
+        (*this)[i] = 0;
+    }
+}
+
+inline
+void
+scfx_mant::resize_to( int size, int restore )
+{
+    if( size == m_size )
+    {
+        return;
+    }
+
+    if( ! m_array )
+    {
+        m_array = alloc( m_size = size );
+    }
+    else
+    {
+        word* p = alloc( size );
+
+	if( restore )
+	{
+	    int end = sc_min( size, m_size );
+	    if( restore == 1 )		// msb resized -> align at 0
+	    {
+	        for( int i = 0; i < size; i ++ )
+		{
+		    if( i < end )
+		    {
+#if defined( SC_BIG_ENDIAN )
+		        p[-i] = m_array[-i];
+#elif defined( SC_LITTLE_ENDIAN )
+			p[i] = m_array[i];
+#endif
+		    }
+		    else
+		    {
+#if defined( SC_BIG_ENDIAN )
+		        p[-i] = 0;
+#elif defined( SC_LITTLE_ENDIAN )
+			p[i] = 0;
+#endif
+		    }
+		}
+	    }
+	    else			// lsb resized -> align at size-1
+	    {
+	        for( int i = 0; i < size; i ++ )
+		{
+		    if( i < end )
+		    {
+#if defined( SC_BIG_ENDIAN )
+		        p[-size+1+i] = m_array[-m_size+1+i];
+#elif defined( SC_LITTLE_ENDIAN )
+			p[size-1-i] = m_array[m_size-1-i];
+#endif
+		    }
+		    else
+		    {
+#if defined( SC_BIG_ENDIAN )
+		        p[-size+1+i] = 0;
+#elif defined( SC_LITTLE_ENDIAN )
+			p[size-1-i] = 0;
+#endif
+		    }
+		}
+	    }
+	}
+
+	free( m_array, m_size );
+	m_array = p;
+	m_size = size;
+    }
+}
+
+inline
+half_word
+scfx_mant::half_at( int i ) const
+{
+    SC_ASSERT_( ( i >> 1 ) >= 0 && ( i >> 1 ) < m_size,
+		"mantissa index out of range" );
+#if defined( SC_BIG_ENDIAN )
+    return reinterpret_cast<half_word*>( m_array )[-i];
+#elif defined( SC_LITTLE_ENDIAN )
+    return reinterpret_cast<half_word*>( m_array )[i];
+#endif
+}
+
+inline
+half_word&
+scfx_mant::half_at( int i )
+{
+    SC_ASSERT_( ( i >> 1 ) >= 0 && ( i >> 1 ) < m_size,
+		"mantissa index out of range" );
+#if defined( SC_BIG_ENDIAN )
+    return reinterpret_cast<half_word*>( m_array )[-i];
+#elif defined( SC_LITTLE_ENDIAN )
+    return reinterpret_cast<half_word*>( m_array )[i];
+#endif
+}
+
+inline
+half_word*
+scfx_mant::half_addr( int i ) const
+{
+    SC_ASSERT_( i >= 0 && i < m_size, "mantissa index out of range" );
+#if defined( SC_BIG_ENDIAN )
+    return reinterpret_cast<half_word*>( m_array - i ) + 1;
+#elif defined( SC_LITTLE_ENDIAN )
+    return reinterpret_cast<half_word*>( m_array + i );
+#endif
+}
+
+
+// ----------------------------------------------------------------------------
+//  one's complement of a mantissa
+// ----------------------------------------------------------------------------
+
+inline
+void
+complement( scfx_mant& target, const scfx_mant& source, int size )
+{
+    for( int i = 0; i < size; i ++ )
+    {
+        target[i] = ~source[i];
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  increment mantissa
+// ----------------------------------------------------------------------------
+
+inline
+void
+inc( scfx_mant& mant )
+{
+    for( int i = 0; i < mant.size(); i ++ )
+    {
+        if( ++ mant[i] )
+	{
+	    break;
+	}
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : scfx_mant_ref
+//
+//  Mantissa reference class.
+// ----------------------------------------------------------------------------
+
+class scfx_mant_ref
+{
+
+    scfx_mant* m_mant;
+    bool       m_not_const;
+
+public:
+
+    scfx_mant_ref();
+    scfx_mant_ref( const scfx_mant& );
+    scfx_mant_ref( scfx_mant* );
+
+    scfx_mant_ref& operator = ( const scfx_mant& );
+    scfx_mant_ref& operator = ( scfx_mant* );
+
+    ~scfx_mant_ref();
+
+    operator scfx_mant&();
+
+    word operator [] ( int );
+
+private:
+
+    void remove_it();
+
+    scfx_mant_ref( const scfx_mant_ref& );
+    scfx_mant_ref& operator = ( const scfx_mant_ref& );
+
+    void* operator new( std::size_t sz ) { return ::operator new( sz ); }
+
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+inline
+void
+scfx_mant_ref::remove_it()
+{
+    if( m_not_const )
+    {
+        delete m_mant;
+    }
+}
+
+inline
+scfx_mant_ref::scfx_mant_ref()
+: m_mant( 0 ), m_not_const( false )
+{}
+
+inline
+scfx_mant_ref::scfx_mant_ref( const scfx_mant& mant )
+: m_mant( const_cast<scfx_mant*>( &mant ) ), m_not_const( false )
+{}
+
+inline
+scfx_mant_ref::scfx_mant_ref( scfx_mant* mant )
+: m_mant( mant ), m_not_const( true )
+{}
+
+inline
+scfx_mant_ref&
+scfx_mant_ref::operator = ( const scfx_mant& mant )
+{
+    remove_it();
+
+    m_mant = const_cast<scfx_mant*>( &mant );
+    m_not_const = false;
+
+    return *this;
+}
+
+inline
+scfx_mant_ref&
+scfx_mant_ref::operator = ( scfx_mant* mant )
+{
+    remove_it();
+
+    m_mant = mant;
+    m_not_const = true;
+
+    return *this;
+}
+
+inline
+scfx_mant_ref::~scfx_mant_ref()
+{
+    remove_it();
+}
+
+inline
+scfx_mant_ref::operator scfx_mant&()
+{
+    // SC_ASSERT_( m_not_const, "not allowed to modify mant" );
+    return *m_mant;
+}
+
+inline
+word
+scfx_mant_ref::operator [] ( int i )
+{
+    return (*m_mant)[i];
+}
+
+} // namespace sc_dt
+
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/scfx_other_defs.h b/ext/systemc/src/sysc/datatypes/fx/scfx_other_defs.h
new file mode 100644
index 000000000..a52d74b6b
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/scfx_other_defs.h
@@ -0,0 +1,433 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  scfx_other_defs.h - 
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: scfx_other_defs.h,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SCFX_OTHER_DEFS_H
+#define SCFX_OTHER_DEFS_H
+
+
+#include "sysc/datatypes/fx/sc_fx_ids.h"
+#include "sysc/datatypes/int/sc_signed.h"
+#include "sysc/datatypes/int/sc_unsigned.h"
+#include "sysc/datatypes/int/sc_int_base.h"
+#include "sysc/datatypes/int/sc_uint_base.h"
+#include "sysc/tracing/sc_trace.h"
+
+
+namespace sc_dt
+{
+
+#ifdef SC_INCLUDE_FX
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signed
+// ----------------------------------------------------------------------------
+
+// assignment operators
+
+inline
+const sc_signed&
+sc_signed::operator = ( const sc_fxval& v )
+{
+    if( ! v.is_normal() ) /* also triggers OBSERVER_READ call */
+    {
+	SC_REPORT_ERROR( sc_core::SC_ID_INVALID_FX_VALUE_,
+			 "sc_signed::operator = ( const sc_fxval& )" );
+    }
+
+    for( int i = 0; i < length(); ++ i )
+	(*this)[i] = v.get_bit( i );
+
+    return *this;
+}
+
+inline
+const sc_signed&
+sc_signed::operator = ( const sc_fxval_fast& v )
+{
+    if( ! v.is_normal() ) /* also triggers OBSERVER_READ call */
+    {
+	SC_REPORT_ERROR( sc_core::SC_ID_INVALID_FX_VALUE_,
+			 "sc_signed::operator = ( const sc_fxval_fast& )" );
+    }
+
+    for( int i = 0; i < length(); ++ i )
+	(*this)[i] = v.get_bit( i );
+
+    return *this;
+}
+
+inline
+const sc_signed&
+sc_signed::operator = ( const sc_fxnum& v )
+{
+    if( ! v.is_normal() ) /* also triggers OBSERVER_READ call */
+    {
+	SC_REPORT_ERROR( sc_core::SC_ID_INVALID_FX_VALUE_,
+			 "sc_signed::operator = ( const sc_fxnum& )" );
+    }
+
+    for( int i = 0; i < length(); ++ i )
+	(*this)[i] = v.get_bit( i );
+
+    return *this;
+}
+
+inline
+const sc_signed&
+sc_signed::operator = ( const sc_fxnum_fast& v )
+{
+    if( ! v.is_normal() ) /* also triggers OBSERVER_READ call */
+    {
+	SC_REPORT_ERROR( sc_core::SC_ID_INVALID_FX_VALUE_,
+			 "sc_signed::operator = ( const sc_fxnum_fast& )" );
+    }
+
+    for( int i = 0; i < length(); ++ i )
+	(*this)[i] = v.get_bit( i );
+
+    return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_unsigned
+// ----------------------------------------------------------------------------
+
+// assignment operators
+
+inline
+const sc_unsigned&
+sc_unsigned::operator = ( const sc_fxval& v )
+{
+    if( ! v.is_normal() ) /* also triggers OBSERVER_READ call */
+    {
+	SC_REPORT_ERROR( sc_core::SC_ID_INVALID_FX_VALUE_,
+			 "sc_unsigned::operator = ( const sc_fxval& )" );
+    }
+
+    for( int i = 0; i < length(); ++ i )
+	(*this)[i] = v.get_bit( i );
+
+    return *this;
+}
+
+inline
+const sc_unsigned&
+sc_unsigned::operator = ( const sc_fxval_fast& v )
+{
+    if( ! v.is_normal() ) /* also triggers OBSERVER_READ call */
+    {
+	SC_REPORT_ERROR( sc_core::SC_ID_INVALID_FX_VALUE_,
+			 "sc_unsigned::operator = ( const sc_fxval_fast& )" );
+    }
+
+    for( int i = 0; i < length(); ++ i )
+	(*this)[i] = v.get_bit( i );
+
+    return *this;
+}
+
+inline
+const sc_unsigned&
+sc_unsigned::operator = ( const sc_fxnum& v )
+{
+    if( ! v.is_normal() ) /* also triggers OBSERVER_READ call */
+    {
+	SC_REPORT_ERROR( sc_core::SC_ID_INVALID_FX_VALUE_,
+			 "sc_unsigned::operator = ( const sc_fxnum& )" );
+    }
+
+    for( int i = 0; i < length(); ++ i )
+	(*this)[i] = v.get_bit( i );
+
+    return *this;
+}
+
+inline
+const sc_unsigned&
+sc_unsigned::operator = ( const sc_fxnum_fast& v )
+{
+    if( ! v.is_normal() ) /* also triggers OBSERVER_READ call */
+    {
+	SC_REPORT_ERROR( sc_core::SC_ID_INVALID_FX_VALUE_,
+			 "sc_unsigned::operator = ( const sc_fxnum_fast& )" );
+    }
+
+    for( int i = 0; i < length(); ++ i )
+	(*this)[i] = v.get_bit( i );
+
+    return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_int_base
+// ----------------------------------------------------------------------------
+
+#ifndef _32BIT_
+#define NUM_WIDTH LLWIDTH
+#else
+#define NUM_WIDTH INTWIDTH
+#endif
+
+
+// assignment operators
+
+inline
+sc_int_base&
+sc_int_base::operator = ( const sc_fxval& v )
+{
+    if( ! v.is_normal() ) { /* also triggers OBSERVER_READ call */
+	SC_REPORT_ERROR( sc_core::SC_ID_INVALID_FX_VALUE_,
+			 "sc_int_base::operator = ( const sc_fxval& )" );
+    }
+    for( int i = 0; i < m_len; ++ i ) {
+	set( i, v.get_bit( i ) );
+    }
+    extend_sign();
+    return *this;
+}
+
+inline
+sc_int_base&
+sc_int_base::operator = ( const sc_fxval_fast& v )
+{
+    if( ! v.is_normal() ) { /* also triggers OBSERVER_READ call */
+	SC_REPORT_ERROR( sc_core::SC_ID_INVALID_FX_VALUE_,
+			 "sc_int_base::operator = ( const sc_fxval_fast& )" );
+    }
+    for( int i = 0; i < m_len; ++ i ) {
+	set( i, v.get_bit( i ) );
+    }
+    extend_sign();
+    return *this;
+}
+
+inline
+sc_int_base&
+sc_int_base::operator = ( const sc_fxnum& v )
+{
+    if( ! v.is_normal() ) { /* also triggers OBSERVER_READ call */
+	SC_REPORT_ERROR( sc_core::SC_ID_INVALID_FX_VALUE_,
+			 "sc_int_base::operator = ( const sc_fxnum& )" );
+    }
+    for( int i = 0; i < m_len; ++ i ) {
+	set( i, v.get_bit( i ) );
+    }
+    extend_sign();
+    return *this;
+}
+
+inline
+sc_int_base&
+sc_int_base::operator = ( const sc_fxnum_fast& v )
+{
+    if( ! v.is_normal() ) { /* also triggers OBSERVER_READ call */
+	SC_REPORT_ERROR( sc_core::SC_ID_INVALID_FX_VALUE_,
+			 "sc_int_base::operator = ( const sc_fxnum_fast& )" );
+    }
+    for( int i = 0; i < m_len; ++ i ) {
+	set( i, v.get_bit( i ) );
+    }
+    extend_sign();
+    return *this;
+}
+
+#undef NUM_WIDTH
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_uint_base
+// ----------------------------------------------------------------------------
+
+// assignment operators
+
+inline
+sc_uint_base&
+sc_uint_base::operator = ( const sc_fxval& v )
+{
+    if( ! v.is_normal() ) { /* also triggers OBSERVER_READ call */
+	SC_REPORT_ERROR( sc_core::SC_ID_INVALID_FX_VALUE_,
+			 "sc_uint_base::operator = ( const sc_fxval& )" );
+    }
+    for( int i = 0; i < m_len; ++ i ) {
+	set( i, v.get_bit( i ) );
+    }
+    extend_sign();
+    return *this;
+}
+
+inline
+sc_uint_base&
+sc_uint_base::operator = ( const sc_fxval_fast& v )
+{
+    if( ! v.is_normal() ) { /* also triggers OBSERVER_READ call */
+	SC_REPORT_ERROR( sc_core::SC_ID_INVALID_FX_VALUE_,
+			 "sc_uint_base::operator = ( const sc_fxval_fast& )" );
+    }
+    for( int i = 0; i < m_len; ++ i ) {
+	set( i, v.get_bit( i ) );
+    }
+    extend_sign();
+    return *this;
+}
+
+inline
+sc_uint_base&
+sc_uint_base::operator = ( const sc_fxnum& v )
+{
+    if( ! v.is_normal() ) { /* also triggers OBSERVER_READ call */
+	SC_REPORT_ERROR( sc_core::SC_ID_INVALID_FX_VALUE_,
+			 "sc_uint_base::operator = ( const sc_fxnum& )" );
+    }
+    for( int i = 0; i < m_len; ++ i ) {
+	set( i, v.get_bit( i ) );
+    }
+    extend_sign();
+    return *this;
+}
+
+inline
+sc_uint_base&
+sc_uint_base::operator = ( const sc_fxnum_fast& v )
+{
+    if( ! v.is_normal() ) { /* also triggers OBSERVER_READ call */
+	SC_REPORT_ERROR( sc_core::SC_ID_INVALID_FX_VALUE_,
+			 "sc_uint_base::operator = ( const sc_fxnum_fast& )" );
+    }
+    for( int i = 0; i < m_len; ++ i ) {
+	set( i, v.get_bit( i ) );
+    }
+    extend_sign();
+    return *this;
+}
+
+
+#endif
+
+
+// ----------------------------------------------------------------------------
+//  FUNCTION : sc_trace
+// ----------------------------------------------------------------------------
+
+inline
+void
+sc_trace( sc_core::sc_trace_file* tf,
+	  const sc_fxval& object, const std::string& name )
+{
+    if( tf )
+	tf->trace( object, name );
+}
+
+inline
+void
+sc_trace( sc_core::sc_trace_file* tf,
+	  const sc_fxval* object, const std::string& name )
+{
+    if( tf )
+	tf->trace( *object, name );
+}
+
+inline
+void
+sc_trace( sc_core::sc_trace_file* tf,
+	  const sc_fxval_fast& object, const std::string& name )
+{
+    if( tf )
+	tf->trace( object, name );
+}
+
+inline
+void
+sc_trace( sc_core::sc_trace_file* tf,
+	  const sc_fxval_fast* object, const std::string& name )
+{
+    if( tf )
+	tf->trace( *object, name );
+}
+
+inline
+void
+sc_trace( sc_core::sc_trace_file* tf,
+	  const sc_fxnum& object, const std::string& name )
+{
+    if( tf )
+	tf->trace( object, name );
+}
+
+inline
+void
+sc_trace( sc_core::sc_trace_file* tf,
+	  const sc_fxnum* object, const std::string& name )
+{
+    if( tf )
+	tf->trace( *object, name );
+}
+
+inline
+void
+sc_trace( sc_core::sc_trace_file* tf,
+	  const sc_fxnum_fast& object, const std::string& name )
+{
+    if( tf )
+	tf->trace( object, name );
+}
+
+inline
+void
+sc_trace( sc_core::sc_trace_file* tf,
+	  const sc_fxnum_fast* object, const std::string& name )
+{
+    if( tf )
+	tf->trace( *object, name );
+}
+
+} // namespace sc_dt
+
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/scfx_params.h b/ext/systemc/src/sysc/datatypes/fx/scfx_params.h
new file mode 100644
index 000000000..8cd646651
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/scfx_params.h
@@ -0,0 +1,222 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  scfx_params.h - 
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: scfx_params.h,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SCFX_PARAMS_H
+#define SCFX_PARAMS_H
+
+
+#include "sysc/datatypes/fx/sc_fx_ids.h"
+#include "sysc/datatypes/fx/sc_fxcast_switch.h"
+#include "sysc/datatypes/fx/sc_fxtype_params.h"
+
+
+namespace sc_dt
+{
+
+// classes defined in this module
+class scfx_params;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : scfx_params
+//
+//  ...
+// ----------------------------------------------------------------------------
+
+class scfx_params
+{
+
+public:
+
+    // constructor
+
+    scfx_params( const sc_fxtype_params&,
+		 sc_enc,
+		 const sc_fxcast_switch& );
+
+
+    // query functions
+
+    const sc_fxtype_params& type_params() const;
+    sc_enc enc() const;
+    const sc_fxcast_switch& cast_switch() const;
+
+
+    // shortcuts
+
+    int wl() const;
+    int iwl() const;
+    int fwl() const;
+    sc_q_mode q_mode() const;
+    sc_o_mode o_mode() const;
+    int n_bits() const;
+
+
+    // dump content
+
+    void dump( ::std::ostream& ) const;
+
+private:
+
+    sc_fxtype_params m_type_params;
+    sc_enc           m_enc;
+    sc_fxcast_switch m_cast_switch;
+    
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+// constructor
+
+inline
+scfx_params::scfx_params( const sc_fxtype_params& type_params_,
+			  sc_enc enc_,
+			  const sc_fxcast_switch& cast_sw )
+: m_type_params( type_params_ ),
+  m_enc( enc_ ),
+  m_cast_switch( cast_sw )
+{
+    if( m_enc == SC_US_ && m_type_params.o_mode() == SC_WRAP_SM )
+    {
+	SC_REPORT_ERROR( sc_core::SC_ID_INVALID_O_MODE_,
+			 "SC_WRAP_SM not defined for unsigned numbers" );
+    }
+
+}
+
+
+// query functions
+
+inline
+const sc_fxtype_params&
+scfx_params::type_params() const
+{
+    return m_type_params;
+}
+
+inline
+sc_enc
+scfx_params::enc() const
+{
+    return m_enc;
+}
+
+inline
+const sc_fxcast_switch&
+scfx_params::cast_switch() const
+{
+    return m_cast_switch;
+}
+
+
+// shortcuts
+
+inline
+int
+scfx_params::wl() const
+{
+    return m_type_params.wl();
+}
+
+inline
+int
+scfx_params::iwl() const
+{
+    return m_type_params.iwl();
+}
+
+inline
+int
+scfx_params::fwl() const
+{
+    return ( m_type_params.wl() - m_type_params.iwl() );
+}
+
+inline
+sc_q_mode
+scfx_params::q_mode() const
+{
+    return m_type_params.q_mode();
+}
+
+inline
+sc_o_mode
+scfx_params::o_mode() const
+{
+    return m_type_params.o_mode();
+}
+
+inline
+int
+scfx_params::n_bits() const
+{
+    return m_type_params.n_bits();
+}
+
+
+// dump content
+
+inline
+void
+scfx_params::dump( ::std::ostream& os ) const
+{
+    os << "scfx_params" << ::std::endl;
+    os << "(" << ::std::endl;
+    os << "type_params = ";
+    m_type_params.dump( os );
+    os << "enc         = " << m_enc << ::std::endl;
+    os << "cast_switch = ";
+    m_cast_switch.dump( os );
+    os << ")" << ::std::endl;
+}
+
+} // namespace sc_dt
+
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/scfx_pow10.cpp b/ext/systemc/src/sysc/datatypes/fx/scfx_pow10.cpp
new file mode 100644
index 000000000..ac931763b
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/scfx_pow10.cpp
@@ -0,0 +1,147 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  scfx_pow10.cpp - 
+
+  Original Author: Robert Graulich, Synopsys, Inc.
+                   Martin Janssen,  Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: scfx_pow10.cpp,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include "sysc/datatypes/fx/scfx_pow10.h"
+
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  CLASS : scfx_pow10
+//
+//  Class to compute (and cache) powers of 10 in arbitrary precision.
+// ----------------------------------------------------------------------------
+
+scfx_pow10::scfx_pow10()
+{
+    m_pos[0] = scfx_rep( 10.0 );
+    m_neg[0] = scfx_rep( 0.1 );
+
+    for( int i = 1; i < SCFX_POW10_TABLE_SIZE; i ++ )
+    {
+        m_pos[i].set_nan();
+	m_neg[i].set_nan();
+    }
+}
+
+scfx_pow10::~scfx_pow10()
+{}
+
+
+const scfx_rep
+scfx_pow10::operator() ( int i )
+{
+    if( i == 0 ) {
+        return scfx_rep( 1.0 );
+    }
+
+    if( i > 0 )
+    {
+        int bit = scfx_find_msb( i );
+	scfx_rep result = *pos( bit );
+	if( bit )
+	{
+	    while( -- bit >= 0 )
+	    {
+	        if( ( 1 << bit ) & i )
+		{
+		    scfx_rep* tmp = mult_scfx_rep( result, *pos( bit ) );
+		    result = *tmp;
+		    delete tmp;
+		}
+	    }
+	}
+	return result;
+    }
+    else
+    {
+        i = -i;
+	int bit = scfx_find_msb( i );
+	scfx_rep result = *neg( bit );
+	if( bit )
+	{
+	    while( -- bit >= 0 )
+	    {
+	        if( ( 1 << bit ) & i )
+		{
+		    scfx_rep* tmp = mult_scfx_rep( result, *neg( bit ) );
+		    result = *tmp;
+		    delete tmp;
+		}
+	    }
+	}
+	return result;
+    }
+}
+
+
+scfx_rep*
+scfx_pow10::pos( int i )
+{
+    if( ! m_pos[i].is_normal() )
+    {
+        multiply( m_pos[i], *pos( i - 1 ), *pos( i - 1 ) );
+    }
+    return &m_pos[i];
+}
+
+scfx_rep*
+scfx_pow10::neg( int i )
+{
+    if( ! m_neg[i].is_normal() )
+    {
+	multiply( m_neg[i], *neg( i - 1 ), *neg( i - 1 ) );
+    }
+    return &m_neg[i];
+}
+
+} // namespace sc_dt
+
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/scfx_pow10.h b/ext/systemc/src/sysc/datatypes/fx/scfx_pow10.h
new file mode 100644
index 000000000..c9b278561
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/scfx_pow10.h
@@ -0,0 +1,95 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  scfx_pow10.h - 
+
+  Original Author: Robert Graulich, Synopsys, Inc.
+                   Martin Janssen,  Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: scfx_pow10.h,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SCFX_POW10_H
+#define SCFX_POW10_H
+
+
+#include "sysc/datatypes/fx/scfx_rep.h"
+
+
+namespace sc_dt
+{
+
+// classes defined in this module
+class scfx_pow10;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : scfx_pow10
+//
+//  Class to compute (and cache) powers of 10 in arbitrary precision.
+// ----------------------------------------------------------------------------
+
+const int SCFX_POW10_TABLE_SIZE = 32;
+
+
+class scfx_pow10
+{
+
+public:
+
+    scfx_pow10();
+    ~scfx_pow10();
+
+    const scfx_rep operator() ( int );
+
+private:
+
+    scfx_rep* pos( int );
+    scfx_rep* neg( int );
+
+    scfx_rep m_pos[SCFX_POW10_TABLE_SIZE];
+    scfx_rep m_neg[SCFX_POW10_TABLE_SIZE];
+};
+
+} // namespace sc_dt
+
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/scfx_rep.cpp b/ext/systemc/src/sysc/datatypes/fx/scfx_rep.cpp
new file mode 100644
index 000000000..772835e6d
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/scfx_rep.cpp
@@ -0,0 +1,2926 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  scfx_rep.cpp - 
+
+  Original Author: Robert Graulich, Synopsys, Inc.
+                   Martin Janssen,  Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: scfx_rep.cpp,v $
+// Revision 1.4  2011/08/24 22:05:43  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.3  2011/08/15 16:43:24  acg
+//  Torsten Maehne: changes to remove unused argument warnings.
+//
+// Revision 1.2  2009/02/28 00:26:20  acg
+//  Andy Goodrich: bug fixes.
+//
+// Revision 1.2  2008/11/06 17:22:47  acg
+//  Andy Goodrich: bug fixes for 2.2.1.
+//
+// Revision 1.1.1.1  2006/12/15 20:31:36  acg
+// SystemC 2.2
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include "sysc/utils/sc_machine.h"
+#include "sysc/datatypes/fx/scfx_rep.h"
+
+#include "sysc/datatypes/fx/scfx_ieee.h"
+#include "sysc/datatypes/fx/scfx_pow10.h"
+#include "sysc/datatypes/fx/scfx_utils.h"
+
+#include "sysc/datatypes/bit/sc_bv_base.h"
+
+#include <ctype.h>
+#include <cstdio>
+#include <stdlib.h>
+#include <math.h>
+
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  some utilities
+// ----------------------------------------------------------------------------
+
+static scfx_pow10 pow10_fx;
+
+static const int mantissa0_size = SCFX_IEEE_DOUBLE_M_SIZE - bits_in_int;
+
+static inline
+int
+n_word( int x )
+{
+    return ( x + bits_in_word - 1 ) / bits_in_word;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CONSTRUCTORS
+// ----------------------------------------------------------------------------
+
+scfx_rep::scfx_rep()
+: m_mant( min_mant ), m_wp(), m_sign(), m_state(), m_msw(), m_lsw(), 
+  m_r_flag( false )
+{
+    set_zero();
+}
+
+scfx_rep::scfx_rep( int a )
+: m_mant( min_mant ), m_wp(), m_sign(), m_state(), m_msw(), m_lsw(), 
+  m_r_flag( false )
+{
+    if( a != 0 )
+    {
+        m_mant.clear();
+	m_wp = m_msw = m_lsw = 2;
+	m_state = normal;
+	if( a > 0 )
+	{
+	    m_mant[2] = a;
+	    m_sign = 1;
+	}
+	else
+	{
+	    m_mant[2] = -a;
+	    m_sign = -1;
+	}
+    }
+    else
+        set_zero();
+}
+
+scfx_rep::scfx_rep( unsigned int a )
+: m_mant( min_mant ), m_wp(), m_sign(), m_state(), m_msw(), m_lsw(), 
+  m_r_flag( false )
+{
+    if( a != 0 )
+    {
+        m_mant.clear();
+	m_wp = m_msw = m_lsw = 2;
+	m_state = normal;
+	m_mant[2] = a;
+	m_sign = 1;
+    }
+    else
+        set_zero();
+}
+
+scfx_rep::scfx_rep( long a )
+: m_mant( min_mant ), m_wp(), m_sign(), m_state(), m_msw(), m_lsw(), 
+  m_r_flag( false )
+{
+    if( a != 0 )
+    {
+        m_mant.clear();
+	m_state = normal;
+        if ( a > 0 )
+        {
+	    m_sign = 1;
+        }
+        else
+        {
+            a = -a;
+            m_sign = -1;
+        } 
+#       if defined(SC_LONG_64)
+            m_wp = 1;
+            m_mant[1] = static_cast<word>( a );
+            m_mant[2] = static_cast<word>( a >> bits_in_word );
+	    find_sw();
+#       else
+            m_wp = 2;
+            m_msw = 2;
+            m_lsw = 2;
+            m_mant[2] = a;
+#       endif
+
+    }
+    else
+        set_zero();
+}
+
+scfx_rep::scfx_rep( unsigned long a )
+: m_mant( min_mant ), m_wp(), m_sign(), m_state(), m_msw(), m_lsw(), 
+  m_r_flag( false )
+{
+    if( a != 0 )
+    {
+        m_mant.clear();
+	m_wp = m_msw = m_lsw = 2;
+	m_state = normal;
+#       if defined(SC_LONG_64)
+	    m_wp = 1;
+	    m_mant[1] = static_cast<word>( a );
+	    m_mant[2] = static_cast<word>( a >> bits_in_word );
+	    find_sw();
+#       else
+	    m_wp = 2;
+	    m_msw = 2;
+	    m_lsw = 2;
+	    m_mant[2] = a;
+#	endif
+	m_sign = 1;
+    }
+    else
+        set_zero();
+}
+
+scfx_rep::scfx_rep( double a )
+: m_mant( min_mant ), m_wp( 0 ), m_sign(), m_state( normal ), m_msw( 0 ), 
+  m_lsw( 0 ), m_r_flag( false )
+{
+    m_mant.clear();
+
+    scfx_ieee_double id( a );
+
+    m_sign = id.negative() ? -1 : 1;
+
+    if( id.is_nan() )
+        m_state = not_a_number;
+    else if( id.is_inf() )
+        m_state = infinity;
+    else if( id.is_subnormal() )
+    {
+	m_mant[0] = id.mantissa1();
+	m_mant[1] = id.mantissa0();
+	normalize( id.exponent() + 1 - SCFX_IEEE_DOUBLE_M_SIZE );
+    }
+    else if( id.is_normal() )
+    {
+	m_mant[0] = id.mantissa1();
+	m_mant[1] = id.mantissa0() | ( 1 << mantissa0_size );
+	normalize( id.exponent() - SCFX_IEEE_DOUBLE_M_SIZE );
+    }
+}
+
+scfx_rep::scfx_rep( int64 a )
+: m_mant( min_mant ), m_wp(), m_sign(), m_state(), m_msw(), m_lsw(), 
+  m_r_flag( false )
+{
+    if( a != 0 )
+    {
+        m_mant.clear();
+	m_wp = 1;
+	m_state = normal;
+	if( a > 0 )
+	{
+	    m_mant[1] = static_cast<word>( a );
+	    m_mant[2] = static_cast<word>( a >> bits_in_word );
+	    m_sign = 1;
+	}
+	else
+	{
+	    m_mant[1] = static_cast<word>( -a );
+	    m_mant[2] = static_cast<word>( (-a) >> bits_in_word );
+	    m_sign = -1;
+	}
+	find_sw();
+    }
+    else
+        set_zero();
+}
+
+scfx_rep::scfx_rep( uint64 a )
+: m_mant( min_mant ), m_wp(), m_sign(), m_state(), m_msw(), m_lsw(), 
+  m_r_flag( false )
+{
+    if( a != 0 )
+    {
+        m_mant.clear();
+	m_wp = 1;
+	m_state = normal;
+	m_mant[1] = static_cast<word>( a );
+	m_mant[2] = static_cast<word>( a >> bits_in_word );
+	m_sign = 1;
+	find_sw();
+    }
+    else
+        set_zero();
+}
+
+scfx_rep::scfx_rep( const sc_signed& a )
+: m_mant( min_mant ), m_wp(), m_sign(), m_state(), m_msw(), m_lsw(), 
+  m_r_flag( false )
+{
+    if( a.iszero() )
+	set_zero();
+    else
+    {
+	int words = n_word( a.length() );
+	if( words > size() )
+	    resize_to( words );
+	m_mant.clear();
+	m_wp = 0;
+	m_state = normal;
+	if( a.sign() )
+	{
+	    sc_signed a2 = -a;
+	    for( int i = 0; i < a2.length(); ++ i )
+	    {
+		if( a2[i] )
+		{
+		    scfx_index x = calc_indices( i );
+		    m_mant[x.wi()] |= 1 << x.bi();
+		}
+	    }
+	    m_sign = -1;
+	}
+	else
+	{
+	    for( int i = 0; i < a.length(); ++ i )
+	    {
+		if( a[i] )
+		{
+		    scfx_index x = calc_indices( i );
+		    m_mant[x.wi()] |= 1 << x.bi();
+		}
+	    }
+	    m_sign = 1;
+	}
+	find_sw();
+    }
+}
+
+scfx_rep::scfx_rep( const sc_unsigned& a )
+: m_mant( min_mant ), m_wp(), m_sign(), m_state(), m_msw(), m_lsw(), 
+  m_r_flag( false )
+{
+    if( a.iszero() )
+	set_zero();
+    else
+    {
+	int words = n_word( a.length() );
+	if( words > size() )
+	    resize_to( words );
+	m_mant.clear();
+	m_wp = 0;
+	m_state = normal;
+	for( int i = 0; i < a.length(); ++ i )
+	{
+	    if( a[i] )
+	    {
+		scfx_index x = calc_indices( i );
+		m_mant[x.wi()] |= 1 << x.bi();
+	    }
+	}
+	m_sign = 1;
+	find_sw();
+    }
+}
+
+
+// copy constructor
+
+scfx_rep::scfx_rep( const scfx_rep& a )
+: m_mant( a.m_mant ), m_wp( a.m_wp ), m_sign( a.m_sign ), m_state( a.m_state ),
+  m_msw( a.m_msw ), m_lsw( a.m_lsw ), m_r_flag( false )
+{}
+
+
+// ----------------------------------------------------------------------------
+//  OPERATORS : new, delete
+//
+//  Memory management for class scfx_rep.
+// ----------------------------------------------------------------------------
+
+union scfx_rep_node
+{
+    char           data[sizeof( scfx_rep )];
+    scfx_rep_node* next;
+};
+
+
+static scfx_rep_node* list = 0;
+
+
+void*
+scfx_rep::operator new( std::size_t size )
+{
+    const int ALLOC_SIZE = 1024;
+
+    if( size != sizeof( scfx_rep ) )
+	return ::operator new( size );
+
+    if( ! list )
+    {
+	list = new scfx_rep_node[ALLOC_SIZE];
+	for( int i = 0; i < ALLOC_SIZE - 1; i ++ )
+	    list[i].next = list + i + 1;
+	list[ALLOC_SIZE - 1].next = 0;
+    }
+
+    scfx_rep* ptr = reinterpret_cast<scfx_rep*>( list->data );
+    list = list->next;
+
+    return ptr;
+}
+
+
+void scfx_rep::operator delete( void* ptr, std::size_t size )
+{
+    if( size != sizeof( scfx_rep ) )
+    {
+	::operator delete( ptr );
+	return;
+    }
+
+    scfx_rep_node* node = static_cast<scfx_rep_node*>( ptr );
+    node->next = list;
+    list = node;
+}
+
+
+// ----------------------------------------------------------------------------
+//  METHOD : from_string
+//
+//  Convert from character string to sc_fxrep.
+// ----------------------------------------------------------------------------
+
+#define SCFX_FAIL_IF_(cnd)                                                    \
+{                                                                             \
+    if( ( cnd ) )                                                             \
+    {                                                                         \
+        m_state = not_a_number;                                               \
+	m_mant.clear(); /* to avoid Purify UMRs during assignment */          \
+        return;                                                               \
+    }                                                                         \
+}
+
+
+void
+scfx_rep::from_string( const char* s, int cte_wl )
+{
+    SCFX_FAIL_IF_( s == 0 || *s == 0 );
+
+    scfx_string s2;
+    s2 += s;
+    s2 += '\0';
+
+    bool sign_char;
+    m_sign = scfx_parse_sign( s, sign_char );
+
+    sc_numrep numrep = scfx_parse_prefix( s );
+
+    int base = 0;
+
+    switch( numrep )
+    {
+	case SC_DEC:
+	{
+	    base = 10;
+	    if( scfx_is_nan( s ) )
+	    {   // special case: NaN
+		m_state = not_a_number;
+		m_mant.clear(); /* to avoid Purify UMRs during assignment */
+		return;
+	    }
+	    if( scfx_is_inf( s ) )
+	    {   // special case: Infinity
+		m_state = infinity;
+		m_mant.clear(); /* to avoid Purify UMRs during assignment */
+		return;
+	    }
+	    break;
+	}
+	case SC_BIN:
+	case SC_BIN_US:
+	{
+	    SCFX_FAIL_IF_( sign_char );
+	    base = 2;
+	    break;
+	}
+	
+	case SC_BIN_SM:
+	{
+	    base = 2;
+	    break;
+	}
+	case SC_OCT:
+	case SC_OCT_US:
+	{
+	    SCFX_FAIL_IF_( sign_char );
+	    base = 8;
+	    break;
+	}
+	case SC_OCT_SM:
+	{
+	    base = 8;
+	    break;
+	}
+	case SC_HEX:
+	case SC_HEX_US:
+	{
+	    SCFX_FAIL_IF_( sign_char );
+	    base = 16;
+	    break;
+	}
+	case SC_HEX_SM:
+	{
+	    base = 16;
+	    break;
+	}
+	case SC_CSD:
+	{
+	    SCFX_FAIL_IF_( sign_char );
+	    base = 2;
+	    scfx_csd2tc( s2 );
+	    s = (const char*) s2 + 4;
+	    numrep = SC_BIN;
+	    break;
+	}
+        default:;
+    }
+
+    //
+    // find end of mantissa and count the digits and points
+    //
+
+    const char *end = s;
+    bool based_point = false;
+    int int_digits = 0;
+    int frac_digits = 0;
+
+    while( *end )
+    {
+	if( scfx_exp_start( end ) )
+	    break;
+	
+	if( *end == '.' )
+	{
+	    SCFX_FAIL_IF_( based_point );
+	    based_point = true;
+	}
+	else
+	{
+	    SCFX_FAIL_IF_( ! scfx_is_digit( *end, numrep ) );
+	    if( based_point )
+		frac_digits ++;
+	    else
+		int_digits ++;
+	}
+
+	++ end;
+    }
+
+    SCFX_FAIL_IF_( int_digits == 0 && frac_digits == 0 );
+
+    // [ exponent ]
+    
+    int exponent = 0;
+
+    if( *end )
+    {
+	for( const char *e = end + 2; *e; ++ e )
+	    SCFX_FAIL_IF_( ! scfx_is_digit( *e, SC_DEC ) );
+	exponent = atoi( end + 1 );
+    }
+
+    //
+    // check if the mantissa is negative
+    //
+
+    bool mant_is_neg = false;
+
+    switch( numrep )
+    {
+	case SC_BIN:
+	case SC_OCT:
+	case SC_HEX:
+	{
+	    const char* p = s;
+	    if( *p == '.' )
+		++ p;
+
+	    mant_is_neg = ( scfx_to_digit( *p, numrep ) >= ( base >> 1 ) );
+
+	    break;
+	}
+	default:
+	    ;
+    }
+
+    //
+    // convert the mantissa
+    //
+
+    switch( base )
+    {
+        case 2:
+	{
+	    int bit_offset = exponent % bits_in_word;
+	    int word_offset = exponent / bits_in_word;
+
+	    int_digits += bit_offset;
+	    frac_digits -= bit_offset;
+
+	    int words = n_word( int_digits ) + n_word( frac_digits );
+	    if( words > size() )
+		resize_to( words );
+	    m_mant.clear();
+
+	    int j = n_word( frac_digits ) * bits_in_word + int_digits - 1;
+	    
+	    for( ; s < end; s ++ )
+	    {
+		switch( *s )
+		{
+		    case '1':
+		        set_bin( j );
+		    case '0':
+			j --;
+		    case '.':
+			break;
+		    default:
+			SCFX_FAIL_IF_( true );  // should not happen
+		}
+	    }
+
+	    m_wp = n_word( frac_digits ) - word_offset;
+	    break;
+	}
+        case 8:
+	{
+	    exponent *= 3;
+	    int_digits *= 3;
+	    frac_digits *= 3;
+
+	    int bit_offset = exponent % bits_in_word;
+	    int word_offset = exponent / bits_in_word;
+
+	    int_digits += bit_offset;
+	    frac_digits -= bit_offset;
+
+	    int words = n_word( int_digits ) + n_word( frac_digits );
+	    if( words > size() )
+		resize_to( words );
+	    m_mant.clear();
+
+	    int j = n_word( frac_digits ) * bits_in_word + int_digits - 3;
+	    
+	    for( ; s < end; s ++ )
+	    {
+		switch( *s )
+		{
+		    case '7': case '6': case '5': case '4':
+		    case '3': case '2': case '1':
+		        set_oct( j, *s - '0' );
+		    case '0':
+			j -= 3;
+		    case '.':
+			break;
+		    default:
+			SCFX_FAIL_IF_( true );  // should not happen
+		}
+	    }
+
+	    m_wp = n_word( frac_digits ) - word_offset;
+	    break;
+	}
+        case 10:
+	{
+	    word carry, temp;
+	    int length = int_digits + frac_digits;
+	    resize_to( sc_max( min_mant, n_word( 4 * length ) ) );
+
+	    m_mant.clear();
+	    m_msw = m_lsw = 0;
+	    
+	    for( ; s < end; s ++ )
+	    {
+		switch( *s )
+		{
+		    case '9': case '8': case '7': case '6': case '5':
+		    case '4': case '3': case '2': case '1': case '0':
+		        multiply_by_ten();
+			carry = *s - '0';
+			for ( int i = 0; carry && i < m_mant.size(); i++ )
+			{
+			    temp = m_mant[i];
+                            temp += carry;			    
+			    carry = temp < m_mant[i];
+			    m_mant[i] = temp;
+			}
+		    case '.':
+			break;
+		    default:
+			SCFX_FAIL_IF_( true );  // should not happen
+		}
+	    }
+	    
+	    m_wp = 0;
+	    find_sw();
+
+	    int denominator = frac_digits - exponent;
+	    
+	    if( denominator )
+	    {
+		scfx_rep frac_num = pow10_fx( denominator );
+		scfx_rep* temp_num =
+		    div_scfx_rep( const_cast<const scfx_rep&>( *this ),
+				   frac_num, cte_wl );
+		*this = *temp_num;
+		delete temp_num;
+	    }
+
+	    break;
+	}
+        case 16:
+	{
+	    exponent *= 4;
+	    int_digits *= 4;
+	    frac_digits *= 4;
+
+	    int bit_offset = exponent % bits_in_word;
+	    int word_offset = exponent / bits_in_word;
+
+	    int_digits += bit_offset;
+	    frac_digits -= bit_offset;
+
+	    int words = n_word( int_digits ) + n_word( frac_digits );
+	    if( words > size() )
+		resize_to( words );
+	    m_mant.clear();
+
+	    int j = n_word( frac_digits ) * bits_in_word + int_digits - 4;
+	    
+	    for( ; s < end; s ++ )
+	    {
+		switch( *s )
+		{
+		    case 'f': case 'e': case 'd': case 'c': case 'b': case 'a':
+		       set_hex( j, *s - 'a' + 10 );
+		       j -= 4;
+		       break;
+		    case 'F': case 'E': case 'D': case 'C': case 'B': case 'A':
+		       set_hex( j, *s - 'A' + 10 );
+		       j -= 4;
+		       break;
+		    case '9': case '8': case '7': case '6': case '5':
+		    case '4': case '3': case '2': case '1':
+		       set_hex( j, *s - '0' );
+		    case '0':
+		       j -= 4;
+		    case '.':
+		       break;
+		   default:
+		       SCFX_FAIL_IF_( true );  // should not happen
+		}
+	    }
+
+	    m_wp = n_word( frac_digits ) - word_offset;
+	    break;
+	}
+    }
+
+    m_state = normal;
+    find_sw();
+
+    //
+    // two's complement of mantissa if it is negative
+    //
+
+    if( mant_is_neg )
+    {
+	m_mant[m_msw] |=  -1 << scfx_find_msb( m_mant[m_msw] );
+	for( int i = m_msw + 1; i < m_mant.size(); ++ i )
+	    m_mant[i] = static_cast<word>( -1 );
+	complement( m_mant, m_mant, m_mant.size() );
+	inc( m_mant );
+	m_sign *= -1;
+	find_sw();
+    }
+}
+
+
+#undef SCFX_FAIL_IF_
+
+
+// ----------------------------------------------------------------------------
+//  METHOD : to_double
+//
+//  Convert from scfx_rep to double.
+// ----------------------------------------------------------------------------
+
+double
+scfx_rep::to_double() const 
+{
+    scfx_ieee_double id;
+
+    // handle special cases
+
+    if( is_nan() )
+    {
+        id.set_nan();
+	return id;
+    }
+
+    if( is_inf() )
+    {
+        id.set_inf();
+	id.negative( m_sign < 0 );
+	return id;
+    }
+
+    if( is_zero() )
+    {
+	id = 0.;
+	id.negative( m_sign < 0 );
+	return id;
+    }
+
+    int msb = scfx_find_msb( m_mant[m_msw] );
+
+    int exp = (m_msw - m_wp) * bits_in_word + msb;
+
+    if( exp > SCFX_IEEE_DOUBLE_E_MAX )
+    {
+	id.set_inf();
+	id.negative( m_sign < 0 );
+	return id;
+    }
+
+    if( exp < SCFX_IEEE_DOUBLE_E_MIN
+	- static_cast<int>( SCFX_IEEE_DOUBLE_M_SIZE ) )
+    {
+	id = 0.;
+	return id;
+    }
+ 
+    int shift = mantissa0_size - msb;
+
+    unsigned int m0;
+    unsigned int m1 = 0;
+    unsigned int guard = 0;
+
+    if( shift == 0 )
+    {
+        m0 = m_mant[m_msw] & ~( 1 << mantissa0_size );
+	if( m_msw > m_lsw )
+	{
+	    m1 = m_mant[m_msw - 1];
+	    if( m_msw - 1 > m_lsw )
+	        guard = m_mant[m_msw - 2] >> ( bits_in_word - 1 );
+	}
+    }
+    else if( shift < 0 )
+    {
+	m0 = ( m_mant[m_msw] >> -shift ) & ~( 1 << mantissa0_size );
+	m1 = m_mant[m_msw] << ( bits_in_word + shift );
+	if( m_msw > m_lsw )
+	{
+	    m1 |= m_mant[m_msw - 1] >> -shift;
+	    guard = ( m_mant[m_msw - 1] >> ( -shift - 1 ) ) & 1;
+	}
+    }
+    else
+    {
+	m0 = ( m_mant[m_msw] << shift ) & ~( 1 << mantissa0_size );
+	if( m_msw > m_lsw )
+	{
+	    m0 |= m_mant[m_msw - 1] >> ( bits_in_word - shift );
+	    m1 = m_mant[m_msw - 1] << shift;
+	    if( m_msw - 1 > m_lsw )
+	    {
+	        m1 |= m_mant[m_msw - 2] >> ( bits_in_word - shift );
+		guard = ( m_mant[m_msw - 2] >> (bits_in_word - shift - 1) )
+                      & 1;
+	    }      
+	}
+    }
+
+    if( exp < SCFX_IEEE_DOUBLE_E_MIN )
+    {
+	m0 |= ( 1 << mantissa0_size );
+
+	int subnormal_shift = SCFX_IEEE_DOUBLE_E_MIN - exp;
+
+	if( subnormal_shift < bits_in_word )
+	{
+	    m1 = m1 >> subnormal_shift
+	       | m0 << ( bits_in_word - subnormal_shift );
+	    m0 = m0 >> subnormal_shift;
+	}
+	else
+	{
+	    m1 = m0 >> ( subnormal_shift - bits_in_word );
+	    m0 = 0;
+	}
+
+	guard = 0;
+
+	exp = SCFX_IEEE_DOUBLE_E_MIN - 1;
+    }
+
+    id.mantissa0( m0 );
+    id.mantissa1( m1 );
+    id.exponent( exp );
+    id.negative( m_sign < 0 );
+
+    double result = id;
+
+    if( guard != 0 )
+        result += m_sign * scfx_pow2( exp - SCFX_IEEE_DOUBLE_M_SIZE );
+
+    return result;
+}
+
+
+// ----------------------------------------------------------------------------
+//  METHOD : to_string
+//
+//  Convert from scfx_rep to character string.
+// ----------------------------------------------------------------------------
+
+void
+print_dec( scfx_string& s, const scfx_rep& num, int w_prefix, sc_fmt fmt )
+{
+    if( num.is_neg() )
+	s += '-';
+
+    if( w_prefix == 1 ) {
+	scfx_print_prefix( s, SC_DEC );
+    }
+
+    if( num.is_zero() )
+    {
+	s += '0';
+	return;
+    }
+
+    // split 'num' into its integer and fractional part
+
+    scfx_rep int_part  = num;
+    scfx_rep frac_part = num;
+
+    int i;
+    
+    for( i = int_part.m_lsw; i <= int_part.m_msw && i < int_part.m_wp; i ++ )
+	int_part.m_mant[i] = 0;
+    int_part.find_sw();
+    if( int_part.m_wp < int_part.m_lsw )
+	int_part.resize_to( int_part.size() - int_part.m_wp, -1 );
+    
+    for( i = frac_part.m_msw;
+	 i >= frac_part.m_lsw && i >= frac_part.m_wp;
+	 i -- )
+	frac_part.m_mant[i] = 0;
+    frac_part.find_sw();
+    if( frac_part.m_msw == frac_part.size() - 1 )
+	frac_part.resize_to( frac_part.size() + 1, 1 );
+
+    // print integer part
+
+    int int_digits = 0;
+    int int_zeros  = 0;
+    
+    if( ! int_part.is_zero() )
+    {
+	double int_wl = ( int_part.m_msw - int_part.m_wp ) * bits_in_word
+	              + scfx_find_msb( int_part.m_mant[int_part.m_msw] ) + 1;
+	int_digits = (int) ceil( int_wl * log10( 2. ) );
+
+	int len = s.length();
+	s.append( int_digits );
+
+	bool zero_digits = ( frac_part.is_zero() && fmt != SC_F );
+
+	for( i = int_digits + len - 1; i >= len; i-- )
+	{
+	    unsigned int remainder = int_part.divide_by_ten();
+	    s[i] = static_cast<char>( '0' + remainder );
+	    
+	    if( zero_digits )
+	    {
+		if( remainder == 0 )
+		    int_zeros ++;
+		else
+		    zero_digits = false;
+	    }
+	}
+
+	// discard trailing zeros from int_part
+	s.discard( int_zeros );
+
+	if( s[len] == '0' )
+	{
+	    // int_digits was overestimated by one
+	    s.remove( len );
+	    -- int_digits;
+	}
+    }
+
+    // print fractional part
+
+    int frac_digits = 0;
+    int frac_zeros  = 0;
+
+    if( ! frac_part.is_zero() )
+    {
+	s += '.';
+
+	bool zero_digits = ( int_digits == 0 && fmt != SC_F );
+
+	double frac_wl = ( frac_part.m_wp - frac_part.m_msw ) * bits_in_word
+	               - scfx_find_msb( frac_part.m_mant[frac_part.m_msw] )
+                       - 1;
+	frac_zeros = (int) floor( frac_wl * log10( 2. ) );
+
+	scfx_rep temp;
+	sc_dt::multiply( temp, frac_part, pow10_fx( frac_zeros ) );
+	frac_part = temp;
+	if( frac_part.m_msw == frac_part.size() - 1 )
+	    frac_part.resize_to( frac_part.size() + 1, 1 );
+	
+	frac_digits = frac_zeros;
+	if( ! zero_digits )
+	{
+	    for( i = 0; i < frac_zeros; i ++ )
+		s += '0';
+	    frac_zeros = 0;
+	}
+
+	while( ! frac_part.is_zero() )
+	{
+	    frac_part.multiply_by_ten();
+	    int n = frac_part.m_mant[frac_part.m_msw + 1];
+	
+	    if( zero_digits )
+	    {
+		if( n == 0 )
+		    frac_zeros ++;
+		else
+		    zero_digits = false;
+	    }
+	
+	    if( ! zero_digits )
+		s += static_cast<char>( '0' + n );
+
+	    frac_part.m_mant[frac_part.m_msw + 1] = 0;
+	    frac_digits ++;
+	}
+    }
+
+    // print exponent
+    
+    if( fmt != SC_F )
+    {
+        if( frac_digits == 0 )
+	    scfx_print_exp( s, int_zeros );
+	else if( int_digits == 0 )
+	    scfx_print_exp( s, - frac_zeros );
+    }
+}
+
+void
+print_other( scfx_string& s, const scfx_rep& a, sc_numrep numrep, int w_prefix,
+	     sc_fmt fmt, const scfx_params* params )
+{
+    scfx_rep b = a;
+
+    sc_numrep numrep2 = numrep;
+
+    bool numrep_is_sm = ( numrep == SC_BIN_SM ||
+			  numrep == SC_OCT_SM ||
+			  numrep == SC_HEX_SM );
+
+    if( numrep_is_sm )
+    {
+	if( b.is_neg() )
+	{
+	    s += '-';
+	    b = *neg_scfx_rep( a );
+	}
+	switch( numrep )
+	{
+	    case SC_BIN_SM:
+		numrep2 = SC_BIN_US;
+		break;
+	    case SC_OCT_SM:
+		numrep2 = SC_OCT_US;
+		break;
+	    case SC_HEX_SM:
+		numrep2 = SC_HEX_US;
+		break;
+	    default:
+		;
+	}
+    }
+    
+    if( w_prefix != 0 ) {
+	scfx_print_prefix( s, numrep );
+    }
+
+    numrep = numrep2;
+
+    int msb, lsb;
+
+    if( params != 0 )
+    {
+	msb = params->iwl() - 1;
+	lsb = params->iwl() - params->wl();
+
+	if( params->enc() == SC_TC_ &&
+	    ( numrep == SC_BIN_US ||
+	      numrep == SC_OCT_US ||
+	      numrep == SC_HEX_US ) &&
+	    ! numrep_is_sm &&
+	    params->wl() > 1 )
+	    -- msb;
+	else if( params->enc() == SC_US_ &&
+	    ( numrep == SC_BIN ||
+	      numrep == SC_OCT ||
+	      numrep == SC_HEX ||
+	      numrep == SC_CSD ) )
+	    ++ msb;
+    }
+    else
+    {
+	if( b.is_zero() )
+	{
+	    msb = 0;
+	    lsb = 0;
+	}
+	else
+	{
+	    msb = ( b.m_msw - b.m_wp ) * bits_in_word
+		+ scfx_find_msb( b.m_mant[ b.m_msw ] ) + 1;
+	    while( b.get_bit( msb ) == b.get_bit( msb - 1 ) )
+		-- msb;
+
+	    if( numrep == SC_BIN_US ||
+		numrep == SC_OCT_US ||
+		numrep == SC_HEX_US )
+		-- msb;
+
+	    lsb = ( b.m_lsw - b.m_wp ) * bits_in_word
+		+ scfx_find_lsb( b.m_mant[ b.m_lsw ] );
+	}
+    }
+
+    int step;
+
+    switch( numrep )
+    {
+	case SC_BIN:
+	case SC_BIN_US:
+	case SC_CSD:
+	    step = 1;
+	   break;
+	case SC_OCT:
+	case SC_OCT_US:
+	    step = 3;
+	    break;
+	case SC_HEX:
+	case SC_HEX_US:
+	    step = 4;
+	    break;
+	default:
+	    step = 0;
+    }
+
+    msb = (int) ceil( double( msb + 1 ) / step ) * step - 1;
+
+    lsb = (int) floor( double( lsb ) / step ) * step;
+
+    if( msb < 0 )
+    {
+	s += '.';
+	if( fmt == SC_F )
+	{
+	    int sign = ( b.is_neg() ) ? ( 1 << step ) - 1 : 0;
+	    for( int i = ( msb + 1 ) / step; i < 0; i ++ )
+	    {
+		if( sign < 10 )
+		    s += static_cast<char>( sign + '0' );
+		else
+		    s += static_cast<char>( sign + 'a' - 10 );
+	    }
+	}
+    }
+
+    int i = msb;
+    while( i >= lsb )
+    {
+        int value = 0;
+        for( int j = step - 1; j >= 0; -- j )
+	{
+            value += static_cast<int>( b.get_bit( i ) ) << j;
+            -- i;
+        }
+        if( value < 10 )
+            s += static_cast<char>( value + '0' );
+	else
+            s += static_cast<char>( value + 'a' - 10 );
+	if( i == -1 )
+	    s += '.';
+    }
+
+    if( lsb > 0 && fmt == SC_F )
+    {
+	for( int i = lsb / step; i > 0; i -- )
+	    s += '0';
+    }
+
+    if( s[s.length() - 1] == '.' )
+	s.discard( 1 );
+
+    if( fmt != SC_F )
+    {
+	if( msb < 0 )
+	    scfx_print_exp( s, ( msb + 1 ) / step );
+	else if( lsb > 0 )
+	    scfx_print_exp( s, lsb / step );
+    }
+
+    if( numrep == SC_CSD )
+	scfx_tc2csd( s, w_prefix );
+}
+
+const char*
+scfx_rep::to_string( sc_numrep numrep, int w_prefix,
+		     sc_fmt fmt, const scfx_params* params ) const
+{
+    static scfx_string s;
+
+    s.clear();
+
+    if( is_nan() )
+        scfx_print_nan( s );
+    else if( is_inf() )
+        scfx_print_inf( s, is_neg() );
+    else if( is_neg() && ! is_zero() &&
+	     ( numrep == SC_BIN_US ||
+	       numrep == SC_OCT_US ||
+	       numrep == SC_HEX_US ) )
+        s += "negative";
+    else if( numrep == SC_DEC || numrep == SC_NOBASE )
+        sc_dt::print_dec( s, *this, w_prefix, fmt );
+    else
+        sc_dt::print_other( s, *this, numrep, w_prefix, fmt, params );
+
+    return s;
+}
+
+
+// ----------------------------------------------------------------------------
+//  ADD
+//
+//  add two mantissas of the same size
+//  result has the same size
+//  returns carry of operation
+// ----------------------------------------------------------------------------
+
+static inline
+int
+add_mants( int size, scfx_mant& result,
+	   const scfx_mant& a, const scfx_mant& b )
+{
+    unsigned int carry = 0;
+
+    int index = 0;
+
+    do
+    {
+        word x = a[index];
+	word y = b[index];
+
+	y += carry;
+	carry = y < carry;
+	y += x;
+	carry += y < x;
+	result[index] = y;
+    }
+    while( ++ index < size );
+
+    return ( carry ? 1 : 0 );
+}
+
+
+static inline
+int
+sub_mants( int size, scfx_mant& result,
+	   const scfx_mant& a, const scfx_mant& b )
+{
+    unsigned carry = 0;
+
+    int index = 0;
+
+    do
+    {
+	word x = a[index];
+	word y = b[index];
+
+	y += carry;
+	carry = y < carry;
+	y = x - y;
+	carry += y > x;
+	result[index] = y;
+    }
+    while( ++ index < size );
+
+    return ( carry ? 1 : 0 );
+}
+
+
+scfx_rep*
+add_scfx_rep( const scfx_rep& lhs, const scfx_rep& rhs, int max_wl )
+{
+    scfx_rep& result = *new scfx_rep;
+
+    //
+    // check for special cases
+    //
+
+    if( lhs.is_nan() || rhs.is_nan()
+    ||  ( lhs.is_inf() && rhs.is_inf() && lhs.m_sign != rhs.m_sign ) )
+    {
+	result.set_nan();
+	return &result;
+    }
+
+    if( lhs.is_inf() )
+    {
+	result.set_inf( lhs.m_sign );
+	return &result;
+    }
+
+    if( rhs.is_inf() )
+    {
+	result.set_inf( rhs.m_sign );
+	return &result;
+    }
+
+    //
+    // align operands if needed
+    //
+
+    scfx_mant_ref lhs_mant;
+    scfx_mant_ref rhs_mant;
+
+    int len_mant = lhs.size();
+    int new_wp = lhs.m_wp;
+
+    align( lhs, rhs, new_wp, len_mant, lhs_mant, rhs_mant );
+
+    //
+    // size the result mantissa
+    //
+
+    result.resize_to( len_mant );
+    result.m_wp = new_wp;
+
+    //
+    // do it
+    //
+
+    if( lhs.m_sign == rhs.m_sign )
+    {
+	add_mants( len_mant, result.m_mant, lhs_mant, rhs_mant );
+	result.m_sign = lhs.m_sign;
+    }
+    else
+    {
+	int cmp = compare_abs( lhs, rhs );
+
+	if( cmp == 1 )
+	{
+	    sub_mants( len_mant, result.m_mant, lhs_mant, rhs_mant );
+	    result.m_sign = lhs.m_sign;
+	}
+	else if ( cmp == -1 )
+	{
+	    sub_mants( len_mant, result.m_mant, rhs_mant, lhs_mant );
+	    result.m_sign = rhs.m_sign;
+	}
+	else
+	{
+	    result.m_mant.clear();
+	    result.m_sign = 1;
+	}
+    }
+
+    result.find_sw();
+    result.round( max_wl );
+
+    return &result;
+}
+
+
+// ----------------------------------------------------------------------------
+//  SUB
+//
+//  sub two word's of the same size
+//  result has the same size
+//  returns carry of operation
+// ----------------------------------------------------------------------------
+
+static inline
+int
+sub_with_index(       scfx_mant& a, int a_msw, int /*a_lsw*/,
+		const scfx_mant& b, int b_msw, int b_lsw )
+{
+    unsigned carry = 0;
+
+    int size    = b_msw - b_lsw;
+    int a_index = a_msw - size;
+    int b_index = b_msw - size;
+
+    do
+    {
+	word x = a[a_index];
+	word y = b[b_index];
+
+	y += carry;
+	carry = y < carry;
+	y = x - y;
+	carry += y > x;
+	a[a_index] = y;
+
+	a_index ++;
+	b_index ++;
+    }
+    while( size -- );
+
+    if( carry )
+    {
+        // special case: a[a_msw + 1 ] == 1
+        a[a_msw + 1] = 0;
+    }
+
+    return ( carry ? 1 : 0 );
+}
+
+
+scfx_rep*
+sub_scfx_rep( const scfx_rep& lhs, const scfx_rep& rhs, int max_wl )
+{
+    scfx_rep& result = *new scfx_rep;
+
+    //
+    // check for special cases
+    //
+
+    if( lhs.is_nan() || rhs.is_nan()
+    ||  ( lhs.is_inf() && rhs.is_inf() && lhs.m_sign == rhs.m_sign ) )
+    {
+	result.set_nan();
+	return &result;
+    }
+
+    if( lhs.is_inf() )
+    {
+	result.set_inf( lhs.m_sign );
+	return &result;
+    }
+
+    if( rhs.is_inf() )
+    {
+	result.set_inf( -1 * rhs.m_sign );
+	return &result;
+    }
+
+    //
+    // align operands if needed
+    //
+
+    scfx_mant_ref lhs_mant;
+    scfx_mant_ref rhs_mant;
+
+    int len_mant = lhs.size();
+    int new_wp = lhs.m_wp;
+
+    align( lhs, rhs, new_wp, len_mant, lhs_mant, rhs_mant );
+
+    //
+    // size the result mantissa
+    //
+
+    result.resize_to( len_mant );
+    result.m_wp = new_wp;
+
+    //
+    // do it
+    //
+
+    if( lhs.m_sign != rhs.m_sign )
+    {
+	add_mants( len_mant, result.m_mant, lhs_mant, rhs_mant );
+	result.m_sign = lhs.m_sign;
+    }
+    else
+    {
+	int cmp = compare_abs( lhs, rhs );
+
+	if( cmp == 1 )
+	{
+	    sub_mants( len_mant, result.m_mant, lhs_mant, rhs_mant );
+	    result.m_sign = lhs.m_sign;
+	}
+	else if ( cmp == -1 )
+	{
+	    sub_mants( len_mant, result.m_mant, rhs_mant, lhs_mant );
+	    result.m_sign = -rhs.m_sign;
+	} else {
+	    result.m_mant.clear();
+	    result.m_sign = 1;
+	}
+    }
+
+    result.find_sw();
+    result.round( max_wl );
+
+    return &result;
+}
+
+
+// ----------------------------------------------------------------------------
+//  MUL
+// ----------------------------------------------------------------------------
+
+union word_short
+{
+    word l;
+    struct
+    {
+#if defined( SC_BIG_ENDIAN )
+        half_word u;
+        half_word l;
+#elif defined( SC_LITTLE_ENDIAN )
+        half_word l;
+        half_word u;
+#endif
+    } s;
+};
+
+
+#if defined( SC_BIG_ENDIAN )
+static const int half_word_incr = -1;
+#elif defined( SC_LITTLE_ENDIAN )
+static const int half_word_incr = 1;
+#endif
+
+
+void
+multiply( scfx_rep& result, const scfx_rep& lhs, const scfx_rep& rhs,
+	  int max_wl )
+{
+    //
+    // check for special cases
+    //
+
+    if( lhs.is_nan() || rhs.is_nan()
+    ||  (lhs.is_inf() && rhs.is_zero())
+    ||  (lhs.is_zero() && rhs.is_inf()) )
+    {
+	result.set_nan();
+	return;
+    }
+
+    if( lhs.is_inf() || rhs.is_inf() )
+    {
+	result.set_inf( lhs.m_sign * rhs.m_sign );
+	return;
+    }
+    
+    if( lhs.is_zero() || rhs.is_zero() ) {
+	result.set_zero( lhs.m_sign * rhs.m_sign );
+	return;
+    }
+
+    //
+    // do it
+    //
+
+    int len_lhs = lhs.m_msw - lhs.m_lsw + 1;
+    int len_rhs = rhs.m_msw - rhs.m_lsw + 1;
+
+    int new_size = sc_max( min_mant, len_lhs + len_rhs );
+    int new_wp   = ( lhs.m_wp - lhs.m_lsw ) + ( rhs.m_wp - rhs.m_lsw );
+    int new_sign = lhs.m_sign * rhs.m_sign;
+
+    result.resize_to( new_size );
+    result.m_mant.clear();
+    result.m_wp    = new_wp;
+    result.m_sign  = new_sign;
+    result.m_state = scfx_rep::normal;
+
+    half_word *s1 = lhs.m_mant.half_addr( lhs.m_lsw );
+    half_word *s2 = rhs.m_mant.half_addr( rhs.m_lsw );
+
+    half_word *t = result.m_mant.half_addr();
+
+    len_lhs <<= 1;
+    len_rhs <<= 1;
+
+    int i1, i2;
+
+    for( i1 = 0; i1 * half_word_incr < len_lhs; i1 += half_word_incr )
+    {
+	word_short ls;
+	ls.l = 0;
+
+	half_word v1 = s1[i1];
+
+	for( i2  = 0; i2 * half_word_incr < len_rhs; i2 += half_word_incr )
+	{
+	    ls.l  += v1 * s2[i2];
+	    ls.s.l = ls.s.u + ( ( t[i2] += ls.s.l ) < ls.s.l );
+	    ls.s.u = 0;
+	}
+
+	t[i2] = ls.s.l;
+	t += half_word_incr;
+    }
+
+    result.find_sw();
+    result.round( max_wl );
+}
+
+
+// ----------------------------------------------------------------------------
+//  DIV
+// ----------------------------------------------------------------------------
+
+scfx_rep*
+div_scfx_rep( const scfx_rep& lhs, const scfx_rep& rhs, int div_wl )
+{
+    scfx_rep& result = *new scfx_rep;
+
+    //
+    // check for special cases
+    //
+
+    if( lhs.is_nan() || rhs.is_nan() || (lhs.is_inf() && rhs.is_inf()) ||
+	(lhs.is_zero() && rhs.is_zero()) )
+    {
+	result.set_nan();
+	return &result;
+    }
+
+    if( lhs.is_inf() || rhs.is_zero() )
+    {
+	result.set_inf( lhs.m_sign * rhs.m_sign );
+	return &result;
+    }
+
+    if( lhs.is_zero() || rhs.is_inf() )
+    {
+	result.set_zero( lhs.m_sign * rhs.m_sign );
+	return &result;
+    }
+
+    //
+    // do it
+    //
+
+    // compute one bit more for rounding
+    div_wl ++;
+
+    result.resize_to( sc_max( n_word( div_wl ) + 1, min_mant ) );
+    result.m_mant.clear();
+    result.m_sign = lhs.m_sign * rhs.m_sign;
+
+    int msb_lhs = scfx_find_msb( lhs.m_mant[lhs.m_msw] )
+	        + ( lhs.m_msw - lhs.m_wp ) * bits_in_word;
+    int msb_rhs = scfx_find_msb( rhs.m_mant[rhs.m_msw] )
+	        + ( rhs.m_msw - rhs.m_wp ) * bits_in_word;
+
+    int msb_res = msb_lhs - msb_rhs;
+    int to_shift = -msb_res % bits_in_word;
+    int result_index;
+
+    int c = ( msb_res % bits_in_word >= 0 ) ? 1 : 0;
+
+    result_index = (result.size() - c) * bits_in_word + msb_res % bits_in_word;
+    result.m_wp   = (result.size() - c) - msb_res / bits_in_word;
+
+    scfx_rep remainder = lhs;
+
+    // align msb from remainder to msb from rhs
+    remainder.lshift( to_shift );
+
+    // make sure msw( remainder ) < size - 1
+    if( remainder.m_msw == remainder.size() - 1 )
+	remainder.resize_to( remainder.size() + 1, 1 );
+
+    // make sure msw( remainder ) >= msw( rhs )!
+    int msw_diff = rhs.m_msw - remainder.m_msw;
+    if (msw_diff > 0)
+	remainder.resize_to( remainder.size() + msw_diff, -1 );
+
+    int counter;
+
+    for( counter = div_wl; counter && ! remainder.is_zero(); counter -- )
+    {
+	if( compare_msw_ff( rhs, remainder ) <= 0 )
+	{
+	    result.set_bin( result_index );
+	    sub_with_index( remainder.m_mant, remainder.m_msw, remainder.m_lsw,
+			    rhs.m_mant, rhs.m_msw, rhs.m_lsw );
+	}
+	result_index --;
+	remainder.shift_left( 1 );
+        remainder.m_lsw = remainder.find_lsw();
+    }
+
+    // perform convergent rounding, if needed
+    if( counter == 0 )
+    {
+	int index = result_index + 1 - result.m_wp * bits_in_word;
+
+	scfx_index x = result.calc_indices( index );
+	scfx_index x1 = result.calc_indices( index + 1 );
+
+	if( result.o_bit_at( x ) && result.o_bit_at( x1 ) )
+	    result.q_incr( x );
+
+	result.m_r_flag = true;
+    }
+
+    result.find_sw();
+
+    return &result;
+}
+
+
+// ----------------------------------------------------------------------------
+//  destructive shift mantissa to the left
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::lshift( int n )
+{
+    if( n == 0 )
+        return;
+
+    if( n < 0 )
+    {
+        rshift( -n );
+	return;
+    }
+
+    if( is_normal() )
+    {
+        int shift_bits  = n % bits_in_word;
+	int shift_words = n / bits_in_word;
+
+	// resize if needed
+	if( m_msw == size() - 1 &&
+	    scfx_find_msb( m_mant[m_msw] ) >= bits_in_word - shift_bits )
+	    resize_to( size() + 1, 1 );
+
+	// do it
+	m_wp -= shift_words;
+	shift_left( shift_bits );
+	find_sw();
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  destructive shift mantissa to the right
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::rshift( int n )
+{
+    if( n == 0 )
+        return;
+
+    if( n < 0 )
+    {
+        lshift( -n );
+	return;
+    }
+
+    if( is_normal() )
+    {
+        int shift_bits  = n % bits_in_word;
+	int shift_words = n / bits_in_word;
+
+	// resize if needed
+	if( m_lsw == 0 && scfx_find_lsb( m_mant[m_lsw] ) < shift_bits )
+	    resize_to( size() + 1, -1 );
+
+	// do it
+	m_wp += shift_words;
+	shift_right( shift_bits );
+	find_sw();
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  FRIEND FUNCTION : compare_abs
+//
+//  Compares the absolute values of two scfx_reps, excluding the special cases.
+// ----------------------------------------------------------------------------
+
+int
+compare_abs( const scfx_rep& a, const scfx_rep& b )
+{
+    // check for zero
+
+    word a_word = a.m_mant[a.m_msw];
+    word b_word = b.m_mant[b.m_msw];
+  
+    if( a_word == 0 || b_word == 0 )
+    {
+	if( a_word != 0 )
+	    return 1;
+	if( b_word != 0 )
+	    return -1;
+	return 0;
+    }
+
+    // compare msw index
+
+    int a_msw = a.m_msw - a.m_wp;
+    int b_msw = b.m_msw - b.m_wp;
+
+    if( a_msw > b_msw )
+	return 1;
+
+    if( a_msw < b_msw )
+	return -1;
+
+    // compare content
+
+    int a_i = a.m_msw;
+    int b_i = b.m_msw;
+
+    while( a_i >= a.m_lsw && b_i >= b.m_lsw )
+    {
+	a_word = a.m_mant[a_i];
+	b_word = b.m_mant[b_i];
+	if( a_word > b_word )
+	    return 1;
+	if( a_word < b_word )
+	    return -1;
+	-- a_i;
+	-- b_i;
+    }
+
+    bool a_zero = true;
+    while( a_i >= a.m_lsw )
+    {
+	a_zero = a_zero && ( a.m_mant[a_i] == 0 );
+	-- a_i;
+    }
+  
+    bool b_zero = true;
+    while( b_i >= b.m_lsw )
+    {
+	b_zero = b_zero && ( b.m_mant[b_i] == 0 );
+	-- b_i;
+    }
+
+    // assertion: a_zero || b_zero == true
+
+    if( ! a_zero && b_zero )
+	return 1;
+
+    if( a_zero && ! b_zero )
+	return -1;
+
+    return 0;
+}
+
+
+// ----------------------------------------------------------------------------
+//  FRIEND FUNCTION : cmp_scfx_rep
+//
+//  Compares the values of two scfx_reps, including the special cases.
+// ----------------------------------------------------------------------------
+
+int
+cmp_scfx_rep( const scfx_rep& a, const scfx_rep& b )
+{
+    // handle special cases
+
+    if( a.is_nan() || b.is_nan() )
+    {
+#if 0
+	if( a.is_nan() && b.is_nan() )
+	{
+	    return 0;
+	}
+#endif
+	return 2;
+    }
+
+    if( a.is_inf() || b.is_inf() )
+    {
+	if( a.is_inf() )
+	{
+	    if( ! a.is_neg() )
+	    {
+		if( b.is_inf() && ! b.is_neg() )
+		{
+		    return 0;
+		}
+		else
+		{
+		    return 1;
+		}
+	    }
+	    else
+	    {
+		if( b.is_inf() && b.is_neg() )
+		{
+		    return 0;
+		}
+		else
+		{
+		    return -1;
+		}
+	    }
+	}
+	if( b.is_inf() )
+	{
+	    if( ! b.is_neg() )
+	    {
+		return -1;
+	    }
+	    else
+	    {
+		return 1;
+	    }
+	}
+    }
+  
+    if( a.is_zero() && b.is_zero() )
+    {
+	return 0;
+    }
+
+    // compare sign
+
+    if( a.m_sign != b.m_sign )
+    {
+	return a.m_sign;
+    }
+
+    return ( a.m_sign * compare_abs( a, b ) );
+}
+
+
+// ----------------------------------------------------------------------------
+//  PRIVATE METHOD : quantization
+//
+//  Performs destructive quantization.
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::quantization( const scfx_params& params, bool& q_flag )
+{
+    scfx_index x = calc_indices( params.iwl() - params.wl() );
+
+    if( x.wi() < 0 )
+        return;
+
+    if( x.wi() >= size() )
+        resize_to( x.wi() + 1, 1 );
+
+    bool qb = q_bit( x );
+    bool qz = q_zero( x );
+
+    q_flag = ( qb || ! qz );
+
+    if( q_flag )
+    {
+        switch( params.q_mode() )
+	{
+            case SC_TRN:			// truncation
+	    {
+	        if( is_neg() )
+		    q_incr( x );
+		break;
+	    }
+            case SC_RND:			// rounding to plus infinity
+	    {
+	        if( ! is_neg() )
+		{
+		    if( qb )
+			q_incr( x );
+		}
+		else
+		{
+		    if( qb && ! qz )
+			q_incr( x );
+		}
+		break;
+	    }
+            case SC_TRN_ZERO:			// truncation to zero
+	    {
+	        break;
+	    }
+            case SC_RND_INF:			// rounding to infinity
+	    {
+	        if( qb )
+		    q_incr( x );
+		break;
+	    }
+            case SC_RND_CONV:			// convergent rounding
+	    {
+		if( (qb && ! qz) || (qb && qz && q_odd( x )) )
+		    q_incr( x );
+		break;
+	    }
+            case SC_RND_ZERO:			// rounding to zero
+	    {
+		if( qb && ! qz )
+		    q_incr( x );
+		break;
+	    }
+            case SC_RND_MIN_INF:		// rounding to minus infinity
+	    {
+		if( ! is_neg() )
+		{
+		    if( qb && ! qz )
+			q_incr( x );
+		}
+		else
+		{
+		    if( qb )
+			q_incr( x );
+		}
+		break;
+	    }
+            default:
+	        ;
+	}
+	q_clear( x );
+	
+	find_sw();
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  PRIVATE METHOD : overflow
+//
+//  Performs destructive overflow handling.
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::overflow( const scfx_params& params, bool& o_flag )
+{
+    scfx_index x = calc_indices( params.iwl() - 1 );
+
+    if( x.wi() >= size() )
+        resize_to( x.wi() + 1, 1 );
+
+    if( x.wi() < 0 )
+    {
+        resize_to( size() - x.wi(), -1 );
+        x.wi( 0 );
+    }
+
+    bool zero_left = o_zero_left( x );
+    bool bit_at = o_bit_at( x );
+    bool zero_right = o_zero_right( x );
+
+    bool under = false;
+    bool over = false;
+
+    sc_enc enc = params.enc();
+
+    if( enc == SC_TC_ )
+    {
+	if( is_neg() )
+	{
+	    if( params.o_mode() == SC_SAT_SYM )
+		under = ( ! zero_left || bit_at );
+	    else
+		under = (! zero_left || (zero_left && bit_at && ! zero_right));
+	}
+	else
+	    over = ( ! zero_left || bit_at );
+    }
+    else
+    {
+	if( is_neg() )
+	    under = ( ! is_zero() );
+        else
+	    over = ( ! zero_left );
+    }
+
+    o_flag = ( under || over );
+
+    if( o_flag )
+    {
+	scfx_index x2 = calc_indices( params.iwl() - params.wl() );
+
+	if( x2.wi() < 0 )
+	{
+	    resize_to( size() - x2.wi(), -1 );
+	    x.wi( x.wi() - x2.wi() );
+	    x2.wi( 0 );
+	}
+
+	switch( params.o_mode() )
+	{
+            case SC_WRAP:			// wrap-around
+	    {
+		int n_bits = params.n_bits();
+
+		if( n_bits == 0 )
+		{
+		    // wrap-around all 'wl' bits
+		    toggle_tc();
+		    o_extend( x, enc );
+		    toggle_tc();
+		}
+		else if( n_bits < params.wl() )
+		{
+		    scfx_index x3 = calc_indices( params.iwl() - 1 - n_bits );
+
+		    // wrap-around least significant 'wl - n_bits' bits;
+		    // saturate most significant 'n_bits' bits
+		    toggle_tc();
+		    o_set( x, x3, enc, under );
+		    o_extend( x, enc );
+		    toggle_tc();
+		}
+		else
+		{
+		    // saturate all 'wl' bits
+		    if( under )
+			o_set_low( x, enc );
+		    else
+			o_set_high( x, x2, enc );
+		}
+		break;
+	    }
+            case SC_SAT:			// saturation
+	    {
+		if( under )
+		    o_set_low( x, enc );
+		else
+		    o_set_high( x, x2, enc );
+		break;
+	    }
+            case SC_SAT_SYM:			// symmetrical saturation
+	    {
+		if( under )
+		{
+		    if( enc == SC_TC_ )
+			o_set_high( x, x2, SC_TC_, -1 );
+		    else
+			o_set_low( x, SC_US_ );
+		}
+		else
+		    o_set_high( x, x2, enc );
+		break;
+	    }
+            case SC_SAT_ZERO:			// saturation to zero
+	    {
+		set_zero();
+		break;
+	    }
+            case SC_WRAP_SM:			// sign magnitude wrap-around
+	    {
+		SC_ERROR_IF_( enc == SC_US_,
+			      sc_core::SC_ID_WRAP_SM_NOT_DEFINED_ );
+
+		int n_bits = params.n_bits();
+
+		if( n_bits == 0 )
+		{
+		    scfx_index x4 = calc_indices( params.iwl() );
+
+		    if( x4.wi() >= size() )
+			resize_to( x4.wi() + 1, 1 );
+
+		    toggle_tc();
+		    if( o_bit_at( x4 ) != o_bit_at( x ) )
+			o_invert( x2 );
+		    o_extend( x, SC_TC_ );
+		    toggle_tc();
+		}
+		else if( n_bits == 1 )
+		{
+		    toggle_tc();
+		    if( is_neg() != o_bit_at( x ) )
+			o_invert( x2 );
+		    o_extend( x, SC_TC_ );
+		    toggle_tc();
+		}
+		else if( n_bits < params.wl() )
+		{
+		    scfx_index x3 = calc_indices( params.iwl() - 1 - n_bits );
+		    scfx_index x4 = calc_indices( params.iwl() - n_bits );
+
+		    // wrap-around least significant 'wl - n_bits' bits;
+		    // saturate most significant 'n_bits' bits
+		    toggle_tc();
+		    if( is_neg() == o_bit_at( x4 ) )
+			o_invert( x2 );
+		    o_set( x, x3, SC_TC_, under );
+		    o_extend( x, SC_TC_ );
+		    toggle_tc();
+		}
+		else
+		{
+		    if( under )
+			o_set_low( x, SC_TC_ );
+		    else
+			o_set_high( x, x2, SC_TC_ );
+		}
+		break;
+	    }
+            default:
+	        ;
+	}
+
+	find_sw();
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  PUBLIC METHOD : cast
+//
+//  Performs a destructive cast operation on a scfx_rep.
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::cast( const scfx_params& params, bool& q_flag, bool& o_flag )
+{
+    q_flag = false;
+    o_flag = false;
+
+    // check for special cases
+    
+    if( is_zero() )
+    {
+	if( is_neg() )
+	    m_sign = 1;
+	return;
+    }
+
+    // perform casting
+
+    quantization( params, q_flag );
+    overflow( params, o_flag );
+
+    // check for special case: -0
+
+    if( is_zero() && is_neg() )
+	m_sign = 1;
+}
+
+
+// ----------------------------------------------------------------------------
+//  make sure, the two mantissas are aligned
+// ----------------------------------------------------------------------------
+
+void
+align( const scfx_rep& lhs, const scfx_rep& rhs, int& new_wp,
+       int& len_mant, scfx_mant_ref& lhs_mant, scfx_mant_ref& rhs_mant )
+{
+    bool need_lhs = true;
+    bool need_rhs = true;
+
+    if( lhs.m_wp != rhs.m_wp || lhs.size() != rhs.size() )
+    {
+	int lower_bound_lhs = lhs.m_lsw - lhs.m_wp;
+	int upper_bound_lhs = lhs.m_msw - lhs.m_wp;
+	int lower_bound_rhs = rhs.m_lsw - rhs.m_wp;
+	int upper_bound_rhs = rhs.m_msw - rhs.m_wp;
+
+	int lower_bound = sc_min( lower_bound_lhs, lower_bound_rhs );
+	int upper_bound = sc_max( upper_bound_lhs, upper_bound_rhs );
+
+	new_wp   = -lower_bound;
+	len_mant = sc_max( min_mant, upper_bound - lower_bound + 1 );
+
+	if( new_wp != lhs.m_wp || len_mant != lhs.size() )
+	{
+	    lhs_mant = lhs.resize( len_mant, new_wp );
+	    need_lhs = false;
+	}
+
+	if( new_wp != rhs.m_wp || len_mant != rhs.size() )
+        {
+	    rhs_mant = rhs.resize( len_mant, new_wp );
+	    need_rhs = false;
+	}
+    }
+
+    if( need_lhs )
+    {
+	lhs_mant = lhs.m_mant;
+    }
+
+    if( need_rhs )
+    {
+	rhs_mant = rhs.m_mant;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  compare two mantissas
+// ----------------------------------------------------------------------------
+
+int
+compare_msw_ff( const scfx_rep& lhs, const scfx_rep& rhs )
+{
+    // special case: rhs.m_mant[rhs.m_msw + 1] == 1
+    if( rhs.m_msw < rhs.size() - 1 && rhs.m_mant[rhs.m_msw + 1 ] != 0 )
+    {
+	return -1;
+    }
+
+    int lhs_size = lhs.m_msw - lhs.m_lsw + 1;
+    int rhs_size = rhs.m_msw - rhs.m_lsw + 1;
+
+    int size = sc_min( lhs_size, rhs_size );
+
+    int lhs_index = lhs.m_msw;
+    int rhs_index = rhs.m_msw;
+
+    int i;
+
+    for( i = 0;
+	 i < size && lhs.m_mant[lhs_index] == rhs.m_mant[rhs_index];
+	 i ++ )
+    {
+	lhs_index --;
+	rhs_index --;
+    }
+
+    if( i == size )
+    {
+	if( lhs_size == rhs_size )
+	{
+	    return 0;
+	}
+
+	if( lhs_size < rhs_size )
+	{
+	    return -1;
+	}
+	else
+	{
+	    return 1;
+	}
+  }
+
+  if( lhs.m_mant[lhs_index] < rhs.m_mant[rhs_index] )
+  {
+      return -1;
+  } else {
+      return 1;
+  }
+}
+
+
+// ----------------------------------------------------------------------------
+//  divide the mantissa by ten
+// ----------------------------------------------------------------------------
+
+unsigned int
+scfx_rep::divide_by_ten()
+{
+#if defined( SC_BIG_ENDIAN )
+    half_word* hw = (half_word*) &m_mant[m_msw];
+#elif defined( SC_LITTLE_ENDIAN )
+    half_word* hw = ( (half_word*) &m_mant[m_msw] ) + 1;
+#endif
+
+    unsigned int remainder = 0;
+
+    word_short ls;
+    ls.l = 0;
+
+#if defined( SC_BIG_ENDIAN )
+    for( int i = 0, end = ( m_msw - m_wp + 1 ) * 2; i < end; i ++ )
+#elif defined( SC_LITTLE_ENDIAN )
+    for( int i = 0, end = -( m_msw - m_wp + 1 ) * 2; i > end; i -- )
+#endif
+    {
+	ls.s.u = static_cast<half_word>( remainder );
+	ls.s.l = hw[i];
+	remainder = ls.l % 10;
+	ls.l /= 10;
+	hw[i] = ls.s.l;
+    }
+
+    return remainder;
+}
+
+
+// ----------------------------------------------------------------------------
+//  multiply the mantissa by ten
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::multiply_by_ten()
+{
+    int size = m_mant.size() + 1;
+
+    scfx_mant mant8( size );
+    scfx_mant mant2( size );
+
+    size --;
+
+    mant8[size] = (m_mant[size - 1] >> (bits_in_word - 3));
+    mant2[size] = (m_mant[size - 1] >> (bits_in_word - 1));
+
+    while( -- size )
+    {
+	mant8[size] = ( m_mant[size] << 3 ) |
+	              ( m_mant[size - 1] >> ( bits_in_word - 3 ) );
+	mant2[size] = ( m_mant[size] << 1 ) |
+	              ( m_mant[size - 1] >> ( bits_in_word - 1 ) );
+    }
+
+    mant8[0] = ( m_mant[0] << 3 );
+    mant2[0] = ( m_mant[0] << 1 );
+
+    add_mants( m_mant.size(), m_mant, mant8, mant2 );
+
+#if 0
+    for( int i = size() - 1; i > 0; i -- )
+    {
+	m_mant[i] = ( m_mant[i] << 3 ) |
+                    ( m_mant[i-1] >> ( bits_in_word - 3 ) )
+	          + ( m_mant[i] << 1 ) |
+                    ( m_mant[i-1] >> ( bits_in_word - 1 ) );
+    }
+    m_mant[0] = ( m_mant[0] << 3 ) + ( m_mant[0] << 1 );
+#endif
+}
+
+
+// ----------------------------------------------------------------------------
+//  normalize
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::normalize( int exponent )
+{
+    int shift = exponent % bits_in_word;
+    if( shift < 0 )
+    {
+	shift += bits_in_word;
+    }
+
+    if( shift )
+    {
+	shift_left( shift );
+    }
+
+    find_sw();
+
+    m_wp = (shift - exponent) / bits_in_word;
+}
+
+
+// ----------------------------------------------------------------------------
+//  return a new mantissa that is aligned and resized
+// ----------------------------------------------------------------------------
+
+scfx_mant*
+scfx_rep::resize( int new_size, int new_wp ) const
+{
+    scfx_mant *result = new scfx_mant( new_size );
+
+    result->clear();
+
+    int shift = new_wp - m_wp;
+
+    for( int j = m_lsw; j <= m_msw; j ++ )
+    {
+	(*result)[j+shift] = m_mant[j];
+    }
+
+    return result;
+}
+
+
+// ----------------------------------------------------------------------------
+//  set a single bit
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::set_bin( int i )
+{
+    m_mant[i >> 5] |= 1 << ( i & 31 );
+}
+
+
+// ----------------------------------------------------------------------------
+//  set three bits
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::set_oct( int i, int n )
+{
+    if( n & 1 )
+    {
+	m_mant[i >> 5] |= 1 << ( i & 31 );
+    }
+    i ++;
+    if( n & 2 )
+    {
+	m_mant[i >> 5] |= 1 << ( i & 31 );
+    }
+    i ++;
+    if( n & 4 )
+    {
+	m_mant[i >> 5] |= 1 << ( i & 31 );
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  set four bits
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::set_hex( int i, int n )
+{
+    if( n & 1 )
+    {
+	m_mant[i >> 5] |= 1 << ( i & 31 );
+    }
+    i ++;
+    if( n & 2 )
+    {
+	m_mant[i >> 5] |= 1 << ( i & 31 );
+    }
+    i ++;
+    if( n & 4 )
+    {
+	m_mant[i >> 5] |= 1 << ( i & 31 );
+    }
+    i ++;
+    if( n & 8 )
+    {
+	m_mant[i >> 5] |= 1 << ( i & 31 );
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  PRIVATE METHOD : shift_left
+//
+//  Shifts a scfx_rep to the left by a MAXIMUM of bits_in_word - 1 bits.
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::shift_left( int n )
+{
+    if( n != 0 )
+    {
+	int shift_left  = n;
+	int shift_right = bits_in_word - n;
+
+	SC_ASSERT_( !(m_mant[size()-1] >> shift_right),
+		    "shift_left overflow" );
+
+	for( int i = size() - 1; i > 0; i -- )
+	{
+	    m_mant[i] = ( m_mant[i] << shift_left ) |
+		       ( m_mant[i-1] >> shift_right );
+	}
+	m_mant[0] <<= shift_left;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  PRIVATE METHOD : shift_right
+//
+//  Shifts a scfx_rep to the right by a MAXIMUM of bits_in_word - 1 bits.
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::shift_right( int n )
+{
+    if( n != 0 )
+    {
+	int shift_left  = bits_in_word - n;
+	int shift_right = n;
+
+	SC_ASSERT_( !(m_mant[0] << shift_left), "shift_right overflow" );
+
+	for( int i = 0; i < size() - 1; i ++ )
+	{
+	    m_mant[i] = ( m_mant[i] >> shift_right ) |
+		       ( m_mant[i+1] << shift_left );
+	}
+	m_mant[size()-1] >>= shift_right;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  METHOD : get_bit
+//
+//  Tests a bit, in two's complement.
+// ----------------------------------------------------------------------------
+
+bool
+scfx_rep::get_bit( int i ) const
+{
+    if( ! is_normal() )
+	return false;
+
+    scfx_index x = calc_indices( i );
+
+    if( x.wi() >= size() )
+	return is_neg();
+
+    if( x.wi() < 0 )
+	return false;
+
+    const_cast<scfx_rep*>( this )->toggle_tc();
+
+    bool result = ( m_mant[x.wi()] & ( 1 << x.bi() ) ) != 0;
+
+    const_cast<scfx_rep*>( this )->toggle_tc();
+
+    return result;
+}
+
+
+// ----------------------------------------------------------------------------
+//  METHOD : set
+//
+//  Sets a bit, in two's complement, between iwl-1 and -fwl.
+// ----------------------------------------------------------------------------
+
+bool
+scfx_rep::set( int i, const scfx_params& params )
+{
+    if( ! is_normal() )
+	return false;
+
+    scfx_index x = calc_indices( i );
+
+    if( x.wi() >= size() )
+    {
+	if( is_neg() )
+	    return true;
+	else
+	    resize_to( x.wi() + 1, 1 );
+    }
+    else if( x.wi() < 0 )
+    {
+	resize_to( size() - x.wi(), -1 );
+	x.wi( 0 );
+    }
+
+    toggle_tc();
+
+    m_mant[x.wi()] |= 1 << x.bi();
+
+    if( i == params.iwl() - 1 )
+        o_extend( x, params.enc() );  // sign extension
+
+    toggle_tc();
+
+    find_sw();
+
+    return true;
+}
+
+
+// ----------------------------------------------------------------------------
+//  METHOD : clear
+//
+//  Clears a bit, in two's complement, between iwl-1 and -fwl.
+// ----------------------------------------------------------------------------
+
+bool
+scfx_rep::clear( int i, const scfx_params& params )
+{
+    if( ! is_normal() )
+	return false;
+
+    scfx_index x = calc_indices( i );
+
+    if( x.wi() >= size() )
+    {
+	if( ! is_neg() )
+	    return true;
+	else
+	    resize_to( x.wi() + 1, 1 );
+    }
+    else if( x.wi() < 0 )
+	return true;
+
+    toggle_tc();
+
+    m_mant[x.wi()] &= ~( 1 << x.bi() );
+
+    if( i == params.iwl() - 1 )
+        o_extend( x, params.enc() );  // sign extension
+
+    toggle_tc();
+
+    find_sw();
+
+    return true;
+}
+
+
+// ----------------------------------------------------------------------------
+//  METHOD : get_slice
+// ----------------------------------------------------------------------------
+
+bool
+scfx_rep::get_slice( int i, int j, const scfx_params&,
+		     sc_bv_base& bv ) const
+{
+    if( is_nan() || is_inf() )
+	return false;
+
+    // get the bits
+
+    int l = j;
+    for( int k = 0; k < bv.length(); ++ k )
+    {
+	bv[k] = get_bit( l );
+
+	if( i >= j )
+	    ++ l;
+	else
+	    -- l;
+    }
+
+    return true;
+}
+
+bool
+scfx_rep::set_slice( int i, int j, const scfx_params& params,
+		     const sc_bv_base& bv )
+{
+    if( is_nan() || is_inf() )
+        return false;
+
+    // set the bits
+
+    int l = j;
+    for( int k = 0; k < bv.length(); ++ k )
+    {
+	if( bv[k].to_bool() )
+	    set( l, params );
+	else
+	    clear( l, params );
+
+	if( i >= j )
+	    ++ l;
+	else
+	    -- l;
+    }
+
+    return true;
+}
+
+
+// ----------------------------------------------------------------------------
+//  METHOD : print
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::print( ::std::ostream& os ) const
+{
+    os << to_string( SC_DEC, -1, SC_E );
+}
+
+
+// ----------------------------------------------------------------------------
+//  METHOD : dump
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::dump( ::std::ostream& os ) const
+{
+    os << "scfx_rep" << ::std::endl;
+    os << "(" << ::std::endl;
+
+    os << "mant  =" << ::std::endl;
+    for( int i = size() - 1; i >= 0; i -- )
+    {
+	char buf[BUFSIZ];
+	std::sprintf( buf, " %d: %10u (%8x)", i, (int) m_mant[i], (int) m_mant[i] );
+	os << buf << ::std::endl;
+    }
+
+    os << "wp    = " << m_wp << ::std::endl;
+    os << "sign  = " << m_sign << ::std::endl;
+
+    os << "state = ";
+    switch( m_state )
+    {
+        case normal:
+	    os << "normal";
+	    break;
+        case infinity:
+	    os << "infinity";
+	    break;
+        case not_a_number:
+	    os << "not_a_number";
+	    break;
+        default:
+	    os << "unknown";
+    }
+    os << ::std::endl;
+
+    os << "msw   = " << m_msw << ::std::endl;
+    os << "lsw   = " << m_lsw << ::std::endl;
+
+    os << ")" << ::std::endl;
+}
+
+
+// ----------------------------------------------------------------------------
+//  METHOD : get_type
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::get_type( int& wl, int& iwl, sc_enc& enc ) const
+{
+    if( is_nan() || is_inf() )
+    {
+        wl  = 0;
+        iwl = 0;
+        enc = SC_TC_;
+        return;
+    }
+
+    if( is_zero() )
+    {
+        wl  = 1;
+        iwl = 1;
+        enc = SC_US_;
+        return;
+    }
+
+    int msb = ( m_msw - m_wp ) * bits_in_word
+            + scfx_find_msb( m_mant[ m_msw ] ) + 1;
+    while( get_bit( msb ) == get_bit( msb - 1 ) )
+    {
+        -- msb;
+    }
+
+    int lsb = ( m_lsw - m_wp ) * bits_in_word
+            + scfx_find_lsb( m_mant[ m_lsw ] );
+
+    if( is_neg() )
+    {
+        wl  = msb - lsb + 1;
+        iwl = msb + 1;
+        enc = SC_TC_;
+    }
+    else
+    {
+        wl  = msb - lsb;
+        iwl = msb;
+        enc = SC_US_;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  PRIVATE METHOD : round
+//
+//  Performs convergent rounding (rounding to even) as in floating-point.
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::round( int wl )
+{
+    // check for special cases
+    
+    if( is_nan() || is_inf() || is_zero() )
+	return;
+
+    // estimate effective wordlength and compare
+
+    int wl_effective;
+
+    wl_effective = ( m_msw - m_lsw + 1 ) * bits_in_word;
+    if( wl_effective <= wl )
+	return;
+
+    // calculate effective wordlength and compare
+
+    int msb = scfx_find_msb( m_mant[m_msw] );
+    int lsb = scfx_find_lsb( m_mant[m_lsw] );
+
+    wl_effective = ( m_msw * bits_in_word + msb ) -
+	           ( m_lsw * bits_in_word + lsb ) + 1;
+    if( wl_effective <= wl )
+	return;
+
+    // perform rounding
+
+    int wi = m_msw - ( wl - 1 ) / bits_in_word;
+    int bi =  msb - ( wl - 1 ) % bits_in_word;
+    if( bi < 0 )
+    {
+	-- wi;
+	bi += bits_in_word;
+    }
+
+    scfx_index x( wi, bi );
+
+    if( (q_bit( x ) && ! q_zero( x )) ||
+	(q_bit( x ) && q_zero( x ) && q_odd( x )) )
+	q_incr( x );
+    q_clear( x );
+
+    find_sw();
+
+    m_r_flag = true;
+}
+
+} // namespace sc_dt
+
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/scfx_rep.h b/ext/systemc/src/sysc/datatypes/fx/scfx_rep.h
new file mode 100644
index 000000000..c5b76ce54
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/scfx_rep.h
@@ -0,0 +1,842 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  scfx_rep.h - 
+
+  Original Author: Robert Graulich, Synopsys, Inc.
+                   Martin Janssen,  Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: scfx_rep.h,v $
+// Revision 1.6  2011/08/24 22:05:43  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.5  2011/07/25 10:20:29  acg
+//  Andy Goodrich: check in aftermath of call to automake.
+//
+// Revision 1.4  2010/12/07 20:09:08  acg
+// Andy Goodrich: Philipp Hartmann's constructor disambiguation fix
+//
+// Revision 1.3  2010/08/03 15:54:52  acg
+//  Andy Goodrich: formatting.
+//
+// Revision 1.2  2010/03/15 18:29:01  acg
+//  Andy Goodrich: Moved default argument specifications from friend
+//  declarations to the actual function signatures.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.4  2006/03/13 20:24:27  acg
+//  Andy Goodrich: Addition of function declarations, e.g., neg_scfx_rep(),
+//  to keep gcc 4.x happy.
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SCFX_REP_H
+#define SCFX_REP_H
+
+
+#include <climits>
+
+#include "sysc/datatypes/fx/scfx_mant.h"
+#include "sysc/datatypes/fx/scfx_params.h"
+#include "sysc/datatypes/fx/scfx_string.h"
+
+
+namespace sc_dt
+{
+
+// classes defined in this module
+class scfx_index;
+class scfx_rep;
+
+// forward class declarations
+class sc_bv_base;
+class sc_signed;
+class sc_unsigned;
+
+// function declarations
+void multiply( scfx_rep&, const scfx_rep&, const scfx_rep&, 
+	       int max_wl = SC_DEFAULT_MAX_WL_ );
+scfx_rep*  neg_scfx_rep( const scfx_rep& );
+scfx_rep*  mult_scfx_rep( const scfx_rep&, const scfx_rep&, 
+	                  int max_wl = SC_DEFAULT_MAX_WL_ );
+scfx_rep*  div_scfx_rep( const scfx_rep&, const scfx_rep&, 
+	                 int max_wl = SC_DEFAULT_DIV_WL_ );
+scfx_rep*  add_scfx_rep( const scfx_rep&, const scfx_rep&, 
+	                 int max_wl = SC_DEFAULT_MAX_WL_ );
+scfx_rep*  sub_scfx_rep( const scfx_rep&, const scfx_rep&, 
+	                 int max_wl = SC_DEFAULT_MAX_WL_ );
+scfx_rep*  lsh_scfx_rep( const scfx_rep&, int );
+scfx_rep*  rsh_scfx_rep( const scfx_rep&, int );
+int        cmp_scfx_rep( const scfx_rep&, const scfx_rep& );
+
+
+const int min_mant = 4;
+
+const int bits_in_int  = sizeof(int)  * CHAR_BIT;
+const int bits_in_word = sizeof(word) * CHAR_BIT;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : scfx_index
+// ----------------------------------------------------------------------------
+
+class scfx_index
+{
+
+public:
+
+    scfx_index( int wi_, int bi_ ) : m_wi( wi_ ), m_bi( bi_ ) {}
+
+    int wi() const { return m_wi; }
+    int bi() const { return m_bi; }
+
+    void wi( int wi_ ) { m_wi = wi_; }
+
+private:
+
+    int m_wi;
+    int m_bi;
+
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : scfx_rep
+//
+//  Arbitrary-precision fixed-point implementation class.
+// ----------------------------------------------------------------------------
+
+class scfx_rep
+{
+    enum state
+    {
+        normal,
+        infinity,
+        not_a_number
+    };
+
+public:
+
+    // constructors
+
+             scfx_rep();
+    explicit scfx_rep( int );
+    explicit scfx_rep( unsigned int );
+    explicit scfx_rep( long );
+    explicit scfx_rep( unsigned long );
+    explicit scfx_rep( double );
+    explicit scfx_rep( const char* );
+    explicit scfx_rep( int64 );
+    explicit scfx_rep( uint64 );
+    explicit scfx_rep( const sc_signed& );
+    explicit scfx_rep( const sc_unsigned& );
+
+
+    // copy constructor
+
+             scfx_rep( const scfx_rep& );
+
+
+    // destructor
+
+    ~scfx_rep();
+
+
+    void* operator new( std::size_t );
+    void  operator delete( void*, std::size_t );
+
+
+    void from_string( const char*, int );
+
+    double to_double() const;
+
+    const char* to_string( sc_numrep,
+			   int,
+			   sc_fmt,
+			   const scfx_params* = 0 ) const;
+
+
+    // assignment operator
+
+    void operator = ( const scfx_rep& );
+
+    friend void multiply( scfx_rep&, const scfx_rep&, const scfx_rep&, int );
+
+    friend scfx_rep* neg_scfx_rep( const scfx_rep& );
+    friend scfx_rep* mult_scfx_rep( const scfx_rep&, const scfx_rep&, int );
+    friend scfx_rep* div_scfx_rep( const scfx_rep&, const scfx_rep&, int );
+    friend scfx_rep* add_scfx_rep( const scfx_rep&, const scfx_rep&, int );
+    friend scfx_rep* sub_scfx_rep( const scfx_rep&, const scfx_rep&, int );
+    friend scfx_rep* lsh_scfx_rep( const scfx_rep&, int );
+    friend scfx_rep* rsh_scfx_rep( const scfx_rep&, int );
+
+    void lshift( int );
+    void rshift( int );
+
+    friend int        cmp_scfx_rep( const scfx_rep&, const scfx_rep& );
+
+    void cast( const scfx_params&, bool&, bool& );
+
+    bool is_neg() const;
+    bool is_zero() const;
+    bool is_nan() const;
+    bool is_inf() const;
+    bool is_normal() const;
+
+    void set_zero( int = 1 );
+    void set_nan();
+    void set_inf( int );
+
+    bool   get_bit( int ) const;
+    bool   set( int, const scfx_params& );
+    bool clear( int, const scfx_params& );
+
+    bool get_slice( int, int, const scfx_params&, sc_bv_base& ) const;
+    bool set_slice( int, int, const scfx_params&, const sc_bv_base& );
+
+    void print( ::std::ostream& ) const;
+    void dump( ::std::ostream& ) const;
+
+    void get_type( int&, int&, sc_enc& ) const;
+
+    friend scfx_rep* quantization_scfx_rep( const scfx_rep&,
+					     const scfx_params&,
+					     bool& );
+    friend scfx_rep*     overflow_scfx_rep( const scfx_rep&,
+					     const scfx_params&,
+					     bool& );
+
+    bool rounding_flag() const;
+
+private:
+
+    friend void  align( const scfx_rep&, const scfx_rep&, int&, int&,
+			scfx_mant_ref&, scfx_mant_ref& );
+    friend int   compare_msw( const scfx_rep&, const scfx_rep& );
+    friend int   compare_msw_ff( const scfx_rep& lhs, const scfx_rep& rhs );
+    unsigned int divide_by_ten();
+    int          find_lsw() const;
+    int          find_msw() const;
+    void         find_sw();
+    void         multiply_by_ten();
+    void         normalize( int );
+    scfx_mant*   resize( int, int ) const;
+    void         set_bin( int );
+    void         set_oct( int, int );
+    void         set_hex( int, int );
+    void         shift_left( int );
+    void         shift_right( int );
+
+    const scfx_index calc_indices( int ) const;
+
+    void o_extend( const scfx_index&, sc_enc );
+    bool o_bit_at( const scfx_index& ) const;
+    bool o_zero_left( const scfx_index& ) const;
+    bool o_zero_right( const scfx_index& ) const;
+    void o_set_low( const scfx_index&, sc_enc );
+    void o_set_high( const scfx_index&, const scfx_index&, sc_enc, int = 1 );
+    void o_set( const scfx_index&, const scfx_index&, sc_enc, bool );
+    void o_invert( const scfx_index& );
+    bool q_bit( const scfx_index& ) const;
+    void q_clear( const scfx_index& );
+    void q_incr( const scfx_index& );
+    bool q_odd( const scfx_index& ) const;
+    bool q_zero( const scfx_index& ) const;
+
+    void resize_to( int, int = 0 );
+    int  size() const;
+    void toggle_tc();
+
+    friend void print_dec( scfx_string&, const scfx_rep&, int, sc_fmt );
+    friend void print_other( scfx_string&, const scfx_rep&, sc_numrep, int,
+			     sc_fmt, const scfx_params* );
+
+    void quantization( const scfx_params&, bool& );
+    void     overflow( const scfx_params&, bool& );
+
+    friend int compare_abs( const scfx_rep&, const scfx_rep& );
+
+    void round( int );
+
+private:
+
+    scfx_mant m_mant;     // mantissa (bits of the value).
+    int       m_wp;       // index of highest order word in value.
+    int       m_sign;     // sign of value.
+    state     m_state;    // value state, e.g., normal, inf, etc.
+    int       m_msw;      // index of most significant non-zero word.
+    int       m_lsw;      // index of least significant non-zero word.
+    bool      m_r_flag;   // true if founding occurred.
+
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+inline
+void
+scfx_rep::set_zero( int sign )
+{
+    m_mant.clear();
+    m_wp = m_msw = m_lsw = 0;
+    m_sign = sign;
+    m_state = normal;
+}
+
+inline
+void
+scfx_rep::set_nan()
+{
+    m_mant.resize_to( min_mant );
+    m_state = not_a_number;
+}
+
+inline
+void
+scfx_rep::set_inf( int sign )
+{
+    m_mant.resize_to( min_mant );
+    m_state = infinity;
+    m_sign = sign;
+}
+
+
+// constructors
+
+inline
+scfx_rep::scfx_rep( const char* s )
+: m_mant( min_mant ), m_wp( 2 ), m_sign( 1 ), m_state( normal ),
+  m_msw(0), m_lsw(0), m_r_flag( false )
+{
+    from_string( s, SC_DEFAULT_CTE_WL_ );
+}
+
+
+// destructor
+
+inline
+scfx_rep::~scfx_rep()
+{}
+
+
+// assignment operator
+
+inline
+void
+scfx_rep::operator = ( const scfx_rep& f )
+{
+    if( &f != this )
+    {
+        m_mant  = f.m_mant;
+	m_wp    = f.m_wp;
+	m_sign  = f.m_sign;
+	m_state = f.m_state;
+	m_msw   = f.m_msw;
+	m_lsw   = f.m_lsw;
+	round( SC_DEFAULT_MAX_WL_ );
+    }
+}
+
+inline
+scfx_rep*
+neg_scfx_rep( const scfx_rep& a )
+{
+    scfx_rep& c = *new scfx_rep( a );
+    c.m_sign = - c.m_sign;
+    return &c;
+}
+
+inline
+scfx_rep*
+mult_scfx_rep( const scfx_rep& a, const scfx_rep& b, int max_wl )
+{
+    scfx_rep& c = *new scfx_rep;
+    sc_dt::multiply( c, a, b, max_wl );
+    return &c;
+}
+
+inline
+scfx_rep*
+lsh_scfx_rep( const scfx_rep& a, int b )
+{
+    scfx_rep& c = *new scfx_rep( a );
+    c.lshift( b );
+    return &c;
+}
+
+inline
+scfx_rep*
+rsh_scfx_rep( const scfx_rep& a, int b )
+{
+    scfx_rep& c = *new scfx_rep( a );
+    c.rshift( b );
+    return &c;
+}
+
+inline
+int
+scfx_rep::size() const
+{
+    return m_mant.size();
+}
+
+inline
+bool
+scfx_rep::is_neg() const
+{
+    return ( m_sign == -1 );
+}
+
+inline
+bool
+scfx_rep::is_zero() const
+{
+    if( m_state != normal )
+        return false;
+
+    for( int i = 0; i < size(); i ++ )
+    {
+        if( m_mant[i] )
+	    return false;
+    }
+
+    return true;
+}
+
+inline
+bool
+scfx_rep::is_nan() const
+{
+    return ( m_state == not_a_number );
+}
+
+inline
+bool
+scfx_rep::is_inf() const
+{
+    return ( m_state == infinity );
+}
+
+inline
+bool
+scfx_rep::is_normal() const
+{
+    return ( m_state == normal );
+}
+
+inline
+scfx_rep*
+quantization_scfx_rep( const scfx_rep& a,
+			const scfx_params& params,
+			bool& q_flag )
+{
+    scfx_rep& c = *new scfx_rep( a );
+    c.quantization( params, q_flag );
+    return &c;
+}
+
+inline
+scfx_rep*
+overflow_scfx_rep( const scfx_rep& a,
+		    const scfx_params& params,
+		    bool& o_flag )
+{
+    scfx_rep& c = *new scfx_rep( a );
+    c.overflow( params, o_flag );
+    return &c;
+}
+
+inline
+bool
+scfx_rep::rounding_flag() const
+{
+    return m_r_flag;
+}
+
+inline
+void
+scfx_rep::resize_to( int new_size, int restore )
+{
+    if( restore == -1 )
+    {
+        int size_incr = new_size - size();
+	m_wp += size_incr;
+	m_msw += size_incr;
+	m_lsw += size_incr;
+    }
+    m_mant.resize_to( new_size, restore );
+}
+
+inline
+const scfx_index
+scfx_rep::calc_indices( int n ) const
+{
+    int wi = n / bits_in_word + m_wp;
+    int bi = n % bits_in_word;
+
+    if( bi < 0 )
+    {
+        bi += bits_in_word;
+	-- wi;
+    }
+
+    return scfx_index( wi, bi );
+}
+
+inline
+void
+scfx_rep::o_extend( const scfx_index& x, sc_enc enc )
+{
+    int wi = x.wi();
+    int bi = x.bi();
+
+    SC_ASSERT_( wi >= 0 && wi < size(), "word index out of range" );
+    
+    if( enc == SC_US_ || ( m_mant[wi] & ( ((word)1) << bi ) ) == 0 )
+    {
+        if( bi != bits_in_word - 1 )
+	    m_mant[wi] &= ~( ((word)-1) << ( bi + 1 ) );
+	for( int i = wi + 1; i < size(); ++ i )
+	    m_mant[i] = 0;
+	m_sign = 1;
+    }
+    else
+    {
+        if( bi != bits_in_word - 1 )
+	    m_mant[wi] |= ( ((word)-1) << ( bi + 1 ) );
+	for( int i = wi + 1; i < size(); ++ i )
+	    m_mant[i] = static_cast<word>( -1 );
+	m_sign = -1;
+    }
+}
+
+inline
+bool
+scfx_rep::o_bit_at( const scfx_index& x ) const
+{
+    int wi = x.wi();
+    int bi = x.bi();
+    
+    SC_ASSERT_( wi >= 0 && wi < size(), "word index out of range" );
+
+    return ( m_mant[wi] & ( ((word)1) << bi ) ) != 0;
+}
+
+inline
+bool
+scfx_rep::o_zero_left( const scfx_index& x ) const
+{
+    int wi = x.wi();
+    int bi = x.bi();
+
+    SC_ASSERT_( wi >= 0 && wi < size(), "word index out of range" );
+
+    bool zero = true;
+    if( bi != bits_in_word - 1 )
+        zero = ( m_mant[wi] & ( ((word)-1) << ( bi + 1 ) ) ) == 0;
+    for( int i = wi + 1; i < size(); ++ i )
+	zero = zero && m_mant[i] == 0;
+
+    return zero;
+}
+
+inline
+bool
+scfx_rep::o_zero_right( const scfx_index& x ) const
+{
+    int wi = x.wi();
+    int bi = x.bi();
+
+    SC_ASSERT_( wi >= 0 && wi < size(), "word index out of range" );
+
+    bool zero = ( m_mant[wi] & ~( ((word)-1) << bi ) ) == 0;
+    for( int i = wi - 1; i >= 0; -- i )
+	zero = zero && m_mant[i] == 0;
+
+    return zero;
+}
+
+inline
+void
+scfx_rep::o_set_low( const scfx_index& x, sc_enc enc )
+{
+    int wi = x.wi();
+    int bi = x.bi();
+
+    SC_ASSERT_( wi >= 0 && wi < size(), "word index out of range" );
+
+    m_mant.clear();
+
+    if( enc == SC_TC_ )
+    {
+	m_mant[wi] |= ( ((word)1) << bi );
+	m_sign = -1;
+    }
+    else
+	m_sign = 1;
+}
+
+inline
+void
+scfx_rep::o_set_high( const scfx_index& x, const scfx_index& x2,
+		      sc_enc enc, int sign )
+{
+    int wi = x.wi();
+    int bi = x.bi();
+    int wi2 = x2.wi();
+    int bi2 = x2.bi();
+
+    SC_ASSERT_( wi >= 0 && wi < size(), "word index out of range" );
+    SC_ASSERT_( wi2 >= 0 && wi2 < size(), "word index out of range" );
+    
+    int i;
+
+    for( i = 0; i < size(); ++ i )
+	m_mant[i] = static_cast<word>( -1 );
+
+    m_mant[wi] &= ~( ((word)-1) << bi );
+    for( i = wi + 1; i < size(); ++ i )
+	m_mant[i] = 0;
+
+    m_mant[wi2] &= ( ((word)-1) << bi2 );
+    for( i = wi2 - 1; i >= 0; -- i )
+	m_mant[i] = 0;
+    
+    if( enc == SC_TC_ )
+	m_sign = sign;
+    else
+    {
+	m_mant[wi] |= ( ((word)1) << bi );
+	m_sign = 1;
+    }
+}
+
+inline
+void
+scfx_rep::o_set( const scfx_index& x, const scfx_index& x3,
+		 sc_enc enc, bool under )
+{
+    int wi = x.wi();
+    int bi = x.bi();
+    int wi3 = x3.wi();
+    int bi3 = x3.bi();
+    
+    SC_ASSERT_( wi >= 0 && wi < size(), "word index out of range" );
+    SC_ASSERT_( wi3 >= 0 && wi3 < size(), "word index out of range" );
+
+    if( bi3 != bits_in_word - 1 )
+    {
+	if( under )
+	    m_mant[wi3] &= ~( ((word)-1) << ( bi3 + 1 ) );
+	else
+	    m_mant[wi3] |= ( ((word)-1) << ( bi3 + 1 ) );
+    }
+    for( int i = wi3 + 1; i < size(); ++ i )
+    {
+	if( under )
+	    m_mant[i] = 0;
+	else
+	    m_mant[i] = static_cast<word>( -1 );
+    }
+	
+    if( enc == SC_TC_ )
+    {
+	if( under )
+	    m_mant[wi] |= ( ((word)1) << bi );
+	else
+	    m_mant[wi] &= ~( ((word)1) << bi );
+    }
+}
+
+inline
+void
+scfx_rep::o_invert( const scfx_index& x2 )
+{
+    int wi2 = x2.wi();
+    int bi2 = x2.bi();
+
+    m_mant[wi2] ^= ( ((word)-1) << bi2 );
+    for( int i = wi2 + 1; i < size(); ++ i )
+	m_mant[i] = ~ m_mant[i];
+}
+
+inline
+bool
+scfx_rep::q_bit( const scfx_index& x ) const
+{
+    int wi = x.wi();
+    int bi = x.bi();
+
+    SC_ASSERT_( wi >= 0 && wi < size(), "word index out of range" );
+
+    if( bi != 0 )
+        return ( m_mant[wi] & ( ((word)1) << ( bi - 1 ) ) ) != 0;
+    else if( wi != 0 )
+        return ( m_mant[wi - 1] & ( ((word)1) << ( bits_in_word - 1 ) ) ) != 0;
+    else
+        return false;
+}
+
+inline
+void
+scfx_rep::q_clear( const scfx_index& x )
+{
+    int wi = x.wi();
+    int bi = x.bi();
+    
+    SC_ASSERT_( wi >= 0 && wi < size(), "word index out of range" );
+
+    m_mant[wi] &= ( ((word)-1) << bi );
+    for( int i = wi - 1; i >= 0; -- i )
+        m_mant[i] = 0;
+}
+
+inline
+void
+scfx_rep::q_incr( const scfx_index& x )
+{
+    int wi = x.wi();
+    int bi = x.bi();
+    
+    SC_ASSERT_( wi >= 0 && wi < size(), "word index out of range" );
+
+    word old_val = m_mant[wi];
+    m_mant[wi] += ( ((word)1) << bi );
+    if( m_mant[wi] <= old_val )
+    {
+        if( wi + 1 == size() )
+          resize_to( size() + 1, 1 );
+
+        for( int i = wi + 1; i < size(); ++ i )
+	{
+	    if( ++ m_mant[i] != 0 )
+	        break;
+	}
+    }
+}
+
+inline
+bool
+scfx_rep::q_odd( const scfx_index& x ) const
+{
+    int wi = x.wi();
+    int bi = x.bi();
+
+    SC_ASSERT_( wi >= 0 && wi < size(), "word index out of range" );
+
+    return ( m_mant[wi] & ( ((word)1) << bi ) ) != 0;
+}
+
+inline
+bool
+scfx_rep::q_zero( const scfx_index& x ) const
+{
+    int wi = x.wi();
+    int bi = x.bi();
+
+    SC_ASSERT_( wi >= 0 && wi < size(), "word index out of range" );
+
+    bool zero;
+
+    if( bi != 0 )
+    {
+        zero = ( m_mant[wi] & ~( ((word)-1) << (bi - 1) ) ) == 0;
+	for( int i = wi - 1; i >= 0; -- i )
+	    zero = zero && m_mant[i] == 0;
+    }
+    else if( wi != 0 )
+    {
+        zero = ( m_mant[wi - 1] & ~( ((word)-1) << (bits_in_word - 1) ) ) == 0;
+	for( int i = wi - 2; i >= 0; -- i )
+	    zero = zero && m_mant[i] == 0;
+    }
+    else
+        zero = true;
+
+    return zero;
+}
+
+inline
+int
+scfx_rep::find_lsw() const
+{
+    for( int i = 0; i < size(); i ++ )
+    {
+        if( m_mant[i] )
+	    return i;
+    }
+    return 0;
+}
+
+inline
+int
+scfx_rep::find_msw() const
+{
+    for( int i = size() - 1; i >= 0; i -- )
+    {
+        if( m_mant[i] )
+	    return i;
+    }
+    return 0;
+}
+
+inline
+void
+scfx_rep::find_sw()
+{
+    m_lsw = find_lsw();
+    m_msw = find_msw();
+}
+
+inline
+void
+scfx_rep::toggle_tc()
+{
+    if( is_neg() )
+    {
+        complement( m_mant, m_mant, m_mant.size() );
+	inc( m_mant );
+    }
+}
+
+} // namespace sc_dt
+
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/scfx_string.h b/ext/systemc/src/sysc/datatypes/fx/scfx_string.h
new file mode 100644
index 000000000..338031ccc
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/scfx_string.h
@@ -0,0 +1,232 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  scfx_string.h - 
+
+  Original Author: Robert Graulich, Synopsys, Inc.
+                   Martin Janssen,  Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+// $Log: scfx_string.h,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.2  2006/01/03 23:18:34  acg
+// Changed copyright to include 2006.
+//
+// Revision 1.1.1.1  2005/12/19 23:16:43  acg
+// First check in of SystemC 2.1 into its own archive.
+//
+// Revision 1.9  2005/09/15 23:02:03  acg
+// Added std:: prefix to appropriate methods and types to get around
+// issues with the Edison Front End.
+//
+// Revision 1.8  2005/06/07 17:27:02  acg
+// Fixed bug in scfx_string::operator += where an array reference was used
+// rather than the [] operator.  This meant that the buffer may have been
+// accessed beyond its allocated storage.
+//
+
+#ifndef SCFX_STRING_H
+#define SCFX_STRING_H
+
+#include <cstdio>
+
+
+namespace sc_dt
+{
+
+// classes defined in this module
+class scfx_string;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : scfx_string
+//
+//  Simple string class for internal use.
+// ----------------------------------------------------------------------------
+
+class scfx_string
+{
+    void resize( std::size_t );
+
+public:
+
+    scfx_string();
+
+    ~scfx_string();
+
+    int length() const;
+
+    void clear();
+
+    char& operator [] ( int );
+
+    void append( int );
+    void discard( int );
+    void remove( int );
+
+    void operator += ( char );
+    void operator += ( const char* );
+
+    operator const char* ();
+
+private:
+
+    std::size_t m_len;
+    std::size_t m_alloc;
+    char*  m_buffer;
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+inline
+void
+scfx_string::resize( std::size_t i )
+{
+    do {
+	m_alloc *= 2;
+    } while( i >= m_alloc );
+
+    char* temp = new char[m_alloc];
+
+    for( int j = 0; j < (int) m_len; ++ j ) {
+	temp[j] = m_buffer[j];
+    }
+    temp[m_len] = 0;
+
+    delete [] m_buffer;
+    m_buffer = temp;
+}
+
+
+inline
+scfx_string::scfx_string()
+: m_len( 0 ), m_alloc( BUFSIZ ), m_buffer( new char[m_alloc] )
+{
+    m_buffer[m_len] = 0;
+}
+
+
+inline
+scfx_string::~scfx_string()
+{
+    delete [] m_buffer;
+}
+
+
+inline
+int
+scfx_string::length() const
+{
+    return m_len;
+}
+
+
+inline
+void
+scfx_string::clear()
+{
+    m_len = 0;
+    m_buffer[m_len] = 0;
+}
+
+
+inline
+char&
+scfx_string::operator [] ( int i )
+{
+    if( i >= (int) m_alloc ) {
+	resize( i );
+    }
+    return m_buffer[i];
+}
+
+
+inline
+void
+scfx_string::append( int n )
+{
+    m_len += n;
+    m_buffer[m_len] = 0;
+}
+
+inline
+void
+scfx_string::discard( int n )
+{
+    m_len -= n;
+    m_buffer[m_len] = 0;
+}
+
+inline
+void
+scfx_string::remove( int i )
+{
+    for( int j = i + 1; j < (int) m_len; ++ j )
+	m_buffer[j - 1] = m_buffer[j];
+    -- m_len;
+    m_buffer[m_len] = 0;
+}
+
+
+inline
+void
+scfx_string::operator += ( char c )
+{
+    this->operator [] ( m_len ) = c;
+    m_len ++;
+    this->operator [] ( m_len ) = 0;
+}
+
+inline
+void
+scfx_string::operator += ( const char* s )
+{
+    while( *s )
+	(*this) += *s ++;
+}
+
+
+inline
+scfx_string::operator const char*()
+{
+    m_buffer[m_len] = 0;
+    return m_buffer;
+}
+
+} // namespace sc_dt
+
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/scfx_utils.cpp b/ext/systemc/src/sysc/datatypes/fx/scfx_utils.cpp
new file mode 100644
index 000000000..0735a6c25
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/scfx_utils.cpp
@@ -0,0 +1,176 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  scfx_utils.cpp - 
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: scfx_utils.cpp,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include "sysc/datatypes/fx/scfx_utils.h"
+
+
+namespace sc_dt
+{
+
+void
+scfx_tc2csd( scfx_string& s, int w_prefix )
+{
+    if( w_prefix != 0 ) {
+	SC_ASSERT_( s[0] == '0' && s[1] == 'c' &&
+		    s[2] == 's' && s[3] == 'd', "invalid prefix" );
+    }
+
+    scfx_string csd;
+
+    // copy bits from 's' into 'csd'; skip prefix, point, and exponent
+    int i = 0;
+    int j = (w_prefix != 0 ? 4 : 0);
+    while( s[j] )
+    {
+	if( s[j] == '0' || s[j] == '1' )
+	    csd[i ++] = s[j];
+	else if( s[j] != '.' )
+	    break;
+	++ j;
+    }
+    csd[i] = '\0';
+
+    // convert 'csd' from two's complement to csd
+    -- i;
+    while( i >= 0 )
+    {
+	if( csd[i] == '0' )
+	    -- i;
+	else
+	{
+	    if( i > 0 && csd[i - 1] == '0' )
+		-- i;
+	    else if( i == 0 )
+		csd[i --] = '-';
+	    else
+	    {   // i > 0 && csd[i - 1] == '1'
+		csd[i --] = '-';
+		while( i >= 0 && csd[i] == '1' )
+		    csd[i --] = '0';
+		if( i > 0 )
+		    csd[i] = '1';
+		else if( i == 0 )
+		    csd[i --] = '1';
+	    }
+	}
+    }
+
+    // copy bits from 'csd' back into 's'
+    i = 0;
+    j = (w_prefix != 0 ? 4 : 0);
+    while( csd[i] )
+    {
+	if( s[j] == '.' )
+	    ++ j;
+	s[j ++] = csd[i ++];
+    }
+}
+
+
+void
+scfx_csd2tc( scfx_string& csd )
+{
+    SC_ASSERT_( csd[0] == '0' && csd[1] == 'c' &&
+		csd[2] == 's' && csd[3] == 'd', "invalid prefix" );
+
+    scfx_string s;
+
+    // copy bits from 'csd' into 's'; skip prefix, point, and exponent
+    int i = 0;
+    s[i ++] = '0';
+    int j = 4;
+    while( csd[j] )
+    {
+	if( csd[j] == '-' || csd[j] == '0' || csd[j] == '1' )
+	    s[i ++] = csd[j];
+	else if( csd[j] != '.' )
+	    break;
+	++ j;
+    }
+    s[i] = '\0';
+
+    // convert 's' from csd to two's complement
+    int len = i;
+    i = 1;
+    while( i < len )
+    {
+        while( i < len && s[i] != '-' )
+	    i ++;
+	if( i < len )
+	{
+	    j = i ++;
+	    s[j --] = '1';
+	    while( j >= 0 && s[j] == '0' )
+	        s[j --] = '1';
+	    if( j >= 0 )
+	        s[j] = '0';
+	}
+    }
+
+    // copy bits from 's' back into 'csd'
+    j = csd.length();
+    csd[j + 1] = '\0';
+    while( j > 4 )
+    {
+	csd[j] = csd[j - 1];
+	-- j;
+    }
+        
+    i = 0;
+    j = 4;
+    while( s[i] )
+    {
+	if( csd[j] == '.' )
+	    ++ j;
+	csd[j ++] = s[i ++];
+    }
+}
+
+} // namespace sc_dt
+
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/fx/scfx_utils.h b/ext/systemc/src/sysc/datatypes/fx/scfx_utils.h
new file mode 100644
index 000000000..55fabe045
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/fx/scfx_utils.h
@@ -0,0 +1,534 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  scfx_utils.h - 
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: scfx_utils.h,v $
+// Revision 1.2  2009/02/28 00:26:20  acg
+//  Andy Goodrich: bug fixes.
+//
+// Revision 1.1.1.1  2006/12/15 20:31:36  acg
+// SystemC 2.2
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SCFX_UTILS_H
+#define SCFX_UTILS_H
+
+
+#include "sysc/datatypes/fx/sc_fxdefs.h"
+#include "sysc/datatypes/fx/scfx_params.h"
+#include "sysc/datatypes/fx/scfx_string.h"
+
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  Find the most and least significant non-zero bits in a unsigned long
+// ----------------------------------------------------------------------------
+
+#define MSB_STATEMENT(n) if( x >> n ) { x >>= n; i += n; }
+
+inline
+int
+scfx_find_msb( unsigned long x )
+{
+    int i = 0;
+#   if defined(SC_LONG_64)
+        MSB_STATEMENT( 32 );
+#   endif // defined(SC_LONG_64)
+    MSB_STATEMENT( 16 );
+    MSB_STATEMENT( 8 );
+    MSB_STATEMENT( 4 );
+    MSB_STATEMENT( 2 );
+    MSB_STATEMENT( 1 );
+    return i;
+}
+
+#undef MSB_STATEMENT
+
+#define LSB_STATEMENT(n) if( x << n ) { x <<= n; i -= n; }
+
+inline
+int
+scfx_find_lsb( unsigned long x )
+{
+    int i;
+#   if defined(SC_LONG_64)
+        i = 63;
+        LSB_STATEMENT( 32 );
+#   else
+        i = 31;
+#   endif // defined(SC_LONG_64)
+    LSB_STATEMENT( 16 );
+    LSB_STATEMENT( 8 );
+    LSB_STATEMENT( 4 );
+    LSB_STATEMENT( 2 );
+    LSB_STATEMENT( 1 );
+    return i;
+}
+
+#undef LSB_STATEMENT
+
+
+// ----------------------------------------------------------------------------
+//  Utilities for parsing a character string number
+// ----------------------------------------------------------------------------
+
+inline
+int
+scfx_parse_sign( const char*& s, bool& sign_char )
+{
+    int sign = 1;
+
+    if( *s == '+' )
+    {
+        ++ s;
+	sign_char = true;
+    }
+    else if( *s == '-' )
+    {
+        sign = -1;
+        ++ s;
+	sign_char = true;
+    }
+    else
+	sign_char = false;
+
+    return sign;
+}
+
+inline
+sc_numrep
+scfx_parse_prefix( const char*& s )
+{
+    if( s[0] == '0' ) {
+        switch( s[1] )
+        {
+	    case 'b':
+	    case 'B':
+            {
+	        if( (s[2] == 'u' || s[2] == 'U') && (s[3] == 's' || s[3] == 'S') ) {
+		    s += 4;
+                    return SC_BIN_US;
+                }
+                if( (s[2] == 's' || s[2] == 'S') && (s[3] == 'm' || s[3] == 'M') ) {
+                    s += 4;
+                    return SC_BIN_SM;
+                }
+                s += 2;
+                return SC_BIN;
+            }
+	    case 'o':
+	    case 'O':
+	    {
+                if( (s[2] == 'u' || s[2] == 'U') && (s[3] == 's' || s[3] == 'S') ) {
+                    s += 4;
+                    return SC_OCT_US;
+                }
+                if( (s[2] == 's' || s[2] == 'S') && (s[3] == 'm' || s[3] == 'M') ) {
+                    s += 4;
+                    return SC_OCT_SM;
+                }
+                s += 2;
+                return SC_OCT;
+            }
+  	    case 'x':
+	    case 'X':
+            {
+                if( (s[2] == 'u' || s[2] == 'U') && (s[3] == 's' || s[3] == 'S') ) {
+                    s += 4;
+                    return SC_HEX_US;
+                }
+                if( (s[2] == 's' || s[2] == 'S') && (s[3] == 'm' || s[3] == 'M') ) {
+                    s += 4;
+                    return SC_HEX_SM;
+                }
+                s += 2;
+                return SC_HEX;
+            }
+   	    case 'd':
+	    case 'D':
+            {
+                s += 2;
+                return SC_DEC;
+            }
+	    case 'c':
+	    case 'C':
+            {
+                if( (s[2] == 's' || s[2] == 'S') && (s[3] == 'd' || s[3] == 'D') ) {
+                    s += 4;
+                    return SC_CSD;
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+
+    return SC_DEC;
+}
+
+
+inline
+int
+scfx_parse_base( const char*& s )
+{
+    const char* s1 = s + 1;
+
+    int base = 10;
+
+    if( *s == '0' )
+    {
+        switch( *s1 )
+	{
+            case 'b':
+            case 'B': base =  2; s += 2; break;
+            case 'o':
+            case 'O': base =  8; s += 2; break;
+            case 'd':
+            case 'D': base = 10; s += 2; break;
+            case 'x':
+            case 'X': base = 16; s += 2; break;
+        }
+    }
+
+    return base;
+}
+
+inline
+bool
+scfx_is_equal( const char* a, const char* b )
+{
+    while( *a != 0 && *b != 0 && *a == *b )
+    {
+        ++ a;
+        ++ b;
+    }
+    return ( *a == 0 && *b == 0 );
+}
+
+inline
+bool
+scfx_is_nan( const char* s )
+{
+    return scfx_is_equal( s, "NaN" );
+}
+
+inline
+bool
+scfx_is_inf( const char* s )
+{
+    return ( scfx_is_equal( s, "Inf" ) || scfx_is_equal( s, "Infinity" ) );
+}
+
+inline
+bool
+scfx_exp_start( const char* s )
+{
+    if( *s == 'e' || *s == 'E' )
+    {
+        ++ s;
+        if( *s == '+' || *s == '-' )
+            return true;
+    }
+    return false;
+}
+
+inline
+bool
+scfx_is_digit( char c, sc_numrep numrep )
+{
+    bool is_digit;
+
+    switch( numrep )
+    {
+        case SC_DEC:
+	{
+            switch( c )
+	    {
+                case '0': case '1': case '2': case '3': case '4':
+                case '5': case '6': case '7': case '8': case '9':
+		{
+                    is_digit = true;
+                    break;
+		}
+                default:
+                    is_digit = false;
+            }
+            break;
+	}
+	case SC_BIN:
+	case SC_BIN_US:
+	case SC_BIN_SM:
+	{
+            switch( c )
+	    {
+                case '0': case '1':
+		{
+                    is_digit = true;
+                    break;
+		}
+                default:
+                    is_digit = false;
+            }
+            break;
+	}
+	case SC_OCT:
+	case SC_OCT_US:
+	case SC_OCT_SM:
+	{
+            switch( c )
+	    {
+                case '0': case '1': case '2': case '3':
+                case '4': case '5': case '6': case '7':
+		{
+                    is_digit = true;
+                    break;
+		}
+                default:
+                    is_digit = false;
+            }
+            break;
+	}
+	case SC_HEX:
+	case SC_HEX_US:
+	case SC_HEX_SM:
+	{
+            switch( c )
+	    {
+                case '0': case '1': case '2': case '3': case '4':
+                case '5': case '6': case '7': case '8': case '9':
+                case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
+                case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
+		{
+                    is_digit = true;
+                    break;
+		}
+                default:
+                    is_digit = false;
+            }
+            break;
+	}
+	case SC_CSD:
+	{
+            switch( c )
+	    {
+		case '0': case '1': case '-':
+		{
+                    is_digit = true;
+                    break;
+		}
+                default:
+                    is_digit = false;
+            }
+            break;
+	}
+	default:
+            is_digit = false;
+    }
+
+    return is_digit;
+}
+
+inline
+int
+scfx_to_digit( char c, sc_numrep numrep )
+{
+    int to_digit;
+    
+    switch( numrep )
+    {
+	case SC_DEC:
+	case SC_BIN:
+	case SC_BIN_US:
+	case SC_BIN_SM:
+	case SC_OCT:
+	case SC_OCT_US:
+	case SC_OCT_SM:
+	{
+            to_digit = c - '0';
+            break;
+	}
+	case SC_HEX:
+	case SC_HEX_US:
+	case SC_HEX_SM:
+	{
+            switch( c )
+	    {
+                case '0': case '1': case '2': case '3': case '4':
+                case '5': case '6': case '7': case '8': case '9':
+                    to_digit = c - '0';
+                    break;
+                case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
+                    to_digit = c - 'a' + 10;
+                    break;
+                case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
+                    to_digit = c - 'A' + 10;
+                    break;
+                default:
+                    to_digit = -2;
+            }
+            break;
+	}
+	case SC_CSD:
+	{
+            if( c == '-' )
+                to_digit = -1;
+            else
+                to_digit = c - '0';
+            break;
+	}
+        default:
+            to_digit = -2;
+    }
+
+    return to_digit;
+}
+
+
+// ----------------------------------------------------------------------------
+//  Utilities for printing a character string number
+// ----------------------------------------------------------------------------
+
+inline
+void
+scfx_print_nan( scfx_string& s )
+{
+    s += "NaN";
+}
+
+inline
+void
+scfx_print_inf( scfx_string& s, bool negative )
+{
+    if( negative )
+        s += "-Inf";
+    else
+        s += "Inf";
+}
+
+inline
+void
+scfx_print_prefix( scfx_string& s, sc_numrep numrep )
+{
+    switch( numrep )
+    {
+        case SC_DEC:
+	    s += "0d";
+	    break;
+        case SC_BIN:
+	    s += "0b";
+	    break;
+        case SC_BIN_US:
+	    s += "0bus";
+	    break;
+        case SC_BIN_SM:
+	    s += "0bsm";
+	    break;
+        case SC_OCT:
+	    s += "0o";
+	    break;
+        case SC_OCT_US:
+	    s += "0ous";
+	    break;
+        case SC_OCT_SM:
+	    s += "0osm";
+	    break;
+        case SC_HEX:
+	    s += "0x";
+	    break;
+        case SC_HEX_US:
+	    s += "0xus";
+	    break;
+        case SC_HEX_SM:
+	    s += "0xsm";
+	    break;
+        case SC_CSD:
+	    s += "0csd";
+	    break;
+        default:
+	    s += "unknown";
+    }
+}
+
+inline
+void
+scfx_print_exp( scfx_string& s, int exp )
+{
+    if( exp != 0 )
+    {
+        s += 'e';
+                
+        if( exp < 0 )
+	{
+            exp = - exp;
+            s += '-';
+        }
+	else
+            s += '+';
+
+        bool first = true;
+        int scale = 1000000000;
+        do
+	{
+            int digit = exp / scale;
+            exp = exp % scale;
+            if( digit != 0 || ! first )
+	    {
+                s += static_cast<char>( digit + '0' );
+                first = false;
+            }
+            scale /= 10;
+        }
+	while( scale > 0 );
+    }
+}
+
+
+void scfx_tc2csd( scfx_string&, int );
+void scfx_csd2tc( scfx_string& );
+
+} // namespace sc_dt
+
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_bigint.h b/ext/systemc/src/sysc/datatypes/int/sc_bigint.h
new file mode 100644
index 000000000..d5445fc84
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_bigint.h
@@ -0,0 +1,271 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_bigint.h -- Template version of sc_signed. This class enables
+                 compile-time bit widths for sc_signed numbers.
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Gene Bushayev, Synopsys, Inc.
+  Description of Modification: - Interface between sc_bigint and sc_bv/sc_lv.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_bigint.h,v $
+// Revision 1.2  2011/02/18 20:19:14  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:49:31  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#ifndef SC_BIGINT_H
+#define SC_BIGINT_H
+
+
+#include "sysc/datatypes/int/sc_signed.h"
+#include "sysc/datatypes/int/sc_unsigned.h"
+
+namespace sc_dt
+{
+
+// classes defined in this module
+template <int W> class sc_bigint;
+
+// forward class declarations
+class sc_bv_base;
+class sc_lv_base;
+class sc_fxval;
+class sc_fxval_fast;
+class sc_fxnum;
+class sc_fxnum_fast;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_bigint<W>
+//
+//  Arbitrary size signed integer type.
+// ----------------------------------------------------------------------------
+
+#ifdef SC_MAX_NBITS
+template< int W = SC_MAX_NBITS >
+#else
+template< int W >
+#endif
+class sc_bigint
+    : public sc_signed
+{
+public:
+
+    // constructors
+
+    sc_bigint()
+	: sc_signed( W )
+	{}
+
+    sc_bigint( const sc_bigint<W>& v )
+	: sc_signed( W )
+	{ *this = v; }
+
+    sc_bigint( const sc_signed& v )
+	: sc_signed( W )
+	{ *this = v; }
+
+    sc_bigint( const sc_signed_subref& v )
+	: sc_signed( W )
+	{ *this = v; }
+
+    template< class T >
+    sc_bigint( const sc_generic_base<T>& a )
+	: sc_signed( W )
+	{ a->to_sc_signed(*this); }
+
+    sc_bigint( const sc_unsigned& v )
+	: sc_signed( W )
+	{ *this = v; }
+
+    sc_bigint( const sc_unsigned_subref& v )
+	: sc_signed( W )
+	{ *this = v; }
+
+    sc_bigint( const char* v )
+	: sc_signed( W )
+	{ *this = v; }
+
+    sc_bigint( int64 v )
+	: sc_signed( W )
+	{ *this = v; }
+
+    sc_bigint( uint64 v )
+	: sc_signed( W )
+	{ *this = v; }
+
+    sc_bigint( long v )
+	: sc_signed( W )
+	{ *this = v; }
+
+    sc_bigint( unsigned long v )
+	: sc_signed( W )
+	{ *this = v; }
+
+    sc_bigint( int v )
+	: sc_signed( W )
+	{ *this = v; }
+
+    sc_bigint( unsigned int v )
+	: sc_signed( W )
+	{ *this = v; }
+
+    sc_bigint( double v )
+	: sc_signed( W )
+	{ *this = v; }
+  
+    sc_bigint( const sc_bv_base& v )
+	: sc_signed( W )
+	{ *this = v; }
+
+    sc_bigint( const sc_lv_base& v )
+	: sc_signed( W )
+	{ *this = v; }
+
+#ifdef SC_INCLUDE_FX
+
+    explicit sc_bigint( const sc_fxval& v )
+	: sc_signed( W )
+	{ *this = v; }
+
+    explicit sc_bigint( const sc_fxval_fast& v )
+	: sc_signed( W )
+	{ *this = v; }
+
+    explicit sc_bigint( const sc_fxnum& v )
+	: sc_signed( W )
+	{ *this = v; }
+
+    explicit sc_bigint( const sc_fxnum_fast& v )
+	: sc_signed( W )
+	{ *this = v; }
+
+#endif
+
+
+#ifndef SC_MAX_NBITS
+
+    // destructor
+
+    ~sc_bigint()
+	{}
+
+#endif
+ 
+    // assignment operators
+
+    sc_bigint<W>& operator = ( const sc_bigint<W>& v )
+	{ sc_signed::operator = ( v ); return *this; }
+
+    sc_bigint<W>& operator = ( const sc_signed& v )
+	{ sc_signed::operator = ( v ); return *this; }
+
+    sc_bigint<W>& operator = (const sc_signed_subref& v )
+	{ sc_signed::operator = ( v ); return *this; }
+
+    template< class T >
+    sc_bigint<W>& operator = ( const sc_generic_base<T>& a )
+	{ a->to_sc_signed(*this); return *this;}
+
+    sc_bigint<W>& operator = ( const sc_unsigned& v )
+	{ sc_signed::operator = ( v ); return *this; }
+
+    sc_bigint<W>& operator = ( const sc_unsigned_subref& v )
+	{ sc_signed::operator = ( v ); return *this; }
+
+    sc_bigint<W>& operator = ( const char* v )
+	{ sc_signed::operator = ( v ); return *this; }
+
+    sc_bigint<W>& operator = ( int64 v )
+	{ sc_signed::operator = ( v ); return *this; }
+
+    sc_bigint<W>& operator = ( uint64 v )
+	{ sc_signed::operator = ( v ); return *this; }
+
+    sc_bigint<W>& operator = ( long v )
+	{ sc_signed::operator = ( v ); return *this; }
+
+    sc_bigint<W>& operator = ( unsigned long v )
+	{ sc_signed::operator = ( v ); return *this; }
+
+    sc_bigint<W>& operator = ( int v )
+	{ sc_signed::operator = ( v ); return *this; }
+
+    sc_bigint<W>& operator = ( unsigned int v )
+	{ sc_signed::operator = ( v ); return *this; }
+
+    sc_bigint<W>& operator = ( double v )
+	{ sc_signed::operator = ( v ); return *this; }
+
+
+    sc_bigint<W>& operator = ( const sc_bv_base& v )
+	{ sc_signed::operator = ( v ); return *this; }
+
+    sc_bigint<W>& operator = ( const sc_lv_base& v )
+	{ sc_signed::operator = ( v ); return *this; }
+
+    sc_bigint<W>& operator = ( const sc_int_base& v )
+	{ sc_signed::operator = ( v ); return *this; }
+
+    sc_bigint<W>& operator = ( const sc_uint_base& v )
+	{ sc_signed::operator = ( v ); return *this; }
+
+#ifdef SC_INCLUDE_FX
+
+    sc_bigint<W>& operator = ( const sc_fxval& v )
+	{ sc_signed::operator = ( v ); return *this; }
+
+    sc_bigint<W>& operator = ( const sc_fxval_fast& v )
+	{ sc_signed::operator = ( v ); return *this; }
+
+    sc_bigint<W>& operator = ( const sc_fxnum& v )
+	{ sc_signed::operator = ( v ); return *this; }
+
+    sc_bigint<W>& operator = ( const sc_fxnum_fast& v )
+	{ sc_signed::operator = ( v ); return *this; }
+
+#endif
+};
+
+} // namespace sc_dt
+
+
+#endif
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_biguint.h b/ext/systemc/src/sysc/datatypes/int/sc_biguint.h
new file mode 100644
index 000000000..689f41e63
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_biguint.h
@@ -0,0 +1,272 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_biguint.h -- Template version of sc_unsigned. This class
+                  enables compile-time bit widths for sc_unsigned numbers.
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+ 
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Gene Bushayev, Synopsys, Inc.
+  Description of Modification: - Interface between sc_bigint and sc_bv/sc_lv.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_biguint.h,v $
+// Revision 1.2  2011/02/18 20:19:14  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:49:31  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#ifndef SC_BIGUINT_H
+#define SC_BIGUINT_H
+
+
+#include "sysc/datatypes/int/sc_signed.h"
+#include "sysc/datatypes/int/sc_unsigned.h"
+
+namespace sc_dt
+{
+
+// classes defined in this module
+template <int W> class sc_biguint;
+
+// forward class declarations
+class sc_bv_base;
+class sc_lv_base;
+class sc_fxval;
+class sc_fxval_fast;
+class sc_fxnum;
+class sc_fxnum_fast;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_biguint<W>
+//
+//  Arbitrary size unsigned integer type.
+// ----------------------------------------------------------------------------
+
+#ifdef SC_MAX_NBITS
+template< int W = SC_MAX_NBITS >
+#else
+template< int W >
+#endif
+class sc_biguint
+    : public sc_unsigned
+{
+public:
+
+    // constructors
+
+    sc_biguint()
+	: sc_unsigned( W )
+	{}
+
+    sc_biguint( const sc_biguint<W>& v )
+	: sc_unsigned( W )
+	{ *this = v; }
+
+    sc_biguint( const sc_unsigned& v )
+	: sc_unsigned( W )
+	{ *this = v; }
+
+    sc_biguint( const sc_unsigned_subref& v )
+	: sc_unsigned( W )
+	{ *this = v; }
+
+    template< class T >
+    sc_biguint( const sc_generic_base<T>& a )
+	: sc_unsigned( W )
+	{ a->to_sc_unsigned(*this); }
+
+    sc_biguint( const sc_signed& v )
+	: sc_unsigned( W )
+	{ *this = v; }
+
+    sc_biguint( const sc_signed_subref& v )
+	: sc_unsigned( W )
+	{ *this = v; }
+
+    sc_biguint( const char* v )
+	: sc_unsigned( W )
+	{ *this = v; } 
+
+    sc_biguint( int64 v )
+	: sc_unsigned( W )
+	{ *this = v; }
+
+    sc_biguint( uint64 v )
+	: sc_unsigned( W )
+	{ *this = v; }
+
+    sc_biguint( long v )
+	: sc_unsigned( W )
+	{ *this = v; }
+
+    sc_biguint( unsigned long v )
+	: sc_unsigned( W )
+	{ *this = v; }
+
+    sc_biguint( int v )
+	: sc_unsigned( W )
+	{ *this = v; } 
+
+    sc_biguint( unsigned int v )
+	: sc_unsigned( W )
+	{ *this = v; }
+
+    sc_biguint( double v )
+	: sc_unsigned( W )
+	{ *this = v; }
+  
+    sc_biguint( const sc_bv_base& v )
+	: sc_unsigned( W )
+	{ *this = v; }
+
+    sc_biguint( const sc_lv_base& v )
+	: sc_unsigned( W )
+	{ *this = v; }
+
+#ifdef SC_INCLUDE_FX
+
+    explicit sc_biguint( const sc_fxval& v )
+	: sc_unsigned( W )
+	{ *this = v; }
+
+    explicit sc_biguint( const sc_fxval_fast& v )
+	: sc_unsigned( W )
+	{ *this = v; }
+
+    explicit sc_biguint( const sc_fxnum& v )
+	: sc_unsigned( W )
+	{ *this = v; }
+
+    explicit sc_biguint( const sc_fxnum_fast& v )
+	: sc_unsigned( W )
+	{ *this = v; }
+
+#endif
+
+
+#ifndef SC_MAX_NBITS
+
+    // destructor
+
+    ~sc_biguint()
+	{}
+
+#endif
+ 
+
+    // assignment operators
+
+    sc_biguint<W>& operator = ( const sc_biguint<W>& v )
+	{ sc_unsigned::operator = ( v ); return *this; }
+
+    sc_biguint<W>& operator = ( const sc_unsigned& v )
+	{ sc_unsigned::operator = ( v ); return *this; }
+
+    sc_biguint<W>& operator = ( const sc_unsigned_subref& v )
+	{ sc_unsigned::operator = ( v ); return *this; }
+
+    template< class T >
+    sc_biguint<W>& operator = ( const sc_generic_base<T>& a )
+	{ a->to_sc_unsigned(*this); return *this; }
+
+    sc_biguint<W>& operator = ( const sc_signed& v )
+	{ sc_unsigned::operator = ( v ); return *this; }
+
+    sc_biguint<W>& operator = ( const sc_signed_subref& v )
+	{ sc_unsigned::operator = ( v ); return *this; }
+
+    sc_biguint<W>& operator = ( const char* v ) 
+	{ sc_unsigned::operator = ( v ); return *this; }
+
+    sc_biguint<W>& operator = ( int64 v )
+	{ sc_unsigned::operator = ( v ); return *this; }
+
+    sc_biguint<W>& operator = ( uint64 v )
+	{ sc_unsigned::operator = ( v ); return *this; }
+
+    sc_biguint<W>& operator = ( long v )
+	{ sc_unsigned::operator = ( v ); return *this; }
+
+    sc_biguint<W>& operator = ( unsigned long v )
+	{ sc_unsigned::operator = ( v ); return *this; }
+
+    sc_biguint<W>& operator = ( int v ) 
+	{ sc_unsigned::operator = ( v ); return *this; }
+
+    sc_biguint<W>& operator = ( unsigned int v ) 
+	{ sc_unsigned::operator = ( v ); return *this; }
+
+    sc_biguint<W>& operator = ( double v )
+	{ sc_unsigned::operator = ( v ); return *this; }
+
+
+    sc_biguint<W>& operator = ( const sc_bv_base& v )
+	{ sc_unsigned::operator = ( v ); return *this; }
+
+    sc_biguint<W>& operator = ( const sc_lv_base& v )
+	{ sc_unsigned::operator = ( v ); return *this; }
+
+    sc_biguint<W>& operator = ( const sc_int_base& v )
+	{ sc_unsigned::operator = ( v ); return *this; }
+
+    sc_biguint<W>& operator = ( const sc_uint_base& v )
+	{ sc_unsigned::operator = ( v ); return *this; }
+
+#ifdef SC_INCLUDE_FX
+
+    sc_biguint<W>& operator = ( const sc_fxval& v )
+	{ sc_unsigned::operator = ( v ); return *this; }
+
+    sc_biguint<W>& operator = ( const sc_fxval_fast& v )
+	{ sc_unsigned::operator = ( v ); return *this; }
+
+    sc_biguint<W>& operator = ( const sc_fxnum& v )
+	{ sc_unsigned::operator = ( v ); return *this; }
+
+    sc_biguint<W>& operator = ( const sc_fxnum_fast& v )
+	{ sc_unsigned::operator = ( v ); return *this; }
+
+#endif
+};
+
+} // namespace sc_dt
+
+
+#endif
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_int.h b/ext/systemc/src/sysc/datatypes/int/sc_int.h
new file mode 100644
index 000000000..adcb6b321
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_int.h
@@ -0,0 +1,312 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_int.h -- A sc_int is a signed integer whose length is less than the
+              machine's native integer length. We provide two implementations
+              (i) sc_int with length between 1 - 64, and (ii) sc_int with
+              length between 1 - 32. Implementation (i) is the default
+              implementation, while implementation (ii) can be used only if
+              the class library is compiled with -D_32BIT_. Unlike arbitrary
+              precision, arithmetic and bitwise operations are performed
+              using the native types (hence capped at 32/64 bits). The sc_int
+              integer is useful when the user does not need arbitrary
+              precision and the performance is superior to
+              sc_bigint/sc_biguint.
+
+  Original Author: Amit Rao, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Ali Dasdan, Synopsys, Inc.
+  Description of Modification: - Resolved ambiguity with sc_(un)signed.
+                               - Merged the code for 64- and 32-bit versions
+                                 via the constants in sc_nbdefs.h.
+                               - Eliminated redundant file inclusions.
+    
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_int.h,v $
+// Revision 1.2  2011/02/18 20:19:14  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:49:31  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#ifndef SC_INT_H
+#define SC_INT_H
+
+
+#include "sysc/datatypes/int/sc_int_base.h"
+
+
+namespace sc_dt
+{
+
+// classes defined in this module
+template <int W> class sc_int;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_int<W>
+//
+//  Template class sc_int<W> is the interface that the user sees. It is
+//  derived from sc_int_base and most of its methods are just wrappers
+//  that call the corresponding method in the parent class. Note that
+//  the length of sc_int datatype is specified as a template parameter.
+// ----------------------------------------------------------------------------
+
+template <int W>
+class sc_int
+    : public sc_int_base
+{
+public:
+
+    // constructors
+
+    sc_int()
+	: sc_int_base( W )
+	{}
+
+    sc_int( int_type v )
+	: sc_int_base( v, W )
+	{}
+
+    sc_int( const sc_int<W>& a )
+	: sc_int_base( a )
+	{}
+
+    sc_int( const sc_int_base& a )
+	: sc_int_base( W )
+	{ sc_int_base::operator = ( a ); }
+
+    sc_int( const sc_int_subref_r& a )
+	: sc_int_base( W )
+	{ sc_int_base::operator = ( a ); }
+
+    template< class T >
+    sc_int( const sc_generic_base<T>& a )
+	: sc_int_base( W )
+	{ sc_int_base::operator = ( a->to_int64() ); }
+
+    sc_int( const sc_signed& a )
+	: sc_int_base( W )
+	{ sc_int_base::operator = ( a ); }
+
+    sc_int( const sc_unsigned& a )
+	: sc_int_base( W )
+	{ sc_int_base::operator = ( a ); }
+
+#ifdef SC_INCLUDE_FX
+
+    explicit sc_int( const sc_fxval& a )
+	: sc_int_base( W )
+	{ sc_int_base::operator = ( a ); }
+
+    explicit sc_int( const sc_fxval_fast& a )
+	: sc_int_base( W )
+	{ sc_int_base::operator = ( a ); }
+
+    explicit sc_int( const sc_fxnum& a )
+	: sc_int_base( W )
+	{ sc_int_base::operator = ( a ); }
+
+    explicit sc_int( const sc_fxnum_fast& a )
+	: sc_int_base( W )
+	{ sc_int_base::operator = ( a ); }
+
+#endif
+
+    sc_int( const sc_bv_base& a )
+	: sc_int_base( W )
+	{ sc_int_base::operator = ( a ); }
+
+    sc_int( const sc_lv_base& a )
+	: sc_int_base( W )
+	{ sc_int_base::operator = ( a ); }
+
+    sc_int( const char* a )
+	: sc_int_base( W )
+	{ sc_int_base::operator = ( a ); }
+
+    sc_int( unsigned long a )
+	: sc_int_base( W )
+	{ sc_int_base::operator = ( a ); }
+
+    sc_int( long a )
+	: sc_int_base( W )
+	{ sc_int_base::operator = ( a ); }
+
+    sc_int( unsigned int a )
+	: sc_int_base( W )
+	{ sc_int_base::operator = ( a ); }
+
+    sc_int( int a )
+	: sc_int_base( W )
+	{ sc_int_base::operator = ( a ); }
+
+    sc_int( uint64 a )
+	: sc_int_base( W )
+	{ sc_int_base::operator = ( a ); }
+
+    sc_int( double a )
+	: sc_int_base( W )
+	{ sc_int_base::operator = ( a ); }
+
+
+    // assignment operators
+
+    sc_int<W>& operator = ( int_type v )
+	{ sc_int_base::operator = ( v ); return *this; }
+
+    sc_int<W>& operator = ( const sc_int_base& a )
+	{ sc_int_base::operator = ( a ); return *this; }
+
+    sc_int<W>& operator = ( const sc_int_subref_r& a )
+	{ sc_int_base::operator = ( a ); return *this; }
+
+    sc_int<W>& operator = ( const sc_int<W>& a )
+	{ m_val = a.m_val; return *this; }
+
+    template< class T >
+    sc_int<W>& operator = ( const sc_generic_base<T>& a )
+	{ sc_int_base::operator = ( a->to_int64() ); return *this; }
+
+    sc_int<W>& operator = ( const sc_signed& a )
+	{ sc_int_base::operator = ( a ); return *this; }
+
+    sc_int<W>& operator = ( const sc_unsigned& a )
+	{ sc_int_base::operator = ( a ); return *this; }
+
+#ifdef SC_INCLUDE_FX
+
+    sc_int<W>& operator = ( const sc_fxval& a )
+	{ sc_int_base::operator = ( a ); return *this; }
+
+    sc_int<W>& operator = ( const sc_fxval_fast& a )
+	{ sc_int_base::operator = ( a ); return *this; }
+
+    sc_int<W>& operator = ( const sc_fxnum& a )
+	{ sc_int_base::operator = ( a ); return *this; }
+
+    sc_int<W>& operator = ( const sc_fxnum_fast& a )
+	{ sc_int_base::operator = ( a ); return *this; }
+
+#endif
+
+    sc_int<W>& operator = ( const sc_bv_base& a )
+	{ sc_int_base::operator = ( a ); return *this; }
+
+    sc_int<W>& operator = ( const sc_lv_base& a )
+	{ sc_int_base::operator = ( a ); return *this; }
+
+    sc_int<W>& operator = ( const char* a )
+	{ sc_int_base::operator = ( a ); return *this; }
+
+    sc_int<W>& operator = ( unsigned long a )
+	{ sc_int_base::operator = ( a ); return *this; }
+
+    sc_int<W>& operator = ( long a )
+	{ sc_int_base::operator = ( a ); return *this; }
+
+    sc_int<W>& operator = ( unsigned int a )
+	{ sc_int_base::operator = ( a ); return *this; }
+
+    sc_int<W>& operator = ( int a )
+	{ sc_int_base::operator = ( a ); return *this; }
+
+    sc_int<W>& operator = ( uint64 a )
+	{ sc_int_base::operator = ( a ); return *this; }
+
+    sc_int<W>& operator = ( double a )
+	{ sc_int_base::operator = ( a ); return *this; }
+
+
+    // arithmetic assignment operators
+
+    sc_int<W>& operator += ( int_type v )
+	{ sc_int_base::operator += ( v ); return *this; }
+
+    sc_int<W>& operator -= ( int_type v )
+	{ sc_int_base::operator -= ( v ); return *this; }
+
+    sc_int<W>& operator *= ( int_type v )
+	{ sc_int_base::operator *= ( v ); return *this; }
+
+    sc_int<W>& operator /= ( int_type v )
+	{ sc_int_base::operator /= ( v ); return *this; }
+
+    sc_int<W>& operator %= ( int_type v )
+	{ sc_int_base::operator %= ( v ); return *this; }
+
+
+    // bitwise assignment operators
+
+    sc_int<W>& operator &= ( int_type v )
+	{ sc_int_base::operator &= ( v ); return *this; }
+
+    sc_int<W>& operator |= ( int_type v )
+	{ sc_int_base::operator |= ( v ); return *this; }
+
+    sc_int<W>& operator ^= ( int_type v )
+	{ sc_int_base::operator ^= ( v ); return *this; }
+
+
+    sc_int<W>& operator <<= ( int_type v )
+	{ sc_int_base::operator <<= ( v ); return *this; }
+
+    sc_int<W>& operator >>= ( int_type v )
+	{ sc_int_base::operator >>= ( v ); return *this; }
+
+
+    // prefix and postfix increment and decrement operators
+
+    sc_int<W>& operator ++ () // prefix
+	{ sc_int_base::operator ++ (); return *this; }
+
+    const sc_int<W> operator ++ ( int ) // postfix
+	{ return sc_int<W>( sc_int_base::operator ++ ( 0 ) ); }
+
+    sc_int<W>& operator -- () // prefix
+	{ sc_int_base::operator -- (); return *this; }
+
+    const sc_int<W> operator -- ( int ) // postfix
+	{ return sc_int<W>( sc_int_base::operator -- ( 0 ) ); }
+};
+
+} // namespace sc_dt
+
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_int32_mask.cpp b/ext/systemc/src/sysc/datatypes/int/sc_int32_mask.cpp
new file mode 100644
index 000000000..5e55dfb87
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_int32_mask.cpp
@@ -0,0 +1,665 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_int32_mask.cpp -- Fills the mask_int lookup table to enable efficient
+                       part-selection on 32-bit sc_ints and sc_uints.
+
+  Original Author: Amit Rao, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Ali Dasdan, Synopsys, Inc.
+  Description of Modification: - Resolved ambiguity with sc_(un)signed.
+                               - Merged the code for 64- and 32-bit versions
+                                 via the constants in sc_nbdefs.h.
+                               - Eliminated redundant file inclusions.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_int32_mask.cpp,v $
+// Revision 1.2  2011/02/18 20:19:14  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:49:31  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#ifdef _32BIT_
+
+#include "sysc/datatypes/int/sc_int_base.h"
+#include "sysc/datatypes/int/sc_uint_base.h"
+
+
+namespace sc_dt
+{
+
+const uint_type mask_int[SC_INTWIDTH][SC_INTWIDTH] = 
+{
+{
+0xfffffffeU
+},
+{
+0xfffffffcU,
+0xfffffffdU
+},
+{
+0xfffffff8U,
+0xfffffff9U,
+0xfffffffbU
+},
+{
+0xfffffff0U,
+0xfffffff1U,
+0xfffffff3U,
+0xfffffff7U
+},
+{
+0xffffffe0U,
+0xffffffe1U,
+0xffffffe3U,
+0xffffffe7U,
+0xffffffefU
+},
+{
+0xffffffc0U,
+0xffffffc1U,
+0xffffffc3U,
+0xffffffc7U,
+0xffffffcfU,
+0xffffffdfU
+},
+{
+0xffffff80U,
+0xffffff81U,
+0xffffff83U,
+0xffffff87U,
+0xffffff8fU,
+0xffffff9fU,
+0xffffffbfU
+},
+{
+0xffffff00U,
+0xffffff01U,
+0xffffff03U,
+0xffffff07U,
+0xffffff0fU,
+0xffffff1fU,
+0xffffff3fU,
+0xffffff7fU
+},
+{
+0xfffffe00U,
+0xfffffe01U,
+0xfffffe03U,
+0xfffffe07U,
+0xfffffe0fU,
+0xfffffe1fU,
+0xfffffe3fU,
+0xfffffe7fU,
+0xfffffeffU
+},
+{
+0xfffffc00U,
+0xfffffc01U,
+0xfffffc03U,
+0xfffffc07U,
+0xfffffc0fU,
+0xfffffc1fU,
+0xfffffc3fU,
+0xfffffc7fU,
+0xfffffcffU,
+0xfffffdffU
+},
+{
+0xfffff800U,
+0xfffff801U,
+0xfffff803U,
+0xfffff807U,
+0xfffff80fU,
+0xfffff81fU,
+0xfffff83fU,
+0xfffff87fU,
+0xfffff8ffU,
+0xfffff9ffU,
+0xfffffbffU
+},
+{
+0xfffff000U,
+0xfffff001U,
+0xfffff003U,
+0xfffff007U,
+0xfffff00fU,
+0xfffff01fU,
+0xfffff03fU,
+0xfffff07fU,
+0xfffff0ffU,
+0xfffff1ffU,
+0xfffff3ffU,
+0xfffff7ffU
+},
+{
+0xffffe000U,
+0xffffe001U,
+0xffffe003U,
+0xffffe007U,
+0xffffe00fU,
+0xffffe01fU,
+0xffffe03fU,
+0xffffe07fU,
+0xffffe0ffU,
+0xffffe1ffU,
+0xffffe3ffU,
+0xffffe7ffU,
+0xffffefffU
+},
+{
+0xffffc000U,
+0xffffc001U,
+0xffffc003U,
+0xffffc007U,
+0xffffc00fU,
+0xffffc01fU,
+0xffffc03fU,
+0xffffc07fU,
+0xffffc0ffU,
+0xffffc1ffU,
+0xffffc3ffU,
+0xffffc7ffU,
+0xffffcfffU,
+0xffffdfffU
+},
+{
+0xffff8000U,
+0xffff8001U,
+0xffff8003U,
+0xffff8007U,
+0xffff800fU,
+0xffff801fU,
+0xffff803fU,
+0xffff807fU,
+0xffff80ffU,
+0xffff81ffU,
+0xffff83ffU,
+0xffff87ffU,
+0xffff8fffU,
+0xffff9fffU,
+0xffffbfffU
+},
+{
+0xffff0000U,
+0xffff0001U,
+0xffff0003U,
+0xffff0007U,
+0xffff000fU,
+0xffff001fU,
+0xffff003fU,
+0xffff007fU,
+0xffff00ffU,
+0xffff01ffU,
+0xffff03ffU,
+0xffff07ffU,
+0xffff0fffU,
+0xffff1fffU,
+0xffff3fffU,
+0xffff7fffU
+},
+{
+0xfffe0000U,
+0xfffe0001U,
+0xfffe0003U,
+0xfffe0007U,
+0xfffe000fU,
+0xfffe001fU,
+0xfffe003fU,
+0xfffe007fU,
+0xfffe00ffU,
+0xfffe01ffU,
+0xfffe03ffU,
+0xfffe07ffU,
+0xfffe0fffU,
+0xfffe1fffU,
+0xfffe3fffU,
+0xfffe7fffU,
+0xfffeffffU
+},
+{
+0xfffc0000U,
+0xfffc0001U,
+0xfffc0003U,
+0xfffc0007U,
+0xfffc000fU,
+0xfffc001fU,
+0xfffc003fU,
+0xfffc007fU,
+0xfffc00ffU,
+0xfffc01ffU,
+0xfffc03ffU,
+0xfffc07ffU,
+0xfffc0fffU,
+0xfffc1fffU,
+0xfffc3fffU,
+0xfffc7fffU,
+0xfffcffffU,
+0xfffdffffU
+},
+{
+0xfff80000U,
+0xfff80001U,
+0xfff80003U,
+0xfff80007U,
+0xfff8000fU,
+0xfff8001fU,
+0xfff8003fU,
+0xfff8007fU,
+0xfff800ffU,
+0xfff801ffU,
+0xfff803ffU,
+0xfff807ffU,
+0xfff80fffU,
+0xfff81fffU,
+0xfff83fffU,
+0xfff87fffU,
+0xfff8ffffU,
+0xfff9ffffU,
+0xfffbffffU
+},
+{
+0xfff00000U,
+0xfff00001U,
+0xfff00003U,
+0xfff00007U,
+0xfff0000fU,
+0xfff0001fU,
+0xfff0003fU,
+0xfff0007fU,
+0xfff000ffU,
+0xfff001ffU,
+0xfff003ffU,
+0xfff007ffU,
+0xfff00fffU,
+0xfff01fffU,
+0xfff03fffU,
+0xfff07fffU,
+0xfff0ffffU,
+0xfff1ffffU,
+0xfff3ffffU,
+0xfff7ffffU
+},
+{
+0xffe00000U,
+0xffe00001U,
+0xffe00003U,
+0xffe00007U,
+0xffe0000fU,
+0xffe0001fU,
+0xffe0003fU,
+0xffe0007fU,
+0xffe000ffU,
+0xffe001ffU,
+0xffe003ffU,
+0xffe007ffU,
+0xffe00fffU,
+0xffe01fffU,
+0xffe03fffU,
+0xffe07fffU,
+0xffe0ffffU,
+0xffe1ffffU,
+0xffe3ffffU,
+0xffe7ffffU,
+0xffefffffU
+},
+{
+0xffc00000U,
+0xffc00001U,
+0xffc00003U,
+0xffc00007U,
+0xffc0000fU,
+0xffc0001fU,
+0xffc0003fU,
+0xffc0007fU,
+0xffc000ffU,
+0xffc001ffU,
+0xffc003ffU,
+0xffc007ffU,
+0xffc00fffU,
+0xffc01fffU,
+0xffc03fffU,
+0xffc07fffU,
+0xffc0ffffU,
+0xffc1ffffU,
+0xffc3ffffU,
+0xffc7ffffU,
+0xffcfffffU,
+0xffdfffffU
+},
+{
+0xff800000U,
+0xff800001U,
+0xff800003U,
+0xff800007U,
+0xff80000fU,
+0xff80001fU,
+0xff80003fU,
+0xff80007fU,
+0xff8000ffU,
+0xff8001ffU,
+0xff8003ffU,
+0xff8007ffU,
+0xff800fffU,
+0xff801fffU,
+0xff803fffU,
+0xff807fffU,
+0xff80ffffU,
+0xff81ffffU,
+0xff83ffffU,
+0xff87ffffU,
+0xff8fffffU,
+0xff9fffffU,
+0xffbfffffU
+},
+{
+0xff000000U,
+0xff000001U,
+0xff000003U,
+0xff000007U,
+0xff00000fU,
+0xff00001fU,
+0xff00003fU,
+0xff00007fU,
+0xff0000ffU,
+0xff0001ffU,
+0xff0003ffU,
+0xff0007ffU,
+0xff000fffU,
+0xff001fffU,
+0xff003fffU,
+0xff007fffU,
+0xff00ffffU,
+0xff01ffffU,
+0xff03ffffU,
+0xff07ffffU,
+0xff0fffffU,
+0xff1fffffU,
+0xff3fffffU,
+0xff7fffffU
+},
+{
+0xfe000000U,
+0xfe000001U,
+0xfe000003U,
+0xfe000007U,
+0xfe00000fU,
+0xfe00001fU,
+0xfe00003fU,
+0xfe00007fU,
+0xfe0000ffU,
+0xfe0001ffU,
+0xfe0003ffU,
+0xfe0007ffU,
+0xfe000fffU,
+0xfe001fffU,
+0xfe003fffU,
+0xfe007fffU,
+0xfe00ffffU,
+0xfe01ffffU,
+0xfe03ffffU,
+0xfe07ffffU,
+0xfe0fffffU,
+0xfe1fffffU,
+0xfe3fffffU,
+0xfe7fffffU,
+0xfeffffffU
+},
+{
+0xfc000000U,
+0xfc000001U,
+0xfc000003U,
+0xfc000007U,
+0xfc00000fU,
+0xfc00001fU,
+0xfc00003fU,
+0xfc00007fU,
+0xfc0000ffU,
+0xfc0001ffU,
+0xfc0003ffU,
+0xfc0007ffU,
+0xfc000fffU,
+0xfc001fffU,
+0xfc003fffU,
+0xfc007fffU,
+0xfc00ffffU,
+0xfc01ffffU,
+0xfc03ffffU,
+0xfc07ffffU,
+0xfc0fffffU,
+0xfc1fffffU,
+0xfc3fffffU,
+0xfc7fffffU,
+0xfcffffffU,
+0xfdffffffU
+},
+{
+0xf8000000U,
+0xf8000001U,
+0xf8000003U,
+0xf8000007U,
+0xf800000fU,
+0xf800001fU,
+0xf800003fU,
+0xf800007fU,
+0xf80000ffU,
+0xf80001ffU,
+0xf80003ffU,
+0xf80007ffU,
+0xf8000fffU,
+0xf8001fffU,
+0xf8003fffU,
+0xf8007fffU,
+0xf800ffffU,
+0xf801ffffU,
+0xf803ffffU,
+0xf807ffffU,
+0xf80fffffU,
+0xf81fffffU,
+0xf83fffffU,
+0xf87fffffU,
+0xf8ffffffU,
+0xf9ffffffU,
+0xfbffffffU
+},
+{
+0xf0000000U,
+0xf0000001U,
+0xf0000003U,
+0xf0000007U,
+0xf000000fU,
+0xf000001fU,
+0xf000003fU,
+0xf000007fU,
+0xf00000ffU,
+0xf00001ffU,
+0xf00003ffU,
+0xf00007ffU,
+0xf0000fffU,
+0xf0001fffU,
+0xf0003fffU,
+0xf0007fffU,
+0xf000ffffU,
+0xf001ffffU,
+0xf003ffffU,
+0xf007ffffU,
+0xf00fffffU,
+0xf01fffffU,
+0xf03fffffU,
+0xf07fffffU,
+0xf0ffffffU,
+0xf1ffffffU,
+0xf3ffffffU,
+0xf7ffffffU
+},
+{
+0xe0000000U,
+0xe0000001U,
+0xe0000003U,
+0xe0000007U,
+0xe000000fU,
+0xe000001fU,
+0xe000003fU,
+0xe000007fU,
+0xe00000ffU,
+0xe00001ffU,
+0xe00003ffU,
+0xe00007ffU,
+0xe0000fffU,
+0xe0001fffU,
+0xe0003fffU,
+0xe0007fffU,
+0xe000ffffU,
+0xe001ffffU,
+0xe003ffffU,
+0xe007ffffU,
+0xe00fffffU,
+0xe01fffffU,
+0xe03fffffU,
+0xe07fffffU,
+0xe0ffffffU,
+0xe1ffffffU,
+0xe3ffffffU,
+0xe7ffffffU,
+0xefffffffU
+},
+{
+0xc0000000U,
+0xc0000001U,
+0xc0000003U,
+0xc0000007U,
+0xc000000fU,
+0xc000001fU,
+0xc000003fU,
+0xc000007fU,
+0xc00000ffU,
+0xc00001ffU,
+0xc00003ffU,
+0xc00007ffU,
+0xc0000fffU,
+0xc0001fffU,
+0xc0003fffU,
+0xc0007fffU,
+0xc000ffffU,
+0xc001ffffU,
+0xc003ffffU,
+0xc007ffffU,
+0xc00fffffU,
+0xc01fffffU,
+0xc03fffffU,
+0xc07fffffU,
+0xc0ffffffU,
+0xc1ffffffU,
+0xc3ffffffU,
+0xc7ffffffU,
+0xcfffffffU,
+0xdfffffffU
+},
+{
+0x80000000U,
+0x80000001U,
+0x80000003U,
+0x80000007U,
+0x8000000fU,
+0x8000001fU,
+0x8000003fU,
+0x8000007fU,
+0x800000ffU,
+0x800001ffU,
+0x800003ffU,
+0x800007ffU,
+0x80000fffU,
+0x80001fffU,
+0x80003fffU,
+0x80007fffU,
+0x8000ffffU,
+0x8001ffffU,
+0x8003ffffU,
+0x8007ffffU,
+0x800fffffU,
+0x801fffffU,
+0x803fffffU,
+0x807fffffU,
+0x80ffffffU,
+0x81ffffffU,
+0x83ffffffU,
+0x87ffffffU,
+0x8fffffffU,
+0x9fffffffU,
+0xbfffffffU
+},
+{
+0x0U,
+0x1U,
+0x3U,
+0x7U,
+0xfU,
+0x1fU,
+0x3fU,
+0x7fU,
+0xffU,
+0x1ffU,
+0x3ffU,
+0x7ffU,
+0xfffU,
+0x1fffU,
+0x3fffU,
+0x7fffU,
+0xffffU,
+0x1ffffU,
+0x3ffffU,
+0x7ffffU,
+0xfffffU,
+0x1fffffU,
+0x3fffffU,
+0x7fffffU,
+0xffffffU,
+0x1ffffffU,
+0x3ffffffU,
+0x7ffffffU,
+0xfffffffU,
+0x1fffffffU,
+0x3fffffffU,
+0x7fffffffU
+}
+};
+
+} // namespace sc_dt
+
+#endif
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_int64_io.cpp b/ext/systemc/src/sysc/datatypes/int/sc_int64_io.cpp
new file mode 100644
index 000000000..b43bc6ed8
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_int64_io.cpp
@@ -0,0 +1,182 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_int64_io.cpp --
+
+  Original Author: Amit Rao, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_int64_io.cpp,v $
+// Revision 1.2  2011/02/18 20:19:14  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:49:31  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#include "sysc/utils/sc_iostream.h"
+#include "sysc/datatypes/int/sc_unsigned.h"
+#include "sysc/datatypes/int/sc_signed.h"
+#include "sysc/datatypes/int/sc_int_base.h"
+#include "sysc/datatypes/int/sc_uint_base.h"
+
+
+#if defined( _MSC_VER )
+
+namespace sc_dt
+{
+
+static void
+write_uint64(::std::ostream& os, uint64 val, int sign)
+{
+    const int WRITE_BUF_SIZE = 10 + sizeof(uint64)*3;
+    char buf[WRITE_BUF_SIZE];
+    char* buf_ptr = buf + WRITE_BUF_SIZE;
+    const char* show_base = "";
+    int show_base_len = 0;
+    int show_pos = 0;
+    fmtflags flags = os.flags();
+
+    if ((flags & ::std::ios::basefield) == ::std::ios::oct) {
+        do {
+            *--buf_ptr = (char)((val & 7) + '0');
+            val = val >> 3;
+        } while (val != 0);
+        if ((flags & ::std::ios::showbase) && (*buf_ptr != '0'))
+            *--buf_ptr = '0';
+    } else if ((flags & ::std::ios::basefield) == ::std::ios::hex) {
+        const char* xdigs = (flags & ::std::ios::uppercase) ? 
+            "0123456789ABCDEF0X" : 
+            "0123456789abcdef0x";
+        do {
+            *--buf_ptr = xdigs[val & 15];
+            val = val >> 4;
+        } while (val != 0);
+        if ((flags & ::std::ios::showbase)) {
+            show_base = xdigs + 16;
+            show_base_len = 2;
+        }
+    } else {
+        while (val > UINT_MAX) {
+            *--buf_ptr = (char)((val % 10) + '0');
+            val /= 10;
+        }
+        unsigned ival = (unsigned) val;
+        do {
+            *--buf_ptr = (ival % 10) + '0';
+            ival /= 10;
+        } while (ival != 0);
+        if (sign > 0 && (flags & ::std::ios::showpos))
+            show_pos = 1;
+    }
+
+    int buf_len = buf + WRITE_BUF_SIZE - buf_ptr;
+    int w = os.width(0);
+
+    int len = buf_len + show_pos;
+    if (sign < 0) len++;
+    len += show_base_len;
+
+    int padding = len > w ? 0 : w - len;
+    fmtflags pad_kind = flags & ::std::ios::adjustfield;
+    char fill_char = os.fill();
+
+    if (padding > 0 &&
+        ::std::ios::left != pad_kind &&
+        ::std::ios::internal != pad_kind) {
+        for (int i = padding - 1; i >= 0; --i) {
+            if (! os.put(fill_char))
+                goto fail;
+        }
+    }
+    if (sign < 0 || show_pos) {
+        if (! os.put(sign < 0 ? '-' : '+'))
+            goto fail;
+    }
+    if (show_base_len) {
+        if (! os.write(show_base, show_base_len))
+            goto fail;
+    }
+    if ((fmtflags)::std::ios::internal == pad_kind && padding > 0) {
+        for (int i = padding - 1; i >= 0; --i) {
+            if (! os.put(fill_char))
+                goto fail;
+        }
+    }
+    if (! os.write(buf_ptr, buf_len))
+        goto fail;
+    if ((fmtflags)::std::ios::left == pad_kind && padding > 0) {
+        for (int i = padding - 1; i >= 0; --i) {
+            if (! os.put(fill_char))
+                goto fail;
+        }
+    }
+    os.osfx();
+    return;
+fail:
+    //os.set(::std::ios::badbit);
+    os.osfx();
+}
+
+::std::ostream&
+operator << ( ::std::ostream& os, int64 n )
+{
+    if (os.opfx()) {
+        int sign = 1;
+        uint64 abs_n = (uint64) n;
+        if (n < 0 && (os.flags() & (::std::ios::oct|::std::ios::hex)) == 0) {
+            abs_n = -1*((uint64) n);
+            sign = -1;
+        }
+        sc_dt::write_uint64(os, abs_n, sign);
+    }
+    return os;
+}
+
+::std::ostream&
+operator << ( ::std::ostream& os, uint64 n )
+{
+    if (os.opfx()) {
+        sc_dt::write_uint64(os, n, 0);
+    }
+    return os;
+}
+
+} // namespace sc_dt
+
+
+#endif
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_int64_mask.cpp b/ext/systemc/src/sysc/datatypes/int/sc_int64_mask.cpp
new file mode 100644
index 000000000..df69a6dda
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_int64_mask.cpp
@@ -0,0 +1,4502 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_int64_mask.cpp -- Fills the mask_int lookup table to enable efficient
+                       part-selection on 64-bit sc_ints and sc_uints.
+
+  Original Author: Amit Rao, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Ali Dasdan, Synopsys, Inc.
+  Description of Modification: - Resolved ambiguity with sc_(un)signed.
+                               - Merged the code for 64- and 32-bit versions
+                                 via the constants in sc_nbdefs.h.
+                               - Eliminated redundant file inclusions.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_int64_mask.cpp,v $
+// Revision 1.3  2011/02/18 20:19:14  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.2  2009/05/22 16:06:29  acg
+//  Andy Goodrich: process control updates.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:49:31  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#ifndef _32BIT_
+
+#include "sysc/datatypes/int/sc_int_base.h"
+#include "sysc/datatypes/int/sc_uint_base.h"
+
+
+namespace sc_dt
+{
+
+#if !defined(_WIN32) || defined(__MINGW32__)
+
+const uint_type mask_int[SC_INTWIDTH][SC_INTWIDTH] = 
+{
+{
+0xfffffffffffffffeULL
+},
+{
+0xfffffffffffffffcULL,
+0xfffffffffffffffdULL
+},
+{
+0xfffffffffffffff8ULL,
+0xfffffffffffffff9ULL,
+0xfffffffffffffffbULL
+},
+{
+0xfffffffffffffff0ULL,
+0xfffffffffffffff1ULL,
+0xfffffffffffffff3ULL,
+0xfffffffffffffff7ULL
+},
+{
+0xffffffffffffffe0ULL,
+0xffffffffffffffe1ULL,
+0xffffffffffffffe3ULL,
+0xffffffffffffffe7ULL,
+0xffffffffffffffefULL
+},
+{
+0xffffffffffffffc0ULL,
+0xffffffffffffffc1ULL,
+0xffffffffffffffc3ULL,
+0xffffffffffffffc7ULL,
+0xffffffffffffffcfULL,
+0xffffffffffffffdfULL
+},
+{
+0xffffffffffffff80ULL,
+0xffffffffffffff81ULL,
+0xffffffffffffff83ULL,
+0xffffffffffffff87ULL,
+0xffffffffffffff8fULL,
+0xffffffffffffff9fULL,
+0xffffffffffffffbfULL
+},
+{
+0xffffffffffffff00ULL,
+0xffffffffffffff01ULL,
+0xffffffffffffff03ULL,
+0xffffffffffffff07ULL,
+0xffffffffffffff0fULL,
+0xffffffffffffff1fULL,
+0xffffffffffffff3fULL,
+0xffffffffffffff7fULL
+},
+{
+0xfffffffffffffe00ULL,
+0xfffffffffffffe01ULL,
+0xfffffffffffffe03ULL,
+0xfffffffffffffe07ULL,
+0xfffffffffffffe0fULL,
+0xfffffffffffffe1fULL,
+0xfffffffffffffe3fULL,
+0xfffffffffffffe7fULL,
+0xfffffffffffffeffULL
+},
+{
+0xfffffffffffffc00ULL,
+0xfffffffffffffc01ULL,
+0xfffffffffffffc03ULL,
+0xfffffffffffffc07ULL,
+0xfffffffffffffc0fULL,
+0xfffffffffffffc1fULL,
+0xfffffffffffffc3fULL,
+0xfffffffffffffc7fULL,
+0xfffffffffffffcffULL,
+0xfffffffffffffdffULL
+},
+{
+0xfffffffffffff800ULL,
+0xfffffffffffff801ULL,
+0xfffffffffffff803ULL,
+0xfffffffffffff807ULL,
+0xfffffffffffff80fULL,
+0xfffffffffffff81fULL,
+0xfffffffffffff83fULL,
+0xfffffffffffff87fULL,
+0xfffffffffffff8ffULL,
+0xfffffffffffff9ffULL,
+0xfffffffffffffbffULL
+},
+{
+0xfffffffffffff000ULL,
+0xfffffffffffff001ULL,
+0xfffffffffffff003ULL,
+0xfffffffffffff007ULL,
+0xfffffffffffff00fULL,
+0xfffffffffffff01fULL,
+0xfffffffffffff03fULL,
+0xfffffffffffff07fULL,
+0xfffffffffffff0ffULL,
+0xfffffffffffff1ffULL,
+0xfffffffffffff3ffULL,
+0xfffffffffffff7ffULL
+},
+{
+0xffffffffffffe000ULL,
+0xffffffffffffe001ULL,
+0xffffffffffffe003ULL,
+0xffffffffffffe007ULL,
+0xffffffffffffe00fULL,
+0xffffffffffffe01fULL,
+0xffffffffffffe03fULL,
+0xffffffffffffe07fULL,
+0xffffffffffffe0ffULL,
+0xffffffffffffe1ffULL,
+0xffffffffffffe3ffULL,
+0xffffffffffffe7ffULL,
+0xffffffffffffefffULL
+},
+{
+0xffffffffffffc000ULL,
+0xffffffffffffc001ULL,
+0xffffffffffffc003ULL,
+0xffffffffffffc007ULL,
+0xffffffffffffc00fULL,
+0xffffffffffffc01fULL,
+0xffffffffffffc03fULL,
+0xffffffffffffc07fULL,
+0xffffffffffffc0ffULL,
+0xffffffffffffc1ffULL,
+0xffffffffffffc3ffULL,
+0xffffffffffffc7ffULL,
+0xffffffffffffcfffULL,
+0xffffffffffffdfffULL
+},
+{
+0xffffffffffff8000ULL,
+0xffffffffffff8001ULL,
+0xffffffffffff8003ULL,
+0xffffffffffff8007ULL,
+0xffffffffffff800fULL,
+0xffffffffffff801fULL,
+0xffffffffffff803fULL,
+0xffffffffffff807fULL,
+0xffffffffffff80ffULL,
+0xffffffffffff81ffULL,
+0xffffffffffff83ffULL,
+0xffffffffffff87ffULL,
+0xffffffffffff8fffULL,
+0xffffffffffff9fffULL,
+0xffffffffffffbfffULL
+},
+{
+0xffffffffffff0000ULL,
+0xffffffffffff0001ULL,
+0xffffffffffff0003ULL,
+0xffffffffffff0007ULL,
+0xffffffffffff000fULL,
+0xffffffffffff001fULL,
+0xffffffffffff003fULL,
+0xffffffffffff007fULL,
+0xffffffffffff00ffULL,
+0xffffffffffff01ffULL,
+0xffffffffffff03ffULL,
+0xffffffffffff07ffULL,
+0xffffffffffff0fffULL,
+0xffffffffffff1fffULL,
+0xffffffffffff3fffULL,
+0xffffffffffff7fffULL
+},
+{
+0xfffffffffffe0000ULL,
+0xfffffffffffe0001ULL,
+0xfffffffffffe0003ULL,
+0xfffffffffffe0007ULL,
+0xfffffffffffe000fULL,
+0xfffffffffffe001fULL,
+0xfffffffffffe003fULL,
+0xfffffffffffe007fULL,
+0xfffffffffffe00ffULL,
+0xfffffffffffe01ffULL,
+0xfffffffffffe03ffULL,
+0xfffffffffffe07ffULL,
+0xfffffffffffe0fffULL,
+0xfffffffffffe1fffULL,
+0xfffffffffffe3fffULL,
+0xfffffffffffe7fffULL,
+0xfffffffffffeffffULL
+},
+{
+0xfffffffffffc0000ULL,
+0xfffffffffffc0001ULL,
+0xfffffffffffc0003ULL,
+0xfffffffffffc0007ULL,
+0xfffffffffffc000fULL,
+0xfffffffffffc001fULL,
+0xfffffffffffc003fULL,
+0xfffffffffffc007fULL,
+0xfffffffffffc00ffULL,
+0xfffffffffffc01ffULL,
+0xfffffffffffc03ffULL,
+0xfffffffffffc07ffULL,
+0xfffffffffffc0fffULL,
+0xfffffffffffc1fffULL,
+0xfffffffffffc3fffULL,
+0xfffffffffffc7fffULL,
+0xfffffffffffcffffULL,
+0xfffffffffffdffffULL
+},
+{
+0xfffffffffff80000ULL,
+0xfffffffffff80001ULL,
+0xfffffffffff80003ULL,
+0xfffffffffff80007ULL,
+0xfffffffffff8000fULL,
+0xfffffffffff8001fULL,
+0xfffffffffff8003fULL,
+0xfffffffffff8007fULL,
+0xfffffffffff800ffULL,
+0xfffffffffff801ffULL,
+0xfffffffffff803ffULL,
+0xfffffffffff807ffULL,
+0xfffffffffff80fffULL,
+0xfffffffffff81fffULL,
+0xfffffffffff83fffULL,
+0xfffffffffff87fffULL,
+0xfffffffffff8ffffULL,
+0xfffffffffff9ffffULL,
+0xfffffffffffbffffULL
+},
+{
+0xfffffffffff00000ULL,
+0xfffffffffff00001ULL,
+0xfffffffffff00003ULL,
+0xfffffffffff00007ULL,
+0xfffffffffff0000fULL,
+0xfffffffffff0001fULL,
+0xfffffffffff0003fULL,
+0xfffffffffff0007fULL,
+0xfffffffffff000ffULL,
+0xfffffffffff001ffULL,
+0xfffffffffff003ffULL,
+0xfffffffffff007ffULL,
+0xfffffffffff00fffULL,
+0xfffffffffff01fffULL,
+0xfffffffffff03fffULL,
+0xfffffffffff07fffULL,
+0xfffffffffff0ffffULL,
+0xfffffffffff1ffffULL,
+0xfffffffffff3ffffULL,
+0xfffffffffff7ffffULL
+},
+{
+0xffffffffffe00000ULL,
+0xffffffffffe00001ULL,
+0xffffffffffe00003ULL,
+0xffffffffffe00007ULL,
+0xffffffffffe0000fULL,
+0xffffffffffe0001fULL,
+0xffffffffffe0003fULL,
+0xffffffffffe0007fULL,
+0xffffffffffe000ffULL,
+0xffffffffffe001ffULL,
+0xffffffffffe003ffULL,
+0xffffffffffe007ffULL,
+0xffffffffffe00fffULL,
+0xffffffffffe01fffULL,
+0xffffffffffe03fffULL,
+0xffffffffffe07fffULL,
+0xffffffffffe0ffffULL,
+0xffffffffffe1ffffULL,
+0xffffffffffe3ffffULL,
+0xffffffffffe7ffffULL,
+0xffffffffffefffffULL
+},
+{
+0xffffffffffc00000ULL,
+0xffffffffffc00001ULL,
+0xffffffffffc00003ULL,
+0xffffffffffc00007ULL,
+0xffffffffffc0000fULL,
+0xffffffffffc0001fULL,
+0xffffffffffc0003fULL,
+0xffffffffffc0007fULL,
+0xffffffffffc000ffULL,
+0xffffffffffc001ffULL,
+0xffffffffffc003ffULL,
+0xffffffffffc007ffULL,
+0xffffffffffc00fffULL,
+0xffffffffffc01fffULL,
+0xffffffffffc03fffULL,
+0xffffffffffc07fffULL,
+0xffffffffffc0ffffULL,
+0xffffffffffc1ffffULL,
+0xffffffffffc3ffffULL,
+0xffffffffffc7ffffULL,
+0xffffffffffcfffffULL,
+0xffffffffffdfffffULL
+},
+{
+0xffffffffff800000ULL,
+0xffffffffff800001ULL,
+0xffffffffff800003ULL,
+0xffffffffff800007ULL,
+0xffffffffff80000fULL,
+0xffffffffff80001fULL,
+0xffffffffff80003fULL,
+0xffffffffff80007fULL,
+0xffffffffff8000ffULL,
+0xffffffffff8001ffULL,
+0xffffffffff8003ffULL,
+0xffffffffff8007ffULL,
+0xffffffffff800fffULL,
+0xffffffffff801fffULL,
+0xffffffffff803fffULL,
+0xffffffffff807fffULL,
+0xffffffffff80ffffULL,
+0xffffffffff81ffffULL,
+0xffffffffff83ffffULL,
+0xffffffffff87ffffULL,
+0xffffffffff8fffffULL,
+0xffffffffff9fffffULL,
+0xffffffffffbfffffULL
+},
+{
+0xffffffffff000000ULL,
+0xffffffffff000001ULL,
+0xffffffffff000003ULL,
+0xffffffffff000007ULL,
+0xffffffffff00000fULL,
+0xffffffffff00001fULL,
+0xffffffffff00003fULL,
+0xffffffffff00007fULL,
+0xffffffffff0000ffULL,
+0xffffffffff0001ffULL,
+0xffffffffff0003ffULL,
+0xffffffffff0007ffULL,
+0xffffffffff000fffULL,
+0xffffffffff001fffULL,
+0xffffffffff003fffULL,
+0xffffffffff007fffULL,
+0xffffffffff00ffffULL,
+0xffffffffff01ffffULL,
+0xffffffffff03ffffULL,
+0xffffffffff07ffffULL,
+0xffffffffff0fffffULL,
+0xffffffffff1fffffULL,
+0xffffffffff3fffffULL,
+0xffffffffff7fffffULL
+},
+{
+0xfffffffffe000000ULL,
+0xfffffffffe000001ULL,
+0xfffffffffe000003ULL,
+0xfffffffffe000007ULL,
+0xfffffffffe00000fULL,
+0xfffffffffe00001fULL,
+0xfffffffffe00003fULL,
+0xfffffffffe00007fULL,
+0xfffffffffe0000ffULL,
+0xfffffffffe0001ffULL,
+0xfffffffffe0003ffULL,
+0xfffffffffe0007ffULL,
+0xfffffffffe000fffULL,
+0xfffffffffe001fffULL,
+0xfffffffffe003fffULL,
+0xfffffffffe007fffULL,
+0xfffffffffe00ffffULL,
+0xfffffffffe01ffffULL,
+0xfffffffffe03ffffULL,
+0xfffffffffe07ffffULL,
+0xfffffffffe0fffffULL,
+0xfffffffffe1fffffULL,
+0xfffffffffe3fffffULL,
+0xfffffffffe7fffffULL,
+0xfffffffffeffffffULL
+},
+{
+0xfffffffffc000000ULL,
+0xfffffffffc000001ULL,
+0xfffffffffc000003ULL,
+0xfffffffffc000007ULL,
+0xfffffffffc00000fULL,
+0xfffffffffc00001fULL,
+0xfffffffffc00003fULL,
+0xfffffffffc00007fULL,
+0xfffffffffc0000ffULL,
+0xfffffffffc0001ffULL,
+0xfffffffffc0003ffULL,
+0xfffffffffc0007ffULL,
+0xfffffffffc000fffULL,
+0xfffffffffc001fffULL,
+0xfffffffffc003fffULL,
+0xfffffffffc007fffULL,
+0xfffffffffc00ffffULL,
+0xfffffffffc01ffffULL,
+0xfffffffffc03ffffULL,
+0xfffffffffc07ffffULL,
+0xfffffffffc0fffffULL,
+0xfffffffffc1fffffULL,
+0xfffffffffc3fffffULL,
+0xfffffffffc7fffffULL,
+0xfffffffffcffffffULL,
+0xfffffffffdffffffULL
+},
+{
+0xfffffffff8000000ULL,
+0xfffffffff8000001ULL,
+0xfffffffff8000003ULL,
+0xfffffffff8000007ULL,
+0xfffffffff800000fULL,
+0xfffffffff800001fULL,
+0xfffffffff800003fULL,
+0xfffffffff800007fULL,
+0xfffffffff80000ffULL,
+0xfffffffff80001ffULL,
+0xfffffffff80003ffULL,
+0xfffffffff80007ffULL,
+0xfffffffff8000fffULL,
+0xfffffffff8001fffULL,
+0xfffffffff8003fffULL,
+0xfffffffff8007fffULL,
+0xfffffffff800ffffULL,
+0xfffffffff801ffffULL,
+0xfffffffff803ffffULL,
+0xfffffffff807ffffULL,
+0xfffffffff80fffffULL,
+0xfffffffff81fffffULL,
+0xfffffffff83fffffULL,
+0xfffffffff87fffffULL,
+0xfffffffff8ffffffULL,
+0xfffffffff9ffffffULL,
+0xfffffffffbffffffULL
+},
+{
+0xfffffffff0000000ULL,
+0xfffffffff0000001ULL,
+0xfffffffff0000003ULL,
+0xfffffffff0000007ULL,
+0xfffffffff000000fULL,
+0xfffffffff000001fULL,
+0xfffffffff000003fULL,
+0xfffffffff000007fULL,
+0xfffffffff00000ffULL,
+0xfffffffff00001ffULL,
+0xfffffffff00003ffULL,
+0xfffffffff00007ffULL,
+0xfffffffff0000fffULL,
+0xfffffffff0001fffULL,
+0xfffffffff0003fffULL,
+0xfffffffff0007fffULL,
+0xfffffffff000ffffULL,
+0xfffffffff001ffffULL,
+0xfffffffff003ffffULL,
+0xfffffffff007ffffULL,
+0xfffffffff00fffffULL,
+0xfffffffff01fffffULL,
+0xfffffffff03fffffULL,
+0xfffffffff07fffffULL,
+0xfffffffff0ffffffULL,
+0xfffffffff1ffffffULL,
+0xfffffffff3ffffffULL,
+0xfffffffff7ffffffULL
+},
+{
+0xffffffffe0000000ULL,
+0xffffffffe0000001ULL,
+0xffffffffe0000003ULL,
+0xffffffffe0000007ULL,
+0xffffffffe000000fULL,
+0xffffffffe000001fULL,
+0xffffffffe000003fULL,
+0xffffffffe000007fULL,
+0xffffffffe00000ffULL,
+0xffffffffe00001ffULL,
+0xffffffffe00003ffULL,
+0xffffffffe00007ffULL,
+0xffffffffe0000fffULL,
+0xffffffffe0001fffULL,
+0xffffffffe0003fffULL,
+0xffffffffe0007fffULL,
+0xffffffffe000ffffULL,
+0xffffffffe001ffffULL,
+0xffffffffe003ffffULL,
+0xffffffffe007ffffULL,
+0xffffffffe00fffffULL,
+0xffffffffe01fffffULL,
+0xffffffffe03fffffULL,
+0xffffffffe07fffffULL,
+0xffffffffe0ffffffULL,
+0xffffffffe1ffffffULL,
+0xffffffffe3ffffffULL,
+0xffffffffe7ffffffULL,
+0xffffffffefffffffULL
+},
+{
+0xffffffffc0000000ULL,
+0xffffffffc0000001ULL,
+0xffffffffc0000003ULL,
+0xffffffffc0000007ULL,
+0xffffffffc000000fULL,
+0xffffffffc000001fULL,
+0xffffffffc000003fULL,
+0xffffffffc000007fULL,
+0xffffffffc00000ffULL,
+0xffffffffc00001ffULL,
+0xffffffffc00003ffULL,
+0xffffffffc00007ffULL,
+0xffffffffc0000fffULL,
+0xffffffffc0001fffULL,
+0xffffffffc0003fffULL,
+0xffffffffc0007fffULL,
+0xffffffffc000ffffULL,
+0xffffffffc001ffffULL,
+0xffffffffc003ffffULL,
+0xffffffffc007ffffULL,
+0xffffffffc00fffffULL,
+0xffffffffc01fffffULL,
+0xffffffffc03fffffULL,
+0xffffffffc07fffffULL,
+0xffffffffc0ffffffULL,
+0xffffffffc1ffffffULL,
+0xffffffffc3ffffffULL,
+0xffffffffc7ffffffULL,
+0xffffffffcfffffffULL,
+0xffffffffdfffffffULL
+},
+{
+0xffffffff80000000ULL,
+0xffffffff80000001ULL,
+0xffffffff80000003ULL,
+0xffffffff80000007ULL,
+0xffffffff8000000fULL,
+0xffffffff8000001fULL,
+0xffffffff8000003fULL,
+0xffffffff8000007fULL,
+0xffffffff800000ffULL,
+0xffffffff800001ffULL,
+0xffffffff800003ffULL,
+0xffffffff800007ffULL,
+0xffffffff80000fffULL,
+0xffffffff80001fffULL,
+0xffffffff80003fffULL,
+0xffffffff80007fffULL,
+0xffffffff8000ffffULL,
+0xffffffff8001ffffULL,
+0xffffffff8003ffffULL,
+0xffffffff8007ffffULL,
+0xffffffff800fffffULL,
+0xffffffff801fffffULL,
+0xffffffff803fffffULL,
+0xffffffff807fffffULL,
+0xffffffff80ffffffULL,
+0xffffffff81ffffffULL,
+0xffffffff83ffffffULL,
+0xffffffff87ffffffULL,
+0xffffffff8fffffffULL,
+0xffffffff9fffffffULL,
+0xffffffffbfffffffULL
+},
+{
+0xffffffff00000000ULL,
+0xffffffff00000001ULL,
+0xffffffff00000003ULL,
+0xffffffff00000007ULL,
+0xffffffff0000000fULL,
+0xffffffff0000001fULL,
+0xffffffff0000003fULL,
+0xffffffff0000007fULL,
+0xffffffff000000ffULL,
+0xffffffff000001ffULL,
+0xffffffff000003ffULL,
+0xffffffff000007ffULL,
+0xffffffff00000fffULL,
+0xffffffff00001fffULL,
+0xffffffff00003fffULL,
+0xffffffff00007fffULL,
+0xffffffff0000ffffULL,
+0xffffffff0001ffffULL,
+0xffffffff0003ffffULL,
+0xffffffff0007ffffULL,
+0xffffffff000fffffULL,
+0xffffffff001fffffULL,
+0xffffffff003fffffULL,
+0xffffffff007fffffULL,
+0xffffffff00ffffffULL,
+0xffffffff01ffffffULL,
+0xffffffff03ffffffULL,
+0xffffffff07ffffffULL,
+0xffffffff0fffffffULL,
+0xffffffff1fffffffULL,
+0xffffffff3fffffffULL,
+0xffffffff7fffffffULL
+},
+{
+0xfffffffe00000000ULL,
+0xfffffffe00000001ULL,
+0xfffffffe00000003ULL,
+0xfffffffe00000007ULL,
+0xfffffffe0000000fULL,
+0xfffffffe0000001fULL,
+0xfffffffe0000003fULL,
+0xfffffffe0000007fULL,
+0xfffffffe000000ffULL,
+0xfffffffe000001ffULL,
+0xfffffffe000003ffULL,
+0xfffffffe000007ffULL,
+0xfffffffe00000fffULL,
+0xfffffffe00001fffULL,
+0xfffffffe00003fffULL,
+0xfffffffe00007fffULL,
+0xfffffffe0000ffffULL,
+0xfffffffe0001ffffULL,
+0xfffffffe0003ffffULL,
+0xfffffffe0007ffffULL,
+0xfffffffe000fffffULL,
+0xfffffffe001fffffULL,
+0xfffffffe003fffffULL,
+0xfffffffe007fffffULL,
+0xfffffffe00ffffffULL,
+0xfffffffe01ffffffULL,
+0xfffffffe03ffffffULL,
+0xfffffffe07ffffffULL,
+0xfffffffe0fffffffULL,
+0xfffffffe1fffffffULL,
+0xfffffffe3fffffffULL,
+0xfffffffe7fffffffULL,
+0xfffffffeffffffffULL
+},
+{
+0xfffffffc00000000ULL,
+0xfffffffc00000001ULL,
+0xfffffffc00000003ULL,
+0xfffffffc00000007ULL,
+0xfffffffc0000000fULL,
+0xfffffffc0000001fULL,
+0xfffffffc0000003fULL,
+0xfffffffc0000007fULL,
+0xfffffffc000000ffULL,
+0xfffffffc000001ffULL,
+0xfffffffc000003ffULL,
+0xfffffffc000007ffULL,
+0xfffffffc00000fffULL,
+0xfffffffc00001fffULL,
+0xfffffffc00003fffULL,
+0xfffffffc00007fffULL,
+0xfffffffc0000ffffULL,
+0xfffffffc0001ffffULL,
+0xfffffffc0003ffffULL,
+0xfffffffc0007ffffULL,
+0xfffffffc000fffffULL,
+0xfffffffc001fffffULL,
+0xfffffffc003fffffULL,
+0xfffffffc007fffffULL,
+0xfffffffc00ffffffULL,
+0xfffffffc01ffffffULL,
+0xfffffffc03ffffffULL,
+0xfffffffc07ffffffULL,
+0xfffffffc0fffffffULL,
+0xfffffffc1fffffffULL,
+0xfffffffc3fffffffULL,
+0xfffffffc7fffffffULL,
+0xfffffffcffffffffULL,
+0xfffffffdffffffffULL
+},
+{
+0xfffffff800000000ULL,
+0xfffffff800000001ULL,
+0xfffffff800000003ULL,
+0xfffffff800000007ULL,
+0xfffffff80000000fULL,
+0xfffffff80000001fULL,
+0xfffffff80000003fULL,
+0xfffffff80000007fULL,
+0xfffffff8000000ffULL,
+0xfffffff8000001ffULL,
+0xfffffff8000003ffULL,
+0xfffffff8000007ffULL,
+0xfffffff800000fffULL,
+0xfffffff800001fffULL,
+0xfffffff800003fffULL,
+0xfffffff800007fffULL,
+0xfffffff80000ffffULL,
+0xfffffff80001ffffULL,
+0xfffffff80003ffffULL,
+0xfffffff80007ffffULL,
+0xfffffff8000fffffULL,
+0xfffffff8001fffffULL,
+0xfffffff8003fffffULL,
+0xfffffff8007fffffULL,
+0xfffffff800ffffffULL,
+0xfffffff801ffffffULL,
+0xfffffff803ffffffULL,
+0xfffffff807ffffffULL,
+0xfffffff80fffffffULL,
+0xfffffff81fffffffULL,
+0xfffffff83fffffffULL,
+0xfffffff87fffffffULL,
+0xfffffff8ffffffffULL,
+0xfffffff9ffffffffULL,
+0xfffffffbffffffffULL
+},
+{
+0xfffffff000000000ULL,
+0xfffffff000000001ULL,
+0xfffffff000000003ULL,
+0xfffffff000000007ULL,
+0xfffffff00000000fULL,
+0xfffffff00000001fULL,
+0xfffffff00000003fULL,
+0xfffffff00000007fULL,
+0xfffffff0000000ffULL,
+0xfffffff0000001ffULL,
+0xfffffff0000003ffULL,
+0xfffffff0000007ffULL,
+0xfffffff000000fffULL,
+0xfffffff000001fffULL,
+0xfffffff000003fffULL,
+0xfffffff000007fffULL,
+0xfffffff00000ffffULL,
+0xfffffff00001ffffULL,
+0xfffffff00003ffffULL,
+0xfffffff00007ffffULL,
+0xfffffff0000fffffULL,
+0xfffffff0001fffffULL,
+0xfffffff0003fffffULL,
+0xfffffff0007fffffULL,
+0xfffffff000ffffffULL,
+0xfffffff001ffffffULL,
+0xfffffff003ffffffULL,
+0xfffffff007ffffffULL,
+0xfffffff00fffffffULL,
+0xfffffff01fffffffULL,
+0xfffffff03fffffffULL,
+0xfffffff07fffffffULL,
+0xfffffff0ffffffffULL,
+0xfffffff1ffffffffULL,
+0xfffffff3ffffffffULL,
+0xfffffff7ffffffffULL
+},
+{
+0xffffffe000000000ULL,
+0xffffffe000000001ULL,
+0xffffffe000000003ULL,
+0xffffffe000000007ULL,
+0xffffffe00000000fULL,
+0xffffffe00000001fULL,
+0xffffffe00000003fULL,
+0xffffffe00000007fULL,
+0xffffffe0000000ffULL,
+0xffffffe0000001ffULL,
+0xffffffe0000003ffULL,
+0xffffffe0000007ffULL,
+0xffffffe000000fffULL,
+0xffffffe000001fffULL,
+0xffffffe000003fffULL,
+0xffffffe000007fffULL,
+0xffffffe00000ffffULL,
+0xffffffe00001ffffULL,
+0xffffffe00003ffffULL,
+0xffffffe00007ffffULL,
+0xffffffe0000fffffULL,
+0xffffffe0001fffffULL,
+0xffffffe0003fffffULL,
+0xffffffe0007fffffULL,
+0xffffffe000ffffffULL,
+0xffffffe001ffffffULL,
+0xffffffe003ffffffULL,
+0xffffffe007ffffffULL,
+0xffffffe00fffffffULL,
+0xffffffe01fffffffULL,
+0xffffffe03fffffffULL,
+0xffffffe07fffffffULL,
+0xffffffe0ffffffffULL,
+0xffffffe1ffffffffULL,
+0xffffffe3ffffffffULL,
+0xffffffe7ffffffffULL,
+0xffffffefffffffffULL
+},
+{
+0xffffffc000000000ULL,
+0xffffffc000000001ULL,
+0xffffffc000000003ULL,
+0xffffffc000000007ULL,
+0xffffffc00000000fULL,
+0xffffffc00000001fULL,
+0xffffffc00000003fULL,
+0xffffffc00000007fULL,
+0xffffffc0000000ffULL,
+0xffffffc0000001ffULL,
+0xffffffc0000003ffULL,
+0xffffffc0000007ffULL,
+0xffffffc000000fffULL,
+0xffffffc000001fffULL,
+0xffffffc000003fffULL,
+0xffffffc000007fffULL,
+0xffffffc00000ffffULL,
+0xffffffc00001ffffULL,
+0xffffffc00003ffffULL,
+0xffffffc00007ffffULL,
+0xffffffc0000fffffULL,
+0xffffffc0001fffffULL,
+0xffffffc0003fffffULL,
+0xffffffc0007fffffULL,
+0xffffffc000ffffffULL,
+0xffffffc001ffffffULL,
+0xffffffc003ffffffULL,
+0xffffffc007ffffffULL,
+0xffffffc00fffffffULL,
+0xffffffc01fffffffULL,
+0xffffffc03fffffffULL,
+0xffffffc07fffffffULL,
+0xffffffc0ffffffffULL,
+0xffffffc1ffffffffULL,
+0xffffffc3ffffffffULL,
+0xffffffc7ffffffffULL,
+0xffffffcfffffffffULL,
+0xffffffdfffffffffULL
+},
+{
+0xffffff8000000000ULL,
+0xffffff8000000001ULL,
+0xffffff8000000003ULL,
+0xffffff8000000007ULL,
+0xffffff800000000fULL,
+0xffffff800000001fULL,
+0xffffff800000003fULL,
+0xffffff800000007fULL,
+0xffffff80000000ffULL,
+0xffffff80000001ffULL,
+0xffffff80000003ffULL,
+0xffffff80000007ffULL,
+0xffffff8000000fffULL,
+0xffffff8000001fffULL,
+0xffffff8000003fffULL,
+0xffffff8000007fffULL,
+0xffffff800000ffffULL,
+0xffffff800001ffffULL,
+0xffffff800003ffffULL,
+0xffffff800007ffffULL,
+0xffffff80000fffffULL,
+0xffffff80001fffffULL,
+0xffffff80003fffffULL,
+0xffffff80007fffffULL,
+0xffffff8000ffffffULL,
+0xffffff8001ffffffULL,
+0xffffff8003ffffffULL,
+0xffffff8007ffffffULL,
+0xffffff800fffffffULL,
+0xffffff801fffffffULL,
+0xffffff803fffffffULL,
+0xffffff807fffffffULL,
+0xffffff80ffffffffULL,
+0xffffff81ffffffffULL,
+0xffffff83ffffffffULL,
+0xffffff87ffffffffULL,
+0xffffff8fffffffffULL,
+0xffffff9fffffffffULL,
+0xffffffbfffffffffULL
+},
+{
+0xffffff0000000000ULL,
+0xffffff0000000001ULL,
+0xffffff0000000003ULL,
+0xffffff0000000007ULL,
+0xffffff000000000fULL,
+0xffffff000000001fULL,
+0xffffff000000003fULL,
+0xffffff000000007fULL,
+0xffffff00000000ffULL,
+0xffffff00000001ffULL,
+0xffffff00000003ffULL,
+0xffffff00000007ffULL,
+0xffffff0000000fffULL,
+0xffffff0000001fffULL,
+0xffffff0000003fffULL,
+0xffffff0000007fffULL,
+0xffffff000000ffffULL,
+0xffffff000001ffffULL,
+0xffffff000003ffffULL,
+0xffffff000007ffffULL,
+0xffffff00000fffffULL,
+0xffffff00001fffffULL,
+0xffffff00003fffffULL,
+0xffffff00007fffffULL,
+0xffffff0000ffffffULL,
+0xffffff0001ffffffULL,
+0xffffff0003ffffffULL,
+0xffffff0007ffffffULL,
+0xffffff000fffffffULL,
+0xffffff001fffffffULL,
+0xffffff003fffffffULL,
+0xffffff007fffffffULL,
+0xffffff00ffffffffULL,
+0xffffff01ffffffffULL,
+0xffffff03ffffffffULL,
+0xffffff07ffffffffULL,
+0xffffff0fffffffffULL,
+0xffffff1fffffffffULL,
+0xffffff3fffffffffULL,
+0xffffff7fffffffffULL
+},
+{
+0xfffffe0000000000ULL,
+0xfffffe0000000001ULL,
+0xfffffe0000000003ULL,
+0xfffffe0000000007ULL,
+0xfffffe000000000fULL,
+0xfffffe000000001fULL,
+0xfffffe000000003fULL,
+0xfffffe000000007fULL,
+0xfffffe00000000ffULL,
+0xfffffe00000001ffULL,
+0xfffffe00000003ffULL,
+0xfffffe00000007ffULL,
+0xfffffe0000000fffULL,
+0xfffffe0000001fffULL,
+0xfffffe0000003fffULL,
+0xfffffe0000007fffULL,
+0xfffffe000000ffffULL,
+0xfffffe000001ffffULL,
+0xfffffe000003ffffULL,
+0xfffffe000007ffffULL,
+0xfffffe00000fffffULL,
+0xfffffe00001fffffULL,
+0xfffffe00003fffffULL,
+0xfffffe00007fffffULL,
+0xfffffe0000ffffffULL,
+0xfffffe0001ffffffULL,
+0xfffffe0003ffffffULL,
+0xfffffe0007ffffffULL,
+0xfffffe000fffffffULL,
+0xfffffe001fffffffULL,
+0xfffffe003fffffffULL,
+0xfffffe007fffffffULL,
+0xfffffe00ffffffffULL,
+0xfffffe01ffffffffULL,
+0xfffffe03ffffffffULL,
+0xfffffe07ffffffffULL,
+0xfffffe0fffffffffULL,
+0xfffffe1fffffffffULL,
+0xfffffe3fffffffffULL,
+0xfffffe7fffffffffULL,
+0xfffffeffffffffffULL
+},
+{
+0xfffffc0000000000ULL,
+0xfffffc0000000001ULL,
+0xfffffc0000000003ULL,
+0xfffffc0000000007ULL,
+0xfffffc000000000fULL,
+0xfffffc000000001fULL,
+0xfffffc000000003fULL,
+0xfffffc000000007fULL,
+0xfffffc00000000ffULL,
+0xfffffc00000001ffULL,
+0xfffffc00000003ffULL,
+0xfffffc00000007ffULL,
+0xfffffc0000000fffULL,
+0xfffffc0000001fffULL,
+0xfffffc0000003fffULL,
+0xfffffc0000007fffULL,
+0xfffffc000000ffffULL,
+0xfffffc000001ffffULL,
+0xfffffc000003ffffULL,
+0xfffffc000007ffffULL,
+0xfffffc00000fffffULL,
+0xfffffc00001fffffULL,
+0xfffffc00003fffffULL,
+0xfffffc00007fffffULL,
+0xfffffc0000ffffffULL,
+0xfffffc0001ffffffULL,
+0xfffffc0003ffffffULL,
+0xfffffc0007ffffffULL,
+0xfffffc000fffffffULL,
+0xfffffc001fffffffULL,
+0xfffffc003fffffffULL,
+0xfffffc007fffffffULL,
+0xfffffc00ffffffffULL,
+0xfffffc01ffffffffULL,
+0xfffffc03ffffffffULL,
+0xfffffc07ffffffffULL,
+0xfffffc0fffffffffULL,
+0xfffffc1fffffffffULL,
+0xfffffc3fffffffffULL,
+0xfffffc7fffffffffULL,
+0xfffffcffffffffffULL,
+0xfffffdffffffffffULL
+},
+{
+0xfffff80000000000ULL,
+0xfffff80000000001ULL,
+0xfffff80000000003ULL,
+0xfffff80000000007ULL,
+0xfffff8000000000fULL,
+0xfffff8000000001fULL,
+0xfffff8000000003fULL,
+0xfffff8000000007fULL,
+0xfffff800000000ffULL,
+0xfffff800000001ffULL,
+0xfffff800000003ffULL,
+0xfffff800000007ffULL,
+0xfffff80000000fffULL,
+0xfffff80000001fffULL,
+0xfffff80000003fffULL,
+0xfffff80000007fffULL,
+0xfffff8000000ffffULL,
+0xfffff8000001ffffULL,
+0xfffff8000003ffffULL,
+0xfffff8000007ffffULL,
+0xfffff800000fffffULL,
+0xfffff800001fffffULL,
+0xfffff800003fffffULL,
+0xfffff800007fffffULL,
+0xfffff80000ffffffULL,
+0xfffff80001ffffffULL,
+0xfffff80003ffffffULL,
+0xfffff80007ffffffULL,
+0xfffff8000fffffffULL,
+0xfffff8001fffffffULL,
+0xfffff8003fffffffULL,
+0xfffff8007fffffffULL,
+0xfffff800ffffffffULL,
+0xfffff801ffffffffULL,
+0xfffff803ffffffffULL,
+0xfffff807ffffffffULL,
+0xfffff80fffffffffULL,
+0xfffff81fffffffffULL,
+0xfffff83fffffffffULL,
+0xfffff87fffffffffULL,
+0xfffff8ffffffffffULL,
+0xfffff9ffffffffffULL,
+0xfffffbffffffffffULL
+},
+{
+0xfffff00000000000ULL,
+0xfffff00000000001ULL,
+0xfffff00000000003ULL,
+0xfffff00000000007ULL,
+0xfffff0000000000fULL,
+0xfffff0000000001fULL,
+0xfffff0000000003fULL,
+0xfffff0000000007fULL,
+0xfffff000000000ffULL,
+0xfffff000000001ffULL,
+0xfffff000000003ffULL,
+0xfffff000000007ffULL,
+0xfffff00000000fffULL,
+0xfffff00000001fffULL,
+0xfffff00000003fffULL,
+0xfffff00000007fffULL,
+0xfffff0000000ffffULL,
+0xfffff0000001ffffULL,
+0xfffff0000003ffffULL,
+0xfffff0000007ffffULL,
+0xfffff000000fffffULL,
+0xfffff000001fffffULL,
+0xfffff000003fffffULL,
+0xfffff000007fffffULL,
+0xfffff00000ffffffULL,
+0xfffff00001ffffffULL,
+0xfffff00003ffffffULL,
+0xfffff00007ffffffULL,
+0xfffff0000fffffffULL,
+0xfffff0001fffffffULL,
+0xfffff0003fffffffULL,
+0xfffff0007fffffffULL,
+0xfffff000ffffffffULL,
+0xfffff001ffffffffULL,
+0xfffff003ffffffffULL,
+0xfffff007ffffffffULL,
+0xfffff00fffffffffULL,
+0xfffff01fffffffffULL,
+0xfffff03fffffffffULL,
+0xfffff07fffffffffULL,
+0xfffff0ffffffffffULL,
+0xfffff1ffffffffffULL,
+0xfffff3ffffffffffULL,
+0xfffff7ffffffffffULL
+},
+{
+0xffffe00000000000ULL,
+0xffffe00000000001ULL,
+0xffffe00000000003ULL,
+0xffffe00000000007ULL,
+0xffffe0000000000fULL,
+0xffffe0000000001fULL,
+0xffffe0000000003fULL,
+0xffffe0000000007fULL,
+0xffffe000000000ffULL,
+0xffffe000000001ffULL,
+0xffffe000000003ffULL,
+0xffffe000000007ffULL,
+0xffffe00000000fffULL,
+0xffffe00000001fffULL,
+0xffffe00000003fffULL,
+0xffffe00000007fffULL,
+0xffffe0000000ffffULL,
+0xffffe0000001ffffULL,
+0xffffe0000003ffffULL,
+0xffffe0000007ffffULL,
+0xffffe000000fffffULL,
+0xffffe000001fffffULL,
+0xffffe000003fffffULL,
+0xffffe000007fffffULL,
+0xffffe00000ffffffULL,
+0xffffe00001ffffffULL,
+0xffffe00003ffffffULL,
+0xffffe00007ffffffULL,
+0xffffe0000fffffffULL,
+0xffffe0001fffffffULL,
+0xffffe0003fffffffULL,
+0xffffe0007fffffffULL,
+0xffffe000ffffffffULL,
+0xffffe001ffffffffULL,
+0xffffe003ffffffffULL,
+0xffffe007ffffffffULL,
+0xffffe00fffffffffULL,
+0xffffe01fffffffffULL,
+0xffffe03fffffffffULL,
+0xffffe07fffffffffULL,
+0xffffe0ffffffffffULL,
+0xffffe1ffffffffffULL,
+0xffffe3ffffffffffULL,
+0xffffe7ffffffffffULL,
+0xffffefffffffffffULL
+},
+{
+0xffffc00000000000ULL,
+0xffffc00000000001ULL,
+0xffffc00000000003ULL,
+0xffffc00000000007ULL,
+0xffffc0000000000fULL,
+0xffffc0000000001fULL,
+0xffffc0000000003fULL,
+0xffffc0000000007fULL,
+0xffffc000000000ffULL,
+0xffffc000000001ffULL,
+0xffffc000000003ffULL,
+0xffffc000000007ffULL,
+0xffffc00000000fffULL,
+0xffffc00000001fffULL,
+0xffffc00000003fffULL,
+0xffffc00000007fffULL,
+0xffffc0000000ffffULL,
+0xffffc0000001ffffULL,
+0xffffc0000003ffffULL,
+0xffffc0000007ffffULL,
+0xffffc000000fffffULL,
+0xffffc000001fffffULL,
+0xffffc000003fffffULL,
+0xffffc000007fffffULL,
+0xffffc00000ffffffULL,
+0xffffc00001ffffffULL,
+0xffffc00003ffffffULL,
+0xffffc00007ffffffULL,
+0xffffc0000fffffffULL,
+0xffffc0001fffffffULL,
+0xffffc0003fffffffULL,
+0xffffc0007fffffffULL,
+0xffffc000ffffffffULL,
+0xffffc001ffffffffULL,
+0xffffc003ffffffffULL,
+0xffffc007ffffffffULL,
+0xffffc00fffffffffULL,
+0xffffc01fffffffffULL,
+0xffffc03fffffffffULL,
+0xffffc07fffffffffULL,
+0xffffc0ffffffffffULL,
+0xffffc1ffffffffffULL,
+0xffffc3ffffffffffULL,
+0xffffc7ffffffffffULL,
+0xffffcfffffffffffULL,
+0xffffdfffffffffffULL
+},
+{
+0xffff800000000000ULL,
+0xffff800000000001ULL,
+0xffff800000000003ULL,
+0xffff800000000007ULL,
+0xffff80000000000fULL,
+0xffff80000000001fULL,
+0xffff80000000003fULL,
+0xffff80000000007fULL,
+0xffff8000000000ffULL,
+0xffff8000000001ffULL,
+0xffff8000000003ffULL,
+0xffff8000000007ffULL,
+0xffff800000000fffULL,
+0xffff800000001fffULL,
+0xffff800000003fffULL,
+0xffff800000007fffULL,
+0xffff80000000ffffULL,
+0xffff80000001ffffULL,
+0xffff80000003ffffULL,
+0xffff80000007ffffULL,
+0xffff8000000fffffULL,
+0xffff8000001fffffULL,
+0xffff8000003fffffULL,
+0xffff8000007fffffULL,
+0xffff800000ffffffULL,
+0xffff800001ffffffULL,
+0xffff800003ffffffULL,
+0xffff800007ffffffULL,
+0xffff80000fffffffULL,
+0xffff80001fffffffULL,
+0xffff80003fffffffULL,
+0xffff80007fffffffULL,
+0xffff8000ffffffffULL,
+0xffff8001ffffffffULL,
+0xffff8003ffffffffULL,
+0xffff8007ffffffffULL,
+0xffff800fffffffffULL,
+0xffff801fffffffffULL,
+0xffff803fffffffffULL,
+0xffff807fffffffffULL,
+0xffff80ffffffffffULL,
+0xffff81ffffffffffULL,
+0xffff83ffffffffffULL,
+0xffff87ffffffffffULL,
+0xffff8fffffffffffULL,
+0xffff9fffffffffffULL,
+0xffffbfffffffffffULL
+},
+{
+0xffff000000000000ULL,
+0xffff000000000001ULL,
+0xffff000000000003ULL,
+0xffff000000000007ULL,
+0xffff00000000000fULL,
+0xffff00000000001fULL,
+0xffff00000000003fULL,
+0xffff00000000007fULL,
+0xffff0000000000ffULL,
+0xffff0000000001ffULL,
+0xffff0000000003ffULL,
+0xffff0000000007ffULL,
+0xffff000000000fffULL,
+0xffff000000001fffULL,
+0xffff000000003fffULL,
+0xffff000000007fffULL,
+0xffff00000000ffffULL,
+0xffff00000001ffffULL,
+0xffff00000003ffffULL,
+0xffff00000007ffffULL,
+0xffff0000000fffffULL,
+0xffff0000001fffffULL,
+0xffff0000003fffffULL,
+0xffff0000007fffffULL,
+0xffff000000ffffffULL,
+0xffff000001ffffffULL,
+0xffff000003ffffffULL,
+0xffff000007ffffffULL,
+0xffff00000fffffffULL,
+0xffff00001fffffffULL,
+0xffff00003fffffffULL,
+0xffff00007fffffffULL,
+0xffff0000ffffffffULL,
+0xffff0001ffffffffULL,
+0xffff0003ffffffffULL,
+0xffff0007ffffffffULL,
+0xffff000fffffffffULL,
+0xffff001fffffffffULL,
+0xffff003fffffffffULL,
+0xffff007fffffffffULL,
+0xffff00ffffffffffULL,
+0xffff01ffffffffffULL,
+0xffff03ffffffffffULL,
+0xffff07ffffffffffULL,
+0xffff0fffffffffffULL,
+0xffff1fffffffffffULL,
+0xffff3fffffffffffULL,
+0xffff7fffffffffffULL
+},
+{
+0xfffe000000000000ULL,
+0xfffe000000000001ULL,
+0xfffe000000000003ULL,
+0xfffe000000000007ULL,
+0xfffe00000000000fULL,
+0xfffe00000000001fULL,
+0xfffe00000000003fULL,
+0xfffe00000000007fULL,
+0xfffe0000000000ffULL,
+0xfffe0000000001ffULL,
+0xfffe0000000003ffULL,
+0xfffe0000000007ffULL,
+0xfffe000000000fffULL,
+0xfffe000000001fffULL,
+0xfffe000000003fffULL,
+0xfffe000000007fffULL,
+0xfffe00000000ffffULL,
+0xfffe00000001ffffULL,
+0xfffe00000003ffffULL,
+0xfffe00000007ffffULL,
+0xfffe0000000fffffULL,
+0xfffe0000001fffffULL,
+0xfffe0000003fffffULL,
+0xfffe0000007fffffULL,
+0xfffe000000ffffffULL,
+0xfffe000001ffffffULL,
+0xfffe000003ffffffULL,
+0xfffe000007ffffffULL,
+0xfffe00000fffffffULL,
+0xfffe00001fffffffULL,
+0xfffe00003fffffffULL,
+0xfffe00007fffffffULL,
+0xfffe0000ffffffffULL,
+0xfffe0001ffffffffULL,
+0xfffe0003ffffffffULL,
+0xfffe0007ffffffffULL,
+0xfffe000fffffffffULL,
+0xfffe001fffffffffULL,
+0xfffe003fffffffffULL,
+0xfffe007fffffffffULL,
+0xfffe00ffffffffffULL,
+0xfffe01ffffffffffULL,
+0xfffe03ffffffffffULL,
+0xfffe07ffffffffffULL,
+0xfffe0fffffffffffULL,
+0xfffe1fffffffffffULL,
+0xfffe3fffffffffffULL,
+0xfffe7fffffffffffULL,
+0xfffeffffffffffffULL
+},
+{
+0xfffc000000000000ULL,
+0xfffc000000000001ULL,
+0xfffc000000000003ULL,
+0xfffc000000000007ULL,
+0xfffc00000000000fULL,
+0xfffc00000000001fULL,
+0xfffc00000000003fULL,
+0xfffc00000000007fULL,
+0xfffc0000000000ffULL,
+0xfffc0000000001ffULL,
+0xfffc0000000003ffULL,
+0xfffc0000000007ffULL,
+0xfffc000000000fffULL,
+0xfffc000000001fffULL,
+0xfffc000000003fffULL,
+0xfffc000000007fffULL,
+0xfffc00000000ffffULL,
+0xfffc00000001ffffULL,
+0xfffc00000003ffffULL,
+0xfffc00000007ffffULL,
+0xfffc0000000fffffULL,
+0xfffc0000001fffffULL,
+0xfffc0000003fffffULL,
+0xfffc0000007fffffULL,
+0xfffc000000ffffffULL,
+0xfffc000001ffffffULL,
+0xfffc000003ffffffULL,
+0xfffc000007ffffffULL,
+0xfffc00000fffffffULL,
+0xfffc00001fffffffULL,
+0xfffc00003fffffffULL,
+0xfffc00007fffffffULL,
+0xfffc0000ffffffffULL,
+0xfffc0001ffffffffULL,
+0xfffc0003ffffffffULL,
+0xfffc0007ffffffffULL,
+0xfffc000fffffffffULL,
+0xfffc001fffffffffULL,
+0xfffc003fffffffffULL,
+0xfffc007fffffffffULL,
+0xfffc00ffffffffffULL,
+0xfffc01ffffffffffULL,
+0xfffc03ffffffffffULL,
+0xfffc07ffffffffffULL,
+0xfffc0fffffffffffULL,
+0xfffc1fffffffffffULL,
+0xfffc3fffffffffffULL,
+0xfffc7fffffffffffULL,
+0xfffcffffffffffffULL,
+0xfffdffffffffffffULL
+},
+{
+0xfff8000000000000ULL,
+0xfff8000000000001ULL,
+0xfff8000000000003ULL,
+0xfff8000000000007ULL,
+0xfff800000000000fULL,
+0xfff800000000001fULL,
+0xfff800000000003fULL,
+0xfff800000000007fULL,
+0xfff80000000000ffULL,
+0xfff80000000001ffULL,
+0xfff80000000003ffULL,
+0xfff80000000007ffULL,
+0xfff8000000000fffULL,
+0xfff8000000001fffULL,
+0xfff8000000003fffULL,
+0xfff8000000007fffULL,
+0xfff800000000ffffULL,
+0xfff800000001ffffULL,
+0xfff800000003ffffULL,
+0xfff800000007ffffULL,
+0xfff80000000fffffULL,
+0xfff80000001fffffULL,
+0xfff80000003fffffULL,
+0xfff80000007fffffULL,
+0xfff8000000ffffffULL,
+0xfff8000001ffffffULL,
+0xfff8000003ffffffULL,
+0xfff8000007ffffffULL,
+0xfff800000fffffffULL,
+0xfff800001fffffffULL,
+0xfff800003fffffffULL,
+0xfff800007fffffffULL,
+0xfff80000ffffffffULL,
+0xfff80001ffffffffULL,
+0xfff80003ffffffffULL,
+0xfff80007ffffffffULL,
+0xfff8000fffffffffULL,
+0xfff8001fffffffffULL,
+0xfff8003fffffffffULL,
+0xfff8007fffffffffULL,
+0xfff800ffffffffffULL,
+0xfff801ffffffffffULL,
+0xfff803ffffffffffULL,
+0xfff807ffffffffffULL,
+0xfff80fffffffffffULL,
+0xfff81fffffffffffULL,
+0xfff83fffffffffffULL,
+0xfff87fffffffffffULL,
+0xfff8ffffffffffffULL,
+0xfff9ffffffffffffULL,
+0xfffbffffffffffffULL
+},
+{
+0xfff0000000000000ULL,
+0xfff0000000000001ULL,
+0xfff0000000000003ULL,
+0xfff0000000000007ULL,
+0xfff000000000000fULL,
+0xfff000000000001fULL,
+0xfff000000000003fULL,
+0xfff000000000007fULL,
+0xfff00000000000ffULL,
+0xfff00000000001ffULL,
+0xfff00000000003ffULL,
+0xfff00000000007ffULL,
+0xfff0000000000fffULL,
+0xfff0000000001fffULL,
+0xfff0000000003fffULL,
+0xfff0000000007fffULL,
+0xfff000000000ffffULL,
+0xfff000000001ffffULL,
+0xfff000000003ffffULL,
+0xfff000000007ffffULL,
+0xfff00000000fffffULL,
+0xfff00000001fffffULL,
+0xfff00000003fffffULL,
+0xfff00000007fffffULL,
+0xfff0000000ffffffULL,
+0xfff0000001ffffffULL,
+0xfff0000003ffffffULL,
+0xfff0000007ffffffULL,
+0xfff000000fffffffULL,
+0xfff000001fffffffULL,
+0xfff000003fffffffULL,
+0xfff000007fffffffULL,
+0xfff00000ffffffffULL,
+0xfff00001ffffffffULL,
+0xfff00003ffffffffULL,
+0xfff00007ffffffffULL,
+0xfff0000fffffffffULL,
+0xfff0001fffffffffULL,
+0xfff0003fffffffffULL,
+0xfff0007fffffffffULL,
+0xfff000ffffffffffULL,
+0xfff001ffffffffffULL,
+0xfff003ffffffffffULL,
+0xfff007ffffffffffULL,
+0xfff00fffffffffffULL,
+0xfff01fffffffffffULL,
+0xfff03fffffffffffULL,
+0xfff07fffffffffffULL,
+0xfff0ffffffffffffULL,
+0xfff1ffffffffffffULL,
+0xfff3ffffffffffffULL,
+0xfff7ffffffffffffULL
+},
+{
+0xffe0000000000000ULL,
+0xffe0000000000001ULL,
+0xffe0000000000003ULL,
+0xffe0000000000007ULL,
+0xffe000000000000fULL,
+0xffe000000000001fULL,
+0xffe000000000003fULL,
+0xffe000000000007fULL,
+0xffe00000000000ffULL,
+0xffe00000000001ffULL,
+0xffe00000000003ffULL,
+0xffe00000000007ffULL,
+0xffe0000000000fffULL,
+0xffe0000000001fffULL,
+0xffe0000000003fffULL,
+0xffe0000000007fffULL,
+0xffe000000000ffffULL,
+0xffe000000001ffffULL,
+0xffe000000003ffffULL,
+0xffe000000007ffffULL,
+0xffe00000000fffffULL,
+0xffe00000001fffffULL,
+0xffe00000003fffffULL,
+0xffe00000007fffffULL,
+0xffe0000000ffffffULL,
+0xffe0000001ffffffULL,
+0xffe0000003ffffffULL,
+0xffe0000007ffffffULL,
+0xffe000000fffffffULL,
+0xffe000001fffffffULL,
+0xffe000003fffffffULL,
+0xffe000007fffffffULL,
+0xffe00000ffffffffULL,
+0xffe00001ffffffffULL,
+0xffe00003ffffffffULL,
+0xffe00007ffffffffULL,
+0xffe0000fffffffffULL,
+0xffe0001fffffffffULL,
+0xffe0003fffffffffULL,
+0xffe0007fffffffffULL,
+0xffe000ffffffffffULL,
+0xffe001ffffffffffULL,
+0xffe003ffffffffffULL,
+0xffe007ffffffffffULL,
+0xffe00fffffffffffULL,
+0xffe01fffffffffffULL,
+0xffe03fffffffffffULL,
+0xffe07fffffffffffULL,
+0xffe0ffffffffffffULL,
+0xffe1ffffffffffffULL,
+0xffe3ffffffffffffULL,
+0xffe7ffffffffffffULL,
+0xffefffffffffffffULL
+},
+{
+0xffc0000000000000ULL,
+0xffc0000000000001ULL,
+0xffc0000000000003ULL,
+0xffc0000000000007ULL,
+0xffc000000000000fULL,
+0xffc000000000001fULL,
+0xffc000000000003fULL,
+0xffc000000000007fULL,
+0xffc00000000000ffULL,
+0xffc00000000001ffULL,
+0xffc00000000003ffULL,
+0xffc00000000007ffULL,
+0xffc0000000000fffULL,
+0xffc0000000001fffULL,
+0xffc0000000003fffULL,
+0xffc0000000007fffULL,
+0xffc000000000ffffULL,
+0xffc000000001ffffULL,
+0xffc000000003ffffULL,
+0xffc000000007ffffULL,
+0xffc00000000fffffULL,
+0xffc00000001fffffULL,
+0xffc00000003fffffULL,
+0xffc00000007fffffULL,
+0xffc0000000ffffffULL,
+0xffc0000001ffffffULL,
+0xffc0000003ffffffULL,
+0xffc0000007ffffffULL,
+0xffc000000fffffffULL,
+0xffc000001fffffffULL,
+0xffc000003fffffffULL,
+0xffc000007fffffffULL,
+0xffc00000ffffffffULL,
+0xffc00001ffffffffULL,
+0xffc00003ffffffffULL,
+0xffc00007ffffffffULL,
+0xffc0000fffffffffULL,
+0xffc0001fffffffffULL,
+0xffc0003fffffffffULL,
+0xffc0007fffffffffULL,
+0xffc000ffffffffffULL,
+0xffc001ffffffffffULL,
+0xffc003ffffffffffULL,
+0xffc007ffffffffffULL,
+0xffc00fffffffffffULL,
+0xffc01fffffffffffULL,
+0xffc03fffffffffffULL,
+0xffc07fffffffffffULL,
+0xffc0ffffffffffffULL,
+0xffc1ffffffffffffULL,
+0xffc3ffffffffffffULL,
+0xffc7ffffffffffffULL,
+0xffcfffffffffffffULL,
+0xffdfffffffffffffULL
+},
+{
+0xff80000000000000ULL,
+0xff80000000000001ULL,
+0xff80000000000003ULL,
+0xff80000000000007ULL,
+0xff8000000000000fULL,
+0xff8000000000001fULL,
+0xff8000000000003fULL,
+0xff8000000000007fULL,
+0xff800000000000ffULL,
+0xff800000000001ffULL,
+0xff800000000003ffULL,
+0xff800000000007ffULL,
+0xff80000000000fffULL,
+0xff80000000001fffULL,
+0xff80000000003fffULL,
+0xff80000000007fffULL,
+0xff8000000000ffffULL,
+0xff8000000001ffffULL,
+0xff8000000003ffffULL,
+0xff8000000007ffffULL,
+0xff800000000fffffULL,
+0xff800000001fffffULL,
+0xff800000003fffffULL,
+0xff800000007fffffULL,
+0xff80000000ffffffULL,
+0xff80000001ffffffULL,
+0xff80000003ffffffULL,
+0xff80000007ffffffULL,
+0xff8000000fffffffULL,
+0xff8000001fffffffULL,
+0xff8000003fffffffULL,
+0xff8000007fffffffULL,
+0xff800000ffffffffULL,
+0xff800001ffffffffULL,
+0xff800003ffffffffULL,
+0xff800007ffffffffULL,
+0xff80000fffffffffULL,
+0xff80001fffffffffULL,
+0xff80003fffffffffULL,
+0xff80007fffffffffULL,
+0xff8000ffffffffffULL,
+0xff8001ffffffffffULL,
+0xff8003ffffffffffULL,
+0xff8007ffffffffffULL,
+0xff800fffffffffffULL,
+0xff801fffffffffffULL,
+0xff803fffffffffffULL,
+0xff807fffffffffffULL,
+0xff80ffffffffffffULL,
+0xff81ffffffffffffULL,
+0xff83ffffffffffffULL,
+0xff87ffffffffffffULL,
+0xff8fffffffffffffULL,
+0xff9fffffffffffffULL,
+0xffbfffffffffffffULL
+},
+{
+0xff00000000000000ULL,
+0xff00000000000001ULL,
+0xff00000000000003ULL,
+0xff00000000000007ULL,
+0xff0000000000000fULL,
+0xff0000000000001fULL,
+0xff0000000000003fULL,
+0xff0000000000007fULL,
+0xff000000000000ffULL,
+0xff000000000001ffULL,
+0xff000000000003ffULL,
+0xff000000000007ffULL,
+0xff00000000000fffULL,
+0xff00000000001fffULL,
+0xff00000000003fffULL,
+0xff00000000007fffULL,
+0xff0000000000ffffULL,
+0xff0000000001ffffULL,
+0xff0000000003ffffULL,
+0xff0000000007ffffULL,
+0xff000000000fffffULL,
+0xff000000001fffffULL,
+0xff000000003fffffULL,
+0xff000000007fffffULL,
+0xff00000000ffffffULL,
+0xff00000001ffffffULL,
+0xff00000003ffffffULL,
+0xff00000007ffffffULL,
+0xff0000000fffffffULL,
+0xff0000001fffffffULL,
+0xff0000003fffffffULL,
+0xff0000007fffffffULL,
+0xff000000ffffffffULL,
+0xff000001ffffffffULL,
+0xff000003ffffffffULL,
+0xff000007ffffffffULL,
+0xff00000fffffffffULL,
+0xff00001fffffffffULL,
+0xff00003fffffffffULL,
+0xff00007fffffffffULL,
+0xff0000ffffffffffULL,
+0xff0001ffffffffffULL,
+0xff0003ffffffffffULL,
+0xff0007ffffffffffULL,
+0xff000fffffffffffULL,
+0xff001fffffffffffULL,
+0xff003fffffffffffULL,
+0xff007fffffffffffULL,
+0xff00ffffffffffffULL,
+0xff01ffffffffffffULL,
+0xff03ffffffffffffULL,
+0xff07ffffffffffffULL,
+0xff0fffffffffffffULL,
+0xff1fffffffffffffULL,
+0xff3fffffffffffffULL,
+0xff7fffffffffffffULL
+},
+{
+0xfe00000000000000ULL,
+0xfe00000000000001ULL,
+0xfe00000000000003ULL,
+0xfe00000000000007ULL,
+0xfe0000000000000fULL,
+0xfe0000000000001fULL,
+0xfe0000000000003fULL,
+0xfe0000000000007fULL,
+0xfe000000000000ffULL,
+0xfe000000000001ffULL,
+0xfe000000000003ffULL,
+0xfe000000000007ffULL,
+0xfe00000000000fffULL,
+0xfe00000000001fffULL,
+0xfe00000000003fffULL,
+0xfe00000000007fffULL,
+0xfe0000000000ffffULL,
+0xfe0000000001ffffULL,
+0xfe0000000003ffffULL,
+0xfe0000000007ffffULL,
+0xfe000000000fffffULL,
+0xfe000000001fffffULL,
+0xfe000000003fffffULL,
+0xfe000000007fffffULL,
+0xfe00000000ffffffULL,
+0xfe00000001ffffffULL,
+0xfe00000003ffffffULL,
+0xfe00000007ffffffULL,
+0xfe0000000fffffffULL,
+0xfe0000001fffffffULL,
+0xfe0000003fffffffULL,
+0xfe0000007fffffffULL,
+0xfe000000ffffffffULL,
+0xfe000001ffffffffULL,
+0xfe000003ffffffffULL,
+0xfe000007ffffffffULL,
+0xfe00000fffffffffULL,
+0xfe00001fffffffffULL,
+0xfe00003fffffffffULL,
+0xfe00007fffffffffULL,
+0xfe0000ffffffffffULL,
+0xfe0001ffffffffffULL,
+0xfe0003ffffffffffULL,
+0xfe0007ffffffffffULL,
+0xfe000fffffffffffULL,
+0xfe001fffffffffffULL,
+0xfe003fffffffffffULL,
+0xfe007fffffffffffULL,
+0xfe00ffffffffffffULL,
+0xfe01ffffffffffffULL,
+0xfe03ffffffffffffULL,
+0xfe07ffffffffffffULL,
+0xfe0fffffffffffffULL,
+0xfe1fffffffffffffULL,
+0xfe3fffffffffffffULL,
+0xfe7fffffffffffffULL,
+0xfeffffffffffffffULL
+},
+{
+0xfc00000000000000ULL,
+0xfc00000000000001ULL,
+0xfc00000000000003ULL,
+0xfc00000000000007ULL,
+0xfc0000000000000fULL,
+0xfc0000000000001fULL,
+0xfc0000000000003fULL,
+0xfc0000000000007fULL,
+0xfc000000000000ffULL,
+0xfc000000000001ffULL,
+0xfc000000000003ffULL,
+0xfc000000000007ffULL,
+0xfc00000000000fffULL,
+0xfc00000000001fffULL,
+0xfc00000000003fffULL,
+0xfc00000000007fffULL,
+0xfc0000000000ffffULL,
+0xfc0000000001ffffULL,
+0xfc0000000003ffffULL,
+0xfc0000000007ffffULL,
+0xfc000000000fffffULL,
+0xfc000000001fffffULL,
+0xfc000000003fffffULL,
+0xfc000000007fffffULL,
+0xfc00000000ffffffULL,
+0xfc00000001ffffffULL,
+0xfc00000003ffffffULL,
+0xfc00000007ffffffULL,
+0xfc0000000fffffffULL,
+0xfc0000001fffffffULL,
+0xfc0000003fffffffULL,
+0xfc0000007fffffffULL,
+0xfc000000ffffffffULL,
+0xfc000001ffffffffULL,
+0xfc000003ffffffffULL,
+0xfc000007ffffffffULL,
+0xfc00000fffffffffULL,
+0xfc00001fffffffffULL,
+0xfc00003fffffffffULL,
+0xfc00007fffffffffULL,
+0xfc0000ffffffffffULL,
+0xfc0001ffffffffffULL,
+0xfc0003ffffffffffULL,
+0xfc0007ffffffffffULL,
+0xfc000fffffffffffULL,
+0xfc001fffffffffffULL,
+0xfc003fffffffffffULL,
+0xfc007fffffffffffULL,
+0xfc00ffffffffffffULL,
+0xfc01ffffffffffffULL,
+0xfc03ffffffffffffULL,
+0xfc07ffffffffffffULL,
+0xfc0fffffffffffffULL,
+0xfc1fffffffffffffULL,
+0xfc3fffffffffffffULL,
+0xfc7fffffffffffffULL,
+0xfcffffffffffffffULL,
+0xfdffffffffffffffULL
+},
+{
+0xf800000000000000ULL,
+0xf800000000000001ULL,
+0xf800000000000003ULL,
+0xf800000000000007ULL,
+0xf80000000000000fULL,
+0xf80000000000001fULL,
+0xf80000000000003fULL,
+0xf80000000000007fULL,
+0xf8000000000000ffULL,
+0xf8000000000001ffULL,
+0xf8000000000003ffULL,
+0xf8000000000007ffULL,
+0xf800000000000fffULL,
+0xf800000000001fffULL,
+0xf800000000003fffULL,
+0xf800000000007fffULL,
+0xf80000000000ffffULL,
+0xf80000000001ffffULL,
+0xf80000000003ffffULL,
+0xf80000000007ffffULL,
+0xf8000000000fffffULL,
+0xf8000000001fffffULL,
+0xf8000000003fffffULL,
+0xf8000000007fffffULL,
+0xf800000000ffffffULL,
+0xf800000001ffffffULL,
+0xf800000003ffffffULL,
+0xf800000007ffffffULL,
+0xf80000000fffffffULL,
+0xf80000001fffffffULL,
+0xf80000003fffffffULL,
+0xf80000007fffffffULL,
+0xf8000000ffffffffULL,
+0xf8000001ffffffffULL,
+0xf8000003ffffffffULL,
+0xf8000007ffffffffULL,
+0xf800000fffffffffULL,
+0xf800001fffffffffULL,
+0xf800003fffffffffULL,
+0xf800007fffffffffULL,
+0xf80000ffffffffffULL,
+0xf80001ffffffffffULL,
+0xf80003ffffffffffULL,
+0xf80007ffffffffffULL,
+0xf8000fffffffffffULL,
+0xf8001fffffffffffULL,
+0xf8003fffffffffffULL,
+0xf8007fffffffffffULL,
+0xf800ffffffffffffULL,
+0xf801ffffffffffffULL,
+0xf803ffffffffffffULL,
+0xf807ffffffffffffULL,
+0xf80fffffffffffffULL,
+0xf81fffffffffffffULL,
+0xf83fffffffffffffULL,
+0xf87fffffffffffffULL,
+0xf8ffffffffffffffULL,
+0xf9ffffffffffffffULL,
+0xfbffffffffffffffULL
+},
+{
+0xf000000000000000ULL,
+0xf000000000000001ULL,
+0xf000000000000003ULL,
+0xf000000000000007ULL,
+0xf00000000000000fULL,
+0xf00000000000001fULL,
+0xf00000000000003fULL,
+0xf00000000000007fULL,
+0xf0000000000000ffULL,
+0xf0000000000001ffULL,
+0xf0000000000003ffULL,
+0xf0000000000007ffULL,
+0xf000000000000fffULL,
+0xf000000000001fffULL,
+0xf000000000003fffULL,
+0xf000000000007fffULL,
+0xf00000000000ffffULL,
+0xf00000000001ffffULL,
+0xf00000000003ffffULL,
+0xf00000000007ffffULL,
+0xf0000000000fffffULL,
+0xf0000000001fffffULL,
+0xf0000000003fffffULL,
+0xf0000000007fffffULL,
+0xf000000000ffffffULL,
+0xf000000001ffffffULL,
+0xf000000003ffffffULL,
+0xf000000007ffffffULL,
+0xf00000000fffffffULL,
+0xf00000001fffffffULL,
+0xf00000003fffffffULL,
+0xf00000007fffffffULL,
+0xf0000000ffffffffULL,
+0xf0000001ffffffffULL,
+0xf0000003ffffffffULL,
+0xf0000007ffffffffULL,
+0xf000000fffffffffULL,
+0xf000001fffffffffULL,
+0xf000003fffffffffULL,
+0xf000007fffffffffULL,
+0xf00000ffffffffffULL,
+0xf00001ffffffffffULL,
+0xf00003ffffffffffULL,
+0xf00007ffffffffffULL,
+0xf0000fffffffffffULL,
+0xf0001fffffffffffULL,
+0xf0003fffffffffffULL,
+0xf0007fffffffffffULL,
+0xf000ffffffffffffULL,
+0xf001ffffffffffffULL,
+0xf003ffffffffffffULL,
+0xf007ffffffffffffULL,
+0xf00fffffffffffffULL,
+0xf01fffffffffffffULL,
+0xf03fffffffffffffULL,
+0xf07fffffffffffffULL,
+0xf0ffffffffffffffULL,
+0xf1ffffffffffffffULL,
+0xf3ffffffffffffffULL,
+0xf7ffffffffffffffULL
+},
+{
+0xe000000000000000ULL,
+0xe000000000000001ULL,
+0xe000000000000003ULL,
+0xe000000000000007ULL,
+0xe00000000000000fULL,
+0xe00000000000001fULL,
+0xe00000000000003fULL,
+0xe00000000000007fULL,
+0xe0000000000000ffULL,
+0xe0000000000001ffULL,
+0xe0000000000003ffULL,
+0xe0000000000007ffULL,
+0xe000000000000fffULL,
+0xe000000000001fffULL,
+0xe000000000003fffULL,
+0xe000000000007fffULL,
+0xe00000000000ffffULL,
+0xe00000000001ffffULL,
+0xe00000000003ffffULL,
+0xe00000000007ffffULL,
+0xe0000000000fffffULL,
+0xe0000000001fffffULL,
+0xe0000000003fffffULL,
+0xe0000000007fffffULL,
+0xe000000000ffffffULL,
+0xe000000001ffffffULL,
+0xe000000003ffffffULL,
+0xe000000007ffffffULL,
+0xe00000000fffffffULL,
+0xe00000001fffffffULL,
+0xe00000003fffffffULL,
+0xe00000007fffffffULL,
+0xe0000000ffffffffULL,
+0xe0000001ffffffffULL,
+0xe0000003ffffffffULL,
+0xe0000007ffffffffULL,
+0xe000000fffffffffULL,
+0xe000001fffffffffULL,
+0xe000003fffffffffULL,
+0xe000007fffffffffULL,
+0xe00000ffffffffffULL,
+0xe00001ffffffffffULL,
+0xe00003ffffffffffULL,
+0xe00007ffffffffffULL,
+0xe0000fffffffffffULL,
+0xe0001fffffffffffULL,
+0xe0003fffffffffffULL,
+0xe0007fffffffffffULL,
+0xe000ffffffffffffULL,
+0xe001ffffffffffffULL,
+0xe003ffffffffffffULL,
+0xe007ffffffffffffULL,
+0xe00fffffffffffffULL,
+0xe01fffffffffffffULL,
+0xe03fffffffffffffULL,
+0xe07fffffffffffffULL,
+0xe0ffffffffffffffULL,
+0xe1ffffffffffffffULL,
+0xe3ffffffffffffffULL,
+0xe7ffffffffffffffULL,
+0xefffffffffffffffULL
+},
+{
+0xc000000000000000ULL,
+0xc000000000000001ULL,
+0xc000000000000003ULL,
+0xc000000000000007ULL,
+0xc00000000000000fULL,
+0xc00000000000001fULL,
+0xc00000000000003fULL,
+0xc00000000000007fULL,
+0xc0000000000000ffULL,
+0xc0000000000001ffULL,
+0xc0000000000003ffULL,
+0xc0000000000007ffULL,
+0xc000000000000fffULL,
+0xc000000000001fffULL,
+0xc000000000003fffULL,
+0xc000000000007fffULL,
+0xc00000000000ffffULL,
+0xc00000000001ffffULL,
+0xc00000000003ffffULL,
+0xc00000000007ffffULL,
+0xc0000000000fffffULL,
+0xc0000000001fffffULL,
+0xc0000000003fffffULL,
+0xc0000000007fffffULL,
+0xc000000000ffffffULL,
+0xc000000001ffffffULL,
+0xc000000003ffffffULL,
+0xc000000007ffffffULL,
+0xc00000000fffffffULL,
+0xc00000001fffffffULL,
+0xc00000003fffffffULL,
+0xc00000007fffffffULL,
+0xc0000000ffffffffULL,
+0xc0000001ffffffffULL,
+0xc0000003ffffffffULL,
+0xc0000007ffffffffULL,
+0xc000000fffffffffULL,
+0xc000001fffffffffULL,
+0xc000003fffffffffULL,
+0xc000007fffffffffULL,
+0xc00000ffffffffffULL,
+0xc00001ffffffffffULL,
+0xc00003ffffffffffULL,
+0xc00007ffffffffffULL,
+0xc0000fffffffffffULL,
+0xc0001fffffffffffULL,
+0xc0003fffffffffffULL,
+0xc0007fffffffffffULL,
+0xc000ffffffffffffULL,
+0xc001ffffffffffffULL,
+0xc003ffffffffffffULL,
+0xc007ffffffffffffULL,
+0xc00fffffffffffffULL,
+0xc01fffffffffffffULL,
+0xc03fffffffffffffULL,
+0xc07fffffffffffffULL,
+0xc0ffffffffffffffULL,
+0xc1ffffffffffffffULL,
+0xc3ffffffffffffffULL,
+0xc7ffffffffffffffULL,
+0xcfffffffffffffffULL,
+0xdfffffffffffffffULL
+},
+{
+0x8000000000000000ULL,
+0x8000000000000001ULL,
+0x8000000000000003ULL,
+0x8000000000000007ULL,
+0x800000000000000fULL,
+0x800000000000001fULL,
+0x800000000000003fULL,
+0x800000000000007fULL,
+0x80000000000000ffULL,
+0x80000000000001ffULL,
+0x80000000000003ffULL,
+0x80000000000007ffULL,
+0x8000000000000fffULL,
+0x8000000000001fffULL,
+0x8000000000003fffULL,
+0x8000000000007fffULL,
+0x800000000000ffffULL,
+0x800000000001ffffULL,
+0x800000000003ffffULL,
+0x800000000007ffffULL,
+0x80000000000fffffULL,
+0x80000000001fffffULL,
+0x80000000003fffffULL,
+0x80000000007fffffULL,
+0x8000000000ffffffULL,
+0x8000000001ffffffULL,
+0x8000000003ffffffULL,
+0x8000000007ffffffULL,
+0x800000000fffffffULL,
+0x800000001fffffffULL,
+0x800000003fffffffULL,
+0x800000007fffffffULL,
+0x80000000ffffffffULL,
+0x80000001ffffffffULL,
+0x80000003ffffffffULL,
+0x80000007ffffffffULL,
+0x8000000fffffffffULL,
+0x8000001fffffffffULL,
+0x8000003fffffffffULL,
+0x8000007fffffffffULL,
+0x800000ffffffffffULL,
+0x800001ffffffffffULL,
+0x800003ffffffffffULL,
+0x800007ffffffffffULL,
+0x80000fffffffffffULL,
+0x80001fffffffffffULL,
+0x80003fffffffffffULL,
+0x80007fffffffffffULL,
+0x8000ffffffffffffULL,
+0x8001ffffffffffffULL,
+0x8003ffffffffffffULL,
+0x8007ffffffffffffULL,
+0x800fffffffffffffULL,
+0x801fffffffffffffULL,
+0x803fffffffffffffULL,
+0x807fffffffffffffULL,
+0x80ffffffffffffffULL,
+0x81ffffffffffffffULL,
+0x83ffffffffffffffULL,
+0x87ffffffffffffffULL,
+0x8fffffffffffffffULL,
+0x9fffffffffffffffULL,
+0xbfffffffffffffffULL
+},
+{
+0x0ULL,
+0x1ULL,
+0x3ULL,
+0x7ULL,
+0xfULL,
+0x1fULL,
+0x3fULL,
+0x7fULL,
+0xffULL,
+0x1ffULL,
+0x3ffULL,
+0x7ffULL,
+0xfffULL,
+0x1fffULL,
+0x3fffULL,
+0x7fffULL,
+0xffffULL,
+0x1ffffULL,
+0x3ffffULL,
+0x7ffffULL,
+0xfffffULL,
+0x1fffffULL,
+0x3fffffULL,
+0x7fffffULL,
+0xffffffULL,
+0x1ffffffULL,
+0x3ffffffULL,
+0x7ffffffULL,
+0xfffffffULL,
+0x1fffffffULL,
+0x3fffffffULL,
+0x7fffffffULL,
+0xffffffffULL,
+0x1ffffffffULL,
+0x3ffffffffULL,
+0x7ffffffffULL,
+0xfffffffffULL,
+0x1fffffffffULL,
+0x3fffffffffULL,
+0x7fffffffffULL,
+0xffffffffffULL,
+0x1ffffffffffULL,
+0x3ffffffffffULL,
+0x7ffffffffffULL,
+0xfffffffffffULL,
+0x1fffffffffffULL,
+0x3fffffffffffULL,
+0x7fffffffffffULL,
+0xffffffffffffULL,
+0x1ffffffffffffULL,
+0x3ffffffffffffULL,
+0x7ffffffffffffULL,
+0xfffffffffffffULL,
+0x1fffffffffffffULL,
+0x3fffffffffffffULL,
+0x7fffffffffffffULL,
+0xffffffffffffffULL,
+0x1ffffffffffffffULL,
+0x3ffffffffffffffULL,
+0x7ffffffffffffffULL,
+0xfffffffffffffffULL,
+0x1fffffffffffffffULL,
+0x3fffffffffffffffULL,
+0x7fffffffffffffffULL
+}
+};
+
+#else //end of #ifndef WIN32
+
+const uint_type mask_int[SC_INTWIDTH][SC_INTWIDTH] = 
+{
+{
+0xfffffffffffffffei64
+},
+{
+0xfffffffffffffffci64,
+0xfffffffffffffffdi64
+},
+{
+0xfffffffffffffff8i64,
+0xfffffffffffffff9i64,
+0xfffffffffffffffbi64
+},
+{
+0xfffffffffffffff0i64,
+0xfffffffffffffff1i64,
+0xfffffffffffffff3i64,
+0xfffffffffffffff7i64
+},
+{
+0xffffffffffffffe0i64,
+0xffffffffffffffe1i64,
+0xffffffffffffffe3i64,
+0xffffffffffffffe7i64,
+0xffffffffffffffefi64
+},
+{
+0xffffffffffffffc0i64,
+0xffffffffffffffc1i64,
+0xffffffffffffffc3i64,
+0xffffffffffffffc7i64,
+0xffffffffffffffcfi64,
+0xffffffffffffffdfi64
+},
+{
+0xffffffffffffff80i64,
+0xffffffffffffff81i64,
+0xffffffffffffff83i64,
+0xffffffffffffff87i64,
+0xffffffffffffff8fi64,
+0xffffffffffffff9fi64,
+0xffffffffffffffbfi64
+},
+{
+0xffffffffffffff00i64,
+0xffffffffffffff01i64,
+0xffffffffffffff03i64,
+0xffffffffffffff07i64,
+0xffffffffffffff0fi64,
+0xffffffffffffff1fi64,
+0xffffffffffffff3fi64,
+0xffffffffffffff7fi64
+},
+{
+0xfffffffffffffe00i64,
+0xfffffffffffffe01i64,
+0xfffffffffffffe03i64,
+0xfffffffffffffe07i64,
+0xfffffffffffffe0fi64,
+0xfffffffffffffe1fi64,
+0xfffffffffffffe3fi64,
+0xfffffffffffffe7fi64,
+0xfffffffffffffeffi64
+},
+{
+0xfffffffffffffc00i64,
+0xfffffffffffffc01i64,
+0xfffffffffffffc03i64,
+0xfffffffffffffc07i64,
+0xfffffffffffffc0fi64,
+0xfffffffffffffc1fi64,
+0xfffffffffffffc3fi64,
+0xfffffffffffffc7fi64,
+0xfffffffffffffcffi64,
+0xfffffffffffffdffi64
+},
+{
+0xfffffffffffff800i64,
+0xfffffffffffff801i64,
+0xfffffffffffff803i64,
+0xfffffffffffff807i64,
+0xfffffffffffff80fi64,
+0xfffffffffffff81fi64,
+0xfffffffffffff83fi64,
+0xfffffffffffff87fi64,
+0xfffffffffffff8ffi64,
+0xfffffffffffff9ffi64,
+0xfffffffffffffbffi64
+},
+{
+0xfffffffffffff000i64,
+0xfffffffffffff001i64,
+0xfffffffffffff003i64,
+0xfffffffffffff007i64,
+0xfffffffffffff00fi64,
+0xfffffffffffff01fi64,
+0xfffffffffffff03fi64,
+0xfffffffffffff07fi64,
+0xfffffffffffff0ffi64,
+0xfffffffffffff1ffi64,
+0xfffffffffffff3ffi64,
+0xfffffffffffff7ffi64
+},
+{
+0xffffffffffffe000i64,
+0xffffffffffffe001i64,
+0xffffffffffffe003i64,
+0xffffffffffffe007i64,
+0xffffffffffffe00fi64,
+0xffffffffffffe01fi64,
+0xffffffffffffe03fi64,
+0xffffffffffffe07fi64,
+0xffffffffffffe0ffi64,
+0xffffffffffffe1ffi64,
+0xffffffffffffe3ffi64,
+0xffffffffffffe7ffi64,
+0xffffffffffffefffi64
+},
+{
+0xffffffffffffc000i64,
+0xffffffffffffc001i64,
+0xffffffffffffc003i64,
+0xffffffffffffc007i64,
+0xffffffffffffc00fi64,
+0xffffffffffffc01fi64,
+0xffffffffffffc03fi64,
+0xffffffffffffc07fi64,
+0xffffffffffffc0ffi64,
+0xffffffffffffc1ffi64,
+0xffffffffffffc3ffi64,
+0xffffffffffffc7ffi64,
+0xffffffffffffcfffi64,
+0xffffffffffffdfffi64
+},
+{
+0xffffffffffff8000i64,
+0xffffffffffff8001i64,
+0xffffffffffff8003i64,
+0xffffffffffff8007i64,
+0xffffffffffff800fi64,
+0xffffffffffff801fi64,
+0xffffffffffff803fi64,
+0xffffffffffff807fi64,
+0xffffffffffff80ffi64,
+0xffffffffffff81ffi64,
+0xffffffffffff83ffi64,
+0xffffffffffff87ffi64,
+0xffffffffffff8fffi64,
+0xffffffffffff9fffi64,
+0xffffffffffffbfffi64
+},
+{
+0xffffffffffff0000i64,
+0xffffffffffff0001i64,
+0xffffffffffff0003i64,
+0xffffffffffff0007i64,
+0xffffffffffff000fi64,
+0xffffffffffff001fi64,
+0xffffffffffff003fi64,
+0xffffffffffff007fi64,
+0xffffffffffff00ffi64,
+0xffffffffffff01ffi64,
+0xffffffffffff03ffi64,
+0xffffffffffff07ffi64,
+0xffffffffffff0fffi64,
+0xffffffffffff1fffi64,
+0xffffffffffff3fffi64,
+0xffffffffffff7fffi64
+},
+{
+0xfffffffffffe0000i64,
+0xfffffffffffe0001i64,
+0xfffffffffffe0003i64,
+0xfffffffffffe0007i64,
+0xfffffffffffe000fi64,
+0xfffffffffffe001fi64,
+0xfffffffffffe003fi64,
+0xfffffffffffe007fi64,
+0xfffffffffffe00ffi64,
+0xfffffffffffe01ffi64,
+0xfffffffffffe03ffi64,
+0xfffffffffffe07ffi64,
+0xfffffffffffe0fffi64,
+0xfffffffffffe1fffi64,
+0xfffffffffffe3fffi64,
+0xfffffffffffe7fffi64,
+0xfffffffffffeffffi64
+},
+{
+0xfffffffffffc0000i64,
+0xfffffffffffc0001i64,
+0xfffffffffffc0003i64,
+0xfffffffffffc0007i64,
+0xfffffffffffc000fi64,
+0xfffffffffffc001fi64,
+0xfffffffffffc003fi64,
+0xfffffffffffc007fi64,
+0xfffffffffffc00ffi64,
+0xfffffffffffc01ffi64,
+0xfffffffffffc03ffi64,
+0xfffffffffffc07ffi64,
+0xfffffffffffc0fffi64,
+0xfffffffffffc1fffi64,
+0xfffffffffffc3fffi64,
+0xfffffffffffc7fffi64,
+0xfffffffffffcffffi64,
+0xfffffffffffdffffi64
+},
+{
+0xfffffffffff80000i64,
+0xfffffffffff80001i64,
+0xfffffffffff80003i64,
+0xfffffffffff80007i64,
+0xfffffffffff8000fi64,
+0xfffffffffff8001fi64,
+0xfffffffffff8003fi64,
+0xfffffffffff8007fi64,
+0xfffffffffff800ffi64,
+0xfffffffffff801ffi64,
+0xfffffffffff803ffi64,
+0xfffffffffff807ffi64,
+0xfffffffffff80fffi64,
+0xfffffffffff81fffi64,
+0xfffffffffff83fffi64,
+0xfffffffffff87fffi64,
+0xfffffffffff8ffffi64,
+0xfffffffffff9ffffi64,
+0xfffffffffffbffffi64
+},
+{
+0xfffffffffff00000i64,
+0xfffffffffff00001i64,
+0xfffffffffff00003i64,
+0xfffffffffff00007i64,
+0xfffffffffff0000fi64,
+0xfffffffffff0001fi64,
+0xfffffffffff0003fi64,
+0xfffffffffff0007fi64,
+0xfffffffffff000ffi64,
+0xfffffffffff001ffi64,
+0xfffffffffff003ffi64,
+0xfffffffffff007ffi64,
+0xfffffffffff00fffi64,
+0xfffffffffff01fffi64,
+0xfffffffffff03fffi64,
+0xfffffffffff07fffi64,
+0xfffffffffff0ffffi64,
+0xfffffffffff1ffffi64,
+0xfffffffffff3ffffi64,
+0xfffffffffff7ffffi64
+},
+{
+0xffffffffffe00000i64,
+0xffffffffffe00001i64,
+0xffffffffffe00003i64,
+0xffffffffffe00007i64,
+0xffffffffffe0000fi64,
+0xffffffffffe0001fi64,
+0xffffffffffe0003fi64,
+0xffffffffffe0007fi64,
+0xffffffffffe000ffi64,
+0xffffffffffe001ffi64,
+0xffffffffffe003ffi64,
+0xffffffffffe007ffi64,
+0xffffffffffe00fffi64,
+0xffffffffffe01fffi64,
+0xffffffffffe03fffi64,
+0xffffffffffe07fffi64,
+0xffffffffffe0ffffi64,
+0xffffffffffe1ffffi64,
+0xffffffffffe3ffffi64,
+0xffffffffffe7ffffi64,
+0xffffffffffefffffi64
+},
+{
+0xffffffffffc00000i64,
+0xffffffffffc00001i64,
+0xffffffffffc00003i64,
+0xffffffffffc00007i64,
+0xffffffffffc0000fi64,
+0xffffffffffc0001fi64,
+0xffffffffffc0003fi64,
+0xffffffffffc0007fi64,
+0xffffffffffc000ffi64,
+0xffffffffffc001ffi64,
+0xffffffffffc003ffi64,
+0xffffffffffc007ffi64,
+0xffffffffffc00fffi64,
+0xffffffffffc01fffi64,
+0xffffffffffc03fffi64,
+0xffffffffffc07fffi64,
+0xffffffffffc0ffffi64,
+0xffffffffffc1ffffi64,
+0xffffffffffc3ffffi64,
+0xffffffffffc7ffffi64,
+0xffffffffffcfffffi64,
+0xffffffffffdfffffi64
+},
+{
+0xffffffffff800000i64,
+0xffffffffff800001i64,
+0xffffffffff800003i64,
+0xffffffffff800007i64,
+0xffffffffff80000fi64,
+0xffffffffff80001fi64,
+0xffffffffff80003fi64,
+0xffffffffff80007fi64,
+0xffffffffff8000ffi64,
+0xffffffffff8001ffi64,
+0xffffffffff8003ffi64,
+0xffffffffff8007ffi64,
+0xffffffffff800fffi64,
+0xffffffffff801fffi64,
+0xffffffffff803fffi64,
+0xffffffffff807fffi64,
+0xffffffffff80ffffi64,
+0xffffffffff81ffffi64,
+0xffffffffff83ffffi64,
+0xffffffffff87ffffi64,
+0xffffffffff8fffffi64,
+0xffffffffff9fffffi64,
+0xffffffffffbfffffi64
+},
+{
+0xffffffffff000000i64,
+0xffffffffff000001i64,
+0xffffffffff000003i64,
+0xffffffffff000007i64,
+0xffffffffff00000fi64,
+0xffffffffff00001fi64,
+0xffffffffff00003fi64,
+0xffffffffff00007fi64,
+0xffffffffff0000ffi64,
+0xffffffffff0001ffi64,
+0xffffffffff0003ffi64,
+0xffffffffff0007ffi64,
+0xffffffffff000fffi64,
+0xffffffffff001fffi64,
+0xffffffffff003fffi64,
+0xffffffffff007fffi64,
+0xffffffffff00ffffi64,
+0xffffffffff01ffffi64,
+0xffffffffff03ffffi64,
+0xffffffffff07ffffi64,
+0xffffffffff0fffffi64,
+0xffffffffff1fffffi64,
+0xffffffffff3fffffi64,
+0xffffffffff7fffffi64
+},
+{
+0xfffffffffe000000i64,
+0xfffffffffe000001i64,
+0xfffffffffe000003i64,
+0xfffffffffe000007i64,
+0xfffffffffe00000fi64,
+0xfffffffffe00001fi64,
+0xfffffffffe00003fi64,
+0xfffffffffe00007fi64,
+0xfffffffffe0000ffi64,
+0xfffffffffe0001ffi64,
+0xfffffffffe0003ffi64,
+0xfffffffffe0007ffi64,
+0xfffffffffe000fffi64,
+0xfffffffffe001fffi64,
+0xfffffffffe003fffi64,
+0xfffffffffe007fffi64,
+0xfffffffffe00ffffi64,
+0xfffffffffe01ffffi64,
+0xfffffffffe03ffffi64,
+0xfffffffffe07ffffi64,
+0xfffffffffe0fffffi64,
+0xfffffffffe1fffffi64,
+0xfffffffffe3fffffi64,
+0xfffffffffe7fffffi64,
+0xfffffffffeffffffi64
+},
+{
+0xfffffffffc000000i64,
+0xfffffffffc000001i64,
+0xfffffffffc000003i64,
+0xfffffffffc000007i64,
+0xfffffffffc00000fi64,
+0xfffffffffc00001fi64,
+0xfffffffffc00003fi64,
+0xfffffffffc00007fi64,
+0xfffffffffc0000ffi64,
+0xfffffffffc0001ffi64,
+0xfffffffffc0003ffi64,
+0xfffffffffc0007ffi64,
+0xfffffffffc000fffi64,
+0xfffffffffc001fffi64,
+0xfffffffffc003fffi64,
+0xfffffffffc007fffi64,
+0xfffffffffc00ffffi64,
+0xfffffffffc01ffffi64,
+0xfffffffffc03ffffi64,
+0xfffffffffc07ffffi64,
+0xfffffffffc0fffffi64,
+0xfffffffffc1fffffi64,
+0xfffffffffc3fffffi64,
+0xfffffffffc7fffffi64,
+0xfffffffffcffffffi64,
+0xfffffffffdffffffi64
+},
+{
+0xfffffffff8000000i64,
+0xfffffffff8000001i64,
+0xfffffffff8000003i64,
+0xfffffffff8000007i64,
+0xfffffffff800000fi64,
+0xfffffffff800001fi64,
+0xfffffffff800003fi64,
+0xfffffffff800007fi64,
+0xfffffffff80000ffi64,
+0xfffffffff80001ffi64,
+0xfffffffff80003ffi64,
+0xfffffffff80007ffi64,
+0xfffffffff8000fffi64,
+0xfffffffff8001fffi64,
+0xfffffffff8003fffi64,
+0xfffffffff8007fffi64,
+0xfffffffff800ffffi64,
+0xfffffffff801ffffi64,
+0xfffffffff803ffffi64,
+0xfffffffff807ffffi64,
+0xfffffffff80fffffi64,
+0xfffffffff81fffffi64,
+0xfffffffff83fffffi64,
+0xfffffffff87fffffi64,
+0xfffffffff8ffffffi64,
+0xfffffffff9ffffffi64,
+0xfffffffffbffffffi64
+},
+{
+0xfffffffff0000000i64,
+0xfffffffff0000001i64,
+0xfffffffff0000003i64,
+0xfffffffff0000007i64,
+0xfffffffff000000fi64,
+0xfffffffff000001fi64,
+0xfffffffff000003fi64,
+0xfffffffff000007fi64,
+0xfffffffff00000ffi64,
+0xfffffffff00001ffi64,
+0xfffffffff00003ffi64,
+0xfffffffff00007ffi64,
+0xfffffffff0000fffi64,
+0xfffffffff0001fffi64,
+0xfffffffff0003fffi64,
+0xfffffffff0007fffi64,
+0xfffffffff000ffffi64,
+0xfffffffff001ffffi64,
+0xfffffffff003ffffi64,
+0xfffffffff007ffffi64,
+0xfffffffff00fffffi64,
+0xfffffffff01fffffi64,
+0xfffffffff03fffffi64,
+0xfffffffff07fffffi64,
+0xfffffffff0ffffffi64,
+0xfffffffff1ffffffi64,
+0xfffffffff3ffffffi64,
+0xfffffffff7ffffffi64
+},
+{
+0xffffffffe0000000i64,
+0xffffffffe0000001i64,
+0xffffffffe0000003i64,
+0xffffffffe0000007i64,
+0xffffffffe000000fi64,
+0xffffffffe000001fi64,
+0xffffffffe000003fi64,
+0xffffffffe000007fi64,
+0xffffffffe00000ffi64,
+0xffffffffe00001ffi64,
+0xffffffffe00003ffi64,
+0xffffffffe00007ffi64,
+0xffffffffe0000fffi64,
+0xffffffffe0001fffi64,
+0xffffffffe0003fffi64,
+0xffffffffe0007fffi64,
+0xffffffffe000ffffi64,
+0xffffffffe001ffffi64,
+0xffffffffe003ffffi64,
+0xffffffffe007ffffi64,
+0xffffffffe00fffffi64,
+0xffffffffe01fffffi64,
+0xffffffffe03fffffi64,
+0xffffffffe07fffffi64,
+0xffffffffe0ffffffi64,
+0xffffffffe1ffffffi64,
+0xffffffffe3ffffffi64,
+0xffffffffe7ffffffi64,
+0xffffffffefffffffi64
+},
+{
+0xffffffffc0000000i64,
+0xffffffffc0000001i64,
+0xffffffffc0000003i64,
+0xffffffffc0000007i64,
+0xffffffffc000000fi64,
+0xffffffffc000001fi64,
+0xffffffffc000003fi64,
+0xffffffffc000007fi64,
+0xffffffffc00000ffi64,
+0xffffffffc00001ffi64,
+0xffffffffc00003ffi64,
+0xffffffffc00007ffi64,
+0xffffffffc0000fffi64,
+0xffffffffc0001fffi64,
+0xffffffffc0003fffi64,
+0xffffffffc0007fffi64,
+0xffffffffc000ffffi64,
+0xffffffffc001ffffi64,
+0xffffffffc003ffffi64,
+0xffffffffc007ffffi64,
+0xffffffffc00fffffi64,
+0xffffffffc01fffffi64,
+0xffffffffc03fffffi64,
+0xffffffffc07fffffi64,
+0xffffffffc0ffffffi64,
+0xffffffffc1ffffffi64,
+0xffffffffc3ffffffi64,
+0xffffffffc7ffffffi64,
+0xffffffffcfffffffi64,
+0xffffffffdfffffffi64
+},
+{
+0xffffffff80000000i64,
+0xffffffff80000001i64,
+0xffffffff80000003i64,
+0xffffffff80000007i64,
+0xffffffff8000000fi64,
+0xffffffff8000001fi64,
+0xffffffff8000003fi64,
+0xffffffff8000007fi64,
+0xffffffff800000ffi64,
+0xffffffff800001ffi64,
+0xffffffff800003ffi64,
+0xffffffff800007ffi64,
+0xffffffff80000fffi64,
+0xffffffff80001fffi64,
+0xffffffff80003fffi64,
+0xffffffff80007fffi64,
+0xffffffff8000ffffi64,
+0xffffffff8001ffffi64,
+0xffffffff8003ffffi64,
+0xffffffff8007ffffi64,
+0xffffffff800fffffi64,
+0xffffffff801fffffi64,
+0xffffffff803fffffi64,
+0xffffffff807fffffi64,
+0xffffffff80ffffffi64,
+0xffffffff81ffffffi64,
+0xffffffff83ffffffi64,
+0xffffffff87ffffffi64,
+0xffffffff8fffffffi64,
+0xffffffff9fffffffi64,
+0xffffffffbfffffffi64
+},
+{
+0xffffffff00000000i64,
+0xffffffff00000001i64,
+0xffffffff00000003i64,
+0xffffffff00000007i64,
+0xffffffff0000000fi64,
+0xffffffff0000001fi64,
+0xffffffff0000003fi64,
+0xffffffff0000007fi64,
+0xffffffff000000ffi64,
+0xffffffff000001ffi64,
+0xffffffff000003ffi64,
+0xffffffff000007ffi64,
+0xffffffff00000fffi64,
+0xffffffff00001fffi64,
+0xffffffff00003fffi64,
+0xffffffff00007fffi64,
+0xffffffff0000ffffi64,
+0xffffffff0001ffffi64,
+0xffffffff0003ffffi64,
+0xffffffff0007ffffi64,
+0xffffffff000fffffi64,
+0xffffffff001fffffi64,
+0xffffffff003fffffi64,
+0xffffffff007fffffi64,
+0xffffffff00ffffffi64,
+0xffffffff01ffffffi64,
+0xffffffff03ffffffi64,
+0xffffffff07ffffffi64,
+0xffffffff0fffffffi64,
+0xffffffff1fffffffi64,
+0xffffffff3fffffffi64,
+0xffffffff7fffffffi64
+},
+{
+0xfffffffe00000000i64,
+0xfffffffe00000001i64,
+0xfffffffe00000003i64,
+0xfffffffe00000007i64,
+0xfffffffe0000000fi64,
+0xfffffffe0000001fi64,
+0xfffffffe0000003fi64,
+0xfffffffe0000007fi64,
+0xfffffffe000000ffi64,
+0xfffffffe000001ffi64,
+0xfffffffe000003ffi64,
+0xfffffffe000007ffi64,
+0xfffffffe00000fffi64,
+0xfffffffe00001fffi64,
+0xfffffffe00003fffi64,
+0xfffffffe00007fffi64,
+0xfffffffe0000ffffi64,
+0xfffffffe0001ffffi64,
+0xfffffffe0003ffffi64,
+0xfffffffe0007ffffi64,
+0xfffffffe000fffffi64,
+0xfffffffe001fffffi64,
+0xfffffffe003fffffi64,
+0xfffffffe007fffffi64,
+0xfffffffe00ffffffi64,
+0xfffffffe01ffffffi64,
+0xfffffffe03ffffffi64,
+0xfffffffe07ffffffi64,
+0xfffffffe0fffffffi64,
+0xfffffffe1fffffffi64,
+0xfffffffe3fffffffi64,
+0xfffffffe7fffffffi64,
+0xfffffffeffffffffi64
+},
+{
+0xfffffffc00000000i64,
+0xfffffffc00000001i64,
+0xfffffffc00000003i64,
+0xfffffffc00000007i64,
+0xfffffffc0000000fi64,
+0xfffffffc0000001fi64,
+0xfffffffc0000003fi64,
+0xfffffffc0000007fi64,
+0xfffffffc000000ffi64,
+0xfffffffc000001ffi64,
+0xfffffffc000003ffi64,
+0xfffffffc000007ffi64,
+0xfffffffc00000fffi64,
+0xfffffffc00001fffi64,
+0xfffffffc00003fffi64,
+0xfffffffc00007fffi64,
+0xfffffffc0000ffffi64,
+0xfffffffc0001ffffi64,
+0xfffffffc0003ffffi64,
+0xfffffffc0007ffffi64,
+0xfffffffc000fffffi64,
+0xfffffffc001fffffi64,
+0xfffffffc003fffffi64,
+0xfffffffc007fffffi64,
+0xfffffffc00ffffffi64,
+0xfffffffc01ffffffi64,
+0xfffffffc03ffffffi64,
+0xfffffffc07ffffffi64,
+0xfffffffc0fffffffi64,
+0xfffffffc1fffffffi64,
+0xfffffffc3fffffffi64,
+0xfffffffc7fffffffi64,
+0xfffffffcffffffffi64,
+0xfffffffdffffffffi64
+},
+{
+0xfffffff800000000i64,
+0xfffffff800000001i64,
+0xfffffff800000003i64,
+0xfffffff800000007i64,
+0xfffffff80000000fi64,
+0xfffffff80000001fi64,
+0xfffffff80000003fi64,
+0xfffffff80000007fi64,
+0xfffffff8000000ffi64,
+0xfffffff8000001ffi64,
+0xfffffff8000003ffi64,
+0xfffffff8000007ffi64,
+0xfffffff800000fffi64,
+0xfffffff800001fffi64,
+0xfffffff800003fffi64,
+0xfffffff800007fffi64,
+0xfffffff80000ffffi64,
+0xfffffff80001ffffi64,
+0xfffffff80003ffffi64,
+0xfffffff80007ffffi64,
+0xfffffff8000fffffi64,
+0xfffffff8001fffffi64,
+0xfffffff8003fffffi64,
+0xfffffff8007fffffi64,
+0xfffffff800ffffffi64,
+0xfffffff801ffffffi64,
+0xfffffff803ffffffi64,
+0xfffffff807ffffffi64,
+0xfffffff80fffffffi64,
+0xfffffff81fffffffi64,
+0xfffffff83fffffffi64,
+0xfffffff87fffffffi64,
+0xfffffff8ffffffffi64,
+0xfffffff9ffffffffi64,
+0xfffffffbffffffffi64
+},
+{
+0xfffffff000000000i64,
+0xfffffff000000001i64,
+0xfffffff000000003i64,
+0xfffffff000000007i64,
+0xfffffff00000000fi64,
+0xfffffff00000001fi64,
+0xfffffff00000003fi64,
+0xfffffff00000007fi64,
+0xfffffff0000000ffi64,
+0xfffffff0000001ffi64,
+0xfffffff0000003ffi64,
+0xfffffff0000007ffi64,
+0xfffffff000000fffi64,
+0xfffffff000001fffi64,
+0xfffffff000003fffi64,
+0xfffffff000007fffi64,
+0xfffffff00000ffffi64,
+0xfffffff00001ffffi64,
+0xfffffff00003ffffi64,
+0xfffffff00007ffffi64,
+0xfffffff0000fffffi64,
+0xfffffff0001fffffi64,
+0xfffffff0003fffffi64,
+0xfffffff0007fffffi64,
+0xfffffff000ffffffi64,
+0xfffffff001ffffffi64,
+0xfffffff003ffffffi64,
+0xfffffff007ffffffi64,
+0xfffffff00fffffffi64,
+0xfffffff01fffffffi64,
+0xfffffff03fffffffi64,
+0xfffffff07fffffffi64,
+0xfffffff0ffffffffi64,
+0xfffffff1ffffffffi64,
+0xfffffff3ffffffffi64,
+0xfffffff7ffffffffi64
+},
+{
+0xffffffe000000000i64,
+0xffffffe000000001i64,
+0xffffffe000000003i64,
+0xffffffe000000007i64,
+0xffffffe00000000fi64,
+0xffffffe00000001fi64,
+0xffffffe00000003fi64,
+0xffffffe00000007fi64,
+0xffffffe0000000ffi64,
+0xffffffe0000001ffi64,
+0xffffffe0000003ffi64,
+0xffffffe0000007ffi64,
+0xffffffe000000fffi64,
+0xffffffe000001fffi64,
+0xffffffe000003fffi64,
+0xffffffe000007fffi64,
+0xffffffe00000ffffi64,
+0xffffffe00001ffffi64,
+0xffffffe00003ffffi64,
+0xffffffe00007ffffi64,
+0xffffffe0000fffffi64,
+0xffffffe0001fffffi64,
+0xffffffe0003fffffi64,
+0xffffffe0007fffffi64,
+0xffffffe000ffffffi64,
+0xffffffe001ffffffi64,
+0xffffffe003ffffffi64,
+0xffffffe007ffffffi64,
+0xffffffe00fffffffi64,
+0xffffffe01fffffffi64,
+0xffffffe03fffffffi64,
+0xffffffe07fffffffi64,
+0xffffffe0ffffffffi64,
+0xffffffe1ffffffffi64,
+0xffffffe3ffffffffi64,
+0xffffffe7ffffffffi64,
+0xffffffefffffffffi64
+},
+{
+0xffffffc000000000i64,
+0xffffffc000000001i64,
+0xffffffc000000003i64,
+0xffffffc000000007i64,
+0xffffffc00000000fi64,
+0xffffffc00000001fi64,
+0xffffffc00000003fi64,
+0xffffffc00000007fi64,
+0xffffffc0000000ffi64,
+0xffffffc0000001ffi64,
+0xffffffc0000003ffi64,
+0xffffffc0000007ffi64,
+0xffffffc000000fffi64,
+0xffffffc000001fffi64,
+0xffffffc000003fffi64,
+0xffffffc000007fffi64,
+0xffffffc00000ffffi64,
+0xffffffc00001ffffi64,
+0xffffffc00003ffffi64,
+0xffffffc00007ffffi64,
+0xffffffc0000fffffi64,
+0xffffffc0001fffffi64,
+0xffffffc0003fffffi64,
+0xffffffc0007fffffi64,
+0xffffffc000ffffffi64,
+0xffffffc001ffffffi64,
+0xffffffc003ffffffi64,
+0xffffffc007ffffffi64,
+0xffffffc00fffffffi64,
+0xffffffc01fffffffi64,
+0xffffffc03fffffffi64,
+0xffffffc07fffffffi64,
+0xffffffc0ffffffffi64,
+0xffffffc1ffffffffi64,
+0xffffffc3ffffffffi64,
+0xffffffc7ffffffffi64,
+0xffffffcfffffffffi64,
+0xffffffdfffffffffi64
+},
+{
+0xffffff8000000000i64,
+0xffffff8000000001i64,
+0xffffff8000000003i64,
+0xffffff8000000007i64,
+0xffffff800000000fi64,
+0xffffff800000001fi64,
+0xffffff800000003fi64,
+0xffffff800000007fi64,
+0xffffff80000000ffi64,
+0xffffff80000001ffi64,
+0xffffff80000003ffi64,
+0xffffff80000007ffi64,
+0xffffff8000000fffi64,
+0xffffff8000001fffi64,
+0xffffff8000003fffi64,
+0xffffff8000007fffi64,
+0xffffff800000ffffi64,
+0xffffff800001ffffi64,
+0xffffff800003ffffi64,
+0xffffff800007ffffi64,
+0xffffff80000fffffi64,
+0xffffff80001fffffi64,
+0xffffff80003fffffi64,
+0xffffff80007fffffi64,
+0xffffff8000ffffffi64,
+0xffffff8001ffffffi64,
+0xffffff8003ffffffi64,
+0xffffff8007ffffffi64,
+0xffffff800fffffffi64,
+0xffffff801fffffffi64,
+0xffffff803fffffffi64,
+0xffffff807fffffffi64,
+0xffffff80ffffffffi64,
+0xffffff81ffffffffi64,
+0xffffff83ffffffffi64,
+0xffffff87ffffffffi64,
+0xffffff8fffffffffi64,
+0xffffff9fffffffffi64,
+0xffffffbfffffffffi64
+},
+{
+0xffffff0000000000i64,
+0xffffff0000000001i64,
+0xffffff0000000003i64,
+0xffffff0000000007i64,
+0xffffff000000000fi64,
+0xffffff000000001fi64,
+0xffffff000000003fi64,
+0xffffff000000007fi64,
+0xffffff00000000ffi64,
+0xffffff00000001ffi64,
+0xffffff00000003ffi64,
+0xffffff00000007ffi64,
+0xffffff0000000fffi64,
+0xffffff0000001fffi64,
+0xffffff0000003fffi64,
+0xffffff0000007fffi64,
+0xffffff000000ffffi64,
+0xffffff000001ffffi64,
+0xffffff000003ffffi64,
+0xffffff000007ffffi64,
+0xffffff00000fffffi64,
+0xffffff00001fffffi64,
+0xffffff00003fffffi64,
+0xffffff00007fffffi64,
+0xffffff0000ffffffi64,
+0xffffff0001ffffffi64,
+0xffffff0003ffffffi64,
+0xffffff0007ffffffi64,
+0xffffff000fffffffi64,
+0xffffff001fffffffi64,
+0xffffff003fffffffi64,
+0xffffff007fffffffi64,
+0xffffff00ffffffffi64,
+0xffffff01ffffffffi64,
+0xffffff03ffffffffi64,
+0xffffff07ffffffffi64,
+0xffffff0fffffffffi64,
+0xffffff1fffffffffi64,
+0xffffff3fffffffffi64,
+0xffffff7fffffffffi64
+},
+{
+0xfffffe0000000000i64,
+0xfffffe0000000001i64,
+0xfffffe0000000003i64,
+0xfffffe0000000007i64,
+0xfffffe000000000fi64,
+0xfffffe000000001fi64,
+0xfffffe000000003fi64,
+0xfffffe000000007fi64,
+0xfffffe00000000ffi64,
+0xfffffe00000001ffi64,
+0xfffffe00000003ffi64,
+0xfffffe00000007ffi64,
+0xfffffe0000000fffi64,
+0xfffffe0000001fffi64,
+0xfffffe0000003fffi64,
+0xfffffe0000007fffi64,
+0xfffffe000000ffffi64,
+0xfffffe000001ffffi64,
+0xfffffe000003ffffi64,
+0xfffffe000007ffffi64,
+0xfffffe00000fffffi64,
+0xfffffe00001fffffi64,
+0xfffffe00003fffffi64,
+0xfffffe00007fffffi64,
+0xfffffe0000ffffffi64,
+0xfffffe0001ffffffi64,
+0xfffffe0003ffffffi64,
+0xfffffe0007ffffffi64,
+0xfffffe000fffffffi64,
+0xfffffe001fffffffi64,
+0xfffffe003fffffffi64,
+0xfffffe007fffffffi64,
+0xfffffe00ffffffffi64,
+0xfffffe01ffffffffi64,
+0xfffffe03ffffffffi64,
+0xfffffe07ffffffffi64,
+0xfffffe0fffffffffi64,
+0xfffffe1fffffffffi64,
+0xfffffe3fffffffffi64,
+0xfffffe7fffffffffi64,
+0xfffffeffffffffffi64
+},
+{
+0xfffffc0000000000i64,
+0xfffffc0000000001i64,
+0xfffffc0000000003i64,
+0xfffffc0000000007i64,
+0xfffffc000000000fi64,
+0xfffffc000000001fi64,
+0xfffffc000000003fi64,
+0xfffffc000000007fi64,
+0xfffffc00000000ffi64,
+0xfffffc00000001ffi64,
+0xfffffc00000003ffi64,
+0xfffffc00000007ffi64,
+0xfffffc0000000fffi64,
+0xfffffc0000001fffi64,
+0xfffffc0000003fffi64,
+0xfffffc0000007fffi64,
+0xfffffc000000ffffi64,
+0xfffffc000001ffffi64,
+0xfffffc000003ffffi64,
+0xfffffc000007ffffi64,
+0xfffffc00000fffffi64,
+0xfffffc00001fffffi64,
+0xfffffc00003fffffi64,
+0xfffffc00007fffffi64,
+0xfffffc0000ffffffi64,
+0xfffffc0001ffffffi64,
+0xfffffc0003ffffffi64,
+0xfffffc0007ffffffi64,
+0xfffffc000fffffffi64,
+0xfffffc001fffffffi64,
+0xfffffc003fffffffi64,
+0xfffffc007fffffffi64,
+0xfffffc00ffffffffi64,
+0xfffffc01ffffffffi64,
+0xfffffc03ffffffffi64,
+0xfffffc07ffffffffi64,
+0xfffffc0fffffffffi64,
+0xfffffc1fffffffffi64,
+0xfffffc3fffffffffi64,
+0xfffffc7fffffffffi64,
+0xfffffcffffffffffi64,
+0xfffffdffffffffffi64
+},
+{
+0xfffff80000000000i64,
+0xfffff80000000001i64,
+0xfffff80000000003i64,
+0xfffff80000000007i64,
+0xfffff8000000000fi64,
+0xfffff8000000001fi64,
+0xfffff8000000003fi64,
+0xfffff8000000007fi64,
+0xfffff800000000ffi64,
+0xfffff800000001ffi64,
+0xfffff800000003ffi64,
+0xfffff800000007ffi64,
+0xfffff80000000fffi64,
+0xfffff80000001fffi64,
+0xfffff80000003fffi64,
+0xfffff80000007fffi64,
+0xfffff8000000ffffi64,
+0xfffff8000001ffffi64,
+0xfffff8000003ffffi64,
+0xfffff8000007ffffi64,
+0xfffff800000fffffi64,
+0xfffff800001fffffi64,
+0xfffff800003fffffi64,
+0xfffff800007fffffi64,
+0xfffff80000ffffffi64,
+0xfffff80001ffffffi64,
+0xfffff80003ffffffi64,
+0xfffff80007ffffffi64,
+0xfffff8000fffffffi64,
+0xfffff8001fffffffi64,
+0xfffff8003fffffffi64,
+0xfffff8007fffffffi64,
+0xfffff800ffffffffi64,
+0xfffff801ffffffffi64,
+0xfffff803ffffffffi64,
+0xfffff807ffffffffi64,
+0xfffff80fffffffffi64,
+0xfffff81fffffffffi64,
+0xfffff83fffffffffi64,
+0xfffff87fffffffffi64,
+0xfffff8ffffffffffi64,
+0xfffff9ffffffffffi64,
+0xfffffbffffffffffi64
+},
+{
+0xfffff00000000000i64,
+0xfffff00000000001i64,
+0xfffff00000000003i64,
+0xfffff00000000007i64,
+0xfffff0000000000fi64,
+0xfffff0000000001fi64,
+0xfffff0000000003fi64,
+0xfffff0000000007fi64,
+0xfffff000000000ffi64,
+0xfffff000000001ffi64,
+0xfffff000000003ffi64,
+0xfffff000000007ffi64,
+0xfffff00000000fffi64,
+0xfffff00000001fffi64,
+0xfffff00000003fffi64,
+0xfffff00000007fffi64,
+0xfffff0000000ffffi64,
+0xfffff0000001ffffi64,
+0xfffff0000003ffffi64,
+0xfffff0000007ffffi64,
+0xfffff000000fffffi64,
+0xfffff000001fffffi64,
+0xfffff000003fffffi64,
+0xfffff000007fffffi64,
+0xfffff00000ffffffi64,
+0xfffff00001ffffffi64,
+0xfffff00003ffffffi64,
+0xfffff00007ffffffi64,
+0xfffff0000fffffffi64,
+0xfffff0001fffffffi64,
+0xfffff0003fffffffi64,
+0xfffff0007fffffffi64,
+0xfffff000ffffffffi64,
+0xfffff001ffffffffi64,
+0xfffff003ffffffffi64,
+0xfffff007ffffffffi64,
+0xfffff00fffffffffi64,
+0xfffff01fffffffffi64,
+0xfffff03fffffffffi64,
+0xfffff07fffffffffi64,
+0xfffff0ffffffffffi64,
+0xfffff1ffffffffffi64,
+0xfffff3ffffffffffi64,
+0xfffff7ffffffffffi64
+},
+{
+0xffffe00000000000i64,
+0xffffe00000000001i64,
+0xffffe00000000003i64,
+0xffffe00000000007i64,
+0xffffe0000000000fi64,
+0xffffe0000000001fi64,
+0xffffe0000000003fi64,
+0xffffe0000000007fi64,
+0xffffe000000000ffi64,
+0xffffe000000001ffi64,
+0xffffe000000003ffi64,
+0xffffe000000007ffi64,
+0xffffe00000000fffi64,
+0xffffe00000001fffi64,
+0xffffe00000003fffi64,
+0xffffe00000007fffi64,
+0xffffe0000000ffffi64,
+0xffffe0000001ffffi64,
+0xffffe0000003ffffi64,
+0xffffe0000007ffffi64,
+0xffffe000000fffffi64,
+0xffffe000001fffffi64,
+0xffffe000003fffffi64,
+0xffffe000007fffffi64,
+0xffffe00000ffffffi64,
+0xffffe00001ffffffi64,
+0xffffe00003ffffffi64,
+0xffffe00007ffffffi64,
+0xffffe0000fffffffi64,
+0xffffe0001fffffffi64,
+0xffffe0003fffffffi64,
+0xffffe0007fffffffi64,
+0xffffe000ffffffffi64,
+0xffffe001ffffffffi64,
+0xffffe003ffffffffi64,
+0xffffe007ffffffffi64,
+0xffffe00fffffffffi64,
+0xffffe01fffffffffi64,
+0xffffe03fffffffffi64,
+0xffffe07fffffffffi64,
+0xffffe0ffffffffffi64,
+0xffffe1ffffffffffi64,
+0xffffe3ffffffffffi64,
+0xffffe7ffffffffffi64,
+0xffffefffffffffffi64
+},
+{
+0xffffc00000000000i64,
+0xffffc00000000001i64,
+0xffffc00000000003i64,
+0xffffc00000000007i64,
+0xffffc0000000000fi64,
+0xffffc0000000001fi64,
+0xffffc0000000003fi64,
+0xffffc0000000007fi64,
+0xffffc000000000ffi64,
+0xffffc000000001ffi64,
+0xffffc000000003ffi64,
+0xffffc000000007ffi64,
+0xffffc00000000fffi64,
+0xffffc00000001fffi64,
+0xffffc00000003fffi64,
+0xffffc00000007fffi64,
+0xffffc0000000ffffi64,
+0xffffc0000001ffffi64,
+0xffffc0000003ffffi64,
+0xffffc0000007ffffi64,
+0xffffc000000fffffi64,
+0xffffc000001fffffi64,
+0xffffc000003fffffi64,
+0xffffc000007fffffi64,
+0xffffc00000ffffffi64,
+0xffffc00001ffffffi64,
+0xffffc00003ffffffi64,
+0xffffc00007ffffffi64,
+0xffffc0000fffffffi64,
+0xffffc0001fffffffi64,
+0xffffc0003fffffffi64,
+0xffffc0007fffffffi64,
+0xffffc000ffffffffi64,
+0xffffc001ffffffffi64,
+0xffffc003ffffffffi64,
+0xffffc007ffffffffi64,
+0xffffc00fffffffffi64,
+0xffffc01fffffffffi64,
+0xffffc03fffffffffi64,
+0xffffc07fffffffffi64,
+0xffffc0ffffffffffi64,
+0xffffc1ffffffffffi64,
+0xffffc3ffffffffffi64,
+0xffffc7ffffffffffi64,
+0xffffcfffffffffffi64,
+0xffffdfffffffffffi64
+},
+{
+0xffff800000000000i64,
+0xffff800000000001i64,
+0xffff800000000003i64,
+0xffff800000000007i64,
+0xffff80000000000fi64,
+0xffff80000000001fi64,
+0xffff80000000003fi64,
+0xffff80000000007fi64,
+0xffff8000000000ffi64,
+0xffff8000000001ffi64,
+0xffff8000000003ffi64,
+0xffff8000000007ffi64,
+0xffff800000000fffi64,
+0xffff800000001fffi64,
+0xffff800000003fffi64,
+0xffff800000007fffi64,
+0xffff80000000ffffi64,
+0xffff80000001ffffi64,
+0xffff80000003ffffi64,
+0xffff80000007ffffi64,
+0xffff8000000fffffi64,
+0xffff8000001fffffi64,
+0xffff8000003fffffi64,
+0xffff8000007fffffi64,
+0xffff800000ffffffi64,
+0xffff800001ffffffi64,
+0xffff800003ffffffi64,
+0xffff800007ffffffi64,
+0xffff80000fffffffi64,
+0xffff80001fffffffi64,
+0xffff80003fffffffi64,
+0xffff80007fffffffi64,
+0xffff8000ffffffffi64,
+0xffff8001ffffffffi64,
+0xffff8003ffffffffi64,
+0xffff8007ffffffffi64,
+0xffff800fffffffffi64,
+0xffff801fffffffffi64,
+0xffff803fffffffffi64,
+0xffff807fffffffffi64,
+0xffff80ffffffffffi64,
+0xffff81ffffffffffi64,
+0xffff83ffffffffffi64,
+0xffff87ffffffffffi64,
+0xffff8fffffffffffi64,
+0xffff9fffffffffffi64,
+0xffffbfffffffffffi64
+},
+{
+0xffff000000000000i64,
+0xffff000000000001i64,
+0xffff000000000003i64,
+0xffff000000000007i64,
+0xffff00000000000fi64,
+0xffff00000000001fi64,
+0xffff00000000003fi64,
+0xffff00000000007fi64,
+0xffff0000000000ffi64,
+0xffff0000000001ffi64,
+0xffff0000000003ffi64,
+0xffff0000000007ffi64,
+0xffff000000000fffi64,
+0xffff000000001fffi64,
+0xffff000000003fffi64,
+0xffff000000007fffi64,
+0xffff00000000ffffi64,
+0xffff00000001ffffi64,
+0xffff00000003ffffi64,
+0xffff00000007ffffi64,
+0xffff0000000fffffi64,
+0xffff0000001fffffi64,
+0xffff0000003fffffi64,
+0xffff0000007fffffi64,
+0xffff000000ffffffi64,
+0xffff000001ffffffi64,
+0xffff000003ffffffi64,
+0xffff000007ffffffi64,
+0xffff00000fffffffi64,
+0xffff00001fffffffi64,
+0xffff00003fffffffi64,
+0xffff00007fffffffi64,
+0xffff0000ffffffffi64,
+0xffff0001ffffffffi64,
+0xffff0003ffffffffi64,
+0xffff0007ffffffffi64,
+0xffff000fffffffffi64,
+0xffff001fffffffffi64,
+0xffff003fffffffffi64,
+0xffff007fffffffffi64,
+0xffff00ffffffffffi64,
+0xffff01ffffffffffi64,
+0xffff03ffffffffffi64,
+0xffff07ffffffffffi64,
+0xffff0fffffffffffi64,
+0xffff1fffffffffffi64,
+0xffff3fffffffffffi64,
+0xffff7fffffffffffi64
+},
+{
+0xfffe000000000000i64,
+0xfffe000000000001i64,
+0xfffe000000000003i64,
+0xfffe000000000007i64,
+0xfffe00000000000fi64,
+0xfffe00000000001fi64,
+0xfffe00000000003fi64,
+0xfffe00000000007fi64,
+0xfffe0000000000ffi64,
+0xfffe0000000001ffi64,
+0xfffe0000000003ffi64,
+0xfffe0000000007ffi64,
+0xfffe000000000fffi64,
+0xfffe000000001fffi64,
+0xfffe000000003fffi64,
+0xfffe000000007fffi64,
+0xfffe00000000ffffi64,
+0xfffe00000001ffffi64,
+0xfffe00000003ffffi64,
+0xfffe00000007ffffi64,
+0xfffe0000000fffffi64,
+0xfffe0000001fffffi64,
+0xfffe0000003fffffi64,
+0xfffe0000007fffffi64,
+0xfffe000000ffffffi64,
+0xfffe000001ffffffi64,
+0xfffe000003ffffffi64,
+0xfffe000007ffffffi64,
+0xfffe00000fffffffi64,
+0xfffe00001fffffffi64,
+0xfffe00003fffffffi64,
+0xfffe00007fffffffi64,
+0xfffe0000ffffffffi64,
+0xfffe0001ffffffffi64,
+0xfffe0003ffffffffi64,
+0xfffe0007ffffffffi64,
+0xfffe000fffffffffi64,
+0xfffe001fffffffffi64,
+0xfffe003fffffffffi64,
+0xfffe007fffffffffi64,
+0xfffe00ffffffffffi64,
+0xfffe01ffffffffffi64,
+0xfffe03ffffffffffi64,
+0xfffe07ffffffffffi64,
+0xfffe0fffffffffffi64,
+0xfffe1fffffffffffi64,
+0xfffe3fffffffffffi64,
+0xfffe7fffffffffffi64,
+0xfffeffffffffffffi64
+},
+{
+0xfffc000000000000i64,
+0xfffc000000000001i64,
+0xfffc000000000003i64,
+0xfffc000000000007i64,
+0xfffc00000000000fi64,
+0xfffc00000000001fi64,
+0xfffc00000000003fi64,
+0xfffc00000000007fi64,
+0xfffc0000000000ffi64,
+0xfffc0000000001ffi64,
+0xfffc0000000003ffi64,
+0xfffc0000000007ffi64,
+0xfffc000000000fffi64,
+0xfffc000000001fffi64,
+0xfffc000000003fffi64,
+0xfffc000000007fffi64,
+0xfffc00000000ffffi64,
+0xfffc00000001ffffi64,
+0xfffc00000003ffffi64,
+0xfffc00000007ffffi64,
+0xfffc0000000fffffi64,
+0xfffc0000001fffffi64,
+0xfffc0000003fffffi64,
+0xfffc0000007fffffi64,
+0xfffc000000ffffffi64,
+0xfffc000001ffffffi64,
+0xfffc000003ffffffi64,
+0xfffc000007ffffffi64,
+0xfffc00000fffffffi64,
+0xfffc00001fffffffi64,
+0xfffc00003fffffffi64,
+0xfffc00007fffffffi64,
+0xfffc0000ffffffffi64,
+0xfffc0001ffffffffi64,
+0xfffc0003ffffffffi64,
+0xfffc0007ffffffffi64,
+0xfffc000fffffffffi64,
+0xfffc001fffffffffi64,
+0xfffc003fffffffffi64,
+0xfffc007fffffffffi64,
+0xfffc00ffffffffffi64,
+0xfffc01ffffffffffi64,
+0xfffc03ffffffffffi64,
+0xfffc07ffffffffffi64,
+0xfffc0fffffffffffi64,
+0xfffc1fffffffffffi64,
+0xfffc3fffffffffffi64,
+0xfffc7fffffffffffi64,
+0xfffcffffffffffffi64,
+0xfffdffffffffffffi64
+},
+{
+0xfff8000000000000i64,
+0xfff8000000000001i64,
+0xfff8000000000003i64,
+0xfff8000000000007i64,
+0xfff800000000000fi64,
+0xfff800000000001fi64,
+0xfff800000000003fi64,
+0xfff800000000007fi64,
+0xfff80000000000ffi64,
+0xfff80000000001ffi64,
+0xfff80000000003ffi64,
+0xfff80000000007ffi64,
+0xfff8000000000fffi64,
+0xfff8000000001fffi64,
+0xfff8000000003fffi64,
+0xfff8000000007fffi64,
+0xfff800000000ffffi64,
+0xfff800000001ffffi64,
+0xfff800000003ffffi64,
+0xfff800000007ffffi64,
+0xfff80000000fffffi64,
+0xfff80000001fffffi64,
+0xfff80000003fffffi64,
+0xfff80000007fffffi64,
+0xfff8000000ffffffi64,
+0xfff8000001ffffffi64,
+0xfff8000003ffffffi64,
+0xfff8000007ffffffi64,
+0xfff800000fffffffi64,
+0xfff800001fffffffi64,
+0xfff800003fffffffi64,
+0xfff800007fffffffi64,
+0xfff80000ffffffffi64,
+0xfff80001ffffffffi64,
+0xfff80003ffffffffi64,
+0xfff80007ffffffffi64,
+0xfff8000fffffffffi64,
+0xfff8001fffffffffi64,
+0xfff8003fffffffffi64,
+0xfff8007fffffffffi64,
+0xfff800ffffffffffi64,
+0xfff801ffffffffffi64,
+0xfff803ffffffffffi64,
+0xfff807ffffffffffi64,
+0xfff80fffffffffffi64,
+0xfff81fffffffffffi64,
+0xfff83fffffffffffi64,
+0xfff87fffffffffffi64,
+0xfff8ffffffffffffi64,
+0xfff9ffffffffffffi64,
+0xfffbffffffffffffi64
+},
+{
+0xfff0000000000000i64,
+0xfff0000000000001i64,
+0xfff0000000000003i64,
+0xfff0000000000007i64,
+0xfff000000000000fi64,
+0xfff000000000001fi64,
+0xfff000000000003fi64,
+0xfff000000000007fi64,
+0xfff00000000000ffi64,
+0xfff00000000001ffi64,
+0xfff00000000003ffi64,
+0xfff00000000007ffi64,
+0xfff0000000000fffi64,
+0xfff0000000001fffi64,
+0xfff0000000003fffi64,
+0xfff0000000007fffi64,
+0xfff000000000ffffi64,
+0xfff000000001ffffi64,
+0xfff000000003ffffi64,
+0xfff000000007ffffi64,
+0xfff00000000fffffi64,
+0xfff00000001fffffi64,
+0xfff00000003fffffi64,
+0xfff00000007fffffi64,
+0xfff0000000ffffffi64,
+0xfff0000001ffffffi64,
+0xfff0000003ffffffi64,
+0xfff0000007ffffffi64,
+0xfff000000fffffffi64,
+0xfff000001fffffffi64,
+0xfff000003fffffffi64,
+0xfff000007fffffffi64,
+0xfff00000ffffffffi64,
+0xfff00001ffffffffi64,
+0xfff00003ffffffffi64,
+0xfff00007ffffffffi64,
+0xfff0000fffffffffi64,
+0xfff0001fffffffffi64,
+0xfff0003fffffffffi64,
+0xfff0007fffffffffi64,
+0xfff000ffffffffffi64,
+0xfff001ffffffffffi64,
+0xfff003ffffffffffi64,
+0xfff007ffffffffffi64,
+0xfff00fffffffffffi64,
+0xfff01fffffffffffi64,
+0xfff03fffffffffffi64,
+0xfff07fffffffffffi64,
+0xfff0ffffffffffffi64,
+0xfff1ffffffffffffi64,
+0xfff3ffffffffffffi64,
+0xfff7ffffffffffffi64
+},
+{
+0xffe0000000000000i64,
+0xffe0000000000001i64,
+0xffe0000000000003i64,
+0xffe0000000000007i64,
+0xffe000000000000fi64,
+0xffe000000000001fi64,
+0xffe000000000003fi64,
+0xffe000000000007fi64,
+0xffe00000000000ffi64,
+0xffe00000000001ffi64,
+0xffe00000000003ffi64,
+0xffe00000000007ffi64,
+0xffe0000000000fffi64,
+0xffe0000000001fffi64,
+0xffe0000000003fffi64,
+0xffe0000000007fffi64,
+0xffe000000000ffffi64,
+0xffe000000001ffffi64,
+0xffe000000003ffffi64,
+0xffe000000007ffffi64,
+0xffe00000000fffffi64,
+0xffe00000001fffffi64,
+0xffe00000003fffffi64,
+0xffe00000007fffffi64,
+0xffe0000000ffffffi64,
+0xffe0000001ffffffi64,
+0xffe0000003ffffffi64,
+0xffe0000007ffffffi64,
+0xffe000000fffffffi64,
+0xffe000001fffffffi64,
+0xffe000003fffffffi64,
+0xffe000007fffffffi64,
+0xffe00000ffffffffi64,
+0xffe00001ffffffffi64,
+0xffe00003ffffffffi64,
+0xffe00007ffffffffi64,
+0xffe0000fffffffffi64,
+0xffe0001fffffffffi64,
+0xffe0003fffffffffi64,
+0xffe0007fffffffffi64,
+0xffe000ffffffffffi64,
+0xffe001ffffffffffi64,
+0xffe003ffffffffffi64,
+0xffe007ffffffffffi64,
+0xffe00fffffffffffi64,
+0xffe01fffffffffffi64,
+0xffe03fffffffffffi64,
+0xffe07fffffffffffi64,
+0xffe0ffffffffffffi64,
+0xffe1ffffffffffffi64,
+0xffe3ffffffffffffi64,
+0xffe7ffffffffffffi64,
+0xffefffffffffffffi64
+},
+{
+0xffc0000000000000i64,
+0xffc0000000000001i64,
+0xffc0000000000003i64,
+0xffc0000000000007i64,
+0xffc000000000000fi64,
+0xffc000000000001fi64,
+0xffc000000000003fi64,
+0xffc000000000007fi64,
+0xffc00000000000ffi64,
+0xffc00000000001ffi64,
+0xffc00000000003ffi64,
+0xffc00000000007ffi64,
+0xffc0000000000fffi64,
+0xffc0000000001fffi64,
+0xffc0000000003fffi64,
+0xffc0000000007fffi64,
+0xffc000000000ffffi64,
+0xffc000000001ffffi64,
+0xffc000000003ffffi64,
+0xffc000000007ffffi64,
+0xffc00000000fffffi64,
+0xffc00000001fffffi64,
+0xffc00000003fffffi64,
+0xffc00000007fffffi64,
+0xffc0000000ffffffi64,
+0xffc0000001ffffffi64,
+0xffc0000003ffffffi64,
+0xffc0000007ffffffi64,
+0xffc000000fffffffi64,
+0xffc000001fffffffi64,
+0xffc000003fffffffi64,
+0xffc000007fffffffi64,
+0xffc00000ffffffffi64,
+0xffc00001ffffffffi64,
+0xffc00003ffffffffi64,
+0xffc00007ffffffffi64,
+0xffc0000fffffffffi64,
+0xffc0001fffffffffi64,
+0xffc0003fffffffffi64,
+0xffc0007fffffffffi64,
+0xffc000ffffffffffi64,
+0xffc001ffffffffffi64,
+0xffc003ffffffffffi64,
+0xffc007ffffffffffi64,
+0xffc00fffffffffffi64,
+0xffc01fffffffffffi64,
+0xffc03fffffffffffi64,
+0xffc07fffffffffffi64,
+0xffc0ffffffffffffi64,
+0xffc1ffffffffffffi64,
+0xffc3ffffffffffffi64,
+0xffc7ffffffffffffi64,
+0xffcfffffffffffffi64,
+0xffdfffffffffffffi64
+},
+{
+0xff80000000000000i64,
+0xff80000000000001i64,
+0xff80000000000003i64,
+0xff80000000000007i64,
+0xff8000000000000fi64,
+0xff8000000000001fi64,
+0xff8000000000003fi64,
+0xff8000000000007fi64,
+0xff800000000000ffi64,
+0xff800000000001ffi64,
+0xff800000000003ffi64,
+0xff800000000007ffi64,
+0xff80000000000fffi64,
+0xff80000000001fffi64,
+0xff80000000003fffi64,
+0xff80000000007fffi64,
+0xff8000000000ffffi64,
+0xff8000000001ffffi64,
+0xff8000000003ffffi64,
+0xff8000000007ffffi64,
+0xff800000000fffffi64,
+0xff800000001fffffi64,
+0xff800000003fffffi64,
+0xff800000007fffffi64,
+0xff80000000ffffffi64,
+0xff80000001ffffffi64,
+0xff80000003ffffffi64,
+0xff80000007ffffffi64,
+0xff8000000fffffffi64,
+0xff8000001fffffffi64,
+0xff8000003fffffffi64,
+0xff8000007fffffffi64,
+0xff800000ffffffffi64,
+0xff800001ffffffffi64,
+0xff800003ffffffffi64,
+0xff800007ffffffffi64,
+0xff80000fffffffffi64,
+0xff80001fffffffffi64,
+0xff80003fffffffffi64,
+0xff80007fffffffffi64,
+0xff8000ffffffffffi64,
+0xff8001ffffffffffi64,
+0xff8003ffffffffffi64,
+0xff8007ffffffffffi64,
+0xff800fffffffffffi64,
+0xff801fffffffffffi64,
+0xff803fffffffffffi64,
+0xff807fffffffffffi64,
+0xff80ffffffffffffi64,
+0xff81ffffffffffffi64,
+0xff83ffffffffffffi64,
+0xff87ffffffffffffi64,
+0xff8fffffffffffffi64,
+0xff9fffffffffffffi64,
+0xffbfffffffffffffi64
+},
+{
+0xff00000000000000i64,
+0xff00000000000001i64,
+0xff00000000000003i64,
+0xff00000000000007i64,
+0xff0000000000000fi64,
+0xff0000000000001fi64,
+0xff0000000000003fi64,
+0xff0000000000007fi64,
+0xff000000000000ffi64,
+0xff000000000001ffi64,
+0xff000000000003ffi64,
+0xff000000000007ffi64,
+0xff00000000000fffi64,
+0xff00000000001fffi64,
+0xff00000000003fffi64,
+0xff00000000007fffi64,
+0xff0000000000ffffi64,
+0xff0000000001ffffi64,
+0xff0000000003ffffi64,
+0xff0000000007ffffi64,
+0xff000000000fffffi64,
+0xff000000001fffffi64,
+0xff000000003fffffi64,
+0xff000000007fffffi64,
+0xff00000000ffffffi64,
+0xff00000001ffffffi64,
+0xff00000003ffffffi64,
+0xff00000007ffffffi64,
+0xff0000000fffffffi64,
+0xff0000001fffffffi64,
+0xff0000003fffffffi64,
+0xff0000007fffffffi64,
+0xff000000ffffffffi64,
+0xff000001ffffffffi64,
+0xff000003ffffffffi64,
+0xff000007ffffffffi64,
+0xff00000fffffffffi64,
+0xff00001fffffffffi64,
+0xff00003fffffffffi64,
+0xff00007fffffffffi64,
+0xff0000ffffffffffi64,
+0xff0001ffffffffffi64,
+0xff0003ffffffffffi64,
+0xff0007ffffffffffi64,
+0xff000fffffffffffi64,
+0xff001fffffffffffi64,
+0xff003fffffffffffi64,
+0xff007fffffffffffi64,
+0xff00ffffffffffffi64,
+0xff01ffffffffffffi64,
+0xff03ffffffffffffi64,
+0xff07ffffffffffffi64,
+0xff0fffffffffffffi64,
+0xff1fffffffffffffi64,
+0xff3fffffffffffffi64,
+0xff7fffffffffffffi64
+},
+{
+0xfe00000000000000i64,
+0xfe00000000000001i64,
+0xfe00000000000003i64,
+0xfe00000000000007i64,
+0xfe0000000000000fi64,
+0xfe0000000000001fi64,
+0xfe0000000000003fi64,
+0xfe0000000000007fi64,
+0xfe000000000000ffi64,
+0xfe000000000001ffi64,
+0xfe000000000003ffi64,
+0xfe000000000007ffi64,
+0xfe00000000000fffi64,
+0xfe00000000001fffi64,
+0xfe00000000003fffi64,
+0xfe00000000007fffi64,
+0xfe0000000000ffffi64,
+0xfe0000000001ffffi64,
+0xfe0000000003ffffi64,
+0xfe0000000007ffffi64,
+0xfe000000000fffffi64,
+0xfe000000001fffffi64,
+0xfe000000003fffffi64,
+0xfe000000007fffffi64,
+0xfe00000000ffffffi64,
+0xfe00000001ffffffi64,
+0xfe00000003ffffffi64,
+0xfe00000007ffffffi64,
+0xfe0000000fffffffi64,
+0xfe0000001fffffffi64,
+0xfe0000003fffffffi64,
+0xfe0000007fffffffi64,
+0xfe000000ffffffffi64,
+0xfe000001ffffffffi64,
+0xfe000003ffffffffi64,
+0xfe000007ffffffffi64,
+0xfe00000fffffffffi64,
+0xfe00001fffffffffi64,
+0xfe00003fffffffffi64,
+0xfe00007fffffffffi64,
+0xfe0000ffffffffffi64,
+0xfe0001ffffffffffi64,
+0xfe0003ffffffffffi64,
+0xfe0007ffffffffffi64,
+0xfe000fffffffffffi64,
+0xfe001fffffffffffi64,
+0xfe003fffffffffffi64,
+0xfe007fffffffffffi64,
+0xfe00ffffffffffffi64,
+0xfe01ffffffffffffi64,
+0xfe03ffffffffffffi64,
+0xfe07ffffffffffffi64,
+0xfe0fffffffffffffi64,
+0xfe1fffffffffffffi64,
+0xfe3fffffffffffffi64,
+0xfe7fffffffffffffi64,
+0xfeffffffffffffffi64
+},
+{
+0xfc00000000000000i64,
+0xfc00000000000001i64,
+0xfc00000000000003i64,
+0xfc00000000000007i64,
+0xfc0000000000000fi64,
+0xfc0000000000001fi64,
+0xfc0000000000003fi64,
+0xfc0000000000007fi64,
+0xfc000000000000ffi64,
+0xfc000000000001ffi64,
+0xfc000000000003ffi64,
+0xfc000000000007ffi64,
+0xfc00000000000fffi64,
+0xfc00000000001fffi64,
+0xfc00000000003fffi64,
+0xfc00000000007fffi64,
+0xfc0000000000ffffi64,
+0xfc0000000001ffffi64,
+0xfc0000000003ffffi64,
+0xfc0000000007ffffi64,
+0xfc000000000fffffi64,
+0xfc000000001fffffi64,
+0xfc000000003fffffi64,
+0xfc000000007fffffi64,
+0xfc00000000ffffffi64,
+0xfc00000001ffffffi64,
+0xfc00000003ffffffi64,
+0xfc00000007ffffffi64,
+0xfc0000000fffffffi64,
+0xfc0000001fffffffi64,
+0xfc0000003fffffffi64,
+0xfc0000007fffffffi64,
+0xfc000000ffffffffi64,
+0xfc000001ffffffffi64,
+0xfc000003ffffffffi64,
+0xfc000007ffffffffi64,
+0xfc00000fffffffffi64,
+0xfc00001fffffffffi64,
+0xfc00003fffffffffi64,
+0xfc00007fffffffffi64,
+0xfc0000ffffffffffi64,
+0xfc0001ffffffffffi64,
+0xfc0003ffffffffffi64,
+0xfc0007ffffffffffi64,
+0xfc000fffffffffffi64,
+0xfc001fffffffffffi64,
+0xfc003fffffffffffi64,
+0xfc007fffffffffffi64,
+0xfc00ffffffffffffi64,
+0xfc01ffffffffffffi64,
+0xfc03ffffffffffffi64,
+0xfc07ffffffffffffi64,
+0xfc0fffffffffffffi64,
+0xfc1fffffffffffffi64,
+0xfc3fffffffffffffi64,
+0xfc7fffffffffffffi64,
+0xfcffffffffffffffi64,
+0xfdffffffffffffffi64
+},
+{
+0xf800000000000000i64,
+0xf800000000000001i64,
+0xf800000000000003i64,
+0xf800000000000007i64,
+0xf80000000000000fi64,
+0xf80000000000001fi64,
+0xf80000000000003fi64,
+0xf80000000000007fi64,
+0xf8000000000000ffi64,
+0xf8000000000001ffi64,
+0xf8000000000003ffi64,
+0xf8000000000007ffi64,
+0xf800000000000fffi64,
+0xf800000000001fffi64,
+0xf800000000003fffi64,
+0xf800000000007fffi64,
+0xf80000000000ffffi64,
+0xf80000000001ffffi64,
+0xf80000000003ffffi64,
+0xf80000000007ffffi64,
+0xf8000000000fffffi64,
+0xf8000000001fffffi64,
+0xf8000000003fffffi64,
+0xf8000000007fffffi64,
+0xf800000000ffffffi64,
+0xf800000001ffffffi64,
+0xf800000003ffffffi64,
+0xf800000007ffffffi64,
+0xf80000000fffffffi64,
+0xf80000001fffffffi64,
+0xf80000003fffffffi64,
+0xf80000007fffffffi64,
+0xf8000000ffffffffi64,
+0xf8000001ffffffffi64,
+0xf8000003ffffffffi64,
+0xf8000007ffffffffi64,
+0xf800000fffffffffi64,
+0xf800001fffffffffi64,
+0xf800003fffffffffi64,
+0xf800007fffffffffi64,
+0xf80000ffffffffffi64,
+0xf80001ffffffffffi64,
+0xf80003ffffffffffi64,
+0xf80007ffffffffffi64,
+0xf8000fffffffffffi64,
+0xf8001fffffffffffi64,
+0xf8003fffffffffffi64,
+0xf8007fffffffffffi64,
+0xf800ffffffffffffi64,
+0xf801ffffffffffffi64,
+0xf803ffffffffffffi64,
+0xf807ffffffffffffi64,
+0xf80fffffffffffffi64,
+0xf81fffffffffffffi64,
+0xf83fffffffffffffi64,
+0xf87fffffffffffffi64,
+0xf8ffffffffffffffi64,
+0xf9ffffffffffffffi64,
+0xfbffffffffffffffi64
+},
+{
+0xf000000000000000i64,
+0xf000000000000001i64,
+0xf000000000000003i64,
+0xf000000000000007i64,
+0xf00000000000000fi64,
+0xf00000000000001fi64,
+0xf00000000000003fi64,
+0xf00000000000007fi64,
+0xf0000000000000ffi64,
+0xf0000000000001ffi64,
+0xf0000000000003ffi64,
+0xf0000000000007ffi64,
+0xf000000000000fffi64,
+0xf000000000001fffi64,
+0xf000000000003fffi64,
+0xf000000000007fffi64,
+0xf00000000000ffffi64,
+0xf00000000001ffffi64,
+0xf00000000003ffffi64,
+0xf00000000007ffffi64,
+0xf0000000000fffffi64,
+0xf0000000001fffffi64,
+0xf0000000003fffffi64,
+0xf0000000007fffffi64,
+0xf000000000ffffffi64,
+0xf000000001ffffffi64,
+0xf000000003ffffffi64,
+0xf000000007ffffffi64,
+0xf00000000fffffffi64,
+0xf00000001fffffffi64,
+0xf00000003fffffffi64,
+0xf00000007fffffffi64,
+0xf0000000ffffffffi64,
+0xf0000001ffffffffi64,
+0xf0000003ffffffffi64,
+0xf0000007ffffffffi64,
+0xf000000fffffffffi64,
+0xf000001fffffffffi64,
+0xf000003fffffffffi64,
+0xf000007fffffffffi64,
+0xf00000ffffffffffi64,
+0xf00001ffffffffffi64,
+0xf00003ffffffffffi64,
+0xf00007ffffffffffi64,
+0xf0000fffffffffffi64,
+0xf0001fffffffffffi64,
+0xf0003fffffffffffi64,
+0xf0007fffffffffffi64,
+0xf000ffffffffffffi64,
+0xf001ffffffffffffi64,
+0xf003ffffffffffffi64,
+0xf007ffffffffffffi64,
+0xf00fffffffffffffi64,
+0xf01fffffffffffffi64,
+0xf03fffffffffffffi64,
+0xf07fffffffffffffi64,
+0xf0ffffffffffffffi64,
+0xf1ffffffffffffffi64,
+0xf3ffffffffffffffi64,
+0xf7ffffffffffffffi64
+},
+{
+0xe000000000000000i64,
+0xe000000000000001i64,
+0xe000000000000003i64,
+0xe000000000000007i64,
+0xe00000000000000fi64,
+0xe00000000000001fi64,
+0xe00000000000003fi64,
+0xe00000000000007fi64,
+0xe0000000000000ffi64,
+0xe0000000000001ffi64,
+0xe0000000000003ffi64,
+0xe0000000000007ffi64,
+0xe000000000000fffi64,
+0xe000000000001fffi64,
+0xe000000000003fffi64,
+0xe000000000007fffi64,
+0xe00000000000ffffi64,
+0xe00000000001ffffi64,
+0xe00000000003ffffi64,
+0xe00000000007ffffi64,
+0xe0000000000fffffi64,
+0xe0000000001fffffi64,
+0xe0000000003fffffi64,
+0xe0000000007fffffi64,
+0xe000000000ffffffi64,
+0xe000000001ffffffi64,
+0xe000000003ffffffi64,
+0xe000000007ffffffi64,
+0xe00000000fffffffi64,
+0xe00000001fffffffi64,
+0xe00000003fffffffi64,
+0xe00000007fffffffi64,
+0xe0000000ffffffffi64,
+0xe0000001ffffffffi64,
+0xe0000003ffffffffi64,
+0xe0000007ffffffffi64,
+0xe000000fffffffffi64,
+0xe000001fffffffffi64,
+0xe000003fffffffffi64,
+0xe000007fffffffffi64,
+0xe00000ffffffffffi64,
+0xe00001ffffffffffi64,
+0xe00003ffffffffffi64,
+0xe00007ffffffffffi64,
+0xe0000fffffffffffi64,
+0xe0001fffffffffffi64,
+0xe0003fffffffffffi64,
+0xe0007fffffffffffi64,
+0xe000ffffffffffffi64,
+0xe001ffffffffffffi64,
+0xe003ffffffffffffi64,
+0xe007ffffffffffffi64,
+0xe00fffffffffffffi64,
+0xe01fffffffffffffi64,
+0xe03fffffffffffffi64,
+0xe07fffffffffffffi64,
+0xe0ffffffffffffffi64,
+0xe1ffffffffffffffi64,
+0xe3ffffffffffffffi64,
+0xe7ffffffffffffffi64,
+0xefffffffffffffffi64
+},
+{
+0xc000000000000000i64,
+0xc000000000000001i64,
+0xc000000000000003i64,
+0xc000000000000007i64,
+0xc00000000000000fi64,
+0xc00000000000001fi64,
+0xc00000000000003fi64,
+0xc00000000000007fi64,
+0xc0000000000000ffi64,
+0xc0000000000001ffi64,
+0xc0000000000003ffi64,
+0xc0000000000007ffi64,
+0xc000000000000fffi64,
+0xc000000000001fffi64,
+0xc000000000003fffi64,
+0xc000000000007fffi64,
+0xc00000000000ffffi64,
+0xc00000000001ffffi64,
+0xc00000000003ffffi64,
+0xc00000000007ffffi64,
+0xc0000000000fffffi64,
+0xc0000000001fffffi64,
+0xc0000000003fffffi64,
+0xc0000000007fffffi64,
+0xc000000000ffffffi64,
+0xc000000001ffffffi64,
+0xc000000003ffffffi64,
+0xc000000007ffffffi64,
+0xc00000000fffffffi64,
+0xc00000001fffffffi64,
+0xc00000003fffffffi64,
+0xc00000007fffffffi64,
+0xc0000000ffffffffi64,
+0xc0000001ffffffffi64,
+0xc0000003ffffffffi64,
+0xc0000007ffffffffi64,
+0xc000000fffffffffi64,
+0xc000001fffffffffi64,
+0xc000003fffffffffi64,
+0xc000007fffffffffi64,
+0xc00000ffffffffffi64,
+0xc00001ffffffffffi64,
+0xc00003ffffffffffi64,
+0xc00007ffffffffffi64,
+0xc0000fffffffffffi64,
+0xc0001fffffffffffi64,
+0xc0003fffffffffffi64,
+0xc0007fffffffffffi64,
+0xc000ffffffffffffi64,
+0xc001ffffffffffffi64,
+0xc003ffffffffffffi64,
+0xc007ffffffffffffi64,
+0xc00fffffffffffffi64,
+0xc01fffffffffffffi64,
+0xc03fffffffffffffi64,
+0xc07fffffffffffffi64,
+0xc0ffffffffffffffi64,
+0xc1ffffffffffffffi64,
+0xc3ffffffffffffffi64,
+0xc7ffffffffffffffi64,
+0xcfffffffffffffffi64,
+0xdfffffffffffffffi64
+},
+{
+0x8000000000000000i64,
+0x8000000000000001i64,
+0x8000000000000003i64,
+0x8000000000000007i64,
+0x800000000000000fi64,
+0x800000000000001fi64,
+0x800000000000003fi64,
+0x800000000000007fi64,
+0x80000000000000ffi64,
+0x80000000000001ffi64,
+0x80000000000003ffi64,
+0x80000000000007ffi64,
+0x8000000000000fffi64,
+0x8000000000001fffi64,
+0x8000000000003fffi64,
+0x8000000000007fffi64,
+0x800000000000ffffi64,
+0x800000000001ffffi64,
+0x800000000003ffffi64,
+0x800000000007ffffi64,
+0x80000000000fffffi64,
+0x80000000001fffffi64,
+0x80000000003fffffi64,
+0x80000000007fffffi64,
+0x8000000000ffffffi64,
+0x8000000001ffffffi64,
+0x8000000003ffffffi64,
+0x8000000007ffffffi64,
+0x800000000fffffffi64,
+0x800000001fffffffi64,
+0x800000003fffffffi64,
+0x800000007fffffffi64,
+0x80000000ffffffffi64,
+0x80000001ffffffffi64,
+0x80000003ffffffffi64,
+0x80000007ffffffffi64,
+0x8000000fffffffffi64,
+0x8000001fffffffffi64,
+0x8000003fffffffffi64,
+0x8000007fffffffffi64,
+0x800000ffffffffffi64,
+0x800001ffffffffffi64,
+0x800003ffffffffffi64,
+0x800007ffffffffffi64,
+0x80000fffffffffffi64,
+0x80001fffffffffffi64,
+0x80003fffffffffffi64,
+0x80007fffffffffffi64,
+0x8000ffffffffffffi64,
+0x8001ffffffffffffi64,
+0x8003ffffffffffffi64,
+0x8007ffffffffffffi64,
+0x800fffffffffffffi64,
+0x801fffffffffffffi64,
+0x803fffffffffffffi64,
+0x807fffffffffffffi64,
+0x80ffffffffffffffi64,
+0x81ffffffffffffffi64,
+0x83ffffffffffffffi64,
+0x87ffffffffffffffi64,
+0x8fffffffffffffffi64,
+0x9fffffffffffffffi64,
+0xbfffffffffffffffi64
+},
+{
+0x0i64,
+0x1i64,
+0x3i64,
+0x7i64,
+0xfi64,
+0x1fi64,
+0x3fi64,
+0x7fi64,
+0xffi64,
+0x1ffi64,
+0x3ffi64,
+0x7ffi64,
+0xfffi64,
+0x1fffi64,
+0x3fffi64,
+0x7fffi64,
+0xffffi64,
+0x1ffffi64,
+0x3ffffi64,
+0x7ffffi64,
+0xfffffi64,
+0x1fffffi64,
+0x3fffffi64,
+0x7fffffi64,
+0xffffffi64,
+0x1ffffffi64,
+0x3ffffffi64,
+0x7ffffffi64,
+0xfffffffi64,
+0x1fffffffi64,
+0x3fffffffi64,
+0x7fffffffi64,
+0xffffffffi64,
+0x1ffffffffi64,
+0x3ffffffffi64,
+0x7ffffffffi64,
+0xfffffffffi64,
+0x1fffffffffi64,
+0x3fffffffffi64,
+0x7fffffffffi64,
+0xffffffffffi64,
+0x1ffffffffffi64,
+0x3ffffffffffi64,
+0x7ffffffffffi64,
+0xfffffffffffi64,
+0x1fffffffffffi64,
+0x3fffffffffffi64,
+0x7fffffffffffi64,
+0xffffffffffffi64,
+0x1ffffffffffffi64,
+0x3ffffffffffffi64,
+0x7ffffffffffffi64,
+0xfffffffffffffi64,
+0x1fffffffffffffi64,
+0x3fffffffffffffi64,
+0x7fffffffffffffi64,
+0xffffffffffffffi64,
+0x1ffffffffffffffi64,
+0x3ffffffffffffffi64,
+0x7ffffffffffffffi64,
+0xfffffffffffffffi64,
+0x1fffffffffffffffi64,
+0x3fffffffffffffffi64,
+0x7fffffffffffffffi64
+}
+};
+
+#endif // end of #ifndef WIN32
+
+} // namespace sc_dt
+
+#endif
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_int_base.cpp b/ext/systemc/src/sysc/datatypes/int/sc_int_base.cpp
new file mode 100644
index 000000000..fb28d44a2
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_int_base.cpp
@@ -0,0 +1,749 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_int_base.cpp -- contains interface definitions between sc_int and
+                sc_signed, sc_unsigned, and definitions for sc_int_subref.
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+    
+ *****************************************************************************/
+
+
+// $Log: sc_int_base.cpp,v $
+// Revision 1.5  2011/02/18 20:19:14  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.4  2010/02/04 22:23:29  acg
+//  Andy Goodrich: fixed bug in concatenation reads for part selections,
+//  the mask being used was 32 bits and should have been 64 bits.
+//
+// Revision 1.3  2008/06/19 17:47:56  acg
+//  Andy Goodrich: fixes for bugs. See 2.2.1 RELEASENOTES.
+//
+// Revision 1.2  2007/11/04 21:27:00  acg
+//  Andy Goodrich: changes to make sure the proper value is returned from
+//  concat_get_data().
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:49:31  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#include "sysc/kernel/sc_macros.h"
+#include "sysc/datatypes/int/sc_signed.h"
+#include "sysc/datatypes/int/sc_unsigned.h"
+#include "sysc/datatypes/int/sc_int_base.h"
+#include "sysc/datatypes/int/sc_uint_base.h"
+#include "sysc/datatypes/int/sc_signed.h"
+#include "sysc/datatypes/int/sc_int_ids.h"
+#include "sysc/datatypes/bit/sc_bv_base.h"
+#include "sysc/datatypes/bit/sc_lv_base.h"
+#include "sysc/datatypes/misc/sc_concatref.h"
+#include "sysc/datatypes/fx/sc_fix.h"
+#include "sysc/datatypes/fx/scfx_other_defs.h"
+
+
+namespace sc_dt
+{
+
+// to avoid code bloat in sc_int_concref<T1,T2>
+
+void
+sc_int_concref_invalid_length( int length )
+{
+    char msg[BUFSIZ];
+    std::sprintf( msg,
+	     "sc_int_concref<T1,T2> initialization: length = %d "
+	     "violates 1 <= length <= %d",
+	     length, SC_INTWIDTH );
+    SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_int_bitref
+//
+//  Proxy class for sc_int bit selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+sc_core::sc_vpool<sc_int_bitref> sc_int_bitref::m_pool(9);
+
+// concatenation methods:
+
+// #### OPTIMIZE
+void sc_int_bitref::concat_set(int64 src, int low_i)
+{
+    sc_int_base aa( 1 );
+    *this = aa = (low_i < 64) ? src >> low_i : src >> 63;
+}
+
+void sc_int_bitref::concat_set(const sc_signed& src, int low_i)
+{
+    sc_int_base aa( 1 );
+    if ( low_i < src.length() )
+	*this = aa = 1 & (src >> low_i);
+    else
+	*this = aa = (src < 0) ? (int_type)-1 : 0;
+}
+
+void sc_int_bitref::concat_set(const sc_unsigned& src, int low_i)
+{
+    sc_int_base aa( 1 );
+    if ( low_i < src.length() )
+	*this = aa = 1 & (src >> low_i);
+    else
+	*this = aa = 0;
+}
+
+void sc_int_bitref::concat_set(uint64 src, int low_i)
+{
+    sc_int_base aa( 1 );
+    *this = aa = (low_i < 64) ? src >> low_i : 0;
+}
+
+
+// other methods
+
+void
+sc_int_bitref::scan( ::std::istream& is )
+{
+    bool b;
+    is >> b;
+    *this = b;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_int_subref_r
+//
+//  Proxy class for sc_int part selection (l-value).
+// ----------------------------------------------------------------------------
+
+bool sc_int_subref_r::concat_get_ctrl( sc_digit* dst_p, int low_i ) const
+{    
+    int       dst_i;       // Word in dst_p now processing.
+    int       end_i;       // Highest order word in dst_p to process.
+    int       high_i;      // Index of high order bit in dst_p to set.
+    uint_type mask;        // Mask for bits to extract or keep.
+
+    dst_i = low_i / BITS_PER_DIGIT;
+    high_i = low_i + (m_left-m_right);
+    end_i = high_i / BITS_PER_DIGIT;
+    mask = ~mask_int[m_left][m_right];
+
+
+    // PROCESS THE FIRST WORD:
+
+    dst_p[dst_i] = (sc_digit)(dst_p[dst_i] & mask);
+    switch ( end_i - dst_i )
+    {
+     // BITS ARE ACROSS TWO WORDS:
+
+     case 1:
+        dst_i++;
+        dst_p[dst_i] = 0;
+        break;
+
+     // BITS ARE ACROSS THREE WORDS:
+
+     case 2:
+        dst_i++;
+        dst_p[dst_i++] = 0;
+        dst_p[dst_i] = 0;
+        break;
+
+     // BITS ARE ACROSS FOUR WORDS:
+
+     case 3:
+        dst_i++;
+        dst_p[dst_i++] = 0;
+        dst_p[dst_i++] = 0;
+        dst_p[dst_i] = 0;
+        break;
+    }
+    return false;
+}
+
+
+bool sc_int_subref_r::concat_get_data( sc_digit* dst_p, int low_i ) const
+{    
+    int       dst_i;      // Word in dst_p now processing.
+    int       end_i;      // Highest order word in dst_p to process.
+    int       high_i;     // Index of high order bit in dst_p to set.
+    int       left_shift; // Left shift for val.
+    uint_type mask;       // Mask for bits to extract or keep.
+    bool      non_zero;	  // True if value inserted is non-zero.
+    uint_type val;        // Selection value extracted from m_obj_p.
+
+    dst_i = low_i / BITS_PER_DIGIT;
+    left_shift = low_i % BITS_PER_DIGIT;
+    high_i = low_i + (m_left-m_right);
+    end_i = high_i / BITS_PER_DIGIT;
+    mask = ~mask_int[m_left][m_right];
+    val = (m_obj_p->m_val & mask) >> m_right;
+    non_zero = val != 0;
+
+
+    // PROCESS THE FIRST WORD:
+
+    mask = ~(-1 << left_shift);
+    dst_p[dst_i] = (sc_digit)((dst_p[dst_i] & mask) | 
+		((val << left_shift) & DIGIT_MASK));
+
+    switch ( end_i - dst_i )
+    {
+     // BITS ARE ACROSS TWO WORDS:
+
+     case 1:
+        dst_i++;
+        val >>= (BITS_PER_DIGIT-left_shift);
+        dst_p[dst_i] = (sc_digit)(val & DIGIT_MASK);
+        break;
+
+     // BITS ARE ACROSS THREE WORDS:
+
+     case 2:
+        dst_i++;
+        val >>= (BITS_PER_DIGIT-left_shift);
+        dst_p[dst_i++] = (sc_digit)(val & DIGIT_MASK);
+        val >>= BITS_PER_DIGIT;
+        dst_p[dst_i] = (sc_digit)val;
+        break;
+
+     // BITS ARE ACROSS FOUR WORDS:
+
+     case 3:
+        dst_i++;
+        val >>= (BITS_PER_DIGIT-left_shift);
+        dst_p[dst_i++] = (sc_digit)(val & DIGIT_MASK);
+        val >>= BITS_PER_DIGIT;
+        dst_p[dst_i++] = (sc_digit)(val & DIGIT_MASK);
+        val >>= BITS_PER_DIGIT;
+        dst_p[dst_i] = (sc_digit)val;
+        break;
+    }
+    return non_zero;
+}
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_int_subref
+//
+//  Proxy class for sc_int part selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+sc_core::sc_vpool<sc_int_subref> sc_int_subref::m_pool(9);
+
+// assignment operators
+  
+sc_int_subref& 
+sc_int_subref::operator = ( int_type v )
+{
+    int_type val = m_obj_p->m_val;
+    uint_type mask = mask_int[m_left][m_right];
+    val &= mask;
+    val |= (v << m_right) & ~mask;
+    m_obj_p->m_val = val;
+    m_obj_p->extend_sign();
+    return *this;
+}
+
+sc_int_subref&
+sc_int_subref::operator = ( const sc_signed& a )
+{
+    sc_int_base aa( length() );
+    return ( *this = aa = a );
+}
+
+sc_int_subref&
+sc_int_subref::operator = ( const sc_unsigned& a )
+{
+    sc_int_base aa( length() );
+    return ( *this = aa = a );
+}
+
+sc_int_subref&
+sc_int_subref::operator = ( const sc_bv_base& a )
+{
+    sc_int_base aa( length() );
+    return ( *this = aa = a );
+}
+
+sc_int_subref&
+sc_int_subref::operator = ( const sc_lv_base& a )
+{
+    sc_int_base aa( length() );
+    return ( *this = aa = a );
+}
+
+
+// concatenation methods:
+
+// #### OPTIMIZE
+void sc_int_subref::concat_set(int64 src, int low_i)
+{
+    sc_int_base aa ( length() );
+    *this = aa = (low_i < 64) ? src >> low_i : src >> 63;
+}
+
+void sc_int_subref::concat_set(const sc_signed& src, int low_i)
+{
+    sc_int_base aa( length() );
+    if ( low_i < src.length() )
+	*this = aa = src >> low_i;
+    else
+	*this = (src < 0) ? (int_type)-1 : 0;
+}
+
+void sc_int_subref::concat_set(const sc_unsigned& src, int low_i)
+{
+    sc_int_base aa( length() );
+    if ( low_i < src.length() )
+	*this = aa = src >> low_i;
+    else
+	*this = 0;
+}
+
+void sc_int_subref::concat_set(uint64 src, int low_i)
+{
+    sc_int_base aa ( length() );
+    *this = aa = (low_i < 64) ? src >> low_i : 0;
+}
+
+
+// other methods
+
+void
+sc_int_subref::scan( ::std::istream& is )
+{
+    std::string s;
+    is >> s;
+    *this = s.c_str();
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_int_base
+//
+//  Base class for sc_int.
+// ----------------------------------------------------------------------------
+
+// support methods
+
+void
+sc_int_base::invalid_length() const
+{
+    char msg[BUFSIZ];
+    std::sprintf( msg,
+	     "sc_int[_base] initialization: length = %d violates "
+	     "1 <= length <= %d",
+	     m_len, SC_INTWIDTH );
+    SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
+}
+
+void
+sc_int_base::invalid_index( int i ) const
+{
+    char msg[BUFSIZ];
+    std::sprintf( msg,
+	     "sc_int[_base] bit selection: index = %d violates "
+	     "0 <= index <= %d",
+	     i, m_len - 1 );
+    SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
+}
+
+void
+sc_int_base::invalid_range( int l, int r ) const
+{
+    char msg[BUFSIZ];
+    std::sprintf( msg,
+	     "sc_int[_base] part selection: left = %d, right = %d violates "
+	     "%d >= left >= right >= 0",
+	     l, r, m_len - 1 );
+    SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
+}
+
+
+void
+sc_int_base::check_value() const
+{
+    int_type limit = (int_type) 1 << ( m_len - 1 );
+    if( m_val < -limit || m_val >= limit ) {
+	char msg[BUFSIZ];
+	std::sprintf( msg, "sc_int[_base]: value does not fit into a length of %d",
+		 m_len );
+	SC_REPORT_WARNING( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
+    }
+}
+
+
+// constructors
+sc_int_base::sc_int_base( const sc_bv_base& v ) 
+    : m_val(0), m_len( v.length() ), m_ulen( SC_INTWIDTH - m_len )
+{
+    check_length();
+    *this = v;
+}
+sc_int_base::sc_int_base( const sc_lv_base& v )
+    : m_val(0), m_len( v.length() ), m_ulen( SC_INTWIDTH - m_len )
+{
+    check_length();
+    *this = v;
+}
+sc_int_base::sc_int_base( const sc_uint_subref_r& v )
+    : m_val(0), m_len( v.length() ), m_ulen( SC_INTWIDTH - m_len )
+{
+    check_length();
+    *this = v.to_uint64();
+}
+sc_int_base::sc_int_base( const sc_signed_subref_r& v )
+    : m_val(0), m_len( v.length() ), m_ulen( SC_INTWIDTH - m_len )
+{
+    check_length();
+    *this = v.to_uint64();
+}
+sc_int_base::sc_int_base( const sc_unsigned_subref_r& v )
+    : m_val(0), m_len( v.length() ), m_ulen( SC_INTWIDTH - m_len )
+{
+    check_length();
+    *this = v.to_uint64();
+}
+
+sc_int_base::sc_int_base( const sc_signed& a )
+    : m_val( 0 ), m_len( a.length() ), m_ulen( SC_INTWIDTH - m_len )
+{
+    check_length();
+#if 0
+    for( int i = m_len - 1; i >= 0; -- i ) {
+	set( i, a.test( i ) );
+    }
+    extend_sign();
+#else
+    *this = a.to_int64();
+#endif
+}
+
+sc_int_base::sc_int_base( const sc_unsigned& a )
+    : m_val( 0 ), m_len( a.length() ), m_ulen( SC_INTWIDTH - m_len )
+{
+    check_length();
+#if 0
+    for( int i = m_len - 1; i >= 0; -- i ) {
+	set( i, a.test( i ) );
+    }
+    extend_sign();
+#else
+    *this = a.to_int64();
+#endif
+}
+
+
+// assignment operators
+
+sc_int_base& 
+sc_int_base::operator = ( const sc_signed& a )
+{
+    int minlen = sc_min( m_len, a.length() );
+    int i = 0;
+    for( ; i < minlen; ++ i ) {
+	set( i, a.test( i ) );
+    }
+    bool sgn = a.sign();
+    for( ; i < m_len; ++ i ) {
+	// sign extension
+	set( i, sgn );
+    }
+    extend_sign();
+    return *this;
+}
+
+sc_int_base& 
+sc_int_base::operator = ( const sc_unsigned& a )
+{
+    int minlen = sc_min( m_len, a.length() );
+    int i = 0;
+    for( ; i < minlen; ++ i ) {
+	set( i, a.test( i ) );
+    }
+    for( ; i < m_len; ++ i ) {
+	// zero extension
+	set( i, 0 );
+    }
+    extend_sign();
+    return *this;
+}
+
+
+sc_int_base&
+sc_int_base::operator = ( const sc_bv_base& a )
+{
+    int minlen = sc_min( m_len, a.length() );
+    int i = 0;
+    for( ; i < minlen; ++ i ) {
+	set( i, a.get_bit( i ) );
+    }
+    for( ; i < m_len; ++ i ) {
+	// zero extension
+	set( i, 0 );
+    }
+    extend_sign();
+    return *this;
+}
+
+sc_int_base&
+sc_int_base::operator = ( const sc_lv_base& a )
+{
+    int minlen = sc_min( m_len, a.length() );
+    int i = 0;
+    for( ; i < minlen; ++ i ) {
+	set( i, sc_logic( a.get_bit( i ) ).to_bool() );
+    }
+    for( ; i < m_len; ++ i ) {
+	// zero extension
+	set( i, 0 );
+    }
+    extend_sign();
+    return *this;
+}
+
+sc_int_base&
+sc_int_base::operator = ( const char* a )
+{
+    if( a == 0 ) {
+	SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_,
+			 "character string is zero" );
+    }
+    if( *a == 0 ) {
+	SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_,
+			 "character string is empty" );
+    }
+    try {
+	int len = m_len;
+	sc_fix aa( a, len, len, SC_TRN, SC_WRAP, 0, SC_ON );
+	return this->operator = ( aa );
+    } catch( sc_core::sc_report ) {
+	char msg[BUFSIZ];
+	std::sprintf( msg, "character string '%s' is not valid", a );
+	SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_, msg );
+	// never reached
+	return *this;
+    }
+}
+
+// explicit conversion to character string
+
+const std::string
+sc_int_base::to_string( sc_numrep numrep ) const
+{
+    int len = m_len;
+    sc_fix aa( *this, len, len, SC_TRN, SC_WRAP, 0, SC_ON );
+    return aa.to_string( numrep );
+}
+
+const std::string
+sc_int_base::to_string( sc_numrep numrep, bool w_prefix ) const
+{
+    int len = m_len;
+    sc_fix aa( *this, len, len, SC_TRN, SC_WRAP, 0, SC_ON );
+    return aa.to_string( numrep, w_prefix );
+}
+
+
+// reduce methods
+
+bool
+sc_int_base::and_reduce() const
+{
+    return ( m_val == int_type( -1 ) );
+}
+
+bool
+sc_int_base::or_reduce() const
+{
+    return ( m_val != int_type( 0 ) );
+}
+
+bool
+sc_int_base::xor_reduce() const
+{
+    uint_type mask = ~UINT_ZERO;
+    uint_type val = m_val & (mask >> m_ulen);
+    int n = SC_INTWIDTH;
+    do {
+	n >>= 1;
+	mask >>= n;
+	val = ((val & (mask << n)) >> n) ^ (val & mask);
+    } while( n != 1 );
+    return ( val != uint_type( 0 ) );
+}
+
+
+bool sc_int_base::concat_get_ctrl( sc_digit* dst_p, int low_i ) const
+{    
+    int        dst_i;       // Word in dst_p now processing.
+    int        end_i;       // Highest order word in dst_p to process.
+    int        left_shift;  // Left shift for val.
+    uint_type  mask;        // Mask for bits to extract or keep.
+
+    dst_i = low_i / BITS_PER_DIGIT;
+    left_shift = low_i % BITS_PER_DIGIT;
+    end_i = (low_i + (m_len-1)) / BITS_PER_DIGIT;
+
+    mask = ~(-1 << left_shift);
+    dst_p[dst_i] = (sc_digit)(dst_p[dst_i] & mask);
+	dst_i++;
+	for ( ; dst_i <= end_i; dst_i++ ) dst_p[dst_i] = 0;
+	return false;
+}
+
+//------------------------------------------------------------------------------
+//"sc_int_base::concat_get_data"
+//
+// This method transfers the value of this object instance to the supplied
+// array of sc_unsigned digits starting with the bit specified by low_i within
+// the array of digits.
+//
+// Notes:
+//   (1) we don't worry about masking the high order data we transfer since
+//       concat_get_data() is called from low order bit to high order bit. So
+//       the bits above where we place ours will be filled in by someone else.
+//
+//   dst_p -> array of sc_unsigned digits to be filled in.
+//   low_i =  first bit within dst_p to be set.
+//------------------------------------------------------------------------------
+bool sc_int_base::concat_get_data( sc_digit* dst_p, int low_i ) const
+{    
+    int        dst_i;       // Word in dst_p now processing.
+    int        end_i;       // Highest order word in dst_p to process.
+    int        high_i;      // Index of high order bit in dst_p to set.
+    int        left_shift;  // Left shift for val.
+    uint_type  mask;        // Mask for bits to extract or keep.
+    bool       non_zero;    // True if value inserted is non-zero.
+    uint_type  val;         // Value for this object.
+
+    dst_i = low_i / BITS_PER_DIGIT;
+    left_shift = low_i % BITS_PER_DIGIT;
+    high_i = low_i + (m_len-1);
+    end_i = high_i / BITS_PER_DIGIT;
+    val = m_val;
+    non_zero = val != 0;
+
+    // MASK OFF DATA TO BE TRANSFERRED BASED ON WIDTH:
+
+    if ( m_len < 64 )
+    {
+	mask = ~((uint_type)-1 << m_len);
+        val &=  mask;
+    }
+
+    // PROCESS THE FIRST WORD:
+
+    mask = (-1 << left_shift);
+    dst_p[dst_i] = (sc_digit)((dst_p[dst_i] & ~mask) | 
+		((val <<left_shift) & DIGIT_MASK));
+    switch ( end_i - dst_i )
+    {
+     // BITS ARE ACROSS TWO WORDS:
+
+     case 1:
+	dst_i++;
+	val >>= (BITS_PER_DIGIT-left_shift);
+	dst_p[dst_i] = (sc_digit)val;
+	break;
+
+     // BITS ARE ACROSS THREE WORDS:
+
+     case 2:
+	dst_i++;
+	val >>= (BITS_PER_DIGIT-left_shift);
+	dst_p[dst_i++] = ((sc_digit)val) & DIGIT_MASK;
+	val >>= BITS_PER_DIGIT;
+	dst_p[dst_i] = (sc_digit)val;
+	break;
+
+     // BITS ARE ACROSS FOUR WORDS:
+
+     case 3:
+	dst_i++;
+	val >>= (BITS_PER_DIGIT-left_shift);
+	dst_p[dst_i++] = (sc_digit)(val & DIGIT_MASK);
+	val >>= BITS_PER_DIGIT;
+	dst_p[dst_i++] = (sc_digit)(val & DIGIT_MASK);
+	val >>= BITS_PER_DIGIT;
+	dst_p[dst_i] = (sc_digit)val;
+	break;
+    }
+    return non_zero;
+}
+
+// #### OPTIMIZE
+void sc_int_base::concat_set(int64 src, int low_i)
+{
+    *this = (low_i < 64) ? src >> low_i : src >> 63;
+}
+
+void sc_int_base::concat_set(const sc_signed& src, int low_i)
+{
+    if ( low_i < src.length() )
+	*this = src >> low_i;
+    else
+        *this = (src < 0) ? (int_type)-1 : 0;
+}
+
+void sc_int_base::concat_set(const sc_unsigned& src, int low_i)
+{
+    if ( low_i < src.length() )
+	*this = src >> low_i;
+    else
+        *this = 0;
+}
+
+void sc_int_base::concat_set(uint64 src, int low_i)
+{
+    *this = (low_i < 64) ? src >> low_i : 0;
+}
+
+// other methods
+
+void
+sc_int_base::scan( ::std::istream& is )
+{
+    std::string s;
+    is >> s;
+    *this = s.c_str();
+}
+
+} // namespace sc_dt;
+
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_int_base.h b/ext/systemc/src/sysc/datatypes/int/sc_int_base.h
new file mode 100644
index 000000000..a9b8a6457
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_int_base.h
@@ -0,0 +1,1382 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_int_base.h -- A sc_int is a signed integer whose length is less than the
+              machine's native integer length. We provide two implementations
+              (i) sc_int with length between 1 - 64, and (ii) sc_int with
+              length between 1 - 32. Implementation (i) is the default
+              implementation, while implementation (ii) can be used only if
+              the class library is compiled with -D_32BIT_. Unlike arbitrary
+              precision, arithmetic and bitwise operations are performed
+              using the native types (hence capped at 32/64 bits). The sc_int
+              integer is useful when the user does not need arbitrary
+              precision and the performance is superior to
+              sc_bigint/sc_biguint.
+
+  Original Author: Amit Rao, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Ali Dasdan, Synopsys, Inc.
+  Description of Modification: - Resolved ambiguity with sc_(un)signed.
+                               - Merged the code for 64- and 32-bit versions
+                                 via the constants in sc_nbdefs.h.
+                               - Eliminated redundant file inclusions.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_int_base.h,v $
+// Revision 1.3  2011/08/24 22:05:45  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.2  2011/02/18 20:19:15  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.4  2006/05/08 17:50:01  acg
+//   Andy Goodrich: Added David Long's declarations for friend operators,
+//   functions, and methods, to keep the Microsoft compiler happy.
+//
+// Revision 1.3  2006/01/13 18:49:31  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#ifndef SC_INT_BASE_H
+#define SC_INT_BASE_H
+
+#include "sysc/kernel/sc_object.h"
+#include "sysc/datatypes/misc/sc_value_base.h"
+#include "sysc/datatypes/int/sc_int_ids.h"
+#include "sysc/datatypes/int/sc_length_param.h"
+#include "sysc/datatypes/int/sc_nbdefs.h"
+#include "sysc/datatypes/int/sc_uint_base.h"
+#include "sysc/utils/sc_iostream.h"
+#include "sysc/utils/sc_temporary.h"
+
+
+namespace sc_dt
+{
+
+class sc_concatref;
+
+// classes defined in this module
+class sc_int_bitref_r;
+class sc_int_bitref;
+class sc_int_subref_r;
+class sc_int_subref;
+class sc_int_base;
+class sc_signed_subref_r;
+class sc_unsigned_subref_r;
+
+// forward class declarations
+class sc_bv_base;
+class sc_lv_base;
+class sc_signed;
+class sc_unsigned;
+class sc_fxval;
+class sc_fxval_fast;
+class sc_fxnum;
+class sc_fxnum_fast;
+
+
+extern const uint_type mask_int[SC_INTWIDTH][SC_INTWIDTH];
+
+// friend operator declarations
+    // relational operators
+
+    inline bool operator == ( const sc_int_base& a, const sc_int_base& b );
+
+    inline bool operator != ( const sc_int_base& a, const sc_int_base& b );
+
+    inline bool operator <  ( const sc_int_base& a, const sc_int_base& b );
+
+    inline bool operator <= ( const sc_int_base& a, const sc_int_base& b );
+
+    inline bool operator >  ( const sc_int_base& a, const sc_int_base& b );
+
+    inline bool operator >= ( const sc_int_base& a, const sc_int_base& b );
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_int_bitref_r
+//
+//  Proxy class for sc_int bit selection (r-value only).
+// ----------------------------------------------------------------------------
+
+class sc_int_bitref_r : public sc_value_base
+{
+    friend class sc_int_base;
+
+protected:
+
+    // constructor
+
+    sc_int_bitref_r() : sc_value_base(), m_index(), m_obj_p()
+        {}
+
+    // initializer for sc_core::sc_vpool:
+
+    void initialize( const sc_int_base* obj_p, int index_ )
+    {
+	m_obj_p = (sc_int_base*)obj_p;
+	m_index = index_;
+    }
+
+public:
+
+    // copy constructor
+
+    sc_int_bitref_r( const sc_int_bitref_r& a ) :
+        sc_value_base(a), m_index(a.m_index), m_obj_p(a.m_obj_p)
+        {}
+
+    // destructor
+
+    virtual ~sc_int_bitref_r()
+	{}
+
+    // capacity
+
+    int length() const
+	{ return 1; }
+
+#ifdef SC_DT_DEPRECATED
+    int bitwidth() const
+	{ return length(); }
+#endif
+
+    // concatenation support
+
+    virtual int concat_length( bool *xz_present_p ) const
+	{ if (xz_present_p) *xz_present_p = false; return 1; }
+    virtual bool concat_get_ctrl( sc_digit* dst_p, int low_i ) const
+        {
+	    int bit_mask = 1 << (low_i % BITS_PER_DIGIT);
+	    int word_i = low_i / BITS_PER_DIGIT;
+
+	    dst_p[word_i] &= ~bit_mask;
+	    return false;
+	}
+    virtual bool concat_get_data( sc_digit* dst_p, int low_i ) const
+        {
+	    bool non_zero;
+	    int bit_mask = 1 << (low_i % BITS_PER_DIGIT);
+	    int word_i = low_i / BITS_PER_DIGIT;
+
+	    if ( operator uint64() )
+	    {
+		dst_p[word_i] |= bit_mask;
+		non_zero = true;
+	    }
+	    else
+	    {
+		dst_p[word_i] &= ~bit_mask;
+		non_zero = false;
+	    }
+	    return non_zero;
+	}
+    virtual uint64 concat_get_uint64() const
+	{ return operator uint64(); }
+
+
+
+
+    // implicit conversions
+
+    operator uint64 () const;
+    bool operator ! () const;
+    bool operator ~ () const;
+
+
+    // explicit conversions
+
+    uint64 value() const
+	{ return operator uint64(); }
+
+    bool to_bool() const
+	{ return operator uint64(); }
+
+
+    // other methods
+
+    void print( ::std::ostream& os = ::std::cout ) const
+	{ os << to_bool(); }
+
+protected:
+    int          m_index;
+    sc_int_base* m_obj_p;
+
+private:
+
+    // disabled
+    sc_int_bitref_r& operator = ( const sc_int_bitref_r& );
+};
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream&, const sc_int_bitref_r& );
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_int_bitref
+//
+//  Proxy class for sc_int bit selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+class sc_int_bitref
+    : public sc_int_bitref_r
+{
+    friend class sc_int_base;
+    friend class sc_core::sc_vpool<sc_int_bitref>;
+
+
+    // constructor
+
+    sc_int_bitref() : sc_int_bitref_r()
+      {}
+
+
+public:
+
+    // copy constructor
+
+    sc_int_bitref( const sc_int_bitref& a ) : sc_int_bitref_r( a )
+      {}
+
+    // assignment operators
+
+    sc_int_bitref& operator = ( const sc_int_bitref_r& b );
+    sc_int_bitref& operator = ( const sc_int_bitref& b );
+    sc_int_bitref& operator = ( bool b );
+
+    sc_int_bitref& operator &= ( bool b );
+    sc_int_bitref& operator |= ( bool b );
+    sc_int_bitref& operator ^= ( bool b );
+
+	// concatenation methods
+
+    virtual void concat_set(int64 src, int low_i);
+    virtual void concat_set(const sc_signed& src, int low_i);
+    virtual void concat_set(const sc_unsigned& src, int low_i);
+    virtual void concat_set(uint64 src, int low_i);
+
+
+    // other methods
+
+    void scan( ::std::istream& is = ::std::cin );
+
+public:
+    static sc_core::sc_vpool<sc_int_bitref> m_pool;
+
+};
+
+
+
+inline
+::std::istream&
+operator >> ( ::std::istream&, sc_int_bitref& );
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_int_subref_r
+//
+//  Proxy class for sc_int part selection (r-value only).
+// ----------------------------------------------------------------------------
+
+class sc_int_subref_r : public sc_value_base
+{
+    friend class sc_int_base;
+    friend class sc_int_signal;
+    friend class sc_int_subref;
+
+protected:
+
+    // constructor
+
+    sc_int_subref_r() : sc_value_base(), m_left(0), m_obj_p(0), m_right(0)
+        {}
+
+    // initializer for sc_core::sc_vpool:
+
+    void initialize( const sc_int_base* obj_p, int left_i, int right_i )
+    {
+	m_obj_p = (sc_int_base*)obj_p;
+	m_left = left_i;
+	m_right = right_i;
+    }
+
+
+public:
+    // copy constructor
+
+    sc_int_subref_r( const sc_int_subref_r& a ) :
+        sc_value_base(a), m_left( a.m_left ), m_obj_p( a.m_obj_p ), 
+	m_right( a.m_right )
+        {}
+
+    // destructor
+
+    virtual ~sc_int_subref_r()
+	{}
+
+    // capacity
+
+    int length() const
+        { return ( m_left - m_right + 1 ); }
+
+#ifdef SC_DT_DEPRECATED
+    int bitwidth() const
+	{ return length(); }
+#endif
+
+    // concatenation support
+
+    virtual int concat_length(bool* xz_present_p) const
+	{ if ( xz_present_p ) *xz_present_p = false; return length(); }
+    virtual bool concat_get_ctrl( sc_digit* dst_p, int low_i ) const;
+    virtual bool concat_get_data( sc_digit* dst_p, int low_i ) const;
+    virtual uint64 concat_get_uint64() const
+    {
+	int    len = length();
+	uint64 val = operator uint_type();
+	if ( len < 64 )
+	    return (uint64)(val & ~((uint_type)-1 << len));
+	else
+	    return (uint64)val;
+    }
+
+    // reduce methods
+
+    bool and_reduce() const;
+
+    bool nand_reduce() const
+	{ return ( ! and_reduce() ); }
+
+    bool or_reduce() const;
+
+    bool nor_reduce() const
+	{ return ( ! or_reduce() ); }
+
+    bool xor_reduce() const;
+
+    bool xnor_reduce() const
+	{ return ( ! xor_reduce() ); }
+
+
+    // implicit conversion to uint_type
+
+    operator uint_type () const;
+
+
+    // explicit conversions
+
+    uint_type value() const
+	{ return operator uint_type(); }
+
+
+    int           to_int() const;
+    unsigned int  to_uint() const;
+    long          to_long() const;
+    unsigned long to_ulong() const;
+    int64         to_int64() const;
+    uint64        to_uint64() const;
+    double        to_double() const;
+
+
+    // explicit conversion to character string
+
+    const std::string to_string( sc_numrep numrep = SC_DEC ) const;
+    const std::string to_string( sc_numrep numrep, bool w_prefix ) const;
+
+
+    // other methods
+
+    void print( ::std::ostream& os = ::std::cout ) const
+	{ os << to_string(sc_io_base(os,SC_DEC),sc_io_show_base(os)); }
+
+protected:
+
+    int          m_left;
+    sc_int_base* m_obj_p;
+    int          m_right;
+
+private:
+    const sc_int_subref_r& operator = ( const sc_int_subref_r& );
+};
+
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream&, const sc_int_subref_r& );
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_int_subref
+//
+//  Proxy class for sc_int part selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+class sc_int_subref
+    : public sc_int_subref_r
+{
+    friend class sc_int_base;
+    friend class sc_core::sc_vpool<sc_int_subref>;
+
+
+protected:
+
+    // constructor
+    sc_int_subref() : sc_int_subref_r()
+        {}
+
+public:
+
+    // copy constructor
+
+    sc_int_subref( const sc_int_subref& a ) : sc_int_subref_r( a )
+        {}
+
+    // assignment operators
+
+    sc_int_subref& operator = ( int_type v );
+    sc_int_subref& operator = ( const sc_int_base& a );
+
+    sc_int_subref& operator = ( const sc_int_subref_r& a )
+	{ return operator = ( a.operator uint_type() ); }
+
+    sc_int_subref& operator = ( const sc_int_subref& a )
+	{ return operator = ( a.operator uint_type() ); }
+
+    template< class T >
+    sc_int_subref& operator = ( const sc_generic_base<T>& a )
+        { return operator = ( a->to_int64() ); }
+
+    sc_int_subref& operator = ( const char* a );
+
+    sc_int_subref& operator = ( unsigned long a )
+	{ return operator = ( (int_type) a ); }
+
+    sc_int_subref& operator = ( long a )
+	{ return operator = ( (int_type) a ); }
+
+    sc_int_subref& operator = ( unsigned int a )
+	{ return operator = ( (int_type) a ); }
+
+    sc_int_subref& operator = ( int a )
+	{ return operator = ( (int_type) a ); }
+
+    sc_int_subref& operator = ( uint64 a )
+	{ return operator = ( (int_type) a ); }
+
+    sc_int_subref& operator = ( double a )
+	{ return operator = ( (int_type) a ); }
+
+    sc_int_subref& operator = ( const sc_signed& );
+    sc_int_subref& operator = ( const sc_unsigned& );
+    sc_int_subref& operator = ( const sc_bv_base& );
+    sc_int_subref& operator = ( const sc_lv_base& );
+
+	// concatenation methods
+
+    virtual void concat_set(int64 src, int low_i);
+    virtual void concat_set(const sc_signed& src, int low_i);
+    virtual void concat_set(const sc_unsigned& src, int low_i);
+    virtual void concat_set(uint64 src, int low_i);
+
+    // other methods
+
+    void scan( ::std::istream& is = ::std::cin );
+
+public:
+    static sc_core::sc_vpool<sc_int_subref> m_pool;
+
+};
+
+
+
+inline
+::std::istream&
+operator >> ( ::std::istream&, sc_int_subref& );
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_int_base
+//
+//  Base class for sc_int.
+// ----------------------------------------------------------------------------
+
+class sc_int_base : public sc_value_base
+{
+    friend class sc_int_bitref_r;
+    friend class sc_int_bitref;
+    friend class sc_int_subref_r;
+    friend class sc_int_subref;
+
+
+    // support methods
+
+    void invalid_length() const;
+    void invalid_index( int i ) const;
+    void invalid_range( int l, int r ) const;
+
+    void check_length() const
+	{ if( m_len <= 0 || m_len > SC_INTWIDTH ) { invalid_length(); } }
+
+    void check_index( int i ) const
+	{ if( i < 0 || i >= m_len ) { invalid_index( i ); } }
+
+    void check_range( int l, int r ) const
+	{ if( r < 0 || l >= m_len || l < r ) { invalid_range( l, r ); } }
+
+    void check_value() const;
+
+    void extend_sign()
+	{
+#ifdef DEBUG_SYSTEMC
+	    check_value();
+#endif
+	    m_val = ( m_val << m_ulen >> m_ulen );
+	}
+
+public:
+
+    // constructors
+
+    explicit sc_int_base( int w = sc_length_param().len() )
+	: m_val( 0 ), m_len( w ), m_ulen( SC_INTWIDTH - m_len )
+	{ check_length(); }
+
+    sc_int_base( int_type v, int w )
+	: m_val( v ), m_len( w ), m_ulen( SC_INTWIDTH - m_len )
+	{ check_length(); extend_sign(); }
+
+    sc_int_base( const sc_int_base& a )
+	: sc_value_base(a), m_val( a.m_val ), m_len( a.m_len ), 
+	  m_ulen( a.m_ulen )
+	{}
+
+    explicit sc_int_base( const sc_int_subref_r& a )
+        : m_val( a ), m_len( a.length() ), m_ulen( SC_INTWIDTH - m_len )
+        { extend_sign(); }
+
+    template< class T >
+    explicit sc_int_base( const sc_generic_base<T>& a ) :
+        m_val( a->to_int64() ), m_len( a->length() ),
+	m_ulen( SC_INTWIDTH - m_len )
+	{ check_length(); extend_sign(); }
+
+    explicit sc_int_base( const sc_signed& a );
+    explicit sc_int_base( const sc_unsigned& a );
+    explicit sc_int_base( const sc_bv_base& v );
+    explicit sc_int_base( const sc_lv_base& v );
+    explicit sc_int_base( const sc_uint_subref_r& v );
+    explicit sc_int_base( const sc_signed_subref_r& v );
+    explicit sc_int_base( const sc_unsigned_subref_r& v );
+
+
+
+    // destructor
+
+    virtual ~sc_int_base()
+	{}
+
+    // assignment operators
+
+    sc_int_base& operator = ( int_type v )
+	{ m_val = v; extend_sign(); return *this; }
+
+    sc_int_base& operator = ( const sc_int_base& a )
+	{ m_val = a.m_val; extend_sign(); return *this; }
+
+    sc_int_base& operator = ( const sc_int_subref_r& a )
+        { m_val = a; extend_sign(); return *this; }
+
+    template<class T>
+    sc_int_base& operator = ( const sc_generic_base<T>& a )
+        { m_val = a->to_int64(); extend_sign(); return *this; }
+
+    sc_int_base& operator = ( const sc_signed& a );
+    sc_int_base& operator = ( const sc_unsigned& a );
+
+#ifdef SC_INCLUDE_FX
+    sc_int_base& operator = ( const sc_fxval& a );
+    sc_int_base& operator = ( const sc_fxval_fast& a );
+    sc_int_base& operator = ( const sc_fxnum& a );
+    sc_int_base& operator = ( const sc_fxnum_fast& a );
+#endif
+
+    sc_int_base& operator = ( const sc_bv_base& a );
+    sc_int_base& operator = ( const sc_lv_base& a );
+
+    sc_int_base& operator = ( const char* a );
+
+    sc_int_base& operator = ( unsigned long a )
+	{ m_val = a; extend_sign(); return *this; }
+
+    sc_int_base& operator = ( long a )
+	{ m_val = a; extend_sign(); return *this; }
+
+    sc_int_base& operator = ( unsigned int a )
+	{ m_val = a; extend_sign(); return *this; }
+
+    sc_int_base& operator = ( int a )
+	{ m_val = a; extend_sign(); return *this; }
+
+    sc_int_base& operator = ( uint64 a )
+	{ m_val = a; extend_sign(); return *this; }
+
+    sc_int_base& operator = ( double a )
+	{ m_val = (int_type) a; extend_sign(); return *this; }
+
+
+    // arithmetic assignment operators
+
+    sc_int_base& operator += ( int_type v )
+	{ m_val += v; extend_sign(); return *this; }
+
+    sc_int_base& operator -= ( int_type v )
+	{ m_val -= v; extend_sign(); return *this; }
+
+    sc_int_base& operator *= ( int_type v )
+	{ m_val *= v; extend_sign(); return *this; }
+
+    sc_int_base& operator /= ( int_type v )
+	{ m_val /= v; extend_sign(); return *this; }
+
+    sc_int_base& operator %= ( int_type v )
+	{ m_val %= v; extend_sign(); return *this; }
+
+
+    // bitwise assignment operators
+
+    sc_int_base& operator &= ( int_type v )
+	{ m_val &= v; extend_sign(); return *this; }
+
+    sc_int_base& operator |= ( int_type v )
+	{ m_val |= v; extend_sign(); return *this; }
+
+    sc_int_base& operator ^= ( int_type v )
+	{ m_val ^= v; extend_sign(); return *this; }
+
+
+    sc_int_base& operator <<= ( int_type v )
+	{ m_val <<= v; extend_sign(); return *this; }
+
+    sc_int_base& operator >>= ( int_type v )
+	{ m_val >>= v; /* no sign extension needed */ return *this; }
+
+
+    // prefix and postfix increment and decrement operators
+
+    sc_int_base& operator ++ () // prefix
+	{ ++ m_val; extend_sign(); return *this; }
+
+    const sc_int_base operator ++ ( int ) // postfix
+	{ sc_int_base tmp( *this ); ++ m_val; extend_sign(); return tmp; }
+
+    sc_int_base& operator -- () // prefix
+	{ -- m_val; extend_sign(); return *this; }
+
+    const sc_int_base operator -- ( int ) // postfix
+	{ sc_int_base tmp( *this ); -- m_val; extend_sign(); return tmp; }
+
+
+    // relational operators
+
+    friend bool operator == ( const sc_int_base& a, const sc_int_base& b )
+	{ return a.m_val == b.m_val; }
+
+    friend bool operator != ( const sc_int_base& a, const sc_int_base& b )
+	{ return a.m_val != b.m_val; }
+
+    friend bool operator <  ( const sc_int_base& a, const sc_int_base& b )
+	{ return a.m_val < b.m_val; }
+
+    friend bool operator <= ( const sc_int_base& a, const sc_int_base& b )
+	{ return a.m_val <= b.m_val; }
+
+    friend bool operator >  ( const sc_int_base& a, const sc_int_base& b )
+	{ return a.m_val > b.m_val; }
+
+    friend bool operator >= ( const sc_int_base& a, const sc_int_base& b )
+	{ return a.m_val >= b.m_val; }
+
+
+    // bit selection
+
+    sc_int_bitref&         operator [] ( int i );
+    const sc_int_bitref_r& operator [] ( int i ) const;
+
+    sc_int_bitref&         bit( int i );
+    const sc_int_bitref_r& bit( int i ) const;
+
+
+    // part selection
+
+    sc_int_subref&         operator () ( int left, int right );
+    const sc_int_subref_r& operator () ( int left, int right ) const;
+
+    sc_int_subref&         range( int left, int right );
+    const sc_int_subref_r& range( int left, int right ) const;
+
+
+    // bit access, without bounds checking or sign extension
+
+    bool test( int i ) const
+	{ return ( 0 != (m_val & (UINT_ONE << i)) ); }
+
+    void set( int i )
+	{ m_val |= (UINT_ONE << i); }
+
+    void set( int i, bool v )
+	{ v ? m_val |= (UINT_ONE << i) : m_val &= ~(UINT_ONE << i); }
+
+
+    // capacity
+
+    int length() const
+	{ return m_len; }
+
+#ifdef SC_DT_DEPRECATED
+    int bitwidth() const
+	{ return length(); }
+#endif
+
+    // concatenation support
+
+    virtual int concat_length(bool* xz_present_p) const
+	{ if ( xz_present_p ) *xz_present_p = false; return length(); }
+    virtual bool concat_get_ctrl( sc_digit* dst_p, int low_i ) const;
+    virtual bool concat_get_data( sc_digit* dst_p, int low_i ) const;
+    virtual uint64 concat_get_uint64() const
+	{
+	    if ( m_len < 64 )
+		return (uint64)(m_val & ~((uint_type)-1 << m_len));
+	    else
+		return (uint64)m_val;
+	}
+    virtual void concat_set(int64 src, int low_i);
+    virtual void concat_set(const sc_signed& src, int low_i);
+    virtual void concat_set(const sc_unsigned& src, int low_i);
+    virtual void concat_set(uint64 src, int low_i);
+
+
+    // reduce methods
+
+    bool and_reduce() const;
+
+    bool nand_reduce() const
+	{ return ( ! and_reduce() ); }
+
+    bool or_reduce() const;
+
+    bool nor_reduce() const
+	{ return ( ! or_reduce() ); }
+
+    bool xor_reduce() const;
+
+    bool xnor_reduce() const
+	{ return ( ! xor_reduce() ); }
+
+
+    // implicit conversion to int_type
+
+    operator int_type() const
+	{ return m_val; }
+
+
+    // explicit conversions
+
+    int_type value() const
+	{ return operator int_type(); }
+
+
+    int to_int() const
+	{ return (int) m_val; }
+
+    unsigned int to_uint() const
+	{ return (unsigned int) m_val; }
+
+    long to_long() const
+	{ return (long) m_val; }
+
+    unsigned long to_ulong() const
+	{ return (unsigned long) m_val; }
+
+    int64 to_int64() const
+	{ return (int64) m_val; }
+
+    uint64 to_uint64() const
+	{ return (uint64) m_val; }
+
+    double to_double() const
+	{ return (double) m_val; }
+
+
+#ifndef _32BIT_
+    long long_low() const
+	{ return (long) (m_val & UINT64_32ONES); }
+
+    long long_high() const
+	{ return (long) ((m_val >> 32) & UINT64_32ONES); }
+#endif
+
+
+    // explicit conversion to character string
+
+    const std::string to_string( sc_numrep numrep = SC_DEC ) const;
+    const std::string to_string( sc_numrep numrep, bool w_prefix ) const;
+
+
+    // other methods
+
+    void print( ::std::ostream& os = ::std::cout ) const
+	{ os << to_string(sc_io_base(os,SC_DEC),sc_io_show_base(os)); }
+
+    void scan( ::std::istream& is = ::std::cin );
+
+protected:
+
+    int_type m_val;   // value
+    int      m_len;   // length
+    int      m_ulen;  // unused length
+};
+
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream&, const sc_int_base& );
+
+inline
+::std::istream&
+operator >> ( ::std::istream&, sc_int_base& );
+
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_int_bitref_r
+//
+//  Proxy class for sc_int bit selection (r-value only).
+// ----------------------------------------------------------------------------
+
+// implicit conversion to uint64
+
+inline
+sc_int_bitref_r::operator uint64 () const
+{
+    return m_obj_p->test( m_index );
+}
+
+inline
+bool
+sc_int_bitref_r::operator ! () const
+{
+    return ! m_obj_p->test( m_index );
+}
+
+inline
+bool
+sc_int_bitref_r::operator ~ () const
+{
+    return ! m_obj_p->test( m_index );
+}
+
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_int_bitref_r& a )
+{
+    a.print( os );
+    return os;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_int_bitref
+//
+//  Proxy class for sc_int bit selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+// assignment operators
+
+inline
+sc_int_bitref&
+sc_int_bitref::operator = ( const sc_int_bitref_r& b )
+{
+    m_obj_p->set( m_index, (bool) b );
+    m_obj_p->extend_sign();
+    return *this;
+}
+
+inline
+sc_int_bitref&
+sc_int_bitref::operator = ( const sc_int_bitref& b )
+{
+    m_obj_p->set( m_index, (bool) b );
+    m_obj_p->extend_sign();
+    return *this;
+}
+
+inline
+sc_int_bitref&
+sc_int_bitref::operator = ( bool b )
+{
+    m_obj_p->set( m_index, b );
+    m_obj_p->extend_sign();
+    return *this;
+}
+
+
+inline
+sc_int_bitref&
+sc_int_bitref::operator &= ( bool b )
+{
+    if( ! b ) {
+	m_obj_p->set( m_index, b );
+	m_obj_p->extend_sign();
+    }
+    return *this;
+}
+
+inline
+sc_int_bitref&
+sc_int_bitref::operator |= ( bool b )
+{
+    if( b ) {
+	m_obj_p->set( m_index, b );
+	m_obj_p->extend_sign();
+    }
+    return *this;
+}
+
+inline
+sc_int_bitref&
+sc_int_bitref::operator ^= ( bool b )
+{
+    if( b ) {
+	m_obj_p->m_val ^= (UINT_ONE << m_index);
+	m_obj_p->extend_sign();
+    }
+    return *this;
+}
+
+
+
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_int_bitref& a )
+{
+    a.scan( is );
+    return is;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_int_subref_r
+//
+//  Proxy class for sc_int part selection (r-value only).
+// ----------------------------------------------------------------------------
+
+// implicit conversion to int_type
+
+inline
+sc_int_subref_r::operator uint_type() const
+{
+    uint_type /*int_type*/ val = m_obj_p->m_val;
+    int uleft = SC_INTWIDTH - (m_left + 1);
+    int uright = uleft + m_right;
+    return ( val << uleft >> uright );
+}
+
+
+// reduce methods
+
+inline
+bool
+sc_int_subref_r::and_reduce() const
+{
+    sc_int_base a( *this );
+    return a.and_reduce();
+}
+
+inline
+bool
+sc_int_subref_r::or_reduce() const
+{
+    sc_int_base a( *this );
+    return a.or_reduce();
+}
+
+inline
+bool
+sc_int_subref_r::xor_reduce() const
+{
+    sc_int_base a( *this );
+    return a.xor_reduce();
+}
+
+
+// explicit conversions
+
+inline
+int
+sc_int_subref_r::to_int() const
+{
+	int result = static_cast<int>(operator uint_type());
+	return result;
+}
+
+inline
+unsigned int
+sc_int_subref_r::to_uint() const
+{
+	unsigned int result = static_cast<unsigned int>(operator uint_type());
+	return result;
+}
+
+inline
+long
+sc_int_subref_r::to_long() const
+{
+	long result = static_cast<long>(operator uint_type());
+	return result;
+}
+
+inline
+unsigned long
+sc_int_subref_r::to_ulong() const
+{
+	unsigned long result = static_cast<unsigned long>(operator uint_type());
+	return result;
+}
+
+inline
+int64
+sc_int_subref_r::to_int64() const
+{
+	int64 result = operator uint_type();
+	return result;
+}
+
+inline
+uint64
+sc_int_subref_r::to_uint64() const
+{
+	uint64 result = operator uint_type();
+	return result;
+}
+
+inline
+double
+sc_int_subref_r::to_double() const
+{
+	double result = static_cast<double>(operator uint_type());
+	return result;
+}
+
+
+// explicit conversion to character string
+
+inline
+const std::string
+sc_int_subref_r::to_string( sc_numrep numrep ) const
+{
+	sc_uint_base a(length());
+    a = operator uint_type();
+    return a.to_string( numrep );
+}
+
+inline
+const std::string
+sc_int_subref_r::to_string( sc_numrep numrep, bool w_prefix ) const
+{
+	sc_uint_base a(length());
+    a = operator uint_type();
+    return a.to_string( numrep, w_prefix );
+}
+
+
+// functional notation for the reduce methods
+
+inline
+bool
+and_reduce( const sc_int_subref_r& a )
+{
+    return a.and_reduce();
+}
+
+inline
+bool
+nand_reduce( const sc_int_subref_r& a )
+{
+    return a.nand_reduce();
+}
+
+inline
+bool
+or_reduce( const sc_int_subref_r& a )
+{
+    return a.or_reduce();
+}
+
+inline
+bool
+nor_reduce( const sc_int_subref_r& a )
+{
+    return a.nor_reduce();
+}
+
+inline
+bool
+xor_reduce( const sc_int_subref_r& a )
+{
+    return a.xor_reduce();
+}
+
+inline
+bool
+xnor_reduce( const sc_int_subref_r& a )
+{
+    return a.xnor_reduce();
+}
+
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_int_subref_r& a )
+{
+    a.print( os );
+    return os;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_int_subref
+//
+//  Proxy class for sc_int part selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+// assignment operators
+
+inline
+sc_int_subref&
+sc_int_subref::operator = ( const sc_int_base& a )
+{
+    return operator = ( a.operator int_type() );
+}
+
+inline
+sc_int_subref&
+sc_int_subref::operator = ( const char* a )
+{
+    sc_int_base aa( length() );
+    return ( *this = aa = a );
+}
+
+
+
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_int_subref& a )
+{
+    a.scan( is );
+    return is;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_int_base
+//
+//  Base class for sc_int.
+// ----------------------------------------------------------------------------
+
+// bit selection
+
+inline
+sc_int_bitref&
+sc_int_base::operator [] ( int i )
+{
+    check_index( i );
+    sc_int_bitref* result_p = sc_int_bitref::m_pool.allocate();
+    result_p->initialize(this, i);
+    return *result_p;
+}
+
+inline
+const sc_int_bitref_r&
+sc_int_base::operator [] ( int i ) const
+{
+    check_index( i );
+    sc_int_bitref* result_p = sc_int_bitref::m_pool.allocate();
+    result_p->initialize(this, i);
+    return *result_p;
+}
+
+
+inline
+sc_int_bitref&
+sc_int_base::bit( int i )
+{
+    check_index( i );
+    sc_int_bitref* result_p = sc_int_bitref::m_pool.allocate();
+    result_p->initialize(this, i);
+    return *result_p;
+}
+
+inline
+const sc_int_bitref_r&
+sc_int_base::bit( int i ) const
+{
+    check_index( i );
+    sc_int_bitref* result_p = sc_int_bitref::m_pool.allocate();
+    result_p->initialize(this, i);
+    return *result_p;
+}
+
+
+// part selection
+
+inline
+sc_int_subref&
+sc_int_base::operator () ( int left, int right )
+{
+    check_range( left, right );
+    sc_int_subref* result_p = sc_int_subref::m_pool.allocate();
+    result_p->initialize(this, left, right);
+    return *result_p;
+}
+
+inline
+const sc_int_subref_r&
+sc_int_base::operator () ( int left, int right ) const
+{
+    check_range( left, right );
+    sc_int_subref* result_p = sc_int_subref::m_pool.allocate();
+    result_p->initialize(this, left, right);
+    return *result_p;
+}
+
+
+inline
+sc_int_subref&
+sc_int_base::range( int left, int right )
+{
+    check_range( left, right );
+    sc_int_subref* result_p = sc_int_subref::m_pool.allocate();
+    result_p->initialize(this, left, right);
+    return *result_p;
+}
+
+inline
+const sc_int_subref_r&
+sc_int_base::range( int left, int right ) const
+{
+    check_range( left, right );
+    sc_int_subref* result_p = sc_int_subref::m_pool.allocate();
+    result_p->initialize(this, left, right);
+    return *result_p;
+}
+
+
+// functional notation for the reduce methods
+
+inline
+bool
+and_reduce( const sc_int_base& a )
+{
+    return a.and_reduce();
+}
+
+inline
+bool
+nand_reduce( const sc_int_base& a )
+{
+    return a.nand_reduce();
+}
+
+inline
+bool
+or_reduce( const sc_int_base& a )
+{
+    return a.or_reduce();
+}
+
+inline
+bool
+nor_reduce( const sc_int_base& a )
+{
+    return a.nor_reduce();
+}
+
+inline
+bool
+xor_reduce( const sc_int_base& a )
+{
+    return a.xor_reduce();
+}
+
+inline
+bool
+xnor_reduce( const sc_int_base& a )
+{
+    return a.xnor_reduce();
+}
+
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_int_base& a )
+{
+    a.print( os );
+    return os;
+}
+
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_int_base& a )
+{
+    a.scan( is );
+    return is;
+}
+
+} // namespace sc_dt
+
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_int_ids.h b/ext/systemc/src/sysc/datatypes/int/sc_int_ids.h
new file mode 100644
index 000000000..13b269590
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_int_ids.h
@@ -0,0 +1,80 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_int_ids.h -- Report ids for the datatypes/int code.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2002-01-17
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+    
+ *****************************************************************************/
+
+// $Log: sc_int_ids.h,v $
+// Revision 1.2  2011/02/18 20:19:15  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:49:31  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#ifndef SC_INT_IDS_H
+#define SC_INT_IDS_H
+
+
+#include "sysc/utils/sc_report.h"
+
+
+// ----------------------------------------------------------------------------
+//  Report ids (datatypes/int)
+//
+//  Report ids in the range of 400-499.
+// ----------------------------------------------------------------------------
+
+#ifndef SC_DEFINE_MESSAGE
+#define SC_DEFINE_MESSAGE(id,unused1,unused2) \
+    namespace sc_core { extern const char id[]; }
+extern const char SC_ID_REGISTER_ID_FAILED_[]; // in sc_report_handler.cpp
+#endif
+
+
+SC_DEFINE_MESSAGE( SC_ID_INIT_FAILED_, 400, "initialization failed" )
+SC_DEFINE_MESSAGE( SC_ID_ASSIGNMENT_FAILED_, 401, "assignment failed" )
+SC_DEFINE_MESSAGE( SC_ID_OPERATION_FAILED_, 402, "operation failed" )
+SC_DEFINE_MESSAGE( SC_ID_CONVERSION_FAILED_, 403, "conversion failed" )
+
+
+
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_length_param.cpp b/ext/systemc/src/sysc/datatypes/int/sc_length_param.cpp
new file mode 100644
index 000000000..c0ba66b6b
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_length_param.cpp
@@ -0,0 +1,97 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_length_param.cpp - 
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2002-03-19
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_length_param.cpp,v $
+// Revision 1.2  2011/02/18 20:19:15  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:49:32  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#include "sysc/datatypes/int/sc_length_param.h"
+
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_length_param
+//
+//  Length parameter type.
+// ----------------------------------------------------------------------------
+
+const std::string
+sc_length_param::to_string() const
+{
+    std::string s;
+
+    char buf[BUFSIZ];
+
+    s += "(";
+    std::sprintf( buf, "%d", m_len );
+    s += buf;
+    s += ")";
+
+    return s;
+}
+
+
+void
+sc_length_param::print( ::std::ostream& os ) const
+{
+    os << to_string();
+}
+
+void
+sc_length_param::dump( ::std::ostream& os ) const
+{
+    os << "sc_length_param" << ::std::endl;
+    os << "(" << ::std::endl;
+    os << "len = " << m_len << ::std::endl;
+    os << ")" << ::std::endl;
+}
+
+} // namespace sc_dt
+
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_length_param.h b/ext/systemc/src/sysc/datatypes/int/sc_length_param.h
new file mode 100644
index 000000000..aadb52bda
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_length_param.h
@@ -0,0 +1,203 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_length_param.h -
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2002-03-19
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_length_param.h,v $
+// Revision 1.3  2011/08/24 22:05:46  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.2  2011/02/18 20:19:15  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.4  2006/05/08 17:50:01  acg
+//   Andy Goodrich: Added David Long's declarations for friend operators,
+//   functions, and methods, to keep the Microsoft compiler happy.
+//
+// Revision 1.3  2006/01/13 18:49:32  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#ifndef SC_LENGTH_PARAM_H
+#define SC_LENGTH_PARAM_H
+
+
+#include "sysc/datatypes/fx/sc_context.h"
+
+
+namespace sc_dt
+{
+
+// classes defined in this module
+class sc_length_param;
+
+// friend operator declarations
+    bool operator == ( const sc_length_param&,
+                              const sc_length_param& );
+    bool operator != ( const sc_length_param&,
+			      const sc_length_param& );
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_length_param
+//
+//  Length parameter type.
+// ----------------------------------------------------------------------------
+
+class sc_length_param
+{
+public:
+
+             sc_length_param();
+             sc_length_param( int );
+             sc_length_param( const sc_length_param& );
+    explicit sc_length_param( sc_without_context );
+
+    sc_length_param& operator = ( const sc_length_param& );
+
+    friend bool operator == ( const sc_length_param&,
+                              const sc_length_param& );
+    friend bool operator != ( const sc_length_param&,
+			      const sc_length_param& );
+
+    int len() const;
+    void len( int );
+
+    const std::string to_string() const;
+
+    void print( ::std::ostream& = ::std::cout ) const;
+    void dump( ::std::ostream& = ::std::cout ) const;
+
+private:
+
+    int m_len;
+};
+
+
+// ----------------------------------------------------------------------------
+//  TYPEDEF : sc_length_context
+//
+//  Context type for the length parameter type.
+// ----------------------------------------------------------------------------
+
+typedef sc_context<sc_length_param> sc_length_context;
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+inline
+sc_length_param::sc_length_param() : m_len()
+{
+    *this = sc_length_context::default_value();
+}
+
+inline
+sc_length_param::sc_length_param( int len_ ) : m_len(len_)
+{
+    SC_CHECK_WL_( len_ );
+}
+
+inline
+sc_length_param::sc_length_param( const sc_length_param& a )
+    : m_len( a.m_len )
+{}
+
+inline
+sc_length_param::sc_length_param( sc_without_context )
+    : m_len( SC_DEFAULT_WL_ )
+{}
+
+
+inline
+sc_length_param&
+sc_length_param::operator = ( const sc_length_param& a )
+{
+    if( &a != this )
+    {
+	m_len = a.m_len;
+    }
+    return *this;
+}
+
+
+inline
+bool
+operator == ( const sc_length_param& a, const sc_length_param& b )
+{
+    return ( a.m_len == b.m_len );
+}
+
+inline
+bool
+operator != ( const sc_length_param& a, const sc_length_param& b )
+{
+    return ( a.m_len != b.m_len );
+}
+
+
+inline
+int
+sc_length_param::len() const
+{
+    return m_len;
+}
+
+inline
+void
+sc_length_param::len( int len_ )
+{
+    SC_CHECK_WL_( len_ );
+    m_len = len_;
+}
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_length_param& a )
+{
+    a.print( os );
+    return os;
+}
+
+} // namespace sc_dt
+
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_nbcommon.inc b/ext/systemc/src/sysc/datatypes/int/sc_nbcommon.inc
new file mode 100644
index 000000000..89fc4ba83
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_nbcommon.inc
@@ -0,0 +1,2989 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_nbcommon.cpp -- Functions common to both sc_signed and sc_unsigned.
+                     This file is included in sc_signed.cpp and
+                     sc_unsigned.cpp after the macros are defined accordingly.
+                     For example, sc_signed.cpp will first define CLASS_TYPE
+                     as sc_signed before including this file. This file like
+                     sc_nbfriends.cpp and sc_nbexterns.cpp is created in order
+                     to ensure only one version of each function, regardless
+                     of the class that they interface to.
+ 
+  Original Author: Ali Dasdan, Synopsys, Inc.
+  
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// ----------------------------------------------------------------------------
+//  SECTION : Public members
+// ----------------------------------------------------------------------------
+
+// Create a CLASS_TYPE number with nb bits.
+CLASS_TYPE::CLASS_TYPE( int nb ) :
+    sc_value_base(), sgn(), nbits(), ndigits(), digit()
+{
+    sgn = default_sign();
+    if( nb > 0 ) {
+	nbits = num_bits( nb );
+    } else {
+	char msg[BUFSIZ];
+	std::sprintf( msg, "%s::%s( int nb ) : nb = %d is not valid",
+		 CLASS_TYPE_STR, CLASS_TYPE_STR, nb );
+	SC_REPORT_ERROR( sc_core::SC_ID_INIT_FAILED_, msg );
+    }
+    ndigits = DIV_CEIL(nbits);
+#ifdef SC_MAX_NBITS
+    test_bound(nb);
+#else
+    digit = new sc_digit[ndigits];
+#endif
+    makezero();
+}
+
+
+// Create a copy of v with sgn s. v is of the same type.
+CLASS_TYPE::CLASS_TYPE(const CLASS_TYPE& v) :
+    sc_value_base(v), sgn(v.sgn), nbits(v.nbits), ndigits(v.ndigits), digit()
+{
+#ifndef SC_MAX_NBITS
+  digit = new sc_digit[ndigits];
+#endif
+
+  vec_copy(ndigits, digit, v.digit);
+}
+
+
+// Create a copy of v where v is of the different type.
+CLASS_TYPE::CLASS_TYPE(const OTHER_CLASS_TYPE& v) :
+    sc_value_base(v), sgn(v.sgn), nbits(num_bits(v.nbits)), ndigits(), digit()
+{
+#if (IF_SC_SIGNED == 1)
+  ndigits = v.ndigits;
+#else
+  ndigits = DIV_CEIL(nbits);
+#endif
+
+#ifndef SC_MAX_NBITS
+  digit = new sc_digit[ndigits];
+#endif
+
+  copy_digits(v.nbits, v.ndigits, v.digit);
+}
+
+// Create a copy of v where v is an sign-less instance.
+CLASS_TYPE::CLASS_TYPE(const sc_bv_base& v) :
+    sc_value_base(), sgn(), nbits(), ndigits(), digit()
+{
+    int nb = v.length();
+    sgn = default_sign();
+    if( nb > 0 ) {
+        nbits = num_bits( nb );
+    } else {
+        char msg[BUFSIZ];
+        std::sprintf( msg, "%s::%s( sc_bv_base ) : nb = %d is not valid",
+                 CLASS_TYPE_STR, CLASS_TYPE_STR, nb );
+        SC_REPORT_ERROR( sc_core::SC_ID_INIT_FAILED_, msg );
+    }
+    ndigits = DIV_CEIL(nbits);
+#   ifdef SC_MAX_NBITS
+        test_bound(nb);
+#    else
+        digit = new sc_digit[ndigits];
+#    endif
+    makezero();
+    *this = v;
+}
+
+CLASS_TYPE::CLASS_TYPE(const sc_lv_base& v) : 
+    sc_value_base(), sgn(), nbits(), ndigits(), digit()
+{
+    int nb = v.length();
+    sgn = default_sign();
+    if( nb > 0 ) {
+        nbits = num_bits( nb );
+    } else {
+        char msg[BUFSIZ];
+        std::sprintf( msg, "%s::%s( sc_lv_base ) : nb = %d is not valid",
+                 CLASS_TYPE_STR, CLASS_TYPE_STR, nb );
+        SC_REPORT_ERROR( sc_core::SC_ID_INIT_FAILED_, msg );
+    }
+    ndigits = DIV_CEIL(nbits);
+#   ifdef SC_MAX_NBITS
+        test_bound(nb);
+#    else
+        digit = new sc_digit[ndigits];
+#    endif
+    makezero();
+    *this = v;
+}
+
+CLASS_TYPE::CLASS_TYPE(const sc_int_subref_r& v) :
+    sc_value_base(v), sgn(), nbits(), ndigits(), digit()
+{
+    int nb = v.length();
+    sgn = default_sign();
+    if( nb > 0 ) {
+        nbits = num_bits( nb );
+    } else {
+        char msg[BUFSIZ];
+        std::sprintf( msg, "%s::%s( sc_int_subref ) : nb = %d is not valid",
+                 CLASS_TYPE_STR, CLASS_TYPE_STR, nb );
+        SC_REPORT_ERROR( sc_core::SC_ID_INIT_FAILED_, msg );
+    }
+    ndigits = DIV_CEIL(nbits);
+#   ifdef SC_MAX_NBITS
+        test_bound(nb);
+#    else
+        digit = new sc_digit[ndigits];
+#    endif
+    makezero();
+    *this = v.to_uint64();
+}
+
+CLASS_TYPE::CLASS_TYPE(const sc_uint_subref_r& v) :
+    sc_value_base(v), sgn(), nbits(), ndigits(), digit()
+{
+    int nb = v.length();
+    sgn = default_sign();
+    if( nb > 0 ) {
+        nbits = num_bits( nb );
+    } else {
+        char msg[BUFSIZ];
+        std::sprintf( msg, "%s::%s( sc_uint_subref ) : nb = %d is not valid",
+                 CLASS_TYPE_STR, CLASS_TYPE_STR, nb );
+        SC_REPORT_ERROR( sc_core::SC_ID_INIT_FAILED_, msg );
+    }
+    ndigits = DIV_CEIL(nbits);
+#   ifdef SC_MAX_NBITS
+        test_bound(nb);
+#    else
+        digit = new sc_digit[ndigits];
+#    endif
+    makezero();
+    *this = v.to_uint64();
+}
+
+CLASS_TYPE::CLASS_TYPE(const sc_signed_subref_r& v) :
+    sc_value_base(v), sgn(), nbits(), ndigits(), digit()
+{
+    int nb = v.length();
+    sgn = default_sign();
+    if( nb > 0 ) {
+        nbits = num_bits( nb );
+    } else {
+        char msg[BUFSIZ];
+        std::sprintf( msg, "%s::%s( sc_signed_subref ) : nb = %d is not valid",
+                 CLASS_TYPE_STR, CLASS_TYPE_STR, nb );
+        SC_REPORT_ERROR( sc_core::SC_ID_INIT_FAILED_, msg );
+    }
+    ndigits = DIV_CEIL(nbits);
+#   ifdef SC_MAX_NBITS
+        test_bound(nb);
+#    else
+        digit = new sc_digit[ndigits];
+#    endif
+    makezero();
+    *this = sc_unsigned(v.m_obj_p, v.m_left, v.m_right);
+}
+
+CLASS_TYPE::CLASS_TYPE(const sc_unsigned_subref_r& v) :
+    sc_value_base(v), sgn(), nbits(), ndigits(), digit()
+{
+    int nb = v.length();
+    sgn = default_sign();
+    if( nb > 0 ) {
+        nbits = num_bits( nb );
+    } else {
+        char msg[BUFSIZ];
+        std::sprintf( msg, "%s::%s( sc_unsigned_subref ) : nb = %d is not valid",
+                 CLASS_TYPE_STR, CLASS_TYPE_STR, nb );
+        SC_REPORT_ERROR( sc_core::SC_ID_INIT_FAILED_, msg );
+    }
+    ndigits = DIV_CEIL(nbits);
+#   ifdef SC_MAX_NBITS
+        test_bound(nb);
+#    else
+        digit = new sc_digit[ndigits];
+#    endif
+    makezero();
+    *this = sc_unsigned(v.m_obj_p, v.m_left, v.m_right);
+}
+
+// ----------------------------------------------------------------------------
+//  SECTION: Public members - Concatenation support.
+// ----------------------------------------------------------------------------
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Public members - Assignment operators.
+// ----------------------------------------------------------------------------
+
+// Assignment from v of the same type.
+const CLASS_TYPE&
+CLASS_TYPE::operator=(const CLASS_TYPE& v)
+{
+  if (this != &v) {
+
+    sgn = v.sgn;
+
+    if (sgn == SC_ZERO)
+      vec_zero(ndigits, digit);
+
+    else
+      copy_digits(v.nbits, v.ndigits, v.digit);
+
+  }
+
+  return *this;
+}
+
+
+// Assignment from v of the different type.
+const CLASS_TYPE&
+CLASS_TYPE::operator=(const OTHER_CLASS_TYPE& v)
+{
+  sgn = v.sgn;
+
+  if (sgn == SC_ZERO)
+    vec_zero(ndigits, digit);
+
+  else
+    copy_digits(v.nbits, v.ndigits, v.digit);
+    
+  return *this;
+}
+
+
+// Assignment from an sc_unsigned_subref_r
+const CLASS_TYPE& 
+CLASS_TYPE::operator=(const sc_unsigned_subref_r& v)
+{
+  return operator=(sc_unsigned(v));
+}
+
+
+// Assignment from an sc_signed_subref_r
+const CLASS_TYPE& 
+CLASS_TYPE::operator=(const sc_signed_subref_r& v)
+{
+  return operator=(sc_unsigned(v));
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Input and output operators
+// ----------------------------------------------------------------------------
+
+void
+CLASS_TYPE::scan( ::std::istream& is )
+{
+    std::string s;
+    is >> s;
+    *this = s.c_str();
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: PLUS operators: +, +=, ++
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u + v:
+// 1. 0 + v = v
+// 2. u + 0 = u
+// 3. if sgn(u) == sgn(v)
+//    3.1 u + v = +(u + v) = sgn(u) * (u + v) 
+//    3.2 (-u) + (-v) = -(u + v) = sgn(u) * (u + v)
+// 4. if sgn(u) != sgn(v)
+//    4.1 u + (-v) = u - v = sgn(u) * (u - v)
+//    4.2 (-u) + v = -(u - v) ==> sgn(u) * (u - v)
+//
+// Specialization of above cases for computing ++u or u++: 
+// 1. 0 + 1 = 1
+// 3. u + 1 = u + 1 = sgn(u) * (u + 1)
+// 4. (-u) + 1 = -(u - 1) = sgn(u) * (u - 1)
+
+const CLASS_TYPE&
+CLASS_TYPE::operator+=(const CLASS_TYPE& v)
+{
+  // u = *this
+
+  if (sgn == SC_ZERO) // case 1
+    return (*this = v);
+
+  if (v.sgn == SC_ZERO) // case 2
+    return *this;
+
+  // cases 3 and 4
+  add_on_help(sgn, nbits, ndigits, digit,
+              v.sgn, v.nbits, v.ndigits, v.digit);
+
+  convert_SM_to_2C_to_SM();
+
+  return *this; 
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator+=(const OTHER_CLASS_TYPE& v)
+{
+  // u = *this
+
+  if (sgn == SC_ZERO) // case 1
+    return (*this = v);
+
+  if (v.sgn == SC_ZERO) // case 2
+    return *this;
+
+  // cases 3 and 4
+  add_on_help(sgn, nbits, ndigits, digit,
+              v.sgn, v.nbits, v.ndigits, v.digit);
+
+  convert_SM_to_2C_to_SM();
+
+  return *this; 
+}
+
+
+CLASS_TYPE&
+CLASS_TYPE::operator++() // prefix
+{
+    *this = *this + 1;
+    return *this;   
+}
+
+
+const CLASS_TYPE
+CLASS_TYPE::operator++(int) // postfix
+{
+  // Copy digit into d.
+
+#ifdef SC_MAX_NBITS
+  sc_digit d[MAX_NDIGITS];
+#else
+  sc_digit *d = new sc_digit[ndigits];
+#endif
+
+  small_type s = sgn;
+
+  vec_copy(ndigits, d, digit);
+
+  *this = *this + 1;
+
+  return CLASS_TYPE(s, nbits, ndigits, d);
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator+=(int64 v)
+{
+  // u = *this
+
+  if (sgn == SC_ZERO)  // case 1
+    return (*this = v);
+
+  if (v == 0) // case 2
+    return *this;
+
+  CONVERT_INT64(v);
+
+  // cases 3 and 4
+  add_on_help(sgn, nbits, ndigits, digit,
+              vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+  convert_SM_to_2C_to_SM();
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator+=(uint64 v)
+{
+  // u = *this
+
+  if (sgn == SC_ZERO)  // case 1
+    return (*this = v);
+
+  if (v == 0)  // case 2
+    return *this;
+
+  CONVERT_INT64(v);
+
+  // cases 3 and 4
+  add_on_help(sgn, nbits, ndigits, digit,
+              vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+  convert_SM_to_2C_to_SM();
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator+=(long v)
+{
+  // u = *this
+
+  if (sgn == SC_ZERO)  // case 1
+    return (*this = v);
+
+  if (v == 0) // case 2
+    return *this;
+
+  CONVERT_LONG(v);
+
+  // cases 3 and 4
+  add_on_help(sgn, nbits, ndigits, digit,
+              vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+  convert_SM_to_2C_to_SM();
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator+=(unsigned long v)
+{
+  // u = *this
+
+  if (sgn == SC_ZERO)  // case 1
+    return (*this = v);
+
+  if (v == 0)  // case 2
+    return *this;
+
+  CONVERT_LONG(v);
+
+  // cases 3 and 4
+  add_on_help(sgn, nbits, ndigits, digit,
+              vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+  convert_SM_to_2C_to_SM();
+
+  return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: MINUS operators: -, -=, --
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u + v:
+// 1. u - 0 = u 
+// 2. 0 - v = -v
+// 3. if sgn(u) != sgn(v)
+//    3.1 u - (-v) = u + v = sgn(u) * (u + v)
+//    3.2 (-u) - v = -(u + v) ==> sgn(u) * (u + v)
+// 4. if sgn(u) == sgn(v)
+//    4.1 u - v = +(u - v) = sgn(u) * (u - v) 
+//    4.2 (-u) - (-v) = -(u - v) = sgn(u) * (u - v)
+//
+// Specialization of above cases for computing --u or u--: 
+// 1. 0 - 1 = -1
+// 3. (-u) - 1 = -(u + 1) = sgn(u) * (u + 1)
+// 4. u - 1 = u - 1 = sgn(u) * (u - 1)
+
+const CLASS_TYPE&
+CLASS_TYPE::operator-=(const CLASS_TYPE& v)
+{
+  // u = *this
+
+  if (v.sgn == SC_ZERO)  // case 1
+    return *this;
+
+  if (sgn == SC_ZERO) { // case 2
+
+    sgn = -v.sgn;
+    copy_digits(v.nbits, v.ndigits, v.digit);   
+
+  }
+  else {
+    
+    // cases 3 and 4
+    add_on_help(sgn, nbits, ndigits, digit, 
+                -v.sgn, v.nbits, v.ndigits, v.digit);
+
+    convert_SM_to_2C_to_SM();
+
+  }
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator-=(const OTHER_CLASS_TYPE& v)
+{
+  // u = *this
+
+  if (v.sgn == SC_ZERO)  // case 1
+    return *this;
+
+  if (sgn == SC_ZERO) { // case 2
+
+    sgn = -v.sgn;
+    copy_digits(v.nbits, v.ndigits, v.digit);   
+
+  }
+  else {
+
+    // cases 3 and 4
+    add_on_help(sgn, nbits, ndigits, digit, 
+                -v.sgn, v.nbits, v.ndigits, v.digit);
+
+    convert_SM_to_2C_to_SM();
+    
+  }
+  
+  return *this;
+}
+
+
+CLASS_TYPE&
+CLASS_TYPE::operator--() // prefix
+{
+    *this = *this - 1;
+    return *this;   
+}
+
+
+const CLASS_TYPE
+CLASS_TYPE::operator--(int) // postfix
+{
+  // Copy digit into d.
+
+#ifdef SC_MAX_NBITS
+  sc_digit d[MAX_NDIGITS];
+#else
+  sc_digit *d = new sc_digit[ndigits];
+#endif
+
+  small_type s = sgn;
+
+  vec_copy(ndigits, d, digit);
+
+  *this = *this - 1;
+
+  return CLASS_TYPE(s, nbits, ndigits, d);
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator-=(int64 v)
+{
+  // u = *this
+
+  if (v == 0) // case 1
+    return *this;
+
+  if (sgn == SC_ZERO) // case 2
+    return (*this = -v);
+
+  CONVERT_INT64(v);
+
+  // cases 3 and 4
+  add_on_help(sgn, nbits, ndigits, digit,
+              -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+  convert_SM_to_2C_to_SM();
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator-=(uint64 v)
+{
+  // u = *this
+
+  if (v == 0) // case 1
+    return *this;
+
+  int64 v2 = (int64) v;
+
+  if (sgn == SC_ZERO) // case 2
+    return (*this = -v2);
+
+  CONVERT_INT64(v);
+
+  // cases 3 and 4
+  add_on_help(sgn, nbits, ndigits, digit,
+              -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+  convert_SM_to_2C_to_SM();
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator-=(long v)
+{
+  // u = *this
+
+  if (v == 0) // case 1
+    return *this;
+
+  if (sgn == SC_ZERO) // case 2
+    return (*this = -v);
+
+  CONVERT_LONG(v);
+
+  // cases 3 and 4
+  add_on_help(sgn, nbits, ndigits, digit,
+              -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+  convert_SM_to_2C_to_SM();
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator-=(unsigned long v)
+{
+  // u = *this
+
+  if (v == 0) // case 1
+    return *this;
+
+  long v2 = (long) v;
+
+  if (sgn == SC_ZERO) // case 2
+    return (*this = -v2);
+
+  CONVERT_LONG(v);
+
+  // cases 3 and 4
+  add_on_help(sgn, nbits, ndigits, digit,
+              -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+  convert_SM_to_2C_to_SM();
+
+  return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: MULTIPLICATION operators: *, *=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u * v:
+// 1. u * 0 = 0 * v = 0
+// 2. 1 * v = v and -1 * v = -v
+// 3. u * 1 = u and u * -1 = -u
+// 4. u * v = u * v
+
+const CLASS_TYPE&
+CLASS_TYPE::operator*=(const CLASS_TYPE& v)
+{
+  // u = *this
+
+  sgn = mul_signs(sgn, v.sgn);
+
+  if (sgn == SC_ZERO) // case 1
+    vec_zero(ndigits, digit);
+
+  else
+    // cases 2-4
+    MUL_ON_HELPER(sgn,  nbits, ndigits, digit,
+                  v.nbits, v.ndigits, v.digit);
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator*=(const OTHER_CLASS_TYPE& v)
+{
+  // u = *this
+
+  sgn = mul_signs(sgn, v.sgn);
+
+  if (sgn == SC_ZERO) // case 1
+    vec_zero(ndigits, digit);
+
+  else 
+    // cases 2-4
+    MUL_ON_HELPER(sgn,  nbits, ndigits, digit,
+                  v.nbits, v.ndigits, v.digit);
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator*=(int64 v)
+{
+  // u = *this
+
+  sgn = mul_signs(sgn, get_sign(v));
+
+  if (sgn == SC_ZERO) // case 1
+    vec_zero(ndigits, digit);
+
+  else {  // cases 2-4
+
+    CONVERT_INT64_2(v);
+
+    MUL_ON_HELPER(sgn,  nbits, ndigits, digit,
+                  BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+  }
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator*=(uint64 v)
+{
+  // u = *this
+
+  sgn = mul_signs(sgn, get_sign(v));
+
+  if (sgn == SC_ZERO) // case 1
+    vec_zero(ndigits, digit);
+
+  else { // cases 2-4
+
+    CONVERT_INT64_2(v);
+
+    MUL_ON_HELPER(sgn,  nbits, ndigits, digit,
+                  BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+  }
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator*=(long v)
+{
+  // u = *this
+
+  sgn = mul_signs(sgn, get_sign(v));
+
+  if (sgn == SC_ZERO) // case 1
+    vec_zero(ndigits, digit);
+
+  else {   // cases 2-4
+
+    CONVERT_LONG_2(v);
+
+    MUL_ON_HELPER(sgn,  nbits, ndigits, digit,
+                  BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+  }
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator*=(unsigned long v)
+{
+  // u = *this
+
+  sgn = mul_signs(sgn, get_sign(v));
+
+  if (sgn == SC_ZERO) // case 1
+    vec_zero(ndigits, digit);
+
+  else {  // cases 2-4
+
+    CONVERT_LONG_2(v);
+
+    MUL_ON_HELPER(sgn,  nbits, ndigits, digit,
+                  BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+  }
+
+  return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: DIVISION operators: /, /=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when finding the quotient q = floor(u/v):
+// Note that u = q * v + r for r < q.
+// 1. 0 / 0 or u / 0 => error
+// 2. 0 / v => 0 = 0 * v + 0
+// 3. u / v && u = v => u = 1 * u + 0  - u or v can be 1 or -1
+// 4. u / v && u < v => u = 0 * v + u  - u can be 1 or -1
+// 5. u / v && u > v => u = q * v + r  - v can be 1 or -1
+
+const CLASS_TYPE&
+CLASS_TYPE::operator/=(const CLASS_TYPE& v)
+{
+  sgn = mul_signs(sgn, v.sgn);
+
+  if (sgn == SC_ZERO) {
+
+    div_by_zero(v.sgn); // case 1
+    vec_zero(ndigits, digit);  // case 2
+
+  }
+  else  // other cases
+    DIV_ON_HELPER(sgn, nbits, ndigits, digit,
+                  v.nbits, v.ndigits, v.digit);
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator/=(const OTHER_CLASS_TYPE& v)
+{
+  sgn = mul_signs(sgn, v.sgn);
+
+  if (sgn == SC_ZERO) {
+
+    div_by_zero(v.sgn); // case 1
+    vec_zero(ndigits, digit);  // case 2
+
+  }
+  else  // other cases
+    DIV_ON_HELPER(sgn, nbits, ndigits, digit,
+                  v.nbits, v.ndigits, v.digit);
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator/=(int64 v)
+{
+  // u = *this
+
+  sgn = mul_signs(sgn, get_sign(v));
+
+  if (sgn == SC_ZERO) {
+
+    div_by_zero(v);  // case 1
+    vec_zero(ndigits, digit); // case 2
+
+  }
+  else {
+
+    CONVERT_INT64_2(v);
+
+    // other cases
+    DIV_ON_HELPER(sgn, nbits, ndigits, digit,
+                  BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+  }
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator/=(uint64 v)
+{
+  // u = *this
+
+  sgn = mul_signs(sgn, get_sign(v));
+
+  if (sgn == SC_ZERO) {
+
+    div_by_zero(v);  // case 1
+    vec_zero(ndigits, digit);  // case 2
+
+  }
+  else {
+
+    CONVERT_INT64_2(v);
+
+    // other cases
+    DIV_ON_HELPER(sgn, nbits, ndigits, digit,
+                  BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+  }
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator/=(long v)
+{
+  // u = *this
+
+  sgn = mul_signs(sgn, get_sign(v));
+
+  if (sgn == SC_ZERO) {
+
+    div_by_zero(v);  // case 1
+    vec_zero(ndigits, digit); // case 2
+
+  }
+  else {
+
+    CONVERT_LONG_2(v);
+
+    // other cases
+    DIV_ON_HELPER(sgn,  nbits, ndigits, digit,
+                  BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+  }
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator/=(unsigned long v)
+{
+  // u = *this
+
+  sgn = mul_signs(sgn, get_sign(v));
+
+  if (sgn == SC_ZERO) {
+
+    div_by_zero(v);  // case 1
+    vec_zero(ndigits, digit);  // case 2
+
+  }
+  else {
+    
+    CONVERT_LONG_2(v);
+
+    // other cases
+    DIV_ON_HELPER(sgn,  nbits, ndigits, digit,
+                  BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+  }
+
+  return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: MOD operators: %, %=.
+// ----------------------------------------------------------------------------
+
+// Cases to consider when finding the remainder r = u % v:
+// Note that u = q * v + r for r < q.
+// 1. 0 % 0 or u % 0 => error
+// 2. 0 % v => 0 = 0 * v + 0
+// 3. u % v && u = v => u = 1 * u + 0  - u or v can be 1 or -1
+// 4. u % v && u < v => u = 0 * v + u  - u can be 1 or -1
+// 5. u % v && u > v => u = q * v + r  - v can be 1 or -1
+
+const CLASS_TYPE&
+CLASS_TYPE::operator%=(const CLASS_TYPE& v)
+{
+  if ((sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
+
+    div_by_zero(v.sgn);  // case 1
+    vec_zero(ndigits, digit);  // case 2
+
+  }
+  else // other cases
+    MOD_ON_HELPER(sgn, nbits, ndigits, digit,
+                  v.nbits, v.ndigits, v.digit);
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator%=(const OTHER_CLASS_TYPE& v)
+{
+  if ((sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
+
+    div_by_zero(v.sgn);  // case 1
+    vec_zero(ndigits, digit);  // case 2
+
+  }
+  else  // other cases
+    MOD_ON_HELPER(sgn, nbits, ndigits, digit,
+                  v.nbits, v.ndigits, v.digit);
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator%=(int64 v)
+{
+  small_type vs = get_sign(v);
+
+  if ((sgn == SC_ZERO) || (vs == SC_ZERO)) {
+
+    div_by_zero(v);  // case 1
+    vec_zero(ndigits, digit);  // case 2
+
+  }
+  else {
+    
+    CONVERT_INT64_2(v);
+
+    // other cases
+    MOD_ON_HELPER(sgn, nbits, ndigits, digit,
+                  BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+  }
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator%=(uint64 v)
+{
+  if ((sgn == SC_ZERO) || (v == 0)) {
+
+    div_by_zero(v);  // case 1
+    vec_zero(ndigits, digit);  // case 2
+
+  }
+  else {
+    
+    CONVERT_INT64_2(v);
+
+    // other cases
+    MOD_ON_HELPER(sgn, nbits, ndigits, digit,
+                  BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+  }
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator%=(long v)
+{
+  small_type vs = get_sign(v);
+
+  if ((sgn == SC_ZERO) || (vs == SC_ZERO)) {
+
+    div_by_zero(v);  // case 1
+    vec_zero(ndigits, digit);  // case 2
+
+  }
+  else {
+    
+    CONVERT_LONG_2(v);
+
+    // other cases
+    MOD_ON_HELPER(sgn, nbits, ndigits, digit,
+                  BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+  }
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator%=(unsigned long v)
+{
+  if ((sgn == SC_ZERO) || (v == 0)) {
+
+    div_by_zero(v);  // case 1
+    vec_zero(ndigits, digit);  // case 2
+
+  }
+  else {
+    
+    CONVERT_LONG_2(v);
+
+    // other cases
+    MOD_ON_HELPER(sgn, nbits, ndigits, digit,
+                  BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+  }
+
+  return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Bitwise AND operators: &, &=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u & v:
+// 1. u & 0 = 0 & v = 0
+// 2. u & v => sgn = +
+// 3. (-u) & (-v) => sgn = -
+// 4. u & (-v) => sgn = +
+// 5. (-u) & v => sgn = +
+
+const CLASS_TYPE&
+CLASS_TYPE::operator&=(const CLASS_TYPE& v)
+{
+  // u = *this
+
+  if ((sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1
+    makezero();
+
+  else  {  // other cases
+
+    and_on_help(sgn, nbits, ndigits, digit,
+                v.sgn, v.nbits, v.ndigits, v.digit);
+
+    convert_2C_to_SM();
+
+  }
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator&=(const OTHER_CLASS_TYPE& v)
+{
+  // u = *this
+
+  if ((sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1
+    makezero();
+
+  else {  // other cases
+    
+    and_on_help(sgn, nbits, ndigits, digit,
+                v.sgn, v.nbits, v.ndigits, v.digit);
+
+    convert_2C_to_SM();
+
+  }
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator&=(int64 v)
+{
+  // u = *this
+
+  if ((sgn == SC_ZERO) || (v == 0)) // case 1
+    makezero();
+
+  else {    // other cases
+
+    CONVERT_INT64(v);
+
+    and_on_help(sgn, nbits, ndigits, digit,
+                vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+    convert_2C_to_SM();
+
+  }
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator&=(uint64 v)
+{
+  // u = *this
+
+  if ((sgn == SC_ZERO) || (v == 0))  // case 1
+    makezero();
+
+  else {  // other cases
+
+    CONVERT_INT64(v);
+
+    and_on_help(sgn, nbits, ndigits, digit,
+                vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+    convert_2C_to_SM();
+    
+  }
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator&=(long v)
+{
+  // u = *this
+
+  if ((sgn == SC_ZERO) || (v == 0))  // case 1
+    makezero();
+
+  else {      // other cases
+
+    CONVERT_LONG(v);
+
+    and_on_help(sgn, nbits, ndigits, digit,
+                vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+    convert_2C_to_SM();
+
+  }
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator&=(unsigned long v)
+{
+  // u = *this
+
+  if ((sgn == SC_ZERO) || (v == 0))  // case 1
+    makezero();
+
+  else {  // other cases
+
+    CONVERT_LONG(v);
+
+    and_on_help(sgn, nbits, ndigits, digit,
+                vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+    convert_2C_to_SM();
+
+  }
+
+  return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Bitwise OR operators: |, |=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u | v:
+// 1. u | 0 = u
+// 2. 0 | v = v
+// 3. u | v => sgn = +
+// 4. (-u) | (-v) => sgn = -
+// 5. u | (-v) => sgn = -
+// 6. (-u) | v => sgn = -
+
+const CLASS_TYPE&
+CLASS_TYPE::operator|=(const CLASS_TYPE& v)
+{
+  if (v.sgn == SC_ZERO)  // case 1
+    return *this;
+
+  if (sgn == SC_ZERO)  // case 2
+    return (*this = v);
+
+  // other cases
+  or_on_help(sgn, nbits, ndigits, digit,
+             v.sgn, v.nbits, v.ndigits, v.digit);
+
+  convert_2C_to_SM();
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator|=(const OTHER_CLASS_TYPE& v)
+{
+  if (v.sgn == SC_ZERO)  // case 1
+    return *this;
+
+  if (sgn == SC_ZERO)  // case 2
+    return (*this = v);
+
+  // other cases
+  or_on_help(sgn, nbits, ndigits, digit,
+             v.sgn, v.nbits, v.ndigits, v.digit);
+
+  convert_2C_to_SM();
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator|=(int64 v)
+{
+  if (v == 0)  // case 1
+    return *this;
+
+  if (sgn == SC_ZERO)  // case 2
+    return (*this = v);
+
+  // other cases
+
+  CONVERT_INT64(v);
+
+  or_on_help(sgn, nbits, ndigits, digit,
+             vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+  convert_2C_to_SM();
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator|=(uint64 v)
+{
+  if (v == 0)  // case 1
+    return *this;
+
+  if (sgn == SC_ZERO)  // case 2
+    return (*this = v);
+
+  // other cases
+
+  CONVERT_INT64(v);
+
+  or_on_help(sgn, nbits, ndigits, digit,
+             vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+  convert_2C_to_SM();
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator|=(long v)
+{
+  if (v == 0)  // case 1
+    return *this;
+
+  if (sgn == SC_ZERO)  // case 2
+    return (*this = v);
+
+  // other cases
+
+  CONVERT_LONG(v);
+
+  or_on_help(sgn, nbits, ndigits, digit,
+             vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+  convert_2C_to_SM();
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator|=(unsigned long v)
+{
+  if (v == 0)  // case 1
+    return *this;
+
+  if (sgn == SC_ZERO)  // case 2
+    return (*this = v);
+
+  // other cases
+
+  CONVERT_LONG(v);
+
+  or_on_help(sgn, nbits, ndigits, digit,
+             vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+  convert_2C_to_SM();
+
+  return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Bitwise XOR operators: ^, ^=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u ^ v:
+// Note that  u ^ v = (~u & v) | (u & ~v).
+// 1. u ^ 0 = u
+// 2. 0 ^ v = v
+// 3. u ^ v => sgn = +
+// 4. (-u) ^ (-v) => sgn = -
+// 5. u ^ (-v) => sgn = -
+// 6. (-u) ^ v => sgn = +
+
+const CLASS_TYPE&
+CLASS_TYPE::operator^=(const CLASS_TYPE& v)
+{
+  // u = *this
+
+  if (v.sgn == SC_ZERO)  // case 1
+    return *this;
+
+  if (sgn == SC_ZERO)  // case 2
+    return (*this = v);
+
+  // other cases
+  xor_on_help(sgn, nbits, ndigits, digit,
+              v.sgn, v.nbits, v.ndigits, v.digit);
+
+  convert_2C_to_SM();
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator^=(const OTHER_CLASS_TYPE& v)
+{
+  // u = *this
+
+  if (v.sgn == SC_ZERO)  // case 1
+    return *this;
+
+  if (sgn == SC_ZERO)  // case 2
+    return (*this = v);
+
+  // other cases
+  xor_on_help(sgn, nbits, ndigits, digit,
+              v.sgn, v.nbits, v.ndigits, v.digit);
+
+  convert_2C_to_SM();
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator^=(int64 v)
+{
+  if (v == 0)  // case 1
+    return *this;
+
+  if (sgn == SC_ZERO)  // case 2
+    return (*this = v);
+
+  // other cases
+
+  CONVERT_INT64(v);
+
+  xor_on_help(sgn, nbits, ndigits, digit,
+              vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+  convert_2C_to_SM();
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator^=(uint64 v)
+{
+  if (v == 0)  // case 1
+    return *this;
+
+  if (sgn == SC_ZERO)  // case 2
+    return (*this = v);
+
+  // other cases
+
+  CONVERT_INT64(v);
+
+  xor_on_help(sgn, nbits, ndigits, digit,
+              vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+  
+  convert_2C_to_SM();
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator^=(long v)
+{
+  if (v == 0)  // case 1
+    return *this;
+
+  if (sgn == SC_ZERO)  // case 2
+    return (*this = v);
+
+  // other cases
+
+  CONVERT_LONG(v);
+
+  xor_on_help(sgn, nbits, ndigits, digit,
+              vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+  convert_2C_to_SM();
+
+  return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator^=(unsigned long v)
+{
+  if (v == 0)  // case 1
+    return *this;
+
+  if (sgn == SC_ZERO)  // case 2
+    return (*this = v);
+
+  // other cases
+
+  CONVERT_LONG(v);
+
+  xor_on_help(sgn, nbits, ndigits, digit,
+              vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+  
+  convert_2C_to_SM();
+
+  return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Bitwise NOT operator: ~
+// ----------------------------------------------------------------------------
+
+CLASS_TYPE
+operator~(const CLASS_TYPE& u)
+{
+  small_type s = u.sgn;
+
+  if (s == SC_ZERO) {
+
+    sc_digit d = 1;
+    return CLASS_TYPE(SC_NEG, u.nbits, 1, &d, false);
+
+  }
+
+  int nd = u.ndigits;
+
+#ifdef SC_MAX_NBITS
+  sc_digit d[MAX_NDIGITS];
+#else
+  sc_digit *d = new sc_digit[nd];
+#endif
+
+  vec_copy(nd, d, u.digit);
+
+  if (s == SC_POS) {
+
+    s = SC_NEG;
+    vec_add_small_on(nd, d, 1);
+
+  }
+  else {
+
+    s = SC_POS;
+    vec_sub_small_on(nd, d, 1);
+
+    if (check_for_zero(nd, d))
+      s = SC_ZERO;
+
+  }
+
+  return CLASS_TYPE(s, u.nbits, nd, d);
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: LEFT SHIFT operators: <<, <<=
+// ----------------------------------------------------------------------------
+
+CLASS_TYPE
+operator<<(const CLASS_TYPE& u, const CLASS_TYPE& v)
+{
+  if (v.sgn == SC_ZERO) 
+    return CLASS_TYPE(u);
+
+#ifdef SC_SIGNED
+  if (v.sgn == SC_NEG)
+    return CLASS_TYPE(u);
+#endif
+
+  return operator<<(u, v.to_ulong());
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator<<=(const CLASS_TYPE& v)
+{
+  if (v.sgn == SC_ZERO)
+    return *this;
+
+#ifdef SC_SIGNED
+  if (v.sgn == SC_NEG)
+    return *this;
+#endif 
+
+  return operator<<=(v.to_ulong());
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator<<=(const OTHER_CLASS_TYPE& v)
+{
+  if (v.sgn == SC_ZERO)
+    return *this;
+
+#ifdef SC_UNSIGNED
+  if (v.sgn == SC_NEG)
+    return *this;
+#endif
+
+  return operator<<=(v.to_ulong());
+}
+
+
+CLASS_TYPE
+operator<<(const CLASS_TYPE& u, int64 v)
+{
+  if (v <= 0)
+    return CLASS_TYPE(u);
+
+  return operator<<(u, (unsigned long) v);
+}
+
+
+CLASS_TYPE
+operator<<(const CLASS_TYPE& u, uint64 v)
+{
+  if (v == 0)
+    return CLASS_TYPE(u);
+
+  return operator<<(u, (unsigned long) v);
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator<<=(int64 v)
+{
+  if (v <= 0)
+    return *this;
+
+  return operator<<=((unsigned long) v);
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator<<=(uint64 v)
+{
+  if (v == 0)
+    return *this;
+
+  return operator<<=((unsigned long) v);
+}
+
+
+CLASS_TYPE
+operator<<(const CLASS_TYPE& u, long v)
+{
+  if (v <= 0)
+    return CLASS_TYPE(u);
+
+  return operator<<(u, (unsigned long) v);
+}
+
+CLASS_TYPE
+operator<<(const CLASS_TYPE& u, unsigned long v)
+{
+  if (v == 0)
+    return CLASS_TYPE(u);
+
+  if (u.sgn == SC_ZERO)
+    return CLASS_TYPE(u);
+
+  int nb = u.nbits + v;
+  int nd = DIV_CEIL(nb);
+
+#ifdef SC_MAX_NBITS
+  test_bound(nb);
+  sc_digit d[MAX_NDIGITS];
+#else
+  sc_digit *d = new sc_digit[nd];
+#endif  
+
+  vec_copy_and_zero(nd, d, u.ndigits, u.digit);
+
+  convert_SM_to_2C(u.sgn, nd, d);
+
+  vec_shift_left(nd, d, v);
+
+  small_type s = convert_signed_2C_to_SM(nb, nd, d);
+
+  return CLASS_TYPE(s, nb, nd, d);
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator<<=(long v)
+{
+  if (v <= 0)
+    return *this;
+
+  return operator<<=((unsigned long) v);
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator<<=(unsigned long v)
+{
+  if (v == 0)
+    return *this;
+
+  if (sgn == SC_ZERO)
+    return *this;
+
+  convert_SM_to_2C();
+
+  vec_shift_left(ndigits, digit, v);
+
+  convert_2C_to_SM();
+
+  return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: RIGHT SHIFT operators: >>, >>=
+// ----------------------------------------------------------------------------
+
+CLASS_TYPE
+operator>>(const CLASS_TYPE& u, const CLASS_TYPE& v)
+{
+  if (v.sgn == SC_ZERO)
+    return CLASS_TYPE(u);
+
+#ifdef SC_SIGNED
+  if (v.sgn == SC_NEG)
+    return CLASS_TYPE(u);
+#endif
+
+  return operator>>(u, v.to_long());
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator>>=(const CLASS_TYPE& v)
+{
+  if (v.sgn == SC_ZERO)
+    return *this;
+
+#ifdef SC_SIGNED
+  if (v.sgn == SC_NEG)
+    return *this;
+#endif
+
+  return operator>>=(v.to_long());
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator>>=(const OTHER_CLASS_TYPE& v)
+{
+  if (v.sgn == SC_ZERO)
+    return *this;
+
+#ifdef SC_UNSIGNED
+  if (v.sgn == SC_NEG)
+    return *this;
+#endif
+
+  return operator>>=(v.to_ulong());
+}
+
+
+CLASS_TYPE
+operator>>(const CLASS_TYPE& u, int64 v)
+{
+  if (v <= 0)
+    return CLASS_TYPE(u);
+
+  return operator>>(u, (unsigned long) v);
+}
+
+
+CLASS_TYPE
+operator>>(const CLASS_TYPE& u, uint64 v)
+{
+  if (v == 0)
+    return CLASS_TYPE(u);
+
+  return operator>>(u, (unsigned long) v);
+}
+
+const CLASS_TYPE&
+CLASS_TYPE::operator>>=(int64 v)
+{
+  if (v <= 0)
+    return *this;
+
+  return operator>>=((unsigned long) v);
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator>>=(uint64 v)
+{
+  if (v == 0)
+    return *this;
+
+  return operator>>=((unsigned long) v);
+}
+
+
+CLASS_TYPE
+operator>>(const CLASS_TYPE& u, long v)
+{
+  if (v <= 0)
+    return CLASS_TYPE(u);
+
+  return operator>>(u, (unsigned long) v);
+}
+
+
+CLASS_TYPE
+operator>>(const CLASS_TYPE& u, unsigned long v)
+{
+  if (v == 0)
+    return CLASS_TYPE(u);
+
+  if (u.sgn == SC_ZERO)
+    return CLASS_TYPE(u);
+
+  int nb = u.nbits;
+  int nd = u.ndigits;
+
+#ifdef SC_MAX_NBITS
+  sc_digit d[MAX_NDIGITS];
+#else
+  sc_digit *d = new sc_digit[nd];
+#endif  
+
+  vec_copy(nd, d, u.digit);
+
+  convert_SM_to_2C(u.sgn, nd, d);
+
+  if (u.sgn == SC_NEG)
+    vec_shift_right(nd, d, v, DIGIT_MASK);
+  else
+    vec_shift_right(nd, d, v, 0);
+    
+  small_type s = convert_signed_2C_to_SM(nb, nd, d);
+
+  return CLASS_TYPE(s, nb, nd, d);
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator>>=(long v)
+{
+  if (v <= 0)
+    return *this;
+
+  return operator>>=((unsigned long) v);
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator>>=(unsigned long v)
+{
+  if (v == 0)
+    return *this;
+
+  if (sgn == SC_ZERO)
+    return *this;
+
+  convert_SM_to_2C();
+
+  if (sgn == SC_NEG)
+    vec_shift_right(ndigits, digit, v, DIGIT_MASK);
+  else 
+    vec_shift_right(ndigits, digit, v, 0);
+
+  convert_2C_to_SM();
+
+  return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: EQUAL TO operator: ==
+// ----------------------------------------------------------------------------
+
+// Defined in the sc_signed.cpp and sc_unsigned.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: NOT_EQUAL operator: !=
+// ----------------------------------------------------------------------------
+
+bool
+operator!=(const CLASS_TYPE& u, const CLASS_TYPE& v)
+{
+  return (! operator==(u, v));
+}
+
+
+bool
+operator!=(const CLASS_TYPE& u, int64 v)
+{
+  return (! operator==(u, v));
+}
+
+
+bool
+operator!=(int64 u, const CLASS_TYPE& v)
+{
+  return (! operator==(u, v));  
+}
+
+
+bool
+operator!=(const CLASS_TYPE& u, uint64 v)
+{
+  return (! operator==(u, v));  
+}
+
+
+bool
+operator!=(uint64 u, const CLASS_TYPE& v)
+{
+  return (! operator==(u, v));  
+}
+
+
+bool
+operator!=(const CLASS_TYPE& u, long v)
+{
+  return (! operator==(u, v));
+}
+
+
+bool
+operator!=(long u, const CLASS_TYPE& v)
+{
+  return (! operator==(u, v));  
+}
+
+
+bool
+operator!=(const CLASS_TYPE& u, unsigned long v)
+{
+  return (! operator==(u, v));  
+}
+
+
+bool
+operator!=(unsigned long u, const CLASS_TYPE& v)
+{
+  return (! operator==(u, v));  
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: LESS THAN operator: <
+// ----------------------------------------------------------------------------
+
+// Defined in the sc_signed.cpp and sc_unsigned.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: LESS THAN or EQUAL operator: <=
+// ----------------------------------------------------------------------------
+
+bool
+operator<=(const CLASS_TYPE& u, const CLASS_TYPE& v)
+{
+  return (operator<(u, v) || operator==(u, v));
+}
+
+
+bool
+operator<=(const CLASS_TYPE& u, int64 v)
+{
+  return (operator<(u, v) || operator==(u, v));
+}
+
+
+bool
+operator<=(int64 u, const CLASS_TYPE& v)
+{
+  return (operator<(u, v) || operator==(u, v));
+}
+
+
+bool
+operator<=(const CLASS_TYPE& u, uint64 v)
+{
+  return (operator<(u, v) || operator==(u, v));
+}
+
+
+bool
+operator<=(uint64 u, const CLASS_TYPE& v)
+{
+  return (operator<(u, v) || operator==(u, v));
+}
+
+
+bool
+operator<=(const CLASS_TYPE& u, long v)
+{
+  return (operator<(u, v) || operator==(u, v));
+}
+
+
+bool
+operator<=(long u, const CLASS_TYPE& v)
+{
+  return (operator<(u, v) || operator==(u, v));
+}
+
+
+bool
+operator<=(const CLASS_TYPE& u, unsigned long v)
+{
+  return (operator<(u, v) || operator==(u, v));
+}
+
+
+bool
+operator<=(unsigned long u, const CLASS_TYPE& v)
+{
+  return (operator<(u, v) || operator==(u, v));
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: GREATER THAN operator: >
+// ----------------------------------------------------------------------------
+
+bool
+operator>(const CLASS_TYPE& u, const CLASS_TYPE& v)
+{
+  return (! (operator<=(u, v)));
+}
+
+
+bool
+operator>(const CLASS_TYPE& u, int64 v)
+{
+  return (! (operator<=(u, v)));
+}
+
+
+bool
+operator>(int64 u, const CLASS_TYPE& v)
+{
+  return (! (operator<=(u, v)));
+}
+
+
+bool
+operator>(const CLASS_TYPE& u, uint64 v)
+{
+  return (! (operator<=(u, v)));
+}
+
+
+bool
+operator>(uint64 u, const CLASS_TYPE& v)
+{
+  return (! (operator<=(u, v)));
+}
+
+
+bool
+operator>(const CLASS_TYPE& u, long v)
+{
+  return (! (operator<=(u, v)));
+}
+
+
+bool
+operator>(long u, const CLASS_TYPE& v)
+{
+  return (! (operator<=(u, v)));
+}
+
+
+bool
+operator>(const CLASS_TYPE& u, unsigned long v)
+{
+  return (! (operator<=(u, v)));
+}
+
+
+bool
+operator>(unsigned long u, const CLASS_TYPE& v)
+{
+  return (! (operator<=(u, v)));
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: GREATER THAN or EQUAL operator: >=
+// ----------------------------------------------------------------------------
+
+bool
+operator>=(const CLASS_TYPE& u, const CLASS_TYPE& v)
+{
+  return (! (operator<(u, v)));
+}
+
+
+bool
+operator>=(const CLASS_TYPE& u, int64 v)
+{
+  return (! (operator<(u, v)));
+}
+
+
+bool
+operator>=(int64 u, const CLASS_TYPE& v)
+{
+  return (! (operator<(u, v)));
+}
+
+
+bool
+operator>=(const CLASS_TYPE& u, uint64 v)
+{
+  return (! (operator<(u, v)));
+}
+
+
+bool
+operator>=(uint64 u, const CLASS_TYPE& v)
+{
+  return (! (operator<(u, v)));
+}
+
+
+bool
+operator>=(const CLASS_TYPE& u, long v)
+{
+  return (! (operator<(u, v)));
+}
+
+
+bool
+operator>=(long u, const CLASS_TYPE& v)
+{
+  return (! (operator<(u, v)));
+}
+
+
+bool
+operator>=(const CLASS_TYPE& u, unsigned long v)
+{
+  return (! (operator<(u, v)));
+}
+
+
+bool
+operator>=(unsigned long u, const CLASS_TYPE& v)
+{
+  return (! (operator<(u, v)));
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Public members - Other utils.
+// ----------------------------------------------------------------------------
+
+// Convert to int64, long, or int.
+#define TO_INTX(RET_TYPE, UP_RET_TYPE)   \
+                                                             \
+if (sgn == SC_ZERO)                                          \
+return 0;                                                    \
+                                                             \
+int vnd = sc_min((int)DIGITS_PER_ ## UP_RET_TYPE, ndigits); \
+                                                             \
+RET_TYPE v = 0;                                              \
+while (--vnd >= 0)                                           \
+v = (v << BITS_PER_DIGIT) + digit[vnd];                      \
+                                                             \
+if (sgn == SC_NEG)                                           \
+return -v;                                                   \
+else                                                         \
+return v;                                                    
+
+
+int64
+CLASS_TYPE::to_int64() const
+{
+  TO_INTX(int64, INT64);
+}
+
+
+long
+CLASS_TYPE::to_long() const
+{
+  TO_INTX(long, LONG);
+}
+
+
+int
+CLASS_TYPE::to_int() const
+{
+  TO_INTX(int, INT);
+}
+
+
+// Convert to unsigned int64, unsigned long or unsigned
+// int. to_uint64, to_ulong, and to_uint have the same body except for
+// the type of v defined inside.
+uint64
+CLASS_TYPE::to_uint64() const
+{
+  if (sgn == SC_ZERO)
+    return 0;
+
+  int vnd = sc_min((int)DIGITS_PER_INT64, ndigits);
+
+  uint64 v = 0;
+
+  if (sgn == SC_NEG) {
+
+#ifdef SC_MAX_NBITS
+    sc_digit d[MAX_NDIGITS];
+#else
+    sc_digit *d = new sc_digit[ndigits];
+#endif
+
+    vec_copy(ndigits, d, digit);
+
+    convert_SM_to_2C_trimmed(IF_SC_SIGNED, sgn, nbits, ndigits, d);
+
+    while (--vnd >= 0)
+      v = (v << BITS_PER_DIGIT) + d[vnd];
+
+#ifndef SC_MAX_NBITS
+    delete [] d;
+#endif
+
+  }
+  else {
+
+    while (--vnd >= 0)
+      v = (v << BITS_PER_DIGIT) + digit[vnd];
+
+  }
+
+  return v;
+}
+
+
+unsigned long
+CLASS_TYPE::to_ulong() const
+{
+  if (sgn == SC_ZERO)
+    return 0;
+
+  int vnd = sc_min((int)DIGITS_PER_LONG, ndigits);
+
+  unsigned long v = 0;
+
+  if (sgn == SC_NEG) {
+
+#ifdef SC_MAX_NBITS
+    sc_digit d[MAX_NDIGITS];
+#else
+    sc_digit *d = new sc_digit[ndigits];
+#endif
+
+    vec_copy(ndigits, d, digit);
+
+    convert_SM_to_2C_trimmed(IF_SC_SIGNED, sgn, nbits, ndigits, d);
+
+    while (--vnd >= 0)
+      v = (v << BITS_PER_DIGIT) + d[vnd];
+
+#ifndef SC_MAX_NBITS
+    delete [] d;
+#endif
+
+  }
+  else {
+
+    while (--vnd >= 0)
+      v = (v << BITS_PER_DIGIT) + digit[vnd];
+
+  }
+
+  return v;
+}
+
+
+unsigned int
+CLASS_TYPE::to_uint() const
+{
+  if (sgn == SC_ZERO)
+    return 0;
+
+  int vnd = sc_min((int)DIGITS_PER_INT, ndigits);
+
+  unsigned int v = 0;
+
+  if (sgn == SC_NEG) {
+
+#ifdef SC_MAX_NBITS
+    sc_digit d[MAX_NDIGITS];
+#else
+    sc_digit *d = new sc_digit[ndigits];
+#endif
+
+    vec_copy(ndigits, d, digit);
+
+    convert_SM_to_2C_trimmed(IF_SC_SIGNED, sgn, nbits, ndigits, d);
+
+    while (--vnd >= 0)
+      v = (v << BITS_PER_DIGIT) + d[vnd];
+
+#ifndef SC_MAX_NBITS
+    delete [] d;
+#endif
+
+  }
+  else {
+
+    while (--vnd >= 0)
+      v = (v << BITS_PER_DIGIT) + digit[vnd];
+
+  }
+
+  return v;
+}
+
+
+// Convert to double.
+double
+CLASS_TYPE::to_double() const
+{
+  if (sgn == SC_ZERO)
+    return (double) 0.0;
+
+  int vnd = ndigits;
+
+  double v = 0.0;
+  while (--vnd >= 0)
+    v = v * DIGIT_RADIX + digit[vnd];
+
+  if (sgn == SC_NEG)
+    return -v;
+  else
+    return v;
+}
+
+
+// Return true if the bit i is 1, false otherwise. If i is outside the
+// bounds, return 1/0 according to the sign of the number by assuming
+// that the number has infinite length.
+
+bool
+CLASS_TYPE::test(int i) const
+{
+#ifdef SC_SIGNED
+  if (check_if_outside(i)) {
+    if (sgn == SC_NEG)
+      return 1;
+    else
+      return 0;
+  }
+#else
+  if (check_if_outside(i))
+    return 0;
+#endif  
+
+  int bit_num = bit_ord(i);
+  int digit_num = digit_ord(i);
+
+  if (sgn == SC_NEG) {
+
+#ifdef SC_MAX_NBITS
+    sc_digit d[MAX_NDIGITS];
+#else
+    sc_digit *d = new sc_digit[ndigits];
+#endif
+
+    vec_copy(ndigits, d, digit);
+    vec_complement(ndigits, d);
+    bool val = ((d[digit_num] & one_and_zeros(bit_num)) != 0);
+
+#ifndef SC_MAX_NBITS
+    delete [] d;
+#endif
+
+    return val;
+
+  }
+  else 
+    return ((digit[digit_num] & one_and_zeros(bit_num)) != 0);
+}
+
+
+// Set the ith bit with 1.
+void 
+CLASS_TYPE::set(int i) 
+{
+  if (check_if_outside(i))
+    return;
+
+  int bit_num = bit_ord(i);
+  int digit_num = digit_ord(i);
+
+  convert_SM_to_2C();
+  digit[digit_num] |= one_and_zeros(bit_num);    
+  digit[digit_num] &= DIGIT_MASK; // Needed to zero the overflow bits.
+  convert_2C_to_SM();
+}
+
+
+// Set the ith bit with 0, i.e., clear the ith bit.
+void 
+CLASS_TYPE::clear(int i)
+{
+  if (check_if_outside(i))
+    return;
+
+  int bit_num = bit_ord(i);
+  int digit_num = digit_ord(i);
+
+  convert_SM_to_2C();
+  digit[digit_num] &= ~(one_and_zeros(bit_num));
+  digit[digit_num] &= DIGIT_MASK; // Needed to zero the overflow bits.
+  convert_2C_to_SM();
+}
+
+
+// Create a mirror image of the number.
+void
+CLASS_TYPE::reverse()
+{
+  convert_SM_to_2C();
+  vec_reverse(length(), ndigits, digit, length() - 1);
+  convert_2C_to_SM();
+}
+
+
+// Get a packed bit representation of the number.
+void 
+CLASS_TYPE::get_packed_rep(sc_digit *buf) const
+{
+  int buf_ndigits = (length() - 1) / BITS_PER_DIGIT_TYPE + 1;
+
+  // Initialize buf to zero.
+  vec_zero(buf_ndigits, buf);
+
+  if (sgn == SC_ZERO)
+    return;
+
+  const sc_digit *digit_or_d;
+#ifdef SC_MAX_NBITS
+  sc_digit d[MAX_NDIGITS];
+#else
+  sc_digit *d = new sc_digit[ndigits];
+#endif
+
+  if (sgn == SC_POS)
+    digit_or_d = digit;
+
+  else 
+  {
+    // If sgn is negative, we have to convert digit to its 2's
+    // complement. Since this function is const, we can not do it on
+    // digit. Since buf doesn't have overflow bits, we cannot also do
+    // it on buf. Thus, we have to do the complementation on a copy of
+    // digit, i.e., on d.
+
+    vec_copy(ndigits, d, digit);
+    vec_complement(ndigits, d);
+
+    buf[buf_ndigits - 1] = ~((sc_digit) 0);
+
+    digit_or_d = d;
+
+  }
+
+  // Copy the bits from digit to buf. The division and mod operations
+  // below can be converted to addition/subtraction and comparison
+  // operations at the expense of complicating the code. We can do it
+  // if we see any performance problems.
+
+  for (int i = length() - 1; i >= 0; --i) {
+
+    if ((digit_or_d[digit_ord(i)] & one_and_zeros(bit_ord(i))) != 0) // Test.
+
+      buf[i / BITS_PER_DIGIT_TYPE] |= 
+        one_and_zeros(i % BITS_PER_DIGIT_TYPE); // Set.
+
+    else  
+
+      buf[i / BITS_PER_DIGIT_TYPE] &= 
+        ~(one_and_zeros(i % BITS_PER_DIGIT_TYPE));  // Clear.
+
+  }
+
+#ifndef SC_MAX_NBITS
+    delete[] d;
+#endif
+}
+
+
+// Set a packed bit representation of the number.
+void 
+CLASS_TYPE::set_packed_rep(sc_digit *buf)
+{
+  // Initialize digit to zero.
+  vec_zero(ndigits, digit);
+
+  // Copy the bits from buf to digit.
+  for (int i = length() - 1; i >= 0; --i) {
+
+    if ((buf[i / BITS_PER_DIGIT_TYPE] & 
+         one_and_zeros(i % BITS_PER_DIGIT_TYPE)) != 0) // Test.
+
+      digit[digit_ord(i)] |= one_and_zeros(bit_ord(i));     // Set.
+
+    else  
+
+      digit[digit_ord(i)] &= ~(one_and_zeros(bit_ord(i)));  // Clear
+
+  }
+
+  convert_2C_to_SM();
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Private members.
+// ----------------------------------------------------------------------------
+
+// Create a copy of v with sgn s.
+CLASS_TYPE::CLASS_TYPE(const CLASS_TYPE& v, small_type s) :
+    sc_value_base(v), sgn(s), nbits(v.nbits), ndigits(v.ndigits), digit()
+{
+#ifndef SC_MAX_NBITS
+  digit = new sc_digit[ndigits];
+#endif
+
+  vec_copy(ndigits, digit, v.digit);
+}
+
+
+// Create a copy of v where v is of the different type.
+CLASS_TYPE::CLASS_TYPE(const OTHER_CLASS_TYPE& v, small_type s) :
+    sc_value_base(v), sgn(s), nbits(num_bits(v.nbits)), ndigits(), digit()
+{
+#if (IF_SC_SIGNED == 1)
+  ndigits = v.ndigits;
+#else
+  ndigits = DIV_CEIL(nbits);
+#endif
+
+#ifndef SC_MAX_NBITS
+  digit = new sc_digit[ndigits];
+#endif
+
+  copy_digits(v.nbits, v.ndigits, v.digit);
+}
+
+
+// Create a signed number with (s, nb, nd, d) as its attributes (as
+// defined in class CLASS_TYPE). If alloc is set, delete d.
+CLASS_TYPE::CLASS_TYPE(small_type s, int nb, 
+                       int nd, sc_digit *d, 
+                       bool alloc) :
+    sc_value_base(), sgn(s), nbits(num_bits(nb)), ndigits(), digit()
+{
+  ndigits = DIV_CEIL(nbits);
+
+#ifndef SC_MAX_NBITS
+  digit = new sc_digit[ndigits];
+#endif
+
+  if (ndigits <= nd)
+    vec_copy(ndigits, digit, d);
+  else
+    vec_copy_and_zero(ndigits, digit, nd, d);
+
+#ifndef SC_MAX_NBITS
+  if (alloc)
+    delete [] d;
+#endif
+}
+
+// This constructor is mainly used in finding a "range" of bits from a
+// number of type CLASS_TYPE. The function range(l, r) can have
+// arbitrary precedence between l and r. If l is smaller than r, then
+// the output is the reverse of range(r, l). 
+CLASS_TYPE::CLASS_TYPE(const CLASS_TYPE* u, int l, int r) :
+    sc_value_base(), sgn(), nbits(), ndigits(), digit()
+{
+  bool reversed = false;
+
+  if( l < r ) {
+    reversed = true;
+    int tmp = l;
+    l = r;
+    r = tmp;
+  }
+
+  // at this point, l >= r
+
+  // make sure that l and r point to the bits of u
+  r = sc_max( r, 0 );
+  l = sc_min( l, u->nbits - 1 );
+    
+  nbits = num_bits( l - r + 1 );
+
+  // nbits can still be <= 0 because l and r have just been updated
+  // with the bounds of u.
+
+  // if u == 0 or the range is out of bounds, return 0
+  if( u->sgn == SC_ZERO || nbits <= num_bits( 0 ) ) {
+    sgn = SC_ZERO;
+    if( nbits <= num_bits( 0 ) ) {
+      nbits = 1;
+    }
+    ndigits = DIV_CEIL( nbits );
+#ifndef SC_MAX_NBITS
+    digit = new sc_digit[ndigits];
+#endif
+    vec_zero( ndigits, digit );
+    return;
+  }
+
+  // The rest will be executed if u is not zero.
+
+  ndigits = DIV_CEIL(nbits);
+  
+  // The number of bits up to and including l and r, respectively.
+  int nl = l + 1; 
+  int nr = r + 1; 
+  
+  // The indices of the digits that have lth and rth bits, respectively.
+  int left_digit = DIV_CEIL(nl) - 1;
+  int right_digit = DIV_CEIL(nr) - 1;
+  
+  int nd;
+
+  // The range is performed on the 2's complement representation, so
+  // first get the indices for that.
+  if (u->sgn == SC_NEG)
+    nd = left_digit + 1;
+  else
+    nd = left_digit - right_digit + 1;
+
+  // Allocate memory for the range.
+#ifdef SC_MAX_NBITS
+  sc_digit d[MAX_NDIGITS];
+#else
+  digit = new sc_digit[ndigits];
+  sc_digit *d = new sc_digit[nd];
+#endif
+  
+  // Getting the range on the 2's complement representation.
+  if (u->sgn == SC_NEG) {
+    
+    vec_copy(nd, d, u->digit);
+    vec_complement(nd, d);  // d = -d;
+    vec_shift_right(nd, d, r, DIGIT_MASK);
+    
+  }
+  else {
+    
+    for (int i = right_digit; i <= left_digit; ++i)
+      d[i - right_digit] = u->digit[i];
+    
+    vec_shift_right(nd, d, r - right_digit * BITS_PER_DIGIT, 0);
+    
+  }
+  
+  vec_zero(ndigits, digit);
+
+  if (! reversed)
+    vec_copy(sc_min(nd, ndigits), digit, d);
+  
+  else {
+
+    // If l < r, i.e., reversed is set, reverse the bits of digit.  d
+    // will be used as a temporary store. The following code tries to
+    // minimize the use of bit_ord and digit_ord, which use mod and
+    // div operators. Since these operators are function calls to
+    // standard library routines, they are slow. The main idea in
+    // reversing is "read bits out of d from left to right and push
+    // them into digit using right shifting."
+
+    // Take care of the last digit.
+    int nd_less_1 = nd - 1;
+
+    // Deletions will start from the left end and move one position
+    // after each deletion.
+    sc_digit del_mask = one_and_zeros(bit_ord(l - r));
+      
+    while (del_mask) {
+      vec_shift_right(ndigits, digit, 1, ((d[nd_less_1] & del_mask) != 0));
+      del_mask >>= 1;
+    }
+
+    // Take care of the other digits if any.
+
+    // Insertion to digit will always occur at the left end.
+    sc_digit ins_mask = one_and_zeros(BITS_PER_DIGIT - 1);
+
+    for (int j = nd - 2; j >= 0; --j) { // j = nd - 2
+
+      // Deletions will start from the left end and move one position
+      // after each deletion.
+      del_mask = ins_mask;
+
+      while (del_mask) {
+        vec_shift_right(ndigits, digit, 1, ((d[j] & del_mask) != 0));
+        del_mask >>= 1;
+      }
+    }
+
+    if (u->sgn == SC_NEG)
+      vec_shift_right(ndigits, digit, 
+                      ndigits * BITS_PER_DIGIT - length(), DIGIT_MASK);
+    else
+      vec_shift_right(ndigits, digit, 
+                      ndigits * BITS_PER_DIGIT - length(), 0);
+
+
+  }  // if reversed.
+
+  convert_2C_to_SM();
+  
+#ifndef SC_MAX_NBITS
+  delete [] d;
+#endif
+}
+
+// This constructor is mainly used in finding a "range" of bits from a
+// number of type OTHER_CLASS_TYPE. The function range(l, r) can have
+// arbitrary precedence between l and r. If l is smaller than r, then
+// the output is the reverse of range(r, l). 
+CLASS_TYPE::CLASS_TYPE(const OTHER_CLASS_TYPE* u, int l, int r) :
+    sc_value_base(), sgn(), nbits(), ndigits(), digit()
+{
+  bool reversed = false;
+
+  if( l < r ) {
+    reversed = true;
+    int tmp = l;
+    l = r;
+    r = tmp;
+  }
+
+  // at this point, l >= r
+
+  // make sure that l and r point to the bits of u
+  r = sc_max( r, 0 );
+  l = sc_min( l, u->nbits - 1 );
+    
+  nbits = num_bits( l - r + 1 );
+
+  // nbits can still be <= 0 because l and r have just been updated
+  // with the bounds of u.
+
+  // if u == 0 or the range is out of bounds, return 0
+  if( u->sgn == SC_ZERO || nbits <= num_bits( 0 ) ) {
+    sgn = SC_ZERO;
+    if( nbits <= num_bits( 0 ) ) {
+      nbits = 1;
+    }
+    ndigits = DIV_CEIL( nbits );
+#ifndef SC_MAX_NBITS
+    digit = new sc_digit[ndigits];
+#endif
+    vec_zero( ndigits, digit );
+    return;
+  }
+
+  // The rest will be executed if u is not zero.
+
+  ndigits = DIV_CEIL(nbits);
+  
+  // The number of bits up to and including l and r, respectively.
+  int nl = l + 1; 
+  int nr = r + 1; 
+  
+  // The indices of the digits that have lth and rth bits, respectively.
+  int left_digit = DIV_CEIL(nl) - 1;
+  int right_digit = DIV_CEIL(nr) - 1;
+  
+  int nd;
+
+  // The range is performed on the 2's complement representation, so
+  // first get the indices for that.
+  if (u->sgn == SC_NEG)
+    nd = left_digit + 1;
+  else
+    nd = left_digit - right_digit + 1;
+
+  // Allocate memory for the range.
+#ifdef SC_MAX_NBITS
+  sc_digit d[MAX_NDIGITS];
+#else
+  digit = new sc_digit[ndigits];
+  sc_digit *d = new sc_digit[nd];
+#endif
+  
+  // Getting the range on the 2's complement representation.
+  if (u->sgn == SC_NEG) {
+    
+    vec_copy(nd, d, u->digit);
+    vec_complement(nd, d);  // d = -d;
+    vec_shift_right(nd, d, r, DIGIT_MASK);
+    
+  }
+  else {
+    
+    for (int i = right_digit; i <= left_digit; ++i)
+      d[i - right_digit] = u->digit[i];
+    
+    vec_shift_right(nd, d, r - right_digit * BITS_PER_DIGIT, 0);
+    
+  }
+  
+  vec_zero(ndigits, digit);
+
+  if (! reversed)
+    vec_copy(sc_min(nd, ndigits), digit, d);
+  
+  else {
+
+    // If l < r, i.e., reversed is set, reverse the bits of digit.  d
+    // will be used as a temporary store. The following code tries to
+    // minimize the use of bit_ord and digit_ord, which use mod and
+    // div operators. Since these operators are function calls to
+    // standard library routines, they are slow. The main idea in
+    // reversing is "read bits out of d from left to right and push
+    // them into digit using right shifting."
+
+    // Take care of the last digit.
+    int nd_less_1 = nd - 1;
+
+    // Deletions will start from the left end and move one position
+    // after each deletion.
+    sc_digit del_mask = one_and_zeros(bit_ord(l - r));
+      
+    while (del_mask) {
+      vec_shift_right(ndigits, digit, 1, ((d[nd_less_1] & del_mask) != 0));
+      del_mask >>= 1;
+    }
+
+    // Take care of the other digits if any.
+
+    // Insertion to digit will always occur at the left end.
+    sc_digit ins_mask = one_and_zeros(BITS_PER_DIGIT - 1);
+
+    for (int j = nd - 2; j >= 0; --j) { // j = nd - 2
+
+      // Deletions will start from the left end and move one position
+      // after each deletion.
+      del_mask = ins_mask;
+
+      while (del_mask) {
+        vec_shift_right(ndigits, digit, 1, ((d[j] & del_mask) != 0));
+        del_mask >>= 1;
+      }
+    }
+
+    if (u->sgn == SC_NEG)
+      vec_shift_right(ndigits, digit, 
+                      ndigits * BITS_PER_DIGIT - length(), DIGIT_MASK);
+    else
+      vec_shift_right(ndigits, digit, 
+                      ndigits * BITS_PER_DIGIT - length(), 0);
+
+
+  }  // if reversed.
+
+  convert_2C_to_SM();
+  
+#ifndef SC_MAX_NBITS
+  delete [] d;
+#endif
+}
+
+
+// Print out all the physical attributes.
+void
+CLASS_TYPE::dump(::std::ostream& os) const
+{
+  // Save the current setting, and set the base to decimal.
+#if defined(__MINGW32__)
+  std::_Ios_Fmtflags old_flags = os.setf(::std::ios::dec,::std::ios::basefield);
+#else
+  fmtflags old_flags = os.setf(::std::ios::dec, ::std::ios::basefield);
+#endif
+
+  os << "width = " << length() << ::std::endl;
+  os << "value = " << *this << ::std::endl;
+  os << "bits  = ";
+
+  int len = length();
+
+  for (int i = len - 1; i >= 0; --i) {
+
+    os << "01"[test(i)];
+    if (--len % 4 == 0)
+      os << " ";
+
+  }
+
+  os << ::std::endl;
+
+  // Restore old_flags.
+  os.setf(old_flags, ::std::ios::basefield);
+}
+
+
+// Checks to see if bit_num is out of bounds.
+bool
+CLASS_TYPE::check_if_outside(int bit_num) const
+{
+  if ((bit_num < 0) || (num_bits(bit_num) >= nbits)) {
+
+#ifdef DEBUG_SYSTEMC
+      if( bit_num < 0 || bit_num >= nbits ) {
+	  char msg[BUFSIZ];
+	  std::sprintf( msg, "%s::check_if_outside( int bit_num ) : "
+		   "bit_num = %d is out of bounds",
+		   CLASS_TYPE_STR, bit_num );
+	  SC_REPORT_WARNING( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
+      }
+#endif
+
+    return true;
+  }
+
+  return false;
+}
+
+// End of file.
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_nbdefs.cpp b/ext/systemc/src/sysc/datatypes/int/sc_nbdefs.cpp
new file mode 100644
index 000000000..48f2d39de
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_nbdefs.cpp
@@ -0,0 +1,93 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_nbdefs.h -- Top level header file for arbitrary precision signed/unsigned
+                 arithmetic. This file defines all the constants needed.
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+  
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_nbdefs.cpp,v $
+// Revision 1.3  2011/02/18 20:19:15  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.2  2009/05/22 16:06:29  acg
+//  Andy Goodrich: process control updates.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:49:32  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#include "sysc/datatypes/int/sc_nbdefs.h"
+
+
+namespace sc_dt
+{
+
+#ifdef SC_MAX_NBITS
+const int MAX_NDIGITS      = DIV_CEIL(SC_MAX_NBITS) + 2;
+// Consider a number with x bits another with y bits. The maximum
+// number of bits happens when we multiply them. The result will have
+// (x + y) bits. Assume that x + y <= SC_MAX_NBITS. Then, DIV_CEIL(x) +
+// DIV_CEIL(y) <= DIV_CEIL(SC_MAX_NBITS) + 2. This is the reason for +2
+// above. With this change, MAX_NDIGITS must be enough to hold the
+// result of any operation.
+#endif
+
+// Support for the long long type. This type is not in the standard
+// but is usually supported by compilers.
+#if !defined(_WIN32) || defined(__MINGW32__)
+const uint64 UINT64_ZERO   = 0ULL;
+const uint64 UINT64_ONE    = 1ULL;
+const uint64 UINT64_32ONES = 0x00000000ffffffffULL;
+#else
+const uint64 UINT64_ZERO   = 0i64;
+const uint64 UINT64_ONE    = 1i64;
+const uint64 UINT64_32ONES = 0x00000000ffffffffi64;
+#endif
+
+const small_type NB_DEFAULT_BASE = SC_DEC;
+
+#ifndef _32BIT_
+const uint64 UINT_ZERO = UINT64_ZERO;
+const uint64 UINT_ONE  = UINT64_ONE;
+#else
+const unsigned int UINT_ZERO = 0U;
+const unsigned int UINT_ONE  = 1U;
+#endif
+
+} // namespace sc_dt
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_nbdefs.h b/ext/systemc/src/sysc/datatypes/int/sc_nbdefs.h
new file mode 100644
index 000000000..0d70b74ea
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_nbdefs.h
@@ -0,0 +1,282 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_nbdefs.h -- Top level header file for arbitrary precision signed/unsigned
+                 arithmetic. This file defines all the constants needed.
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+  
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_nbdefs.h,v $
+// Revision 1.7  2011/02/18 20:19:15  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.6  2011/02/18 20:09:34  acg
+//  Philipp A. Hartmann: added alternative #define for Windows to guard.
+//
+// Revision 1.5  2011/01/20 16:52:20  acg
+//  Andy Goodrich: changes for IEEE 1666 2011.
+//
+// Revision 1.4  2010/02/08 18:35:55  acg
+//  Andy Goodrich: Philipp Hartmann's changes for Solaris and Linux 64.
+//
+// Revision 1.2  2009/05/22 16:06:29  acg
+//  Andy Goodrich: process control updates.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:49:32  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#ifndef SC_NBDEFS_H
+#define SC_NBDEFS_H
+
+
+#include "sysc/kernel/sc_cmnhdr.h"
+
+#include <climits>
+
+#if defined(__sun) || defined(__sun__)
+#  include <inttypes.h>
+#elif !defined(WIN32) && !defined(_WIN32)
+#  include <stdint.h>
+#endif
+
+#include "sysc/utils/sc_iostream.h"
+#include "sysc/kernel/sc_constants.h"   // For SC_MAX_NBITS
+
+// Activate support mixed operands for concatenation via the comma operator
+#define SC_DT_MIXED_COMMA_OPERATORS
+
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  ENUM : sc_numrep
+//
+//  Enumeration of number representations for character string conversion.
+// ----------------------------------------------------------------------------
+
+enum sc_numrep
+{
+    SC_NOBASE = 0,
+    SC_BIN    = 2,
+    SC_OCT    = 8,
+    SC_DEC    = 10,
+    SC_HEX    = 16,
+    SC_BIN_US,
+    SC_BIN_SM,
+    SC_OCT_US,
+    SC_OCT_SM,
+    SC_HEX_US,
+    SC_HEX_SM,
+    SC_CSD
+};
+
+
+// Sign of a number:
+#define SC_NEG       -1     // Negative number
+#define SC_ZERO      0      // Zero
+#define SC_POS       1      // Positive number
+#define SC_NOSIGN    2      // Uninitialized sc_signed number
+
+typedef unsigned char uchar;
+
+// A small_type number is at least a char. Defining an int is probably
+// better for alignment.
+typedef int small_type;
+
+// Attributes of a byte.
+#define BITS_PER_BYTE   8
+#define BYTE_RADIX      256
+#define BYTE_MASK       255
+
+// LOG2_BITS_PER_BYTE = log2(BITS_PER_BYTE), assuming that
+// BITS_PER_BYTE is a power of 2.
+#define LOG2_BITS_PER_BYTE 3
+
+// Attributes of the unsigned long. These definitions are used mainly in
+// the functions that are aware of the internal representation of
+// digits, e.g., get/set_packed_rep().
+#define BYTES_PER_DIGIT_TYPE  4
+#define BITS_PER_DIGIT_TYPE   32
+
+// Attributes of a digit, i.e., unsigned long less the overflow bits.
+#define BYTES_PER_DIGIT 4
+#define BITS_PER_DIGIT  30
+#define DIGIT_RADIX     (1ul << BITS_PER_DIGIT)
+#define DIGIT_MASK      (DIGIT_RADIX - 1)
+// Make sure that BYTES_PER_DIGIT = ceil(BITS_PER_DIGIT / BITS_PER_BYTE).
+
+// Similar attributes for the half of a digit. Note that
+// HALF_DIGIT_RADIX is equal to the square root of DIGIT_RADIX. These
+// definitions are used mainly in the multiplication routines.
+#define BITS_PER_HALF_DIGIT (BITS_PER_DIGIT / 2)
+#define HALF_DIGIT_RADIX    (1ul << BITS_PER_HALF_DIGIT)
+#define HALF_DIGIT_MASK     (HALF_DIGIT_RADIX - 1)
+
+// DIV_CEIL2(x, y) = ceil(x / y). x and y are positive numbers.
+#define DIV_CEIL2(x, y) (((x) - 1) / (y) + 1)
+
+// DIV_CEIL(x) = ceil(x / BITS_PER_DIGIT) = the number of digits to
+// store x bits. x is a positive number.
+#define DIV_CEIL(x) DIV_CEIL2(x, BITS_PER_DIGIT)
+
+#ifdef SC_MAX_NBITS
+extern const int MAX_NDIGITS;
+// Consider a number with x bits another with y bits. The maximum
+// number of bits happens when we multiply them. The result will have
+// (x + y) bits. Assume that x + y <= SC_MAX_NBITS. Then, DIV_CEIL(x) +
+// DIV_CEIL(y) <= DIV_CEIL(SC_MAX_NBITS) + 2. This is the reason for +2
+// above. With this change, MAX_NDIGITS must be enough to hold the
+// result of any operation.
+#endif
+
+// Support for "digit" vectors used to hold the values of sc_signed,
+// sc_unsigned, sc_bv_base,  and sc_lv_base data types. This type is also used 
+// in the concatenation support. An sc_digit is currently an unsigned 32-bit 
+// quantity. The typedef used is an unsigned int, rather than an unsigned long,
+// since the unsigned long data type varies in size between 32-bit and 64-bit 
+// machines.
+
+typedef unsigned int sc_digit;	// 32-bit unsigned integer
+
+// Support for the long long type. This type is not in the standard
+// but is usually supported by compilers.
+#ifndef _WIN32
+#   if defined(__x86_64__)
+        typedef long long          int64;
+        typedef unsigned long long uint64;
+#   else
+        typedef int64_t            int64;
+        typedef uint64_t           uint64;
+#   endif
+    extern const uint64        UINT64_ZERO;
+    extern const uint64        UINT64_ONE;
+    extern const uint64        UINT64_32ONES;
+#else
+    typedef __int64            int64;
+    typedef unsigned __int64   uint64;
+    extern const uint64        UINT64_ZERO;
+    extern const uint64        UINT64_ONE;
+    extern const uint64        UINT64_32ONES;
+#endif
+
+
+// Bits per ...
+// will be deleted in the future. Use numeric_limits instead
+#define BITS_PER_CHAR    8
+#define BITS_PER_INT    (sizeof(int) * BITS_PER_CHAR)
+#define BITS_PER_LONG   (sizeof(long) * BITS_PER_CHAR)
+#define BITS_PER_INT64  (sizeof(::sc_dt::int64) * BITS_PER_CHAR)
+#define BITS_PER_UINT   (sizeof(unsigned int) * BITS_PER_CHAR)
+#define BITS_PER_ULONG  (sizeof(unsigned long) * BITS_PER_CHAR)
+#define BITS_PER_UINT64 (sizeof(::sc_dt::uint64) * BITS_PER_CHAR)
+
+// Digits per ...
+#define DIGITS_PER_CHAR   1
+#define DIGITS_PER_INT    ((BITS_PER_INT+29)/30)
+#define DIGITS_PER_LONG   ((BITS_PER_LONG+29)/30)
+#define DIGITS_PER_INT64  ((BITS_PER_INT64+29)/30)
+#define DIGITS_PER_UINT   ((BITS_PER_UINT+29)/30)
+#define DIGITS_PER_ULONG  ((BITS_PER_ULONG+29)/30)
+#define DIGITS_PER_UINT64 ((BITS_PER_UINT64+29)/30)
+
+// Above, BITS_PER_X is mainly used for sc_signed, and BITS_PER_UX is
+// mainly used for sc_unsigned.
+
+#if defined( _WIN32 ) || defined( __HP_aCC )
+typedef unsigned long fmtflags;
+#else
+typedef ::std::ios::fmtflags fmtflags;
+#endif
+
+extern const small_type NB_DEFAULT_BASE ;
+
+// For sc_int code:
+#define LLWIDTH  BITS_PER_INT64
+#define INTWIDTH BITS_PER_INT
+
+#ifndef _32BIT_
+
+typedef int64 int_type;
+typedef uint64 uint_type;
+#define SC_INTWIDTH 64
+extern const uint64 UINT_ZERO;
+extern const uint64 UINT_ONE;
+
+#else
+
+typedef int int_type;
+typedef unsigned int uint_type;
+#define SC_INTWIDTH 32
+extern const unsigned int UINT_ZERO;
+extern const unsigned int UINT_ONE;
+
+#endif
+
+
+#if defined(_MSC_VER) && ( _MSC_VER < 1300 )
+    // VC++6 bug
+    ::std::ostream& operator << ( ::std::ostream&, int64 );
+    ::std::ostream& operator << ( ::std::ostream&, uint64 );
+#endif
+
+} // namespace sc_dt
+
+
+#if defined(_MSC_VER) && ( _MSC_VER < 1300 )
+
+    inline
+    ::std::ostream&
+    operator << ( ::std::ostream& os, sc_dt::int64 a )
+    {
+	sc_dt::operator << ( os, a );
+	return os;
+    }
+
+    inline
+    ::std::ostream&
+    operator << ( ::std::ostream& os, sc_dt::uint64 a )
+    {
+	sc_dt::operator << ( os, a );
+	return os;
+    }
+
+#endif
+
+
+#endif
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_nbexterns.cpp b/ext/systemc/src/sysc/datatypes/int/sc_nbexterns.cpp
new file mode 100644
index 000000000..245df73b8
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_nbexterns.cpp
@@ -0,0 +1,894 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_nbexterns.cpp -- External functions for both sc_signed and sc_unsigned
+                      classes. These functions work on two parameters u and
+                      v, and copy the result to the first parameter u. This
+                      is also the reason that they are suffixed with _on_help.
+ 
+  Original Author: Ali Dasdan, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_nbexterns.cpp,v $
+// Revision 1.2  2011/02/18 20:19:15  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:49:32  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#include "sysc/datatypes/int/sc_nbexterns.h"
+#include "sysc/kernel/sc_macros.h"
+
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  SECTION: External functions for PLUS operators.
+// ----------------------------------------------------------------------------
+
+// Handles the cases 3 and 4 and returns the result in u.
+void
+add_on_help(small_type &us, int /* unb */, int und,
+            sc_digit *ud, 
+            small_type vs, int /* vnb */, int vnd,
+            const sc_digit *vd)
+{
+
+  vnd = vec_skip_leading_zeros(vnd, vd);
+
+  if (us == vs) {  // case 3
+
+    if (und >= vnd)
+      vec_add_on(und, ud, vnd, vd);
+    else
+      vec_add_on2(und, ud, vnd, vd);
+
+  }
+  else {  // case 4
+
+    // vec_cmp expects that und is the number of non-zero digits in ud.
+    int new_und = vec_skip_leading_zeros(und, ud); 
+    int cmp_res = vec_cmp(new_und, ud, vnd, vd);
+
+    if (cmp_res == 0)  { // u == v
+      us = SC_ZERO;
+      vec_zero(und, ud);
+      return;
+    }
+
+    if (cmp_res > 0) // u > v
+      vec_sub_on(und, ud, vnd, vd);
+
+    else { // u < v
+      us = -us;
+      vec_sub_on2(und, ud, vnd, vd);
+    }
+
+  }
+}
+
+
+// ----------------------------------------------------------------------------
+
+/* 
+
+mul_on_help_signed and mul_on_help_unsigned have the same body except
+that CONVERT_SM_to_2C_to_SM and COPY_DIGITS are defined for signed and
+unsigned, respectively.  This comment also applies to the
+signed/unsigned versions of div_on_help and mod_on_help. It is
+possible to take COPY_DIGITS out of these functions and create a
+single version of each of these helper functions; however, this will
+impose an onverhead on performance. In the versions below, any change
+in the signed version of a helper function must be carried to a
+corresponding change in the unsigned verion of the same function or
+vice versa.
+
+*/
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: External functions of MULTIPLICATION operators.
+// ----------------------------------------------------------------------------
+
+void
+mul_on_help_signed(small_type &us, 
+                   int unb, int und, 
+                   sc_digit *ud, 
+                   int vnb, int vnd,
+                   const sc_digit *vd)
+{
+#define CONVERT_SM_to_2C_to_SM convert_signed_SM_to_2C_to_SM
+#define COPY_DIGITS copy_digits_signed
+
+  {  // Body of mul_on_help
+
+    int old_und = und;
+
+    und = vec_skip_leading_zeros(und, ud);
+    vnd = vec_skip_leading_zeros(vnd, vd);
+    
+    sc_digit ud0 = (*ud);
+    sc_digit vd0 = (*vd);
+    
+    if ((vnd == 1) && (vd0 == 1)) {
+      us = CONVERT_SM_to_2C_to_SM(us, unb, old_und, ud);
+      return;
+    }
+    
+    if ((und == 1) && (ud0 == 1)) {
+      COPY_DIGITS(us, unb, old_und, ud, vnb, vnd, vd);
+      return;
+    }
+    
+    if ((und == 1) && (vnd == 1) && 
+        (ud0 < HALF_DIGIT_RADIX) && (vd0 < HALF_DIGIT_RADIX)) {
+      
+      sc_digit d = ud0 * vd0;
+      COPY_DIGITS(us, unb, old_und, ud, unb + vnb, 1, &d);
+      return;
+      
+    }
+    
+    int nd = und + vnd;
+    
+#ifdef SC_MAX_NBITS
+    sc_digit d[MAX_NDIGITS];
+#else
+    sc_digit *d = new sc_digit[nd];
+#endif
+  
+    vec_zero(nd, d);
+    
+    if ((und == 1) && (ud0 < HALF_DIGIT_RADIX))
+      vec_mul_small(vnd, vd, ud0, d);
+    
+    else if ((vnd == 1) && (vd0 < HALF_DIGIT_RADIX))
+      vec_mul_small(und, ud, vd0, d);
+    
+    else if (vnd < und)
+      vec_mul(und, ud, vnd, vd, d);
+    
+    else
+      vec_mul(vnd, vd, und, ud, d);
+    
+    COPY_DIGITS(us, unb, old_und, ud, unb + vnb, nd, d);
+    
+#ifndef SC_MAX_NBITS
+    delete [] d;
+#endif
+    
+  }
+
+#undef COPY_DIGITS
+#undef CONVERT_SM_to_2C_to_SM
+
+}
+
+
+void
+mul_on_help_unsigned(small_type &us, 
+                     int unb, int und, 
+                     sc_digit *ud, 
+                     int vnb, int vnd,
+                     const sc_digit *vd)
+{
+#define CONVERT_SM_to_2C_to_SM convert_unsigned_SM_to_2C_to_SM
+#define COPY_DIGITS copy_digits_unsigned
+
+  {  // Body of mul_on_help
+
+    int old_und = und;
+
+    und = vec_skip_leading_zeros(und, ud);
+    vnd = vec_skip_leading_zeros(vnd, vd);
+    
+    sc_digit ud0 = (*ud);
+    sc_digit vd0 = (*vd);
+    
+    if ((vnd == 1) && (vd0 == 1)) {
+      us = CONVERT_SM_to_2C_to_SM(us, unb, old_und, ud);
+      return;
+    }
+    
+    if ((und == 1) && (ud0 == 1)) {
+      COPY_DIGITS(us, unb, old_und, ud, vnb, vnd, vd);
+      return;
+    }
+    
+    if ((und == 1) && (vnd == 1) && 
+        (ud0 < HALF_DIGIT_RADIX) && (vd0 < HALF_DIGIT_RADIX)) {
+      
+      sc_digit d = ud0 * vd0;
+      COPY_DIGITS(us, unb, old_und, ud, unb + vnb, 1, &d);
+      return;
+      
+    }
+    
+    int nd = und + vnd;
+    
+#ifdef SC_MAX_NBITS
+    sc_digit d[MAX_NDIGITS];
+#else
+    sc_digit *d = new sc_digit[nd];
+#endif
+  
+    vec_zero(nd, d);
+    
+    if ((und == 1) && (ud0 < HALF_DIGIT_RADIX))
+      vec_mul_small(vnd, vd, ud0, d);
+    
+    else if ((vnd == 1) && (vd0 < HALF_DIGIT_RADIX))
+      vec_mul_small(und, ud, vd0, d);
+    
+    else if (vnd < und)
+      vec_mul(und, ud, vnd, vd, d);
+    
+    else
+      vec_mul(vnd, vd, und, ud, d);
+    
+    COPY_DIGITS(us, unb, old_und, ud, unb + vnb, nd, d);
+    
+#ifndef SC_MAX_NBITS
+    delete [] d;
+#endif
+    
+  }
+
+#undef COPY_DIGITS
+#undef CONVERT_SM_to_2C_to_SM
+
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: External functions for DIVISION operators.
+// ----------------------------------------------------------------------------
+
+void
+div_on_help_signed(small_type &us, 
+                   int unb, int und, 
+                   sc_digit *ud, 
+                   int vnb, int vnd,
+                   const sc_digit *vd)
+{
+#define CONVERT_SM_to_2C_to_SM convert_signed_SM_to_2C_to_SM
+#define COPY_DIGITS copy_digits_signed
+
+  {  // Body of div_on_help
+
+    int old_und = und;
+    
+    und = vec_skip_leading_zeros(und, ud);
+    vnd = vec_skip_leading_zeros(vnd, vd);
+    
+    int cmp_res = vec_cmp(und, ud, vnd, vd);
+    
+    if (cmp_res < 0) { // u < v => u / v = 0 - case 4
+      us = SC_ZERO;
+      vec_zero(old_und, ud);
+      return;
+    }
+    
+    sc_digit vd0 = (*vd);
+    
+    if ((cmp_res > 0) && (vnd == 1) && (vd0 == 1))  {
+      us = CONVERT_SM_to_2C_to_SM(us, unb, old_und, ud);
+      return;
+    }
+    
+    // One extra digit for d is allocated to simplify vec_div_*().
+    int nd = sc_max(und, vnd) + 1;
+    
+#ifdef SC_MAX_NBITS
+    sc_digit d[MAX_NDIGITS + 1];
+#else
+    sc_digit *d = new sc_digit[nd];
+#endif
+    
+    vec_zero(nd, d);
+    
+    // u = v => u / v = 1 - case 3
+    if (cmp_res == 0)
+      d[0] = 1;
+    
+    else if ((vnd == 1) && (und == 1))
+      d[0] = (*ud) / vd0;
+    
+    else if ((vnd == 1) && (vd0 < HALF_DIGIT_RADIX))
+      vec_div_small(und, ud, vd0, d);
+    
+    else
+      vec_div_large(und, ud, vnd, vd, d);
+    
+    COPY_DIGITS(us, unb, old_und, ud, sc_max(unb, vnb), nd - 1, d);
+    
+#ifndef SC_MAX_NBITS
+    delete [] d;
+#endif
+    
+  }
+  
+#undef COPY_DIGITS
+#undef CONVERT_SM_to_2C_to_SM
+
+}
+
+
+void
+div_on_help_unsigned(small_type &us, 
+                     int unb, int und, 
+                     sc_digit *ud, 
+                     int vnb, int vnd,
+                     const sc_digit *vd)
+{
+#define CONVERT_SM_to_2C_to_SM convert_unsigned_SM_to_2C_to_SM
+#define COPY_DIGITS copy_digits_unsigned
+
+  {  // Body of div_on_help
+
+    int old_und = und;
+    
+    und = vec_skip_leading_zeros(und, ud);
+    vnd = vec_skip_leading_zeros(vnd, vd);
+    
+    int cmp_res = vec_cmp(und, ud, vnd, vd);
+    
+    if (cmp_res < 0) { // u < v => u / v = 0 - case 4
+      us = SC_ZERO;
+      vec_zero(old_und, ud);
+      return;
+    }
+    
+    sc_digit vd0 = (*vd);
+    
+    if ((cmp_res > 0) && (vnd == 1) && (vd0 == 1))  {
+      us = CONVERT_SM_to_2C_to_SM(us, unb, old_und, ud);
+      return;
+    }
+    
+    // One extra digit for d is allocated to simplify vec_div_*().
+    int nd = sc_max(und, vnd) + 1;
+    
+#ifdef SC_MAX_NBITS
+    sc_digit d[MAX_NDIGITS + 1];
+#else
+    sc_digit *d = new sc_digit[nd];
+#endif
+    
+    vec_zero(nd, d);
+    
+    // u = v => u / v = 1 - case 3
+    if (cmp_res == 0)
+      d[0] = 1;
+    
+    else if ((vnd == 1) && (und == 1))
+      d[0] = (*ud) / vd0;
+    
+    else if ((vnd == 1) && (vd0 < HALF_DIGIT_RADIX))
+      vec_div_small(und, ud, vd0, d);
+    
+    else
+      vec_div_large(und, ud, vnd, vd, d);
+    
+    COPY_DIGITS(us, unb, old_und, ud, sc_max(unb, vnb), nd - 1, d);
+    
+#ifndef SC_MAX_NBITS
+    delete [] d;
+#endif
+    
+  }
+  
+#undef COPY_DIGITS
+#undef CONVERT_SM_to_2C_to_SM
+
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: External functions for MOD operators.
+// ----------------------------------------------------------------------------
+
+void
+mod_on_help_signed(small_type &us, 
+                   int unb, int und, 
+                   sc_digit *ud, 
+                   int /* vnb */, int vnd,
+                   const sc_digit *vd)
+{
+
+#define COPY_DIGITS copy_digits_signed
+
+  { // Body of mod_on_help
+
+    int old_und = und;
+    
+    und = vec_skip_leading_zeros(und, ud);
+    vnd = vec_skip_leading_zeros(vnd, vd);
+    
+    int cmp_res = vec_cmp(und, ud, vnd, vd);
+    
+    // u < v => u % v = u - case 4
+    if (cmp_res < 0) 
+      return;
+    
+    // u = v => u % v = 0 - case 3
+    if (cmp_res == 0) { 
+      us = SC_ZERO;
+      vec_zero(old_und, ud);
+      return;
+    }
+    
+    // else if u > v - case 5
+    
+    sc_digit vd0 = (*vd);
+    
+    if ((vnd == 1) && (vd0 == 1)) {
+      us = SC_ZERO;
+      vec_zero(old_und, ud);
+      return;
+    }
+    
+    // One extra digit for d is allocated to simplify vec_div_*().
+    int nd = sc_max(und, vnd) + 1;
+    
+#ifdef SC_MAX_NBITS
+    sc_digit d[MAX_NDIGITS + 1];
+#else
+    sc_digit *d = new sc_digit[nd];
+#endif
+    
+    vec_zero(nd, d);
+    
+    if ((vnd == 1) && (und == 1))
+      d[0] = (*ud) % vd0;
+    
+    if ((vnd == 1) && (vd0 < HALF_DIGIT_RADIX))
+      d[0] = vec_rem_small(und, ud, vd0);
+    
+    else
+      vec_rem_large(und, ud, vnd, vd, d);
+    
+    us = check_for_zero(us, nd - 1, d);
+    
+    if (us == SC_ZERO)
+      vec_zero(old_und, ud);
+    else
+      COPY_DIGITS(us, unb, old_und, ud, sc_min(unb, vnd), nd - 1, d);
+    
+#ifndef SC_MAX_NBITS
+    delete [] d;
+#endif
+    
+  }
+  
+#undef COPY_DIGITS
+  
+}
+
+
+void
+mod_on_help_unsigned(small_type &us, 
+                     int unb, int und, 
+                     sc_digit *ud, 
+                     int /* vnb */, int vnd,
+                     const sc_digit *vd)
+{
+
+#define COPY_DIGITS copy_digits_unsigned
+
+  { // Body of mod_on_help
+
+    int old_und = und;
+    
+    und = vec_skip_leading_zeros(und, ud);
+    vnd = vec_skip_leading_zeros(vnd, vd);
+    
+    int cmp_res = vec_cmp(und, ud, vnd, vd);
+    
+    // u < v => u % v = u - case 4
+    if (cmp_res < 0) 
+      return;
+    
+    // u = v => u % v = 0 - case 3
+    if (cmp_res == 0) { 
+      us = SC_ZERO;
+      vec_zero(old_und, ud);
+      return;
+    }
+    
+    // else if u > v - case 5
+    
+    sc_digit vd0 = (*vd);
+    
+    if ((vnd == 1) && (vd0 == 1)) {
+      us = SC_ZERO;
+      vec_zero(old_und, ud);
+      return;
+    }
+    
+    // One extra digit for d is allocated to simplify vec_div_*().
+    int nd = sc_max(und, vnd) + 1;
+    
+#ifdef SC_MAX_NBITS
+    sc_digit d[MAX_NDIGITS + 1];
+#else
+    sc_digit *d = new sc_digit[nd];
+#endif
+    
+    vec_zero(nd, d);
+    
+    if ((vnd == 1) && (und == 1))
+      d[0] = (*ud) % vd0;
+    
+    if ((vnd == 1) && (vd0 < HALF_DIGIT_RADIX))
+      d[0] = vec_rem_small(und, ud, vd0);
+    
+    else
+      vec_rem_large(und, ud, vnd, vd, d);
+    
+    us = check_for_zero(us, nd - 1, d);
+    
+    if (us == SC_ZERO)
+      vec_zero(old_und, ud);
+    else
+      COPY_DIGITS(us, unb, old_und, ud, sc_min(unb, vnd), nd - 1, d);
+    
+#ifndef SC_MAX_NBITS
+    delete [] d;
+#endif
+    
+  }
+  
+#undef COPY_DIGITS
+  
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: External functions for AND operators.
+// ----------------------------------------------------------------------------
+
+// Handles the cases 2-5 and returns the result in u.
+void
+and_on_help(small_type us, 
+            int /* unb */, int und, 
+            sc_digit *ud, 
+            small_type vs,
+            int /* vnb */, int vnd,
+            const sc_digit *vd)
+{
+
+  sc_digit *x = ud;
+  const sc_digit *y = vd;
+  int xnd = und;
+  int ynd = vnd;
+
+  // Truncate y.
+  if (xnd < ynd)
+    ynd = xnd;
+
+  const sc_digit *xend = (x + xnd);
+  const sc_digit *yend = (y + ynd);
+
+  // x is longer than y.
+
+  small_type s = mul_signs(us, vs);
+
+  if (s > 0) {
+
+    if (us > 0) { // case 2
+
+      while (y < yend)
+        (*x++) &= (*y++);
+
+      while (x < xend)
+        (*x++) = 0;
+
+    }
+    else {  // case 3
+
+      sc_digit xcarry = 1;
+      sc_digit ycarry = 1;
+
+      while (y < yend) {
+        xcarry += (~(*x) & DIGIT_MASK);
+        ycarry += (~(*y++) & DIGIT_MASK);
+        (*x++) = (xcarry & ycarry) & DIGIT_MASK;
+        xcarry >>= BITS_PER_DIGIT;
+        ycarry >>= BITS_PER_DIGIT;
+      }
+
+      while (x < xend) {
+        xcarry += (~(*x) & DIGIT_MASK);
+        ycarry += DIGIT_MASK;
+        (*x++) = (xcarry & ycarry) & DIGIT_MASK;
+        xcarry >>= BITS_PER_DIGIT;
+        ycarry >>= BITS_PER_DIGIT;
+      }
+
+    }
+  }
+  else {
+
+    if (us > 0) { // case 4
+
+      sc_digit ycarry = 1;
+
+      while (y < yend) {
+        ycarry += (~(*y++) & DIGIT_MASK);
+        (*x++) &= ycarry & DIGIT_MASK;
+        ycarry >>= BITS_PER_DIGIT;
+      }
+
+      while (x < xend) {
+        ycarry += DIGIT_MASK;
+        (*x++) &= ycarry & DIGIT_MASK;
+        ycarry >>= BITS_PER_DIGIT;
+      }
+
+    }
+    else {  // case 5
+
+      sc_digit xcarry = 1;
+
+      while (y < yend) {
+        xcarry += (~(*x) & DIGIT_MASK);
+        (*x++) = (xcarry & (*y++)) & DIGIT_MASK;
+        xcarry >>= BITS_PER_DIGIT;
+      }
+
+      while (x < xend)
+        (*x++) = 0;
+
+    }
+  }
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: External functions for OR operators.
+// ----------------------------------------------------------------------------
+
+// Handles the cases 3-5 and returns the result in u.
+void
+or_on_help(small_type us, 
+           int /* unb */, int und, 
+           sc_digit *ud, 
+           small_type vs,
+           int /* vnb */, int vnd,
+           const sc_digit *vd)
+{
+  
+  sc_digit *x = ud;
+  const sc_digit *y = vd;
+  int xnd = und;
+  int ynd = vnd;
+
+  if (xnd < ynd)
+    ynd = xnd;
+
+  const sc_digit *xend = (x + xnd);
+  const sc_digit *yend = (y + ynd);
+
+  // x is longer than y.
+
+  small_type s = mul_signs(us, vs);
+
+  if (s > 0) {
+
+    if (us > 0) { // case 3
+
+      while (y < yend)
+        (*x++) |= (*y++);
+
+      // No change for the rest of x.
+
+    }
+    else {  // case 4
+
+      sc_digit xcarry = 1;
+      sc_digit ycarry = 1;
+
+      while (y < yend) {
+        xcarry += (~(*x) & DIGIT_MASK);
+        ycarry += (~(*y++) & DIGIT_MASK);
+        (*x++) = (xcarry | ycarry) & DIGIT_MASK;
+        xcarry >>= BITS_PER_DIGIT;
+        ycarry >>= BITS_PER_DIGIT;
+      }
+
+      while (x < xend) {
+        xcarry += (~(*x) & DIGIT_MASK);
+        ycarry += DIGIT_MASK;
+        (*x++) = (xcarry | ycarry) & DIGIT_MASK;
+        xcarry >>= BITS_PER_DIGIT;
+        ycarry >>= BITS_PER_DIGIT;
+      }
+    }
+
+  }
+  else {
+
+    if (us > 0) { // case 5
+
+      sc_digit ycarry = 1;
+
+      while (y < yend) {
+        ycarry += (~(*y++) & DIGIT_MASK);
+        (*x) = ((*x) | ycarry) & DIGIT_MASK;
+        x++;
+        ycarry >>= BITS_PER_DIGIT;
+      }
+
+      while (x < xend) {
+        ycarry += DIGIT_MASK;
+        (*x) = ((*x) | ycarry) & DIGIT_MASK;
+        x++;
+        ycarry >>= BITS_PER_DIGIT;
+      }
+
+    }
+    else {  // case 6
+
+      sc_digit xcarry = 1;
+
+      while (y < yend) {
+        xcarry += (~(*x) & DIGIT_MASK);
+        (*x++) = (xcarry | (*y++)) & DIGIT_MASK;
+        xcarry >>= BITS_PER_DIGIT;
+      }
+
+      while (x < xend) {
+        xcarry += (~(*x) & DIGIT_MASK);
+        (*x++) = xcarry & DIGIT_MASK;
+        xcarry >>= BITS_PER_DIGIT;
+      }
+    }
+  }
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: External functions for XOR operators.
+// ----------------------------------------------------------------------------
+
+// Handles the cases 3-5 and returns the result in u.
+void
+xor_on_help(small_type us, 
+            int /* unb */, int und, 
+            sc_digit *ud, 
+            small_type vs,
+            int /* vnb */, int vnd,
+            const sc_digit *vd)
+{
+  
+  sc_digit *x = ud;
+  const sc_digit *y = vd;
+  int xnd = und;
+  int ynd = vnd;
+
+  if (xnd < ynd)
+    ynd = xnd;
+
+  const sc_digit *xend = (x + xnd);
+  const sc_digit *yend = (y + ynd);
+
+  // x is longer than y.
+
+  small_type s = mul_signs(us, vs);
+
+  if (s > 0) {
+
+    if (us > 0) { // case 3
+
+      while (y < yend) {
+        (*x) = ((*x) ^ (*y)) & DIGIT_MASK;
+        x++;
+        y++;
+      }
+
+      // No change for the rest of x.
+
+    }
+    else {  // case 4
+
+      sc_digit xcarry = 1;
+      sc_digit ycarry = 1;
+
+      while (y < yend) {
+        xcarry += (~(*x) & DIGIT_MASK);
+        ycarry += (~(*y++) & DIGIT_MASK);
+        (*x++) = (xcarry ^ ycarry) & DIGIT_MASK;
+        xcarry >>= BITS_PER_DIGIT;
+        ycarry >>= BITS_PER_DIGIT;
+      }
+
+      while (x < xend) {
+        xcarry += (~(*x) & DIGIT_MASK);
+        ycarry += DIGIT_MASK;
+        (*x++) = (xcarry ^ ycarry) & DIGIT_MASK;
+        xcarry >>= BITS_PER_DIGIT;
+        ycarry >>= BITS_PER_DIGIT;
+      }
+    }
+  }
+  else {
+
+    if (us > 0) { // case 5
+
+      sc_digit ycarry = 1;
+
+      while (y < yend) {
+        ycarry += (~(*y++) & DIGIT_MASK);
+        (*x) = ((*x) ^ ycarry) & DIGIT_MASK;
+        x++;
+        ycarry >>= BITS_PER_DIGIT;
+      }
+
+      while (x < xend) {
+        ycarry += DIGIT_MASK;
+        (*x) = ((*x) ^ ycarry) & DIGIT_MASK;
+        x++;
+        ycarry >>= BITS_PER_DIGIT;
+      }
+
+    }
+    else {  // case 6
+
+      sc_digit xcarry = 1;
+
+      while (y < yend) {
+        xcarry += (~(*x) & DIGIT_MASK);
+        (*x++) = (xcarry ^ (*y++)) & DIGIT_MASK;
+        xcarry >>= BITS_PER_DIGIT;
+      }
+
+      while (x < xend) {
+        xcarry += (~(*x) & DIGIT_MASK);
+        (*x++) = xcarry & DIGIT_MASK;
+        xcarry >>= BITS_PER_DIGIT;
+      }
+    }
+  }
+}
+
+} // namespace sc_dt
+
+
+// End of file
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_nbexterns.h b/ext/systemc/src/sysc/datatypes/int/sc_nbexterns.h
new file mode 100644
index 000000000..98f5cda91
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_nbexterns.h
@@ -0,0 +1,123 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_nbexterns.h -- External functions for both sc_signed and sc_unsigned
+                    classes. These functions work on two parameters u and
+                    v, and copy the result to the first parameter u. This
+                    is also the reason that they are suffixed with _on_help.
+ 
+                    The vec_* functions are called through either these
+                    functions or those in sc_nbfriends.cpp. The functions in
+                    sc_nbfriends.cpp perform their work on two inputs u and v,
+                    and return the result object.
+ 
+  Original Author: Ali Dasdan, Synopsys, Inc.
+ 
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_nbexterns.h,v $
+// Revision 1.2  2011/02/18 20:19:15  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:49:32  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#ifndef SC_NBEXTERNS_H
+#define SC_NBEXTERNS_H
+
+
+#include "sysc/datatypes/int/sc_nbutils.h"
+
+
+namespace sc_dt
+{
+
+extern 
+void add_on_help(small_type &us, 
+                 int unb, int und, sc_digit *ud, 
+                 small_type vs, 
+                 int vnb, int vnd, const sc_digit *vd);
+
+extern 
+void mul_on_help_signed(small_type &us,
+                        int unb, int und, sc_digit *ud, 
+                        int vnb, int vnd, const sc_digit *vd);
+
+void div_on_help_signed(small_type &us,
+                        int unb, int und, sc_digit *ud, 
+                        int vnb, int vnd, const sc_digit *vd);
+
+extern 
+void mod_on_help_signed(small_type &us,
+                        int unb, int und, sc_digit *ud, 
+                        int vnb, int vnd, const sc_digit *vd);
+
+extern 
+void mul_on_help_unsigned(small_type &us,
+                          int unb, int und, sc_digit *ud, 
+                          int vnb, int vnd, const sc_digit *vd);
+
+void div_on_help_unsigned(small_type &us,
+                          int unb, int und, sc_digit *ud, 
+                          int vnb, int vnd, const sc_digit *vd);
+
+extern 
+void mod_on_help_unsigned(small_type &us,
+                          int unb, int und, sc_digit *ud, 
+                          int vnb, int vnd, const sc_digit *vd);
+
+extern 
+void and_on_help(small_type us, 
+                 int unb, int und, sc_digit *ud, 
+                 small_type vs,
+                 int vnb, int vnd, const sc_digit *vd);
+
+extern 
+void or_on_help(small_type us, 
+                int unb, int und, sc_digit *ud, 
+                small_type vs,
+                int vnb, int vnd, const sc_digit *vd);
+
+extern 
+void xor_on_help(small_type us, 
+                 int unb, int und, sc_digit *ud, 
+                 small_type vs,
+                 int vnb, int vnd, const sc_digit *vd);
+
+} // namespace sc_dt
+
+
+#endif
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_nbfriends.inc b/ext/systemc/src/sysc/datatypes/int/sc_nbfriends.inc
new file mode 100644
index 000000000..5d67939e5
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_nbfriends.inc
@@ -0,0 +1,727 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_nbfriends.inc -- Friend functions for both sc_signed and sc_unsigned
+                      classes. The vec_* functions are called through either
+                      these functions or those in sc_nbexterns.cpp. These
+                      functions perform their work on two inputs u and v, and
+                      return the result object. The functions in
+                      sc_nbexterns.cpp perform their work on one of their
+                      inputs.
+
+                      The functions here try to use faster algorithms in case
+                      the input numbers are small. The bitwise functions (and,
+                      or, and xor) need the 2's complement representations of
+                      their inputs. Instead of complementing their inputs
+                      first and then processing, they complement their inputs
+                      while processing without allocating extra temporary
+                      memory.
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// ----------------------------------------------------------------------------
+//  Naming conventions:
+//  For sc_signed or sc_unsigned number u:
+//    us : u's sign, unb : u's number of bits, 
+//    und : u's number of digits, ud : u's digits array.
+// ----------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
+//  SECTION: Friend functions for PLUS operators.
+// ----------------------------------------------------------------------------
+
+// Handles cases 3 and 4 and returns the result.
+CLASS_TYPE
+ADD_HELPER(small_type us, int unb, int und,
+           const sc_digit *ud, 
+           small_type vs, int vnb, int vnd,
+           const sc_digit *vd)
+{
+
+  und = vec_skip_leading_zeros(und, ud);
+  vnd = vec_skip_leading_zeros(vnd, vd);
+
+  int nb = sc_max(unb, vnb);
+  int nd = sc_max(und, vnd) + 1;
+
+#ifdef SC_MAX_NBITS
+  test_bound(nb);
+  sc_digit d[MAX_NDIGITS];
+#else
+  sc_digit *d = new sc_digit[nd];
+#endif
+  
+  d[nd - 1] = d[nd - 2] = 0;
+
+  // case 3
+  if (us == vs) {
+
+    ++nb;
+
+    if ((und == 1) && (vnd == 1)) {
+      sc_digit carry = (*ud) + (*vd);
+      d[0] = carry & DIGIT_MASK;
+      d[1] = carry >> BITS_PER_DIGIT;
+    }
+
+    else if (und >= vnd)
+      vec_add(und, ud, vnd, vd, d);
+
+    else
+      vec_add(vnd, vd, und, ud, d);
+
+  }
+
+  // case 4
+  else {
+
+    int cmp_res = vec_cmp(und, ud, vnd, vd);
+    
+    if (cmp_res == 0) { // u == v
+#ifndef SC_MAX_NBITS
+      delete[] d;
+#endif
+      return CLASS_TYPE();
+    }
+    
+    if (cmp_res > 0)  { // u > v
+
+      if ((und == 1) && (vnd == 1))
+        d[0] = (*ud) - (*vd);
+      else
+        vec_sub(und, ud, vnd, vd, d);
+
+    }
+    else { // u < v
+
+      us = -us;
+
+      if ((und == 1) && (vnd == 1))
+        d[0] = (*vd) - (*ud);
+      else
+        vec_sub(vnd, vd, und, ud, d);
+
+    }
+  }
+  
+  return CLASS_TYPE(us, nb, nd, d);
+  
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Friend functions of MULTIPLICATION operators.
+// ----------------------------------------------------------------------------
+
+// Handles the case 4 and returns the result.
+CLASS_TYPE 
+MUL_HELPER(small_type s, 
+           int unb, int und, 
+           const sc_digit *ud, 
+           int vnb, int vnd,
+           const sc_digit *vd)
+{
+
+  und = vec_skip_leading_zeros(und, ud);
+  vnd = vec_skip_leading_zeros(vnd, vd);
+
+  int nb = unb + vnb;
+  int nd = und + vnd;
+  
+#ifdef SC_MAX_NBITS
+  test_bound(nb);
+  sc_digit d[MAX_NDIGITS];
+#else
+  sc_digit *d = new sc_digit[nd];
+#endif
+
+  vec_zero(nd, d);
+    
+  sc_digit ud0 = (*ud);
+  sc_digit vd0 = (*vd);
+
+  if ((vnd == 1) && (vd0 == 1))
+    vec_copy(und, d, ud);
+
+  else if ((und == 1) && (ud0 == 1))
+    vec_copy(vnd, d, vd);
+
+  else if ((und == 1) && (vnd == 1) && 
+      (ud0 < HALF_DIGIT_RADIX) && (vd0 < HALF_DIGIT_RADIX))
+    d[0] = ud0 * vd0;
+  
+  else if ((und == 1) && (ud0 < HALF_DIGIT_RADIX))
+    vec_mul_small(vnd, vd, ud0, d);
+
+  else if ((vnd == 1) && (vd0 < HALF_DIGIT_RADIX))
+    vec_mul_small(und, ud, vd0, d);
+
+  else if (vnd < und)
+    vec_mul(und, ud, vnd, vd, d);
+
+  else
+    vec_mul(vnd, vd, und, ud, d);
+  
+  return CLASS_TYPE(s, nb, nd, d);
+
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Friend functions for DIVISION operators.
+// ----------------------------------------------------------------------------
+
+// Handles the cases 3-4 and returns the result.
+CLASS_TYPE 
+DIV_HELPER(small_type s, 
+           int unb, int und, 
+           const sc_digit *ud, 
+           int vnb, int vnd,
+           const sc_digit *vd)
+{
+
+  und = vec_skip_leading_zeros(und, ud);
+  vnd = vec_skip_leading_zeros(vnd, vd);
+
+  int cmp_res = vec_cmp(und, ud, vnd, vd);
+
+  // u < v => u / v = 0 - case 4
+  if (cmp_res < 0) 
+    return CLASS_TYPE();
+
+  // One extra digit for d is allocated to simplify vec_div_*().
+  int nd = sc_max(und, vnd) + 1;
+
+#ifdef SC_MAX_NBITS
+  sc_digit d[MAX_NDIGITS + 1];
+#else
+  sc_digit *d = new sc_digit[nd];
+#endif
+
+  vec_zero(nd, d);
+
+  sc_digit vd0 = (*vd);
+
+  // u = v => u / v = 1 - case 3
+  if (cmp_res == 0)
+    d[0] = 1;
+
+  // else if u > v - case 5
+
+  else if ((vnd == 1) && (vd0 == 1))
+    vec_copy(und, d, ud);
+
+  else if ((vnd == 1) && (und == 1))
+    d[0] = (*ud) / vd0;
+ 
+  else if ((vnd == 1) && (vd0 < HALF_DIGIT_RADIX))
+    vec_div_small(und, ud, vd0, d);
+
+  else
+    vec_div_large(und, ud, vnd, vd, d);
+
+  return CLASS_TYPE(s, sc_max(unb, vnb), nd - 1, d);
+  
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Friend functions for MOD operators.
+// ----------------------------------------------------------------------------
+
+// Handles the cases 3-4 and returns the result.
+CLASS_TYPE 
+MOD_HELPER(small_type us, 
+           int unb, int und, 
+           const sc_digit *ud, 
+           int vnb, int vnd,
+           const sc_digit *vd)
+{
+
+  und = vec_skip_leading_zeros(und, ud);
+  vnd = vec_skip_leading_zeros(vnd, vd);
+
+  int cmp_res = vec_cmp(und, ud, vnd, vd);
+
+  // u = v => u % v = 0 - case 3
+  if (cmp_res == 0) 
+    return CLASS_TYPE();
+
+  sc_digit vd0 = (*vd);
+
+  if ((cmp_res > 0) && (vnd == 1) && (vd0 == 1))
+    return CLASS_TYPE();
+
+  // One extra digit for d is allocated to simplify vec_div_*().
+  int nd = sc_max(und, vnd) + 1;
+
+#ifdef SC_MAX_NBITS
+  sc_digit d[MAX_NDIGITS + 1];
+#else
+  sc_digit *d = new sc_digit[nd];
+#endif
+
+  vec_zero(nd, d);
+
+  // u < v => u % v = u - case 4
+  if (cmp_res < 0) 
+    vec_copy(und, d, ud);
+
+  // else if u > v - case 5
+
+  else if ((vnd == 1) && (und == 1))
+    d[0] = (*ud) % vd0;
+
+  else if ((vnd == 1) && (vd0 < HALF_DIGIT_RADIX))
+    d[0] = vec_rem_small(und, ud, vd0);
+
+  else
+    vec_rem_large(und, ud, vnd, vd, d);
+
+  us = check_for_zero(us, nd - 1, d);
+
+  if (us == SC_ZERO) {
+#ifndef SC_MAX_NBITS
+    delete[] d;
+#endif
+    return CLASS_TYPE();
+  } else
+    return CLASS_TYPE(us, sc_min(unb, vnb), nd - 1, d);
+
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Friend functions for AND operators.
+// ----------------------------------------------------------------------------
+
+// Handles the cases 2-5 and returns the result.
+CLASS_TYPE 
+AND_HELPER(small_type us, 
+           int unb, int und, 
+           const sc_digit *ud, 
+           small_type vs,
+           int vnb, int vnd,
+           const sc_digit *vd)
+{
+
+  int nb = sc_max(unb, vnb);
+  int nd = sc_max(und, vnd);
+
+#ifdef SC_MAX_NBITS
+  sc_digit dbegin[MAX_NDIGITS];
+#else
+  sc_digit *dbegin = new sc_digit[nd];
+#endif
+
+  sc_digit *d = dbegin;
+
+  const sc_digit *x;
+  const sc_digit *y;
+  int xnd;
+  int ynd;
+  small_type xs;
+  small_type ys;
+
+  if (und >= vnd) {
+    x = ud;
+    y = vd;
+    xnd = und;
+    ynd = vnd;
+    xs = us;
+    ys = vs;
+  }
+  else {
+    y = ud;
+    x = vd;
+    ynd = und;
+    xnd = vnd;
+    ys = us;
+    xs = vs;
+  }
+
+  const sc_digit *xend = (x + xnd);
+  const sc_digit *yend = (y + ynd);
+
+  // x is longer than y.
+
+  small_type s = mul_signs(xs, ys);
+
+  if (s > 0) {
+
+    if (xs > 0) { // case 2
+
+      while (y < yend)
+        (*d++) = (*x++) & (*y++);
+
+      while (x++ < xend) 
+        (*d++) = 0;
+
+    }
+    else {  // case 3
+
+      sc_digit xcarry = 1;
+      sc_digit ycarry = 1;
+
+      while (y < yend) {
+        xcarry += (~(*x++) & DIGIT_MASK);
+        ycarry += (~(*y++) & DIGIT_MASK);
+        (*d++) = (xcarry & ycarry) & DIGIT_MASK;
+        xcarry >>= BITS_PER_DIGIT;
+        ycarry >>= BITS_PER_DIGIT;
+      }
+
+      while (x < xend) {
+        xcarry += (~(*x++) & DIGIT_MASK);
+        ycarry += DIGIT_MASK;
+        (*d++) = (xcarry & ycarry) & DIGIT_MASK;
+        xcarry >>= BITS_PER_DIGIT;
+        ycarry >>= BITS_PER_DIGIT;
+      }
+
+    }
+  }
+  else {
+
+    if (xs > 0) { // case 4
+
+      sc_digit ycarry = 1;
+
+      while (y < yend) {
+        ycarry += (~(*y++) & DIGIT_MASK);
+        (*d++) = ((*x++) & ycarry) & DIGIT_MASK;
+        ycarry >>= BITS_PER_DIGIT;
+      }
+
+      while (x < xend) {
+        ycarry += DIGIT_MASK;
+        (*d++) = ((*x++) & ycarry) & DIGIT_MASK;
+        ycarry >>= BITS_PER_DIGIT;
+      }
+
+    }
+    else {  // case 5
+
+      sc_digit xcarry = 1;
+
+      while (y < yend) {
+        xcarry += (~(*x++) & DIGIT_MASK);
+        (*d++) = (xcarry & (*y++)) & DIGIT_MASK;
+        xcarry >>= BITS_PER_DIGIT;
+      }
+
+      while (x++ < xend)
+        (*d++) = 0;
+
+    }
+  }
+
+  s = convert_signed_2C_to_SM(nb, nd, dbegin);
+
+  return CLASS_TYPE(s, nb, nd, dbegin);  
+
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Friend functions for OR operators.
+// ----------------------------------------------------------------------------
+
+// Handles the cases 3-5 and returns the result.
+CLASS_TYPE 
+OR_HELPER(small_type us, 
+          int unb, int und, 
+          const sc_digit *ud, 
+          small_type vs,
+          int vnb, int vnd,
+          const sc_digit *vd)
+{
+  
+  int nb = sc_max(unb, vnb);
+  int nd = sc_max(und, vnd);
+
+#ifdef SC_MAX_NBITS
+  sc_digit dbegin[MAX_NDIGITS];
+#else
+  sc_digit *dbegin = new sc_digit[nd];
+#endif
+
+  sc_digit *d = dbegin;
+
+  const sc_digit *x;
+  const sc_digit *y;
+  int xnd;
+  int ynd;
+  small_type xs;
+  small_type ys;
+
+  if (und >= vnd) {
+    x = ud;
+    y = vd;
+    xnd = und;
+    ynd = vnd;
+    xs = us;
+    ys = vs;
+  }
+  else {
+    y = ud;
+    x = vd;
+    ynd = und;
+    xnd = vnd;
+    ys = us;
+    xs = vs;
+  }
+
+  const sc_digit *xend = (x + xnd);
+  const sc_digit *yend = (y + ynd);
+
+  // x is longer than y.
+
+  small_type s = mul_signs(xs, ys);
+
+  if (s > 0) {
+
+    if (xs > 0) { // case 3
+
+      while (y < yend)
+        (*d++) = (*x++) | (*y++);
+
+      while (x < xend)
+        (*d++) = (*x++);
+
+    }
+    else {  // case 4
+
+      sc_digit xcarry = 1;
+      sc_digit ycarry = 1;
+
+      while (y < yend) {
+        xcarry += (~(*x++) & DIGIT_MASK);
+        ycarry += (~(*y++) & DIGIT_MASK);
+        (*d++) = (xcarry | ycarry) & DIGIT_MASK;
+        xcarry >>= BITS_PER_DIGIT;
+        ycarry >>= BITS_PER_DIGIT;
+      }
+
+      while (x < xend) {
+        xcarry += (~(*x++) & DIGIT_MASK);
+        ycarry += DIGIT_MASK;
+        (*d++) = (xcarry | ycarry) & DIGIT_MASK;
+        xcarry >>= BITS_PER_DIGIT;
+        ycarry >>= BITS_PER_DIGIT;
+      }
+
+    }
+
+  }
+  else {
+
+    if (xs > 0) { // case 5
+
+      sc_digit ycarry = 1;
+
+      while (y < yend) {
+        ycarry += (~(*y++) & DIGIT_MASK);
+        (*d++) = ((*x++) | ycarry) & DIGIT_MASK;
+        ycarry >>= BITS_PER_DIGIT;
+      }
+
+      while (x < xend) {
+        ycarry += DIGIT_MASK;
+        (*d++) = ((*x++) | ycarry) & DIGIT_MASK;
+        ycarry >>= BITS_PER_DIGIT;
+      }
+
+    }
+    else {  // case 6
+
+      sc_digit xcarry = 1;
+
+      while (y < yend) {
+        xcarry += (~(*x++) & DIGIT_MASK);
+        (*d++) = (xcarry | (*y++)) & DIGIT_MASK;
+        xcarry >>= BITS_PER_DIGIT;
+      }
+
+      while (x < xend) {
+        xcarry += (~(*x++) & DIGIT_MASK);
+        (*d++) = xcarry & DIGIT_MASK;
+        xcarry >>= BITS_PER_DIGIT;
+      }
+    }
+
+  }
+
+  s = convert_signed_2C_to_SM(nb, nd, dbegin);
+
+  return CLASS_TYPE(s, nb, nd, dbegin);
+
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Friend functions for XOR operators.
+// ----------------------------------------------------------------------------
+
+// Handles the cases 3-5 and returns the result.
+CLASS_TYPE 
+XOR_HELPER(small_type us, 
+           int unb, int und, 
+           const sc_digit *ud, 
+           small_type vs,
+           int vnb, int vnd,
+           const sc_digit *vd)
+{
+  
+  int nb = sc_max(unb, vnb);
+  int nd = sc_max(und, vnd);
+
+#ifdef SC_MAX_NBITS
+  sc_digit dbegin[MAX_NDIGITS];
+#else
+  sc_digit *dbegin = new sc_digit[nd];
+#endif
+
+  sc_digit *d = dbegin;
+
+  const sc_digit *x;
+  const sc_digit *y;
+  int xnd;
+  int ynd;
+  small_type xs;
+  small_type ys;
+
+  if (und >= vnd) {
+    x = ud;
+    y = vd;
+    xnd = und;
+    ynd = vnd;
+    xs = us;
+    ys = vs;
+  }
+  else {
+    y = ud;
+    x = vd;
+    ynd = und;
+    xnd = vnd;
+    ys = us;
+    xs = vs;
+  }
+
+  const sc_digit *xend = (x + xnd);
+  const sc_digit *yend = (y + ynd);
+
+  // x is longer than y.
+
+  small_type s = mul_signs(xs, ys);
+
+  if (s > 0) {
+
+    if (xs > 0) { // case 3
+
+      while (y < yend)
+        (*d++) = ((*x++) ^ (*y++)) & DIGIT_MASK;
+
+      while (x < xend)
+        (*d++) = (*x++);
+
+    }
+    else {  // case 4
+
+      sc_digit xcarry = 1;
+      sc_digit ycarry = 1;
+
+      while (y < yend) {
+        xcarry += (~(*x++) & DIGIT_MASK);
+        ycarry += (~(*y++) & DIGIT_MASK);
+        (*d++) = (xcarry ^ ycarry) & DIGIT_MASK;
+        xcarry >>= BITS_PER_DIGIT;
+        ycarry >>= BITS_PER_DIGIT;
+      }
+
+      while (x < xend) {
+        xcarry += (~(*x++) & DIGIT_MASK);
+        ycarry += DIGIT_MASK;
+        (*d++) = (xcarry ^ ycarry) & DIGIT_MASK;
+        xcarry >>= BITS_PER_DIGIT;
+        ycarry >>= BITS_PER_DIGIT;
+      }
+
+    }
+  }
+  else {
+
+    if (xs > 0) { // case 5
+
+      sc_digit ycarry = 1;
+
+      while (y < yend) {
+        ycarry += (~(*y++) & DIGIT_MASK);
+        (*d++) = ((*x++) ^ ycarry) & DIGIT_MASK;
+        ycarry >>= BITS_PER_DIGIT;
+      }
+
+      while (x < xend) {
+        ycarry += DIGIT_MASK;
+        (*d++) = ((*x++) ^ ycarry) & DIGIT_MASK;
+        ycarry >>= BITS_PER_DIGIT;
+      }
+
+    }
+    else {  // case 6
+
+      sc_digit xcarry = 1;
+
+      while (y < yend) {
+        xcarry += (~(*x++) & DIGIT_MASK);
+        (*d++) = (xcarry ^ (*y++)) & DIGIT_MASK;
+        xcarry >>= BITS_PER_DIGIT;
+      }
+
+      while (x < xend) {
+        xcarry += (~(*x++) & DIGIT_MASK);
+        (*d++) = xcarry & DIGIT_MASK;
+        xcarry >>= BITS_PER_DIGIT;
+      }
+    }
+  }
+
+  s = convert_signed_2C_to_SM(nb, nd, dbegin);
+
+  return CLASS_TYPE(s, nb, nd, dbegin);
+
+}
+
+// End of file.
+
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_nbutils.cpp b/ext/systemc/src/sysc/datatypes/int/sc_nbutils.cpp
new file mode 100644
index 000000000..385502aa6
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_nbutils.cpp
@@ -0,0 +1,1892 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_nbutils.cpp -- External and friend functions for both sc_signed and
+                    sc_unsigned classes.
+ 
+  Original Author: Ali Dasdan, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_nbutils.cpp,v $
+// Revision 1.4  2011/08/24 22:05:46  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.3  2011/02/18 20:19:15  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.2  2007/11/04 21:26:40  acg
+//  Andy Goodrich: added a buffer to the allocation of the q array to address
+//  an issue with references outside the array by 1 byte detected by valgrind.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:49:32  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#include <ctype.h>
+#include <cstdio>
+#include <string.h>
+
+#include "sysc/datatypes/int/sc_int_ids.h"
+#include "sysc/datatypes/int/sc_nbutils.h"
+#include "sysc/kernel/sc_macros.h"
+
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  ENUM : sc_numrep
+//
+//  Enumeration of number representations for character string conversion.
+// ----------------------------------------------------------------------------
+
+const std::string
+to_string( sc_numrep numrep )
+{
+    switch( numrep )
+    {
+#   define CASE_ENUM2STR( Value ) \
+      case Value: return #Value
+
+      CASE_ENUM2STR(SC_DEC);
+
+      CASE_ENUM2STR(SC_BIN);
+      CASE_ENUM2STR(SC_BIN_US);
+      CASE_ENUM2STR(SC_BIN_SM);
+
+      CASE_ENUM2STR(SC_OCT);
+      CASE_ENUM2STR(SC_OCT_US);
+      CASE_ENUM2STR(SC_OCT_SM);
+
+      CASE_ENUM2STR(SC_HEX);
+      CASE_ENUM2STR(SC_HEX_US);
+      CASE_ENUM2STR(SC_HEX_SM);
+
+      CASE_ENUM2STR(SC_CSD);
+
+#   undef CASE_ENUM2STR
+
+    default:
+      return "unknown";
+    }
+}
+
+// ----------------------------------------------------------------------------
+//  SECTION: General utility functions.
+// ----------------------------------------------------------------------------
+
+// Return the number of characters to advance the source of c.  This
+// function implements one move of the FSM to parse the following
+// regular expressions. Error checking is done in the caller.
+
+small_type
+fsm_move(char c, small_type &b, small_type &s, small_type &state)
+{
+
+  // Possible regular expressions (REs):
+  // Let N = any digit depending on the base.
+  //    1. [0|1|..|9]N*
+  //    2. [+|-][0|1|..|9]N*
+  //    3. 0[b|B|d|D|o|O|x|X][0|1|..|F]N*
+  //    4. [+|-]?0[b|B|d|D|o|O|x|X][0|1|..|F]N*
+  //
+  // The finite state machine (FMS) to parse these regular expressions
+  // has 4 states, 0 to 3. 0 is the initial state and 3 is the final
+  // state.
+  //
+  // Default sign = SC_POS, default base = NB_DEFAULT_BASE.
+
+  switch (state) {
+
+  case 0: // The initial state.
+    switch (c) { 
+    case '0': s = SC_POS; state = 1; return 0; // RE 1 or 3
+    case '+': s = SC_POS; state = 2; return 1; // RE 2
+    case '-': s = SC_NEG; state = 2; return 1; // RE 2
+    default:  s = SC_POS; b = NB_DEFAULT_BASE; state = 3; return 0; // RE 1
+    }
+    // break; //unreachable code
+  case 1: // 0...
+    switch (c) {
+    case 'x': case 'X': b = SC_HEX; state = 3; return 2; // RE 3 or 4
+    case 'd': case 'D': b = SC_DEC; state = 3; return 2; // RE 3 or 4
+    case 'o': case 'O': b = SC_OCT; state = 3; return 2; // RE 3 or 4
+    case 'b': case 'B': b = SC_BIN; state = 3; return 2; // RE 3 or 4
+    default:  b = NB_DEFAULT_BASE; state = 3; return 0; // RE 1
+    }
+    // break; //unreachable code
+  case 2: // +... or -...
+    switch (c) {
+    case '0': state = 1; return 0; // RE 2 or 4
+    default:  b = NB_DEFAULT_BASE; state = 3; return 0; // RE 2
+    }
+    // break; //unreachable code
+  case 3: // The final state.
+    break;
+
+  default:
+    // Any other state is not possible.
+    assert((0 <= state) && (state <= 3));
+
+  } // switch
+
+  return 0;
+
+}  
+
+
+// Get base b and sign s of the number in the char string v. Return a
+// pointer to the first char after the point where b and s are
+// determined or where the end of v is reached. The input string v has
+// to be null terminated.
+const char 
+*get_base_and_sign(const char *v, small_type &b, small_type &s)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert(v != NULL);
+#endif
+
+  const small_type STATE_START = 0;
+  const small_type STATE_FINISH = 3;
+
+  // Default sign = SC_POS, default base = 10.
+  s = SC_POS;
+  b = NB_DEFAULT_BASE;
+
+  small_type state = STATE_START;
+  small_type nskip = 0; // Skip that many chars.
+  const char *u = v;
+
+  while (*u) {
+    if (isspace(*u))  // Skip white space.
+      ++u;
+    else {
+      nskip += fsm_move(*u, b, s, state);
+      if (state == STATE_FINISH)
+        break;
+      else
+        ++u;
+    }
+  }
+
+#ifdef DEBUG_SYSTEMC
+  // Test to see if the above loop executed more than it should
+  // have. The max number of skipped chars is equal to the length of
+  // the longest format specifier, e.g., "-0x".
+  assert(nskip <= 3);
+#endif
+
+  v += nskip;
+
+  // Handles empty strings or strings without any digits after the
+  // base or base and sign specifier.
+  if (*v == '\0') { 
+      char msg[BUFSIZ];
+      std::sprintf( msg,
+	       "get_base_and_sign( const char* v, small_type&, small_type& ) : "
+	       "v = \"\" is not valid" );
+      SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_, msg );
+  }
+
+  return v;
+
+}
+
+//------------------------------------------------------------------------------
+//"parse_binary_bits"
+//
+// This function parses the supplied string into the supplied vector as a
+// right justified bit value.
+//    src_p  -> character string representing the bits to be parsed.
+//    dst_n  =  number of words in data_p and ctrl_p.
+//    data_p -> words w/BITS_PER_DIGIT bits to receive the value's data bits.
+//    ctrl_p -> words w/BITS_PER_DIGIT bits to receive the value's control bits,
+//              or zero.
+// Result is true if value was non-zero.
+//------------------------------------------------------------------------------
+void parse_binary_bits( 
+    const char* src_p, int dst_n, sc_digit* data_p, sc_digit* ctrl_p )
+{
+    int      bit_i;    // Number of bit now processing.
+    sc_digit ctrl;     // Control word now assembling.
+    sc_digit data;     // Data word now assembling.
+    int      delta_n;  // src_n - dst_n*BITS_PER_DIGIT.
+    int      src_i;    // Index in src_p now accessing (left to right).
+    int      src_n;    // Length of source that is left in bits.
+    int      word_i;   // Bit within word now accessing (left to right).
+
+    // MAKE SURE WE HAVE A STRING TO PARSE:
+
+    if( src_p == 0 ) {
+        SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_,
+                         "character string is zero" );
+    }
+    if( *src_p == 0 ) {
+        SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_,
+                         "character string is empty" );
+    }
+
+
+    // INDEX INTO THE SOURCE TO A DEPTH THAT WILL ACCOMODATE OUR SIZE:
+    //
+    // If the source is smaller than our value initialize our value to zero.
+
+    src_n = strlen(src_p);
+    delta_n = src_n - (dst_n*BITS_PER_DIGIT);
+    if ( delta_n > 0 ) 
+    {
+        src_p = &src_p[delta_n];
+        src_n -= delta_n;
+    }
+    else
+    {
+        for ( word_i = 0; word_i < dst_n; word_i++ ) data_p[word_i] = 0;
+	    if ( ctrl_p ) 
+		for ( word_i = 0; word_i < dst_n; word_i++ ) ctrl_p[word_i] = 0;
+    }
+
+
+    // LOOP OVER THE SOURCE ASSEMBLING WORDS AND PLACING THEM IN OUR VALUE:
+    //
+    // We stride right to left through the source in BITS_PER_DIGIT chunks.
+    // Each of those chunks is processed from left to right a bit at a time.
+    // We process the high order word specially, since there are less bits.
+
+    src_n = src_n - BITS_PER_DIGIT;
+    for (word_i=0; word_i < dst_n; word_i++)
+    {
+        src_i = src_n;
+
+
+        // PARTIAL LAST WORD TO ASSEMBLE:
+
+        if ( src_i < 0 ) 
+        {
+            src_n += BITS_PER_DIGIT;
+            src_i = 0;
+            data = 0;
+            ctrl = 0;
+            for ( src_i = 0; src_i < src_n; src_i++ )
+            {
+                ctrl = ctrl << 1;
+                data = data << 1;
+                switch( src_p[src_i] )
+                {
+                  case 'X':
+                  case 'x': ctrl = ctrl | 1; data = data | 1; break;
+                  case '1': data = data | 1; break;
+                  case 'Z':
+                  case 'z': ctrl = ctrl | 1; break;
+                  case '0':                  break;
+                  default:
+                    {
+                        char msg[BUFSIZ];
+                        std::sprintf( msg, "character string '%s' is not valid", 
+                        src_p );
+                        SC_REPORT_ERROR(sc_core::SC_ID_CONVERSION_FAILED_, msg);
+                    }
+                    break;
+                }
+            }
+            if ( ctrl_p ) ctrl_p[word_i] = ctrl;
+            data_p[word_i] = data;
+            break;
+        }
+
+
+        // FULL WORD TO BE ASSEMBLED:
+
+        ctrl = 0;
+        data = 0;
+        for ( bit_i = 0; bit_i < BITS_PER_DIGIT; bit_i++ )
+        {
+            ctrl = ctrl << 1;
+            data = data << 1;
+            switch( src_p[src_i++] )
+            {
+              case 'X':
+              case 'x': ctrl = ctrl | 1; data = data | 1; break;
+              case '1': data = data | 1; break;
+              case 'Z':
+              case 'z': ctrl = ctrl | 1; break;
+              case '0':                  break;
+              default:
+                {
+                    char msg[BUFSIZ];
+                    std::sprintf( msg, "character string '%s' is not valid", 
+                    src_p );
+                    SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_, msg );
+                }
+                break;
+            }
+        }
+        if ( ctrl_p ) ctrl_p[word_i] = ctrl;
+        data_p[word_i] = data;
+        src_n = src_n - BITS_PER_DIGIT;
+    }
+}
+        
+
+//------------------------------------------------------------------------------
+//"parse_hex_bits"
+//
+// This function parses the supplied string into the supplied vector as a
+// right justified bit value.
+//    src_p  -> character string representing the bits to be parsed.
+//    dst_n  =  number of words in data_p and ctrl_p.
+//    data_p -> words w/32 bits to receive the value's data bits.
+//    ctrl_p -> words w/32 bits to receive the value's control bits,
+//              or zero.
+// Result is true if value was non-zero.
+//------------------------------------------------------------------------------
+void parse_hex_bits( 
+	const char* src_p, int dst_n, sc_digit* data_p, sc_digit* ctrl_p )
+{
+    sc_digit ctrl;     // Control word now assembling.
+    sc_digit data;     // Data word now assembling.
+    int      delta_n;  // src_n - dst_n*BITS_PER_DIGIT.
+    int      digit_i;  // Number of digit now processing.
+    int      src_i;    // Index in src_p now accessing (left to right).
+    int      src_n;    // Length of source that is left in bits.
+    int      word_i;   // Bit within word now accessing (left to right).
+
+    // MAKE SURE WE HAVE A STRING TO PARSE:
+
+    if( src_p == 0 ) {
+        SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_,
+                         "character string is zero" );
+    }
+    if( *src_p == 0 ) {
+        SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_,
+                         "character string is empty" );
+    }
+
+
+    // INDEX INTO THE SOURCE TO A DEPTH THAT WILL ACCOMODATE OUR SIZE:
+    //
+    // If the source is smaller than our value initialize our value to zero.
+
+    src_n = strlen(src_p);
+    delta_n = src_n - (dst_n*8);
+    if ( delta_n > 0 ) 
+    {
+        src_p = &src_p[delta_n];
+        src_n -= delta_n;
+    }
+    else
+    {
+        for ( word_i = 0; word_i < dst_n; word_i++ ) data_p[word_i] = 0;
+		if ( ctrl_p ) 
+			for ( word_i = 0; word_i < dst_n; word_i++ ) ctrl_p[word_i] = 0;
+    }
+
+
+    // LOOP OVER THE SOURCE ASSEMBLING WORDS AND PLACING THEM IN OUR VALUE:
+    //
+    // We stride right to left through the source in BITS_PER_DIGIT chunks.
+    // Each of those chunks is processed from left to right a bit at a time.
+    // We process the high order word specially, since there are less bits.
+
+    src_n = src_n - 8;
+    for (word_i=0; word_i < dst_n; word_i++)
+    {
+        src_i = src_n;
+
+
+        // PARTIAL LAST WORD TO ASSEMBLE:
+
+        if ( src_i < 0 ) 
+        {
+            src_n += 8;
+            src_i = 0;
+            data = 0;
+            ctrl = 0;
+            for ( src_i = 0; src_i < src_n; src_i++ )
+            {
+                ctrl = ctrl << 4;
+                data = data << 4;
+                switch( src_p[src_i] )
+                {
+                  case 'X':
+                  case 'x': ctrl = ctrl | 15; data = data | 15; break;
+		  case 'F':
+                  case 'f': data = data | 15; break;
+		  case 'E':
+                  case 'e': data = data | 14; break;
+		  case 'D':
+                  case 'd': data = data | 13; break;
+		  case 'C':
+                  case 'c': data = data | 12; break;
+		  case 'B':
+                  case 'b': data = data | 11; break;
+		  case 'A':
+                  case 'a': data = data | 10; break;
+                  case '9': data = data |  9; break;
+                  case '8': data = data |  8; break;
+                  case '7': data = data |  7; break;
+                  case '6': data = data |  6; break;
+                  case '5': data = data |  5; break;
+                  case '4': data = data |  4; break;
+                  case '3': data = data |  3; break;
+                  case '2': data = data |  2; break;
+                  case '1': data = data |  1; break;
+                  case '0':                  break;
+                  case 'Z':
+                  case 'z': ctrl = ctrl | 15; break;
+                  default:
+                    {
+                        char msg[BUFSIZ];
+                        std::sprintf( msg, "character string '%s' is not valid", 
+                        src_p );
+                        SC_REPORT_ERROR(sc_core::SC_ID_CONVERSION_FAILED_, msg);
+                    }
+                    break;
+                }
+            }
+            if ( ctrl_p ) ctrl_p[word_i] = ctrl;
+            data_p[word_i] = data;
+            break;
+        }
+
+
+        // FULL WORD TO BE ASSEMBLED:
+
+        ctrl = 0;
+        data = 0;
+        for ( digit_i = 0; digit_i < 8; digit_i++ )
+        {
+            ctrl = ctrl << 4;
+            data = data << 4;
+            switch( src_p[src_i++] )
+            {
+	      case 'X':
+	      case 'x': ctrl = ctrl | 15; data = data | 15; break;
+	      case 'F':
+	      case 'f': data = data | 15; break;
+	      case 'E':
+	      case 'e': data = data | 14; break;
+	      case 'D':
+	      case 'd': data = data | 13; break;
+	      case 'C':
+	      case 'c': data = data | 12; break;
+	      case 'B':
+	      case 'b': data = data | 11; break;
+	      case 'A':
+	      case 'a': data = data | 10; break;
+	      case '9': data = data |  9; break;
+	      case '8': data = data |  8; break;
+	      case '7': data = data |  7; break;
+	      case '6': data = data |  6; break;
+	      case '5': data = data |  5; break;
+	      case '4': data = data |  4; break;
+	      case '3': data = data |  3; break;
+	      case '2': data = data |  2; break;
+	      case '1': data = data |  1; break;
+	      case '0':                  break;
+	      case 'Z':
+	      case 'z': ctrl = ctrl | 15; break;
+              default:
+                {
+                    char msg[BUFSIZ];
+                    std::sprintf( msg, "character string '%s' is not valid", 
+                    src_p );
+                    SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_, msg );
+                }
+                break;
+            }
+        }
+        if ( ctrl_p ) ctrl_p[word_i] = ctrl;
+        data_p[word_i] = data;
+        src_n = src_n - BITS_PER_DIGIT;
+    }
+}
+        
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Utility functions involving unsigned vectors.
+// ----------------------------------------------------------------------------
+
+// Read u from a null terminated char string v. Note that operator>>
+// in sc_nbcommon.cpp is similar to this function.
+small_type
+vec_from_str(int unb, int und, sc_digit *u, 
+             const char *v, sc_numrep base) 
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert((unb > 0) && (und > 0) && (u != NULL));
+  assert(v != NULL);
+#endif
+
+  is_valid_base(base);
+
+  small_type b, s;  // base and sign.
+
+  v = get_base_and_sign(v, b, s);
+
+  if (base != SC_NOBASE) {
+    if (b == NB_DEFAULT_BASE)
+      b = base;
+    else {
+	char msg[BUFSIZ];
+	std::sprintf( msg,
+		 "vec_from_str( int, int, sc_digit*, const char*, sc_numrep base ) : "
+		 "base = %s does not match the default base",
+		 to_string( base ).c_str() );
+	SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_, msg );
+    }
+  }
+
+  vec_zero(und, u);
+
+  char c;
+  
+  for ( ; (c = *v); ++v) {
+
+    if (isalnum(c)) {
+      
+      small_type val;  // Numeric value of a char.
+    
+      if (isalpha(c)) // Hex digit.
+        val = toupper(c) - 'A' + 10;
+      else
+        val = c - '0';
+      
+      if (val >= b) {
+	  char msg[BUFSIZ];
+	  std::sprintf( msg,
+		   "vec_from_str( int, int, sc_digit*, const char*, sc_numrep base ) : "
+		   "'%c' is not a valid digit in base %d",
+		   *v, b );
+	  SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_, msg );
+      }
+      
+      // digit = digit * b + val;
+      vec_mul_small_on(und, u, b);
+      
+      if (val)
+        vec_add_small_on(und, u, val);
+
+    }
+    else {
+	char msg[BUFSIZ];
+	std::sprintf( msg,
+		 "vec_from_str( int, int, sc_digit*, const char*, sc_numrep base ) : "
+		 "'%c' is not a valid digit in base %d",
+		 *v, b );
+	SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_, msg );
+    }
+  }
+
+  return convert_signed_SM_to_2C_to_SM(s, unb, und, u);
+}
+
+
+// All vec_ functions assume that the vector to hold the result,
+// called w, has sufficient length to hold the result. For efficiency
+// reasons, we do not test whether or not we are out of bounds.
+
+// Compute w = u + v, where w, u, and v are vectors. 
+// - ulen >= vlen
+// - wlen >= sc_max(ulen, vlen) + 1
+void
+vec_add(int ulen, const sc_digit *u,
+        int vlen, const sc_digit *v,
+        sc_digit *w)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert((ulen > 0) && (u != NULL));
+  assert((vlen > 0) && (v != NULL));
+  assert(w != NULL);
+  assert(ulen >= vlen);
+#endif
+
+  const sc_digit *uend = (u + ulen);
+  const sc_digit *vend = (v + vlen);
+
+  sc_digit carry = 0;   // Also used as sum to save space.
+
+  // Add along the shorter v.
+  while (v < vend) {
+    carry += (*u++) + (*v++);
+    (*w++) = carry & DIGIT_MASK;
+    carry >>= BITS_PER_DIGIT;
+  }
+
+  // Propagate the carry.
+  while (carry && (u < uend)) {
+    carry = (*u++) + 1;
+    (*w++) = carry & DIGIT_MASK;
+    carry >>= BITS_PER_DIGIT;
+  }
+
+  // Copy the rest of u to the result.
+  while (u < uend)
+    (*w++) = (*u++);
+
+  // Propagate the carry if it is still 1.
+  if (carry)
+    (*w) = 1;
+
+}
+
+
+// Compute u += v, where u and v are vectors.
+// - ulen >= vlen
+void
+vec_add_on(int ulen, sc_digit *ubegin, 
+           int vlen, const sc_digit *v)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert((ulen > 0) && (ubegin != NULL));
+  assert((vlen > 0) && (v != NULL));
+  assert(ulen >= vlen);
+#endif
+
+  sc_digit *u = ubegin;
+  const sc_digit *uend = (u + ulen);
+  const sc_digit *vend = (v + vlen);
+
+  sc_digit carry = 0;   // Also used as sum to save space.
+
+  // Add along the shorter v.
+  while (v < vend) {
+    carry += (*u) + (*v++);
+    (*u++) = carry & DIGIT_MASK;
+    carry >>= BITS_PER_DIGIT;
+  }
+
+  // Propagate the carry.
+  while (carry && (u < uend)) {
+    carry = (*u) + 1;
+    (*u++) = carry & DIGIT_MASK;
+    carry >>= BITS_PER_DIGIT;
+  }
+
+#ifdef DEBUG_SYSTEMC
+  if( carry != 0 ) {
+      SC_REPORT_WARNING( sc_core::SC_ID_WITHOUT_MESSAGE_,
+			 "vec_add_on( int, sc_digit*, int, const "
+			 "sc_digit* ) : "
+			 "result of addition is wrapped around" );
+  }
+#endif
+
+}
+
+
+// Compute u += v, where u and v are vectors.
+// - ulen < vlen
+void
+vec_add_on2(int ulen, sc_digit *ubegin, 
+            int
+#ifdef DEBUG_SYSTEMC
+            vlen
+#endif
+            , const sc_digit *v)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert((ulen > 0) && (ubegin != NULL));
+  assert((vlen > 0) && (v != NULL));
+  assert(ulen < vlen);
+#endif
+
+  sc_digit *u = ubegin;
+  const sc_digit *uend = (u + ulen);
+
+  sc_digit carry = 0;   // Also used as sum to save space.
+
+  // Add along the shorter u.
+  while (u < uend) {
+    carry += (*u) + (*v++);
+    (*u++) = carry & DIGIT_MASK;
+    carry >>= BITS_PER_DIGIT;
+  }
+
+#ifdef DEBUG_SYSTEMC
+  if( carry != 0 ) {
+      SC_REPORT_WARNING( sc_core::SC_ID_WITHOUT_MESSAGE_,
+                         "vec_add_on2( int, sc_digit*, int, const "
+			 "sc_digit* ) : "
+			 "result of addition is wrapped around" );
+  }
+#endif
+}
+
+
+// Compute w = u + v, where w and u are vectors, and v is a scalar.
+void
+vec_add_small(int ulen, const sc_digit *u,
+              sc_digit v, 
+              sc_digit *w)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert((ulen > 0) && (u != NULL));
+  assert(w != NULL);
+#endif
+
+  const sc_digit *uend = (u + ulen);
+
+  // Add along the shorter v.
+  sc_digit carry = (*u++) + v;
+  (*w++) = carry & DIGIT_MASK;
+  carry >>= BITS_PER_DIGIT;
+
+  // Propagate the carry.
+  while (carry && (u < uend)) {
+    carry = (*u++) + 1;
+    (*w++) = carry & DIGIT_MASK;
+    carry >>= BITS_PER_DIGIT;
+  }
+
+  // Copy the rest of u to the result.
+  while (u < uend)
+    (*w++) = (*u++);
+
+  // Propagate the carry if it is still 1.
+  if (carry)
+    (*w) = 1;
+
+}
+
+// Compute u += v, where u is vectors, and v is a scalar.
+void 
+vec_add_small_on(int ulen, sc_digit *u, sc_digit v)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert((ulen > 0) && (u != NULL));
+#endif
+
+  int i = 0;
+
+  while (v && (i < ulen)) {
+    v += u[i];
+    u[i++] = v & DIGIT_MASK;
+    v >>= BITS_PER_DIGIT;
+  }
+
+#ifdef DEBUG_SYSTEMC
+  if( v != 0 ) {
+      SC_REPORT_WARNING( sc_core::SC_ID_WITHOUT_MESSAGE_,
+                         "vec_add_small_on( int, sc_digit*, unsigned "
+			 "long ) : "
+			 "result of addition is wrapped around" );
+  }
+#endif
+
+}
+
+// Compute w = u - v, where w, u, and v are vectors.
+// - ulen >= vlen
+// - wlen >= sc_max(ulen, vlen)
+void
+vec_sub(int ulen, const sc_digit *u,
+        int vlen, const sc_digit *v,
+        sc_digit *w)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert((ulen > 0) && (u != NULL));
+  assert((vlen > 0) && (v != NULL));
+  assert(w != NULL);
+  assert(ulen >= vlen);
+#endif
+
+  const sc_digit *uend = (u + ulen);
+  const sc_digit *vend = (v + vlen);
+
+  sc_digit borrow = 0;   // Also used as diff to save space.
+
+  // Subtract along the shorter v.
+  while (v < vend) {
+    borrow = ((*u++) + DIGIT_RADIX) - (*v++) - borrow;
+    (*w++) = borrow & DIGIT_MASK;
+    borrow = 1 - (borrow >> BITS_PER_DIGIT);
+  }
+
+  // Propagate the borrow.
+  while (borrow && (u < uend)) {
+    borrow = ((*u++) + DIGIT_RADIX) - 1;
+    (*w++) = borrow & DIGIT_MASK;
+    borrow = 1 - (borrow >> BITS_PER_DIGIT);
+  }
+
+#ifdef DEBUG_SYSTEMC
+  assert(borrow == 0);
+#endif
+
+  // Copy the rest of u to the result.
+  while (u < uend)
+    (*w++) = (*u++);
+
+}
+
+// Compute u = u - v, where u and v are vectors.
+// - u > v
+// - ulen >= vlen
+void
+vec_sub_on(int ulen, sc_digit *ubegin,
+           int vlen, const sc_digit *v)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert((ulen > 0) && (ubegin != NULL));
+  assert((vlen > 0) && (v != NULL));
+  assert(ulen >= vlen);
+#endif
+
+  sc_digit *u = ubegin;
+  const sc_digit *uend = (u + ulen);
+  const sc_digit *vend = (v + vlen);
+
+  sc_digit borrow = 0;   // Also used as diff to save space.
+
+  // Subtract along the shorter v.
+  while (v < vend) {
+    borrow = ((*u) + DIGIT_RADIX) - (*v++) - borrow;
+    (*u++) = borrow & DIGIT_MASK;
+    borrow = 1 - (borrow >> BITS_PER_DIGIT);
+  }
+
+  // Propagate the borrow.
+  while (borrow && (u < uend)) {
+    borrow = ((*u) + DIGIT_RADIX) - 1;
+    (*u++) = borrow & DIGIT_MASK;
+    borrow = 1 - (borrow >> BITS_PER_DIGIT);
+  }
+
+#ifdef DEBUG_SYSTEMC
+  assert(borrow == 0);
+#endif
+
+}
+
+// Compute u = v - u, where u and v are vectors.
+// - v > u
+// - ulen <= vlen or ulen > ulen
+void
+vec_sub_on2(int ulen, sc_digit *ubegin,
+            int vlen, const sc_digit *v)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert((ulen > 0) && (ubegin != NULL));
+  assert((vlen > 0) && (v != NULL));
+#endif
+
+  sc_digit *u = ubegin;
+  const sc_digit *uend = (u + sc_min(ulen, vlen));
+
+  sc_digit borrow = 0;   // Also used as diff to save space.
+
+  // Subtract along the shorter u.
+  while (u < uend) {
+    borrow = ((*v++) + DIGIT_RADIX) - (*u) - borrow;
+    (*u++) = borrow & DIGIT_MASK;
+    borrow = 1 - (borrow >> BITS_PER_DIGIT);
+  }
+
+#ifdef DEBUG_SYSTEMC
+  if( borrow != 0 ) {
+      SC_REPORT_WARNING( sc_core::SC_ID_WITHOUT_MESSAGE_,
+                         "vec_sub_on2( int, sc_digit*, int, const "
+			 "sc_digit* ) : "
+			 "result of subtraction is wrapped around" );
+  }
+#endif
+}
+
+// Compute w = u - v, where w and u are vectors, and v is a scalar.
+void
+vec_sub_small(int ulen, const sc_digit *u,
+              sc_digit v, 
+              sc_digit *w)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert(ulen > 0);
+  assert(u != NULL);
+#endif
+
+  const sc_digit *uend = (u + ulen);
+
+  // Add along the shorter v.
+  sc_digit borrow = ((*u++) + DIGIT_RADIX) - v;
+  (*w++) = borrow & DIGIT_MASK;
+  borrow = 1 - (borrow >> BITS_PER_DIGIT);
+
+  // Propagate the borrow.
+  while (borrow && (u < uend)) {
+    borrow = ((*u++) + DIGIT_RADIX) - 1;
+    (*w++) = borrow & DIGIT_MASK;
+    borrow = 1 - (borrow >> BITS_PER_DIGIT);
+  }
+
+#ifdef DEBUG_SYSTEMC
+  assert(borrow == 0);
+#endif
+
+  // Copy the rest of u to the result.
+  while (u < uend)
+    (*w++) = (*u++);
+
+}
+
+
+// Compute u -= v, where u is vectors, and v is a scalar.
+void 
+vec_sub_small_on(int ulen, sc_digit *u, sc_digit v)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert((ulen > 0) && (u != NULL));
+#endif
+
+  for (int i = 0; i < ulen; ++i) {
+    v = (u[i] + DIGIT_RADIX) - v;    
+    u[i] = v & DIGIT_MASK;
+    v = 1 - (v >> BITS_PER_DIGIT);
+  }
+
+#ifdef DEBUG_SYSTEMC
+  assert(v == 0);
+#endif
+
+}
+
+// Compute w = u * v, where w, u, and v are vectors.
+void
+vec_mul(int ulen, const sc_digit *u,
+        int vlen, const sc_digit *vbegin, 
+        sc_digit *wbegin)
+{
+
+  /* Consider u = Ax + B and v = Cx + D where x is equal to
+     HALF_DIGIT_RADIX. In other words, A is the higher half of u and
+     B is the lower half of u. The interpretation for v is
+     similar. Then, we have the following picture:
+
+              u_h     u_l
+     u: -------- --------
+               A        B
+
+              v_h     v_l
+     v: -------- --------
+               C        D
+ 
+     result (d):                     
+     carry_before:                           -------- --------
+                                              carry_h  carry_l
+     result_before:        -------- -------- -------- --------
+                               R1_h     R1_l     R0_h     R0_l
+                                             -------- --------
+                                                 BD_h     BD_l
+                                    -------- --------
+                                        AD_h     AD_l
+                                    -------- --------
+                                        BC_h     BC_l
+                           -------- --------
+                               AC_h     AC_l
+     result_after:         -------- -------- -------- --------
+                              R1_h'    R1_l'    R0_h'    R0_l'
+ 
+     prod_l = R0_h|R0_l + B * D  + 0|carry_l
+            = R0_h|R0_l + BD_h|BD_l + 0|carry_l
+ 
+     prod_h = A * D + B * C + high_half(prod_l) + carry_h
+            = AD_h|AD_l + BC_h|BC_l + high_half(prod_l) + 0|carry_h
+ 
+     carry = A * C + high_half(prod_h)
+           = AC_h|AC_l + high_half(prod_h)
+ 
+     R0_l' = low_half(prod_l)
+ 
+     R0_h' = low_half(prod_h)
+ 
+     R0 = high_half(prod_h)|low_half(prod_l)
+ 
+     where '|' is the concatenation operation and the suffixes 0 and 1
+     show the iteration number, i.e., 0 is the current iteration and 1
+     is the next iteration.
+ 
+     NOTE: sc_max(prod_l, prod_h, carry) <= 2 * x^2 - 1, so any
+     of these numbers can be stored in a digit.
+
+     NOTE: low_half(u) returns the lower BITS_PER_HALF_DIGIT of u,
+     whereas high_half(u) returns the rest of the bits, which may
+     contain more bits than BITS_PER_HALF_DIGIT.  
+  */
+
+#ifdef DEBUG_SYSTEMC
+  assert((ulen > 0) && (u != NULL));
+  assert((vlen > 0) && (vbegin != NULL));
+  assert(wbegin != NULL);
+#endif
+
+#define prod_h carry
+
+  const sc_digit *uend = (u + ulen);
+  const sc_digit *vend = (vbegin + vlen);
+
+  while (u < uend) {
+
+    sc_digit u_h = (*u++);        // A|B
+    sc_digit u_l = low_half(u_h); // B
+    u_h = high_half(u_h);           // A
+
+#ifdef DEBUG_SYSTEMC
+    // The overflow bits must be zero.
+    assert(u_h == (u_h & HALF_DIGIT_MASK));
+#endif
+
+    sc_digit carry = 0;
+
+    sc_digit *w = (wbegin++);
+
+    const sc_digit *v = vbegin;
+
+    while (v < vend) {
+
+      sc_digit v_h = (*v++);         // C|D
+      sc_digit v_l = low_half(v_h);  // D
+
+      v_h = high_half(v_h);            // C
+
+#ifdef DEBUG_SYSTEMC
+      // The overflow bits must be zero.
+      assert(v_h == (v_h & HALF_DIGIT_MASK));
+#endif
+
+      sc_digit prod_l = (*w) + u_l * v_l + low_half(carry);
+
+      prod_h = u_h * v_l + u_l * v_h + high_half(prod_l) + high_half(carry);
+
+      (*w++) = concat(low_half(prod_h), low_half(prod_l));
+
+      carry = u_h * v_h + high_half(prod_h);
+
+    }
+
+    (*w) = carry;
+
+  }
+
+#undef prod_h
+
+}
+
+// Compute w = u * v, where w and u are vectors, and v is a scalar. 
+// - 0 < v < HALF_DIGIT_RADIX.
+void
+vec_mul_small(int ulen, const sc_digit *u,
+              sc_digit v, sc_digit *w)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert((ulen > 0) && (u != NULL));
+  assert(w != NULL);
+  assert((0 < v) && (v < HALF_DIGIT_RADIX));
+#endif
+
+#define prod_h carry
+
+  const sc_digit *uend = (u + ulen);
+
+  sc_digit carry = 0;
+
+  while (u < uend) {
+
+    sc_digit u_AB = (*u++);
+
+#ifdef DEBUG_SYSTEMC
+    // The overflow bits must be zero.
+    assert(high_half(u_AB) == high_half_masked(u_AB));
+#endif
+
+    sc_digit prod_l = v * low_half(u_AB) + low_half(carry);
+
+    prod_h = v * high_half(u_AB) + high_half(prod_l) + high_half(carry);
+
+    (*w++) = concat(low_half(prod_h), low_half(prod_l));
+
+    carry = high_half(prod_h);
+
+  }
+
+  (*w) = carry;
+
+#undef prod_h
+
+}
+
+// Compute u = u * v, where u is a vector, and v is a scalar.
+// - 0 < v < HALF_DIGIT_RADIX. 
+void
+vec_mul_small_on(int ulen, sc_digit *u, sc_digit v)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert((ulen > 0) && (u != NULL));
+  assert((0 < v) && (v < HALF_DIGIT_RADIX));
+#endif
+
+#define prod_h carry
+
+  sc_digit carry = 0;
+
+  for (int i = 0; i < ulen; ++i) {
+
+#ifdef DEBUG_SYSTEMC
+    // The overflow bits must be zero.
+    assert(high_half(u[i]) == high_half_masked(u[i]));
+#endif
+
+    sc_digit prod_l = v * low_half(u[i]) + low_half(carry);
+
+    prod_h = v * high_half(u[i]) + high_half(prod_l) + high_half(carry);
+
+    u[i] = concat(low_half(prod_h), low_half(prod_l));
+
+    carry = high_half(prod_h);
+
+  }
+
+#undef prod_h
+
+#ifdef DEBUG_SYSTEMC
+  if( carry != 0 ) {
+      SC_REPORT_WARNING( sc_core::SC_ID_WITHOUT_MESSAGE_,
+                         "vec_mul_small_on( int, sc_digit*, unsigned "
+			 "long ) : "
+			 "result of multiplication is wrapped around" );
+  }
+#endif
+}
+
+// Compute w = u / v, where w, u, and v are vectors. 
+// - u and v are assumed to have at least two digits as uchars.
+void
+vec_div_large(int ulen, const sc_digit *u,
+              int vlen, const sc_digit *v,
+              sc_digit *w)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert((ulen > 0) && (u != NULL));
+  assert((vlen > 0) && (v != NULL));
+  assert(w != NULL);
+  assert(BITS_PER_DIGIT >= 3 * BITS_PER_BYTE);
+#endif
+
+  // We will compute q = x / y where x = u and y = v. The reason for
+  // using x and y is that x and y are BYTE_RADIX copies of u and v,
+  // respectively. The use of BYTE_RADIX radix greatly simplifies the
+  // complexity of the division operation. These copies are also
+  // needed even when we use DIGIT_RADIX representation.
+
+  int xlen = BYTES_PER_DIGIT * ulen + 1;
+  int ylen = BYTES_PER_DIGIT * vlen;
+
+#ifdef SC_MAX_NBITS
+  uchar x[DIV_CEIL2(SC_MAX_NBITS, BITS_PER_BYTE)];
+  uchar y[DIV_CEIL2(SC_MAX_NBITS, BITS_PER_BYTE)];
+  uchar q[DIV_CEIL2(SC_MAX_NBITS, BITS_PER_BYTE)];
+#else
+  uchar *x = new uchar[xlen];
+  uchar *y = new uchar[ylen];
+  // valgrind complains about us accessing too far to so leave a buffer.
+  uchar *q = new uchar[(xlen - ylen) + 10];
+#endif
+
+  // q corresponds to w.
+
+  // Set (uchar) x = (sc_digit) u.
+  xlen = vec_to_char(ulen, u, xlen, x);
+
+  // Skip all the leading zeros in x.
+  while ((--xlen >= 0) && (! x[xlen])) continue;
+  xlen++;
+
+  // Set (uchar) y = (sc_digit) v.
+  ylen = vec_to_char(vlen, v, ylen, y);
+
+  // Skip all the leading zeros in y.
+  while ((--ylen >= 0) && (! y[ylen])) continue;
+  ylen++;
+
+#ifdef DEBUG_SYSTEMC
+  assert(xlen > 1);
+  assert(ylen > 1);
+#endif
+
+  // At this point, all the leading zeros are eliminated from x and y.
+
+  // Zero the last digit of x.
+  x[xlen] = 0;
+
+  // The first two digits of y.
+  sc_digit y2 = (y[ylen - 1] << BITS_PER_BYTE) + y[ylen - 2];
+
+  const sc_digit DOUBLE_BITS_PER_BYTE = 2 * BITS_PER_BYTE;
+
+  // Find each q[k].
+  for (int k = (xlen - ylen); k >= 0; --k) {
+
+    // qk is a guess for q[k] such that q[k] = qk or qk - 1.
+    sc_digit qk;
+
+    // Find qk by just using 2 digits of y and 3 digits of x. The
+    // following code assumes that sizeof(sc_digit) >= 3 BYTEs.
+    int k2 = k + ylen;
+
+    qk = ((x[k2] << DOUBLE_BITS_PER_BYTE) + 
+          (x[k2 - 1] << BITS_PER_BYTE) + x[k2 - 2]) / y2;
+
+    if (qk >= BYTE_RADIX)     // qk cannot be larger than the largest
+      qk = BYTE_RADIX - 1;    // digit in BYTE_RADIX.
+
+    // q[k] = qk or qk - 1. The following if-statement determines which:
+    if (qk) {
+
+      uchar *xk = (x + k);  // A shortcut for x[k].
+
+      // x = x - y * qk :
+      sc_digit carry = 0;
+
+      for (int i = 0; i < ylen; ++i) {
+        carry += y[i] * qk;
+        sc_digit diff = (xk[i] + BYTE_RADIX) - (carry & BYTE_MASK);
+        xk[i] = (uchar)(diff & BYTE_MASK);
+        carry = (carry >> BITS_PER_BYTE) + (1 - (diff >> BITS_PER_BYTE));
+      }
+
+      // If carry, qk may be one too large.
+      if (carry) {
+
+        // 2's complement the last digit.
+        carry = (xk[ylen] + BYTE_RADIX) - carry;
+        xk[ylen] = (uchar)(carry & BYTE_MASK);
+        carry = 1 - (carry >> BITS_PER_BYTE);
+        
+        if (carry) {
+
+          // qk was one too large, so decrement it.
+          --qk;
+        
+          // Since qk was decreased by one, y must be added to x:
+          // That is, x = x - y * (qk - 1) = x - y * qk + y = x_above + y.
+          carry = 0;
+
+          for (int i = 0; i < ylen; ++i) {
+            carry += xk[i] + y[i];
+            xk[i] = (uchar)(carry & BYTE_MASK);
+            carry >>= BITS_PER_BYTE;
+          }
+
+          if (carry)
+            xk[ylen] = (uchar)((xk[ylen] + 1) & BYTE_MASK);
+
+        }  // second if carry
+      }  // first if carry
+    }  // if qk
+
+    q[k] = (uchar)qk;
+
+  }  // for k
+
+  // Set (sc_digit) w = (uchar) q.
+  vec_from_char(xlen - ylen + 1, q, ulen, w);
+
+#ifndef SC_MAX_NBITS
+  delete [] x;
+  delete [] y;
+  delete [] q;
+#endif
+
+}
+
+// Compute w = u / v, where u and w are vectors, and v is a scalar.
+// - 0 < v < HALF_DIGIT_RADIX. Below, we rename w to q.
+void 
+vec_div_small(int ulen, const sc_digit *u,
+              sc_digit v, sc_digit *q)
+{
+
+  // Given (u = u_1u_2...u_n)_b = (q = q_1q_2...q_n) * v + r, where b
+  // is the base, and 0 <= r < v. Then, the algorithm is as follows:
+  //
+  // r = 0; 
+  // for (j = 1; j <= n; j++) {
+  //   q_j = (r * b + u_j) / v;
+  //   r = (r * b + u_j) % v;
+  // }
+  // 
+  // In our case, b = DIGIT_RADIX, and u = Ax + B and q = Cx + D where
+  // x = HALF_DIGIT_RADIX. Note that r < v < x and b = x^2. Then, a
+  // typical situation is as follows:
+  //
+  // ---- ----
+  // 0    r
+  //           ---- ----
+  //           A    B
+  //      ---- ---- ----
+  //      r    A    B     = r * b + u
+  //
+  // Hence, C = (r|A) / v.
+  //        D = (((r|A) % v)|B) / v
+  //        r = (((r|A) % v)|B) % v
+
+#ifdef DEBUG_SYSTEMC
+  assert((ulen > 0) && (u != NULL));
+  assert(q != NULL);
+  assert((0 < v) && (v < HALF_DIGIT_RADIX));
+#endif
+
+#define q_h r
+
+  sc_digit r = 0;
+  const sc_digit *ubegin = u;
+
+  u += ulen;
+  q += ulen;
+
+  while (ubegin < u) {
+
+    sc_digit u_AB = (*--u);       // A|B
+
+#ifdef DEBUG_SYSTEMC
+    // The overflow bits must be zero.
+    assert(high_half(u_AB) == high_half_masked(u_AB));
+#endif
+
+    sc_digit num = concat(r, high_half(u_AB));  // num = r|A
+    q_h = num / v;                           // C
+    num = concat((num % v), low_half(u_AB)); // num = (((r|A) % v)|B) 
+    (*--q) = concat(q_h, num / v);           // q = C|D
+    r = num % v;
+
+  }
+
+#undef q_h
+
+}
+
+// Compute w = u % v, where w, u, and v are vectors. 
+// - u and v are assumed to have at least two digits as uchars.
+void
+vec_rem_large(int ulen, const sc_digit *u,
+              int vlen, const sc_digit *v,
+              sc_digit *w)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert((ulen > 0) && (u != NULL));
+  assert((vlen > 0) && (v != NULL));
+  assert(w != NULL);
+  assert(BITS_PER_DIGIT >= 3 * BITS_PER_BYTE);
+#endif
+
+  // This function is adapted from vec_div_large.
+
+  int xlen = BYTES_PER_DIGIT * ulen + 1;
+  int ylen = BYTES_PER_DIGIT * vlen;
+
+#ifdef SC_MAX_NBITS
+  uchar x[DIV_CEIL2(SC_MAX_NBITS, BITS_PER_BYTE)];
+  uchar y[DIV_CEIL2(SC_MAX_NBITS, BITS_PER_BYTE)];
+#else
+  uchar *x = new uchar[xlen];
+  uchar *y = new uchar[ylen];
+#endif
+
+  // r corresponds to w.
+
+  // Set (uchar) x = (sc_digit) u.
+  xlen = vec_to_char(ulen, u, xlen, x);
+
+  // Skip all the leading zeros in x.
+  while ((--xlen >= 0) && (! x[xlen])) continue;
+  xlen++;
+
+  // Set (uchar) y = (sc_digit) v.
+  ylen = vec_to_char(vlen, v, ylen, y);
+
+  // Skip all the leading zeros in y.
+  while ((--ylen >= 0) && (! y[ylen])) continue;
+  ylen++;
+
+#ifdef DEBUG_SYSTEMC
+  assert(xlen > 1);
+  assert(ylen > 1);
+#endif
+
+  // At this point, all the leading zeros are eliminated from x and y.
+
+  // Zero the last digit of x.
+  x[xlen] = 0;
+
+  // The first two digits of y.
+  sc_digit y2 = (y[ylen - 1] << BITS_PER_BYTE) + y[ylen - 2];
+
+  const sc_digit DOUBLE_BITS_PER_BYTE = 2 * BITS_PER_BYTE;
+
+  // Find each q[k].
+  for (int k = xlen - ylen; k >= 0; --k) {
+
+    // qk is a guess for q[k] such that q[k] = qk or qk - 1.
+    sc_digit qk;
+
+    // Find qk by just using 2 digits of y and 3 digits of x. The
+    // following code assumes that sizeof(sc_digit) >= 3 BYTEs.
+    int k2 = k + ylen;
+
+    qk = ((x[k2] << DOUBLE_BITS_PER_BYTE) +
+      (x[k2 - 1] << BITS_PER_BYTE) + x[k2 - 2]) / y2;
+
+    if (qk >= BYTE_RADIX)     // qk cannot be larger than the largest
+      qk = BYTE_RADIX - 1;    // digit in BYTE_RADIX.
+
+    // q[k] = qk or qk - 1. The following if-statement determines which.
+    if (qk) {
+
+      uchar *xk = (x + k);  // A shortcut for x[k].
+
+      // x = x - y * qk;
+      sc_digit carry = 0;
+
+      for (int i = 0; i < ylen; ++i) {
+        carry += y[i] * qk;
+        sc_digit diff = (xk[i] + BYTE_RADIX) - (carry & BYTE_MASK);
+        xk[i] = (uchar)(diff & BYTE_MASK);
+        carry = (carry >> BITS_PER_BYTE) + (1 - (diff >> BITS_PER_BYTE));
+      }
+
+      if (carry) {
+
+        // 2's complement the last digit.
+        carry = (xk[ylen] + BYTE_RADIX) - carry;
+        xk[ylen] = (uchar)(carry & BYTE_MASK);
+        carry = 1 - (carry >> BITS_PER_BYTE);
+        
+        if (carry) {
+
+          // qk was one too large, so decrement it.
+          // --qk;
+        
+          // x = x - y * (qk - 1) = x - y * qk + y = x_above + y.
+          carry = 0;
+
+          for (int i = 0; i < ylen; ++i) {
+            carry += xk[i] + y[i];
+            xk[i] = (uchar)(carry & BYTE_MASK);
+            carry >>= BITS_PER_BYTE;
+          }
+
+          if (carry)
+            xk[ylen] = (uchar)((xk[ylen] + 1) & BYTE_MASK);
+
+        }  // second if carry
+      } // first if carry
+    }  // if qk
+  }  // for k
+
+  // Set (sc_digit) w = (uchar) x for the remainder.
+  vec_from_char(ylen, x, ulen, w);
+
+#ifndef SC_MAX_NBITS
+  delete [] x;
+  delete [] y;
+#endif
+
+}
+
+// Compute r = u % v, where u is a vector, and r and v are scalars.
+// - 0 < v < HALF_DIGIT_RADIX. 
+// - The remainder r is returned.
+sc_digit
+vec_rem_small(int ulen, const sc_digit *u, sc_digit v)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert((ulen > 0) && (u != NULL));
+  assert((0 < v) && (v < HALF_DIGIT_RADIX));
+#endif
+
+  // This function is adapted from vec_div_small().
+
+  sc_digit r = 0;
+  const sc_digit *ubegin = u;
+
+  u += ulen;
+
+  while (ubegin < u) {
+    sc_digit u_AB = (*--u);  // A|B
+
+#ifdef DEBUG_SYSTEMC
+    // The overflow bits must be zero.
+    assert(high_half(u_AB) == high_half_masked(u_AB));
+#endif
+
+    // r = (((r|A) % v)|B) % v
+    r = (concat(((concat(r, high_half(u_AB))) % v), low_half(u_AB))) % v;
+  }
+
+  return r;
+
+}
+
+// u = u / v, r = u % v.
+sc_digit
+vec_rem_on_small(int ulen, sc_digit *u, sc_digit v)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert((ulen > 0) && (u != NULL));
+  assert(v > 0);
+#endif
+
+#define q_h r
+
+  sc_digit r = 0;
+  const sc_digit *ubegin = u;
+
+  u += ulen;
+
+  while (ubegin < u) {
+
+    sc_digit u_AB = (*--u);       // A|B
+
+#ifdef DEBUG_SYSTEMC
+    // The overflow bits must be zero.
+    assert(high_half(u_AB) == high_half_masked(u_AB));
+#endif
+
+    sc_digit num = concat(r, high_half(u_AB));  // num = r|A
+    q_h = num / v;                           // C
+    num = concat((num % v), low_half(u_AB)); // num = (((r|A) % v)|B) 
+    (*u) = concat(q_h, num / v);             // q = C|D
+    r = num % v;
+
+  }
+
+#undef q_h
+
+  return r;
+
+}
+
+// Set (uchar) v = (sc_digit) u. Return the new vlen.
+int
+vec_to_char(int ulen, const sc_digit *u,
+            int vlen, uchar *v)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert((ulen > 0) && (u != NULL));
+  assert((vlen > 0) && (v != NULL));
+#endif
+
+  int nbits = ulen * BITS_PER_DIGIT;
+
+  int right = 0;
+  int left = right + BITS_PER_BYTE - 1;
+
+  vlen = 0;
+
+  while (nbits > 0) {
+
+    int left_digit = left / BITS_PER_DIGIT;
+    int right_digit = right / BITS_PER_DIGIT;
+
+    int nsr = ((vlen << LOG2_BITS_PER_BYTE) % BITS_PER_DIGIT);
+
+    int d = u[right_digit] >> nsr;
+
+    if (left_digit != right_digit) {
+
+      if (left_digit < ulen)
+        d |= u[left_digit] << (BITS_PER_DIGIT - nsr);
+
+    }
+
+    v[vlen++] = (uchar)(d & BYTE_MASK);
+
+    left += BITS_PER_BYTE;
+    right += BITS_PER_BYTE;
+    nbits -= BITS_PER_BYTE;
+
+  }
+
+  return vlen;
+
+}
+
+// Set (sc_digit) v = (uchar) u. 
+// - sizeof(uchar) <= sizeof(sc_digit), 
+void 
+vec_from_char(int ulen, const uchar *u, 
+              int vlen, sc_digit *v)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert((ulen > 0) && (u != NULL));
+  assert((vlen > 0) && (v != NULL));
+  assert(sizeof(uchar) <= sizeof(sc_digit));
+#endif
+
+  sc_digit *vend = (v + vlen);
+
+  const int nsr = BITS_PER_DIGIT - BITS_PER_BYTE;
+  const sc_digit mask = one_and_ones(nsr);
+
+  (*v) = (sc_digit) u[ulen - 1];
+
+  for (int i = ulen - 2; i >= 0; --i) {
+
+    // Manual inlining of vec_shift_left().
+
+    sc_digit *viter = v;
+
+    sc_digit carry = 0;
+
+    while (viter < vend) {
+      sc_digit vval = (*viter);
+      (*viter++) = (((vval & mask) << BITS_PER_BYTE) | carry);
+      carry = vval >> nsr;
+    }
+
+    if (viter < vend)
+      (*viter) = carry;
+
+    (*v) |= (sc_digit) u[i];
+
+  }
+
+}
+
+// Set u <<= nsl.
+// If nsl is negative, it is ignored.
+void 
+vec_shift_left(int ulen, sc_digit *u, int nsl)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert((ulen > 0) && (u != NULL));
+#endif
+
+  if (nsl <= 0)
+    return;
+
+  // Shift left whole digits if nsl is large enough.
+  if (nsl >= (int) BITS_PER_DIGIT) {
+
+    int nd;
+
+    if (nsl % BITS_PER_DIGIT == 0) {
+      nd = nsl / BITS_PER_DIGIT;  // No need to use DIV_CEIL(nsl).
+      nsl = 0;
+    }
+    else {
+      nd = DIV_CEIL(nsl) - 1;
+      nsl -= nd * BITS_PER_DIGIT;
+    }
+
+    if (nd) {
+
+      // Shift left for nd digits.
+      for (int j = ulen - 1; j >= nd; --j)
+        u[j] = u[j - nd];
+      
+      vec_zero( sc_min( nd, ulen ), u );
+      
+    }
+
+    if (nsl == 0)
+      return;
+
+  }
+
+  // Shift left if nsl < BITS_PER_DIGIT.
+  sc_digit *uiter = u;
+  sc_digit *uend = uiter + ulen;
+
+  int nsr = BITS_PER_DIGIT - nsl;
+  sc_digit mask = one_and_ones(nsr);
+
+  sc_digit carry = 0;
+
+  while (uiter < uend) {
+    sc_digit uval = (*uiter);
+    (*uiter++) = (((uval & mask) << nsl) | carry);
+    carry = uval >> nsr;
+  }
+
+  if (uiter < uend)
+    (*uiter) = carry;
+
+}
+
+// Set u >>= nsr.
+// If nsr is negative, it is ignored.
+void 
+vec_shift_right(int ulen, sc_digit *u, int nsr, sc_digit fill)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert((ulen > 0) && (u != NULL));
+#endif
+
+  // fill is usually either 0 or DIGIT_MASK; it can be any value.
+
+  if (nsr <= 0)
+    return;
+
+  // Shift right whole digits if nsr is large enough.
+  if (nsr >= (int) BITS_PER_DIGIT) {
+
+    int nd;
+
+    if (nsr % BITS_PER_DIGIT == 0) {
+      nd = nsr / BITS_PER_DIGIT;
+      nsr = 0;
+    }
+    else {
+      nd = DIV_CEIL(nsr) - 1;
+      nsr -= nd * BITS_PER_DIGIT;
+    }
+    
+    if (nd) {
+
+      // Shift right for nd digits.
+      for (int j = 0; j < (ulen - nd); ++j)
+        u[j] = u[j + nd];
+
+      if (fill) {
+        for (int j = ulen - sc_min( nd, ulen ); j < ulen; ++j)
+          u[j] = fill;
+      }
+      else
+        vec_zero(ulen - sc_min( nd, ulen ), ulen, u);
+     
+    }
+
+    if (nsr == 0)
+      return;
+
+  }
+
+  // Shift right if nsr < BITS_PER_DIGIT.
+  sc_digit *ubegin = u;
+  sc_digit *uiter = (ubegin + ulen);
+
+  int nsl = BITS_PER_DIGIT - nsr;
+  sc_digit mask = one_and_ones(nsr);
+
+  sc_digit carry = (fill & mask) << nsl;
+
+  while (ubegin < uiter) {
+    sc_digit uval = (*--uiter);
+    (*uiter) = (uval >> nsr) | carry;
+    carry = (uval & mask) << nsl;
+  }
+
+}
+
+
+// Let u[l..r], where l and r are left and right bit positions
+// respectively, be equal to its mirror image.
+void
+vec_reverse(int unb, int und, sc_digit *ud, 
+            int l, int r)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert((unb > 0) && (und > 0) && (ud != NULL));
+  assert((0 <= r) && (r <= l) && (l < unb));
+#endif
+
+  if (l < r) {
+      char msg[BUFSIZ];
+      std::sprintf( msg, "vec_reverse( int, int, sc_digit*, int l, int r ) : "
+	       "l = %d < r = %d is not valid",
+	       l, r );
+      SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_, msg );
+  }
+
+  // Make sure that l and r are within bounds.
+  r = sc_max(r, 0);
+  l = sc_min(l, unb - 1);
+
+  // Allocate memory for processing.
+#ifdef SC_MAX_NBITS
+  sc_digit d[MAX_NDIGITS];
+#else
+  sc_digit *d = new sc_digit[und];
+#endif
+
+  // d is a copy of ud.
+  vec_copy(und, d, ud);
+
+  // Based on the value of the ith in d, find the value of the jth bit
+  // in ud.
+
+  for (int i = l, j = r; i >= r; --i, ++j) {
+
+    if ((d[digit_ord(i)] & one_and_zeros(bit_ord(i))) != 0) // Test.
+      ud[digit_ord(j)] |= one_and_zeros(bit_ord(j));     // Set.
+    else  
+      ud[digit_ord(j)] &= ~(one_and_zeros(bit_ord(j)));  // Clear.
+
+  }
+
+#ifndef SC_MAX_NBITS
+  delete [] d;
+#endif
+    
+}
+
+} // namespace sc_dt
+
+
+// End of file.
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_nbutils.h b/ext/systemc/src/sysc/datatypes/int/sc_nbutils.h
new file mode 100644
index 000000000..0bd4b4b03
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_nbutils.h
@@ -0,0 +1,1051 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_nbutils.h -- External and friend functions for both sc_signed and
+                  sc_unsigned classes.
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+ 
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_nbutils.h,v $
+// Revision 1.6  2011/09/08 16:12:15  acg
+//  Philipp A. Hartmann: fix issue with Sun machines wrt real math libraries.
+//
+// Revision 1.5  2011/08/26 23:00:01  acg
+//  Torsten Maehne: remove use of ieeefp.h.
+//
+// Revision 1.4  2011/08/15 16:43:24  acg
+//  Torsten Maehne: changes to remove unused argument warnings.
+//
+// Revision 1.3  2011/02/18 20:19:15  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.2  2010/09/06 16:35:48  acg
+//  Andy Goodrich: changed i386 to __i386__ in ifdef's.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:49:32  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#ifndef SC_NBUTILS_H
+#define SC_NBUTILS_H
+
+#include <cmath>
+#include <limits>
+
+#include "sysc/datatypes/bit/sc_bit_ids.h"
+#include "sysc/datatypes/int/sc_int_ids.h"
+#include "sysc/datatypes/int/sc_nbdefs.h"
+#include "sysc/utils/sc_report.h"
+
+
+namespace sc_dt
+{
+
+//-----------------------------------------------------------------------------
+//"sc_io_base"
+//
+// This inline function returns the type of an i/o stream's base as a SystemC
+// base designator.
+//   stream_object = reference to the i/o stream whose base is to be returned.
+//
+//"sc_io_show_base"
+//
+// This inline function returns true if the base should be shown when a SystemC
+// value is displayed via the supplied stream operator.
+//   stream_object = reference to the i/o stream to return showbase value for.
+//-----------------------------------------------------------------------------
+#if defined(__GNUC__) || defined(_MSC_VER) || defined(__SUNPRO_CC)
+    inline sc_numrep
+    sc_io_base( systemc_ostream& os, sc_numrep def_base )
+    {
+        std::ios::fmtflags flags = os.flags() & std::ios::basefield;
+        if ( flags & ::std::ios::dec ) return  SC_DEC;
+        if ( flags & ::std::ios::hex ) return  SC_HEX;
+        if ( flags & ::std::ios::oct ) return  SC_OCT;
+        return def_base;
+    }
+
+    inline bool
+    sc_io_show_base( systemc_ostream& os )
+    {
+        return (os.flags() & ::std::ios::showbase) != 0 ;
+    }
+#else   // Other
+    inline sc_numrep
+    sc_io_base( systemc_ostream& /*unused*/, sc_numrep /*unused*/ )
+    {
+        return SC_DEC;
+    }
+    inline bool
+    sc_io_show_base( systemc_ostream& /*unused*/ )
+    {
+        return false;
+    }
+#endif
+
+const std::string to_string( sc_numrep );
+
+inline
+systemc_ostream&
+operator << ( systemc_ostream& os, sc_numrep numrep )
+{
+    os << to_string( numrep );
+    return os;
+}
+
+// only used within vec_from_str (non-standard, deprecated)
+inline void
+is_valid_base(sc_numrep base)
+{
+  switch (base) {
+    case SC_NOBASE: case SC_BIN: 
+    case SC_OCT: case SC_DEC: 
+    case SC_HEX: 
+        break;
+    case SC_BIN_US: case SC_BIN_SM: 
+    case SC_OCT_US: case SC_OCT_SM:
+    case SC_HEX_US: case SC_HEX_SM:
+    case SC_CSD:
+      SC_REPORT_ERROR( sc_core::SC_ID_NOT_IMPLEMENTED_,
+		       "is_valid_base( sc_numrep base ) : "
+		       "bases SC_CSD, or ending in _US and _SM are not supported" );
+      break;
+    default:
+      char msg[BUFSIZ];
+      std::sprintf( msg, "is_valid_base( sc_numrep base ) : "
+	       "base = %s is not valid",
+	       to_string( base ).c_str() );
+      SC_REPORT_ERROR( sc_core::SC_ID_VALUE_NOT_VALID_, msg );
+  }
+}
+
+// ----------------------------------------------------------------------------
+
+// One transition of the FSM to find base and sign of a number.
+extern
+small_type 
+fsm_move(char c, small_type &b, small_type &s, small_type &state);
+
+// Parse a character string into its equivalent binary bits.
+extern
+void parse_binary_bits( 
+    const char* src_p, int dst_n, sc_digit* data_p, sc_digit* ctrl_p=0
+);
+
+
+// Parse a character string into its equivalent hexadecimal bits.
+extern
+void parse_hex_bits( 
+    const char* src_p, int dst_n, sc_digit* data_p, sc_digit* ctrl_p=0
+);
+
+
+// Find the base and sign of a number in v.
+extern 
+const char *
+get_base_and_sign(const char *v, small_type &base, small_type &sign);
+
+// Create a number out of v in base.
+extern 
+small_type 
+vec_from_str(int unb, int und, sc_digit *u, 
+             const char *v, sc_numrep base = SC_NOBASE) ;
+
+
+// ----------------------------------------------------------------------------
+//  Naming convention for the vec_ functions below:
+//    vec_OP(u, v, w)  : computes w = u OP v.
+//    vec_OP_on(u, v)  : computes u = u OP v if u has more digits than v.
+//    vec_OP_on2(u, v) : computes u = u OP v if u has fewer digits than v.
+//    _large           : parameters are vectors.
+//    _small           : one of the parameters is a single digit.
+//    Xlen             : the number of digits in X.
+// ----------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
+//  Functions for vector addition: w = u + v or u += v.
+// ----------------------------------------------------------------------------
+
+extern 
+void 
+vec_add(int ulen, const sc_digit *u, 
+        int vlen, const sc_digit *v, sc_digit *w);
+
+extern 
+void 
+vec_add_on(int ulen, sc_digit *u, 
+           int vlen, const sc_digit *v);
+
+extern 
+void 
+vec_add_on2(int ulen, sc_digit *u, 
+            int vlen, const sc_digit *v);
+
+extern 
+void 
+vec_add_small(int ulen, const sc_digit *u,
+              sc_digit v, sc_digit *w);
+
+extern 
+void 
+vec_add_small_on(int ulen, sc_digit *u, sc_digit v);
+
+
+// ----------------------------------------------------------------------------
+//  Functions for vector subtraction: w = u - v, u -= v, or u = v - u.
+// ----------------------------------------------------------------------------
+
+extern 
+void 
+vec_sub(int ulen, const sc_digit *u, 
+        int vlen, const sc_digit *v, sc_digit *w);
+
+extern 
+void 
+vec_sub_on(int ulen, sc_digit *u, 
+           int vlen, const sc_digit *v);
+
+extern 
+void 
+vec_sub_on2(int ulen, sc_digit *u,
+            int vlen, const sc_digit *v);
+
+extern 
+void 
+vec_sub_small(int ulen, const sc_digit *u,
+              sc_digit v, sc_digit *w);
+
+extern 
+void 
+vec_sub_small_on(int ulen, sc_digit *u, sc_digit v);
+
+
+// ----------------------------------------------------------------------------
+//  Functions for vector multiplication: w = u * v or u *= v.
+// ----------------------------------------------------------------------------
+
+extern 
+void 
+vec_mul(int ulen, const sc_digit *u, 
+        int vlen, const sc_digit *v, sc_digit *w);
+
+extern 
+void 
+vec_mul_small(int ulen, const sc_digit *u,
+              sc_digit v, sc_digit *w);
+
+extern 
+void 
+vec_mul_small_on(int ulen, sc_digit *u, sc_digit v);
+
+
+// ----------------------------------------------------------------------------
+//  Functions for vector division: w = u / v.
+// ----------------------------------------------------------------------------
+
+extern 
+void 
+vec_div_large(int ulen, const sc_digit *u, 
+              int vlen, const sc_digit *v, sc_digit *w);
+
+extern 
+void 
+vec_div_small(int ulen, const sc_digit *u, 
+              sc_digit v, sc_digit *w);
+
+
+// ----------------------------------------------------------------------------
+//  Functions for vector remainder: w = u % v or u %= v.
+// ----------------------------------------------------------------------------
+
+extern 
+void 
+vec_rem_large(int ulen, const sc_digit *u, 
+              int vlen, const sc_digit *v, sc_digit *w);
+
+extern 
+sc_digit 
+vec_rem_small(int ulen, const sc_digit *u, sc_digit v);
+
+extern 
+sc_digit 
+vec_rem_on_small(int ulen, sc_digit *u, sc_digit v);
+
+
+// ----------------------------------------------------------------------------
+//  Functions to convert between vectors of char and sc_digit.
+// ----------------------------------------------------------------------------
+
+extern 
+int 
+vec_to_char(int ulen, const sc_digit *u, 
+            int vlen, uchar *v);
+
+extern 
+void 
+vec_from_char(int ulen, const uchar *u,
+              int vlen, sc_digit *v);
+
+
+// ----------------------------------------------------------------------------
+//  Functions to shift left or right, or to create a mirror image of vectors.
+// ----------------------------------------------------------------------------
+
+extern 
+void 
+vec_shift_left(int ulen, sc_digit *u, int nsl);
+
+extern 
+void 
+vec_shift_right(int vlen, sc_digit *u, int nsr, sc_digit fill = 0);
+
+extern
+void 
+vec_reverse(int unb, int und, sc_digit *ud, 
+            int l, int r = 0);
+
+
+// ----------------------------------------------------------------------------
+//  Various utility functions. 
+// ----------------------------------------------------------------------------
+
+// Return the low half part of d.
+inline 
+sc_digit 
+low_half(sc_digit d) 
+{
+  return (d & HALF_DIGIT_MASK);
+}
+
+// Return the high half part of d. The high part of the digit may have
+// more bits than BITS_PER_HALF_DIGIT due to, e.g., overflow in the
+// multiplication. Hence, in other functions that use high_half(),
+// make sure that the result contains BITS_PER_HALF_DIGIT if
+// necessary. This is done by high_half_masked().
+inline 
+sc_digit 
+high_half(sc_digit d) 
+{
+  return (d >> BITS_PER_HALF_DIGIT);
+}
+
+inline
+sc_digit
+high_half_masked(sc_digit d)
+{
+  return (high_half(d) & HALF_DIGIT_MASK);
+}
+
+// Concatenate the high part h and low part l. Assumes that h and l
+// are less than or equal to HALF_DIGIT_MASK;
+inline 
+sc_digit 
+concat(sc_digit h, sc_digit l) 
+{
+  return ((h << BITS_PER_HALF_DIGIT) | l);
+}
+
+// Create a number with n 1's.
+inline
+sc_digit
+one_and_ones(int n)
+{
+  return (((sc_digit) 1 << n) - 1);
+}
+
+// Create a number with one 1 and n 0's.
+inline
+sc_digit
+one_and_zeros(int n)
+{
+  return ((sc_digit) 1 << n);
+}
+
+
+// ----------------------------------------------------------------------------
+
+// Find the digit that bit i is in.
+inline
+int 
+digit_ord(int i)
+{
+  return (i / BITS_PER_DIGIT);
+}
+
+// Find the bit in digit_ord(i) that bit i corressponds to.
+inline
+int 
+bit_ord(int i)
+{
+  return (i % BITS_PER_DIGIT);
+}
+
+
+// ----------------------------------------------------------------------------
+//  Functions to compare, zero, complement vector(s).
+// ----------------------------------------------------------------------------
+
+// Compare u and v and return r
+//  r = 0 if u == v
+//  r < 0 if u < v
+//  r > 0 if u > v
+// - Assume that all the leading zero digits are already skipped.
+// - ulen and/or vlen can be zero.
+// - Every digit is less than or equal to DIGIT_MASK;
+inline 
+int
+vec_cmp(int ulen, const sc_digit *u, 
+        int vlen, const sc_digit *v)
+{
+
+#ifdef DEBUG_SYSTEMC
+  // assert((ulen <= 0) || (u != NULL));
+  // assert((vlen <= 0) || (v != NULL));
+
+  // ulen and vlen can be equal to 0 because vec_cmp can be called
+  // after vec_skip_leading_zeros.
+  assert((ulen >= 0) && (u != NULL));
+  assert((vlen >= 0) && (v != NULL));
+  // If ulen > 0, then the leading digit of u must be non-zero.
+  assert((ulen <= 0) || (u[ulen - 1] != 0));
+  assert((vlen <= 0) || (v[vlen - 1] != 0));
+#endif
+
+  if (ulen != vlen)
+    return (ulen - vlen);
+
+  // ulen == vlen >= 1
+  while ((--ulen >= 0) && (u[ulen] == v[ulen]))
+    ;
+
+  if (ulen < 0)
+    return 0;
+
+#ifdef DEBUG_SYSTEMC
+  // Test to see if the result is wrong due to the presence of
+  // overflow bits.
+  assert((u[ulen] & DIGIT_MASK) != (v[ulen] & DIGIT_MASK));
+#endif
+
+  return (int) (u[ulen] - v[ulen]);
+
+}
+
+// Find the index of the first non-zero digit.
+// - ulen (before) = the number of digits in u.
+// - the returned value = the index of the first non-zero digit. 
+// A negative value of -1 indicates that every digit in u is zero.
+inline
+int
+vec_find_first_nonzero(int ulen, const sc_digit *u)
+{
+
+#ifdef DEBUG_SYSTEMC
+  // assert((ulen <= 0) || (u != NULL));
+  assert((ulen > 0) && (u != NULL));
+#endif
+
+  while ((--ulen >= 0) && (! u[ulen]))
+    ;
+
+  return ulen;
+  
+}
+
+// Skip all the leading zero digits.  
+// - ulen (before) = the number of digits in u.
+// - the returned value = the number of non-zero digits in u.
+// - the returned value is non-negative.
+inline 
+int
+vec_skip_leading_zeros(int ulen, const sc_digit *u)
+{
+
+#ifdef DEBUG_SYSTEMC
+  // assert((ulen <= 0) || (u != NULL));
+  assert((ulen > 0) && (u != NULL));
+#endif
+
+  return (1 + vec_find_first_nonzero(ulen, u));
+
+}
+
+// Compare u and v and return r
+//  r = 0 if u == v
+//  r < 0 if u < v
+//  r > 0 if u > v
+inline 
+int 
+vec_skip_and_cmp(int ulen, const sc_digit *u, 
+                 int vlen, const sc_digit *v)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert((ulen > 0) && (u != NULL));
+  assert((vlen > 0) && (v != NULL));
+#endif
+
+  ulen = vec_skip_leading_zeros(ulen, u);
+  vlen = vec_skip_leading_zeros(vlen, v);
+  // ulen and/or vlen can be equal to zero here.
+  return vec_cmp(ulen, u, vlen, v);
+
+}
+
+// Set u[i] = 0 where i = from ... (ulen - 1).
+inline
+void
+vec_zero(int from, int ulen, sc_digit *u)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert((ulen > 0) && (u != NULL));
+#endif
+
+  for(int i = from; i < ulen; i++)
+    u[i] = 0;
+
+}
+
+// Set u[i] = 0 where i = 0 .. (ulen - 1).
+inline
+void
+vec_zero(int ulen, sc_digit *u)
+{
+  vec_zero(0, ulen, u);
+}
+
+// Copy n digits from v to u.
+inline
+void
+vec_copy(int n, sc_digit *u, const sc_digit *v)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert((n > 0) && (u != NULL) && (v != NULL));
+#endif
+
+  for (int i = 0; i < n; ++i)
+    u[i] = v[i];
+}
+
+// Copy v to u, where ulen >= vlen, and zero the rest of the digits in u.
+inline
+void
+vec_copy_and_zero(int ulen, sc_digit *u, 
+                  int vlen, const sc_digit *v)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert((ulen > 0) && (u != NULL));
+  assert((vlen > 0) && (v != NULL));
+  assert(ulen >= vlen);
+#endif
+
+  vec_copy(vlen, u, v);
+  vec_zero(vlen, ulen, u);
+
+}
+
+// 2's-complement the digits in u.
+inline
+void
+vec_complement(int ulen, sc_digit *u)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert((ulen > 0) && (u != NULL));
+#endif
+
+  sc_digit carry = 1;
+
+  for (int i = 0; i < ulen; ++i) {
+    carry += (~u[i] & DIGIT_MASK);
+    u[i] = carry & DIGIT_MASK;
+    carry >>= BITS_PER_DIGIT;
+  }
+  
+}
+
+
+// ----------------------------------------------------------------------------
+//  Functions to handle built-in types or signs.
+// ----------------------------------------------------------------------------
+
+// u = v
+// - v is an unsigned long or uint64, and positive integer.
+template< class Type >
+inline
+void
+from_uint(int ulen, sc_digit *u, Type v)
+{
+
+#ifdef DEBUG_SYSTEMC
+  // assert((ulen <= 0) || (u != NULL));
+  assert((ulen > 0) && (u != NULL));
+  assert(v >= 0);
+#endif
+
+  int i = 0;
+
+  while (v && (i < ulen)) {
+#ifndef _WIN32
+    u[i++] = static_cast<sc_digit>( v & DIGIT_MASK );
+#else
+    u[i++] = ((sc_digit) v) & DIGIT_MASK;
+#endif
+    v >>= BITS_PER_DIGIT;
+  }
+
+  vec_zero(i, ulen, u);
+
+}
+
+
+// Get u's sign and return its absolute value.
+// u can be long, unsigned long, int64, or uint64.
+template< class Type >
+inline
+small_type
+get_sign(Type &u) 
+{
+  if (u > 0)
+    return SC_POS;
+
+  if (u == 0)
+    return SC_ZERO;
+
+  // no positive number representable for minimum value,
+  // leave as is to avoid Undefined Behaviour
+  if( SC_LIKELY_( u > (std::numeric_limits<Type>::min)() ) )
+    u = -u;
+
+  return SC_NEG;
+}
+
+
+// Return us * vs:
+// - Return SC_ZERO if either sign is SC_ZERO.
+// - Return SC_POS if us == vs
+// - Return SC_NEG if us != vs.
+inline
+small_type
+mul_signs(small_type us, small_type vs)
+{
+  if ((us == SC_ZERO) || (vs == SC_ZERO))
+    return SC_ZERO;
+
+  if (us == vs)
+    return SC_POS;
+
+  return SC_NEG;
+}
+
+
+// ----------------------------------------------------------------------------
+//  Functions to test for errors and print out error messages.
+// ----------------------------------------------------------------------------
+
+#ifdef SC_MAX_NBITS
+
+inline
+void
+test_bound(int nb)
+{
+  if (nb > SC_MAX_NBITS) {
+      char msg[BUFSIZ];
+      std::sprintf( msg, "test_bound( int nb ) : "
+	       "nb = %d > SC_MAX_NBITS = %d is not valid",
+	       nb, SC_MAX_NBITS );
+      SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
+  }
+}
+
+#endif
+
+template< class Type >
+inline
+void
+div_by_zero(Type s)
+{
+  if (s == 0) {
+      SC_REPORT_ERROR( sc_core::SC_ID_OPERATION_FAILED_,
+		       "div_by_zero<Type>( Type ) : division by zero" );
+  }
+}
+
+
+// ----------------------------------------------------------------------------
+//  Functions to check if a given vector is zero or make one.
+// ----------------------------------------------------------------------------
+
+// If u[i] is zero for every i = 0,..., ulen - 1, return SC_ZERO,
+// else return s.
+inline
+small_type 
+check_for_zero(small_type s, int ulen, const sc_digit *u)
+{
+
+#ifdef DEBUG_SYSTEMC
+  // assert(ulen >= 0);
+  assert((ulen > 0) && (u != NULL));
+#endif
+
+  if (vec_find_first_nonzero(ulen, u) < 0)
+    return SC_ZERO;  
+
+  return s;
+
+}
+
+// If u[i] is zero for every i = 0,..., ulen - 1, return true,
+// else return false.
+inline
+bool
+check_for_zero(int ulen, const sc_digit *u)
+{
+
+#ifdef DEBUG_SYSTEMC
+  // assert(ulen >= 0);
+  assert((ulen > 0) && (u != NULL));
+#endif
+
+  if (vec_find_first_nonzero(ulen, u) < 0)
+    return true;
+
+  return false;
+
+}
+
+inline
+small_type
+make_zero(int nd, sc_digit *d)
+{
+  vec_zero(nd, d);
+  return SC_ZERO;
+}
+
+
+// ----------------------------------------------------------------------------
+//  Functions for both signed and unsigned numbers to convert sign-magnitude
+//  (SM) and 2's complement (2C) representations.
+//  added = 1 => for signed.
+//  added = 0 => for unsigned.
+//  IF_SC_SIGNED can be used as 'added'.
+// ----------------------------------------------------------------------------
+
+// Trim the extra leading bits of a signed or unsigned number.
+inline
+void
+trim(small_type added, int nb, int nd, sc_digit *d)
+{
+#ifdef DEBUG_SYSTEMC
+  assert((nb > 0) && (nd > 0) && (d != NULL));
+#endif
+
+  d[nd - 1] &= one_and_ones(bit_ord(nb - 1) + added);    
+}
+
+// Convert an (un)signed number from sign-magnitude representation to
+// 2's complement representation and trim the extra bits.
+inline
+void
+convert_SM_to_2C_trimmed(small_type added, 
+                         small_type s, int nb, int nd, sc_digit *d)
+{
+  if (s == SC_NEG) {
+    vec_complement(nd, d);
+    trim(added, nb, nd, d);
+  }
+}
+
+// Convert an (un)signed number from sign-magnitude representation to
+// 2's complement representation but do not trim the extra bits.
+inline
+void
+convert_SM_to_2C(small_type s, int nd, sc_digit *d)
+{
+  if (s == SC_NEG)
+    vec_complement(nd, d);
+}
+
+
+// ----------------------------------------------------------------------------
+//  Functions to convert between sign-magnitude (SM) and 2's complement
+//  (2C) representations of signed numbers.
+// ----------------------------------------------------------------------------
+
+// Trim the extra leading bits off a signed number.
+inline
+void
+trim_signed(int nb, int nd, sc_digit *d)
+{
+#ifdef DEBUG_SYSTEMC
+  assert((nb > 0) && (nd > 0) && (d != NULL));
+#endif
+
+  d[nd - 1] &= one_and_ones(bit_ord(nb - 1) + 1);
+}
+
+// Convert a signed number from 2's complement representation to
+// sign-magnitude representation, and return its sign. nd is d's
+// actual size, without zeros eliminated.
+inline
+small_type
+convert_signed_2C_to_SM(int nb, int nd, sc_digit *d)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert((nb > 0) && (nd > 0) && (d != NULL));
+#endif
+
+  small_type s;
+
+  int xnb = bit_ord(nb - 1) + 1;
+
+  // Test the sign bit.  
+  if (d[nd - 1] & one_and_zeros(xnb - 1)) {
+    s = SC_NEG;
+    vec_complement(nd, d);
+  }
+  else
+    s = SC_POS;
+
+  // Trim the last digit.
+  d[nd - 1] &= one_and_ones(xnb);
+
+  // Check if the new number is zero.
+  if (s == SC_POS)
+    return check_for_zero(s, nd, d);
+
+  return s;
+
+}
+
+// Convert a signed number from sign-magnitude representation to 2's
+// complement representation, get its sign, convert back to
+// sign-magnitude representation, and return its sign. nd is d's
+// actual size, without zeros eliminated.
+inline
+small_type 
+convert_signed_SM_to_2C_to_SM(small_type s, int nb, int nd, sc_digit *d)
+{
+  convert_SM_to_2C(s, nd, d);
+  return convert_signed_2C_to_SM(nb, nd, d);
+}
+
+// Convert a signed number from sign-magnitude representation to 2's
+// complement representation and trim the extra bits.
+inline
+void
+convert_signed_SM_to_2C_trimmed(small_type s, int nb, int nd, sc_digit *d)
+{
+  convert_SM_to_2C_trimmed(1, s, nb, nd, d);
+}
+
+// Convert a signed number from sign-magnitude representation to 2's
+// complement representation but do not trim the extra bits.
+inline
+void
+convert_signed_SM_to_2C(small_type s, int nd, sc_digit *d)
+{
+  convert_SM_to_2C(s, nd, d);
+}
+
+
+// ----------------------------------------------------------------------------
+//  Functions to convert between sign-magnitude (SM) and 2's complement
+//  (2C) representations of unsigned numbers.
+// ----------------------------------------------------------------------------
+
+// Trim the extra leading bits off an unsigned number.
+inline
+void
+trim_unsigned(int nb, int nd, sc_digit *d)
+{
+#ifdef DEBUG_SYSTEMC
+  assert((nb > 0) && (nd > 0) && (d != NULL));
+#endif
+
+  d[nd - 1] &= one_and_ones(bit_ord(nb - 1));    
+}
+
+// Convert an unsigned number from 2's complement representation to
+// sign-magnitude representation, and return its sign. nd is d's
+// actual size, without zeros eliminated.
+inline
+small_type
+convert_unsigned_2C_to_SM(int nb, int nd, sc_digit *d)
+{
+  trim_unsigned(nb, nd, d);
+  return check_for_zero(SC_POS, nd, d);
+}
+
+// Convert an unsigned number from sign-magnitude representation to
+// 2's complement representation, get its sign, convert back to
+// sign-magnitude representation, and return its sign. nd is d's
+// actual size, without zeros eliminated.
+inline
+small_type
+convert_unsigned_SM_to_2C_to_SM(small_type s, int nb, int nd, sc_digit *d)
+{
+  convert_SM_to_2C(s, nd, d);
+  return convert_unsigned_2C_to_SM(nb, nd, d);
+}
+
+// Convert an unsigned number from sign-magnitude representation to
+// 2's complement representation and trim the extra bits.
+inline
+void
+convert_unsigned_SM_to_2C_trimmed(small_type s, int nb, int nd, sc_digit *d)
+{
+  convert_SM_to_2C_trimmed(0, s, nb, nd, d);
+}
+
+// Convert an unsigned number from sign-magnitude representation to
+// 2's complement representation but do not trim the extra bits.
+inline
+void
+convert_unsigned_SM_to_2C(small_type s, int nd, sc_digit *d)
+{
+  convert_SM_to_2C(s, nd, d);
+}
+
+
+// ----------------------------------------------------------------------------
+//  Functions to copy one (un)signed number to another.
+// ----------------------------------------------------------------------------
+
+// Copy v to u.
+inline
+void
+copy_digits_signed(small_type &us, 
+                   int unb, int und, sc_digit *ud,
+                   int vnb, int vnd, const sc_digit *vd)
+{
+
+  if (und <= vnd) {
+
+    vec_copy(und, ud, vd);
+
+    if (unb <= vnb)
+      us = convert_signed_SM_to_2C_to_SM(us, unb, und, ud);
+
+  }
+  else // und > vnd
+    vec_copy_and_zero(und, ud, vnd, vd);
+
+}
+
+// Copy v to u.
+inline
+void
+copy_digits_unsigned(small_type &us, 
+                     int unb, int und, sc_digit *ud,
+                     int /* vnb */, int vnd, const sc_digit *vd)
+{
+
+  if (und <= vnd)
+    vec_copy(und, ud, vd);
+
+  else // und > vnd
+    vec_copy_and_zero(und, ud, vnd, vd);
+
+  us = convert_unsigned_SM_to_2C_to_SM(us, unb, und, ud);
+
+}
+
+
+// ----------------------------------------------------------------------------
+//  Faster set(i, v), without bound checking.
+// ----------------------------------------------------------------------------
+
+// A version of set(i, v) without bound checking.
+inline
+void
+safe_set(int i, bool v, sc_digit *d)
+{
+
+#ifdef DEBUG_SYSTEMC
+  assert((i >= 0) && (d != NULL));
+#endif
+
+  int bit_num = bit_ord(i);
+  int digit_num = digit_ord(i);    
+  
+  if (v)
+    d[digit_num] |= one_and_zeros(bit_num);      
+  else
+    d[digit_num] &= ~(one_and_zeros(bit_num));
+  
+}
+
+
+// ----------------------------------------------------------------------------
+//  Function to check if a double number is bad (NaN or infinite).
+// ----------------------------------------------------------------------------
+
+inline
+bool
+is_nan( double v )
+{
+    return std::numeric_limits<double>::has_quiet_NaN && (v != v);
+}
+
+inline
+bool
+is_inf( double v )
+{
+    return v ==  std::numeric_limits<double>::infinity()
+        || v == -std::numeric_limits<double>::infinity();
+}
+
+inline
+void
+is_bad_double(double v)
+{
+// Windows throws exception.
+    if( is_nan(v) || is_inf(v) )
+        SC_REPORT_ERROR( sc_core::SC_ID_VALUE_NOT_VALID_,
+		         "is_bad_double( double v ) : "
+		         "v is not finite - NaN or Inf" );
+}
+
+} // namespace sc_dt
+
+
+#endif
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_signed.cpp b/ext/systemc/src/sysc/datatypes/int/sc_signed.cpp
new file mode 100644
index 000000000..7e5cfacff
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_signed.cpp
@@ -0,0 +1,4134 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_signed.cpp -- Arbitrary precision signed arithmetic.
+ 
+                   This file includes the definitions of sc_signed_bitref,
+                   sc_signed_subref, and sc_signed classes. The first two
+                   classes are proxy classes to reference one bit and a range
+                   of bits of a sc_signed number, respectively. This file also
+                   includes sc_nbcommon.cpp and sc_nbfriends.cpp, which
+                   contain the definitions shared by sc_unsigned.
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+  
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_signed.cpp,v $
+// Revision 1.6  2011/02/18 20:19:15  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.5  2008/12/10 20:38:45  acg
+//  Andy Goodrich: fixed conversion of double values to the digits vector.
+//  The bits above the radix were not being masked off.
+//
+// Revision 1.4  2008/06/19 17:47:56  acg
+//  Andy Goodrich: fixes for bugs. See 2.2.1 RELEASENOTES.
+//
+// Revision 1.3  2008/04/29 21:20:41  acg
+//  Andy Goodrich: added mask to first word transferred when processing
+//  a negative sc_signed value in sc_signed::concat_get_data().
+//
+// Revision 1.2  2007/11/04 21:27:00  acg
+//  Andy Goodrich: changes to make sure the proper value is returned from
+//  concat_get_data().
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.5  2006/10/23 19:32:47  acg
+//  Andy Goodrich: further fix for incorrect value being returned from
+//  concat_get_data. This one is in the non-aligned value code.
+//
+// Revision 1.3  2006/01/13 18:49:32  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#include <ctype.h>
+#include <math.h>
+
+#include "sysc/kernel/sc_cmnhdr.h"
+#include "sysc/kernel/sc_macros.h"
+#include "sysc/datatypes/int/sc_signed.h"
+#include "sysc/datatypes/int/sc_unsigned.h"
+#include "sysc/datatypes/int/sc_int_base.h"
+#include "sysc/datatypes/int/sc_uint_base.h"
+#include "sysc/datatypes/int/sc_int_ids.h"
+#include "sysc/datatypes/bit/sc_bv_base.h"
+#include "sysc/datatypes/bit/sc_lv_base.h"
+#include "sysc/datatypes/misc/sc_concatref.h"
+#include "sysc/datatypes/fx/sc_fix.h"
+#include "sysc/datatypes/fx/scfx_other_defs.h"
+
+
+namespace sc_dt
+{
+
+// Pool of temporary instances:
+
+sc_core::sc_vpool<sc_signed_bitref> sc_signed_bitref::m_pool(9);
+sc_core::sc_vpool<sc_signed_subref> sc_signed_subref::m_pool(9);
+
+// -----------------------------------------------------------------------------
+// SECTION: Public members - Invalid selections.
+// -----------------------------------------------------------------------------
+
+void
+sc_signed::invalid_index( int i ) const
+{
+    char msg[BUFSIZ];
+    std::sprintf( msg,
+         "sc_bigint bit selection: index = %d violates "
+         "0 <= index <= %d", i, nbits - 1 );
+    SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
+}
+
+void
+sc_signed::invalid_range( int l, int r ) const
+{
+    char msg[BUFSIZ];
+    std::sprintf( msg,
+         "sc_bigint part selection: left = %d, right = %d \n"
+	 "  violates either (%d >= left >= 0) or (%d >= right >= 0)",
+         l, r, nbits-1, nbits-1 );
+    SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
+}
+
+
+// ----------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
+//  SECTION: Public members.
+// ----------------------------------------------------------------------------
+
+// Most public members are included from sc_nbcommon.inc. However, some 
+// concatenation support appears here to optimize between the signed and
+// unsigned cases.
+
+// Insert this object's value at the specified place in a vector of biguint
+// style values.
+
+bool sc_signed::concat_get_ctrl( sc_digit* dst_p, int low_i ) const
+{
+    int      dst_i;        // Index to next word to set in dst_p.
+    int      end_i;        // Index of high order word to set.
+    int      left_shift;   // Amount to shift value left.
+    sc_digit mask;         // Mask for partial word sets.
+
+
+    // CALCULATE METRICS FOR DATA MOVEMENT:
+
+    dst_i = low_i / BITS_PER_DIGIT;
+    end_i = (low_i + nbits - 1) / BITS_PER_DIGIT;               
+    left_shift = low_i % BITS_PER_DIGIT;
+
+
+    // ALL DATA TO BE MOVED IS IN A SINGLE WORD:
+
+    mask = ~(-1 << left_shift);    
+    dst_p[dst_i] = ( dst_p[dst_i] & ~mask );         
+    dst_i++;
+
+    for ( ; dst_i <= end_i; dst_i++ ) dst_p[dst_i] = 0;    
+
+    return false; 
+}
+
+bool sc_signed::concat_get_data( sc_digit* dst_p, int low_i ) const
+{
+    sc_digit carry;        // Carry bit for complements.
+    int      dst_i;        // Index to next word to set in dst_p.
+    int      end_i;        // Index of high order word to set.
+    int      high_i;       // Index w/in word of high order bit.
+    int      left_shift;   // Amount to shift value left.
+    sc_digit left_word;    // High word component for set.
+    sc_digit mask;         // Mask for partial word sets.
+    bool     result;	 // True if inserted non-zero data.
+    int      right_shift;  // Amount to shift value right.
+    sc_digit right_word;   // Low word component for set.
+    int      src_i;        // Index to next word to get from digit.
+
+
+
+    // CALCULATE METRICS FOR DATA MOVEMENT:
+
+    dst_i = low_i / BITS_PER_DIGIT;
+    high_i = low_i + nbits - 1;
+    end_i = high_i / BITS_PER_DIGIT;
+    left_shift = low_i % BITS_PER_DIGIT;
+
+    switch ( sgn )
+    {
+      // POSITIVE SOURCE VALUE:
+
+      case SC_POS:
+
+	result = true;
+
+        // ALL DATA TO BE MOVED IS IN A SINGLE WORD:
+
+        if ( dst_i == end_i )
+        {
+            mask = ~(-1 << left_shift);
+            dst_p[dst_i] = ( ( dst_p[dst_i] & mask ) | 
+                (digit[0] << left_shift) ) & DIGIT_MASK;
+        }
+
+
+        // DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED:
+
+        else if ( left_shift == 0 )
+        {
+            for ( src_i = 0; dst_i < end_i; dst_i++, src_i++ )
+            {
+                dst_p[dst_i] = digit[src_i];
+            }
+            high_i = high_i % BITS_PER_DIGIT;
+            mask = ~(-2 << high_i) & DIGIT_MASK;
+            dst_p[dst_i] = digit[src_i] & mask;
+        }
+
+
+        // DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED:
+
+        else
+        {
+            high_i = high_i % BITS_PER_DIGIT;
+            right_shift = BITS_PER_DIGIT - left_shift;
+            mask = ~(-1 << left_shift);
+            right_word = digit[0];
+            dst_p[dst_i] = (dst_p[dst_i] & mask) | 
+                ((right_word << left_shift) & DIGIT_MASK);
+            for ( src_i = 1, dst_i++; dst_i < end_i; dst_i++, src_i++ )
+            {
+                left_word = digit[src_i];
+                dst_p[dst_i] = ((left_word << left_shift)&DIGIT_MASK) |
+                    (right_word >> right_shift);
+                right_word = left_word;
+            }
+            left_word = (src_i < ndigits) ? digit[src_i] : 0;
+            mask = ~(-2 << high_i) & DIGIT_MASK;
+            dst_p[dst_i] = ((left_word << left_shift) |
+                (right_word >> right_shift)) & mask;
+        }
+        break;
+
+
+      // SOURCE VALUE IS NEGATIVE:
+
+      case SC_NEG:
+
+        // ALL DATA TO BE MOVED IS IN A SINGLE WORD:
+
+	result = true;
+        if ( dst_i == end_i )
+        {
+            mask = ~(-1 << nbits);
+            right_word = ((digit[0] ^ DIGIT_MASK) + 1) & mask;
+            mask = ~(-1 << left_shift);
+            dst_p[dst_i] = ( ( dst_p[dst_i] & mask ) | 
+                (right_word << left_shift) ) & DIGIT_MASK;
+        }
+
+
+        // DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED:
+
+        else if ( left_shift == 0 )
+        {
+            carry = 1;
+            for ( src_i = 0; dst_i < end_i; dst_i++, src_i++ )
+            {
+                right_word = (digit[src_i] ^ DIGIT_MASK) + carry;
+                dst_p[dst_i] = right_word &  DIGIT_MASK;
+                carry = right_word >> BITS_PER_DIGIT;
+            }
+            high_i = high_i % BITS_PER_DIGIT;
+            mask = (~(-2 << high_i)) & DIGIT_MASK;
+            right_word = (src_i < ndigits) ? 
+	        (digit[src_i] ^ DIGIT_MASK) + carry : DIGIT_MASK + carry;
+            dst_p[dst_i] = right_word & mask;
+        }
+
+
+        // DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED:
+
+        else
+        {
+            high_i = high_i % BITS_PER_DIGIT;
+            right_shift = BITS_PER_DIGIT - left_shift;
+            mask = ~(-1 << left_shift);
+            carry = 1;
+            right_word = (digit[0] ^ DIGIT_MASK) + carry;
+            dst_p[dst_i] = (dst_p[dst_i] & mask) | 
+                ((right_word << left_shift) & DIGIT_MASK);
+	    carry = right_word >> BITS_PER_DIGIT;
+	    right_word &= DIGIT_MASK;
+            for ( src_i = 1, dst_i++; dst_i < end_i; dst_i++, src_i++ )
+            {
+                left_word = (digit[src_i] ^ DIGIT_MASK) + carry;
+                dst_p[dst_i] = ((left_word << left_shift)&DIGIT_MASK) |
+                    (right_word >> right_shift);
+                carry = left_word >> BITS_PER_DIGIT;
+                right_word = left_word & DIGIT_MASK;
+            }
+            left_word = (src_i < ndigits) ? 
+	        (digit[src_i] ^ DIGIT_MASK) + carry : carry;
+            mask = ~(-2 << high_i) & DIGIT_MASK;
+            dst_p[dst_i] = ((left_word << left_shift) |
+                (right_word >> right_shift)) & mask;
+        }
+	break;
+
+
+      // VALUE IS ZERO:
+
+      default:
+	result = false;
+
+
+        // ALL DATA TO BE MOVED IS IN A SINGLE WORD:
+
+        if ( dst_i == end_i )
+        {
+            mask = ~(-1 << nbits) << left_shift;
+            dst_p[dst_i] = dst_p[dst_i] & ~mask;
+        }
+
+
+        // DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED:
+
+        else if ( left_shift == 0 )
+        {
+            carry = 1;
+            for ( src_i = 0; dst_i < end_i; dst_i++, src_i++ )
+            {
+                dst_p[dst_i] = 0;
+            }
+            high_i = high_i % BITS_PER_DIGIT;
+            mask = ~(-2 << high_i) & DIGIT_MASK;
+            dst_p[dst_i] = 0; // #### digit[src_i] & mask;
+        }
+
+
+        // DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED:
+
+        else
+        {
+            high_i = high_i % BITS_PER_DIGIT;
+            right_shift = BITS_PER_DIGIT - left_shift;
+            mask = ~(-1 << left_shift);
+            dst_p[dst_i] = (dst_p[dst_i] & mask);
+            for ( dst_i++; dst_i <= end_i; dst_i++ )
+            {
+                dst_p[dst_i] = 0;
+            }
+        }
+	break;
+    }
+    return result;
+}
+
+// Return this object instance's bits as a uint64 without sign extension.
+
+uint64 sc_signed::concat_get_uint64() const
+{
+    uint64        result;
+
+    switch ( sgn )
+    {
+      case SC_POS:
+	result = 0;
+	if ( ndigits > 2 )
+	    result = digit[2];
+	if ( ndigits > 1 )
+	    result = (result << BITS_PER_DIGIT) | digit[1];
+	result = (result << BITS_PER_DIGIT) | digit[0];
+	break;
+      case SC_NEG:
+	result = 0;
+	if ( ndigits > 2 )
+	    result = digit[2];
+	if ( ndigits > 1 )
+	    result = (result << BITS_PER_DIGIT) | digit[1];
+	result = (result << BITS_PER_DIGIT) | digit[0];
+	result = -result;
+	if ( nbits < 64 ) 
+	{
+	    uint64 mask = ~0;
+	    result = result & ~(mask << nbits);
+	}
+	break;
+      default:
+	result = 0;
+	break;
+    }
+    return result;
+}
+
+// #### OPTIMIZE
+void sc_signed::concat_set(int64 src, int low_i)  
+{    
+    *this = (low_i < 64) ? src >> low_i : src >> 63;
+}
+
+void sc_signed::concat_set(const sc_signed& src, int low_i)
+{
+    if ( low_i < src.length() )
+        *this = src >> low_i;
+    else
+        *this = (src<0) ? (int_type)-1 : 0;
+}       
+
+void sc_signed::concat_set(const sc_unsigned& src, int low_i)
+{
+    if ( low_i < src.length() )
+        *this = src >> low_i;
+    else
+        *this = 0;
+}
+
+void sc_signed::concat_set(uint64 src, int low_i)
+{
+    *this = (low_i < 64) ? src >> low_i : 0;
+}
+
+// ----------------------------------------------------------------------------
+//  SECTION: Public members - Reduction methods.   
+// ----------------------------------------------------------------------------
+
+bool sc_signed::and_reduce() const 
+{
+    sc_digit current; // Current digit examining.
+    int      i;       // Index of digit examining.
+
+    if ( sgn == SC_NEG )
+    {
+	current = (1 << BITS_PER_DIGIT);
+	for ( i = 0; i < ndigits-1; i++ )  
+	{
+	    current = (current >> BITS_PER_DIGIT) + (digit[i]^DIGIT_MASK);
+	    if ( (current & DIGIT_MASK) != DIGIT_MASK ) return false;
+	}
+	current = (current >> BITS_PER_DIGIT) + (digit[i]^DIGIT_MASK);
+	if ( (current & ~(-1 << (nbits % BITS_PER_DIGIT))) == 
+	    (sc_digit) ~(-1 << (nbits % BITS_PER_DIGIT)) ) 
+		return true;
+    }
+    return false;
+}
+
+bool sc_signed::or_reduce() const 
+{
+    return sgn == SC_ZERO ? false : true;
+}
+
+bool sc_signed::xor_reduce() const 
+{
+    int i;   // Digit examining.
+    int odd; // Flag for odd number of digits.
+
+    odd = 0;
+    for ( i = 0; i < nbits; i++ )    
+        if ( test(i) ) odd = ~odd;
+    return odd ? true : false;
+}
+
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Public members - Assignment operators.
+// ----------------------------------------------------------------------------
+
+// assignment operators
+
+const sc_signed&
+sc_signed::operator = ( const char* a )
+{
+    if( a == 0 ) {
+        SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_,
+                         "character string is zero" );
+    } 
+    if( *a == 0 ) {
+        SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_,
+                         "character string is empty" );
+    }
+    try {
+        int len = length();
+        sc_fix aa( a, len, len, SC_TRN, SC_WRAP, 0, SC_ON );
+        return this->operator = ( aa );
+    } catch( sc_core::sc_report ) {
+        char msg[BUFSIZ];
+        std::sprintf( msg, "character string '%s' is not valid", a );
+        SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_, msg );
+        // never reached
+    }
+    return *this;
+}
+
+const sc_signed&
+sc_signed::operator=(int64 v)
+{
+  sgn = get_sign(v);
+  // v >= 0 now.
+  if (sgn == SC_ZERO)
+    vec_zero(ndigits, digit);
+  else {
+    from_uint(ndigits, digit, (uint64) v);
+    if (nbits <= (int)BITS_PER_INT64)
+      convert_SM_to_2C_to_SM();
+  }
+  return *this;
+}
+
+const sc_signed&
+sc_signed::operator=(uint64 v)
+{
+  sgn = get_sign(v);
+  if (sgn == SC_ZERO)
+    vec_zero(ndigits, digit);
+  else {
+    from_uint(ndigits, digit, v);
+    if (nbits <= (int)BITS_PER_INT64)
+      convert_SM_to_2C_to_SM();
+  }
+  return *this;
+}
+
+const sc_signed&
+sc_signed::operator=(long v)
+{
+  sgn = get_sign(v);
+  // v >= 0 now.
+  if (sgn == SC_ZERO)
+    vec_zero(ndigits, digit);
+  else {
+    from_uint(ndigits, digit, (unsigned long) v);
+    if (nbits <= (int)BITS_PER_LONG)
+      convert_SM_to_2C_to_SM();
+  }
+  return *this;
+}
+
+const sc_signed&
+sc_signed::operator=(unsigned long v)
+{
+  sgn = get_sign(v);
+  if (sgn == SC_ZERO)
+    vec_zero(ndigits, digit);
+  else {
+    from_uint(ndigits, digit, v);
+    if (nbits <= (int)BITS_PER_LONG)
+      convert_SM_to_2C_to_SM();
+  }
+  return *this;
+}
+
+const sc_signed&
+sc_signed::operator=(double v)
+{
+  is_bad_double(v);
+  if (v < 0) {
+    v = -v;
+    sgn = SC_NEG;
+  }
+  else
+    sgn = SC_POS;
+  int i = 0;
+  while (floor(v) && (i < ndigits)) {
+#ifndef _WIN32
+    digit[i++] = ((sc_digit)floor(remainder(v, DIGIT_RADIX))) & DIGIT_MASK;
+#else
+    digit[i++] = ((sc_digit)floor(fmod(v, DIGIT_RADIX))) & DIGIT_MASK;
+#endif
+    v /= DIGIT_RADIX;
+  }
+  vec_zero(i, ndigits, digit);
+  convert_SM_to_2C_to_SM();
+  return *this;  
+}
+
+
+// ----------------------------------------------------------------------------
+
+const sc_signed&
+sc_signed::operator = ( const sc_bv_base& v )
+{
+    int minlen = sc_min( nbits, v.length() );
+    int i = 0;
+    for( ; i < minlen; ++ i ) {
+	safe_set( i, v.get_bit( i ), digit );
+    }
+    for( ; i < nbits; ++ i ) {
+	safe_set( i, 0, digit );  // zero-extend
+    }
+    convert_2C_to_SM();
+    return *this;
+}
+
+const sc_signed&
+sc_signed::operator = ( const sc_lv_base& v )
+{
+    int minlen = sc_min( nbits, v.length() );
+    int i = 0;
+    for( ; i < minlen; ++ i ) {
+	safe_set( i, sc_logic( v.get_bit( i ) ).to_bool(), digit );
+    }
+    for( ; i < nbits; ++ i ) {
+	safe_set( i, 0, digit );  // zero-extend
+    }
+    convert_2C_to_SM();
+    return *this;
+}
+
+
+// explicit conversion to character string
+
+const std::string
+sc_signed::to_string( sc_numrep numrep ) const
+{
+    int len = length();
+    sc_fix aa( *this, len, len, SC_TRN, SC_WRAP, 0, SC_ON );
+    return aa.to_string( numrep );
+}
+
+const std::string
+sc_signed::to_string( sc_numrep numrep, bool w_prefix ) const
+{
+    int len = length();
+    sc_fix aa( *this, len, len, SC_TRN, SC_WRAP, 0, SC_ON );
+    return aa.to_string( numrep, w_prefix );
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Interfacing with sc_int_base
+// ----------------------------------------------------------------------------
+
+const sc_signed&
+sc_signed::operator = (const sc_int_base& v)
+{ return operator=((int64) v); }
+
+
+sc_signed
+operator + ( const sc_unsigned& u, const sc_int_base& v )
+{ return operator + ( u, SCAST<int64>( v ) ); }
+
+sc_signed
+operator + ( const sc_int_base& u, const sc_unsigned& v )
+{ return operator + ( SCAST<int64>( u ), v ); }
+
+sc_signed 
+operator + (const sc_signed& u, const sc_int_base& v) 
+{ return operator+(u, (int64) v); }
+
+sc_signed 
+operator + (const sc_int_base& u, const sc_signed& v) 
+{ return operator+((int64) u, v); }
+
+const sc_signed& 
+sc_signed::operator += (const sc_int_base& v)
+{ return operator+=((int64) v); }
+
+
+sc_signed 
+operator - (const sc_unsigned& u, const sc_int_base& v) 
+{ return operator-(u, (int64) v); }
+
+sc_signed 
+operator - (const sc_int_base& u, const sc_unsigned& v) 
+{ return operator-((int64) u, v); }
+
+sc_signed 
+operator-(const sc_signed& u, const sc_int_base& v) 
+{ return operator-(u, (int64) v); }
+
+sc_signed 
+operator - (const sc_int_base& u, const sc_signed& v) 
+{ return operator-((int64) u, v); }
+
+const sc_signed& 
+sc_signed::operator -= (const sc_int_base& v)
+{ return operator-=((int64) v); }
+
+
+sc_signed
+operator * ( const sc_unsigned& u, const sc_int_base& v )
+{ return operator * ( u, SCAST<int64>( v ) ); }
+
+sc_signed
+operator * ( const sc_int_base& u, const sc_unsigned& v )
+{ return operator * ( SCAST<int64>( u ), v ); }
+
+sc_signed 
+operator * (const sc_signed& u, const sc_int_base& v) 
+{ return operator*(u, (int64) v); }
+
+sc_signed 
+operator * (const sc_int_base& u, const sc_signed& v) 
+{ return operator*((int64) u, v); }
+
+const sc_signed& 
+sc_signed::operator *= (const sc_int_base& v)
+{ return operator*=((int64) v); }
+
+
+sc_signed
+operator / ( const sc_unsigned& u, const sc_int_base& v )
+{ return operator / ( u, SCAST<int64>( v ) ); }
+
+sc_signed
+operator / ( const sc_int_base& u, const sc_unsigned& v )
+{ return operator / ( SCAST<int64>( u ), v ); }
+
+sc_signed 
+operator / (const sc_signed& u, const sc_int_base& v) 
+{ return operator/(u, (int64) v); }
+
+sc_signed 
+operator / (const sc_int_base& u, const sc_signed& v) 
+{ return operator/((int64) u, v); }
+
+const sc_signed& 
+sc_signed::operator /= (const sc_int_base& v)
+{ return operator/=((int64) v); }
+
+
+sc_signed
+operator % ( const sc_unsigned& u, const sc_int_base& v )
+{ return operator % ( u, SCAST<int64>( v ) ); }
+
+sc_signed
+operator % ( const sc_int_base& u, const sc_unsigned& v )
+{ return operator % ( SCAST<int64>( u ), v ); }
+
+sc_signed 
+operator % (const sc_signed& u, const sc_int_base& v) 
+{ return operator%(u, (int64) v); }
+
+sc_signed 
+operator % (const sc_int_base& u, const sc_signed& v) 
+{ return operator%((int64) u, v); }
+
+const sc_signed& 
+sc_signed::operator %= (const sc_int_base& v)
+{ return operator%=((int64) v); }
+
+
+sc_signed
+operator & ( const sc_unsigned& u, const sc_int_base& v )
+{ return operator & ( u, SCAST<int64>( v ) ); }
+
+sc_signed
+operator & ( const sc_int_base& u, const sc_unsigned& v )
+{ return operator & ( SCAST<int64>( u ), v ); }
+
+sc_signed 
+operator & (const sc_signed& u, const sc_int_base& v) 
+{ return operator&(u, (int64) v); }
+
+sc_signed 
+operator & (const sc_int_base& u, const sc_signed& v) 
+{ return operator&((int64) u, v); }
+
+const sc_signed& 
+sc_signed::operator &= (const sc_int_base& v)
+{ return operator&=((int64) v); }
+
+
+sc_signed
+operator | ( const sc_unsigned& u, const sc_int_base& v )
+{ return operator | ( u, SCAST<int64>( v ) ); }
+
+sc_signed
+operator | ( const sc_int_base& u, const sc_unsigned& v )
+{ return operator | ( SCAST<int64>( u ), v ); }
+
+sc_signed 
+operator | (const sc_signed& u, const sc_int_base& v) 
+{ return operator|(u, (int64) v); }
+
+sc_signed 
+operator | (const sc_int_base& u, const sc_signed& v) 
+{ return operator|((int64) u, v); }
+
+const sc_signed& 
+sc_signed::operator |= (const sc_int_base& v)
+{ return operator|=((int64) v); }
+
+
+sc_signed
+operator ^ ( const sc_unsigned& u, const sc_int_base& v )
+{ return operator ^ ( u, SCAST<int64>( v ) ); }
+
+sc_signed
+operator ^ ( const sc_int_base& u, const sc_unsigned& v )
+{ return operator ^ ( SCAST<int64>( u ), v ); }
+
+sc_signed 
+operator ^ (const sc_signed& u, const sc_int_base& v) 
+{ return operator^(u, (int64) v); }
+
+sc_signed 
+operator ^ (const sc_int_base& u, const sc_signed& v) 
+{ return operator^((int64) u, v); }
+
+const sc_signed& 
+sc_signed::operator ^= (const sc_int_base& v)
+{ return operator^=((int64) v); }
+
+
+sc_signed 
+operator << (const sc_signed& u, const sc_int_base& v)
+{ return operator<<(u, (int64) v); }
+
+const sc_signed& 
+sc_signed::operator <<= (const sc_int_base& v)
+{ return operator<<=((int64) v); }
+
+
+sc_signed 
+operator >> (const sc_signed&    u, const sc_int_base&  v)
+{ return operator>>(u, (int64) v); }
+
+const sc_signed& 
+sc_signed::operator >>= (const sc_int_base&  v)
+{ return operator>>=((int64) v); }
+
+
+bool 
+operator == (const sc_signed& u, const sc_int_base& v)
+{ return operator==(u, (int64) v); }
+
+bool 
+operator == (const sc_int_base& u, const sc_signed& v) 
+{ return operator==((int64) u, v); }
+
+
+bool 
+operator != (const sc_signed& u, const sc_int_base& v)
+{ return operator!=(u, (int64) v); }
+
+bool 
+operator != (const sc_int_base& u, const sc_signed& v) 
+{ return operator!=((int64) u, v); }
+
+
+bool 
+operator < (const sc_signed& u, const sc_int_base& v)
+{ return operator<(u, (int64) v); }
+
+bool 
+operator < (const sc_int_base& u, const sc_signed& v) 
+{ return operator<((int64) u, v); }
+
+
+bool 
+operator <= (const sc_signed& u, const sc_int_base& v)
+{ return operator<=(u, (int64) v); }
+
+bool
+operator <= (const sc_int_base& u, const sc_signed& v) 
+{ return operator<=((int64) u, v); }
+
+
+bool 
+operator > (const sc_signed& u, const sc_int_base& v)
+{ return operator>(u, (int64) v); }
+
+bool 
+operator > (const sc_int_base& u, const sc_signed& v) 
+{ return operator>((int64) u, v); }
+
+
+bool 
+operator >= (const sc_signed& u, const sc_int_base& v)
+{ return operator>=(u, (int64) v); }
+
+bool 
+operator >= (const sc_int_base& u, const sc_signed& v) 
+{ return operator>=((int64) u, v); }
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Interfacing with sc_uint_base
+// ----------------------------------------------------------------------------
+
+const sc_signed&
+sc_signed::operator = (const sc_uint_base& v)
+{ return operator=((uint64) v); }
+
+
+sc_signed
+operator + (const sc_signed& u, const sc_uint_base& v) 
+{ return operator+(u, (uint64) v); }
+
+sc_signed
+operator + (const sc_uint_base& u, const sc_signed& v) 
+{ return operator+((uint64) u, v); }
+
+const sc_signed&
+sc_signed::operator += (const sc_uint_base& v)
+{ return operator+=((uint64) v); }
+
+
+sc_signed
+operator - (const sc_unsigned& u, const sc_uint_base& v) 
+{ return operator-(u, (uint64) v); }
+
+sc_signed
+operator - (const sc_uint_base& u, const sc_unsigned& v) 
+{ return operator-((uint64) u, v); }
+
+sc_signed
+operator - (const sc_signed& u, const sc_uint_base& v) 
+{ return operator-(u, (uint64) v); }
+
+sc_signed
+operator - (const sc_uint_base& u, const sc_signed& v) 
+{ return operator-((uint64) u, v); }
+
+const sc_signed&
+sc_signed::operator -= (const sc_uint_base& v)
+{ return operator-=((uint64) v); }
+
+
+sc_signed 
+operator * (const sc_signed& u, const sc_uint_base& v) 
+{ return operator*(u, (uint64) v); }
+
+sc_signed 
+operator * (const sc_uint_base& u, const sc_signed& v) 
+{ return operator*((uint64) u, v); }
+
+const sc_signed& 
+sc_signed::operator *= (const sc_uint_base& v)
+{ return operator*=((uint64) v); }
+
+
+sc_signed
+operator / (const sc_signed& u, const sc_uint_base& v) 
+{ return operator/(u, (uint64) v); }
+
+sc_signed
+operator / (const sc_uint_base& u, const sc_signed& v) 
+{ return operator/((uint64) u, v); }
+
+const sc_signed&
+sc_signed::operator /= (const sc_uint_base& v)
+{ return operator/=((uint64) v); }
+
+
+sc_signed 
+operator % (const sc_signed& u, const sc_uint_base& v) 
+{ return operator%(u, (uint64) v); }
+
+sc_signed 
+operator % (const sc_uint_base& u, const sc_signed& v) 
+{ return operator%((uint64) u, v); }
+
+const sc_signed& 
+sc_signed::operator %= (const sc_uint_base& v)
+{ return operator%=((uint64) v); }
+
+
+sc_signed 
+operator & (const sc_signed& u, const sc_uint_base& v) 
+{ return operator&(u, (uint64) v); }
+
+sc_signed 
+operator & (const sc_uint_base& u, const sc_signed& v) 
+{ return operator&((uint64) u, v); }
+
+const sc_signed& 
+sc_signed::operator &= (const sc_uint_base& v)
+{ return operator&=((uint64) v); }
+
+
+sc_signed 
+operator | (const sc_signed& u, const sc_uint_base& v) 
+{ return operator|(u, (uint64) v); }
+
+sc_signed 
+operator | (const sc_uint_base& u, const sc_signed& v) 
+{ return operator|((uint64) u, v); }
+
+const sc_signed& 
+sc_signed::operator |= (const sc_uint_base& v)
+{ return operator|=((uint64) v); }
+
+
+sc_signed 
+operator ^ (const sc_signed& u, const sc_uint_base& v) 
+{ return operator^(u, (uint64) v); }
+
+sc_signed 
+operator ^ (const sc_uint_base& u, const sc_signed& v) 
+{ return operator^((uint64) u, v); }
+
+const sc_signed& 
+sc_signed::operator ^= (const sc_uint_base& v)
+{ return operator^=((uint64) v); }
+
+
+sc_signed 
+operator << (const sc_signed& u, const sc_uint_base& v)
+{ return operator<<(u, (uint64) v); }
+
+const sc_signed& 
+sc_signed::operator <<= (const sc_uint_base& v)
+{ return operator<<=((uint64) v); }
+
+
+sc_signed
+operator >> (const sc_signed&    u, const sc_uint_base&  v)
+{ return operator>>(u, (uint64) v); }
+
+const sc_signed& 
+sc_signed::operator >>= (const sc_uint_base&  v)
+{ return operator>>=((uint64) v); }
+
+
+bool 
+operator == (const sc_signed& u, const sc_uint_base& v)
+{ return operator==(u, (uint64) v); }
+
+bool 
+operator == (const sc_uint_base& u, const sc_signed& v) 
+{ return operator==((uint64) u, v); }
+
+
+bool 
+operator != (const sc_signed& u, const sc_uint_base& v)
+{ return operator!=(u, (uint64) v); }
+
+bool 
+operator != (const sc_uint_base& u, const sc_signed& v) 
+{ return operator!=((uint64) u, v); }
+
+
+bool 
+operator < (const sc_signed& u, const sc_uint_base& v)
+{ return operator<(u, (uint64) v); }
+
+bool 
+operator < (const sc_uint_base& u, const sc_signed& v) 
+{ return operator<((uint64) u, v); }
+
+
+bool 
+operator <= (const sc_signed& u, const sc_uint_base& v)
+{ return operator<=(u, (uint64) v); }
+
+bool 
+operator <= (const sc_uint_base& u, const sc_signed& v) 
+{ return operator<=((uint64) u, v); }
+
+
+bool 
+operator > (const sc_signed& u, const sc_uint_base& v)
+{ return operator>(u, (uint64) v); }
+
+bool 
+operator > (const sc_uint_base& u, const sc_signed& v) 
+{ return operator>((uint64) u, v); }
+
+
+bool 
+operator >= (const sc_signed& u, const sc_uint_base& v)
+{ return operator>=(u, (uint64) v); }
+
+bool 
+operator >= (const sc_uint_base& u, const sc_signed& v) 
+{ return operator>=((uint64) u, v); }
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Input and output operators
+// ----------------------------------------------------------------------------
+
+// Operators in this section are included from sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Operator macros.
+// ----------------------------------------------------------------------------
+
+#define CONVERT_LONG(u) \
+small_type u ## s = get_sign(u);                        \
+sc_digit u ## d[DIGITS_PER_ULONG];                    \
+from_uint(DIGITS_PER_ULONG, u ## d, (unsigned long) u); 
+
+#define CONVERT_LONG_2(u) \
+sc_digit u ## d[DIGITS_PER_ULONG];                     \
+from_uint(DIGITS_PER_ULONG, u ## d, (unsigned long) u); 
+
+#define CONVERT_INT(u) \
+small_type u ## s = get_sign(u);                        \
+sc_digit u ## d[DIGITS_PER_UINT];                    \
+from_uint(DIGITS_PER_UINT, u ## d, (unsigned int) u); 
+
+#define CONVERT_INT_2(u) \
+sc_digit u ## d[DIGITS_PER_UINT];                     \
+from_uint(DIGITS_PER_UINT, u ## d, (unsigned int) u); 
+
+#define CONVERT_INT64(u) \
+small_type u ## s = get_sign(u);                   \
+sc_digit u ## d[DIGITS_PER_UINT64];              \
+from_uint(DIGITS_PER_UINT64, u ## d, (uint64) u); 
+
+#define CONVERT_INT64_2(u) \
+sc_digit u ## d[DIGITS_PER_UINT64];              \
+from_uint(DIGITS_PER_UINT64, u ## d, (uint64) u); 
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: PLUS operators: +, +=, ++
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u + v:
+// 1. 0 + v = v
+// 2. u + 0 = u
+// 3. if sgn(u) == sgn(v)
+//    3.1 u + v = +(u + v) = sgn(u) * (u + v) 
+//    3.2 (-u) + (-v) = -(u + v) = sgn(u) * (u + v)
+// 4. if sgn(u) != sgn(v)
+//    4.1 u + (-v) = u - v = sgn(u) * (u - v)
+//    4.2 (-u) + v = -(u - v) ==> sgn(u) * (u - v)
+//
+// Specialization of above cases for computing ++u or u++: 
+// 1. 0 + 1 = 1
+// 3. u + 1 = u + 1 = sgn(u) * (u + 1)
+// 4. (-u) + 1 = -(u - 1) = sgn(u) * (u - 1)
+
+sc_signed
+operator+(const sc_unsigned& u, const sc_signed& v)
+{
+
+  if (u.sgn == SC_ZERO) // case 1
+    return sc_signed(v);
+
+  if (v.sgn == SC_ZERO) // case 2
+    return sc_signed(u);
+
+  // cases 3 and 4
+  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator+(const sc_signed& u, const sc_unsigned& v)
+{
+
+  if (u.sgn == SC_ZERO) // case 1
+    return sc_signed(v);
+
+  if (v.sgn == SC_ZERO) // case 2
+    return sc_signed(u);
+
+  // cases 3 and 4
+  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator+(const sc_signed& u, const sc_signed& v)
+{
+
+  if (u.sgn == SC_ZERO) // case 1
+    return sc_signed(v);
+
+  if (v.sgn == SC_ZERO) // case 2
+    return sc_signed(u);
+
+  // cases 3 and 4
+  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           v.sgn, v.nbits, v.ndigits, v.digit);
+  
+}
+
+
+sc_signed
+operator+(const sc_signed &u, int64 v)
+{
+
+  if (v == 0)  // case 2
+    return sc_signed(u);
+
+  CONVERT_INT64(v);
+
+  if (u.sgn == SC_ZERO)  // case 1
+    return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+  // cases 3 and 4
+  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+}
+
+
+sc_signed
+operator+(int64 u, const sc_signed &v)
+{
+
+  if (u == 0) // case 1
+    return sc_signed(v);
+
+  CONVERT_INT64(u);
+
+  if (v.sgn == SC_ZERO)  // case 2
+    return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+  // cases 3 and 4
+
+  return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                           v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator+(const sc_unsigned &u, int64 v)
+{
+
+  if (v == 0)  // case 2
+    return sc_signed(u);
+
+  CONVERT_INT64(v);
+
+  if (u.sgn == SC_ZERO)  // case 1
+    return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+  // cases 3 and 4
+  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+}
+
+
+sc_signed
+operator+(int64 u, const sc_unsigned &v)
+{
+
+  if (u == 0) // case 1
+    return sc_signed(v);
+
+  CONVERT_INT64(u);
+
+  if (v.sgn == SC_ZERO)  // case 2
+    return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+  // cases 3 and 4
+
+  return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                           v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator+(const sc_signed &u, uint64 v)
+{
+
+  if (v == 0)  // case 2
+    return sc_signed(u);
+
+  CONVERT_INT64(v);
+
+  if (u.sgn == SC_ZERO)  // case 1
+    return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+  // cases 3 and 4
+  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+}
+
+
+sc_signed
+operator+(uint64 u, const sc_signed &v)
+{
+
+  if (u == 0) // case 1
+    return sc_signed(v);
+
+  CONVERT_INT64(u);
+
+  if (v.sgn == SC_ZERO)  // case 2
+    return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+  // cases 3 and 4
+
+  return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                           v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator+(const sc_signed &u, long v)
+{
+
+  if (v == 0)  // case 2
+    return sc_signed(u);
+
+  CONVERT_LONG(v);
+
+  if (u.sgn == SC_ZERO)  // case 1
+    return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+  // cases 3 and 4
+  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+}
+
+
+sc_signed
+operator+(long u, const sc_signed &v)
+{
+
+  if (u == 0) // case 1
+    return sc_signed(v);
+
+  CONVERT_LONG(u);
+
+  if (v.sgn == SC_ZERO)  // case 2
+    return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+  // cases 3 and 4
+  return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                           v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator+(const sc_unsigned &u, long v)
+{
+
+  if (v == 0)  // case 2
+    return sc_signed(u);
+
+  CONVERT_LONG(v);
+
+  if (u.sgn == SC_ZERO)  // case 1
+    return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+  // cases 3 and 4
+  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+}
+
+
+sc_signed
+operator+(long u, const sc_unsigned &v)
+{
+
+  if (u == 0) // case 1
+    return sc_signed(v);
+
+  CONVERT_LONG(u);
+
+  if (v.sgn == SC_ZERO)  // case 2
+    return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+  // cases 3 and 4
+  return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                           v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator+(const sc_signed &u, unsigned long v)
+{
+
+  if (v == 0) // case 2
+    return sc_signed(u);
+
+  CONVERT_LONG(v);
+
+  if (u.sgn == SC_ZERO)  // case 1
+    return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+  // cases 3 and 4
+  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+}
+
+
+sc_signed
+operator+(unsigned long u, const sc_signed &v)
+{
+
+  if (u == 0) // case 1
+    return sc_signed(v);
+
+  CONVERT_LONG(u);
+
+  if (v.sgn == SC_ZERO)  // case 2
+    return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+  // cases 3 and 4
+  return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                           v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+// ----------------------------------------------------------------------------
+//  SECTION: MINUS operators: -, -=, --
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u + v:
+// 1. u - 0 = u 
+// 2. 0 - v = -v
+// 3. if sgn(u) != sgn(v)
+//    3.1 u - (-v) = u + v = sgn(u) * (u + v)
+//    3.2 (-u) - v = -(u + v) ==> sgn(u) * (u + v)
+// 4. if sgn(u) == sgn(v)
+//    4.1 u - v = +(u - v) = sgn(u) * (u - v) 
+//    4.2 (-u) - (-v) = -(u - v) = sgn(u) * (u - v)
+//
+// Specialization of above cases for computing --u or u--: 
+// 1. 0 - 1 = -1
+// 3. (-u) - 1 = -(u + 1) = sgn(u) * (u + 1)
+// 4. u - 1 = u - 1 = sgn(u) * (u - 1)
+
+sc_signed
+operator-(const sc_unsigned& u, const sc_unsigned& v)
+{
+
+  if (v.sgn == SC_ZERO)  // case 1
+    return sc_signed(u);
+
+  if (u.sgn == SC_ZERO) // case 2
+    return sc_signed(v, -v.sgn);
+
+  // cases 3 and 4
+  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           -v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator-(const sc_unsigned& u, const sc_signed& v)
+{
+
+  if (v.sgn == SC_ZERO)  // case 1
+    return sc_signed(u);
+
+  if (u.sgn == SC_ZERO) // case 2
+    return sc_signed(v, -v.sgn);
+
+  // cases 3 and 4
+  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           -v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator-(const sc_signed& u, const sc_unsigned& v)
+{
+
+  if (v.sgn == SC_ZERO)  // case 1
+    return sc_signed(u);
+
+  if (u.sgn == SC_ZERO) // case 2
+    return sc_signed(v, -v.sgn);
+
+  // cases 3 and 4
+  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           -v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator-(const sc_signed& u, const sc_signed& v)
+{
+
+  if (v.sgn == SC_ZERO)  // case 1
+    return sc_signed(u);
+
+  if (u.sgn == SC_ZERO) // case 2
+    return sc_signed(v, -v.sgn);
+
+  // cases 3 and 4
+  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           -v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator-(const sc_signed &u, int64 v)
+{
+
+  if (v == 0) // case 1
+    return sc_signed(u);
+
+  CONVERT_INT64(v);
+
+  if (u.sgn == SC_ZERO) // case 2
+    return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+  // cases 3 and 4
+  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+}
+
+
+sc_signed
+operator-(int64 u, const sc_signed& v)
+{
+
+  if (u == 0) // case 1
+    return sc_signed(v, -v.sgn);
+
+  CONVERT_INT64(u);
+
+  if (v.sgn == SC_ZERO) // case 2
+    return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+  // cases 3 and 4
+
+  return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                           -v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator-(const sc_unsigned &u, int64 v)
+{
+
+  if (v == 0) // case 1
+    return sc_signed(u);
+
+  CONVERT_INT64(v);
+
+  if (u.sgn == SC_ZERO) // case 2
+    return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+  // cases 3 and 4
+  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+}
+
+
+sc_signed
+operator-(int64 u, const sc_unsigned& v)
+{
+
+  if (u == 0) // case 1
+    return sc_signed(v, -v.sgn);
+
+  CONVERT_INT64(u);
+
+  if (v.sgn == SC_ZERO) // case 2
+    return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+  // cases 3 and 4
+
+  return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                           -v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator-(const sc_signed &u, uint64 v)
+{
+
+  if (v == 0) // case 1
+    return sc_signed(u);
+
+  CONVERT_INT64(v);
+
+  if (u.sgn == SC_ZERO) // case 2
+    return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+  // cases 3 and 4
+
+  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+}
+
+
+sc_signed
+operator-(uint64 u, const sc_signed& v)
+{
+
+  if (u == 0) // case 1
+    return sc_signed(v, -v.sgn);
+
+  CONVERT_INT64(u);
+
+  if (v.sgn == SC_ZERO) // case 2
+    return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+  // cases 3 and 4
+  return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                           -v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator-(const sc_unsigned &u, uint64 v)
+{
+
+  if (v == 0) // case 1
+    return sc_signed(u);
+
+  CONVERT_INT64(v);
+
+  if (u.sgn == SC_ZERO) // case 2
+    return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+  // cases 3 and 4
+
+  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+}
+
+
+sc_signed
+operator-(uint64 u, const sc_unsigned& v)
+{
+
+  if (u == 0) // case 1
+    return sc_signed(v, -v.sgn);
+
+  CONVERT_INT64(u);
+
+  if (v.sgn == SC_ZERO) // case 2
+    return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+  // cases 3 and 4
+  return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                           -v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator-(const sc_signed &u, long v)
+{
+
+  if (v == 0) // case 1
+    return sc_signed(u);
+
+  CONVERT_LONG(v);
+
+  if (u.sgn == SC_ZERO) // case 2
+    return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+  // cases 3 and 4
+  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+}
+
+
+sc_signed
+operator-(long u, const sc_signed& v)
+{
+
+  if (u == 0) // case 1
+    return sc_signed(v, -v.sgn);
+
+  CONVERT_LONG(u);
+
+  if (v.sgn == SC_ZERO) // case 2
+    return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+  // cases 3 and 4
+  return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                           -v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator-(const sc_unsigned &u, long v)
+{
+
+  if (v == 0) // case 1
+    return sc_signed(u);
+
+  CONVERT_LONG(v);
+
+  if (u.sgn == SC_ZERO) // case 2
+    return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+  // cases 3 and 4
+  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+}
+
+
+sc_signed
+operator-(long u, const sc_unsigned& v)
+{
+
+  if (u == 0) // case 1
+    return sc_signed(v, -v.sgn);
+
+  CONVERT_LONG(u);
+
+  if (v.sgn == SC_ZERO) // case 2
+    return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+  // cases 3 and 4
+  return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                           -v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator-(const sc_signed &u, unsigned long v)
+{
+
+  if (v == 0) // case 1
+    return sc_signed(u);
+
+  CONVERT_LONG(v);
+
+  if (u.sgn == SC_ZERO) // case 2
+    return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+  // cases 3 and 4
+  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+}
+
+
+sc_signed
+operator-(unsigned long u, const sc_signed& v)
+{
+  if (u == 0) // case 1
+    return sc_signed(v, -v.sgn);
+
+  CONVERT_LONG(u);
+
+  if (v.sgn == SC_ZERO) // case 2
+    return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+  // cases 3 and 4
+  return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                           -v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator-(const sc_unsigned &u, unsigned long v)
+{
+
+  if (v == 0) // case 1
+    return sc_signed(u);
+
+  CONVERT_LONG(v);
+
+  if (u.sgn == SC_ZERO) // case 2
+    return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+  // cases 3 and 4
+  return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+}
+
+
+sc_signed
+operator-(unsigned long u, const sc_unsigned& v)
+{
+  if (u == 0) // case 1
+    return sc_signed(v, -v.sgn);
+
+  CONVERT_LONG(u);
+
+  if (v.sgn == SC_ZERO) // case 2
+    return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+  // cases 3 and 4
+  return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                           -v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: MULTIPLICATION operators: *, *=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u * v:
+// 1. u * 0 = 0 * v = 0
+// 2. 1 * v = v and -1 * v = -v
+// 3. u * 1 = u and u * -1 = -u
+// 4. u * v = u * v
+
+sc_signed
+operator*(const sc_unsigned& u, const sc_signed& v)
+{
+ 
+  small_type s = mul_signs(u.sgn, v.sgn);
+
+  if (s == SC_ZERO) // case 1
+    return sc_signed();
+
+  // cases 2-4
+  return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
+                           v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator*(const sc_signed& u, const sc_unsigned& v)
+{
+ 
+  small_type s = mul_signs(u.sgn, v.sgn);
+
+  if (s == SC_ZERO) // case 1
+    return sc_signed();
+
+  // cases 2-4
+  return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
+                           v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator*(const sc_signed& u, const sc_signed& v)
+{
+ 
+  small_type s = mul_signs(u.sgn, v.sgn);
+
+  if (s == SC_ZERO) // case 1
+    return sc_signed();
+
+  // cases 2-4
+  return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
+                           v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator*(const sc_signed& u, int64 v)
+{
+
+  small_type s = mul_signs(u.sgn, get_sign(v));
+
+  if (s == SC_ZERO) // case 1
+    return sc_signed();
+
+  CONVERT_INT64_2(v);
+
+  // cases 2-4
+  return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 
+                           BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+  
+}
+
+
+sc_signed
+operator*(int64 u, const sc_signed& v)
+{
+
+  small_type s = mul_signs(v.sgn, get_sign(u));
+
+  if (s == SC_ZERO) // case 1
+    return sc_signed();
+
+  CONVERT_INT64_2(u);
+
+  // cases 2-4
+  return mul_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 
+                           v.nbits, v.ndigits, v.digit);
+  
+}
+
+
+sc_signed
+operator*(const sc_unsigned& u, int64 v)
+{
+
+  small_type s = mul_signs(u.sgn, get_sign(v));
+
+  if (s == SC_ZERO) // case 1
+    return sc_signed();
+
+  CONVERT_INT64_2(v);
+
+  // cases 2-4
+  return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 
+                           BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+  
+}
+
+
+sc_signed
+operator*(int64 u, const sc_unsigned& v)
+{
+
+  small_type s = mul_signs(v.sgn, get_sign(u));
+
+  if (s == SC_ZERO) // case 1
+    return sc_signed();
+
+  CONVERT_INT64_2(u);
+
+  // cases 2-4
+  return mul_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 
+                           v.nbits, v.ndigits, v.digit);
+  
+}
+
+
+sc_signed
+operator*(const sc_signed& u, uint64 v)
+{
+
+  small_type s = mul_signs(u.sgn, get_sign(v));
+
+  if (s == SC_ZERO) // case 1
+    return sc_signed();
+
+  CONVERT_INT64_2(v);
+
+  // cases 2-4
+  return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 
+                           BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+  
+}
+
+
+sc_signed
+operator*(uint64 u, const sc_signed& v)
+{
+
+  small_type s = mul_signs(v.sgn, get_sign(u));
+
+  if (s == SC_ZERO) // case 1
+    return sc_signed();
+
+  CONVERT_INT64_2(u);
+
+  // cases 2-4
+  return mul_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 
+                           v.nbits, v.ndigits, v.digit);
+  
+}
+
+
+sc_signed
+operator*(const sc_signed& u, long v)
+{
+
+  small_type s = mul_signs(u.sgn, get_sign(v));
+
+  if (s == SC_ZERO) // case 1
+    return sc_signed();
+
+  CONVERT_LONG_2(v);
+
+  // cases 2-4
+  return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 
+                           BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+  
+}
+
+
+sc_signed
+operator*(long u, const sc_signed& v)
+{
+
+  small_type s = mul_signs(v.sgn, get_sign(u));
+
+  if (s == SC_ZERO) // case 1
+    return sc_signed();
+
+  CONVERT_LONG_2(u);
+
+  // cases 2-4
+  return mul_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 
+                           v.nbits, v.ndigits, v.digit);
+  
+}
+
+
+sc_signed
+operator*(const sc_unsigned& u, long v)
+{
+
+  small_type s = mul_signs(u.sgn, get_sign(v));
+
+  if (s == SC_ZERO) // case 1
+    return sc_signed();
+
+  CONVERT_LONG_2(v);
+
+  // cases 2-4
+  return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 
+                           BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+  
+}
+
+
+sc_signed
+operator*(long u, const sc_unsigned& v)
+{
+
+  small_type s = mul_signs(v.sgn, get_sign(u));
+
+  if (s == SC_ZERO) // case 1
+    return sc_signed();
+
+  CONVERT_LONG_2(u);
+
+  // cases 2-4
+  return mul_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 
+                           v.nbits, v.ndigits, v.digit);
+  
+}
+
+
+sc_signed
+operator*(const sc_signed& u, unsigned long v)
+{
+
+  small_type s = mul_signs(u.sgn, get_sign(v));
+
+  if (s == SC_ZERO) // case 1
+    return sc_signed();
+
+  CONVERT_LONG_2(v);
+
+  // else cases 2-4
+  return mul_signed_friend(s, u.nbits, u.ndigits, u.digit, 
+                           BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+  
+}
+
+sc_signed
+operator*(unsigned long u, const sc_signed& v)
+{
+
+  small_type s = mul_signs(v.sgn, get_sign(u));
+
+  if (s == SC_ZERO) // case 1
+    return sc_signed();
+
+  CONVERT_LONG_2(u);
+
+  // cases 2-4
+  return mul_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 
+                           v.nbits, v.ndigits, v.digit);
+  
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: DIVISION operators: /, /=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when finding the quotient q = floor(u/v):
+// Note that u = q * v + r for r < q.
+// 1. 0 / 0 or u / 0 => error
+// 2. 0 / v => 0 = 0 * v + 0
+// 3. u / v && u = v => u = 1 * u + 0  - u or v can be 1 or -1
+// 4. u / v && u < v => u = 0 * v + u  - u can be 1 or -1
+// 5. u / v && u > v => u = q * v + r  - v can be 1 or -1
+
+sc_signed
+operator/(const sc_unsigned& u, const sc_signed& v)
+{
+
+  small_type s = mul_signs(u.sgn, v.sgn);
+
+  if (s == SC_ZERO) {
+    div_by_zero(v.sgn); // case 1
+    return sc_signed();  // case 2
+  }
+
+  // other cases
+  return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
+                           v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator/(const sc_signed& u, const sc_unsigned& v)
+{
+
+  small_type s = mul_signs(u.sgn, v.sgn);
+
+  if (s == SC_ZERO) {
+    div_by_zero(v.sgn); // case 1
+    return sc_signed();  // case 2
+  }
+
+  // other cases
+  return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
+                           v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator/(const sc_signed& u, const sc_signed& v)
+{
+
+  small_type s = mul_signs(u.sgn, v.sgn);
+
+  if (s == SC_ZERO) {
+    div_by_zero(v.sgn); // case 1
+    return sc_signed();  // case 2
+  }
+
+  // other cases
+  return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
+                           v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator/(const sc_signed& u, int64 v)
+{
+
+  small_type s = mul_signs(u.sgn, get_sign(v));
+
+  if (s == SC_ZERO) {
+    div_by_zero(v);  // case 1
+    return sc_signed();  // case 2
+  }
+
+  CONVERT_INT64_2(v);
+
+  // other cases
+  return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 
+                           BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+  
+}
+
+
+sc_signed
+operator/(int64 u, const sc_signed& v)
+{
+
+  small_type s = mul_signs(v.sgn, get_sign(u));
+
+  if (s == SC_ZERO) {
+    div_by_zero(v.sgn);  // case 1
+    return sc_signed();  // case 2
+  }
+
+  CONVERT_INT64_2(u);
+
+  // other cases
+  return div_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 
+                           v.nbits, v.ndigits, v.digit);
+  
+}
+
+
+sc_signed
+operator/(const sc_unsigned& u, int64 v)
+{
+
+  small_type s = mul_signs(u.sgn, get_sign(v));
+
+  if (s == SC_ZERO) {
+    div_by_zero(v);  // case 1
+    return sc_signed();  // case 2
+  }
+
+  CONVERT_INT64_2(v);
+
+  // other cases
+  return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 
+                           BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+  
+}
+
+
+sc_signed
+operator/(int64 u, const sc_unsigned& v)
+{
+
+  small_type s = mul_signs(v.sgn, get_sign(u));
+
+  if (s == SC_ZERO) {
+    div_by_zero(v.sgn);  // case 1
+    return sc_signed();  // case 2
+  }
+
+  CONVERT_INT64_2(u);
+
+  // other cases
+  return div_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 
+                           v.nbits, v.ndigits, v.digit);
+  
+}
+
+
+sc_signed
+operator/(const sc_signed& u, uint64 v)
+{
+
+  small_type s = mul_signs(u.sgn, get_sign(v));
+
+  if (s == SC_ZERO) {
+    div_by_zero(v);  // case 1
+    return sc_signed();  // case 2
+  }
+
+  CONVERT_INT64_2(v);
+
+  // other cases
+  return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 
+                           BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+  
+}
+
+
+sc_signed
+operator/(uint64 u, const sc_signed& v)
+{
+
+  small_type s = mul_signs(v.sgn, get_sign(u));
+
+  if (s == SC_ZERO) {
+    div_by_zero(v.sgn);  // case 1
+    return sc_signed();  // case 2
+
+  }
+
+  CONVERT_INT64_2(u);
+
+  // other cases
+  return div_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 
+                           v.nbits, v.ndigits, v.digit);
+  
+}
+
+
+sc_signed
+operator/(const sc_signed& u, long v)
+{
+
+  small_type s = mul_signs(u.sgn, get_sign(v));
+
+  if (s == SC_ZERO) {
+    div_by_zero(v);  // case 1
+    return sc_signed();  // case 2
+  }
+
+  CONVERT_LONG_2(v);
+
+  // other cases
+  return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 
+                           BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+  
+}
+
+
+sc_signed
+operator/(long u, const sc_signed& v)
+{
+
+  small_type s = mul_signs(v.sgn, get_sign(u));
+
+  if (s == SC_ZERO) {
+    div_by_zero(v.sgn);  // case 1
+    return sc_signed();  // case 2
+  }
+
+  CONVERT_LONG_2(u);
+
+  // other cases
+  return div_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 
+                           v.nbits, v.ndigits, v.digit);
+  
+}
+
+
+sc_signed
+operator/(const sc_unsigned& u, long v)
+{
+
+  small_type s = mul_signs(u.sgn, get_sign(v));
+
+  if (s == SC_ZERO) {
+    div_by_zero(v);  // case 1
+    return sc_signed();  // case 2
+  }
+
+  CONVERT_LONG_2(v);
+
+  // other cases
+  return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 
+                           BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+  
+}
+
+
+sc_signed
+operator/(long u, const sc_unsigned& v)
+{
+
+  small_type s = mul_signs(v.sgn, get_sign(u));
+
+  if (s == SC_ZERO) {
+    div_by_zero(v.sgn);  // case 1
+    return sc_signed();  // case 2
+  }
+
+  CONVERT_LONG_2(u);
+
+  // other cases
+  return div_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 
+                           v.nbits, v.ndigits, v.digit);
+  
+}
+
+
+sc_signed
+operator/(const sc_signed& u, unsigned long v)
+{
+
+  small_type s = mul_signs(u.sgn, get_sign(v));
+
+  if (s == SC_ZERO) {
+    div_by_zero(v);  // case 1
+    return sc_signed();  // case 2
+  }
+
+  CONVERT_LONG_2(v);
+
+  // other cases
+  return div_signed_friend(s, u.nbits, u.ndigits, u.digit, 
+                           BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+  
+}
+
+
+sc_signed
+operator/(unsigned long u, const sc_signed& v)
+{
+
+  small_type s = mul_signs(v.sgn, get_sign(u));
+
+  if (s == SC_ZERO) {
+    div_by_zero(v.sgn);  // case 1
+    return sc_signed();  // case 2
+
+  }
+
+  CONVERT_LONG_2(u);
+
+  // other cases
+  return div_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 
+                           v.nbits, v.ndigits, v.digit);
+  
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: MOD operators: %, %=.
+// ----------------------------------------------------------------------------
+
+// Cases to consider when finding the remainder r = u % v:
+// Note that u = q * v + r for r < q.
+// 1. 0 % 0 or u % 0 => error
+// 2. 0 % v => 0 = 0 * v + 0
+// 3. u % v && u = v => u = 1 * u + 0  - u or v can be 1 or -1
+// 4. u % v && u < v => u = 0 * v + u  - u can be 1 or -1
+// 5. u % v && u > v => u = q * v + r  - v can be 1 or -1
+
+sc_signed
+operator%(const sc_unsigned& u, const sc_signed& v)
+{
+
+  if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
+    div_by_zero(v.sgn);  // case 1
+    return sc_signed();  // case 2
+  }
+
+  // other cases
+  return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator%(const sc_signed& u, const sc_unsigned& v)
+{
+
+  if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
+    div_by_zero(v.sgn);  // case 1
+    return sc_signed();  // case 2
+  }
+
+  // other cases
+  return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator%(const sc_signed& u, const sc_signed& v)
+{
+
+  if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
+    div_by_zero(v.sgn);  // case 1
+    return sc_signed();  // case 2
+  }
+
+  // other cases
+  return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator%(const sc_signed& u, int64 v)
+{
+
+  small_type vs = get_sign(v);
+
+  if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) {
+    div_by_zero(v);  // case 1
+    return sc_signed();  // case 2
+  }
+
+  CONVERT_INT64_2(v);
+
+  // other cases
+  return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+}
+
+
+sc_signed
+operator%(int64 u, const sc_signed& v)
+{
+
+  small_type us = get_sign(u);
+
+  if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) {
+    div_by_zero(v.sgn);  // case 1
+    return sc_signed();  // case 2
+  }
+
+  CONVERT_INT64_2(u);
+
+  // other cases
+  return mod_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                           v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator%(const sc_unsigned& u, int64 v)
+{
+
+  small_type vs = get_sign(v);
+
+  if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) {
+    div_by_zero(v);  // case 1
+    return sc_signed();  // case 2
+  }
+
+  CONVERT_INT64_2(v);
+
+  // other cases
+  return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+}
+
+
+sc_signed
+operator%(int64 u, const sc_unsigned& v)
+{
+
+  small_type us = get_sign(u);
+
+  if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) {
+    div_by_zero(v.sgn);  // case 1
+    return sc_signed();  // case 2
+  }
+
+  CONVERT_INT64_2(u);
+
+  // other cases
+  return mod_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                           v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator%(const sc_signed& u, uint64 v)
+{
+
+  if ((u.sgn == SC_ZERO) || (v == 0)) {
+    div_by_zero(v);  // case 1
+    return sc_signed();  // case 2
+  }
+
+  CONVERT_INT64_2(v);
+
+  // other cases
+  return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+}
+
+
+sc_signed
+operator%(uint64 u, const sc_signed& v)
+{
+
+  if ((u == 0) || (v.sgn == SC_ZERO)) {
+    div_by_zero(v.sgn);  // case 1
+    return sc_signed();  // case 2
+  }
+
+  CONVERT_INT64(u);
+
+  // other cases
+  return mod_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                           v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator%(const sc_signed& u, long v)
+{
+
+  small_type vs = get_sign(v);
+
+  if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) {
+    div_by_zero(v);  // case 1
+    return sc_signed();  // case 2
+  }
+
+  CONVERT_LONG_2(v);
+
+  // other cases
+  return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_signed
+operator%(long u, const sc_signed& v)
+{
+
+  small_type us = get_sign(u);
+
+  if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) {
+    div_by_zero(v.sgn);  // case 1
+    return sc_signed();  // case 2
+  }
+
+  CONVERT_LONG_2(u);
+
+  // other cases
+  return mod_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                           v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator%(const sc_unsigned& u, long v)
+{
+
+  small_type vs = get_sign(v);
+
+  if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) {
+    div_by_zero(v);  // case 1
+    return sc_signed();  // case 2
+  }
+
+  CONVERT_LONG_2(v);
+
+  // other cases
+  return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_signed
+operator%(long u, const sc_unsigned& v)
+{
+
+  small_type us = get_sign(u);
+
+  if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) {
+    div_by_zero(v.sgn);  // case 1
+    return sc_signed();  // case 2
+  }
+
+  CONVERT_LONG_2(u);
+
+  // other cases
+  return mod_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                           v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator%(const sc_signed& u, unsigned long v)
+{
+
+  if ((u.sgn == SC_ZERO) || (v == 0)) {
+    div_by_zero(v);  // case 1
+    return sc_signed();  // case 2
+  }
+
+  CONVERT_LONG_2(v);
+
+  // other cases
+  return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+}
+
+
+sc_signed
+operator%(unsigned long u, const sc_signed& v)
+{
+
+  if ((u == 0) || (v.sgn == SC_ZERO)) {
+    div_by_zero(v.sgn);  // case 1
+    return sc_signed();  // case 2
+  }
+
+  CONVERT_LONG(u);
+
+  // other cases
+  return mod_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                           v.nbits, v.ndigits, v.digit);
+
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Bitwise AND operators: &, &=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u & v:
+// 1. u & 0 = 0 & v = 0
+// 2. u & v => sgn = +
+// 3. (-u) & (-v) => sgn = -
+// 4. u & (-v) => sgn = +
+// 5. (-u) & v => sgn = +
+
+sc_signed
+operator&(const sc_unsigned& u, const sc_signed& v)
+{
+
+  if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1
+    return sc_signed();
+
+  // other cases
+  return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator&(const sc_signed& u, const sc_unsigned& v)
+{
+
+  if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1
+    return sc_signed();
+
+  // other cases
+  return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator&(const sc_signed& u, const sc_signed& v)
+{
+
+  if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1
+    return sc_signed();
+
+  // other cases
+  return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator&(const sc_signed& u, int64 v)
+{
+
+  if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
+    return sc_signed();
+
+  CONVERT_INT64(v);
+
+  // other cases
+  return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+}
+
+
+sc_signed
+operator&(int64 u, const sc_signed& v)
+{
+
+  if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
+    return sc_signed();
+
+  CONVERT_INT64(u);
+
+  // other cases
+  return and_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                           v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator&(const sc_unsigned& u, int64 v)
+{
+
+  if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
+    return sc_signed();
+
+  CONVERT_INT64(v);
+
+  // other cases
+  return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+}
+
+
+sc_signed
+operator&(int64 u, const sc_unsigned& v)
+{
+
+  if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
+    return sc_signed();
+
+  CONVERT_INT64(u);
+
+  // other cases
+  return and_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                           v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator&(const sc_signed& u, uint64 v)
+{
+
+  if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
+    return sc_signed();
+
+  CONVERT_INT64(v);
+
+  // other cases
+  return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+  
+}
+
+
+sc_signed
+operator&(uint64 u, const sc_signed& v)
+{
+
+  if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
+    return sc_signed();
+
+  CONVERT_INT64(u);
+
+  // other cases
+  return and_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                           v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator&(const sc_signed& u, long v)
+{
+
+  if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
+    return sc_signed();
+
+  CONVERT_LONG(v);
+
+  // other cases
+  return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+}
+
+
+sc_signed
+operator&(long u, const sc_signed& v)
+{
+
+  if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
+    return sc_signed();
+
+  CONVERT_LONG(u);
+
+  // other cases
+  return and_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                           v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator&(const sc_unsigned& u, long v)
+{
+
+  if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
+    return sc_signed();
+
+  CONVERT_LONG(v);
+
+  // other cases
+  return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+}
+
+
+sc_signed
+operator&(long u, const sc_unsigned& v)
+{
+
+  if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
+    return sc_signed();
+
+  CONVERT_LONG(u);
+
+  // other cases
+  return and_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                           v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator&(const sc_signed& u, unsigned long v)
+{
+
+  if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
+    return sc_signed();
+
+  CONVERT_LONG(v);
+
+  // other cases
+  return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+}
+
+
+sc_signed
+operator&(unsigned long u, const sc_signed& v)
+{
+
+  if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
+    return sc_signed();
+
+  CONVERT_LONG(u);
+
+  // other cases
+  return and_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                           v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Bitwise OR operators: |, |=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u | v:
+// 1. u | 0 = u
+// 2. 0 | v = v
+// 3. u | v => sgn = +
+// 4. (-u) | (-v) => sgn = -
+// 5. u | (-v) => sgn = -
+// 6. (-u) | v => sgn = -
+
+sc_signed
+operator|(const sc_unsigned& u, const sc_signed& v)
+{
+
+  if (v.sgn == SC_ZERO)  // case 1
+    return sc_signed(u);
+
+  if (u.sgn == SC_ZERO)  // case 2
+    return sc_signed(v);
+
+  // other cases
+  return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                          v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator|(const sc_signed& u, const sc_unsigned& v)
+{
+
+  if (v.sgn == SC_ZERO)  // case 1
+    return sc_signed(u);
+
+  if (u.sgn == SC_ZERO)  // case 2
+    return sc_signed(v);
+
+  // other cases
+  return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                          v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator|(const sc_signed& u, const sc_signed& v)
+{
+
+  if (v.sgn == SC_ZERO)  // case 1
+    return sc_signed(u);
+
+  if (u.sgn == SC_ZERO)  // case 2
+    return sc_signed(v);
+
+  // other cases
+  return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                          v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator|(const sc_signed& u, int64 v)
+{
+
+  if (v == 0)  // case 1
+    return sc_signed(u);
+
+  CONVERT_INT64(v);
+
+  if (u.sgn == SC_ZERO)  // case 2
+    return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+  // other cases
+  return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                          vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+}
+
+
+sc_signed
+operator|(int64 u, const sc_signed& v)
+{
+
+  if (u == 0)
+    return sc_signed(v);
+
+  CONVERT_INT64(u);
+
+  if (v.sgn == SC_ZERO)
+    return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+  // other cases
+  return or_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                          v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator|(const sc_unsigned& u, int64 v)
+{
+
+  if (v == 0)  // case 1
+    return sc_signed(u);
+
+  CONVERT_INT64(v);
+
+  if (u.sgn == SC_ZERO)  // case 2
+    return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+  // other cases
+  return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                          vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+}
+
+
+sc_signed
+operator|(int64 u, const sc_unsigned& v)
+{
+
+  if (u == 0)
+    return sc_signed(v);
+
+  CONVERT_INT64(u);
+
+  if (v.sgn == SC_ZERO)
+    return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+  // other cases
+  return or_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                          v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator|(const sc_signed& u, uint64 v)
+{
+
+  if (v == 0)  // case 1
+    return sc_signed(u);
+
+  CONVERT_INT64(v);
+
+  if (u.sgn == SC_ZERO)  // case 2
+    return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+  // other cases
+  return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                          vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+}
+
+
+sc_signed
+operator|(uint64 u, const sc_signed& v)
+{
+
+  if (u == 0)
+    return sc_signed(v);
+
+  CONVERT_INT64(u);
+
+  if (v.sgn == SC_ZERO)
+    return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+  // other cases
+  return or_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                          v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator|(const sc_signed& u, long v)
+{
+
+  if (v == 0)  // case 1
+    return sc_signed(u);
+
+  CONVERT_LONG(v);
+
+  if (u.sgn == SC_ZERO)  // case 2
+    return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+  // other cases
+  return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                          vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+}
+
+
+sc_signed
+operator|(long u, const sc_signed& v)
+{
+
+  if (u == 0)
+    return sc_signed(v);
+
+  CONVERT_LONG(u);
+
+  if (v.sgn == SC_ZERO)
+    return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+  // other cases
+  return or_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                          v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator|(const sc_unsigned& u, long v)
+{
+
+  if (v == 0)  // case 1
+    return sc_signed(u);
+
+  CONVERT_LONG(v);
+
+  if (u.sgn == SC_ZERO)  // case 2
+    return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+  // other cases
+  return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                          vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+}
+
+
+sc_signed
+operator|(long u, const sc_unsigned& v)
+{
+
+  if (u == 0)
+    return sc_signed(v);
+
+  CONVERT_LONG(u);
+
+  if (v.sgn == SC_ZERO)
+    return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+  // other cases
+  return or_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                          v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator|(const sc_signed& u, unsigned long v)
+{
+
+  if (v == 0)  // case 1
+    return sc_signed(u);
+
+  CONVERT_LONG(v);
+
+  if (u.sgn == SC_ZERO)  // case 2
+    return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+  // other cases
+  return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                          vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+}
+
+
+sc_signed
+operator|(unsigned long u, const sc_signed& v)
+{
+
+  if (u == 0)
+    return sc_signed(v);
+
+  CONVERT_LONG(u);
+
+  if (v.sgn == SC_ZERO)
+    return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+  // other cases
+  return or_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                          v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Bitwise XOR operators: ^, ^=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u ^ v:
+// Note that  u ^ v = (~u & v) | (u & ~v).
+// 1. u ^ 0 = u
+// 2. 0 ^ v = v
+// 3. u ^ v => sgn = +
+// 4. (-u) ^ (-v) => sgn = -
+// 5. u ^ (-v) => sgn = -
+// 6. (-u) ^ v => sgn = +
+
+sc_signed
+operator^(const sc_unsigned& u, const sc_signed& v)
+{
+
+  if (v.sgn == SC_ZERO)  // case 1
+    return sc_signed(u);
+
+  if (u.sgn == SC_ZERO)  // case 2
+    return sc_signed(v);
+
+  // other cases
+  return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator^(const sc_signed& u, const sc_unsigned& v)
+{
+
+  if (v.sgn == SC_ZERO)  // case 1
+    return sc_signed(u);
+
+  if (u.sgn == SC_ZERO)  // case 2
+    return sc_signed(v);
+
+  // other cases
+  return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator^(const sc_signed& u, const sc_signed& v)
+{
+
+  if (v.sgn == SC_ZERO)  // case 1
+    return sc_signed(u);
+
+  if (u.sgn == SC_ZERO)  // case 2
+    return sc_signed(v);
+
+  // other cases
+  return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator^(const sc_signed& u, int64 v)
+{
+
+  if (v == 0)  // case 1
+    return sc_signed(u);
+
+  CONVERT_INT64(v);
+
+  if (u.sgn == SC_ZERO)  // case 2
+    return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+  // other cases
+  return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+}
+
+
+sc_signed
+operator^(int64 u, const sc_signed& v)
+{
+
+  if (u == 0)
+    return sc_signed(v);
+
+  CONVERT_INT64(u);
+
+  if (v.sgn == SC_ZERO)
+    return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+  // other cases
+  return xor_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                           v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator^(const sc_unsigned& u, int64 v)
+{
+
+  if (v == 0)  // case 1
+    return sc_signed(u);
+
+  CONVERT_INT64(v);
+
+  if (u.sgn == SC_ZERO)  // case 2
+    return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+  // other cases
+  return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+}
+
+
+sc_signed
+operator^(int64 u, const sc_unsigned& v)
+{
+
+  if (u == 0)
+    return sc_signed(v);
+
+  CONVERT_INT64(u);
+
+  if (v.sgn == SC_ZERO)
+    return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+  // other cases
+  return xor_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                           v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator^(const sc_signed& u, uint64 v)
+{
+
+  if (v == 0)  // case 1
+    return sc_signed(u);
+
+  CONVERT_INT64(v);
+
+  if (u.sgn == SC_ZERO)  // case 2
+    return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+  // other cases
+  return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+}
+
+sc_signed
+operator^(uint64 u, const sc_signed& v)
+{
+  if (u == 0)
+    return sc_signed(v);
+
+  CONVERT_INT64(u);
+
+  if (v.sgn == SC_ZERO)
+    return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+  // other cases
+  return xor_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                           v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator^(const sc_signed& u, long v)
+{
+
+  if (v == 0)  // case 1
+    return sc_signed(u);
+
+  CONVERT_LONG(v);
+
+  if (u.sgn == SC_ZERO)  // case 2
+    return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+  // other cases
+  return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+}
+
+
+sc_signed
+operator^(long u, const sc_signed& v)
+{
+
+  if (u == 0)
+    return sc_signed(v);
+
+  CONVERT_LONG(u);
+
+  if (v.sgn == SC_ZERO)
+    return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+  // other cases
+  return xor_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                           v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator^(const sc_unsigned& u, long v)
+{
+
+  if (v == 0)  // case 1
+    return sc_signed(u);
+
+  CONVERT_LONG(v);
+
+  if (u.sgn == SC_ZERO)  // case 2
+    return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+  // other cases
+  return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+}
+
+
+sc_signed
+operator^(long u, const sc_unsigned& v)
+{
+
+  if (u == 0)
+    return sc_signed(v);
+
+  CONVERT_LONG(u);
+
+  if (v.sgn == SC_ZERO)
+    return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+  // other cases
+  return xor_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                           v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator^(const sc_signed& u, unsigned long v)
+{
+
+  if (v == 0)  // case 1
+    return sc_signed(u);
+
+  CONVERT_LONG(v);
+
+  if (u.sgn == SC_ZERO)  // case 2
+    return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+  // other cases
+  return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+}
+
+sc_signed
+operator^(unsigned long u, const sc_signed& v)
+{
+  if (u == 0)
+    return sc_signed(v);
+
+  CONVERT_LONG(u);
+
+  if (v.sgn == SC_ZERO)
+    return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+  // other cases
+  return xor_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                           v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Bitwise NOT operator: ~
+// ----------------------------------------------------------------------------
+
+// Operators in this section are included from sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: LEFT SHIFT operators: <<, <<=
+// ----------------------------------------------------------------------------
+
+sc_signed
+operator<<(const sc_signed& u, const sc_unsigned& v)
+{
+  if (v.sgn == SC_ZERO)
+    return sc_signed(u);
+
+  return operator<<(u, v.to_ulong());
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: RIGHT SHIFT operators: >>, >>=
+// ----------------------------------------------------------------------------
+
+sc_signed
+operator>>(const sc_signed& u, const sc_unsigned& v)
+{
+
+  if (v.sgn == SC_ZERO)
+    return sc_signed(u);
+
+  return operator>>(u, v.to_ulong());
+
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Unary arithmetic operators.
+// ----------------------------------------------------------------------------
+
+sc_signed
+operator+(const sc_signed& u)
+{
+  return sc_signed(u);
+}
+
+sc_signed
+operator-(const sc_signed& u)
+{
+  return sc_signed(u, -u.sgn);
+}
+
+sc_signed
+operator-(const sc_unsigned& u)
+{
+  return sc_signed(u, -u.sgn);
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: EQUAL operator: ==
+// ----------------------------------------------------------------------------
+
+bool
+operator==(const sc_signed& u, const sc_signed& v)
+{
+ 
+  if (u.sgn != v.sgn)
+    return false;
+
+  if (&u == &v)
+    return true;
+  
+  if (vec_skip_and_cmp(u.ndigits, u.digit, v.ndigits, v.digit) != 0)
+    return false;
+
+  return true;
+
+}
+
+
+bool
+operator==(const sc_signed& u, int64 v)
+{
+
+  CONVERT_INT64(v);
+
+  if (u.sgn != vs)
+    return false;
+
+  if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) != 0)
+    return false;
+
+  return true;
+  
+}
+
+
+bool
+operator==(int64 u, const sc_signed& v)
+{
+
+  CONVERT_INT64(u);
+
+  if (us != v.sgn)
+    return false;
+
+  if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) != 0)
+    return false;
+
+  return true;
+  
+}
+
+
+bool
+operator==(const sc_signed& u, uint64 v)
+{
+
+  CONVERT_INT64(v);
+
+  if (u.sgn != vs)
+    return false;
+
+  if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) != 0)
+    return false;
+
+  return true;
+  
+}
+
+
+bool
+operator==(uint64 u, const sc_signed& v)
+{
+
+  CONVERT_INT64(u);
+
+  if (us != v.sgn)
+    return false;
+
+  if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) != 0)
+    return false;
+
+  return true;
+  
+}
+
+
+bool
+operator==(const sc_signed& u, long v)
+{
+
+  CONVERT_LONG(v);
+
+  if (u.sgn != vs)
+    return false;
+
+  if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) != 0)
+    return false;
+
+  return true;
+  
+}
+
+
+bool
+operator==(long u, const sc_signed& v)
+{
+
+  CONVERT_LONG(u);
+
+  if (us != v.sgn)
+    return false;
+
+  if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) != 0)
+    return false;
+
+  return true;
+  
+}
+
+
+bool
+operator==(const sc_signed& u, unsigned long v)
+{
+
+  CONVERT_LONG(v);
+
+  if (u.sgn != vs)
+    return false;
+
+  if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) != 0)
+    return false;
+
+  return true;
+  
+}
+
+
+bool
+operator==(unsigned long u, const sc_signed& v)
+{
+
+  CONVERT_LONG(u);
+
+  if (us != v.sgn)
+    return false;
+
+  if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) != 0)
+    return false;
+
+  return true;
+  
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: NOT_EQUAL operator: !=
+// ----------------------------------------------------------------------------
+
+// Operators in this section are included from sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: LESS THAN operator: <
+// ----------------------------------------------------------------------------
+
+bool
+operator<(const sc_signed& u, const sc_signed& v)
+{
+
+  if (u.sgn < v.sgn)
+    return true;
+
+  if (u.sgn > v.sgn)
+    return false;
+
+  // u.sgn == v.sgn
+
+  if (&u == &v)
+    return false;
+
+  if (u.sgn == SC_POS) {
+
+    if (vec_skip_and_cmp(u.ndigits, u.digit, v.ndigits, v.digit) < 0)
+      return true;
+
+  }
+  else if (u.sgn == SC_NEG) {
+
+    if (vec_skip_and_cmp(u.ndigits, u.digit, v.ndigits, v.digit) > 0)
+      return true;
+
+  }
+
+  return false;
+
+}
+
+
+bool
+operator<(const sc_signed& u, int64 v)
+{
+
+  CONVERT_INT64(v);
+
+  if (u.sgn < vs)
+    return true;
+
+  if (u.sgn > vs)
+    return false;
+
+  // u.sgn == vs
+
+  if (vs == SC_POS) {
+
+    if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) < 0)
+      return true;
+
+  }
+  else if (vs == SC_NEG) {
+
+    if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) > 0)
+      return true;
+
+  }
+
+  return false;
+
+}
+
+
+bool
+operator<(int64 u, const sc_signed& v)
+{
+
+  CONVERT_INT64(u);
+
+  if (us < v.sgn)
+    return true;
+
+  if (us > v.sgn)
+    return false;
+
+  // us == v.sgn
+
+  if (us == SC_POS) {
+
+    if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) < 0)
+      return true;
+
+  }
+  else if (us == SC_NEG) {
+
+    if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) > 0)
+      return true;
+
+  }
+
+  return false;
+
+}
+
+
+bool
+operator<(const sc_signed& u, uint64 v)
+{
+
+  CONVERT_INT64(v);
+
+  if (u.sgn < vs)
+    return true;
+
+  if (u.sgn > vs)
+    return false;
+
+  // u.sgn == vs
+
+  if (vs == SC_POS) {
+
+    if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) < 0)
+      return true;
+    
+  }
+
+  return false;
+
+}
+
+
+bool
+operator<(uint64 u, const sc_signed& v)
+{
+
+  CONVERT_INT64(u);
+
+  if (us < v.sgn)
+    return true;
+
+  if (us > v.sgn)
+    return false;
+
+  // us == v.sgn
+
+  if (us == SC_POS) {
+
+    if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) < 0)
+      return true;
+
+  }
+
+  return false;    
+
+}
+
+
+bool
+operator<(const sc_signed& u, long v)
+{
+
+  CONVERT_LONG(v);
+
+  if (u.sgn < vs)
+    return true;
+
+  if (u.sgn > vs)
+    return false;
+
+  // u.sgn == vs
+
+  if (vs == SC_POS) {
+
+    if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) < 0)
+      return true;
+
+  }
+  else if (vs == SC_NEG) {
+
+    if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) > 0)
+      return true;
+
+  }
+
+  return false;
+
+}
+
+
+bool
+operator<(long u, const sc_signed& v)
+{
+  CONVERT_LONG(u);
+
+  if (us < v.sgn)
+    return true;
+
+  if (us > v.sgn)
+    return false;
+
+  // us == v.sgn
+
+  if (us == SC_POS) {
+
+    if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) < 0)
+      return true;
+
+  }
+  else if (us == SC_NEG) {
+
+    if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) > 0)
+      return true;
+
+  }
+
+  return false;
+}
+
+
+bool
+operator<(const sc_signed& u, unsigned long v)
+{
+  CONVERT_LONG(v);
+
+  if (u.sgn < vs)
+    return true;
+
+  if (u.sgn > vs)
+    return false;
+
+  // u.sgn == vs
+
+  if (vs == SC_POS) {
+
+    if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) < 0)
+      return true;
+    
+  }
+
+  return false;
+}
+
+
+bool
+operator<(unsigned long u, const sc_signed& v)
+{
+  CONVERT_LONG(u);
+
+  if (us < v.sgn)
+    return true;
+
+  if (us > v.sgn)
+    return false;
+
+  // us == v.sgn
+
+  if (us == SC_POS) {
+
+    if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) < 0)
+      return true;
+
+  }
+
+  return false;    
+}
+
+
+// ---------------------------------------------------------------------------
+//  SECTION: LESS THAN or EQUAL operator: <=
+// ---------------------------------------------------------------------------
+
+// Operators in this section are included from sc_nbcommon.cpp.
+
+
+// ---------------------------------------------------------------------------
+//  SECTION: GREATER THAN operator: >
+// ---------------------------------------------------------------------------
+
+// Operators in this section are included from sc_nbcommon.cpp.
+
+
+// ---------------------------------------------------------------------------
+//  SECTION: GREATER THAN or EQUAL operator: >=
+// ---------------------------------------------------------------------------
+
+// Operators in this section are included from sc_nbcommon.cpp.
+
+
+// ---------------------------------------------------------------------------
+//  SECTION: Public members - Other utils.
+// ---------------------------------------------------------------------------
+
+bool 
+sc_signed::iszero() const
+{
+  if (sgn == SC_ZERO)
+    return true;
+  else if (sgn != SC_NOSIGN) 
+    return false;
+  else 
+    return check_for_zero(ndigits, digit);
+}
+
+
+bool
+sc_signed::sign() const
+{
+  if (sgn == SC_NEG)
+    return 1;
+  else if (sgn != SC_NOSIGN)
+    return 0;
+  else
+    return ((digit[ndigits - 1] & one_and_zeros(bit_ord(nbits - 1))) != 0);
+}
+
+// The rest of the utils in this section are included from sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Private members.
+// ----------------------------------------------------------------------------
+
+// The private members in this section are included from sc_nbcommon.cpp.
+
+#define CLASS_TYPE sc_signed
+#define CLASS_TYPE_STR "sc_signed"
+
+#define ADD_HELPER add_signed_friend
+#define SUB_HELPER sub_signed_friend
+#define MUL_HELPER mul_signed_friend
+#define DIV_HELPER div_signed_friend
+#define MOD_HELPER mod_signed_friend
+#define AND_HELPER and_signed_friend
+#define  OR_HELPER  or_signed_friend
+#define XOR_HELPER xor_signed_friend 
+
+#include "sc_nbfriends.inc"
+
+#undef  SC_UNSIGNED
+#define SC_SIGNED
+#define IF_SC_SIGNED              1  // 1 = sc_signed
+#define CLASS_TYPE_SUBREF         sc_signed_subref_r
+#define OTHER_CLASS_TYPE          sc_unsigned
+#define OTHER_CLASS_TYPE_SUBREF   sc_unsigned_subref_r
+
+#define MUL_ON_HELPER mul_on_help_signed
+#define DIV_ON_HELPER div_on_help_signed
+#define MOD_ON_HELPER mod_on_help_signed
+
+#include "sc_nbcommon.inc"
+
+#undef MOD_ON_HELPER
+#undef DIV_ON_HELPER
+#undef MUL_ON_HELPER
+
+#undef OTHER_CLASS_TYPE_SUBREF
+#undef OTHER_CLASS_TYPE
+#undef CLASS_TYPE_SUBREF
+#undef IF_SC_SIGNED
+#undef SC_SIGNED
+
+#undef XOR_HELPER
+#undef  OR_HELPER
+#undef AND_HELPER
+#undef MOD_HELPER
+#undef DIV_HELPER
+#undef MUL_HELPER
+#undef SUB_HELPER
+#undef ADD_HELPER
+
+#undef CLASS_TYPE
+#undef CLASS_TYPE_STR
+
+#include "sc_signed_bitref.inc"
+#include "sc_signed_subref.inc"
+
+#undef CONVERT_LONG
+#undef CONVERT_LONG_2
+#undef CONVERT_INT64
+#undef CONVERT_INT64_2
+
+} // namespace sc_dt
+
+
+// End of file.
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_signed.h b/ext/systemc/src/sysc/datatypes/int/sc_signed.h
new file mode 100644
index 000000000..8e2d4f541
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_signed.h
@@ -0,0 +1,2382 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_signed.h -- Arbitrary precision signed arithmetic.
+
+    This file includes the definitions of sc_signed_bitref,
+    sc_signed_subref, and sc_signed classes. The first two classes are
+    proxy classes to reference one bit and a range of bits of a
+    sc_signed number, respectively.
+
+    An sc_signed number has the sign-magnitude representation
+    internally. However, its interface guarantees a 2's-complement
+    representation. The sign-magnitude representation is chosen
+    because of its efficiency: The sc_signed and sc_unsigned types are
+    optimized for arithmetic rather than bitwise operations. For
+    arithmetic operations, the sign-magnitude representation performs
+    better.
+
+    The implementations of sc_signed and sc_unsigned classes are
+    almost identical: Most of the member and friend functions are
+    defined in sc_nbcommon.cpp and sc_nbfriends.cpp so that they can
+    be shared by both of these classes. These functions are chosed by
+    defining a few macros before including them such as IF_SC_SIGNED
+    and CLASS_TYPE. Our implementation choices are mostly dictated by
+    performance considerations in that we tried to provide the most
+    efficient sc_signed and sc_unsigned types without compromising
+    their interface.
+
+    For the behavior of operators, we have two semantics: the old and
+    new. The most important difference between these two semantics is
+    that the old semantics is closer to C/C++ semantics in that the
+    result type of a binary operator on unsigned and signed arguments
+    is unsigned; the new semantics, on the other hand, requires the
+    result type be signed. The new semantics is required by the VSIA
+    C/C++ data types standard. We have implemented the new semantics.
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_signed.h,v $
+// Revision 1.3  2011/08/24 22:05:46  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.2  2011/02/18 20:19:15  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.5  2006/05/08 17:50:01  acg
+//   Andy Goodrich: Added David Long's declarations for friend operators,
+//   functions, and methods, to keep the Microsoft compiler happy.
+//
+// Revision 1.4  2006/03/13 20:25:27  acg
+//  Andy Goodrich: Addition of function declarations, e.g., xor_signed_friend()
+//  to keep gcc 4.x happy.
+//
+// Revision 1.3  2006/01/13 18:49:32  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#ifndef SC_SIGNED_H
+#define SC_SIGNED_H
+
+
+#include "sysc/kernel/sc_object.h"
+#include "sysc/datatypes/misc/sc_value_base.h"
+#include "sysc/utils/sc_iostream.h"
+#include "sysc/utils/sc_temporary.h"
+#include "sysc/datatypes/int/sc_length_param.h"
+#include "sysc/datatypes/int/sc_nbdefs.h"
+#include "sysc/datatypes/int/sc_nbutils.h"
+#include "sysc/datatypes/int/sc_nbexterns.h"
+#include "sysc/datatypes/int/sc_unsigned.h"
+
+
+namespace sc_dt
+{
+
+// classes defined in this module
+class sc_signed_bitref_r;
+class sc_signed_bitref;
+class sc_signed_subref_r;
+class sc_signed_subref;
+class sc_concatref;
+class sc_signed;
+
+// forward class declarations
+class sc_bv_base;
+class sc_lv_base;
+class sc_int_base;
+class sc_uint_base;
+class sc_int_subref_r;
+class sc_uint_subref_r;
+class sc_signed;
+class sc_unsigned;
+class sc_unsigned_subref_r;
+class sc_fxval;
+class sc_fxval_fast;
+class sc_fxnum;
+class sc_fxnum_fast;
+
+
+// Helper function declarations
+sc_signed add_signed_friend(small_type us,
+                                     int unb,
+                                     int und,
+                                     const sc_digit *ud,
+                                     small_type vs,
+                                     int vnb,
+                                     int vnd,
+                                     const sc_digit *vd);
+
+sc_signed sub_signed_friend(small_type us,
+                                     int unb,
+                                     int und,
+                                     const sc_digit *ud,
+                                     small_type vs,
+                                     int vnb,
+                                     int vnd,
+                                     const sc_digit *vd);
+
+sc_signed mul_signed_friend(small_type s,
+                                     int unb,
+                                     int und,
+                                     const sc_digit *ud,
+                                     int vnb,
+                                     int vnd,
+                                     const sc_digit *vd);
+
+sc_signed div_signed_friend(small_type s,
+                                     int unb,
+                                     int und,
+                                     const sc_digit *ud,
+                                     int vnb,
+                                     int vnd,
+                                     const sc_digit *vd);
+
+sc_signed mod_signed_friend(small_type us,
+                                     int unb,
+                                     int und,
+                                     const sc_digit *ud,
+                                     int vnb,
+                                     int vnd,
+                                     const sc_digit *vd);
+
+sc_signed and_signed_friend(small_type us,
+                                     int unb,
+                                     int und,
+                                     const sc_digit *ud,
+                                     small_type vs,
+                                     int vnb,
+                                     int vnd,
+                                     const sc_digit *vd);
+
+sc_signed or_signed_friend(small_type us,
+                                    int unb,
+                                    int und,
+                                    const sc_digit *ud,
+                                    small_type vs,
+                                    int vnb,
+                                    int vnd,
+                                    const sc_digit *vd);
+
+sc_signed xor_signed_friend(small_type us,
+                                     int unb,
+                                     int und,
+                                     const sc_digit *ud,
+                                     small_type vs,
+                                     int vnb,
+                                     int vnd,
+                                     const sc_digit *vd);
+
+
+// friend operator declarations
+  // ARITHMETIC OPERATORS:
+
+  // ADDition operators:
+
+  sc_signed operator + (const sc_unsigned&  u, const sc_signed&    v);
+  sc_signed operator + (const sc_signed&    u, const sc_unsigned&  v);
+
+  sc_signed operator + (const sc_unsigned&  u, int64               v);
+  sc_signed operator + (const sc_unsigned&  u, long                v);
+  inline sc_signed operator + (const sc_unsigned&  u, int                 v);
+
+  sc_signed operator + (int64               u, const sc_unsigned&  v);
+  sc_signed operator + (long                u, const sc_unsigned&  v);
+  inline sc_signed operator + (int                 u, const sc_unsigned&  v);
+
+  sc_signed operator + (const sc_signed&    u, const sc_signed&    v);
+  sc_signed operator + (const sc_signed&    u, int64               v);
+  sc_signed operator + (const sc_signed&    u, uint64              v);
+  sc_signed operator + (const sc_signed&    u, long                v);
+  sc_signed operator + (const sc_signed&    u, unsigned long       v);
+  inline sc_signed operator + (const sc_signed&    u, int                 v);
+  inline sc_signed operator + (const sc_signed&    u, unsigned int        v);
+
+  sc_signed operator + (int64               u, const sc_signed&    v);
+  sc_signed operator + (uint64              u, const sc_signed&    v);
+  sc_signed operator + (long                u, const sc_signed&    v);
+  sc_signed operator + (unsigned long       u, const sc_signed&    v);
+  inline sc_signed operator + (int                 u, const sc_signed&    v);
+  inline sc_signed operator + (unsigned int        u, const sc_signed&    v);
+
+  sc_signed operator + (const sc_unsigned&  u, const sc_int_base&  v);
+  sc_signed operator + (const sc_int_base&  u, const sc_unsigned&  v);
+  sc_signed operator + (const sc_signed&    u, const sc_int_base&  v);
+  sc_signed operator + (const sc_signed&    u, const sc_uint_base& v);
+  sc_signed operator + (const sc_int_base&  u, const sc_signed&    v);
+  sc_signed operator + (const sc_uint_base& u, const sc_signed&    v);
+
+
+
+  // SUBtraction operators:
+
+  sc_signed operator - (const sc_unsigned&  u, const sc_signed&    v);
+  sc_signed operator - (const sc_signed&    u, const sc_unsigned&  v);
+
+  sc_signed operator - (const sc_unsigned&  u, const sc_unsigned&  v);
+  sc_signed operator - (const sc_unsigned&  u, int64               v);
+  sc_signed operator - (const sc_unsigned&  u, uint64              v);
+  sc_signed operator - (const sc_unsigned&  u, long                v);
+  sc_signed operator - (const sc_unsigned&  u, unsigned long       v);
+  inline sc_signed operator - (const sc_unsigned&  u, int                v);
+  inline sc_signed operator - (const sc_unsigned&  u, unsigned int       v);
+
+  sc_signed operator - (int64               u, const sc_unsigned&  v);
+  sc_signed operator - (uint64              u, const sc_unsigned&  v);
+  sc_signed operator - (long                u, const sc_unsigned&  v);
+  sc_signed operator - (unsigned long       u, const sc_unsigned&  v);
+  inline sc_signed operator - (int                 u, const sc_unsigned&  v);
+  inline sc_signed operator - (unsigned int        u, const sc_unsigned& v);
+
+  sc_signed operator - (const sc_signed&    u, const sc_signed&    v);
+  sc_signed operator - (const sc_signed&    u, int64               v);
+  sc_signed operator - (const sc_signed&    u, uint64              v);
+  sc_signed operator - (const sc_signed&    u, long                v);
+  sc_signed operator - (const sc_signed&    u, unsigned long       v);
+  inline sc_signed operator - (const sc_signed&    u, int                 v);
+  inline sc_signed operator - (const sc_signed&    u, unsigned int        v);
+
+  sc_signed operator - (int64               u, const sc_signed&    v);
+  sc_signed operator - (uint64              u, const sc_signed&    v);
+  sc_signed operator - (long                u, const sc_signed&    v);
+  sc_signed operator - (unsigned long       u, const sc_signed&    v);
+  inline sc_signed operator - (int                 u, const sc_signed&    v);
+  inline sc_signed operator - (unsigned int        u, const sc_signed&    v);
+
+
+  sc_signed operator - (const sc_unsigned&  u, const sc_int_base&  v);
+  sc_signed operator - (const sc_unsigned&  u, const sc_uint_base& v);
+  sc_signed operator - (const sc_int_base&  u, const sc_unsigned&  v);
+  sc_signed operator - (const sc_uint_base& u, const sc_unsigned&  v);
+  sc_signed operator - (const sc_signed&    u, const sc_int_base&  v);
+  sc_signed operator - (const sc_signed&    u, const sc_uint_base& v);
+  sc_signed operator - (const sc_int_base&  u, const sc_signed&    v);
+  sc_signed operator - (const sc_uint_base& u, const sc_signed&    v);
+
+
+
+  // MULtiplication operators:
+
+  sc_signed operator * (const sc_unsigned&  u, const sc_signed&    v);
+  sc_signed operator * (const sc_signed&    u, const sc_unsigned&  v);
+
+  sc_signed operator * (const sc_unsigned&  u, int64               v);
+  sc_signed operator * (const sc_unsigned&  u, long                v);
+  inline sc_signed operator * (const sc_unsigned&  u, int                 v);
+
+  sc_signed operator * (int64               u, const sc_unsigned&  v);
+  sc_signed operator * (long                u, const sc_unsigned&  v);
+  inline sc_signed operator * (int                 u, const sc_unsigned&  v);
+
+  sc_signed operator * (const sc_signed&  u, const sc_signed&  v);
+  sc_signed operator * (const sc_signed&  u, int64             v);
+  sc_signed operator * (const sc_signed&  u, uint64            v);
+  sc_signed operator * (const sc_signed&  u, long              v);
+  sc_signed operator * (const sc_signed&  u, unsigned long     v);
+  inline sc_signed operator * (const sc_signed&  u, int               v);
+  inline sc_signed operator * (const sc_signed&  u, unsigned int      v);
+
+  sc_signed operator * (int64             u, const sc_signed&  v);
+  sc_signed operator * (uint64            u, const sc_signed&  v);
+  sc_signed operator * (long              u, const sc_signed&  v);
+  sc_signed operator * (unsigned long     u, const sc_signed&  v);
+  inline sc_signed operator * (int               u, const sc_signed&  v);
+  inline sc_signed operator * (unsigned int      u, const sc_signed&  v);
+
+  sc_signed operator * (const sc_unsigned&  u, const sc_int_base&  v);
+  sc_signed operator * (const sc_int_base&  u, const sc_unsigned&  v);
+  sc_signed operator * (const sc_signed&    u, const sc_int_base&  v);
+  sc_signed operator * (const sc_signed&    u, const sc_uint_base& v);
+  sc_signed operator * (const sc_int_base&  u, const sc_signed&    v);
+  sc_signed operator * (const sc_uint_base& u, const sc_signed&    v);
+
+
+
+  // DIVision operators:
+
+  sc_signed operator / (const sc_unsigned&  u, const sc_signed&    v);
+  sc_signed operator / (const sc_signed&    u, const sc_unsigned&  v);
+
+  sc_signed operator / (const sc_unsigned&  u, int64               v);
+  sc_signed operator / (const sc_unsigned&  u, long                v);
+  inline sc_signed operator / (const sc_unsigned&  u, int                 v);
+
+  sc_signed operator / (int64               u, const sc_unsigned&  v);
+  sc_signed operator / (long                u, const sc_unsigned&  v);
+  inline sc_signed operator / (int                 u, const sc_unsigned&  v);
+
+  sc_signed operator / (const sc_signed&    u, const sc_signed&    v);
+  sc_signed operator / (const sc_signed&    u, int64               v);
+  sc_signed operator / (const sc_signed&    u, uint64              v);
+  sc_signed operator / (const sc_signed&    u, long                v);
+  sc_signed operator / (const sc_signed&    u, unsigned long       v);
+  inline sc_signed operator / (const sc_signed&    u, int                 v);
+  inline sc_signed operator / (const sc_signed&    u, unsigned int        v);
+
+  sc_signed operator / (int64               u, const sc_signed&    v);
+  sc_signed operator / (uint64              u, const sc_signed&    v);
+  sc_signed operator / (long                u, const sc_signed&    v);
+  sc_signed operator / (unsigned long       u, const sc_signed&    v);
+  inline sc_signed operator / (int                 u, const sc_signed&    v);
+  inline sc_signed operator / (unsigned int        u, const sc_signed&    v);
+
+  sc_signed operator / (const sc_unsigned&  u, const sc_int_base&  v);
+  sc_signed operator / (const sc_int_base&  u, const sc_unsigned&  v);
+  sc_signed operator / (const sc_signed&    u, const sc_int_base&  v);
+  sc_signed operator / (const sc_signed&    u, const sc_uint_base& v);
+  sc_signed operator / (const sc_int_base&  u, const sc_signed&    v);
+  sc_signed operator / (const sc_uint_base& u, const sc_signed&    v);
+
+
+
+  // MODulo operators:
+
+  sc_signed operator % (const sc_unsigned&  u, const sc_signed&    v);
+  sc_signed operator % (const sc_signed&    u, const sc_unsigned&  v);
+
+  sc_signed operator % (const sc_unsigned&  u, int64               v);
+  sc_signed operator % (const sc_unsigned&  u, long                v);
+  inline sc_signed operator % (const sc_unsigned&  u, int                 v);
+
+  sc_signed operator % (int64               u, const sc_unsigned&  v);
+  sc_signed operator % (long                u, const sc_unsigned&  v);
+  inline sc_signed operator % (int                 u, const sc_unsigned&  v);
+
+  sc_signed operator % (const sc_signed&    u, const sc_signed&    v);
+  sc_signed operator % (const sc_signed&    u, int64               v);
+  sc_signed operator % (const sc_signed&    u, uint64              v);
+  sc_signed operator % (const sc_signed&    u, long                v);
+  sc_signed operator % (const sc_signed&    u, unsigned long       v);
+  inline sc_signed operator % (const sc_signed&    u, int                 v);
+  inline sc_signed operator % (const sc_signed&    u, unsigned int        v);
+
+  sc_signed operator % (int64               u, const sc_signed&    v);
+  sc_signed operator % (uint64              u, const sc_signed&    v);
+  sc_signed operator % (long                u, const sc_signed&    v);
+  sc_signed operator % (unsigned long       u, const sc_signed&    v);
+  inline sc_signed operator % (int                 u, const sc_signed&    v);
+  inline sc_signed operator % (unsigned int        u, const sc_signed&    v);
+
+  sc_signed operator % (const sc_unsigned&  u, const sc_int_base&  v);
+  sc_signed operator % (const sc_int_base&  u, const sc_unsigned&  v);
+  sc_signed operator % (const sc_signed&    u, const sc_int_base&  v);
+  sc_signed operator % (const sc_signed&    u, const sc_uint_base& v);
+  sc_signed operator % (const sc_int_base&  u, const sc_signed&    v);
+  sc_signed operator % (const sc_uint_base& u, const sc_signed&    v);
+
+
+
+  // BITWISE OPERATORS:
+
+  // Bitwise AND operators:
+
+  sc_signed operator & (const sc_unsigned&  u, const sc_signed&    v);
+  sc_signed operator & (const sc_signed&    u, const sc_unsigned&  v);
+
+  sc_signed operator & (const sc_unsigned&  u, int64               v);
+  sc_signed operator & (const sc_unsigned&  u, long                v);
+  inline sc_signed operator & (const sc_unsigned&  u, int                 v);
+
+  sc_signed operator & (int64               u, const sc_unsigned&  v);
+  sc_signed operator & (long                u, const sc_unsigned&  v);
+  inline sc_signed operator & (int                 u, const sc_unsigned&  v);
+
+  sc_signed operator & (const sc_signed&    u, const sc_signed&    v);
+  sc_signed operator & (const sc_signed&    u, int64               v);
+  sc_signed operator & (const sc_signed&    u, uint64              v);
+  sc_signed operator & (const sc_signed&    u, long                v);
+  sc_signed operator & (const sc_signed&    u, unsigned long       v);
+  inline sc_signed operator & (const sc_signed&    u, int                 v);
+  inline sc_signed operator & (const sc_signed&    u, unsigned int        v);
+
+  sc_signed operator & (int64             u, const sc_signed&  v);
+  sc_signed operator & (uint64            u, const sc_signed&  v);
+  sc_signed operator & (long              u, const sc_signed&  v);
+  sc_signed operator & (unsigned long     u, const sc_signed&  v);
+  inline sc_signed operator & (int               u, const sc_signed&  v);
+  inline sc_signed operator & (unsigned int      u, const sc_signed&  v);
+
+  sc_signed operator & (const sc_unsigned&  u, const sc_int_base&  v);
+  sc_signed operator & (const sc_int_base&  u, const sc_unsigned&  v);
+  sc_signed operator & (const sc_signed&    u, const sc_int_base&  v);
+  sc_signed operator & (const sc_signed&    u, const sc_uint_base& v);
+  sc_signed operator & (const sc_int_base&  u, const sc_signed&    v);
+  sc_signed operator & (const sc_uint_base& u, const sc_signed&    v);
+
+
+
+  // Bitwise OR operators:
+
+  sc_signed operator | (const sc_unsigned&  u, const sc_signed&    v);
+  sc_signed operator | (const sc_signed&    u, const sc_unsigned&  v);
+
+  sc_signed operator | (const sc_unsigned&  u, int64               v);
+  sc_signed operator | (const sc_unsigned&  u, long                v);
+  inline sc_signed operator | (const sc_unsigned&  u, int                 v);
+
+  sc_signed operator | (int64               u, const sc_unsigned&  v);
+  sc_signed operator | (long                u, const sc_unsigned&  v);
+  inline sc_signed operator | (int                 u, const sc_unsigned&  v);
+
+  sc_signed operator | (const sc_signed&    u, const sc_signed&    v);
+  sc_signed operator | (const sc_signed&    u, int64               v);
+  sc_signed operator | (const sc_signed&    u, uint64              v);
+  sc_signed operator | (const sc_signed&    u, long                v);
+  sc_signed operator | (const sc_signed&    u, unsigned long       v);
+  inline sc_signed operator | (const sc_signed&    u, int                 v);
+  inline sc_signed operator | (const sc_signed&    u, unsigned int        v);
+
+  sc_signed operator | (int64             u, const sc_signed&  v);
+  sc_signed operator | (uint64            u, const sc_signed&  v);
+  sc_signed operator | (long              u, const sc_signed&  v);
+  sc_signed operator | (unsigned long     u, const sc_signed&  v);
+  inline sc_signed operator | (int               u, const sc_signed&  v);
+  inline sc_signed operator | (unsigned int      u, const sc_signed&  v);
+
+  sc_signed operator | (const sc_unsigned&  u, const sc_int_base&  v);
+  sc_signed operator | (const sc_int_base&  u, const sc_unsigned&  v);
+  sc_signed operator | (const sc_signed&    u, const sc_int_base&  v);
+  sc_signed operator | (const sc_signed&    u, const sc_uint_base& v);
+  sc_signed operator | (const sc_int_base&  u, const sc_signed&    v);
+  sc_signed operator | (const sc_uint_base& u, const sc_signed&    v);
+
+
+
+  // Bitwise XOR operators:
+
+  sc_signed operator ^ (const sc_unsigned&  u, const sc_signed&    v);
+  sc_signed operator ^ (const sc_signed&    u, const sc_unsigned&  v);
+
+  sc_signed operator ^ (const sc_unsigned&  u, int64               v);
+  sc_signed operator ^ (const sc_unsigned&  u, long                v);
+  inline sc_signed operator ^ (const sc_unsigned&  u, int                 v);
+
+  sc_signed operator ^ (int64               u, const sc_unsigned&  v);
+  sc_signed operator ^ (long                u, const sc_unsigned&  v);
+  inline sc_signed operator ^ (int                 u, const sc_unsigned&  v);
+
+  sc_signed operator ^ (const sc_signed&    u, const sc_signed&    v);
+  sc_signed operator ^ (const sc_signed&    u, int64               v);
+  sc_signed operator ^ (const sc_signed&    u, uint64              v);
+  sc_signed operator ^ (const sc_signed&    u, long                v);
+  sc_signed operator ^ (const sc_signed&    u, unsigned long       v);
+  inline sc_signed operator ^ (const sc_signed&    u, int                 v);
+  inline sc_signed operator ^ (const sc_signed&    u, unsigned int        v);
+
+  sc_signed operator ^ (int64             u, const sc_signed&  v);
+  sc_signed operator ^ (uint64            u, const sc_signed&  v);
+  sc_signed operator ^ (long              u, const sc_signed&  v);
+  sc_signed operator ^ (unsigned long     u, const sc_signed&  v);
+  inline sc_signed operator ^ (int               u, const sc_signed&  v);
+  inline sc_signed operator ^ (unsigned int      u, const sc_signed&  v);
+
+  sc_signed operator ^ (const sc_unsigned&  u, const sc_int_base&  v);
+  sc_signed operator ^ (const sc_int_base&  u, const sc_unsigned&  v);
+  sc_signed operator ^ (const sc_signed&    u, const sc_int_base&  v);
+  sc_signed operator ^ (const sc_signed&    u, const sc_uint_base& v);
+  sc_signed operator ^ (const sc_int_base&  u, const sc_signed&    v);
+  sc_signed operator ^ (const sc_uint_base& u, const sc_signed&    v);
+
+
+
+  // SHIFT OPERATORS:
+
+  // LEFT SHIFT operators:
+
+  sc_unsigned operator << (const sc_unsigned&  u, const sc_signed&    v);
+    sc_signed operator << (const sc_signed&    u, const sc_unsigned&  v);
+
+    sc_signed operator << (const sc_signed&    u, const sc_signed&    v);
+    sc_signed operator << (const sc_signed&    u, int64               v);
+    sc_signed operator << (const sc_signed&    u, uint64              v);
+    sc_signed operator << (const sc_signed&    u, long                v);
+    sc_signed operator << (const sc_signed&    u, unsigned long       v);
+  inline   sc_signed operator << (const sc_signed&    u, int                 v);
+  inline   sc_signed operator << (const sc_signed&    u, unsigned int        v);
+
+    sc_signed operator << (const sc_signed&    u, const sc_int_base&  v);
+    sc_signed operator << (const sc_signed&    u, const sc_uint_base& v);
+
+
+
+  // RIGHT SHIFT operators:
+
+  sc_unsigned operator >> (const sc_unsigned&  u, const sc_signed&    v);
+    sc_signed operator >> (const sc_signed&    u, const sc_unsigned&  v);
+
+    sc_signed operator >> (const sc_signed&    u, const sc_signed&    v);
+    sc_signed operator >> (const sc_signed&    u, int64               v);
+    sc_signed operator >> (const sc_signed&    u, uint64              v);
+    sc_signed operator >> (const sc_signed&    u, long                v);
+    sc_signed operator >> (const sc_signed&    u, unsigned long       v);
+  inline   sc_signed operator >> (const sc_signed&    u, int                 v);
+  inline   sc_signed operator >> (const sc_signed&    u, unsigned int        v);
+
+  sc_signed operator >> (const sc_signed&    u, const sc_int_base&  v);
+  sc_signed operator >> (const sc_signed&    u, const sc_uint_base& v);
+
+
+
+  // Unary arithmetic operators
+  sc_signed operator + (const sc_signed&   u);
+  sc_signed operator - (const sc_signed&   u);
+  sc_signed operator - (const sc_unsigned& u);
+
+  // LOGICAL OPERATORS:
+
+  // Logical EQUAL operators:
+
+  bool operator == (const sc_unsigned&  u, const sc_signed&    v);
+  bool operator == (const sc_signed&    u, const sc_unsigned&  v);
+
+  bool operator == (const sc_signed&    u, const sc_signed&    v);
+  bool operator == (const sc_signed&    u, int64               v);
+  bool operator == (const sc_signed&    u, uint64              v);
+  bool operator == (const sc_signed&    u, long                v);
+  bool operator == (const sc_signed&    u, unsigned long       v);
+  inline bool operator == (const sc_signed&    u, int                 v);
+  inline bool operator == (const sc_signed&    u, unsigned int        v);
+
+  bool operator == (int64               u, const sc_signed&    v);
+  bool operator == (uint64              u, const sc_signed&    v);
+  bool operator == (long                u, const sc_signed&    v);
+  bool operator == (unsigned long       u, const sc_signed&    v);
+  inline bool operator == (int                 u, const sc_signed&    v);
+  inline bool operator == (unsigned int        u, const sc_signed&    v);
+
+  bool operator == (const sc_signed&    u, const sc_int_base&  v);
+  bool operator == (const sc_signed&    u, const sc_uint_base& v);
+  bool operator == (const sc_int_base&  u, const sc_signed&    v);
+  bool operator == (const sc_uint_base& u, const sc_signed&    v);
+
+  // Logical NOT_EQUAL operators:
+
+  bool operator != (const sc_unsigned&  u, const sc_signed&    v);
+  bool operator != (const sc_signed&    u, const sc_unsigned&  v);
+
+  bool operator != (const sc_signed&    u, const sc_signed&    v);
+  bool operator != (const sc_signed&    u, int64               v);
+  bool operator != (const sc_signed&    u, uint64              v);
+  bool operator != (const sc_signed&    u, long                v);
+  bool operator != (const sc_signed&    u, unsigned long       v);
+  inline bool operator != (const sc_signed&    u, int                 v);
+  inline bool operator != (const sc_signed&    u, unsigned int        v);
+
+  bool operator != (int64               u, const sc_signed&    v);
+  bool operator != (uint64              u, const sc_signed&    v);
+  bool operator != (long                u, const sc_signed&    v);
+  bool operator != (unsigned long       u, const sc_signed&    v);
+  inline bool operator != (int                 u, const sc_signed&    v);
+  inline bool operator != (unsigned int        u, const sc_signed&    v);
+
+  bool operator != (const sc_signed&    u, const sc_int_base&  v);
+  bool operator != (const sc_signed&    u, const sc_uint_base& v);
+  bool operator != (const sc_int_base&  u, const sc_signed&    v);
+  bool operator != (const sc_uint_base& u, const sc_signed&    v);
+
+  // Logical LESS_THAN operators:
+
+  bool operator < (const sc_unsigned&  u, const sc_signed&    v);
+  bool operator < (const sc_signed&    u, const sc_unsigned&  v);
+
+  bool operator < (const sc_signed&    u, const sc_signed&    v);
+  bool operator < (const sc_signed&    u, int64               v);
+  bool operator < (const sc_signed&    u, uint64              v);
+  bool operator < (const sc_signed&    u, long                v);
+  bool operator < (const sc_signed&    u, unsigned long       v);
+  inline bool operator < (const sc_signed&    u, int                 v);
+  inline bool operator < (const sc_signed&    u, unsigned int        v);
+
+  bool operator < (int64               u, const sc_signed&    v);
+  bool operator < (uint64              u, const sc_signed&    v);
+  bool operator < (long                u, const sc_signed&    v);
+  bool operator < (unsigned long       u, const sc_signed&    v);
+  inline bool operator < (int                 u, const sc_signed&    v);
+  inline bool operator < (unsigned int        u, const sc_signed&    v);
+
+  bool operator < (const sc_signed&    u, const sc_int_base&  v);
+  bool operator < (const sc_signed&    u, const sc_uint_base& v);
+  bool operator < (const sc_int_base&  u, const sc_signed&    v);
+  bool operator < (const sc_uint_base& u, const sc_signed&    v);
+
+  // Logical LESS_THAN_AND_EQUAL operators:
+
+  bool operator <= (const sc_unsigned&  u, const sc_signed&    v);
+  bool operator <= (const sc_signed&    u, const sc_unsigned&  v);
+
+  bool operator <= (const sc_signed&    u, const sc_signed&    v);
+  bool operator <= (const sc_signed&    u, int64               v);
+  bool operator <= (const sc_signed&    u, uint64              v);
+  bool operator <= (const sc_signed&    u, long                v);
+  bool operator <= (const sc_signed&    u, unsigned long       v);
+  inline bool operator <= (const sc_signed&    u, int                 v);
+  inline bool operator <= (const sc_signed&    u, unsigned int        v);
+
+  bool operator <= (int64               u, const sc_signed&    v);
+  bool operator <= (uint64              u, const sc_signed&    v);
+  bool operator <= (long                u, const sc_signed&    v);
+  bool operator <= (unsigned long       u, const sc_signed&    v);
+  inline bool operator <= (int                 u, const sc_signed&    v);
+  inline bool operator <= (unsigned int        u, const sc_signed&    v);
+
+  bool operator <= (const sc_signed&    u, const sc_int_base&  v);
+  bool operator <= (const sc_signed&    u, const sc_uint_base& v);
+  bool operator <= (const sc_int_base&  u, const sc_signed&    v);
+  bool operator <= (const sc_uint_base& u, const sc_signed&    v);
+
+  // Logical GREATER_THAN operators:
+
+  bool operator > (const sc_unsigned&  u, const sc_signed&    v);
+  bool operator > (const sc_signed&    u, const sc_unsigned&  v);
+
+  bool operator > (const sc_signed&    u, const sc_signed&    v);
+  bool operator > (const sc_signed&    u, int64               v);
+  bool operator > (const sc_signed&    u, uint64              v);
+  bool operator > (const sc_signed&    u, long                v);
+  bool operator > (const sc_signed&    u, unsigned long       v);
+  inline bool operator > (const sc_signed&    u, int                 v);
+  inline bool operator > (const sc_signed&    u, unsigned int        v);
+
+  bool operator > (int64               u, const sc_signed&    v);
+  bool operator > (uint64              u, const sc_signed&    v);
+  bool operator > (long                u, const sc_signed&    v);
+  bool operator > (unsigned long       u, const sc_signed&    v);
+  inline bool operator > (int                 u, const sc_signed&    v);
+  inline bool operator > (unsigned int        u, const sc_signed&    v);
+
+  bool operator > (const sc_signed&    u, const sc_int_base&  v);
+  bool operator > (const sc_signed&    u, const sc_uint_base& v);
+  bool operator > (const sc_int_base&  u, const sc_signed&    v);
+  bool operator > (const sc_uint_base& u, const sc_signed&    v);
+
+  // Logical GREATER_THAN_AND_EQUAL operators:
+
+  bool operator >= (const sc_unsigned&  u, const sc_signed&    v);
+  bool operator >= (const sc_signed&    u, const sc_unsigned&  v);
+
+  bool operator >= (const sc_signed&    u, const sc_signed&    v);
+  bool operator >= (const sc_signed&    u, int64               v);
+  bool operator >= (const sc_signed&    u, uint64              v);
+  bool operator >= (const sc_signed&    u, long                v);
+  bool operator >= (const sc_signed&    u, unsigned long       v);
+  inline bool operator >= (const sc_signed&    u, int                 v);
+  inline bool operator >= (const sc_signed&    u, unsigned int        v);
+
+  bool operator >= (int64               u, const sc_signed&    v);
+  bool operator >= (uint64              u, const sc_signed&    v);
+  bool operator >= (long                u, const sc_signed&    v);
+  bool operator >= (unsigned long       u, const sc_signed&    v);
+  inline bool operator >= (int                 u, const sc_signed&    v);
+  inline bool operator >= (unsigned int        u, const sc_signed&    v);
+
+  bool operator >= (const sc_signed&    u, const sc_int_base&  v);
+  bool operator >= (const sc_signed&    u, const sc_uint_base& v);
+  bool operator >= (const sc_int_base&  u, const sc_signed&    v);
+  bool operator >= (const sc_uint_base& u, const sc_signed&    v);
+
+  // Bitwise NOT operator (unary).
+  sc_signed operator ~ (const sc_signed& u);
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signed_bitref_r
+//
+//  Proxy class for sc_signed bit selection (r-value only).
+// ----------------------------------------------------------------------------
+
+class sc_signed_bitref_r : public sc_value_base
+{
+    friend class sc_signed;
+
+protected:
+
+    // constructor
+
+    sc_signed_bitref_r() : sc_value_base(), m_index(0), m_obj_p(0)
+        {}
+
+    void initialize( const sc_signed* obj_p, int index_ )
+        {
+	    m_index = index_;
+	    m_obj_p = ( CCAST<sc_signed*>( obj_p ) );
+	}
+
+public:
+
+    // destructor
+
+    virtual ~sc_signed_bitref_r()
+	{}
+
+    // copy constructor
+
+    sc_signed_bitref_r( const sc_signed_bitref_r& a )
+	: sc_value_base(a), m_index( a.m_index ), m_obj_p( a.m_obj_p )
+	{}
+
+    // capacity
+
+    int length() const
+	{ return 1; }
+
+
+    // implicit conversion to bool
+
+    operator uint64 () const;
+    bool operator ! () const;
+    bool operator ~ () const;
+
+
+    // explicit conversions
+
+    bool value() const
+	{ return operator uint64(); }
+
+    bool to_bool() const
+	{ return operator uint64(); }
+
+    // concatenation support
+
+    virtual int concat_length(bool* xz_present_p) const
+        { if ( xz_present_p ) *xz_present_p = false; return 1; }
+    virtual uint64 concat_get_uint64() const
+	{ return (uint64)operator uint64(); }
+    virtual bool concat_get_ctrl( sc_digit* dst_p, int low_i ) const
+	{
+	    int  bit_mask = 1 << (low_i % BITS_PER_DIGIT);
+	    int  word_i = low_i / BITS_PER_DIGIT;
+	    dst_p[word_i] &= ~bit_mask;
+	    return false;
+        }
+    virtual bool concat_get_data( sc_digit* dst_p, int low_i ) const
+	{
+	    int  bit_mask = 1 << (low_i % BITS_PER_DIGIT);
+	    bool result;	// True if non-zero.
+	    int  word_i = low_i / BITS_PER_DIGIT;
+	    if ( operator uint64() )
+	    {
+		dst_p[word_i] |= bit_mask;
+		result = true;
+	    }
+	    else
+	    {
+		dst_p[word_i] &= ~bit_mask;
+		result = false;
+	    }
+	    return result;
+        }
+
+
+    // other methods
+
+    void print( ::std::ostream& os = ::std::cout ) const
+	{ os << to_bool(); }
+
+protected:
+
+    int        m_index;  // Bit to be selected.
+    sc_signed* m_obj_p;  // Target of this bit selection.
+
+private:
+
+    // disabled
+    const sc_signed_bitref_r& operator = ( const sc_signed_bitref_r& );
+};
+
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream&, const sc_signed_bitref_r& );
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signed_bitref
+//
+//  Proxy class for sc_signed bit selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+class sc_signed_bitref
+    : public sc_signed_bitref_r
+{
+    friend class sc_signed;
+    friend class sc_core::sc_vpool<sc_signed_bitref>;
+
+
+    // constructor
+
+protected:
+
+    sc_signed_bitref() : sc_signed_bitref_r()
+	{}
+
+public:
+
+    // copy constructor
+
+    sc_signed_bitref( const sc_signed_bitref& a )
+	: sc_signed_bitref_r( a )
+	{}
+
+    // assignment operators
+
+    const sc_signed_bitref& operator = ( const sc_signed_bitref_r& );
+    const sc_signed_bitref& operator = ( const sc_signed_bitref& );
+    const sc_signed_bitref& operator = ( bool );
+
+    const sc_signed_bitref& operator &= ( bool );
+    const sc_signed_bitref& operator |= ( bool );
+    const sc_signed_bitref& operator ^= ( bool );
+
+    // concatenation methods
+
+    virtual void concat_set(int64 src, int low_i);
+    virtual void concat_set(const sc_signed& src, int low_i);
+    virtual void concat_set(const sc_unsigned& src, int low_i);
+    virtual void concat_set(uint64 src, int low_i);
+
+
+    // other methods
+
+    void scan( ::std::istream& is = ::std::cin );
+
+protected:
+    static sc_core::sc_vpool<sc_signed_bitref> m_pool;
+};
+
+
+
+inline
+::std::istream&
+operator >> ( ::std::istream&, sc_signed_bitref& );
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signed_subref_r
+//
+//  Proxy class for sc_signed part selection (r-value only).
+// ----------------------------------------------------------------------------
+
+class sc_signed_subref_r : public sc_value_base
+{
+    friend class sc_signed;
+    friend class sc_signed_signal;
+    friend class sc_unsigned;
+
+protected:
+
+    // constructor
+
+    sc_signed_subref_r() : sc_value_base(), m_left(0), m_obj_p(0), m_right(0)
+	{}
+
+    void initialize( const sc_signed* obj_p, int left_, int right_ )
+        {
+	    m_obj_p = ( CCAST<sc_signed*>( obj_p ));
+	    m_left = left_;
+	    m_right = right_;
+	}
+
+
+public:
+
+    // destructor
+
+    virtual ~sc_signed_subref_r()
+	{}
+
+    // copy constructor
+
+    sc_signed_subref_r( const sc_signed_subref_r& a )
+	: sc_value_base(a), m_left( a.m_left ), m_obj_p( a.m_obj_p ), 
+	  m_right( a.m_right )
+	{}
+
+
+    // capacity
+
+    int length() const
+        { return m_left >= m_right ? (m_left-m_right+1) : (m_right-m_left+1 ); }
+
+
+    // implicit conversion to sc_unsigned
+
+    operator sc_unsigned () const;
+
+
+    // explicit conversions
+
+    int           to_int() const;
+    unsigned int  to_uint() const;
+    long          to_long() const;
+    unsigned long to_ulong() const;
+    int64         to_int64() const;
+    uint64        to_uint64() const;
+    double        to_double() const;
+
+
+    // explicit conversion to character string
+
+    const std::string to_string( sc_numrep numrep = SC_DEC ) const;
+    const std::string to_string( sc_numrep numrep, bool w_prefix ) const;
+
+    // concatenation support
+
+    virtual int concat_length(bool* xz_present_p) const
+        {
+	    if ( xz_present_p ) *xz_present_p = false;
+	    return m_left - m_right + 1;
+        }
+    virtual uint64 concat_get_uint64() const;
+    virtual bool concat_get_ctrl( sc_digit* dst_p, int low_i ) const;
+    virtual bool concat_get_data( sc_digit* dst_p, int low_i ) const;
+
+    // reduce methods
+
+    bool and_reduce() const;
+    bool nand_reduce() const;
+    bool or_reduce() const;
+    bool nor_reduce() const;
+    bool xor_reduce() const ;
+    bool xnor_reduce() const;
+
+
+    // other methods
+
+    void print( ::std::ostream& os = ::std::cout ) const
+	{ os << to_string(sc_io_base(os,SC_DEC),sc_io_show_base(os)); }
+
+protected:
+
+    int        m_left;   // Left-most bit in this part selection.
+    sc_signed* m_obj_p;  // Target of this part selection.
+    int        m_right;  // Right-most bit in this part selection.
+
+private:
+    const sc_signed_subref_r& operator = ( const sc_signed_subref_r& );
+
+};
+
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream&, const sc_signed_subref_r& );
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signed_subref
+//
+//  Proxy class for sc_signed part selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+class sc_signed_subref
+    : public sc_signed_subref_r
+{
+    friend class sc_signed;
+    friend class sc_core::sc_vpool<sc_signed_subref>;
+
+
+    // constructor
+
+    sc_signed_subref() : sc_signed_subref_r()
+        {}
+
+public:
+
+    // copy constructor
+
+    sc_signed_subref( const sc_signed_subref& a )
+	: sc_signed_subref_r( a )
+	{}
+
+
+    // assignment operators
+
+    const sc_signed_subref& operator = ( const sc_signed_subref_r& a );
+    const sc_signed_subref& operator = ( const sc_signed_subref& a );
+    const sc_signed_subref& operator = ( const sc_signed& a );
+
+    const sc_signed_subref& operator = ( const sc_unsigned_subref_r& a );
+    const sc_signed_subref& operator = ( const sc_unsigned& a );
+
+    template< class T >
+    const sc_signed_subref& operator = ( const sc_generic_base<T>& a )
+    {
+        sc_unsigned temp( length() );
+	a->to_sc_unsigned(temp);
+	return operator = (temp);
+    }
+
+    const sc_signed_subref& operator = ( const char* a );
+    const sc_signed_subref& operator = ( unsigned long a );
+    const sc_signed_subref& operator = ( long a );
+    const sc_signed_subref& operator = ( unsigned int a )
+	{ return operator = ( (unsigned long) a ); }
+
+    const sc_signed_subref& operator = ( int a )
+	{ return operator = ( (long) a ); }
+
+    const sc_signed_subref& operator = ( uint64 a );
+    const sc_signed_subref& operator = ( int64 a );
+    const sc_signed_subref& operator = ( double a );
+    const sc_signed_subref& operator = ( const sc_int_base& a );
+    const sc_signed_subref& operator = ( const sc_uint_base& a );
+
+    // concatenation methods
+
+    virtual void concat_set(int64 src, int low_i);
+    virtual void concat_set(const sc_signed& src, int low_i);
+    virtual void concat_set(const sc_unsigned& src, int low_i);
+    virtual void concat_set(uint64 src, int low_i);
+
+    // other methods
+
+    void scan( ::std::istream& is = ::std::cin );
+
+protected:
+    static sc_core::sc_vpool<sc_signed_subref> m_pool;
+};
+
+
+
+inline
+::std::istream&
+operator >> ( ::std::istream&, sc_signed_subref& );
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signed
+//
+//  Arbitrary precision signed number.
+// ----------------------------------------------------------------------------
+
+class sc_signed : public sc_value_base
+{
+    friend class sc_concatref;
+    friend class sc_signed_bitref_r;
+    friend class sc_signed_bitref;
+    friend class sc_signed_subref_r;
+    friend class sc_signed_subref;
+    friend class sc_unsigned;
+    friend class sc_unsigned_subref;
+
+  // Needed for types using sc_signed.
+  typedef bool elemtype;
+
+public:
+
+    // constructors
+
+    explicit sc_signed( int nb = sc_length_param().len() );
+    sc_signed( const sc_signed&   v );
+    sc_signed( const sc_unsigned& v );
+    template<class T>
+    explicit sc_signed( const sc_generic_base<T>& v );
+    explicit sc_signed( const sc_bv_base& v );
+    explicit sc_signed( const sc_lv_base& v );
+    explicit sc_signed( const sc_int_subref_r& v );
+    explicit sc_signed( const sc_uint_subref_r& v );
+    explicit sc_signed( const sc_signed_subref_r& v );
+    explicit sc_signed( const sc_unsigned_subref_r& v );
+
+    // assignment operators
+
+    const sc_signed& operator = (const sc_signed&          v);
+    const sc_signed& operator = (const sc_signed_subref_r& a );
+
+    template< class T >
+    const sc_signed& operator = ( const sc_generic_base<T>& a )
+        { a->to_sc_signed(*this); return *this; }
+
+    const sc_signed& operator = (const sc_unsigned&        v);
+    const sc_signed& operator = (const sc_unsigned_subref_r& a );
+
+    const sc_signed& operator = (const char*               v);
+    const sc_signed& operator = (int64                     v);
+    const sc_signed& operator = (uint64                    v);
+    const sc_signed& operator = (long                      v);
+    const sc_signed& operator = (unsigned long             v);
+
+    const sc_signed& operator = (int                       v)
+	{ return operator=((long) v); }
+
+    const sc_signed& operator = (unsigned int              v)
+	{ return operator=((unsigned long) v); }
+
+    const sc_signed& operator = (double                    v);
+    const sc_signed& operator = (const sc_int_base&        v);
+    const sc_signed& operator = (const sc_uint_base&       v);
+
+    const sc_signed& operator = ( const sc_bv_base& );
+    const sc_signed& operator = ( const sc_lv_base& );
+
+#ifdef SC_INCLUDE_FX
+    const sc_signed& operator = ( const sc_fxval& );
+    const sc_signed& operator = ( const sc_fxval_fast& );
+    const sc_signed& operator = ( const sc_fxnum& );
+    const sc_signed& operator = ( const sc_fxnum_fast& );
+#endif
+
+
+    // destructor
+
+    virtual ~sc_signed()
+	{
+#ifndef SC_MAX_NBITS
+	    delete [] digit;
+#endif
+	}
+
+    // Concatenation support:
+
+    sc_digit* get_raw() const
+	{ return digit; }
+    virtual int concat_length(bool* xz_present_p) const
+	{ if ( xz_present_p ) *xz_present_p = false; return nbits; }
+    virtual bool concat_get_ctrl( sc_digit* dst_p, int low_i ) const;
+    virtual bool concat_get_data( sc_digit* dst_p, int low_i ) const;
+    virtual uint64 concat_get_uint64() const;
+    virtual void concat_set(int64 src, int low_i);
+    virtual void concat_set(const sc_signed& src, int low_i);
+    virtual void concat_set(const sc_unsigned& src, int low_i);
+    virtual void concat_set(uint64 src, int low_i);
+
+
+
+    // Increment operators.
+    sc_signed& operator ++ ();
+    const sc_signed operator ++ (int);
+
+    // Decrement operators.
+    sc_signed& operator -- ();
+    const sc_signed operator -- (int);
+
+
+    // bit selection
+
+    inline void check_index( int i ) const
+        { if ( i < 0 || i >= nbits ) invalid_index(i); }
+
+    void invalid_index( int i ) const;
+
+    sc_signed_bitref& operator [] ( int i )
+        {
+            check_index(i);
+	    sc_signed_bitref* result_p =
+	        sc_signed_bitref::m_pool.allocate();
+	    result_p->initialize( this, i );
+	    return *result_p;
+	}
+
+    const sc_signed_bitref_r& operator [] ( int i ) const
+        {
+            check_index(i);
+	    sc_signed_bitref* result_p =
+	        sc_signed_bitref::m_pool.allocate();
+	    result_p->initialize( this, i );
+	    return *result_p;
+	}
+
+    sc_signed_bitref& bit( int i )
+        {
+            check_index(i);
+	    sc_signed_bitref* result_p =
+	        sc_signed_bitref::m_pool.allocate();
+	    result_p->initialize( this, i );
+	    return *result_p;
+	}
+
+    const sc_signed_bitref_r& bit( int i ) const
+        {
+            check_index(i);
+	    sc_signed_bitref* result_p =
+	        sc_signed_bitref::m_pool.allocate();
+	    result_p->initialize( this, i );
+	    return *result_p;
+	}
+
+
+    // part selection
+
+    // Subref operators. Help access the range of bits from the ith to
+    // jth. These indices have arbitrary precedence with respect to each
+    // other, i.e., we can have i <= j or i > j. Note the equivalence
+    // between range(i, j) and operator(i, j). Also note that
+    // operator(i, i) returns a signed number that corresponds to the
+    // bit operator[i], so these two forms are not the same.
+
+    inline void check_range( int l, int r ) const
+        {
+            if ( l < r )
+            {
+                if ( l < 0 || r >= nbits ) invalid_range(l,r);
+            }
+            else
+            {
+                if ( r < 0 || l >= nbits ) invalid_range(l,r);
+            }
+        }
+
+    void invalid_range( int l, int r ) const;
+
+    sc_signed_subref& range( int i, int j )
+        {
+	    check_range( i, j );
+	    sc_signed_subref* result_p =
+	        sc_signed_subref::m_pool.allocate();
+	    result_p->initialize( this, i, j );
+	    return *result_p;
+	}
+
+    const sc_signed_subref_r& range( int i, int j ) const
+        {
+	    check_range( i, j );
+	    sc_signed_subref* result_p =
+	        sc_signed_subref::m_pool.allocate();
+	    result_p->initialize( this, i, j );
+	    return *result_p;
+	}
+
+    sc_signed_subref& operator () ( int i, int j )
+        {
+	    check_range( i, j );
+	    sc_signed_subref* result_p =
+	        sc_signed_subref::m_pool.allocate();
+	    result_p->initialize( this, i, j );
+	    return *result_p;
+	}
+
+    const sc_signed_subref_r& operator () ( int i, int j ) const
+        {
+	    check_range( i, j );
+	    sc_signed_subref* result_p =
+	        sc_signed_subref::m_pool.allocate();
+	    result_p->initialize( this, i, j );
+	    return *result_p;
+	}
+
+
+    // explicit conversions
+
+    int           to_int() const;
+    unsigned int  to_uint() const;
+    long          to_long() const;
+    unsigned long to_ulong() const;
+    int64         to_int64() const;
+    uint64        to_uint64() const;
+    double        to_double() const;
+
+#ifdef SC_DT_DEPRECATED
+    int to_signed() const
+	{ return to_int(); }
+
+    unsigned int to_unsigned() const
+	{ return to_uint(); }
+#endif
+
+    // explicit conversion to character string
+
+    const std::string to_string( sc_numrep numrep = SC_DEC ) const;
+    const std::string to_string( sc_numrep numrep, bool w_prefix ) const;
+
+
+    // Print functions. dump prints the internals of the class.
+
+    void print( ::std::ostream& os = ::std::cout ) const
+	{ os << to_string(sc_io_base(os,SC_DEC),sc_io_show_base(os)); }
+
+    void scan( ::std::istream& is = ::std::cin );
+
+    void dump( ::std::ostream& os = ::std::cout ) const;
+
+
+  // Functions to find various properties.
+  int  length() const { return nbits; }  // Bit width.
+  bool iszero() const;                   // Is the number zero?
+  bool sign() const;                     // Sign.
+
+   // reduce methods
+
+    bool and_reduce() const;
+
+    bool nand_reduce() const
+        { return ( ! and_reduce() ); }
+
+    bool or_reduce() const;
+
+    bool nor_reduce() const
+        { return ( ! or_reduce() ); }
+
+    bool xor_reduce() const;
+
+    bool xnor_reduce() const
+        { return ( ! xor_reduce() ); }
+
+  // Functions to access individual bits.
+  bool test(int i) const;      // Is the ith bit 0 or 1?
+  void set(int i);             // Set the ith bit to 1.
+  void clear(int i);           // Set the ith bit to 0.
+  void set(int i, bool v)      // Set the ith bit to v.
+    { if (v) set(i); else clear(i);  }
+  void invert(int i)           // Negate the ith bit.
+    { if (test(i)) clear(i); else set(i);  }
+
+  // Make the number equal to its mirror image.
+  void reverse();
+
+  // Get/set a packed bit representation of the number.
+  void get_packed_rep(sc_digit *buf) const;
+  void set_packed_rep(sc_digit *buf);
+
+  /*
+    The comparison of the old and new semantics are as follows:
+
+    Let s = sc_signed,
+        u = sc_unsigned,
+        un = { uint64, unsigned long, unsigned int },
+        sn = { int64, long, int, char* }, and
+        OP = { +, -, *, /, % }.
+
+    Old semantics:                     New semantics:
+      u OP u -> u                        u OP u -> u
+      s OP u -> u                        s OP u -> s
+      u OP s -> u                        u OP s -> s
+      s OP s -> s                        s OP s -> s
+
+      u OP un = un OP u -> u             u OP un = un OP u -> u
+      u OP sn = sn OP u -> u             u OP sn = sn OP u -> s
+
+      s OP un = un OP s -> s             s OP un = un OP s -> s
+      s OP sn = sn OP s -> s             s OP sn = sn OP s -> s
+
+    In the new semantics, the result is u if both operands are u; the
+    result is s otherwise. The only exception is subtraction. The result
+    of a subtraction is always s.
+
+    The old semantics is like C/C++ semantics on integer types; the
+    new semantics is due to the VSIA C/C++ data types standard.
+   */
+
+  // ARITHMETIC OPERATORS:
+
+  // ADDition operators:
+
+  friend sc_signed operator + (const sc_unsigned&  u, const sc_signed&    v);
+  friend sc_signed operator + (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend sc_signed operator + (const sc_unsigned&  u, int64               v);
+  friend sc_signed operator + (const sc_unsigned&  u, long                v);
+  friend sc_signed operator + (const sc_unsigned&  u, int                 v)
+    { return operator+(u, (long) v); }
+
+  friend sc_signed operator + (int64               u, const sc_unsigned&  v);
+  friend sc_signed operator + (long                u, const sc_unsigned&  v);
+  friend sc_signed operator + (int                 u, const sc_unsigned&  v)
+    { return operator+((long) u, v); }
+
+  friend sc_signed operator + (const sc_signed&    u, const sc_signed&    v);
+  friend sc_signed operator + (const sc_signed&    u, int64               v);
+  friend sc_signed operator + (const sc_signed&    u, uint64              v);
+  friend sc_signed operator + (const sc_signed&    u, long                v);
+  friend sc_signed operator + (const sc_signed&    u, unsigned long       v);
+  friend sc_signed operator + (const sc_signed&    u, int                 v)
+    { return operator+(u, (long) v); }
+  friend sc_signed operator + (const sc_signed&    u, unsigned int        v)
+    { return operator+(u, (unsigned long) v); }
+
+  friend sc_signed operator + (int64               u, const sc_signed&    v);
+  friend sc_signed operator + (uint64              u, const sc_signed&    v);
+  friend sc_signed operator + (long                u, const sc_signed&    v);
+  friend sc_signed operator + (unsigned long       u, const sc_signed&    v);
+  friend sc_signed operator + (int                 u, const sc_signed&    v)
+    { return operator+((long) u, v); }
+  friend sc_signed operator + (unsigned int        u, const sc_signed&    v)
+    { return operator+((unsigned long) u, v); }
+
+  const sc_signed& operator += (const sc_signed&    v);
+  const sc_signed& operator += (const sc_unsigned&  v);
+  const sc_signed& operator += (int64               v);
+  const sc_signed& operator += (uint64              v);
+  const sc_signed& operator += (long                v);
+  const sc_signed& operator += (unsigned long       v);
+  const sc_signed& operator += (int                 v)
+    { return operator+=((long) v); }
+  const sc_signed& operator += (unsigned int        v)
+    { return operator+=((unsigned long) v); }
+
+  friend sc_signed operator + (const sc_unsigned&  u, const sc_int_base&  v);
+  friend sc_signed operator + (const sc_int_base&  u, const sc_unsigned&  v);
+  friend sc_signed operator + (const sc_signed&    u, const sc_int_base&  v);
+  friend sc_signed operator + (const sc_signed&    u, const sc_uint_base& v);
+  friend sc_signed operator + (const sc_int_base&  u, const sc_signed&    v);
+  friend sc_signed operator + (const sc_uint_base& u, const sc_signed&    v);
+  const sc_signed& operator += (const sc_int_base&  v);
+  const sc_signed& operator += (const sc_uint_base& v);
+
+  // SUBtraction operators:
+
+  friend sc_signed operator - (const sc_unsigned&  u, const sc_signed&    v);
+  friend sc_signed operator - (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend sc_signed operator - (const sc_unsigned&  u, const sc_unsigned&  v);
+  friend sc_signed operator - (const sc_unsigned&  u, int64               v);
+  friend sc_signed operator - (const sc_unsigned&  u, uint64              v);
+  friend sc_signed operator - (const sc_unsigned&  u, long                v);
+  friend sc_signed operator - (const sc_unsigned&  u, unsigned long       v);
+  friend sc_signed operator - (const sc_unsigned&  u, int                v)
+    { return operator-(u, (long) v); }
+  friend sc_signed operator - (const sc_unsigned&  u, unsigned int       v)
+    { return operator-(u, (unsigned long) v); }
+
+  friend sc_signed operator - (int64               u, const sc_unsigned&  v);
+  friend sc_signed operator - (uint64              u, const sc_unsigned&  v);
+  friend sc_signed operator - (long                u, const sc_unsigned&  v);
+  friend sc_signed operator - (unsigned long       u, const sc_unsigned&  v);
+  friend sc_signed operator - (int                 u, const sc_unsigned&  v)
+    { return operator-((long) u, v); }
+  friend sc_signed operator - (unsigned int        u, const sc_unsigned& v)
+    { return operator-((unsigned long) u, v); }
+
+  friend sc_signed operator - (const sc_signed&    u, const sc_signed&    v);
+  friend sc_signed operator - (const sc_signed&    u, int64               v);
+  friend sc_signed operator - (const sc_signed&    u, uint64              v);
+  friend sc_signed operator - (const sc_signed&    u, long                v);
+  friend sc_signed operator - (const sc_signed&    u, unsigned long       v);
+  friend sc_signed operator - (const sc_signed&    u, int                 v)
+    { return operator-(u, (long) v); }
+  friend sc_signed operator - (const sc_signed&    u, unsigned int        v)
+    { return operator-(u, (unsigned long) v); }
+
+  friend sc_signed operator - (int64               u, const sc_signed&    v);
+  friend sc_signed operator - (uint64              u, const sc_signed&    v);
+  friend sc_signed operator - (long                u, const sc_signed&    v);
+  friend sc_signed operator - (unsigned long       u, const sc_signed&    v);
+  friend sc_signed operator - (int                 u, const sc_signed&    v)
+    { return operator-((long) u, v); }
+  friend sc_signed operator - (unsigned int        u, const sc_signed&    v)
+    { return operator-((unsigned long) u, v); }
+
+  const sc_signed& operator -= (const sc_signed&    v);
+  const sc_signed& operator -= (const sc_unsigned&  v);
+  const sc_signed& operator -= (int64               v);
+  const sc_signed& operator -= (uint64              v);
+  const sc_signed& operator -= (long                v);
+  const sc_signed& operator -= (unsigned long       v);
+  const sc_signed& operator -= (int                 v)
+    { return operator -= ((long) v); }
+  const sc_signed& operator -= (unsigned int        v)
+    { return operator -= ((unsigned long) v); }
+
+  friend sc_signed operator - (const sc_unsigned&  u, const sc_int_base&  v);
+  friend sc_signed operator - (const sc_unsigned&  u, const sc_uint_base& v);
+  friend sc_signed operator - (const sc_int_base&  u, const sc_unsigned&  v);
+  friend sc_signed operator - (const sc_uint_base& u, const sc_unsigned&  v);
+  friend sc_signed operator - (const sc_signed&    u, const sc_int_base&  v);
+  friend sc_signed operator - (const sc_signed&    u, const sc_uint_base& v);
+  friend sc_signed operator - (const sc_int_base&  u, const sc_signed&    v);
+  friend sc_signed operator - (const sc_uint_base& u, const sc_signed&    v);
+  const sc_signed& operator -= (const sc_int_base&  v);
+  const sc_signed& operator -= (const sc_uint_base& v);
+
+  // MULtiplication operators:
+
+  friend sc_signed operator * (const sc_unsigned&  u, const sc_signed&    v);
+  friend sc_signed operator * (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend sc_signed operator * (const sc_unsigned&  u, int64               v);
+  friend sc_signed operator * (const sc_unsigned&  u, long                v);
+  friend sc_signed operator * (const sc_unsigned&  u, int                 v)
+    { return operator*(u, (long) v); }
+
+  friend sc_signed operator * (int64               u, const sc_unsigned&  v);
+  friend sc_signed operator * (long                u, const sc_unsigned&  v);
+  friend sc_signed operator * (int                 u, const sc_unsigned&  v)
+    { return operator*((long) u, v); }
+
+  friend sc_signed operator * (const sc_signed&  u, const sc_signed&  v);
+  friend sc_signed operator * (const sc_signed&  u, int64             v);
+  friend sc_signed operator * (const sc_signed&  u, uint64            v);
+  friend sc_signed operator * (const sc_signed&  u, long              v);
+  friend sc_signed operator * (const sc_signed&  u, unsigned long     v);
+  friend sc_signed operator * (const sc_signed&  u, int               v)
+    { return operator*(u, (long) v); }
+  friend sc_signed operator * (const sc_signed&  u, unsigned int      v)
+    { return operator*(u, (unsigned long) v); }
+
+  friend sc_signed operator * (int64             u, const sc_signed&  v);
+  friend sc_signed operator * (uint64            u, const sc_signed&  v);
+  friend sc_signed operator * (long              u, const sc_signed&  v);
+  friend sc_signed operator * (unsigned long     u, const sc_signed&  v);
+  friend sc_signed operator * (int               u, const sc_signed&  v)
+    { return operator*((long) u, v); }
+  friend sc_signed operator * (unsigned int      u, const sc_signed&  v)
+    { return operator*((unsigned long) u, v); }
+
+  const sc_signed& operator *= (const sc_signed&    v);
+  const sc_signed& operator *= (const sc_unsigned&  v);
+  const sc_signed& operator *= (int64               v);
+  const sc_signed& operator *= (uint64              v);
+  const sc_signed& operator *= (long                v);
+  const sc_signed& operator *= (unsigned long       v);
+  const sc_signed& operator *= (int                 v)
+    { return operator*=((long) v); }
+  const sc_signed& operator *= (unsigned int        v)
+    { return operator*=((unsigned long) v); }
+
+  friend sc_signed operator * (const sc_unsigned&  u, const sc_int_base&  v);
+  friend sc_signed operator * (const sc_int_base&  u, const sc_unsigned&  v);
+  friend sc_signed operator * (const sc_signed&    u, const sc_int_base&  v);
+  friend sc_signed operator * (const sc_signed&    u, const sc_uint_base& v);
+  friend sc_signed operator * (const sc_int_base&  u, const sc_signed&    v);
+  friend sc_signed operator * (const sc_uint_base& u, const sc_signed&    v);
+  const sc_signed& operator *= (const sc_int_base&  v);
+  const sc_signed& operator *= (const sc_uint_base& v);
+
+  // DIVision operators:
+
+  friend sc_signed operator / (const sc_unsigned&  u, const sc_signed&    v);
+  friend sc_signed operator / (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend sc_signed operator / (const sc_unsigned&  u, int64               v);
+  friend sc_signed operator / (const sc_unsigned&  u, long                v);
+  friend sc_signed operator / (const sc_unsigned&  u, int                 v)
+    { return operator/(u, (long) v); }
+
+  friend sc_signed operator / (int64               u, const sc_unsigned&  v);
+  friend sc_signed operator / (long                u, const sc_unsigned&  v);
+  friend sc_signed operator / (int                 u, const sc_unsigned&  v)
+    { return operator/((long) u, v); }
+
+  friend sc_signed operator / (const sc_signed&    u, const sc_signed&    v);
+  friend sc_signed operator / (const sc_signed&    u, int64               v);
+  friend sc_signed operator / (const sc_signed&    u, uint64              v);
+  friend sc_signed operator / (const sc_signed&    u, long                v);
+  friend sc_signed operator / (const sc_signed&    u, unsigned long       v);
+  friend sc_signed operator / (const sc_signed&    u, int                 v)
+    { return operator/(u, (long) v); }
+  friend sc_signed operator / (const sc_signed&    u, unsigned int        v)
+    { return operator/(u, (unsigned long) v); }
+
+  friend sc_signed operator / (int64               u, const sc_signed&    v);
+  friend sc_signed operator / (uint64              u, const sc_signed&    v);
+  friend sc_signed operator / (long                u, const sc_signed&    v);
+  friend sc_signed operator / (unsigned long       u, const sc_signed&    v);
+  friend sc_signed operator / (int                 u, const sc_signed&    v)
+    { return operator/((long) u, v); }
+  friend sc_signed operator / (unsigned int        u, const sc_signed&    v)
+    { return operator/((unsigned long) u, v); }
+
+  const sc_signed& operator /= (const sc_signed&    v);
+  const sc_signed& operator /= (const sc_unsigned&  v);
+  const sc_signed& operator /= (int64               v);
+  const sc_signed& operator /= (uint64              v);
+  const sc_signed& operator /= (long                v);
+  const sc_signed& operator /= (unsigned long       v);
+  const sc_signed& operator /= (int                 v)
+    { return operator/=((long) v); }
+  const sc_signed& operator /= (unsigned int        v)
+    { return operator/=((unsigned long) v); }
+
+  friend sc_signed operator / (const sc_unsigned&  u, const sc_int_base&  v);
+  friend sc_signed operator / (const sc_int_base&  u, const sc_unsigned&  v);
+  friend sc_signed operator / (const sc_signed&    u, const sc_int_base&  v);
+  friend sc_signed operator / (const sc_signed&    u, const sc_uint_base& v);
+  friend sc_signed operator / (const sc_int_base&  u, const sc_signed&    v);
+  friend sc_signed operator / (const sc_uint_base& u, const sc_signed&    v);
+  const sc_signed& operator /= (const sc_int_base&  v);
+  const sc_signed& operator /= (const sc_uint_base& v);
+
+  // MODulo operators:
+
+  friend sc_signed operator % (const sc_unsigned&  u, const sc_signed&    v);
+  friend sc_signed operator % (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend sc_signed operator % (const sc_unsigned&  u, int64               v);
+  friend sc_signed operator % (const sc_unsigned&  u, long                v);
+  friend sc_signed operator % (const sc_unsigned&  u, int                 v)
+    { return operator%(u, (long) v); }
+
+  friend sc_signed operator % (int64               u, const sc_unsigned&  v);
+  friend sc_signed operator % (long                u, const sc_unsigned&  v);
+  friend sc_signed operator % (int                 u, const sc_unsigned&  v)
+    { return operator%((long) u, v); }
+
+  friend sc_signed operator % (const sc_signed&    u, const sc_signed&    v);
+  friend sc_signed operator % (const sc_signed&    u, int64               v);
+  friend sc_signed operator % (const sc_signed&    u, uint64              v);
+  friend sc_signed operator % (const sc_signed&    u, long                v);
+  friend sc_signed operator % (const sc_signed&    u, unsigned long       v);
+  friend sc_signed operator % (const sc_signed&    u, int                 v)
+    { return operator%(u, (long) v); }
+  friend sc_signed operator % (const sc_signed&    u, unsigned int        v)
+    { return operator%(u, (unsigned long) v); }
+
+  friend sc_signed operator % (int64               u, const sc_signed&    v);
+  friend sc_signed operator % (uint64              u, const sc_signed&    v);
+  friend sc_signed operator % (long                u, const sc_signed&    v);
+  friend sc_signed operator % (unsigned long       u, const sc_signed&    v);
+  friend sc_signed operator % (int                 u, const sc_signed&    v)
+    { return operator%((long) u, v); }
+  friend sc_signed operator % (unsigned int        u, const sc_signed&    v)
+    { return operator%((unsigned long) u, v); }
+
+  const sc_signed& operator %= (const sc_signed&    v);
+  const sc_signed& operator %= (const sc_unsigned&  v);
+  const sc_signed& operator %= (int64               v);
+  const sc_signed& operator %= (uint64              v);
+  const sc_signed& operator %= (long                v);
+  const sc_signed& operator %= (unsigned long       v);
+  const sc_signed& operator %= (int                 v)
+    { return operator%=((long) v); }
+  const sc_signed& operator %= (unsigned int        v)
+    { return operator%=((unsigned long) v); }
+
+  friend sc_signed operator % (const sc_unsigned&  u, const sc_int_base&  v);
+  friend sc_signed operator % (const sc_int_base&  u, const sc_unsigned&  v);
+  friend sc_signed operator % (const sc_signed&    u, const sc_int_base&  v);
+  friend sc_signed operator % (const sc_signed&    u, const sc_uint_base& v);
+  friend sc_signed operator % (const sc_int_base&  u, const sc_signed&    v);
+  friend sc_signed operator % (const sc_uint_base& u, const sc_signed&    v);
+  const sc_signed& operator %= (const sc_int_base&  v);
+  const sc_signed& operator %= (const sc_uint_base& v);
+
+  // BITWISE OPERATORS:
+
+  // Bitwise AND operators:
+
+  friend sc_signed operator & (const sc_unsigned&  u, const sc_signed&    v);
+  friend sc_signed operator & (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend sc_signed operator & (const sc_unsigned&  u, int64               v);
+  friend sc_signed operator & (const sc_unsigned&  u, long                v);
+  friend sc_signed operator & (const sc_unsigned&  u, int                 v)
+    { return operator&(u, (long) v); }
+
+  friend sc_signed operator & (int64               u, const sc_unsigned&  v);
+  friend sc_signed operator & (long                u, const sc_unsigned&  v);
+  friend sc_signed operator & (int                 u, const sc_unsigned&  v)
+    { return operator&((long) u, v); }
+
+  friend sc_signed operator & (const sc_signed&    u, const sc_signed&    v);
+  friend sc_signed operator & (const sc_signed&    u, int64               v);
+  friend sc_signed operator & (const sc_signed&    u, uint64              v);
+  friend sc_signed operator & (const sc_signed&    u, long                v);
+  friend sc_signed operator & (const sc_signed&    u, unsigned long       v);
+  friend sc_signed operator & (const sc_signed&    u, int                 v)
+    { return operator&(u, (long) v); }
+  friend sc_signed operator & (const sc_signed&    u, unsigned int        v)
+    { return operator&(u, (unsigned long) v); }
+
+  friend sc_signed operator & (int64             u, const sc_signed&  v);
+  friend sc_signed operator & (uint64            u, const sc_signed&  v);
+  friend sc_signed operator & (long              u, const sc_signed&  v);
+  friend sc_signed operator & (unsigned long     u, const sc_signed&  v);
+  friend sc_signed operator & (int               u, const sc_signed&  v)
+    { return operator&((long) u, v); }
+  friend sc_signed operator & (unsigned int      u, const sc_signed&  v)
+    { return operator&((unsigned long) u, v); }
+
+  const sc_signed& operator &= (const sc_signed&    v);
+  const sc_signed& operator &= (const sc_unsigned&  v);
+  const sc_signed& operator &= (int64               v);
+  const sc_signed& operator &= (uint64              v);
+  const sc_signed& operator &= (long                v);
+  const sc_signed& operator &= (unsigned long       v);
+  const sc_signed& operator &= (int                 v)
+    { return operator&=((long) v); }
+  const sc_signed& operator &= (unsigned int        v)
+    { return operator&=((unsigned long) v); }
+
+  friend sc_signed operator & (const sc_unsigned&  u, const sc_int_base&  v);
+  friend sc_signed operator & (const sc_int_base&  u, const sc_unsigned&  v);
+  friend sc_signed operator & (const sc_signed&    u, const sc_int_base&  v);
+  friend sc_signed operator & (const sc_signed&    u, const sc_uint_base& v);
+  friend sc_signed operator & (const sc_int_base&  u, const sc_signed&    v);
+  friend sc_signed operator & (const sc_uint_base& u, const sc_signed&    v);
+  const sc_signed& operator &= (const sc_int_base&  v);
+  const sc_signed& operator &= (const sc_uint_base& v);
+
+  // Bitwise OR operators:
+
+  friend sc_signed operator | (const sc_unsigned&  u, const sc_signed&    v);
+  friend sc_signed operator | (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend sc_signed operator | (const sc_unsigned&  u, int64               v);
+  friend sc_signed operator | (const sc_unsigned&  u, long                v);
+  friend sc_signed operator | (const sc_unsigned&  u, int                 v)
+    { return operator|(u, (long) v); }
+
+  friend sc_signed operator | (int64               u, const sc_unsigned&  v);
+  friend sc_signed operator | (long                u, const sc_unsigned&  v);
+  friend sc_signed operator | (int                 u, const sc_unsigned&  v)
+    { return operator|((long) u, v); }
+
+  friend sc_signed operator | (const sc_signed&    u, const sc_signed&    v);
+  friend sc_signed operator | (const sc_signed&    u, int64               v);
+  friend sc_signed operator | (const sc_signed&    u, uint64              v);
+  friend sc_signed operator | (const sc_signed&    u, long                v);
+  friend sc_signed operator | (const sc_signed&    u, unsigned long       v);
+  friend sc_signed operator | (const sc_signed&    u, int                 v)
+    { return operator|(u, (long) v); }
+  friend sc_signed operator | (const sc_signed&    u, unsigned int        v)
+    { return operator|(u, (unsigned long) v); }
+
+  friend sc_signed operator | (int64             u, const sc_signed&  v);
+  friend sc_signed operator | (uint64            u, const sc_signed&  v);
+  friend sc_signed operator | (long              u, const sc_signed&  v);
+  friend sc_signed operator | (unsigned long     u, const sc_signed&  v);
+  friend sc_signed operator | (int               u, const sc_signed&  v)
+    { return operator|((long) u, v); }
+  friend sc_signed operator | (unsigned int      u, const sc_signed&  v)
+    { return operator|((unsigned long) u, v); }
+
+  const sc_signed& operator |= (const sc_signed&    v);
+  const sc_signed& operator |= (const sc_unsigned&  v);
+  const sc_signed& operator |= (int64               v);
+  const sc_signed& operator |= (uint64              v);
+  const sc_signed& operator |= (long                v);
+  const sc_signed& operator |= (unsigned long       v);
+  const sc_signed& operator |= (int                 v)
+    { return operator|=((long) v); }
+  const sc_signed& operator |= (unsigned int        v)
+    { return operator|=((unsigned long) v); }
+
+  friend sc_signed operator | (const sc_unsigned&  u, const sc_int_base&  v);
+  friend sc_signed operator | (const sc_int_base&  u, const sc_unsigned&  v);
+  friend sc_signed operator | (const sc_signed&    u, const sc_int_base&  v);
+  friend sc_signed operator | (const sc_signed&    u, const sc_uint_base& v);
+  friend sc_signed operator | (const sc_int_base&  u, const sc_signed&    v);
+  friend sc_signed operator | (const sc_uint_base& u, const sc_signed&    v);
+  const sc_signed& operator |= (const sc_int_base&  v);
+  const sc_signed& operator |= (const sc_uint_base& v);
+
+  // Bitwise XOR operators:
+
+  friend sc_signed operator ^ (const sc_unsigned&  u, const sc_signed&    v);
+  friend sc_signed operator ^ (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend sc_signed operator ^ (const sc_unsigned&  u, int64               v);
+  friend sc_signed operator ^ (const sc_unsigned&  u, long                v);
+  friend sc_signed operator ^ (const sc_unsigned&  u, int                 v)
+    { return operator^(u, (long) v); }
+
+  friend sc_signed operator ^ (int64               u, const sc_unsigned&  v);
+  friend sc_signed operator ^ (long                u, const sc_unsigned&  v);
+  friend sc_signed operator ^ (int                 u, const sc_unsigned&  v)
+    { return operator^((long) u, v); }
+
+  friend sc_signed operator ^ (const sc_signed&    u, const sc_signed&    v);
+  friend sc_signed operator ^ (const sc_signed&    u, int64               v);
+  friend sc_signed operator ^ (const sc_signed&    u, uint64              v);
+  friend sc_signed operator ^ (const sc_signed&    u, long                v);
+  friend sc_signed operator ^ (const sc_signed&    u, unsigned long       v);
+  friend sc_signed operator ^ (const sc_signed&    u, int                 v)
+    { return operator^(u, (long) v); }
+  friend sc_signed operator ^ (const sc_signed&    u, unsigned int        v)
+    { return operator^(u, (unsigned long) v); }
+
+  friend sc_signed operator ^ (int64             u, const sc_signed&  v);
+  friend sc_signed operator ^ (uint64            u, const sc_signed&  v);
+  friend sc_signed operator ^ (long              u, const sc_signed&  v);
+  friend sc_signed operator ^ (unsigned long     u, const sc_signed&  v);
+  friend sc_signed operator ^ (int               u, const sc_signed&  v)
+    { return operator^((long) u, v); }
+  friend sc_signed operator ^ (unsigned int      u, const sc_signed&  v)
+    { return operator^((unsigned long) u, v); }
+
+  const sc_signed& operator ^= (const sc_signed&    v);
+  const sc_signed& operator ^= (const sc_unsigned&  v);
+  const sc_signed& operator ^= (int64               v);
+  const sc_signed& operator ^= (uint64              v);
+  const sc_signed& operator ^= (long                v);
+  const sc_signed& operator ^= (unsigned long       v);
+  const sc_signed& operator ^= (int                 v)
+    { return operator^=((long) v); }
+  const sc_signed& operator ^= (unsigned int        v)
+    { return operator^=((unsigned long) v); }
+
+  friend sc_signed operator ^ (const sc_unsigned&  u, const sc_int_base&  v);
+  friend sc_signed operator ^ (const sc_int_base&  u, const sc_unsigned&  v);
+  friend sc_signed operator ^ (const sc_signed&    u, const sc_int_base&  v);
+  friend sc_signed operator ^ (const sc_signed&    u, const sc_uint_base& v);
+  friend sc_signed operator ^ (const sc_int_base&  u, const sc_signed&    v);
+  friend sc_signed operator ^ (const sc_uint_base& u, const sc_signed&    v);
+  const sc_signed& operator ^= (const sc_int_base&  v);
+  const sc_signed& operator ^= (const sc_uint_base& v);
+
+  // SHIFT OPERATORS:
+
+  // LEFT SHIFT operators:
+
+  friend sc_unsigned operator << (const sc_unsigned&  u, const sc_signed&    v);
+  friend   sc_signed operator << (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend   sc_signed operator << (const sc_signed&    u, const sc_signed&    v);
+  friend   sc_signed operator << (const sc_signed&    u, int64               v);
+  friend   sc_signed operator << (const sc_signed&    u, uint64              v);
+  friend   sc_signed operator << (const sc_signed&    u, long                v);
+  friend   sc_signed operator << (const sc_signed&    u, unsigned long       v);
+  friend   sc_signed operator << (const sc_signed&    u, int                 v)
+    { return operator<<(u, (long) v); }
+  friend   sc_signed operator << (const sc_signed&    u, unsigned int        v)
+    { return operator<<(u, (unsigned long) v); }
+
+  const sc_signed& operator <<= (const sc_signed&    v);
+  const sc_signed& operator <<= (const sc_unsigned&  v);
+  const sc_signed& operator <<= (int64               v);
+  const sc_signed& operator <<= (uint64              v);
+  const sc_signed& operator <<= (long                v);
+  const sc_signed& operator <<= (unsigned long       v);
+  const sc_signed& operator <<= (int                 v)
+    { return operator<<=((long) v); }
+  const sc_signed& operator <<= (unsigned int        v)
+    { return operator<<=((unsigned long) v); }
+
+  friend   sc_signed operator << (const sc_signed&    u, const sc_int_base&  v);
+  friend   sc_signed operator << (const sc_signed&    u, const sc_uint_base& v);
+  const sc_signed& operator <<= (const sc_int_base&  v);
+  const sc_signed& operator <<= (const sc_uint_base& v);
+
+  // RIGHT SHIFT operators:
+
+  friend sc_unsigned operator >> (const sc_unsigned&  u, const sc_signed&    v);
+  friend   sc_signed operator >> (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend   sc_signed operator >> (const sc_signed&    u, const sc_signed&    v);
+  friend   sc_signed operator >> (const sc_signed&    u, int64               v);
+  friend   sc_signed operator >> (const sc_signed&    u, uint64              v);
+  friend   sc_signed operator >> (const sc_signed&    u, long                v);
+  friend   sc_signed operator >> (const sc_signed&    u, unsigned long       v);
+  friend   sc_signed operator >> (const sc_signed&    u, int                 v)
+    { return operator>>(u, (long) v); }
+  friend   sc_signed operator >> (const sc_signed&    u, unsigned int        v)
+    { return operator>>(u, (unsigned long) v); }
+
+  const sc_signed& operator >>= (const sc_signed&    v);
+  const sc_signed& operator >>= (const sc_unsigned&  v);
+  const sc_signed& operator >>= (int64               v);
+  const sc_signed& operator >>= (uint64              v);
+  const sc_signed& operator >>= (long                v);
+  const sc_signed& operator >>= (unsigned long       v);
+  const sc_signed& operator >>= (int                 v)
+    { return operator>>=((long) v); }
+  const sc_signed& operator >>= (unsigned int        v)
+    { return operator>>=((unsigned long) v); }
+
+  friend sc_signed operator >> (const sc_signed&    u, const sc_int_base&  v);
+  friend sc_signed operator >> (const sc_signed&    u, const sc_uint_base& v);
+  const sc_signed& operator >>= (const sc_int_base&  v);
+  const sc_signed& operator >>= (const sc_uint_base& v);
+
+  // Unary arithmetic operators
+  friend sc_signed operator + (const sc_signed&   u);
+  friend sc_signed operator - (const sc_signed&   u);
+  friend sc_signed operator - (const sc_unsigned& u);
+
+  // LOGICAL OPERATORS:
+
+  // Logical EQUAL operators:
+
+  friend bool operator == (const sc_unsigned&  u, const sc_signed&    v);
+  friend bool operator == (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend bool operator == (const sc_signed&    u, const sc_signed&    v);
+  friend bool operator == (const sc_signed&    u, int64               v);
+  friend bool operator == (const sc_signed&    u, uint64              v);
+  friend bool operator == (const sc_signed&    u, long                v);
+  friend bool operator == (const sc_signed&    u, unsigned long       v);
+  friend bool operator == (const sc_signed&    u, int                 v)
+    { return operator==(u, (long) v); }
+  friend bool operator == (const sc_signed&    u, unsigned int        v)
+    { return operator==(u, (unsigned long) v); }
+
+  friend bool operator == (int64               u, const sc_signed&    v);
+  friend bool operator == (uint64              u, const sc_signed&    v);
+  friend bool operator == (long                u, const sc_signed&    v);
+  friend bool operator == (unsigned long       u, const sc_signed&    v);
+  friend bool operator == (int                 u, const sc_signed&    v)
+    { return operator==((long) u, v); }
+  friend bool operator == (unsigned int        u, const sc_signed&    v)
+    { return operator==((unsigned long) u, v); }
+
+  friend bool operator == (const sc_signed&    u, const sc_int_base&  v);
+  friend bool operator == (const sc_signed&    u, const sc_uint_base& v);
+  friend bool operator == (const sc_int_base&  u, const sc_signed&    v);
+  friend bool operator == (const sc_uint_base& u, const sc_signed&    v);
+
+  // Logical NOT_EQUAL operators:
+
+  friend bool operator != (const sc_unsigned&  u, const sc_signed&    v);
+  friend bool operator != (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend bool operator != (const sc_signed&    u, const sc_signed&    v);
+  friend bool operator != (const sc_signed&    u, int64               v);
+  friend bool operator != (const sc_signed&    u, uint64              v);
+  friend bool operator != (const sc_signed&    u, long                v);
+  friend bool operator != (const sc_signed&    u, unsigned long       v);
+  friend bool operator != (const sc_signed&    u, int                 v)
+    { return operator!=(u, (long) v); }
+  friend bool operator != (const sc_signed&    u, unsigned int        v)
+    { return operator!=(u, (unsigned long) v); }
+
+  friend bool operator != (int64               u, const sc_signed&    v);
+  friend bool operator != (uint64              u, const sc_signed&    v);
+  friend bool operator != (long                u, const sc_signed&    v);
+  friend bool operator != (unsigned long       u, const sc_signed&    v);
+  friend bool operator != (int                 u, const sc_signed&    v)
+    { return operator!=((long) u, v); }
+  friend bool operator != (unsigned int        u, const sc_signed&    v)
+    { return operator!=((unsigned long) u, v); }
+
+  friend bool operator != (const sc_signed&    u, const sc_int_base&  v);
+  friend bool operator != (const sc_signed&    u, const sc_uint_base& v);
+  friend bool operator != (const sc_int_base&  u, const sc_signed&    v);
+  friend bool operator != (const sc_uint_base& u, const sc_signed&    v);
+
+  // Logical LESS_THAN operators:
+
+  friend bool operator < (const sc_unsigned&  u, const sc_signed&    v);
+  friend bool operator < (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend bool operator < (const sc_signed&    u, const sc_signed&    v);
+  friend bool operator < (const sc_signed&    u, int64               v);
+  friend bool operator < (const sc_signed&    u, uint64              v);
+  friend bool operator < (const sc_signed&    u, long                v);
+  friend bool operator < (const sc_signed&    u, unsigned long       v);
+  friend bool operator < (const sc_signed&    u, int                 v)
+    { return operator<(u, (long) v); }
+  friend bool operator < (const sc_signed&    u, unsigned int        v)
+    { return operator<(u, (unsigned long) v); }
+
+  friend bool operator < (int64               u, const sc_signed&    v);
+  friend bool operator < (uint64              u, const sc_signed&    v);
+  friend bool operator < (long                u, const sc_signed&    v);
+  friend bool operator < (unsigned long       u, const sc_signed&    v);
+  friend bool operator < (int                 u, const sc_signed&    v)
+    { return operator<((long) u, v); }
+  friend bool operator < (unsigned int        u, const sc_signed&    v)
+    { return operator<((unsigned long) u, v); }
+
+  friend bool operator < (const sc_signed&    u, const sc_int_base&  v);
+  friend bool operator < (const sc_signed&    u, const sc_uint_base& v);
+  friend bool operator < (const sc_int_base&  u, const sc_signed&    v);
+  friend bool operator < (const sc_uint_base& u, const sc_signed&    v);
+
+  // Logical LESS_THAN_AND_EQUAL operators:
+
+  friend bool operator <= (const sc_unsigned&  u, const sc_signed&    v);
+  friend bool operator <= (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend bool operator <= (const sc_signed&    u, const sc_signed&    v);
+  friend bool operator <= (const sc_signed&    u, int64               v);
+  friend bool operator <= (const sc_signed&    u, uint64              v);
+  friend bool operator <= (const sc_signed&    u, long                v);
+  friend bool operator <= (const sc_signed&    u, unsigned long       v);
+  friend bool operator <= (const sc_signed&    u, int                 v)
+    { return operator<=(u, (long) v); }
+  friend bool operator <= (const sc_signed&    u, unsigned int        v)
+    { return operator<=(u, (unsigned long) v); }
+
+  friend bool operator <= (int64               u, const sc_signed&    v);
+  friend bool operator <= (uint64              u, const sc_signed&    v);
+  friend bool operator <= (long                u, const sc_signed&    v);
+  friend bool operator <= (unsigned long       u, const sc_signed&    v);
+  friend bool operator <= (int                 u, const sc_signed&    v)
+    { return operator<=((long) u, v); }
+  friend bool operator <= (unsigned int        u, const sc_signed&    v)
+    { return operator<=((unsigned long) u, v); }
+
+  friend bool operator <= (const sc_signed&    u, const sc_int_base&  v);
+  friend bool operator <= (const sc_signed&    u, const sc_uint_base& v);
+  friend bool operator <= (const sc_int_base&  u, const sc_signed&    v);
+  friend bool operator <= (const sc_uint_base& u, const sc_signed&    v);
+
+  // Logical GREATER_THAN operators:
+
+  friend bool operator > (const sc_unsigned&  u, const sc_signed&    v);
+  friend bool operator > (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend bool operator > (const sc_signed&    u, const sc_signed&    v);
+  friend bool operator > (const sc_signed&    u, int64               v);
+  friend bool operator > (const sc_signed&    u, uint64              v);
+  friend bool operator > (const sc_signed&    u, long                v);
+  friend bool operator > (const sc_signed&    u, unsigned long       v);
+  friend bool operator > (const sc_signed&    u, int                 v)
+    { return operator>(u, (long) v); }
+  friend bool operator > (const sc_signed&    u, unsigned int        v)
+    { return operator>(u, (unsigned long) v); }
+
+  friend bool operator > (int64               u, const sc_signed&    v);
+  friend bool operator > (uint64              u, const sc_signed&    v);
+  friend bool operator > (long                u, const sc_signed&    v);
+  friend bool operator > (unsigned long       u, const sc_signed&    v);
+  friend bool operator > (int                 u, const sc_signed&    v)
+    { return operator>((long) u, v); }
+  friend bool operator > (unsigned int        u, const sc_signed&    v)
+    { return operator>((unsigned long) u, v); }
+
+  friend bool operator > (const sc_signed&    u, const sc_int_base&  v);
+  friend bool operator > (const sc_signed&    u, const sc_uint_base& v);
+  friend bool operator > (const sc_int_base&  u, const sc_signed&    v);
+  friend bool operator > (const sc_uint_base& u, const sc_signed&    v);
+
+  // Logical GREATER_THAN_AND_EQUAL operators:
+
+  friend bool operator >= (const sc_unsigned&  u, const sc_signed&    v);
+  friend bool operator >= (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend bool operator >= (const sc_signed&    u, const sc_signed&    v);
+  friend bool operator >= (const sc_signed&    u, int64               v);
+  friend bool operator >= (const sc_signed&    u, uint64              v);
+  friend bool operator >= (const sc_signed&    u, long                v);
+  friend bool operator >= (const sc_signed&    u, unsigned long       v);
+  friend bool operator >= (const sc_signed&    u, int                 v)
+    { return operator>=(u, (long) v); }
+  friend bool operator >= (const sc_signed&    u, unsigned int        v)
+    { return operator>=(u, (unsigned long) v); }
+
+  friend bool operator >= (int64               u, const sc_signed&    v);
+  friend bool operator >= (uint64              u, const sc_signed&    v);
+  friend bool operator >= (long                u, const sc_signed&    v);
+  friend bool operator >= (unsigned long       u, const sc_signed&    v);
+  friend bool operator >= (int                 u, const sc_signed&    v)
+    { return operator>=((long) u, v); }
+  friend bool operator >= (unsigned int        u, const sc_signed&    v)
+    { return operator>=((unsigned long) u, v); }
+
+  friend bool operator >= (const sc_signed&    u, const sc_int_base&  v);
+  friend bool operator >= (const sc_signed&    u, const sc_uint_base& v);
+  friend bool operator >= (const sc_int_base&  u, const sc_signed&    v);
+  friend bool operator >= (const sc_uint_base& u, const sc_signed&    v);
+
+  // Bitwise NOT operator (unary).
+  friend sc_signed operator ~ (const sc_signed& u);
+
+  // Helper functions.
+  friend sc_signed add_signed_friend(small_type us,
+                                     int unb,
+                                     int und,
+                                     const sc_digit *ud,
+                                     small_type vs,
+                                     int vnb,
+                                     int vnd,
+                                     const sc_digit *vd);
+
+  friend sc_signed sub_signed_friend(small_type us,
+                                     int unb,
+                                     int und,
+                                     const sc_digit *ud,
+                                     small_type vs,
+                                     int vnb,
+                                     int vnd,
+                                     const sc_digit *vd);
+
+  friend sc_signed mul_signed_friend(small_type s,
+                                     int unb,
+                                     int und,
+                                     const sc_digit *ud,
+                                     int vnb,
+                                     int vnd,
+                                     const sc_digit *vd);
+
+  friend sc_signed div_signed_friend(small_type s,
+                                     int unb,
+                                     int und,
+                                     const sc_digit *ud,
+                                     int vnb,
+                                     int vnd,
+                                     const sc_digit *vd);
+
+  friend sc_signed mod_signed_friend(small_type us,
+                                     int unb,
+                                     int und,
+                                     const sc_digit *ud,
+                                     int vnb,
+                                     int vnd,
+                                     const sc_digit *vd);
+
+  friend sc_signed and_signed_friend(small_type us,
+                                     int unb,
+                                     int und,
+                                     const sc_digit *ud,
+                                     small_type vs,
+                                     int vnb,
+                                     int vnd,
+                                     const sc_digit *vd);
+
+  friend sc_signed or_signed_friend(small_type us,
+                                    int unb,
+                                    int und,
+                                    const sc_digit *ud,
+                                    small_type vs,
+                                    int vnb,
+                                    int vnd,
+                                    const sc_digit *vd);
+
+  friend sc_signed xor_signed_friend(small_type us,
+                                     int unb,
+                                     int und,
+                                     const sc_digit *ud,
+                                     small_type vs,
+                                     int vnb,
+                                     int vnd,
+                                     const sc_digit *vd);
+
+private:
+
+  small_type  sgn;         // Shortened as s.
+  int nbits;       // Shortened as nb.
+  int ndigits;     // Shortened as nd.
+
+#ifdef SC_MAX_NBITS
+  sc_digit digit[DIV_CEIL(SC_MAX_NBITS)];   // Shortened as d.
+#else
+  sc_digit *digit;                       // Shortened as d.
+#endif
+
+  // Private constructors:
+
+  // Create a copy of v with sign s.
+  sc_signed(const sc_signed&   v, small_type s);
+  sc_signed(const sc_unsigned& v, small_type s);
+
+  // Create a signed number with the given attributes.
+  sc_signed(small_type s, int nb, int nd,
+            sc_digit *d, bool alloc = true);
+
+  // Create an unsigned number using the bits u[l..r].
+  sc_signed(const sc_signed* u, int l, int r);
+  sc_signed(const sc_unsigned* u, int l, int r);
+
+  // Private member functions. The called functions are inline functions.
+
+  small_type default_sign() const
+    { return SC_NOSIGN; }
+
+  int num_bits(int nb) const { return nb; }
+
+  bool check_if_outside(int bit_num) const;
+
+  void copy_digits(int nb, int nd, const sc_digit *d)
+    { copy_digits_signed(sgn, nbits, ndigits, digit, nb, nd, d); }
+
+  void makezero()
+    { sgn = make_zero(ndigits, digit); }
+
+  // Conversion functions between 2's complement (2C) and
+  // sign-magnitude (SM):
+  void convert_2C_to_SM()
+    { sgn = convert_signed_2C_to_SM(nbits, ndigits, digit); }
+
+  void convert_SM_to_2C_to_SM()
+    { sgn = convert_signed_SM_to_2C_to_SM(sgn, nbits, ndigits, digit); }
+
+  void convert_SM_to_2C()
+    { convert_signed_SM_to_2C(sgn, ndigits, digit); }
+
+};
+
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream&, const sc_signed& );
+
+inline
+::std::istream&
+operator >> ( ::std::istream&, sc_signed& );
+
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_signed_bitref_r& a )
+{
+    a.print( os );
+    return os;
+}
+
+
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_signed_bitref& a )
+{
+    a.scan( is );
+    return is;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signed_subref_r
+//
+//  Proxy class for sc_signed part selection (r-value only).
+// ----------------------------------------------------------------------------
+
+
+// reduce methods
+
+inline bool sc_signed_subref_r::and_reduce() const
+{
+   const sc_signed* target_p = m_obj_p;
+   for ( int i = m_right; i <= m_left; i++ )
+	if ( !target_p->test(i) ) return false;
+   return true;
+}
+
+inline bool sc_signed_subref_r::nand_reduce() const
+{
+    return !and_reduce();
+}
+
+inline bool sc_signed_subref_r::or_reduce() const
+{
+   const sc_signed* target_p = m_obj_p;
+   for ( int i = m_right; i <= m_left; i++ )
+	if ( target_p->test(i) ) return true;
+   return false;
+}
+
+inline bool sc_signed_subref_r::nor_reduce() const
+{
+    return !or_reduce();
+}
+
+inline bool sc_signed_subref_r::xor_reduce() const
+{
+   int                odd;
+   const sc_signed* target_p = m_obj_p;
+   odd = 0;
+   for ( int i = m_right; i <= m_left; i++ )
+	if ( target_p->test(i) ) odd = ~odd;
+   return odd ? true : false;
+}
+
+inline bool sc_signed_subref_r::xnor_reduce() const
+{
+    return !xor_reduce();
+}
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_signed_subref_r& a )
+{
+    a.print( os );
+    return os;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signed_subref
+//
+//  Proxy class for sc_signed part selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+// assignment operators
+
+inline
+const sc_signed_subref&
+sc_signed_subref::operator = ( const char* a )
+{
+    sc_signed aa( length() );
+    return ( *this = aa = a );
+}
+
+
+
+
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_signed_subref& a )
+{
+    a.scan( is );
+    return is;
+}
+
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signed
+//
+//  Arbitrary precision signed number.
+// ----------------------------------------------------------------------------
+
+template<class T>
+sc_signed::sc_signed( const sc_generic_base<T>& v )
+{
+    int nb = v->length();
+    sgn = default_sign();
+    if( nb > 0 ) {
+        nbits = num_bits( nb );
+    } else {
+        char msg[BUFSIZ];
+        std::sprintf( msg,
+		    "sc_unsigned( sc_generic_base<T> ) : nb = %d is not valid", nb);
+        SC_REPORT_ERROR( sc_core::SC_ID_INIT_FAILED_, msg );
+    }
+    ndigits = DIV_CEIL(nbits);
+#   ifdef SC_MAX_NBITS
+        test_bound(nb);
+#    else
+        digit = new sc_digit[ndigits];
+#    endif
+    makezero();
+    v->to_sc_signed(*this);
+}
+
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_signed& a )
+{
+    a.print( os );
+    return os;
+}
+
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_signed& a )
+{
+    a.scan( is );
+    return is;
+}
+
+
+} // namespace sc_dt
+
+
+#endif
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_signed_bitref.inc b/ext/systemc/src/sysc/datatypes/int/sc_signed_bitref.inc
new file mode 100644
index 000000000..46d347d94
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_signed_bitref.inc
@@ -0,0 +1,163 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_signed_bitref.h -- Proxy class that is declared in sc_signed.h.
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signed_bitref_r
+//
+//  Proxy class for sc_signed bit selection (r-value only).
+// ----------------------------------------------------------------------------
+
+// implicit conversion to uint64
+
+sc_signed_bitref_r::operator uint64 () const
+{
+    return m_obj_p->test( m_index );
+}
+
+bool
+sc_signed_bitref_r::operator ! () const
+{
+    return ( ! m_obj_p->test( m_index ) );
+}
+
+bool
+sc_signed_bitref_r::operator ~ () const
+{
+    return ( ! m_obj_p->test( m_index ) );
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signed_bitref
+//
+//  Proxy class for sc_signed bit selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+// assignment operators
+
+const sc_signed_bitref&
+sc_signed_bitref::operator = ( const sc_signed_bitref_r& b )
+{
+    m_obj_p->set( m_index, (bool) b );
+    return *this;
+}
+
+const sc_signed_bitref&
+sc_signed_bitref::operator = ( const sc_signed_bitref& b )
+{
+    m_obj_p->set( m_index, (bool) b );
+    return *this;
+}
+
+const sc_signed_bitref&
+sc_signed_bitref::operator = ( bool b )
+{
+    m_obj_p->set( m_index, b );
+    return *this;
+}
+
+
+const sc_signed_bitref&
+sc_signed_bitref::operator &= ( bool b )
+{
+    if( ! b ) {
+	m_obj_p->clear( m_index );
+    }
+    return *this;
+}
+
+const sc_signed_bitref&
+sc_signed_bitref::operator |= ( bool b )
+{
+    if( b ) {
+	m_obj_p->set( m_index );
+    }
+    return *this;
+}
+
+const sc_signed_bitref&
+sc_signed_bitref::operator ^= ( bool b )
+{
+    if( b ) {
+	m_obj_p->invert( m_index );
+    }
+    return *this;
+}
+
+// #### OPTIMIZE
+void sc_signed_bitref::concat_set(int64 src, int low_i)  
+{    
+	bool value = 1 & ((low_i < 64) ? (src >> low_i) : (src >> 63));
+    m_obj_p->set(low_i, value);
+}
+
+void sc_signed_bitref::concat_set(const sc_signed& src, int low_i)
+{
+    if ( low_i < src.length() )
+        m_obj_p->set(low_i, src.test(low_i));
+    else
+        m_obj_p->set(low_i, src<0);
+}       
+
+void sc_signed_bitref::concat_set(const sc_unsigned& src, int low_i)
+{
+    if ( low_i < src.length() )
+        m_obj_p->set(low_i, src.test(low_i));
+    else
+        m_obj_p->set(low_i, 0);
+}
+
+void sc_signed_bitref::concat_set(uint64 src, int low_i)
+{
+	bool value = 1 & ((low_i < 64) ? (src >> low_i) : 0);
+    m_obj_p->set(low_i, value);
+}
+
+
+// other methods
+
+void
+sc_signed_bitref::scan( ::std::istream& is )
+{
+    bool b;
+    is >> b;
+    *this = b;
+}
+
+
+// End of file
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_signed_subref.inc b/ext/systemc/src/sysc/datatypes/int/sc_signed_subref.inc
new file mode 100644
index 000000000..3f50210a7
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_signed_subref.inc
@@ -0,0 +1,408 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_signed_subref.h -- Proxy class that is declared in sc_signed.h.  
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signed_subref_r
+//
+//  Proxy class for sc_signed part selection (r-value only).
+// ----------------------------------------------------------------------------
+
+// concatenation support
+
+uint64 sc_signed_subref_r::concat_get_uint64() const 
+{
+    sc_unsigned a( m_obj_p, m_left, m_right );
+    return a.to_uint64();
+}
+
+
+bool sc_signed_subref_r::concat_get_ctrl(sc_digit* dst_p, int low_i ) const
+{
+    sc_unsigned a( m_obj_p, m_left, m_right );
+    return a.concat_get_ctrl( dst_p, low_i );
+}
+
+
+bool sc_signed_subref_r::concat_get_data(sc_digit* dst_p, int low_i ) const
+{
+    sc_unsigned a( m_obj_p, m_left, m_right );
+    return a.concat_get_data( dst_p, low_i );
+}
+
+
+// implicit conversion to sc_signed
+
+sc_signed_subref_r::operator sc_unsigned () const
+{
+    return sc_unsigned( m_obj_p, m_left, m_right );
+}
+
+
+// explicit conversions
+
+int
+sc_signed_subref_r::to_int() const
+{
+    sc_unsigned a( m_obj_p, m_left, m_right );
+    return a.to_int();
+}
+
+unsigned int
+sc_signed_subref_r::to_uint() const
+{
+    sc_unsigned a( m_obj_p, m_left, m_right );
+    return a.to_uint();
+}
+
+long
+sc_signed_subref_r::to_long() const
+{
+    sc_unsigned a( m_obj_p, m_left, m_right );
+    return a.to_long();
+}
+
+unsigned long
+sc_signed_subref_r::to_ulong() const
+{
+    sc_unsigned a( m_obj_p, m_left, m_right );
+    return a.to_ulong();
+}
+
+int64
+sc_signed_subref_r::to_int64() const
+{
+    sc_unsigned a( m_obj_p, m_left, m_right );
+    return a.to_int64();
+}
+
+uint64
+sc_signed_subref_r::to_uint64() const
+{
+    sc_unsigned a( m_obj_p, m_left, m_right );
+    return a.to_uint64();
+}
+
+double
+sc_signed_subref_r::to_double() const
+{
+    sc_unsigned a( m_obj_p, m_left, m_right );
+    return a.to_double();
+}
+
+
+// explicit conversion to character string
+
+const std::string
+sc_signed_subref_r::to_string( sc_numrep numrep ) const
+{
+    sc_unsigned a( length() );
+    a = *this;
+    return a.to_string( numrep );
+}
+
+const std::string
+sc_signed_subref_r::to_string( sc_numrep numrep, bool w_prefix ) const
+{
+    sc_unsigned a( length() );
+    a = *this;
+    return a.to_string( numrep, w_prefix );
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signed_subref
+//
+//  Proxy class for sc_signed part selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+// assignment operators
+
+const sc_signed_subref&
+sc_signed_subref::operator = ( const sc_signed_subref_r& a )
+{
+    return operator = ( (sc_unsigned)( a ) );
+}
+
+const sc_signed_subref& 
+sc_signed_subref::operator = ( const sc_signed_subref& v )
+{
+    if( this == &v ) {
+	return *this;
+    }
+    return operator = ( (sc_unsigned)( v ) ); 
+}
+
+const sc_signed_subref& 
+sc_signed_subref::operator = ( const sc_signed& v )
+{
+    int i;
+    int l = sc_min( m_left, v.nbits - 1 + m_right );
+
+    for( i = m_right; i <= l; ++ i ) m_obj_p->set( i, v.test( i - m_right ) );
+    for ( ; i <= m_left; i++ ) m_obj_p->set( i, v.test( l ) );
+
+    return *this;
+} 
+
+const sc_signed_subref& 
+sc_signed_subref::operator = ( const sc_unsigned_subref_r& v )
+{
+    return operator = ( (sc_unsigned)( v ) );
+}
+
+const sc_signed_subref& 
+sc_signed_subref::operator = ( const sc_unsigned& v )
+{
+    int i;
+    int l = sc_min( m_left, v.nbits - 1 + m_right );
+
+    for( i = m_right; i <= l; ++ i ) m_obj_p->set( i, v.test( i - m_right ) );
+    for ( ; i <= m_left; i++ ) m_obj_p->set( i, 0 );
+    return *this;
+} 
+
+const sc_signed_subref& 
+sc_signed_subref::operator = ( unsigned long v )
+{
+    for( int i = m_right; i <= m_left; ++ i ) {
+	m_obj_p->set( i, static_cast<bool>( v & 1 ) );
+	v >>= 1;
+    }
+    return *this;
+}
+
+const sc_signed_subref& 
+sc_signed_subref::operator = ( long v ) 
+{
+    unsigned long v2 = (unsigned long) v;
+    for( int i = m_right; i <= m_left; ++ i ) {
+	m_obj_p->set( i, static_cast<bool>( v2 & 1 ) );
+	v2 >>= 1;
+    }
+    return *this;
+}
+
+const sc_signed_subref& 
+sc_signed_subref::operator = ( uint64 v )
+{
+    for( int i = m_right; i <= m_left; ++ i ) {
+	m_obj_p->set( i, static_cast<bool>( v & 1 ) );
+	v >>= 1;
+    }
+    return *this;
+}
+
+const sc_signed_subref& 
+sc_signed_subref::operator = ( int64 v ) 
+{
+    uint64 v2 = (uint64) v;
+    for( int i = m_right; i <= m_left; ++ i ) {
+	m_obj_p->set( i, static_cast<bool>( v2 & 1 ) );
+	v2 >>= 1;
+    }
+    return *this;
+}
+
+const sc_signed_subref& 
+sc_signed_subref::operator = ( double v )
+{
+    is_bad_double(v);
+
+    int nb = m_left - m_right + 1;
+    int nd = DIV_CEIL(nb);
+
+#ifdef SC_MAX_NBITS
+    sc_digit d[MAX_NDIGITS];
+#else
+    sc_digit *d = new sc_digit[nd];
+#endif
+
+    if (v < 0)
+	v = -v;
+
+    int i = 0;
+
+    while (floor(v) && (i < nd)) {
+#ifndef _WIN32
+	d[i++] = (sc_digit) floor(remainder(v, DIGIT_RADIX));
+#else
+	d[i++] = (sc_digit) floor(fmod(v, DIGIT_RADIX));
+#endif
+	v /= DIGIT_RADIX;
+    }
+
+    vec_zero(i, nd, d);
+
+    sc_digit val = 1;  // Bit value.
+    int j = 0;   // Current digit in d.
+
+    i = 0;  // Current bit in d.
+
+    while (i < nb) {
+
+	m_obj_p->set(i + m_right, (bool) (d[j] & val));
+
+	++i;
+
+	if (i % BITS_PER_DIGIT == 0) {
+	    val = 1;
+	    ++j;
+	}
+	else
+	    val <<= 1;
+    }
+
+#ifndef SC_MAX_NBITS
+    delete [] d;
+#endif
+
+    return *this;
+}
+
+const sc_signed_subref&
+sc_signed_subref::operator = ( const sc_int_base& a )
+{
+    return operator = ( (int64) a );
+}
+
+const sc_signed_subref&
+sc_signed_subref::operator = ( const sc_uint_base& a )
+{
+    return operator = ( (uint64) a );
+}
+
+// concatenation methods
+
+
+void sc_signed_subref::concat_set( int64 src, int low_i )
+{
+    int  i;
+    int  l;
+    bool sign = src < 0;
+
+    if ( low_i < 64 )    
+    {    
+	src = src >> low_i;
+	l = sc_min( m_left, (63-low_i) + m_right );    
+	for( i = m_right; i <= l; ++ i ) {    
+		m_obj_p->set( i, src & 1 );    
+		src = src >> 1;    
+	}    
+	for ( ; i <= m_left; i++ ) m_obj_p->set(i, sign);     
+    }    
+    else    
+    {    
+	for( i = m_right; i <= m_left; ++ i ) m_obj_p->set(i, sign);     
+    }    
+}
+
+void sc_signed_subref::concat_set( const sc_signed& src, int low_i )
+{
+    int i;
+    int l;
+    int src_i;
+    bool sign = src.test(src.nbits-1);
+    l = src.nbits - (low_i+1);
+    if ( l >= 0 )
+    {
+	l = sc_min( m_left, l + m_right );
+	src_i = low_i;
+	for( i = m_right; i <= l; ++ i, src_i++ ) {
+	    m_obj_p->set( i, src.test( src_i ) );
+	}
+	for ( ; i <= m_left; i++ ) m_obj_p->set(i, sign);
+    }
+    else
+    {    
+	for( i = m_right; i <= m_left; ++ i ) m_obj_p->set(i, sign);     
+    }    
+}
+
+void sc_signed_subref::concat_set( const sc_unsigned& src, int low_i )
+{
+    int i;
+    int l;
+    int src_i;
+    l = src.nbits - (low_i+2);
+    if ( l >= 0 )
+    {
+	l = sc_min( m_left, l + m_right );
+	src_i = low_i;
+	for( i = m_right; i <= l; ++ i, src_i++ ) {
+	    m_obj_p->set( i, src.test( src_i ) );
+	}
+	for ( ; i <= m_left; i++ ) m_obj_p->set(false);
+    }
+    else
+    {    
+	for( i = m_right; i <= m_left; ++ i ) m_obj_p->set(false);     
+    }    
+}
+
+void sc_signed_subref::concat_set( uint64 src, int low_i )
+{
+    int  i;
+    int  l;
+
+    if ( low_i < 64 )  
+    {    
+	src = src >> low_i;
+	l = sc_min( m_left, (63-low_i) + m_right );    
+	for( i = m_right; i <= l; ++ i ) {    
+		m_obj_p->set( i, src & 1 );    
+		src = src >> 1;    
+	}    
+	for ( ; i <= m_left; i++ ) m_obj_p->set(false);     
+    }    
+    else    
+    {    
+	for( i = m_right; i <= m_left; ++ i ) m_obj_p->set(false);     
+    }    
+}
+// other methods
+
+void
+sc_signed_subref::scan( ::std::istream& is )
+{
+    std::string s;
+    is >> s;
+    *this = s.c_str();
+}
+
+
+// End of file
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_uint.h b/ext/systemc/src/sysc/datatypes/int/sc_uint.h
new file mode 100644
index 000000000..90ebd7f97
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_uint.h
@@ -0,0 +1,312 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_uint.h -- A sc_uint is an unsigned integer whose length is less than the
+               machine's native integer length. We provide two implementations
+               (i) sc_uint with length between 1 - 64, and (ii) sc_uint with
+               length between 1 - 32. Implementation (i) is the default
+               implementation, while implementation (ii) can be used only if
+               compiled with -D_32BIT_. Unlike arbitrary precision, arithmetic
+               and bitwise operations are performed using the native types
+               (hence capped at 32/64 bits). The sc_uint integer is useful
+               when the user does not need arbitrary precision and the
+               performance is superior to sc_bigint/sc_biguint.
+
+  Original Author: Amit Rao, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Ali Dasdan, Synopsys, Inc.
+  Description of Modification: - Resolved ambiguity with sc_(un)signed.
+                               - Merged the code for 64- and 32-bit versions
+                                 via the constants in sc_nbdefs.h.
+                               - Eliminated redundant file inclusions.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_uint.h,v $
+// Revision 1.2  2011/02/18 20:19:15  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:49:32  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#ifndef SC_UINT_H
+#define SC_UINT_H
+
+
+#include "sysc/datatypes/int/sc_uint_base.h"
+
+
+namespace sc_dt
+{
+
+// classes defined in this module
+template <int W> class sc_uint;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_uint<W>
+//
+//  Template class sc_uint<W> is the interface that the user sees. It
+//  is derived from sc_uint_base and most of its methods are just
+//  wrappers that call the corresponding method in the parent
+//  class. Note that the length of sc_uint datatype is specified as a
+//  template parameter.
+// ----------------------------------------------------------------------------
+
+template <int W>
+class sc_uint
+    : public sc_uint_base
+{
+public:
+
+    // constructors
+
+    sc_uint()
+	: sc_uint_base( W )
+	{}
+
+    sc_uint( uint_type v )
+	: sc_uint_base( v, W )
+	{}
+
+    sc_uint( const sc_uint<W>& a )
+	: sc_uint_base( a )
+	{}
+
+    sc_uint( const sc_uint_base& a )
+	: sc_uint_base( W )
+	{ sc_uint_base::operator = ( a ); }
+
+    sc_uint( const sc_uint_subref_r& a )
+	: sc_uint_base( W )
+	{ sc_uint_base::operator = ( a ); }
+
+    template< class T >
+    sc_uint( const sc_generic_base<T>& a )
+	: sc_uint_base( W )
+	{ sc_uint_base::operator = ( a ); }
+
+    sc_uint( const sc_signed& a )
+	: sc_uint_base( W )
+	{ sc_uint_base::operator = ( a ); }
+
+    sc_uint( const sc_unsigned& a )
+	: sc_uint_base( W )
+	{ sc_uint_base::operator = ( a ); }
+
+#ifdef SC_INCLUDE_FX
+
+    explicit sc_uint( const sc_fxval& a )
+	: sc_uint_base( W )
+	{ sc_uint_base::operator = ( a ); }
+
+    explicit sc_uint( const sc_fxval_fast& a )
+	: sc_uint_base( W )
+	{ sc_uint_base::operator = ( a ); }
+
+    explicit sc_uint( const sc_fxnum& a )
+	: sc_uint_base( W )
+	{ sc_uint_base::operator = ( a ); }
+
+    explicit sc_uint( const sc_fxnum_fast& a )
+	: sc_uint_base( W )
+	{ sc_uint_base::operator = ( a ); }
+
+#endif
+
+    sc_uint( const sc_bv_base& a )
+	: sc_uint_base( W )
+	{ sc_uint_base::operator = ( a ); }
+
+    sc_uint( const sc_lv_base& a )
+	: sc_uint_base( W )
+	{ sc_uint_base::operator = ( a ); }
+
+    sc_uint( const char* a )
+	: sc_uint_base( W )
+	{ sc_uint_base::operator = ( a ); }
+
+    sc_uint( unsigned long a )
+	: sc_uint_base( W )
+	{ sc_uint_base::operator = ( a ); }
+
+    sc_uint( long a )
+	: sc_uint_base( W )
+	{ sc_uint_base::operator = ( a ); }
+
+    sc_uint( unsigned int a )
+	: sc_uint_base( W )
+	{ sc_uint_base::operator = ( a ); }
+
+    sc_uint( int a )
+	: sc_uint_base( W )
+	{ sc_uint_base::operator = ( a ); }
+
+    sc_uint( int64 a )
+	: sc_uint_base( W )
+	{ sc_uint_base::operator = ( a ); }
+
+    sc_uint( double a )
+	: sc_uint_base( W )
+	{ sc_uint_base::operator = ( a ); }
+
+
+    // assignment operators
+
+    sc_uint<W>& operator = ( uint_type v )
+	{ sc_uint_base::operator = ( v ); return *this; }
+
+    sc_uint<W>& operator = ( const sc_uint_base& a )
+	{ sc_uint_base::operator = ( a ); return *this; }
+
+    sc_uint<W>& operator = ( const sc_uint_subref_r& a )
+	{ sc_uint_base::operator = ( a ); return *this; }
+
+    sc_uint<W>& operator = ( const sc_uint<W>& a )
+	{ m_val = a.m_val; return *this; }
+
+    template<class T>
+    sc_uint<W>& operator = ( const sc_generic_base<T>& a )
+	{ sc_uint_base::operator = ( a ); return *this; }
+
+    sc_uint<W>& operator = ( const sc_signed& a )
+	{ sc_uint_base::operator = ( a ); return *this; }
+
+    sc_uint<W>& operator = ( const sc_unsigned& a )
+	{ sc_uint_base::operator = ( a ); return *this; }
+
+#ifdef SC_INCLUDE_FX
+
+    sc_uint<W>& operator = ( const sc_fxval& a )
+	{ sc_uint_base::operator = ( a ); return *this; }
+
+    sc_uint<W>& operator = ( const sc_fxval_fast& a )
+	{ sc_uint_base::operator = ( a ); return *this; }
+
+    sc_uint<W>& operator = ( const sc_fxnum& a )
+	{ sc_uint_base::operator = ( a ); return *this; }
+
+    sc_uint<W>& operator = ( const sc_fxnum_fast& a )
+	{ sc_uint_base::operator = ( a ); return *this; }
+
+#endif
+
+    sc_uint<W>& operator = ( const sc_bv_base& a )
+	{ sc_uint_base::operator = ( a ); return *this; }
+
+    sc_uint<W>& operator = ( const sc_lv_base& a )
+	{ sc_uint_base::operator = ( a ); return *this; }
+
+    sc_uint<W>& operator = ( const char* a )
+	{ sc_uint_base::operator = ( a ); return *this; }
+
+    sc_uint<W>& operator = ( unsigned long a )
+	{ sc_uint_base::operator = ( a ); return *this; }
+
+    sc_uint<W>& operator = ( long a )
+	{ sc_uint_base::operator = ( a ); return *this; }
+
+    sc_uint<W>& operator = ( unsigned int a )
+	{ sc_uint_base::operator = ( a ); return *this; }
+
+    sc_uint<W>& operator = ( int a )
+	{ sc_uint_base::operator = ( a ); return *this; }
+
+    sc_uint<W>& operator = ( int64 a )
+	{ sc_uint_base::operator = ( a ); return *this; }
+
+    sc_uint<W>& operator = ( double a )
+	{ sc_uint_base::operator = ( a ); return *this; }
+
+
+    // arithmetic assignment operators
+
+    sc_uint<W>& operator += ( uint_type v )
+	{ sc_uint_base::operator += ( v ); return *this; }
+
+    sc_uint<W>& operator -= ( uint_type v )
+	{ sc_uint_base::operator -= ( v ); return *this; }
+
+    sc_uint<W>& operator *= ( uint_type v )
+	{ sc_uint_base::operator *= ( v ); return *this; }
+
+    sc_uint<W>& operator /= ( uint_type v )
+	{ sc_uint_base::operator /= ( v ); return *this; }
+
+    sc_uint<W>& operator %= ( uint_type v )
+	{ sc_uint_base::operator %= ( v ); return *this; }
+
+  
+    // bitwise assignment operators
+
+    sc_uint<W>& operator &= ( uint_type v )
+	{ sc_uint_base::operator &= ( v ); return *this; }
+
+    sc_uint<W>& operator |= ( uint_type v )
+	{ sc_uint_base::operator |= ( v ); return *this; }
+
+    sc_uint<W>& operator ^= ( uint_type v )
+	{ sc_uint_base::operator ^= ( v ); return *this; }
+
+
+    sc_uint<W>& operator <<= ( uint_type v )
+	{ sc_uint_base::operator <<= ( v ); return *this; }
+
+    sc_uint<W>& operator >>= ( uint_type v )
+	{ sc_uint_base::operator >>= ( v ); return *this; }
+
+
+    // prefix and postfix increment and decrement operators
+
+    sc_uint<W>& operator ++ () // prefix
+	{ sc_uint_base::operator ++ (); return *this; }
+
+    const sc_uint<W> operator ++ ( int ) // postfix
+	{ return sc_uint<W>( sc_uint_base::operator ++ ( 0 ) ); }
+
+    sc_uint<W>& operator -- () // prefix
+	{ sc_uint_base::operator -- (); return *this; }
+
+    const sc_uint<W> operator -- ( int ) // postfix
+	{ return sc_uint<W>( sc_uint_base::operator -- ( 0 ) ); }
+};
+
+} // namespace sc_dt
+
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_uint_base.cpp b/ext/systemc/src/sysc/datatypes/int/sc_uint_base.cpp
new file mode 100644
index 000000000..e3a12e4e0
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_uint_base.cpp
@@ -0,0 +1,727 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_uint_base.cpp -- contains interface definitions between sc_uint and
+                 sc_signed, sc_unsigned, and definitions for sc_uint_subref.
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_uint_base.cpp,v $
+// Revision 1.5  2011/02/18 20:19:15  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.4  2010/02/04 22:23:29  acg
+//  Andy Goodrich: fixed bug in concatenation reads for part selections,
+//  the mask being used was 32 bits and should have been 64 bits.
+//
+// Revision 1.3  2008/06/19 17:47:57  acg
+//  Andy Goodrich: fixes for bugs. See 2.2.1 RELEASENOTES.
+//
+// Revision 1.2  2007/11/04 21:27:00  acg
+//  Andy Goodrich: changes to make sure the proper value is returned from
+//  concat_get_data().
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:49:32  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#include "sysc/kernel/sc_macros.h"
+#include "sysc/datatypes/int/sc_signed.h"
+#include "sysc/datatypes/int/sc_unsigned.h"
+#include "sysc/datatypes/int/sc_uint_base.h"
+#include "sysc/datatypes/int/sc_int_ids.h"
+#include "sysc/datatypes/bit/sc_bv_base.h"
+#include "sysc/datatypes/bit/sc_lv_base.h"
+#include "sysc/datatypes/misc/sc_concatref.h"
+#include "sysc/datatypes/fx/sc_ufix.h"
+#include "sysc/datatypes/fx/scfx_other_defs.h"
+
+
+namespace sc_dt
+{
+
+// to avoid code bloat in sc_uint_concat<T1,T2>
+
+void
+sc_uint_concref_invalid_length( int length )
+{
+    char msg[BUFSIZ];
+    std::sprintf( msg,
+	     "sc_uint_concref<T1,T2> initialization: length = %d "
+	     "violates 1 <= length <= %d",
+	     length, SC_INTWIDTH );
+    SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
+}
+
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_uint_bitref
+//
+//  Proxy class for sc_uint bit selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+sc_core::sc_vpool<sc_uint_bitref> sc_uint_bitref::m_pool(9);
+
+// concatenation methods:
+
+// #### OPTIMIZE
+void sc_uint_bitref::concat_set(int64 src, int low_i)
+{   
+    sc_uint_base aa( 1 );
+    *this = aa = (low_i < 64) ? src >> low_i : src >> 63;
+}
+
+void sc_uint_bitref::concat_set(const sc_signed& src, int low_i)
+{
+    sc_uint_base aa( 1 );     
+    if ( low_i < src.length() )
+        *this = aa = 1 & (src >> low_i);      
+    else
+        *this = aa = (src < 0) ? (int_type)-1 : 0;
+}
+
+void sc_uint_bitref::concat_set(const sc_unsigned& src, int low_i)
+{
+    sc_uint_base aa( 1 );
+    if ( low_i < src.length() )
+        *this = aa = 1 & (src >> low_i);
+    else
+        *this = aa = 0;
+}
+
+void sc_uint_bitref::concat_set(uint64 src, int low_i)
+{
+    sc_uint_base aa( 1 );
+    *this = aa = (low_i < 64) ? src >> low_i : 0;
+}
+
+
+// other methods
+
+void
+sc_uint_bitref::scan( ::std::istream& is )
+{
+    bool b;
+    is >> b;
+    *this = b;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_uint_subref_r
+//
+//  Proxy class for sc_uint part selection (l-value).
+// ----------------------------------------------------------------------------
+
+bool sc_uint_subref_r::concat_get_ctrl( sc_digit* dst_p, int low_i ) const
+{
+    int       dst_i;	   // Word in dst_p now processing.
+    int       end_i;	   // Highest order word in dst_p to process.
+    int       left_shift;  // Left shift for val.
+    uint_type mask;	   // Mask for bits to extract or keep.
+
+    dst_i = low_i / BITS_PER_DIGIT;
+    left_shift = low_i % BITS_PER_DIGIT;
+    end_i = (low_i + (m_left-m_right)) / BITS_PER_DIGIT; 
+
+    mask = ~(-1 << left_shift);
+    dst_p[dst_i] = (sc_digit)((dst_p[dst_i] & mask));
+
+    dst_i++;
+    for ( ; dst_i <= end_i; dst_i++ ) dst_p[dst_i] = 0;
+
+    return false;
+}
+
+bool sc_uint_subref_r::concat_get_data( sc_digit* dst_p, int low_i ) const
+{
+    int       dst_i;	   // Word in dst_p now processing.
+    int       end_i;	   // Highest order word in dst_p to process.
+    int       high_i;	   // Index of high order bit in dst_p to set.
+    int       left_shift;  // Left shift for val.
+    uint_type mask;	   // Mask for bits to extract or keep.
+    bool      result;	   // True if inserting non-zero value.
+    uint_type val;	   // Selection value extracted from m_obj_p.
+
+    dst_i = low_i / BITS_PER_DIGIT;
+    left_shift = low_i % BITS_PER_DIGIT;
+    high_i = low_i + (m_left-m_right); 
+    end_i = high_i / BITS_PER_DIGIT;
+    mask = ~mask_int[m_left][m_right];
+    val = (m_obj_p->m_val & mask) >> m_right;
+    result = val != 0;
+
+
+    // PROCESS THE FIRST WORD:
+
+    mask = ~(-1 << left_shift);
+    dst_p[dst_i] = (sc_digit)(((dst_p[dst_i] & mask)) | 
+	((val << left_shift) & DIGIT_MASK));
+
+    switch ( end_i - dst_i )
+    {
+     // BITS ARE ACROSS TWO WORDS:
+
+     case 1:
+        dst_i++;
+        val >>= (BITS_PER_DIGIT-left_shift);
+        dst_p[dst_i] = (sc_digit)val;
+        break;
+
+     // BITS ARE ACROSS THREE WORDS:
+
+     case 2:
+        dst_i++;
+        val >>= (BITS_PER_DIGIT-left_shift);
+        dst_p[dst_i++] = (sc_digit)(val & DIGIT_MASK);
+        val >>= BITS_PER_DIGIT;
+        dst_p[dst_i] = (sc_digit)val;
+        break;
+
+     // BITS ARE ACROSS THREE WORDS:
+
+     case 3:
+        dst_i++;
+        val >>= (BITS_PER_DIGIT-left_shift);
+        dst_p[dst_i++] = (sc_digit)(val & DIGIT_MASK);
+        val >>= BITS_PER_DIGIT;
+        dst_p[dst_i++] = (sc_digit)(val & DIGIT_MASK);
+        val >>= BITS_PER_DIGIT;
+        dst_p[dst_i] = (sc_digit)val;
+        break;
+    }
+    return result;
+}
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_uint_subref
+//
+//  Proxy class for sc_uint part selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+sc_core::sc_vpool<sc_uint_subref> sc_uint_subref::m_pool(9);
+
+// assignment operators
+
+sc_uint_subref& 
+sc_uint_subref::operator = ( uint_type v )
+{
+    uint_type val = m_obj_p->m_val;
+    uint_type mask = mask_int[m_left][m_right];
+    val &= mask;
+    val |= (v << m_right) & ~mask;
+    m_obj_p->m_val = val;
+    m_obj_p->extend_sign();
+    return *this;
+}
+
+sc_uint_subref&
+sc_uint_subref::operator = ( const sc_signed& a )
+{
+    sc_uint_base aa( length() );
+    return ( *this = aa = a );
+}
+
+sc_uint_subref&
+sc_uint_subref::operator = ( const sc_unsigned& a )
+{
+    sc_uint_base aa( length() );
+    return ( *this = aa = a );
+}
+
+sc_uint_subref&
+sc_uint_subref::operator = ( const sc_bv_base& a )
+{
+    sc_uint_base aa( length() );
+    return ( *this = aa = a );
+}
+
+sc_uint_subref&
+sc_uint_subref::operator = ( const sc_lv_base& a )
+{
+    sc_uint_base aa( length() );
+    return ( *this = aa = a );
+}
+
+// concatenation methods:
+
+// #### OPTIMIZE
+void sc_uint_subref::concat_set(int64 src, int low_i)
+{
+    sc_uint_base aa( length() );
+    *this = aa = (low_i < 64) ? src >> low_i : src >> 63;
+}
+
+void sc_uint_subref::concat_set(const sc_signed& src, int low_i)   
+{
+    sc_uint_base aa( length() );   
+    if ( low_i < src.length() )
+        *this = aa = src >> low_i;
+    else
+        *this = aa = (src < 0) ? (int_type)-1 : 0;
+}
+
+void sc_uint_subref::concat_set(const sc_unsigned& src, int low_i)   
+{
+    sc_uint_base aa( length() );
+    if ( low_i < src.length() )
+        *this = aa = src >> low_i;
+    else
+        *this = aa = 0;
+} 
+
+void sc_uint_subref::concat_set(uint64 src, int low_i)   
+{      
+    sc_uint_base aa( length() );
+    *this = aa = (low_i < 64) ? src >> low_i : 0;
+}
+
+// other methods
+
+void
+sc_uint_subref::scan( ::std::istream& is )
+{
+    std::string s;
+    is >> s;
+    *this = s.c_str();
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_uint_base
+//
+//  Base class for sc_uint.
+// ----------------------------------------------------------------------------
+
+// support methods
+
+void
+sc_uint_base::invalid_length() const
+{
+    char msg[BUFSIZ];
+    std::sprintf( msg,
+	     "sc_uint[_base] initialization: length = %d violates "
+	     "1 <= length <= %d",
+	     m_len, SC_INTWIDTH );
+    SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
+}
+
+void
+sc_uint_base::invalid_index( int i ) const
+{
+    char msg[BUFSIZ];
+    std::sprintf( msg,
+	     "sc_uint[_base] bit selection: index = %d violates "
+	     "0 <= index <= %d",
+	     i, m_len - 1 );
+    SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
+}
+
+void
+sc_uint_base::invalid_range( int l, int r ) const
+{
+    char msg[BUFSIZ];
+    std::sprintf( msg,
+	     "sc_uint[_base] part selection: left = %d, right = %d violates "
+	     "%d >= left >= right >= 0",
+	     l, r, m_len - 1 );
+    SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
+}
+
+
+void
+sc_uint_base::check_value() const
+{
+    uint_type limit = (~UINT_ZERO >> m_ulen);
+    if( m_val > limit ) {
+	char msg[BUFSIZ];
+	std::sprintf( msg, "sc_uint[_base]: value does not fit into a length of %d",
+		 m_len );
+	SC_REPORT_WARNING( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
+    }
+}
+
+
+// constructors
+
+sc_uint_base::sc_uint_base( const sc_bv_base& v ) 
+    : m_val(0), m_len( v.length() ), m_ulen( SC_INTWIDTH - m_len )
+{
+    check_length();
+    *this = v;
+}
+sc_uint_base::sc_uint_base( const sc_lv_base& v )
+    : m_val(0), m_len( v.length() ), m_ulen( SC_INTWIDTH - m_len )
+{
+    check_length();
+    *this = v;
+}
+sc_uint_base::sc_uint_base( const sc_int_subref_r& v )
+    : m_val(0), m_len( v.length() ), m_ulen( SC_INTWIDTH - m_len )
+{
+    check_length();
+    *this = v.to_uint64();
+}
+sc_uint_base::sc_uint_base( const sc_signed_subref_r& v )
+    : m_val(0), m_len( v.length() ), m_ulen( SC_INTWIDTH - m_len )
+{
+    check_length();
+    *this = v.to_uint64();
+}
+sc_uint_base::sc_uint_base( const sc_unsigned_subref_r& v )
+    : m_val(0), m_len( v.length() ), m_ulen( SC_INTWIDTH - m_len )
+{
+    check_length();
+    *this = v.to_uint64();
+}
+
+sc_uint_base::sc_uint_base( const sc_signed& a )
+    : m_val( 0 ), m_len( a.length() ), m_ulen( SC_INTWIDTH - m_len )
+{
+    check_length();
+#if 0
+    for( int i = m_len - 1; i >= 0; -- i ) {
+	set( i, a.test( i ) );
+    }
+    extend_sign();
+#else
+    *this = a.to_uint64();
+#endif
+}
+
+sc_uint_base::sc_uint_base( const sc_unsigned& a )
+    : m_val( 0 ), m_len( a.length() ), m_ulen( SC_INTWIDTH - m_len )
+{
+    check_length();
+#if 0
+    for( int i = m_len - 1; i >= 0; -- i ) {
+	set( i, a.test( i ) );
+    }
+    extend_sign();
+#else
+    *this = a.to_uint64();
+#endif
+}
+
+// assignment operators
+
+sc_uint_base&
+sc_uint_base::operator = ( const sc_signed& a )
+{
+    int minlen = sc_min( m_len, a.length() );
+    int i = 0;
+    for( ; i < minlen; ++ i ) {
+	set( i, a.test( i ) );
+    }
+    bool sgn = a.sign();
+    for( ; i < m_len; ++ i ) {
+	// sign extension
+	set( i, sgn );
+    }
+    extend_sign();
+    return *this;
+}
+
+sc_uint_base& 
+sc_uint_base::operator = ( const sc_unsigned& a )
+{
+    int minlen = sc_min( m_len, a.length() );
+    int i = 0;
+    for( ; i < minlen; ++ i ) {
+	set( i, a.test( i ) );
+    }
+    for( ; i < m_len; ++ i ) {
+	// zero extension
+	set( i, 0 );
+    }
+    extend_sign();
+    return *this;
+}
+
+
+sc_uint_base&
+sc_uint_base::operator = ( const sc_bv_base& a )
+{
+    int minlen = sc_min( m_len, a.length() );
+    int i = 0;
+    for( ; i < minlen; ++ i ) {
+	set( i, a.get_bit( i ) );
+    }
+    for( ; i < m_len; ++ i ) {
+	// zero extension
+	set( i, 0 );
+    }
+    extend_sign();
+    return *this;
+}
+
+sc_uint_base&
+sc_uint_base::operator = ( const sc_lv_base& a )
+{
+    int minlen = sc_min( m_len, a.length() );
+    int i = 0;
+    for( ; i < minlen; ++ i ) {
+	set( i, sc_logic( a.get_bit( i ) ).to_bool() );
+    }
+    for( ; i < m_len; ++ i ) {
+	// zero extension
+	set( i, 0 );
+    }
+    extend_sign();
+    return *this;
+}
+
+sc_uint_base&
+sc_uint_base::operator = ( const char* a )
+{
+    if( a == 0 ) {
+	SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_,
+			 "character string is zero" );
+    }
+    if( *a == 0 ) {
+	SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_,
+			 "character string is empty" );
+    }
+    try {
+	int len = m_len;
+	sc_ufix aa( a, len, len, SC_TRN, SC_WRAP, 0, SC_ON );
+	return this->operator = ( aa );
+    } catch( sc_core::sc_report ) {
+	char msg[BUFSIZ];
+	std::sprintf( msg, "character string '%s' is not valid", a );
+	SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_, msg );
+	// never reached
+	return *this;
+    }
+}
+
+
+// explicit conversion to character string
+
+const std::string
+sc_uint_base::to_string( sc_numrep numrep ) const
+{
+    int len = m_len;
+    sc_ufix aa( *this, len, len, SC_TRN, SC_WRAP, 0, SC_ON );
+    return aa.to_string( numrep );
+}
+
+const std::string
+sc_uint_base::to_string( sc_numrep numrep, bool w_prefix ) const
+{
+    int len = m_len;
+    sc_ufix aa( *this, len, len, SC_TRN, SC_WRAP, 0, SC_ON );
+    return aa.to_string( numrep, w_prefix );
+}
+
+
+// reduce methods
+
+bool
+sc_uint_base::and_reduce() const
+{
+    return ( m_val == (~UINT_ZERO >> m_ulen) );
+}
+
+bool
+sc_uint_base::or_reduce() const
+{
+    return ( m_val != uint_type( 0 ) );
+}
+
+bool
+sc_uint_base::xor_reduce() const
+{
+    uint_type mask = ~UINT_ZERO;
+    uint_type val = m_val;
+    int n = SC_INTWIDTH;
+    do {
+	n >>= 1;
+	mask >>= n;
+	val = ((val & (mask << n)) >> n) ^ (val & mask);
+    } while( n != 1 );
+    return ( val != uint_type( 0 ) );
+}
+
+
+bool sc_uint_base::concat_get_ctrl( sc_digit* dst_p, int low_i ) const
+{    
+    int       dst_i;       // Word in dst_p now processing.
+    int       end_i;       // Highest order word in dst_p to process.
+    int       left_shift;  // Left shift for val.
+    uint_type mask;        // Mask for bits to extract or keep.
+
+    dst_i = low_i / BITS_PER_DIGIT;
+    left_shift = low_i % BITS_PER_DIGIT;
+    end_i = (low_i + (m_len-1)) / BITS_PER_DIGIT;
+
+    // PROCESS THE FIRST WORD:
+
+    mask = ~((uint_type)-1 << left_shift);
+    dst_p[dst_i] = (sc_digit)((dst_p[dst_i] & mask));
+
+    dst_i++;
+    for ( ; dst_i <= end_i; dst_i++ ) dst_p[dst_i] = 0;
+    return false;
+}
+
+//------------------------------------------------------------------------------
+//"sc_uint_base::concat_get_data"
+//
+// This method transfers the value of this object instance to the supplied
+// array of sc_unsigned digits starting with the bit specified by low_i within
+// the array of digits.
+//
+// Notes:
+//   (1) we don't worry about masking the high order data we transfer since
+//       concat_get_data() is called from low order bit to high order bit. So
+//       the bits above where we place ours will be filled in by someone else.
+//
+//   dst_p -> array of sc_unsigned digits to be filled in.
+//   low_i =  first bit within dst_p to be set.
+//------------------------------------------------------------------------------
+bool sc_uint_base::concat_get_data( sc_digit* dst_p, int low_i ) const
+{    
+    int       dst_i;       // Word in dst_p now processing.
+    int       end_i;       // Highest order word in dst_p to process.
+    int       high_i;      // Index of high order bit in dst_p to set.
+    int       left_shift;  // Left shift for val.
+    uint_type mask;        // Mask for bits to extract or keep.
+    bool      result;	   // True if inserting non-zero value.
+    uint_type val;         // Value for this object.
+
+    dst_i = low_i / BITS_PER_DIGIT;
+    left_shift = low_i % BITS_PER_DIGIT;
+    high_i = low_i + (m_len-1);
+    end_i = high_i / BITS_PER_DIGIT;
+    val = m_val;
+    result = val != 0;
+
+    // MASK OFF DATA TO BE TRANSFERRED BASE ON WIDTH:
+
+    if ( m_len < 64 )
+    {
+	mask = ~((uint_type)-1 << m_len);
+        val &=  mask;
+    }
+
+    // PROCESS THE FIRST WORD:
+
+    mask = ~((uint_type)-1 << left_shift);
+    dst_p[dst_i] = (sc_digit)(((dst_p[dst_i] & mask)) | 
+	((val << left_shift) & DIGIT_MASK));
+
+    switch ( end_i - dst_i )
+    {
+     // BITS ARE ACROSS TWO WORDS:
+
+     case 1:
+	dst_i++;
+	val >>= (BITS_PER_DIGIT-left_shift);
+	dst_p[dst_i] = (sc_digit)val;
+	break;
+
+     // BITS ARE ACROSS THREE WORDS:
+
+     case 2:
+	dst_i++;
+	val >>= (BITS_PER_DIGIT-left_shift);
+	dst_p[dst_i++] = (sc_digit)(val & DIGIT_MASK);
+	val >>= BITS_PER_DIGIT;
+	dst_p[dst_i] = (sc_digit)val;
+	break;
+
+     // BITS ARE ACROSS FOUR WORDS:
+
+     case 3:
+        dst_i++;
+        val >>= (BITS_PER_DIGIT-left_shift);
+        dst_p[dst_i++] = (sc_digit)(val & DIGIT_MASK);
+        val >>= BITS_PER_DIGIT;
+        dst_p[dst_i++] = (sc_digit)(val & DIGIT_MASK);
+        val >>= BITS_PER_DIGIT;
+        dst_p[dst_i] = (sc_digit)val;
+        break;
+
+    }
+    return result;
+}
+
+// #### OPTIMIZE
+void sc_uint_base::concat_set(int64 src, int low_i)
+{
+    *this = (low_i < 64) ? src >> low_i : src >> 63;
+}
+
+void sc_uint_base::concat_set(const sc_signed& src, int low_i)
+{
+    if ( low_i < src.length() )
+        *this = src >> low_i;                             
+    else
+        *this = (src < 0) ? (int_type)-1 : 0; 
+}
+
+void sc_uint_base::concat_set(const sc_unsigned& src, int low_i)
+{
+    if ( low_i < src.length() )
+        *this = src >> low_i;
+    else
+        *this = 0;
+}
+
+void sc_uint_base::concat_set(uint64 src, int low_i)
+{
+    *this = (low_i < 64) ? src >> low_i : 0;
+}
+
+
+// other methods
+
+void
+sc_uint_base::scan( ::std::istream& is )
+{
+    std::string s;
+    is >> s;
+    *this = s.c_str();
+}
+
+} // namespace sc_dt
+
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_uint_base.h b/ext/systemc/src/sysc/datatypes/int/sc_uint_base.h
new file mode 100644
index 000000000..87fd92bc0
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_uint_base.h
@@ -0,0 +1,1352 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_uint_base.h -- A sc_uint is an unsigned integer whose length is less than
+               the machine's native integer length. We provide two
+               implementations (i) sc_uint with length between 1 - 64, and (ii)
+               sc_uint with length between 1 - 32. Implementation (i) is the
+               default implementation, while implementation (ii) can be used
+               only if compiled with -D_32BIT_. Unlike arbitrary precision,
+               arithmetic and bitwise operations are performed using the native
+               types (hence capped at 32/64 bits). The sc_uint integer is
+               useful when the user does not need arbitrary precision and the
+               performance is superior to sc_bigint/sc_biguint.
+
+  Original Author: Amit Rao, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Ali Dasdan, Synopsys, Inc.
+  Description of Modification: - Resolved ambiguity with sc_(un)signed.
+                               - Merged the code for 64- and 32-bit versions
+                                 via the constants in sc_nbdefs.h.
+                               - Eliminated redundant file inclusions.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_uint_base.h,v $
+// Revision 1.3  2011/08/24 22:05:46  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.2  2011/02/18 20:19:15  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.4  2006/05/08 17:50:02  acg
+//   Andy Goodrich: Added David Long's declarations for friend operators,
+//   functions, and methods, to keep the Microsoft compiler happy.
+//
+// Revision 1.3  2006/01/13 18:49:32  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#ifndef SC_UINT_BASE_H
+#define SC_UINT_BASE_H
+
+
+#include "sysc/kernel/sc_object.h"
+#include "sysc/datatypes/misc/sc_value_base.h"
+#include "sysc/datatypes/int/sc_int_ids.h"
+#include "sysc/datatypes/int/sc_length_param.h"
+#include "sysc/datatypes/int/sc_nbdefs.h"
+#include "sysc/datatypes/fx/scfx_ieee.h"
+#include "sysc/utils/sc_iostream.h"
+#include "sysc/utils/sc_temporary.h"
+
+
+namespace sc_dt
+{
+
+class sc_concatref;
+
+// classes defined in this module
+class sc_uint_bitref_r;
+class sc_uint_bitref;
+class sc_uint_subref_r;
+class sc_uint_subref;
+class sc_uint_base;
+
+// forward class declarations
+class sc_bv_base;
+class sc_lv_base;
+class sc_int_subref_r;
+class sc_signed_subref_r;
+class sc_unsigned_subref_r;
+class sc_signed;
+class sc_unsigned;
+class sc_fxval;
+class sc_fxval_fast;
+class sc_fxnum;
+class sc_fxnum_fast;
+
+
+extern const uint_type mask_int[SC_INTWIDTH][SC_INTWIDTH];
+
+// friend operator declarations
+    inline bool operator == ( const sc_uint_base& a, const sc_uint_base& b );
+    inline bool operator != ( const sc_uint_base& a, const sc_uint_base& b );
+    inline bool operator <  ( const sc_uint_base& a, const sc_uint_base& b );
+    inline bool operator <= ( const sc_uint_base& a, const sc_uint_base& b );
+    inline bool operator >  ( const sc_uint_base& a, const sc_uint_base& b );
+    inline bool operator >= ( const sc_uint_base& a, const sc_uint_base& b );
+
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_uint_bitref_r
+//
+//  Proxy class for sc_uint bit selection (r-value only).
+// ----------------------------------------------------------------------------
+
+class sc_uint_bitref_r : public sc_value_base
+{
+    friend class sc_uint_base;
+    friend class sc_uint_signal;
+
+
+    // constructors
+
+public:
+    sc_uint_bitref_r( const sc_uint_bitref_r& init ) :
+	 sc_value_base(init), m_index(init.m_index), m_obj_p(init.m_obj_p)
+	 {}
+
+protected:
+    sc_uint_bitref_r() : sc_value_base(), m_index(0), m_obj_p(0)
+        {}
+
+    // initializer for sc_core::sc_vpool:
+
+    void initialize( const sc_uint_base* obj_p, int index_ )
+    {
+        m_obj_p = (sc_uint_base*)obj_p;
+        m_index = index_;
+    }
+
+public:
+
+    // destructor
+
+    virtual ~sc_uint_bitref_r()
+	{}
+
+    // concatenation support
+
+    virtual int concat_length(bool* xz_present_p) const
+	{ if ( xz_present_p ) *xz_present_p = false; return 1; }
+    virtual bool concat_get_ctrl( sc_digit* dst_p, int low_i ) const
+        {
+            int  bit_mask = 1 << (low_i % BITS_PER_DIGIT);
+            int  word_i = low_i / BITS_PER_DIGIT;
+
+	    dst_p[word_i] &= ~bit_mask;
+	    return false;
+        }
+    virtual bool concat_get_data( sc_digit* dst_p, int low_i ) const
+        {
+            int  bit_mask = 1 << (low_i % BITS_PER_DIGIT);
+	    bool result;             // True is non-zero.
+            int  word_i = low_i / BITS_PER_DIGIT;
+
+            if ( operator uint64() )
+	    {
+                dst_p[word_i] |= bit_mask;
+		result = true;
+	    }
+            else
+	    {
+                dst_p[word_i] &= ~bit_mask;
+		result = false;
+	    }
+	    return result;
+        }
+    virtual uint64 concat_get_uint64() const
+	{ return operator uint64(); }
+
+    // capacity
+
+    int length() const
+	{ return 1; }
+
+#ifdef SC_DT_DEPRECATED
+    int bitwidth() const
+	{ return length(); }
+#endif
+
+
+    // implicit conversion to uint64
+
+    operator uint64 () const;
+    bool operator ! () const;
+    bool operator ~ () const;
+
+
+    // explicit conversions
+
+    uint64 value() const
+	{ return operator uint64 (); }
+
+    bool to_bool() const
+	{ return operator uint64 (); }
+
+
+    // other methods
+
+    void print( ::std::ostream& os = ::std::cout ) const
+	{ os << to_bool(); }
+
+protected:
+
+    int           m_index;
+    sc_uint_base* m_obj_p;
+
+private:
+
+    // disabled
+    sc_uint_bitref_r& operator = ( const sc_uint_bitref_r& );
+};
+
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream&, const sc_uint_bitref_r& );
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_uint_bitref
+//
+//  Proxy class for sc_uint bit selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+class sc_uint_bitref
+    : public sc_uint_bitref_r
+{
+    friend class sc_uint_base;
+    friend class sc_core::sc_vpool<sc_uint_bitref>;
+
+
+    // constructors
+
+protected:
+    sc_uint_bitref() : sc_uint_bitref_r()
+        {}
+public:
+    sc_uint_bitref( const sc_uint_bitref& init ) : sc_uint_bitref_r(init)
+        {}
+
+public:
+
+    // assignment operators
+
+    sc_uint_bitref& operator = ( const sc_uint_bitref_r& b );
+    sc_uint_bitref& operator = ( const sc_uint_bitref& b );
+    sc_uint_bitref& operator = ( bool b );
+
+    sc_uint_bitref& operator &= ( bool b );
+    sc_uint_bitref& operator |= ( bool b );
+    sc_uint_bitref& operator ^= ( bool b );
+
+	// concatenation methods
+
+    virtual void concat_set(int64 src, int low_i);
+    virtual void concat_set(const sc_signed& src, int low_i);
+    virtual void concat_set(const sc_unsigned& src, int low_i);
+    virtual void concat_set(uint64 src, int low_i);
+
+    // other methods
+
+    void scan( ::std::istream& is = ::std::cin );
+
+protected:
+    static sc_core::sc_vpool<sc_uint_bitref> m_pool;
+
+};
+
+
+
+inline
+::std::istream&
+operator >> ( ::std::istream&, sc_uint_bitref& );
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_uint_subref_r
+//
+//  Proxy class for sc_uint part selection (r-value only).
+// ----------------------------------------------------------------------------
+
+class sc_uint_subref_r : public sc_value_base
+{
+    friend class sc_uint_base;
+	friend class sc_uint_subref;
+
+
+    // constructors
+
+public:
+    sc_uint_subref_r( const sc_uint_subref_r& init ) :
+        sc_value_base(init), m_left(init.m_left), m_obj_p(init.m_obj_p), 
+	m_right(init.m_right)
+	{}
+
+protected:
+    sc_uint_subref_r() : sc_value_base(), m_left(0), m_obj_p(0), m_right(0)
+	{}
+
+    // initializer for sc_core::sc_vpool:
+
+    void initialize( const sc_uint_base* obj_p, int left_i, int right_i )
+    {
+        m_obj_p = (sc_uint_base*)obj_p;
+        m_left = left_i;
+        m_right = right_i;
+    }
+
+public:
+
+    // destructor
+
+    virtual ~sc_uint_subref_r()
+	{}
+
+    // capacity
+
+    int length() const
+	{ return ( m_left - m_right + 1 ); }
+
+#ifdef SC_DT_DEPRECATED
+    int bitwidth() const
+	{ return length(); }
+#endif
+
+    // concatenation support
+
+    virtual int concat_length(bool* xz_present_p) const
+	{ if ( xz_present_p ) *xz_present_p = false; return length(); }
+    virtual bool concat_get_ctrl( sc_digit* dst_p, int low_i ) const;
+    virtual bool concat_get_data( sc_digit* dst_p, int low_i ) const;
+    virtual uint64 concat_get_uint64() const
+	{ return (uint64)operator uint_type(); }
+
+
+    // reduce methods
+
+    bool and_reduce() const;
+
+    bool nand_reduce() const
+	{ return ( ! and_reduce() ); }
+
+    bool or_reduce() const;
+
+    bool nor_reduce() const
+	{ return ( ! or_reduce() ); }
+
+    bool xor_reduce() const;
+
+    bool xnor_reduce() const
+	{ return ( ! xor_reduce() ); }
+
+
+    // implicit conversion to uint_type
+
+    operator uint_type() const;
+
+
+    // explicit conversions
+
+    uint_type value() const
+	{ return operator uint_type(); }
+
+
+    int           to_int() const;
+    unsigned int  to_uint() const;
+    long          to_long() const;
+    unsigned long to_ulong() const;
+    int64         to_int64() const;
+    uint64        to_uint64() const;
+    double        to_double() const;
+
+
+    // explicit conversion to character string
+
+    const std::string to_string( sc_numrep numrep = SC_DEC ) const;
+    const std::string to_string( sc_numrep numrep, bool w_prefix ) const;
+
+
+    // other methods
+
+    void print( ::std::ostream& os = ::std::cout ) const
+	{ os << to_string(sc_io_base(os,SC_DEC),sc_io_show_base(os)); }
+
+protected:
+
+    int           m_left;
+    sc_uint_base* m_obj_p;
+    int           m_right;
+
+private:
+
+    // disabled
+    sc_uint_subref_r& operator = ( const sc_uint_subref_r& );
+};
+
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream&, const sc_uint_subref_r& );
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_uint_subref
+//
+//  Proxy class for sc_uint part selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+class sc_uint_subref
+    : public sc_uint_subref_r
+{
+    friend class sc_uint_base;
+    friend class sc_core::sc_vpool<sc_uint_subref>;
+
+
+    // constructors
+
+protected:
+    sc_uint_subref() : sc_uint_subref_r()
+        {}
+
+public:
+    sc_uint_subref( const sc_uint_subref& init ) : sc_uint_subref_r(init)
+        {}
+
+public:
+
+    // assignment operators
+
+    sc_uint_subref& operator = ( uint_type v );
+
+    sc_uint_subref& operator = ( const sc_uint_base& a );
+
+    sc_uint_subref& operator = ( const sc_uint_subref_r& a )
+	{ return operator = ( a.operator uint_type() ); }
+
+    sc_uint_subref& operator = ( const sc_uint_subref& a )
+	{ return operator = ( a.operator uint_type() ); }
+
+    template<class T>
+    sc_uint_subref& operator = ( const sc_generic_base<T>& a )
+        { return operator = ( a->to_uint64() ); }
+
+    sc_uint_subref& operator = ( const char* a );
+
+    sc_uint_subref& operator = ( unsigned long a )
+	{ return operator = ( (uint_type) a ); }
+
+    sc_uint_subref& operator = ( long a )
+	{ return operator = ( (uint_type) a ); }
+
+    sc_uint_subref& operator = ( unsigned int a )
+	{ return operator = ( (uint_type) a ); }
+
+    sc_uint_subref& operator = ( int a )
+	{ return operator = ( (uint_type) a ); }
+
+    sc_uint_subref& operator = ( int64 a )
+	{ return operator = ( (uint_type) a ); }
+
+    sc_uint_subref& operator = ( double a )
+	{ return operator = ( (uint_type) a ); }
+
+    sc_uint_subref& operator = ( const sc_signed& );
+    sc_uint_subref& operator = ( const sc_unsigned& );
+    sc_uint_subref& operator = ( const sc_bv_base& );
+    sc_uint_subref& operator = ( const sc_lv_base& );
+
+	// concatenation methods
+
+    virtual void concat_set(int64 src, int low_i);
+    virtual void concat_set(const sc_signed& src, int low_i);
+    virtual void concat_set(const sc_unsigned& src, int low_i);
+    virtual void concat_set(uint64 src, int low_i);
+
+    // other methods
+
+    void scan( ::std::istream& is = ::std::cin );
+
+protected:
+    static sc_core::sc_vpool<sc_uint_subref> m_pool;
+
+};
+
+
+
+inline
+::std::istream&
+operator >> ( ::std::istream&, sc_uint_subref& );
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_uint_base
+//
+//  Base class for sc_uint.
+// ----------------------------------------------------------------------------
+
+class sc_uint_base : public sc_value_base
+{
+    friend class sc_uint_bitref_r;
+    friend class sc_uint_bitref;
+    friend class sc_uint_subref_r;
+    friend class sc_uint_subref;
+
+
+    // support methods
+
+    void invalid_length() const;
+    void invalid_index( int i ) const;
+    void invalid_range( int l, int r ) const;
+
+    void check_length() const
+	{ if( m_len <= 0 || m_len > SC_INTWIDTH ) { invalid_length(); } }
+
+    void check_index( int i ) const
+	{ if( i < 0 || i >= m_len ) { invalid_index( i ); } }
+
+    void check_range( int l, int r ) const
+	{ if( r < 0 || l >= m_len || l < r ) { invalid_range( l, r ); } }
+
+    void check_value() const;
+
+    void extend_sign()
+	{
+#ifdef DEBUG_SYSTEMC
+	    check_value();
+#endif
+	    m_val &= ( ~UINT_ZERO >> m_ulen );
+	}
+
+public:
+
+    // constructors
+
+    explicit sc_uint_base( int w = sc_length_param().len() )
+	: m_val( 0 ), m_len( w ), m_ulen( SC_INTWIDTH - m_len )
+	{ check_length(); }
+
+    sc_uint_base( uint_type v, int w )
+	: m_val( v ), m_len( w ), m_ulen( SC_INTWIDTH - m_len )
+	{ check_length(); extend_sign(); }
+
+    sc_uint_base( const sc_uint_base& a )
+        : sc_value_base(a), m_val(a.m_val), m_len(a.m_len), m_ulen(a.m_ulen)
+	{}
+
+    explicit sc_uint_base( const sc_uint_subref_r& a )
+        : m_val( a ), m_len( a.length() ), m_ulen( SC_INTWIDTH - m_len )
+        { extend_sign(); }
+
+    template<class T>
+    explicit sc_uint_base( const sc_generic_base<T>& a )
+	: m_val( a->to_uint64() ), m_len( a->length() ),
+	  m_ulen( SC_INTWIDTH - m_len )
+	{ check_length(); extend_sign(); }
+
+    explicit sc_uint_base( const sc_bv_base& v );
+    explicit sc_uint_base( const sc_lv_base& v );
+    explicit sc_uint_base( const sc_int_subref_r& v );
+    explicit sc_uint_base( const sc_signed_subref_r& v );
+    explicit sc_uint_base( const sc_unsigned_subref_r& v );
+    explicit sc_uint_base( const sc_signed& a );
+    explicit sc_uint_base( const sc_unsigned& a );
+
+
+    // destructor
+
+    virtual ~sc_uint_base()
+	{}
+
+
+    // assignment operators
+
+    sc_uint_base& operator = ( uint_type v )
+	{ m_val = v; extend_sign(); return *this; }
+
+    sc_uint_base& operator = ( const sc_uint_base& a )
+	{ m_val = a.m_val; extend_sign(); return *this; }
+
+    sc_uint_base& operator = ( const sc_uint_subref_r& a )
+        { m_val = a; extend_sign(); return *this; }
+
+    template<class T>
+    sc_uint_base& operator = ( const sc_generic_base<T>& a )
+        { m_val = a->to_uint64(); extend_sign(); return *this; }
+
+    sc_uint_base& operator = ( const sc_signed& a );
+    sc_uint_base& operator = ( const sc_unsigned& a );
+
+#ifdef SC_INCLUDE_FX
+    sc_uint_base& operator = ( const sc_fxval& a );
+    sc_uint_base& operator = ( const sc_fxval_fast& a );
+    sc_uint_base& operator = ( const sc_fxnum& a );
+    sc_uint_base& operator = ( const sc_fxnum_fast& a );
+#endif
+
+    sc_uint_base& operator = ( const sc_bv_base& a );
+    sc_uint_base& operator = ( const sc_lv_base& a );
+
+    sc_uint_base& operator = ( const char* a );
+
+    sc_uint_base& operator = ( unsigned long a )
+	{ m_val = a; extend_sign(); return *this; }
+
+    sc_uint_base& operator = ( long a )
+	{ m_val = a; extend_sign(); return *this; }
+
+    sc_uint_base& operator = ( unsigned int a )
+	{ m_val = a; extend_sign(); return *this; }
+
+    sc_uint_base& operator = ( int a )
+	{ m_val = a; extend_sign(); return *this; }
+
+    sc_uint_base& operator = ( int64 a )
+	{ m_val = a; extend_sign(); return *this; }
+
+    sc_uint_base& operator = ( double a )
+	{ m_val = (uint_type) a; extend_sign(); return *this; }
+
+
+    // arithmetic assignment operators
+
+    sc_uint_base& operator += ( uint_type v )
+	{ m_val += v; extend_sign(); return *this; }
+
+    sc_uint_base& operator -= ( uint_type v )
+	{ m_val -= v; extend_sign(); return *this; }
+
+    sc_uint_base& operator *= ( uint_type v )
+	{ m_val *= v; extend_sign(); return *this; }
+
+    sc_uint_base& operator /= ( uint_type v )
+	{ m_val /= v; extend_sign(); return *this; }
+
+    sc_uint_base& operator %= ( uint_type v )
+	{ m_val %= v; extend_sign(); return *this; }
+
+
+    // bitwise assignment operators
+
+    sc_uint_base& operator &= ( uint_type v )
+	{ m_val &= v; extend_sign(); return *this; }
+
+    sc_uint_base& operator |= ( uint_type v )
+	{ m_val |= v; extend_sign(); return *this; }
+
+    sc_uint_base& operator ^= ( uint_type v )
+	{ m_val ^= v; extend_sign(); return *this; }
+
+
+    sc_uint_base& operator <<= ( uint_type v )
+	{ m_val <<= v; extend_sign(); return *this; }
+
+    sc_uint_base& operator >>= ( uint_type v )
+	{ m_val >>= v; /* no sign extension needed */ return *this; }
+
+
+    // prefix and postfix increment and decrement operators
+
+    sc_uint_base& operator ++ () // prefix
+	{ ++ m_val; extend_sign(); return *this; }
+
+    const sc_uint_base operator ++ ( int ) // postfix
+	{ sc_uint_base tmp( *this ); ++ m_val; extend_sign(); return tmp; }
+
+    sc_uint_base& operator -- () // prefix
+	{ -- m_val; extend_sign(); return *this; }
+
+    const sc_uint_base operator -- ( int ) // postfix
+	{ sc_uint_base tmp( *this ); -- m_val; extend_sign(); return tmp; }
+
+
+    // relational operators
+
+    friend bool operator == ( const sc_uint_base& a, const sc_uint_base& b )
+	{ return a.m_val == b.m_val; }
+
+    friend bool operator != ( const sc_uint_base& a, const sc_uint_base& b )
+	{ return a.m_val != b.m_val; }
+
+    friend bool operator <  ( const sc_uint_base& a, const sc_uint_base& b )
+	{ return a.m_val < b.m_val; }
+
+    friend bool operator <= ( const sc_uint_base& a, const sc_uint_base& b )
+	{ return a.m_val <= b.m_val; }
+
+    friend bool operator >  ( const sc_uint_base& a, const sc_uint_base& b )
+	{ return a.m_val > b.m_val; }
+
+    friend bool operator >= ( const sc_uint_base& a, const sc_uint_base& b )
+	{ return a.m_val >= b.m_val; }
+
+
+    // bit selection
+
+    sc_uint_bitref&         operator [] ( int i );
+    const sc_uint_bitref_r& operator [] ( int i ) const;
+
+    sc_uint_bitref&         bit( int i );
+    const sc_uint_bitref_r& bit( int i ) const;
+
+
+    // part selection
+
+    sc_uint_subref&         operator () ( int left, int right );
+    const sc_uint_subref_r& operator () ( int left, int right ) const;
+
+    sc_uint_subref&         range( int left, int right );
+    const sc_uint_subref_r& range( int left, int right ) const;
+
+
+    // bit access, without bounds checking or sign extension
+
+    bool test( int i ) const
+	{ return ( 0 != (m_val & (UINT_ONE << i)) ); }
+
+    void set( int i )
+	{ m_val |= (UINT_ONE << i); }
+
+    void set( int i, bool v )
+	{ v ? m_val |= (UINT_ONE << i) : m_val &= ~(UINT_ONE << i); }
+
+
+    // capacity
+
+    int length() const
+	{ return m_len; }
+
+#ifdef SC_DT_DEPRECATED
+    int bitwidth() const
+	{ return length(); }
+#endif
+
+    // concatenation support
+
+    virtual int concat_length(bool* xz_present_p) const
+	{ if ( xz_present_p ) *xz_present_p = false; return length(); }
+    virtual bool concat_get_ctrl( sc_digit* dst_p, int low_i ) const;
+    virtual bool concat_get_data( sc_digit* dst_p, int low_i ) const;
+    virtual uint64 concat_get_uint64() const
+        { return m_val; }
+    virtual void concat_set(int64 src, int low_i);
+    virtual void concat_set(const sc_signed& src, int low_i);
+    virtual void concat_set(const sc_unsigned& src, int low_i);
+    virtual void concat_set(uint64 src, int low_i);
+
+
+    // reduce methods
+
+    bool and_reduce() const;
+
+    bool nand_reduce() const
+	{ return ( ! and_reduce() ); }
+
+    bool or_reduce() const;
+
+    bool nor_reduce() const
+	{ return ( ! or_reduce() ); }
+
+    bool xor_reduce() const;
+
+    bool xnor_reduce() const
+	{ return ( ! xor_reduce() ); }
+
+
+    // implicit conversion to uint_type
+
+    operator uint_type() const
+	{ return m_val; }
+
+
+    // explicit conversions
+
+    uint_type value() const
+	{ return operator uint_type(); }
+
+
+    int to_int() const
+	{ return (int) m_val; }
+
+    unsigned int to_uint() const
+	{ return (unsigned int) m_val; }
+
+    long to_long() const
+	{ return (long) m_val; }
+
+    unsigned long to_ulong() const
+	{ return (unsigned long) m_val; }
+
+    int64 to_int64() const
+	{ return (int64) m_val; }
+
+    uint64 to_uint64() const
+	{ return (uint64) m_val; }
+
+    double to_double() const
+        { return uint64_to_double( m_val ); }
+
+
+#ifndef _32BIT_
+    long long_low() const
+	{ return (long) (m_val & UINT64_32ONES); }
+
+    long long_high() const
+	{ return (long) ((m_val >> 32) & UINT64_32ONES); }
+#endif
+
+    // explicit conversion to character string
+
+    const std::string to_string( sc_numrep numrep = SC_DEC ) const;
+    const std::string to_string( sc_numrep numrep, bool w_prefix ) const;
+
+
+    // other methods
+
+    void print( ::std::ostream& os = ::std::cout ) const
+	{ os << to_string(sc_io_base(os,SC_DEC),sc_io_show_base(os)); }
+
+    void scan( ::std::istream& is = ::std::cin );
+
+protected:
+
+    uint_type m_val;   // value
+    int       m_len;   // length
+    int       m_ulen;  // unused length
+};
+
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream&, const sc_uint_base& );
+
+inline
+::std::istream&
+operator >> ( ::std::istream&, sc_uint_base& );
+
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_uint_bitref_r
+//
+//  Proxy class for sc_uint bit selection (r-value only).
+// ----------------------------------------------------------------------------
+
+// implicit conversion to bool
+
+inline
+sc_uint_bitref_r::operator uint64 () const
+{
+    return m_obj_p->test( m_index );
+}
+
+inline
+bool
+sc_uint_bitref_r::operator ! () const
+{
+    return ! m_obj_p->test( m_index );
+}
+
+inline
+bool
+sc_uint_bitref_r::operator ~ () const
+{
+    return ! m_obj_p->test( m_index );
+}
+
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_uint_bitref_r& a )
+{
+    a.print( os );
+    return os;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_uint_bitref
+//
+//  Proxy class for sc_uint bit selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+// assignment operators
+
+inline
+sc_uint_bitref&
+sc_uint_bitref::operator = ( const sc_uint_bitref_r& b )
+{
+    m_obj_p->set( m_index, b.to_bool() );
+    return *this;
+}
+
+inline
+sc_uint_bitref&
+sc_uint_bitref::operator = ( const sc_uint_bitref& b )
+{
+    m_obj_p->set( m_index, b.to_bool() );
+    return *this;
+}
+
+inline
+sc_uint_bitref&
+sc_uint_bitref::operator = ( bool b )
+{
+    m_obj_p->set( m_index, b );
+    return *this;
+}
+
+
+inline
+sc_uint_bitref&
+sc_uint_bitref::operator &= ( bool b )
+{
+    if( ! b ) {
+	m_obj_p->set( m_index, b );
+    }
+    return *this;
+}
+
+inline
+sc_uint_bitref&
+sc_uint_bitref::operator |= ( bool b )
+{
+    if( b ) {
+	m_obj_p->set( m_index, b );
+    }
+    return *this;
+}
+
+inline
+sc_uint_bitref&
+sc_uint_bitref::operator ^= ( bool b )
+{
+    if( b ) {
+	m_obj_p->m_val ^= (UINT_ONE << m_index);
+    }
+    return *this;
+}
+
+
+
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_uint_bitref& a )
+{
+    a.scan( is );
+    return is;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_uint_subref_r
+//
+//  Proxy class for sc_uint part selection (r-value only).
+// ----------------------------------------------------------------------------
+
+// implicit conversion to uint_type
+
+inline
+sc_uint_subref_r::operator uint_type() const
+{
+    uint_type val = m_obj_p->m_val;
+    int uleft = SC_INTWIDTH - (m_left + 1);
+    return ( (val & (~UINT_ZERO >> uleft)) >> m_right );
+}
+
+
+// reduce methods
+
+inline
+bool
+sc_uint_subref_r::and_reduce() const
+{
+    sc_uint_base a( *this );
+    return a.and_reduce();
+}
+
+inline
+bool
+sc_uint_subref_r::or_reduce() const
+{
+    sc_uint_base a( *this );
+    return a.or_reduce();
+}
+
+inline
+bool
+sc_uint_subref_r::xor_reduce() const
+{
+    sc_uint_base a( *this );
+    return a.xor_reduce();
+}
+
+
+// explicit conversions
+
+inline
+int
+sc_uint_subref_r::to_int() const
+{
+    sc_uint_base a( *this );
+    return a.to_int();
+}
+
+inline
+unsigned int
+sc_uint_subref_r::to_uint() const
+{
+    sc_uint_base a( *this );
+    return a.to_uint();
+}
+
+inline
+long
+sc_uint_subref_r::to_long() const
+{
+    sc_uint_base a( *this );
+    return a.to_long();
+}
+
+inline
+unsigned long
+sc_uint_subref_r::to_ulong() const
+{
+    sc_uint_base a( *this );
+    return a.to_ulong();
+}
+
+inline
+int64
+sc_uint_subref_r::to_int64() const
+{
+    sc_uint_base a( *this );
+    return a.to_int64();
+}
+
+inline
+uint64
+sc_uint_subref_r::to_uint64() const
+{
+    sc_uint_base a( *this );
+    return a.to_uint64();
+}
+
+inline
+double
+sc_uint_subref_r::to_double() const
+{
+    sc_uint_base a( *this );
+    return a.to_double();
+}
+
+
+// explicit conversion to character string
+
+inline
+const std::string
+sc_uint_subref_r::to_string( sc_numrep numrep ) const
+{
+    sc_uint_base a( *this );
+    return a.to_string( numrep );
+}
+
+inline
+const std::string
+sc_uint_subref_r::to_string( sc_numrep numrep, bool w_prefix ) const
+{
+    sc_uint_base a( *this );
+    return a.to_string( numrep, w_prefix );
+}
+
+
+// functional notation for the reduce methods
+
+inline
+bool
+and_reduce( const sc_uint_subref_r& a )
+{
+    return a.and_reduce();
+}
+
+inline
+bool
+nand_reduce( const sc_uint_subref_r& a )
+{
+    return a.nand_reduce();
+}
+
+inline
+bool
+or_reduce( const sc_uint_subref_r& a )
+{
+    return a.or_reduce();
+}
+
+inline
+bool
+nor_reduce( const sc_uint_subref_r& a )
+{
+    return a.nor_reduce();
+}
+
+inline
+bool
+xor_reduce( const sc_uint_subref_r& a )
+{
+    return a.xor_reduce();
+}
+
+inline
+bool
+xnor_reduce( const sc_uint_subref_r& a )
+{
+    return a.xnor_reduce();
+}
+
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_uint_subref_r& a )
+{
+    a.print( os );
+    return os;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_uint_subref
+//
+//  Proxy class for sc_uint part selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+// assignment operators
+
+inline
+sc_uint_subref&
+sc_uint_subref::operator = ( const sc_uint_base& a )
+{
+    return operator = ( a.operator uint_type() );
+}
+
+inline
+sc_uint_subref&
+sc_uint_subref::operator = ( const char* a )
+{
+    sc_uint_base aa( length() );
+    return ( *this = aa = a );
+}
+
+
+
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_uint_subref& a )
+{
+    a.scan( is );
+    return is;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_uint_base
+//
+//  Base class for sc_uint.
+// ----------------------------------------------------------------------------
+
+// bit selection
+
+inline
+sc_uint_bitref&
+sc_uint_base::operator [] ( int i )
+{
+    check_index( i );
+    sc_uint_bitref* result_p = sc_uint_bitref::m_pool.allocate();
+    result_p->initialize(this, i);
+    return *result_p;
+}
+
+inline
+const sc_uint_bitref_r&
+sc_uint_base::operator [] ( int i ) const
+{
+    check_index( i );
+    sc_uint_bitref* result_p = sc_uint_bitref::m_pool.allocate();
+    result_p->initialize(this, i);
+    return *result_p;
+}
+
+
+inline
+sc_uint_bitref&
+sc_uint_base::bit( int i )
+{
+    check_index( i );
+    sc_uint_bitref* result_p = sc_uint_bitref::m_pool.allocate();
+    result_p->initialize(this, i);
+    return *result_p;
+}
+
+inline
+const sc_uint_bitref_r&
+sc_uint_base::bit( int i ) const
+{
+    check_index( i );
+    sc_uint_bitref* result_p = sc_uint_bitref::m_pool.allocate();
+    result_p->initialize(this, i);
+    return *result_p;
+}
+
+
+// part selection
+
+inline
+sc_uint_subref&
+sc_uint_base::operator () ( int left, int right )
+{
+    check_range( left, right );
+    sc_uint_subref* result_p = sc_uint_subref::m_pool.allocate();
+    result_p->initialize(this, left, right);
+    return *result_p;
+}
+
+inline
+const sc_uint_subref_r&
+sc_uint_base::operator () ( int left, int right ) const
+{
+    check_range( left, right );
+    sc_uint_subref* result_p = sc_uint_subref::m_pool.allocate();
+    result_p->initialize(this, left, right);
+    return *result_p;
+}
+
+
+inline
+sc_uint_subref&
+sc_uint_base::range( int left, int right )
+{
+    check_range( left, right );
+    sc_uint_subref* result_p = sc_uint_subref::m_pool.allocate();
+    result_p->initialize(this, left, right);
+    return *result_p;
+}
+
+inline
+const sc_uint_subref_r&
+sc_uint_base::range( int left, int right ) const
+{
+    check_range( left, right );
+    sc_uint_subref* result_p = sc_uint_subref::m_pool.allocate();
+    result_p->initialize(this, left, right);
+    return *result_p;
+}
+
+
+// functional notation for the reduce methods
+
+inline
+bool
+and_reduce( const sc_uint_base& a )
+{
+    return a.and_reduce();
+}
+
+inline
+bool
+nand_reduce( const sc_uint_base& a )
+{
+    return a.nand_reduce();
+}
+
+inline
+bool
+or_reduce( const sc_uint_base& a )
+{
+    return a.or_reduce();
+}
+
+inline
+bool
+nor_reduce( const sc_uint_base& a )
+{
+    return a.nor_reduce();
+}
+
+inline
+bool
+xor_reduce( const sc_uint_base& a )
+{
+    return a.xor_reduce();
+}
+
+inline
+bool
+xnor_reduce( const sc_uint_base& a )
+{
+    return a.xnor_reduce();
+}
+
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_uint_base& a )
+{
+    a.print( os );
+    return os;
+}
+
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_uint_base& a )
+{
+    a.scan( is );
+    return is;
+}
+
+} // namespace sc_dt
+
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_unsigned.cpp b/ext/systemc/src/sysc/datatypes/int/sc_unsigned.cpp
new file mode 100644
index 000000000..75af69deb
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_unsigned.cpp
@@ -0,0 +1,2240 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_unsigned.cpp -- Arbitrary precision signed arithmetic.
+
+    This file includes the definitions of sc_unsigned_bitref,
+    sc_unsigned_subref, and sc_unsigned classes. The first two classes
+    are proxy classes to reference one bit and a range of bits of a
+    sc_unsigned number, respectively. This file also includes
+    sc_nbcommon.cpp and sc_nbfriends.cpp, which contain the
+    definitions shared by sc_unsigned.
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+  
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_unsigned.cpp,v $
+// Revision 1.7  2011/02/18 20:19:15  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.6  2008/12/10 20:38:45  acg
+//  Andy Goodrich: fixed conversion of double values to the digits vector.
+//  The bits above the radix were not being masked off.
+//
+// Revision 1.5  2008/06/19 17:47:57  acg
+//  Andy Goodrich: fixes for bugs. See 2.2.1 RELEASENOTES.
+//
+// Revision 1.4  2008/06/19 16:57:57  acg
+//  Andy Goodrich: added case for negative unsigned values to the support in
+//  concate_get_data().
+//
+// Revision 1.3  2007/11/04 21:27:00  acg
+//  Andy Goodrich: changes to make sure the proper value is returned from
+//  concat_get_data().
+//
+// Revision 1.2  2007/02/22 21:35:05  acg
+//  Andy Goodrich: cleaned up comments in concat_get_ctrl and concat_get_data.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.4  2006/08/29 23:36:54  acg
+//  Andy Goodrich: fixed and_reduce and optimized or_reduce.
+//
+// Revision 1.3  2006/01/13 18:49:32  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#include <ctype.h>
+#include <math.h>
+
+#include "sysc/kernel/sc_cmnhdr.h"
+#include "sysc/kernel/sc_macros.h"
+#include "sysc/datatypes/int/sc_unsigned.h"
+#include "sysc/datatypes/int/sc_signed.h"
+#include "sysc/datatypes/int/sc_int_base.h"
+#include "sysc/datatypes/int/sc_uint_base.h"
+#include "sysc/datatypes/int/sc_int_ids.h"
+#include "sysc/datatypes/bit/sc_bv_base.h"
+#include "sysc/datatypes/bit/sc_lv_base.h"
+#include "sysc/datatypes/misc/sc_concatref.h"
+#include "sysc/datatypes/fx/sc_ufix.h"
+#include "sysc/datatypes/fx/scfx_other_defs.h"
+
+namespace sc_dt
+{
+
+// Pool of temporary instances:
+//   The sc_unsigned pool is used by the concatenation support.
+//   The bit and part reference pools allow references to be returned.
+
+sc_core::sc_vpool<sc_unsigned> sc_unsigned::m_pool(8);	
+sc_core::sc_vpool<sc_unsigned_bitref> sc_unsigned_bitref::m_pool(9);	
+sc_core::sc_vpool<sc_unsigned_subref> sc_unsigned_subref::m_pool(9);	
+
+// -----------------------------------------------------------------------------
+// SECTION: Public members - Invalid selections.
+// -----------------------------------------------------------------------------
+
+void
+sc_unsigned::invalid_index( int i ) const
+{
+    char msg[BUFSIZ];
+    std::sprintf( msg,
+         "sc_biguint bit selection: index = %d violates "
+         "0 <= index <= %d",
+         i, nbits - 2 );
+    SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
+}
+
+void
+sc_unsigned::invalid_range( int l, int r ) const
+{
+    char msg[BUFSIZ];
+    std::sprintf( msg,
+         "sc_biguint part selection: left = %d, right = %d \n"
+	 "  violates either (%d >= left >= 0) or (%d >= right >= 0)",
+         l, r, nbits-2, nbits-2 );
+    SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, msg );
+}
+
+// ----------------------------------------------------------------------------
+//  SECTION: Public members - Concatenation support.
+// ----------------------------------------------------------------------------
+
+// Most public members are included from sc_nbcommon.inc. However, some 
+// concatenation support appears here to optimize between the signed and
+// unsigned cases.
+
+
+
+// Insert this object's value at the specified place in a vector of big style
+// values.
+
+bool sc_unsigned::concat_get_ctrl( sc_digit* dst_p, int low_i ) const
+{
+    int      dst_i;        // Index to next word to set in dst_p.
+    int      end_i;        // Index of high order word to set.
+    int      left_shift;   // Amount to shift value left.
+    sc_digit mask;         // Mask for partial word sets.
+
+
+    // CALCULATE METRICS FOR DATA MOVEMENT:
+
+    dst_i = low_i / BITS_PER_DIGIT;
+    end_i = (low_i + nbits - 2) / BITS_PER_DIGIT;
+    left_shift = low_i % BITS_PER_DIGIT;
+
+
+    // MOVE FIRST WORD (IT MAY BE PARTIAL) AND THEN ANY OTHERS:
+    // 
+    // We may "clobber" upper bits, but they will be written at some point
+    // anyway.
+
+    mask = ~(-1 << left_shift);
+    dst_p[dst_i] = ( dst_p[dst_i] & ~mask );
+    dst_i++;
+
+    for ( ; dst_i <= end_i; dst_i++ ) dst_p[dst_i] = 0;
+
+    return false;
+}
+
+bool sc_unsigned::concat_get_data( sc_digit* dst_p, int low_i ) const
+{
+    sc_digit carry;        // Carry for negating value.
+    int      dst_i;        // Index to next word to set in dst_p.
+    int      end_i;        // Index of high order word to set.
+    int      high_i;       // Index w/in word of high order bit.
+    int      left_shift;   // Amount to shift value left.
+    sc_digit left_word;    // High word component for set.
+    sc_digit mask;         // Mask for partial word sets.
+    bool     result;       // True if inserting non-zero data.
+    int      right_shift;  // Amount to shift value right.
+    sc_digit right_word;   // Low word component for set.
+    int      real_bits;    // nbits - 1.
+    int      src_i;        // Index to next word to get from digit.
+
+
+    // CALCULATE METRICS FOR DATA MOVEMENT:
+
+    real_bits = nbits - 1;          // Remove that extra sign bit.
+    dst_i = low_i / BITS_PER_DIGIT;
+    high_i = low_i + real_bits - 1;
+    end_i = high_i / BITS_PER_DIGIT;
+    left_shift = low_i % BITS_PER_DIGIT;
+
+
+    switch ( sgn )
+    {
+
+      // POSITIVE SOURCE VALUE:
+
+      case SC_POS:
+	result = true;
+
+	// ALL DATA TO BE MOVED IS IN A SINGLE WORD:
+
+	if ( dst_i == end_i )
+	{
+	    mask = ~(-1 << left_shift);
+	    dst_p[dst_i] = ( ( dst_p[dst_i] & mask ) | 
+		(digit[0] << left_shift) ) & DIGIT_MASK;
+	}
+
+
+	// DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED:
+
+	else if ( left_shift == 0 )
+	{
+	    for ( src_i = 0; dst_i < end_i; dst_i++, src_i++ )
+	    {
+		dst_p[dst_i] = digit[src_i];
+	    }
+	    high_i = high_i % BITS_PER_DIGIT;
+	    mask = ~(-2 << high_i) & DIGIT_MASK;
+	    dst_p[dst_i] = digit[src_i] & mask;
+	}
+
+
+	// DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED:
+
+	else
+	{
+	    high_i = high_i % BITS_PER_DIGIT;
+	    right_shift = BITS_PER_DIGIT - left_shift;
+	    mask = ~(-1 << left_shift);
+	    right_word = digit[0];
+	    dst_p[dst_i] = (dst_p[dst_i] & mask) | 
+		((right_word << left_shift) & DIGIT_MASK);
+	    for ( src_i = 1, dst_i++; dst_i < end_i; dst_i++, src_i++ )
+	    {
+		left_word = digit[src_i];
+		dst_p[dst_i] = ((left_word << left_shift)&DIGIT_MASK) |
+		    (right_word >> right_shift);
+		right_word = left_word;
+	    }
+	    left_word = (src_i < ndigits) ? digit[src_i] : 0;
+	    mask = ~(-2 << high_i) & DIGIT_MASK;
+	    dst_p[dst_i] = ((left_word << left_shift) |
+		(right_word >> right_shift)) & mask;
+	}
+	break;
+
+      // SOURCE VALUE IS NEGATIVE:
+
+      case SC_NEG:
+
+        // ALL DATA TO BE MOVED IS IN A SINGLE WORD:
+
+	result = true;
+        if ( dst_i == end_i )
+        {
+            mask = ~(-1 << nbits);
+            right_word = ((digit[0] ^ DIGIT_MASK) + 1) & mask;
+            mask = ~(-1 << left_shift);
+            dst_p[dst_i] = ( ( dst_p[dst_i] & mask ) |
+                (right_word << left_shift) ) & DIGIT_MASK;
+        }
+
+
+        // DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED:
+
+        else if ( left_shift == 0 )
+        {
+            carry = 1;
+            for ( src_i = 0; dst_i < end_i; dst_i++, src_i++ )
+            {
+                right_word = (digit[src_i] ^ DIGIT_MASK) + carry;
+                dst_p[dst_i] = right_word &  DIGIT_MASK;
+                carry = right_word >> BITS_PER_DIGIT;
+            }
+            high_i = high_i % BITS_PER_DIGIT;
+            mask = (~(-2 << high_i)) & DIGIT_MASK;
+            right_word = (src_i < ndigits) ? 
+		(digit[src_i] ^ DIGIT_MASK) + carry : DIGIT_MASK + carry;
+            dst_p[dst_i] = right_word & mask;
+        }
+
+
+        // DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED:
+
+        else
+        {
+            high_i = high_i % BITS_PER_DIGIT;
+            right_shift = BITS_PER_DIGIT - left_shift;
+            mask = ~(-1 << left_shift);
+            carry = 1;
+            right_word = (digit[0] ^ DIGIT_MASK) + carry;
+            dst_p[dst_i] = (dst_p[dst_i] & mask) | 
+                ((right_word << left_shift) & DIGIT_MASK);
+	    carry = right_word >> BITS_PER_DIGIT;
+	    right_word &= DIGIT_MASK;
+            for ( src_i = 1, dst_i++; dst_i < end_i; dst_i++, src_i++ )
+            {
+                left_word = (digit[src_i] ^ DIGIT_MASK) + carry;
+                dst_p[dst_i] = ((left_word << left_shift)&DIGIT_MASK) |
+                    (right_word >> right_shift);
+                carry = left_word >> BITS_PER_DIGIT;
+                right_word = left_word & DIGIT_MASK;
+            }
+            left_word = (src_i < ndigits) ? 
+		(digit[src_i] ^ DIGIT_MASK) + carry : carry;
+            mask = ~(-2 << high_i) & DIGIT_MASK;
+            dst_p[dst_i] = ((left_word << left_shift) |
+                (right_word >> right_shift)) & mask;
+        }
+	break;
+
+
+      // VALUE IS ZERO:
+
+      default:
+	result = false;
+
+        // ALL DATA TO BE MOVED IS IN A SINGLE WORD:
+
+        if ( dst_i == end_i )
+        {
+            mask = ~(-1 << real_bits) << left_shift;
+            dst_p[dst_i] = dst_p[dst_i] & ~mask;
+        }
+
+
+        // DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED:
+
+        else if ( left_shift == 0 )
+        {
+            for ( src_i = 0; dst_i < end_i; dst_i++, src_i++ )
+            {
+                dst_p[dst_i] = 0;
+            }
+            high_i = high_i % BITS_PER_DIGIT;
+            mask = ~(-2 << high_i) & DIGIT_MASK;
+            dst_p[dst_i] = 0; 
+        }
+
+
+        // DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED:
+
+        else
+        {
+            high_i = high_i % BITS_PER_DIGIT;
+            right_shift = BITS_PER_DIGIT - left_shift;
+            mask = ~(-1 << left_shift);
+            dst_p[dst_i] = (dst_p[dst_i] & mask);
+            for ( dst_i++; dst_i <= end_i; dst_i++ )
+            {
+                dst_p[dst_i] = 0;
+            }
+        }
+        break;
+    }
+    return result;
+}
+
+// Return this object instance's bits as a uint64 without sign extension.
+
+uint64 sc_unsigned::concat_get_uint64() const
+{
+    uint64        result;
+
+    switch ( sgn )
+    {
+      case SC_POS:
+        result = 0;        
+        if ( ndigits > 2 )
+            result = digit[2];
+        if ( ndigits > 1 )
+            result = (result << BITS_PER_DIGIT) | digit[1];
+        result = (result << BITS_PER_DIGIT) | digit[0];    
+        break;
+      default:
+        result = 0;
+        break;
+    }
+    return result;
+}
+
+// #### OPTIMIZE
+void sc_unsigned::concat_set(int64 src, int low_i)  
+{    
+    *this = (low_i < 64) ? src >> low_i : src >> 63;
+}
+
+void sc_unsigned::concat_set(const sc_signed& src, int low_i)
+{
+    if ( low_i < src.length() )
+        *this = src >> low_i;
+    else
+        *this = (src<0) ? (int_type)-1 : 0;
+}       
+
+void sc_unsigned::concat_set(const sc_unsigned& src, int low_i)
+{
+    if ( low_i < src.length() )
+        *this = src >> low_i;
+    else
+        *this = 0;
+}
+
+void sc_unsigned::concat_set(uint64 src, int low_i)
+{
+    *this = (low_i < 64) ? src >> low_i : 0;
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Public members - Reduction methods.
+// ----------------------------------------------------------------------------
+
+bool sc_unsigned::and_reduce() const
+{
+    int i;   // Digit examining.
+
+	if ( sgn == SC_ZERO ) return false;
+    for ( i = 0; i < ndigits-1; i++ )
+        if ( (digit[i] & DIGIT_MASK) != DIGIT_MASK ) return false;
+    if ( (digit[i] & ~(-1 << ((nbits-1) % BITS_PER_DIGIT))) ==
+        (sc_digit)~(-1 << ((nbits-1) % BITS_PER_DIGIT)))
+		return true;
+    return false;
+}
+
+bool sc_unsigned::or_reduce() const
+{
+	return ( sgn == SC_ZERO ) ? false : true;
+}
+
+bool sc_unsigned::xor_reduce() const
+{
+    int i;   // Digit examining.
+    int odd; // Flag for odd number of digits.
+
+    odd = 0;
+    for ( i = 0; i < nbits-1; i++ )
+	if ( test(i) ) odd = ~odd;
+    return odd ? true : false;
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Public members - Assignment operators.
+// ----------------------------------------------------------------------------
+
+// assignment operators
+
+const sc_unsigned&
+sc_unsigned::operator = ( const char* a )
+{
+    if( a == 0 ) {
+        SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_,
+                         "character string is zero" );
+    }
+    if( *a == 0 ) {
+        SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_,
+                         "character string is empty" );
+    }
+    try {     
+        int len = length();
+        sc_ufix aa( a, len, len, SC_TRN, SC_WRAP, 0, SC_ON );
+        return this->operator = ( aa );
+    } catch( sc_core::sc_report ) {
+        char msg[BUFSIZ];
+        std::sprintf( msg, "character string '%s' is not valid", a );
+        SC_REPORT_ERROR( sc_core::SC_ID_CONVERSION_FAILED_, msg );
+        // never reached
+    }
+    return *this;
+} 
+
+const sc_unsigned&
+sc_unsigned::operator=(int64 v)
+{
+  sgn = get_sign(v);
+  if ( sgn == SC_ZERO ) {
+    vec_zero(ndigits, digit);
+  }
+  else {
+    from_uint(ndigits, digit, (uint64) v);
+    convert_SM_to_2C_to_SM(); 
+  }
+  return *this;
+}
+
+const sc_unsigned&
+sc_unsigned::operator=(uint64 v)
+{
+  if (v == 0) {
+    sgn = SC_ZERO;
+    vec_zero(ndigits, digit);
+  }
+  else {
+    sgn = SC_POS;
+    from_uint(ndigits, digit, v);
+    convert_SM_to_2C_to_SM();
+  }
+  return *this;
+}
+
+const sc_unsigned&
+sc_unsigned::operator=(long v)
+{
+  sgn = get_sign(v);
+  if ( sgn == SC_ZERO ) {
+    vec_zero(ndigits, digit);
+  }
+  else {
+    from_uint(ndigits, digit, (unsigned long) v);
+    convert_SM_to_2C_to_SM(); 
+  }
+  return *this;
+}
+
+const sc_unsigned&
+sc_unsigned::operator=(unsigned long v)
+{
+  if (v == 0) {
+    sgn = SC_ZERO;
+    vec_zero(ndigits, digit);
+  }
+  else {
+    sgn = SC_POS;
+    from_uint(ndigits, digit, v);
+    convert_SM_to_2C_to_SM();
+  }
+  return *this;
+}
+
+const sc_unsigned&
+sc_unsigned::operator=(double v)
+{
+  is_bad_double(v);
+  sgn = SC_POS;
+  int i = 0;
+  while (floor(v) && (i < ndigits)) {
+#ifndef _WIN32
+    digit[i++] = ((sc_digit)floor(remainder(v, DIGIT_RADIX))) & DIGIT_MASK;
+#else
+    digit[i++] = ((sc_digit)floor(fmod(v, DIGIT_RADIX))) & DIGIT_MASK;
+#endif
+    v /= DIGIT_RADIX;
+  }
+  vec_zero(i, ndigits, digit);
+  convert_SM_to_2C_to_SM();
+  return *this;  
+}
+
+
+// ----------------------------------------------------------------------------
+
+const sc_unsigned&
+sc_unsigned::operator = ( const sc_bv_base& v )
+{
+    int minlen = sc_min( nbits, v.length() );
+    int i = 0;
+    for( ; i < minlen; ++ i ) {
+	safe_set( i, v.get_bit( i ), digit );
+    }
+    for( ; i < nbits; ++ i ) {
+	safe_set( i, 0, digit );  // zero-extend
+    }
+    convert_2C_to_SM();
+    return *this;
+}
+
+const sc_unsigned&
+sc_unsigned::operator = ( const sc_lv_base& v )
+{
+    int minlen = sc_min( nbits, v.length() );
+    int i = 0;
+    for( ; i < minlen; ++ i ) {
+	safe_set( i, sc_logic( v.get_bit( i ) ).to_bool(), digit );
+    }
+    for( ; i < nbits; ++ i ) {
+	safe_set( i, 0, digit );  // zero-extend
+    }
+    convert_2C_to_SM();
+    return *this;
+}
+
+
+// explicit conversion to character string
+
+const std::string
+sc_unsigned::to_string( sc_numrep numrep ) const
+{
+    int len = length();
+    sc_ufix aa( *this, len, len, SC_TRN, SC_WRAP, 0, SC_ON );
+    return aa.to_string( numrep );
+}
+
+const std::string
+sc_unsigned::to_string( sc_numrep numrep, bool w_prefix ) const
+{
+    int len = length();
+    sc_ufix aa( *this, len, len, SC_TRN, SC_WRAP, 0, SC_ON );
+    return aa.to_string( numrep, w_prefix );
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Interfacing with sc_int_base
+// ----------------------------------------------------------------------------
+
+const sc_unsigned& 
+sc_unsigned::operator= (const sc_int_base& v)
+{ return operator=((int64) v); }
+
+const sc_unsigned& 
+sc_unsigned::operator+=(const sc_int_base& v)
+{ return operator+=((int64) v); }
+
+const sc_unsigned& 
+sc_unsigned::operator-=(const sc_int_base& v)
+{ return operator-=((int64) v); }
+
+const sc_unsigned& 
+sc_unsigned::operator*=(const sc_int_base& v)
+{ return operator*=((int64) v); }
+
+const sc_unsigned& 
+sc_unsigned::operator/=(const sc_int_base& v)
+{ return operator/=((int64) v); }
+
+const sc_unsigned& 
+sc_unsigned::operator%=(const sc_int_base& v)
+{ return operator%=((int64) v); }
+
+const sc_unsigned& 
+sc_unsigned::operator&=(const sc_int_base& v)
+{ return operator&=((int64) v); }
+
+const sc_unsigned& 
+sc_unsigned::operator|=(const sc_int_base& v)
+{ return operator|=((int64) v); }
+
+const sc_unsigned& 
+sc_unsigned::operator^=(const sc_int_base& v)
+{ return operator^=((int64) v); }
+
+sc_unsigned 
+operator<<(const sc_unsigned& u, const sc_int_base& v)
+{ return operator<<(u, (int64) v); }
+const sc_unsigned& 
+sc_unsigned::operator<<=(const sc_int_base& v)
+{ return operator<<=((int64) v); }
+
+sc_unsigned 
+operator>>(const sc_unsigned&    u, const sc_int_base&  v)
+{ return operator>>(u, (int64) v); }
+const sc_unsigned& 
+sc_unsigned::operator>>=(const sc_int_base&  v)
+{ return operator>>=((int64) v); }
+
+bool 
+operator==(const sc_unsigned& u, const sc_int_base& v)
+{ return operator==(u, (int64) v); }
+bool 
+operator==(const sc_int_base& u, const sc_unsigned& v) 
+{ return operator==((int64) u, v); }
+
+bool 
+operator!=(const sc_unsigned& u, const sc_int_base& v)
+{ return operator!=(u, (int64) v); }
+bool 
+operator!=(const sc_int_base& u, const sc_unsigned& v) 
+{ return operator!=((int64) u, v); }
+
+bool 
+operator<(const sc_unsigned& u, const sc_int_base& v)
+{ return operator<(u, (int64) v); }
+bool 
+operator<(const sc_int_base& u, const sc_unsigned& v) 
+{ return operator<((int64) u, v); }
+
+bool 
+operator<=(const sc_unsigned& u, const sc_int_base& v)
+{ return operator<=(u, (int64) v); }
+bool 
+operator<=(const sc_int_base& u, const sc_unsigned& v) 
+{ return operator<=((int64) u, v); }
+
+bool 
+operator>(const sc_unsigned& u, const sc_int_base& v)
+{ return operator>(u, (int64) v); }
+bool 
+operator>(const sc_int_base& u, const sc_unsigned& v) 
+{ return operator>((int64) u, v); }
+
+bool 
+operator>=(const sc_unsigned& u, const sc_int_base& v)
+{ return operator>=(u, (int64) v); }
+bool 
+operator>=(const sc_int_base& u, const sc_unsigned& v) 
+{ return operator>=((int64) u, v); }
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Interfacing with sc_uint_base
+// ----------------------------------------------------------------------------
+
+const sc_unsigned& 
+sc_unsigned::operator= (const sc_uint_base& v)
+{ return operator=((uint64) v); }
+
+sc_unsigned 
+operator+(const sc_unsigned& u, const sc_uint_base& v) 
+{ return operator+(u, (uint64) v); }
+sc_unsigned 
+operator+(const sc_uint_base& u, const sc_unsigned& v) 
+{ return operator+((uint64) u, v); }
+const sc_unsigned& 
+sc_unsigned::operator+=(const sc_uint_base& v)
+{ return operator+=((uint64) v); }
+
+const sc_unsigned& 
+sc_unsigned::operator-=(const sc_uint_base& v)
+{ return operator-=((uint64) v); }
+
+sc_unsigned 
+operator*(const sc_unsigned& u, const sc_uint_base& v) 
+{ return operator*(u, (uint64) v); }
+sc_unsigned 
+operator*(const sc_uint_base& u, const sc_unsigned& v) 
+{ return operator*((uint64) u, v); }
+const sc_unsigned& 
+sc_unsigned::operator*=(const sc_uint_base& v)
+{ return operator*=((uint64) v); }
+
+sc_unsigned 
+operator/(const sc_unsigned& u, const sc_uint_base& v) 
+{ return operator/(u, (uint64) v); }
+sc_unsigned 
+operator/(const sc_uint_base& u, const sc_unsigned& v) 
+{ return operator/((uint64) u, v); }
+const sc_unsigned& 
+sc_unsigned::operator/=(const sc_uint_base& v)
+{ return operator/=((uint64) v); }
+
+sc_unsigned 
+operator%(const sc_unsigned& u, const sc_uint_base& v) 
+{ return operator%(u, (uint64) v); }
+sc_unsigned 
+operator%(const sc_uint_base& u, const sc_unsigned& v) 
+{ return operator%((uint64) u, v); }
+const sc_unsigned& 
+sc_unsigned::operator%=(const sc_uint_base& v)
+{ return operator%=((uint64) v); }
+
+sc_unsigned 
+operator&(const sc_unsigned& u, const sc_uint_base& v) 
+{ return operator&(u, (uint64) v); }
+sc_unsigned 
+operator&(const sc_uint_base& u, const sc_unsigned& v) 
+{ return operator&((uint64) u, v); }
+const sc_unsigned& 
+sc_unsigned::operator&=(const sc_uint_base& v)
+{ return operator&=((uint64) v); }
+
+sc_unsigned 
+operator|(const sc_unsigned& u, const sc_uint_base& v) 
+{ return operator|(u, (uint64) v); }
+sc_unsigned 
+operator|(const sc_uint_base& u, const sc_unsigned& v) 
+{ return operator|((uint64) u, v); }
+const sc_unsigned& 
+sc_unsigned::operator|=(const sc_uint_base& v)
+{ return operator|=((uint64) v); }
+
+sc_unsigned 
+operator^(const sc_unsigned& u, const sc_uint_base& v) 
+{ return operator^(u, (uint64) v); }
+sc_unsigned 
+operator^(const sc_uint_base& u, const sc_unsigned& v) 
+{ return operator^((uint64) u, v); }
+const sc_unsigned& 
+sc_unsigned::operator^=(const sc_uint_base& v)
+{ return operator^=((uint64) v); }
+
+sc_unsigned 
+operator<<(const sc_unsigned& u, const sc_uint_base& v)
+{ return operator<<(u, (uint64) v); }
+const sc_unsigned& 
+sc_unsigned::operator<<=(const sc_uint_base& v)
+{ return operator<<=((uint64) v); }
+
+sc_unsigned 
+operator>>(const sc_unsigned&    u, const sc_uint_base&  v)
+{ return operator>>(u, (uint64) v); }
+const sc_unsigned& 
+sc_unsigned::operator>>=(const sc_uint_base&  v)
+{ return operator>>=((uint64) v); }
+
+bool 
+operator==(const sc_unsigned& u, const sc_uint_base& v)
+{ return operator==(u, (uint64) v); }
+bool 
+operator==(const sc_uint_base& u, const sc_unsigned& v) 
+{ return operator==((uint64) u, v); }
+
+bool 
+operator!=(const sc_unsigned& u, const sc_uint_base& v)
+{ return operator!=(u, (uint64) v); }
+bool 
+operator!=(const sc_uint_base& u, const sc_unsigned& v) 
+{ return operator!=((uint64) u, v); }
+
+bool 
+operator<(const sc_unsigned& u, const sc_uint_base& v)
+{ return operator<(u, (uint64) v); }
+bool 
+operator<(const sc_uint_base& u, const sc_unsigned& v) 
+{ return operator<((uint64) u, v); }
+
+bool 
+operator<=(const sc_unsigned& u, const sc_uint_base& v)
+{ return operator<=(u, (uint64) v); }
+bool 
+operator<=(const sc_uint_base& u, const sc_unsigned& v) 
+{ return operator<=((uint64) u, v); }
+
+bool 
+operator>(const sc_unsigned& u, const sc_uint_base& v)
+{ return operator>(u, (uint64) v); }
+bool 
+operator>(const sc_uint_base& u, const sc_unsigned& v) 
+{ return operator>((uint64) u, v); }
+
+bool 
+operator>=(const sc_unsigned& u, const sc_uint_base& v)
+{ return operator>=(u, (uint64) v); }
+bool 
+operator>=(const sc_uint_base& u, const sc_unsigned& v) 
+{ return operator>=((uint64) u, v); }
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Input and output operators
+// ----------------------------------------------------------------------------
+
+// The operators in this section are included from sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Operator macros.
+// ----------------------------------------------------------------------------
+
+#define CONVERT_LONG(u) \
+small_type u ## s = get_sign(u);                   \
+sc_digit u ## d[DIGITS_PER_ULONG];                    \
+from_uint(DIGITS_PER_ULONG, u ## d, (unsigned long) u); 
+
+#define CONVERT_LONG_2(u) \
+sc_digit u ## d[DIGITS_PER_ULONG];                     \
+from_uint(DIGITS_PER_ULONG, u ## d, (unsigned long) u); 
+
+#define CONVERT_INT(u) \
+small_type u ## s = get_sign(u);                        \
+sc_digit u ## d[DIGITS_PER_UINT];                    \
+from_uint(DIGITS_PER_UINT, u ## d, (unsigned int) u); 
+
+#define CONVERT_INT_2(u) \
+sc_digit u ## d[DIGITS_PER_UINT];                     \
+from_uint(DIGITS_PER_UINT, u ## d, (unsigned int) u); 
+
+#define CONVERT_INT64(u) \
+small_type u ## s = get_sign(u);                   \
+sc_digit u ## d[DIGITS_PER_UINT64];              \
+from_uint(DIGITS_PER_UINT64, u ## d, (uint64) u); 
+
+#define CONVERT_INT64_2(u) \
+sc_digit u ## d[DIGITS_PER_UINT64];              \
+from_uint(DIGITS_PER_UINT64, u ## d, (uint64) u); 
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: PLUS operators: +, +=, ++
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u + v:
+// 1. 0 + v = v
+// 2. u + 0 = u
+// 3. if sgn(u) == sgn(v)
+//    3.1 u + v = +(u + v) = sgn(u) * (u + v) 
+//    3.2 (-u) + (-v) = -(u + v) = sgn(u) * (u + v)
+// 4. if sgn(u) != sgn(v)
+//    4.1 u + (-v) = u - v = sgn(u) * (u - v)
+//    4.2 (-u) + v = -(u - v) ==> sgn(u) * (u - v)
+//
+// Specialization of above cases for computing ++u or u++: 
+// 1. 0 + 1 = 1
+// 3. u + 1 = u + 1 = sgn(u) * (u + 1)
+// 4. (-u) + 1 = -(u - 1) = sgn(u) * (u - 1)
+
+sc_unsigned
+operator+(const sc_unsigned& u, const sc_unsigned& v)
+{
+
+  if (u.sgn == SC_ZERO) // case 1
+    return sc_unsigned(v);
+
+  if (v.sgn == SC_ZERO) // case 2
+    return sc_unsigned(u);
+
+  // cases 3 and 4
+  return add_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+  
+}
+
+
+sc_unsigned
+operator+(const sc_unsigned &u, uint64 v)
+{
+
+  if (v == 0)  // case 2
+    return sc_unsigned(u);
+
+  CONVERT_INT64(v);
+
+  if (u.sgn == SC_ZERO)  // case 1
+    return sc_unsigned(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+  // cases 3 and 4
+  return add_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+}
+
+
+sc_unsigned
+operator+(uint64 u, const sc_unsigned &v)
+{
+
+  if (u == 0) // case 1
+    return sc_unsigned(v);
+
+  CONVERT_INT64(u);
+
+  if (v.sgn == SC_ZERO)  // case 2
+    return sc_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+  // cases 3 and 4
+
+  return add_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_unsigned
+operator+(const sc_unsigned &u, unsigned long v)
+{
+
+  if (v == 0) // case 2
+    return sc_unsigned(u);
+
+  CONVERT_LONG(v);
+
+  if (u.sgn == SC_ZERO)  // case 1
+    return sc_unsigned(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+  // cases 3 and 4
+  return add_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+}
+
+
+sc_unsigned
+operator+(unsigned long u, const sc_unsigned &v)
+{
+
+  if (u == 0) // case 1
+    return sc_unsigned(v);
+
+  CONVERT_LONG(u);
+
+  if (v.sgn == SC_ZERO)  // case 2
+    return sc_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+  // cases 3 and 4
+  return add_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: MINUS operators: -, -=, --
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u + v:
+// 1. u - 0 = u 
+// 2. 0 - v = -v
+// 3. if sgn(u) != sgn(v)
+//    3.1 u - (-v) = u + v = sgn(u) * (u + v)
+//    3.2 (-u) - v = -(u + v) ==> sgn(u) * (u + v)
+// 4. if sgn(u) == sgn(v)
+//    4.1 u - v = +(u - v) = sgn(u) * (u - v) 
+//    4.2 (-u) - (-v) = -(u - v) = sgn(u) * (u - v)
+//
+// Specialization of above cases for computing --u or u--: 
+// 1. 0 - 1 = -1
+// 3. (-u) - 1 = -(u + 1) = sgn(u) * (u + 1)
+// 4. u - 1 = u - 1 = sgn(u) * (u - 1)
+
+// The operators in this section are included from sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: MULTIPLICATION operators: *, *=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u * v:
+// 1. u * 0 = 0 * v = 0
+// 2. 1 * v = v and -1 * v = -v
+// 3. u * 1 = u and u * -1 = -u
+// 4. u * v = u * v
+
+sc_unsigned
+operator*(const sc_unsigned& u, const sc_unsigned& v)
+{
+ 
+  small_type s = mul_signs(u.sgn, v.sgn);
+
+  if (s == SC_ZERO) // case 1
+    return sc_unsigned();
+
+  // cases 2-4
+  return mul_unsigned_friend(s, u.nbits, u.ndigits, u.digit,
+                             v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_unsigned
+operator*(const sc_unsigned& u, uint64 v)
+{
+
+  small_type s = mul_signs(u.sgn, get_sign(v));
+
+  if (s == SC_ZERO) // case 1
+    return sc_unsigned();
+
+  CONVERT_INT64_2(v);
+
+  // cases 2-4
+  return mul_unsigned_friend(s, u.nbits, u.ndigits, u.digit, 
+                             BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+  
+}
+
+
+sc_unsigned
+operator*(uint64 u, const sc_unsigned& v)
+{
+
+  small_type s = mul_signs(v.sgn, get_sign(u));
+
+  if (s == SC_ZERO) // case 1
+    return sc_unsigned();
+
+  CONVERT_INT64_2(u);
+
+  // cases 2-4
+  return mul_unsigned_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 
+                             v.nbits, v.ndigits, v.digit);
+  
+}
+
+
+sc_unsigned
+operator*(const sc_unsigned& u, unsigned long v)
+{
+
+  small_type s = mul_signs(u.sgn, get_sign(v));
+
+  if (s == SC_ZERO) // case 1
+    return sc_unsigned();
+
+  CONVERT_LONG_2(v);
+
+  // else cases 2-4
+  return mul_unsigned_friend(s, u.nbits, u.ndigits, u.digit, 
+                             BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+  
+}
+
+sc_unsigned
+operator*(unsigned long u, const sc_unsigned& v)
+{
+
+  small_type s = mul_signs(v.sgn, get_sign(u));
+
+  if (s == SC_ZERO) // case 1
+    return sc_unsigned();
+
+  CONVERT_LONG_2(u);
+
+  // cases 2-4
+  return mul_unsigned_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 
+                             v.nbits, v.ndigits, v.digit);
+  
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: DIVISION operators: /, /=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when finding the quotient q = floor(u/v):
+// Note that u = q * v + r for r < q.
+// 1. 0 / 0 or u / 0 => error
+// 2. 0 / v => 0 = 0 * v + 0
+// 3. u / v && u = v => u = 1 * u + 0  - u or v can be 1 or -1
+// 4. u / v && u < v => u = 0 * v + u  - u can be 1 or -1
+// 5. u / v && u > v => u = q * v + r  - v can be 1 or -1
+
+sc_unsigned
+operator/(const sc_unsigned& u, const sc_unsigned& v)
+{
+
+  small_type s = mul_signs(u.sgn, v.sgn);
+
+  if (s == SC_ZERO) {
+    div_by_zero(v.sgn); // case 1
+    return sc_unsigned();  // case 2
+  }
+
+  // other cases
+  return div_unsigned_friend(s, u.nbits, u.ndigits, u.digit,
+                             v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_unsigned
+operator/(const sc_unsigned& u, uint64 v)
+{
+
+  small_type s = mul_signs(u.sgn, get_sign(v));
+
+  if (s == SC_ZERO) {
+    div_by_zero(v);  // case 1
+    return sc_unsigned();  // case 2
+  }
+
+  CONVERT_INT64_2(v);
+
+  // other cases
+  return div_unsigned_friend(s, u.nbits, u.ndigits, u.digit, 
+                             BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+  
+}
+
+
+sc_unsigned
+operator/(uint64 u, const sc_unsigned& v)
+{
+
+  small_type s = mul_signs(v.sgn, get_sign(u));
+
+  if (s == SC_ZERO) {
+    div_by_zero(v.sgn);  // case 1
+    return sc_unsigned();  // case 2
+
+  }
+
+  CONVERT_INT64_2(u);
+
+  // other cases
+  return div_unsigned_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, 
+                             v.nbits, v.ndigits, v.digit);
+  
+}
+
+
+sc_unsigned
+operator/(const sc_unsigned& u, unsigned long v)
+{
+
+  small_type s = mul_signs(u.sgn, get_sign(v));
+
+  if (s == SC_ZERO) {
+    div_by_zero(v);  // case 1
+    return sc_unsigned();  // case 2
+  }
+
+  CONVERT_LONG_2(v);
+
+  // other cases
+  return div_unsigned_friend(s, u.nbits, u.ndigits, u.digit, 
+                             BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+  
+}
+
+
+sc_unsigned
+operator/(unsigned long u, const sc_unsigned& v)
+{
+
+  small_type s = mul_signs(v.sgn, get_sign(u));
+
+  if (s == SC_ZERO) {
+    div_by_zero(v.sgn);  // case 1
+    return sc_unsigned();  // case 2
+
+  }
+
+  CONVERT_LONG_2(u);
+
+  // other cases
+  return div_unsigned_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, 
+                             v.nbits, v.ndigits, v.digit);
+  
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: MOD operators: %, %=.
+// ----------------------------------------------------------------------------
+
+// Cases to consider when finding the remainder r = u % v:
+// Note that u = q * v + r for r < q.
+// 1. 0 % 0 or u % 0 => error
+// 2. 0 % v => 0 = 0 * v + 0
+// 3. u % v && u = v => u = 1 * u + 0  - u or v can be 1 or -1
+// 4. u % v && u < v => u = 0 * v + u  - u can be 1 or -1
+// 5. u % v && u > v => u = q * v + r  - v can be 1 or -1
+
+sc_unsigned
+operator%(const sc_unsigned& u, const sc_unsigned& v)
+{
+
+  if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
+    div_by_zero(v.sgn);  // case 1
+    return sc_unsigned();  // case 2
+  }
+
+  // other cases
+  return mod_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_unsigned
+operator%(const sc_unsigned& u, uint64 v)
+{
+
+  if ((u.sgn == SC_ZERO) || (v == 0)) {
+    div_by_zero(v);  // case 1
+    return sc_unsigned();  // case 2
+  }
+
+  CONVERT_INT64_2(v);
+
+  // other cases
+  return mod_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+}
+
+
+sc_unsigned
+operator%(uint64 u, const sc_unsigned& v)
+{
+
+  if ((u == 0) || (v.sgn == SC_ZERO)) {
+    div_by_zero(v.sgn);  // case 1
+    return sc_unsigned();  // case 2
+  }
+
+  CONVERT_INT64(u);
+
+  // other cases
+  return mod_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                             v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_unsigned
+operator%(const sc_unsigned& u, unsigned long v)
+{
+
+  if ((u.sgn == SC_ZERO) || (v == 0)) {
+    div_by_zero(v);  // case 1
+    return sc_unsigned();  // case 2
+  }
+
+  CONVERT_LONG_2(v);
+
+  // other cases
+  return mod_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+}
+
+
+sc_unsigned
+operator%(unsigned long u, const sc_unsigned& v)
+{
+
+  if ((u == 0) || (v.sgn == SC_ZERO)) {
+    div_by_zero(v.sgn);  // case 1
+    return sc_unsigned();  // case 2
+  }
+
+  CONVERT_LONG(u);
+
+  // other cases
+  return mod_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                             v.nbits, v.ndigits, v.digit);
+
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Bitwise AND operators: &, &=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u & v:
+// 1. u & 0 = 0 & v = 0
+// 2. u & v => sgn = +
+// 3. (-u) & (-v) => sgn = -
+// 4. u & (-v) => sgn = +
+// 5. (-u) & v => sgn = +
+
+sc_unsigned
+operator&(const sc_unsigned& u, const sc_unsigned& v)
+{
+
+  if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1
+    return sc_unsigned();
+
+  // other cases
+  return and_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_unsigned
+operator&(const sc_unsigned& u, uint64 v)
+{
+
+  if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
+    return sc_unsigned();
+
+  CONVERT_INT64(v);
+
+  // other cases
+  return and_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+  
+}
+
+
+sc_unsigned
+operator&(uint64 u, const sc_unsigned& v)
+{
+
+  if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
+    return sc_unsigned();
+
+  CONVERT_INT64(u);
+
+  // other cases
+  return and_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_unsigned
+operator&(const sc_unsigned& u, unsigned long v)
+{
+
+  if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
+    return sc_unsigned();
+
+  CONVERT_LONG(v);
+
+  // other cases
+  return and_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+}
+
+
+sc_unsigned
+operator&(unsigned long u, const sc_unsigned& v)
+{
+
+  if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
+    return sc_unsigned();
+
+  CONVERT_LONG(u);
+
+  // other cases
+  return and_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Bitwise OR operators: |, |=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u | v:
+// 1. u | 0 = u
+// 2. 0 | v = v
+// 3. u | v => sgn = +
+// 4. (-u) | (-v) => sgn = -
+// 5. u | (-v) => sgn = -
+// 6. (-u) | v => sgn = -
+
+sc_unsigned
+operator|(const sc_unsigned& u, const sc_unsigned& v)
+{
+
+  if (v.sgn == SC_ZERO)  // case 1
+    return sc_unsigned(u);
+
+  if (u.sgn == SC_ZERO)  // case 2
+    return sc_unsigned(v);
+
+  // other cases
+  return or_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                            v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_unsigned
+operator|(const sc_unsigned& u, uint64 v)
+{
+
+  if (v == 0)  // case 1
+    return sc_unsigned(u);
+
+  CONVERT_INT64(v);
+
+  if (u.sgn == SC_ZERO)  // case 2
+    return sc_unsigned(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+  // other cases
+  return or_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                            vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+}
+
+
+sc_unsigned
+operator|(uint64 u, const sc_unsigned& v)
+{
+
+  if (u == 0)
+    return sc_unsigned(v);
+
+  CONVERT_INT64(u);
+
+  if (v.sgn == SC_ZERO)
+    return sc_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+  // other cases
+  return or_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                            v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_unsigned
+operator|(const sc_unsigned& u, unsigned long v)
+{
+
+  if (v == 0)  // case 1
+    return sc_unsigned(u);
+
+  CONVERT_LONG(v);
+
+  if (u.sgn == SC_ZERO)  // case 2
+    return sc_unsigned(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+  // other cases
+  return or_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                            vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+}
+
+
+sc_unsigned
+operator|(unsigned long u, const sc_unsigned& v)
+{
+
+  if (u == 0)
+    return sc_unsigned(v);
+
+  CONVERT_LONG(u);
+
+  if (v.sgn == SC_ZERO)
+    return sc_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+  // other cases
+  return or_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                            v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Bitwise XOR operators: ^, ^=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u ^ v:
+// Note that  u ^ v = (~u & v) | (u & ~v).
+// 1. u ^ 0 = u
+// 2. 0 ^ v = v
+// 3. u ^ v => sgn = +
+// 4. (-u) ^ (-v) => sgn = -
+// 5. u ^ (-v) => sgn = -
+// 6. (-u) ^ v => sgn = +
+
+sc_unsigned
+operator^(const sc_unsigned& u, const sc_unsigned& v)
+{
+
+  if (v.sgn == SC_ZERO)  // case 1
+    return sc_unsigned(u);
+
+  if (u.sgn == SC_ZERO)  // case 2
+    return sc_unsigned(v);
+
+  // other cases
+  return xor_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_unsigned
+operator^(const sc_unsigned& u, uint64 v)
+{
+
+  if (v == 0)  // case 1
+    return sc_unsigned(u);
+
+  CONVERT_INT64(v);
+
+  if (u.sgn == SC_ZERO)  // case 2
+    return sc_unsigned(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+  // other cases
+  return xor_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+}
+
+sc_unsigned
+operator^(uint64 u, const sc_unsigned& v)
+{
+  if (u == 0)
+    return sc_unsigned(v);
+
+  CONVERT_INT64(u);
+
+  if (v.sgn == SC_ZERO)
+    return sc_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+  // other cases
+  return xor_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_unsigned
+operator^(const sc_unsigned& u, unsigned long v)
+{
+
+  if (v == 0)  // case 1
+    return sc_unsigned(u);
+
+  CONVERT_LONG(v);
+
+  if (u.sgn == SC_ZERO)  // case 2
+    return sc_unsigned(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+  // other cases
+  return xor_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+}
+
+sc_unsigned
+operator^(unsigned long u, const sc_unsigned& v)
+{
+  if (u == 0)
+    return sc_unsigned(v);
+
+  CONVERT_LONG(u);
+
+  if (v.sgn == SC_ZERO)
+    return sc_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+  // other cases
+  return xor_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Bitwise NOT operator: ~
+// ----------------------------------------------------------------------------
+
+// Operators in this section are included from sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: LEFT SHIFT operators: <<, <<=
+// ----------------------------------------------------------------------------
+
+sc_unsigned
+operator<<(const sc_unsigned& u, const sc_signed& v)
+{
+  if ((v.sgn == SC_ZERO) || (v.sgn == SC_NEG))
+    return sc_unsigned(u);
+
+  return operator<<(u, v.to_ulong());
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: RIGHT SHIFT operators: >>, >>=
+// ----------------------------------------------------------------------------
+
+sc_unsigned
+operator>>(const sc_unsigned& u, const sc_signed& v)
+{
+
+  if ((v.sgn == SC_ZERO) || (v.sgn == SC_NEG))
+    return sc_unsigned(u);
+
+  return operator>>(u, v.to_long());
+
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Unary arithmetic operators.
+// ----------------------------------------------------------------------------
+
+sc_unsigned
+operator+(const sc_unsigned& u)
+{
+  return sc_unsigned(u);
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: EQUAL operator: ==
+// ----------------------------------------------------------------------------
+
+bool
+operator==(const sc_unsigned& u, const sc_unsigned& v)
+{
+  if (&u == &v)
+    return true;
+  if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
+                       v.sgn, v.nbits, v.ndigits, v.digit) != 0)
+    return false;
+  return true;
+}
+
+
+bool
+operator==(const sc_unsigned& u, const sc_signed& v)
+{
+  if (v.sgn == SC_NEG)
+    return false;
+  if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
+                       v.sgn, v.nbits, v.ndigits, v.digit, 0, 1) != 0)
+    return false;
+  return true;
+}
+
+
+bool
+operator==(const sc_signed& u, const sc_unsigned& v)
+{
+  if (u.sgn == SC_NEG)
+    return false;
+  if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
+                       v.sgn, v.nbits, v.ndigits, v.digit, 1, 0) != 0)
+    return false;
+  return true;
+}
+
+
+bool
+operator==(const sc_unsigned& u, int64 v)
+{
+  if (v < 0)
+    return false;
+  CONVERT_INT64(v);
+  if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
+                       vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd) != 0)
+    return false;
+  return true;
+}
+
+
+bool
+operator==(int64 u, const sc_unsigned& v)
+{
+  if (u < 0)
+    return false;
+  CONVERT_INT64(u);
+  if (compare_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                       v.sgn, v.nbits, v.ndigits, v.digit) != 0)
+    return false;
+  return true;
+}
+
+
+bool
+operator==(const sc_unsigned& u, uint64 v)
+{
+  CONVERT_INT64(v);
+  if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
+                       vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd) != 0)
+    return false;
+  return true;
+}
+
+
+bool
+operator==(uint64 u, const sc_unsigned& v)
+{
+  CONVERT_INT64(u);
+  if (compare_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                       v.sgn, v.nbits, v.ndigits, v.digit) != 0)
+    return false;
+  return true;
+}
+
+
+bool
+operator==(const sc_unsigned& u, long v)
+{
+  if (v < 0)
+    return false;
+  CONVERT_LONG(v);
+  if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
+                       vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd) != 0)
+    return false;
+  return true;
+}
+
+
+bool
+operator==(long u, const sc_unsigned& v)
+{
+  if (u < 0)
+    return false;
+  CONVERT_LONG(u);
+  if (compare_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                       v.sgn, v.nbits, v.ndigits, v.digit) != 0)
+    return false;
+  return true;
+}
+
+
+bool
+operator==(const sc_unsigned& u, unsigned long v)
+{
+  CONVERT_LONG(v);
+  if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
+                       vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd) != 0)
+    return false;
+  return true;
+}
+
+
+bool
+operator==(unsigned long u, const sc_unsigned& v)
+{
+  CONVERT_LONG(u);
+  if (compare_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                       v.sgn, v.nbits, v.ndigits, v.digit) != 0)
+    return false;
+  return true;
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: NOT_EQUAL operator: !=
+// ----------------------------------------------------------------------------
+
+bool
+operator!=(const sc_unsigned& u, const sc_signed& v)
+{
+  return (! operator==(u, v));
+}
+
+
+bool
+operator!=(const sc_signed& u, const sc_unsigned& v)
+{
+  return (! operator==(u, v));
+}
+
+// The rest of the operators in this section are included from sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: LESS THAN operator: <
+// ----------------------------------------------------------------------------
+
+bool
+operator<(const sc_unsigned& u, const sc_unsigned& v)
+{
+  if (&u == &v)
+    return false;
+  if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
+                       v.sgn, v.nbits, v.ndigits, v.digit) < 0)
+    return true;
+  return false;
+}
+
+
+bool
+operator<(const sc_unsigned& u, const sc_signed& v)
+{
+  if (v.sgn == SC_NEG)
+    return false;
+  if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
+                       v.sgn, v.nbits, v.ndigits, v.digit, 0, 1) < 0)
+    return true;
+  return false;
+}
+
+
+bool
+operator<(const sc_signed& u, const sc_unsigned& v)
+{
+  if (u.sgn == SC_NEG)
+    return true;
+  if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
+                       v.sgn, v.nbits, v.ndigits, v.digit, 1, 0) < 0)
+    return true;
+  return false;
+}
+
+
+bool
+operator<(const sc_unsigned& u, int64 v)
+{
+  if (v < 0)
+    return false;
+  CONVERT_INT64(v);
+  if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
+                       vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd) < 0)
+    return true;
+  return false;
+}
+
+
+bool
+operator<(int64 u, const sc_unsigned& v)
+{
+  if (u < 0)
+    return true;
+  CONVERT_INT64(u);
+  if (compare_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                       v.sgn, v.nbits, v.ndigits, v.digit) < 0)
+    return true;
+  return false;
+}
+
+
+bool
+operator<(const sc_unsigned& u, uint64 v)
+{
+  CONVERT_INT64(v);
+  if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
+                       vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd) < 0)
+    return true;
+  return false;
+}
+
+
+bool
+operator<(uint64 u, const sc_unsigned& v)
+{
+  CONVERT_INT64(u);
+  if (compare_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                       v.sgn, v.nbits, v.ndigits, v.digit) < 0)
+    return true;
+  return false;    
+}
+
+
+bool
+operator<(const sc_unsigned& u, long v)
+{
+  if (v < 0)
+    return false;
+  CONVERT_LONG(v);
+  if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
+                       vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd) < 0)
+    return true;
+  return false;
+}
+
+
+bool
+operator<(long u, const sc_unsigned& v)
+{
+  if (u < 0)
+    return true;
+  CONVERT_LONG(u);
+  if (compare_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                       v.sgn, v.nbits, v.ndigits, v.digit) < 0)
+    return true;
+  return false;
+}
+
+
+bool
+operator<(const sc_unsigned& u, unsigned long v)
+{
+  CONVERT_LONG(v);
+  if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit, 
+                       vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd) < 0)
+    return true;
+  return false;
+}
+
+
+bool
+operator<(unsigned long u, const sc_unsigned& v)
+{
+  CONVERT_LONG(u);
+  if (compare_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                       v.sgn, v.nbits, v.ndigits, v.digit) < 0)
+    return true;
+  return false;    
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: LESS THAN or EQUAL operator: <=
+// ----------------------------------------------------------------------------
+
+bool
+operator<=(const sc_unsigned& u, const sc_signed& v)
+{
+  return (operator<(u, v) || operator==(u, v));
+}
+
+
+bool
+operator<=(const sc_signed& u, const sc_unsigned& v)
+{
+  return (operator<(u, v) || operator==(u, v));
+}
+
+// The rest of the operators in this section are included from sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: GREATER THAN operator: >
+// ----------------------------------------------------------------------------
+
+bool
+operator>(const sc_unsigned& u, const sc_signed& v)
+{
+  return (! (operator<=(u, v)));
+}
+
+
+bool
+operator>(const sc_signed& u, const sc_unsigned& v)
+{
+  return (! (operator<=(u, v)));
+}
+
+// The rest of the operators in this section are included from sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: GREATER THAN or EQUAL operator: >=
+// ----------------------------------------------------------------------------
+
+bool
+operator>=(const sc_unsigned& u, const sc_signed& v)
+{
+  return (! (operator<(u, v)));
+}
+
+
+bool
+operator>=(const sc_signed& u, const sc_unsigned& v)
+{
+  return (! (operator<(u, v)));
+}
+
+// The rest of the operators in this section are included from sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Friends 
+// ----------------------------------------------------------------------------
+
+// Compare u and v as unsigned and return r
+//  r = 0 if u == v
+//  r < 0 if u < v
+//  r > 0 if u > v
+
+int
+compare_unsigned(small_type us, 
+                 int unb, int und, const sc_digit *ud, 
+                 small_type vs, 
+                 int vnb, int vnd, const sc_digit *vd,
+                 small_type if_u_signed, 
+                 small_type if_v_signed)
+{
+
+  if (us == vs) {
+
+    if (us == SC_ZERO)
+      return 0;
+
+    else {
+
+      int cmp_res = vec_skip_and_cmp(und, ud, vnd, vd);
+
+      if (us == SC_POS)
+        return cmp_res;
+      else
+        return -cmp_res;
+
+    }
+  }
+  else {
+
+    if (us == SC_ZERO)
+      return -vs;
+
+    if (vs == SC_ZERO)
+      return us;
+
+    int cmp_res;
+
+    int nd = (us == SC_NEG ? und : vnd);
+
+#ifdef SC_MAX_NBITS
+    sc_digit d[MAX_NDIGITS];
+#else
+    sc_digit *d = new sc_digit[nd];
+#endif
+
+    if (us == SC_NEG) {
+
+      vec_copy(nd, d, ud);
+      vec_complement(nd, d);
+      trim(if_u_signed, unb, nd, d);
+      cmp_res = vec_skip_and_cmp(nd, d, vnd, vd);
+
+    }
+    else {
+
+      vec_copy(nd, d, vd);
+      vec_complement(nd, d);
+      trim(if_v_signed, vnb, nd, d);
+      cmp_res = vec_skip_and_cmp(und, ud, nd, d);
+
+    }
+
+#ifndef SC_MAX_NBITS
+    delete [] d;
+#endif
+
+    return cmp_res;
+
+  }
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Public members - Other utils.
+// ----------------------------------------------------------------------------
+
+bool 
+sc_unsigned::iszero() const
+{
+  if (sgn == SC_ZERO)
+    return true;
+
+  else if (sgn == SC_NEG) {
+
+    // A negative unsigned number can be zero, e.g., -16 in 4 bits, so
+    // check that.
+
+#ifdef SC_MAX_NBITS
+    sc_digit d[MAX_NDIGITS];
+#else
+    sc_digit *d = new sc_digit[ndigits];
+#endif
+
+    vec_copy(ndigits, d, digit);
+    vec_complement(ndigits, d);
+    trim_unsigned(nbits, ndigits, d);
+
+    bool res = check_for_zero(ndigits, d);
+
+#ifndef SC_MAX_NBITS
+    delete [] d;
+#endif
+
+    return res;
+    
+  }
+  else
+    return false;
+}
+
+// The rest of the utils in this section are included from sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Private members.
+// ----------------------------------------------------------------------------
+
+// The private members in this section are included from
+// sc_nbcommon.cpp.
+
+#define CLASS_TYPE sc_unsigned
+#define CLASS_TYPE_STR "sc_unsigned"
+
+#define ADD_HELPER add_unsigned_friend
+#define SUB_HELPER sub_unsigned_friend
+#define MUL_HELPER mul_unsigned_friend
+#define DIV_HELPER div_unsigned_friend
+#define MOD_HELPER mod_unsigned_friend
+#define AND_HELPER and_unsigned_friend
+#define  OR_HELPER  or_unsigned_friend
+#define XOR_HELPER xor_unsigned_friend 
+
+#include "sc_nbfriends.inc"
+
+#undef  SC_SIGNED
+#define SC_UNSIGNED
+#define IF_SC_SIGNED              0  // 0 = sc_unsigned
+#define CLASS_TYPE_SUBREF         sc_unsigned_subref_r
+#define OTHER_CLASS_TYPE          sc_signed
+#define OTHER_CLASS_TYPE_SUBREF   sc_signed_subref_r
+
+#define MUL_ON_HELPER mul_on_help_unsigned
+#define DIV_ON_HELPER div_on_help_unsigned
+#define MOD_ON_HELPER mod_on_help_unsigned
+
+#include "sc_nbcommon.inc"
+
+#undef MOD_ON_HELPER
+#undef DIV_ON_HELPER
+#undef MUL_ON_HELPER
+
+#undef OTHER_CLASS_TYPE_SUBREF
+#undef OTHER_CLASS_TYPE
+#undef CLASS_TYPE_SUBREF
+#undef IF_SC_SIGNED
+#undef SC_UNSIGNED
+
+#undef XOR_HELPER
+#undef  OR_HELPER
+#undef AND_HELPER
+#undef MOD_HELPER
+#undef DIV_HELPER
+#undef MUL_HELPER
+#undef SUB_HELPER
+#undef ADD_HELPER
+
+#undef CLASS_TYPE
+#undef CLASS_TYPE_STR
+
+#include "sc_unsigned_bitref.inc"
+#include "sc_unsigned_subref.inc"
+
+#undef CONVERT_LONG
+#undef CONVERT_LONG_2
+#undef CONVERT_INT64
+#undef CONVERT_INT64_2
+
+} // namespace sc_dt
+
+
+// End of file.
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_unsigned.h b/ext/systemc/src/sysc/datatypes/int/sc_unsigned.h
new file mode 100644
index 000000000..4260542a3
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_unsigned.h
@@ -0,0 +1,2191 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_unsigned.h -- Arbitrary precision unsigned arithmetic.
+
+    This file includes the definitions of sc_unsigned_bitref,
+    sc_unsigned_subref, and sc_unsigned classes. The first two classes
+    are proxy classes to reference one bit and a range of bits of a
+    sc_unsigned number, respectively.
+
+    An sc_signed number has the sign-magnitude representation
+    internally. However, its interface guarantees a 2's-complement
+    representation. The sign-magnitude representation is chosen
+    because of its efficiency: The sc_signed and sc_unsigned types are
+    optimized for arithmetic rather than bitwise operations. For
+    arithmetic operations, the sign-magnitude representation performs
+    better.
+
+    It is also important to note that an sc_unsigned number with n
+    bits is equivalent to an sc_signed non-negative number with n + 1
+    bits.
+
+    The implementations of sc_signed and sc_unsigned classes are
+    almost identical: Most of the member and friend functions are
+    defined in sc_nbcommon.cpp and sc_nbfriends.cpp so that they can
+    be shared by both of these classes. These functions are chosed by
+    defining a few macros before including them such as IF_SC_SIGNED
+    and CLASS_TYPE. Our implementation choices are mostly dictated by
+    performance considerations in that we tried to provide the most
+    efficient sc_signed and sc_unsigned types without compromising
+    their interface.
+
+    For the behavior of operators, we have two semantics: the old and
+    new. The most important difference between these two semantics is
+    that the old semantics is closer to C/C++ semantics in that the
+    result type of a binary operator on unsigned and signed arguments
+    is unsigned; the new semantics, on the other hand, requires the
+    result type be signed. The new semantics is required by the VSIA
+    C/C++ data types standard. We have implemented the new semantics.
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_unsigned.h,v $
+// Revision 1.4  2011/08/24 22:05:46  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.3  2011/02/18 20:19:15  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.2  2009/02/28 00:26:26  acg
+//  Andy Goodrich: bug fixes.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.5  2006/05/08 17:50:02  acg
+//   Andy Goodrich: Added David Long's declarations for friend operators,
+//   functions, and methods, to keep the Microsoft compiler happy.
+//
+// Revision 1.4  2006/03/13 20:25:27  acg
+//  Andy Goodrich: Addition of function declarations, e.g., xor_signed_friend()
+//  to keep gcc 4.x happy.
+//
+// Revision 1.3  2006/01/13 18:49:32  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#ifndef SC_UNSIGNED_H
+#define SC_UNSIGNED_H
+
+
+#include "sysc/kernel/sc_object.h"
+#include "sysc/datatypes/misc/sc_value_base.h"
+#include "sysc/utils/sc_iostream.h"
+#include "sysc/utils/sc_temporary.h"
+#include "sysc/datatypes/int/sc_length_param.h"
+#include "sysc/datatypes/int/sc_nbdefs.h"
+#include "sysc/datatypes/int/sc_nbutils.h"
+#include "sysc/datatypes/int/sc_nbexterns.h"
+#include "sysc/utils/sc_temporary.h"
+
+
+namespace sc_dt
+{
+
+// classes defined in this module
+class sc_unsigned_bitref_r;
+class sc_unsigned_bitref;
+class sc_unsigned_subref_r;
+class sc_unsigned_subref;
+class sc_concatref;
+class sc_unsigned;
+
+// forward class declarations
+class sc_bv_base;
+class sc_lv_base;
+class sc_int_base;
+class sc_uint_base;
+class sc_int_subref_r;
+class sc_uint_subref_r;
+class sc_signed;
+class sc_signed_subref_r;
+class sc_fxval;
+class sc_fxval_fast;
+class sc_fxnum;
+class sc_fxnum_fast;
+
+// Helper function declarions
+int compare_unsigned(small_type us,
+                              int unb,
+                              int und,
+                              const sc_digit *ud,
+                              small_type vs,
+                              int vnb,
+                              int vnd,
+                              const sc_digit *vd,
+                              small_type if_u_signed=0,
+                              small_type if_v_signed=0);
+
+sc_unsigned add_unsigned_friend(small_type us,
+                                         int unb,
+                                         int und,
+                                         const sc_digit *ud,
+                                         small_type vs,
+                                         int vnb,
+                                         int vnd,
+                                         const sc_digit *vd);
+
+sc_unsigned sub_unsigned_friend(small_type us,
+                                         int unb,
+                                         int und,
+                                         const sc_digit *ud,
+                                         small_type vs,
+                                         int vnb,
+                                         int vnd,
+                                         const sc_digit *vd);
+
+sc_unsigned mul_unsigned_friend(small_type s,
+                                         int unb,
+                                         int und,
+                                         const sc_digit *ud,
+                                         int vnb,
+                                         int vnd,
+                                         const sc_digit *vd);
+
+sc_unsigned div_unsigned_friend(small_type s,
+                                         int unb,
+                                         int und,
+                                         const sc_digit *ud,
+                                         int vnb,
+                                         int vnd,
+                                         const sc_digit *vd);
+
+sc_unsigned mod_unsigned_friend(small_type us,
+                                         int unb,
+                                         int und,
+                                         const sc_digit *ud,
+                                         int vnb,
+                                         int vnd,
+                                         const sc_digit *vd);
+
+sc_unsigned and_unsigned_friend(small_type us,
+                                         int unb,
+                                         int und,
+                                         const sc_digit *ud,
+                                         small_type vs,
+                                         int vnb,
+                                         int vnd,
+                                         const sc_digit *vd);
+
+
+sc_unsigned or_unsigned_friend(small_type us,
+                                        int unb,
+                                        int und,
+                                        const sc_digit *ud,
+                                        small_type vs,
+                                        int vnb,
+                                        int vnd,
+                                        const sc_digit *vd);
+
+sc_unsigned xor_unsigned_friend(small_type us,
+                                         int unb,
+                                         int und,
+                                         const sc_digit *ud,
+                                         small_type vs,
+                                         int vnb,
+                                         int vnd,
+                                         const sc_digit *vd);
+
+// friend operator declarations
+  // ARITHMETIC OPERATORS:
+
+  // ADDition operators:
+
+    sc_signed operator + (const sc_unsigned&  u, const sc_signed&    v);
+    sc_signed operator + (const sc_signed&    u, const sc_unsigned&  v);
+
+  sc_unsigned operator + (const sc_unsigned&  u, const sc_unsigned&  v);
+    sc_signed operator + (const sc_unsigned&  u, int64               v);
+  sc_unsigned operator + (const sc_unsigned&  u, uint64              v);
+    sc_signed operator + (const sc_unsigned&  u, long                v);
+  sc_unsigned operator + (const sc_unsigned&  u, unsigned long       v);
+    sc_signed operator + (const sc_unsigned&  u, int                 v);
+  inline sc_unsigned operator + (const sc_unsigned&  u, unsigned int        v);
+
+    sc_signed operator + (int64               u, const sc_unsigned&  v);
+  sc_unsigned operator + (uint64              u, const sc_unsigned&  v);
+    sc_signed operator + (long                u, const sc_unsigned&  v);
+  sc_unsigned operator + (unsigned long       u, const sc_unsigned&  v);
+    sc_signed operator + (int                 u, const sc_unsigned&  v);
+  inline sc_unsigned operator + (unsigned int        u, const sc_unsigned&  v);
+
+  sc_unsigned operator + (const sc_unsigned&  u, const sc_uint_base& v);
+    sc_signed operator + (const sc_unsigned&  u, const sc_int_base&  v);
+  sc_unsigned operator + (const sc_uint_base& u, const sc_unsigned&  v);
+    sc_signed operator + (const sc_int_base&  u, const sc_unsigned&  v);
+
+  // SUBtraction operators:
+
+    sc_signed operator - (const sc_unsigned&  u, const sc_signed&    v);
+    sc_signed operator - (const sc_signed&    u, const sc_unsigned&  v);
+
+    sc_signed operator - (const sc_unsigned&  u, const sc_unsigned&  v);
+    sc_signed operator - (const sc_unsigned&  u, int64               v);
+    sc_signed operator - (const sc_unsigned&  u, uint64              v);
+    sc_signed operator - (const sc_unsigned&  u, long                v);
+    sc_signed operator - (const sc_unsigned&  u, unsigned long       v);
+    sc_signed operator - (const sc_unsigned&  u, int                 v);
+    sc_signed operator - (const sc_unsigned&  u, unsigned int        v);
+
+    sc_signed operator - (int64               u, const sc_unsigned&  v);
+    sc_signed operator - (uint64              u, const sc_unsigned&  v);
+    sc_signed operator - (long                u, const sc_unsigned&  v);
+    sc_signed operator - (unsigned long       u, const sc_unsigned&  v);
+    sc_signed operator - (int                 u, const sc_unsigned&  v);
+    sc_signed operator - (unsigned int        u, const sc_unsigned&  v);
+
+    sc_signed operator - (const sc_unsigned&  u, const sc_uint_base& v);
+    sc_signed operator - (const sc_unsigned&  u, const sc_int_base&  v);
+    sc_signed operator - (const sc_uint_base& u, const sc_unsigned&  v);
+    sc_signed operator - (const sc_int_base&  u, const sc_unsigned&  v);
+
+  // MULtiplication operators:
+
+    sc_signed operator * (const sc_unsigned&  u, const sc_signed&    v);
+    sc_signed operator * (const sc_signed&    u, const sc_unsigned&  v);
+
+  sc_unsigned operator * (const sc_unsigned&  u, const sc_unsigned&  v);
+    sc_signed operator * (const sc_unsigned&  u, int64               v);
+  sc_unsigned operator * (const sc_unsigned&  u, uint64              v);
+    sc_signed operator * (const sc_unsigned&  u, long                v);
+  sc_unsigned operator * (const sc_unsigned&  u, unsigned long       v);
+    sc_signed operator * (const sc_unsigned&  u, int                 v);
+  inline sc_unsigned operator * (const sc_unsigned&  u, unsigned int        v);
+
+    sc_signed operator * (int64               u, const sc_unsigned&  v);
+  sc_unsigned operator * (uint64              u, const sc_unsigned&  v);
+    sc_signed operator * (long                u, const sc_unsigned&  v);
+  sc_unsigned operator * (unsigned long       u, const sc_unsigned&  v);
+    sc_signed operator * (int                 u, const sc_unsigned&  v);
+  inline sc_unsigned operator * (unsigned int        u, const sc_unsigned&  v);
+
+  sc_unsigned operator * (const sc_unsigned&  u, const sc_uint_base& v);
+    sc_signed operator * (const sc_unsigned&  u, const sc_int_base&  v);
+  sc_unsigned operator * (const sc_uint_base& u, const sc_unsigned&  v);
+    sc_signed operator * (const sc_int_base&  u, const sc_unsigned&  v);
+
+  // DIVision operators:
+
+    sc_signed operator / (const sc_unsigned&  u, const sc_signed&    v);
+    sc_signed operator / (const sc_signed&    u, const sc_unsigned&  v);
+
+  sc_unsigned operator / (const sc_unsigned&  u, const sc_unsigned&  v);
+    sc_signed operator / (const sc_unsigned&  u, int64               v);
+  sc_unsigned operator / (const sc_unsigned&  u, uint64              v);
+    sc_signed operator / (const sc_unsigned&  u, long                v);
+  sc_unsigned operator / (const sc_unsigned&  u, unsigned long       v);
+    sc_signed operator / (const sc_unsigned&  u, int                 v);
+  inline sc_unsigned operator / (const sc_unsigned&  u, unsigned int        v);
+
+    sc_signed operator / (int64               u, const sc_unsigned&  v);
+  sc_unsigned operator / (uint64              u, const sc_unsigned&  v);
+    sc_signed operator / (long                u, const sc_unsigned&  v);
+  sc_unsigned operator / (unsigned long       u, const sc_unsigned&  v);
+    sc_signed operator / (int                 u, const sc_unsigned&  v);
+  inline sc_unsigned operator / (unsigned int        u, const sc_unsigned&  v);
+
+  sc_unsigned operator / (const sc_unsigned&  u, const sc_uint_base& v);
+    sc_signed operator / (const sc_unsigned&  u, const sc_int_base&  v);
+  sc_unsigned operator / (const sc_uint_base& u, const sc_unsigned&  v);
+    sc_signed operator / (const sc_int_base&  u, const sc_unsigned&  v);
+
+  // MODulo operators:
+
+    sc_signed operator % (const sc_unsigned&  u, const sc_signed&    v);
+    sc_signed operator % (const sc_signed&    u, const sc_unsigned&  v);
+
+  sc_unsigned operator % (const sc_unsigned&  u, const sc_unsigned&  v);
+    sc_signed operator % (const sc_unsigned&  u, int64               v);
+  sc_unsigned operator % (const sc_unsigned&  u, uint64              v);
+    sc_signed operator % (const sc_unsigned&  u, long                v);
+  sc_unsigned operator % (const sc_unsigned&  u, unsigned long       v);
+    sc_signed operator % (const sc_unsigned&  u, int                 v);
+  inline sc_unsigned operator % (const sc_unsigned&  u, unsigned int        v);
+
+    sc_signed operator % (int64               u, const sc_unsigned&  v);
+  sc_unsigned operator % (uint64              u, const sc_unsigned&  v);
+    sc_signed operator % (long                u, const sc_unsigned&  v);
+  sc_unsigned operator % (unsigned long       u, const sc_unsigned&  v);
+    sc_signed operator % (int                 u, const sc_unsigned&  v);
+  inline sc_unsigned operator % (unsigned int        u, const sc_unsigned&  v);
+
+  sc_unsigned operator % (const sc_unsigned&  u, const sc_uint_base& v);
+    sc_signed operator % (const sc_unsigned&  u, const sc_int_base&  v);
+  sc_unsigned operator % (const sc_uint_base& u, const sc_unsigned&  v);
+    sc_signed operator % (const sc_int_base&  u, const sc_unsigned&  v);
+
+  // BITWISE OPERATORS:
+
+  // Bitwise AND operators:
+
+    sc_signed operator & (const sc_unsigned&  u, const sc_signed&    v);
+    sc_signed operator & (const sc_signed&    u, const sc_unsigned&  v);
+
+  sc_unsigned operator & (const sc_unsigned&  u, const sc_unsigned&  v);
+    sc_signed operator & (const sc_unsigned&  u, int64               v);
+  sc_unsigned operator & (const sc_unsigned&  u, uint64              v);
+    sc_signed operator & (const sc_unsigned&  u, long                v);
+  sc_unsigned operator & (const sc_unsigned&  u, unsigned long       v);
+    sc_signed operator & (const sc_unsigned&  u, int                 v);
+  inline sc_unsigned operator & (const sc_unsigned&  u, unsigned int        v);
+
+    sc_signed operator & (int64               u, const sc_unsigned&  v);
+  sc_unsigned operator & (uint64              u, const sc_unsigned&  v);
+    sc_signed operator & (long                u, const sc_unsigned&  v);
+  sc_unsigned operator & (unsigned long       u, const sc_unsigned&  v);
+    sc_signed operator & (int                 u, const sc_unsigned&  v);
+  inline sc_unsigned operator & (unsigned int        u, const sc_unsigned&  v);
+
+  sc_unsigned operator & (const sc_unsigned&  u, const sc_uint_base& v);
+    sc_signed operator & (const sc_unsigned&  u, const sc_int_base&  v);
+  sc_unsigned operator & (const sc_uint_base& u, const sc_unsigned&  v);
+    sc_signed operator & (const sc_int_base&  u, const sc_unsigned&  v);
+
+  // Bitwise OR operators:
+
+    sc_signed operator | (const sc_unsigned&  u, const sc_signed&    v);
+    sc_signed operator | (const sc_signed&    u, const sc_unsigned&  v);
+
+  sc_unsigned operator | (const sc_unsigned&  u, const sc_unsigned&  v);
+    sc_signed operator | (const sc_unsigned&  u, int64               v);
+  sc_unsigned operator | (const sc_unsigned&  u, uint64              v);
+    sc_signed operator | (const sc_unsigned&  u, long                v);
+  sc_unsigned operator | (const sc_unsigned&  u, unsigned long       v);
+    sc_signed operator | (const sc_unsigned&  u, int                 v);
+  inline sc_unsigned operator | (const sc_unsigned&  u, unsigned int        v);
+
+    sc_signed operator | (int64               u, const sc_unsigned&  v);
+  sc_unsigned operator | (uint64              u, const sc_unsigned&  v);
+    sc_signed operator | (long                u, const sc_unsigned&  v);
+  sc_unsigned operator | (unsigned long       u, const sc_unsigned&  v);
+    sc_signed operator | (int                 u, const sc_unsigned&  v);
+  inline sc_unsigned operator | (unsigned int        u, const sc_unsigned&  v);
+
+  sc_unsigned operator | (const sc_unsigned&  u, const sc_uint_base& v);
+    sc_signed operator | (const sc_unsigned&  u, const sc_int_base&  v);
+  sc_unsigned operator | (const sc_uint_base& u, const sc_unsigned&  v);
+    sc_signed operator | (const sc_int_base&  u, const sc_unsigned&  v);
+
+  // Bitwise XOR operators:
+
+    sc_signed operator ^ (const sc_unsigned&  u, const sc_signed&    v);
+    sc_signed operator ^ (const sc_signed&    u, const sc_unsigned&  v);
+
+  sc_unsigned operator ^ (const sc_unsigned&  u, const sc_unsigned&  v);
+    sc_signed operator ^ (const sc_unsigned&  u, int64               v);
+  sc_unsigned operator ^ (const sc_unsigned&  u, uint64              v);
+    sc_signed operator ^ (const sc_unsigned&  u, long                v);
+  sc_unsigned operator ^ (const sc_unsigned&  u, unsigned long       v);
+    sc_signed operator ^ (const sc_unsigned&  u, int                 v);
+  inline sc_unsigned operator ^ (const sc_unsigned&  u, unsigned int        v);
+
+    sc_signed operator ^ (int64               u, const sc_unsigned&  v);
+  sc_unsigned operator ^ (uint64              u, const sc_unsigned&  v);
+    sc_signed operator ^ (long                u, const sc_unsigned&  v);
+  sc_unsigned operator ^ (unsigned long       u, const sc_unsigned&  v);
+    sc_signed operator ^ (int                 u, const sc_unsigned&  v);
+  inline sc_unsigned operator ^ (unsigned int        u, const sc_unsigned&  v);
+
+  sc_unsigned operator ^ (const sc_unsigned&  u, const sc_uint_base& v);
+    sc_signed operator ^ (const sc_unsigned&  u, const sc_int_base&  v);
+  sc_unsigned operator ^ (const sc_uint_base& u, const sc_unsigned&  v);
+    sc_signed operator ^ (const sc_int_base&  u, const sc_unsigned&  v);
+
+  // SHIFT OPERATORS:
+
+  // LEFT SHIFT operators:
+
+  sc_unsigned operator << (const sc_unsigned&  u, const sc_signed&    v);
+    sc_signed operator << (const sc_signed&    u, const sc_unsigned&  v);
+
+  sc_unsigned operator << (const sc_unsigned&  u, const sc_unsigned&  v);
+  sc_unsigned operator << (const sc_unsigned&  u, int64               v);
+  sc_unsigned operator << (const sc_unsigned&  u, uint64              v);
+  sc_unsigned operator << (const sc_unsigned&  u, long                v);
+  sc_unsigned operator << (const sc_unsigned&  u, unsigned long       v);
+  inline sc_unsigned operator << (const sc_unsigned&  u, int                 v);
+  inline sc_unsigned operator << (const sc_unsigned&  u, unsigned int        v);
+
+  sc_unsigned operator << (const sc_unsigned&  u, const sc_uint_base& v);
+  sc_unsigned operator << (const sc_unsigned&  u, const sc_int_base&  v);
+
+  // RIGHT SHIFT operators:
+
+  sc_unsigned operator >> (const sc_unsigned&  u, const sc_signed&    v);
+    sc_signed operator >> (const sc_signed&    u, const sc_unsigned&  v);
+
+  sc_unsigned operator >> (const sc_unsigned&  u, const sc_unsigned&  v);
+  sc_unsigned operator >> (const sc_unsigned&  u, int64               v);
+  sc_unsigned operator >> (const sc_unsigned&  u, uint64              v);
+  sc_unsigned operator >> (const sc_unsigned&  u, long                v);
+  sc_unsigned operator >> (const sc_unsigned&  u, unsigned long       v);
+  inline sc_unsigned operator >> (const sc_unsigned&  u, int                 v);
+  inline sc_unsigned operator >> (const sc_unsigned&  u, unsigned int        v);
+
+  sc_unsigned operator >> ( const sc_unsigned& , const sc_uint_base& );
+  sc_unsigned operator >> ( const sc_unsigned&, const sc_int_base& );
+
+  // Unary arithmetic operators
+  sc_unsigned operator + (const sc_unsigned& u);
+    sc_signed operator - (const sc_unsigned& u);
+
+  // LOGICAL OPERATORS:
+
+  // Logical EQUAL operators:
+
+  bool operator == (const sc_unsigned&  u, const sc_signed&    v);
+  bool operator == (const sc_signed&    u, const sc_unsigned&  v);
+
+  bool operator == (const sc_unsigned&  u, const sc_unsigned&  v);
+  bool operator == (const sc_unsigned&  u, int64               v);
+  bool operator == (const sc_unsigned&  u, uint64              v);
+  bool operator == (const sc_unsigned&  u, long                v);
+  bool operator == (const sc_unsigned&  u, unsigned long       v);
+  inline bool operator == (const sc_unsigned&  u, int                 v);
+  inline bool operator == (const sc_unsigned&  u, unsigned int        v);
+
+  bool operator == (int64               u, const sc_unsigned&  v);
+  bool operator == (uint64              u, const sc_unsigned&  v);
+  bool operator == (long                u, const sc_unsigned&  v);
+  bool operator == (unsigned long       u, const sc_unsigned&  v);
+  inline bool operator == (int                 u, const sc_unsigned&  v);
+  inline bool operator == (unsigned int        u, const sc_unsigned&  v) ;
+
+  bool operator == (const sc_unsigned&  u, const sc_uint_base& v);
+  bool operator == (const sc_unsigned&  u, const sc_int_base&  v);
+  bool operator == (const sc_uint_base& u, const sc_unsigned&  v);
+  bool operator == (const sc_int_base&  u, const sc_unsigned&  v);
+
+  // Logical NOT_EQUAL operators:
+
+  bool operator != (const sc_unsigned&  u, const sc_signed&    v);
+  bool operator != (const sc_signed&    u, const sc_unsigned&  v);
+
+  bool operator != (const sc_unsigned&  u, const sc_unsigned&  v);
+  bool operator != (const sc_unsigned&  u, int64               v);
+  bool operator != (const sc_unsigned&  u, uint64              v);
+  bool operator != (const sc_unsigned&  u, long                v);
+  bool operator != (const sc_unsigned&  u, unsigned long       v);
+  inline bool operator != (const sc_unsigned&  u, int                 v);
+  inline bool operator != (const sc_unsigned&  u, unsigned int        v);
+
+  bool operator != (int64               u, const sc_unsigned&  v);
+  bool operator != (uint64              u, const sc_unsigned&  v);
+  bool operator != (long                u, const sc_unsigned&  v);
+  bool operator != (unsigned long       u, const sc_unsigned&  v);
+  inline bool operator != (int                 u, const sc_unsigned&  v);
+  inline bool operator != (unsigned int        u, const sc_unsigned&  v);
+
+  bool operator != (const sc_unsigned&  u, const sc_uint_base& v);
+  bool operator != (const sc_unsigned&  u, const sc_int_base&  v);
+  bool operator != (const sc_uint_base& u, const sc_unsigned&  v);
+  bool operator != (const sc_int_base&  u, const sc_unsigned&  v);
+
+  // Logical LESS_THAN operators:
+
+  bool operator < (const sc_unsigned&  u, const sc_signed&    v);
+  bool operator < (const sc_signed&    u, const sc_unsigned&  v);
+
+  bool operator < (const sc_unsigned&  u, const sc_unsigned&  v);
+  bool operator < (const sc_unsigned&  u, int64               v);
+  bool operator < (const sc_unsigned&  u, uint64              v);
+  bool operator < (const sc_unsigned&  u, long                v);
+  bool operator < (const sc_unsigned&  u, unsigned long       v);
+  inline bool operator < (const sc_unsigned&  u, int                 v);
+  inline bool operator < (const sc_unsigned&  u, unsigned int        v);
+
+  bool operator < (int64               u, const sc_unsigned&  v);
+  bool operator < (uint64              u, const sc_unsigned&  v);
+  bool operator < (long                u, const sc_unsigned&  v);
+  bool operator < (unsigned long       u, const sc_unsigned&  v);
+  inline bool operator < (int                 u, const sc_unsigned&  v);
+  inline bool operator < (unsigned int        u, const sc_unsigned&  v);
+
+  bool operator < (const sc_unsigned&  u, const sc_uint_base& v);
+  bool operator < (const sc_unsigned&  u, const sc_int_base&  v);
+  bool operator < (const sc_uint_base& u, const sc_unsigned&  v);
+  bool operator < (const sc_int_base&  u, const sc_unsigned&  v);
+
+  // Logical LESS_THAN_AND_EQUAL operators:
+
+  bool operator <= (const sc_unsigned&  u, const sc_signed&    v);
+  bool operator <= (const sc_signed&    u, const sc_unsigned&  v);
+
+  bool operator <= (const sc_unsigned&  u, const sc_unsigned&  v);
+  bool operator <= (const sc_unsigned&  u, int64               v);
+  bool operator <= (const sc_unsigned&  u, uint64              v);
+  bool operator <= (const sc_unsigned&  u, long                v);
+  bool operator <= (const sc_unsigned&  u, unsigned long       v);
+  inline bool operator <= (const sc_unsigned&  u, int                 v);
+  inline bool operator <= (const sc_unsigned&  u, unsigned int        v);
+
+  bool operator <= (int64               u, const sc_unsigned&  v);
+  bool operator <= (uint64              u, const sc_unsigned&  v);
+  bool operator <= (long                u, const sc_unsigned&  v);
+  bool operator <= (unsigned long       u, const sc_unsigned&  v);
+  inline bool operator <= (int                 u, const sc_unsigned&  v);
+  inline bool operator <= (unsigned int        u, const sc_unsigned&  v);
+
+  bool operator <= (const sc_unsigned&  u, const sc_uint_base& v);
+  bool operator <= (const sc_unsigned&  u, const sc_int_base&  v);
+  bool operator <= (const sc_uint_base& u, const sc_unsigned&  v);
+  bool operator <= (const sc_int_base&  u, const sc_unsigned&  v);
+
+  // Logical GREATER_THAN operators:
+
+  bool operator > (const sc_unsigned&  u, const sc_signed&    v);
+  bool operator > (const sc_signed&    u, const sc_unsigned&  v);
+
+  bool operator > (const sc_unsigned&  u, const sc_unsigned&  v);
+  bool operator > (const sc_unsigned&  u, int64               v);
+  bool operator > (const sc_unsigned&  u, uint64              v);
+  bool operator > (const sc_unsigned&  u, long                v);
+  bool operator > (const sc_unsigned&  u, unsigned long       v);
+  inline bool operator > (const sc_unsigned&  u, int                 v);
+  inline bool operator > (const sc_unsigned&  u, unsigned int        v);
+
+  bool operator > (int64               u, const sc_unsigned&  v);
+  bool operator > (uint64              u, const sc_unsigned&  v);
+  bool operator > (long                u, const sc_unsigned&  v);
+  bool operator > (unsigned long       u, const sc_unsigned&  v);
+  inline bool operator > (int                 u, const sc_unsigned&  v);
+  inline bool operator > (unsigned int        u, const sc_unsigned&  v);
+
+  bool operator > (const sc_unsigned&  u, const sc_uint_base& v);
+  bool operator > (const sc_unsigned&  u, const sc_int_base&  v);
+  bool operator > (const sc_uint_base& u, const sc_unsigned&  v);
+  bool operator > (const sc_int_base&  u, const sc_unsigned&  v);
+
+  // Logical GREATER_THAN_AND_EQUAL operators:
+
+  bool operator >= (const sc_unsigned&  u, const sc_signed&    v);
+  bool operator >= (const sc_signed&    u, const sc_unsigned&  v);
+
+  bool operator >= (const sc_unsigned&  u, const sc_unsigned&  v);
+  bool operator >= (const sc_unsigned&  u, int64               v);
+  bool operator >= (const sc_unsigned&  u, uint64              v);
+  bool operator >= (const sc_unsigned&  u, long                v);
+  bool operator >= (const sc_unsigned&  u, unsigned long       v);
+  inline bool operator >= (const sc_unsigned&  u, int                 v);
+  inline bool operator >= (const sc_unsigned&  u, unsigned int        v);
+
+  bool operator >= (int64               u, const sc_unsigned&  v);
+  bool operator >= (uint64              u, const sc_unsigned&  v);
+  bool operator >= (long                u, const sc_unsigned&  v);
+  bool operator >= (unsigned long       u, const sc_unsigned&  v);
+  inline bool operator >= (int                 u, const sc_unsigned&  v);
+  inline bool operator >= (unsigned int        u, const sc_unsigned&  v);
+
+  bool operator >= (const sc_unsigned&  u, const sc_uint_base& v);
+  bool operator >= (const sc_unsigned&  u, const sc_int_base&  v);
+  bool operator >= (const sc_uint_base& u, const sc_unsigned&  v);
+  bool operator >= (const sc_int_base&  u, const sc_unsigned&  v);
+
+  // Bitwise NOT operator (unary).
+  sc_unsigned operator ~ (const sc_unsigned& u);
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_unsigned_bitref_r
+//
+//  Proxy class for sc_unsigned bit selection (r-value only).
+// ----------------------------------------------------------------------------
+
+class sc_unsigned_bitref_r : public sc_value_base
+{
+    friend class sc_unsigned;
+
+protected:
+
+    // construction and initialization:
+
+    sc_unsigned_bitref_r() : sc_value_base(), m_index(0), m_obj_p(0)
+        {}
+
+    void initialize( const sc_unsigned* obj_p, int index_ )
+        {
+	    m_obj_p = CCAST<sc_unsigned*>( obj_p );
+	    m_index = index_;
+	}
+
+public:
+
+    // destructor
+
+    virtual ~sc_unsigned_bitref_r()
+	{}
+
+    // copy constructor
+
+    sc_unsigned_bitref_r( const sc_unsigned_bitref_r& a )
+	: sc_value_base(a), m_index( a.m_index ), m_obj_p( a.m_obj_p )
+	{}
+
+    // capacity
+
+    int length() const
+	{ return 1; }
+
+
+    // implicit conversion to bool
+
+    operator uint64 () const;
+    bool operator ! () const;
+    bool operator ~ () const;
+
+
+    // explicit conversions
+
+    uint64 value() const
+	{ return operator uint64(); }
+
+    bool to_bool() const
+	{ return operator uint64(); }
+
+
+    // concatenation support
+
+    virtual int concat_length(bool* xz_present_p) const
+        { if ( xz_present_p ) *xz_present_p = false; return 1; }
+    virtual uint64 concat_get_uint64() const
+        { return (uint64)operator uint64(); }
+    virtual bool concat_get_ctrl( sc_digit* dst_p, int low_i ) const
+        {
+            int  bit_mask = 1 << (low_i % BITS_PER_DIGIT);
+            int  word_i = low_i / BITS_PER_DIGIT;
+	    dst_p[word_i] &= ~bit_mask;
+	    return false;
+        }
+    virtual bool concat_get_data( sc_digit* dst_p, int low_i ) const
+        {
+            int  bit_mask = 1 << (low_i % BITS_PER_DIGIT);
+	    bool result;	// True if non-zero.
+            int  word_i = low_i / BITS_PER_DIGIT;
+            if ( operator uint64() )
+	    {
+                dst_p[word_i] |= bit_mask;
+		result = true;
+	    }
+            else
+	    {
+                dst_p[word_i] &= ~bit_mask;
+		result = false;
+	    }
+	    return result;
+        }
+
+    // other methods
+
+    void print( ::std::ostream& os = ::std::cout ) const
+	{ os << to_bool(); }
+
+protected:
+
+    int          m_index;
+    sc_unsigned* m_obj_p;
+
+private:
+
+    // disabled
+    const sc_unsigned_bitref_r& operator = ( const sc_unsigned_bitref_r& );
+};
+
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream&, const sc_unsigned_bitref_r& );
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_unsigned_bitref
+//
+//  Proxy class for sc_unsigned bit selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+class sc_unsigned_bitref
+    : public sc_unsigned_bitref_r
+{
+    friend class sc_unsigned;
+    friend class sc_core::sc_vpool<sc_unsigned_bitref>;
+
+
+protected: // construction
+
+    sc_unsigned_bitref() : sc_unsigned_bitref_r()
+        {}
+
+public:
+
+    // copy constructor
+
+    sc_unsigned_bitref( const sc_unsigned_bitref& a )
+	: sc_unsigned_bitref_r( a )
+	{}
+
+
+    // assignment operators
+
+    const sc_unsigned_bitref& operator = ( const sc_unsigned_bitref_r& );
+    const sc_unsigned_bitref& operator = ( const sc_unsigned_bitref& );
+    const sc_unsigned_bitref& operator = ( bool );
+
+    const sc_unsigned_bitref& operator &= ( bool );
+    const sc_unsigned_bitref& operator |= ( bool );
+    const sc_unsigned_bitref& operator ^= ( bool );
+
+    // concatenation methods
+
+    virtual void concat_set(int64 src, int low_i);
+    virtual void concat_set(const sc_signed& src, int low_i);
+    virtual void concat_set(const sc_unsigned& src, int low_i);
+    virtual void concat_set(uint64 src, int low_i);
+
+
+    // other methods
+
+    void scan( ::std::istream& is = ::std::cin );
+
+protected:
+    static sc_core::sc_vpool<sc_unsigned_bitref> m_pool;
+};
+
+
+
+inline
+::std::istream&
+operator >> ( ::std::istream&, sc_unsigned_bitref& );
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_unsigned_subref_r
+//
+//  Proxy class for sc_unsigned part selection (r-value only).
+// ----------------------------------------------------------------------------
+
+class sc_unsigned_subref_r : public sc_value_base
+{
+    friend class sc_signed;
+    friend class sc_unsigned;
+    friend class sc_unsigned_signal;
+
+protected:
+
+    // constructor
+
+    sc_unsigned_subref_r() : sc_value_base(), m_left(0), m_obj_p(0), m_right(0)
+	{}
+
+    void initialize( const sc_unsigned* obj_p, int left_, int right_ )
+	{
+	    m_obj_p = CCAST<sc_unsigned*>( obj_p );
+	    m_left = left_;
+	    m_right = right_;
+	}
+
+public:
+
+    // destructor
+
+    virtual ~sc_unsigned_subref_r()
+	{}
+
+
+    // copy constructor
+
+    sc_unsigned_subref_r( const sc_unsigned_subref_r& a )
+	: sc_value_base(a), m_left( a.m_left ), m_obj_p( a.m_obj_p ), 
+	  m_right( a.m_right )
+	{}
+
+
+    // capacity
+
+    int length() const
+	{ return m_left >= m_right ? (m_left-m_right+1) : (m_right-m_left+1 ); }
+
+
+    // implicit conversion to sc_unsigned
+
+    operator sc_unsigned () const;
+
+
+    // explicit conversions
+
+    int           to_int() const;
+    unsigned int  to_uint() const;
+    long          to_long() const;
+    unsigned long to_ulong() const;
+    int64         to_int64() const;
+    uint64        to_uint64() const;
+    double        to_double() const;
+
+
+    // explicit conversion to character string
+
+    const std::string to_string( sc_numrep numrep = SC_DEC ) const;
+    const std::string to_string( sc_numrep numrep, bool w_prefix ) const;
+
+
+    // concatenation support
+
+    virtual int concat_length(bool* xz_present_p) const
+	{
+	    if ( xz_present_p ) *xz_present_p = false;
+	    return m_left - m_right + 1;
+	}
+    virtual uint64 concat_get_uint64() const;
+    virtual bool concat_get_ctrl( sc_digit* dst_p, int low_i ) const;
+    virtual bool concat_get_data( sc_digit* dst_p, int low_i ) const;
+
+    // reduce methods
+
+    bool and_reduce() const;
+    bool nand_reduce() const;
+    bool or_reduce() const;
+    bool nor_reduce() const;
+    bool xor_reduce() const ;
+    bool xnor_reduce() const;
+
+    // other methods
+
+    void print( ::std::ostream& os = ::std::cout ) const
+	{ os << to_string(sc_io_base(os,SC_DEC),sc_io_show_base(os)); }
+
+protected:
+
+    int          m_left;   // Left-most bit in this part selection.
+    sc_unsigned* m_obj_p;  // Target of this part selection.
+    int          m_right;  // Right-most bit in this part selection.
+
+private:
+
+    // disabled
+    const sc_unsigned_subref_r& operator = ( const sc_unsigned_subref_r& );
+};
+
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream&, const sc_unsigned_subref_r& );
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_unsigned_subref
+//
+//  Proxy class for sc_unsigned part selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+class sc_unsigned_subref
+    : public sc_unsigned_subref_r
+{
+    friend class sc_unsigned;
+    friend class sc_core::sc_vpool<sc_unsigned_subref>;
+
+
+    // constructor
+
+protected:
+    sc_unsigned_subref() : sc_unsigned_subref_r()
+	{}
+
+public:
+
+    // copy constructor
+
+    sc_unsigned_subref( const sc_unsigned_subref& a )
+	: sc_unsigned_subref_r( a )
+	{}
+
+    // assignment operators
+
+    const sc_unsigned_subref& operator = ( const sc_unsigned_subref_r& a );
+    const sc_unsigned_subref& operator = ( const sc_unsigned_subref& a );
+    const sc_unsigned_subref& operator = ( const sc_unsigned& a );
+
+    template<class T>
+    const sc_unsigned_subref& operator = ( const sc_generic_base<T>& a );
+    const sc_unsigned_subref& operator = ( const sc_signed_subref_r& a );
+    const sc_unsigned_subref& operator = ( const sc_signed& a );
+
+    const sc_unsigned_subref& operator = ( const char* a );
+    const sc_unsigned_subref& operator = ( unsigned long a );
+    const sc_unsigned_subref& operator = ( long a );
+
+    const sc_unsigned_subref& operator = ( unsigned int a )
+	{ return operator = ( (unsigned long) a ); }
+
+    const sc_unsigned_subref& operator = ( int a )
+	{ return operator = ( (long) a ); }
+
+    const sc_unsigned_subref& operator = ( uint64 a );
+    const sc_unsigned_subref& operator = ( int64 a );
+    const sc_unsigned_subref& operator = ( double a );
+    const sc_unsigned_subref& operator = ( const sc_int_base& a );
+    const sc_unsigned_subref& operator = ( const sc_uint_base& a );
+
+    // concatenation methods
+
+    virtual void concat_set(int64 src, int low_i);
+    virtual void concat_set(const sc_signed& src, int low_i);
+    virtual void concat_set(const sc_unsigned& src, int low_i);
+    virtual void concat_set(uint64 src, int low_i);
+
+    // other methods
+
+    void scan( ::std::istream& is = ::std::cin );
+
+protected:
+    static sc_core::sc_vpool<sc_unsigned_subref> m_pool;
+};
+
+
+
+inline
+::std::istream&
+operator >> ( ::std::istream&, sc_unsigned_subref& );
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_unsigned
+//
+//  Arbitrary precision unsigned number.
+// ----------------------------------------------------------------------------
+
+class sc_unsigned : public sc_value_base
+{
+    friend class sc_concatref;
+    friend class sc_unsigned_bitref_r;
+    friend class sc_unsigned_bitref;
+    friend class sc_unsigned_subref_r;
+    friend class sc_unsigned_subref;
+    friend class sc_signed;
+    friend class sc_signed_subref;
+    friend class sc_signed_subref_r;
+
+  // Needed for types using sc_unsigned.
+  typedef bool elemtype;
+
+public:
+
+    // constructors
+
+    explicit sc_unsigned( int nb = sc_length_param().len() );
+    sc_unsigned( const sc_unsigned& v );
+    sc_unsigned( const sc_signed&   v );
+	template<class T>
+    explicit sc_unsigned( const sc_generic_base<T>& v );
+    explicit sc_unsigned( const sc_bv_base& v );
+    explicit sc_unsigned( const sc_lv_base& v );
+    explicit sc_unsigned( const sc_int_subref_r& v );
+    explicit sc_unsigned( const sc_uint_subref_r& v );
+    explicit sc_unsigned( const sc_signed_subref_r& v );
+    explicit sc_unsigned( const sc_unsigned_subref_r& v );
+
+
+
+    // assignment operators
+
+    const sc_unsigned& operator = (const sc_unsigned&        v);
+    const sc_unsigned& operator = (const sc_unsigned_subref_r& a );
+
+    template<class T>
+    const sc_unsigned& operator = ( const sc_generic_base<T>& a )
+        { a->to_sc_unsigned(*this); return *this; }
+
+    const sc_unsigned& operator = (const sc_signed&          v);
+    const sc_unsigned& operator = (const sc_signed_subref_r& a );
+
+    const sc_unsigned& operator = ( const char*               v);
+    const sc_unsigned& operator = ( int64                     v);
+    const sc_unsigned& operator = ( uint64                    v);
+    const sc_unsigned& operator = ( long                      v);
+    const sc_unsigned& operator = ( unsigned long             v);
+
+    const sc_unsigned& operator = ( int                       v)
+	{ return operator=((long) v); }
+
+    const sc_unsigned& operator = ( unsigned int              v)
+	{ return operator=((unsigned long) v); }
+
+    const sc_unsigned& operator = ( double                    v);
+    const sc_unsigned& operator = ( const sc_int_base&        v);
+    const sc_unsigned& operator = ( const sc_uint_base&       v);
+
+    const sc_unsigned& operator = ( const sc_bv_base& );
+    const sc_unsigned& operator = ( const sc_lv_base& );
+
+#ifdef SC_INCLUDE_FX
+    const sc_unsigned& operator = ( const sc_fxval& );
+    const sc_unsigned& operator = ( const sc_fxval_fast& );
+    const sc_unsigned& operator = ( const sc_fxnum& );
+    const sc_unsigned& operator = ( const sc_fxnum_fast& );
+#endif
+
+
+    // destructor
+
+    virtual ~sc_unsigned()
+	{
+#           ifndef SC_MAX_NBITS
+	        delete [] digit;
+#           endif
+	}
+
+    // Concatenation support:
+
+	sc_digit* get_raw() const { return digit; }
+    virtual int concat_length(bool* xz_present_p) const
+       { if ( xz_present_p ) *xz_present_p = false; return nbits-1; }
+    virtual bool concat_get_ctrl( sc_digit* dst_p, int low_i ) const;
+    virtual bool concat_get_data( sc_digit* dst_p, int low_i ) const;
+    virtual uint64 concat_get_uint64() const;
+    virtual void concat_set(int64 src, int low_i);
+    virtual void concat_set(const sc_signed& src, int low_i);
+    virtual void concat_set(const sc_unsigned& src, int low_i);
+    virtual void concat_set(uint64 src, int low_i);
+
+    // Increment operators.
+
+    sc_unsigned& operator ++ ();
+    const sc_unsigned operator ++ (int);
+
+    // Decrement operators.
+
+    sc_unsigned& operator -- ();
+    const sc_unsigned operator -- (int);
+
+
+    // bit selection
+
+    inline void check_index( int i ) const
+        { if ( (i < 0) || (i >= nbits-1) ) invalid_index(i); }
+
+    void invalid_index( int i ) const;
+
+    sc_unsigned_bitref& operator [] ( int i )
+        {
+            check_index(i);
+            sc_unsigned_bitref* result_p =
+	    	sc_unsigned_bitref::m_pool.allocate();
+            result_p->initialize( this, i );
+            return *result_p;
+        }
+
+    const sc_unsigned_bitref_r& operator [] ( int i ) const
+        {
+            check_index(i);
+            sc_unsigned_bitref* result_p =
+	        sc_unsigned_bitref::m_pool.allocate();
+            result_p->initialize( this, i );
+            return *result_p;
+        }
+
+    sc_unsigned_bitref& bit( int i )
+        {
+            check_index(i);
+            sc_unsigned_bitref* result_p =
+	        sc_unsigned_bitref::m_pool.allocate();
+            result_p->initialize( this, i );
+            return *result_p;
+        }
+
+    const sc_unsigned_bitref_r& bit( int i ) const
+        {
+            check_index(i);
+            sc_unsigned_bitref* result_p =
+	        sc_unsigned_bitref::m_pool.allocate();
+            result_p->initialize( this, i );
+            return *result_p;
+        }
+
+
+    // part selection
+
+    // Subref operators. Help access the range of bits from the ith to
+    // jth. These indices have arbitrary precedence with respect to each
+    // other, i.e., we can have i <= j or i > j. Note the equivalence
+    // between range(i, j) and operator (i, j). Also note that
+    // operator (i, i) returns an unsigned number that corresponds to the
+    // bit operator [i], so these two forms are not the same.
+
+    inline void check_range( int l, int r ) const
+        {
+            if ( l < r )
+            {
+                if ( (l < 0) || (r >= nbits-1) ) invalid_range(l,r);
+            }
+            else
+            {
+                if ( (r < 0) || (l >= nbits-1) ) invalid_range(l,r);
+            }
+        }
+
+    void invalid_range( int l, int r ) const;
+
+    sc_unsigned_subref& range( int i, int j )
+        {
+            check_range(i,j);
+            sc_unsigned_subref* result_p =
+	        sc_unsigned_subref::m_pool.allocate();
+            result_p->initialize( this, i, j );
+            return *result_p;
+        }
+
+    const sc_unsigned_subref_r& range( int i, int j ) const
+        {
+            check_range(i,j);
+            sc_unsigned_subref* result_p =
+	        sc_unsigned_subref::m_pool.allocate();
+            result_p->initialize( this, i, j );
+            return *result_p;
+        }
+
+    sc_unsigned_subref& operator () ( int i, int j )
+        {
+            check_range(i,j);
+            sc_unsigned_subref* result_p =
+	        sc_unsigned_subref::m_pool.allocate();
+            result_p->initialize( this, i, j );
+            return *result_p;
+        }
+
+    const sc_unsigned_subref_r& operator () ( int i, int j ) const
+        {
+            check_range(i,j);
+            sc_unsigned_subref* result_p =
+	        sc_unsigned_subref::m_pool.allocate();
+            result_p->initialize( this, i, j );
+            return *result_p;
+        }
+
+    // explicit conversions
+
+    int           to_int() const;
+    unsigned int  to_uint() const;
+    long          to_long() const;
+    unsigned long to_ulong() const;
+    int64         to_int64() const;
+    uint64        to_uint64() const;
+    double        to_double() const;
+
+#ifdef SC_DT_DEPRECATED
+    int to_signed() const
+	{ return to_int(); }
+
+    unsigned int to_unsigned() const
+	{ return to_uint(); }
+#endif
+
+    // explicit conversion to character string
+
+    const std::string to_string( sc_numrep numrep = SC_DEC ) const;
+    const std::string to_string( sc_numrep numrep, bool w_prefix ) const;
+
+    // Print functions. dump prints the internals of the class.
+
+    void print( ::std::ostream& os = ::std::cout ) const
+	{ os << to_string(sc_io_base(os,SC_DEC),sc_io_show_base(os)); }
+
+    void scan( ::std::istream& is = ::std::cin );
+
+    void dump( ::std::ostream& os = ::std::cout ) const;
+
+
+  // Functions to find various properties.
+  int  length() const { return nbits - 1; }  // Bit width.
+  bool iszero() const;                       // Is the number zero?
+  bool sign() const { return 0; }            // Sign.
+
+    // reduce methods
+
+    bool and_reduce() const;
+
+    bool nand_reduce() const
+        { return ( ! and_reduce() ); }
+
+    bool or_reduce() const;
+
+    bool nor_reduce() const
+        { return ( ! or_reduce() ); }
+
+    bool xor_reduce() const;
+
+    bool xnor_reduce() const
+        { return ( ! xor_reduce() ); }
+
+
+  // Functions to access individual bits.
+  bool test(int i) const;      // Is the ith bit 0 or 1?
+  void set(int i);             // Set the ith bit to 1.
+  void clear(int i);           // Set the ith bit to 0.
+  void set(int i, bool v)      // Set the ith bit to v.
+    { if (v) set(i); else clear(i);  }
+  void invert(int i)           // Negate the ith bit.
+    { if (test(i)) clear(i); else set(i);  }
+
+  // Make the number equal to its mirror image.
+  void reverse();
+
+  // Get/set a packed bit representation of the number.
+  void get_packed_rep(sc_digit *buf) const;
+  void set_packed_rep(sc_digit *buf);
+
+  /*
+    The comparison of the old and new semantics are as follows:
+
+    Let s = sc_signed,
+        u = sc_unsigned,
+        un = { uint64, unsigned long, unsigned int },
+        sn = { int64, long, int, char* }, and
+        OP = { +, -, *, /, % }.
+
+    Old semantics:                     New semantics:
+      u OP u -> u                        u OP u -> u
+      s OP u -> u                        s OP u -> s
+      u OP s -> u                        u OP s -> s
+      s OP s -> s                        s OP s -> s
+
+      u OP un = un OP u -> u             u OP un = un OP u -> u
+      u OP sn = sn OP u -> u             u OP sn = sn OP u -> s
+
+      s OP un = un OP s -> s             s OP un = un OP s -> s
+      s OP sn = sn OP s -> s             s OP sn = sn OP s -> s
+
+    In the new semantics, the result is u if both operands are u; the
+    result is s otherwise. The only exception is subtraction. The result
+    of a subtraction is always s.
+
+    The old semantics is like C/C++ semantics on integer types; the
+    new semantics is due to the VSIA C/C++ data types standard.
+   */
+
+  // ARITHMETIC OPERATORS:
+
+  // ADDition operators:
+
+  friend   sc_signed operator + (const sc_unsigned&  u, const sc_signed&    v);
+  friend   sc_signed operator + (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend sc_unsigned operator + (const sc_unsigned&  u, const sc_unsigned&  v);
+  friend   sc_signed operator + (const sc_unsigned&  u, int64               v);
+  friend sc_unsigned operator + (const sc_unsigned&  u, uint64              v);
+  friend   sc_signed operator + (const sc_unsigned&  u, long                v);
+  friend sc_unsigned operator + (const sc_unsigned&  u, unsigned long       v);
+  friend   sc_signed operator + (const sc_unsigned&  u, int                 v);
+  friend sc_unsigned operator + (const sc_unsigned&  u, unsigned int        v)
+    { return operator+(u, (unsigned long) v); }
+
+  friend   sc_signed operator + (int64               u, const sc_unsigned&  v);
+  friend sc_unsigned operator + (uint64              u, const sc_unsigned&  v);
+  friend   sc_signed operator + (long                u, const sc_unsigned&  v);
+  friend sc_unsigned operator + (unsigned long       u, const sc_unsigned&  v);
+  friend   sc_signed operator + (int                 u, const sc_unsigned&  v);
+  friend sc_unsigned operator + (unsigned int        u, const sc_unsigned&  v)
+    { return operator+((unsigned long) u,  v); }
+
+  const sc_unsigned& operator += (const sc_signed&    v);
+  const sc_unsigned& operator += (const sc_unsigned&  v);
+  const sc_unsigned& operator += (int64               v);
+  const sc_unsigned& operator += (uint64              v);
+  const sc_unsigned& operator += (long                v);
+  const sc_unsigned& operator += (unsigned long       v);
+  const sc_unsigned& operator += (int                 v)
+    { return operator+=((long) v); }
+  const sc_unsigned& operator += (unsigned int        v)
+    { return operator+=((unsigned long) v); }
+
+  friend sc_unsigned operator + (const sc_unsigned&  u, const sc_uint_base& v);
+  friend   sc_signed operator + (const sc_unsigned&  u, const sc_int_base&  v);
+  friend sc_unsigned operator + (const sc_uint_base& u, const sc_unsigned&  v);
+  friend   sc_signed operator + (const sc_int_base&  u, const sc_unsigned&  v);
+  const sc_unsigned& operator += (const sc_int_base&  v);
+  const sc_unsigned& operator += (const sc_uint_base& v);
+
+  // SUBtraction operators:
+
+  friend   sc_signed operator - (const sc_unsigned&  u, const sc_signed&    v);
+  friend   sc_signed operator - (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend   sc_signed operator - (const sc_unsigned&  u, const sc_unsigned&  v);
+  friend   sc_signed operator - (const sc_unsigned&  u, int64               v);
+  friend   sc_signed operator - (const sc_unsigned&  u, uint64              v);
+  friend   sc_signed operator - (const sc_unsigned&  u, long                v);
+  friend   sc_signed operator - (const sc_unsigned&  u, unsigned long       v);
+  friend   sc_signed operator - (const sc_unsigned&  u, int                 v);
+  friend   sc_signed operator - (const sc_unsigned&  u, unsigned int        v);
+
+  friend   sc_signed operator - (int64               u, const sc_unsigned&  v);
+  friend   sc_signed operator - (uint64              u, const sc_unsigned&  v);
+  friend   sc_signed operator - (long                u, const sc_unsigned&  v);
+  friend   sc_signed operator - (unsigned long       u, const sc_unsigned&  v);
+  friend   sc_signed operator - (int                 u, const sc_unsigned&  v);
+  friend   sc_signed operator - (unsigned int        u, const sc_unsigned&  v);
+
+  const sc_unsigned& operator -= (const sc_signed&    v);
+  const sc_unsigned& operator -= (const sc_unsigned&  v);
+  const sc_unsigned& operator -= (int64               v);
+  const sc_unsigned& operator -= (uint64              v);
+  const sc_unsigned& operator -= (long                v);
+  const sc_unsigned& operator -= (unsigned long       v);
+  const sc_unsigned& operator -= (int                 v)
+    { return operator-=((long) v); }
+  const sc_unsigned& operator -= (unsigned int        v)
+    { return operator-=((unsigned long) v); }
+
+  friend   sc_signed operator - (const sc_unsigned&  u, const sc_uint_base& v);
+  friend   sc_signed operator - (const sc_unsigned&  u, const sc_int_base&  v);
+  friend   sc_signed operator - (const sc_uint_base& u, const sc_unsigned&  v);
+  friend   sc_signed operator - (const sc_int_base&  u, const sc_unsigned&  v);
+  const sc_unsigned& operator -= (const sc_int_base&  v);
+  const sc_unsigned& operator -= (const sc_uint_base& v);
+
+  // MULtiplication operators:
+
+  friend   sc_signed operator * (const sc_unsigned&  u, const sc_signed&    v);
+  friend   sc_signed operator * (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend sc_unsigned operator * (const sc_unsigned&  u, const sc_unsigned&  v);
+  friend   sc_signed operator * (const sc_unsigned&  u, int64               v);
+  friend sc_unsigned operator * (const sc_unsigned&  u, uint64              v);
+  friend   sc_signed operator * (const sc_unsigned&  u, long                v);
+  friend sc_unsigned operator * (const sc_unsigned&  u, unsigned long       v);
+  friend   sc_signed operator * (const sc_unsigned&  u, int                 v);
+  friend sc_unsigned operator * (const sc_unsigned&  u, unsigned int        v)
+    { return operator*(u, (unsigned long) v); }
+
+  friend   sc_signed operator * (int64               u, const sc_unsigned&  v);
+  friend sc_unsigned operator * (uint64              u, const sc_unsigned&  v);
+  friend   sc_signed operator * (long                u, const sc_unsigned&  v);
+  friend sc_unsigned operator * (unsigned long       u, const sc_unsigned&  v);
+  friend   sc_signed operator * (int                 u, const sc_unsigned&  v);
+  friend sc_unsigned operator * (unsigned int        u, const sc_unsigned&  v)
+    { return operator*((unsigned long) u,  v); }
+
+  const sc_unsigned& operator *= (const sc_signed&    v);
+  const sc_unsigned& operator *= (const sc_unsigned&  v);
+  const sc_unsigned& operator *= (int64               v);
+  const sc_unsigned& operator *= (uint64              v);
+  const sc_unsigned& operator *= (long                v);
+  const sc_unsigned& operator *= (unsigned long       v);
+  const sc_unsigned& operator *= (int                 v)
+    { return operator*=((long) v); }
+  const sc_unsigned& operator *= (unsigned int        v)
+    { return operator*=((unsigned long) v); }
+
+  friend sc_unsigned operator * (const sc_unsigned&  u, const sc_uint_base& v);
+  friend   sc_signed operator * (const sc_unsigned&  u, const sc_int_base&  v);
+  friend sc_unsigned operator * (const sc_uint_base& u, const sc_unsigned&  v);
+  friend   sc_signed operator * (const sc_int_base&  u, const sc_unsigned&  v);
+  const sc_unsigned& operator *= (const sc_int_base&  v);
+  const sc_unsigned& operator *= (const sc_uint_base& v);
+
+  // DIVision operators:
+
+  friend   sc_signed operator / (const sc_unsigned&  u, const sc_signed&    v);
+  friend   sc_signed operator / (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend sc_unsigned operator / (const sc_unsigned&  u, const sc_unsigned&  v);
+  friend   sc_signed operator / (const sc_unsigned&  u, int64               v);
+  friend sc_unsigned operator / (const sc_unsigned&  u, uint64              v);
+  friend   sc_signed operator / (const sc_unsigned&  u, long                v);
+  friend sc_unsigned operator / (const sc_unsigned&  u, unsigned long       v);
+  friend   sc_signed operator / (const sc_unsigned&  u, int                 v);
+  friend sc_unsigned operator / (const sc_unsigned&  u, unsigned int        v)
+    { return operator/(u, (unsigned long) v); }
+
+  friend   sc_signed operator / (int64               u, const sc_unsigned&  v);
+  friend sc_unsigned operator / (uint64              u, const sc_unsigned&  v);
+  friend   sc_signed operator / (long                u, const sc_unsigned&  v);
+  friend sc_unsigned operator / (unsigned long       u, const sc_unsigned&  v);
+  friend   sc_signed operator / (int                 u, const sc_unsigned&  v);
+  friend sc_unsigned operator / (unsigned int        u, const sc_unsigned&  v)
+    { return operator/((unsigned long) u,  v); }
+
+  const sc_unsigned& operator /= (const sc_signed&    v);
+  const sc_unsigned& operator /= (const sc_unsigned&  v);
+  const sc_unsigned& operator /= (int64               v);
+  const sc_unsigned& operator /= (uint64              v);
+  const sc_unsigned& operator /= (long                v);
+  const sc_unsigned& operator /= (unsigned long       v);
+  const sc_unsigned& operator /= (int                 v)
+    { return operator/=((long) v); }
+  const sc_unsigned& operator /= (unsigned int        v)
+    { return operator/=((unsigned long) v); }
+
+  friend sc_unsigned operator / (const sc_unsigned&  u, const sc_uint_base& v);
+  friend   sc_signed operator / (const sc_unsigned&  u, const sc_int_base&  v);
+  friend sc_unsigned operator / (const sc_uint_base& u, const sc_unsigned&  v);
+  friend   sc_signed operator / (const sc_int_base&  u, const sc_unsigned&  v);
+  const sc_unsigned& operator /= (const sc_int_base&  v);
+  const sc_unsigned& operator /= (const sc_uint_base& v);
+
+  // MODulo operators:
+
+  friend   sc_signed operator % (const sc_unsigned&  u, const sc_signed&    v);
+  friend   sc_signed operator % (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend sc_unsigned operator % (const sc_unsigned&  u, const sc_unsigned&  v);
+  friend   sc_signed operator % (const sc_unsigned&  u, int64               v);
+  friend sc_unsigned operator % (const sc_unsigned&  u, uint64              v);
+  friend   sc_signed operator % (const sc_unsigned&  u, long                v);
+  friend sc_unsigned operator % (const sc_unsigned&  u, unsigned long       v);
+  friend   sc_signed operator % (const sc_unsigned&  u, int                 v);
+  friend sc_unsigned operator % (const sc_unsigned&  u, unsigned int        v)
+    { return operator%(u, (unsigned long) v); }
+
+  friend   sc_signed operator % (int64               u, const sc_unsigned&  v);
+  friend sc_unsigned operator % (uint64              u, const sc_unsigned&  v);
+  friend   sc_signed operator % (long                u, const sc_unsigned&  v);
+  friend sc_unsigned operator % (unsigned long       u, const sc_unsigned&  v);
+  friend   sc_signed operator % (int                 u, const sc_unsigned&  v);
+  friend sc_unsigned operator % (unsigned int        u, const sc_unsigned&  v)
+    { return operator%((unsigned long) u,  v); }
+
+  const sc_unsigned& operator %= (const sc_signed&    v);
+  const sc_unsigned& operator %= (const sc_unsigned&  v);
+  const sc_unsigned& operator %= (int64               v);
+  const sc_unsigned& operator %= (uint64              v);
+  const sc_unsigned& operator %= (long                v);
+  const sc_unsigned& operator %= (unsigned long       v);
+  const sc_unsigned& operator %= (int                 v)
+    { return operator%=((long) v); }
+  const sc_unsigned& operator %= (unsigned int        v)
+    { return operator%=((unsigned long) v); }
+
+  friend sc_unsigned operator % (const sc_unsigned&  u, const sc_uint_base& v);
+  friend   sc_signed operator % (const sc_unsigned&  u, const sc_int_base&  v);
+  friend sc_unsigned operator % (const sc_uint_base& u, const sc_unsigned&  v);
+  friend   sc_signed operator % (const sc_int_base&  u, const sc_unsigned&  v);
+  const sc_unsigned& operator %= (const sc_int_base&  v);
+  const sc_unsigned& operator %= (const sc_uint_base& v);
+
+  // BITWISE OPERATORS:
+
+  // Bitwise AND operators:
+
+  friend   sc_signed operator & (const sc_unsigned&  u, const sc_signed&    v);
+  friend   sc_signed operator & (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend sc_unsigned operator & (const sc_unsigned&  u, const sc_unsigned&  v);
+  friend   sc_signed operator & (const sc_unsigned&  u, int64               v);
+  friend sc_unsigned operator & (const sc_unsigned&  u, uint64              v);
+  friend   sc_signed operator & (const sc_unsigned&  u, long                v);
+  friend sc_unsigned operator & (const sc_unsigned&  u, unsigned long       v);
+  friend   sc_signed operator & (const sc_unsigned&  u, int                 v);
+  friend sc_unsigned operator & (const sc_unsigned&  u, unsigned int        v)
+    { return operator&(u, (unsigned long) v); }
+
+  friend   sc_signed operator & (int64               u, const sc_unsigned&  v);
+  friend sc_unsigned operator & (uint64              u, const sc_unsigned&  v);
+  friend   sc_signed operator & (long                u, const sc_unsigned&  v);
+  friend sc_unsigned operator & (unsigned long       u, const sc_unsigned&  v);
+  friend   sc_signed operator & (int                 u, const sc_unsigned&  v);
+  friend sc_unsigned operator & (unsigned int        u, const sc_unsigned&  v)
+    { return operator&((unsigned long) u,  v); }
+
+  const sc_unsigned& operator &= (const sc_signed&    v);
+  const sc_unsigned& operator &= (const sc_unsigned&  v);
+  const sc_unsigned& operator &= (int64               v);
+  const sc_unsigned& operator &= (uint64              v);
+  const sc_unsigned& operator &= (long                v);
+  const sc_unsigned& operator &= (unsigned long       v);
+  const sc_unsigned& operator &= (int                 v)
+    { return operator&=((long) v); }
+  const sc_unsigned& operator &= (unsigned int        v)
+    { return operator&=((unsigned long) v); }
+
+  friend sc_unsigned operator & (const sc_unsigned&  u, const sc_uint_base& v);
+  friend   sc_signed operator & (const sc_unsigned&  u, const sc_int_base&  v);
+  friend sc_unsigned operator & (const sc_uint_base& u, const sc_unsigned&  v);
+  friend   sc_signed operator & (const sc_int_base&  u, const sc_unsigned&  v);
+  const sc_unsigned& operator &= (const sc_int_base&  v);
+  const sc_unsigned& operator &= (const sc_uint_base& v);
+
+  // Bitwise OR operators:
+
+  friend   sc_signed operator | (const sc_unsigned&  u, const sc_signed&    v);
+  friend   sc_signed operator | (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend sc_unsigned operator | (const sc_unsigned&  u, const sc_unsigned&  v);
+  friend   sc_signed operator | (const sc_unsigned&  u, int64               v);
+  friend sc_unsigned operator | (const sc_unsigned&  u, uint64              v);
+  friend   sc_signed operator | (const sc_unsigned&  u, long                v);
+  friend sc_unsigned operator | (const sc_unsigned&  u, unsigned long       v);
+  friend   sc_signed operator | (const sc_unsigned&  u, int                 v);
+  friend sc_unsigned operator | (const sc_unsigned&  u, unsigned int        v)
+    { return operator|(u, (unsigned long) v); }
+
+  friend   sc_signed operator | (int64               u, const sc_unsigned&  v);
+  friend sc_unsigned operator | (uint64              u, const sc_unsigned&  v);
+  friend   sc_signed operator | (long                u, const sc_unsigned&  v);
+  friend sc_unsigned operator | (unsigned long       u, const sc_unsigned&  v);
+  friend   sc_signed operator | (int                 u, const sc_unsigned&  v);
+  friend sc_unsigned operator | (unsigned int        u, const sc_unsigned&  v)
+    { return operator|((unsigned long) u,  v); }
+
+  const sc_unsigned& operator |= (const sc_signed&    v);
+  const sc_unsigned& operator |= (const sc_unsigned&  v);
+  const sc_unsigned& operator |= (int64               v);
+  const sc_unsigned& operator |= (uint64              v);
+  const sc_unsigned& operator |= (long                v);
+  const sc_unsigned& operator |= (unsigned long       v);
+  const sc_unsigned& operator |= (int                 v)
+    { return operator|=((long) v); }
+  const sc_unsigned& operator |= (unsigned int        v)
+    { return operator|=((unsigned long) v); }
+
+  friend sc_unsigned operator | (const sc_unsigned&  u, const sc_uint_base& v);
+  friend   sc_signed operator | (const sc_unsigned&  u, const sc_int_base&  v);
+  friend sc_unsigned operator | (const sc_uint_base& u, const sc_unsigned&  v);
+  friend   sc_signed operator | (const sc_int_base&  u, const sc_unsigned&  v);
+  const sc_unsigned& operator |= (const sc_int_base&  v);
+  const sc_unsigned& operator |= (const sc_uint_base& v);
+
+  // Bitwise XOR operators:
+
+  friend   sc_signed operator ^ (const sc_unsigned&  u, const sc_signed&    v);
+  friend   sc_signed operator ^ (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend sc_unsigned operator ^ (const sc_unsigned&  u, const sc_unsigned&  v);
+  friend   sc_signed operator ^ (const sc_unsigned&  u, int64               v);
+  friend sc_unsigned operator ^ (const sc_unsigned&  u, uint64              v);
+  friend   sc_signed operator ^ (const sc_unsigned&  u, long                v);
+  friend sc_unsigned operator ^ (const sc_unsigned&  u, unsigned long       v);
+  friend   sc_signed operator ^ (const sc_unsigned&  u, int                 v);
+  friend sc_unsigned operator ^ (const sc_unsigned&  u, unsigned int        v)
+    { return operator^(u, (unsigned long) v); }
+
+  friend   sc_signed operator ^ (int64               u, const sc_unsigned&  v);
+  friend sc_unsigned operator ^ (uint64              u, const sc_unsigned&  v);
+  friend   sc_signed operator ^ (long                u, const sc_unsigned&  v);
+  friend sc_unsigned operator ^ (unsigned long       u, const sc_unsigned&  v);
+  friend   sc_signed operator ^ (int                 u, const sc_unsigned&  v);
+  friend sc_unsigned operator ^ (unsigned int        u, const sc_unsigned&  v)
+    { return operator^((unsigned long) u,  v); }
+
+  const sc_unsigned& operator ^= (const sc_signed&    v);
+  const sc_unsigned& operator ^= (const sc_unsigned&  v);
+  const sc_unsigned& operator ^= (int64               v);
+  const sc_unsigned& operator ^= (uint64              v);
+  const sc_unsigned& operator ^= (long                v);
+  const sc_unsigned& operator ^= (unsigned long       v);
+  const sc_unsigned& operator ^= (int                 v)
+    { return operator^=((long) v); }
+  const sc_unsigned& operator ^= (unsigned int        v)
+    { return operator^=((unsigned long) v); }
+
+  friend sc_unsigned operator ^ (const sc_unsigned&  u, const sc_uint_base& v);
+  friend   sc_signed operator ^ (const sc_unsigned&  u, const sc_int_base&  v);
+  friend sc_unsigned operator ^ (const sc_uint_base& u, const sc_unsigned&  v);
+  friend   sc_signed operator ^ (const sc_int_base&  u, const sc_unsigned&  v);
+  const sc_unsigned& operator ^= (const sc_int_base&  v);
+  const sc_unsigned& operator ^= (const sc_uint_base& v);
+
+  // SHIFT OPERATORS:
+
+  // LEFT SHIFT operators:
+
+  friend sc_unsigned operator << (const sc_unsigned&  u, const sc_signed&    v);
+  friend   sc_signed operator << (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend sc_unsigned operator << (const sc_unsigned&  u, const sc_unsigned&  v);
+  friend sc_unsigned operator << (const sc_unsigned&  u, int64               v);
+  friend sc_unsigned operator << (const sc_unsigned&  u, uint64              v);
+  friend sc_unsigned operator << (const sc_unsigned&  u, long                v);
+  friend sc_unsigned operator << (const sc_unsigned&  u, unsigned long       v);
+  friend sc_unsigned operator << (const sc_unsigned&  u, int                 v)
+    { return operator<<(u, (long) v); }
+  friend sc_unsigned operator << (const sc_unsigned&  u, unsigned int        v)
+    { return operator<<(u, (unsigned long) v); }
+
+  const sc_unsigned& operator <<= (const sc_signed&    v);
+  const sc_unsigned& operator <<= (const sc_unsigned&  v);
+  const sc_unsigned& operator <<= (int64               v);
+  const sc_unsigned& operator <<= (uint64              v);
+  const sc_unsigned& operator <<= (long                v);
+  const sc_unsigned& operator <<= (unsigned long       v);
+  const sc_unsigned& operator <<= (int                 v)
+    { return operator<<=((long) v); }
+  const sc_unsigned& operator <<= (unsigned int        v)
+    { return operator<<=((unsigned long) v); }
+
+  friend sc_unsigned operator << (const sc_unsigned&  u, const sc_uint_base& v);
+  friend sc_unsigned operator << (const sc_unsigned&  u, const sc_int_base&  v);
+  const sc_unsigned& operator <<= (const sc_int_base&  v);
+  const sc_unsigned& operator <<= (const sc_uint_base& v);
+
+  // RIGHT SHIFT operators:
+
+  friend sc_unsigned operator >> (const sc_unsigned&  u, const sc_signed&    v);
+  friend   sc_signed operator >> (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend sc_unsigned operator >> (const sc_unsigned&  u, const sc_unsigned&  v);
+  friend sc_unsigned operator >> (const sc_unsigned&  u, int64               v);
+  friend sc_unsigned operator >> (const sc_unsigned&  u, uint64              v);
+  friend sc_unsigned operator >> (const sc_unsigned&  u, long                v);
+  friend sc_unsigned operator >> (const sc_unsigned&  u, unsigned long       v);
+  friend sc_unsigned operator >> (const sc_unsigned&  u, int                 v)
+    { return operator>>(u, (long) v); }
+  friend sc_unsigned operator >> (const sc_unsigned&  u, unsigned int        v)
+    { return operator>>(u, (unsigned long) v); }
+
+  const sc_unsigned& operator >>= (const sc_signed&    v);
+  const sc_unsigned& operator >>= (const sc_unsigned&  v);
+  const sc_unsigned& operator >>= (int64               v);
+  const sc_unsigned& operator >>= (uint64              v);
+  const sc_unsigned& operator >>= (long                v);
+  const sc_unsigned& operator >>= (unsigned long       v);
+  const sc_unsigned& operator >>= (int                 v)
+    { return operator>>=((long) v); }
+  const sc_unsigned& operator >>= (unsigned int        v)
+    { return operator>>=((unsigned long) v); }
+
+  friend sc_unsigned operator >> ( const sc_unsigned& , const sc_uint_base& );
+  friend sc_unsigned operator >> ( const sc_unsigned&, const sc_int_base& );
+  const sc_unsigned& operator >>= (const sc_int_base&  v);
+  const sc_unsigned& operator >>= (const sc_uint_base& v);
+
+  // Unary arithmetic operators
+  friend sc_unsigned operator + (const sc_unsigned& u);
+  friend   sc_signed operator - (const sc_unsigned& u);
+
+  // LOGICAL OPERATORS:
+
+  // Logical EQUAL operators:
+
+  friend bool operator == (const sc_unsigned&  u, const sc_signed&    v);
+  friend bool operator == (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend bool operator == (const sc_unsigned&  u, const sc_unsigned&  v);
+  friend bool operator == (const sc_unsigned&  u, int64               v);
+  friend bool operator == (const sc_unsigned&  u, uint64              v);
+  friend bool operator == (const sc_unsigned&  u, long                v);
+  friend bool operator == (const sc_unsigned&  u, unsigned long       v);
+  friend bool operator == (const sc_unsigned&  u, int                 v)
+    { return operator==(u, (long) v); }
+  friend bool operator == (const sc_unsigned&  u, unsigned int        v)
+    { return operator==(u, (unsigned long) v); }
+
+  friend bool operator == (int64               u, const sc_unsigned&  v);
+  friend bool operator == (uint64              u, const sc_unsigned&  v);
+  friend bool operator == (long                u, const sc_unsigned&  v);
+  friend bool operator == (unsigned long       u, const sc_unsigned&  v);
+  friend bool operator == (int                 u, const sc_unsigned&  v)
+    { return operator==((long) u,  v); }
+  friend bool operator == (unsigned int        u, const sc_unsigned&  v)
+    { return operator==((unsigned long) u,  v); }
+
+  friend bool operator == (const sc_unsigned&  u, const sc_uint_base& v);
+  friend bool operator == (const sc_unsigned&  u, const sc_int_base&  v);
+  friend bool operator == (const sc_uint_base& u, const sc_unsigned&  v);
+  friend bool operator == (const sc_int_base&  u, const sc_unsigned&  v);
+
+  // Logical NOT_EQUAL operators:
+
+  friend bool operator != (const sc_unsigned&  u, const sc_signed&    v);
+  friend bool operator != (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend bool operator != (const sc_unsigned&  u, const sc_unsigned&  v);
+  friend bool operator != (const sc_unsigned&  u, int64               v);
+  friend bool operator != (const sc_unsigned&  u, uint64              v);
+  friend bool operator != (const sc_unsigned&  u, long                v);
+  friend bool operator != (const sc_unsigned&  u, unsigned long       v);
+  friend bool operator != (const sc_unsigned&  u, int                 v)
+    { return operator!=(u, (long) v); }
+  friend bool operator != (const sc_unsigned&  u, unsigned int        v)
+    { return operator!=(u, (unsigned long) v); }
+
+  friend bool operator != (int64               u, const sc_unsigned&  v);
+  friend bool operator != (uint64              u, const sc_unsigned&  v);
+  friend bool operator != (long                u, const sc_unsigned&  v);
+  friend bool operator != (unsigned long       u, const sc_unsigned&  v);
+  friend bool operator != (int                 u, const sc_unsigned&  v)
+    { return operator!=((long) u,  v); }
+  friend bool operator != (unsigned int        u, const sc_unsigned&  v)
+    { return operator!=((unsigned long) u,  v); }
+
+  friend bool operator != (const sc_unsigned&  u, const sc_uint_base& v);
+  friend bool operator != (const sc_unsigned&  u, const sc_int_base&  v);
+  friend bool operator != (const sc_uint_base& u, const sc_unsigned&  v);
+  friend bool operator != (const sc_int_base&  u, const sc_unsigned&  v);
+
+  // Logical LESS_THAN operators:
+
+  friend bool operator < (const sc_unsigned&  u, const sc_signed&    v);
+  friend bool operator < (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend bool operator < (const sc_unsigned&  u, const sc_unsigned&  v);
+  friend bool operator < (const sc_unsigned&  u, int64               v);
+  friend bool operator < (const sc_unsigned&  u, uint64              v);
+  friend bool operator < (const sc_unsigned&  u, long                v);
+  friend bool operator < (const sc_unsigned&  u, unsigned long       v);
+  friend bool operator < (const sc_unsigned&  u, int                 v)
+    { return operator<(u, (long) v); }
+  friend bool operator < (const sc_unsigned&  u, unsigned int        v)
+    { return operator<(u, (unsigned long) v); }
+
+  friend bool operator < (int64               u, const sc_unsigned&  v);
+  friend bool operator < (uint64              u, const sc_unsigned&  v);
+  friend bool operator < (long                u, const sc_unsigned&  v);
+  friend bool operator < (unsigned long       u, const sc_unsigned&  v);
+  friend bool operator < (int                 u, const sc_unsigned&  v)
+    { return operator<((long) u,  v); }
+  friend bool operator < (unsigned int        u, const sc_unsigned&  v)
+    { return operator<((unsigned long) u,  v); }
+
+  friend bool operator < (const sc_unsigned&  u, const sc_uint_base& v);
+  friend bool operator < (const sc_unsigned&  u, const sc_int_base&  v);
+  friend bool operator < (const sc_uint_base& u, const sc_unsigned&  v);
+  friend bool operator < (const sc_int_base&  u, const sc_unsigned&  v);
+
+  // Logical LESS_THAN_AND_EQUAL operators:
+
+  friend bool operator <= (const sc_unsigned&  u, const sc_signed&    v);
+  friend bool operator <= (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend bool operator <= (const sc_unsigned&  u, const sc_unsigned&  v);
+  friend bool operator <= (const sc_unsigned&  u, int64               v);
+  friend bool operator <= (const sc_unsigned&  u, uint64              v);
+  friend bool operator <= (const sc_unsigned&  u, long                v);
+  friend bool operator <= (const sc_unsigned&  u, unsigned long       v);
+  friend bool operator <= (const sc_unsigned&  u, int                 v)
+    { return operator<=(u, (long) v); }
+  friend bool operator <= (const sc_unsigned&  u, unsigned int        v)
+    { return operator<=(u, (unsigned long) v); }
+
+  friend bool operator <= (int64               u, const sc_unsigned&  v);
+  friend bool operator <= (uint64              u, const sc_unsigned&  v);
+  friend bool operator <= (long                u, const sc_unsigned&  v);
+  friend bool operator <= (unsigned long       u, const sc_unsigned&  v);
+  friend bool operator <= (int                 u, const sc_unsigned&  v)
+    { return operator<=((long) u,  v); }
+  friend bool operator <= (unsigned int        u, const sc_unsigned&  v)
+    { return operator<=((unsigned long) u,  v); }
+
+  friend bool operator <= (const sc_unsigned&  u, const sc_uint_base& v);
+  friend bool operator <= (const sc_unsigned&  u, const sc_int_base&  v);
+  friend bool operator <= (const sc_uint_base& u, const sc_unsigned&  v);
+  friend bool operator <= (const sc_int_base&  u, const sc_unsigned&  v);
+
+  // Logical GREATER_THAN operators:
+
+  friend bool operator > (const sc_unsigned&  u, const sc_signed&    v);
+  friend bool operator > (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend bool operator > (const sc_unsigned&  u, const sc_unsigned&  v);
+  friend bool operator > (const sc_unsigned&  u, int64               v);
+  friend bool operator > (const sc_unsigned&  u, uint64              v);
+  friend bool operator > (const sc_unsigned&  u, long                v);
+  friend bool operator > (const sc_unsigned&  u, unsigned long       v);
+  friend bool operator > (const sc_unsigned&  u, int                 v)
+    { return operator>(u, (long) v); }
+  friend bool operator > (const sc_unsigned&  u, unsigned int        v)
+    { return operator>(u, (unsigned long) v); }
+
+  friend bool operator > (int64               u, const sc_unsigned&  v);
+  friend bool operator > (uint64              u, const sc_unsigned&  v);
+  friend bool operator > (long                u, const sc_unsigned&  v);
+  friend bool operator > (unsigned long       u, const sc_unsigned&  v);
+  friend bool operator > (int                 u, const sc_unsigned&  v)
+    { return operator>((long) u,  v); }
+  friend bool operator > (unsigned int        u, const sc_unsigned&  v)
+    { return operator>((unsigned long) u,  v); }
+
+  friend bool operator > (const sc_unsigned&  u, const sc_uint_base& v);
+  friend bool operator > (const sc_unsigned&  u, const sc_int_base&  v);
+  friend bool operator > (const sc_uint_base& u, const sc_unsigned&  v);
+  friend bool operator > (const sc_int_base&  u, const sc_unsigned&  v);
+
+  // Logical GREATER_THAN_AND_EQUAL operators:
+
+  friend bool operator >= (const sc_unsigned&  u, const sc_signed&    v);
+  friend bool operator >= (const sc_signed&    u, const sc_unsigned&  v);
+
+  friend bool operator >= (const sc_unsigned&  u, const sc_unsigned&  v);
+  friend bool operator >= (const sc_unsigned&  u, int64               v);
+  friend bool operator >= (const sc_unsigned&  u, uint64              v);
+  friend bool operator >= (const sc_unsigned&  u, long                v);
+  friend bool operator >= (const sc_unsigned&  u, unsigned long       v);
+  friend bool operator >= (const sc_unsigned&  u, int                 v)
+    { return operator>=(u, (long) v); }
+  friend bool operator >= (const sc_unsigned&  u, unsigned int        v)
+    { return operator>=(u, (unsigned long) v); }
+
+  friend bool operator >= (int64               u, const sc_unsigned&  v);
+  friend bool operator >= (uint64              u, const sc_unsigned&  v);
+  friend bool operator >= (long                u, const sc_unsigned&  v);
+  friend bool operator >= (unsigned long       u, const sc_unsigned&  v);
+  friend bool operator >= (int                 u, const sc_unsigned&  v)
+    { return operator>=((long) u,  v); }
+  friend bool operator >= (unsigned int        u, const sc_unsigned&  v)
+    { return operator>=((unsigned long) u,  v); }
+
+  friend bool operator >= (const sc_unsigned&  u, const sc_uint_base& v);
+  friend bool operator >= (const sc_unsigned&  u, const sc_int_base&  v);
+  friend bool operator >= (const sc_uint_base& u, const sc_unsigned&  v);
+  friend bool operator >= (const sc_int_base&  u, const sc_unsigned&  v);
+
+  // Bitwise NOT operator (unary).
+  friend sc_unsigned operator ~ (const sc_unsigned& u);
+
+  // Helper functions.
+  friend int compare_unsigned(small_type us,
+                              int unb,
+                              int und,
+                              const sc_digit *ud,
+                              small_type vs,
+                              int vnb,
+                              int vnd,
+                              const sc_digit *vd,
+                              small_type if_u_signed,
+                              small_type if_v_signed);
+
+  friend sc_unsigned add_unsigned_friend(small_type us,
+                                         int unb,
+                                         int und,
+                                         const sc_digit *ud,
+                                         small_type vs,
+                                         int vnb,
+                                         int vnd,
+                                         const sc_digit *vd);
+
+  friend sc_unsigned sub_unsigned_friend(small_type us,
+                                         int unb,
+                                         int und,
+                                         const sc_digit *ud,
+                                         small_type vs,
+                                         int vnb,
+                                         int vnd,
+                                         const sc_digit *vd);
+
+  friend sc_unsigned mul_unsigned_friend(small_type s,
+                                         int unb,
+                                         int und,
+                                         const sc_digit *ud,
+                                         int vnb,
+                                         int vnd,
+                                         const sc_digit *vd);
+
+  friend sc_unsigned div_unsigned_friend(small_type s,
+                                         int unb,
+                                         int und,
+                                         const sc_digit *ud,
+                                         int vnb,
+                                         int vnd,
+                                         const sc_digit *vd);
+
+  friend sc_unsigned mod_unsigned_friend(small_type us,
+                                         int unb,
+                                         int und,
+                                         const sc_digit *ud,
+                                         int vnb,
+                                         int vnd,
+                                         const sc_digit *vd);
+
+  friend sc_unsigned and_unsigned_friend(small_type us,
+                                         int unb,
+                                         int und,
+                                         const sc_digit *ud,
+                                         small_type vs,
+                                         int vnb,
+                                         int vnd,
+                                         const sc_digit *vd);
+
+  friend sc_unsigned or_unsigned_friend(small_type us,
+                                        int unb,
+                                        int und,
+                                        const sc_digit *ud,
+                                        small_type vs,
+                                        int vnb,
+                                        int vnd,
+                                        const sc_digit *vd);
+
+  friend sc_unsigned xor_unsigned_friend(small_type us,
+                                         int unb,
+                                         int und,
+                                         const sc_digit *ud,
+                                         small_type vs,
+                                         int vnb,
+                                         int vnd,
+                                         const sc_digit *vd);
+
+public:
+  static sc_core::sc_vpool<sc_unsigned> m_pool;
+
+private:
+
+  small_type  sgn;         // Shortened as s.
+  int nbits;       // Shortened as nb.
+  int ndigits;     // Shortened as nd.
+
+#ifdef SC_MAX_NBITS
+  sc_digit digit[DIV_CEIL(SC_MAX_NBITS)];   // Shortened as d.
+#else
+  sc_digit *digit;                       // Shortened as d.
+#endif
+
+  // Private constructors:
+
+  // Create a copy of v with sign s.
+  sc_unsigned(const sc_unsigned& v, small_type s);
+  sc_unsigned(const sc_signed&   v, small_type s);
+
+  // Create an unsigned number with the given attributes.
+  sc_unsigned(small_type s, int nb, int nd,
+              sc_digit *d, bool alloc = true);
+
+  // Create an unsigned number using the bits u[l..r].
+  sc_unsigned(const sc_signed* u, int l, int r);
+  sc_unsigned(const sc_unsigned* u, int l, int r);
+
+  // Private member functions. The called functions are inline functions.
+
+  small_type default_sign() const
+    { return SC_POS; }
+
+  int num_bits(int nb) const { return nb + 1; }
+
+  bool check_if_outside(int bit_num) const;
+
+  void copy_digits(int nb, int nd, const sc_digit *d)
+    { copy_digits_unsigned(sgn, nbits, ndigits, digit, nb, nd, d); }
+
+  void makezero()
+    { sgn = make_zero(ndigits, digit); }
+
+  // Conversion functions between 2's complement (2C) and
+  // sign-magnitude (SM):
+  void convert_2C_to_SM()
+    { sgn = convert_unsigned_2C_to_SM(nbits, ndigits, digit); }
+
+  void convert_SM_to_2C_to_SM()
+    { sgn = convert_unsigned_SM_to_2C_to_SM(sgn, nbits, ndigits, digit); }
+
+  void convert_SM_to_2C()
+    { convert_unsigned_SM_to_2C(sgn, ndigits, digit); }
+
+};
+
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream&, const sc_unsigned& );
+
+inline
+::std::istream&
+operator >> ( ::std::istream&, sc_unsigned& );
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_unsigned_bitref_r
+//
+//  Proxy class for sc_unsigned bit selection (r-value only).
+// ----------------------------------------------------------------------------
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_unsigned_bitref_r& a )
+{
+    a.print( os );
+    return os;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_unsigned_bitref
+//
+//  Proxy class for sc_unsigned bit selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+template<class T>
+inline const sc_unsigned_subref& sc_unsigned_subref::operator = (
+    const sc_generic_base<T>& a )
+{
+    sc_unsigned temp( length() );
+    a->to_sc_unsigned(temp);
+    return *this = temp;
+}
+
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_unsigned_bitref& a )
+{
+    a.scan( is );
+    return is;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_unsigned_subref_r
+//
+//  Proxy class for sc_unsigned part selection (r-value only).
+// ----------------------------------------------------------------------------
+
+// reduce methods
+
+inline bool sc_unsigned_subref_r::and_reduce() const
+{
+   const sc_unsigned* target_p = m_obj_p;
+   for ( int i = m_right; i <= m_left; i++ )
+	if ( !target_p->test(i) ) return false;
+   return true;
+}
+
+inline bool sc_unsigned_subref_r::nand_reduce() const
+{
+    return !and_reduce();
+}
+
+inline bool sc_unsigned_subref_r::or_reduce() const
+{
+   const sc_unsigned* target_p = m_obj_p;
+   for ( int i = m_right; i <= m_left; i++ )
+	if ( target_p->test(i) ) return true;
+   return false;
+}
+
+inline bool sc_unsigned_subref_r::nor_reduce() const
+{
+    return !or_reduce();
+}
+
+inline bool sc_unsigned_subref_r::xor_reduce() const
+{
+   int                odd;
+   const sc_unsigned* target_p = m_obj_p;
+   odd = 0;
+   for ( int i = m_right; i <= m_left; i++ )
+	if ( target_p->test(i) ) odd = ~odd;
+   return odd ? true : false;
+}
+
+inline bool sc_unsigned_subref_r::xnor_reduce() const
+{
+    return !xor_reduce();
+}
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_unsigned_subref_r& a )
+{
+    a.print( os );
+    return os;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_unsigned_subref
+//
+//  Proxy class for sc_unsigned part selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+// assignment operators
+
+inline
+const sc_unsigned_subref&
+sc_unsigned_subref::operator = ( const char* a )
+{
+    sc_unsigned aa( length() );
+    return ( *this = aa = a );
+}
+
+
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_unsigned_subref& a )
+{
+    a.scan( is );
+    return is;
+}
+
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_unsigned
+//
+//  Arbitrary precision signed number.
+// ----------------------------------------------------------------------------
+
+template<class T>
+sc_unsigned::sc_unsigned( const sc_generic_base<T>& v )
+{
+    int nb = v->length();
+    sgn = default_sign();
+    if( nb > 0 ) {
+        nbits = num_bits( nb );
+    } else {
+        char msg[BUFSIZ];
+        std::sprintf( msg,
+		    "sc_unsigned( sc_generic_base<T> ) : nb = %d is not valid", nb);
+        SC_REPORT_ERROR( sc_core::SC_ID_INIT_FAILED_, msg );
+    }
+    ndigits = DIV_CEIL(nbits);
+#   ifdef SC_MAX_NBITS
+        test_bound(nb);
+#    else
+        digit = new sc_digit[ndigits];
+#    endif
+    makezero();
+    v->to_sc_unsigned(*this);
+}
+
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_unsigned& a )
+{
+    a.print( os );
+    return os;
+}
+
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_unsigned& a )
+{
+    a.scan( is );
+    return is;
+}
+
+
+} // namespace sc_dt
+
+
+#endif
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_unsigned_bitref.inc b/ext/systemc/src/sysc/datatypes/int/sc_unsigned_bitref.inc
new file mode 100644
index 000000000..c1ad02662
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_unsigned_bitref.inc
@@ -0,0 +1,162 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_unsigned_bitref.h -- Proxy class that is declared in sc_unsigned.h.  
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+ 
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_unsigned_bitref_r
+//
+//  Proxy class for sc_unsigned bit selection (r-value only).
+// ----------------------------------------------------------------------------
+
+// implicit conversion to uint64
+
+sc_unsigned_bitref_r::operator uint64 () const
+{
+    return m_obj_p->test( m_index );
+}
+
+bool
+sc_unsigned_bitref_r::operator ! () const
+{
+    return ( ! m_obj_p->test( m_index ) );
+}
+
+bool
+sc_unsigned_bitref_r::operator ~ () const
+{
+    return ( ! m_obj_p->test( m_index ) );
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_unsigned_bitref
+//
+//  Proxy class for sc_unsigned bit selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+// assignment operators
+
+const sc_unsigned_bitref&
+sc_unsigned_bitref::operator = ( const sc_unsigned_bitref_r& b )
+{
+    m_obj_p->set( m_index, (bool) b );
+    return *this;
+}
+
+const sc_unsigned_bitref&
+sc_unsigned_bitref::operator = ( const sc_unsigned_bitref& b )
+{
+    m_obj_p->set( m_index, (bool) b );
+    return *this;
+}
+
+const sc_unsigned_bitref&
+sc_unsigned_bitref::operator = ( bool b )
+{
+    m_obj_p->set( m_index, b );
+    return *this;
+}
+
+
+const sc_unsigned_bitref&
+sc_unsigned_bitref::operator &= ( bool b )
+{
+    if( ! b ) {
+	m_obj_p->clear( m_index );
+    }
+    return *this;
+}
+
+const sc_unsigned_bitref&
+sc_unsigned_bitref::operator |= ( bool b )
+{
+    if( b ) {
+	m_obj_p->set( m_index );
+    }
+    return *this;
+}
+
+const sc_unsigned_bitref&
+sc_unsigned_bitref::operator ^= ( bool b )
+{
+    if( b ) {
+	m_obj_p->invert( m_index );
+    }
+    return *this;
+}
+
+// #### OPTIMIZE
+void sc_unsigned_bitref::concat_set(int64 src, int low_i)
+{
+	bool value = 1 & ((low_i < 64) ? (src >> low_i) : (src >> 63));
+    m_obj_p->set(low_i, value);
+}
+
+void sc_unsigned_bitref::concat_set(const sc_signed& src, int low_i)
+{
+    if ( low_i < src.length() )
+        m_obj_p->set(low_i, src.test(low_i));
+    else
+        m_obj_p->set(low_i, src<0);
+}
+
+void sc_unsigned_bitref::concat_set(const sc_unsigned& src, int low_i)
+{       
+    if ( low_i < src.nbits )
+        m_obj_p->set(low_i, src.test(low_i));
+    else
+        m_obj_p->set(low_i, 0);
+}
+
+void sc_unsigned_bitref::concat_set(uint64 src, int low_i)
+{
+	bool value = ((low_i < 64) ? (src >> low_i)&1 : 0);
+    m_obj_p->set(low_i, value);
+}
+
+// other methods
+
+void
+sc_unsigned_bitref::scan( ::std::istream& is )
+{
+    bool b;
+    is >> b;
+    *this = b;
+}
+
+
+// End of file
diff --git a/ext/systemc/src/sysc/datatypes/int/sc_unsigned_subref.inc b/ext/systemc/src/sysc/datatypes/int/sc_unsigned_subref.inc
new file mode 100644
index 000000000..142d6b2dc
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/int/sc_unsigned_subref.inc
@@ -0,0 +1,407 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_unsigned_subref.h -- Proxy class that is declared in sc_unsigned.h.  
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+ 
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_unsigned_subref_r
+//
+//  Proxy class for sc_unsigned part selection (r-value only).
+// ----------------------------------------------------------------------------
+
+// concatenation support
+
+uint64 sc_unsigned_subref_r::concat_get_uint64() const // #### Speed up!
+{
+    sc_unsigned a( m_obj_p, m_left, m_right );
+    return a.to_uint64();
+}
+
+
+bool sc_unsigned_subref_r::concat_get_ctrl(sc_digit* dst_p, int low_i) const
+    // #### Speed up!
+{
+    sc_unsigned a( m_obj_p, m_left, m_right );  
+    return a.concat_get_ctrl( dst_p, low_i );
+}
+
+bool sc_unsigned_subref_r::concat_get_data(sc_digit* dst_p, int low_i) const
+    // #### Speed up!
+{
+    sc_unsigned a( m_obj_p, m_left, m_right );  
+    return a.concat_get_data( dst_p, low_i );
+}
+
+
+// implicit conversion to sc_unsigned
+
+sc_unsigned_subref_r::operator sc_unsigned () const
+{
+    return sc_unsigned( m_obj_p, m_left, m_right );
+}
+
+
+// explicit conversions
+
+int
+sc_unsigned_subref_r::to_int() const
+{
+    sc_unsigned a(  m_obj_p, m_left, m_right );
+    return a.to_int();
+}
+
+unsigned int
+sc_unsigned_subref_r::to_uint() const
+{
+    sc_unsigned a( m_obj_p, m_left, m_right );
+    return a.to_uint();
+}
+
+long
+sc_unsigned_subref_r::to_long() const
+{
+    sc_unsigned a( m_obj_p, m_left, m_right );
+    return a.to_long();
+}
+
+unsigned long
+sc_unsigned_subref_r::to_ulong() const
+{
+    sc_unsigned a( m_obj_p, m_left, m_right );
+    return a.to_ulong();
+}
+
+int64
+sc_unsigned_subref_r::to_int64() const
+{
+    sc_unsigned a( m_obj_p, m_left, m_right );
+    return a.to_int64();
+}
+
+uint64
+sc_unsigned_subref_r::to_uint64() const
+{
+    sc_unsigned a( m_obj_p, m_left, m_right );
+    return a.to_uint64();
+}
+
+double
+sc_unsigned_subref_r::to_double() const
+{
+    sc_unsigned a( m_obj_p, m_left, m_right );
+    return a.to_double();
+}
+
+
+// explicit conversion to character string
+
+const std::string
+sc_unsigned_subref_r::to_string( sc_numrep numrep ) const
+{
+    sc_unsigned a( length() );
+    a = *this;
+    return a.to_string( numrep );
+}
+
+const std::string
+sc_unsigned_subref_r::to_string( sc_numrep numrep, bool w_prefix ) const
+{
+    sc_unsigned a( length() );
+    a = *this;
+    return a.to_string( numrep, w_prefix );
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_unsigned_subref
+//
+//  Proxy class for sc_unsigned part selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+// assignment operators
+
+const sc_unsigned_subref& 
+sc_unsigned_subref::operator = ( const sc_unsigned_subref_r& a )
+{
+    return operator = ( (sc_unsigned)( a ) );
+}
+
+const sc_unsigned_subref& 
+sc_unsigned_subref::operator = ( const sc_unsigned_subref& a )
+{
+    if( this == &a ) {
+	return *this;
+    }
+    return operator = ( (sc_unsigned)( a ) );
+}
+
+const sc_unsigned_subref& 
+sc_unsigned_subref::operator = ( const sc_unsigned& v )
+{
+    int i;
+    int l = sc_min( m_left, v.nbits - 1 + m_right );
+
+    for( i = m_right; i <= l; ++ i ) m_obj_p->set( i, v.test( i - m_right ) );
+    for ( ; i <= m_left; i++ ) m_obj_p->set( i, v.test( l ) );
+    return *this;
+}
+
+const sc_unsigned_subref& 
+sc_unsigned_subref::operator = ( const sc_signed_subref_r& v )
+{
+    return operator = ( (sc_unsigned)( v ) );
+}
+
+const sc_unsigned_subref& 
+sc_unsigned_subref::operator = ( const sc_signed& v )
+{
+    int i;
+    int l = sc_min( m_left, v.nbits - 1 + m_right );
+
+    for( i = m_right; i <= l; ++ i ) m_obj_p->set( i, v.test( i - m_right ) );
+    for ( ; i <= m_left; i++ ) m_obj_p->set( i, 0 );
+    return *this;
+}
+
+const sc_unsigned_subref& 
+sc_unsigned_subref::operator = ( unsigned long v )
+{
+    for( int i = m_right; i <= m_left; ++ i ) {
+	m_obj_p->set( i, static_cast<bool>( v & 1 ) );
+	v >>= 1;
+    }
+    return *this;
+}
+
+const sc_unsigned_subref& 
+sc_unsigned_subref::operator = ( long v ) 
+{
+    unsigned long v2 = (unsigned long) v;
+    for( int i = m_right; i <= m_left; ++ i ) {
+	m_obj_p->set( i, static_cast<bool>( v2 & 1 ) );
+	v2 >>= 1;
+    }
+    return *this;
+}
+
+const sc_unsigned_subref& 
+sc_unsigned_subref::operator = ( uint64  v )
+{
+    for( int i = m_right; i <= m_left; ++ i ) {
+	m_obj_p->set( i, static_cast<bool>( v & 1 ) );
+	v >>= 1;
+    }
+    return *this;
+}
+
+const sc_unsigned_subref& 
+sc_unsigned_subref::operator = ( int64 v ) 
+{
+    uint64 v2 = (uint64) v;
+    for( int i = m_right; i <= m_left; ++ i ) {
+	m_obj_p->set( i, static_cast<bool>( v2 & 1 ) );
+	v2 >>= 1;
+    }
+    return *this;
+}
+
+const sc_unsigned_subref& 
+sc_unsigned_subref::operator = ( double v )
+{
+    is_bad_double(v);
+
+    int nb = m_left - m_right + 1;
+    int nd = DIV_CEIL(nb);
+
+#ifdef SC_MAX_NBITS
+    sc_digit d[MAX_NDIGITS];
+#else
+    sc_digit *d = new sc_digit[nd];
+#endif
+
+    if (v < 0)
+	v = -v;
+
+    int i = 0;
+
+    while (floor(v) && (i < nd)) {
+#ifndef _WIN32
+	d[i++] = (sc_digit) floor(remainder(v, DIGIT_RADIX));
+#else
+	d[i++] = (sc_digit) floor(fmod(v, DIGIT_RADIX));
+#endif
+	v /= DIGIT_RADIX;
+    }
+
+    vec_zero(i, nd, d);
+
+    sc_digit val = 1;  // Bit value.
+    int j = 0;   // Current digit in d.
+
+    i = 0;  // Current bit in d.
+
+    while (i < nb) {
+
+	m_obj_p->set(i + m_right, (bool) (d[j] & val));
+
+	++i;
+
+	if (i % BITS_PER_DIGIT == 0) {
+	    val = 1;
+	    ++j;
+	}
+	else
+	    val <<= 1;
+    }
+
+#ifndef SC_MAX_NBITS
+    delete [] d;
+#endif
+
+    return *this;
+}
+
+const sc_unsigned_subref&
+sc_unsigned_subref::operator = ( const sc_int_base& a )
+{
+    return operator = ( (int64) a );
+}
+
+const sc_unsigned_subref&
+sc_unsigned_subref::operator = ( const sc_uint_base& a )
+{
+    return operator = ( (uint64) a );
+}
+
+// concatenation methods
+
+void sc_unsigned_subref::concat_set( int64 src, int low_i )
+{
+    int  i;
+    int  l;
+    bool sign = src < 0;
+
+    if ( low_i < 64 )    
+    {    
+	src = src >> low_i;
+	l = sc_min( m_left, (63-low_i) + m_right );    
+	for( i = m_right; i <= l; ++ i ) {    
+		m_obj_p->set( i, src & 1 );    
+		src = src >> 1;    
+	}    
+	for ( ; i <= m_left; i++ ) m_obj_p->set(sign);     
+    }    
+    else    
+    {    
+	for( i = m_right; i <= m_left; ++ i ) m_obj_p->set(sign);     
+    }    
+}
+
+void sc_unsigned_subref::concat_set( const sc_signed& src, int low_i )
+{
+    int i;
+    int l;
+    int src_i;
+    bool sign = src.test(src.nbits-1);
+    l = src.nbits - (low_i+1);
+    if ( l >= 0 )
+    {
+	src_i = low_i;
+	l = sc_min( m_left, l + m_right );
+	for( i = m_right; i <= l; ++ i, src_i++ ) {
+	    m_obj_p->set( i, src.test( src_i ) );
+	}
+	for ( ; i <= m_left; i++ ) m_obj_p->set(i, sign);
+    }
+    else
+    {    
+	for( i = m_right; i <= m_left; ++ i ) m_obj_p->set(i, sign);     
+    }    
+}
+
+void sc_unsigned_subref::concat_set( const sc_unsigned& src, int low_i )
+{
+    int i;
+    int l;
+    int src_i;
+    l = src.nbits - (low_i+2);
+    if ( l >= 0 )
+    {
+	src_i = low_i;
+	l = sc_min( m_left, l + m_right );
+	for( i = m_right; i <= l; ++ i, src_i++ ) {
+	    m_obj_p->set( i, src.test( src_i ) );
+	}
+	for ( ; i <= m_left; i++ ) m_obj_p->set(i, false);
+    }
+    else
+    {    
+	for( i = m_right; i <= m_left; ++ i ) m_obj_p->set(i, false);     
+    }    
+}
+
+void sc_unsigned_subref::concat_set( uint64 src, int low_i )
+{
+    int  i;
+    int  l;
+
+    if ( low_i < 64 )    
+    {    
+	src = src >> low_i;
+	l = sc_min( m_left, (63-low_i) + m_right );    
+	for( i = m_right; i <= l; ++ i ) {    
+		m_obj_p->set( i, src & 1 );    
+		src = src >> 1;    
+	}    
+	for ( ; i <= m_left; i++ ) m_obj_p->set(false);     
+    }    
+    else    
+    {    
+	for( i = m_right; i <= m_left; ++ i ) m_obj_p->set(false);     
+    }    
+}
+// other methods
+
+void
+sc_unsigned_subref::scan( ::std::istream& is )
+{
+    std::string s;
+    is >> s;
+    *this = s.c_str();
+}
+
+
+// End of file
diff --git a/ext/systemc/src/sysc/datatypes/misc/sc_concatref.cpp b/ext/systemc/src/sysc/datatypes/misc/sc_concatref.cpp
new file mode 100644
index 000000000..566bee234
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/misc/sc_concatref.cpp
@@ -0,0 +1,59 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+    sc_concatref.cpp -- Concatenation support.
+
+    Original Author: Andy Goodrich, Forte Design Systems, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_concatref.cpp,v $
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:54:01  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include "sysc/datatypes/misc/sc_concatref.h"
+#include "sysc/utils/sc_temporary.h"
+
+// STORAGE POOLS USED BY sc_concatref:
+
+namespace sc_dt {
+    sc_core::sc_vpool<sc_concat_bool> sc_concat_bool::m_pool(9);
+    sc_core::sc_vpool<sc_concatref>   sc_concatref::m_pool(9);
+} // namespace sc_dt
+
+namespace sc_core {
+    sc_byte_heap             sc_temp_heap(0x300000);
+} // namespace sc_core
diff --git a/ext/systemc/src/sysc/datatypes/misc/sc_concatref.h b/ext/systemc/src/sysc/datatypes/misc/sc_concatref.h
new file mode 100644
index 000000000..92dcc18ec
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/misc/sc_concatref.h
@@ -0,0 +1,855 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_concatref.h -- Concatenation support.
+ 
+  Original Author: Andy Goodrich, Forte Design, Inc.
+  
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+  Andy Goodrich, Forte Design Systems, 17 Nov 2002
+  Creation of sc_concatref class by merging the capabilities of 
+  sc_int_concref, sc_int_concref, sc_uint_concref, sc_uint_concref, 
+  and implementing the capabilities of sc_signed_concref, sc_signed_concref, 
+  sc_unsigned_concref, and sc_unsigned_concref. The resultant class allows 
+  mixed mode concatenations on the left and right sides of an assignment.
+
+ *****************************************************************************/
+
+// $Log: sc_concatref.h,v $
+// Revision 1.6  2011/08/24 22:05:48  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.5  2009/11/17 19:58:15  acg
+//  Andy Goodrich: fix of shift rhs possibilities to include "int".
+//
+// Revision 1.4  2009/02/28 00:26:29  acg
+//  Andy Goodrich: bug fixes.
+//
+// Revision 1.3  2008/04/29 20:23:55  acg
+//  Andy Goodrich: fixed the code that assigns the value of a string to
+//  an sc_concatref instance.
+//
+// Revision 1.2  2008/02/14 20:57:26  acg
+//  Andy Goodrich: added casts to ~0 instances to keep MSVC compiler happy.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.4  2006/10/23 19:36:59  acg
+//  Andy Goodrich: changed casts for operations on concatenation values to
+//  mirror those of sc_unsigned. For instance, an sc_unsigned minus a value
+//  returns an sc_signed result, whereas an sc_concatref minus a value was
+//  returning an sc_unsigned result. Now both sc_unsigned and sc_concatref
+//  minus a value return an sc_signed result.
+//
+// Revision 1.3  2006/01/13 18:54:01  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SC_CONCATREF_H
+#define SC_CONCATREF_H
+
+#include "sysc/kernel/sc_object.h"
+#include "sysc/datatypes/misc/sc_value_base.h"
+#include "sysc/utils/sc_temporary.h"
+#include "sysc/datatypes/bit/sc_bv.h"
+#include "sysc/datatypes/bit/sc_lv.h"
+#include "sysc/datatypes/int/sc_int_base.h"
+#include "sysc/datatypes/int/sc_uint_base.h"
+#include "sysc/datatypes/int/sc_signed.h"
+#include "sysc/datatypes/int/sc_unsigned.h"
+
+namespace sc_core {
+    extern sc_byte_heap sc_temp_heap; // Temporary storage.
+} // namespace sc_core
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_concatref
+//
+//  Proxy class for sized bit concatenation.
+// ----------------------------------------------------------------------------
+
+class sc_concatref : public sc_generic_base<sc_concatref>, public sc_value_base
+{
+public:
+    friend class sc_core::sc_vpool<sc_concatref>;
+
+    inline void initialize( 
+        sc_value_base& left, sc_value_base& right )
+        {    
+            bool left_xz;   // True if x's and/or z's found in left.
+            bool right_xz;  // True if x's and/or z's found in right.
+            
+            m_left_p = (sc_value_base*)&left;
+            m_right_p = (sc_value_base*)&right;
+            m_len_r = right.concat_length(&right_xz);
+            m_len = left.concat_length(&left_xz) + m_len_r;
+            m_flags = ( left_xz || right_xz ) ? cf_xz_present : cf_none;
+        }
+
+
+    inline void initialize( 
+        const sc_value_base& left, const sc_value_base& right )
+        {    
+            bool left_xz;   // True if x's and/or z's found in left.
+            bool right_xz;  // True if x's and/or z's found in right.
+
+            m_left_p = (sc_value_base*)&left;
+            m_right_p = (sc_value_base*)&right;
+            m_len_r = right.concat_length(&right_xz);
+            m_len = left.concat_length(&left_xz) + m_len_r;
+            m_flags = ( left_xz || right_xz ) ? cf_xz_present : cf_none;
+        }
+
+    // destructor
+
+    virtual ~sc_concatref()
+    {}
+
+
+    // capacity
+
+    unsigned int length() const
+        { return m_len; }
+
+#ifdef SC_DT_DEPRECATED
+    int bitwidth() const
+        { return length(); }
+#endif
+
+    // concatenation
+
+    virtual int concat_length( bool* xz_present_p ) const
+    { 
+        if ( xz_present_p ) 
+            *xz_present_p = m_flags & cf_xz_present ? true : false;
+        return m_len; 
+    }
+
+    virtual void concat_clear_data( bool to_ones )
+    { 
+        m_left_p->concat_clear_data(to_ones); 
+        m_right_p->concat_clear_data(to_ones); 
+    }
+
+    virtual bool concat_get_ctrl( sc_digit* dst_p, int low_i ) const
+    {
+        bool rnz = m_right_p->concat_get_ctrl( dst_p, low_i );
+        bool lnz = m_left_p->concat_get_ctrl( dst_p, low_i+m_len_r );
+        return rnz || lnz;
+    }
+
+    virtual bool concat_get_data( sc_digit* dst_p, int low_i ) const
+    {
+        bool rnz = m_right_p->concat_get_data( dst_p, low_i );
+        bool lnz = m_left_p->concat_get_data( dst_p, low_i+m_len_r );
+        return rnz || lnz;
+    }
+
+    virtual uint64 concat_get_uint64() const
+    {
+        if ( m_len_r >= 64 )
+            return m_right_p->concat_get_uint64();
+        else
+        {
+            return (m_left_p->concat_get_uint64() << m_len_r) | 
+                m_right_p->concat_get_uint64();
+        }
+    }
+
+    virtual void concat_set( int64 src, int low_i ) 
+    { 
+        m_right_p->concat_set( src, low_i );
+        m_left_p->concat_set( src, low_i+m_len_r);
+    }
+
+    virtual void concat_set( const sc_signed& src, int low_i ) 
+    {
+        m_right_p->concat_set( src, low_i );
+        m_left_p->concat_set( src, low_i+m_len_r);
+    }
+
+    virtual void concat_set( const sc_unsigned& src, int low_i ) 
+    { 
+        m_right_p->concat_set( src, low_i );
+        m_left_p->concat_set( src, low_i+m_len_r);
+    }
+
+    virtual void concat_set( uint64 src, int low_i )
+    { 
+        m_right_p->concat_set( src, low_i );
+        m_left_p->concat_set( src, low_i+m_len_r);
+    }
+
+
+    // explicit conversions
+
+    uint64 to_uint64() const 
+        {
+            uint64 mask;
+            uint64 result;
+
+            result = m_right_p->concat_get_uint64();
+            if ( m_len_r < 64 )
+            {
+                mask = (uint64)~0;
+                result = (m_left_p->concat_get_uint64() << m_len_r) | 
+                            (result & ~(mask << m_len_r));
+            }
+            if ( m_len < 64 )
+            {
+                mask = (uint64)~0;
+                result = result & ~(mask << m_len);
+            }
+            return result;
+        }
+
+    const sc_unsigned& value() const
+        {
+            bool           left_non_zero;
+            sc_unsigned*   result_p = sc_unsigned::m_pool.allocate();
+            bool           right_non_zero;
+
+            result_p->nbits = result_p->num_bits(m_len);
+	    result_p->ndigits = DIV_CEIL(result_p->nbits);
+            result_p->digit = (sc_digit*)sc_core::sc_temp_heap.allocate( 
+                sizeof(sc_digit)*result_p->ndigits );
+#if defined(_MSC_VER)
+            // workaround spurious initialisation issue on MS Visual C++
+            memset( result_p->digit, 0, sizeof(sc_digit)*result_p->ndigits );
+#else
+            result_p->digit[result_p->ndigits-1] = 0;
+#endif
+            right_non_zero = m_right_p->concat_get_data( result_p->digit, 0 );
+            left_non_zero = m_left_p->concat_get_data(result_p->digit, m_len_r); 
+            if ( left_non_zero || right_non_zero ) 
+                result_p->sgn = SC_POS;
+            else
+                result_p->sgn = SC_ZERO;
+            return *result_p;
+        }
+
+    int64 to_int64() const
+        { 
+            return (int64)to_uint64();
+        }
+    int to_int() const
+        { return (int)to_int64(); }
+    unsigned int  to_uint() const
+        { return (unsigned int)to_uint64(); }
+    long to_long() const
+        { return (long)to_int64(); }
+    unsigned long to_ulong() const
+        { return (unsigned long)to_uint64(); }
+    double to_double() const
+        { return value().to_double(); }
+
+    void to_sc_signed( sc_signed& target ) const
+        { target = value(); }
+
+    void to_sc_unsigned( sc_unsigned& target ) const
+        { target = value(); }
+
+    // implicit conversions:
+
+    operator  uint64 () const 
+        { return to_uint64(); }
+
+    operator const sc_unsigned& () const
+        { return value(); }
+
+    // unary operators:
+
+    sc_unsigned operator + () const
+        { return value(); } 
+
+    sc_signed operator - () const
+        { return -value(); } 
+
+    sc_unsigned operator ~ () const
+        { return ~value(); } 
+
+    // explicit conversion to character string
+
+    const std::string to_string( sc_numrep numrep = SC_DEC ) const
+        { return value().to_string(numrep); }
+
+    const std::string to_string( sc_numrep numrep, bool w_prefix ) const
+        { return value().to_string(numrep,w_prefix); }
+
+
+
+    // assignments
+
+    inline const sc_concatref& operator = ( int v )
+    {
+        m_right_p->concat_set((int64)v, 0);
+        m_left_p->concat_set((int64)v, m_len_r);
+        return *this;
+    }
+
+    inline const sc_concatref& operator = ( long v )
+    {
+        m_right_p->concat_set((int64)v, 0);
+        m_left_p->concat_set((int64)v, m_len_r);
+        return *this;
+    }
+
+    inline const sc_concatref& operator = ( int64 v )
+    {
+        m_right_p->concat_set(v, 0);
+        m_left_p->concat_set(v, m_len_r);
+        return *this;
+    }
+
+    inline const sc_concatref& operator = ( unsigned int v )
+    {
+        m_right_p->concat_set((uint64)v, 0);
+        m_left_p->concat_set((uint64)v, m_len_r);
+        return *this;
+    }
+
+    inline const sc_concatref& operator = ( unsigned long v )
+    {
+        m_right_p->concat_set((uint64)v, 0);
+        m_left_p->concat_set((uint64)v, m_len_r);
+        return *this;
+    }
+
+    inline const sc_concatref& operator = ( uint64 v )
+    {
+        m_right_p->concat_set(v, 0);
+        m_left_p->concat_set(v, m_len_r);
+        return *this;
+    }
+
+    const sc_concatref& operator = ( const sc_concatref& v )
+    {
+        sc_unsigned temp(v.length());
+        temp = v.value();
+        m_right_p->concat_set(temp, 0);
+        m_left_p->concat_set(temp, m_len_r);
+        return *this;
+    }
+
+    const sc_concatref& operator = ( const sc_signed& v )
+    {
+        m_right_p->concat_set(v, 0);
+        m_left_p->concat_set(v, m_len_r);
+        return *this;
+    }
+
+    const sc_concatref& operator = ( const sc_unsigned& v )
+    {
+        m_right_p->concat_set(v, 0);
+        m_left_p->concat_set(v, m_len_r);
+        return *this;
+    }
+
+    const sc_concatref& operator = ( const char* v_p )
+    {
+        sc_unsigned v(m_len);
+        v = v_p;
+        m_right_p->concat_set(v, 0);
+        m_left_p->concat_set(v, m_len_r);
+        return *this;
+    }
+
+    const sc_concatref& operator = ( const sc_bv_base& v )
+    {
+        sc_unsigned temp(v.length());
+        temp = v;
+        m_right_p->concat_set(temp, 0);
+        m_left_p->concat_set(temp, m_len_r);
+        return *this;
+    }
+
+    const sc_concatref& operator = ( const sc_lv_base& v )
+    {
+        sc_unsigned data(v.length());
+        data = v;
+        m_right_p->concat_set(data, 0);
+        m_left_p->concat_set(data, m_len_r);
+        return *this;
+    }
+
+
+    // reduce methods
+
+    bool and_reduce() const
+        { return value().and_reduce(); }
+
+    bool nand_reduce() const
+        { return value().nand_reduce(); }
+
+    bool or_reduce() const
+        { return value().or_reduce(); }
+
+    bool nor_reduce() const
+        { return value().nor_reduce(); }
+
+    bool xor_reduce() const
+        { return value().xor_reduce(); }
+
+    bool xnor_reduce() const
+        { return value().xnor_reduce(); }
+
+    // other methods
+
+    void print( ::std::ostream& os = ::std::cout ) const
+        { os << this->value(); }
+
+    void scan( ::std::istream& is ) 
+    { 
+        std::string s; 
+        is >> s; 
+        *this = s.c_str(); 
+    } 
+
+public:
+    static sc_core::sc_vpool<sc_concatref> m_pool; // Pool of temporary objects.
+
+public:
+    enum concat_flags {
+        cf_none = 0,        // Normal value. 
+        cf_xz_present = 1   // X and/or Z values present.
+    };
+
+protected:
+    sc_value_base*  m_left_p;    // Left hand operand of concatenation.
+    sc_value_base*  m_right_p;   // Right hand operand of concatenation.
+    int             m_len;       // Length of concatenation.
+    int             m_len_r;     // Length of m_rightt_p.
+    concat_flags    m_flags;     // Value is read only.
+
+private:
+    sc_concatref(const sc_concatref&);
+    sc_concatref() : m_left_p(0), m_right_p(0), m_len(0), m_len_r(0), m_flags()
+      {}
+};
+
+
+// functional notation for the reduce methods
+
+inline
+bool
+and_reduce( const sc_concatref& a )
+{
+    return a.and_reduce();
+}
+
+inline
+bool
+nand_reduce( const sc_concatref& a )
+{
+    return a.nand_reduce();
+}
+
+inline
+bool
+or_reduce( const sc_concatref& a )
+{
+    return a.or_reduce();
+}
+
+inline
+bool
+nor_reduce( const sc_concatref& a )
+{
+    return a.nor_reduce();
+}
+
+inline
+bool
+xor_reduce( const sc_concatref& a )
+{
+    return a.xor_reduce();
+}
+
+inline
+bool
+xnor_reduce( const sc_concatref& a )
+{
+    return a.xnor_reduce();
+}
+
+
+// SHIFT OPERATORS FOR sc_concatref OBJECT INSTANCES:
+//
+// Because sc_concatref has implicit casts to both uint64 and sc_unsigned
+// it is necessary to disambiguate the use of the shift operators. We do
+// this in favor of sc_unsigned so that precision is not lost. To get an
+// integer-based result use a cast to uint64 before performing the shift.
+
+inline const sc_unsigned operator << (const sc_concatref& target, uint64 shift)
+{
+    return target.value() << (int)shift;
+}
+
+inline const sc_unsigned operator << (const sc_concatref& target, int64 shift)
+{
+    return target.value() << (int)shift;
+}
+
+inline const sc_unsigned operator << ( 
+    const sc_concatref& target, unsigned long shift )
+{
+    return target.value() << (int)shift;
+}
+
+inline const sc_unsigned operator << ( 
+    const sc_concatref& target, int shift )
+{
+    return target.value() << shift;
+}
+
+inline const sc_unsigned operator << ( 
+    const sc_concatref& target, unsigned int shift )
+{
+    return target.value() << (int)shift;
+}
+
+inline const sc_unsigned operator << ( const sc_concatref& target, long shift )
+{
+    return target.value() << (int)shift;
+}
+
+inline const sc_unsigned operator >> (const sc_concatref& target, uint64 shift)
+{
+    return target.value() >> (int)shift;
+}
+
+inline const sc_unsigned operator >> (const sc_concatref& target, int64 shift)
+{
+    return target.value() >> (int)shift;
+}
+
+inline const sc_unsigned operator >> ( 
+    const sc_concatref& target, unsigned long shift )
+{
+    return target.value() >> (int)shift;
+}
+
+inline const sc_unsigned operator >> ( 
+    const sc_concatref& target, int shift )
+{
+    return target.value() >> shift;
+}
+
+inline const sc_unsigned operator >> ( 
+    const sc_concatref& target, unsigned int shift )
+{
+    return target.value() >> (int)shift;
+}
+
+inline const sc_unsigned operator >> ( const sc_concatref& target, long shift )
+{
+    return target.value() >> (int)shift;
+}
+
+
+// STREAM OPERATORS FOR sc_concatref OBJECT INSTANCES:
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_concatref& v )
+{ 
+    return os << v.value();
+}
+
+inline
+::std::istream&
+operator >> ( ::std::istream& is, sc_concatref& a )
+{
+    sc_unsigned temp(a.concat_length(0));   
+    temp.scan( is );
+    a = temp;
+    return is;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_concat_bool
+//
+//  Proxy class for read-only boolean values in concatenations.
+// ----------------------------------------------------------------------------
+
+class sc_concat_bool : public sc_value_base
+{
+  protected:
+    static sc_core::sc_vpool<sc_concat_bool> m_pool;  // Temporaries pool.
+    bool                                     m_value; // Value for this obj.
+
+  public:
+
+    // constructor:
+    
+    sc_concat_bool()
+    : sc_value_base(), m_value()
+    {}
+
+    // destructor:
+
+    virtual ~sc_concat_bool() 
+        { }
+
+    // allocation of temporary object:
+
+    static inline sc_concat_bool* allocate( bool v )
+    {
+        sc_concat_bool* result_p = m_pool.allocate();
+        result_p->m_value = v;
+        return result_p;
+    }
+
+    // concatenation:
+
+    virtual int concat_length( bool* xz_present_p ) const
+    { 
+        if ( xz_present_p ) *xz_present_p = false;
+        return 1; 
+    }
+
+    virtual bool concat_get_ctrl( sc_digit* dst_p, int low_i ) const
+    {
+        int bit = 1 << (low_i % BITS_PER_DIGIT); 
+        int word_i = low_i / BITS_PER_DIGIT;
+        dst_p[word_i] &= ~bit;
+        return false;
+    }
+
+    virtual bool concat_get_data( sc_digit* dst_p, int low_i ) const
+    {
+        int bit = 1 << (low_i % BITS_PER_DIGIT); 
+        int word_i = low_i / BITS_PER_DIGIT;
+        if ( m_value )
+            dst_p[word_i] |= bit;
+        else 
+            dst_p[word_i] &= ~bit;
+        return m_value;
+    }
+
+    virtual uint64 concat_get_uint64() const
+    {
+        return m_value ? 1 : 0;
+    }
+};
+
+
+// ----------------------------------------------------------------------------
+// ARITHMETIC AND LOGIC OPERATORS FOR sc_concatref
+// ----------------------------------------------------------------------------
+
+#define SC_CONCAT_OP_TYPE(RESULT,OP,OTHER_TYPE) \
+    inline RESULT operator OP ( const sc_concatref& a, OTHER_TYPE b ) \
+    { \
+        return a.value() OP b; \
+    } \
+    inline RESULT operator OP ( OTHER_TYPE a, const sc_concatref& b ) \
+    { \
+        return a OP b.value(); \
+    } 
+
+
+#define SC_CONCAT_OP(RESULT,OP) \
+    inline RESULT operator OP ( const sc_concatref& a, const sc_concatref& b ) \
+    { \
+        return a.value() OP b.value(); \
+    }  \
+    SC_CONCAT_OP_TYPE(const sc_signed,OP,int) \
+    SC_CONCAT_OP_TYPE(const sc_signed,OP,long) \
+    SC_CONCAT_OP_TYPE(const sc_signed,OP,int64) \
+    SC_CONCAT_OP_TYPE(RESULT,OP,unsigned int) \
+    SC_CONCAT_OP_TYPE(RESULT,OP,unsigned long) \
+    SC_CONCAT_OP_TYPE(RESULT,OP,uint64) \
+    SC_CONCAT_OP_TYPE(const sc_signed,OP,const sc_int_base&) \
+    SC_CONCAT_OP_TYPE(RESULT,OP,const sc_uint_base&) \
+    SC_CONCAT_OP_TYPE(const sc_signed,OP,const sc_signed&) \
+    SC_CONCAT_OP_TYPE(RESULT,OP,const sc_unsigned&) \
+    inline RESULT operator OP ( const sc_concatref& a, bool b ) \
+    { \
+        return a.value() OP (int)b; \
+    } \
+    inline RESULT operator OP ( bool a, const sc_concatref& b ) \
+    { \
+        return (int)a OP b.value(); \
+    } 
+
+#define SC_CONCAT_BOOL_OP(OP) \
+    inline bool operator OP ( const sc_concatref& a, const sc_concatref& b ) \
+    { \
+        return a.value() OP b.value(); \
+    }  \
+    SC_CONCAT_OP_TYPE(bool,OP,int) \
+    SC_CONCAT_OP_TYPE(bool,OP,long) \
+    SC_CONCAT_OP_TYPE(bool,OP,int64) \
+    SC_CONCAT_OP_TYPE(bool,OP,unsigned int) \
+    SC_CONCAT_OP_TYPE(bool,OP,unsigned long) \
+    SC_CONCAT_OP_TYPE(bool,OP,uint64) \
+    SC_CONCAT_OP_TYPE(bool,OP,const sc_int_base&) \
+    SC_CONCAT_OP_TYPE(bool,OP,const sc_uint_base&) \
+    SC_CONCAT_OP_TYPE(bool,OP,const sc_signed&) \
+    SC_CONCAT_OP_TYPE(bool,OP,const sc_unsigned&) \
+    inline bool operator OP ( const sc_concatref& a, bool b ) \
+    { \
+        return a.value() OP (int)b; \
+    } \
+    inline bool operator OP ( bool a, const sc_concatref& b ) \
+    { \
+        return (int)a OP b.value(); \
+    } 
+
+SC_CONCAT_OP(const sc_unsigned,+)
+SC_CONCAT_OP(const sc_signed,-)
+SC_CONCAT_OP(const sc_unsigned,*)
+SC_CONCAT_OP(const sc_unsigned,/)
+SC_CONCAT_OP(const sc_unsigned,%)
+SC_CONCAT_OP(const sc_unsigned,&)
+SC_CONCAT_OP(const sc_unsigned,|)
+SC_CONCAT_OP(const sc_unsigned,^)
+SC_CONCAT_BOOL_OP(==)
+SC_CONCAT_BOOL_OP(<=)
+SC_CONCAT_BOOL_OP(>=)
+SC_CONCAT_BOOL_OP(!=)
+SC_CONCAT_BOOL_OP(>)
+SC_CONCAT_BOOL_OP(<)
+
+#undef SC_CONCAT_OP
+#undef SC_CONCAT_OP_TYPE
+
+
+// ----------------------------------------------------------------------------
+// CONCATENATION FUNCTION AND OPERATOR FOR STANDARD SYSTEM C DATA TYPES:
+// ----------------------------------------------------------------------------
+
+inline sc_dt::sc_concatref& concat(
+    sc_dt::sc_value_base& a, sc_dt::sc_value_base& b)
+{
+    sc_dt::sc_concatref* result_p;     // Proxy for the concatenation.
+
+    result_p = sc_dt::sc_concatref::m_pool.allocate();
+    result_p->initialize( a, b );
+    return *result_p;
+}
+
+inline 
+const
+sc_dt::sc_concatref& concat(
+    const sc_dt::sc_value_base& a, const sc_dt::sc_value_base& b)
+{
+    sc_dt::sc_concatref* result_p;     // Proxy for the concatenation.
+
+    result_p = sc_dt::sc_concatref::m_pool.allocate();
+    result_p->initialize( a, b );
+    return *result_p;
+}
+
+inline 
+const
+sc_dt::sc_concatref& concat(const sc_dt::sc_value_base& a, bool b)
+{
+    const sc_dt::sc_concat_bool* b_p;        // Proxy for boolean value.
+    sc_dt::sc_concatref*         result_p;   // Proxy for the concatenation.
+
+    b_p = sc_dt::sc_concat_bool::allocate(b);
+    result_p = sc_dt::sc_concatref::m_pool.allocate();
+    result_p->initialize( a, *b_p );
+    return *result_p;
+}
+
+inline 
+const
+sc_dt::sc_concatref& concat(bool a, const sc_dt::sc_value_base& b)
+{
+    const sc_dt::sc_concat_bool* a_p;        // Proxy for boolean value.
+    sc_dt::sc_concatref*         result_p;   // Proxy for the concatenation.
+
+    a_p = sc_dt::sc_concat_bool::allocate(a);
+    result_p = sc_dt::sc_concatref::m_pool.allocate();
+    result_p->initialize( *a_p, b );
+    return *result_p;
+}
+
+inline sc_dt::sc_concatref& operator , (
+    sc_dt::sc_value_base& a, sc_dt::sc_value_base& b)
+{
+    sc_dt::sc_concatref* result_p;     // Proxy for the concatenation.
+
+    result_p = sc_dt::sc_concatref::m_pool.allocate();
+    result_p->initialize( a, b );
+    return *result_p;
+}
+
+inline 
+const
+sc_dt::sc_concatref& operator , (
+    const sc_dt::sc_value_base& a, const sc_dt::sc_value_base& b)
+{
+    sc_dt::sc_concatref* result_p;     // Proxy for the concatenation.
+
+    result_p = sc_dt::sc_concatref::m_pool.allocate();
+    result_p->initialize( a, b );
+    return *result_p;
+}
+
+inline 
+const
+sc_dt::sc_concatref& operator , (const sc_dt::sc_value_base& a, bool b)
+{
+    const sc_dt::sc_concat_bool* b_p;      // Proxy for boolean value.
+    sc_dt::sc_concatref*         result_p; // Proxy for the concatenation.
+
+    b_p = sc_dt::sc_concat_bool::allocate(b);
+    result_p = sc_dt::sc_concatref::m_pool.allocate();
+    result_p->initialize( a, *b_p );
+    return *result_p;
+}
+
+inline 
+const
+sc_dt::sc_concatref& operator , (bool a, const sc_dt::sc_value_base& b)
+{
+    const sc_dt::sc_concat_bool* a_p;      // Proxy for boolean value.
+    sc_dt::sc_concatref*         result_p; // Proxy for the concatenation.
+
+    a_p = sc_dt::sc_concat_bool::allocate(a);
+    result_p = sc_dt::sc_concatref::m_pool.allocate();
+    result_p->initialize( *a_p, b );
+    return *result_p;
+}
+
+} // namespace sc_dt
+
+#endif //  SC_CONCATREF_H
+
diff --git a/ext/systemc/src/sysc/datatypes/misc/sc_value_base.cpp b/ext/systemc/src/sysc/datatypes/misc/sc_value_base.cpp
new file mode 100644
index 000000000..5f16341a7
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/misc/sc_value_base.cpp
@@ -0,0 +1,138 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_value_base.cpp -- Base class for all SystemC data values.
+
+  Original Author: Andy Goodrich, Forte Design Systems
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_value_base.cpp,v $
+// Revision 1.2  2011/08/15 16:43:24  acg
+//  Torsten Maehne: changes to remove unused argument warnings.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:54:01  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include <cstdlib>
+#include <assert.h>
+#include <ctype.h>
+#include <cstdio>
+
+#include "sysc/datatypes/int/sc_int_ids.h"
+#include "sysc/datatypes/misc/sc_value_base.h"
+
+namespace sc_dt
+{
+
+void sc_value_base::concat_clear_data( bool /* to_ones */ )
+{
+    char error_message[128];
+    std::sprintf(error_message, 
+	"concat_clear_data method not supported by this type");
+    SC_REPORT_ERROR( sc_core::SC_ID_OPERATION_FAILED_, error_message );
+}
+
+bool sc_value_base::concat_get_ctrl( sc_digit* /*dst_p*/, int /*low_i*/ ) const
+{
+    char error_message[128];
+    std::sprintf(error_message, 
+	"concat_get_ctrl method not supported by this type");
+    SC_REPORT_ERROR( sc_core::SC_ID_OPERATION_FAILED_, error_message );
+    return false;
+}
+
+bool sc_value_base::concat_get_data( sc_digit* /*dst_p*/, int /*low_i*/ ) const
+{
+    char error_message[128];
+    std::sprintf(error_message, 
+	"concat_get_data method not supported by this type");
+    SC_REPORT_ERROR( sc_core::SC_ID_OPERATION_FAILED_, error_message );
+    return false;
+}
+
+sc_dt::uint64 sc_value_base::concat_get_uint64() const
+{
+    char error_message[128];
+    std::sprintf(error_message, 
+	"concat_get_uint64 method not supported by this type");
+    SC_REPORT_ERROR( sc_core::SC_ID_OPERATION_FAILED_, error_message );
+    return 0;
+}
+
+int sc_value_base::concat_length(bool* /*xz_present_p*/) const
+{
+    char error_message[128];
+    std::sprintf(error_message, 
+	"concat_length method not supported by this type");
+    SC_REPORT_ERROR( sc_core::SC_ID_OPERATION_FAILED_, error_message );
+    return 0;
+}
+
+void sc_value_base::concat_set( int64 /*src*/, int /*low_i*/ )
+{
+    char error_message[128];
+    std::sprintf(error_message, 
+	"concat_set(int64) method not supported by this type");
+    SC_REPORT_ERROR( sc_core::SC_ID_OPERATION_FAILED_, error_message );
+}
+
+void sc_value_base::concat_set( const sc_signed& /*src*/, int /*low_i*/ )
+{
+    char error_message[128];
+    std::sprintf(error_message, 
+	"concat_set(sc_signed) method not supported by this type");
+    SC_REPORT_ERROR( sc_core::SC_ID_OPERATION_FAILED_, error_message );
+}
+
+void sc_value_base::concat_set( const sc_unsigned& /*src*/, int /*low_i*/ )
+{
+    char error_message[128];
+    std::sprintf(error_message, 
+	"concat_set(sc_unsigned) method not supported by this type");
+    SC_REPORT_ERROR( sc_core::SC_ID_OPERATION_FAILED_, error_message );
+}
+
+void sc_value_base::concat_set( uint64 /*src*/, int /*low_i*/ )
+{
+    char error_message[128];
+    std::sprintf(error_message, 
+	"concat_set(uint64) method not supported by this type");
+    SC_REPORT_ERROR( sc_core::SC_ID_OPERATION_FAILED_, error_message );
+}
+
+} // namespace sc_dt
diff --git a/ext/systemc/src/sysc/datatypes/misc/sc_value_base.h b/ext/systemc/src/sysc/datatypes/misc/sc_value_base.h
new file mode 100644
index 000000000..1a2c73d42
--- /dev/null
+++ b/ext/systemc/src/sysc/datatypes/misc/sc_value_base.h
@@ -0,0 +1,129 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_value_base.h -- Base class for SystemC bit values.
+
+  Original Author: Andy Goodrich, Forte Design Systems
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_value_base.h,v $
+// Revision 1.4  2011/08/29 18:04:32  acg
+//  Philipp A. Hartmann: miscellaneous clean ups.
+//
+// Revision 1.3  2011/08/24 22:05:48  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.2  2011/06/28 21:23:04  acg
+//  Andy Goodrich: merging of SCV tree.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:54:01  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#ifndef SC_VALUE_BASE_H
+#define SC_VALUE_BASE_H
+
+
+#include "sysc/datatypes/int/sc_nbdefs.h"
+
+namespace sc_dt
+{
+
+class sc_signed;
+class sc_unsigned;
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_value_base
+//
+//  Abstract base class of all SystemC native variables. It provides
+//  support for concatenation operations via a set of virtual methods. 
+//  A general description of the methods appear with their default 
+//  definitions in sc_object.cpp.
+// ----------------------------------------------------------------------------
+
+class sc_value_base 
+{
+    friend class sc_concatref;
+  private: 
+    virtual void concat_clear_data( bool to_ones=false );
+    virtual bool concat_get_ctrl( sc_digit* dst_p, int low_i ) const;
+    virtual bool concat_get_data( sc_digit* dst_p, int low_i ) const;
+    virtual uint64 concat_get_uint64() const;
+    virtual int concat_length(bool* xz_present_p=0) const;
+    virtual void concat_set( int64 src, int low_i );
+    virtual void concat_set( const sc_signed& src, int low_i );
+    virtual void concat_set( const sc_unsigned& src, int low_i );
+    virtual void concat_set( uint64 src, int low_i );
+  public:
+    virtual ~sc_value_base() {}
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_generic_base
+//
+//  Proxy class for user-defined value classes and other classes that 
+//  are defined outside of SystemC. 
+//  The class is utilized as a base class for the arbitrary class:
+//
+//       class my_class : public sc_generic_base<my_class>
+//
+//  The purpose of the class is to allow to_XXXX methods defined within that 
+//  class so that assignments and casts from the arbitrary class to native 
+//  SystemC types are possible. To interact correctly with the SystemC library 
+//  the class derived from sc_generic_base must implement the following 
+//  methods: 
+//    (1) uint64 to_uint64() const
+//    (2) int64  to_int64() const
+//    (3) void to_sc_unsigned( sc_unsigned& ) const
+//    (4) void to_sc_signed( sc_signed& ) const
+// ----------------------------------------------------------------------------
+template< class T >
+class sc_generic_base {
+  public: 
+    inline const T* operator-> () const
+    {
+        return (const T*)this;
+    }
+    inline T* operator-> () 
+    {
+        return (T*)this;
+    }
+};
+
+} // namespace sc_dt
+
+#endif
diff --git a/ext/systemc/src/sysc/kernel/sc_attribute.cpp b/ext/systemc/src/sysc/kernel/sc_attribute.cpp
new file mode 100644
index 000000000..de89c6adf
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_attribute.cpp
@@ -0,0 +1,191 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_attribute.cpp -- Attribute classes.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+ CHANGE LOG APPEARS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#include "sysc/kernel/sc_attribute.h"
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_attr_base
+//
+//  Attribute base class.
+// ----------------------------------------------------------------------------
+
+// constructors
+
+sc_attr_base::sc_attr_base( const std::string& name_ )
+: m_name( name_ )
+{}
+
+sc_attr_base::sc_attr_base( const sc_attr_base& a )
+: m_name( a.m_name )
+{}
+
+
+// destructor (does nothing)
+
+sc_attr_base::~sc_attr_base()
+{}
+
+
+// get the name
+const std::string&
+sc_attr_base::name() const
+{
+    return m_name;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_attr_cltn
+//
+//  Attribute collection class. Stores pointers to attributes.
+//  Note: iterate over the collection by using iterators.
+// ----------------------------------------------------------------------------
+
+// constructors
+
+sc_attr_cltn::sc_attr_cltn() : m_cltn()
+{}
+
+sc_attr_cltn::sc_attr_cltn( const sc_attr_cltn& a )
+: m_cltn( a.m_cltn )
+{}
+
+
+// destructor
+sc_attr_cltn::~sc_attr_cltn()
+{
+    remove_all();
+}
+
+
+// add attribute to the collection.
+// returns 'true' if the name of the attribute is unique,
+// returns 'false' otherwise (attribute is not added).
+
+bool
+sc_attr_cltn::push_back( sc_attr_base* attribute_ )
+{
+    if( attribute_ == 0 ) {
+	return false;
+    }
+    for( int i = m_cltn.size() - 1; i >= 0; -- i ) {
+	if( attribute_->name() == m_cltn[i]->name() ) {
+	    return false;
+	}
+    }
+    m_cltn.push_back( attribute_ );
+    return true;
+}
+
+
+// get attribute by name.
+// returns pointer to attribute, or 0 if name does not exist.
+
+sc_attr_base*
+sc_attr_cltn::operator [] ( const std::string& name_ )
+{
+    for( int i = m_cltn.size() - 1; i >= 0; -- i ) {
+	if( name_ == m_cltn[i]->name() ) {
+	    return m_cltn[i];
+	}
+    }
+    return 0;
+}
+
+const sc_attr_base*
+sc_attr_cltn::operator [] ( const std::string& name_ ) const
+{
+    for( int i = m_cltn.size() - 1; i >= 0; -- i ) {
+	if( name_ == m_cltn[i]->name() ) {
+	    return m_cltn[i];
+	}
+    }
+    return 0;
+}
+
+
+// remove attribute by name.
+// returns pointer to attribute, or 0 if name does not exist.
+
+sc_attr_base*
+sc_attr_cltn::remove( const std::string& name_ )
+{
+    for( int i = m_cltn.size() - 1; i >= 0; -- i ) {
+	if( name_ == m_cltn[i]->name() ) {
+	    sc_attr_base* attribute = m_cltn[i];
+	    std::swap( m_cltn[i], m_cltn.back() );
+	    m_cltn.pop_back();
+	    return attribute;
+	}
+    }
+    return 0;
+}
+
+
+// remove all attributes
+
+void
+sc_attr_cltn::remove_all()
+{
+    m_cltn.clear();
+}
+
+} // namespace sc_core
+
+// $Log: sc_attribute.cpp,v $
+// Revision 1.7  2011/08/26 20:46:08  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.6  2011/08/24 22:05:50  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.5  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.4  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.3  2010/07/22 20:02:33  acg
+//  Andy Goodrich: bug fixes.
+//
+// Revision 1.2  2008/05/22 17:06:24  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.4  2006/01/16 22:27:08  acg
+// Test of $Log comment.
+//
+// Revision 1.3  2006/01/13 18:44:29  acg
+// Added $Log to record CVS changes into the source.
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_attribute.h b/ext/systemc/src/sysc/kernel/sc_attribute.h
new file mode 100644
index 000000000..0efa70de5
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_attribute.h
@@ -0,0 +1,209 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_attribute.h -- Attribute classes.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#ifndef SC_ATTRIBUTE_H
+#define SC_ATTRIBUTE_H
+
+#include <string>
+#include <vector>
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_attr_base
+//
+//  Attribute base class.
+// ----------------------------------------------------------------------------
+
+class sc_attr_base
+{
+public:
+
+    // constructors
+    sc_attr_base( const std::string& name_ );
+    sc_attr_base( const sc_attr_base& );
+
+    // destructor (does nothing)
+    virtual ~sc_attr_base();
+
+    // get the name
+    const std::string& name() const;
+
+private:
+
+    std::string m_name;
+
+private:
+
+    // disabled
+    sc_attr_base();
+    sc_attr_base& operator = ( const sc_attr_base& );
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_attr_cltn
+//
+//  Attribute collection class. Stores pointers to attributes.
+//  Note: iterate over the collection by using iterators.
+// ----------------------------------------------------------------------------
+
+class sc_attr_cltn
+{
+public:
+
+    // typedefs
+    typedef sc_attr_base*                          elem_type;
+    typedef std::vector<elem_type>::iterator       iterator;
+    typedef std::vector<elem_type>::const_iterator const_iterator;
+
+    // constructors
+    sc_attr_cltn();
+    sc_attr_cltn( const sc_attr_cltn& );
+
+    // destructor
+    ~sc_attr_cltn();
+
+    // add attribute to the collection.
+    // returns 'true' if the name of the attribute is unique,
+    // returns 'false' otherwise (attribute is not added).
+    bool push_back( sc_attr_base* );
+
+    // get attribute by name.
+    // returns pointer to attribute, or 0 if name does not exist.
+          sc_attr_base* operator [] ( const std::string& name_ );
+    const sc_attr_base* operator [] ( const std::string& name_ ) const;
+
+    // remove attribute by name.
+    // returns pointer to attribute, or 0 if name does not exist.
+    sc_attr_base* remove( const std::string& name_ );
+
+    // remove all attributes
+    void remove_all();
+
+    // get the size of the collection
+    int size() const
+        { return m_cltn.size(); }
+
+    // get the begin iterator
+    iterator begin()
+        { return m_cltn.begin(); }
+    const_iterator begin() const
+        { return m_cltn.begin(); }
+
+    // get the end iterator
+    iterator end()
+        { return m_cltn.end(); }
+    const_iterator end() const
+        { return m_cltn.end(); }
+
+private:
+    std::vector<sc_attr_base*> m_cltn;
+
+private:
+
+    // disabled
+    sc_attr_cltn& operator = ( const sc_attr_cltn& );
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_attribute<T>
+//
+//  Attribute class.
+//  Note: T must have a default constructor and copy constructor.
+// ----------------------------------------------------------------------------
+
+template <class T>
+class sc_attribute
+: public sc_attr_base
+{
+public:
+
+    // constructors
+
+    sc_attribute( const std::string& name_ )
+        : sc_attr_base( name_ ), value()
+        {}
+
+    sc_attribute( const std::string& name_, const T& value_ )
+        : sc_attr_base( name_ ), value( value_ )
+        {}
+
+    sc_attribute( const sc_attribute<T>& a )
+        : sc_attr_base( a.name() ), value( a.value )
+        {}
+
+
+    // destructor (does nothing)
+
+    virtual ~sc_attribute()
+        {}
+
+public:
+
+    // public data member; for easy access
+    T value;
+
+private:
+
+    // disabled
+    sc_attribute();
+    sc_attribute<T>& operator = ( const sc_attribute<T>& );
+};
+
+} // namespace sc_core
+
+// $Log: sc_attribute.h,v $
+// Revision 1.6  2011/08/26 20:46:08  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.5  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.4  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.3  2010/07/22 20:02:33  acg
+//  Andy Goodrich: bug fixes.
+//
+// Revision 1.2  2008/05/22 17:06:24  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:44:29  acg
+// Added $Log to record CVS changes into the source.
+//
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_boost.h b/ext/systemc/src/sysc/kernel/sc_boost.h
new file mode 100644
index 000000000..4383c21c9
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_boost.h
@@ -0,0 +1,94 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_boost.h -- Thread Semantics Provided By The Boost Library
+
+  Original Author: Stuart Swan, Cadence Design Systems, Inc
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#ifndef SC_BOOST_H
+#define SC_BOOST_H
+
+// namespace sc_dp { This is off because of bugs with gcc 2.9x
+
+// SET THE NAME OF OBJECTS THAT THE SC_BOOST LIBRARY WILL PRODUCE AND INCLUDE IT
+
+#if defined(_MSC_VER) && !defined(__ICL) && !defined(__COMO__)
+#   pragma warning(disable: 4786)  // identifier truncated in debug info
+#   pragma warning(disable: 4710)  // function not inlined  
+#   pragma warning(disable: 4711)  // funct. selected for auto-inline expansion
+#   pragma warning(disable: 4514)  // unreferenced inline removed
+#endif
+
+#include <functional>
+
+#if defined(SC_BOOST_MSVC) && (SC_BOOST_MSVC < 1300)
+#   pragma warning(push, 3)
+#endif
+
+#if defined(SC_BOOST_MSVC) && (SC_BOOST_MSVC < 1300)
+#   pragma warning(pop)
+#endif
+
+// } // namespace sc_dp This is off because of bugs with gcc 2.9x
+
+// macros to help avoid direct user code dependencies on boost lib
+//
+// note the use of the sc_boost namespace for the SystemC version of
+// boost. to replace the version shipped with SystemC with another boost
+// you will need to change the namespace prefix back to boost.
+
+#define sc_bind    std::bind
+#define sc_ref(r)  std::ref(r)
+#define sc_cref(r) std::cref(r)
+
+// $Log: sc_boost.h,v $
+// Revision 1.7  2011/08/26 20:46:09  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.6  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.5  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.4  2009/07/28 01:10:53  acg
+//  Andy Goodrich: updates for 2.3 release candidate.
+//
+// Revision 1.3  2009/02/28 00:26:58  acg
+//  Andy Goodrich: changed boost name space to sc_boost to allow use with
+//  full boost library applications.
+//
+// Revision 1.2  2008/05/22 17:06:24  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:44:29  acg
+// Added $Log to record CVS changes into the source.
+//
+
+#endif // SC_BOOST_H
diff --git a/ext/systemc/src/sysc/kernel/sc_cmnhdr.h b/ext/systemc/src/sysc/kernel/sc_cmnhdr.h
new file mode 100644
index 000000000..fcbb2f568
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_cmnhdr.h
@@ -0,0 +1,138 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_cmnhdr.h - Common header file containing handy pragmas, macros and
+                definitions common to all SystemC source files.
+
+  Original Author: Amit Rao, Synopsys, Inc.
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#ifndef SC_CMNHDR_H
+#define SC_CMNHDR_H
+
+#if defined(_WIN32) || defined(_MSC_VER) || defined(__BORLANDC__) || \
+	defined(__MINGW32__)
+
+// all windows 32-bit compilers should define WIN32
+#if !defined(WIN32) && !defined(WIN64) && !defined(_WIN64)
+#define WIN32
+#endif
+
+// Windows Version Build Option
+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT 0x0400
+#endif
+
+// remember to later include windows.h, if needed
+#define SC_HAS_WINDOWS_H_
+
+#endif // WIN32
+
+// ----------------------------------------------------------------------------
+
+#ifdef _MSC_VER
+
+// Disable VC++ warnings that are harmless
+
+// this : used in base member initializer list
+#pragma warning(disable: 4355)
+
+// new and delete warning when exception handling is turned on
+#pragma warning(disable: 4291)
+
+// in many places implicit conversion to bool
+// from other integral types is performed
+#pragma warning(disable: 4800)
+
+// unary minus operator applied to unsigned
+#pragma warning(disable: 4146)
+
+// multiple copy constructors
+#pragma warning(disable: 4521)
+
+// identifier was truncated to '255' characters in the browser information
+#pragma warning(disable: 4786)
+
+#endif 
+
+// ----------------------------------------------------------------------------
+// helper macros to aid branch prediction on GCC (compatible) compilers
+
+#ifndef __GNUC__
+#  define SC_LIKELY_( x )    !!(x)
+#  define SC_UNLIKELY_( x )  !!(x)
+#else
+#  define SC_LIKELY_( x )    __builtin_expect( !!(x), 1 )
+#  define SC_UNLIKELY_( x )  __builtin_expect( !!(x), 0 )
+#endif
+
+// ----------------------------------------------------------------------------
+
+#include <cassert>
+#include <cstdio>
+#include <cstdlib>
+
+#endif // SC_CMNHDR_H
+
+// ----------------------------------------------------------------------------
+// only include Windows.h, if explicitly requested
+// (deliberately outside of include guards to enable later effect)
+#if defined(SC_HAS_WINDOWS_H_) && defined(SC_INCLUDE_WINDOWS_H)
+#  undef SC_HAS_WINDOWS_H_
+#  include <Windows.h>
+#endif
+
+// $Log: sc_cmnhdr.h,v $
+// Revision 1.8  2011/08/26 20:46:09  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.7  2011/05/09 04:07:48  acg
+//  Philipp A. Hartmann:
+//    (1) Restore hierarchy in all phase callbacks.
+//    (2) Ensure calls to before_end_of_elaboration.
+//
+// Revision 1.6  2011/05/05 17:45:27  acg
+//  Philip A. Hartmann: changes in WIN64 support.
+//  Andy Goodrich: additional DEBUG_MSG instances to trace process handling.
+//
+// Revision 1.5  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.4  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.3  2009/05/22 16:06:29  acg
+//  Andy Goodrich: process control updates.
+//
+// Revision 1.2  2008/05/22 17:06:24  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:44:29  acg
+// Added $Log to record CVS changes into the source.
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_constants.h b/ext/systemc/src/sysc/kernel/sc_constants.h
new file mode 100644
index 000000000..1ff20adbd
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_constants.h
@@ -0,0 +1,82 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_constants.h -- Default constants whose values may need to be
+                    changed depending on the application.
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_CONSTANTS_H
+#define SC_CONSTANTS_H
+
+namespace sc_core {
+
+// Maximum number of bits for arbitrary precision arithmetic. If
+// defined, the arithmetic becomes faster. If not defined, the
+// arithmetic becomes slower and the precision becomes infinite.  It
+// is a good idea to define this constant as a multiple of
+// BITS_PER_DIGIT, which is defined in numeric_bit/sc_nbdefs.h.
+//#define SC_MAX_NBITS    510    // 17 * BITS_PER_DIGIT
+
+
+// deprecated in 1666-2005 and later, but kept for backwards compatibility
+//  - can be set by defining SC_OVERRIDE_DEFAULT_STACK_SIZE
+//  - defaults defined in sc_thread_process.cpp
+extern const int SC_DEFAULT_STACK_SIZE;
+
+
+#ifdef DEBUG_SYSTEMC
+const int SC_MAX_NUM_DELTA_CYCLES = 10000;
+#endif
+
+} // namespace sc_core
+
+// $Log: sc_constants.h,v $
+// Revision 1.7  2011/08/26 20:46:09  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.6  2011/02/18 20:33:26  acg
+//  Philipp A. Hartmann: added default stack size for CYGWIN32.
+//
+// Revision 1.5  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.4  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.3  2010/03/15 18:29:25  acg
+//  Andy Goodrich: Changed the default stack size to 128K from 64K.
+//
+// Revision 1.2  2008/05/22 17:06:24  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:44:29  acg
+// Added $Log to record CVS changes into the source.
+//
+
+#endif
diff --git a/ext/systemc/src/sysc/kernel/sc_cor.h b/ext/systemc/src/sysc/kernel/sc_cor.h
new file mode 100644
index 000000000..49892ca7a
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_cor.h
@@ -0,0 +1,157 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_cor.h -- Coroutine abstract base classes.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-12-18
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#ifndef SC_COR_H
+#define SC_COR_H
+
+
+#include <cassert>
+#include <cstdlib>
+
+namespace sc_core {
+
+class sc_simcontext;
+
+
+// ----------------------------------------------------------------------------
+//  TYPEDEF : sc_cor_fn
+//
+//  Function type for creating coroutines.
+// ----------------------------------------------------------------------------
+
+typedef void (sc_cor_fn)( void* );
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_cor
+//
+//  Coroutine abstract base class.
+// ----------------------------------------------------------------------------
+
+class sc_cor
+{
+protected:
+
+    // constructor
+    sc_cor() {}
+
+public:
+
+    // destructor
+    virtual ~sc_cor() {}
+
+    // switch stack protection on/off
+    virtual void stack_protect( bool /* enable */ ) {}
+
+private:
+
+    // disabled
+    sc_cor( const sc_cor& );
+    sc_cor& operator = ( const sc_cor& );
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_cor_pkg
+//
+//  Coroutine package abstract base class.
+// ----------------------------------------------------------------------------
+
+class sc_cor_pkg
+{
+public:
+
+    // constructor
+    sc_cor_pkg( sc_simcontext* simc )
+        : m_simc( simc ) { assert( simc != 0 ); }
+
+    // destructor
+    virtual ~sc_cor_pkg() {}
+
+    // create a new coroutine
+   virtual sc_cor* create(
+	    std::size_t stack_size, sc_cor_fn* fn, void* arg ) = 0;
+
+    // yield to the next coroutine
+    virtual void yield( sc_cor* next_cor ) = 0;
+
+    // abort the current coroutine (and resume the next coroutine)
+    virtual void abort( sc_cor* next_cor ) = 0;
+
+    // get the main coroutine
+    virtual sc_cor* get_main() = 0;
+
+    // get the simulation context
+    sc_simcontext* simcontext()
+        { return m_simc; }
+
+private:
+
+    sc_simcontext* m_simc;
+
+private:
+
+    // disabled
+    sc_cor_pkg();
+    sc_cor_pkg( const sc_cor_pkg& );
+    sc_cor_pkg& operator = ( const sc_cor_pkg& );
+};
+
+} // namespace sc_core
+
+// $Log: sc_cor.h,v $
+// Revision 1.7  2011/08/26 20:46:09  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.6  2011/08/15 16:43:24  acg
+//  Torsten Maehne: changes to remove unused argument warnings.
+//
+// Revision 1.5  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.4  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.3  2011/01/19 23:21:49  acg
+//  Andy Goodrich: changes for IEEE 1666 2011
+//
+// Revision 1.2  2008/05/22 17:06:24  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:44:29  acg
+// Added $Log to record CVS changes into the source.
+//
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_cor_fiber.cpp b/ext/systemc/src/sysc/kernel/sc_cor_fiber.cpp
new file mode 100644
index 000000000..77cec8227
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_cor_fiber.cpp
@@ -0,0 +1,224 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_cor_fiber.cpp -- Coroutine implementation with fibers.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-12-18
+
+ CHANGE LOG APPEARS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#if defined(_WIN32) || defined(WIN32) || defined(WIN64)
+
+#ifndef SC_INCLUDE_WINDOWS_H
+#  define SC_INCLUDE_WINDOWS_H // include Windows.h, if needed
+#endif
+
+#include "sysc/kernel/sc_cor_fiber.h"
+#include "sysc/kernel/sc_simcontext.h"
+#if defined(__GNUC__) && __USING_SJLJ_EXCEPTIONS__
+#   if (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 2))
+#      include <unwind.h>
+#   else
+       extern "C" void _Unwind_SjLj_Register (struct SjLj_Function_Context *);
+       extern "C" void _Unwind_SjLj_Unregister (struct SjLj_Function_Context *);
+#   endif
+#endif
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  File static variables.
+// ----------------------------------------------------------------------------
+
+// main coroutine
+
+static sc_cor_fiber main_cor;
+#if defined(__GNUC__) && __USING_SJLJ_EXCEPTIONS__
+// current coroutine
+static sc_cor_fiber* curr_cor;
+#endif
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_cor_fiber
+//
+//  Coroutine class implemented with Windows fibers.
+// ----------------------------------------------------------------------------
+
+// destructor
+
+sc_cor_fiber::~sc_cor_fiber()
+{
+    if( m_fiber != 0 ) {
+      PVOID cur_fiber = GetCurrentFiber();
+      if (m_fiber != cur_fiber)
+         DeleteFiber( m_fiber );
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_cor_pkg_fiber
+//
+//  Coroutine package class implemented with QuickThreads.
+// ----------------------------------------------------------------------------
+
+int sc_cor_pkg_fiber::instance_count = 0;
+
+
+// constructor
+
+sc_cor_pkg_fiber::sc_cor_pkg_fiber( sc_simcontext* simc )
+: sc_cor_pkg( simc )
+{
+    if( ++ instance_count == 1 ) {
+        // initialize the main coroutine
+        assert( main_cor.m_fiber == 0 );
+        main_cor.m_fiber = ConvertThreadToFiber( 0 );
+
+        if( !main_cor.m_fiber && GetLastError() == ERROR_ALREADY_FIBER ) {
+            // conversion of current thread to fiber has failed, because
+            // someone else already converted the main thread to a fiber
+            // -> store current fiber
+            main_cor.m_fiber = GetCurrentFiber();
+        }
+        assert( main_cor.m_fiber != 0 );
+
+#       if defined(__GNUC__) && __USING_SJLJ_EXCEPTIONS__
+            // initialize the current coroutine
+            assert( curr_cor == 0 );
+            curr_cor = &main_cor;
+#       endif
+    }
+}
+
+
+// destructor
+
+sc_cor_pkg_fiber::~sc_cor_pkg_fiber()
+{
+    if( -- instance_count == 0 ) {
+	// cleanup the main coroutine
+	main_cor.m_fiber = 0;
+#       if defined(__GNUC__) && __USING_SJLJ_EXCEPTIONS__
+            // cleanup the current coroutine
+            curr_cor = 0;
+#       endif
+    }
+}
+
+
+// create a new coroutine
+
+sc_cor*
+sc_cor_pkg_fiber::create( std::size_t stack_size, sc_cor_fn* fn, void* arg )
+{
+    sc_cor_fiber* cor = new sc_cor_fiber;
+    cor->m_pkg = this;
+    cor->m_stack_size = stack_size;
+    cor->m_fiber = CreateFiberEx( cor->m_stack_size / 2, cor->m_stack_size, 0,
+			        (LPFIBER_START_ROUTINE) fn, arg );
+    return cor;
+}
+
+
+// yield to the next coroutine
+
+void
+sc_cor_pkg_fiber::yield( sc_cor* next_cor )
+{
+    sc_cor_fiber* new_cor = SCAST<sc_cor_fiber*>( next_cor );
+#   if defined(__GNUC__) && __USING_SJLJ_EXCEPTIONS__
+        // Switch SJLJ exception handling function contexts
+        _Unwind_SjLj_Register(&curr_cor->m_eh);
+        _Unwind_SjLj_Unregister(&new_cor->m_eh);
+        curr_cor = new_cor;
+#   endif
+    SwitchToFiber( new_cor->m_fiber );
+}
+
+
+// abort the current coroutine (and resume the next coroutine)
+
+void
+sc_cor_pkg_fiber::abort( sc_cor* next_cor )
+{
+    sc_cor_fiber* new_cor = SCAST<sc_cor_fiber*>( next_cor );
+#   if defined(__GNUC__) && __USING_SJLJ_EXCEPTIONS__
+        // Switch SJLJ exception handling function contexts
+        _Unwind_SjLj_Register(&curr_cor->m_eh);
+        _Unwind_SjLj_Unregister(&new_cor->m_eh);
+        curr_cor = new_cor;
+#   endif
+    SwitchToFiber( new_cor->m_fiber );
+}
+
+
+// get the main coroutine
+
+sc_cor*
+sc_cor_pkg_fiber::get_main()
+{
+    return &main_cor;
+}
+
+} // namespace sc_core
+
+
+// $Log: sc_cor_fiber.cpp,v $
+// Revision 1.9  2011/09/08 16:12:45  acg
+//  Philipp A. Hartmann: make sure we don't try to make a thread a fiber if
+//  its already a fiber.
+//
+// Revision 1.8  2011/08/26 20:46:09  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.7  2011/06/25 17:08:39  acg
+//  Andy Goodrich: Jerome Cornet's changes to use libtool to build the
+//  library.
+//
+// Revision 1.6  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.5  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.4  2011/01/19 23:21:50  acg
+//  Andy Goodrich: changes for IEEE 1666 2011
+//
+// Revision 1.3  2009/05/22 16:06:29  acg
+//  Andy Goodrich: process control updates.
+//
+// Revision 1.2  2008/05/22 17:06:25  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:44:29  acg
+// Added $Log to record CVS changes into the source.
+//
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_cor_fiber.h b/ext/systemc/src/sysc/kernel/sc_cor_fiber.h
new file mode 100644
index 000000000..96163f497
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_cor_fiber.h
@@ -0,0 +1,169 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_cor_fiber.h -- Coroutine implementation with fibers.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-12-18
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#ifndef SC_COR_FIBER_H
+#define SC_COR_FIBER_H
+
+#if defined(_WIN32) || defined(WIN32) || defined(WIN64)
+
+#include "sysc/kernel/sc_cor.h"
+#include "sysc/kernel/sc_cmnhdr.h"
+
+#if defined(__GNUC__) && __USING_SJLJ_EXCEPTIONS__
+   // _Unwind_SjLj_Register() & _Unwind_SjLj_Unregister() only need first field.
+   struct SjLj_Function_Context {
+       struct SjLj_Function_Context *prev;
+   };
+#endif
+
+namespace sc_core {
+
+class sc_cor_pkg_fiber;
+typedef sc_cor_pkg_fiber sc_cor_pkg_t;
+
+#if( defined(_MSC_VER) && _MSC_VER >= 1300 )
+typedef std::size_t size_t;
+#endif
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_cor_fiber
+//
+//  Coroutine class implemented with QuickThreads.
+// ----------------------------------------------------------------------------
+
+class sc_cor_fiber
+: public sc_cor
+{
+
+public:
+
+    // constructor
+    sc_cor_fiber()
+	: m_stack_size( 0 ), m_fiber( 0 ), m_pkg( 0 )
+       {
+#         if defined(__GNUC__) && __USING_SJLJ_EXCEPTIONS__
+              m_eh.prev = 0;
+#         endif
+       }
+
+    // destructor
+    virtual ~sc_cor_fiber();
+
+public:
+
+    std::size_t       m_stack_size;     // stack size
+    void*             m_fiber;          // fiber
+
+    sc_cor_pkg_fiber* m_pkg;            // the creating coroutine package
+#if defined(__GNUC__) && __USING_SJLJ_EXCEPTIONS__
+    struct SjLj_Function_Context m_eh;  // the exception handling context
+#endif
+
+
+private:
+
+    // disabled
+    sc_cor_fiber( const sc_cor_fiber& );
+    sc_cor_fiber& operator = ( const sc_cor_fiber& );
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_cor_pkg_fiber
+//
+//  Coroutine package class implemented with QuickThreads.
+// ----------------------------------------------------------------------------
+
+class sc_cor_pkg_fiber
+: public sc_cor_pkg
+{
+  public:
+
+    // constructor
+    sc_cor_pkg_fiber( sc_simcontext* simc );
+
+    // destructor
+    virtual ~sc_cor_pkg_fiber();
+
+    // create a new coroutine
+    virtual sc_cor* create( std::size_t stack_size, sc_cor_fn* fn, void* arg );
+
+    // yield to the next coroutine
+    virtual void yield( sc_cor* next_cor );
+
+    // abort the current coroutine (and resume the next coroutine)
+    virtual void abort( sc_cor* next_cor );
+
+    // get the main coroutine
+    virtual sc_cor* get_main();
+
+private:
+
+    static int instance_count;
+
+private:
+
+    // disabled
+    sc_cor_pkg_fiber();
+    sc_cor_pkg_fiber( const sc_cor_pkg_fiber& );
+    sc_cor_pkg_fiber& operator = ( const sc_cor_pkg_fiber& );
+};
+
+} // namespace sc_core
+
+#endif // WIN32
+
+// $Log: sc_cor_fiber.h,v $
+// Revision 1.6  2011/08/26 20:46:09  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.5  2011/06/25 17:08:39  acg
+//  Andy Goodrich: Jerome Cornet's changes to use libtool to build the
+//  library.
+//
+// Revision 1.4  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.3  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.2  2008/05/22 17:06:25  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:44:29  acg
+// Added $Log to record CVS changes into the source.
+//
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_cor_pthread.cpp b/ext/systemc/src/sysc/kernel/sc_cor_pthread.cpp
new file mode 100644
index 000000000..d95eca93b
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_cor_pthread.cpp
@@ -0,0 +1,313 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_cor_pthread.cpp -- Coroutine implementation with pthreads.
+
+  Original Author: Andy Goodrich, Forte Design Systems, 2002-11-10
+
+ CHANGE LOG APPEARS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#if !defined(_WIN32) && !defined(WIN32) && defined(SC_USE_PTHREADS)
+
+// ORDER OF THE INCLUDES AND namespace sc_core IS IMPORTANT!!!
+
+#include "sysc/kernel/sc_cor_pthread.h"
+#include "sysc/kernel/sc_simcontext.h"
+
+using namespace std;
+
+namespace sc_core {
+
+// MAKE SURE WE HAVE A NULL THAT WILL WORK:
+
+#if defined(__hpux)
+#   define PTHREAD_NULL cma_c_null
+#else  // !defined(__hpux)
+#   define PTHREAD_NULL NULL
+#endif // !defined(__hpux)
+
+#define DEBUGF \
+    if (0) std::cout << "sc_cor_pthread.cpp(" << __LINE__ << ") "
+
+// ----------------------------------------------------------------------------
+//  File static variables.
+//
+// (1) The thread creation mutex and the creation condition are used to
+//     suspend the thread creating another one until the created thread
+//     reaches its invoke_module_method. This allows us to get control of
+//     thread scheduling away from the pthread package.
+// ----------------------------------------------------------------------------
+
+static sc_cor_pthread* active_cor_p=0;   // Active co-routine.
+static pthread_cond_t  create_condition; // See note 1 above.
+static pthread_mutex_t create_mutex;     // See note 1 above.
+static sc_cor_pthread  main_cor;         // Main coroutine.
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_cor_pthread
+//
+//  Coroutine class implemented with Posix Threads.
+// ----------------------------------------------------------------------------
+
+// constructor
+
+sc_cor_pthread::sc_cor_pthread()
+    : m_cor_fn_arg( 0 ), m_pkg_p( 0 )
+{
+    DEBUGF << this << ": sc_cor_pthread::sc_cor_pthread()" << std::endl;
+    pthread_cond_init( &m_pt_condition, PTHREAD_NULL );
+    pthread_mutex_init( &m_mutex, PTHREAD_NULL );
+}
+
+
+// destructor
+
+sc_cor_pthread::~sc_cor_pthread()
+{
+    DEBUGF << this << ": sc_cor_pthread::~sc_cor_pthread()" << std::endl;
+	pthread_cond_destroy( &m_pt_condition);
+	pthread_mutex_destroy( &m_mutex );
+}
+
+
+// This static method is a Posix Threads helper callback and invokes a thread
+// for the first time. It performs some synchronization and then invokes the
+// actual sc_cor helper function.
+//     context_p -> thread to invoke module method of.
+// Result is 0 and ignored.
+
+void* sc_cor_pthread::invoke_module_method(void* context_p)
+{
+    sc_cor_pthread* p = (sc_cor_pthread*)context_p;
+    DEBUGF << p << ": sc_cor_pthread::invoke_module_method()" << std::endl;
+
+
+    // SUSPEND THE THREAD SO WE CAN GAIN CONTROL FROM THE PTHREAD PACKAGE:
+    //
+    // Since pthread_create schedules each thread behind our back for its
+    // initial execution we immediately suspend a newly created thread
+    // here so we can control when its execution will occur. We also wake
+    // up the main thread which is waiting for this thread to execute to this
+    // wait point.
+
+    pthread_mutex_lock( &create_mutex );
+	DEBUGF << p << ": child signalling main thread " << endl;
+    pthread_cond_signal( &create_condition );
+    pthread_mutex_lock( &p->m_mutex );
+    pthread_mutex_unlock( &create_mutex );
+    pthread_cond_wait( &p->m_pt_condition, &p->m_mutex );
+    pthread_mutex_unlock( &p->m_mutex );
+
+
+    // CALL THE SYSTEMC CODE THAT WILL ACTUALLY START THE THREAD OFF:
+
+    active_cor_p = p;
+    DEBUGF << p << ": about to invoke real method " 
+	   << active_cor_p << std::endl;
+    (p->m_cor_fn)(p->m_cor_fn_arg);
+
+    return 0;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_cor_pkg_pthread
+//
+//  Coroutine package class implemented with Posix Threads.
+// ----------------------------------------------------------------------------
+
+int sc_cor_pkg_pthread::instance_count = 0;
+
+
+// constructor
+
+sc_cor_pkg_pthread::sc_cor_pkg_pthread( sc_simcontext* simc )
+: sc_cor_pkg( simc )
+{
+    // initialize the current coroutine
+    if( ++ instance_count == 1 )
+    {
+        pthread_cond_init( &create_condition, PTHREAD_NULL );
+        pthread_mutex_init( &create_mutex, PTHREAD_NULL );
+        assert( active_cor_p == 0 );
+        main_cor.m_pkg_p = this;
+		DEBUGF << &main_cor << ": is main co-routine" << std::endl;
+        active_cor_p = &main_cor;
+    }
+}
+
+
+// destructor
+
+sc_cor_pkg_pthread::~sc_cor_pkg_pthread()
+{
+    if( -- instance_count == 0 ) {
+        // cleanup the main coroutine
+    }
+}
+
+
+// create a new coroutine
+
+sc_cor*
+sc_cor_pkg_pthread::create( std::size_t stack_size, sc_cor_fn* fn, void* arg )
+{
+    sc_cor_pthread* cor_p = new sc_cor_pthread;
+    DEBUGF << &main_cor << ": sc_cor_pkg_pthread::create(" 
+	       << cor_p << ")" << std::endl;
+
+
+    // INITIALIZE OBJECT'S FIELDS FROM ARGUMENT LIST:
+
+    cor_p->m_pkg_p = this;
+    cor_p->m_cor_fn = fn;
+    cor_p->m_cor_fn_arg = arg;
+
+
+	// SET UP THREAD CREATION ATTRIBUTES:
+	//
+	// Use default values except for stack size. If stack size is non-zero
+	// set it.
+
+    pthread_attr_t attr;
+	pthread_attr_init( &attr ); 
+	if ( stack_size != 0 )
+	{
+		pthread_attr_setstacksize( &attr, stack_size );
+	}
+
+
+    // ALLOCATE THE POSIX THREAD TO USE AND FORCE SEQUENTIAL EXECUTION:
+    //
+    // Because pthread_create causes the created thread to be executed,
+    // we need to let it run until we can block in the invoke_module_method.
+    // So we:
+    //   (1) Lock the creation mutex before creating the new thread.
+    //   (2) Sleep on the creation condition, which will be signalled by
+    //       the newly created thread just before it goes to sleep in
+    //       invoke_module_method.
+    // This scheme results in the newly created thread being dormant before
+    // the main thread continues execution.
+
+    pthread_mutex_lock( &create_mutex );
+    DEBUGF << &main_cor << ": about to create actual thread " 
+	       << cor_p << std::endl;
+    if ( pthread_create( &cor_p->m_thread, &attr,
+             &sc_cor_pthread::invoke_module_method, (void*)cor_p ) )
+    {
+        std::fprintf(stderr, "ERROR - could not create thread\n");
+    }
+
+    DEBUGF << &main_cor << ": main thread waiting for signal from " 
+	       << cor_p << std::endl;
+    pthread_cond_wait( &create_condition, &create_mutex );
+	DEBUGF << &main_cor << ": main thread signaled by " 
+	       << cor_p << endl;
+	pthread_attr_destroy( &attr ); 
+    pthread_mutex_unlock( &create_mutex );
+    DEBUGF << &main_cor << ": exiting sc_cor_pkg_pthread::create(" 
+	       << cor_p << ")" << std::endl;
+
+    return cor_p;
+}
+
+
+// yield to the next coroutine
+//
+// We don't do anything after the p_thread_cond_wait since it won't
+// happen until the thread wakes up again!
+
+void
+sc_cor_pkg_pthread::yield( sc_cor* next_cor_p )
+{
+    sc_cor_pthread* from_p = active_cor_p;
+    sc_cor_pthread* to_p = (sc_cor_pthread*)next_cor_p;
+
+    DEBUGF << from_p << ": switch to " << to_p << std::endl;
+    if ( to_p != from_p )
+    {
+        pthread_mutex_lock( &to_p->m_mutex );
+        pthread_cond_signal( &to_p->m_pt_condition );
+        pthread_mutex_lock( &from_p->m_mutex );
+        pthread_mutex_unlock( &to_p->m_mutex );
+        pthread_cond_wait( &from_p->m_pt_condition, &from_p->m_mutex );
+        pthread_mutex_unlock( &from_p->m_mutex );
+    }
+
+    active_cor_p = from_p; // When we come out of wait make ourselves active.
+	DEBUGF << from_p << " restarting after yield to " << to_p << std::endl;
+}
+
+
+// abort the current coroutine (and resume the next coroutine)
+
+void
+sc_cor_pkg_pthread::abort( sc_cor* next_cor_p )
+{
+    sc_cor_pthread* n_p = (sc_cor_pthread*)next_cor_p;
+
+    DEBUGF << active_cor_p << ": aborting, switching to " << n_p << std::endl;
+    pthread_mutex_lock( &n_p->m_mutex );
+    pthread_cond_signal( &n_p->m_pt_condition );
+    pthread_mutex_unlock( &n_p->m_mutex );
+}
+
+
+// get the main coroutine
+
+sc_cor*
+sc_cor_pkg_pthread::get_main()
+{
+    return &main_cor;
+}
+
+} // namespace sc_core
+
+#endif // !defined(_WIN32) && !defined(WIN32) && defined(SC_USE_PTHREADS)
+
+
+// $Log: sc_cor_pthread.cpp,v $
+// Revision 1.6  2011/08/30 21:51:04  acg
+//  Jerome Cornet: auto processing of pthread configurations.
+//
+// Revision 1.5  2011/08/26 20:46:09  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.4  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.3  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.2  2008/05/22 17:06:25  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:44:29  acg
+// Added $Log to record CVS changes into the source.
+//
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_cor_pthread.h b/ext/systemc/src/sysc/kernel/sc_cor_pthread.h
new file mode 100644
index 000000000..f4d835de3
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_cor_pthread.h
@@ -0,0 +1,157 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_cor_pthread.h -- Coroutine implementation with pthreads.
+
+  Original Author: Andy Goodrich, Forte Design Systems, 2002-11-10
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#ifndef SC_COR_PTHREAD_H
+#define SC_COR_PTHREAD_H
+
+
+#if defined(SC_USE_PTHREADS)
+
+#include "sysc/kernel/sc_cor.h"
+#include "sysc/kernel/sc_cmnhdr.h"
+#include <pthread.h>
+
+namespace sc_core {
+
+class sc_cor_pkg_pthread;
+typedef sc_cor_pkg_pthread sc_cor_pkg_t;
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_cor_pthread
+//
+//  Coroutine class implemented with Posix Threads.
+//
+// Notes:
+//   (1) The thread creation mutex and the creation condition are used to
+//       suspend the thread creating another one until the created thread
+//       reaches its invoke_module_method. This allows us to get control of
+//       thread scheduling away from the pthread package.
+// ----------------------------------------------------------------------------
+
+class sc_cor_pthread : public sc_cor
+{
+  public:
+
+    // constructor
+    sc_cor_pthread();
+
+    // destructor
+    virtual ~sc_cor_pthread();
+
+	// module method invocator (starts thread execution)
+	static void* invoke_module_method( void* context_p );
+
+  public:
+	static sc_cor_pthread* m_active_cor_p;	   // Active coroutine.
+
+  public:
+	sc_cor_fn*          m_cor_fn;		// Core function.
+	void*               m_cor_fn_arg;	// Core function argument.
+	pthread_mutex_t     m_mutex;        // Mutex to suspend thread on.
+    sc_cor_pkg_pthread* m_pkg_p;        // the creating coroutine package
+	pthread_cond_t      m_pt_condition; // Condition waiting for.
+	pthread_t           m_thread;       // Our pthread storage.
+
+private:
+
+    // disabled
+    sc_cor_pthread( const sc_cor_pthread& );
+    sc_cor_pthread& operator = ( const sc_cor_pthread& );
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_cor_pkg_pthread
+//
+//  Coroutine package class implemented with Posix Threads.
+// ----------------------------------------------------------------------------
+
+class sc_cor_pkg_pthread
+: public sc_cor_pkg
+{
+public:
+
+    // constructor
+    sc_cor_pkg_pthread( sc_simcontext* simc );
+
+    // destructor
+    virtual ~sc_cor_pkg_pthread();
+
+    // create a new coroutine
+    virtual sc_cor* create( std::size_t stack_size, sc_cor_fn* fn, void* arg );
+
+    // yield to the next coroutine
+    virtual void yield( sc_cor* next_cor );
+
+    // abort the current coroutine (and resume the next coroutine)
+    virtual void abort( sc_cor* next_cor );
+
+    // get the main coroutine
+    virtual sc_cor* get_main();
+
+private:
+
+    static int instance_count;
+
+private:
+
+    // disabled
+    sc_cor_pkg_pthread();
+    sc_cor_pkg_pthread( const sc_cor_pkg_pthread& );
+    sc_cor_pkg_pthread& operator = ( const sc_cor_pkg_pthread& );
+};
+
+} // namespace sc_core
+
+#endif
+
+// $Log: sc_cor_pthread.h,v $
+// Revision 1.5  2011/08/26 20:46:09  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.4  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.3  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.2  2008/05/22 17:06:25  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:44:29  acg
+// Added $Log to record CVS changes into the source.
+//
+
+#endif // defined(SC_USE_PTHREADS)
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_cor_qt.cpp b/ext/systemc/src/sysc/kernel/sc_cor_qt.cpp
new file mode 100644
index 000000000..d42298a62
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_cor_qt.cpp
@@ -0,0 +1,271 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_cor_qt.cpp -- Coroutine implementation with QuickThreads.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-12-18
+
+ CHANGE LOG APPEARS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#if !defined(_WIN32) && !defined(WIN32) && !defined(SC_USE_PTHREADS)
+
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+
+#include "sysc/kernel/sc_cor_qt.h"
+#include "sysc/kernel/sc_simcontext.h"
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  File static variables.
+// ----------------------------------------------------------------------------
+
+// main coroutine
+
+static sc_cor_qt main_cor;
+
+// current coroutine
+
+static sc_cor_qt* curr_cor = 0;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_cor_qt
+//
+//  Coroutine class implemented with QuickThreads.
+// ----------------------------------------------------------------------------
+
+// switch stack protection on/off
+
+void
+sc_cor_qt::stack_protect( bool enable )
+{
+    // Code needs to be tested on HP-UX and disabled if it doesn't work there
+    // Code still needs to be ported to WIN32
+
+    static std::size_t pagesize;
+    
+    if( pagesize == 0 ) {
+#       if defined(__ppc__)
+	    pagesize = getpagesize();
+#       else
+	    pagesize = sysconf( _SC_PAGESIZE );
+#       endif 
+    }
+
+    assert( pagesize != 0 );
+    assert( m_stack_size > ( 2 * pagesize ) );
+
+#ifdef QUICKTHREADS_GROW_DOWN
+    // Stacks grow from high address down to low address
+    caddr_t redzone = caddr_t( ( ( std::size_t( m_stack ) + pagesize - 1 ) /
+				 pagesize ) * pagesize );
+#else
+    // Stacks grow from low address up to high address
+    caddr_t redzone = caddr_t( ( ( std::size_t( m_stack ) +
+				   m_stack_size - pagesize ) /
+				 pagesize ) * pagesize );
+#endif
+
+    int ret;
+
+    // Enable the red zone at the end of the stack so that references within
+    // it will cause an interrupt.
+
+    if( enable ) {
+        ret = mprotect( redzone, pagesize - 1, PROT_NONE );
+    } 
+    
+    // Revert the red zone to normal memory usage. Try to make it read - write -
+    // execute. If that does not work then settle for read - write
+
+    else {
+        ret = mprotect( redzone, pagesize - 1, PROT_READ|PROT_WRITE|PROT_EXEC);
+        if ( ret != 0 )
+            ret = mprotect( redzone, pagesize - 1, PROT_READ | PROT_WRITE );
+    }
+
+    assert( ret == 0 );
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_cor_pkg_qt
+//
+//  Coroutine package class implemented with QuickThreads.
+// ----------------------------------------------------------------------------
+
+int sc_cor_pkg_qt::instance_count = 0;
+
+
+// support function
+
+inline
+void*
+stack_align( void* sp, int alignment, std::size_t* stack_size )
+{
+    int round_up_mask = alignment - 1;
+    *stack_size = (*stack_size + round_up_mask) & ~round_up_mask;
+    return ( (void*)(((qt_word_t) sp + round_up_mask) & ~round_up_mask) );
+}
+
+
+// constructor
+
+sc_cor_pkg_qt::sc_cor_pkg_qt( sc_simcontext* simc )
+: sc_cor_pkg( simc )
+{
+    if( ++ instance_count == 1 ) {
+	// initialize the current coroutine
+	assert( curr_cor == 0 );
+	curr_cor = &main_cor;
+    }
+}
+
+
+// destructor
+
+sc_cor_pkg_qt::~sc_cor_pkg_qt()
+{
+    if( -- instance_count == 0 ) {
+	// cleanup the current coroutine
+	curr_cor = 0;
+    }
+}
+
+
+// create a new coroutine
+
+extern "C"
+void
+sc_cor_qt_wrapper( void* arg, void* cor, qt_userf_t* fn )
+{
+    curr_cor = RCAST<sc_cor_qt*>( cor );
+    // invoke the user function
+    (*(sc_cor_fn*) fn)( arg );
+    // not reached
+}
+
+sc_cor*
+sc_cor_pkg_qt::create( std::size_t stack_size, sc_cor_fn* fn, void* arg )
+{
+    sc_cor_qt* cor = new sc_cor_qt();
+    cor->m_pkg = this;
+    cor->m_stack_size = stack_size;
+    cor->m_stack = new char[cor->m_stack_size];
+    void* sto = stack_align( cor->m_stack, QUICKTHREADS_STKALIGN, 
+                             &cor->m_stack_size );
+    cor->m_sp = QUICKTHREADS_SP(sto, cor->m_stack_size - QUICKTHREADS_STKALIGN);
+    cor->m_sp = QUICKTHREADS_ARGS( cor->m_sp, arg, cor, (qt_userf_t*) fn,
+			           sc_cor_qt_wrapper );
+    return cor;
+}
+
+
+// yield to the next coroutine
+
+extern "C"
+void*
+sc_cor_qt_yieldhelp( qt_t* sp, void* old_cor, void* )
+{
+    RCAST<sc_cor_qt*>( old_cor )->m_sp = sp;
+    return 0;
+}
+
+void
+sc_cor_pkg_qt::yield( sc_cor* next_cor )
+{
+    sc_cor_qt* new_cor = SCAST<sc_cor_qt*>( next_cor );
+    sc_cor_qt* old_cor = curr_cor;
+    curr_cor = new_cor;
+    QUICKTHREADS_BLOCK( sc_cor_qt_yieldhelp, old_cor, 0, new_cor->m_sp );
+}
+
+
+// abort the current coroutine (and resume the next coroutine)
+
+extern "C"
+void*
+sc_cor_qt_aborthelp( qt_t*, void*, void* )
+{
+    return 0;
+}
+
+void
+sc_cor_pkg_qt::abort( sc_cor* next_cor )
+{
+    sc_cor_qt* new_cor = SCAST<sc_cor_qt*>( next_cor );
+    sc_cor_qt* old_cor = curr_cor;
+    curr_cor = new_cor;
+    QUICKTHREADS_ABORT( sc_cor_qt_aborthelp, old_cor, 0, new_cor->m_sp );
+}
+
+
+// get the main coroutine
+
+sc_cor*
+sc_cor_pkg_qt::get_main()
+{
+    return &main_cor;
+}
+
+} // namespace sc_core
+
+#endif
+
+// $Log: sc_cor_qt.cpp,v $
+// Revision 1.9  2011/08/29 18:04:32  acg
+//  Philipp A. Hartmann: miscellaneous clean ups.
+//
+// Revision 1.8  2011/08/26 20:46:09  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.7  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.6  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.5  2010/08/03 16:52:14  acg
+//  Andy Goodrich: line formatting.
+//
+// Revision 1.4  2008/11/11 14:03:07  acg
+//  Andy Goodrich: added execute access to the release of red zone storage
+//  per Ulli's suggestion.
+//
+// Revision 1.3  2008/05/22 17:06:25  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.2  2008/03/24 18:32:36  acg
+//  Andy Goodrich: added include of sys/types.h to pick up the declaration
+//  of caddr_t.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:44:29  acg
+// Added $Log to record CVS changes into the source.
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_cor_qt.h b/ext/systemc/src/sysc/kernel/sc_cor_qt.h
new file mode 100644
index 000000000..644d39c3f
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_cor_qt.h
@@ -0,0 +1,154 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_cor_qt.h -- Coroutine implementation with QuickThreads.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-12-18
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#ifndef SC_COR_QT_H
+#define SC_COR_QT_H
+
+
+#if !defined(_WIN32) && !defined(WIN32) && !defined(WIN64)  && !defined(SC_USE_PTHREADS)
+
+#include "sysc/kernel/sc_cor.h"
+#include "sysc/qt/qt.h"
+
+namespace sc_core {
+
+class sc_cor_pkg_qt;
+typedef sc_cor_pkg_qt sc_cor_pkg_t;
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_cor_qt
+//
+//  Coroutine class implemented with QuickThreads.
+// ----------------------------------------------------------------------------
+
+class sc_cor_qt
+: public sc_cor
+{
+public:
+
+    // constructor
+    sc_cor_qt()
+	: m_stack_size( 0 ), m_stack( 0 ), m_sp( 0 ), m_pkg( 0 )
+	{}
+
+    // destructor
+    virtual ~sc_cor_qt()
+        { delete[] (char*) m_stack; }
+
+    // switch stack protection on/off
+    virtual void stack_protect( bool enable );
+
+public:
+
+    std::size_t    m_stack_size;  // stack size
+    void*          m_stack;       // stack
+    qt_t*          m_sp;          // stack pointer
+
+    sc_cor_pkg_qt* m_pkg;         // the creating coroutine package
+
+private:
+
+    // disabled
+    sc_cor_qt( const sc_cor_qt& );
+    sc_cor_qt& operator = ( const sc_cor_qt& );
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_cor_pkg_qt
+//
+//  Coroutine package class implemented with QuickThreads.
+// ----------------------------------------------------------------------------
+
+class sc_cor_pkg_qt
+: public sc_cor_pkg
+{
+public:
+
+    // constructor
+    sc_cor_pkg_qt( sc_simcontext* simc );
+
+    // destructor
+    virtual ~sc_cor_pkg_qt();
+
+    // create a new coroutine
+    virtual sc_cor* create( std::size_t stack_size, sc_cor_fn* fn, void* arg );
+
+    // yield to the next coroutine
+    virtual void yield( sc_cor* next_cor );
+
+    // abort the current coroutine (and resume the next coroutine)
+    virtual void abort( sc_cor* next_cor );
+
+    // get the main coroutine
+    virtual sc_cor* get_main();
+
+private:
+
+    static int instance_count;
+
+private:
+
+    // disabled
+    sc_cor_pkg_qt();
+    sc_cor_pkg_qt( const sc_cor_pkg_qt& );
+    sc_cor_pkg_qt& operator = ( const sc_cor_pkg_qt& );
+};
+
+} // namespace sc_core
+
+#endif
+
+// $Log: sc_cor_qt.h,v $
+// Revision 1.6  2011/08/29 18:04:32  acg
+//  Philipp A. Hartmann: miscellaneous clean ups.
+//
+// Revision 1.5  2011/08/26 20:46:09  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.4  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.3  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.2  2008/05/22 17:06:25  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:44:29  acg
+// Added $Log to record CVS changes into the source.
+//
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_cthread_process.cpp b/ext/systemc/src/sysc/kernel/sc_cthread_process.cpp
new file mode 100644
index 000000000..fef5cc8d8
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_cthread_process.cpp
@@ -0,0 +1,123 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_cthread_process.cpp -- Clocked thread implementation.
+
+  Original Author: Andy Goodrich, Forte Design Systems, 4 August 2005
+               
+
+ CHANGE LOG APPEARS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#include "sysc/kernel/sc_cthread_process.h"
+#include "sysc/kernel/sc_simcontext_int.h"
+
+namespace sc_core {
+
+//------------------------------------------------------------------------------
+//"sc_cthread_process::dont_initialize"
+//
+// This virtual method sets the initialization switch for this object instance.
+//------------------------------------------------------------------------------
+void sc_cthread_process::dont_initialize( bool /* dont */ )
+{
+    SC_REPORT_WARNING( SC_ID_DONT_INITIALIZE_, 0 );
+}
+
+//------------------------------------------------------------------------------
+//"sc_cthread_process::sc_cthread_process"
+//
+// This is the object instance constructor for this class.
+//------------------------------------------------------------------------------
+sc_cthread_process::sc_cthread_process( const char* name_p, 
+    bool free_host, SC_ENTRY_FUNC method_p, 
+    sc_process_host* host_p, const sc_spawn_options* opt_p 
+):
+    sc_thread_process(name_p, free_host, method_p, host_p, opt_p)
+{
+    m_dont_init = true;
+    m_process_kind = SC_CTHREAD_PROC_;
+}
+
+//------------------------------------------------------------------------------
+//"sc_cthread_process::~sc_cthread_process"
+//
+// This is the object instance constructor for this class.
+//------------------------------------------------------------------------------
+sc_cthread_process::~sc_cthread_process()
+{
+}
+
+} // namespace sc_core 
+
+// $Log: sc_cthread_process.cpp,v $
+// Revision 1.11  2011/08/26 20:46:09  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.10  2011/08/15 16:43:24  acg
+//  Torsten Maehne: changes to remove unused argument warnings.
+//
+// Revision 1.9  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.8  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.7  2011/02/11 13:25:24  acg
+//  Andy Goodrich: Philipp A. Hartmann's changes:
+//    (1) Removal of SC_CTHREAD method overloads.
+//    (2) New exception processing code.
+//
+// Revision 1.6  2011/02/01 21:00:35  acg
+//  Andy Goodrich: removed throw_reset as it is now handled by parent
+//  sc_thread_process::throw_reset().
+//
+// Revision 1.5  2011/01/18 20:10:44  acg
+//  Andy Goodrich: changes for IEEE1666_2011 semantics.
+//
+// Revision 1.4  2009/07/28 01:10:53  acg
+//  Andy Goodrich: updates for 2.3 release candidate.
+//
+// Revision 1.3  2009/05/22 16:06:29  acg
+//  Andy Goodrich: process control updates.
+//
+// Revision 1.2  2008/05/22 17:06:25  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.6  2006/04/20 17:08:16  acg
+//  Andy Goodrich: 3.0 style process changes.
+//
+// Revision 1.5  2006/04/11 23:13:20  acg
+//   Andy Goodrich: Changes for reduced reset support that only includes
+//   sc_cthread, but has preliminary hooks for expanding to method and thread
+//   processes also.
+//
+// Revision 1.4  2006/01/24 20:49:04  acg
+// Andy Goodrich: changes to remove the use of deprecated features within the
+// simulator, and to issue warning messages when deprecated features are used.
+//
+// Revision 1.3  2006/01/13 18:44:29  acg
+// Added $Log to record CVS changes into the source.
+//
diff --git a/ext/systemc/src/sysc/kernel/sc_cthread_process.h b/ext/systemc/src/sysc/kernel/sc_cthread_process.h
new file mode 100644
index 000000000..6d35ece0d
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_cthread_process.h
@@ -0,0 +1,144 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_cthread_process.h -- Clocked thread declarations
+
+  Original Author: Andy Goodrich, Forte Design Systems, 4 August 2005
+               
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#if !defined(sc_cthread_process_h_INCLUDED)
+#define sc_cthread_process_h_INCLUDED
+
+#include "sysc/kernel/sc_thread_process.h"
+
+namespace sc_core {
+
+// friend function declarations:
+
+void halt( sc_simcontext* );
+void wait( int, sc_simcontext* );
+
+
+//==============================================================================
+// sc_cthread_process -
+//
+//==============================================================================
+class sc_cthread_process : public sc_thread_process {
+
+    friend class sc_module;
+    friend class sc_process_handle;
+    friend class sc_process_table;
+    friend class sc_thread_process;
+    friend class sc_simcontext;
+
+    friend void sc_cthread_cor_fn( void* );
+
+    friend void halt( sc_simcontext* );
+    friend void wait( int, sc_simcontext* );
+
+  public:
+    sc_cthread_process( const char* name_p, bool free_host,
+        SC_ENTRY_FUNC method_p, sc_process_host* host_p, 
+        const sc_spawn_options* opt_p );
+
+    virtual void dont_initialize( bool dont );
+    virtual const char* kind() const
+        { return "sc_cthread_process"; }
+
+private:
+
+    sc_cthread_process( const char*   nm,
+            SC_ENTRY_FUNC fn,
+            sc_process_host*    host );
+
+    // may not be deleted manually (called from sc_process_b)
+    virtual ~sc_cthread_process();
+
+    bool eval_watchlist();
+    bool eval_watchlist_curr_level();
+
+    void wait_halt();
+
+};
+
+//------------------------------------------------------------------------------
+//"sc_cthread_process::wait_halt"
+//
+//------------------------------------------------------------------------------
+inline void sc_cthread_process::wait_halt()
+{
+    m_wait_cycle_n = 0;
+    suspend_me();
+    throw sc_halt();
+}
+
+} // namespace sc_core 
+
+// $Log: sc_cthread_process.h,v $
+// Revision 1.8  2011/08/26 20:46:09  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.7  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.6  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.5  2011/02/11 13:25:24  acg
+//  Andy Goodrich: Philipp A. Hartmann's changes:
+//    (1) Removal of SC_CTHREAD method overloads.
+//    (2) New exception processing code.
+//
+// Revision 1.4  2011/02/01 21:01:41  acg
+//  Andy Goodrich: removed throw_reset() as it is now handled by the parent
+//  method sc_thread_process::throw_reset().
+//
+// Revision 1.3  2011/01/18 20:10:44  acg
+//  Andy Goodrich: changes for IEEE1666_2011 semantics.
+//
+// Revision 1.2  2008/05/22 17:06:25  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.6  2006/05/08 17:57:13  acg
+//  Andy Goodrich: Added David Long's forward declarations for friend functions
+//  to keep the Microsoft C++ compiler happy.
+//
+// Revision 1.5  2006/04/20 17:08:16  acg
+//  Andy Goodrich: 3.0 style process changes.
+//
+// Revision 1.4  2006/04/11 23:13:20  acg
+//   Andy Goodrich: Changes for reduced reset support that only includes
+//   sc_cthread, but has preliminary hooks for expanding to method and thread
+//   processes also.
+//
+// Revision 1.3  2006/01/13 18:44:29  acg
+// Added $Log to record CVS changes into the source.
+//
+
+#endif // !defined(sc_cthread_process_h_INCLUDED)
diff --git a/ext/systemc/src/sysc/kernel/sc_dynamic_processes.h b/ext/systemc/src/sysc/kernel/sc_dynamic_processes.h
new file mode 100644
index 000000000..628c3300a
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_dynamic_processes.h
@@ -0,0 +1,67 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_dynamic_process.h -- Dynamic Process Package Definitions
+
+  Original Author: Andy Goodrich, Forte Design Systems, 5 May 2003
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#ifndef SC_DYNAMIC_PROCESSES_H
+#define SC_DYNAMIC_PROCESSES_H
+
+#include "sysc/kernel/sc_except.h"
+#include "sysc/kernel/sc_spawn.h"
+#include "sysc/kernel/sc_join.h"
+#include "sysc/kernel/sc_boost.h"
+
+// $Log: sc_dynamic_processes.h,v $
+// Revision 1.5  2011/08/26 20:46:09  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.4  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.3  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.2  2008/05/22 17:06:25  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.5  2006/04/20 17:08:16  acg
+//  Andy Goodrich: 3.0 style process changes.
+//
+// Revision 1.4  2006/04/11 23:13:20  acg
+//   Andy Goodrich: Changes for reduced reset support that only includes
+//   sc_cthread, but has preliminary hooks for expanding to method and thread
+//   processes also.
+//
+// Revision 1.3  2006/01/13 18:44:29  acg
+// Added $Log to record CVS changes into the source.
+//
+
+#endif // SC_DYNAMIC_PROCESSES_H
diff --git a/ext/systemc/src/sysc/kernel/sc_event.cpp b/ext/systemc/src/sysc/kernel/sc_event.cpp
new file mode 100644
index 000000000..488210ee9
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_event.cpp
@@ -0,0 +1,759 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_event.cpp --
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+ CHANGE LOG APPEARS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "sysc/kernel/sc_event.h"
+#include "sysc/kernel/sc_kernel_ids.h"
+#include "sysc/kernel/sc_phase_callback_registry.h"
+#include "sysc/kernel/sc_process.h"
+#include "sysc/kernel/sc_process_handle.h"
+#include "sysc/kernel/sc_simcontext_int.h"
+#include "sysc/kernel/sc_object_manager.h"
+#include "sysc/utils/sc_utils_ids.h"
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_event
+//
+//  The event class.
+// ----------------------------------------------------------------------------
+
+const char*
+sc_event::basename() const
+{
+    const char* p = strrchr( m_name.c_str(), SC_HIERARCHY_CHAR );
+    return p ? (p + 1) : m_name.c_str();
+}
+
+void
+sc_event::cancel()
+{
+    // cancel a delta or timed notification
+    switch( m_notify_type ) {
+    case DELTA: {
+        // remove this event from the delta events set
+        m_simc->remove_delta_event( this );
+        m_notify_type = NONE;
+        break;
+    }
+    case TIMED: {
+        // remove this event from the timed events set
+        sc_assert( m_timed != 0 );
+        m_timed->m_event = 0;
+        m_timed = 0;
+        m_notify_type = NONE;
+        break;
+    }
+    default:
+        ;
+    }
+}
+
+
+void
+sc_event::notify()
+{
+    // immediate notification
+    if(
+        // coming from sc_prim_channel::update
+        m_simc->update_phase()
+#if SC_HAS_PHASE_CALLBACKS_
+        // coming from phase callbacks
+        || m_simc->notify_phase()
+#endif
+      )
+    {
+        SC_REPORT_ERROR( SC_ID_IMMEDIATE_NOTIFICATION_, "" );
+        return;
+    }
+    cancel();
+    trigger();
+}
+
+void
+sc_event::notify( const sc_time& t )
+{
+    if( m_notify_type == DELTA ) {
+        return;
+    }
+    if( t == SC_ZERO_TIME ) {
+#       if SC_HAS_PHASE_CALLBACKS_
+            if( SC_UNLIKELY_( m_simc->get_status()
+                              & (SC_END_OF_UPDATE|SC_BEFORE_TIMESTEP) ) )
+            {
+                std::stringstream msg;
+                msg << m_simc->get_status()
+                    << ":\n\t delta notification of `"
+                    << name() << "' ignored";
+                SC_REPORT_WARNING( SC_ID_PHASE_CALLBACK_FORBIDDEN_
+                                 , msg.str().c_str() );
+                return;
+            }
+#       endif
+        if( m_notify_type == TIMED ) {
+            // remove this event from the timed events set
+            sc_assert( m_timed != 0 );
+            m_timed->m_event = 0;
+            m_timed = 0;
+        }
+        // add this event to the delta events set
+        m_delta_event_index = m_simc->add_delta_event( this );
+        m_notify_type = DELTA;
+        return;
+    }
+#   if SC_HAS_PHASE_CALLBACKS_
+        if( SC_UNLIKELY_( m_simc->get_status()
+                        & (SC_END_OF_UPDATE|SC_BEFORE_TIMESTEP) ) )
+        {
+            std::stringstream msg;
+            msg << m_simc->get_status()
+                << ":\n\t timed notification of `"
+                << name() << "' ignored";
+            SC_REPORT_WARNING( SC_ID_PHASE_CALLBACK_FORBIDDEN_
+                             , msg.str().c_str() );
+            return;
+        }
+#   endif
+    if( m_notify_type == TIMED ) {
+        sc_assert( m_timed != 0 );
+        if( m_timed->m_notify_time <= m_simc->time_stamp() + t ) {
+            return;
+        }
+        // remove this event from the timed events set
+        m_timed->m_event = 0;
+        m_timed = 0;
+    }
+    // add this event to the timed events set
+    sc_event_timed* et = new sc_event_timed( this, m_simc->time_stamp() + t );
+    m_simc->add_timed_event( et );
+    m_timed = et;
+    m_notify_type = TIMED;
+}
+
+static void sc_warn_notify_delayed()
+{
+    static bool warn_notify_delayed=true;
+    if ( warn_notify_delayed )
+    {
+        warn_notify_delayed = false;
+        SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
+      "notify_delayed(...) is deprecated, use notify(sc_time) instead" );
+    }
+}
+
+void
+sc_event::notify_delayed()
+{
+    sc_warn_notify_delayed();
+    if( m_notify_type != NONE ) {
+        SC_REPORT_ERROR( SC_ID_NOTIFY_DELAYED_, 0 );
+    }
+    // add this event to the delta events set
+    m_delta_event_index = m_simc->add_delta_event( this );
+    m_notify_type = DELTA;
+}
+
+void
+sc_event::notify_delayed( const sc_time& t )
+{
+    sc_warn_notify_delayed();
+    if( m_notify_type != NONE ) {
+        SC_REPORT_ERROR( SC_ID_NOTIFY_DELAYED_, 0 );
+    }
+    if( t == SC_ZERO_TIME ) {
+        // add this event to the delta events set
+        m_delta_event_index = m_simc->add_delta_event( this );
+        m_notify_type = DELTA;
+    } else {
+        // add this event to the timed events set
+        sc_event_timed* et = new sc_event_timed( this,
+                                                 m_simc->time_stamp() + t );
+        m_simc->add_timed_event( et );
+        m_timed = et;
+        m_notify_type = TIMED;
+    }
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_event::register_event"
+// | 
+// | This method sets the name of this object instance and optionally adds 
+// | it to the object manager's hierarchy. The object instance will be
+// | inserted into the object manager's hierarchy if one of the following is
+// | true:
+// |   (a) the leaf name is non-null and does not start with  
+// |       SC_KERNEL_EVENT_PREFIX.
+// |   (b) the event is being created before the start of simulation.
+// |
+// | Arguments:
+// |     leaf_name = leaf name of the object or NULL.
+// +----------------------------------------------------------------------------
+void sc_event::register_event( const char* leaf_name )
+{
+    sc_object_manager* object_manager = m_simc->get_object_manager();
+    m_parent_p = m_simc->active_object();
+
+    // No name provided, if we are not executing then create a name:
+
+    if( !leaf_name || !leaf_name[0] )
+    {
+	if ( sc_is_running( m_simc ) ) return;
+        leaf_name = sc_gen_unique_name("event");    
+    }
+
+    // Create a hierarchichal name and place it into the object manager if
+    // its not a kernel event:
+
+    object_manager->create_name( leaf_name ).swap( m_name );
+
+    if ( strncmp( leaf_name, SC_KERNEL_EVENT_PREFIX, 
+                  strlen(SC_KERNEL_EVENT_PREFIX) ) )
+    {
+	object_manager->insert_event(m_name, this);
+	if ( m_parent_p )
+	    m_parent_p->add_child_event( this );
+	else
+	    m_simc->add_child_event( this );
+    }
+}
+
+void
+sc_event::reset()
+{
+    m_notify_type = NONE;
+    m_delta_event_index = -1;
+    m_timed = 0;
+    // clear the dynamic sensitive methods
+    m_methods_dynamic.resize(0);
+    // clear the dynamic sensitive threads
+    m_threads_dynamic.resize(0);
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_event::sc_event(name)"
+// | 
+// | This is the object instance constructor for named sc_event instances.
+// | If the name is non-null or the this is during elaboration add the
+// | event to the object hierarchy.
+// |
+// | Arguments:
+// |     name = name of the event.
+// +----------------------------------------------------------------------------
+sc_event::sc_event( const char* name ) :
+    m_name(),
+    m_parent_p(NULL),
+    m_simc( sc_get_curr_simcontext() ),
+    m_notify_type( NONE ),
+    m_delta_event_index( -1 ),
+    m_timed( 0 ),
+    m_methods_static(),
+    m_methods_dynamic(),
+    m_threads_static(),
+    m_threads_dynamic()
+{
+    // Skip simulator's internally defined events.
+
+    register_event( name );
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_event::sc_event(name)"
+// | 
+// | This is the object instance constructor for non-named sc_event instances.
+// | If this is during elaboration add create a name and add it to the object
+// | hierarchy.
+// +----------------------------------------------------------------------------
+sc_event::sc_event() :
+    m_name(),
+    m_parent_p(NULL),
+    m_simc( sc_get_curr_simcontext() ),
+    m_notify_type( NONE ),
+    m_delta_event_index( -1 ),
+    m_timed( 0 ),
+    m_methods_static(),
+    m_methods_dynamic(),
+    m_threads_static(),
+    m_threads_dynamic()
+{
+
+    register_event( NULL );
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_event::~sc_event"
+// | 
+// | This is the object instance destructor for this class. It cancels any
+// | outstanding waits and removes the event from the object manager's 
+// | instance table if it has a name.
+// +----------------------------------------------------------------------------
+sc_event::~sc_event()
+{
+    cancel();
+    if ( m_name.length() != 0 )
+    {
+	sc_object_manager* object_manager_p = m_simc->get_object_manager();
+	object_manager_p->remove_event( m_name );
+    }
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_event::trigger"
+// | 
+// | This method "triggers" this object instance. This consists of scheduling
+// | for execution all the processes that are schedulable and waiting on this 
+// | event.
+// +----------------------------------------------------------------------------
+void
+sc_event::trigger()
+{
+    int       last_i; // index of last element in vector now accessing.
+    int       size;   // size of vector now accessing.
+
+
+    // trigger the static sensitive methods
+
+    if( ( size = m_methods_static.size() ) != 0 ) 
+    {
+        sc_method_handle* l_methods_static = &m_methods_static[0];
+        int i = size - 1;
+        do {
+            sc_method_handle method_h = l_methods_static[i];
+            method_h->trigger_static();
+        } while( -- i >= 0 );
+    }
+
+    // trigger the dynamic sensitive methods
+
+
+    if( ( size = m_methods_dynamic.size() ) != 0 ) 
+    {
+	last_i = size - 1;
+	sc_method_handle* l_methods_dynamic = &m_methods_dynamic[0];
+	for ( int i = 0; i <= last_i; i++ )
+	{
+	    sc_method_handle method_h = l_methods_dynamic[i];
+	    if ( method_h->trigger_dynamic( this ) )
+	    {
+		l_methods_dynamic[i] = l_methods_dynamic[last_i];
+		last_i--;
+		i--;
+	    }
+	}
+        m_methods_dynamic.resize(last_i+1);
+    }
+
+
+    // trigger the static sensitive threads
+
+    if( ( size = m_threads_static.size() ) != 0 ) 
+    {
+        sc_thread_handle* l_threads_static = &m_threads_static[0];
+        int i = size - 1;
+        do {
+            sc_thread_handle thread_h = l_threads_static[i];
+            thread_h->trigger_static();
+        } while( -- i >= 0 );
+    }
+
+    // trigger the dynamic sensitive threads
+
+    if( ( size = m_threads_dynamic.size() ) != 0 ) 
+    {
+	last_i = size - 1;
+	sc_thread_handle* l_threads_dynamic = &m_threads_dynamic[0];
+	for ( int i = 0; i <= last_i; i++ )
+	{
+	    sc_thread_handle thread_h = l_threads_dynamic[i];
+	    if ( thread_h->trigger_dynamic( this ) )
+	    {
+		l_threads_dynamic[i] = l_threads_dynamic[last_i];
+		i--;
+		last_i--;
+	    }
+	}
+        m_threads_dynamic.resize(last_i+1);
+    }
+
+    m_notify_type = NONE;
+    m_delta_event_index = -1;
+    m_timed = 0;
+}
+
+
+bool
+sc_event::remove_static( sc_method_handle method_h_ ) const
+{
+    int size;
+    if ( ( size = m_methods_static.size() ) != 0 ) {
+      sc_method_handle* l_methods_static = &m_methods_static[0];
+      for( int i = size - 1; i >= 0; -- i ) {
+          if( l_methods_static[i] == method_h_ ) {
+              l_methods_static[i] = l_methods_static[size - 1];
+              m_methods_static.resize(size-1);
+              return true;
+          }
+      }
+    }
+    return false;
+}
+
+bool
+sc_event::remove_static( sc_thread_handle thread_h_ ) const
+{
+    int size;
+    if ( ( size = m_threads_static.size() ) != 0 ) {
+      sc_thread_handle* l_threads_static = &m_threads_static[0];
+      for( int i = size - 1; i >= 0; -- i ) {
+          if( l_threads_static[i] == thread_h_ ) {
+              l_threads_static[i] = l_threads_static[size - 1];
+              m_threads_static.resize(size-1);
+              return true;
+          }
+      }
+    }
+    return false;
+}
+
+bool
+sc_event::remove_dynamic( sc_method_handle method_h_ ) const
+{
+    int size;
+    if ( ( size = m_methods_dynamic.size() ) != 0 ) {
+      sc_method_handle* l_methods_dynamic = &m_methods_dynamic[0];
+      for( int i = size - 1; i >= 0; -- i ) {
+          if( l_methods_dynamic[i] == method_h_ ) {
+              l_methods_dynamic[i] = l_methods_dynamic[size - 1];
+              m_methods_dynamic.resize(size-1);
+              return true;
+          }
+      }
+    }
+    return false;
+}
+
+bool
+sc_event::remove_dynamic( sc_thread_handle thread_h_ ) const
+{
+    int size;
+    if ( ( size= m_threads_dynamic.size() ) != 0 ) {
+      sc_thread_handle* l_threads_dynamic = &m_threads_dynamic[0];
+      for( int i = size - 1; i >= 0; -- i ) {
+          if( l_threads_dynamic[i] == thread_h_ ) {
+              l_threads_dynamic[i] = l_threads_dynamic[size - 1];
+              m_threads_dynamic.resize(size-1);
+              return true;
+          }
+      }
+    }
+    return false;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_event_timed
+//
+//  Class for storing the time to notify a timed event.
+// ----------------------------------------------------------------------------
+
+// dedicated memory management; not MT-Safe
+
+union sc_event_timed_u
+{
+    sc_event_timed_u* next;
+    char              dummy[sizeof( sc_event_timed )];
+};
+
+static
+sc_event_timed_u* free_list = 0;
+
+void*
+sc_event_timed::allocate()
+{
+    const int ALLOC_SIZE = 64;
+
+    if( free_list == 0 ) {
+        free_list = (sc_event_timed_u*) malloc( ALLOC_SIZE *
+                                                sizeof( sc_event_timed ) );
+        int i = 0;
+        for( ; i < ALLOC_SIZE - 1; ++ i ) {
+            free_list[i].next = &free_list[i + 1];
+        }
+        free_list[i].next = 0;
+    }
+
+    sc_event_timed_u* q = free_list;
+    free_list = free_list->next;
+    return q;
+}
+
+void
+sc_event_timed::deallocate( void* p )
+{
+    if( p != 0 ) {
+        sc_event_timed_u* q = RCAST<sc_event_timed_u*>( p );
+        q->next = free_list;
+        free_list = q;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_event_list
+//
+//  Base class for lists of events.
+// ----------------------------------------------------------------------------
+
+void
+sc_event_list::push_back( const sc_event& e )
+{
+    // make sure e is not already in the list
+    if ( m_events.size() != 0 ) {
+      const sc_event** l_events = &m_events[0];
+      for( int i = m_events.size() - 1; i >= 0; -- i ) {
+          if( &e == l_events[i] ) {
+              // event already in the list; ignore
+              return;
+          }
+      }
+    }
+    m_events.push_back( &e );
+}
+
+void 
+sc_event_list::push_back( const sc_event_list& el )
+{
+    m_events.reserve( size() + el.size() );
+    for ( int i = el.m_events.size() - 1; i >= 0; --i )
+    {
+        push_back( *el.m_events[i] );
+    }
+    el.auto_delete();
+}
+
+void
+sc_event_list::add_dynamic( sc_method_handle method_h ) const
+{
+    m_busy++;
+    if ( m_events.size() != 0 ) {
+      const sc_event* const * l_events = &m_events[0];
+      for( int i = m_events.size() - 1; i >= 0; -- i ) {
+          l_events[i]->add_dynamic( method_h );
+      }
+  }
+}
+
+void
+sc_event_list::add_dynamic( sc_thread_handle thread_h ) const
+{
+    m_busy++;
+    if ( m_events.size() != 0 ) {
+      const sc_event* const* l_events = &m_events[0];
+      for( int i = m_events.size() - 1; i >= 0; -- i ) {
+          l_events[i]->add_dynamic( thread_h );
+      }
+  }
+}
+
+void
+sc_event_list::remove_dynamic( sc_method_handle method_h,
+                               const sc_event* e_not ) const
+{
+    if ( m_events.size() != 0 ) {
+      const sc_event* const* l_events = &m_events[0];
+      for( int i = m_events.size() - 1; i >= 0; -- i ) {
+          const sc_event* e = l_events[i];
+          if( e != e_not ) {
+              e->remove_dynamic( method_h );
+          }
+      }
+  }
+}
+
+void
+sc_event_list::remove_dynamic( sc_thread_handle thread_h,
+                               const sc_event* e_not ) const
+{
+    if ( m_events.size() != 0 ) {
+      const sc_event* const* l_events = &m_events[0];
+      for( int i = m_events.size() - 1; i >= 0; -- i ) {
+          const sc_event* e = l_events[i];
+          if( e != e_not ) {
+              e->remove_dynamic( thread_h );
+          }
+      }
+  }
+}
+
+void
+sc_event_list::report_premature_destruction() const
+{
+    // TDB: reliably detect premature destruction
+    //
+    // If an event list is used as a member of a module,
+    // its lifetime may (correctly) end, although there
+    // are processes currently waiting for it.
+    //
+    // Detecting (and ignoring) this corner-case is quite
+    // difficult for similar reasons to the sc_is_running()
+    // return value during the destruction of the module
+    // hierarchy.
+    //
+    // Ignoring the lifetime checks for now, if no process
+    // is currently running (which is only part of the story):
+
+    if( sc_get_current_process_handle().valid() ) {
+        // FIXME: improve error-handling
+        sc_assert( false && "sc_event_list prematurely destroyed" );
+    }
+
+}
+
+void
+sc_event_list::report_invalid_modification() const
+{
+    // FIXME: improve error-handling
+    sc_assert( false && "sc_event_list modfied while being waited on" );
+}
+
+// ----------------------------------------------------------------------------
+//  Deprecated functional notation for notifying events.
+// ----------------------------------------------------------------------------
+
+static void sc_warn_notify()
+{
+    static bool warn_notify=true;
+    if ( warn_notify )
+    {
+  SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
+      "the notify() function is deprecated use sc_event::notify()" );
+  warn_notify = false;
+    }
+}
+
+void
+notify( sc_event& e )
+{
+    sc_warn_notify();
+    e.notify();
+}
+
+void
+notify( const sc_time& t, sc_event& e )
+{
+    sc_warn_notify();
+    e.notify( t );
+}
+
+void
+notify( double v, sc_time_unit tu, sc_event& e )
+{
+    sc_warn_notify();
+    e.notify( v, tu );
+}
+
+} // namespace sc_core
+
+// $Log: sc_event.cpp,v $
+// Revision 1.17  2011/08/26 20:46:09  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.16  2011/08/24 22:05:50  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.15  2011/03/12 21:07:51  acg
+//  Andy Goodrich: changes to kernel generated event support.
+//
+// Revision 1.14  2011/03/06 15:55:52  acg
+//  Andy Goodrich: changes for named events.
+//
+// Revision 1.13  2011/03/05 01:39:21  acg
+//  Andy Goodrich: changes for named events.
+//
+// Revision 1.12  2011/02/19 08:33:25  acg
+//  Andy Goodrich: remove }'s that should have been removed before.
+//
+// Revision 1.11  2011/02/19 08:30:53  acg
+//  Andy Goodrich: Moved process queueing into trigger_static from
+//  sc_event::notify.
+//
+// Revision 1.10  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.9  2011/02/17 19:49:51  acg
+//  Andy Goodrich:
+//    (1) Changed signature of trigger_dynamic() to return a bool again.
+//    (2) Moved process run queue processing into trigger_dynamic().
+//
+// Revision 1.8  2011/02/16 22:37:30  acg
+//  Andy Goodrich: clean up to remove need for ps_disable_pending.
+//
+// Revision 1.7  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.6  2011/02/01 21:02:28  acg
+//  Andy Goodrich: new return code for trigger_dynamic() calls.
+//
+// Revision 1.5  2011/01/18 20:10:44  acg
+//  Andy Goodrich: changes for IEEE1666_2011 semantics.
+//
+// Revision 1.4  2011/01/06 18:04:05  acg
+//  Andy Goodrich: added code to leave disabled processes on the dynamic
+//  method and thread queues.
+//
+// Revision 1.3  2008/05/22 17:06:25  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.2  2007/01/17 22:44:30  acg
+//  Andy Goodrich: fix for Microsoft compiler.
+//
+// Revision 1.7  2006/04/11 23:13:20  acg
+//   Andy Goodrich: Changes for reduced reset support that only includes
+//   sc_cthread, but has preliminary hooks for expanding to method and thread
+//   processes also.
+//
+// Revision 1.6  2006/01/25 00:31:19  acg
+//  Andy Goodrich: Changed over to use a standard message id of
+//  SC_ID_IEEE_1666_DEPRECATION for all deprecation messages.
+//
+// Revision 1.5  2006/01/24 20:59:11  acg
+//  Andy Goodrich: fix up of CVS comments, new version roll.
+//
+// Revision 1.4  2006/01/24 20:48:14  acg
+// Andy Goodrich: added deprecation warnings for notify_delayed(). Added two
+// new implementation-dependent methods, notify_next_delta() & notify_internal()
+// to replace calls to notify_delayed() from within the simulator. These two
+// new methods are simpler than notify_delayed() and should speed up simulations
+//
+// Revision 1.3  2006/01/13 18:44:29  acg
+// Added $Log to record CVS changes into the source.
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_event.h b/ext/systemc/src/sysc/kernel/sc_event.h
new file mode 100644
index 000000000..9633752ce
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_event.h
@@ -0,0 +1,884 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_event.h --
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#ifndef SC_EVENT_H
+#define SC_EVENT_H
+
+#include "sysc/kernel/sc_cmnhdr.h"
+#include "sysc/kernel/sc_kernel_ids.h"
+#include "sysc/kernel/sc_simcontext.h"
+#include "sysc/communication/sc_writer_policy.h"
+
+namespace sc_core {
+
+// forward declarations
+class sc_event;
+class sc_event_timed;
+class sc_event_list;
+class sc_event_or_list;
+class sc_event_and_list;
+class sc_object;
+
+// friend function declarations
+    int sc_notify_time_compare( const void*, const void* );
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_event_expr
+//
+//  The event expression class.
+// ----------------------------------------------------------------------------
+
+template< typename T >
+class sc_event_expr
+{
+    friend class sc_event;
+    friend class sc_event_and_list;
+    friend class sc_event_or_list;
+
+    typedef T type;
+
+    inline sc_event_expr()
+       : m_expr( new T(true) )
+    {}
+
+public:
+
+    inline sc_event_expr( sc_event_expr const & e) // move semantics
+      : m_expr(e.m_expr)
+    {
+        e.m_expr = 0;
+    }
+
+    T const & release() const
+    {
+        sc_assert( m_expr );
+        T* expr = m_expr;
+        m_expr=0;
+        return *expr;
+    }
+
+    void push_back( sc_event const & e) const
+    {
+        sc_assert( m_expr );
+        m_expr->push_back(e);
+    }
+
+    void push_back( type const & el) const
+    {
+        sc_assert( m_expr );
+        m_expr->push_back(el);
+    }
+    operator T const &() const
+    {
+        return release();
+    }
+
+    ~sc_event_expr()
+    {
+        delete m_expr;
+    }
+
+private:
+    mutable type * m_expr;
+
+    // disabled
+    void operator=( sc_event_expr const & );
+};
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_event_list
+//
+//  Base class for lists of events.
+// ----------------------------------------------------------------------------
+
+class sc_event_list
+{
+    friend class sc_process_b;
+    friend class sc_method_process;
+    friend class sc_thread_process;
+    friend void sc_thread_cor_fn( void* arg );
+
+public:
+    sc_event_list( const sc_event_list& );
+    sc_event_list& operator = ( const sc_event_list& );
+
+    int size() const;
+
+protected:
+
+    void push_back( const sc_event& );
+    void push_back( const sc_event_list& );
+
+    explicit
+    sc_event_list( bool and_list_, bool auto_delete_ = false );
+
+    sc_event_list( const sc_event&,
+                   bool and_list_,
+                   bool auto_delete_ = false );
+
+    ~sc_event_list();
+
+    void swap( sc_event_list& );
+    void move_from( const sc_event_list& );
+
+    bool and_list() const;
+
+    void add_dynamic( sc_method_handle ) const;
+    void add_dynamic( sc_thread_handle ) const;
+    void remove_dynamic( sc_method_handle, const sc_event* ) const;
+    void remove_dynamic( sc_thread_handle, const sc_event* ) const;
+
+    bool busy()        const;
+    bool temporary()   const;
+    void auto_delete() const;
+
+    void report_premature_destruction() const;
+    void report_invalid_modification()  const;
+
+private:
+
+    std::vector<const sc_event*> m_events;
+    bool                         m_and_list;
+    bool                         m_auto_delete;
+    mutable unsigned             m_busy;
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_event_and_list
+//
+//  AND list of events.
+// ----------------------------------------------------------------------------
+
+class sc_event_and_list
+: public sc_event_list
+{
+    friend class sc_event;
+    friend class sc_event_expr<sc_event_and_list>;
+    friend class sc_process_b;
+    friend class sc_method_process;
+    friend class sc_thread_process;
+
+protected:
+
+    explicit
+    sc_event_and_list( bool auto_delete_ );
+
+public:
+
+    sc_event_and_list();
+    sc_event_and_list( const sc_event& );
+
+    void swap( sc_event_and_list& );
+    sc_event_and_list& operator &= ( const sc_event& );
+    sc_event_and_list& operator &= ( const sc_event_and_list & );
+
+    sc_event_expr<sc_event_and_list>  operator & ( const sc_event& );
+    sc_event_expr<sc_event_and_list>  operator & ( const sc_event_and_list& );
+};
+
+typedef sc_event_expr<sc_event_and_list> sc_event_and_expr;
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_event_or_list
+//
+//  OR list of events.
+// ----------------------------------------------------------------------------
+
+class sc_event_or_list
+: public sc_event_list
+{
+    friend class sc_event;
+    friend class sc_event_expr<sc_event_or_list>;
+    friend class sc_process_b;
+    friend class sc_method_process;
+    friend class sc_thread_process;
+
+protected:
+
+    explicit
+    sc_event_or_list( bool auto_delete_ );
+
+public:
+    sc_event_or_list();
+    sc_event_or_list( const sc_event& );
+    void swap( sc_event_or_list& );
+    sc_event_or_list& operator |= ( const sc_event& );
+    sc_event_or_list& operator |= ( const sc_event_or_list & );
+    sc_event_expr<sc_event_or_list>  operator | ( const sc_event& ) const;
+    sc_event_expr<sc_event_or_list>  operator | ( const sc_event_or_list& ) const;
+};
+
+typedef sc_event_expr<sc_event_or_list> sc_event_or_expr;
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_event
+//
+//  The event class.
+// ----------------------------------------------------------------------------
+
+class sc_event
+{
+    friend class sc_clock;
+    friend class sc_event_list;
+    friend class sc_event_timed;
+    friend class sc_simcontext;
+    friend class sc_object;
+    friend class sc_process_b;
+    friend class sc_method_process;
+    friend class sc_thread_process;
+    template<typename IF, sc_writer_policy POL> friend class sc_signal;
+    friend void sc_thread_cor_fn( void* arg );
+
+public:
+
+    sc_event();
+    sc_event( const char* name );
+    ~sc_event();
+
+    void cancel();
+
+    const char* name() const             { return m_name.c_str(); }
+    const char* basename() const;
+    sc_object* get_parent_object() const { return m_parent_p; }
+    bool in_hierarchy() const            { return m_name.length() != 0; }
+
+    void notify();
+    void notify( const sc_time& );
+    void notify( double, sc_time_unit );
+
+    void notify_delayed();
+    void notify_delayed( const sc_time& );
+    void notify_delayed( double, sc_time_unit );
+
+    sc_event_or_expr  operator | ( const sc_event& ) const; 
+    sc_event_or_expr  operator | ( const sc_event_or_list& ) const;
+    sc_event_and_expr operator & ( const sc_event& ) const;
+    sc_event_and_expr operator & ( const sc_event_and_list& ) const;
+
+
+private:
+
+    void add_static( sc_method_handle ) const;
+    void add_static( sc_thread_handle ) const;
+    void add_dynamic( sc_method_handle ) const;
+    void add_dynamic( sc_thread_handle ) const;
+
+    void notify_internal( const sc_time& );
+    void notify_next_delta();
+
+    bool remove_static( sc_method_handle ) const;
+    bool remove_static( sc_thread_handle ) const;
+    bool remove_dynamic( sc_method_handle ) const;
+    bool remove_dynamic( sc_thread_handle ) const;
+
+    void register_event( const char* name );
+    void reset();
+
+    void trigger();
+
+private:
+
+    enum notify_t { NONE, DELTA, TIMED };
+
+    std::string     m_name;     // name of object.
+    sc_object*      m_parent_p; // parent sc_object for this event.
+    sc_simcontext*  m_simc;
+    notify_t        m_notify_type;
+    int             m_delta_event_index;
+    sc_event_timed* m_timed;
+
+    mutable std::vector<sc_method_handle> m_methods_static;
+    mutable std::vector<sc_method_handle> m_methods_dynamic;
+    mutable std::vector<sc_thread_handle> m_threads_static;
+    mutable std::vector<sc_thread_handle> m_threads_dynamic;
+
+private:
+
+    // disabled
+    sc_event( const sc_event& );
+    sc_event& operator = ( const sc_event& );
+};
+
+#define SC_KERNEL_EVENT_PREFIX "$$$$kernel_event$$$$_"
+
+extern sc_event sc_non_event; // Event that never happens.
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_event_timed
+//
+//  Class for storing the time to notify a timed event.
+// ----------------------------------------------------------------------------
+
+class sc_event_timed
+{
+    friend class sc_event;
+    friend class sc_simcontext;
+
+    friend int sc_notify_time_compare( const void*, const void* );
+
+private:
+
+    sc_event_timed( sc_event* e, const sc_time& t )
+        : m_event( e ), m_notify_time( t )
+        {}
+
+    ~sc_event_timed()
+        { if( m_event != 0 ) { m_event->m_timed = 0; } }
+
+    sc_event* event() const
+        { return m_event; }
+
+    const sc_time& notify_time() const
+        { return m_notify_time; }
+
+    static void* operator new( std::size_t )
+        { return allocate(); }
+
+    static void operator delete( void* p, std::size_t )
+        { deallocate( p ); }
+
+private:
+
+    // dedicated memory management
+    static void* allocate();
+    static void  deallocate( void* );
+
+private:
+
+    sc_event* m_event;
+    sc_time   m_notify_time;
+
+private:
+
+    // disabled
+    sc_event_timed();
+    sc_event_timed( const sc_event_timed& );
+    sc_event_timed& operator = ( const sc_event_timed& );
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+inline
+void
+sc_event::notify( double v, sc_time_unit tu )
+{
+    notify( sc_time( v, tu, m_simc ) );
+}
+
+
+inline
+void
+sc_event::notify_internal( const sc_time& t )
+{
+    if( t == SC_ZERO_TIME ) {
+        // add this event to the delta events set
+        m_delta_event_index = m_simc->add_delta_event( this );
+        m_notify_type = DELTA;
+    } else {
+        sc_event_timed* et =
+		new sc_event_timed( this, m_simc->time_stamp() + t );
+        m_simc->add_timed_event( et );
+        m_timed = et;
+        m_notify_type = TIMED;
+    }
+}
+
+inline
+void
+sc_event::notify_next_delta()
+{
+    if( m_notify_type != NONE ) {
+        SC_REPORT_ERROR( SC_ID_NOTIFY_DELAYED_, 0 );
+    }
+    // add this event to the delta events set
+    m_delta_event_index = m_simc->add_delta_event( this );
+    m_notify_type = DELTA;
+}
+
+inline
+void
+sc_event::notify_delayed( double v, sc_time_unit tu )
+{
+    notify_delayed( sc_time( v, tu, m_simc ) );
+}
+
+
+inline
+void
+sc_event::add_static( sc_method_handle method_h ) const
+{
+    m_methods_static.push_back( method_h );
+}
+
+inline
+void
+sc_event::add_static( sc_thread_handle thread_h ) const
+{
+    m_threads_static.push_back( thread_h );
+}
+
+inline
+void
+sc_event::add_dynamic( sc_method_handle method_h ) const
+{
+    m_methods_dynamic.push_back( method_h );
+}
+
+inline
+void
+sc_event::add_dynamic( sc_thread_handle thread_h ) const
+{
+    m_threads_dynamic.push_back( thread_h );
+}
+
+
+// ----------------------------------------------------------------------------
+//  Deprecated functional notation for notifying events.
+// ----------------------------------------------------------------------------
+
+extern void notify( sc_event& e );
+extern void notify( const sc_time& t, sc_event& e );
+extern void notify( double v, sc_time_unit tu, sc_event& e );
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+inline
+sc_event_list::sc_event_list( bool and_list_, bool auto_delete_ ) 
+  : m_events() 
+  , m_and_list( and_list_ ) 
+  , m_auto_delete( auto_delete_ ) 
+  , m_busy( 0 )
+{
+}
+
+inline
+sc_event_list::sc_event_list( const sc_event& e,
+                              bool and_list_,
+                              bool auto_delete_ )
+  : m_events()
+  , m_and_list( and_list_ )
+  , m_auto_delete( auto_delete_ )
+  , m_busy(0)
+{
+    m_events.push_back( &e );
+}
+
+inline
+sc_event_list::sc_event_list( sc_event_list const & that )
+  : m_events()
+  , m_and_list( that.m_and_list )
+  , m_auto_delete( false )
+  , m_busy( 0 )
+{
+    move_from( that );
+    that.auto_delete(); // free automatic lists
+}
+
+inline
+sc_event_list&
+sc_event_list::operator=( sc_event_list const & that )
+{
+    if( m_busy )
+        report_invalid_modification();
+
+    move_from( that );
+    that.auto_delete(); // free automatic lists
+
+    return *this;
+}
+
+inline
+sc_event_list::~sc_event_list()
+{
+    if( m_busy )
+        report_premature_destruction();
+}
+
+inline
+void
+sc_event_list::swap( sc_event_list& that )
+{
+    if( busy() || that.busy() )
+        report_invalid_modification();
+    m_events.swap( that.m_events );
+}
+
+inline
+void
+sc_event_list::move_from( sc_event_list const&  that )
+{
+    if( that.temporary() ) {
+        swap( const_cast<sc_event_list&>(that) ); // move from source
+    } else {
+        m_events = that.m_events;                 // copy from source
+    }
+}
+
+inline
+int
+sc_event_list::size() const
+{
+    return m_events.size();
+}
+
+inline
+bool
+sc_event_list::and_list() const
+{
+    return m_and_list;
+}
+
+
+inline
+bool
+sc_event_list::busy() const
+{
+    return m_busy != 0;
+}
+
+
+inline
+bool
+sc_event_list::temporary() const
+{
+    return m_auto_delete && ! m_busy;
+}
+
+inline
+void
+sc_event_list::auto_delete() const
+{
+    if( m_busy ) {
+        --m_busy;
+    }
+    if( ! m_busy && m_auto_delete ) {
+        delete this;
+    }
+}
+
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+inline
+sc_event_or_list::sc_event_or_list()
+  : sc_event_list( false )
+{}
+
+inline
+sc_event_or_list::sc_event_or_list( const sc_event& e )
+: sc_event_list( false )
+{
+  push_back( e );
+}
+
+inline
+sc_event_or_list::sc_event_or_list( bool auto_delete_ )
+: sc_event_list( false, auto_delete_ )
+{}
+
+inline
+sc_event_or_list&
+sc_event_or_list::operator |= ( const sc_event& e )
+{
+    if( busy() )
+        report_invalid_modification();
+
+    push_back( e );
+    return *this;
+}
+
+inline
+sc_event_or_list&
+sc_event_or_list::operator |= ( const sc_event_or_list& el )
+{
+    if( busy() )
+        report_invalid_modification();
+
+    push_back( el );
+    return *this;
+}
+
+inline
+sc_event_or_expr
+sc_event_or_list::operator | ( const sc_event& e2 ) const
+{
+    sc_event_or_expr expr;
+    expr.push_back( *this );
+    expr.push_back( e2 );
+    return expr;
+}
+
+inline
+sc_event_or_expr
+sc_event_or_list::operator | ( const sc_event_or_list& e2 ) const
+{
+    sc_event_or_expr expr;
+    expr.push_back( *this );
+    expr.push_back( e2 );
+    return expr;
+}
+
+
+// sc_event
+
+inline
+sc_event_or_expr
+sc_event::operator | ( const sc_event& e2 ) const
+{
+    sc_event_or_expr expr;
+    expr.push_back( *this );
+    expr.push_back( e2 );
+    return expr;
+}
+
+inline
+sc_event_or_expr
+sc_event::operator | ( const sc_event_or_list& e2 ) const
+{
+    sc_event_or_expr expr;
+    expr.push_back( *this );
+    expr.push_back( e2 );
+    return expr;
+}
+
+// sc_event_expr
+
+inline
+sc_event_or_expr
+operator | ( sc_event_or_expr expr, sc_event const & e )
+{
+    expr.push_back( e );
+    return expr;
+}
+
+inline
+sc_event_or_expr
+operator | ( sc_event_or_expr expr, sc_event_or_list const & el )
+{
+    expr.push_back( el );
+    return expr;
+}
+
+inline
+void
+sc_event_or_list::swap( sc_event_or_list & that )
+{
+  sc_event_list::swap( that );
+}
+
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+inline
+sc_event_and_list::sc_event_and_list()
+  : sc_event_list( true )
+{}
+
+inline
+sc_event_and_list::sc_event_and_list( const sc_event& e )
+: sc_event_list( true )
+{
+  push_back( e );
+}
+
+inline
+sc_event_and_list::sc_event_and_list( bool auto_delete_ )
+: sc_event_list( true, auto_delete_ )
+{}
+
+inline
+void
+sc_event_and_list::swap( sc_event_and_list & that )
+{
+  sc_event_list::swap( that );
+}
+
+
+inline
+sc_event_and_list&
+sc_event_and_list::operator &= ( const sc_event& e )
+{
+    if( busy() )
+        report_invalid_modification();
+
+    push_back( e );
+    return *this;
+}
+
+inline
+sc_event_and_list&
+sc_event_and_list::operator &= ( const sc_event_and_list& el )
+{
+    if( busy() )
+        report_invalid_modification();
+
+    push_back( el );
+    return *this;
+}
+
+inline
+sc_event_and_expr
+sc_event_and_list::operator & ( const sc_event& e )
+{
+    sc_event_and_expr expr;
+    expr.push_back( *this );
+    expr.push_back( e );
+    return expr;
+}
+
+inline
+sc_event_and_expr
+sc_event_and_list::operator & ( const sc_event_and_list& el )
+{
+    sc_event_and_expr expr;
+    expr.push_back( *this );
+    expr.push_back( el );
+    return expr;
+}
+
+// sc_event
+
+inline
+sc_event_and_expr
+sc_event::operator & ( const sc_event& e2 ) const
+{
+    sc_event_and_expr expr;
+    expr.push_back( *this );
+    expr.push_back( e2 );
+    return expr;
+}
+
+inline
+sc_event_and_expr
+sc_event::operator & ( const sc_event_and_list& e2 ) const
+{
+    sc_event_and_expr expr;
+    expr.push_back( *this );
+    expr.push_back( e2 );
+    return expr;
+}
+
+// sc_event_expr
+
+inline
+sc_event_and_expr
+operator & ( sc_event_and_expr expr, sc_event const & e )
+{
+    expr.push_back( e );
+    return expr;
+}
+
+inline
+sc_event_and_expr
+operator & ( sc_event_and_expr expr, sc_event_and_list const & el )
+{
+    expr.push_back( el );
+    return expr;
+}
+
+} // namespace sc_core
+
+// $Log: sc_event.h,v $
+// Revision 1.14  2011/08/29 18:04:32  acg
+//  Philipp A. Hartmann: miscellaneous clean ups.
+//
+// Revision 1.13  2011/08/26 20:46:09  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.12  2011/08/24 22:05:50  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.11  2011/03/12 21:07:51  acg
+//  Andy Goodrich: changes to kernel generated event support.
+//
+// Revision 1.10  2011/03/06 15:55:11  acg
+//  Andy Goodrich: Changes for named events.
+//
+// Revision 1.9  2011/03/05 01:39:21  acg
+//  Andy Goodrich: changes for named events.
+//
+// Revision 1.8  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.7  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.6  2011/02/01 21:03:23  acg
+//  Andy Goodrich: new return codes for trigger_dynamic calls.
+//
+// Revision 1.5  2011/01/18 20:10:44  acg
+//  Andy Goodrich: changes for IEEE1666_2011 semantics.
+//
+// Revision 1.4  2010/12/07 20:09:11  acg
+// Andy Goodrich: writer policy fix.
+//
+// Revision 1.3  2009/05/22 16:06:29  acg
+//  Andy Goodrich: process control updates.
+//
+// Revision 1.2  2008/05/22 17:06:25  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.8  2006/05/26 20:33:16  acg
+//   Andy Goodrich: changes required by additional platform compilers (i.e.,
+//   Microsoft VC++, Sun Forte, HP aCC).
+//
+// Revision 1.7  2006/05/08 17:57:51  acg
+// Andy Goodrich: added David Long's forward declarations for friend
+//   functions, methods, and operators to keep the Microsoft compiler happy.
+//
+// Revision 1.6  2006/04/11 23:13:20  acg
+//   Andy Goodrich: Changes for reduced reset support that only includes
+//   sc_cthread, but has preliminary hooks for expanding to method and thread
+//   processes also.
+//
+// Revision 1.5  2006/01/24 20:56:00  acg
+//  Andy Goodrich: fixed up CVS comment.
+//
+// Revision 1.4  2006/01/24 20:48:14  acg
+// Andy Goodrich: added deprecation warnings for notify_delayed(). Added two
+// new implementation-dependent methods, notify_next_delta() & notify_internal()
+// to replace calls to notify_delayed() from within the simulator. These two
+// new methods are simpler than notify_delayed() and should speed up simulations
+//
+// Revision 1.3  2006/01/13 18:44:29  acg
+// Added $Log to record CVS changes into the source.
+//
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_except.cpp b/ext/systemc/src/sysc/kernel/sc_except.cpp
new file mode 100644
index 000000000..2699f8daf
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_except.cpp
@@ -0,0 +1,142 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_except.cpp -- kill/reset exception handling
+
+  Original Author: Philipp A. Hartmann, OFFIS
+
+ CHANGE LOG APPEARS AT THE END OF THE FILE
+ *****************************************************************************/
+
+#include "sysc/kernel/sc_cmnhdr.h"
+//
+#include "sysc/kernel/sc_except.h"
+#include "sysc/kernel/sc_process.h"
+//
+#include "sysc/utils/sc_report.h"
+
+namespace sc_core {
+
+sc_unwind_exception::sc_unwind_exception( sc_process_b* proc_p, bool is_reset )
+  : m_proc_p(proc_p), m_is_reset( is_reset )
+{
+  sc_assert( m_proc_p );
+  m_proc_p->start_unwinding();
+}
+
+bool
+sc_unwind_exception::active() const
+{
+  return m_proc_p && m_proc_p->is_unwinding();
+}
+
+void
+sc_unwind_exception::clear() const
+{
+  sc_assert( m_proc_p );
+  m_proc_p->clear_unwinding();
+}
+
+const char*
+sc_unwind_exception::what() const throw()
+{
+  return ( m_is_reset ) ? "RESET" : "KILL";
+}
+
+sc_unwind_exception::~sc_unwind_exception() throw()
+{
+  if( active() ) {
+      // can't throw an exception, since we're already throwing
+      // -> abort instead
+      SC_REPORT_FATAL( SC_ID_RETHROW_UNWINDING_, m_proc_p->name() );
+  }
+}
+
+// handle and translate uncaught exceptions here
+//
+// These exceptions can either escape from sc_main() directly,
+// indirectly from an SC_METHOD(), or are thrown from within
+// an SC_(C)THREAD()
+//
+// returns a pointer to a dynamically allocated sc_report object,
+// containing the caught message
+
+sc_report*
+sc_handle_exception()
+{
+    try {
+
+        // re-throw exception here
+        try { throw; }
+
+        catch( sc_report & ) // to be on the safe side
+        {
+            throw; // continue
+        }
+        catch( sc_unwind_exception const & )
+        {
+            sc_assert( false && "Unhandled kill/reset, should never happen" );
+        }
+        catch( std::exception const & x )
+        {
+            SC_REPORT_ERROR( SC_ID_SIMULATION_UNCAUGHT_EXCEPTION_, x.what() );
+        }
+        catch( char const * x )
+        {
+            SC_REPORT_ERROR( SC_ID_SIMULATION_UNCAUGHT_EXCEPTION_, x );
+        }
+        catch( ... )
+        {
+            SC_REPORT_ERROR( SC_ID_SIMULATION_UNCAUGHT_EXCEPTION_,
+                             "UNKNOWN EXCEPTION" );
+        }
+    }
+    // everything is an sc_report now
+    catch( sc_report & rpt )
+    {
+        sc_report* rpt_p = new sc_report;
+        rpt_p->swap( rpt );
+        return rpt_p;
+    }
+    return 0;
+}
+
+} // namespace sc_core
+
+// $Log: sc_except.cpp,v $
+// Revision 1.4  2011/08/26 20:46:09  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.3  2011/05/09 04:07:48  acg
+//  Philipp A. Hartmann:
+//    (1) Restore hierarchy in all phase callbacks.
+//    (2) Ensure calls to before_end_of_elaboration.
+//
+// Revision 1.2  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.1  2011/02/10 22:47:38  acg
+//  Andy Goodrich: first check in of Philipp A. Hartmann's new exception
+//  processing code.
+//
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_except.h b/ext/systemc/src/sysc/kernel/sc_except.h
new file mode 100644
index 000000000..e3bacbd9c
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_except.h
@@ -0,0 +1,178 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_except.h - Exception classes to be handled by SystemC.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#ifndef SC_EXCEPT_H
+#define SC_EXCEPT_H
+
+#include <exception>
+
+namespace sc_core {
+
+class sc_simcontext;
+class sc_process_b;
+class sc_method_process;
+class sc_thread_process;
+void sc_thread_cor_fn( void* arg );
+
+/*
+ *  These classes are intentionally empty. Their raison d'etre is for
+ *  the implementation of various SystemC throws.
+ */
+
+class sc_user
+{
+    /*EMPTY*/
+public:
+    sc_user() {}
+    sc_user( const sc_user& ) {}
+};
+
+class sc_halt
+{
+public:
+    sc_halt() {}
+    sc_halt( const sc_halt& ) {}
+};
+
+class sc_kill
+{
+public:
+    sc_kill() {}
+    sc_kill( const sc_kill& ) {}
+};
+
+class sc_unwind_exception : public std::exception
+{
+    friend class sc_simcontext;
+    friend class sc_process_b;
+    friend class sc_method_process;
+    friend class sc_thread_process;
+    friend void sc_thread_cor_fn( void* arg );
+
+  public:
+    virtual bool is_reset() const { return m_is_reset; }
+    virtual const char* what() const throw();
+
+  public:
+
+    // enable catch by value
+    sc_unwind_exception( const sc_unwind_exception& );
+    virtual ~sc_unwind_exception() throw();
+
+  protected:
+    explicit
+    sc_unwind_exception( sc_process_b* target_p, bool is_reset = false );
+
+    bool active() const;
+    void clear()  const;
+
+  private:
+    // disabled
+    sc_unwind_exception& operator=( const sc_unwind_exception& );
+
+    mutable sc_process_b* m_proc_p;   // used to check, if caught by the kernel
+    const   bool          m_is_reset; // true if this is an unwind of a reset
+
+};
+
+inline
+sc_unwind_exception::sc_unwind_exception( const sc_unwind_exception& that )
+  : std::exception( that )
+  , m_proc_p( that.m_proc_p )
+  , m_is_reset( that.m_is_reset )
+{
+    that.m_proc_p = 0; // move to new instance
+}
+
+//------------------------------------------------------------------------------
+// global exception handling
+//------------------------------------------------------------------------------
+ 
+class sc_report;
+sc_report* sc_handle_exception();
+
+} // namespace sc_core
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Gene Bushuyev. Synopsys, Inc.
+  Description of Modification: - Had to add empty public default and copy
+                                 constructors to satisfy VC6.0.
+    
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_except.h,v $
+// Revision 1.11  2011/08/26 21:40:26  acg
+//  Philipp A. Hartmann: fix up sc_unwind_exception copy-ctor.
+//
+// Revision 1.10  2011/08/26 20:46:09  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.9  2011/08/24 22:05:50  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.8  2011/05/09 04:07:48  acg
+//  Philipp A. Hartmann:
+//    (1) Restore hierarchy in all phase callbacks.
+//    (2) Ensure calls to before_end_of_elaboration.
+//
+// Revision 1.7  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.6  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.5  2011/02/11 13:25:24  acg
+//  Andy Goodrich: Philipp A. Hartmann's changes:
+//    (1) Removal of SC_CTHREAD method overloads.
+//    (2) New exception processing code.
+//
+// Revision 1.4  2011/01/18 20:10:44  acg
+//  Andy Goodrich: changes for IEEE1666_2011 semantics.
+//
+// Revision 1.3  2009/05/22 16:06:29  acg
+//  Andy Goodrich: process control updates.
+//
+// Revision 1.2  2008/05/22 17:06:25  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:44:29  acg
+// Added $Log to record CVS changes into the source.
+
+#endif
diff --git a/ext/systemc/src/sysc/kernel/sc_externs.h b/ext/systemc/src/sysc/kernel/sc_externs.h
new file mode 100644
index 000000000..1d1818089
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_externs.h
@@ -0,0 +1,65 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_externs.h -- Declaration of `sc_main' and other global variables.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#ifndef SC_EXTERNS_H
+#define SC_EXTERNS_H
+
+
+
+extern "C" int sc_main( int argc, char* argv[] );
+
+namespace sc_core {
+	extern "C" int sc_elab_and_sim( int argc, char* argv[] );
+	extern "C" int sc_argc();
+	extern "C" const char* const* sc_argv();
+
+} // namespace sc_core
+
+// $Log: sc_externs.h,v $
+// Revision 1.5  2011/08/26 20:46:09  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.4  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.3  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.2  2008/05/22 17:06:25  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:44:29  acg
+// Added $Log to record CVS changes into the source.
+//
+
+#endif
diff --git a/ext/systemc/src/sysc/kernel/sc_join.cpp b/ext/systemc/src/sysc/kernel/sc_join.cpp
new file mode 100644
index 000000000..25f6f6cea
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_join.cpp
@@ -0,0 +1,143 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_join.cpp -- Join Process Synchronization Implementation
+
+  Original Author: Andy Goodrich, Forte Design Systems, 5 May 2003
+
+ CHANGE LOG APPEARS AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#include <cassert>
+#include <cstdlib>
+#include <cstddef>
+
+#include "sysc/kernel/sc_process_handle.h"
+#include "sysc/kernel/sc_simcontext.h"
+#include "sysc/kernel/sc_simcontext_int.h"
+#include "sysc/kernel/sc_kernel_ids.h"
+#include "sysc/kernel/sc_thread_process.h"
+#include "sysc/kernel/sc_join.h"
+
+namespace sc_core {
+
+//------------------------------------------------------------------------------
+//"sc_join::sc_join"
+//
+// This is the object instance constructor for this class.
+//------------------------------------------------------------------------------
+sc_join::sc_join()
+  : m_join_event( (std::string(SC_KERNEL_EVENT_PREFIX)+"_join_event").c_str() )
+  , m_threads_n(0)
+{}
+
+//------------------------------------------------------------------------------
+//"sc_join::add_process - sc_process_b*"
+//
+// This method adds a process to this join object instance. This consists of
+// incrementing the count of processes in the join process and adding this 
+// object instance to the supplied thread's monitoring queue.
+//     process_p -> thread to be monitored.
+//------------------------------------------------------------------------------
+void sc_join::add_process( sc_process_b* process_p )
+{
+    sc_thread_handle handle = DCAST<sc_thread_handle>(process_p);
+    assert( handle != 0 );
+    m_threads_n++;
+    handle->add_monitor( this );
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_join::add_process - sc_process_handle"
+//
+// This method adds a process to this join object instance. This consists of
+// incrementing the count of processes in the join process and adding this 
+// object instance to the supplied thread's monitoring queue.
+//     process_h = handle for process to be monitored.
+//------------------------------------------------------------------------------
+void sc_join::add_process( sc_process_handle process_h )
+{
+    sc_thread_handle thread_p; // Thread within process_h.
+
+    thread_p = process_h.operator sc_thread_handle();
+    if ( thread_p )
+    {
+        m_threads_n++;
+        thread_p->add_monitor( this );
+    }
+    else
+    {
+        SC_REPORT_ERROR( SC_ID_JOIN_ON_METHOD_HANDLE_, 0 ); 
+    }
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_join::signal"
+//
+// This virtual method is called when a process being monitored by this object
+// instance sends a signal. If the signal type is spm_exit and the count of 
+// threads that we are waiting to terminate on goes to zero we fire our join 
+// event.
+//     thread_p -> thread that is signalling.
+//     type     =  type of signal being sent.
+//------------------------------------------------------------------------------
+void sc_join::signal(sc_thread_handle thread_p, int type)
+{
+    switch ( type )
+    {
+      case sc_process_monitor::spm_exit:
+        thread_p->remove_monitor(this);
+        if ( --m_threads_n == 0 ) m_join_event.notify();
+        break;
+    }
+}
+
+} // namespace sc_core
+
+// $Log: sc_join.cpp,v $
+// Revision 1.7  2011/08/26 21:45:00  acg
+//  Andy Goodrich: fix internal event naming.
+//
+// Revision 1.6  2011/08/26 20:46:09  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.5  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.4  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.3  2009/07/28 01:10:53  acg
+//  Andy Goodrich: updates for 2.3 release candidate.
+//
+// Revision 1.2  2008/05/22 17:06:25  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:44:29  acg
+// Added $Log to record CVS changes into the source.
+//
diff --git a/ext/systemc/src/sysc/kernel/sc_join.h b/ext/systemc/src/sysc/kernel/sc_join.h
new file mode 100644
index 000000000..e240f51a2
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_join.h
@@ -0,0 +1,136 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_join.h -- Join Process Synchronization Definition
+
+  Original Author: Andy Goodrich, Forte Design Systems, 5 May 2003
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+// $Log: sc_join.h,v $
+// Revision 1.8  2011/08/26 21:45:00  acg
+//  Andy Goodrich: fix internal event naming.
+//
+// Revision 1.7  2011/08/26 20:46:09  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+
+#ifndef SC_JOIN_H
+#define SC_JOIN_H
+
+#include "sysc/kernel/sc_process.h"
+#include "sysc/kernel/sc_wait.h"
+
+namespace sc_core {
+
+//==============================================================================
+// CLASS sc_join
+//
+// This class provides a way of waiting for a set of threads to complete their
+// execution. The threads whose completion is to be monitored are registered,
+// and upon their completion an event notification will occur.
+//==============================================================================
+class sc_join : public sc_process_monitor {
+    friend class sc_process_b;
+    friend class sc_process_handle;
+  public:
+    sc_join();
+    void add_process( sc_process_handle process_h );
+    inline int process_count();
+    virtual void signal(sc_thread_handle thread_p, int type);
+    inline void wait();
+    inline void wait_clocked();
+
+  protected: 
+    void add_process( sc_process_b* process_p );
+
+  protected:
+    sc_event m_join_event;  // Event to notify when all threads have reported.
+    int      m_threads_n;   // # of threads still need to wait for.
+};
+
+int sc_join::process_count() { return m_threads_n; }
+
+// suspend a thread that does not have a sensitivity list:
+
+inline void sc_join::wait() { ::sc_core::wait(m_join_event); }
+
+// suspend a thread that has a sensitivity list:
+
+inline void sc_join::wait_clocked()
+{
+    do { ::sc_core::wait(); } while (m_threads_n != 0);
+}
+
+#define SC_CJOIN \
+    }; \
+    sc_core::sc_join           join; \
+    for ( unsigned int i = 0; \
+        i < sizeof(forkees)/sizeof(sc_core::sc_process_handle); \
+        i++ ) \
+        join.add_process(forkees[i]); \
+    join.wait_clocked(); \
+}
+
+#define SC_FORK \
+{ \
+    sc_core::sc_process_handle forkees[] = {
+
+#define SC_JOIN \
+    }; \
+    sc_core::sc_join           join; \
+    for ( unsigned int i = 0; \
+        i < sizeof(forkees)/sizeof(sc_core::sc_process_handle); \
+        i++ ) \
+        join.add_process(forkees[i]); \
+    join.wait(); \
+}
+
+} // namespace sc_core
+
+// Revision 1.6  2011/08/24 22:05:50  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.5  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.4  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.3  2009/07/28 01:10:53  acg
+//  Andy Goodrich: updates for 2.3 release candidate.
+//
+// Revision 1.2  2008/05/22 17:06:25  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.5  2006/04/28 21:38:27  acg
+//  Andy Goodrich: fixed loop constraint that was using sizeof(sc_thread_handle)
+//  rather than sizeof(sc_process_handle).
+//
+// Revision 1.4  2006/01/13 18:44:29  acg
+// Added $Log to record CVS changes into the source.
+
+#endif // SC_JOIN_H
diff --git a/ext/systemc/src/sysc/kernel/sc_kernel_ids.h b/ext/systemc/src/sysc/kernel/sc_kernel_ids.h
new file mode 100644
index 000000000..32846df12
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_kernel_ids.h
@@ -0,0 +1,321 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_kernel_ids.h -- Report ids for the kernel code.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2002-01-17
+
+ CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_KERNEL_IDS_H
+#define SC_KERNEL_IDS_H
+
+
+#include "sysc/utils/sc_report.h"
+
+
+// ----------------------------------------------------------------------------
+//  Report ids (kernel)
+//
+//  Report ids in the range of 500-599.
+// ----------------------------------------------------------------------------
+
+#ifndef SC_DEFINE_MESSAGE
+#define SC_DEFINE_MESSAGE(id,unused1,unused2) \
+    namespace sc_core { extern const char id[]; }
+namespace sc_core {
+    extern const char SC_ID_REGISTER_ID_FAILED_[]; // in sc_report_handler.cpp
+}
+#endif
+
+SC_DEFINE_MESSAGE(SC_ID_NO_BOOL_RETURNED_            , 500, 
+	"operator does not return boolean")
+SC_DEFINE_MESSAGE(SC_ID_NO_INT_RETURNED_             , 501,
+	"operator does not return int")
+SC_DEFINE_MESSAGE(SC_ID_NO_SC_LOGIC_RETURNED_        , 502,
+	"operator does not return sc_logic")
+SC_DEFINE_MESSAGE(SC_ID_OPERAND_NOT_SC_LOGIC_        , 503,
+	"operand is not sc_logic")
+SC_DEFINE_MESSAGE(SC_ID_OPERAND_NOT_BOOL_            , 504,
+	"operand is not bool")
+SC_DEFINE_MESSAGE(SC_ID_INSTANCE_EXISTS_             , 505,
+	"object already exists")       
+SC_DEFINE_MESSAGE(SC_ID_ILLEGAL_CHARACTERS_          , 506,
+	"illegal characters" )
+SC_DEFINE_MESSAGE(SC_ID_VC6_PROCESS_HELPER_          , 507,
+	"internal error: sc_vc6_process_helper" )
+SC_DEFINE_MESSAGE(SC_ID_VC6_MAX_PROCESSES_EXCEEDED_  , 508,
+	"maximum number of processes per module exceeded (VC6)" )
+SC_DEFINE_MESSAGE(SC_ID_END_MODULE_NOT_CALLED_       , 509,
+	"module construction not properly completed: did "
+	"you forget to add a sc_module_name parameter to "
+	"your module constructor?" )
+SC_DEFINE_MESSAGE(SC_ID_HIER_NAME_INCORRECT_         , 510,
+	"hierarchical name as shown may be incorrect due to previous errors" )
+SC_DEFINE_MESSAGE(SC_ID_SET_STACK_SIZE_              , 511,
+	"set_stack_size() is only allowed for SC_THREADs and SC_CTHREADs" )
+SC_DEFINE_MESSAGE(SC_ID_SC_MODULE_NAME_USE_          , 512,
+	"incorrect use of sc_module_name" )
+SC_DEFINE_MESSAGE(SC_ID_SC_MODULE_NAME_REQUIRED_     , 513,
+	"an sc_module_name parameter for your constructor is required" )
+SC_DEFINE_MESSAGE(SC_ID_SET_TIME_RESOLUTION_         , 514,
+	"set time resolution failed" )
+SC_DEFINE_MESSAGE(SC_ID_SET_DEFAULT_TIME_UNIT_       , 515,
+	"set default time unit failed" )
+SC_DEFINE_MESSAGE(SC_ID_DEFAULT_TIME_UNIT_CHANGED_   , 516,
+	"default time unit changed to time resolution" )
+SC_DEFINE_MESSAGE(SC_ID_INCONSISTENT_API_CONFIG_     , 517,
+	"inconsistent library configuration detected" )
+// available message number 518
+SC_DEFINE_MESSAGE(SC_ID_WAIT_NOT_ALLOWED_            , 519,
+	"wait() is only allowed in SC_THREADs and SC_CTHREADs" )
+SC_DEFINE_MESSAGE(SC_ID_NEXT_TRIGGER_NOT_ALLOWED_    , 520,
+	"next_trigger() is only allowed in SC_METHODs" )
+SC_DEFINE_MESSAGE(SC_ID_IMMEDIATE_NOTIFICATION_      , 521,
+	"immediate notification is not allowed during the update phase" )
+SC_DEFINE_MESSAGE(SC_ID_HALT_NOT_ALLOWED_            , 522,
+	"halt() is only allowed in SC_CTHREADs" )
+SC_DEFINE_MESSAGE(SC_ID_WATCHING_NOT_ALLOWED_        , 523,
+	"watching() has been deprecated, use reset_signal_is()" )
+SC_DEFINE_MESSAGE(SC_ID_DONT_INITIALIZE_             , 524,
+	"dont_initialize() has no effect for SC_CTHREADs" )
+SC_DEFINE_MESSAGE(SC_ID_WAIT_N_INVALID_              , 525,
+	"wait(n) is only valid for n > 0" )
+SC_DEFINE_MESSAGE(SC_ID_MAKE_SENSITIVE_              , 526,
+	"make sensitive failed" )
+SC_DEFINE_MESSAGE(SC_ID_MAKE_SENSITIVE_POS_          , 527,
+	"make sensitive pos failed" )
+SC_DEFINE_MESSAGE(SC_ID_MAKE_SENSITIVE_NEG_          , 528,
+	"make sensitive neg failed" )
+SC_DEFINE_MESSAGE(SC_ID_INSERT_MODULE_               , 529,
+	"insert module failed" )
+SC_DEFINE_MESSAGE(SC_ID_REMOVE_MODULE_               , 530,
+	"remove module failed" )
+SC_DEFINE_MESSAGE(SC_ID_NOTIFY_DELAYED_              , 531,
+	"notify_delayed() cannot be called on events "
+	"that have pending notifications" )
+SC_DEFINE_MESSAGE(SC_ID_GEN_UNIQUE_NAME_             , 532,
+	"cannot generate unique name from null string" )
+SC_DEFINE_MESSAGE(SC_ID_MODULE_NAME_STACK_EMPTY_     , 533,
+	"module name stack is empty: did you forget to "
+	"add a sc_module_name parameter to your module "
+	"constructor?" )
+// available message number 534
+// available message number 535
+SC_DEFINE_MESSAGE( SC_ID_IMMEDIATE_SELF_NOTIFICATION_, 536,
+         "immediate self-notification ignored as of IEEE 1666-2011" )
+SC_DEFINE_MESSAGE( SC_ID_WAIT_DURING_UNWINDING_      , 537,
+         "wait() not allowed during unwinding" )
+SC_DEFINE_MESSAGE(SC_ID_CYCLE_MISSES_EVENTS_         , 538,
+         "the simulation contains timed-events but they are "
+         "ignored by sc_cycle() ==> the simulation will be "
+	 "incorrect" )
+SC_DEFINE_MESSAGE( SC_ID_RETHROW_UNWINDING_          , 539,
+         "sc_unwind_exception not re-thrown during kill/reset" )
+SC_DEFINE_MESSAGE( SC_ID_PROCESS_ALREADY_UNWINDING_  , 540,
+         "kill/reset ignored during unwinding" )
+SC_DEFINE_MESSAGE(SC_ID_MODULE_METHOD_AFTER_START_   , 541,
+	"call to SC_METHOD in sc_module while simulation running" )
+SC_DEFINE_MESSAGE(SC_ID_MODULE_THREAD_AFTER_START_   , 542,
+	"call to SC_THREAD in sc_module while simulation running" )
+SC_DEFINE_MESSAGE(SC_ID_MODULE_CTHREAD_AFTER_START_   , 543,
+	"call to SC_CTHREAD in sc_module while simulation running" )
+SC_DEFINE_MESSAGE(SC_ID_SIMULATION_TIME_OVERFLOW_   , 544,
+	"simulation time value overflow, simulation aborted" )
+SC_DEFINE_MESSAGE(SC_ID_SIMULATION_STOP_CALLED_TWICE_ , 545,
+	"sc_stop has already been called" ) 
+SC_DEFINE_MESSAGE(SC_ID_SIMULATION_START_AFTER_STOP_  , 546,
+	"sc_start called after sc_stop has been called" ) 
+SC_DEFINE_MESSAGE(SC_ID_STOP_MODE_AFTER_START_        , 547,
+	"attempt to set sc_stop mode  after start will be ignored" ) 
+SC_DEFINE_MESSAGE( SC_ID_SIMULATION_START_AFTER_ERROR_, 548,
+       "attempt to restart simulation after error" )
+SC_DEFINE_MESSAGE( SC_ID_SIMULATION_UNCAUGHT_EXCEPTION_, 549,
+       "uncaught exception" )
+SC_DEFINE_MESSAGE(SC_ID_PHASE_CALLBACKS_UNSUPPORTED_   , 550,
+       "simulation phase callbacks not enabled")
+SC_DEFINE_MESSAGE(SC_ID_PHASE_CALLBACK_NOT_IMPLEMENTED_, 551,
+       "empty simulation phase callback called" )
+SC_DEFINE_MESSAGE(SC_ID_PHASE_CALLBACK_REGISTER_,        552,
+       "register simulation phase callback" )
+SC_DEFINE_MESSAGE(SC_ID_PHASE_CALLBACK_FORBIDDEN_,       553,
+       "forbidden action in simulation phase callback" )
+// available message number 554
+// available message number 555
+SC_DEFINE_MESSAGE(SC_ID_THROW_IT_IGNORED_  , 556,
+        "throw_it on method/non-running process is being ignored " )
+SC_DEFINE_MESSAGE(SC_ID_NOT_EXPECTING_DYNAMIC_EVENT_NOTIFY_ , 557,
+	"dynamic event notification encountered when sensitivity is static" )
+SC_DEFINE_MESSAGE(SC_ID_DISABLE_WILL_ORPHAN_PROCESS_     , 558,
+       "disable() or dont_initialize() called on process with no static sensitivity, it will be orphaned" )
+SC_DEFINE_MESSAGE(SC_ID_PROCESS_CONTROL_CORNER_CASE_     , 559,
+	"Undefined process control interaction" ) 
+SC_DEFINE_MESSAGE(SC_ID_METHOD_TERMINATION_EVENT_        , 560,
+	"Attempt to get terminated event for a method process" ) 
+SC_DEFINE_MESSAGE(SC_ID_JOIN_ON_METHOD_HANDLE_        , 561,
+	"Attempt to register method process with sc_join object" ) 
+SC_DEFINE_MESSAGE(SC_ID_NO_PROCESS_SEMANTICS_         , 563,
+	"Attempt to invoke process with no semantics() method" )
+SC_DEFINE_MESSAGE(SC_ID_EVENT_ON_NULL_PROCESS_         , 564,
+	"Attempt to get an event for non-existent process" )
+// available message number 565
+SC_DEFINE_MESSAGE(SC_ID_UNKNOWN_PROCESS_TYPE_,       566,
+	"Unknown process type" )
+// available message number 567
+SC_DEFINE_MESSAGE(SC_ID_NEGATIVE_SIMULATION_TIME_, 568,
+        "negative simulation interval specified in sc_start call" )
+SC_DEFINE_MESSAGE(SC_ID_BAD_SC_MODULE_CONSTRUCTOR_  , 569,
+        "sc_module(const char*), sc_module(const std::string&) "
+        "have been deprecated, use sc_module(const sc_module_name&)" )
+SC_DEFINE_MESSAGE(SC_ID_EMPTY_PROCESS_HANDLE_  , 570,
+        "attempt to use an empty process handle ignored" )
+SC_DEFINE_MESSAGE(SC_ID_NO_SC_START_ACTIVITY_  , 571,
+        "no activity or clock movement for sc_start() invocation" )
+SC_DEFINE_MESSAGE(SC_ID_KILL_PROCESS_WHILE_UNITIALIZED_  , 572,
+        "a process may not be killed before it is initialized" )
+SC_DEFINE_MESSAGE(SC_ID_RESET_PROCESS_WHILE_NOT_RUNNING_  , 573,
+        "a process may not be asynchronously reset while the simulation is not running" )
+SC_DEFINE_MESSAGE(SC_ID_THROW_IT_WHILE_NOT_RUNNING_  , 574,
+        "throw_it not allowed unless simulation is running " )
+
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+    
+ *****************************************************************************/
+
+// $Log: sc_kernel_ids.h,v $
+// Revision 1.25  2011/08/26 22:06:34  acg
+//  Torsten Maehne: formating fix.
+//
+// Revision 1.24  2011/08/07 19:08:04  acg
+//  Andy Goodrich: moved logs to end of file so line number synching works
+//  better between versions.
+//
+// Revision 1.23  2011/07/24 11:15:47  acg
+//  Philipp A. Hartmann: Improvements to error/warning messages related to
+//  process control.
+//
+// Revision 1.22  2011/05/09 04:07:48  acg
+//  Philipp A. Hartmann:
+//    (1) Restore hierarchy in all phase callbacks.
+//    (2) Ensure calls to before_end_of_elaboration.
+//
+// Revision 1.21  2011/04/19 19:15:41  acg
+//  Andy Goodrich: fix so warning message is always issued for a throw_it()
+//  on a method process.
+//
+// Revision 1.20  2011/04/19 15:04:27  acg
+//  Philipp A. Hartmann: clean up SC_ID messages.
+//
+// Revision 1.19  2011/04/19 02:39:09  acg
+//  Philipp A. Hartmann: added checks for additional throws during stack unwinds.
+//
+// Revision 1.18  2011/04/05 06:23:45  acg
+//  Andy Goodrich: comments for throws while the simulator is not running.
+//
+// Revision 1.17  2011/04/01 22:30:39  acg
+//  Andy Goodrich: change hard assertion to warning for trigger_dynamic()
+//  getting called when there is only STATIC sensitivity. This can result
+//  because of sc_process_handle::throw_it().
+//
+// Revision 1.16  2011/03/28 13:02:51  acg
+//  Andy Goodrich: Changes for disable() interactions.
+//
+// Revision 1.15  2011/03/07 17:34:21  acg
+//  Andy Goodrich: changed process control corner case message. Added more
+//  place holders for unused message numbers.
+//
+// Revision 1.14  2011/03/06 19:57:11  acg
+//  Andy Goodrich: refinements for the illegal suspend - synchronous reset
+//  interaction.
+//
+// Revision 1.13  2011/03/06 15:56:29  acg
+//  Andy Goodrich: added process control corner case error message, remove
+//  unused messages.
+//
+// Revision 1.12  2011/03/05 19:44:20  acg
+//  Andy Goodrich: changes for object and event naming and structures.
+//
+// Revision 1.11  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.10  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.9  2011/02/13 21:29:16  acg
+//  Andy Goodrich: added error messages for throws that occur before
+//  simulator intialization.
+//
+// Revision 1.8  2011/02/11 13:25:24  acg
+//  Andy Goodrich: Philipp A. Hartmann's changes:
+//    (1) Removal of SC_CTHREAD method overloads.
+//    (2) New exception processing code.
+//
+// Revision 1.7  2011/02/07 19:17:20  acg
+//  Andy Goodrich: changes for IEEE 1666 compatibility.
+//
+// Revision 1.6  2011/01/19 23:21:50  acg
+//  Andy Goodrich: changes for IEEE 1666 2011
+//
+// Revision 1.5  2010/07/30 05:21:22  acg
+//  Andy Goodrich: release 2.3 fixes.
+//
+// Revision 1.4  2009/02/28 00:26:58  acg
+//  Andy Goodrich: changed boost name space to sc_boost to allow use with
+//  full boost library applications.
+//
+// Revision 1.3  2008/11/17 15:57:15  acg
+//  Andy Goodrich: added deprecation message for sc_module(const char*)
+//
+// Revision 1.2  2008/05/22 17:06:25  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.7  2006/08/29 23:37:13  acg
+//  Andy Goodrich: Added check for negative time.
+//
+// Revision 1.6  2006/04/20 17:08:16  acg
+//  Andy Goodrich: 3.0 style process changes.
+//
+// Revision 1.5  2006/01/25 00:31:19  acg
+//  Andy Goodrich: Changed over to use a standard message id of
+//  SC_ID_IEEE_1666_DEPRECATION for all deprecation messages.
+//
+// Revision 1.4  2006/01/24 20:49:04  acg
+// Andy Goodrich: changes to remove the use of deprecated features within the
+// simulator, and to issue warning messages when deprecated features are used.
+//
+// Revision 1.3  2006/01/13 18:44:29  acg
+// Added $Log to record CVS changes into the source.
+//
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_macros.h b/ext/systemc/src/sysc/kernel/sc_macros.h
new file mode 100644
index 000000000..baa6d6e3b
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_macros.h
@@ -0,0 +1,136 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_macros.h -- Miscellaneous definitions that are needed by the headers.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#ifndef SC_MACROS_H
+#define SC_MACROS_H
+
+
+namespace sc_dt {
+
+template <class T>
+inline
+const T
+sc_min( const T& a, const T& b )
+{
+    return ( ( a <= b ) ? a : b );
+}
+
+template <class T>
+inline
+const T
+sc_max( const T& a, const T& b )
+{
+    return ( ( a >= b ) ? a : b );
+}
+
+template <class T>
+inline
+const T
+sc_abs( const T& a )
+{
+    // return ( a >= 0 ? a : -a );
+    // the code below is functionaly the same as the code above; the
+    // difference is that the code below works for all arithmetic
+    // SystemC datatypes.
+    T z( a );
+    z = 0;
+    if( a >= z ) {
+	return a;
+    } else {
+	T c( a );
+	c = -a;
+	return c;
+    }
+}
+
+} // namespace sc_dt 
+
+namespace sc_core {
+
+// token stringification
+
+#define SC_STRINGIFY_HELPER_( Arg ) \
+  SC_STRINGIFY_HELPER_DEFERRED_( Arg )
+#define SC_STRINGIFY_HELPER_DEFERRED_( Arg ) \
+  SC_STRINGIFY_HELPER_MORE_DEFERRED_( Arg )
+#define SC_STRINGIFY_HELPER_MORE_DEFERRED_( Arg ) \
+  #Arg 
+
+
+// token concatenation
+
+#define SC_CONCAT_HELPER_( a, b ) \
+  SC_CONCAT_HELPER_DEFERRED_( a, b )
+#define SC_CONCAT_HELPER_DEFERRED_( a, b ) \
+  SC_CONCAT_HELPER_MORE_DEFERRED_( a,b )
+#define SC_CONCAT_HELPER_MORE_DEFERRED_( a, b ) \
+  a ## b
+#define SC_CONCAT_UNDERSCORE_( a, b ) \
+  SC_CONCAT_HELPER_( a, SC_CONCAT_HELPER_( _, b ) )
+
+/*
+ *  These help debugging --
+ *  -- user can find out where each process is stopped at.
+ */
+
+#define WAIT()                                                                \
+    ::sc_core::sc_set_location( __FILE__, __LINE__ );                         \
+    ::sc_core::wait()
+
+#define WAITN(n)                                                              \
+    ::sc_core::sc_set_location( __FILE__, __LINE__ );                         \
+    ::sc_core::wait(n)
+
+#define WAIT_UNTIL(expr)                                                      \
+    ::sc_core::sc_set_location( __FILE__, __LINE__ );                         \
+    do { ::sc_core::wait(); } while( !(expr) )
+
+} // namespace sc_core
+
+// $Log: sc_macros.h,v $
+// Revision 1.5  2011/08/26 20:46:09  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.4  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.3  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.2  2008/05/22 17:06:25  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:44:29  acg
+// Added $Log to record CVS changes into the source.
+
+#endif
diff --git a/ext/systemc/src/sysc/kernel/sc_main.cpp b/ext/systemc/src/sysc/kernel/sc_main.cpp
new file mode 100644
index 000000000..a5f780d70
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_main.cpp
@@ -0,0 +1,58 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_main.cpp - Wrapper around user's toplevel routine `sc_main'.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+ CHANGE LOG APPEARS AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#include "sysc/kernel/sc_cmnhdr.h"
+#include "sysc/kernel/sc_externs.h"
+
+int
+main( int argc, char* argv[] )
+{
+	return sc_core::sc_elab_and_sim( argc, argv );
+}
+
+// $Log: sc_main.cpp,v $
+// Revision 1.5  2011/08/26 20:46:09  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.4  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.3  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.2  2008/05/22 17:06:25  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:44:29  acg
+// Added $Log to record CVS changes into the source.
+//
diff --git a/ext/systemc/src/sysc/kernel/sc_main_main.cpp b/ext/systemc/src/sysc/kernel/sc_main_main.cpp
new file mode 100644
index 000000000..1cdf1eb49
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_main_main.cpp
@@ -0,0 +1,167 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_main_main.cpp - Wrapper around user's toplevel routine `sc_main'.
+
+  Original Author: Andy Goodrich, Forte Design Systems
+
+ CHANGE LOG APPEARS AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#include "sysc/kernel/sc_cmnhdr.h"
+#include "sysc/kernel/sc_externs.h"
+#include "sysc/kernel/sc_except.h"
+#include "sysc/utils/sc_iostream.h"
+#include "sysc/utils/sc_report.h"
+#include "sysc/utils/sc_report_handler.h"
+#include "sysc/utils/sc_utils_ids.h"
+#include <vector>
+
+namespace sc_core {
+
+extern void pln();
+
+static int    argc_copy;	// Copy of argc value passed to sc_elab_and_sim.
+static char** argv_copy;	// Copy of argv value passed to sc_elab_and_sim.
+
+static
+inline
+void
+message_function( const char* s )
+{
+    ::std::cout << "\n" << s << ::std::endl;
+}
+
+bool sc_in_action = false;
+
+int sc_argc() 
+{
+    return argc_copy;
+}
+
+const char* const* sc_argv() 
+{
+    return argv_copy;
+}
+
+
+int
+sc_elab_and_sim( int argc, char* argv[] )
+{
+    int status = 1;
+    argc_copy = argc;
+    argv_copy = argv;
+    std::vector<char*> argv_call;
+    for ( int i = 0; i < argc; i++ ) 
+        argv_call.push_back(argv[i]);
+
+    try
+    {
+        pln();
+
+        // Perform initialization here
+        sc_in_action = true;
+
+        status = sc_main( argc, &argv_call[0] );
+
+        // Perform cleanup here
+        sc_in_action = false;
+    }
+    catch( const sc_report& x )
+    {
+	message_function( x.what() );
+    }
+    catch( ... )
+    {
+        // translate other escaping exceptions
+        sc_report*  err_p = sc_handle_exception();
+        if( err_p ) message_function( err_p->what() );
+        delete err_p;
+    }
+
+    // IF DEPRECATION WARNINGS WERE ISSUED TELL THE USER HOW TO TURN THEM OFF 
+
+    if ( sc_report_handler::get_count( SC_ID_IEEE_1666_DEPRECATION_ ) > 0 )
+    {
+        std::stringstream ss;
+
+#       define MSGNL  "\n             "
+#       define CODENL "\n  "
+
+        ss <<
+          "You can turn off warnings about" MSGNL
+          "IEEE 1666 deprecated features by placing this method call" MSGNL
+          "as the first statement in your sc_main() function:\n" CODENL
+          "sc_core::sc_report_handler::set_actions( "
+          "\"" << SC_ID_IEEE_1666_DEPRECATION_ << "\"," CODENL
+          "                                         " /* indent param */
+          "sc_core::SC_DO_NOTHING );"
+          << std::endl;
+
+        SC_REPORT_INFO( SC_ID_IEEE_1666_DEPRECATION_, ss.str().c_str() );
+    }
+
+    return status;
+}
+
+} // namespace sc_core
+
+// $Log: sc_main_main.cpp,v $
+// Revision 1.9  2011/08/26 20:46:10  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.8  2011/05/09 04:07:48  acg
+//  Philipp A. Hartmann:
+//    (1) Restore hierarchy in all phase callbacks.
+//    (2) Ensure calls to before_end_of_elaboration.
+//
+// Revision 1.7  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.6  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.5  2010/03/15 18:29:25  acg
+//  Andy Goodrich: Changed the default stack size to 128K from 64K.
+//
+// Revision 1.4  2009/10/14 19:06:48  acg
+//  Andy Goodrich: changed the way the "copy" of argv is handled. It is
+//  now passed to sc_main, and the original is referenced via argv_copy.
+//
+// Revision 1.3  2008/05/22 17:06:25  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.2  2008/04/11 20:41:28  acg
+//  Andy Goodrich: changed the return value in sc_elab_and_sim() to be 1
+//  when an exception occurs in sc_main() rather than 0.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.4  2006/01/25 00:31:19  acg
+//  Andy Goodrich: Changed over to use a standard message id of
+//  SC_ID_IEEE_1666_DEPRECATION for all deprecation messages.
+//
+// Revision 1.3  2006/01/13 18:44:29  acg
+// Added $Log to record CVS changes into the source.
+//
diff --git a/ext/systemc/src/sysc/kernel/sc_method_process.cpp b/ext/systemc/src/sysc/kernel/sc_method_process.cpp
new file mode 100644
index 000000000..994e495ad
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_method_process.cpp
@@ -0,0 +1,1023 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_method_process.cpp -- Method process implementation
+
+  Original Author: Andy Goodrich, Forte Design Systems, 4 August 2005
+               
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+#include "sysc/kernel/sc_method_process.h"
+#include "sysc/kernel/sc_simcontext_int.h"
+#include "sysc/kernel/sc_module.h"
+#include "sysc/kernel/sc_spawn_options.h"
+
+// DEBUGGING MACROS:
+//
+// DEBUG_MSG(NAME,P,MSG)
+//     MSG  = message to print
+//     NAME = name that must match the process for the message to print, or
+//            null if the message should be printed unconditionally.
+//     P    = pointer to process message is for, or NULL in which case the
+//            message will not print.
+#if 0
+#   define DEBUG_NAME ""
+#   define DEBUG_MSG(NAME,P,MSG) \
+    { \
+        if ( P && ( (strlen(NAME)==0) || !strcmp(NAME,P->name())) ) \
+          std::cout << "**** " << sc_time_stamp() << " ("  \
+	            << sc_get_current_process_name() << "): " << MSG \
+		    << " - " << P->name() << std::endl; \
+    }
+#else
+#   define DEBUG_MSG(NAME,P,MSG) 
+#endif
+
+namespace sc_core {
+
+// +----------------------------------------------------------------------------
+// |"sc_method_process::check_for_throws"
+// | 
+// | This method checks to see if this method process should throw an exception
+// | or not. It is called from sc_simcontext::preempt_with() to see if the
+// | thread that was executed during the preemption did a kill or other 
+// | manipulation on this object instance that requires it to throw an 
+// | exception.
+// +----------------------------------------------------------------------------
+void sc_method_process::check_for_throws()
+{
+    if ( !m_unwinding )
+    {
+	switch( m_throw_status )
+	{
+	  case THROW_ASYNC_RESET:
+	    simcontext()->preempt_with(this);
+	    break;
+          case THROW_KILL:
+	    throw sc_unwind_exception( this, false );
+	  default:
+	    break;
+	}
+    }
+}
+
+//------------------------------------------------------------------------------
+//"sc_method_process::clear_trigger"
+//
+// This method clears any pending trigger for this object instance.
+//------------------------------------------------------------------------------
+void sc_method_process::clear_trigger()
+{
+    switch( m_trigger_type ) {
+      case STATIC: 
+        return;
+      case EVENT: 
+        m_event_p->remove_dynamic( this );
+        m_event_p = 0;
+        break;
+      case OR_LIST: 
+        m_event_list_p->remove_dynamic( this, 0 );
+        m_event_list_p->auto_delete();
+        m_event_list_p = 0;
+        break;
+      case AND_LIST: 
+        m_event_list_p->remove_dynamic( this, 0 );
+        m_event_list_p->auto_delete();
+        m_event_list_p = 0;
+        m_event_count = 0;
+        break;
+      case TIMEOUT: 
+        m_timeout_event_p->cancel();
+        m_timeout_event_p->reset();
+        break;
+      case EVENT_TIMEOUT: 
+        m_timeout_event_p->cancel();
+        m_timeout_event_p->reset();
+        m_event_p->remove_dynamic( this );
+        m_event_p = 0;
+        break;
+      case OR_LIST_TIMEOUT: 
+        m_timeout_event_p->cancel();
+        m_timeout_event_p->reset();
+        m_event_list_p->remove_dynamic( this, 0 );
+        m_event_list_p->auto_delete();
+        m_event_list_p = 0;
+      break;
+      case AND_LIST_TIMEOUT: 
+        m_timeout_event_p->cancel();
+        m_timeout_event_p->reset();
+        m_event_list_p->remove_dynamic( this, 0 );
+        m_event_list_p->auto_delete();
+        m_event_list_p = 0;
+        m_event_count = 0;
+        break;
+    }
+    m_trigger_type = STATIC;
+}
+
+//------------------------------------------------------------------------------
+//"sc_method_process::disable_process"
+//
+// This virtual method disables this process and its children if requested to.
+//     descendants = indicator of whether this process' children should also
+//                   be suspended
+//------------------------------------------------------------------------------
+void sc_method_process::disable_process(
+    sc_descendant_inclusion_info descendants )
+{     
+
+    // IF NEEDED PROPOGATE THE SUSPEND REQUEST THROUGH OUR DESCENDANTS:
+
+    if ( descendants == SC_INCLUDE_DESCENDANTS )
+    {
+        const std::vector<sc_object*>& children = get_child_objects();
+        int                            child_n  = children.size();
+
+        for ( int child_i = 0; child_i < child_n; child_i++ )
+        {
+            sc_process_b* child_p = DCAST<sc_process_b*>(children[child_i]);
+            if ( child_p ) child_p->disable_process(descendants);
+        }
+    }
+
+    // DON'T ALLOW CORNER CASE BY DEFAULT:
+
+    if ( !sc_allow_process_control_corners )
+    {
+	switch( m_trigger_type )
+	{ 
+	  case AND_LIST_TIMEOUT:
+	  case EVENT_TIMEOUT: 
+	  case OR_LIST_TIMEOUT:
+	  case TIMEOUT:
+	    report_error( SC_ID_PROCESS_CONTROL_CORNER_CASE_,
+	                  "attempt to disable a method with timeout wait" );
+	    break;
+	  default:
+	    break;
+	}
+    }
+
+    // DISABLE OUR OBJECT INSTANCE:
+
+    m_state = m_state | ps_bit_disabled;
+
+    // IF THIS CALL IS BEFORE THE SIMULATION DON'T RUN THE METHOD:
+
+    if ( !sc_is_running() )
+    {
+        sc_get_curr_simcontext()->remove_runnable_method(this);
+    }
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_method_process::enable_process"
+//
+// This method enables the execution of this process, and if requested, its
+// descendants. If the process was suspended and has a resumption pending it 
+// will be dispatched in the next delta cycle. Otherwise the state will be
+// adjusted to indicate it is no longer suspended, but no immediate execution
+// will occur.
+//------------------------------------------------------------------------------
+void sc_method_process::enable_process(
+    sc_descendant_inclusion_info descendants )
+{
+
+    // IF NEEDED PROPOGATE THE RESUME REQUEST THROUGH OUR DESCENDANTS:
+
+    if ( descendants == SC_INCLUDE_DESCENDANTS )
+    {
+        const std::vector<sc_object*>& children = get_child_objects();
+        int                            child_n  = children.size();
+
+        for ( int child_i = 0; child_i < child_n; child_i++ )
+        {
+            sc_process_b* child_p = DCAST<sc_process_b*>(children[child_i]);
+            if ( child_p ) child_p->enable_process(descendants);
+        }
+    }
+
+    // ENABLE THIS OBJECT INSTANCE:
+    //
+    // If it was disabled and ready to run then put it on the run queue.
+
+    m_state = m_state & ~ps_bit_disabled;
+    if ( m_state == ps_bit_ready_to_run )
+    {
+        m_state = ps_normal;
+	if ( next_runnable() == 0 )
+	    simcontext()->push_runnable_method(this);
+    }
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_method_process::kill_process"
+//
+// This method removes throws a kill for this object instance. It calls the
+// sc_process_b::kill_process() method to perform low level clean up. 
+//------------------------------------------------------------------------------
+void sc_method_process::kill_process(sc_descendant_inclusion_info descendants)
+{
+
+    // IF THE SIMULATION HAS NOT BEEN INITIALIZED YET THAT IS AN ERROR:
+
+    if ( sc_get_status() == SC_ELABORATION )
+    {
+        report_error( SC_ID_KILL_PROCESS_WHILE_UNITIALIZED_ );
+    }
+
+    // IF NEEDED, PROPOGATE THE KILL REQUEST THROUGH OUR DESCENDANTS:
+
+    if ( descendants == SC_INCLUDE_DESCENDANTS )
+    {
+        const std::vector<sc_object*> children = get_child_objects();
+        int                           child_n  = children.size();
+
+        for ( int child_i = 0; child_i < child_n; child_i++ )
+        {
+            sc_process_b* child_p = DCAST<sc_process_b*>(children[child_i]);
+            if ( child_p ) child_p->kill_process(descendants);
+        }
+    }
+
+    // IF THE PROCESS IS CURRENTLY UNWINDING OR IS ALREADY A ZOMBIE
+    // IGNORE THE KILL:
+
+    if ( m_unwinding )
+    {
+        SC_REPORT_WARNING( SC_ID_PROCESS_ALREADY_UNWINDING_, name() );
+        return;
+    }
+
+    if ( m_state & ps_bit_zombie )
+        return;
+
+
+    // REMOVE OUR PROCESS FROM EVENTS, ETC., AND IF ITS THE ACTIVE PROCESS
+    // THROW ITS KILL. 
+    // 
+    // Note we set the throw status to kill regardless if we throw or not.
+    // That lets check_for_throws stumble across it if we were in the call
+    // chain when the kill call occurred.
+
+    if ( next_runnable() != 0 )
+        simcontext()->remove_runnable_method( this );
+    disconnect_process();
+
+    m_throw_status = THROW_KILL; 
+    if ( sc_get_current_process_b() == this )
+    {
+        throw sc_unwind_exception( this, false );
+    }
+}
+
+//------------------------------------------------------------------------------
+//"sc_method_process::sc_method_process"
+//
+// This is the object instance constructor for this class.
+//------------------------------------------------------------------------------
+sc_method_process::sc_method_process( const char* name_p, 
+    bool free_host, SC_ENTRY_FUNC method_p, 
+    sc_process_host* host_p, const sc_spawn_options* opt_p 
+):
+    sc_process_b(
+        name_p ? name_p : sc_gen_unique_name("method_p"), 
+        false, free_host, method_p, host_p, opt_p),
+	m_cor(0), m_stack_size(0), m_monitor_q()
+{
+
+    // CHECK IF THIS IS AN sc_module-BASED PROCESS AND SIMUALTION HAS STARTED:
+
+    if ( DCAST<sc_module*>(host_p) != 0 && sc_is_running() )
+    {
+        report_error( SC_ID_MODULE_METHOD_AFTER_START_, "" );
+    }
+
+    // INITIALIZE VALUES:
+    //
+    // If there are spawn options use them.
+
+    m_process_kind = SC_METHOD_PROC_;
+    if (opt_p) {
+        m_dont_init = opt_p->m_dont_initialize;
+
+        // traverse event sensitivity list
+        for (unsigned int i = 0; i < opt_p->m_sensitive_events.size(); i++) {
+            sc_sensitive::make_static_sensitivity(
+                this, *opt_p->m_sensitive_events[i]);
+        }
+
+        // traverse port base sensitivity list
+        for ( unsigned int i = 0; i < opt_p->m_sensitive_port_bases.size(); i++)
+        {
+            sc_sensitive::make_static_sensitivity(
+                this, *opt_p->m_sensitive_port_bases[i]);
+        }
+
+        // traverse interface sensitivity list
+        for ( unsigned int i = 0; i < opt_p->m_sensitive_interfaces.size(); i++)
+        {
+            sc_sensitive::make_static_sensitivity(
+                this, *opt_p->m_sensitive_interfaces[i]);
+        }
+
+        // traverse event finder sensitivity list
+        for ( unsigned int i = 0; i < opt_p->m_sensitive_event_finders.size();
+            i++)
+        {
+            sc_sensitive::make_static_sensitivity(
+                this, *opt_p->m_sensitive_event_finders[i]);
+        }
+
+	// process any reset signal specification:
+
+	opt_p->specify_resets();
+    }
+
+    else
+    {
+        m_dont_init = false;
+    }
+}
+
+//------------------------------------------------------------------------------
+//"sc_method_process::sc_method_process"
+//
+// This is the object instance destructor for this class.
+//------------------------------------------------------------------------------
+sc_method_process::~sc_method_process()
+{
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_method_process::suspend_process"
+//
+// This virtual method suspends this process and its children if requested to.
+//     descendants = indicator of whether this process' children should also
+//                   be suspended
+//------------------------------------------------------------------------------
+void sc_method_process::suspend_process(
+    sc_descendant_inclusion_info descendants )
+{     
+
+    // IF NEEDED PROPOGATE THE SUSPEND REQUEST THROUGH OUR DESCENDANTS:
+
+    if ( descendants == SC_INCLUDE_DESCENDANTS )
+    {
+        const std::vector<sc_object*>& children = get_child_objects();
+        int                            child_n  = children.size();
+
+        for ( int child_i = 0; child_i < child_n; child_i++ )
+        {
+            sc_process_b* child_p = DCAST<sc_process_b*>(children[child_i]);
+            if ( child_p ) child_p->suspend_process(descendants);
+        }
+    }
+
+    // CORNER CASE CHECKS, THE FOLLOWING ARE ERRORS:
+    //   (a) if this method has a reset_signal_is specification 
+    //   (b) if this method is in synchronous reset
+
+    if ( !sc_allow_process_control_corners && m_has_reset_signal )
+    {
+	report_error(SC_ID_PROCESS_CONTROL_CORNER_CASE_,
+		     "attempt to suspend a method that has a reset signal");
+    }
+    else if ( !sc_allow_process_control_corners && m_sticky_reset )
+    {
+	report_error(SC_ID_PROCESS_CONTROL_CORNER_CASE_,
+		     "attempt to suspend a method in synchronous reset");
+    }
+
+    // SUSPEND OUR OBJECT INSTANCE:
+    //
+    // (1) If we are on the runnable queue then set suspended and ready_to_run,
+    //     and remove ourselves from the run queue.
+    // (2) If this is a self-suspension then a resume should cause immediate
+    //     scheduling of the process.
+
+    m_state = m_state | ps_bit_suspended;
+    if ( next_runnable() != 0 ) 
+    {
+	m_state = m_state | ps_bit_ready_to_run;
+	simcontext()->remove_runnable_method( this );
+    }
+    if ( sc_get_current_process_b() == DCAST<sc_process_b*>(this)  )
+    {
+	m_state = m_state | ps_bit_ready_to_run;
+    }
+}
+
+//------------------------------------------------------------------------------
+//"sc_method_process::resume_process"
+//
+// This method resumes the execution of this process, and if requested, its
+// descendants. If the process was suspended and has a resumption pending it 
+// will be dispatched in the next delta cycle. Otherwise the state will be
+// adjusted to indicate it is no longer suspended, but no immediate execution
+// will occur.
+//------------------------------------------------------------------------------
+void sc_method_process::resume_process(
+    sc_descendant_inclusion_info descendants )
+{
+
+    // IF NEEDED PROPOGATE THE RESUME REQUEST THROUGH OUR DESCENDANTS:
+
+    if ( descendants == SC_INCLUDE_DESCENDANTS )
+    {
+        const std::vector<sc_object*>& children = get_child_objects();
+        int                            child_n  = children.size();
+
+        for ( int child_i = 0; child_i < child_n; child_i++ )
+        {
+            sc_process_b* child_p = DCAST<sc_process_b*>(children[child_i]);
+            if ( child_p ) child_p->resume_process(descendants);
+        }
+    }
+
+
+    // BY DEFAULT THE CORNER CASE IS AN ERROR:
+
+    if ( !sc_allow_process_control_corners && (m_state & ps_bit_disabled) &&
+         (m_state & ps_bit_suspended) )
+    {
+	m_state = m_state & ~ps_bit_suspended;
+        report_error( SC_ID_PROCESS_CONTROL_CORNER_CASE_, 
+	              "call to resume() on a disabled suspended method");
+    }
+
+    // CLEAR THE SUSPENDED BIT:
+
+    m_state = m_state & ~ps_bit_suspended;
+
+    // RESUME OBJECT INSTANCE:
+    //
+    // If this is not a self-resume and the method is ready to run then
+    // put it on the runnable queue.
+
+    if ( m_state & ps_bit_ready_to_run )
+    {
+	m_state = m_state & ~ps_bit_ready_to_run;
+	if ( next_runnable() == 0 && 
+	   ( sc_get_current_process_b() != DCAST<sc_process_b*>(this) ) )
+        {
+	    simcontext()->push_runnable_method(this);
+	    remove_dynamic_events();  
+	}
+    }
+}
+
+//------------------------------------------------------------------------------
+//"sc_method_process::throw_reset"
+//
+// This virtual method is invoked to "throw" a reset. 
+//
+// If the reset is synchronous this is a no-op, except for triggering the
+// reset event if it is present.
+//
+// If the reset is asynchronous we:
+//   (a) cancel any dynamic waits 
+//   (b) if it is the active process actually throw a reset exception.
+//   (c) if it was not the active process and does not have a static
+//       sensitivity emit an error if corner cases are to be considered
+//       errors.
+//
+// Notes:
+//   (1) If the process had a reset event it will have been triggered in 
+//       sc_process_b::semantics()
+//
+// Arguments:
+//   async = true if this is an asynchronous reset.
+//------------------------------------------------------------------------------
+void sc_method_process::throw_reset( bool async )
+{
+    // IF THE PROCESS IS CURRENTLY UNWINDING OR IS ALREADY A ZOMBIE
+    // IGNORE THE RESET:
+
+    if ( m_unwinding )
+    {
+        SC_REPORT_WARNING( SC_ID_PROCESS_ALREADY_UNWINDING_, name() );
+        return;
+    }
+
+    if ( m_state & ps_bit_zombie )
+        return;
+
+    // Set the throw status and if its an asynchronous reset throw an
+    // exception:
+
+    m_throw_status = async ? THROW_ASYNC_RESET : THROW_SYNC_RESET;
+    if ( async )
+    {
+        remove_dynamic_events();
+	if ( sc_get_current_process_b() == this )
+	{
+	    DEBUG_MSG(DEBUG_NAME,this,"throw_reset: throwing exception");
+	    m_throw_status = THROW_ASYNC_RESET;
+	    throw sc_unwind_exception( this, true );
+	}
+	else 
+	{
+	    DEBUG_MSG(DEBUG_NAME,this,
+	              "throw_reset: queueing this method for execution");
+	    simcontext()->preempt_with(this);
+	}
+    }
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_method_process::throw_user"
+//
+// This virtual method is invoked when a user exception is to be thrown.
+// If requested it will also throw the exception to the children of this 
+// object instance. Since this is a method no throw will occur for this
+// object instance. The children will be awakened from youngest child to
+// eldest.
+//     helper_p    -> object to use to throw the exception.
+//     descendants =  indicator of whether this process' children should also
+//                    be suspended
+//------------------------------------------------------------------------------
+void sc_method_process::throw_user( const sc_throw_it_helper& helper,
+    sc_descendant_inclusion_info descendants )
+{     
+
+    // IF THE SIMULATION IS NOT ACTUALLY RUNNING THIS IS AN ERROR:
+
+    if (  sc_get_status() != SC_RUNNING )
+    {
+        report_error( SC_ID_THROW_IT_WHILE_NOT_RUNNING_ );
+    }
+
+    // IF NEEDED PROPOGATE THE THROW REQUEST THROUGH OUR DESCENDANTS:
+
+    if ( descendants == SC_INCLUDE_DESCENDANTS )
+    {
+        const std::vector<sc_object*> children = get_child_objects();
+        int                           child_n  = children.size();
+
+        for ( int child_i = 0; child_i < child_n; child_i++ )
+        {
+            sc_process_b* child_p = DCAST<sc_process_b*>(children[child_i]);
+            if ( child_p ) 
+	    {
+	        DEBUG_MSG(DEBUG_NAME,child_p,"about to throw user on");
+	        child_p->throw_user(helper, descendants);
+	    }
+        }
+    }
+
+#if 0 // shouldn't we throw, if we're currently running?
+
+    if ( sc_get_current_process_b() == (sc_process_b*)this )
+    {
+        remove_dynamic_events();
+        m_throw_status = THROW_USER;
+        if ( m_throw_helper_p != 0 ) delete m_throw_helper_p;
+        m_throw_helper_p = helper.clone();
+        m_throw_helper_p->throw_it();
+    }
+
+    // throw_it HAS NO EFFECT ON A METHOD, ISSUE A WARNING:
+
+    else
+
+#endif
+   {
+        SC_REPORT_WARNING( SC_ID_THROW_IT_IGNORED_, name() );
+   }
+
+
+}
+
+//------------------------------------------------------------------------------
+//"sc_method_process::trigger_dynamic"
+//
+// This method sets up a dynamic trigger on an event.
+//
+// Notes:
+//   (1) This method is identical to sc_thread_process::trigger_dynamic(), 
+//       but they cannot be combined as sc_process_b::trigger_dynamic() 
+//       because the signatures things like sc_event::remove_dynamic()
+//       have different overloads for sc_method_process* and sc_thread_process*.
+//       So if you change code here you'll also need to change it in 
+//       sc_thread_process.cpp.
+//
+// Result is true if this process should be removed from the event's list,
+// false if not.
+//
+// If the triggering process is the same process, the trigger is
+// ignored as well, unless SC_ENABLE_IMMEDIATE_SELF_NOTIFICATIONS
+// is defined.
+//------------------------------------------------------------------------------
+bool sc_method_process::trigger_dynamic( sc_event* e )
+{
+    // No time outs yet, and keep gcc happy.
+
+    m_timed_out = false;
+
+    // Escape cases:
+    //   (a) If this method issued the notify() don't schedule it for
+    //       execution, but leave the sensitivity in place.
+    //   (b) If this method is already runnable can't trigger an event.
+
+#if ! defined( SC_ENABLE_IMMEDIATE_SELF_NOTIFICATIONS )
+    if( SC_UNLIKELY_( sc_get_current_process_b() == this ) )
+    {
+        report_immediate_self_notification();
+        return false;
+    }
+#endif // SC_ENABLE_IMMEDIATE_SELF_NOTIFICATIONS
+
+    if( is_runnable() ) 
+        return true;
+
+    // If a process is disabled then we ignore any events, leaving them enabled:
+    //
+    // But if this is a time out event we need to remove both it and the
+    // event that was being waited for.
+
+    if ( m_state & ps_bit_disabled )
+    {
+        if ( e == m_timeout_event_p )
+	{
+	    remove_dynamic_events( true );  
+	    return true;
+	}
+	else
+	{
+	    return false;
+	}
+    }
+
+
+    // Process based on the event type and current process state:
+    //
+    // Every case needs to set 'rc' and continue on to the end of
+    // this method to allow suspend processing to work correctly.
+
+    switch( m_trigger_type ) 
+    {
+      case EVENT: 
+	m_event_p = 0;
+	m_trigger_type = STATIC;
+	break;
+
+      case AND_LIST:
+        -- m_event_count;
+	if ( m_event_count == 0 )
+	{
+	    m_event_list_p->auto_delete();
+	    m_event_list_p = 0;
+	    m_trigger_type = STATIC;
+	}
+	else
+	{
+	    return true;
+	}
+	break;
+
+      case OR_LIST:
+	m_event_list_p->remove_dynamic( this, e );
+	m_event_list_p->auto_delete();
+	m_event_list_p = 0;
+	m_trigger_type = STATIC;
+	break;
+
+      case TIMEOUT: 
+	m_trigger_type = STATIC;
+	break;
+
+      case EVENT_TIMEOUT: 
+        if ( e == m_timeout_event_p )
+	{
+	    m_timed_out = true;
+	    m_event_p->remove_dynamic( this );
+	    m_event_p = 0;
+	    m_trigger_type = STATIC;
+	}
+	else
+	{
+	    m_timeout_event_p->cancel();
+	    m_timeout_event_p->reset();
+	    m_event_p = 0;
+	    m_trigger_type = STATIC;
+	}
+	break;
+
+      case OR_LIST_TIMEOUT:
+        if ( e == m_timeout_event_p )
+	{
+            m_timed_out = true;
+            m_event_list_p->remove_dynamic( this, e ); 
+            m_event_list_p->auto_delete();
+            m_event_list_p = 0; 
+            m_trigger_type = STATIC;
+	}
+
+	else
+	{
+            m_timeout_event_p->cancel();
+            m_timeout_event_p->reset();
+	    m_event_list_p->remove_dynamic( this, e ); 
+	    m_event_list_p->auto_delete();
+	    m_event_list_p = 0; 
+	    m_trigger_type = STATIC;
+	}
+	break;
+      
+      case AND_LIST_TIMEOUT:
+        if ( e == m_timeout_event_p )
+	{
+            m_timed_out = true;
+            m_event_list_p->remove_dynamic( this, e ); 
+            m_event_list_p->auto_delete();
+            m_event_list_p = 0; 
+            m_trigger_type = STATIC;
+	}
+
+	else
+	{
+	    -- m_event_count;
+	    if ( m_event_count == 0 )
+	    {
+		m_timeout_event_p->cancel();
+		m_timeout_event_p->reset();
+		// no need to remove_dynamic
+		m_event_list_p->auto_delete();
+		m_event_list_p = 0; 
+		m_trigger_type = STATIC;
+	    }
+	    else
+	    {
+	        return true;
+	    }
+	}
+	break;
+
+      case STATIC: {
+        // we should never get here, but throw_it() can make it happen.
+	SC_REPORT_WARNING(SC_ID_NOT_EXPECTING_DYNAMIC_EVENT_NOTIFY_, name());
+        return true;
+      }
+    }
+
+    // If we get here then the method has satisfied its next_trigger, if its 
+    // suspended mark its state as ready to run. If its not suspended then push
+    // it onto the runnable queue.
+
+    if ( (m_state & ps_bit_suspended) )
+    {
+	m_state = m_state | ps_bit_ready_to_run;
+    }
+    else
+    {
+        simcontext()->push_runnable_method(this);
+    }
+
+    return true;
+}
+
+} // namespace sc_core 
+
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_method_process.cpp,v $
+// Revision 1.49  2011/08/29 18:24:47  acg
+//  Andy Goodrich: remove temporary comment flagging new preempt_with() call.
+//
+// Revision 1.48  2011/08/29 18:04:32  acg
+//  Philipp A. Hartmann: miscellaneous clean ups.
+//
+// Revision 1.47  2011/08/24 22:05:50  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.46  2011/08/07 19:08:04  acg
+//  Andy Goodrich: moved logs to end of file so line number synching works
+//  better between versions.
+//
+// Revision 1.45  2011/07/29 22:42:45  acg
+//  Andy Goodrich: added check_for_throws() to fix case where a method is
+//  deleted by a process it resets or kills so that it can throw itself.
+//  Philipp A. Hartmann: changes to handle case where a process control
+//  invocation on a child process causes the list of child processes to change.
+//
+// Revision 1.44  2011/07/24 11:27:04  acg
+//  Andy Goodrich: moved the check for unwinding processes until after the
+//  descendants have been processed in throw_user and kill.
+//
+// Revision 1.43  2011/07/24 11:20:03  acg
+//  Philipp A. Hartmann: process control error message improvements:
+//  (1) Downgrade error to warning for re-kills of processes.
+//  (2) Add process name to process messages.
+//  (3) drop some superfluous colons in messages.
+//
+// Revision 1.42  2011/05/05 17:45:27  acg
+//  Philip A. Hartmann: changes in WIN64 support.
+//  Andy Goodrich: additional DEBUG_MSG instances to trace process handling.
+//
+// Revision 1.41  2011/04/19 19:15:41  acg
+//  Andy Goodrich: fix so warning message is always issued for a throw_it()
+//  on a method process.
+//
+// Revision 1.40  2011/04/19 15:04:27  acg
+//  Philipp A. Hartmann: clean up SC_ID messages.
+//
+// Revision 1.39  2011/04/19 02:39:09  acg
+//  Philipp A. Hartmann: added checks for additional throws during stack unwinds.
+//
+// Revision 1.38  2011/04/13 02:41:34  acg
+//  Andy Goodrich: eliminate warning messages generated when the DEBUG_MSG
+//  macro is used.
+//
+// Revision 1.37  2011/04/11 22:10:46  acg
+//  Andy Goodrich:
+//    (1) Add DEBUG_MSG macro and use it to generate a journal of method
+//        throws if it is enabled.
+//    (2) Trim down to the expected behavior of scheduling a method that
+//        is asynchronously reset in anticipation of IEEE 1666 being revised.
+//
+// Revision 1.36  2011/04/10 22:15:29  acg
+//  Andy Goodrich: change to call methods on asynchronous reset.
+//
+// Revision 1.35  2011/04/08 22:31:40  acg
+//  Andy Goodrich: removed unused code.
+//
+// Revision 1.34  2011/04/08 18:24:07  acg
+//  Andy Goodrich: fix asynchronous reset dispatch and when the reset_event()
+//  is fired.
+//
+// Revision 1.33  2011/04/05 20:50:56  acg
+//  Andy Goodrich:
+//    (1) changes to make sure that event(), posedge() and negedge() only
+//        return true if the clock has not moved.
+//    (2) fixes for method self-resumes.
+//    (3) added SC_PRERELEASE_VERSION
+//    (4) removed kernel events from the object hierarchy, added
+//        sc_hierarchy_name_exists().
+//
+// Revision 1.32  2011/04/01 22:30:39  acg
+//  Andy Goodrich: change hard assertion to warning for trigger_dynamic()
+//  getting called when there is only STATIC sensitivity. This can result
+//  because of sc_process_handle::throw_it().
+//
+// Revision 1.31  2011/03/28 13:02:51  acg
+//  Andy Goodrich: Changes for disable() interactions.
+//
+// Revision 1.30  2011/03/23 16:17:52  acg
+//  Andy Goodrich: don't emit an error message for a resume on a disabled
+//  process that is not suspended.
+//
+// Revision 1.29  2011/03/20 13:43:23  acg
+//  Andy Goodrich: added async_signal_is() plus suspend() as a corner case.
+//
+// Revision 1.28  2011/03/08 20:49:30  acg
+//  Andy Goodrich: implement coarse checking for synchronous reset - suspend
+//  interaction.
+//
+// Revision 1.27  2011/03/08 20:32:28  acg
+//  Andy Goodrich: implemented "coarse" checking for undefined process
+//  control interactions.
+//
+// Revision 1.26  2011/03/07 18:25:19  acg
+//  Andy Goodrich: tightening of check for resume on a disabled process to
+//  only produce an error if it is ready to run.
+//
+// Revision 1.25  2011/03/07 17:38:43  acg
+//  Andy Goodrich: tightening up of checks for undefined interaction between
+//  synchronous reset and suspend.
+//
+// Revision 1.24  2011/03/06 23:30:13  acg
+//  Andy Goodrich: refining suspend - sync reset corner case checking so that
+//  the following are error situations:
+//    (1) Calling suspend on a process with a reset_signal_is() specification
+//        or sync_reset_on() is active.
+//    (2) Calling sync_reset_on() on a suspended process.
+//
+// Revision 1.23  2011/03/06 19:57:11  acg
+//  Andy Goodrich: refinements for the illegal suspend - synchronous reset
+//  interaction.
+//
+// Revision 1.22  2011/03/06 16:47:09  acg
+//  Andy Goodrich: changes for testing sync_reset - suspend corner cases.
+//
+// Revision 1.21  2011/03/06 15:57:08  acg
+//  Andy Goodrich: added process control corner case checks.
+//
+// Revision 1.20  2011/03/05 19:44:20  acg
+//  Andy Goodrich: changes for object and event naming and structures.
+//
+// Revision 1.19  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.18  2011/02/17 19:50:43  acg
+//  Andy Goodrich:
+//    (1) Changed signature of trigger_dynamic back to a bool.
+//    (2) Added run queue processing into trigger dynamic.
+//    (3) Simplified process control support.
+//
+// Revision 1.17  2011/02/16 22:37:30  acg
+//  Andy Goodrich: clean up to remove need for ps_disable_pending.
+//
+// Revision 1.16  2011/02/13 23:09:58  acg
+//  Andy Goodrich: only remove dynamic events for asynchronous resets.
+//
+// Revision 1.15  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.14  2011/02/13 21:31:02  acg
+//  Andy Goodrich: added error messages for throws when simulator has not
+//  been initialized. Added missing remove_dynamic_events() call to the
+//  reset code.
+//
+// Revision 1.13  2011/02/11 13:25:24  acg
+//  Andy Goodrich: Philipp A. Hartmann's changes:
+//    (1) Removal of SC_CTHREAD method overloads.
+//    (2) New exception processing code.
+//
+// Revision 1.12  2011/02/07 19:17:20  acg
+//  Andy Goodrich: changes for IEEE 1666 compatibility.
+//
+// Revision 1.11  2011/02/04 15:27:36  acg
+//  Andy Goodrich: changes for suspend-resume semantics.
+//
+// Revision 1.10  2011/02/01 23:01:53  acg
+//  Andy Goodrich: removed dead code.
+//
+// Revision 1.9  2011/02/01 21:05:05  acg
+//  Andy Goodrich: Changes in trigger_dynamic methods to handle new
+//  process control rules about event sensitivity.
+//
+// Revision 1.8  2011/01/25 20:50:37  acg
+//  Andy Goodrich: changes for IEEE 1666 2011.
+//
+// Revision 1.7  2011/01/18 20:10:44  acg
+//  Andy Goodrich: changes for IEEE1666_2011 semantics.
+//
+// Revision 1.6  2011/01/06 18:02:43  acg
+//  Andy Goodrich: added check for ps_disabled to method_dynamic().
+//
+// Revision 1.5  2010/11/20 17:10:56  acg
+//  Andy Goodrich: reset processing changes for new IEEE 1666 standard.
+//
+// Revision 1.4  2010/07/22 20:02:33  acg
+//  Andy Goodrich: bug fixes.
+//
+// Revision 1.3  2009/05/22 16:06:29  acg
+//  Andy Goodrich: process control updates.
+//
+// Revision 1.2  2008/05/22 17:06:25  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.7  2006/04/20 17:08:16  acg
+//  Andy Goodrich: 3.0 style process changes.
+//
+// Revision 1.6  2006/04/11 23:13:20  acg
+//   Andy Goodrich: Changes for reduced reset support that only includes
+//   sc_cthread, but has preliminary hooks for expanding to method and thread
+//   processes also.
+//
+// Revision 1.5  2006/01/26 21:04:54  acg
+//  Andy Goodrich: deprecation message changes and additional messages.
+//
+// Revision 1.4  2006/01/24 20:49:05  acg
+// Andy Goodrich: changes to remove the use of deprecated features within the
+// simulator, and to issue warning messages when deprecated features are used.
+//
+// Revision 1.3  2006/01/13 18:44:29  acg
+// Added $Log to record CVS changes into the source.
+//
diff --git a/ext/systemc/src/sysc/kernel/sc_method_process.h b/ext/systemc/src/sysc/kernel/sc_method_process.h
new file mode 100644
index 000000000..00f6e37e7
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_method_process.h
@@ -0,0 +1,467 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_method_process.h -- Method process declarations
+
+  Original Author: Andy Goodrich, Forte Design Systems, 4 August 2005
+               
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+// $Log: sc_method_process.h,v $
+// Revision 1.23  2011/09/05 21:20:22  acg
+//  Andy Goodrich: result of automake invocation.
+//
+// Revision 1.22  2011/08/29 18:04:32  acg
+//  Philipp A. Hartmann: miscellaneous clean ups.
+//
+// Revision 1.21  2011/08/26 20:46:10  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+
+#if !defined(sc_method_process_h_INCLUDED)
+#define sc_method_process_h_INCLUDED
+
+#include "sysc/kernel/sc_process.h"
+#include "sysc/kernel/sc_spawn_options.h"
+#include "sysc/kernel/sc_cor.h"
+#include "sysc/kernel/sc_event.h"
+#include "sysc/kernel/sc_except.h"
+
+
+// DEBUGGING MACROS:
+//
+// DEBUG_MSG(NAME,P,MSG)
+//     MSG  = message to print
+//     NAME = name that must match the process for the message to print, or
+//            null if the message should be printed unconditionally.
+//     P    = pointer to process message is for, or NULL in which case the
+//            message will not print.
+#if 0
+#   define DEBUG_NAME ""
+#   define DEBUG_MSG(NAME,P,MSG) \
+    { \
+        if ( P && ( (strlen(NAME)==0) || !strcmp(NAME,P->name())) ) \
+          std::cout << "**** " << sc_time_stamp() << " ("  \
+	            << sc_get_current_process_name() << "): " << MSG \
+		    << " - " << P->name() << std::endl; \
+    }
+#else
+#   define DEBUG_MSG(NAME,P,MSG) 
+#endif
+
+
+namespace sc_core {
+
+// forward function and class declarations:
+
+void sc_method_cor_fn( void* );
+void sc_cmethod_cor_fn( void* );
+void sc_set_stack_size( sc_method_handle, std::size_t );
+class sc_event;
+class sc_module;
+class sc_process_table;
+class sc_process_handle;
+class sc_simcontext;
+class sc_runnable;
+
+void next_trigger( sc_simcontext* );
+void next_trigger( const sc_event&, sc_simcontext* );
+void next_trigger( const sc_event_or_list&, sc_simcontext* );
+void next_trigger( const sc_event_and_list&, sc_simcontext* );
+void next_trigger( const sc_time&, sc_simcontext* );
+void next_trigger( const sc_time&, const sc_event&, sc_simcontext* );
+void next_trigger( const sc_time&, const sc_event_or_list&, sc_simcontext* );
+void next_trigger( const sc_time&, const sc_event_and_list&, sc_simcontext* );
+
+struct sc_invoke_method; 
+//==============================================================================
+// sc_method_process -
+//
+//==============================================================================
+class sc_method_process : public sc_process_b {
+    friend struct sc_invoke_method; 
+    friend void sc_method_cor_fn( void* );
+    friend void sc_cmethod_cor_fn( void* );
+    friend void sc_set_stack_size( sc_method_handle, std::size_t );
+    friend class sc_event;
+    friend class sc_module;
+    friend class sc_process_table;
+    friend class sc_process_handle;
+    friend class sc_simcontext;
+    friend class sc_runnable;
+
+    friend void next_trigger( sc_simcontext* );
+    friend void next_trigger( const sc_event&,
+                  sc_simcontext* );
+    friend void next_trigger( const sc_event_or_list&,
+                  sc_simcontext* );
+    friend void next_trigger( const sc_event_and_list&,
+                  sc_simcontext* );
+    friend void next_trigger( const sc_time&,
+                  sc_simcontext* );
+    friend void next_trigger( const sc_time&, const sc_event&,
+                  sc_simcontext* );
+    friend void next_trigger( const sc_time&, const sc_event_or_list&,
+                  sc_simcontext* );
+    friend void next_trigger( const sc_time&, const sc_event_and_list&,
+                  sc_simcontext* );
+
+  public:
+    sc_method_process( const char* name_p, bool free_host,
+        SC_ENTRY_FUNC method_p, sc_process_host* host_p, 
+        const sc_spawn_options* opt_p );
+
+    virtual const char* kind() const
+        { return "sc_method_process"; }
+
+  protected:
+    void check_for_throws();
+    virtual void disable_process(
+        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS );
+    virtual void enable_process(
+        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS );
+    inline bool run_process();
+    virtual void kill_process(
+        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS );
+    sc_method_handle next_exist();
+    sc_method_handle next_runnable();
+    void clear_trigger();
+    void next_trigger( const sc_event& );
+    void next_trigger( const sc_event_or_list& );
+    void next_trigger( const sc_event_and_list& );
+    void next_trigger( const sc_time& );
+    void next_trigger( const sc_time&, const sc_event& );
+    void next_trigger( const sc_time&, const sc_event_or_list& );
+    void next_trigger( const sc_time&, const sc_event_and_list& );
+    virtual void resume_process(
+        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS );
+    void set_next_exist( sc_method_handle next_p );
+    void set_next_runnable( sc_method_handle next_p );
+    void set_stack_size( std::size_t size );
+    virtual void suspend_process( 
+        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS );
+    virtual void throw_reset( bool async );
+    virtual void throw_user( const sc_throw_it_helper& helper,
+        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS );
+    bool trigger_dynamic( sc_event* );
+    inline void trigger_static();
+
+  protected:
+    sc_cor*                          m_cor;        // Thread's coroutine.
+    std::size_t                      m_stack_size; // Thread stack size.
+    std::vector<sc_process_monitor*> m_monitor_q;  // Thread monitors.
+
+  private:
+    // may not be deleted manually (called from sc_process_b)
+    virtual ~sc_method_process();
+
+  private: // disabled
+    sc_method_process( const sc_method_process& );
+    const sc_method_process& operator = ( const sc_method_process& );
+
+};
+
+inline
+void
+sc_method_process::next_trigger( const sc_event& e )
+{
+    clear_trigger();
+    e.add_dynamic( this );
+    m_event_p = &e;
+    m_trigger_type = EVENT;
+}
+
+inline
+void
+sc_method_process::next_trigger( const sc_event_or_list& el )
+{
+    clear_trigger();
+    el.add_dynamic( this );
+    m_event_list_p = &el;
+    m_trigger_type = OR_LIST;
+}
+
+inline
+void
+sc_method_process::next_trigger( const sc_event_and_list& el )
+{
+    clear_trigger();
+    el.add_dynamic( this );
+    m_event_list_p = &el;
+    m_event_count = el.size();
+    m_trigger_type = AND_LIST;
+}
+
+inline
+void
+sc_method_process::next_trigger( const sc_time& t )
+{
+    clear_trigger();
+    m_timeout_event_p->notify_internal( t );
+    m_timeout_event_p->add_dynamic( this );
+    m_trigger_type = TIMEOUT;
+}
+
+inline
+void
+sc_method_process::next_trigger( const sc_time& t, const sc_event& e )
+{
+    clear_trigger();
+    m_timeout_event_p->notify_internal( t );
+    m_timeout_event_p->add_dynamic( this );
+    e.add_dynamic( this );
+    m_event_p = &e;
+    m_trigger_type = EVENT_TIMEOUT;
+}
+
+inline
+void
+sc_method_process::next_trigger( const sc_time& t, const sc_event_or_list& el )
+{
+    clear_trigger();
+    m_timeout_event_p->notify_internal( t );
+    m_timeout_event_p->add_dynamic( this );
+    el.add_dynamic( this );
+    m_event_list_p = &el;
+    m_trigger_type = OR_LIST_TIMEOUT;
+}
+
+inline
+void
+sc_method_process::next_trigger( const sc_time& t, const sc_event_and_list& el )
+{
+    clear_trigger();
+    m_timeout_event_p->notify_internal( t );
+    m_timeout_event_p->add_dynamic( this );
+    el.add_dynamic( this );
+    m_event_list_p = &el;
+    m_event_count = el.size();
+    m_trigger_type = AND_LIST_TIMEOUT;
+}
+
+inline
+void sc_method_process::set_next_exist(sc_method_handle next_p)
+{
+    m_exist_p = next_p;
+}
+
+inline
+sc_method_handle sc_method_process::next_exist()
+{
+    return (sc_method_handle)m_exist_p;
+}
+
+
+inline
+void sc_method_process::set_next_runnable(sc_method_handle next_p)
+{
+    m_runnable_p = next_p;
+}
+
+inline
+sc_method_handle sc_method_process::next_runnable()
+{
+    return (sc_method_handle)m_runnable_p;
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_method_process::run_process"
+// | 
+// | This method executes this object instance, including fielding exceptions.
+// |
+// | Result is false if an unfielded exception occurred, true if not.
+// +----------------------------------------------------------------------------
+inline bool sc_method_process::run_process()
+{
+    // Execute this object instance's semantics and catch any exceptions that
+    // are generated:
+
+    bool restart = false;
+    do {
+        try {
+            DEBUG_MSG(DEBUG_NAME,this,"executing method semantics");
+            semantics();
+            restart = false;
+        }
+        catch( sc_unwind_exception& ex ) {
+            DEBUG_MSG(DEBUG_NAME,this,"caught unwind exception");
+            ex.clear();
+            restart = ex.is_reset();
+        }
+        catch( ... ) {
+            sc_report* err_p = sc_handle_exception();
+            simcontext()->set_error( err_p );
+            return false;
+        }
+    } while( restart );
+
+    return true;
+}
+
+//------------------------------------------------------------------------------
+//"sc_method_process::trigger_static"
+//
+// This inline method adds the current method to the queue of runnable
+// processes, if required.  This is the case if the following criteria
+// are met:
+//   (1) The process is in a runnable state.
+//   (2) The process is not already on the run queue.
+//   (3) The process is expecting a static trigger, 
+//       dynamic event waits take priority.
+//
+//
+// If the triggering process is the same process, the trigger is
+// ignored as well, unless SC_ENABLE_IMMEDIATE_SELF_NOTIFICATIONS
+// is defined.
+//------------------------------------------------------------------------------
+inline
+void
+sc_method_process::trigger_static()
+{
+    if ( (m_state & ps_bit_disabled) || is_runnable() ||
+          m_trigger_type != STATIC )
+        return;
+
+#if ! defined( SC_ENABLE_IMMEDIATE_SELF_NOTIFICATIONS )
+    if( SC_UNLIKELY_( sc_get_current_process_b() == this ) )
+    {
+        report_immediate_self_notification();
+        return;
+    }
+#endif // SC_ENABLE_IMMEDIATE_SELF_NOTIFICATIONS
+
+    // If we get here then the method is has satisfied its wait, if its 
+    // suspended mark its state as ready to run. If its not suspended then 
+    // push it onto the runnable queue.
+
+    if ( m_state & ps_bit_suspended )
+    {
+        m_state = m_state | ps_bit_ready_to_run;
+    }
+    else
+    {
+        simcontext()->push_runnable_method(this);
+    }
+}
+
+#undef DEBUG_MSG
+
+} // namespace sc_core 
+
+// Revision 1.20  2011/08/24 22:05:50  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.19  2011/07/29 22:43:15  acg
+//  Andy Goodrich: addition of check_for_throws() method.
+//
+// Revision 1.18  2011/07/24 11:18:09  acg
+//  Philipp A. Hartmann: add code to restart a method process after a
+//  self-reset.
+//
+// Revision 1.17  2011/05/09 04:07:48  acg
+//  Philipp A. Hartmann:
+//    (1) Restore hierarchy in all phase callbacks.
+//    (2) Ensure calls to before_end_of_elaboration.
+//
+// Revision 1.16  2011/04/13 02:41:34  acg
+//  Andy Goodrich: eliminate warning messages generated when the DEBUG_MSG
+//  macro is used.
+//
+// Revision 1.15  2011/04/10 22:12:32  acg
+//  Andy Goodrich: adding debugging macros.
+//
+// Revision 1.14  2011/04/08 22:31:21  acg
+//  Andy Goodrich: added new inline method run_process() to hide the process
+//  implementation for sc_simcontext.
+//
+// Revision 1.13  2011/04/05 20:50:56  acg
+//  Andy Goodrich:
+//    (1) changes to make sure that event(), posedge() and negedge() only
+//        return true if the clock has not moved.
+//    (2) fixes for method self-resumes.
+//    (3) added SC_PRERELEASE_VERSION
+//    (4) removed kernel events from the object hierarchy, added
+//        sc_hierarchy_name_exists().
+//
+// Revision 1.12  2011/04/01 21:24:57  acg
+//  Andy Goodrich: removed unused code.
+//
+// Revision 1.11  2011/02/19 08:30:53  acg
+//  Andy Goodrich: Moved process queueing into trigger_static from
+//  sc_event::notify.
+//
+// Revision 1.10  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.9  2011/02/17 19:51:34  acg
+//  Andy Goodrich:
+//    (1) Changed the signature of trigger_dynamic back to a bool.
+//    (2) Removed ready_to_run().
+//    (3) Simplified process control usage.
+//
+// Revision 1.8  2011/02/16 22:37:30  acg
+//  Andy Goodrich: clean up to remove need for ps_disable_pending.
+//
+// Revision 1.7  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.6  2011/02/01 21:05:05  acg
+//  Andy Goodrich: Changes in trigger_dynamic methods to handle new
+//  process control rules about event sensitivity.
+//
+// Revision 1.5  2011/01/18 20:10:44  acg
+//  Andy Goodrich: changes for IEEE1666_2011 semantics.
+//
+// Revision 1.4  2009/07/28 01:10:53  acg
+//  Andy Goodrich: updates for 2.3 release candidate.
+//
+// Revision 1.3  2009/05/22 16:06:29  acg
+//  Andy Goodrich: process control updates.
+//
+// Revision 1.2  2008/05/22 17:06:25  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.7  2006/05/08 17:57:13  acg
+//  Andy Goodrich: Added David Long's forward declarations for friend functions
+//  to keep the Microsoft C++ compiler happy.
+//
+// Revision 1.6  2006/04/20 17:08:17  acg
+//  Andy Goodrich: 3.0 style process changes.
+//
+// Revision 1.5  2006/04/11 23:13:21  acg
+//   Andy Goodrich: Changes for reduced reset support that only includes
+//   sc_cthread, but has preliminary hooks for expanding to method and thread
+//   processes also.
+//
+// Revision 1.4  2006/01/24 20:49:05  acg
+// Andy Goodrich: changes to remove the use of deprecated features within the
+// simulator, and to issue warning messages when deprecated features are used.
+//
+// Revision 1.3  2006/01/13 18:44:29  acg
+// Added $Log to record CVS changes into the source.
+
+#endif // !defined(sc_method_process_h_INCLUDED)
diff --git a/ext/systemc/src/sysc/kernel/sc_module.cpp b/ext/systemc/src/sysc/kernel/sc_module.cpp
new file mode 100644
index 000000000..efca2a4dc
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_module.cpp
@@ -0,0 +1,846 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_module.cpp -- Base class of all sequential and combinational processes.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#include <cassert>
+#include <math.h>
+#include <stddef.h>
+#include <stdio.h>
+
+#include "sysc/kernel/sc_event.h"
+#include "sysc/kernel/sc_kernel_ids.h"
+#include "sysc/kernel/sc_module.h"
+#include "sysc/kernel/sc_module_registry.h"
+#include "sysc/kernel/sc_name_gen.h"
+#include "sysc/kernel/sc_object_manager.h"
+#include "sysc/kernel/sc_process.h"
+#include "sysc/kernel/sc_process_handle.h"
+#include "sysc/kernel/sc_simcontext.h"
+#include "sysc/kernel/sc_simcontext_int.h"
+#include "sysc/kernel/sc_object_int.h"
+#include "sysc/kernel/sc_reset.h"
+#include "sysc/communication/sc_communication_ids.h"
+#include "sysc/communication/sc_interface.h"
+#include "sysc/communication/sc_port.h"
+#include "sysc/communication/sc_signal.h"
+#include "sysc/communication/sc_signal_ports.h"
+#include "sysc/utils/sc_utils_ids.h"
+#include "sysc/utils/sc_iostream.h"
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_module_dynalloc_list
+//
+//  Garbage collection for modules dynamically allocated with SC_NEW.
+// ----------------------------------------------------------------------------
+
+class sc_module_dynalloc_list
+{
+public:
+
+    sc_module_dynalloc_list() : m_list()
+        {}
+
+    ~sc_module_dynalloc_list();
+
+    void add( sc_module* p )
+        { m_list.push_back( p ); }
+
+private:
+
+    sc_plist<sc_module*> m_list;
+};
+
+
+//------------------------------------------------------------------------------
+//"~sc_module_dynalloc_list"
+//
+// Note we clear the m_parent field for the module being deleted. This because
+// we process the list front to back so the parent has already been deleted, 
+// and we don't want ~sc_object() to try to access the parent which may 
+// contain garbage.
+//------------------------------------------------------------------------------
+sc_module_dynalloc_list::~sc_module_dynalloc_list()
+{
+    sc_plist<sc_module*>::iterator it( m_list );
+    while( ! it.empty() ) {
+        (*it)->m_parent = 0;
+        delete *it;
+        it ++;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+
+sc_module*
+sc_module_dynalloc( sc_module* module_ )
+{
+    static sc_module_dynalloc_list dynalloc_list;
+    dynalloc_list.add( module_ );
+    return module_;
+}
+
+
+// ----------------------------------------------------------------------------
+//  STRUCT : sc_bind_proxy
+//
+//  Struct for temporarily storing a pointer to an interface or port.
+//  Used for positional binding.
+// ----------------------------------------------------------------------------
+    
+sc_bind_proxy::sc_bind_proxy()
+: iface( 0 ),
+  port( 0 )
+{}
+
+sc_bind_proxy::sc_bind_proxy( sc_interface& iface_ )
+: iface( &iface_ ),
+  port( 0 )
+{}
+
+sc_bind_proxy::sc_bind_proxy( sc_port_base& port_ )
+: iface( 0 ),
+  port( &port_ )
+{}
+
+
+const sc_bind_proxy SC_BIND_PROXY_NIL;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_module
+//
+//  Base class for all structural entities.
+// ----------------------------------------------------------------------------
+
+void
+sc_module::sc_module_init()
+{
+    simcontext()->get_module_registry()->insert( *this );
+    simcontext()->hierarchy_push( this );
+    m_end_module_called = false;
+    m_module_name_p = 0;
+    m_port_vec = new std::vector<sc_port_base*>;
+    m_port_index = 0;
+    m_name_gen = new sc_name_gen;
+}
+
+/*
+ *  This form of the constructor assumes that the user has
+ *  used an sc_module_name parameter for his/her constructor.
+ *  That parameter object has been pushed onto the stack,
+ *  and can be looked up by calling the 
+ *  top_of_module_name_stack() function of the object manager.
+ *  This technique has two advantages:
+ *
+ *  1) The user no longer has to write sc_module(name) in the
+ *     constructor initializer.
+ *  2) The user no longer has to call end_module() at the end
+ *     of the constructor -- a common negligence.
+ *
+ *  But it is important to note that sc_module_name may be used
+ *  in the user's constructor's parameter. If it is used anywhere
+ *  else, unexpected things will happen. The error-checking
+ *  mechanism builtin here cannot hope to catch all misuses.
+ *
+ */
+
+sc_module::sc_module()
+: sc_object(::sc_core::sc_get_curr_simcontext()
+                  ->get_object_manager()
+                  ->top_of_module_name_stack()
+                  ->operator const char*()),
+  sensitive(this),
+  sensitive_pos(this),
+  sensitive_neg(this),
+  m_end_module_called(false),
+  m_port_vec(),
+  m_port_index(0),
+  m_name_gen(0),
+  m_module_name_p(0)
+{
+    /* When this form is used, we better have a fresh sc_module_name
+       on the top of the stack */
+    sc_module_name* mod_name = 
+        simcontext()->get_object_manager()->top_of_module_name_stack();
+    if (0 == mod_name || 0 != mod_name->m_module_p)
+        SC_REPORT_ERROR( SC_ID_SC_MODULE_NAME_REQUIRED_, 0 );
+    sc_module_init();
+    mod_name->set_module( this );
+    m_module_name_p = mod_name; // must come after sc_module_init call.
+}
+
+sc_module::sc_module( const sc_module_name& )
+: sc_object(::sc_core::sc_get_curr_simcontext()
+                  ->get_object_manager()
+                  ->top_of_module_name_stack()
+                  ->operator const char*()),
+  sensitive(this),
+  sensitive_pos(this),
+  sensitive_neg(this),
+  m_end_module_called(false),
+  m_port_vec(),
+  m_port_index(0),
+  m_name_gen(0),
+  m_module_name_p(0)
+{
+    /* For those used to the old style of passing a name to sc_module,
+       this constructor will reduce the chance of making a mistake */
+
+    /* When this form is used, we better have a fresh sc_module_name
+       on the top of the stack */
+    sc_module_name* mod_name = 
+        simcontext()->get_object_manager()->top_of_module_name_stack();
+    if (0 == mod_name || 0 != mod_name->m_module_p)
+      SC_REPORT_ERROR( SC_ID_SC_MODULE_NAME_REQUIRED_, 0 );
+    sc_module_init();
+    mod_name->set_module( this );
+    m_module_name_p = mod_name; // must come after sc_module_init call.
+}
+
+/* --------------------------------------------------------------------
+ *
+ * Deprecated constructors:
+ *   sc_module( const char* )
+ *   sc_module( const std::string& )
+ */
+sc_module::sc_module( const char* nm )
+: sc_object(nm),
+  sensitive(this),
+  sensitive_pos(this),
+  sensitive_neg(this),
+  m_end_module_called(false),
+  m_port_vec(),
+  m_port_index(0),
+  m_name_gen(0),
+  m_module_name_p(0)
+{
+    SC_REPORT_WARNING( SC_ID_BAD_SC_MODULE_CONSTRUCTOR_, nm );
+    sc_module_init();
+}
+
+sc_module::sc_module( const std::string& s )
+: sc_object( s.c_str() ),
+  sensitive(this),
+  sensitive_pos(this),
+  sensitive_neg(this),
+  m_end_module_called(false),
+  m_port_vec(),
+  m_port_index(0),
+  m_name_gen(0),
+  m_module_name_p(0)
+{
+    SC_REPORT_WARNING( SC_ID_BAD_SC_MODULE_CONSTRUCTOR_, s.c_str() );
+    sc_module_init();
+}
+
+/* -------------------------------------------------------------------- */
+
+sc_module::~sc_module()
+{
+    delete m_port_vec;
+    delete m_name_gen;
+    orphan_child_objects();
+    if ( m_module_name_p )
+    {
+	m_module_name_p->clear_module( this ); // must be before end_module()
+    	end_module();
+    }
+    simcontext()->get_module_registry()->remove( *this );
+}
+
+
+const ::std::vector<sc_object*>&
+sc_module::get_child_objects() const
+{
+    return m_child_objects;
+}
+
+// set SC_THREAD asynchronous reset sensitivity
+
+void
+sc_module::async_reset_signal_is( const sc_in<bool>& port, bool level )
+{
+	sc_reset::reset_signal_is(true, port, level);
+}
+
+void
+sc_module::async_reset_signal_is( const sc_inout<bool>& port, bool level )
+{
+	sc_reset::reset_signal_is(true, port, level);
+}
+
+void
+sc_module::async_reset_signal_is( const sc_out<bool>& port, bool level )
+{
+	sc_reset::reset_signal_is(true, port, level);
+}
+
+void
+sc_module::async_reset_signal_is(const sc_signal_in_if<bool>& iface, bool level)
+{
+	sc_reset::reset_signal_is(true, iface, level);
+}
+
+void
+sc_module::end_module()
+{
+    if( ! m_end_module_called ) {
+	/* TBD: Can check here to alert the user that end_module
+                was not called for a previous module. */
+	(void)sc_get_curr_simcontext()->hierarchy_pop();
+	sc_get_curr_simcontext()->reset_curr_proc(); 
+	sensitive.reset();
+	sensitive_pos.reset();
+	sensitive_neg.reset();
+	m_end_module_called = true;
+	m_module_name_p = 0; // make sure we are not called in ~sc_module().
+    }
+}
+
+
+// to prevent initialization for SC_METHODs and SC_THREADs
+
+void
+sc_module::dont_initialize()
+{
+    sc_process_handle last_proc = sc_get_last_created_process_handle();
+    last_proc.dont_initialize( true );
+}
+
+// set SC_THREAD synchronous reset sensitivity
+
+void
+sc_module::reset_signal_is( const sc_in<bool>& port, bool level )
+{
+	sc_reset::reset_signal_is(false, port, level);
+}
+
+void
+sc_module::reset_signal_is( const sc_inout<bool>& port, bool level )
+{
+	sc_reset::reset_signal_is(false, port, level);
+}
+
+void
+sc_module::reset_signal_is( const sc_out<bool>& port, bool level )
+{
+	sc_reset::reset_signal_is(false, port, level);
+}
+
+void
+sc_module::reset_signal_is( const sc_signal_in_if<bool>& iface, bool level )
+{
+	sc_reset::reset_signal_is(false, iface, level);
+}
+
+// to generate unique names for objects in an MT-Safe way
+
+const char*
+sc_module::gen_unique_name( const char* basename_, bool preserve_first )
+{
+    return m_name_gen->gen_unique_name( basename_, preserve_first );
+}
+
+
+// called by construction_done 
+
+void
+sc_module::before_end_of_elaboration()
+{}
+
+// We push the sc_module instance onto the stack of open objects so 
+// that any objects that are created in before_end_of_elaboration have
+// the proper parent. After the call we pop the hierarchy.
+void
+sc_module::construction_done()
+{
+    hierarchy_scope scope(this);
+    before_end_of_elaboration();
+}
+
+// called by elaboration_done (does nothing by default)
+
+void
+sc_module::end_of_elaboration()
+{}
+
+
+// We push the sc_module instance onto the stack of open objects so 
+// that any objects that are created in end_of_elaboration have
+// the proper parent. After the call we pop the hierarchy.
+void
+sc_module::elaboration_done( bool& error_ )
+{
+    if( ! m_end_module_called ) {
+	char msg[BUFSIZ];
+	std::sprintf( msg, "module '%s'", name() );
+	SC_REPORT_WARNING( SC_ID_END_MODULE_NOT_CALLED_, msg );
+	if( error_ ) {
+	    SC_REPORT_WARNING( SC_ID_HIER_NAME_INCORRECT_, 0 );
+	}
+	error_ = true;
+    }
+    hierarchy_scope scope(this);
+    end_of_elaboration();
+}
+
+// called by start_simulation (does nothing by default)
+
+void
+sc_module::start_of_simulation()
+{}
+
+void
+sc_module::start_simulation()
+{
+    hierarchy_scope scope(this);
+    start_of_simulation();
+}
+
+// called by simulation_done (does nothing by default)
+
+void
+sc_module::end_of_simulation()
+{}
+
+void
+sc_module::simulation_done()
+{
+    hierarchy_scope scope(this);
+    end_of_simulation();
+}
+
+void
+sc_module::set_stack_size( std::size_t size )
+{
+    sc_process_handle  proc_h(
+    	sc_is_running() ?
+	sc_get_current_process_handle() :
+	sc_get_last_created_process_handle()
+    );
+    sc_thread_handle thread_h;  // Current process as thread.
+
+
+    thread_h = (sc_thread_handle)proc_h;
+    if ( thread_h ) 
+    {
+	thread_h->set_stack_size( size );
+    }
+    else
+    {
+	SC_REPORT_WARNING( SC_ID_SET_STACK_SIZE_, 0 );
+    }
+}
+
+
+int
+sc_module::append_port( sc_port_base* port_ )
+{
+    int index = m_port_vec->size();
+    m_port_vec->push_back( port_ );
+    return index;
+}
+
+
+// positional binding methods
+
+static void sc_warn_arrow_arrow_bind()
+{
+    static bool warn_arrow_arrow_bind=true;
+    if ( warn_arrow_arrow_bind )
+    {
+    	warn_arrow_arrow_bind = false;
+	SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
+	    "positional binding using << or , is deprecated, use () instead.");
+    }
+}
+
+sc_module&
+sc_module::operator << ( sc_interface& interface_ )
+{
+    sc_warn_arrow_arrow_bind();
+    positional_bind(interface_);
+    return *this;
+}
+
+sc_module&
+sc_module::operator << ( sc_port_base& port_ )
+{
+    sc_warn_arrow_arrow_bind();
+    positional_bind(port_);
+    return *this;
+}
+
+
+void
+sc_module::positional_bind( sc_interface& interface_ )
+{
+    if( m_port_index == (int)m_port_vec->size() ) {
+	char msg[BUFSIZ];
+	if( m_port_index == 0 ) {
+	    std::sprintf( msg, "module `%s' has no ports", name() );
+	} else {
+	    std::sprintf( msg, "all ports of module `%s' are bound", name() );
+	}
+	SC_REPORT_ERROR( SC_ID_BIND_IF_TO_PORT_, msg );
+    }
+    int status = (*m_port_vec)[m_port_index]->pbind( interface_ );
+    if( status != 0 ) {
+	char msg[BUFSIZ];
+	switch( status ) {
+	case 1:
+	    std::sprintf( msg, "port %d of module `%s' is already bound",
+		     m_port_index, name() );
+	    break;
+	case 2:
+	    std::sprintf( msg, "type mismatch on port %d of module `%s'",
+		     m_port_index, name() );
+	    break;
+	default:
+	    std::sprintf( msg, "unknown error" );
+	    break;
+	}
+	SC_REPORT_ERROR( SC_ID_BIND_IF_TO_PORT_, msg );
+    }
+    ++ m_port_index;
+}
+
+void
+sc_module::positional_bind( sc_port_base& port_ )
+{
+    if( m_port_index == (int)m_port_vec->size() ) {
+	char msg[BUFSIZ];
+	if( m_port_index == 0 ) {
+	    std::sprintf( msg, "module `%s' has no ports", name() );
+	} else {
+	    std::sprintf( msg, "all ports of module `%s' are bound", name() );
+	}
+	SC_REPORT_ERROR( SC_ID_BIND_PORT_TO_PORT_, msg );
+    }
+    int status = (*m_port_vec)[m_port_index]->pbind( port_ );
+    if( status != 0 ) {
+	char msg[BUFSIZ];
+	switch( status ) {
+	case 1:
+	    std::sprintf( msg, "port %d of module `%s' is already bound",
+		     m_port_index, name() );
+	    break;
+	case 2:
+	    std::sprintf( msg, "type mismatch on port %d of module `%s'",
+		     m_port_index, name() );
+	    break;
+	default:
+	    std::sprintf( msg, "unknown error" );
+	    break;
+	}
+	SC_REPORT_ERROR( SC_ID_BIND_PORT_TO_PORT_, msg );
+    }
+    ++ m_port_index;
+}
+
+
+#define TRY_BIND( p )                                                         \
+    if( (p).iface != 0 ) {                                                    \
+        positional_bind( *(p).iface );                                        \
+    } else if( (p).port != 0 ) {                                              \
+        positional_bind( *(p).port );                                         \
+    } else {                                                                  \
+        return;                                                               \
+    }
+
+
+void
+sc_module::operator () ( const sc_bind_proxy& p001,
+			 const sc_bind_proxy& p002,
+			 const sc_bind_proxy& p003,
+			 const sc_bind_proxy& p004,
+			 const sc_bind_proxy& p005,
+			 const sc_bind_proxy& p006,
+			 const sc_bind_proxy& p007,
+			 const sc_bind_proxy& p008,
+			 const sc_bind_proxy& p009,
+			 const sc_bind_proxy& p010,
+			 const sc_bind_proxy& p011,
+			 const sc_bind_proxy& p012,
+			 const sc_bind_proxy& p013,
+			 const sc_bind_proxy& p014,
+			 const sc_bind_proxy& p015,
+			 const sc_bind_proxy& p016,
+			 const sc_bind_proxy& p017,
+			 const sc_bind_proxy& p018,
+			 const sc_bind_proxy& p019,
+			 const sc_bind_proxy& p020,
+			 const sc_bind_proxy& p021,
+			 const sc_bind_proxy& p022,
+			 const sc_bind_proxy& p023,
+			 const sc_bind_proxy& p024,
+			 const sc_bind_proxy& p025,
+			 const sc_bind_proxy& p026,
+			 const sc_bind_proxy& p027,
+			 const sc_bind_proxy& p028,
+			 const sc_bind_proxy& p029,
+			 const sc_bind_proxy& p030,
+			 const sc_bind_proxy& p031,
+			 const sc_bind_proxy& p032,
+			 const sc_bind_proxy& p033,
+			 const sc_bind_proxy& p034,
+			 const sc_bind_proxy& p035,
+			 const sc_bind_proxy& p036,
+			 const sc_bind_proxy& p037,
+			 const sc_bind_proxy& p038,
+			 const sc_bind_proxy& p039,
+			 const sc_bind_proxy& p040,
+			 const sc_bind_proxy& p041,
+			 const sc_bind_proxy& p042,
+			 const sc_bind_proxy& p043,
+			 const sc_bind_proxy& p044,
+			 const sc_bind_proxy& p045,
+			 const sc_bind_proxy& p046,
+			 const sc_bind_proxy& p047,
+			 const sc_bind_proxy& p048,
+			 const sc_bind_proxy& p049,
+			 const sc_bind_proxy& p050,
+			 const sc_bind_proxy& p051,
+			 const sc_bind_proxy& p052,
+			 const sc_bind_proxy& p053,
+			 const sc_bind_proxy& p054,
+			 const sc_bind_proxy& p055,
+			 const sc_bind_proxy& p056,
+			 const sc_bind_proxy& p057,
+			 const sc_bind_proxy& p058,
+			 const sc_bind_proxy& p059,
+			 const sc_bind_proxy& p060,
+			 const sc_bind_proxy& p061,
+			 const sc_bind_proxy& p062,
+			 const sc_bind_proxy& p063,
+			 const sc_bind_proxy& p064 )
+{
+    static bool warn_only_once=true;
+    if ( m_port_index > 0 && warn_only_once )
+    {
+        warn_only_once = false;
+	SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
+	 "multiple () binding deprecated, use explicit port binding instead." );
+    }
+
+    TRY_BIND( p001 );
+    TRY_BIND( p002 );
+    TRY_BIND( p003 );
+    TRY_BIND( p004 );
+    TRY_BIND( p005 );
+    TRY_BIND( p006 );
+    TRY_BIND( p007 );
+    TRY_BIND( p008 );
+    TRY_BIND( p009 );
+    TRY_BIND( p010 );
+    TRY_BIND( p011 );
+    TRY_BIND( p012 );
+    TRY_BIND( p013 );
+    TRY_BIND( p014 );
+    TRY_BIND( p015 );
+    TRY_BIND( p016 );
+    TRY_BIND( p017 );
+    TRY_BIND( p018 );
+    TRY_BIND( p019 );
+    TRY_BIND( p020 );
+    TRY_BIND( p021 );
+    TRY_BIND( p022 );
+    TRY_BIND( p023 );
+    TRY_BIND( p024 );
+    TRY_BIND( p025 );
+    TRY_BIND( p026 );
+    TRY_BIND( p027 );
+    TRY_BIND( p028 );
+    TRY_BIND( p029 );
+    TRY_BIND( p030 );
+    TRY_BIND( p031 );
+    TRY_BIND( p032 );
+    TRY_BIND( p033 );
+    TRY_BIND( p034 );
+    TRY_BIND( p035 );
+    TRY_BIND( p036 );
+    TRY_BIND( p037 );
+    TRY_BIND( p038 );
+    TRY_BIND( p039 );
+    TRY_BIND( p040 );
+    TRY_BIND( p041 );
+    TRY_BIND( p042 );
+    TRY_BIND( p043 );
+    TRY_BIND( p044 );
+    TRY_BIND( p045 );
+    TRY_BIND( p046 );
+    TRY_BIND( p047 );
+    TRY_BIND( p048 );
+    TRY_BIND( p049 );
+    TRY_BIND( p050 );
+    TRY_BIND( p051 );
+    TRY_BIND( p052 );
+    TRY_BIND( p053 );
+    TRY_BIND( p054 );
+    TRY_BIND( p055 );
+    TRY_BIND( p056 );
+    TRY_BIND( p057 );
+    TRY_BIND( p058 );
+    TRY_BIND( p059 );
+    TRY_BIND( p060 );
+    TRY_BIND( p061 );
+    TRY_BIND( p062 );
+    TRY_BIND( p063 );
+    TRY_BIND( p064 );
+}
+
+} // namespace sc_core
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Ali Dasdan, Synopsys, Inc.
+  Description of Modification: - Implementation of operator() and operator,
+                                 positional connection method.
+                               - Implementation of error checking in
+                                 operator<<'s.
+                               - Implementation of the function test_module_prm.
+                               - Implementation of set_stack_size().
+
+      Name, Affiliation, Date: Andy Goodrich, Forte Design Systems 20 May 2003
+  Description of Modification: Inherit from sc_process_host
+
+      Name, Affiliation, Date: Bishnupriya Bhattacharya, Cadence Design Systems,
+                               25 August, 2003
+  Description of Modification: dont_initialize() uses 
+                               sc_get_last_created_process_handle() instead of
+                               sc_get_current_process_b()
+
+      Name, Affiliation, Date: Andy Goodrich, Forte Design Systems 25 Mar 2003
+  Description of Modification: Fixed bug in SC_NEW, see comments on 
+                               ~sc_module_dynalloc_list below.
+
+
+ *****************************************************************************/
+
+
+// $Log: sc_module.cpp,v $
+// Revision 1.14  2011/08/29 18:04:32  acg
+//  Philipp A. Hartmann: miscellaneous clean ups.
+//
+// Revision 1.13  2011/08/26 20:46:10  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.12  2011/08/24 22:05:51  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.11  2011/03/05 19:44:20  acg
+//  Andy Goodrich: changes for object and event naming and structures.
+//
+// Revision 1.10  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.9  2011/02/16 22:37:30  acg
+//  Andy Goodrich: clean up to remove need for ps_disable_pending.
+//
+// Revision 1.8  2011/02/14 17:51:40  acg
+//  Andy Goodrich: proper pushing an poppping of the module hierarchy for
+//  start_of_simulation() and end_of_simulation.
+//
+// Revision 1.7  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.6  2011/01/25 20:50:37  acg
+//  Andy Goodrich: changes for IEEE 1666 2011.
+//
+// Revision 1.5  2009/05/22 16:06:29  acg
+//  Andy Goodrich: process control updates.
+//
+// Revision 1.4  2008/11/17 15:57:15  acg
+//  Andy Goodrich: added deprecation message for sc_module(const char*)
+//
+// Revision 1.3  2008/05/22 17:06:25  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.2  2007/05/17 20:16:33  acg
+//  Andy Goodrich: changes for beta release to LWG.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.9  2006/12/02 20:58:18  acg
+//  Andy Goodrich: updates from 2.2 for IEEE 1666 support.
+//
+// Revision 1.8  2006/03/21 00:00:34  acg
+//   Andy Goodrich: changed name of sc_get_current_process_base() to be
+//   sc_get_current_process_b() since its returning an sc_process_b instance.
+//
+// Revision 1.7  2006/03/14 23:56:58  acg
+//   Andy Goodrich: This fixes a bug when an exception is thrown in
+//   sc_module::sc_module() for a dynamically allocated sc_module
+//   object. We are calling sc_module::end_module() on a module that has
+//   already been deleted. The scenario runs like this:
+//
+//   a) the sc_module constructor is entered
+//   b) the exception is thrown
+//   c) the exception processor deletes the storage for the sc_module
+//   d) the stack is unrolled causing the sc_module_name instance to be deleted
+//   e) ~sc_module_name() calls end_module() with its pointer to the sc_module
+//   f) because the sc_module has been deleted its storage is corrupted,
+//      either by linking it to a free space chain, or by reuse of some sort
+//   g) the m_simc field is garbage
+//   h) the m_object_manager field is also garbage
+//   i) an exception occurs
+//
+//   This does not happen for automatic sc_module instances since the
+//   storage for the module is not reclaimed its just part of the stack.
+//
+//   I am fixing this by having the destructor for sc_module clear the
+//   module pointer in its sc_module_name instance. That cuts things at
+//   step (e) above, since the pointer will be null if the module has
+//   already been deleted. To make sure the module stack is okay, I call
+//   end-module() in ~sc_module in the case where there is an
+//   sc_module_name pointer lying around.
+//
+// Revision 1.6  2006/01/26 21:04:54  acg
+//  Andy Goodrich: deprecation message changes and additional messages.
+//
+// Revision 1.5  2006/01/25 00:31:19  acg
+//  Andy Goodrich: Changed over to use a standard message id of
+//  SC_ID_IEEE_1666_DEPRECATION for all deprecation messages.
+//
+// Revision 1.4  2006/01/24 20:49:05  acg
+// Andy Goodrich: changes to remove the use of deprecated features within the
+// simulator, and to issue warning messages when deprecated features are used.
+//
+// Revision 1.3  2006/01/13 18:44:29  acg
+// Added $Log to record CVS changes into the source.
+//
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_module.h b/ext/systemc/src/sysc/kernel/sc_module.h
new file mode 100644
index 000000000..8a68cb049
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_module.h
@@ -0,0 +1,583 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_module.h -- Base class of all hierarchical modules and channels.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+                   Martin Janssen, Synopsys, Inc.
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#ifndef SC_MODULE_H
+#define SC_MODULE_H
+
+#include "sysc/kernel/sc_kernel_ids.h"
+#include "sysc/kernel/sc_process.h"
+#include "sysc/kernel/sc_module_name.h"
+#include "sysc/kernel/sc_sensitive.h"
+#include "sysc/kernel/sc_time.h"
+#include "sysc/kernel/sc_wait.h"
+#include "sysc/kernel/sc_wait_cthread.h"
+#include "sysc/kernel/sc_process.h"
+#include "sysc/kernel/sc_process_handle.h"
+#include "sysc/utils/sc_list.h"
+
+namespace sc_core {
+
+class sc_name_gen;
+template<class T> class sc_in;
+template<class T> class sc_inout;
+template<class T> class sc_out;
+
+// ----------------------------------------------------------------------------
+//  STRUCT : sc_bind_proxy
+//
+//  Struct for temporarily storing a pointer to an interface or port.
+//  Used for positional binding.
+// ----------------------------------------------------------------------------
+
+struct sc_bind_proxy
+{
+    sc_interface* iface;
+    sc_port_base* port;
+    
+    sc_bind_proxy();
+    sc_bind_proxy( sc_interface& );
+    sc_bind_proxy( sc_port_base& );
+};
+
+
+extern const sc_bind_proxy SC_BIND_PROXY_NIL;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_module
+//
+//  Base class for all structural entities.
+// ----------------------------------------------------------------------------
+
+class sc_module
+: public sc_object, public sc_process_host
+{
+    friend class sc_module_name;
+    friend class sc_module_registry;
+    friend class sc_object;
+    friend class sc_port_registry;
+	friend class sc_process_b;
+    friend class sc_simcontext;
+
+public:
+
+    sc_simcontext* sc_get_curr_simcontext()
+	{ return simcontext(); }
+
+    // to generate unique names for objects in an MT-Safe way
+    const char* gen_unique_name( const char* basename_, bool preserve_first );
+
+    virtual const char* kind() const
+        { return "sc_module"; }
+
+protected:
+  
+    // called by construction_done 
+    virtual void before_end_of_elaboration();
+
+    void construction_done();
+
+    // called by elaboration_done (does nothing by default)
+    virtual void end_of_elaboration();
+
+    void elaboration_done( bool& );
+
+    // called by start_simulation (does nothing by default)
+    virtual void start_of_simulation();
+
+    void start_simulation();
+
+    // called by simulation_done (does nothing by default)
+    virtual void end_of_simulation();
+
+    void simulation_done();
+
+    void sc_module_init();
+
+    // constructor
+    sc_module();
+    sc_module( const sc_module_name& nm ); /* for those used to old style */
+
+    /* DEPRECATED */ sc_module( const char* nm ); 
+    /* DEPRECATED */ sc_module( const std::string& nm );
+
+public:
+
+    // destructor
+    virtual ~sc_module();
+
+    // positional binding methods
+
+    sc_module& operator << ( sc_interface& );
+    sc_module& operator << ( sc_port_base& );
+
+    sc_module& operator , ( sc_interface& interface_ )
+        { return operator << ( interface_ ); }
+
+    sc_module& operator , ( sc_port_base& port_ )
+        { return operator << ( port_ ); }
+
+    // operator() is declared at the end of the class.
+
+    const ::std::vector<sc_object*>& get_child_objects() const;
+
+protected:
+
+    // this must be called by user-defined modules
+    void end_module();
+
+
+    // to prevent initialization for SC_METHODs and SC_THREADs
+    void dont_initialize();
+
+    // positional binding code - used by operator ()
+
+    void positional_bind( sc_interface& );
+    void positional_bind( sc_port_base& );
+
+    // set reset sensitivity for SC_xTHREADs
+    void async_reset_signal_is( const sc_in<bool>& port, bool level );
+    void async_reset_signal_is( const sc_inout<bool>& port, bool level );
+    void async_reset_signal_is( const sc_out<bool>& port, bool level );
+    void async_reset_signal_is( const sc_signal_in_if<bool>& iface, bool level);
+    void reset_signal_is( const sc_in<bool>& port, bool level );
+    void reset_signal_is( const sc_inout<bool>& port, bool level );
+    void reset_signal_is( const sc_out<bool>& port, bool level );
+    void reset_signal_is( const sc_signal_in_if<bool>& iface, bool level );
+
+    // static sensitivity for SC_THREADs and SC_CTHREADs
+
+    void wait()
+        { ::sc_core::wait( simcontext() ); }
+
+    // dynamic sensitivity for SC_THREADs and SC_CTHREADs
+
+    void wait( const sc_event& e )
+        { ::sc_core::wait( e, simcontext() ); }
+
+    void wait( const sc_event_or_list& el )
+	{ ::sc_core::wait( el, simcontext() ); }
+
+    void wait( const sc_event_and_list& el )
+	{ ::sc_core::wait( el, simcontext() ); }
+
+    void wait( const sc_time& t )
+        { ::sc_core::wait( t, simcontext() ); }
+
+    void wait( double v, sc_time_unit tu )
+        { ::sc_core::wait( sc_time( v, tu, simcontext() ), simcontext() ); }
+
+    void wait( const sc_time& t, const sc_event& e )
+        { ::sc_core::wait( t, e, simcontext() ); }
+
+    void wait( double v, sc_time_unit tu, const sc_event& e )
+        { ::sc_core::wait( 
+		sc_time( v, tu, simcontext() ), e, simcontext() ); }
+
+    void wait( const sc_time& t, const sc_event_or_list& el )
+        { ::sc_core::wait( t, el, simcontext() ); }
+
+    void wait( double v, sc_time_unit tu, const sc_event_or_list& el )
+        { ::sc_core::wait( sc_time( v, tu, simcontext() ), el, simcontext() ); }
+
+    void wait( const sc_time& t, const sc_event_and_list& el )
+        { ::sc_core::wait( t, el, simcontext() ); }
+
+    void wait( double v, sc_time_unit tu, const sc_event_and_list& el )
+        { ::sc_core::wait( sc_time( v, tu, simcontext() ), el, simcontext() ); }
+
+
+    // static sensitivity for SC_METHODs
+
+    void next_trigger()
+	{ ::sc_core::next_trigger( simcontext() ); }
+
+
+    // dynamic sensitivty for SC_METHODs
+
+    void next_trigger( const sc_event& e )
+        { ::sc_core::next_trigger( e, simcontext() ); }
+
+    void next_trigger( const sc_event_or_list& el )
+        { ::sc_core::next_trigger( el, simcontext() ); }
+
+    void next_trigger( const sc_event_and_list& el )
+        { ::sc_core::next_trigger( el, simcontext() ); }
+
+    void next_trigger( const sc_time& t )
+        { ::sc_core::next_trigger( t, simcontext() ); }
+
+    void next_trigger( double v, sc_time_unit tu )
+        { ::sc_core::next_trigger( 
+	    sc_time( v, tu, simcontext() ), simcontext() ); }
+
+    void next_trigger( const sc_time& t, const sc_event& e )
+        { ::sc_core::next_trigger( t, e, simcontext() ); }
+
+    void next_trigger( double v, sc_time_unit tu, const sc_event& e )
+        { ::sc_core::next_trigger( 
+		sc_time( v, tu, simcontext() ), e, simcontext() ); }
+
+    void next_trigger( const sc_time& t, const sc_event_or_list& el )
+        { ::sc_core::next_trigger( t, el, simcontext() ); }
+
+    void next_trigger( double v, sc_time_unit tu, const sc_event_or_list& el )
+        { ::sc_core::next_trigger( 
+	    sc_time( v, tu, simcontext() ), el, simcontext() ); }
+
+    void next_trigger( const sc_time& t, const sc_event_and_list& el )
+        { ::sc_core::next_trigger( t, el, simcontext() ); }
+
+    void next_trigger( double v, sc_time_unit tu, const sc_event_and_list& el )
+        { ::sc_core::next_trigger( 
+	    sc_time( v, tu, simcontext() ), el, simcontext() ); }
+
+
+    // for SC_METHODs and SC_THREADs and SC_CTHREADs
+
+    bool timed_out()
+        { return ::sc_core::timed_out(); }
+
+
+    // for SC_CTHREADs
+
+    void halt()
+        { ::sc_core::halt( simcontext() ); }
+
+    void wait( int n )
+        { ::sc_core::wait( n, simcontext() ); }
+
+    void at_posedge( const sc_signal_in_if<bool>& s )
+	{ ::sc_core::at_posedge( s, simcontext() ); }
+
+    void at_posedge( const sc_signal_in_if<sc_dt::sc_logic>& s )
+	{ ::sc_core::at_posedge( s, simcontext() ); }
+
+    void at_negedge( const sc_signal_in_if<bool>& s )
+	{ ::sc_core::at_negedge( s, simcontext() ); }
+
+    void at_negedge( const sc_signal_in_if<sc_dt::sc_logic>& s )
+	{ ::sc_core::at_negedge( s, simcontext() ); }
+
+    // Catch uses of watching:
+    void watching( bool /* expr */ )
+        { SC_REPORT_ERROR(SC_ID_WATCHING_NOT_ALLOWED_,""); }
+
+    // These are protected so that user derived classes can refer to them.
+    sc_sensitive     sensitive;
+    sc_sensitive_pos sensitive_pos;
+    sc_sensitive_neg sensitive_neg;
+
+    // Function to set the stack size of the current (c)thread process.
+    void set_stack_size( std::size_t );
+
+    int append_port( sc_port_base* );
+
+private:
+    sc_module( const sc_module& );
+    const sc_module& operator = ( const sc_module& );
+
+private:
+
+    bool                        m_end_module_called;
+    std::vector<sc_port_base*>* m_port_vec;
+    int                         m_port_index;
+    sc_name_gen*                m_name_gen;
+    sc_module_name*             m_module_name_p;
+
+public:
+
+    void defunct() { }
+
+    // positional binding methods (cont'd)
+
+    void operator () ( const sc_bind_proxy& p001,
+		       const sc_bind_proxy& p002 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p003 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p004 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p005 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p006 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p007 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p008 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p009 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p010 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p011 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p012 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p013 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p014 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p015 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p016 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p017 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p018 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p019 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p020 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p021 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p022 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p023 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p024 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p025 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p026 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p027 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p028 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p029 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p030 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p031 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p032 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p033 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p034 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p035 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p036 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p037 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p038 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p039 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p040 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p041 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p042 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p043 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p044 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p045 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p046 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p047 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p048 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p049 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p050 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p051 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p052 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p053 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p054 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p055 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p056 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p057 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p058 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p059 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p060 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p061 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p062 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p063 = SC_BIND_PROXY_NIL,
+		       const sc_bind_proxy& p064 = SC_BIND_PROXY_NIL );
+
+};
+
+extern sc_module* sc_module_dynalloc(sc_module*);
+#define SC_NEW(x)  ::sc_core::sc_module_dynalloc(new x);
+
+
+// -----------------------------------------------------------------------------
+// SOME MACROS TO SIMPLIFY SYNTAX:
+// -----------------------------------------------------------------------------
+
+#define SC_MODULE(user_module_name)                                           \
+    struct user_module_name : ::sc_core::sc_module
+
+#define SC_CTOR(user_module_name)                                             \
+    typedef user_module_name SC_CURRENT_USER_MODULE;                          \
+    user_module_name( ::sc_core::sc_module_name )
+
+// the SC_HAS_PROCESS macro call must be followed by a ;
+#define SC_HAS_PROCESS(user_module_name)                                      \
+    typedef user_module_name SC_CURRENT_USER_MODULE
+
+// The this-> construct on sensitive operators in the macros below is
+// required for gcc 4.x when a templated class has a templated parent that is
+// derived from sc_module:
+//
+// template<typename X>
+// class B : public sc_module;
+// template<typename X>
+// class A : public B<X>
+
+#define declare_method_process(handle, name, host_tag, func)        \
+    {		                                                    \
+        ::sc_core::sc_process_handle handle =                      \
+	    sc_core::sc_get_curr_simcontext()->create_method_process( \
+		name,  false, SC_MAKE_FUNC_PTR( host_tag, func ), \
+		this, 0 ); \
+        this->sensitive << handle;                                        \
+        this->sensitive_pos << handle;                                    \
+        this->sensitive_neg << handle;                                    \
+    }
+
+#define declare_thread_process(handle, name, host_tag, func)        \
+    {                                                               \
+        ::sc_core::sc_process_handle handle =                      \
+	     sc_core::sc_get_curr_simcontext()->create_thread_process( \
+                 name,  false,           \
+                 SC_MAKE_FUNC_PTR( host_tag, func ), this, 0 ); \
+        this->sensitive << handle;                                        \
+        this->sensitive_pos << handle;                                    \
+        this->sensitive_neg << handle;                                    \
+    }
+
+#define declare_cthread_process(handle, name, host_tag, func, edge) \
+    {                                                               \
+        ::sc_core::sc_process_handle handle =                     \
+	     sc_core::sc_get_curr_simcontext()->create_cthread_process( \
+            name,  false,          \
+                     SC_MAKE_FUNC_PTR( host_tag, func ), this, 0 ); \
+        this->sensitive.operator() ( handle, edge );\
+    }
+
+#define SC_CTHREAD(func, edge)                                                \
+    declare_cthread_process( func ## _handle,                                 \
+                             #func,                                           \
+                             SC_CURRENT_USER_MODULE,                          \
+                             func,                                            \
+                             edge )
+
+#define SC_METHOD(func)                                                       \
+    declare_method_process( func ## _handle,                                  \
+                            #func,                                            \
+                            SC_CURRENT_USER_MODULE,                           \
+                            func )
+
+#define SC_THREAD(func)                                                       \
+    declare_thread_process( func ## _handle,                                  \
+                            #func,                                            \
+                            SC_CURRENT_USER_MODULE,                           \
+                            func )
+
+
+
+// ----------------------------------------------------------------------------
+//  TYPEDEFS
+// ----------------------------------------------------------------------------
+
+typedef sc_module sc_channel;
+typedef sc_module sc_behavior;
+
+} // namespace sc_core
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Ali Dasdan, Synopsys, Inc.
+  Description of Modification: - Implementation of operator() and operator,
+                                 positional connection method.
+                               - Implementation of error checking in
+                                 operator<<'s.
+                               - Implementation of the function test_module_prm.
+                               - Implementation of set_stack_size().
+
+      Name, Affiliation, Date: Gene Bushuyev, Synopsys, Inc.
+  Description of Modification: - Change implementation for VC6.
+
+      Name, Affiliation, Date: Andy Godorich, Forte
+                               Bishnupriya Bhattacharya, Cadence Design Systems,
+                               25 August, 2003
+  Description of Modification: inherit from sc_process_host as a part of
+                               implementing dynamic processes
+
+ *****************************************************************************/
+
+// $Log: sc_module.h,v $
+// Revision 1.11  2011/08/26 20:46:10  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.10  2011/08/15 16:43:24  acg
+//  Torsten Maehne: changes to remove unused argument warnings.
+//
+// Revision 1.9  2011/03/05 19:44:20  acg
+//  Andy Goodrich: changes for object and event naming and structures.
+//
+// Revision 1.8  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.7  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.6  2011/01/18 20:10:44  acg
+//  Andy Goodrich: changes for IEEE1666_2011 semantics.
+//
+// Revision 1.5  2010/12/07 20:09:12  acg
+// Andy Goodrich: remove unused signal declaration
+//
+// Revision 1.4  2009/05/22 16:06:29  acg
+//  Andy Goodrich: process control updates.
+//
+// Revision 1.3  2008/05/22 17:06:25  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.2  2007/01/24 20:14:40  acg
+//  Andy Goodrich: improved comments about the use of this-> in the macros
+//  that access sensitive.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.10  2006/12/02 20:58:18  acg
+//  Andy Goodrich: updates from 2.2 for IEEE 1666 support.
+//
+// Revision 1.7  2006/04/11 23:13:21  acg
+//   Andy Goodrich: Changes for reduced reset support that only includes
+//   sc_cthread, but has preliminary hooks for expanding to method and thread
+//   processes also.
+//
+// Revision 1.6  2006/03/15 17:53:34  acg
+//  Andy Goodrich, Forte Design
+//  Reordered includes to pick up <cassert> for use by sc_process_name.h
+//
+// Revision 1.5  2006/03/14 23:56:58  acg
+//   Andy Goodrich: This fixes a bug when an exception is thrown in
+//   sc_module::sc_module() for a dynamically allocated sc_module
+//   object. We are calling sc_module::end_module() on a module that has
+//   already been deleted. The scenario runs like this:
+//
+//   a) the sc_module constructor is entered
+//   b) the exception is thrown
+//   c) the exception processor deletes the storage for the sc_module
+//   d) the stack is unrolled causing the sc_module_name instance to be deleted
+//   e) ~sc_module_name() calls end_module() with its pointer to the sc_module
+//   f) because the sc_module has been deleted its storage is corrupted,
+//      either by linking it to a free space chain, or by reuse of some sort
+//   g) the m_simc field is garbage
+//   h) the m_object_manager field is also garbage
+//   i) an exception occurs
+//
+//   This does not happen for automatic sc_module instances since the
+//   storage for the module is not reclaimed its just part of the stack.
+//
+//   I am fixing this by having the destructor for sc_module clear the
+//   module pointer in its sc_module_name instance. That cuts things at
+//   step (e) above, since the pointer will be null if the module has
+//   already been deleted. To make sure the module stack is okay, I call
+//   end-module() in ~sc_module in the case where there is an
+//   sc_module_name pointer lying around.
+//
+// Revision 1.4  2006/01/24 20:49:05  acg
+// Andy Goodrich: changes to remove the use of deprecated features within the
+// simulator, and to issue warning messages when deprecated features are used.
+//
+// Revision 1.3  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+
+#endif
diff --git a/ext/systemc/src/sysc/kernel/sc_module_name.cpp b/ext/systemc/src/sysc/kernel/sc_module_name.cpp
new file mode 100644
index 000000000..a5352690f
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_module_name.cpp
@@ -0,0 +1,123 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_module_name.cpp -- An object used to help manage object names 
+                        and hierarchy
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+#include <cstdlib>
+
+#include "sysc/kernel/sc_kernel_ids.h"
+#include "sysc/kernel/sc_module.h"
+#include "sysc/kernel/sc_module_name.h"
+#include "sysc/kernel/sc_object_manager.h"
+#include "sysc/kernel/sc_simcontext.h"
+#include "sysc/utils/sc_iostream.h"
+
+namespace sc_core {
+
+sc_module_name::sc_module_name( const char* name_ )
+: m_name( name_ ),
+  m_module_p( 0 ),
+  m_next( 0 ),
+  m_simc( sc_get_curr_simcontext() ),
+  m_pushed( true )
+{
+    m_simc->get_object_manager()->push_module_name( this );
+}
+
+sc_module_name::sc_module_name( const sc_module_name& name_ )
+: m_name( name_.m_name ),
+  m_module_p( 0 ),
+  m_next( 0 ),
+  m_simc( name_.m_simc ),
+  m_pushed( false )
+{}
+
+sc_module_name::~sc_module_name()
+{
+    if( m_pushed ) {
+        sc_module_name* smn = m_simc->get_object_manager()->pop_module_name();
+        if( this != smn ) {
+            SC_REPORT_ERROR( SC_ID_SC_MODULE_NAME_USE_, 0 );
+        }
+	if ( m_module_p ) m_module_p->end_module();
+    }
+}
+
+sc_module_name::operator const char*() const
+{
+    return m_name;
+}
+
+} // namespace sc_core
+
+// $Log: sc_module_name.cpp,v $
+// Revision 1.5  2011/08/26 20:46:10  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.4  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.3  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.2  2008/05/22 17:06:26  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.4  2006/03/14 23:56:58  acg
+//   Andy Goodrich: This fixes a bug when an exception is thrown in
+//   sc_module::sc_module() for a dynamically allocated sc_module
+//   object. We are calling sc_module::end_module() on a module that has
+//   already been deleted. The scenario runs like this:
+//
+//   a) the sc_module constructor is entered
+//   b) the exception is thrown
+//   c) the exception processor deletes the storage for the sc_module
+//   d) the stack is unrolled causing the sc_module_name instance to be deleted
+//   e) ~sc_module_name() calls end_module() with its pointer to the sc_module
+//   f) because the sc_module has been deleted its storage is corrupted,
+//      either by linking it to a free space chain, or by reuse of some sort
+//   g) the m_simc field is garbage
+//   h) the m_object_manager field is also garbage
+//   i) an exception occurs
+//
+//   This does not happen for automatic sc_module instances since the
+//   storage for the module is not reclaimed its just part of the stack.
+//
+//   I am fixing this by having the destructor for sc_module clear the
+//   module pointer in its sc_module_name instance. That cuts things at
+//   step (e) above, since the pointer will be null if the module has
+//   already been deleted. To make sure the module stack is okay, I call
+//   end-module() in ~sc_module in the case where there is an
+//   sc_module_name pointer lying around.
+//
+// Revision 1.3  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+//
diff --git a/ext/systemc/src/sysc/kernel/sc_module_name.h b/ext/systemc/src/sysc/kernel/sc_module_name.h
new file mode 100644
index 000000000..a2149cc6a
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_module_name.h
@@ -0,0 +1,140 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_module_name.h -- An object used to help manage object names 
+                      and hierarchy.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+// $Log: sc_module_name.h,v $
+// Revision 1.5  2011/08/26 20:46:10  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+
+#ifndef SC_MODULE_NAME_H
+#define SC_MODULE_NAME_H
+
+
+namespace sc_core {
+
+class sc_module;
+class sc_simcontext;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_module_name
+//
+//  Module name class.
+// ----------------------------------------------------------------------------
+
+class sc_module_name
+{
+    friend class sc_module;
+    friend class sc_object_manager;
+
+public:
+
+    sc_module_name( const char* );
+    sc_module_name( const sc_module_name& );
+
+    ~sc_module_name();
+
+    operator const char*() const;
+
+protected:
+    inline void clear_module( sc_module* module_p );
+    inline void set_module( sc_module* module_p );
+
+private:
+
+    const char*     m_name;
+    sc_module*      m_module_p;
+    sc_module_name* m_next;
+    sc_simcontext*  m_simc;
+    bool            m_pushed;
+
+private:
+
+    // disabled
+    sc_module_name();
+    sc_module_name& operator = ( const sc_module_name& );
+};
+
+inline void sc_module_name::clear_module( sc_module* module_p )
+{
+    assert( m_module_p == module_p );
+    m_module_p = 0;
+}
+
+inline void sc_module_name::set_module( sc_module* module_p )
+{
+    m_module_p = module_p;
+}
+
+} // namespace sc_core
+
+// Revision 1.4  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.3  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.2  2008/05/22 17:06:26  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.4  2006/03/14 23:56:58  acg
+//   Andy Goodrich: This fixes a bug when an exception is thrown in
+//   sc_module::sc_module() for a dynamically allocated sc_module
+//   object. We are calling sc_module::end_module() on a module that has
+//   already been deleted. The scenario runs like this:
+//
+//   a) the sc_module constructor is entered
+//   b) the exception is thrown
+//   c) the exception processor deletes the storage for the sc_module
+//   d) the stack is unrolled causing the sc_module_name instance to be deleted
+//   e) ~sc_module_name() calls end_module() with its pointer to the sc_module
+//   f) because the sc_module has been deleted its storage is corrupted,
+//      either by linking it to a free space chain, or by reuse of some sort
+//   g) the m_simc field is garbage
+//   h) the m_object_manager field is also garbage
+//   i) an exception occurs
+//
+//   This does not happen for automatic sc_module instances since the
+//   storage for the module is not reclaimed its just part of the stack.
+//
+//   I am fixing this by having the destructor for sc_module clear the
+//   module pointer in its sc_module_name instance. That cuts things at
+//   step (e) above, since the pointer will be null if the module has
+//   already been deleted. To make sure the module stack is okay, I call
+//   end-module() in ~sc_module in the case where there is an
+//   sc_module_name pointer lying around.
+//
+// Revision 1.3  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+
+#endif
diff --git a/ext/systemc/src/sysc/kernel/sc_module_registry.cpp b/ext/systemc/src/sysc/kernel/sc_module_registry.cpp
new file mode 100644
index 000000000..2d8b02c34
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_module_registry.cpp
@@ -0,0 +1,184 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_module_registry.cpp -- Registry for all modules.
+                            FOR INTERNAL USE ONLY.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#include "sysc/kernel/sc_kernel_ids.h"
+#include "sysc/kernel/sc_module.h"
+#include "sysc/kernel/sc_module_registry.h"
+#include "sysc/kernel/sc_simcontext.h"
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_module_registry
+//
+//  Registry for all modules.
+//  FOR INTERNAL USE ONLY!
+// ----------------------------------------------------------------------------
+
+void
+sc_module_registry::insert( sc_module& module_ )
+{
+    if( sc_is_running() ) {
+	SC_REPORT_ERROR( SC_ID_INSERT_MODULE_, "simulation running" );
+    }
+
+    if( m_simc->elaboration_done() ) {
+       SC_REPORT_ERROR( SC_ID_INSERT_MODULE_, "elaboration done" );
+    }
+
+#ifdef DEBUG_SYSTEMC
+    // check if module_ is already inserted
+    for( int i = size() - 1; i >= 0; -- i ) {
+	if( &module_ == m_module_vec[i] ) {
+	    SC_REPORT_ERROR( SC_ID_INSERT_MODULE_, "already inserted" );
+	}
+    }
+#endif
+
+    // insert
+    m_module_vec.push_back( &module_ );
+}
+
+void
+sc_module_registry::remove( sc_module& module_ )
+{
+    int i;
+    for( i = 0; i < size(); ++ i ) {
+	if( &module_ == m_module_vec[i] ) {
+	    break;
+	}
+    }
+    if( i == size() ) {
+	SC_REPORT_ERROR( SC_ID_REMOVE_MODULE_, 0 );
+    }
+
+    // remove
+    m_module_vec[i] = m_module_vec[size() - 1];
+    m_module_vec.resize(m_module_vec.size()-1);
+}
+
+
+// constructor
+
+sc_module_registry::sc_module_registry( sc_simcontext& simc_ )
+ : m_construction_done(0), m_module_vec(), m_simc( &simc_ )
+{}
+
+
+// destructor
+
+sc_module_registry::~sc_module_registry()
+{}
+
+// called when construction is done
+
+bool
+sc_module_registry::construction_done()
+{
+    if( size() == m_construction_done )
+        // nothing has been updated
+        return true;
+
+    for( ; m_construction_done < size(); ++m_construction_done ) {
+        m_module_vec[m_construction_done]->construction_done();
+    }
+    return false;
+}
+
+// called when elaboration is done
+
+void
+sc_module_registry::elaboration_done()
+{
+    bool error = false;
+    for( int i = 0; i < size(); ++ i ) {
+	m_module_vec[i]->elaboration_done( error );
+    }
+}
+
+// called before simulation begins
+
+void
+sc_module_registry::start_simulation()
+{
+    for( int i = 0; i < size(); ++ i ) {
+	m_module_vec[i]->start_simulation();
+    }
+}
+
+// called after simulation ends
+
+void
+sc_module_registry::simulation_done()
+{
+    for( int i = 0; i < size(); ++ i ) {
+	m_module_vec[i]->simulation_done();
+    }
+}
+
+} // namespace sc_core
+
+// $Log: sc_module_registry.cpp,v $
+// Revision 1.8  2011/08/26 20:46:10  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.7  2011/08/24 22:05:51  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.6  2011/05/09 04:07:49  acg
+//  Philipp A. Hartmann:
+//    (1) Restore hierarchy in all phase callbacks.
+//    (2) Ensure calls to before_end_of_elaboration.
+//
+// Revision 1.5  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.4  2011/02/14 17:51:40  acg
+//  Andy Goodrich: proper pushing an poppping of the module hierarchy for
+//  start_of_simulation() and end_of_simulation.
+//
+// Revision 1.3  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.2  2008/05/22 17:06:26  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.4  2006/01/26 21:04:54  acg
+//  Andy Goodrich: deprecation message changes and additional messages.
+//
+// Revision 1.3  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+//
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_module_registry.h b/ext/systemc/src/sysc/kernel/sc_module_registry.h
new file mode 100644
index 000000000..3e1bb5dff
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_module_registry.h
@@ -0,0 +1,124 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_module_registry.h -- Registry for all modules.
+                          FOR INTERNAL USE ONLY.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#ifndef SC_MODULE_REGISTRY_H
+#define SC_MODULE_REGISTRY_H
+
+
+namespace sc_core {
+
+class sc_module;
+class sc_simcontext;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_module_registry
+//
+//  Registry for all modules.
+//  FOR INTERNAL USE ONLY!
+// ----------------------------------------------------------------------------
+
+class sc_module_registry
+{
+    friend class sc_simcontext;
+
+public:
+
+    void insert( sc_module& );
+    void remove( sc_module& );
+
+    int size() const
+        { return m_module_vec.size(); }
+
+private:
+
+    // constructor
+    explicit sc_module_registry( sc_simcontext& simc_ );
+
+    // destructor
+    ~sc_module_registry();
+
+    // called when construction is done
+    bool construction_done();
+
+    // called when elaboration is done
+    void elaboration_done();
+
+    // called before simulation begins
+    void start_simulation();
+
+    // called after simulation ends
+    void simulation_done();
+
+
+private:
+
+    int                     m_construction_done;
+    std::vector<sc_module*> m_module_vec;
+    sc_simcontext*          m_simc;
+
+private:
+
+    // disabled
+    sc_module_registry();
+    sc_module_registry( const sc_module_registry& );
+    sc_module_registry& operator = ( const sc_module_registry& );
+};
+
+} // namespace sc_core
+
+#endif
+
+// $Log: sc_module_registry.h,v $
+// Revision 1.6  2011/08/26 20:46:10  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.5  2011/05/09 04:07:49  acg
+//  Philipp A. Hartmann:
+//    (1) Restore hierarchy in all phase callbacks.
+//    (2) Ensure calls to before_end_of_elaboration.
+//
+// Revision 1.4  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.3  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.2  2008/05/22 17:06:26  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_name_gen.cpp b/ext/systemc/src/sysc/kernel/sc_name_gen.cpp
new file mode 100644
index 000000000..16f6ad78f
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_name_gen.cpp
@@ -0,0 +1,109 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_name_gen.cpp -- Unique name generator.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#include "sysc/kernel/sc_kernel_ids.h"
+#include "sysc/kernel/sc_name_gen.h"
+#include "sysc/utils/sc_iostream.h"
+
+#if defined(_MSC_VER) && _MSC_VER >= 1310
+// "C4351: new behavior: elements of array will be default initialized"
+#pragma warning(disable: 4351)
+#endif
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_name_gen
+//
+//  Unique name generator class.
+// ----------------------------------------------------------------------------
+
+sc_name_gen::sc_name_gen() : m_unique_name_map(), m_unique_name()
+{}
+
+sc_name_gen::~sc_name_gen()
+{
+    sc_strhash<int*>::iterator it( m_unique_name_map );
+    for( ; ! it.empty(); it ++ ) {
+	delete it.contents();
+    }
+    m_unique_name_map.erase();
+}
+
+
+// to generate unique names for objects in an MT-Safe way
+
+const char*
+sc_name_gen::gen_unique_name( const char* basename_, bool preserve_first )
+{
+    if( basename_ == 0 ) {
+	SC_REPORT_ERROR( SC_ID_GEN_UNIQUE_NAME_, 0 );
+    }
+    int* c = m_unique_name_map[basename_];
+    if( c == 0 ) {
+	c = new int( 0 );
+	m_unique_name_map.insert( CCAST<char*>( basename_ ), c );
+	if (preserve_first) {
+	    std::sprintf( m_unique_name, "%s", basename_ );
+	} else {    
+            std::sprintf( m_unique_name, "%s_%d", basename_, *c );
+        }
+    } else {
+        std::sprintf( m_unique_name, "%s_%d", basename_, ++ (*c) );
+    }
+    return m_unique_name;
+}
+
+} // namespace sc_core
+
+// $Log: sc_name_gen.cpp,v $
+// Revision 1.6  2011/08/26 20:46:10  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.5  2011/08/24 22:05:51  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.4  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.3  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.2  2008/05/22 17:06:26  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+//
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_name_gen.h b/ext/systemc/src/sysc/kernel/sc_name_gen.h
new file mode 100644
index 000000000..0910e014a
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_name_gen.h
@@ -0,0 +1,93 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_name_gen.h -- Unique name generator.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#ifndef SC_NAME_GEN
+#define SC_NAME_GEN
+
+
+#include <cstdio>
+
+#include "sysc/utils/sc_hash.h"
+
+namespace sc_core{
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_name_gen
+//
+//  Unique name generator class.
+// ----------------------------------------------------------------------------
+
+class sc_name_gen
+{
+public:
+
+    sc_name_gen();
+    ~sc_name_gen();
+
+    const char* gen_unique_name( const char* basename_, 
+                                 bool preserve_first = false 
+                               );
+
+private:
+
+    sc_strhash<int*> m_unique_name_map;
+    char             m_unique_name[BUFSIZ];
+
+private:
+
+    // disabled
+    sc_name_gen( const sc_name_gen& );
+    sc_name_gen& operator = ( const sc_name_gen& );
+};
+
+} // namespace sc_core
+
+// $Log: sc_name_gen.h,v $
+// Revision 1.5  2011/08/26 20:46:10  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.4  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.3  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.2  2008/05/22 17:06:26  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_object.cpp b/ext/systemc/src/sysc/kernel/sc_object.cpp
new file mode 100644
index 000000000..e624d12b5
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_object.cpp
@@ -0,0 +1,568 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_object.cpp -- Abstract base class of all SystemC objects.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#include <cstdlib>
+#include <cassert>
+#include <stddef.h>
+#include <cstdio>
+#include <string.h>
+#include <ctype.h>
+
+#include "sysc/kernel/sc_externs.h"
+#include "sysc/kernel/sc_kernel_ids.h"
+#include "sysc/kernel/sc_module.h"
+#include "sysc/kernel/sc_object.h"
+#include "sysc/kernel/sc_object_manager.h"
+#include "sysc/kernel/sc_phase_callback_registry.h"
+#include "sysc/kernel/sc_process_handle.h"
+#include "sysc/kernel/sc_simcontext.h"
+#include "sysc/kernel/sc_event.h"
+#include "sysc/utils/sc_hash.h"
+#include "sysc/utils/sc_iostream.h"
+#include "sysc/utils/sc_list.h"
+#include "sysc/utils/sc_utils_ids.h"
+#include "sysc/utils/sc_mempool.h"
+
+namespace sc_core {
+
+typedef int (*STRCMP)(const void*, const void*);
+
+const char SC_HIERARCHY_CHAR = '.';
+
+/* This will be gotten rid after multiple-processes
+   are implemented.  This is to fix some regression
+   problems. */
+bool sc_enable_name_checking = true;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_object
+//
+//  Abstract base class of all SystemC `simulation' objects.
+// ----------------------------------------------------------------------------
+
+void
+sc_object::add_child_event( sc_event* event_p )
+{
+    // no check if event_p is already in the set
+    m_child_events.push_back( event_p );
+}
+
+void
+sc_object::add_child_object( sc_object* object_ )
+{
+    // no check if object_ is already in the set
+    m_child_objects.push_back( object_ );
+}
+
+const char*
+sc_object::basename() const
+{
+    size_t pos; // position of last SC_HIERARCHY_CHAR.
+    pos = m_name.rfind( (char)SC_HIERARCHY_CHAR );
+    return ( pos == m_name.npos ) ? m_name.c_str() : &(m_name.c_str()[pos+1]);
+} 
+
+void
+sc_object::print(::std::ostream& os) const
+{
+    os << name();
+}
+
+void
+sc_object::dump(::std::ostream& os) const
+{
+    os << "name = " << name() << "\n";
+    os << "kind = " << kind() << "\n";
+}
+
+static int sc_object_num = 0;
+
+static std::string
+sc_object_newname()
+{
+    char        buffer[64];
+    std::string result;
+
+    std::sprintf(buffer, "{%d}", sc_object_num);
+    sc_object_num++;
+    result = buffer;
+
+    return result;
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_object::remove_child_event"
+// | 
+// | This virtual method removes the supplied event from the list of child
+// | events if it is present.
+// |
+// | Arguments:
+// |     event_p -> event to be removed.
+// | Returns true if the event was present, false if not.
+// +----------------------------------------------------------------------------
+bool
+sc_object::remove_child_event( sc_event* event_p )
+{
+    int size = m_child_events.size();
+    for( int i = 0; i < size; ++ i ) {
+        if( event_p == m_child_events[i] ) {
+            m_child_events[i] = m_child_events[size - 1];
+            m_child_events.pop_back();
+            return true;
+        }
+    }
+    return false;
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_object::remove_child_object"
+// | 
+// | This virtual method removes the supplied object from the list of child
+// | objects if it is present.
+// |
+// | Arguments:
+// |     object_p -> object to be removed.
+// | Returns true if the object was present, false if not.
+// +----------------------------------------------------------------------------
+bool
+sc_object::remove_child_object( sc_object* object_p )
+{
+    int size = m_child_objects.size();
+    for( int i = 0; i < size; ++ i ) {
+        if( object_p == m_child_objects[i] ) {
+            m_child_objects[i] = m_child_objects[size - 1];
+            m_child_objects.pop_back();
+	    object_p->m_parent = NULL;
+            return true;
+        }
+    }
+    return false;
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_object::sc_object_init"
+// | 
+// | This method initializes this object instance and places it in to the
+// | object hierarchy if the supplied name is not NULL.
+// |
+// | Arguments:
+// |     nm = leaf name for the object.
+// +----------------------------------------------------------------------------
+void 
+sc_object::sc_object_init(const char* nm) 
+{ 
+    // SET UP POINTERS TO OBJECT MANAGER, PARENT, AND SIMULATION CONTEXT: 
+    //
+    // Make the current simcontext the simcontext for this object 
+
+    m_simc = sc_get_curr_simcontext(); 
+    m_attr_cltn_p = 0; 
+    sc_object_manager* object_manager = m_simc->get_object_manager(); 
+    m_parent = m_simc->active_object();
+
+    // CONSTRUCT PATHNAME TO OBJECT BEING CREATED: 
+    // 
+    // If there is not a leaf name generate one. 
+
+    m_name = object_manager->create_name(nm ? nm : sc_object_newname().c_str());
+
+
+    // PLACE THE OBJECT INTO THE HIERARCHY
+
+    object_manager->insert_object(m_name, this);
+    if ( m_parent )
+        m_parent->add_child_object( this );
+    else
+        m_simc->add_child_object( this );
+} 
+
+sc_object::sc_object() : 
+    m_attr_cltn_p(0), m_child_events(), m_child_objects(), m_name(),
+    m_parent(0), m_simc(0)
+{
+    sc_object_init( sc_gen_unique_name("object") );
+}
+
+sc_object::sc_object( const sc_object& that ) : 
+    m_attr_cltn_p(0), m_child_events(), m_child_objects(), m_name(),
+    m_parent(0), m_simc(0)
+{
+    sc_object_init( sc_gen_unique_name( that.basename() ) );
+}
+
+
+static bool
+object_name_illegal_char(char ch)
+{
+    return (ch == SC_HIERARCHY_CHAR) || isspace(ch);
+}
+
+sc_object::sc_object(const char* nm) : 
+    m_attr_cltn_p(0), m_child_events(), m_child_objects(), m_name(),
+    m_parent(0), m_simc(0)
+{
+    int namebuf_alloc = 0;
+    char* namebuf = 0;
+    const char* p;
+
+    // null name or "" uses machine generated name.
+    
+    if ( !nm || !*nm )
+	nm = sc_gen_unique_name("object");
+    p = nm;
+
+    if (nm && sc_enable_name_checking) {
+        namebuf_alloc = 1 + strlen(nm);
+        namebuf = (char*) sc_mempool::allocate(namebuf_alloc);
+        char* q = namebuf;
+        const char* r = nm;
+        bool has_illegal_char = false;
+        while (*r) {
+            if (object_name_illegal_char(*r)) {
+                has_illegal_char = true;
+                *q = '_';
+            } else {
+                *q = *r;
+            }
+            r++;
+            q++;
+        }
+        *q = '\0';
+        p = namebuf;
+        if (has_illegal_char)
+	{
+	    std::string message = nm;
+	    message += " substituted by ";
+	    message += namebuf;
+            SC_REPORT_WARNING( SC_ID_ILLEGAL_CHARACTERS_, message.c_str());
+	}
+    }
+    sc_object_init(p);
+    sc_mempool::release( namebuf, namebuf_alloc );
+}
+
+sc_object::~sc_object()
+{
+#if SC_HAS_PHASE_CALLBACKS_
+    unregister_simulation_phase_callback( SC_STATUS_ANY );
+#endif
+    detach();
+    delete m_attr_cltn_p;
+}
+
+//------------------------------------------------------------------------------
+//"sc_object::detach"
+//
+// This method detaches this object instance from the object hierarchy.
+// It is called in two places: ~sc_object() and sc_process_b::kill_process().
+//------------------------------------------------------------------------------
+void sc_object::detach()
+{
+    if (m_simc) {
+
+        // REMOVE OBJECT FROM THE OBJECT MANAGER:
+
+        sc_object_manager* object_manager = m_simc->get_object_manager();
+        object_manager->remove_object(m_name);
+
+		// REMOVE OBJECT FROM PARENT'S LIST OF OBJECTS:
+
+        if ( m_parent )
+	    m_parent->remove_child_object( this );
+	else
+	    m_simc->remove_child_object( this );
+
+        // ORPHAN THIS OBJECT'S CHILDREN:
+
+#if 0 // ####
+	    ::std::<sc_object*> children_p = &get_child_objects();
+		int                 child_n = children_p->size();
+		sc_object*          parent_p;
+
+		for ( int child_i = 0; child_i < child_n; child_i++ )
+		{
+			(*children_p)[child_i]->m_parent = 0;
+		}
+#endif
+
+    }
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_object::orphan_child_events"
+// | 
+// | This method moves the children of this object instance to be children
+// | of the simulator.
+// +----------------------------------------------------------------------------
+void sc_object::orphan_child_events()
+{
+    std::vector< sc_event* > const & events = get_child_events();
+
+    std::vector< sc_event* >::const_iterator
+            it  = events.begin(), end = events.end();
+
+    for( ; it != end; ++it  )
+    {
+        (*it)->m_parent_p = NULL;
+        simcontext()->add_child_event(*it);
+    }
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_object::orphan_child_objects"
+// | 
+// | This method moves the children of this object instance to be children
+// | of the simulator.
+// +----------------------------------------------------------------------------
+void sc_object::orphan_child_objects()
+{
+    std::vector< sc_object* > const & children = get_child_objects();
+
+    std::vector< sc_object* >::const_iterator
+            it  = children.begin(), end = children.end();
+
+    for( ; it != end; ++it  )
+    {
+        (*it)->m_parent = NULL;
+        simcontext()->add_child_object(*it);
+    }
+}
+
+void
+sc_object::trace( sc_trace_file * /* unused */) const
+{
+    /* This space is intentionally left blank */
+}
+
+
+// add attribute
+
+bool
+sc_object::add_attribute( sc_attr_base& attribute_ )
+{
+    if ( !m_attr_cltn_p ) m_attr_cltn_p = new sc_attr_cltn;
+    return ( m_attr_cltn_p->push_back( &attribute_ ) );
+}
+
+
+// get attribute by name
+
+sc_attr_base*
+sc_object::get_attribute( const std::string& name_ )
+{
+    if ( !m_attr_cltn_p ) m_attr_cltn_p = new sc_attr_cltn;
+    return ( (*m_attr_cltn_p)[name_] );
+}
+
+const sc_attr_base*
+sc_object::get_attribute( const std::string& name_ ) const
+{
+    if ( !m_attr_cltn_p ) m_attr_cltn_p = new sc_attr_cltn;
+    return ( (*m_attr_cltn_p)[name_] );
+}
+
+
+// remove attribute by name
+
+sc_attr_base*
+sc_object::remove_attribute( const std::string& name_ )
+{
+    if ( m_attr_cltn_p )
+	return ( m_attr_cltn_p->remove( name_ ) );
+    else
+	return 0;
+}
+
+
+// remove all attributes
+
+void
+sc_object::remove_all_attributes()
+{
+    if ( m_attr_cltn_p )
+	m_attr_cltn_p->remove_all();
+}
+
+
+// get the number of attributes
+
+int
+sc_object::num_attributes() const
+{
+    if ( m_attr_cltn_p )
+	return ( m_attr_cltn_p->size() );
+    else
+	return 0;
+}
+
+
+// get the attribute collection
+
+sc_attr_cltn&
+sc_object::attr_cltn()
+{
+    if ( !m_attr_cltn_p ) m_attr_cltn_p = new sc_attr_cltn;
+    return *m_attr_cltn_p;
+}
+
+const sc_attr_cltn&
+sc_object::attr_cltn() const
+{
+    if ( !m_attr_cltn_p ) m_attr_cltn_p = new sc_attr_cltn;
+    return *m_attr_cltn_p;
+}
+
+sc_object*
+sc_object::get_parent() const
+{
+    static bool warn_sc_get_parent_deprecated=true;
+    if ( warn_sc_get_parent_deprecated )
+    {
+        warn_sc_get_parent_deprecated=false;
+        SC_REPORT_INFO(sc_core::SC_ID_IEEE_1666_DEPRECATION_,
+          "sc_object::get_parent() is deprecated, "
+          "use get_parent_object() instead");
+    }
+    return get_parent_object();
+}
+
+// ----------------------------------------------------------------------------
+// simulation phase callbacks
+
+
+sc_object::phase_cb_mask
+sc_object::register_simulation_phase_callback( phase_cb_mask mask )
+{
+    mask = simcontext()->m_phase_cb_registry
+                       ->register_callback(*this, mask);
+    return mask;
+}
+
+
+sc_object::phase_cb_mask
+sc_object::unregister_simulation_phase_callback( phase_cb_mask mask )
+{
+    mask = simcontext()->m_phase_cb_registry
+                       ->unregister_callback(*this, mask);
+    return mask;
+}
+
+
+void
+sc_object::simulation_phase_callback()
+{
+    SC_REPORT_WARNING( SC_ID_PHASE_CALLBACK_NOT_IMPLEMENTED_, name() );
+}
+
+
+} // namespace sc_core
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Bishnupriya Bhattacharya, Cadence Design Systems,
+                               25 August, 2003
+  Description of Modification: if module name hierarchy is empty, sc_object 
+                               ctor assumes the currently executing process 
+                               as the parent object to support dynamic process
+                               creation similar to other sc_objects
+
+      Name, Affiliation, Date: Andy Goodrich, Forte Design Systems
+                               5 September 2003
+  Description of Modification: - Made creation of attributes structure
+                                 conditional on its being used. This eliminates
+                                 100 bytes of storage for each normal sc_object.
+
+ *****************************************************************************/
+
+
+// $Log: sc_object.cpp,v $
+// Revision 1.16  2011/08/29 18:04:32  acg
+//  Philipp A. Hartmann: miscellaneous clean ups.
+//
+// Revision 1.15  2011/08/26 20:46:10  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.14  2011/08/24 22:05:51  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.13  2011/04/01 21:24:57  acg
+//  Andy Goodrich: removed unused code.
+//
+// Revision 1.12  2011/03/06 15:55:11  acg
+//  Andy Goodrich: Changes for named events.
+//
+// Revision 1.11  2011/03/05 19:44:20  acg
+//  Andy Goodrich: changes for object and event naming and structures.
+//
+// Revision 1.10  2011/03/05 04:45:16  acg
+//  Andy Goodrich: moved active process calculation to the sc_simcontext class.
+//
+// Revision 1.9  2011/03/05 01:39:21  acg
+//  Andy Goodrich: changes for named events.
+//
+// Revision 1.8  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.7  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.6  2011/01/25 20:50:37  acg
+//  Andy Goodrich: changes for IEEE 1666 2011.
+//
+// Revision 1.5  2011/01/18 20:10:44  acg
+//  Andy Goodrich: changes for IEEE1666_2011 semantics.
+//
+// Revision 1.4  2010/08/03 17:02:39  acg
+//  Andy Goodrich: formatting changes.
+//
+// Revision 1.3  2009/02/28 00:26:58  acg
+//  Andy Goodrich: changed boost name space to sc_boost to allow use with
+//  full boost library applications.
+//
+// Revision 1.2  2008/05/22 17:06:26  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.5  2006/04/20 17:08:17  acg
+//  Andy Goodrich: 3.0 style process changes.
+//
+// Revision 1.4  2006/03/21 00:00:34  acg
+//   Andy Goodrich: changed name of sc_get_current_process_base() to be
+//   sc_get_current_process_b() since its returning an sc_process_b instance.
+//
+// Revision 1.3  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+//
diff --git a/ext/systemc/src/sysc/kernel/sc_object.h b/ext/systemc/src/sysc/kernel/sc_object.h
new file mode 100644
index 000000000..c6e0957a8
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_object.h
@@ -0,0 +1,244 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_object.h -- Abstract base class of all SystemC `simulation' objects.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#ifndef SC_OBJECT_H
+#define SC_OBJECT_H
+
+
+#include "sysc/utils/sc_iostream.h"
+#include "sysc/kernel/sc_attribute.h"
+
+namespace sc_core {
+
+class sc_event;
+class sc_module;
+class sc_phase_callback_registry;
+class sc_runnable;
+class sc_simcontext;
+class sc_trace_file;
+class sc_trace_file_base;
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_object
+//
+//  Abstract base class of all SystemC `simulation' objects.
+// ----------------------------------------------------------------------------
+
+class sc_object
+{
+    friend class sc_event;
+    friend class sc_module;
+    friend struct sc_invoke_method;
+    friend class sc_module_dynalloc_list;
+    friend class sc_object_manager;
+    friend class sc_phase_callback_registry;
+    friend class sc_process_b;
+    friend class sc_runnable;
+    friend class sc_simcontext;
+    friend class sc_trace_file_base;
+
+public:
+    typedef unsigned phase_cb_mask;
+
+    const char* name() const
+        { return m_name.c_str(); }
+
+    const char* basename() const;
+
+    virtual void print(::std::ostream& os=::std::cout ) const;
+
+    // dump() is more detailed than print()
+    virtual void dump(::std::ostream& os=::std::cout ) const;
+
+    virtual void trace( sc_trace_file* tf ) const;
+
+    virtual const char* kind() const { return "sc_object"; }
+
+    sc_simcontext* simcontext() const
+        { return m_simc; }
+
+    // add attribute
+    bool add_attribute( sc_attr_base& );
+
+    // get attribute by name
+          sc_attr_base* get_attribute( const std::string& name_ );
+    const sc_attr_base* get_attribute( const std::string& name_ ) const;
+
+    // remove attribute by name
+    sc_attr_base* remove_attribute( const std::string& name_ );
+
+    // remove all attributes
+    void remove_all_attributes();
+
+    // get the number of attributes
+    int num_attributes() const;
+
+    // get the attribute collection
+          sc_attr_cltn& attr_cltn();
+    const sc_attr_cltn& attr_cltn() const;
+
+    virtual const std::vector<sc_event*>& get_child_events() const
+        { return m_child_events; }
+
+    virtual const std::vector<sc_object*>& get_child_objects() const
+        { return m_child_objects; }
+
+    sc_object* get_parent() const;
+    sc_object* get_parent_object() const { return m_parent; }
+
+protected:
+
+    sc_object();
+    sc_object(const char* nm);
+
+    sc_object( const sc_object& );
+    sc_object& operator=( const sc_object& );
+
+
+    virtual ~sc_object();
+
+    virtual void add_child_event( sc_event* event_p );
+    virtual void add_child_object( sc_object* object_p );
+    virtual bool remove_child_event( sc_event* event_p );
+    virtual bool remove_child_object( sc_object* object_p );
+
+    phase_cb_mask register_simulation_phase_callback( phase_cb_mask );
+    phase_cb_mask unregister_simulation_phase_callback( phase_cb_mask );
+
+    class hierarchy_scope;
+
+private:
+            void do_simulation_phase_callback();
+    virtual void simulation_phase_callback();
+
+    void detach();
+    virtual void orphan_child_events();
+    virtual void orphan_child_objects();
+    void sc_object_init(const char* nm);
+
+private:
+
+    /* Each simulation object is associated with a simulation context */ 
+    mutable sc_attr_cltn*   m_attr_cltn_p;   // attributes for this object.
+    std::vector<sc_event*>  m_child_events;  // list of child events.
+    std::vector<sc_object*> m_child_objects; // list of child objects.
+    std::string             m_name;          // name of this object.
+    sc_object*              m_parent;        // parent for this object.
+    sc_simcontext*          m_simc;          // simcontext ptr / empty indicator
+};
+
+inline
+sc_object&
+sc_object::operator=( sc_object const & )
+{
+  // deliberately do nothing
+  return *this;
+}
+
+// ----------------------------------------------------------------------------
+
+extern const char SC_HIERARCHY_CHAR;
+extern bool sc_enable_name_checking;
+
+
+inline 
+sc_object* sc_get_parent( const sc_object* obj_p ) 
+{ 
+	return obj_p->get_parent_object(); 
+}
+
+} // namespace sc_core
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Andy Goodrich, Forte Design Systems
+                               5 September 2003
+  Description of Modification: - Made creation of attributes structure      
+                                 conditional on its being used. This eliminates
+                                 100 bytes of storage for each normal sc_object.
+
+ *****************************************************************************/
+
+// $Log: sc_object.h,v $
+// Revision 1.13  2011/08/29 18:04:32  acg
+//  Philipp A. Hartmann: miscellaneous clean ups.
+//
+// Revision 1.12  2011/08/26 20:46:10  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.11  2011/03/06 15:55:11  acg
+//  Andy Goodrich: Changes for named events.
+//
+// Revision 1.10  2011/03/05 19:44:20  acg
+//  Andy Goodrich: changes for object and event naming and structures.
+//
+// Revision 1.9  2011/03/05 01:39:21  acg
+//  Andy Goodrich: changes for named events.
+//
+// Revision 1.8  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.7  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.6  2011/01/25 20:50:37  acg
+//  Andy Goodrich: changes for IEEE 1666 2011.
+//
+// Revision 1.5  2011/01/18 20:10:44  acg
+//  Andy Goodrich: changes for IEEE1666_2011 semantics.
+//
+// Revision 1.4  2010/07/22 20:02:33  acg
+//  Andy Goodrich: bug fixes.
+//
+// Revision 1.3  2009/02/28 00:26:58  acg
+//  Andy Goodrich: changed boost name space to sc_boost to allow use with
+//  full boost library applications.
+//
+// Revision 1.2  2008/05/22 17:06:26  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.5  2006/04/20 17:08:17  acg
+//  Andy Goodrich: 3.0 style process changes.
+//
+// Revision 1.4  2006/04/11 23:13:21  acg
+//   Andy Goodrich: Changes for reduced reset support that only includes
+//   sc_cthread, but has preliminary hooks for expanding to method and thread
+//   processes also.
+//
+// Revision 1.3  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+
+#endif // SC_OBJECT_H
diff --git a/ext/systemc/src/sysc/kernel/sc_object_int.h b/ext/systemc/src/sysc/kernel/sc_object_int.h
new file mode 100644
index 000000000..aca230f8b
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_object_int.h
@@ -0,0 +1,99 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_object_int.h -- For inline definitions of some utility functions.
+                     DO NOT EXPORT THIS INCLUDE FILE.
+
+  Original Author: Philipp A. Hartmann, OFFIS, 2013-02-10
+
+ *****************************************************************************/
+
+#ifndef SC_OBJECT_INT_H_INCLUDED_
+#define SC_OBJECT_INT_H_INCLUDED_
+
+#include "sysc/kernel/sc_object.h"
+#include "sysc/kernel/sc_module.h"
+#include "sysc/kernel/sc_simcontext_int.h"
+#include "sysc/kernel/sc_phase_callback_registry.h"
+
+namespace sc_core {
+
+class sc_object::hierarchy_scope
+{
+public:
+    explicit hierarchy_scope(sc_object* obj);
+    explicit hierarchy_scope(sc_module* mod);
+    ~hierarchy_scope();
+
+private:
+    sc_module * scope_;
+
+private:
+    hierarchy_scope( hierarchy_scope const & other ) /* = delete */;
+    hierarchy_scope& operator=(hierarchy_scope const&) /* = delete */;
+};
+
+
+inline
+sc_object::hierarchy_scope::hierarchy_scope( sc_object* obj )
+  : scope_(0)
+{
+    if( !obj ) return;
+
+    scope_ = dynamic_cast<sc_module*>(obj);
+    if( !scope_ )
+        scope_ = dynamic_cast<sc_module*>(obj->get_parent_object());
+    if( scope_ )
+        scope_->simcontext()->hierarchy_push(scope_);
+}
+
+
+inline
+sc_object::hierarchy_scope::hierarchy_scope( sc_module* mod )
+  : scope_(mod)
+{
+    if( scope_ )
+        scope_->simcontext()->hierarchy_push(scope_);
+}
+
+
+inline
+sc_object::hierarchy_scope::~hierarchy_scope()
+{
+    if( scope_ )
+        scope_->simcontext()->hierarchy_pop();
+}
+
+
+// -----------------------------------------------------------------------
+
+inline void
+sc_object::do_simulation_phase_callback()
+{
+    simulation_phase_callback();
+}
+
+// -----------------------------------------------------------------------
+
+} // namespace sc_core
+
+#endif // SC_OBJECT_INT_H_INCLUDED_
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_object_manager.cpp b/ext/systemc/src/sysc/kernel/sc_object_manager.cpp
new file mode 100644
index 000000000..e46413928
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_object_manager.cpp
@@ -0,0 +1,462 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_object_manager.cpp -- Manager of objects (naming, &c.)
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#include <stdio.h>
+#include <cstdlib>
+#include <cassert>
+#include <ctype.h>
+#include <stddef.h>
+#include <algorithm> // pick up std::sort.
+
+#include "sysc/utils/sc_iostream.h"
+#include "sysc/kernel/sc_object.h"
+#include "sysc/utils/sc_hash.h"
+#include "sysc/utils/sc_list.h"
+#include "sysc/utils/sc_mempool.h"
+#include "sysc/kernel/sc_simcontext.h"
+#include "sysc/kernel/sc_object_manager.h"
+#include "sysc/kernel/sc_kernel_ids.h"
+#include "sysc/kernel/sc_process.h"
+#include "sysc/kernel/sc_module_name.h"
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_object_manager
+//
+//  Manager of objects.
+// ----------------------------------------------------------------------------
+
+sc_object_manager::sc_object_manager() :
+    m_event_it(),
+    m_event_walk_ok(0),
+    m_instance_table(),
+    m_module_name_stack(0),
+    m_object_it(),
+    m_object_stack(),
+    m_object_walk_ok()
+{
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_object_manager::~sc_object_manager"
+// | 
+// | This is the object instance destructor for this class. It goes through
+// | each sc_object instance in the instance table and sets its m_simc field
+// | to NULL.
+// +----------------------------------------------------------------------------
+sc_object_manager::~sc_object_manager()
+{
+    instance_table_t::iterator it;     // instance table iterator.
+
+    for ( it = m_instance_table.begin(); it != m_instance_table.end(); it++) 
+    {
+        sc_object* obj_p = it->second.m_object_p;
+        if ( obj_p ) obj_p->m_simc = 0;
+    }
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_object_manager::create_name"
+// | 
+// | This method creates a hierarchical name based on the name of the active 
+// | object and the supplied leaf name. If the resultant name is not unique it 
+// | will be made unique and a warning message issued.
+// |
+// | Arguments:
+// |     leaf_name = name to use for the leaf of the hierarchy.
+// | Result is an std::string containing the name.
+// +----------------------------------------------------------------------------
+std::string sc_object_manager::create_name(const char* leaf_name) 
+{ 
+    bool        clash;                  // true if path name exists in obj table
+    std::string leafname_string;        // string containing the leaf name.
+    std::string parentname_string;      // parent path name 
+    sc_object*  parent_p;               // parent for this instance or NULL.
+    std::string result_orig_string;     // save for warning message.
+    std::string result_string;          // name to return.
+ 
+    // CONSTRUCT PATHNAME TO THE NAME TO BE RETURNED:
+    // 
+    // If there is not a leaf name generate one. 
+
+    parent_p = sc_get_curr_simcontext()->active_object();
+    parentname_string = parent_p ? parent_p->name() : ""; 
+    leafname_string = leaf_name; 
+    if (parent_p) {
+        result_string = parentname_string;
+	result_string += SC_HIERARCHY_CHAR;
+	result_string += leafname_string;
+    } else { 
+        result_string = leafname_string;
+    } 
+
+    // SAVE the original path name 
+
+    result_orig_string = result_string;
+
+    // MAKE SURE THE ENTITY NAME IS UNIQUE:
+    // 
+    // If not use unique name generator to make it unique. 
+
+    clash = false; 
+    for (;;)
+    {
+	instance_table_t::iterator it = m_instance_table.find(result_string);
+	if ( it == m_instance_table.end() ||
+	     (it->second.m_event_p == NULL && it->second.m_object_p == NULL ) )
+	{
+	    break;
+	}
+        clash = true; 
+        leafname_string = sc_gen_unique_name(leafname_string.c_str(), false); 
+	if (parent_p) {
+	    result_string = parentname_string;
+	    result_string += SC_HIERARCHY_CHAR;
+	    result_string += leafname_string;
+	} else { 
+	    result_string = leafname_string;
+	} 
+    } 
+    if (clash) { 
+	std::string message = result_orig_string;
+	message += ". Latter declaration will be renamed to ";
+	message += result_string;
+        SC_REPORT_WARNING( SC_ID_INSTANCE_EXISTS_, message.c_str());
+    } 
+
+    return result_string;
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_object_manager::find_event"
+// | 
+// | This method returns the sc_event with the supplied name, or a NULL if
+// | the event does not exist.
+// |
+// | Arguments:
+// |     name = name of the event
+// | Result is a pointer to the event or NULL if it does not exist.
+// +----------------------------------------------------------------------------
+sc_event*
+sc_object_manager::find_event(const char* name)
+{
+    instance_table_t::iterator it;
+    it = m_instance_table.find(name);
+    return it == m_instance_table.end() ? NULL : it->second.m_event_p;
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_object_manager::find_object"
+// | 
+// | This method returns the sc_object with the supplied name, or a NULL if
+// | the object does not exist.
+// |
+// | Arguments:
+// |     name = name of the object
+// | Result is a pointer to the object or NULL if it does not exist.
+// +----------------------------------------------------------------------------
+sc_object*
+sc_object_manager::find_object(const char* name)
+{
+    instance_table_t::iterator it;
+    it = m_instance_table.find(name);
+    return it == m_instance_table.end() ? NULL : it->second.m_object_p;
+}
+
+
+// +----------------------------------------------------------------------------
+// |"sc_object_manager::first_object"
+// | 
+// | This method initializes the object iterator to point to the first object
+// | in the instance table, and returns its address. If there are no objects
+// | in the table a NULL value is returned.
+// +----------------------------------------------------------------------------
+sc_object*
+sc_object_manager::first_object()
+{
+    sc_object* result_p; // result to return.
+
+    m_object_walk_ok = true;
+    result_p = NULL;
+    for ( m_object_it = m_instance_table.begin(); 
+          m_object_it != m_instance_table.end(); 
+	  m_object_it++ )
+    {
+        result_p = m_object_it->second.m_object_p;
+	if ( result_p ) break;
+    }
+    return result_p;
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_object_manager::hierarchy_curr"
+// | 
+// | This method returns the current object in the object hierarchy or NULL
+// | if it does not exist.
+// +----------------------------------------------------------------------------
+sc_object*
+sc_object_manager::hierarchy_curr()
+{
+    size_t     hierarchy_n; // current size of the hierarchy.
+
+    hierarchy_n = m_object_stack.size();
+    return hierarchy_n ? m_object_stack[hierarchy_n-1] : 0;
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_object_manager::hierarchy_pop"
+// | 
+// | This method pops the current object off the object hierarchy and returns
+// | it.
+// +----------------------------------------------------------------------------
+sc_object*
+sc_object_manager::hierarchy_pop()
+{
+    size_t     hierarchy_n; // current size of the hierarchy.
+    sc_object* result_p;    // object to return.
+
+    hierarchy_n = m_object_stack.size();
+    if ( hierarchy_n == 0 ) return NULL;
+    hierarchy_n--;
+    result_p = m_object_stack[hierarchy_n];
+    m_object_stack.pop_back();
+    return result_p;
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_object_manager::hierarchy_push"
+// | 
+// | This method pushes down the sc_object hierarchy to make the supplied 
+// | object the current object in the hierarchy.
+// |
+// | Arguments:
+// |     object_p -> object to become the new current object in the hierarchy.
+// +----------------------------------------------------------------------------
+void
+sc_object_manager::hierarchy_push(sc_object* object_p)
+{
+    m_object_stack.push_back(object_p);
+}
+
+
+// +----------------------------------------------------------------------------
+// |"sc_object_manager::hierarchy_size"
+// | 
+// | This method returns the current size of the object hierarchy stack.
+// +----------------------------------------------------------------------------
+int
+sc_object_manager::hierarchy_size()
+{
+    return m_object_stack.size();
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_object_manager::insert_event"
+// | 
+// | This method inserts the supplied sc_event instance into the instance
+// | table using the supplied name.
+// |
+// | Arguments:
+// |     name    =  name of the event to be inserted.
+// |     event_p -> event to be inserted.
+// +----------------------------------------------------------------------------
+void
+sc_object_manager::insert_event(const std::string& name, sc_event* event_p)
+{
+    m_instance_table[name].m_event_p = event_p;
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_object_manager::insert_object"
+// | 
+// | This method inserts the supplied sc_object instance into the instance
+// | table using the supplied name.
+// |
+// | Arguments:
+// |     name     =  name of the event to be inserted.
+// |     object_p -> object to be inserted.
+// +----------------------------------------------------------------------------
+void
+sc_object_manager::insert_object(const std::string& name, sc_object* object_p)
+{
+    m_instance_table[name].m_object_p = object_p;
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_object_manager::next_object"
+// | 
+// | This method returns the next object pointed to by the instance iterator.
+// +----------------------------------------------------------------------------
+sc_object*
+sc_object_manager::next_object()
+{
+    sc_object* result_p; // result to return.
+
+    assert( m_object_walk_ok );
+
+    if ( m_object_it == m_instance_table.end() ) return NULL;
+    m_object_it++;
+
+    for ( result_p = NULL; m_object_it != m_instance_table.end(); 
+	  m_object_it++ )
+    {
+        result_p = m_object_it->second.m_object_p;
+	if ( result_p ) break;
+    }
+    return result_p;
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_object_manager::pop_module_name"
+// | 
+// | This method pops an entry off the module name stack and returns it.
+// +----------------------------------------------------------------------------
+sc_module_name*
+sc_object_manager::pop_module_name()
+{
+    sc_module_name* mod_name = m_module_name_stack;
+    m_module_name_stack = m_module_name_stack->m_next;
+    mod_name->m_next = 0;
+    return mod_name;
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_object_manager::push_module_name"
+// | 
+// | This method pushes the supplied entry onto the module name stack.
+// |
+// | Arguments:
+// |     mod_name_p -> entry to push onto the module name stack.
+// +----------------------------------------------------------------------------
+void
+sc_object_manager::push_module_name(sc_module_name* mod_name_p)
+{
+    mod_name_p->m_next = m_module_name_stack;
+    m_module_name_stack = mod_name_p;
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_object_manager::top_of_module_name_stack"
+// | 
+// | This method returns the module name that is on the top of the module
+// | name stack.
+// +----------------------------------------------------------------------------
+sc_module_name*
+sc_object_manager::top_of_module_name_stack()
+{
+    if( m_module_name_stack == 0 ) {
+	SC_REPORT_ERROR( SC_ID_MODULE_NAME_STACK_EMPTY_, 0 );
+    }
+    return m_module_name_stack;
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_object_manager::remove_event"
+// | 
+// | This method removes the sc_event instance with the supplied name from
+// | the table of instances. Note we just clear the pointer since if the name
+// | was for an sc_object the m_event_p pointer will be null anyway.
+// |
+// | Arguments:
+// |     name = name of the event to be removed.
+// +----------------------------------------------------------------------------
+void
+sc_object_manager::remove_event(const std::string& name)
+{
+    instance_table_t::iterator it;     // instance table iterator.
+    it = m_instance_table.find(name);
+    if ( it != m_instance_table.end() ) it->second.m_event_p = NULL;
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_object_manager::remove_object"
+// | 
+// | This method removes the sc_object instance with the supplied name from
+// | the table of instances. Note we just clear the pointer since if the name
+// | was for an sc_event the m_object_p pointer will be null anyway.
+// |
+// | Arguments:
+// |     name = name of the object to be removed.
+// +----------------------------------------------------------------------------
+void
+sc_object_manager::remove_object(const std::string& name)
+{
+    instance_table_t::iterator it;     // instance table iterator.
+    it = m_instance_table.find(name);
+    if ( it != m_instance_table.end() ) it->second.m_object_p = NULL;
+}
+
+} // namespace sc_core
+
+// $Log: sc_object_manager.cpp,v $
+// Revision 1.13  2011/08/26 20:46:10  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.12  2011/08/24 22:05:51  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.11  2011/06/25 17:08:39  acg
+//  Andy Goodrich: Jerome Cornet's changes to use libtool to build the
+//  library.
+//
+// Revision 1.10  2011/04/01 21:27:54  acg
+//  Andy Goodrich: documentation of event and object insertion methods.
+//
+// Revision 1.9  2011/03/06 15:55:11  acg
+//  Andy Goodrich: Changes for named events.
+//
+// Revision 1.8  2011/03/05 19:44:20  acg
+//  Andy Goodrich: changes for object and event naming and structures.
+//
+// Revision 1.7  2011/03/05 04:45:16  acg
+//  Andy Goodrich: moved active process calculation to the sc_simcontext class.
+//
+// Revision 1.6  2011/03/05 01:39:21  acg
+//  Andy Goodrich: changes for named events.
+//
+// Revision 1.5  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.4  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.3  2010/07/22 20:02:33  acg
+//  Andy Goodrich: bug fixes.
+//
+// Revision 1.2  2008/05/22 17:06:26  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+//
diff --git a/ext/systemc/src/sysc/kernel/sc_object_manager.h b/ext/systemc/src/sysc/kernel/sc_object_manager.h
new file mode 100644
index 000000000..753252c33
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_object_manager.h
@@ -0,0 +1,139 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_object_manager.h -- Manager of objects (naming, &c.)
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#ifndef SC_OBJECT_MANAGER_H
+#define SC_OBJECT_MANAGER_H
+
+#include <map>
+#include <vector>
+
+namespace sc_core {
+
+class sc_event;
+class sc_object;
+class sc_module_name;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_object_manager
+//
+//  Manager of objects.
+// ----------------------------------------------------------------------------
+
+class sc_object_manager
+{
+    friend class sc_event;
+    friend class sc_object;
+    friend class sc_simcontext;
+
+protected:
+    struct table_entry
+    {
+        table_entry() : m_event_p(NULL), m_object_p(NULL) {}
+
+	sc_event*  m_event_p;   // if non-null this is an sc_event.
+        sc_object* m_object_p;  // if non-null this is an sc_object.
+    };
+
+public:
+    typedef std::map<std::string,table_entry> instance_table_t;
+    typedef std::vector<sc_object*>           object_vector_t;
+
+    sc_object_manager();
+    ~sc_object_manager();
+
+    sc_event* find_event(const char* name);
+
+    sc_object* find_object(const char* name);
+    sc_object* first_object();
+    sc_object* next_object();
+
+    void hierarchy_push(sc_object* mdl);
+    sc_object* hierarchy_pop();
+    sc_object* hierarchy_curr();
+    int hierarchy_size();
+
+    void push_module_name(sc_module_name* mod_name);
+    sc_module_name* pop_module_name();
+    sc_module_name* top_of_module_name_stack();
+
+
+private:
+    std::string create_name( const char* leaf_name );
+    void insert_event(const std::string& name, sc_event* obj);
+    void insert_object(const std::string& name, sc_object* obj);
+    void remove_event(const std::string& name);
+    void remove_object(const std::string& name);
+
+private:
+
+    instance_table_t::iterator m_event_it;          // event instance iterator.
+    bool                       m_event_walk_ok;     // true if can walk events.
+    instance_table_t           m_instance_table;    // table of instances.
+    sc_module_name*            m_module_name_stack; // sc_module_name stack.
+    instance_table_t::iterator m_object_it;         // object instance iterator.
+    object_vector_t            m_object_stack;      // sc_object stack.
+    bool                       m_object_walk_ok;    // true if can walk objects.
+};
+
+} // namespace sc_core
+
+// $Log: sc_object_manager.h,v $
+// Revision 1.9  2011/08/26 20:46:10  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.8  2011/03/06 15:55:11  acg
+//  Andy Goodrich: Changes for named events.
+//
+// Revision 1.7  2011/03/05 19:44:20  acg
+//  Andy Goodrich: changes for object and event naming and structures.
+//
+// Revision 1.6  2011/03/05 01:39:21  acg
+//  Andy Goodrich: changes for named events.
+//
+// Revision 1.5  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.4  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.3  2010/07/22 20:02:33  acg
+//  Andy Goodrich: bug fixes.
+//
+// Revision 1.2  2008/05/22 17:06:26  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+
+#endif
diff --git a/ext/systemc/src/sysc/kernel/sc_phase_callback_registry.cpp b/ext/systemc/src/sysc/kernel/sc_phase_callback_registry.cpp
new file mode 100644
index 000000000..84f15c93f
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_phase_callback_registry.cpp
@@ -0,0 +1,301 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_phase_callback_registry.cpp -- Implementation of phase callback registry
+
+  Original Author: Philipp A. Hartmann, OFFIS, 2013-02-15
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+#include "sysc/kernel/sc_object.h"
+#include "sysc/kernel/sc_phase_callback_registry.h"
+#include "sysc/kernel/sc_kernel_ids.h"
+#include "sysc/utils/sc_report.h"
+
+#include <algorithm>
+#include <functional>
+
+namespace sc_core {
+
+#if SC_HAS_PHASE_CALLBACKS_
+
+sc_phase_callback_registry::sc_phase_callback_registry( sc_simcontext& simc )
+  : m_simc( &simc )
+#if 0
+  , m_cb_eval_vec()
+#endif
+  , m_cb_update_vec()
+  , m_cb_timestep_vec()
+{}
+
+sc_phase_callback_registry::~sc_phase_callback_registry()
+{}
+
+static const sc_phase_callback_registry::mask_type
+  SC_PHASE_CALLBACK_MASK = SC_STATUS_ANY;
+
+namespace /* anonymous */ {
+
+struct entry_match
+  : std::unary_function< sc_phase_callback_registry::entry, bool >
+{
+    typedef sc_phase_callback_registry::cb_type* ref_type;
+
+    explicit
+    entry_match( ref_type ref )
+      : ref_(ref)
+    {}
+
+    result_type operator()( argument_type e )
+        { return e.target == ref_; }
+private:
+    sc_phase_callback_registry::cb_type * ref_;
+
+}; // entry_match
+
+template< typename T >
+inline void
+erase_remove( std::vector<T>* vec, T const& t )
+{
+    vec->erase( std::remove( vec->begin(), vec->end(), t ) );
+}
+
+}  // namespace anonymous
+
+
+sc_phase_callback_registry::mask_type
+sc_phase_callback_registry::validate_mask( cb_type& cb
+                                         , mask_type m
+                                         , bool warn = false )
+{
+    if( SC_UNLIKELY_(m & ~SC_PHASE_CALLBACK_MASK) )
+    {
+        if( warn )
+        {
+            std::stringstream ss;
+            ss << cb.name() << ": invalid phase callback mask: "
+               << (sc_status)m;
+            SC_REPORT_WARNING( SC_ID_PHASE_CALLBACK_REGISTER_
+                             , ss.str().c_str() );
+        }
+        m &= SC_PHASE_CALLBACK_MASK;
+    }
+
+    mask_type check_mask;
+
+    // elaboration callbacks
+    check_mask = ( SC_ELABORATION
+                 | SC_BEFORE_END_OF_ELABORATION
+                 | SC_END_OF_ELABORATION );
+    if( SC_UNLIKELY_( (m & check_mask ) && m_simc->elaboration_done() ) )
+    {
+        if( warn )
+        {
+            std::stringstream ss;
+            ss << cb.name() << ": elaboration done\n\t "
+               << (sc_status)( m & check_mask ) << " callback(s) ignored";
+            SC_REPORT_WARNING(SC_ID_PHASE_CALLBACK_REGISTER_
+                             , ss.str().c_str() );
+        }
+        m &= ~check_mask;
+    }
+
+    check_mask = (SC_BEFORE_END_OF_ELABORATION | SC_END_OF_ELABORATION);
+    if( SC_UNLIKELY_(m & SC_ELABORATION) )
+    {
+        if( warn )
+        {
+            std::stringstream ss;
+            ss << cb.name() << ": " << SC_ELABORATION
+               << ":\n\t substituted by " << (sc_status)(check_mask);
+            SC_REPORT_WARNING( SC_ID_PHASE_CALLBACK_REGISTER_
+                             , ss.str().c_str() );
+        }
+        m &= ~SC_ELABORATION;
+        m |= check_mask;
+    }
+
+    check_mask = ( SC_END_OF_INITIALIZATION
+#if 0
+                 | SC_END_OF_EVALUATION
+#endif
+                 | SC_END_OF_UPDATE
+                 | SC_BEFORE_TIMESTEP );
+    if( SC_UNLIKELY_(m & SC_RUNNING) )
+    {
+        if( warn )
+        {
+            std::stringstream ss;
+            ss << cb.name() << ": " << SC_RUNNING
+               << ":\n\t substituted by " << (sc_status)(check_mask);
+            SC_REPORT_WARNING( SC_ID_PHASE_CALLBACK_REGISTER_
+                             , ss.str().c_str() );
+        }
+        m &= ~SC_RUNNING;
+        m |= check_mask;
+    }
+    return m;
+}
+
+
+sc_phase_callback_registry::mask_type
+sc_phase_callback_registry::register_callback( cb_type& cb, mask_type m )
+{
+    storage_type::iterator it =
+      find_if( m_cb_vec.begin(), m_cb_vec.end(), entry_match(&cb) );
+
+    m = validate_mask(cb, m, /* warn */ true );
+
+    mask_type diff_mask = m;
+    mask_type new_mask  = m;
+
+    if( it != m_cb_vec.end() ) // update existing entry
+    {
+        // update masks
+        new_mask   =  (*it).mask | m;
+        diff_mask  = ~(*it).mask & m;
+        (*it).mask = new_mask;
+    }
+    else // new entry
+    {
+        if( !m ) // empty, do nothing
+            return SC_UNITIALIZED;
+
+        entry new_entry = { &cb, new_mask };
+        m_cb_vec.push_back( new_entry );
+    }
+
+    // add to callback shortcut sets
+#if 0
+    if( diff_mask & SC_END_OF_EVALUATION )
+        m_cb_eval_vec.push_back( &cb );
+#endif
+    if( diff_mask & SC_END_OF_UPDATE )
+        m_cb_update_vec.push_back( &cb );
+    if( diff_mask & SC_BEFORE_TIMESTEP )
+        m_cb_timestep_vec.push_back( &cb );
+
+    return new_mask;
+}
+
+
+sc_phase_callback_registry::mask_type
+sc_phase_callback_registry::unregister_callback( cb_type& cb, mask_type m )
+{
+    storage_type::iterator it =
+      find_if( m_cb_vec.begin(), m_cb_vec.end(), entry_match(&cb) );
+
+    m = validate_mask(cb, m);
+
+    mask_type diff_mask = m;
+    mask_type new_mask  = m;
+
+    if( it == m_cb_vec.end() ) { // not registered
+        return SC_UNITIALIZED;
+    }
+
+    // update masks
+    new_mask   = (*it).mask & ~m;
+    diff_mask  = (*it).mask & m;
+    (*it).mask = new_mask;
+
+    if( !new_mask )
+        m_cb_vec.erase(it);
+
+    // drop from callback shortcut sets
+#if 0
+    if( diff_mask & SC_END_OF_EVALUATION )
+        erase_remove( &m_cb_eval_vec, &cb );
+#endif
+    if( diff_mask & SC_END_OF_UPDATE )
+        erase_remove( &m_cb_update_vec, &cb );
+    if( diff_mask & SC_BEFORE_TIMESTEP )
+        erase_remove( &m_cb_timestep_vec, &cb );
+
+    return new_mask;
+}
+
+
+// generic implementation (for non-critical callbacks)
+//  - also restores hierarchy around callback object
+void
+sc_phase_callback_registry::do_callback( sc_status s ) const
+{
+    typedef storage_type::const_iterator it_type;
+    storage_type const & vec = m_cb_vec;
+
+    for(it_type it = vec.begin(), end = vec.end(); it != end; ++it) {
+        if( s & it->mask ) {
+            sc_object::hierarchy_scope scope(it->target);
+            it->target->do_simulation_phase_callback();
+        }
+    }
+}
+
+#else // ! SC_HAS_PHASE_CALLBACKS_
+
+sc_phase_callback_registry::sc_phase_callback_registry( sc_simcontext& ){}
+sc_phase_callback_registry::~sc_phase_callback_registry(){}
+
+static inline void
+warn_phase_callbacks( sc_core::sc_object const& obj )
+{
+    static bool warned = false;
+    if (!warned)
+    {
+        std::stringstream ss;
+        ss << obj.name() << ".\n"
+           << "Please recompile SystemC with "
+              "\"SC_ENABLE_SIMULATION_PHASE_CALLBACKS\" defined.";
+        SC_REPORT_WARNING( SC_ID_PHASE_CALLBACKS_UNSUPPORTED_
+                         , ss.str().c_str() );
+    }
+}
+
+sc_phase_callback_registry::mask_type
+sc_phase_callback_registry::register_callback( cb_type& cb, mask_type )
+{
+    warn_phase_callbacks( cb );
+    return SC_UNITIALIZED;
+}
+
+sc_phase_callback_registry::mask_type
+sc_phase_callback_registry::unregister_callback( cb_type& cb, mask_type )
+{
+    warn_phase_callbacks( cb );
+    return SC_UNITIALIZED;
+}
+
+#endif // ! SC_HAS_PHASE_CALLBACKS_
+
+} // namespace sc_core
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_phase_callback_registry.h b/ext/systemc/src/sysc/kernel/sc_phase_callback_registry.h
new file mode 100644
index 000000000..9510c0d3f
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_phase_callback_registry.h
@@ -0,0 +1,276 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_phase_callback_registry.h -- Definition of the simulation phase callbacks
+
+  The most critical functions are defined inline in this file.  Only active,
+  if SC_ENABLE_SIMULATION_PHASE_CALLBACKS[_TRACING] is defined during the
+  SystemC library build.
+
+  Original Author: Philipp A. Hartmann, OFFIS, 2013-02-15
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+#ifndef SC_PHASE_CALLBACK_REGISTRY_H_INCLUDED_
+#define SC_PHASE_CALLBACK_REGISTRY_H_INCLUDED_
+
+#if defined( SC_ENABLE_SIMULATION_PHASE_CALLBACKS ) \
+ || defined( SC_ENABLE_SIMULATION_PHASE_CALLBACKS_TRACING )
+#  define SC_HAS_PHASE_CALLBACKS_ 1
+#else
+#  define SC_HAS_PHASE_CALLBACKS_ 0
+#endif
+
+#include "sysc/kernel/sc_simcontext.h"
+#include "sysc/kernel/sc_object_int.h"
+#include "sysc/kernel/sc_status.h"
+
+#include <vector>
+
+namespace sc_core {
+
+class sc_simcontext;
+class sc_object;
+
+class sc_phase_callback_registry
+{
+public:
+    typedef sc_phase_callback_registry this_type;
+    typedef sc_object                  cb_type;
+    typedef cb_type::phase_cb_mask     mask_type;
+
+    struct entry
+    {
+        cb_type*  target;
+        mask_type mask;
+    };
+
+    friend class sc_simcontext;
+    friend class sc_object;
+
+private: // interface completely internal
+
+    explicit
+    sc_phase_callback_registry( sc_simcontext& simc );
+
+    ~sc_phase_callback_registry();
+
+    // --- callback forwarders
+
+    bool construction_done()   const; //< returns false
+    void elaboration_done()    const;
+    void initialization_done() const;
+    void start_simulation()    const;
+
+    void evaluation_done()     const;
+    void update_done()         const;
+    void before_timestep()     const;
+
+    void simulation_paused()   const;
+    void simulation_stopped()  const;
+    void simulation_done()     const;
+
+
+    // --- callback registration and implementation
+
+    mask_type register_callback( cb_type&, mask_type mask );
+    mask_type unregister_callback( cb_type&, mask_type mask );
+
+    // generic caller
+    void do_callback( sc_status ) const;
+
+private:
+    typedef std::vector<entry>    storage_type;
+    typedef std::vector<cb_type*> single_storage_type;
+
+#if SC_HAS_PHASE_CALLBACKS_
+
+    // set and restore simulation status
+    struct scoped_status
+    {
+        scoped_status( sc_status& ref, sc_status s )
+          : ref_(ref), prev_(ref) { ref_ = s;}
+        ~scoped_status() { ref_ = prev_; }
+    private:
+        sc_status& ref_;
+        sc_status  prev_;
+    }; // scoped_status
+
+    mask_type validate_mask( cb_type&, mask_type, bool warn );
+
+private:
+
+    sc_simcontext*        m_simc;
+    storage_type          m_cb_vec;            // all callbacks
+#if 0
+    single_storage_type   m_cb_eval_vec;     //  - eval cb shortcut
+#endif
+    single_storage_type   m_cb_update_vec;   //  - update cb shortcut
+    single_storage_type   m_cb_timestep_vec; //  - timestep cb shortcut
+
+#endif // SC_HAS_PHASE_CALLBACKS_
+
+private:
+    // disabled
+    sc_phase_callback_registry( const this_type& );
+    this_type& operator=(const this_type&);
+
+}; // sc_phase_callback_registry
+
+
+// -------------------- callback implementations --------------------
+//                   (empty, if feature is disabled)
+
+inline bool
+sc_phase_callback_registry::construction_done() const
+{
+#if SC_HAS_PHASE_CALLBACKS_
+    do_callback( SC_BEFORE_END_OF_ELABORATION );
+#endif
+    return false;
+}
+
+inline void
+sc_phase_callback_registry::elaboration_done() const
+{
+#if SC_HAS_PHASE_CALLBACKS_
+    do_callback( SC_END_OF_ELABORATION );
+#endif
+}
+
+inline void
+sc_phase_callback_registry::start_simulation() const
+{
+#if SC_HAS_PHASE_CALLBACKS_
+    do_callback( SC_START_OF_SIMULATION );
+#endif
+}
+
+inline void
+sc_phase_callback_registry::initialization_done() const
+{
+#if SC_HAS_PHASE_CALLBACKS_
+    scoped_status scope( m_simc->m_simulation_status
+                       , SC_END_OF_INITIALIZATION );
+
+    do_callback( SC_END_OF_INITIALIZATION );
+#endif
+}
+
+inline void
+sc_phase_callback_registry::simulation_paused() const
+{
+#if SC_HAS_PHASE_CALLBACKS_
+    do_callback( SC_PAUSED );
+#endif
+}
+
+inline void
+sc_phase_callback_registry::simulation_stopped() const
+{
+#if SC_HAS_PHASE_CALLBACKS_
+    do_callback( SC_STOPPED );
+#endif
+}
+
+inline void
+sc_phase_callback_registry::simulation_done() const
+{
+#if SC_HAS_PHASE_CALLBACKS_
+    do_callback( SC_END_OF_SIMULATION );
+#endif
+}
+
+// -------------- specialized callback implementations --------------
+
+#if 0
+inline void
+sc_phase_callback_registry::evaluation_done() const
+{
+#if SC_HAS_PHASE_CALLBACKS_
+
+    if( !m_cb_eval_vec.size() ) return;
+
+    typedef single_storage_type::const_iterator it_type;
+    single_storage_type const & vec = m_cb_eval_vec;
+
+    scoped_status scope( m_simc->m_simulation_status
+                       , SC_END_OF_EVALUATION );
+
+    for(it_type it = vec.begin(), end = vec.end(); it != end; ++it)
+        (*it)->do_simulation_phase_callback();
+#endif
+}
+#endif
+
+inline void
+sc_phase_callback_registry::update_done() const
+{
+#if SC_HAS_PHASE_CALLBACKS_
+
+    if( !m_cb_update_vec.size() ) return;
+
+    typedef single_storage_type::const_iterator it_type;
+    single_storage_type const & vec = m_cb_update_vec;
+
+    scoped_status scope( m_simc->m_simulation_status
+                       , SC_END_OF_UPDATE );
+
+    for(it_type it = vec.begin(), end = vec.end(); it != end; ++it)
+        (*it)->do_simulation_phase_callback();
+#endif
+}
+
+inline void
+sc_phase_callback_registry::before_timestep() const
+{
+#if SC_HAS_PHASE_CALLBACKS_
+
+    if( !m_cb_timestep_vec.size() ) return;
+
+    typedef single_storage_type::const_iterator it_type;
+    single_storage_type const & vec = m_cb_timestep_vec;
+
+    scoped_status scope( m_simc->m_simulation_status
+                       , SC_BEFORE_TIMESTEP );
+
+    for(it_type it = vec.begin(), end = vec.end(); it != end; ++it)
+        (*it)->do_simulation_phase_callback();
+#endif
+}
+
+// ------------------------------------------------------------------
+
+} // namespace sc_core
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+#endif /* SC_PHASE_CALLBACK_REGISTRY_H_INCLUDED_ */
+// Taf!
+
diff --git a/ext/systemc/src/sysc/kernel/sc_process.cpp b/ext/systemc/src/sysc/kernel/sc_process.cpp
new file mode 100644
index 000000000..353eddd6a
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_process.cpp
@@ -0,0 +1,854 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_process.cpp -- Base process implementation.
+
+  Original Authors: Andy Goodrich, Forte Design Systems, 17 June 2003
+                    Stuart Swan, Cadence
+                    Bishnupriya Bhattacharya, Cadence Design Systems,
+                    25 August, 2003
+
+ CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+#include "sysc/kernel/sc_name_gen.h"
+#include "sysc/kernel/sc_cthread_process.h"
+#include "sysc/kernel/sc_method_process.h"
+#include "sysc/kernel/sc_thread_process.h"
+#include "sysc/kernel/sc_sensitive.h"
+#include "sysc/kernel/sc_process_handle.h"
+#include "sysc/kernel/sc_event.h"
+#include <sstream>
+
+namespace sc_core {
+
+// sc_process_handle entities that are returned for null pointer instances:
+//
+// Note the special name for 'non_event' - this makes sure it does not
+// appear as a named event.
+
+std::vector<sc_event*> sc_process_handle::empty_event_vector;
+std::vector<sc_object*> sc_process_handle::empty_object_vector;
+sc_event                sc_process_handle::non_event(SC_KERNEL_EVENT_PREFIX);
+
+// Last process that was created:
+
+sc_process_b* sc_process_b::m_last_created_process_p = 0;
+
+//------------------------------------------------------------------------------
+//"sc_process_b::add_static_event"
+//
+// This method adds an event to the list of static events, and sets the
+// event up to call back this process when it fires.
+//------------------------------------------------------------------------------
+void sc_process_b::add_static_event( const sc_event& e )
+{
+    sc_method_handle method_h; // This process as a method.
+    sc_thread_handle thread_h; // This process as a thread.
+    
+
+    // CHECK TO SEE IF WE ARE ALREADY REGISTERED WITH THE EVENT:
+
+    for( int i = m_static_events.size() - 1; i >= 0; -- i ) {
+        if( &e == m_static_events[i] ) {
+            return;
+        }
+    }
+
+    // REMEMBER THE EVENT AND THEN REGISTER OUR OBJECT INSTANCE WITH IT:
+
+    m_static_events.push_back( &e );
+
+    switch ( m_process_kind )
+    {
+      case SC_THREAD_PROC_:
+      case SC_CTHREAD_PROC_:
+        thread_h = SCAST<sc_thread_handle>( this );
+        e.add_static( thread_h );
+        break;
+      case SC_METHOD_PROC_:
+        method_h = SCAST<sc_method_handle>( this );
+        e.add_static( method_h );
+        break;
+      default:
+        assert( false );
+        break;
+    }
+}
+
+//------------------------------------------------------------------------------
+//"sc_process_b::disconnect_process"
+//
+// This method removes this object instance from use. It will be called by
+// the kill_process() methods of classes derived from it. This object instance
+// will be removed from any data structures it resides, other than existence.
+//------------------------------------------------------------------------------
+void sc_process_b::disconnect_process()
+{
+    int               mon_n;      // monitor queue size.
+    sc_thread_handle  thread_h;   // This process as a thread.
+
+    // IF THIS OBJECT IS PINING FOR THE FJORDS WE ARE DONE:
+
+    if ( m_state & ps_bit_zombie ) return;    
+
+    // IF THIS IS A THREAD SIGNAL ANY MONITORS WAITING FOR IT TO EXIT:
+
+    switch ( m_process_kind )
+    {
+      case SC_THREAD_PROC_:
+      case SC_CTHREAD_PROC_:
+        thread_h = SCAST<sc_thread_handle>(this);
+        mon_n = thread_h->m_monitor_q.size();
+        if ( mon_n )
+        {
+            for ( int mon_i = 0; mon_i < mon_n; mon_i++ )
+            {
+                thread_h->m_monitor_q[mon_i]->signal( thread_h, 
+			      sc_process_monitor::spm_exit);
+            }
+        }
+        break;
+      default:
+        break;
+    }
+
+    // REMOVE EVENT WAITS, AND REMOVE THE PROCESS FROM ITS SC_RESET:
+
+    remove_dynamic_events();
+    remove_static_events();
+
+    for ( std::vector<sc_reset*>::size_type rst_i = 0; rst_i < m_resets.size(); rst_i++ )
+    {
+        m_resets[rst_i]->remove_process( this );
+    }
+    m_resets.resize(0);
+
+
+    // FIRE THE TERMINATION EVENT, MARK AS TERMINATED, AND DECREMENT THE COUNT:
+    //
+    // (1) We wait to set the process kind until after doing the removals
+    //     above.
+    // (2) Decrementing the reference count will result in actual object 
+    //     deletion if we hit zero.
+
+    m_state = ps_bit_zombie;
+    if ( m_term_event_p ) m_term_event_p->notify();
+    reference_decrement();
+}
+
+//------------------------------------------------------------------------------
+//"sc_process_b::delete_process"
+//
+// This method deletes the current instance, if it is not the running
+// process. Otherwise, it is put in the simcontext's process deletion
+// queue.
+//
+// The reason for the two step deletion process is that the process from which
+// reference_decrement() is called may be the running process, so we may need
+// to wait until it goes idle.
+//------------------------------------------------------------------------------
+void sc_process_b::delete_process()
+{
+    assert( m_references_n == 0 );
+
+    // Immediate deletion:
+
+    if ( this != sc_get_current_process_b() )
+    {
+        delete this;
+    }
+  
+    // Deferred deletion: note we set the reference count to one  for the call
+    // to reference_decrement that occurs in sc_simcontext::crunch().
+  
+    else
+    {
+	m_references_n = 1; 
+        detach();
+        simcontext()->mark_to_collect_process( this );
+    }
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_process_b::dont_initialize"
+//
+// This virtual method sets the initialization switch for this object instance.
+//------------------------------------------------------------------------------
+void sc_process_b::dont_initialize( bool dont )
+{
+    m_dont_init = dont;
+}
+
+//------------------------------------------------------------------------------
+//"sc_process_b::dump_state"
+//
+// This method returns the process state as a string.
+//------------------------------------------------------------------------------
+std::string sc_process_b::dump_state() const
+{
+    std::string result;
+    result = "[";
+    if ( m_state == ps_normal ) 
+    {
+        result += " normal";
+    }
+    else
+    {
+        if ( m_state & ps_bit_disabled )
+            result += "disabled ";
+        if ( m_state & ps_bit_suspended )
+            result += "suspended ";
+        if ( m_state & ps_bit_ready_to_run )
+            result += "ready_to_run ";
+        if ( m_state & ps_bit_zombie )
+            result += "zombie ";
+    }
+    result += "]";
+    return result;
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_process_b::gen_unique_name"
+//
+// This method generates a unique name within this object instance's namespace.
+//------------------------------------------------------------------------------
+const char* sc_process_b::gen_unique_name( const char* basename_,
+    bool preserve_first )
+{
+    if ( ! m_name_gen_p ) m_name_gen_p = new sc_name_gen;
+    return m_name_gen_p->gen_unique_name( basename_, preserve_first );
+}
+
+//------------------------------------------------------------------------------
+//"sc_process_b::remove_dynamic_events"
+//
+// This method removes this object instance from the events in its dynamic
+// event lists.
+//
+// Arguments:
+//     skip_timeout = skip cleaning up the timeout event, it will be done
+//                    by sc_event_notify().
+//------------------------------------------------------------------------------
+void
+sc_process_b::remove_dynamic_events( bool skip_timeout )
+{
+    sc_method_handle  method_h;   // This process as a method.
+    sc_thread_handle  thread_h;   // This process as a thread.
+
+    m_trigger_type = STATIC;
+    switch ( m_process_kind )
+    {
+      case SC_THREAD_PROC_:
+      case SC_CTHREAD_PROC_:
+        thread_h = SCAST<sc_thread_handle>(this);
+	if ( thread_h->m_timeout_event_p && !skip_timeout ) {
+	    thread_h->m_timeout_event_p->remove_dynamic(thread_h);
+	    thread_h->m_timeout_event_p->cancel();
+	}
+        if ( m_event_p ) m_event_p->remove_dynamic( thread_h );
+        if ( m_event_list_p )
+        {
+            m_event_list_p->remove_dynamic( thread_h, 0 );
+            m_event_list_p->auto_delete();
+	    m_event_list_p = 0;
+        }
+        break;
+      case SC_METHOD_PROC_:
+        method_h = SCAST<sc_method_handle>(this);
+	if ( method_h->m_timeout_event_p && !skip_timeout ) {
+	    method_h->m_timeout_event_p->remove_dynamic(method_h);
+	    method_h->m_timeout_event_p->cancel();
+	}
+        if ( m_event_p ) m_event_p->remove_dynamic( method_h );
+        if ( m_event_list_p )
+        {
+            m_event_list_p->remove_dynamic( method_h, 0 );
+            m_event_list_p->auto_delete();
+	    m_event_list_p = 0;
+        }
+        break;
+      default: // Some other type, it needs to clean up itself.
+        // std::cout << "Check " << __FILE__ << ":" << __LINE__ << std::endl;
+        break;
+    }
+}
+
+//------------------------------------------------------------------------------
+//"sc_process_b::remove_static_events"
+//
+// This method removes this object instance from the events in its static
+// event list.
+//------------------------------------------------------------------------------
+void
+sc_process_b::remove_static_events()
+{
+    sc_method_handle method_h; // This process as a method.
+    sc_thread_handle thread_h; // This process as a thread.
+
+    switch ( m_process_kind )
+    {
+      case SC_THREAD_PROC_:
+      case SC_CTHREAD_PROC_:
+        thread_h = SCAST<sc_thread_handle>( this );
+        for( int i = m_static_events.size() - 1; i >= 0; -- i ) {
+            m_static_events[i]->remove_static( thread_h );
+        }
+        m_static_events.resize(0);
+        break;
+      case SC_METHOD_PROC_:
+        method_h = DCAST<sc_method_handle>( this );
+        assert( method_h != 0 );
+        for( int i = m_static_events.size() - 1; i >= 0; -- i ) {
+            m_static_events[i]->remove_static( method_h );
+        }
+        m_static_events.resize(0);
+        break;
+      default: // Some other type, it needs to clean up itself.
+        // std::cout << "Check " << __FILE__ << ":" << __LINE__ << std::endl;
+        break;
+    }
+}
+
+//------------------------------------------------------------------------------
+// "sc_process_b::report_error"
+//
+// This method can be used to issue a report from within a process.
+// The error of the given ID is reported with the given message and
+// the process' name() appended to the report.
+//------------------------------------------------------------------------------
+void
+sc_process_b::report_error( const char* msgid, const char* msg ) const
+{
+    std::stringstream sstr;
+    if( msg && msg[0] )
+        sstr << msg << ": ";
+    sstr << name();
+    SC_REPORT_ERROR( msgid, sstr.str().c_str() );
+}
+
+
+//------------------------------------------------------------------------------
+// "sc_process_b::report_immediate_self_notification"
+//
+// This method is used to report an immediate self-notification
+// that used to trigger the process before the clarification in 1666-2011.
+// The warning is only reported once.
+//------------------------------------------------------------------------------
+void
+sc_process_b::report_immediate_self_notification() const
+{
+    static bool once = false;
+    if( !once ) {
+      SC_REPORT_WARNING( SC_ID_IMMEDIATE_SELF_NOTIFICATION_, name() );
+      once = true;
+    }
+}
+
+//------------------------------------------------------------------------------
+//"sc_process_b::reset_changed"
+//      
+// This method is called when there is a change in the value of the
+// signal that was specified via reset_signal_is, or the value of the
+// m_sticky_reset field. We get called any time m_sticky_reset changes
+// or a signal value changes since, since we may need to throw an exception 
+// or clear one. Note that this method may be called when there is no
+// active process, but rather the main simulator is executing so we must
+// check for that case.
+//
+// Arguments:
+//     async    = true if this is an asynchronous reset.
+//     asserted = true if reset being asserted, false if being deasserted.
+//------------------------------------------------------------------------------
+void sc_process_b::reset_changed( bool async, bool asserted )
+{       
+
+    // Error out on the corner case:
+
+    if ( !sc_allow_process_control_corners && !async && 
+         (m_state & ps_bit_suspended) )
+    {
+	report_error( SC_ID_PROCESS_CONTROL_CORNER_CASE_,
+	              "synchronous reset changed on a suspended process" );
+    }
+
+    // IF THIS OBJECT IS PUSHING UP DAISIES WE ARE DONE:
+
+    if ( m_state & ps_bit_zombie ) return;    
+
+    // Reset is being asserted:
+
+    if ( asserted )
+    {
+        // if ( m_reset_event_p ) m_reset_event_p->notify();
+        if ( async )
+	{
+	    m_active_areset_n++;
+	    if ( sc_is_running() ) throw_reset(true);
+	}
+	else
+	{
+	    m_active_reset_n++;
+	    if ( sc_is_running() ) throw_reset(false);
+	}
+    }
+
+    // Reset is being deasserted:
+
+    else 
+    {
+        if ( async )
+	{
+	    m_active_areset_n--;
+	}
+	else
+	{
+	    m_active_reset_n--;
+	}
+    }
+
+    // Clear the throw type if there are no active resets.
+
+    if ( (m_throw_status == THROW_SYNC_RESET || 
+          m_throw_status == THROW_ASYNC_RESET) &&
+         m_active_areset_n == 0 && m_active_reset_n == 0 && !m_sticky_reset )
+    {
+        m_throw_status = THROW_NONE;
+    }
+}       
+
+//------------------------------------------------------------------------------
+//"sc_process_b::reset_event"
+//
+// This method returns a reference to the reset event for this object 
+// instance. If no event exists one is allocated.
+//------------------------------------------------------------------------------
+sc_event& sc_process_b::reset_event()
+{
+    if ( !m_reset_event_p ) 
+    {
+        m_reset_event_p = new sc_event(
+	         (std::string(SC_KERNEL_EVENT_PREFIX)+"_reset_event").c_str() );
+    }
+    return *m_reset_event_p;
+}
+
+//------------------------------------------------------------------------------
+//"sc_process_b::reset_process"
+//
+// This inline method changes the reset state of this object instance and
+// conditionally its descendants. 
+//
+// Notes: 
+//   (1) It is called for sync_reset_on() and sync_reset_off(). It is not used 
+//       for signal sensitive resets, though all reset flow ends up in
+//       reset_changed().
+//
+// Arguments:
+//     rt = source of the reset:
+//            * reset_asynchronous     - sc_process_handle::reset()
+//            * reset_synchronous_off  - sc_process_handle::sync_reset_off()
+//            * reset_synchronous_on   - sc_process_handle::sync_reset_on()
+//     descendants = indication of how to process descendants.
+//------------------------------------------------------------------------------
+void sc_process_b::reset_process( reset_type rt,
+                                  sc_descendant_inclusion_info descendants )
+{
+
+    // PROCESS THIS OBJECT INSTANCE'S DESCENDANTS IF REQUESTED TO:
+
+    if ( descendants == SC_INCLUDE_DESCENDANTS )
+    {
+        const std::vector<sc_object*> children = get_child_objects();
+        int                           child_n  = children.size();
+
+        for ( int child_i = 0; child_i < child_n; child_i++ )
+        {
+            sc_process_b* child_p = DCAST<sc_process_b*>(children[child_i]);
+            if ( child_p ) child_p->reset_process(rt, descendants);
+        }
+    }
+
+    // PROCESS THIS OBJECT INSTANCE:
+
+    switch (rt)
+    {
+      // One-shot asynchronous reset: remove dynamic sensitivity and throw:
+      //
+      // If this is an sc_method only throw if it is active.
+
+      case reset_asynchronous:
+	if ( sc_get_status() != SC_RUNNING )
+	{
+	    report_error(SC_ID_RESET_PROCESS_WHILE_NOT_RUNNING_);
+	}
+	else
+	{
+	    remove_dynamic_events();
+	    throw_reset(true);
+	}
+        break;
+
+      // Turn on sticky synchronous reset: use standard reset mechanism.
+
+      case reset_synchronous_on:
+	if ( m_sticky_reset == false )
+	{
+	    m_sticky_reset = true;
+	    reset_changed( false, true );
+	}
+        break;
+
+      // Turn off sticky synchronous reset: use standard reset mechanism.
+
+      default:
+	if ( m_sticky_reset == true )
+	{
+	    m_sticky_reset = false;
+	    reset_changed( false, false );
+	}
+        break;
+    }   
+}
+
+//------------------------------------------------------------------------------
+//"sc_process_b::sc_process_b"
+//
+// This is the object instance constructor for this class.
+//------------------------------------------------------------------------------
+sc_process_b::sc_process_b( const char* name_p, bool is_thread, bool free_host,
+     SC_ENTRY_FUNC method_p, sc_process_host* host_p, 
+     const sc_spawn_options* /* opt_p  */
+) :
+    sc_object( name_p ),
+    file(0),
+    lineno(0),
+    proc_id( simcontext()->next_proc_id()),
+    m_active_areset_n(0),
+    m_active_reset_n(0),
+    m_dont_init( false ),
+    m_dynamic_proc( simcontext()->elaboration_done() ),
+    m_event_p(0),
+    m_event_count(0),
+    m_event_list_p(0),
+    m_exist_p(0),
+    m_free_host( free_host ),
+    m_has_reset_signal( false ),
+    m_has_stack(false),
+    m_is_thread(is_thread),
+    m_last_report_p(0),
+    m_name_gen_p(0),
+    m_process_kind(SC_NO_PROC_),
+    m_references_n(1), 
+    m_resets(),
+    m_reset_event_p(0),
+    m_resume_event_p(0),
+    m_runnable_p(0),
+    m_semantics_host_p( host_p ),
+    m_semantics_method_p ( method_p ),
+    m_state(ps_normal),
+    m_static_events(),
+    m_sticky_reset(false),
+    m_term_event_p(0),
+    m_throw_helper_p(0),
+    m_throw_status( THROW_NONE ),
+    m_timed_out(false),
+    m_timeout_event_p(0),
+    m_trigger_type(STATIC),
+    m_unwinding(false)
+{
+
+    // THIS OBJECT INSTANCE IS NOW THE LAST CREATED PROCESS:
+
+    m_last_created_process_p = this;
+    m_timeout_event_p = new sc_event(
+	          (std::string(SC_KERNEL_EVENT_PREFIX)+"_free_event").c_str() );
+}
+
+//------------------------------------------------------------------------------
+//"sc_process_b::~sc_process_b"
+//
+// This is the object instance destructor for this class.
+//------------------------------------------------------------------------------
+sc_process_b::~sc_process_b()
+{
+   
+    // REDIRECT ANY CHILDREN AS CHILDREN OF THE SIMULATION CONTEXT:
+
+    orphan_child_objects();
+
+
+    // DELETE SEMANTICS OBJECTS IF NEED BE:
+
+    if ( m_free_host ) delete m_semantics_host_p;
+#   if !defined(SC_USE_MEMBER_FUNC_PTR) // Remove invocation object.
+        delete m_semantics_method_p;
+#   endif
+
+
+    // REMOVE ANY STRUCTURES THAT MAY HAVE BEEN BUILT:
+
+    delete m_last_report_p;
+    delete m_name_gen_p;
+    delete m_reset_event_p;
+    delete m_resume_event_p;
+    delete m_term_event_p;
+    delete m_throw_helper_p;
+    delete m_timeout_event_p;
+
+}
+
+//------------------------------------------------------------------------------
+//"sc_process_b::terminated_event"
+//
+// This method returns a reference to the terminated event for this object 
+// instance. If no event exists one is allocated.
+//------------------------------------------------------------------------------
+sc_event& sc_process_b::terminated_event()
+{
+    if ( !m_term_event_p ) 
+    {
+        m_term_event_p = new sc_event(
+	          (std::string(SC_KERNEL_EVENT_PREFIX)+"_term_event").c_str() );
+    }
+    return *m_term_event_p;
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_process_b::trigger_reset_event"
+// | 
+// | This method triggers the notify event. It exists because we can't get
+// | sc_event context in sc_process.h because the includes would be 
+// | circular... sigh...
+// +----------------------------------------------------------------------------
+void sc_process_b::trigger_reset_event()
+{
+    if ( m_reset_event_p ) m_reset_event_p->notify();
+}
+
+//------------------------------------------------------------------------------
+//"sc_process_handle::operator sc_cthread_handle"
+//
+//------------------------------------------------------------------------------
+sc_process_handle::operator sc_cthread_handle()  
+{
+    return DCAST<sc_cthread_handle>(m_target_p); 
+}
+
+//------------------------------------------------------------------------------
+//"sc_process_handle::sc_method_handle"
+//
+//------------------------------------------------------------------------------
+sc_process_handle::operator sc_method_handle()  
+{
+    return DCAST<sc_method_handle>(m_target_p); 
+}
+
+//------------------------------------------------------------------------------
+//"sc_process_handle::sc_thread_handle"
+//
+//------------------------------------------------------------------------------
+sc_process_handle::operator sc_thread_handle()  
+{
+    return DCAST<sc_thread_handle>(m_target_p); 
+}
+
+} // namespace sc_core 
+
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Andy Goodrich, Forte Design Systems, 12 Aug 05
+  Description of Modification: This is the rewrite of process support. It 
+                               contains some code from the now-defunct 
+                               sc_process_b.cpp, as well as the former 
+                               version of sc_process_b.cpp.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_process.cpp,v $
+// Revision 1.37  2011/08/24 22:05:51  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.36  2011/08/15 16:43:24  acg
+//  Torsten Maehne: changes to remove unused argument warnings.
+//
+// Revision 1.35  2011/08/07 19:08:04  acg
+//  Andy Goodrich: moved logs to end of file so line number synching works
+//  better between versions.
+//
+// Revision 1.34  2011/07/29 22:55:01  acg
+//  Philipp A. Hartmann: add missing include.
+//
+// Revision 1.33  2011/07/29 22:43:41  acg
+//   Philipp A. Hartmann: changes to handle case where a process control
+//   invocation on a child process causes the list of child processes to change.
+//
+// Revision 1.32  2011/07/24 11:20:03  acg
+//  Philipp A. Hartmann: process control error message improvements:
+//  (1) Downgrade error to warning for re-kills of processes.
+//  (2) Add process name to process messages.
+//  (3) drop some superfluous colons in messages.
+//
+// Revision 1.31  2011/04/19 15:04:27  acg
+//  Philipp A. Hartmann: clean up SC_ID messages.
+//
+// Revision 1.30  2011/04/14 22:33:43  acg
+//  Andy Goodrich: added missing checks for a process being a zombie.
+//
+// Revision 1.29  2011/04/13 05:00:43  acg
+//  Andy Goodrich: removed check for method process in termination_event()
+//  since with the new IEEE 1666 2011 its legal.
+//
+// Revision 1.28  2011/04/13 02:44:26  acg
+//  Andy Goodrich: added m_unwinding flag in place of THROW_NOW because the
+//  throw status will be set back to THROW_*_RESET if reset is active and
+//  the check for an unwind being complete was expecting THROW_NONE as the
+//  clearing of THROW_NOW.
+//
+// Revision 1.27  2011/04/10 22:17:35  acg
+//  Andy Goodrich: added trigger_reset_event() to allow sc_process.h to
+//  contain the run_process() inline method. sc_process.h cannot have
+//  sc_simcontext information because of recursive includes.
+//
+// Revision 1.26  2011/04/08 22:33:08  acg
+//  Andy Goodrich: moved the semantics() method to the header file and made
+//  it an inline method.
+//
+// Revision 1.25  2011/04/08 18:24:48  acg
+//  Andy Goodrich: moved reset_changed() to .cpp since it needs visibility
+//  to sc_simcontext.
+//
+// Revision 1.24  2011/04/05 20:50:57  acg
+//  Andy Goodrich:
+//    (1) changes to make sure that event(), posedge() and negedge() only
+//        return true if the clock has not moved.
+//    (2) fixes for method self-resumes.
+//    (3) added SC_PRERELEASE_VERSION
+//    (4) removed kernel events from the object hierarchy, added
+//        sc_hierarchy_name_exists().
+//
+// Revision 1.23  2011/04/05 06:25:38  acg
+//  Andy Goodrich: new checks for simulation running in reset_process().
+//
+// Revision 1.22  2011/03/20 13:43:23  acg
+//  Andy Goodrich: added async_signal_is() plus suspend() as a corner case.
+//
+// Revision 1.21  2011/03/12 21:07:51  acg
+//  Andy Goodrich: changes to kernel generated event support.
+//
+// Revision 1.20  2011/03/07 17:38:43  acg
+//  Andy Goodrich: tightening up of checks for undefined interaction between
+//  synchronous reset and suspend.
+//
+// Revision 1.19  2011/03/06 23:30:13  acg
+//  Andy Goodrich: refining suspend - sync reset corner case checking so that
+//  the following are error situations:
+//    (1) Calling suspend on a process with a reset_signal_is() specification
+//        or sync_reset_on() is active.
+//    (2) Calling sync_reset_on() on a suspended process.
+//
+// Revision 1.18  2011/03/06 19:57:11  acg
+//  Andy Goodrich: refinements for the illegal suspend - synchronous reset
+//  interaction.
+//
+// Revision 1.17  2011/03/06 16:47:09  acg
+//  Andy Goodrich: changes for testing sync_reset - suspend corner cases.
+//
+// Revision 1.16  2011/03/06 15:57:57  acg
+//  Andy Goodrich: added process control corner case checks. Changes for
+//  named events.
+//
+// Revision 1.15  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.14  2011/02/17 19:52:13  acg
+//  Andy Goodrich:
+//    (1) Simplfied process control usage.
+//    (2) Changed dump_status() to dump_state with new signature.
+//
+// Revision 1.13  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.12  2011/02/13 21:41:34  acg
+//  Andy Goodrich: get the log messages for the previous check in correct.
+//
+// Revision 1.11  2011/02/13 21:32:24  acg
+//  Andy Goodrich: moved sc_process_b::reset_process() from header file
+//  to cpp file. Added dump_status() to print out the status of a
+//  process.
+//
+// Revision 1.10  2011/02/04 15:27:36  acg
+//  Andy Goodrich: changes for suspend-resume semantics.
+//
+// Revision 1.9  2011/02/01 21:06:12  acg
+//  Andy Goodrich: new layout for the process_state enum.
+//
+// Revision 1.8  2011/01/25 20:50:37  acg
+//  Andy Goodrich: changes for IEEE 1666 2011.
+//
+// Revision 1.7  2011/01/19 23:21:50  acg
+//  Andy Goodrich: changes for IEEE 1666 2011
+//
+// Revision 1.6  2011/01/18 20:10:45  acg
+//  Andy Goodrich: changes for IEEE1666_2011 semantics.
+//
+// Revision 1.5  2010/07/22 20:02:33  acg
+//  Andy Goodrich: bug fixes.
+//
+// Revision 1.4  2009/05/22 16:06:29  acg
+//  Andy Goodrich: process control updates.
+//
+// Revision 1.3  2008/05/22 17:06:26  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.2  2007/09/20 20:32:35  acg
+//  Andy Goodrich: changes to the semantics of throw_it() to match the
+//  specification. A call to throw_it() will immediately suspend the calling
+//  thread until all the throwees have executed. At that point the calling
+//  thread will be restarted before the execution of any other threads.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.6  2006/04/20 17:08:17  acg
+//  Andy Goodrich: 3.0 style process changes.
+//
+// Revision 1.5  2006/04/11 23:13:21  acg
+//   Andy Goodrich: Changes for reduced reset support that only includes
+//   sc_cthread, but has preliminary hooks for expanding to method and thread
+//   processes also.
+//
+// Revision 1.4  2006/01/24 20:49:05  acg
+// Andy Goodrich: changes to remove the use of deprecated features within the
+// simulator, and to issue warning messages when deprecated features are used.
+//
+// Revision 1.3  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+//
diff --git a/ext/systemc/src/sysc/kernel/sc_process.h b/ext/systemc/src/sysc/kernel/sc_process.h
new file mode 100644
index 000000000..298e2462f
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_process.h
@@ -0,0 +1,887 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_process.h -- Process base class support.
+
+  Original Author: Andy Goodrich, Forte Design Systems, 04 August 2005
+
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#if !defined(sc_process_h_INCLUDED)
+#define sc_process_h_INCLUDED
+
+#include <cassert>
+#include "sysc/utils/sc_iostream.h"
+#include "sysc/kernel/sc_constants.h"
+#include "sysc/kernel/sc_object.h"
+#include "sysc/kernel/sc_kernel_ids.h"
+#include "sysc/communication/sc_export.h"
+
+namespace sc_core {
+
+// Forward declarations:
+class sc_process_handle;
+class sc_thread_process;
+class sc_reset;
+
+const char* sc_gen_unique_name( const char*, bool preserve_first );
+sc_process_handle sc_get_current_process_handle();
+void sc_thread_cor_fn( void* arg );
+bool timed_out( sc_simcontext* );
+
+extern bool sc_allow_process_control_corners; // see sc_simcontext.cpp.
+
+
+// Process handles as forward references:
+
+typedef class sc_cthread_process* sc_cthread_handle;
+typedef class sc_method_process*  sc_method_handle;
+typedef class sc_thread_process*  sc_thread_handle;
+
+
+// Standard process types:
+
+enum sc_curr_proc_kind
+{
+    SC_NO_PROC_,
+    SC_METHOD_PROC_,
+    SC_THREAD_PROC_,
+    SC_CTHREAD_PROC_
+};
+
+// Descendant information for process hierarchy operations:
+
+enum sc_descendant_inclusion_info {
+    SC_NO_DESCENDANTS=0,
+    SC_INCLUDE_DESCENDANTS,
+    SC_INVALID_DESCENDANTS
+};
+
+//==============================================================================
+// CLASS sc_process_host
+//
+// This is the base class for objects which may have processes defined for
+// their methods (e.g., sc_module)
+//==============================================================================
+
+class sc_process_host 
+{
+  public:
+    sc_process_host() {}
+    virtual ~sc_process_host() { } // Needed for cast check for sc_module.
+    void defunct() {}
+};
+
+
+//==============================================================================
+// CLASS sc_process_monitor
+//
+// This class provides a way of monitoring a process' status (e.g., waiting 
+// for a thread to complete its execution.) This class is intended to be a base
+// class for classes which need to monitor a process or processes (e.g.,
+// sc_join.) Its methods should be overloaded where notifications are desired.
+//==============================================================================
+
+class sc_process_monitor {
+  public:
+    enum {
+        spm_exit = 0
+    };
+    virtual ~sc_process_monitor() {}
+    virtual void signal(sc_thread_handle thread_p, int type);
+};
+inline void sc_process_monitor::signal(sc_thread_handle , int ) {}  
+
+//------------------------------------------------------------------------------
+// PROCESS INVOCATION METHOD OR FUNCTION:
+//
+//  Define SC_USE_MEMBER_FUNC_PTR if we want to use member function pointers 
+//  to implement process dispatch. Otherwise, we'll use a hack that involves 
+//  creating a templated invocation object which will invoke the member
+//  function. This should not be necessary, but some compilers (e.g., VC++)
+//  do not allow the conversion from `void (callback_tag::*)()' to 
+//  `void (sc_process_host::*)()'. This is supposed to be OK as long as the 
+//  dynamic type is correct.  C++ Standard 5.4 "Explicit type conversion", 
+//  clause 7: a pointer to member of derived class type may be explicitly 
+//  converted to a pointer to member of an unambiguous non-virtual base class 
+//  type. 
+//-----------------------------------------------------------------------------
+
+#if defined(_MSC_VER)
+#if ( _MSC_VER > 1200 )
+#   define SC_USE_MEMBER_FUNC_PTR
+#endif
+#else
+#   define SC_USE_MEMBER_FUNC_PTR
+#endif
+
+
+// COMPILER DOES SUPPORT CAST TO void (sc_process_host::*)() from (T::*)():
+
+#if defined(SC_USE_MEMBER_FUNC_PTR)
+
+    typedef void (sc_process_host::*SC_ENTRY_FUNC)();
+#   define SC_DECL_HELPER_STRUCT(callback_tag, func) /*EMPTY*/
+#   define SC_MAKE_FUNC_PTR(callback_tag, func) \
+        static_cast<sc_core::SC_ENTRY_FUNC>(&callback_tag::func)
+
+
+// COMPILER NOT DOES SUPPORT CAST TO void (sc_process_host::*)() from (T::*)():
+
+#else // !defined(SC_USE_MEMBER_FUNC_PTR)
+    class sc_process_call_base {
+      public:
+        inline sc_process_call_base()
+        {
+        }
+
+        virtual ~sc_process_call_base()
+        {
+        }
+
+        virtual void invoke(sc_process_host* host_p)
+        {
+        }
+    };
+    extern sc_process_call_base sc_process_defunct;
+
+    template<class T>
+    class sc_process_call : public sc_process_call_base {
+      public:
+        sc_process_call( void (T::*method_p)() ) :
+            sc_process_call_base()
+        {
+             m_method_p = method_p;
+        }
+
+        virtual ~sc_process_call()
+        {
+        }
+
+        virtual void invoke(sc_process_host* host_p)
+        {
+            (((T*)host_p)->*m_method_p)();
+        }
+
+      protected:
+        void (T::*m_method_p)();  // Method implementing the process.
+    };
+
+    typedef sc_process_call_base* SC_ENTRY_FUNC;
+#   define SC_DECL_HELPER_STRUCT(callback_tag, func) /*EMPTY*/
+#   define SC_MAKE_FUNC_PTR(callback_tag, func) \
+        (::sc_core::SC_ENTRY_FUNC) (new \
+        ::sc_core::sc_process_call<callback_tag>(&callback_tag::func))
+
+#endif // !defined(SC_USE_MEMBER_FUNC_PTR)
+
+
+extern void sc_set_stack_size( sc_thread_handle, std::size_t );
+
+class sc_event;
+class sc_event_list;
+class sc_name_gen;
+class sc_spawn_options;
+class sc_unwind_exception;
+
+//==============================================================================
+// CLASS sc_throw_it<EXCEPT> - ARBITRARY EXCEPTION CLASS
+//
+// This class serves as a way of throwing an execption for an aribtrary type
+// without knowing what that type is. A true virtual method in the base
+// class is used to actually throw the execption. A pointer to the base 
+// class is used internally removing the necessity of knowing what the type
+// of EXCEPT is for code internal to the library.
+//
+// Note the clone() true virtual method. This is used to allow instances
+// of the sc_throw_it<EXCEPT> class to be easily garbage collected. Since
+// an exception may be propogated to more than one process knowing when
+// to garbage collect is non-trivial. So when a call is made to 
+// sc_process_handle::throw_it() an instance of sc_throw_it<EXCEPT> is 
+// allocated on the stack. For each process throwing the exception a copy is 
+// made via clone(). That allows those objects to be deleted by the individual
+// processes when they are no longer needed (in this implementation of SystemC 
+// that deletion will occur each time a new exception is thrown ( see 
+// sc_thread_process::suspend_me() ).
+//==============================================================================
+class sc_throw_it_helper {
+  public:
+    virtual sc_throw_it_helper* clone() const = 0;
+    virtual void throw_it() = 0;
+    sc_throw_it_helper() {}
+    virtual ~sc_throw_it_helper() {}
+};
+
+template<typename EXCEPT>
+class sc_throw_it : public sc_throw_it_helper
+{
+    typedef sc_throw_it<EXCEPT> this_type;
+  public:
+    sc_throw_it( const EXCEPT& value ) : m_value(value) { }
+    virtual ~sc_throw_it() {}
+    virtual inline this_type* clone() const { return new this_type(m_value); }
+    virtual inline void throw_it() { throw m_value; }
+  protected:
+    EXCEPT m_value;  // value to be thrown.
+};
+
+//==============================================================================
+// CLASS sc_process_b - USER INITIATED DYNAMIC PROCESS SUPPORT:
+//
+// This class implements the base class for a threaded process_base process 
+// whose semantics are provided by the true virtual method semantics(). 
+// Classes derived from this one will provide a version of semantics which 
+// implements the desired semantics. See the sc_spawn_xxx classes below.
+//
+// Notes:
+//   (1) Object instances of this class maintain a reference count of 
+//       outstanding handles. When the handle count goes to zero the 
+//       object will be deleted. 
+//   (2) Descriptions of the methods and operators in this class appear with
+//       their implementations.
+//   (3) The m_sticky_reset field is used to handle synchronous resets that
+//       are enabled via the sc_process_handle::sync_reset_on() method. These
+//       resets are not generated by a signal, but rather are modal by 
+//       method call: sync_reset_on - sync_reset_off.
+//       
+//==============================================================================
+class sc_process_b : public sc_object { 
+    friend class sc_simcontext;      // Allow static processes to have base.
+    friend class sc_cthread_process; // Child can access parent.
+    friend class sc_method_process;  // Child can access parent.
+    friend class sc_process_handle;  // Allow handles to modify ref. count.
+    friend class sc_thread_process;  // Child can access parent.
+
+    friend class sc_object;
+    friend class sc_port_base;
+    friend class sc_runnable;
+    friend class sc_sensitive;
+    friend class sc_sensitive_pos;
+    friend class sc_sensitive_neg;
+    friend class sc_module;
+    friend class sc_report_handler;
+    friend class sc_reset;
+    friend class sc_reset_finder;
+    friend class sc_unwind_exception;
+
+    friend const char* sc_gen_unique_name( const char*, bool preserve_first );
+    friend sc_process_handle sc_get_current_process_handle();
+    friend void sc_thread_cor_fn( void* arg );
+    friend bool timed_out( sc_simcontext* );
+
+  public:
+    enum process_throw_type {
+        THROW_NONE = 0,
+	THROW_KILL,
+        THROW_USER,
+        THROW_ASYNC_RESET,
+        THROW_SYNC_RESET
+    };
+
+    enum process_state {
+	ps_bit_disabled = 1,      // process is disabled.
+	ps_bit_ready_to_run = 2,  // process is ready to run.
+        ps_bit_suspended = 4,     // process is suspended.
+	ps_bit_zombie = 8,        // process is a zombie.
+        ps_normal = 0             // must be zero.
+    };
+
+    enum reset_type {             // types for sc_process_b::reset_process()
+        reset_asynchronous = 0,   // asynchronous reset.
+        reset_synchronous_off,    // turn off synchronous reset sticky bit.
+        reset_synchronous_on      // turn on synchronous reset sticky bit.
+    };
+
+    enum trigger_t
+    {
+        STATIC,
+        EVENT,
+        OR_LIST,
+        AND_LIST,
+        TIMEOUT,
+        EVENT_TIMEOUT,
+        OR_LIST_TIMEOUT,
+        AND_LIST_TIMEOUT
+    };
+
+  public: 
+    sc_process_b( const char* name_p, bool is_thread, bool free_host, 
+        SC_ENTRY_FUNC method_p, sc_process_host* host_p, 
+        const sc_spawn_options* opt_p );
+
+  protected:
+    // may not be deleted manually (called from destroy_process())
+    virtual ~sc_process_b();
+
+  public:
+    inline int current_state() { return m_state; }
+    bool dont_initialize() const { return m_dont_init; }
+    virtual void dont_initialize( bool dont );
+    std::string dump_state() const;
+    const ::std::vector<sc_object*>& get_child_objects() const;
+    inline sc_curr_proc_kind proc_kind() const;
+    sc_event& reset_event();
+    sc_event& terminated_event();
+
+  public:
+    static inline sc_process_handle last_created_process_handle();
+        
+  protected:
+    virtual void add_child_object( sc_object* );
+    void add_static_event( const sc_event& );
+    bool dynamic() const { return m_dynamic_proc; }
+    const char* gen_unique_name( const char* basename_, bool preserve_first );
+    inline sc_report* get_last_report() { return m_last_report_p; }
+    inline bool is_disabled() const;
+    inline bool is_runnable() const;
+    static inline sc_process_b* last_created_process_base();
+    virtual bool remove_child_object( sc_object* );
+    void remove_dynamic_events( bool skip_timeout = false );
+    void remove_static_events();
+    inline void set_last_report( sc_report* last_p )
+        {  
+            delete m_last_report_p;
+            m_last_report_p = last_p;
+        }
+    inline bool timed_out() const;
+    void report_error( const char* msgid, const char* msg = "" ) const;
+    void report_immediate_self_notification() const;
+
+  protected: // process control methods:
+    virtual void disable_process(
+        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS ) = 0;
+    void disconnect_process();
+    virtual void enable_process(
+        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS ) = 0;
+    inline void initially_in_reset( bool async );
+    inline bool is_unwinding() const;
+    inline bool start_unwinding();
+    inline bool clear_unwinding();
+    virtual void kill_process(
+        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS ) = 0;
+    void reset_changed( bool async, bool asserted );
+    void reset_process( reset_type rt,
+        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS );
+    virtual void resume_process(
+        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS ) = 0;
+    virtual void suspend_process(
+        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS ) = 0;
+    virtual void throw_user( const sc_throw_it_helper& helper,
+        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS ) = 0;
+    virtual void throw_reset( bool async ) = 0;
+    virtual bool terminated() const;
+    void trigger_reset_event();
+
+  private:
+    void        delete_process();
+    inline void reference_decrement();
+    inline void reference_increment();
+
+  protected:
+    inline void semantics();
+
+    // debugging stuff:
+
+  public:
+    const char*                 file;
+    int                         lineno;
+    int                         proc_id;
+
+  protected:
+    int                          m_active_areset_n; // number of aresets active.
+    int                          m_active_reset_n;  // number of resets active.
+    bool                         m_dont_init;       // true: no initialize call.
+    bool                         m_dynamic_proc;    // true: after elaboration.
+    const sc_event*              m_event_p;         // Dynamic event waiting on.
+    int                          m_event_count;     // number of events.
+    const sc_event_list*         m_event_list_p;    // event list waiting on.
+    sc_process_b*                m_exist_p;         // process existence link.
+    bool                         m_free_host;       // free sc_semantic_host_p.
+    bool                         m_has_reset_signal;  // has reset_signal_is.
+    bool                         m_has_stack;       // true is stack present.
+    bool                         m_is_thread;       // true if this is thread.
+    sc_report*                   m_last_report_p;   // last report this process.
+    sc_name_gen*                 m_name_gen_p;      // subprocess name generator
+    sc_curr_proc_kind            m_process_kind;    // type of process.
+    int                          m_references_n;    // outstanding handles.
+    std::vector<sc_reset*>       m_resets;          // resets for process.
+    sc_event*                    m_reset_event_p;   // reset event.
+    sc_event*                    m_resume_event_p;  // resume event.
+    sc_process_b*                m_runnable_p;      // sc_runnable link
+    sc_process_host*             m_semantics_host_p;   // host for semantics.
+    SC_ENTRY_FUNC                m_semantics_method_p; // method for semantics.
+    int                          m_state;           // process state.
+    std::vector<const sc_event*> m_static_events;   // static events waiting on.
+    bool                         m_sticky_reset;    // see note 3 above.
+    sc_event*                    m_term_event_p;    // terminated event.
+    sc_throw_it_helper*          m_throw_helper_p;  // what to throw.
+    process_throw_type           m_throw_status;    // exception throwing status
+    bool                         m_timed_out;       // true if we timed out.
+    sc_event*                    m_timeout_event_p; // timeout event.
+    trigger_t                    m_trigger_type;    // type of trigger using.
+    bool                         m_unwinding;       // true if unwinding stack.
+
+  protected:
+    static sc_process_b* m_last_created_process_p; // Last process created.
+};
+
+typedef sc_process_b sc_process_b;  // For compatibility.
+
+
+//------------------------------------------------------------------------------
+//"sc_process_b::XXXX_child_YYYYY"
+//
+// These methods provide child object support.
+//------------------------------------------------------------------------------
+inline void
+sc_process_b::add_child_object( sc_object* object_p )
+{
+    sc_object::add_child_object( object_p );
+    reference_increment();
+}
+
+inline bool
+sc_process_b::remove_child_object( sc_object* object_p )
+{
+    if ( sc_object::remove_child_object( object_p ) ) {
+	    reference_decrement();
+            return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+inline const ::std::vector<sc_object*>&
+sc_process_b::get_child_objects() const
+{
+    return m_child_objects;
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_process_b::initially_in_reset"
+//
+// This inline method is a callback to indicate that a reset is active at
+// start up. This is because the signal will have been initialized before
+// a reset linkage for it is set up, so we won't get a reset_changed()
+// callback.
+//     async = true if this an asynchronous reset.
+//------------------------------------------------------------------------------
+inline void sc_process_b::initially_in_reset( bool async )
+{
+    if ( async ) 
+        m_active_areset_n++;
+    else
+        m_active_reset_n++;
+}
+
+//------------------------------------------------------------------------------
+//"sc_process_b::is_disabled"
+//
+// This method returns true if this process is disabled. 
+//------------------------------------------------------------------------------
+inline bool sc_process_b::is_disabled() const
+{
+    return (m_state & ps_bit_disabled) ? true : false;
+}
+
+//------------------------------------------------------------------------------
+//"sc_process_b::is_runnable"
+//
+// This method returns true if this process is runnable. That is indicated
+// by a non-zero m_runnable_p field.
+//------------------------------------------------------------------------------
+inline bool sc_process_b::is_runnable() const
+{
+    return m_runnable_p != 0;
+}
+
+//------------------------------------------------------------------------------
+//"sc_process_b::is_unwinding"
+//
+// This method returns true if this process is unwinding from a kill or reset.
+//------------------------------------------------------------------------------
+inline bool sc_process_b::is_unwinding() const
+{
+    return m_unwinding;
+}
+
+//------------------------------------------------------------------------------
+//"sc_process_b::start_unwinding"
+//
+// This method flags that this object instance should start unwinding if the
+// current throw status requires an unwind. 
+//
+// Result is true if the flag is set, false if the flag is already set.
+//------------------------------------------------------------------------------
+inline bool sc_process_b::start_unwinding()
+{
+    if ( !m_unwinding )
+    {
+	switch( m_throw_status )
+	{
+	  case THROW_KILL:
+	  case THROW_ASYNC_RESET:
+	  case THROW_SYNC_RESET:
+	    m_unwinding = true;
+	     return true;
+	  case THROW_USER:
+	   default:
+	     break;
+	 }
+    }
+    return false;
+}
+
+//------------------------------------------------------------------------------
+//"sc_process_b::clear_unwinding"
+//
+// This method clears this object instance's throw status and always returns
+// true.
+//------------------------------------------------------------------------------
+inline bool sc_process_b::clear_unwinding()
+{
+    m_unwinding = false;
+    return true;
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_process_b::last_created_process_base"
+//
+// This virtual method returns the sc_process_b pointer for the last
+// created process. It is only used internally by the simulator.
+//------------------------------------------------------------------------------
+inline sc_process_b* sc_process_b::last_created_process_base()
+{
+    return m_last_created_process_p;
+}
+
+
+
+//------------------------------------------------------------------------------
+//"sc_process_b::proc_kind"
+//
+// This method returns the kind of this process.
+//------------------------------------------------------------------------------
+inline sc_curr_proc_kind sc_process_b::proc_kind() const
+{
+    return m_process_kind;
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_process_b::reference_decrement"
+//
+// This inline method decrements the number of outstanding references to this 
+// object instance. If the number of references goes to zero, this object
+// can be deleted in "sc_process_b::delete_process()".
+//------------------------------------------------------------------------------
+inline void sc_process_b::reference_decrement()
+{
+    m_references_n--;
+    if ( m_references_n == 0 ) delete_process();
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_process_b::reference_increment"
+//
+// This inline method increments the number of outstanding references to this 
+// object instance.
+//------------------------------------------------------------------------------
+inline void sc_process_b::reference_increment()
+{
+    assert(m_references_n != 0);
+    m_references_n++;
+}
+
+//------------------------------------------------------------------------------
+//"sc_process_b::semantics"
+//
+// This inline method invokes the semantics for this object instance. 
+// We check to see if we are initially in reset and then invoke the
+// process semantics.
+//
+// Notes:
+//   (1) For a description of the process reset mechanism see the top of 
+//       the file sc_reset.cpp.
+//------------------------------------------------------------------------------
+struct scoped_flag
+{
+    scoped_flag( bool& b ) : ref(b){ ref = true;  }
+    ~scoped_flag()                 { ref = false; }
+    bool& ref;
+};
+inline void sc_process_b::semantics()
+{
+
+    // within this function, the process has a stack associated
+
+    scoped_flag scoped_stack_flag( m_has_stack );
+
+    assert( m_process_kind != SC_NO_PROC_ );
+
+    // Determine the reset status of this object instance and potentially
+    // trigger its notify event:
+
+    // See if we need to trigger the notify event:
+
+    if ( m_reset_event_p && 
+         ( (m_throw_status == THROW_SYNC_RESET) || 
+	   (m_throw_status == THROW_ASYNC_RESET) )
+    ) {
+        trigger_reset_event();
+    }
+
+    // Set the new reset status of this object based on the reset counts:
+
+    m_throw_status = m_active_areset_n ? THROW_ASYNC_RESET : 
+        ( m_active_reset_n  ?  THROW_SYNC_RESET : THROW_NONE);
+
+    // Dispatch the actual semantics for the process:
+
+#   ifndef SC_USE_MEMBER_FUNC_PTR
+        m_semantics_method_p->invoke( m_semantics_host_p );
+#   else
+        (m_semantics_host_p->*m_semantics_method_p)(); 
+#   endif
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_process_b::terminated"
+//
+// This inline method returns true if this object has terminated.
+//------------------------------------------------------------------------------
+inline bool sc_process_b::terminated() const
+{
+    return (m_state & ps_bit_zombie) != 0;
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_process_b::timed_out"
+//
+// This inline method returns true if this object instance timed out.
+//------------------------------------------------------------------------------
+inline bool sc_process_b::timed_out() const
+{
+    return m_timed_out;
+}
+
+} // namespace sc_core
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Andy Goodrich, Forte Design Systems, 12 Aug 05
+  Description of Modification: This is the rewrite of process support. It 
+                               contains some code from the original
+                               sc_process.h by Stan Liao, and the now-defunct
+                               sc_process_b.h by Stan Liao and Martin
+                               Janssen, all of Synopsys, Inc., It also contains
+                               code from the original sc_process_b.h by 
+                               Andy Goodrich of Forte Design Systems and
+                               Bishnupriya Bhattacharya of Cadence Design
+                               Systems.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_process.h,v $
+// Revision 1.36  2011/08/26 22:44:30  acg
+//  Torsten Maehne: eliminate unused argument warning.
+//
+// Revision 1.35  2011/08/26 20:46:10  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.34  2011/08/24 22:05:51  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.33  2011/08/15 16:43:24  acg
+//  Torsten Maehne: changes to remove unused argument warnings.
+//
+// Revision 1.32  2011/07/24 11:20:03  acg
+//  Philipp A. Hartmann: process control error message improvements:
+//  (1) Downgrade error to warning for re-kills of processes.
+//  (2) Add process name to process messages.
+//  (3) drop some superfluous colons in messages.
+//
+// Revision 1.31  2011/04/13 02:44:26  acg
+//  Andy Goodrich: added m_unwinding flag in place of THROW_NOW because the
+//  throw status will be set back to THROW_*_RESET if reset is active and
+//  the check for an unwind being complete was expecting THROW_NONE as the
+//  clearing of THROW_NOW.
+//
+// Revision 1.30  2011/04/11 22:07:27  acg
+//  Andy Goodrich: check for reset event notification before resetting the
+//  throw_status value.
+//
+// Revision 1.29  2011/04/10 22:17:36  acg
+//  Andy Goodrich: added trigger_reset_event() to allow sc_process.h to
+//  contain the run_process() inline method. sc_process.h cannot have
+//  sc_simcontext information because of recursive includes.
+//
+// Revision 1.28  2011/04/08 22:34:06  acg
+//  Andy Goodrich: moved the semantics() method to this file and made it
+//  an inline method. Added reset processing to the semantics() method.
+//
+// Revision 1.27  2011/04/08 18:24:48  acg
+//  Andy Goodrich: moved reset_changed() to .cpp since it needs visibility
+//  to sc_simcontext.
+//
+// Revision 1.26  2011/04/01 21:24:57  acg
+//  Andy Goodrich: removed unused code.
+//
+// Revision 1.25  2011/03/28 13:02:51  acg
+//  Andy Goodrich: Changes for disable() interactions.
+//
+// Revision 1.24  2011/03/20 13:43:23  acg
+//  Andy Goodrich: added async_signal_is() plus suspend() as a corner case.
+//
+// Revision 1.23  2011/03/12 21:07:51  acg
+//  Andy Goodrich: changes to kernel generated event support.
+//
+// Revision 1.22  2011/03/08 20:49:31  acg
+//  Andy Goodrich: implement coarse checking for synchronous reset - suspend
+//  interaction.
+//
+// Revision 1.21  2011/03/07 17:38:43  acg
+//  Andy Goodrich: tightening up of checks for undefined interaction between
+//  synchronous reset and suspend.
+//
+// Revision 1.20  2011/03/06 19:57:11  acg
+//  Andy Goodrich: refinements for the illegal suspend - synchronous reset
+//  interaction.
+//
+// Revision 1.19  2011/03/05 19:44:20  acg
+//  Andy Goodrich: changes for object and event naming and structures.
+//
+// Revision 1.18  2011/02/19 08:30:53  acg
+//  Andy Goodrich: Moved process queueing into trigger_static from
+//  sc_event::notify.
+//
+// Revision 1.17  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.16  2011/02/18 20:10:44  acg
+//  Philipp A. Hartmann: force return expression to be a bool to keep MSVC
+//  happy.
+//
+// Revision 1.15  2011/02/17 19:52:45  acg
+//  Andy Goodrich:
+//    (1) Simplified process control usage.
+//    (2) Changed dump_status() to dump_state() with new signature.
+//
+// Revision 1.14  2011/02/16 22:37:30  acg
+//  Andy Goodrich: clean up to remove need for ps_disable_pending.
+//
+// Revision 1.13  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.12  2011/02/13 21:41:34  acg
+//  Andy Goodrich: get the log messages for the previous check in correct.
+//
+// Revision 1.11  2011/02/13 21:32:24  acg
+//  Andy Goodrich: moved sc_process_b::reset_process() implementation
+//  from header to cpp file . Added dump_status() to print out the status of a
+//  process.
+//
+// Revision 1.10  2011/02/11 13:25:24  acg
+//  Andy Goodrich: Philipp A. Hartmann's changes:
+//    (1) Removal of SC_CTHREAD method overloads.
+//    (2) New exception processing code.
+//
+// Revision 1.9  2011/02/04 15:27:36  acg
+//  Andy Goodrich: changes for suspend-resume semantics.
+//
+// Revision 1.8  2011/02/01 21:06:12  acg
+//  Andy Goodrich: new layout for the process_state enum.
+//
+// Revision 1.7  2011/01/25 20:50:37  acg
+//  Andy Goodrich: changes for IEEE 1666 2011.
+//
+// Revision 1.6  2011/01/19 23:21:50  acg
+//  Andy Goodrich: changes for IEEE 1666 2011
+//
+// Revision 1.5  2011/01/18 20:10:45  acg
+//  Andy Goodrich: changes for IEEE1666_2011 semantics.
+//
+// Revision 1.4  2010/07/22 20:02:33  acg
+//  Andy Goodrich: bug fixes.
+//
+// Revision 1.3  2009/05/22 16:06:29  acg
+//  Andy Goodrich: process control updates.
+//
+// Revision 1.2  2008/05/22 17:06:26  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.11  2006/05/08 17:58:10  acg
+// Andy Goodrich: added David Long's forward declarations for friend
+//   functions, methods, and operators to keep the Microsoft compiler happy.
+//
+// Revision 1.10  2006/04/28 23:29:01  acg
+//  Andy Goodrich: added an sc_core:: prefix to SC_FUNC_PTR in the
+//  SC_MAKE_FUNC_PTR macro to allow its transpareuse outside of the sc_core
+//  namespace.
+//
+// Revision 1.9  2006/04/28 21:52:57  acg
+//  Andy Goodrich: changed SC_MAKE_FUNC_PTR to use a static cast to address
+//  and AIX issue wrt sc_module's inherited classes.
+//
+// Revision 1.8  2006/04/20 17:08:17  acg
+//  Andy Goodrich: 3.0 style process changes.
+//
+// Revision 1.7  2006/04/11 23:13:21  acg
+//   Andy Goodrich: Changes for reduced reset support that only includes
+//   sc_cthread, but has preliminary hooks for expanding to method and thread
+//   processes also.
+//
+// Revision 1.6  2006/03/13 20:26:50  acg
+//  Andy Goodrich: Addition of forward class declarations, e.g.,
+//  sc_reset, to keep gcc 4.x happy.
+//
+// Revision 1.5  2006/01/31 20:09:10  acg
+//  Andy Goodrich: added explaination of static vs dynamic waits to
+//  sc_process_b::trigger_static.
+//
+// Revision 1.4  2006/01/24 20:49:05  acg
+// Andy Goodrich: changes to remove the use of deprecated features within the
+// simulator, and to issue warning messages when deprecated features are used.
+//
+// Revision 1.3  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+
+#endif // !defined(sc_process_h_INCLUDED)
diff --git a/ext/systemc/src/sysc/kernel/sc_process_handle.h b/ext/systemc/src/sysc/kernel/sc_process_handle.h
new file mode 100644
index 000000000..c219f5fad
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_process_handle.h
@@ -0,0 +1,608 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_process_handle.h -- Process access support.
+
+  Original Author: Andy Goodrich, Forte Design Systems, 17 June 2003
+               
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+// $Log: sc_process_handle.h,v $
+// Revision 1.21  2011/08/26 21:54:04  acg
+//  Torsten Maehne: Simplify use of dynamic_cast<> for initializing m_target.
+//
+// Revision 1.20  2011/08/26 20:46:10  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+
+#if !defined(sc_process_handle_h_INCLUDED)
+#define sc_process_handle_h_INCLUDED
+
+#include "sysc/kernel/sc_module.h"
+
+namespace sc_core {
+
+// forward operator declarations:
+
+class sc_process_handle;
+bool 
+operator == ( const sc_process_handle& left, const sc_process_handle& right );
+bool 
+operator != ( const sc_process_handle& left, const sc_process_handle& right );
+bool 
+operator < ( const sc_process_handle& left, const sc_process_handle& right );
+
+
+
+//=============================================================================
+// CLASS sc_process_handle
+//
+// This class provides access to an sc_process_b object instance in a
+// manner which allows some persistence after the deletion of the actual 
+// process.
+//=============================================================================
+class sc_simcontext;
+class sc_process_handle {
+    typedef sc_process_handle this_type;
+
+    friend bool operator == ( const this_type& left, const this_type& right );
+    friend bool operator != ( const this_type& left, const this_type& right );
+    friend bool operator < ( const this_type& left, const this_type& right );
+    friend class sc_object;
+    friend class sc_join;
+    friend class sc_module;
+    friend class sc_reset;
+    friend class sc_sensitive;
+    friend class sc_sensitive_pos;
+    friend class sc_sensitive_neg;
+    friend class sc_thread_process;
+
+  public:
+    inline sc_process_handle();
+    inline explicit sc_process_handle( sc_object* object_p );
+    inline explicit sc_process_handle( sc_process_b* process_p );
+    inline sc_process_handle( const sc_process_handle& orig );
+    inline ~sc_process_handle();
+    inline sc_process_handle& operator = ( sc_process_handle src );
+    inline void swap( sc_process_handle& other );
+
+  public:
+    inline void disable(
+        sc_descendant_inclusion_info descendants=SC_NO_DESCENDANTS );
+    inline bool dynamic() const;
+    inline void enable(
+        sc_descendant_inclusion_info descendants=SC_NO_DESCENDANTS );
+    inline const std::vector<sc_event*>& get_child_events() const;
+    inline const std::vector<sc_object*>& get_child_objects() const;
+    inline sc_object* get_parent_object() const;
+    inline sc_object* get_process_object() const;
+    inline bool is_unwinding() const;
+    inline void kill( 
+        sc_descendant_inclusion_info descendants=SC_NO_DESCENDANTS );
+    inline const char* name() const;
+    inline sc_curr_proc_kind proc_kind() const;
+    inline void reset( 
+        sc_descendant_inclusion_info descendants=SC_NO_DESCENDANTS );
+    inline sc_event& reset_event() const;
+    inline void resume(
+        sc_descendant_inclusion_info descendants=SC_NO_DESCENDANTS );
+    inline void suspend(
+        sc_descendant_inclusion_info descendants=SC_NO_DESCENDANTS );
+    inline void sync_reset_off( 
+        sc_descendant_inclusion_info descendants=SC_NO_DESCENDANTS );
+    inline void sync_reset_on( 
+        sc_descendant_inclusion_info descendants=SC_NO_DESCENDANTS );
+    inline sc_event& terminated_event();
+    inline bool terminated() const;
+    template<typename EXCEPT>
+    inline void throw_it( const EXCEPT& exception,
+        sc_descendant_inclusion_info descendants=SC_NO_DESCENDANTS );
+    inline bool valid() const;
+
+  public: // implementation specific methods:
+    inline std::string dump_state() const;
+
+  protected:
+    inline bool dont_initialize() const 
+        { return m_target_p ? m_target_p->dont_initialize() : false; }
+    inline void dont_initialize( bool dont );
+
+  public:
+    operator sc_process_b* () 
+        { return m_target_p; }
+    operator sc_cthread_handle ();
+    operator sc_method_handle ();
+    operator sc_thread_handle ();  
+
+  protected:
+    sc_process_b* m_target_p;   // Target for this object instance.
+
+  protected:
+    static std::vector<sc_event*>  empty_event_vector;  // If m_target_p == 0.
+    static std::vector<sc_object*> empty_object_vector; // If m_target_p == 0.
+    static sc_event                non_event;           // If m_target_p == 0.
+};
+
+inline bool operator == ( 
+    const sc_process_handle& left, const sc_process_handle& right )
+{
+    return (left.m_target_p != 0) && (right.m_target_p != 0) &&
+        (left.m_target_p == right.m_target_p);
+}
+
+inline bool operator != ( 
+    const sc_process_handle& left, const sc_process_handle& right )
+{
+    return (left.m_target_p == 0) || (right.m_target_p == 0) ||
+        (left.m_target_p != right.m_target_p);
+}
+
+inline bool operator < (
+    const sc_process_handle& left, const sc_process_handle& right )
+{
+    return left.m_target_p < right.m_target_p;
+}
+
+//------------------------------------------------------------------------------
+//"sc_process_handle::sc_process_handle - non-pointer constructor"
+//
+// This version of the object instance constructor for this class creates
+// an object instance whose target needs to be supplied via an assignment.
+//------------------------------------------------------------------------------
+inline sc_process_handle::sc_process_handle() : m_target_p(0)
+{
+}
+
+//------------------------------------------------------------------------------
+//"sc_process_handle::sc_process_handle - pointer constructor"
+//
+// This version of the object instance constructor for this class creates
+// an object instance whose target is the supplied sc_object instance.
+// The supplied sc_object must in fact be an sc_process_b instance.
+//     object_p -> sc_object instance this is handle for.
+//------------------------------------------------------------------------------
+inline sc_process_handle::sc_process_handle( sc_object* object_p ) :
+    m_target_p(DCAST<sc_process_b*>(object_p))
+{
+    if ( m_target_p ) m_target_p->reference_increment();
+}
+
+//------------------------------------------------------------------------------
+//"sc_process_handle::sc_process_handle - pointer constructor"
+//
+// This version of the object instance constructor for this class creates
+// an object instance whose target is the supplied sc_process_b instance.
+// This saves a dynamic cast compared to the sc_object* case.
+//     process_p -> process instance this is handle for.
+//------------------------------------------------------------------------------
+inline sc_process_handle::sc_process_handle( sc_process_b* process_p ) :
+  m_target_p(process_p)
+{
+  if ( m_target_p ) m_target_p->reference_increment();
+}
+
+//------------------------------------------------------------------------------
+//"sc_process_handle::sc_process_handle - copy constructor"
+//
+// This version of the object instance constructor for this class provides
+// the copy constructor for the class. It clones the supplied original
+// handle and increments the references to its target.
+//     orig = sc_process_handle object instance to be copied from.
+//------------------------------------------------------------------------------
+inline sc_process_handle::sc_process_handle( const sc_process_handle& orig ) :
+    m_target_p(orig.m_target_p)
+{
+    if ( m_target_p ) m_target_p->reference_increment();
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_process_handle::operator ="
+//
+// This assignment operator signature is call by value rather than reference.
+// This means that an sc_process_handle instance will be created and the
+// target for that instance will be incremented before the assignment is done.
+// The assignment is done using the swap() method, which simply swaps the
+// targets of 'orig' and this object instance. We don't need to increment
+// the reference count for our new target since that was done when 'orig'
+// was created. Our old target's reference count will be decremented when
+// 'orig' is deleted.
+//     orig = sc_process_handle object instance to be copied from.
+// Result is a reference for this object instance.
+//------------------------------------------------------------------------------
+inline sc_process_handle& 
+sc_process_handle::operator = ( sc_process_handle orig )
+{
+    swap( orig );
+    return *this;
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_process_handle::~sc_process_handle"
+//
+// This is the object instance destructor for this class. It decrements
+// the reference count for its target.
+//------------------------------------------------------------------------------
+inline sc_process_handle::~sc_process_handle()
+{
+    if ( m_target_p ) m_target_p->reference_decrement();
+}
+
+//------------------------------------------------------------------------------
+//"sc_process_handle::inline methods"
+//
+// These are short inline methods.
+//------------------------------------------------------------------------------
+
+// disable this object instance's target.
+
+inline void sc_process_handle::disable(sc_descendant_inclusion_info descendants)
+{
+    if ( m_target_p ) 
+        m_target_p->disable_process(descendants);
+    else
+        SC_REPORT_WARNING( SC_ID_EMPTY_PROCESS_HANDLE_, "disable()");
+}
+
+// call dont_initialize() on this object instance's target.
+
+inline void sc_process_handle::dont_initialize( bool dont )
+{
+    if ( m_target_p ) 
+        m_target_p->dont_initialize( dont );
+    else
+        SC_REPORT_WARNING( SC_ID_EMPTY_PROCESS_HANDLE_, "dont_initialize()");
+}
+
+// dump the status of this object instance's target:
+
+inline std::string sc_process_handle::dump_state() const
+{
+    return m_target_p ? m_target_p->dump_state() : std::string("NO TARGET");
+}
+
+// return whether this object instance's target is dynamic or not.
+
+inline bool sc_process_handle::dynamic() const
+{
+    return  m_target_p ?  m_target_p->dynamic() : false;
+}
+
+// enable this object instance's target.
+
+inline void sc_process_handle::enable(sc_descendant_inclusion_info descendants)
+{
+    if ( m_target_p ) 
+        m_target_p->enable_process(descendants);
+    else
+        SC_REPORT_WARNING( SC_ID_EMPTY_PROCESS_HANDLE_, "enable()");
+}
+
+// return the child objects for this object instance's target.
+
+inline 
+const std::vector<sc_event*>& sc_process_handle::get_child_events() const
+{
+    return m_target_p ?  m_target_p->get_child_events() : empty_event_vector;
+}
+
+// return the child objects for this object instance's target.
+
+inline 
+const std::vector<sc_object*>& sc_process_handle::get_child_objects() const
+{
+    return m_target_p ?  m_target_p->get_child_objects() : empty_object_vector;
+}
+
+// return the parent object for this object instance's target.
+
+inline sc_object* sc_process_handle::get_parent_object() const
+{
+    return m_target_p ?  m_target_p->get_parent_object() : NULL;
+}
+
+// return this object instance's target.
+
+inline sc_object* sc_process_handle::get_process_object() const
+{
+    return m_target_p;
+}
+
+// return whether this object instance is unwinding or not.
+
+inline bool sc_process_handle::is_unwinding() const
+{
+    if ( m_target_p )
+        return m_target_p->is_unwinding();
+    else {
+        SC_REPORT_WARNING( SC_ID_EMPTY_PROCESS_HANDLE_, "is_unwinding()");
+        return false;
+    }
+}
+
+// kill this object instance's target.
+
+inline void sc_process_handle::kill( sc_descendant_inclusion_info descendants )
+{
+    if ( m_target_p ) 
+        m_target_p->kill_process( descendants );
+    else
+        SC_REPORT_WARNING( SC_ID_EMPTY_PROCESS_HANDLE_, "kill()");
+}
+
+// return the name of this object instance's target.
+
+inline const char* sc_process_handle::name() const
+{
+    return  m_target_p ? m_target_p->name() : ""; 
+}
+
+// return the process kind for this object instance's target.
+
+inline sc_curr_proc_kind sc_process_handle::proc_kind() const
+{
+    return m_target_p ?  m_target_p->proc_kind() : SC_NO_PROC_;
+}
+
+// reset this object instance's target.
+
+inline void sc_process_handle::reset( sc_descendant_inclusion_info descendants )
+{
+    if ( m_target_p ) 
+        m_target_p->reset_process( sc_process_b::reset_asynchronous,
+	                           descendants );
+    else
+        SC_REPORT_WARNING( SC_ID_EMPTY_PROCESS_HANDLE_, "reset()");
+}
+
+// return the reset event for this object instance's target.
+
+inline sc_event& sc_process_handle::reset_event() const
+{
+    if ( m_target_p ) 
+        return m_target_p->reset_event();
+    else
+    {
+        SC_REPORT_WARNING( SC_ID_EMPTY_PROCESS_HANDLE_, "reset()");
+        return sc_process_handle::non_event;
+    }
+}
+
+// resume this object instance's target.
+
+inline void sc_process_handle::resume(sc_descendant_inclusion_info descendants)
+{
+    if ( m_target_p ) 
+        m_target_p->resume_process(descendants);
+    else
+        SC_REPORT_WARNING( SC_ID_EMPTY_PROCESS_HANDLE_, "resume()");
+}
+
+// suspend this object instance's target.
+
+inline void sc_process_handle::suspend(sc_descendant_inclusion_info descendants)
+{
+    if ( m_target_p ) 
+        m_target_p->suspend_process(descendants);
+    else
+        SC_REPORT_WARNING( SC_ID_EMPTY_PROCESS_HANDLE_, "suspend()");
+}
+
+// swap targets of this process handle with the supplied one.
+
+inline void sc_process_handle::swap( sc_process_handle& other )
+{
+    sc_process_b* tmp = m_target_p;
+    m_target_p = other.m_target_p;
+    other.m_target_p = tmp;
+}
+
+// turn sync_reset off for this object instance's target.
+
+inline void sc_process_handle::sync_reset_off(
+    sc_descendant_inclusion_info descendants)
+{
+    if ( m_target_p ) 
+        m_target_p->reset_process( sc_process_b::reset_synchronous_off, 
+	                           descendants);
+    else
+        SC_REPORT_WARNING( SC_ID_EMPTY_PROCESS_HANDLE_, "sync_reset_off()");
+}
+
+// turn sync_reset on for this object instance's target.
+
+inline void sc_process_handle::sync_reset_on(
+    sc_descendant_inclusion_info descendants)
+{
+    if ( m_target_p ) 
+    {
+        m_target_p->reset_process(sc_process_b::reset_synchronous_on, 
+            descendants);
+    }
+    else
+    {
+        SC_REPORT_WARNING( SC_ID_EMPTY_PROCESS_HANDLE_, "sync_reset_on()");
+    }
+}
+
+// terminate this object instance's target.
+
+inline bool sc_process_handle::terminated() const
+{
+    return m_target_p ?  m_target_p->terminated() : false;
+}
+
+// return the termination event for this object instance's target.
+
+inline sc_event& sc_process_handle::terminated_event()
+{
+    if ( m_target_p )
+        return m_target_p->terminated_event();
+    else
+    {
+        SC_REPORT_WARNING( SC_ID_EMPTY_PROCESS_HANDLE_, "terminated_event()");
+        return sc_process_handle::non_event;
+    }
+}
+
+// return true if this object instance has a target, false it not.
+
+inline bool sc_process_handle::valid() const
+{
+    return m_target_p ? true : false;
+}
+
+//------------------------------------------------------------------------------
+//"sc_process_handle::sc_throw_it"
+//
+// This method throws the supplied exception to the process whose handle this
+// object instance is, and optionally to the process' descendants. Once the
+// exception is thrown the currently executed process will suspend to allow
+// the exception to be propagated. Once the propagation has occurred the
+// current process will be resumed.
+//
+// Notes:
+//   (1) We allocate the helper function on the stack, see the description of
+//       sc_throw_it<EXCEPT>, in sc_process.h, for why.
+//
+// Arguments:
+//    exception = exception to be thrown
+//    descendants = indication of whether descendant processes should also
+//                  receive the throw.
+//------------------------------------------------------------------------------
+template<typename EXCEPT>
+inline void sc_process_handle::throw_it( const EXCEPT& exception,
+    sc_descendant_inclusion_info descendants)
+{
+    sc_throw_it<EXCEPT> helper(exception);  // helper to throw the exception.
+
+    if ( !m_target_p ) 
+    {
+        SC_REPORT_WARNING( SC_ID_EMPTY_PROCESS_HANDLE_, "throw_it()");
+	return;
+    }
+    m_target_p->throw_user(helper, descendants);
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_process_b::last_created_process_handle"
+//
+// This method returns the kind of this process.
+//------------------------------------------------------------------------------
+inline sc_process_handle sc_process_b::last_created_process_handle()
+{
+    return sc_process_handle(m_last_created_process_p);
+}
+
+inline sc_process_handle sc_get_last_created_process_handle()
+{
+    return sc_process_b::last_created_process_handle();
+}
+
+} // namespace sc_core
+
+// Revision 1.19  2011/08/24 22:05:51  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.18  2011/04/01 22:08:26  acg
+//  Andy Goodrich: remove unused variable.
+//
+// Revision 1.17  2011/03/12 21:07:51  acg
+//  Andy Goodrich: changes to kernel generated event support.
+//
+// Revision 1.16  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.15  2011/02/17 19:53:03  acg
+//  Andy Goodrich: changed dump_status() to dump_state() with new signature.
+//
+// Revision 1.14  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.13  2011/02/13 21:33:30  acg
+//  Andy Goodrich: added dump_status() to allow the dumping of the status
+//  of a process handle's target.
+//
+// Revision 1.12  2011/02/01 23:01:53  acg
+//  Andy Goodrich: removed dead code.
+//
+// Revision 1.11  2011/02/01 21:07:36  acg
+//  Andy Goodrich: defering of run queue manipulations to the
+//  sc_thread_process::throw_it() method.
+//
+// Revision 1.10  2011/01/25 20:50:37  acg
+//  Andy Goodrich: changes for IEEE 1666 2011.
+//
+// Revision 1.9  2011/01/20 16:52:20  acg
+//  Andy Goodrich: changes for IEEE 1666 2011.
+//
+// Revision 1.8  2011/01/19 23:21:50  acg
+//  Andy Goodrich: changes for IEEE 1666 2011
+//
+// Revision 1.7  2011/01/18 20:10:45  acg
+//  Andy Goodrich: changes for IEEE1666_2011 semantics.
+//
+// Revision 1.6  2010/07/30 05:21:22  acg
+//  Andy Goodrich: release 2.3 fixes.
+//
+// Revision 1.5  2010/07/22 20:02:33  acg
+//  Andy Goodrich: bug fixes.
+//
+// Revision 1.4  2009/05/22 16:06:29  acg
+//  Andy Goodrich: process control updates.
+//
+// Revision 1.3  2008/05/22 17:06:26  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.2  2007/09/20 20:32:35  acg
+//  Andy Goodrich: changes to the semantics of throw_it() to match the
+//  specification. A call to throw_it() will immediately suspend the calling
+//  thread until all the throwees have executed. At that point the calling
+//  thread will be restarted before the execution of any other threads.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.7  2006/05/08 17:58:24  acg
+// Andy Goodrich: added David Long's forward declarations for friend
+//   functions, methods, and operators to keep the Microsoft compiler happy.
+//
+// Revision 1.6  2006/04/20 17:08:17  acg
+//  Andy Goodrich: 3.0 style process changes.
+//
+// Revision 1.5  2006/04/11 23:13:21  acg
+//   Andy Goodrich: Changes for reduced reset support that only includes
+//   sc_cthread, but has preliminary hooks for expanding to method and thread
+//   processes also.
+//
+// Revision 1.4  2006/01/24 20:49:05  acg
+// Andy Goodrich: changes to remove the use of deprecated features within the
+// simulator, and to issue warning messages when deprecated features are used.
+//
+// Revision 1.3  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+
+#endif // !defined(sc_spawn_h_INCLUDED)
diff --git a/ext/systemc/src/sysc/kernel/sc_reset.cpp b/ext/systemc/src/sysc/kernel/sc_reset.cpp
new file mode 100644
index 000000000..2e4bc6c6e
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_reset.cpp
@@ -0,0 +1,440 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_reset.cpp -- Support for reset.
+
+  Original Author: Andy Goodrich, Forte Design Systems
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#include "sysc/kernel/sc_simcontext.h"
+#include "sysc/kernel/sc_reset.h"
+#include "sysc/kernel/sc_process_handle.h"
+#include "sysc/communication/sc_signal.h"
+#include "sysc/communication/sc_signal_ports.h"
+
+
+// THE SYSTEMC PROOF OF CONCEPT SIMULATOR RESET SIGNAL IMPLEMENTATION:
+//
+// (1) An instance of the sc_reset class is attached to each sc_signal<bool> 
+//     that is used as a reset signal.
+//
+// (2) Each process that is senstive to a reset signal will be registered in the
+//     sc_reset class attached to that reset signal.
+//
+// (3) When a change in the value of a reset signal occurs it invokes the
+//     notify_processes() method of its sc_reset object instance. The 
+//     notify_processes() method will call the reset_changed() method of each
+//     process that is registered with it to inform the process that 
+//     state of the reset signal has changed.
+//
+// (4) A process may have multiple reset signals, so counters are kept for the 
+//     number of active asynchronous, and synchronous, reset signals that are
+//     active. Those counters are incremented and decremented in the process'
+//     reset_changed() method.
+//
+// (5) When a process' semantics() method is called the current reset state is
+//     checked, and a reset sequence is initiated if the process is in reset.
+//     This will occur every time an SC_METHOD is dispatched. SC_CTHREAD and
+//     and SC_THREAD instances, only go through the semantics() method they
+//     initially start up. So the reset check  is duplicated in the suspend_me()
+//     method, the tail of which will execute each time the thread is 
+//     dispatched.
+
+namespace sc_core {
+
+class sc_reset_finder;
+static sc_reset_finder* reset_finder_q=0;  // Q of reset finders to reconcile.
+
+//==============================================================================
+// sc_reset_finder - place holder class for a port reset signal until it is
+//                   bound and an interface class is available. When the port
+//                   has been bound the information in this class will be used
+//                   to initialize its sc_reset object instance.
+//==============================================================================
+class sc_reset_finder {
+    friend class sc_reset;
+  public:
+    sc_reset_finder( bool async, const sc_in<bool>* port_p, bool level, 
+        sc_process_b* target_p);
+    sc_reset_finder( bool async, const sc_inout<bool>* port_p, bool level, 
+        sc_process_b* target_p);
+    sc_reset_finder( bool async, const sc_out<bool>* port_p, bool level, 
+        sc_process_b* target_p);
+
+  protected:
+    bool                   m_async;     // True if asynchronous reset.
+    bool                   m_level;     // Level for reset.
+    sc_reset_finder*       m_next_p;    // Next reset finder in list.
+    const sc_in<bool>*     m_in_p;      // Port for which reset is needed.
+    const sc_inout<bool>*  m_inout_p;   // Port for which reset is needed.
+    const sc_out<bool>*    m_out_p;     // Port for which reset is needed.
+    sc_process_b*          m_target_p;  // Process to reset.
+
+  private: // disabled
+    sc_reset_finder( const sc_reset_finder& );
+    const sc_reset_finder& operator = ( const sc_reset_finder& );
+};
+
+inline sc_reset_finder::sc_reset_finder(
+    bool async, const sc_in<bool>* port_p, bool level, sc_process_b* target_p) :
+    m_async(async), m_level(level), m_next_p(0), m_in_p(port_p), m_inout_p(0), 
+    m_out_p(0), m_target_p(target_p)
+{   
+    m_next_p = reset_finder_q;
+    reset_finder_q = this;
+}
+
+inline sc_reset_finder::sc_reset_finder(
+    bool async, const sc_inout<bool>* port_p, bool level, sc_process_b* target_p
+) : 
+    m_async(async), m_level(level), m_next_p(0), m_in_p(0), m_inout_p(port_p), 
+    m_out_p(0), m_target_p(target_p)
+{   
+    m_next_p = reset_finder_q;
+    reset_finder_q = this;
+}
+
+inline sc_reset_finder::sc_reset_finder(
+    bool async, const sc_out<bool>* port_p, bool level, sc_process_b* target_p
+) : 
+    m_async(async), m_level(level), m_next_p(0), m_in_p(0), m_inout_p(0),
+    m_out_p(port_p), m_target_p(target_p)
+{   
+    m_next_p = reset_finder_q;
+    reset_finder_q = this;
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_reset::notify_processes"
+//
+// Notify processes that there is a change in the reset signal value.
+//------------------------------------------------------------------------------
+void sc_reset::notify_processes()
+{
+    bool                                    active;       // true if reset is active.
+    sc_reset_target*                        entry_p;      // reset entry processing.
+    std::vector<sc_reset_target>::size_type process_i;    // index of process resetting.
+    std::vector<sc_reset_target>::size_type process_n;    // # of processes to reset.
+    bool                                    value;        // value of our signal.
+
+    value = m_iface_p->read();
+    process_n = m_targets.size();
+    for ( process_i = 0; process_i < process_n; process_i++ )
+    {
+        entry_p = &m_targets[process_i];
+	active = ( entry_p->m_level == value );
+	entry_p->m_process_p->reset_changed( entry_p->m_async, active );
+    }
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_reset::reconcile_resets"
+//
+// This static method processes the sc_reset_finders to establish the actual
+// reset connections.
+//
+// Notes:
+//   (1) If reset is asserted we tell the process that it is in reset.
+//------------------------------------------------------------------------------
+void sc_reset::reconcile_resets()
+{
+    const sc_signal_in_if<bool>*  iface_p;      // Interface to reset signal.
+    sc_reset_finder*              next_p;       // Next finder to process.
+    sc_reset_finder*              now_p;        // Finder currently processing.
+    sc_reset_target               reset_target; // Target's reset entry.
+    sc_reset*                     reset_p;      // Reset object to use.
+
+    for ( now_p = reset_finder_q; now_p; now_p = next_p )
+    {
+        next_p = now_p->m_next_p;
+        if ( now_p->m_in_p )
+        {
+            iface_p = DCAST<const sc_signal_in_if<bool>*>(
+                now_p->m_in_p->get_interface());
+        }
+        else if ( now_p->m_inout_p )
+        {
+            iface_p = DCAST<const sc_signal_in_if<bool>*>(
+                now_p->m_inout_p->get_interface());
+        }
+        else
+        {
+            iface_p = DCAST<const sc_signal_in_if<bool>*>(
+                now_p->m_out_p->get_interface());
+        }
+        assert( iface_p != 0 );
+        reset_p = iface_p->is_reset();
+	now_p->m_target_p->m_resets.push_back(reset_p);
+	reset_target.m_async = now_p->m_async;
+	reset_target.m_level = now_p->m_level;
+	reset_target.m_process_p = now_p->m_target_p;
+	reset_p->m_targets.push_back(reset_target);
+	if ( iface_p->read() == now_p->m_level ) // see note 1 above
+	    now_p->m_target_p->initially_in_reset( now_p->m_async );
+        delete now_p;
+    }
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_reset::remove_process"
+//
+// This method removes the supplied process from the list of processes that
+// should be notified when there is a change in the value of the reset signal.
+//
+// Arguments:
+//     process_p -> process to be removed.
+//------------------------------------------------------------------------------
+void sc_reset::remove_process( sc_process_b* process_p )
+{
+    int process_i; // Index of process resetting.
+    int process_n; // # of processes to reset.
+
+    process_n = m_targets.size();
+    for ( process_i = 0; process_i < process_n; )
+    {
+        if ( m_targets[process_i].m_process_p == process_p )
+        {
+            m_targets[process_i] = m_targets[process_n-1];
+	    process_n--;
+            m_targets.resize(process_n);
+        }
+	else
+	{
+	    process_i++;
+	}
+    }
+}
+
+//------------------------------------------------------------------------------
+//"sc_reset::reset_signal_is - ports"
+//
+// These overloads of the reset_signal_is() method will register the active
+// process with the sc_reset object instance associated with the supplied port.
+// If the port does not yet have a pointer to its sc_signal<bool> instance it
+// will create an sc_reset_finder class object instance that will be used
+// to set the process' reset information when the port has been bound.
+//
+// Arguments:
+//     async = true if the reset signal is asynchronous, false if not.
+//     port  = port for sc_signal<bool> that will provide the reset signal.
+//     level = level at which reset is active, either true or false.
+//------------------------------------------------------------------------------
+void sc_reset::reset_signal_is( bool async, const sc_in<bool>& port, bool level)
+{
+    const sc_signal_in_if<bool>* iface_p;
+    sc_process_b*                process_p;
+    
+    process_p = (sc_process_b*)sc_get_current_process_handle();
+    assert( process_p );
+    process_p->m_has_reset_signal = true;
+    switch ( process_p->proc_kind() )
+    {
+      case SC_THREAD_PROC_:
+      case SC_METHOD_PROC_:
+      case SC_CTHREAD_PROC_:
+        iface_p = DCAST<const sc_signal_in_if<bool>*>(port.get_interface());
+        if ( iface_p )
+            reset_signal_is( async, *iface_p, level );
+        else
+            new sc_reset_finder( async, &port, level, process_p );
+        break;
+      default:
+        SC_REPORT_ERROR(SC_ID_UNKNOWN_PROCESS_TYPE_, process_p->name());
+        break;
+    }
+}
+
+void sc_reset::reset_signal_is(
+    bool async, const sc_inout<bool>& port, bool level )
+{
+    const sc_signal_in_if<bool>* iface_p;
+    sc_process_b*                process_p;
+    
+    process_p = (sc_process_b*)sc_get_current_process_handle();
+    assert( process_p );
+    process_p->m_has_reset_signal = true;
+    switch ( process_p->proc_kind() )
+    {
+      case SC_THREAD_PROC_:
+      case SC_METHOD_PROC_:
+      case SC_CTHREAD_PROC_:
+        iface_p = DCAST<const sc_signal_in_if<bool>*>(port.get_interface());
+        if ( iface_p )
+            reset_signal_is( async, *iface_p, level );
+        else
+            new sc_reset_finder( async, &port, level, process_p );
+        break;
+      default:
+        SC_REPORT_ERROR(SC_ID_UNKNOWN_PROCESS_TYPE_, process_p->name());
+        break;
+    }
+}
+
+void sc_reset::reset_signal_is(
+    bool async, const sc_out<bool>& port, bool level )
+{
+    const sc_signal_in_if<bool>* iface_p;
+    sc_process_b*                process_p;
+    
+    process_p = (sc_process_b*)sc_get_current_process_handle();
+    assert( process_p );
+    process_p->m_has_reset_signal = true;
+    switch ( process_p->proc_kind() )
+    {
+      case SC_THREAD_PROC_:
+      case SC_METHOD_PROC_:
+      case SC_CTHREAD_PROC_:
+        iface_p = DCAST<const sc_signal_in_if<bool>*>(port.get_interface());
+        if ( iface_p )
+            reset_signal_is( async, *iface_p, level );
+        else
+            new sc_reset_finder( async, &port, level, process_p );
+        break;
+      default:
+        SC_REPORT_ERROR(SC_ID_UNKNOWN_PROCESS_TYPE_, process_p->name());
+        break;
+    }
+}
+
+//------------------------------------------------------------------------------
+//"sc_reset::reset_signal_is"
+//
+// This static method will register the active process instance as being
+// reset by the sc_signal<bool> whose interface has been supplied. If no
+// sc_reset object instance has been attached to the sc_signal<bool> yet, it
+// will be created and attached. The active process instance is pushed into
+// the list of processes that the sc_reset object instance should notify if
+// the value of the reset signal changes.
+//
+// Arguments:
+//     async = true if the reset signal is asynchronous, false if not.
+//     iface = interface for the reset signal.
+//     level = is the level at which reset is active, either true or false.
+// Notes:
+//   (1) If reset is asserted we tell the process that it is in reset
+//       initially.
+//------------------------------------------------------------------------------
+void sc_reset::reset_signal_is( 
+    bool async, const sc_signal_in_if<bool>& iface, bool level )
+{
+    sc_process_b*   process_p;    // process adding reset for.
+    sc_reset_target reset_target; // entry to build for the process.
+    sc_reset*       reset_p;      // reset object.
+
+    process_p = sc_process_b::last_created_process_base();
+    assert( process_p );
+    process_p->m_has_reset_signal = true;
+    switch ( process_p->proc_kind() )
+    {
+      case SC_METHOD_PROC_:
+      case SC_CTHREAD_PROC_:
+      case SC_THREAD_PROC_:
+	reset_p = iface.is_reset();
+	process_p->m_resets.push_back(reset_p);
+        reset_target.m_async = async; 
+	reset_target.m_level = level;
+	reset_target.m_process_p = process_p;
+	reset_p->m_targets.push_back(reset_target);
+	if ( iface.read() == level ) process_p->initially_in_reset( async );
+        break;
+      default:
+        SC_REPORT_ERROR(SC_ID_UNKNOWN_PROCESS_TYPE_, process_p->name());
+        break;
+    }
+}
+
+} // namespace sc_core
+
+// $Log: sc_reset.cpp,v $
+// Revision 1.16  2011/08/26 20:46:10  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.15  2011/08/24 22:05:51  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.14  2011/04/08 22:37:34  acg
+//  Andy Goodrich: documentation of the reset mechanism and additional
+//  documentation of methods. Removal of check for SC_METHODs in
+//  sc_reset_signal_is() that should not have been there.
+//
+// Revision 1.13  2011/03/20 15:13:01  acg
+//  Andy Goodrich: set the reset flag for async_reset_signal_is to catch
+//  the suspend() corner case.
+//
+// Revision 1.12  2011/03/20 13:43:23  acg
+//  Andy Goodrich: added async_signal_is() plus suspend() as a corner case.
+//
+// Revision 1.11  2011/03/06 19:57:11  acg
+//  Andy Goodrich: refinements for the illegal suspend - synchronous reset
+//  interaction.
+//
+// Revision 1.10  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.9  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.8  2011/02/01 21:08:26  acg
+//  Andy Goodrich: new multiple reset support.
+//
+// Revision 1.7  2011/01/06 18:04:38  acg
+//  Andy Goodrich: removed commented out code.
+//
+// Revision 1.6  2010/12/07 20:09:13  acg
+// Andy Goodrich: removed sc_signal overloads since already have sc_signal_in_if overloads.
+//
+// Revision 1.5  2010/11/20 17:10:56  acg
+//  Andy Goodrich: reset processing changes for new IEEE 1666 standard.
+//
+// Revision 1.4  2009/05/22 16:06:29  acg
+//  Andy Goodrich: process control updates.
+//
+// Revision 1.3  2009/03/12 22:59:58  acg
+//  Andy Goodrich: updates for 2.4 stuff.
+//
+// Revision 1.2  2008/05/22 17:06:26  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.7  2006/12/02 20:58:19  acg
+//  Andy Goodrich: updates from 2.2 for IEEE 1666 support.
+//
+// Revision 1.5  2006/04/11 23:13:21  acg
+//   Andy Goodrich: Changes for reduced reset support that only includes
+//   sc_cthread, but has preliminary hooks for expanding to method and thread
+//   processes also.
+//
+// Revision 1.4  2006/01/24 20:49:05  acg
+// Andy Goodrich: changes to remove the use of deprecated features within the
+// simulator, and to issue warning messages when deprecated features are used.
+//
+// Revision 1.3  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+//
diff --git a/ext/systemc/src/sysc/kernel/sc_reset.h b/ext/systemc/src/sysc/kernel/sc_reset.h
new file mode 100644
index 000000000..f0992bb16
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_reset.h
@@ -0,0 +1,164 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_reset.h -- Process reset support.
+
+  Original Author: Andy Goodrich, Forte Design Systems, 17 June 2003
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+#if !defined(sc_reset_h_INCLUDED)
+#define sc_reset_h_INCLUDED
+
+#include "sysc/communication/sc_writer_policy.h"
+
+namespace sc_core {
+
+// FORWARD CLASS REFERENCES:
+
+template<typename DATA> class sc_signal_in_if;
+template<typename IF, sc_writer_policy POL> class sc_signal;
+template<typename DATA> class sc_in;
+template<typename DATA> class sc_inout;
+template<typename DATA> class sc_out;
+template<typename SOURCE> class sc_spawn_reset;
+class sc_reset;
+class sc_process_b;
+
+//==============================================================================
+// CLASS sc_reset_target - RESET ENTRY FOR AN sc_process_b TARGET
+//
+// This class describes a reset condition associated with an sc_process_b
+// instance. 
+//==============================================================================
+class sc_reset_target {
+  public:
+    bool          m_async;     // true asynchronous reset, false synchronous.
+    bool          m_level;     // level for reset.
+    sc_process_b* m_process_p; // process this reset entry is for.
+};
+
+inline std::ostream& operator << ( std::ostream& os, 
+                                   const sc_reset_target& target )
+{
+    os << "[";
+    os << target.m_async << ",";
+    os << target.m_level << ",";
+    os << target.m_process_p << ",";
+    return os;
+}
+
+//==============================================================================
+// CLASS sc_reset - RESET INFORMATION FOR A RESET SIGNAL
+//
+// See the top of sc_reset.cpp for an explaination of how the reset mechanism
+// is implemented.
+//==============================================================================
+class sc_reset {
+    friend class sc_cthread_process;
+    friend class sc_method_process; 
+    friend class sc_module; 
+    friend class sc_process_b;
+    friend class sc_signal<bool, SC_ONE_WRITER>;
+    friend class sc_signal<bool, SC_MANY_WRITERS>;
+    friend class sc_signal<bool, SC_UNCHECKED_WRITERS>;
+    friend class sc_simcontext;
+    template<typename SOURCE> friend class sc_spawn_reset;
+    friend class sc_thread_process; 
+
+  protected:
+    static void reconcile_resets();
+    static void 
+	reset_signal_is(bool async, const sc_signal_in_if<bool>& iface, 
+	                bool level);
+    static void 
+	reset_signal_is( bool async, const sc_in<bool>& iface, bool level);
+    static void 
+	reset_signal_is( bool async, const sc_inout<bool>& iface, bool level);
+    static void 
+	reset_signal_is( bool async, const sc_out<bool>& iface, bool level);
+
+  protected:
+    sc_reset( const sc_signal_in_if<bool>* iface_p ) :
+        m_iface_p(iface_p), m_targets() {}
+    void notify_processes();
+    void remove_process( sc_process_b* );
+
+  protected:
+    const sc_signal_in_if<bool>*  m_iface_p;  // Interface to read.
+    std::vector<sc_reset_target>  m_targets;  // List of processes to reset.
+
+  private: // disabled
+    sc_reset( const sc_reset& );
+    const sc_reset& operator = ( const sc_reset& );
+};
+
+// $Log: sc_reset.h,v $
+// Revision 1.11  2011/08/26 20:46:10  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.10  2011/08/24 22:05:51  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.9  2011/04/08 22:38:30  acg
+//  Andy Goodrich: added comment pointing to the description of how the
+//  reset mechanism works that is in sc_reset.cpp.
+//
+// Revision 1.8  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.7  2011/02/13 21:47:37  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.6  2011/01/06 18:00:32  acg
+//  Andy Goodrich: Removed commented out code.
+//
+// Revision 1.5  2010/12/07 20:09:14  acg
+// Andy Goodrich: removed sc_signal signatures since already have sc_signal_in_if signatures.
+//
+// Revision 1.4  2010/11/20 17:10:57  acg
+//  Andy Goodrich: reset processing changes for new IEEE 1666 standard.
+//
+// Revision 1.3  2009/05/22 16:06:29  acg
+//  Andy Goodrich: process control updates.
+//
+// Revision 1.2  2008/05/22 17:06:26  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.6  2006/12/02 20:58:19  acg
+//  Andy Goodrich: updates from 2.2 for IEEE 1666 support.
+//
+// Revision 1.4  2006/04/11 23:13:21  acg
+//   Andy Goodrich: Changes for reduced reset support that only includes
+//   sc_cthread, but has preliminary hooks for expanding to method and thread
+//   processes also.
+//
+// Revision 1.3  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+
+} // namespace sc_core
+
+#endif // !defined(sc_reset_h_INCLUDED)
diff --git a/ext/systemc/src/sysc/kernel/sc_runnable.h b/ext/systemc/src/sysc/kernel/sc_runnable.h
new file mode 100644
index 000000000..028a9b311
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_runnable.h
@@ -0,0 +1,144 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_runnable.h --
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#ifndef SC_RUNNABLE_H
+#define SC_RUNNABLE_H
+
+
+#include "sysc/kernel/sc_process.h"
+
+namespace sc_core {
+
+//=============================================================================
+//  CLASS : sc_runnable
+//
+//  Class that manages the ready-to-run queues.
+//=============================================================================
+
+class sc_runnable
+{
+
+  public:
+    sc_runnable();
+    ~sc_runnable();
+
+    inline void init();
+    inline void toggle_methods();
+    inline void toggle_threads();
+
+    inline void remove_method( sc_method_handle );
+    inline void remove_thread( sc_thread_handle );
+
+    inline void execute_method_next( sc_method_handle );
+    inline void execute_thread_next( sc_thread_handle );
+
+    inline void push_back_method( sc_method_handle );
+    inline void push_back_thread( sc_thread_handle );
+    inline void push_front_method( sc_method_handle );
+    inline void push_front_thread( sc_thread_handle );
+
+    inline bool is_initialized() const;
+    inline bool is_empty() const;
+
+    inline sc_method_handle pop_method();
+    inline sc_thread_handle pop_thread();
+
+  public: // diagnostics:
+    void dump() const;
+
+  private:
+    sc_method_handle m_methods_push_head;
+    sc_method_handle m_methods_push_tail;
+    sc_method_handle m_methods_pop;
+    sc_thread_handle m_threads_push_head;
+    sc_thread_handle m_threads_push_tail;
+    sc_thread_handle m_threads_pop;
+
+  private:
+    // disabled
+    sc_runnable( const sc_runnable& );
+    sc_runnable& operator = ( const sc_runnable& );
+};
+
+} // namespace sc_core
+
+#endif
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Andy Goodrich, 30 June 2003, Forte Design Systems
+  Description of Modification: Total rewrite using linked list rather than 
+                               fixed vector.
+
+
+      Name, Affiliation, Date: Bishnupriya Bhattacharya, Cadence Design Systems,
+                               25 August, 2003
+  Description of Modification: Add tail pointers for m_methods_push and
+                               m_threads_push to maintain the same scheduler
+                               ordering as 2.0.1
+
+ *****************************************************************************/
+
+// $Log: sc_runnable.h,v $
+// Revision 1.9  2011/08/26 20:46:10  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.8  2011/04/08 18:26:07  acg
+//  Andy Goodrich: added execute_method_next() to handle method dispatch
+//   for asynchronous notifications that occur outside the evaluation phase.
+//
+// Revision 1.7  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.6  2011/02/13 21:47:38  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.5  2011/02/02 06:37:03  acg
+//  Andy Goodrich: removed toggle() method since it is no longer used.
+//
+// Revision 1.4  2011/02/01 21:09:13  acg
+//  Andy Goodrich: addition of toggle_methods() and toggle_threads() calls.
+//
+// Revision 1.3  2011/01/25 20:50:37  acg
+//  Andy Goodrich: changes for IEEE 1666 2011.
+//
+// Revision 1.2  2008/05/22 17:06:26  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_runnable_int.h b/ext/systemc/src/sysc/kernel/sc_runnable_int.h
new file mode 100644
index 000000000..510e93758
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_runnable_int.h
@@ -0,0 +1,574 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*******************************************************************************
+
+  sc_runnable_int.h -- For inline definitions of some utility functions.
+                       DO NOT EXPORT THIS INCLUDE FILE. Include this file
+                       after "sc_process_int.h" so that we can get the base
+                       class right.
+
+  Original Author: Bishnupriya Bhattacharya , Cadence Design, 28th July, 2003
+
+ CHANGE LOG AT THE END OF THE FILE
+ ******************************************************************************/
+
+#ifndef SC_RUNNABLE_INT_H
+#define SC_RUNNABLE_INT_H
+
+
+#include "sysc/kernel/sc_runnable.h"
+#include "sysc/kernel/sc_method_process.h"
+#include "sysc/kernel/sc_thread_process.h"
+
+// DEBUGGING MACROS:
+//
+// DEBUG_MSG(NAME,P,MSG)
+//     MSG  = message to print
+//     NAME = name that must match the process for the message to print, or
+//            null if the message should be printed unconditionally.
+//     P    = pointer to process message is for, or NULL in which case the
+//            message will not print.
+#if 0
+#   define DEBUG_NAME ""
+#   define DEBUG_MSG(NAME,P,MSG) \
+    { \
+        if ( P && ( (strlen(NAME)==0) || !strcmp(NAME,P->name())) ) \
+          std::cout << "**** " << sc_time_stamp() << " ("  \
+	            << sc_get_current_process_name() << "): " << MSG \
+		    << " - " << P->name() << std::endl; \
+    }
+#else
+#   define DEBUG_MSG(NAME,P,MSG) 
+#endif
+
+namespace sc_core {
+
+// The values below are used to indicate when a queue is empty. A non-zero     
+// non-legal pointer value is used for this so that a zero value in the
+// m_execute_p field of an sc_process_b instance can be used to indicate      
+// that is has not been queued for run. (If we did not use a non-zero
+// queue empty indicator then a sc_process_b instance that was queued
+// twice in a row might end up on the queue twice if it were the first
+// one that was queued!)
+
+#define SC_NO_METHODS ((sc_method_handle)0xdb)
+#define SC_NO_THREADS ((sc_thread_handle)0xdb)
+
+
+//------------------------------------------------------------------------------
+//"sc_runnable::dump"
+//
+// This method dumps the contents of this object instance.
+//------------------------------------------------------------------------------
+inline void sc_runnable::dump() const
+{
+    // Dump the thread queues:
+
+    std::cout << "thread pop queue: " << std::endl;
+    for ( sc_thread_handle p = m_threads_pop; p != SC_NO_THREADS; 
+          p = p->next_runnable() )
+    {
+        std::cout << "    " << p << std::endl;
+    }
+
+    std::cout << "thread push queue: " << std::endl;
+    for ( sc_thread_handle p = m_threads_push_head->next_runnable(); 
+          p != SC_NO_THREADS; p = p->next_runnable() )
+    {
+        std::cout << "    " << p << std::endl;
+    }
+}
+
+//------------------------------------------------------------------------------
+//"sc_runnable::execute_method_next"
+//
+// This method pushes the the supplied method to execute as the next process.
+// This is done by pushing it onto the front of the m_methods_pop.
+//     method_h -> method process to add to the queue.
+//------------------------------------------------------------------------------
+inline void sc_runnable::execute_method_next( sc_method_handle method_h )
+{
+    DEBUG_MSG(DEBUG_NAME,method_h,"pushing this method to execute next");
+    method_h->set_next_runnable( m_methods_pop );
+    m_methods_pop = method_h;
+}
+
+//------------------------------------------------------------------------------
+//"sc_runnable::execute_thread_next"
+//
+// This method pushes the the supplied thread to execute as the next process.
+// This is done by pushing it onto the front of the m_threads_pop.
+//     thread_h -> thread process to add to the queue.
+//------------------------------------------------------------------------------
+inline void sc_runnable::execute_thread_next( sc_thread_handle thread_h )
+{
+    DEBUG_MSG(DEBUG_NAME,thread_h,"pushing this thread to execute next");
+    thread_h->set_next_runnable( m_threads_pop );
+    m_threads_pop = thread_h;
+}
+
+//------------------------------------------------------------------------------
+//"sc_runnable::init"
+//
+// This method initializes this object instance. Note we allocate the queue
+// heads if necessary. This is done here rather than in the constructor for
+// this class to eliminate CTOR processing errors with gcc.
+//------------------------------------------------------------------------------
+inline void sc_runnable::init()
+{
+    m_methods_pop = SC_NO_METHODS;
+    if ( !m_methods_push_head )
+    {
+        m_methods_push_head = new sc_method_process("methods_push_head", true, 
+	                                           (SC_ENTRY_FUNC)0, 0, 0);
+        m_methods_push_head->dont_initialize(true);
+	m_methods_push_head->detach();
+    }
+    m_methods_push_tail = m_methods_push_head;
+    m_methods_push_head->set_next_runnable(SC_NO_METHODS);
+
+    m_threads_pop = SC_NO_THREADS;
+    if ( !m_threads_push_head )
+    {
+        m_threads_push_head = new sc_thread_process("threads_push_head", true, 
+	                                            (SC_ENTRY_FUNC)0, 0, 0);
+        m_threads_push_head->dont_initialize(true);
+	m_threads_push_head->detach();
+    }
+    m_threads_push_head->set_next_runnable(SC_NO_THREADS);
+    m_threads_push_tail = m_threads_push_head;
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_runnable::is_empty"
+//
+// This method returns true if the push queue is empty, or false if not.
+//------------------------------------------------------------------------------
+inline bool sc_runnable::is_empty() const
+{
+    return m_methods_push_head->next_runnable() == SC_NO_METHODS && 
+           m_methods_pop == SC_NO_METHODS &&
+	   m_threads_push_head->next_runnable() == SC_NO_THREADS &&
+	   m_threads_pop == SC_NO_THREADS;
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_runnable::is_initialized"
+//
+// This method returns true if the push queue is already initialized.
+//------------------------------------------------------------------------------
+inline bool sc_runnable::is_initialized() const
+{
+    return m_methods_push_head && m_threads_push_head;
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_runnable::push_back_method"
+//
+// This method pushes the supplied method process onto the back of the queue of 
+// runnable method processes.
+//     method_h -> method process to add to the queue.
+//------------------------------------------------------------------------------
+inline void sc_runnable::push_back_method( sc_method_handle method_h )
+{
+    // assert( method_h->next_runnable() == 0 ); // Can't queue twice.
+    DEBUG_MSG(DEBUG_NAME,method_h,"pushing back method");
+    method_h->set_next_runnable(SC_NO_METHODS);
+    m_methods_push_tail->set_next_runnable(method_h);
+    m_methods_push_tail = method_h;
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_runnable::push_back_thread"
+//
+// This method pushes the supplied thread process onto the back of the queue of 
+// runnable thread processes.
+//     thread_h -> thread process to add to the queue.
+//------------------------------------------------------------------------------
+inline void sc_runnable::push_back_thread( sc_thread_handle thread_h )
+{
+    // assert( thread_h->next_runnable() == 0 ); // Can't queue twice.
+    DEBUG_MSG(DEBUG_NAME,thread_h,"pushing back thread");
+    thread_h->set_next_runnable(SC_NO_THREADS);
+    m_threads_push_tail->set_next_runnable(thread_h);
+    m_threads_push_tail = thread_h;
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_runnable::push_front_method"
+//
+// This method pushes the supplied method process onto the front of the queue of
+// runnable method processes. If the queue is empty the process is the tail 
+// also.
+//     method_h -> method process to add to the queue.
+//------------------------------------------------------------------------------
+inline void sc_runnable::push_front_method( sc_method_handle method_h )
+{
+    // assert( method_h->next_runnable() == 0 ); // Can't queue twice.
+    DEBUG_MSG(DEBUG_NAME,method_h,"pushing front method");
+    method_h->set_next_runnable(m_methods_push_head->next_runnable());
+    if ( m_methods_push_tail == m_methods_push_head ) // Empty queue.
+    {
+        m_methods_push_tail->set_next_runnable(method_h);
+	m_methods_push_tail = method_h;
+    }
+    else                                               // Non-empty queue.
+    {
+	m_methods_push_head->set_next_runnable(method_h);
+    }
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_runnable::push_front_thread"
+//
+// This method pushes the supplied thread process onto the front of the queue of
+// runnable thread processes. If the queue is empty the process is the tail 
+// also.
+//     thread_h -> thread process to add to the queue.
+//------------------------------------------------------------------------------
+inline void sc_runnable::push_front_thread( sc_thread_handle thread_h )
+{
+    // assert( thread_h->next_runnable() == 0 ); // Can't queue twice.
+    DEBUG_MSG(DEBUG_NAME,thread_h,"pushing front thread");
+    thread_h->set_next_runnable(m_threads_push_head->next_runnable());
+    if ( m_threads_push_tail == m_threads_push_head ) // Empty queue.
+    {
+        m_threads_push_tail->set_next_runnable(thread_h);
+	m_threads_push_tail = thread_h;
+    }
+    else                                               // Non-empty queue.
+    {
+	m_threads_push_head->set_next_runnable(thread_h);
+    }
+}
+
+//------------------------------------------------------------------------------
+//"sc_runnable::pop_method"
+//
+// This method pops the next method process to be executed, or returns a null 
+// if no method processes are available for execution.
+//------------------------------------------------------------------------------
+inline sc_method_handle sc_runnable::pop_method()
+{
+    sc_method_handle result_p;
+
+    result_p = m_methods_pop;
+    if ( result_p != SC_NO_METHODS ) 
+    {
+        m_methods_pop = result_p->next_runnable();
+        result_p->set_next_runnable(0);
+    }
+    else
+    {
+	result_p = 0;
+    }
+    DEBUG_MSG(DEBUG_NAME,result_p,"popping method");
+    return result_p;
+
+}
+
+//------------------------------------------------------------------------------
+//"sc_runnable::pop_thread"
+//
+// This method pops the next thread process to be executed, or returns a null 
+// if no thread processes are available for execution.
+//------------------------------------------------------------------------------
+inline sc_thread_handle sc_runnable::pop_thread()
+{
+    sc_thread_handle result_p;
+
+    result_p = m_threads_pop;
+    if ( result_p != SC_NO_THREADS ) 
+    {
+        m_threads_pop = result_p->next_runnable();
+        result_p->set_next_runnable(0);
+    }
+    else
+    {
+	    result_p = 0;
+    }
+    DEBUG_MSG(DEBUG_NAME,result_p,"popping thread for execution");
+    return result_p;
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_runnable::remove_method"
+//
+// This method removes the supplied method process from the push queue if it is
+// present. Note we clear the method's next pointer so that it may be queued 
+// again.
+//     remove_p -> method process to remove from the run queue.
+//------------------------------------------------------------------------------
+inline void sc_runnable::remove_method( sc_method_handle remove_p )
+{
+    sc_method_handle now_p;     // Method now checking.
+    sc_method_handle prior_p;   // Method prior to now_p.
+
+    // Don't try to remove things if we have not been initialized.
+
+    if ( !is_initialized() ) return;
+
+    // Search the push queue:
+
+    prior_p = m_methods_push_head;
+    for ( now_p = m_methods_push_head; now_p!= SC_NO_METHODS; 
+	    now_p = now_p->next_runnable() )
+    {
+        if ( remove_p == now_p )
+        {
+            prior_p->set_next_runnable( now_p->next_runnable() );
+            if (now_p == m_methods_push_tail) {
+                m_methods_push_tail = prior_p;
+            }
+            now_p->set_next_runnable(0);
+	    DEBUG_MSG(DEBUG_NAME,now_p,"removing method from push queue");
+            return;
+        }
+        prior_p = now_p;
+    }
+
+    // Search the pop queue:
+
+    prior_p = NULL;
+    for ( now_p = m_methods_pop; now_p != SC_NO_METHODS; 
+	  now_p = now_p->next_runnable() )
+    {
+        if ( remove_p == now_p )
+        {
+	    if ( prior_p )
+		prior_p->set_next_runnable( now_p->next_runnable() );
+	    else
+	        m_methods_pop = now_p->next_runnable();
+            now_p->set_next_runnable(0);
+	    DEBUG_MSG(DEBUG_NAME,now_p,"removing method from pop queue");
+            return;
+        }
+        prior_p = now_p;
+    }
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_runnable::remove_thread"
+//
+// This method removes the supplied thread process from the push or pop
+// queue if it is present. Note we clear the thread's next pointer so that it 
+// may be queued again.
+//     remove_p -> thread process to remove from the run queue.
+//------------------------------------------------------------------------------
+inline void sc_runnable::remove_thread( sc_thread_handle remove_p )
+{
+    sc_thread_handle now_p;     // Thread now checking.
+    sc_thread_handle prior_p;   // Thread prior to now_p.
+
+    // Don't try to remove things if we have not been initialized.
+
+    if ( !is_initialized() ) return;
+
+    // Search the push queue:
+
+    prior_p = m_threads_push_head;
+    for ( now_p = m_threads_push_head; now_p != SC_NO_THREADS; 
+	  now_p = now_p->next_runnable() )
+    {
+        if ( remove_p == now_p )
+        {
+            prior_p->set_next_runnable( now_p->next_runnable() );
+            if (now_p == m_threads_push_tail) {
+                m_threads_push_tail = prior_p;
+            }
+            now_p->set_next_runnable(0);
+	    DEBUG_MSG(DEBUG_NAME,now_p,"removing thread from push queue");
+            return;
+        }
+        prior_p = now_p;
+    }
+
+    // Search the pop queue:
+
+    prior_p = NULL;
+    for ( now_p = m_threads_pop; now_p != SC_NO_THREADS; 
+	  now_p = now_p->next_runnable() )
+    {
+        if ( remove_p == now_p )
+        {
+	    if ( prior_p )
+		prior_p->set_next_runnable( now_p->next_runnable() );
+	    else
+	        m_threads_pop = now_p->next_runnable();
+            now_p->set_next_runnable(0);
+	    DEBUG_MSG(DEBUG_NAME,now_p,"removing thread from pop queue");
+            return;
+        }
+        prior_p = now_p;
+    }
+}
+
+//------------------------------------------------------------------------------
+//"sc_runnable::sc_runnable"
+//
+// This is the object instance constructor for this class.
+//------------------------------------------------------------------------------
+inline sc_runnable::sc_runnable() : 
+   m_methods_push_head(0), m_methods_push_tail(0), m_methods_pop(SC_NO_METHODS),
+   m_threads_push_head(0), m_threads_push_tail(0), m_threads_pop(SC_NO_THREADS)
+{}
+
+//------------------------------------------------------------------------------
+//"sc_runnable::~sc_runnable"
+//
+// This is the object instance destructor for this class.
+//------------------------------------------------------------------------------
+inline sc_runnable::~sc_runnable()
+{
+    delete m_methods_push_head;
+    delete m_threads_push_head;
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_runnable::toggle_methods"
+//
+// This method moves the methods push queue to the pop queue and zeros the push
+// queue. This will only be done if the pop queue is presently empty.
+//------------------------------------------------------------------------------
+inline void sc_runnable::toggle_methods()
+{
+    if ( m_methods_pop == SC_NO_METHODS )
+    {
+	m_methods_pop = m_methods_push_head->next_runnable();
+	m_methods_push_head->set_next_runnable(SC_NO_METHODS);
+	m_methods_push_tail = m_methods_push_head;
+    }
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_runnable::toggle_threads"
+//
+// This method moves the threads push queue to the pop queue and zeros the push
+// queue. This will only be done if the pop queue is presently empty.
+//------------------------------------------------------------------------------
+inline void sc_runnable::toggle_threads()
+{
+    if ( m_threads_pop == SC_NO_THREADS )
+    {
+	m_threads_pop = m_threads_push_head->next_runnable();
+	m_threads_push_head->set_next_runnable(SC_NO_THREADS);
+	m_threads_push_tail = m_threads_push_head;
+    }
+}
+
+#undef SC_NO_METHODS
+#undef SC_NO_THREADS
+#undef DEBUG_MSG
+
+} // namespace sc_core
+
+
+/*******************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+      Andy Goodrich, Forte Design Systems, 2 September 2003
+      Changed queue heads to instances to eliminate the checks for null heads.
+
+ ******************************************************************************/
+
+// $Log: sc_runnable_int.h,v $
+// Revision 1.19  2011/08/24 22:05:51  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.18  2011/08/07 19:08:04  acg
+//  Andy Goodrich: moved logs to end of file so line number synching works
+//  better between versions.
+//
+// Revision 1.17  2011/04/13 02:45:11  acg
+//  Andy Goodrich: eliminated warning message that occurred if the DEBUG_MSG
+//  macro was used.
+//
+// Revision 1.16  2011/04/10 22:18:23  acg
+//  Andy Goodrich: debugging message clean up.
+//
+// Revision 1.15  2011/04/08 18:26:07  acg
+//  Andy Goodrich: added execute_method_next() to handle method dispatch
+//   for asynchronous notifications that occur outside the evaluation phase.
+//
+// Revision 1.14  2011/04/01 21:31:10  acg
+//  Andy Goodrich: turn off diagnostic messages by default.
+//
+// Revision 1.13  2011/04/01 21:30:02  acg
+//  Andy Goodrich: inserted conditional displays for queue manipulations.
+//
+// Revision 1.12  2011/03/30 00:01:34  acg
+//  Philip A. Hartmann: change break to return in remove_method() to short
+//  circuit the search the way remove_thread() works.
+//
+// Revision 1.11  2011/03/28 13:02:52  acg
+//  Andy Goodrich: Changes for disable() interactions.
+//
+// Revision 1.10  2011/03/06 15:58:17  acg
+//  Andy Goodrich: formatting changes.
+//
+// Revision 1.9  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.8  2011/02/13 21:47:38  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.7  2011/02/02 06:37:03  acg
+//  Andy Goodrich: removed toggle() method since it is no longer used.
+//
+// Revision 1.6  2011/02/01 21:09:13  acg
+//  Andy Goodrich: addition of toggle_methods() and toggle_threads() calls.
+//
+// Revision 1.5  2011/01/25 20:50:37  acg
+//  Andy Goodrich: changes for IEEE 1666 2011.
+//
+// Revision 1.4  2010/07/22 20:02:33  acg
+//  Andy Goodrich: bug fixes.
+//
+// Revision 1.3  2009/02/28 00:26:58  acg
+//  Andy Goodrich: changed boost name space to sc_boost to allow use with
+//  full boost library applications.
+//
+// Revision 1.2  2008/05/22 17:06:26  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.4  2006/04/20 17:08:17  acg
+//  Andy Goodrich: 3.0 style process changes.
+//
+// Revision 1.3  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+//
+
+#endif // SC_RUNNABLE_INT_H
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_sensitive.cpp b/ext/systemc/src/sysc/kernel/sc_sensitive.cpp
new file mode 100644
index 000000000..210c2670e
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_sensitive.cpp
@@ -0,0 +1,959 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_sensitive.cpp --
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+                   Martin Janssen, Synopsys, Inc.
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#include "sysc/kernel/sc_event.h"
+#include "sysc/kernel/sc_kernel_ids.h"
+#include "sysc/kernel/sc_module.h"
+#include "sysc/kernel/sc_cthread_process.h"
+#include "sysc/kernel/sc_method_process.h"
+#include "sysc/kernel/sc_thread_process.h"
+#include "sysc/kernel/sc_process_handle.h"
+#include "sysc/kernel/sc_sensitive.h"
+#include "sysc/communication/sc_signal_ports.h"
+#include "sysc/utils/sc_utils_ids.h"
+
+namespace sc_core {
+
+// support functions
+
+static
+sc_method_handle
+as_method_handle( sc_process_b* handle_ )
+{
+    return DCAST<sc_method_handle>( handle_ );
+}
+
+static
+sc_thread_handle
+as_thread_handle( sc_process_b* handle_ )
+{
+    return DCAST<sc_thread_handle>( handle_ );
+}
+
+static 
+void
+warn_no_parens()
+{
+    static bool warn_no_parentheses=true;
+    if ( warn_no_parentheses )
+    {
+	warn_no_parentheses=false;
+	SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
+	    "use of () to specify sensitivity is deprecated, use << instead" );
+    }
+}
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_sensitive
+//
+//  Static sensitivity class for events.
+// ----------------------------------------------------------------------------
+
+// constructor
+
+sc_sensitive::sc_sensitive( sc_module* module_ )
+: m_module( module_ ),
+  m_mode( SC_NONE_ ),
+  m_handle( 0 )
+{}
+
+
+// destructor
+
+sc_sensitive::~sc_sensitive()
+{}
+
+
+// changing between process handles
+
+sc_sensitive&
+sc_sensitive::operator << ( sc_process_handle handle_ )
+{
+    switch ( handle_.proc_kind() )
+	{
+      case SC_CTHREAD_PROC_:
+      case SC_THREAD_PROC_:
+        m_mode = SC_THREAD_;
+	break;
+      case SC_METHOD_PROC_:
+	m_mode = SC_METHOD_;
+	break;
+      default:
+	assert(0);
+    }
+    m_handle = (sc_process_b*)handle_;
+    return *this;
+}
+
+sc_sensitive&
+sc_sensitive::operator << ( const sc_event& event_ )
+{
+    // check
+    if( sc_is_running() ) {
+	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_, "simulation running" );
+    }
+
+    // make sensitive
+    switch( m_mode ) {
+    case SC_METHOD_:
+    case SC_THREAD_: {
+	m_handle->add_static_event( event_ );
+	break;
+    }
+    case SC_NONE_:
+        /* do nothing */
+        break;
+    }
+
+    return *this;
+}
+
+void
+sc_sensitive::make_static_sensitivity(
+    sc_process_b* handle_, const sc_event& event_)
+{
+    handle_->add_static_event( event_ );
+}
+
+
+sc_sensitive&
+sc_sensitive::operator << ( const sc_interface& interface_ )
+{
+    // check
+    if( sc_is_running() ) {
+	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_, "simulation running" );
+    }
+
+    // make sensitive
+    switch( m_mode ) {
+    case SC_METHOD_:
+    case SC_THREAD_: {
+	m_handle->add_static_event( interface_.default_event() );
+	break;
+    }
+    case SC_NONE_:
+        /* do nothing */
+        break;
+    }
+
+    return *this;
+}
+
+void
+sc_sensitive::make_static_sensitivity(
+    sc_process_b* handle_, const sc_interface& interface_)
+{
+    handle_->add_static_event( interface_.default_event() );
+}
+
+sc_sensitive&
+sc_sensitive::operator << ( const sc_port_base& port_ )
+{
+    // check
+    if( sc_is_running() ) {
+	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_, "simulation running" );
+    }
+
+    // make sensitive
+    switch( m_mode ) {
+    case SC_METHOD_: {
+	port_.make_sensitive( as_method_handle( m_handle ) );
+	break;
+    }
+    case SC_THREAD_: {
+	port_.make_sensitive( as_thread_handle( m_handle ) );
+	break;
+    }
+    case SC_NONE_:
+        /* do nothing */
+        break;
+    }
+
+    return *this;
+}
+
+void
+sc_sensitive::make_static_sensitivity(
+    sc_process_b* handle_, const sc_port_base& port_)
+{
+    sc_method_handle handle_m = as_method_handle( handle_ );
+    if ( handle_m ) {
+	port_.make_sensitive( handle_m );
+	return;
+    }
+    sc_thread_handle handle_t = as_thread_handle( handle_ );
+    // assert(handle_t);
+    port_.make_sensitive( handle_t );
+}
+
+sc_sensitive&
+sc_sensitive::operator << ( sc_event_finder& event_finder_ )
+{
+    // check
+    if( sc_is_running() ) {
+	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_, "simulation running" );
+    }
+
+    // make sensitive
+    switch( m_mode ) {
+    case SC_METHOD_: {
+	event_finder_.port().make_sensitive( as_method_handle( m_handle ),
+					     &event_finder_ );
+	break;
+    }
+    case SC_THREAD_: {
+	event_finder_.port().make_sensitive( as_thread_handle( m_handle ),
+					     &event_finder_ );
+	break;
+    }
+    case SC_NONE_:
+        /* do nothing */
+        break;
+    }
+
+    return *this;
+}
+
+void 
+sc_sensitive::make_static_sensitivity(
+    sc_process_b* handle_, sc_event_finder& event_finder_)
+{
+    if (sc_is_running()) {
+      handle_->add_static_event( event_finder_.find_event() );
+    } else {
+	sc_method_handle handle_m = as_method_handle( handle_ );
+	if ( handle_m ) {
+	    event_finder_.port().make_sensitive( handle_m, &event_finder_ );
+	    return;
+        }
+	sc_thread_handle handle_t = as_thread_handle( handle_ );
+	// assert(handle_t);
+	event_finder_.port().make_sensitive( handle_t, &event_finder_);
+    }
+}
+
+
+sc_sensitive&
+sc_sensitive::operator () ( const sc_event& event_ )
+{
+    warn_no_parens();
+    return operator << ( event_ );
+}
+
+sc_sensitive&
+sc_sensitive::operator () ( const sc_interface& interface_ )
+{
+    warn_no_parens();
+    return operator << ( interface_ );
+}
+
+sc_sensitive&
+sc_sensitive::operator () ( const sc_port_base& port_ )
+{
+    warn_no_parens();
+    return operator << ( port_ );
+}
+
+sc_sensitive&
+sc_sensitive::operator () ( sc_event_finder& event_finder_ )
+{
+    warn_no_parens();
+    return operator << ( event_finder_ );
+}
+
+
+sc_sensitive&
+sc_sensitive::operator () ( sc_cthread_handle handle_,
+			    sc_event_finder& event_finder_ )
+{
+    event_finder_.port().make_sensitive( handle_, &event_finder_ );
+    return *this;
+}
+
+sc_sensitive&
+sc_sensitive::operator () ( sc_cthread_handle handle_,
+			    const in_if_b_type& interface_ )
+{
+    handle_->add_static_event( interface_.posedge_event() );
+    return *this;
+}
+
+sc_sensitive&
+sc_sensitive::operator () ( sc_cthread_handle handle_,
+			    const in_if_l_type& interface_ )
+{
+    handle_->add_static_event( interface_.posedge_event() );
+    return *this;
+}
+
+sc_sensitive&
+sc_sensitive::operator () ( sc_cthread_handle handle_,
+			    const in_port_b_type& port_ )
+{
+    port_.make_sensitive( handle_, &port_.pos() );
+    return *this;
+}
+
+sc_sensitive&
+sc_sensitive::operator () ( sc_cthread_handle handle_,
+			    const in_port_l_type& port_ )
+{
+    port_.make_sensitive( handle_, &port_.pos() );
+    return *this;
+}
+
+sc_sensitive&
+sc_sensitive::operator () ( sc_cthread_handle handle_,
+			    const inout_port_b_type& port_ )
+{
+    port_.make_sensitive( handle_, &port_.pos() );
+    return *this;
+}
+
+sc_sensitive&
+sc_sensitive::operator () ( sc_cthread_handle handle_,
+			    const inout_port_l_type& port_ )
+{
+    port_.make_sensitive( handle_, &port_.pos() );
+    return *this;
+}
+
+void sc_sensitive::reset()
+{
+    m_mode = SC_NONE_;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_sensitive_pos
+//
+//  Static sensitivity class for positive edge events.
+// ----------------------------------------------------------------------------
+
+static void sc_deprecated_sensitive_pos()
+{
+    static bool warn_sensitive_pos=true;
+    if ( warn_sensitive_pos )
+    {
+        warn_sensitive_pos=false;
+        SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
+	 "sc_sensitive_pos is deprecated use sc_sensitive << with pos() instead" );
+    }
+}
+
+// constructor
+
+sc_sensitive_pos::sc_sensitive_pos( sc_module* module_ )
+: m_module( module_ ),
+  m_mode( SC_NONE_ ),
+  m_handle( 0 )
+{}
+
+
+// destructor
+
+sc_sensitive_pos::~sc_sensitive_pos()
+{}
+
+
+// changing between process handles
+
+sc_sensitive_pos&
+sc_sensitive_pos::operator << ( sc_process_handle handle_ )
+{
+    switch ( handle_.proc_kind() )
+	{
+      case SC_CTHREAD_PROC_:
+      case SC_THREAD_PROC_:
+        m_mode = SC_THREAD_;
+	break;
+      case SC_METHOD_PROC_:
+	m_mode = SC_METHOD_;
+	break;
+      default:
+	assert(0);
+    }
+    m_handle = (sc_process_b*)handle_;
+    return *this;
+}
+
+sc_sensitive_pos&
+sc_sensitive_pos::operator << ( sc_method_handle handle_ )
+{
+    m_mode = SC_METHOD_;
+    m_handle = handle_;
+    return *this;
+}
+
+sc_sensitive_pos&
+sc_sensitive_pos::operator << ( sc_thread_handle handle_ )
+{
+    m_mode = SC_THREAD_;
+    m_handle = handle_;
+    return *this;
+}
+
+
+sc_sensitive_pos&
+sc_sensitive_pos::operator << ( const in_if_b_type& interface_ )
+{
+    sc_deprecated_sensitive_pos();
+    // check
+    if( sc_is_running() ) {
+	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_POS_, "simulation running" );
+    }
+
+    // make sensitive
+    switch( m_mode ) {
+    case SC_METHOD_:
+    case SC_THREAD_: {
+	m_handle->add_static_event( interface_.posedge_event() );
+	break;
+    }
+    case SC_NONE_:
+        /* do nothing */
+        break;
+    }
+
+    return *this;
+}
+
+sc_sensitive_pos&
+sc_sensitive_pos::operator << ( const in_if_l_type& interface_ )
+{
+    sc_deprecated_sensitive_pos();
+    // check
+    if( sc_is_running() ) {
+	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_POS_, "simulation running" );
+    }
+
+    // make sensitive
+    switch( m_mode ) {
+    case SC_METHOD_:
+    case SC_THREAD_: {
+	m_handle->add_static_event( interface_.posedge_event() );
+	break;
+    }
+    case SC_NONE_:
+        /* do nothing */
+        break;
+    }
+
+    return *this;
+}
+
+sc_sensitive_pos&
+sc_sensitive_pos::operator << ( const in_port_b_type& port_ )
+{
+    sc_deprecated_sensitive_pos();
+    // check
+    if( sc_is_running() ) {
+	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_POS_, "simulation running" );
+    }
+
+    // make sensitive
+    switch( m_mode ) {
+    case SC_METHOD_: {
+	port_.make_sensitive( as_method_handle( m_handle ), &port_.pos() );
+	break;
+    }
+    case SC_THREAD_: {
+	port_.make_sensitive( as_thread_handle( m_handle ), &port_.pos() );
+	break;
+    }
+    case SC_NONE_:
+        /* do nothing */
+        break;
+    }
+
+    return *this;
+}
+
+sc_sensitive_pos&
+sc_sensitive_pos::operator << ( const in_port_l_type& port_ )
+{
+    sc_deprecated_sensitive_pos();
+    // check
+    if( sc_is_running() ) {
+	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_POS_, "simulation running" );
+    }
+
+    // make sensitive
+    switch( m_mode ) {
+    case SC_METHOD_: {
+	port_.make_sensitive( as_method_handle( m_handle ), &port_.pos() );
+	break;
+    }
+    case SC_THREAD_: {
+	port_.make_sensitive( as_thread_handle( m_handle ), &port_.pos() );
+	break;
+    }
+    case SC_NONE_:
+        /* do nothing */
+        break;
+    }
+
+    return *this;
+}
+
+sc_sensitive_pos&
+sc_sensitive_pos::operator << ( const inout_port_b_type& port_ )
+{
+    sc_deprecated_sensitive_pos();
+    // check
+    if( sc_is_running() ) {
+	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_POS_, "simulation running" );
+    }
+
+    // make sensitive
+    switch( m_mode ) {
+    case SC_METHOD_: {
+	port_.make_sensitive( as_method_handle( m_handle ), &port_.pos() );
+	break;
+    }
+    case SC_THREAD_: {
+	port_.make_sensitive( as_thread_handle( m_handle ), &port_.pos() );
+	break;
+    }
+    case SC_NONE_:
+        /* do nothing */
+        break;
+    }
+
+    return *this;
+}
+
+sc_sensitive_pos&
+sc_sensitive_pos::operator << ( const inout_port_l_type& port_ )
+{
+    sc_deprecated_sensitive_pos();
+    // check
+    if( sc_is_running() ) {
+	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_POS_, "simulation running" );
+    }
+
+    // make sensitive
+    switch( m_mode ) {
+    case SC_METHOD_: {
+	port_.make_sensitive( as_method_handle( m_handle ), &port_.pos() );
+	break;
+    }
+    case SC_THREAD_: {
+	port_.make_sensitive( as_thread_handle( m_handle ), &port_.pos() );
+	break;
+    }
+    case SC_NONE_:
+        /* do nothing */
+        break;
+    }
+
+    return *this;
+}
+
+
+sc_sensitive_pos&
+sc_sensitive_pos::operator () ( const in_if_b_type& interface_ )
+{
+    warn_no_parens();
+    return operator << ( interface_ );
+}
+
+sc_sensitive_pos&
+sc_sensitive_pos::operator () ( const in_if_l_type& interface_ )
+{
+    warn_no_parens();
+    return operator << ( interface_ );
+}
+
+sc_sensitive_pos&
+sc_sensitive_pos::operator () ( const in_port_b_type& port_ )
+{
+    warn_no_parens();
+    return operator << ( port_ );
+}
+
+sc_sensitive_pos&
+sc_sensitive_pos::operator () ( const in_port_l_type& port_ )
+{
+    warn_no_parens();
+    return operator << ( port_ );
+}
+
+sc_sensitive_pos&
+sc_sensitive_pos::operator () ( const inout_port_b_type& port_ )
+{
+    warn_no_parens();
+    return operator << ( port_ );
+}
+
+sc_sensitive_pos&
+sc_sensitive_pos::operator () ( const inout_port_l_type& port_ )
+{
+    warn_no_parens();
+    return operator << ( port_ );
+}
+
+void sc_sensitive_pos::reset()
+{
+    m_mode = SC_NONE_;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_sensitive_neg
+//
+//  Static sensitivity class for negative edge events.
+// ----------------------------------------------------------------------------
+
+static void sc_deprecated_sensitive_neg()
+{
+    static bool warn_sensitive_neg=true;
+    if ( warn_sensitive_neg )
+    {
+        warn_sensitive_neg=false;
+        SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
+	 "sc_sensitive_neg is deprecated use sc_sensitive << with neg() instead" );
+    }
+}
+
+// constructor
+
+sc_sensitive_neg::sc_sensitive_neg( sc_module* module_ )
+: m_module( module_ ),
+  m_mode( SC_NONE_ ),
+  m_handle( 0 )
+{}
+
+
+// destructor
+
+sc_sensitive_neg::~sc_sensitive_neg()
+{}
+
+
+// changing between process handles
+
+sc_sensitive_neg&
+sc_sensitive_neg::operator << ( sc_process_handle handle_ )
+{
+    switch ( handle_.proc_kind() )
+	{
+      case SC_CTHREAD_PROC_:
+      case SC_THREAD_PROC_:
+        m_mode = SC_THREAD_;
+	break;
+      case SC_METHOD_PROC_:
+	m_mode = SC_METHOD_;
+	break;
+      default:
+	assert(0);
+    }
+    m_handle = (sc_process_b*)handle_;
+    return *this;
+}
+
+sc_sensitive_neg&
+sc_sensitive_neg::operator << ( sc_method_handle handle_ )
+{
+    m_mode = SC_METHOD_;
+    m_handle = handle_;
+    return *this;
+}
+
+sc_sensitive_neg&
+sc_sensitive_neg::operator << ( sc_thread_handle handle_ )
+{
+    m_mode = SC_THREAD_;
+    m_handle = handle_;
+    return *this;
+}
+
+
+sc_sensitive_neg&
+sc_sensitive_neg::operator << ( const in_if_b_type& interface_ )
+{
+    sc_deprecated_sensitive_neg();
+    // check
+    if( sc_is_running() ) {
+	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_NEG_, "simulation running" );
+    }
+
+    // make sensitive
+    switch( m_mode ) {
+    case SC_METHOD_:
+    case SC_THREAD_: {
+	m_handle->add_static_event( interface_.negedge_event() );
+	break;
+    }
+    case SC_NONE_:
+        /* do nothing */
+        break;
+    }
+
+    return *this;
+}
+
+sc_sensitive_neg&
+sc_sensitive_neg::operator << ( const in_if_l_type& interface_ )
+{
+    sc_deprecated_sensitive_neg();
+    // check
+    if( sc_is_running() ) {
+	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_NEG_, "simulation running" );
+    }
+
+    // make sensitive
+    switch( m_mode ) {
+    case SC_METHOD_:
+    case SC_THREAD_: {
+	m_handle->add_static_event( interface_.negedge_event() );
+	break;
+    }
+    case SC_NONE_:
+        /* do nothing */
+        break;
+    }
+
+    return *this;
+}
+
+sc_sensitive_neg&
+sc_sensitive_neg::operator << ( const in_port_b_type& port_ )
+{
+    sc_deprecated_sensitive_neg();
+    // check
+    if( sc_is_running() ) {
+	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_NEG_, "simulation running" );
+    }
+
+    // make sensitive
+    switch( m_mode ) {
+    case SC_METHOD_: {
+	port_.make_sensitive( as_method_handle( m_handle ), &port_.neg() );
+	break;
+    }
+    case SC_THREAD_: {
+	port_.make_sensitive( as_thread_handle( m_handle ), &port_.neg() );
+	break;
+    }
+    case SC_NONE_:
+        /* do nothing */
+        break;
+    }
+
+    return *this;
+}
+
+sc_sensitive_neg&
+sc_sensitive_neg::operator << ( const in_port_l_type& port_ )
+{
+    sc_deprecated_sensitive_neg();
+    // check
+    if( sc_is_running() ) {
+	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_NEG_, "simulation running" );
+    }
+
+    // make sensitive
+    switch( m_mode ) {
+    case SC_METHOD_: {
+	port_.make_sensitive( as_method_handle( m_handle ), &port_.neg() );
+	break;
+    }
+    case SC_THREAD_: {
+	port_.make_sensitive( as_thread_handle( m_handle ), &port_.neg() );
+	break;
+    }
+    case SC_NONE_:
+        /* do nothing */
+        break;
+    }
+
+    return *this;
+}
+
+sc_sensitive_neg&
+sc_sensitive_neg::operator << ( const inout_port_b_type& port_ )
+{
+    sc_deprecated_sensitive_neg();
+    // check
+    if( sc_is_running() ) {
+	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_NEG_, "simulation running" );
+    }
+
+    // make sensitive
+    switch( m_mode ) {
+    case SC_METHOD_: {
+	port_.make_sensitive( as_method_handle( m_handle ), &port_.neg() );
+	break;
+    }
+    case SC_THREAD_: {
+	port_.make_sensitive( as_thread_handle( m_handle ), &port_.neg() );
+	break;
+    }
+    case SC_NONE_:
+        /* do nothing */
+        break;
+    }
+
+    return *this;
+}
+
+sc_sensitive_neg&
+sc_sensitive_neg::operator << ( const inout_port_l_type& port_ )
+{
+    sc_deprecated_sensitive_neg();
+    // check
+    if( sc_is_running() ) {
+	SC_REPORT_ERROR( SC_ID_MAKE_SENSITIVE_NEG_, "simulation running" );
+    }
+
+    // make sensitive
+    switch( m_mode ) {
+    case SC_METHOD_: {
+	port_.make_sensitive( as_method_handle( m_handle ), &port_.neg() );
+	break;
+    }
+    case SC_THREAD_: {
+	port_.make_sensitive( as_thread_handle( m_handle ), &port_.neg() );
+	break;
+    }
+    case SC_NONE_:
+        /* do nothing */
+        break;
+    }
+
+    return *this;
+}
+
+
+sc_sensitive_neg&
+sc_sensitive_neg::operator () ( const in_if_b_type& interface_ )
+{
+    warn_no_parens();
+    return operator << ( interface_ );
+}
+
+sc_sensitive_neg&
+sc_sensitive_neg::operator () ( const in_if_l_type& interface_ )
+{
+    warn_no_parens();
+    return operator << ( interface_ );
+}
+
+sc_sensitive_neg&
+sc_sensitive_neg::operator () ( const in_port_b_type& port_ )
+{
+    warn_no_parens();
+    return operator << ( port_ );
+}
+
+sc_sensitive_neg&
+sc_sensitive_neg::operator () ( const in_port_l_type& port_ )
+{
+    warn_no_parens();
+    return operator << ( port_ );
+}
+
+sc_sensitive_neg&
+sc_sensitive_neg::operator () ( const inout_port_b_type& port_ )
+{
+    warn_no_parens();
+    return operator << ( port_ );
+}
+
+sc_sensitive_neg&
+sc_sensitive_neg::operator () ( const inout_port_l_type& port_ )
+{
+    warn_no_parens();
+    return operator << ( port_ );
+}
+
+void sc_sensitive_neg::reset()
+{
+    m_mode = SC_NONE_;
+}
+
+} // namespace sc_core
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Bishnupriya Bhattacharya, Cadence Design Systems,
+                               25 August, 2003
+  Description of Modification: add make_static_sensitivity() routines to support
+                               dynamic method process creation with static
+                               sensitivity
+
+ *****************************************************************************/
+
+// $Log: sc_sensitive.cpp,v $
+// Revision 1.5  2011/08/26 20:46:10  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.4  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.3  2011/02/13 21:47:38  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.2  2008/05/22 17:06:26  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.8  2006/04/11 23:13:21  acg
+//   Andy Goodrich: Changes for reduced reset support that only includes
+//   sc_cthread, but has preliminary hooks for expanding to method and thread
+//   processes also.
+//
+// Revision 1.7  2006/01/27 17:31:24  acg
+//  Andy Goodrich: removed debugging comments from << operator code for types
+//  that are deprecated.
+//
+// Revision 1.6  2006/01/26 21:04:54  acg
+//  Andy Goodrich: deprecation message changes and additional messages.
+//
+// Revision 1.5  2006/01/25 00:31:19  acg
+//  Andy Goodrich: Changed over to use a standard message id of
+//  SC_ID_IEEE_1666_DEPRECATION for all deprecation messages.
+//
+// Revision 1.4  2006/01/24 20:49:05  acg
+// Andy Goodrich: changes to remove the use of deprecated features within the
+// simulator, and to issue warning messages when deprecated features are used.
+//
+// Revision 1.3  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+//
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_sensitive.h b/ext/systemc/src/sysc/kernel/sc_sensitive.h
new file mode 100644
index 000000000..9d07bd03a
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_sensitive.h
@@ -0,0 +1,306 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_sensitive.h -- Sensitivity classes. Requires "sc_process.h"
+  for declarations of sc_method_handle, &.c.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+                   Martin Janssen, Synopsys, Inc.
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#ifndef SC_SENSITIVE_H
+#define SC_SENSITIVE_H
+
+#include "sysc/kernel/sc_process.h"
+
+namespace sc_dt
+{
+    class sc_logic;
+}
+
+namespace sc_core {
+
+class sc_process_handle;
+class sc_event;
+class sc_event_finder;
+class sc_interface;
+class sc_module;
+class sc_port_base;
+template <class T> class sc_in;
+template <class T> class sc_inout;
+template <class T> class sc_signal_in_if;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_sensitive
+//
+//  Static sensitivity class for events.
+// ----------------------------------------------------------------------------
+
+class sc_sensitive
+{
+    friend class sc_module;
+
+public:
+
+    // typedefs
+    typedef sc_signal_in_if<bool>            in_if_b_type;
+    typedef sc_signal_in_if<sc_dt::sc_logic> in_if_l_type;
+    typedef sc_in<bool>                      in_port_b_type;
+    typedef sc_in<sc_dt::sc_logic>           in_port_l_type;
+    typedef sc_inout<bool>                   inout_port_b_type;
+    typedef sc_inout<sc_dt::sc_logic>        inout_port_l_type;
+
+private:
+
+    // constructor
+    explicit sc_sensitive( sc_module* );
+
+    // destructor
+    ~sc_sensitive();
+
+public:
+
+    // changing between process handles
+    sc_sensitive& operator << ( sc_process_handle );
+#if 0
+    sc_sensitive& operator << ( sc_method_handle );
+    sc_sensitive& operator << ( sc_thread_handle );
+#endif // 0
+
+    sc_sensitive& operator () ( const sc_event& );
+    sc_sensitive& operator () ( const sc_interface& );
+    sc_sensitive& operator () ( const sc_port_base& );
+    sc_sensitive& operator () ( sc_event_finder& );
+
+    sc_sensitive& operator << ( const sc_event& );
+    sc_sensitive& operator << ( const sc_interface& );
+    sc_sensitive& operator << ( const sc_port_base& );
+    sc_sensitive& operator << ( sc_event_finder& );
+
+    sc_sensitive& operator () ( sc_cthread_handle, sc_event_finder& );
+    sc_sensitive& operator () ( sc_cthread_handle, const in_if_b_type& );
+    sc_sensitive& operator () ( sc_cthread_handle, const in_if_l_type& );
+    sc_sensitive& operator () ( sc_cthread_handle, const in_port_b_type& );
+    sc_sensitive& operator () ( sc_cthread_handle, const in_port_l_type& );
+    sc_sensitive& operator () ( sc_cthread_handle, const inout_port_b_type& );
+    sc_sensitive& operator () ( sc_cthread_handle, const inout_port_l_type& );
+
+    static void make_static_sensitivity( sc_process_b*, const sc_event& );
+    static void make_static_sensitivity( sc_process_b*, const sc_interface& );
+    static void make_static_sensitivity( sc_process_b*, const sc_port_base&);
+    static void make_static_sensitivity( sc_process_b*, sc_event_finder& );
+
+    void reset();
+
+private:
+
+    sc_module*                                m_module;
+    enum { SC_NONE_, SC_METHOD_, SC_THREAD_ } m_mode;
+    sc_process_b*                          m_handle;
+
+private:
+
+    // disabled
+
+    sc_sensitive();
+    sc_sensitive( const sc_sensitive& );
+    sc_sensitive& operator = ( const sc_sensitive& );
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_sensitive_pos
+//
+//  Static sensitivity class for positive edge events.
+// ----------------------------------------------------------------------------
+
+class sc_sensitive_pos
+{
+    friend class sc_module;
+
+public:
+
+    // typedefs
+    typedef sc_signal_in_if<bool>            in_if_b_type;
+    typedef sc_signal_in_if<sc_dt::sc_logic> in_if_l_type;
+    typedef sc_in<bool>                      in_port_b_type;
+    typedef sc_in<sc_dt::sc_logic>           in_port_l_type;
+    typedef sc_inout<bool>                   inout_port_b_type;
+    typedef sc_inout<sc_dt::sc_logic>        inout_port_l_type;
+
+private:
+
+    // constructor
+    explicit sc_sensitive_pos( sc_module* );
+
+    // destructor
+    ~sc_sensitive_pos();
+
+public:
+
+    // changing between process handles
+    sc_sensitive_pos& operator << ( sc_process_handle );
+    sc_sensitive_pos& operator << ( sc_method_handle );
+    sc_sensitive_pos& operator << ( sc_thread_handle );
+
+    sc_sensitive_pos& operator () ( const in_if_b_type& );
+    sc_sensitive_pos& operator () ( const in_if_l_type& );
+    sc_sensitive_pos& operator () ( const in_port_b_type& );
+    sc_sensitive_pos& operator () ( const in_port_l_type& );
+    sc_sensitive_pos& operator () ( const inout_port_b_type& );
+    sc_sensitive_pos& operator () ( const inout_port_l_type& );
+
+    sc_sensitive_pos& operator << ( const in_if_b_type& );
+    sc_sensitive_pos& operator << ( const in_if_l_type& );
+    sc_sensitive_pos& operator << ( const in_port_b_type& );
+    sc_sensitive_pos& operator << ( const in_port_l_type& );
+    sc_sensitive_pos& operator << ( const inout_port_b_type& );
+    sc_sensitive_pos& operator << ( const inout_port_l_type& );
+
+    void reset();
+
+private:
+
+    sc_module*                                m_module;
+    enum { SC_NONE_, SC_METHOD_, SC_THREAD_ } m_mode;
+    sc_process_b*                          m_handle;
+
+private:
+
+    // disabled
+    sc_sensitive_pos();
+    sc_sensitive_pos( const sc_sensitive_pos& );
+    sc_sensitive_pos& operator = ( const sc_sensitive_pos& );
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_sensitive_neg
+//
+//  Static sensitivity class for negative edge events.
+// ----------------------------------------------------------------------------
+
+class sc_sensitive_neg
+{
+    friend class sc_module;
+
+public:
+
+    // typedefs
+    typedef sc_signal_in_if<bool>            in_if_b_type;
+    typedef sc_signal_in_if<sc_dt::sc_logic> in_if_l_type;
+    typedef sc_in<bool>                      in_port_b_type;
+    typedef sc_in<sc_dt::sc_logic>           in_port_l_type;
+    typedef sc_inout<bool>                   inout_port_b_type;
+    typedef sc_inout<sc_dt::sc_logic>        inout_port_l_type;
+
+private:
+
+    // constructor
+    explicit sc_sensitive_neg( sc_module* );
+
+    // destructor
+    ~sc_sensitive_neg();
+
+public:
+
+    // changing between process handles
+    sc_sensitive_neg& operator << ( sc_process_handle );
+    sc_sensitive_neg& operator << ( sc_method_handle );
+    sc_sensitive_neg& operator << ( sc_thread_handle );
+
+    sc_sensitive_neg& operator () ( const in_if_b_type& );
+    sc_sensitive_neg& operator () ( const in_if_l_type& );
+    sc_sensitive_neg& operator () ( const in_port_b_type& );
+    sc_sensitive_neg& operator () ( const in_port_l_type& );
+    sc_sensitive_neg& operator () ( const inout_port_b_type& );
+    sc_sensitive_neg& operator () ( const inout_port_l_type& );
+
+    sc_sensitive_neg& operator << ( const in_if_b_type& );
+    sc_sensitive_neg& operator << ( const in_if_l_type& );
+    sc_sensitive_neg& operator << ( const in_port_b_type& );
+    sc_sensitive_neg& operator << ( const in_port_l_type& );
+    sc_sensitive_neg& operator << ( const inout_port_b_type& );
+    sc_sensitive_neg& operator << ( const inout_port_l_type& );
+
+    void reset();
+
+private:
+
+    sc_module*                                m_module;
+    enum { SC_NONE_, SC_METHOD_, SC_THREAD_ } m_mode;
+    sc_process_b*                          m_handle;
+
+private:
+
+    // disabled
+    sc_sensitive_neg();
+    sc_sensitive_neg( const sc_sensitive_neg& );
+    sc_sensitive_neg& operator = ( const sc_sensitive_neg& );
+};
+
+} // namespace sc_core 
+
+#endif
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Bishnupriya Bhattacharya, Cadence Design Systems,
+                               25 August, 2003
+  Description of Modification: Add make_static_sensitivity() methods to enable
+                               dynamic method process creation with static 
+                               sensitivity.
+
+ *****************************************************************************/
+
+// $Log: sc_sensitive.h,v $
+// Revision 1.5  2011/08/26 20:46:10  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.4  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.3  2011/02/13 21:47:38  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.2  2008/05/22 17:06:26  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.4  2006/04/11 23:13:21  acg
+//   Andy Goodrich: Changes for reduced reset support that only includes
+//   sc_cthread, but has preliminary hooks for expanding to method and thread
+//   processes also.
+//
+// Revision 1.3  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_simcontext.cpp b/ext/systemc/src/sysc/kernel/sc_simcontext.cpp
new file mode 100644
index 000000000..104f7c984
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_simcontext.cpp
@@ -0,0 +1,2284 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_simcontext.cpp -- Provides a simulation context for use with multiple
+                       simulations.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+                   Martin Janssen, Synopsys, Inc.
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+#include <algorithm>
+
+#define SC_DISABLE_API_VERSION_CHECK // for in-library sc_ver.h inclusion
+
+#include "sysc/kernel/sc_cor_fiber.h"
+#include "sysc/kernel/sc_cor_pthread.h"
+#include "sysc/kernel/sc_cor_qt.h"
+#include "sysc/kernel/sc_event.h"
+#include "sysc/kernel/sc_kernel_ids.h"
+#include "sysc/kernel/sc_module.h"
+#include "sysc/kernel/sc_module_registry.h"
+#include "sysc/kernel/sc_name_gen.h"
+#include "sysc/kernel/sc_object_manager.h"
+#include "sysc/kernel/sc_cthread_process.h"
+#include "sysc/kernel/sc_method_process.h"
+#include "sysc/kernel/sc_thread_process.h"
+#include "sysc/kernel/sc_process_handle.h"
+#include "sysc/kernel/sc_simcontext.h"
+#include "sysc/kernel/sc_simcontext_int.h"
+#include "sysc/kernel/sc_reset.h"
+#include "sysc/kernel/sc_ver.h"
+#include "sysc/kernel/sc_boost.h"
+#include "sysc/kernel/sc_spawn.h"
+#include "sysc/kernel/sc_phase_callback_registry.h"
+#include "sysc/communication/sc_port.h"
+#include "sysc/communication/sc_export.h"
+#include "sysc/communication/sc_prim_channel.h"
+#include "sysc/tracing/sc_trace.h"
+#include "sysc/utils/sc_mempool.h"
+#include "sysc/utils/sc_list.h"
+#include "sysc/utils/sc_utils_ids.h"
+
+// DEBUGGING MACROS:
+//
+// DEBUG_MSG(NAME,P,MSG)
+//     MSG  = message to print
+//     NAME = name that must match the process for the message to print, or
+//            null if the message should be printed unconditionally.
+//     P    = pointer to process message is for, or NULL in which case the
+//            message will not print.
+#if 0
+#   define DEBUG_NAME ""
+#   define DEBUG_MSG(NAME,P,MSG) \
+    { \
+        if ( P && ( (strlen(NAME)==0) || !strcmp(NAME,P->name())) ) \
+          std::cout << "**** " << sc_time_stamp() << " ("  \
+	            << sc_get_current_process_name() << "): " << MSG \
+		    << " - " << P->name() << std::endl; \
+    }
+#else
+#   define DEBUG_MSG(NAME,P,MSG) 
+#endif
+
+#if SC_HAS_PHASE_CALLBACKS_
+#  define SC_DO_PHASE_CALLBACK_( Kind ) \
+    m_phase_cb_registry->Kind()
+#else
+#  define SC_DO_PHASE_CALLBACK_( Kind ) \
+    ((void)0) /* do nothing */
+#endif
+
+#if defined( SC_ENABLE_SIMULATION_PHASE_CALLBACKS_TRACING )
+// use callback based tracing
+#  define SC_SIMCONTEXT_TRACING_  0
+#else
+// enable tracing via explicit trace_cycle calls from simulator loop
+#  define SC_SIMCONTEXT_TRACING_  1
+#endif
+
+namespace sc_core {
+
+sc_stop_mode stop_mode = SC_STOP_FINISH_DELTA;
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_process_table
+//
+//  Container class that keeps track of all method processes,
+//  (c)thread processes.
+// ----------------------------------------------------------------------------
+
+class sc_process_table
+{
+  public:
+
+    sc_process_table();
+    ~sc_process_table();
+    void push_front( sc_method_handle );
+    void push_front( sc_thread_handle );
+    sc_method_handle method_q_head();
+    sc_method_handle remove( sc_method_handle );
+    sc_thread_handle thread_q_head();
+    sc_thread_handle remove( sc_thread_handle );
+
+
+  private:
+
+    sc_method_handle  m_method_q;  // Queue of existing method processes.
+    sc_thread_handle  m_thread_q;  // Queue of existing thread processes.
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+sc_process_table::sc_process_table() : m_method_q(0), m_thread_q(0)
+{}
+
+sc_process_table::~sc_process_table()
+{
+
+    sc_method_handle  method_next_p;	// Next method to delete.
+    sc_method_handle  method_now_p;	// Method now deleting.
+
+    for( method_now_p = m_method_q; method_now_p; method_now_p = method_next_p )
+    {
+	method_next_p = method_now_p->next_exist();
+	delete method_now_p;
+    }
+
+    if ( m_thread_q )
+    {
+        ::std::cout << ::std::endl 
+             << "WATCH OUT!! In sc_process_table destructor. "
+             << "Threads and cthreads are not actually getting deleted here. "
+	     << "Some memory may leak. Look at the comments here in "
+	     << "kernel/sc_simcontext.cpp for more details."
+	     << ::std::endl;
+    }
+
+    // don't delete threads and cthreads. If a (c)thread
+    // has died, then it has already been deleted. Only (c)threads created
+    // before simulation-start are in this table. Due to performance
+    // reasons, we don't look up the dying thread in the process table
+    // and remove it from there. simcontext::reset and ~simcontext invoke this
+    // destructor. At present none of these routines are ever invoked. 
+    // We can delete threads and cthreads here if a dying thread figured out
+    // it was created before simulation-start and took itself off the 
+    // process_table. 
+
+#if 0
+    sc_thread_handle  thread_next_p;	// Next thread to delete.
+    sc_thread_handle  thread_now_p;	// Thread now deleting.
+
+    for( thread_now_p=m_thread_q; thread_now_p; thread_now_p=thread_next_p )
+    {
+	thread_next_p = thread_now_p->next_exist();
+	delete thread_now_p;
+    }
+#endif // 0
+}
+
+inline
+sc_method_handle 
+sc_process_table::method_q_head()
+{
+    return m_method_q;
+}
+
+inline
+void
+sc_process_table::push_front( sc_method_handle handle_ )
+{
+    handle_->set_next_exist(m_method_q);
+    m_method_q = handle_;
+}
+
+inline
+void
+sc_process_table::push_front( sc_thread_handle handle_ )
+{
+    handle_->set_next_exist(m_thread_q);
+    m_thread_q = handle_;
+}
+
+sc_method_handle
+sc_process_table::remove( sc_method_handle handle_ )
+{
+    sc_method_handle now_p;	// Entry now examining.
+    sc_method_handle prior_p;	// Entry prior to one now examining.
+
+    prior_p = 0;
+    for ( now_p = m_method_q; now_p; now_p = now_p->next_exist() )
+    {
+	if ( now_p == handle_ )
+	{
+	    if ( prior_p )
+		prior_p->set_next_exist( now_p->next_exist() );
+	    else
+		m_method_q = now_p->next_exist();
+	    return handle_;
+	}
+    }
+    return 0;
+}
+
+sc_thread_handle
+sc_process_table::remove( sc_thread_handle handle_ )
+{
+    sc_thread_handle now_p;	// Entry now examining.
+    sc_thread_handle prior_p;	// Entry prior to one now examining.
+
+    prior_p = 0;
+    for ( now_p = m_thread_q; now_p; now_p = now_p->next_exist() )
+    {
+	if ( now_p == handle_ )
+	{
+	    if ( prior_p )
+		prior_p->set_next_exist( now_p->next_exist() );
+	    else
+		m_thread_q = now_p->next_exist();
+	    return handle_;
+	}
+    }
+    return 0;
+}
+
+inline
+sc_thread_handle 
+sc_process_table::thread_q_head()
+{
+    return m_thread_q;
+}
+
+int
+sc_notify_time_compare( const void* p1, const void* p2 )
+{
+    const sc_event_timed* et1 = static_cast<const sc_event_timed*>( p1 );
+    const sc_event_timed* et2 = static_cast<const sc_event_timed*>( p2 );
+
+    const sc_time& t1 = et1->notify_time();
+    const sc_time& t2 = et2->notify_time();
+    
+    if( t1 < t2 ) {
+	return 1;
+    } else if( t1 > t2 ) {
+	return -1;
+    } else {
+	return 0;
+    }
+}
+
+
+// +============================================================================
+// | CLASS sc_invoke_method - class to invoke sc_method's to support 
+// |                          sc_simcontext::preempt_with().
+// +============================================================================
+SC_MODULE(sc_invoke_method)
+{
+    SC_CTOR(sc_invoke_method)
+    {
+      // remove from object hierarchy
+      detach();
+    }
+
+    virtual ~sc_invoke_method()
+    {
+	m_invokers.resize(0);
+    }
+
+    // Method to call to execute a method's semantics. 
+    
+    void invoke_method( sc_method_handle method_h )
+    {
+	sc_process_handle invoker_h;  // handle for invocation thread to use.
+	std::vector<sc_process_handle>::size_type invokers_n; // number of invocation threads available.
+
+	m_method = method_h;
+
+	// There is not an invocation thread to use, so allocate one.
+
+	invokers_n = m_invokers.size();
+	if ( invokers_n == 0 )
+	{
+	    sc_spawn_options options;
+	    options.dont_initialize();
+	    options.set_stack_size(0x100000);
+	    options.set_sensitivity(&m_dummy);
+	    invoker_h = sc_spawn(sc_bind(&sc_invoke_method::invoker,this), 
+				 sc_gen_unique_name("invoker"), &options);
+	    ((sc_process_b*)invoker_h)->detach();
+	}
+
+	// There is an invocation thread to use, use the last one on the list.
+
+	else
+	{
+	    invoker_h = m_invokers[invokers_n-1];
+	    m_invokers.pop_back();
+	}
+
+	// Fire off the invocation thread to invoke the method's semantics,
+	// When it blocks put it onto the list of invocation threads that
+	// are available.
+
+        sc_get_curr_simcontext()->preempt_with( (sc_thread_handle)invoker_h );
+	DEBUG_MSG( DEBUG_NAME, m_method, "back from preemption" ); 
+	m_invokers.push_back(invoker_h);
+    }
+
+    // Thread to call method from:
+
+    void invoker()
+    {
+	sc_simcontext* csc_p = sc_get_curr_simcontext();
+	sc_process_b*  me = sc_get_current_process_b();
+
+	DEBUG_MSG( DEBUG_NAME, me, "invoker initialization" );
+        for (;; )
+        {
+            DEBUG_MSG( DEBUG_NAME, m_method, "invoker executing method" );
+	    csc_p->set_curr_proc( (sc_process_b*)m_method );
+	    csc_p->get_active_invokers().push_back((sc_thread_handle)me);
+	    m_method->run_process();
+	    csc_p->set_curr_proc( me );
+	    csc_p->get_active_invokers().pop_back();
+            DEBUG_MSG( DEBUG_NAME, m_method, "back from executing method" );
+	    wait();
+	}
+    }
+
+    sc_event                       m_dummy;    // dummy event to wait on.
+    sc_method_handle               m_method;   // method to be invoked.
+    std::vector<sc_process_handle> m_invokers; // list of invoking threads.
+};
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_simcontext
+//
+//  The simulation context.
+// ----------------------------------------------------------------------------
+
+void
+sc_simcontext::init()
+{
+
+    // ALLOCATE VARIOUS MANAGERS AND REGISTRIES:
+
+    m_object_manager = new sc_object_manager;
+    m_module_registry = new sc_module_registry( *this );
+    m_port_registry = new sc_port_registry( *this );
+    m_export_registry = new sc_export_registry( *this );
+    m_prim_channel_registry = new sc_prim_channel_registry( *this );
+    m_phase_cb_registry = new sc_phase_callback_registry( *this );
+    m_name_gen = new sc_name_gen;
+    m_process_table = new sc_process_table;
+    m_current_writer = 0;
+
+
+    // CHECK FOR ENVIRONMENT VARIABLES THAT MODIFY SIMULATOR EXECUTION:
+
+    const char* write_check = std::getenv("SC_SIGNAL_WRITE_CHECK");
+    m_write_check = ( (write_check==0) || strcmp(write_check,"DISABLE") ) ?
+      true : false;
+
+
+    // FINISH INITIALIZATIONS:
+
+    reset_curr_proc();
+    m_next_proc_id = -1;
+    m_timed_events = new sc_ppq<sc_event_timed*>( 128, sc_notify_time_compare );
+    m_something_to_trace = false;
+    m_runnable = new sc_runnable;
+    m_collectable = new sc_process_list;
+    m_time_params = new sc_time_params;
+    m_curr_time = SC_ZERO_TIME;
+    m_max_time = SC_ZERO_TIME;
+    m_change_stamp = 0;
+    m_delta_count = 0;
+    m_forced_stop = false;
+    m_paused = false;
+    m_ready_to_simulate = false;
+    m_elaboration_done = false;
+    m_execution_phase = phase_initialize;
+    m_error = NULL;
+    m_cor_pkg = 0;
+    m_method_invoker_p = NULL;
+    m_cor = 0;
+    m_in_simulator_control = false;
+    m_start_of_simulation_called = false;
+    m_end_of_simulation_called = false;
+    m_simulation_status = SC_ELABORATION;
+}
+
+void
+sc_simcontext::clean()
+{
+    delete m_object_manager;
+    delete m_module_registry;
+    delete m_port_registry;
+    delete m_export_registry;
+    delete m_prim_channel_registry;
+    delete m_phase_cb_registry;
+    delete m_name_gen;
+    delete m_process_table;
+    m_child_objects.resize(0);
+    m_delta_events.resize(0);
+    delete m_timed_events;
+    for( int i = m_trace_files.size() - 1; i >= 0; -- i ) {
+	delete m_trace_files[i];
+    }
+    m_trace_files.resize(0);
+    delete m_runnable;
+    delete m_collectable;
+    delete m_time_params;
+    delete m_cor_pkg;
+    delete m_error;
+}
+
+
+sc_simcontext::sc_simcontext() :
+    m_object_manager(0), m_module_registry(0), m_port_registry(0),
+    m_export_registry(0), m_prim_channel_registry(0),
+    m_phase_cb_registry(0), m_name_gen(0),
+    m_process_table(0), m_curr_proc_info(), m_current_writer(0),
+    m_write_check(false), m_next_proc_id(-1), m_child_events(),
+    m_child_objects(), m_delta_events(), m_timed_events(0), m_trace_files(),
+    m_something_to_trace(false), m_runnable(0), m_collectable(0), 
+    m_time_params(), m_curr_time(SC_ZERO_TIME), m_max_time(SC_ZERO_TIME), 
+    m_change_stamp(0), m_delta_count(0), m_forced_stop(false), m_paused(false),
+    m_ready_to_simulate(false), m_elaboration_done(false),
+    m_execution_phase(phase_initialize), m_error(0),
+    m_in_simulator_control(false), m_end_of_simulation_called(false),
+    m_simulation_status(SC_ELABORATION), m_start_of_simulation_called(false),
+    m_cor_pkg(0), m_cor(0)
+{
+    init();
+}
+
+sc_simcontext::~sc_simcontext()
+{
+    clean();
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_simcontext::active_object"
+// | 
+// | This method returns the currently active object with respect to 
+// | additions to the hierarchy. It will be the top of the object hierarchy
+// | stack if it is non-empty, or it will be the active process, or NULL 
+// | if there is no active process.
+// +----------------------------------------------------------------------------
+sc_object*
+sc_simcontext::active_object() 
+{
+    sc_object* result_p; // pointer to return.
+
+    result_p = m_object_manager->hierarchy_curr();
+    if ( !result_p )
+        result_p = (sc_object*)get_curr_proc_info()->process_handle;
+    return result_p;
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_simcontext::crunch"
+// | 
+// | This method implements the simulator's execution of processes. It performs
+// | one or more "delta" cycles. Each delta cycle consists of an evaluation,
+// | an update phase, and a notification phase. During the evaluation phase any 
+// | processes that are ready to run are executed. After all the processes have
+// | been executed the update phase is entered. During the update phase the 
+// | values of any signals that have changed are updated. After the updates
+// | have been performed the notification phase is entered. During that phase
+// | any notifications that need to occur because of of signal values changes
+// | are performed. This will result in the queueing of processes for execution
+// | that are sensitive to those notifications. At that point a delta cycle
+// | is complete, and the process is started again unless 'once' is true.
+// |
+// | Arguments:
+// |     once = true if only one delta cycle is to be performed.
+// +----------------------------------------------------------------------------
+inline void
+sc_simcontext::crunch( bool once )
+{
+#ifdef DEBUG_SYSTEMC
+    int num_deltas = 0;  // number of delta cycles
+#endif
+
+    while ( true ) 
+    {
+
+	// EVALUATE PHASE
+	
+	m_execution_phase = phase_evaluate;
+	bool empty_eval_phase = true;
+	while( true ) 
+	{
+
+	    // execute method processes
+
+	    m_runnable->toggle_methods();
+	    sc_method_handle method_h = pop_runnable_method();
+	    while( method_h != 0 ) {
+		empty_eval_phase = false;
+		if ( !method_h->run_process() )
+		{
+		    goto out;
+		}
+		method_h = pop_runnable_method();
+	    }
+
+	    // execute (c)thread processes
+
+	    m_runnable->toggle_threads();
+	    sc_thread_handle thread_h = pop_runnable_thread();
+	    while( thread_h != 0 ) {
+                if ( thread_h->m_cor_p != NULL ) break;
+		thread_h = pop_runnable_thread();
+	    }
+
+	    if( thread_h != 0 ) {
+	        empty_eval_phase = false;
+		m_cor_pkg->yield( thread_h->m_cor_p );
+	    }
+	    if( m_error ) {
+		goto out;
+	    }
+
+	    // check for call(s) to sc_stop
+	    if( m_forced_stop ) {
+		if ( stop_mode == SC_STOP_IMMEDIATE ) goto out;
+	    }
+
+	    // no more runnable processes
+
+	    if( m_runnable->is_empty() ) {
+		break;
+	    }
+	}
+
+	// remove finally dead zombies:
+
+        while( ! m_collectable->empty() )
+        {
+	    sc_process_b* del_p = m_collectable->front();
+	    m_collectable->pop_front();
+	    del_p->reference_decrement();
+        }
+
+
+	// UPDATE PHASE
+	//
+	// The change stamp must be updated first so that event_occurred()
+	// will work.
+
+	m_execution_phase = phase_update;
+	if ( !empty_eval_phase ) 
+	{
+//	    SC_DO_PHASE_CALLBACK_(evaluation_done);
+	    m_change_stamp++;
+	    m_delta_count ++;
+	}
+	m_prim_channel_registry->perform_update();
+	SC_DO_PHASE_CALLBACK_(update_done);
+	m_execution_phase = phase_notify;
+
+#if SC_SIMCONTEXT_TRACING_
+	if( m_something_to_trace ) {
+	    trace_cycle( /* delta cycle? */ true );
+	}
+#endif
+
+        // check for call(s) to sc_stop
+        if( m_forced_stop ) {
+            break;
+        }
+
+#ifdef DEBUG_SYSTEMC
+        // check for possible infinite loops
+        if( ++ num_deltas > SC_MAX_NUM_DELTA_CYCLES ) {
+	    ::std::cerr << "SystemC warning: "
+		 << "the number of delta cycles exceeds the limit of "
+		 << SC_MAX_NUM_DELTA_CYCLES
+		 << ", defined in sc_constants.h.\n"
+		 << "This is a possible sign of an infinite loop.\n"
+		 << "Increase the limit if this warning is invalid.\n";
+	    break;
+	}
+#endif
+
+	// NOTIFICATION PHASE:
+	//
+	// Process delta notifications which will queue processes for 
+	// subsequent execution.
+
+        int size = m_delta_events.size();
+	if ( size != 0 )
+	{
+	    sc_event** l_events = &m_delta_events[0];
+	    int i = size - 1;
+	    do {
+		l_events[i]->trigger();
+	    } while( -- i >= 0 );
+	    m_delta_events.resize(0);
+	}
+
+	if( m_runnable->is_empty() ) {
+	    // no more runnable processes
+	    break;
+	}
+
+	// if sc_pause() was called we are done.
+
+	if ( m_paused ) break;
+
+        // IF ONLY DOING ONE CYCLE, WE ARE DONE. OTHERWISE EXECUTE NEW CALLBACKS
+
+        if ( once ) break;
+    }
+
+    // When this point is reached the processing of delta cycles is complete,
+    // if the completion was because of an error throw the exception specified
+    // by '*m_error'.
+out:
+    this->reset_curr_proc();
+    if( m_error ) throw *m_error; // re-throw propagated error
+}
+
+inline
+void
+sc_simcontext::cycle( const sc_time& t)
+{
+    sc_time next_event_time;
+
+    m_in_simulator_control = true;
+    crunch(); 
+    SC_DO_PHASE_CALLBACK_(before_timestep);
+#if SC_SIMCONTEXT_TRACING_
+    if( m_something_to_trace ) {
+        trace_cycle( /* delta cycle? */ false );
+    }
+#endif
+    m_curr_time += t;
+    if ( next_time(next_event_time) && next_event_time <= m_curr_time) {
+        SC_REPORT_WARNING(SC_ID_CYCLE_MISSES_EVENTS_, "");
+    }
+    m_in_simulator_control = false;
+    SC_DO_PHASE_CALLBACK_(simulation_paused);
+}
+
+void
+sc_simcontext::elaborate()
+{
+    if( m_elaboration_done || sim_status() != SC_SIM_OK ) {
+        return;
+    }
+
+    // Instantiate the method invocation module
+    // (not added to public object hierarchy)
+
+    m_method_invoker_p =
+      new sc_invoke_method("$$$$kernel_module$$$$_invoke_method" );
+
+    m_simulation_status = SC_BEFORE_END_OF_ELABORATION;
+    for( int cd = 0; cd != 4; /* empty */ )
+    {
+        cd  = m_port_registry->construction_done();
+        cd += m_export_registry->construction_done();
+        cd += m_prim_channel_registry->construction_done();
+        cd += m_module_registry->construction_done();
+
+        // check for call(s) to sc_stop
+        if( m_forced_stop ) {
+            do_sc_stop_action();
+            return;
+        }
+
+    }
+    SC_DO_PHASE_CALLBACK_(construction_done);
+
+    // SIGNAL THAT ELABORATION IS DONE
+    //
+    // We set the switch before the calls in case someone creates a process 
+    // in an end_of_elaboration callback. We need the information to flag 
+    // the process as being dynamic.
+
+    m_elaboration_done = true;
+    m_simulation_status = SC_END_OF_ELABORATION;
+
+    m_port_registry->elaboration_done();
+    m_export_registry->elaboration_done();
+    m_prim_channel_registry->elaboration_done();
+    m_module_registry->elaboration_done();
+    SC_DO_PHASE_CALLBACK_(elaboration_done);
+    sc_reset::reconcile_resets();
+
+    // check for call(s) to sc_stop
+    if( m_forced_stop ) {
+        do_sc_stop_action();
+        return;
+    }
+}
+
+void
+sc_simcontext::prepare_to_simulate()
+{
+    sc_method_handle  method_p;  // Pointer to method process accessing.
+    sc_thread_handle  thread_p;  // Pointer to thread process accessing.
+
+    if( m_ready_to_simulate || sim_status() != SC_SIM_OK ) {
+        return;
+    }
+
+    // instantiate the coroutine package
+    m_cor_pkg = new sc_cor_pkg_t( this );
+    m_cor = m_cor_pkg->get_main();
+
+    // NOTIFY ALL OBJECTS THAT SIMULATION IS ABOUT TO START:
+
+    m_simulation_status = SC_START_OF_SIMULATION;
+    m_port_registry->start_simulation();
+    m_export_registry->start_simulation();
+    m_prim_channel_registry->start_simulation();
+    m_module_registry->start_simulation();
+    SC_DO_PHASE_CALLBACK_(start_simulation);
+    m_start_of_simulation_called = true;
+
+    // CHECK FOR CALL(S) TO sc_stop 
+
+    if( m_forced_stop ) {
+        do_sc_stop_action();
+        return;
+    }
+
+    // PREPARE ALL (C)THREAD PROCESSES FOR SIMULATION:
+
+    for ( thread_p = m_process_table->thread_q_head(); 
+	  thread_p; thread_p = thread_p->next_exist() )
+    {
+	thread_p->prepare_for_simulation();
+    }
+
+    m_simulation_status = SC_RUNNING;
+    m_ready_to_simulate = true;
+    m_runnable->init();
+
+    // update phase
+
+    m_execution_phase = phase_update;
+    m_prim_channel_registry->perform_update();
+    m_execution_phase = phase_notify;
+
+    int size;
+
+    // make all method processes runnable
+
+    for ( method_p = m_process_table->method_q_head(); 
+	  method_p; method_p = method_p->next_exist() )
+    {
+	if ( ((method_p->m_state & sc_process_b::ps_bit_disabled) != 0) ||
+	     method_p->dont_initialize() ) 
+	{
+	    if ( method_p->m_static_events.size() == 0 )
+	    {
+	        SC_REPORT_WARNING( SC_ID_DISABLE_WILL_ORPHAN_PROCESS_, 
+		                   method_p->name() );
+	    }
+	}
+	else if ( (method_p->m_state & sc_process_b::ps_bit_suspended) == 0) 
+	{
+	    push_runnable_method_front( method_p );
+        }
+	else
+	{
+	    method_p->m_state |= sc_process_b::ps_bit_ready_to_run;
+	}
+    }
+
+    // make thread processes runnable
+    // (cthread processes always have the dont_initialize flag set)
+
+    for ( thread_p = m_process_table->thread_q_head(); 
+	  thread_p; thread_p = thread_p->next_exist() )
+    {
+	if ( ((thread_p->m_state & sc_process_b::ps_bit_disabled) != 0) || 
+	     thread_p->dont_initialize() ) 
+	{
+	    if ( thread_p->m_static_events.size() == 0 )
+	    {
+	        SC_REPORT_WARNING( SC_ID_DISABLE_WILL_ORPHAN_PROCESS_, 
+		                   thread_p->name() );
+	    }
+	}
+	else if ( (thread_p->m_state & sc_process_b::ps_bit_suspended) == 0) 
+	{
+            push_runnable_thread_front( thread_p );
+        }
+	else
+	{
+	    thread_p->m_state |= sc_process_b::ps_bit_ready_to_run;
+	}
+    }
+
+
+    // process delta notifications
+
+    if( ( size = m_delta_events.size() ) != 0 ) {
+        sc_event** l_delta_events = &m_delta_events[0];
+        int i = size - 1;
+        do {
+            l_delta_events[i]->trigger();
+        } while( -- i >= 0 );
+        m_delta_events.resize(0);
+    }
+
+    SC_DO_PHASE_CALLBACK_(initialization_done);
+}
+
+void
+sc_simcontext::initial_crunch( bool no_crunch )
+{
+    if( no_crunch || m_runnable->is_empty() ) {
+        return;
+    }
+
+    // run the delta cycle loop
+
+    crunch();
+    if( m_error ) {
+        return;
+    }
+
+#if SC_SIMCONTEXT_TRACING_
+    if( m_something_to_trace ) {
+        trace_cycle( false );
+    }
+#endif
+
+    // check for call(s) to sc_stop
+    if( m_forced_stop ) {
+        do_sc_stop_action();
+    }
+}
+
+void
+sc_simcontext::initialize( bool no_crunch )
+{
+    m_in_simulator_control = true;
+    elaborate();
+
+    prepare_to_simulate();
+    initial_crunch(no_crunch);
+    m_in_simulator_control = false;
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_simcontext::simulate"
+// | 
+// | This method runs the simulation for the specified amount of time.
+// |
+// | Notes:
+// |   (1) This code always run with an SC_EXIT_ON_STARVATION starvation policy,
+// |       so the simulation time on return will be the minimum of the 
+// |       simulation on entry plus the duration, and the maximum time of any 
+// |       event present in the simulation. If the simulation policy is
+// |       SC_RUN_TO_TIME starvation it is implemented by the caller of this 
+// |       method, e.g., sc_start(), by artificially setting the simulation
+// |       time forward after this method completes.
+// |
+// | Arguments:
+// |     duration = amount of time to simulate.
+// +----------------------------------------------------------------------------
+void
+sc_simcontext::simulate( const sc_time& duration )
+{
+    initialize( true );
+
+    if (sim_status() != SC_SIM_OK) {
+	return;
+    }
+
+    sc_time non_overflow_time = sc_max_time() - m_curr_time;
+    if ( duration > non_overflow_time )
+    {
+	SC_REPORT_ERROR(SC_ID_SIMULATION_TIME_OVERFLOW_, "");
+	return;
+    }
+    else if ( duration < SC_ZERO_TIME )
+    {
+        SC_REPORT_ERROR(SC_ID_NEGATIVE_SIMULATION_TIME_,"");
+    }
+
+    m_in_simulator_control = true;
+    m_paused = false;
+
+    sc_time until_t = m_curr_time + duration;
+    sc_time t;            // current simulaton time.
+
+    // IF DURATION WAS ZERO WE ONLY CRUNCH ONCE:
+    //
+    // We duplicate the code so that we don't add the overhead of the
+    // check to each loop in the do below.
+    if ( duration == SC_ZERO_TIME ) 
+    {
+	m_in_simulator_control = true;
+  	crunch( true );
+	if( m_error ) {
+	    m_in_simulator_control = false;
+	    return;
+	}
+#if SC_SIMCONTEXT_TRACING_
+        if( m_something_to_trace )
+            trace_cycle( /* delta cycle? */ false );
+#endif
+        if( m_forced_stop ) {
+            do_sc_stop_action();
+            return;
+        }
+        // return via implicit pause
+        goto exit_pause;
+    }
+
+    // NON-ZERO DURATION: EXECUTE UP TO THAT TIME, OR UNTIL EVENT STARVATION:
+
+    do {
+
+	crunch();
+	if( m_error ) {
+	    m_in_simulator_control = false;
+	    return;
+	}
+#if SC_SIMCONTEXT_TRACING_
+	if( m_something_to_trace ) {
+	    trace_cycle( false );
+	}
+#endif
+        // check for call(s) to sc_stop() or sc_pause().
+        if( m_forced_stop ) {
+            do_sc_stop_action();
+            return;
+        }
+        if( m_paused ) goto exit_pause; // return explicit pause
+
+	t = m_curr_time; 
+
+	do {
+	    // See note 1 above:
+
+            if ( !next_time(t) || (t > until_t ) ) goto exit_time;
+	    if ( t > m_curr_time ) 
+	    {
+		SC_DO_PHASE_CALLBACK_(before_timestep);
+		m_curr_time = t;
+		m_change_stamp++;
+	    }
+
+	    // PROCESS TIMED NOTIFICATIONS AT THE CURRENT TIME
+
+	    do {
+		sc_event_timed* et = m_timed_events->extract_top();
+		sc_event* e = et->event();
+		delete et;
+		if( e != 0 ) {
+		    e->trigger();
+		}
+	    } while( m_timed_events->size() &&
+		     m_timed_events->top()->notify_time() == t );
+
+	} while( m_runnable->is_empty() );
+    } while ( t < until_t ); // hold off on the delta for the until_t time.
+
+exit_time:  // final simulation time update, if needed
+    if ( t > m_curr_time && t <= until_t ) 
+    {
+        SC_DO_PHASE_CALLBACK_(before_timestep);
+        m_curr_time = t;
+        m_change_stamp++;
+    }
+exit_pause: // call pause callback upon implicit or explicit pause
+    m_execution_phase      = phase_evaluate;
+    m_in_simulator_control = false;
+    SC_DO_PHASE_CALLBACK_(simulation_paused);
+}
+
+void
+sc_simcontext::do_sc_stop_action()
+{
+    SC_REPORT_INFO("/OSCI/SystemC","Simulation stopped by user.");
+    if (m_start_of_simulation_called) {
+	end();
+	m_in_simulator_control = false;
+    }
+    m_simulation_status = SC_STOPPED;
+    SC_DO_PHASE_CALLBACK_(simulation_stopped);
+}
+
+void
+sc_simcontext::mark_to_collect_process( sc_process_b* zombie )
+{
+    m_collectable->push_back( zombie );
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_simcontext::stop"
+//
+// This method stops the simulator after some amount of further processing.
+// How much processing is done depends upon the value of the global variable
+// stop_mode:
+//     SC_STOP_IMMEDIATE - aborts the execution phase of the current delta
+//                         cycle and performs whatever updates are pending.
+//     SC_STOP_FINISH_DELTA - finishes the current delta cycle - both execution
+//                            and updates.
+// If sc_stop is called outside of the purview of the simulator kernel 
+// (e.g., directly from sc_main), the end of simulation notifications 
+// are performed. From within the purview of the simulator kernel, these
+// will be performed at a later time.
+//------------------------------------------------------------------------------
+
+void
+sc_simcontext::stop()
+{
+    static bool stop_warning_issued = false;
+    if (m_forced_stop)
+    {
+        if ( !stop_warning_issued )
+        {
+            stop_warning_issued = true; // This must be before the WARNING!!!
+            SC_REPORT_WARNING(SC_ID_SIMULATION_STOP_CALLED_TWICE_, "");
+        }
+        return;
+    }
+    if ( stop_mode == SC_STOP_IMMEDIATE ) m_runnable->init();
+    m_forced_stop = true;
+    if ( !m_in_simulator_control  )
+    {
+        do_sc_stop_action();
+    } 
+}
+
+void
+sc_simcontext::reset()
+{
+    clean();
+    init();
+}
+
+void
+sc_simcontext::end()
+{
+    m_simulation_status = SC_END_OF_SIMULATION;
+    m_ready_to_simulate = false;
+    m_port_registry->simulation_done();
+    m_export_registry->simulation_done();
+    m_prim_channel_registry->simulation_done();
+    m_module_registry->simulation_done();
+    SC_DO_PHASE_CALLBACK_(simulation_done);
+    m_end_of_simulation_called = true;
+}
+
+void
+sc_simcontext::hierarchy_push( sc_module* mod )
+{
+    m_object_manager->hierarchy_push( mod );
+}
+
+sc_module*
+sc_simcontext::hierarchy_pop()
+{
+	return static_cast<sc_module*>( m_object_manager->hierarchy_pop() );
+}
+
+sc_module*
+sc_simcontext::hierarchy_curr() const
+{
+    return static_cast<sc_module*>( m_object_manager->hierarchy_curr() );
+}
+    
+sc_object*
+sc_simcontext::first_object()
+{
+    return m_object_manager->first_object();
+}
+
+sc_object*
+sc_simcontext::next_object()
+{
+    return m_object_manager->next_object();
+}
+
+sc_object*
+sc_simcontext::find_object( const char* name )
+{
+    static bool warn_find_object=true;
+    if ( warn_find_object )
+    {
+	warn_find_object = false;
+	SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
+	    "sc_simcontext::find_object() is deprecated,\n" \
+            " use sc_find_object()" );
+    }
+    return m_object_manager->find_object( name );
+}
+
+// to generate unique names for objects in an MT-Safe way
+
+const char*
+sc_simcontext::gen_unique_name( const char* basename_, bool preserve_first )
+{
+    return m_name_gen->gen_unique_name( basename_, preserve_first );
+}
+
+
+sc_process_handle 
+sc_simcontext::create_cthread_process( 
+    const char* name_p, bool free_host, SC_ENTRY_FUNC method_p,         
+    sc_process_host* host_p, const sc_spawn_options* opt_p )
+{
+    sc_thread_handle handle = 
+        new sc_cthread_process(name_p, free_host, method_p, host_p, opt_p);
+    if ( m_ready_to_simulate ) 
+    {
+	handle->prepare_for_simulation();
+    } else {
+	m_process_table->push_front( handle );
+    }
+    return sc_process_handle(handle);
+}
+
+
+sc_process_handle 
+sc_simcontext::create_method_process( 
+    const char* name_p, bool free_host, SC_ENTRY_FUNC method_p,         
+    sc_process_host* host_p, const sc_spawn_options* opt_p )
+{
+    sc_method_handle handle = 
+        new sc_method_process(name_p, free_host, method_p, host_p, opt_p);
+    if ( m_ready_to_simulate ) { // dynamic process
+	if ( !handle->dont_initialize() )
+        {
+#ifdef SC_HAS_PHASE_CALLBACKS_
+            if( SC_UNLIKELY_( m_simulation_status
+                            & (SC_END_OF_UPDATE|SC_BEFORE_TIMESTEP) ) )
+            {
+                std::stringstream msg;
+                msg << m_simulation_status 
+                    << ":\n\t immediate method spawning of "
+                       "`" << handle->name() << "' ignored";
+                SC_REPORT_WARNING( SC_ID_PHASE_CALLBACK_FORBIDDEN_
+                                 , msg.str().c_str() );
+            }
+            else
+#endif // SC_HAS_PHASE_CALLBACKS_
+            {
+                push_runnable_method( handle );
+            }
+        }
+        else if ( handle->m_static_events.size() == 0 )
+        {
+            SC_REPORT_WARNING( SC_ID_DISABLE_WILL_ORPHAN_PROCESS_,
+                               handle->name() );
+        }
+
+    } else {
+	m_process_table->push_front( handle );
+    }
+    return sc_process_handle(handle);
+}
+
+
+sc_process_handle 
+sc_simcontext::create_thread_process( 
+    const char* name_p, bool free_host, SC_ENTRY_FUNC method_p,         
+    sc_process_host* host_p, const sc_spawn_options* opt_p )
+{
+    sc_thread_handle handle = 
+        new sc_thread_process(name_p, free_host, method_p, host_p, opt_p);
+    if ( m_ready_to_simulate ) { // dynamic process
+	handle->prepare_for_simulation();
+        if ( !handle->dont_initialize() )
+        {
+#ifdef SC_HAS_PHASE_CALLBACKS_
+            if( SC_UNLIKELY_( m_simulation_status
+                            & (SC_END_OF_UPDATE|SC_BEFORE_TIMESTEP) ) )
+            {
+                std::stringstream msg;
+                msg << m_simulation_status 
+                    << ":\n\t immediate thread spawning of "
+                       "`" << handle->name() << "' ignored";
+                SC_REPORT_WARNING( SC_ID_PHASE_CALLBACK_FORBIDDEN_
+                                 , msg.str().c_str() );
+            }
+            else
+#endif // SC_HAS_PHASE_CALLBACKS_
+            {
+                push_runnable_thread( handle );
+            }
+        }
+        else if ( handle->m_static_events.size() == 0 )
+        {
+            SC_REPORT_WARNING( SC_ID_DISABLE_WILL_ORPHAN_PROCESS_,
+                               handle->name() );
+        }
+
+    } else {
+	m_process_table->push_front( handle );
+    }
+    return sc_process_handle(handle);
+}
+
+void
+sc_simcontext::add_trace_file( sc_trace_file* tf )
+{
+    m_trace_files.push_back( tf );
+    m_something_to_trace = true;
+}
+
+void
+sc_simcontext::remove_trace_file( sc_trace_file* tf )
+{
+    m_trace_files.erase(
+        std::remove( m_trace_files.begin(), m_trace_files.end(), tf )
+    );
+    m_something_to_trace = ( m_trace_files.size() > 0 );
+}
+
+sc_cor*
+sc_simcontext::next_cor()
+{
+    if( m_error ) {
+	return m_cor;
+    }
+    
+    sc_thread_handle thread_h = pop_runnable_thread();
+    while( thread_h != 0 ) {
+	if ( thread_h->m_cor_p != NULL ) break;
+	thread_h = pop_runnable_thread();
+    }
+    
+    if( thread_h != 0 ) {
+	return thread_h->m_cor_p;
+    } else {
+	return m_cor;
+    }
+}
+
+const ::std::vector<sc_object*>&
+sc_simcontext::get_child_objects() const
+{
+    static bool warn_get_child_objects=true;
+    if ( warn_get_child_objects )
+    {
+	warn_get_child_objects = false;
+	SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
+	    "sc_simcontext::get_child_objects() is deprecated,\n" \
+            " use sc_get_top_level_objects()" );
+    }
+    return m_child_objects;
+}
+
+void
+sc_simcontext::add_child_event( sc_event* event_ )
+{
+    // no check if object_ is already in the set
+    m_child_events.push_back( event_ );
+}
+
+void
+sc_simcontext::add_child_object( sc_object* object_ )
+{
+    // no check if object_ is already in the set
+    m_child_objects.push_back( object_ );
+}
+
+void
+sc_simcontext::remove_child_event( sc_event* event_ )
+{
+    int size = m_child_events.size();
+    for( int i = 0; i < size; ++ i ) {
+	if( event_ == m_child_events[i] ) {
+	    m_child_events[i] = m_child_events[size - 1];
+	    m_child_events.resize(size-1);
+	    return;
+	}
+    }
+    // no check if event_ is really in the set
+}
+
+void
+sc_simcontext::remove_child_object( sc_object* object_ )
+{
+    int size = m_child_objects.size();
+    for( int i = 0; i < size; ++ i ) {
+	if( object_ == m_child_objects[i] ) {
+	    m_child_objects[i] = m_child_objects[size - 1];
+	    m_child_objects.resize(size-1);
+	    return;
+	}
+    }
+    // no check if object_ is really in the set
+}
+
+sc_dt::uint64
+sc_simcontext::delta_count() const
+{
+    static bool warn_delta_count=true;
+    if ( warn_delta_count )
+    {
+	warn_delta_count = false;
+	SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
+	    "sc_simcontext::delta_count() is deprecated, use sc_delta_count()" );
+    }
+    return m_delta_count;
+}
+
+bool
+sc_simcontext::is_running() const
+{
+    static bool warn_is_running=true;
+    if ( warn_is_running )
+    {
+	warn_is_running = false;
+	SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
+	    "sc_simcontext::is_running() is deprecated, use sc_is_running()" );
+    }
+    return m_ready_to_simulate;
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_simcontext::next_time"
+// | 
+// | This method returns the time of the next event. If there are no events
+// | it returns false.
+// | 
+// | Arguments:
+// |     result = where to place time of the next event, if no event is 
+// |              found this value will not be changed.
+// | Result is true if an event is found, false if not.
+// +----------------------------------------------------------------------------
+bool
+sc_simcontext::next_time( sc_time& result ) const
+{
+    while( m_timed_events->size() ) {
+	sc_event_timed* et = m_timed_events->top();
+	if( et->event() != 0 ) {
+	    result = et->notify_time();
+	    return true;
+	}
+	delete m_timed_events->extract_top();
+    }
+    return false;
+}
+
+void
+sc_simcontext::remove_delta_event( sc_event* e )
+{
+    int i = e->m_delta_event_index;
+    int j = m_delta_events.size() - 1;
+    assert( i >= 0 && i <= j );
+    if( i != j ) {
+	sc_event** l_delta_events = &m_delta_events[0];
+	l_delta_events[i] = l_delta_events[j];
+	l_delta_events[i]->m_delta_event_index = i;
+    }
+    m_delta_events.resize(m_delta_events.size()-1);
+    e->m_delta_event_index = -1;
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_simcontext::preempt_with"
+// | 
+// | This method executes the supplied method immediately, suspending the
+// | caller. After executing the supplied method the caller's execution will
+// | be restored. It is used to allow a method to immediately throw an 
+// | exception, e.g., when the method's kill_process() method was called.
+// | There are three cases to consider:
+// |   (1) The caller is a method, e.g., murder by method.
+// |   (2) The caller is a thread instance, e.g., murder by thread.
+// |   (3) The caller is this method instance, e.g., suicide.
+// |
+// | Arguments:
+// |     method_h -> method to be executed.
+// +----------------------------------------------------------------------------
+void 
+sc_simcontext::preempt_with( sc_method_handle method_h )
+{
+    sc_curr_proc_info caller_info;     // process info for caller.
+    sc_method_handle  active_method_h; // active method or null.
+    sc_thread_handle  active_thread_h; // active thread or null.
+
+    // Determine the active process and take the thread to be run off the
+    // run queue, if its there, since we will be explicitly causing its 
+    // execution.
+
+    active_method_h = DCAST<sc_method_handle>(sc_get_current_process_b());
+    active_thread_h = DCAST<sc_thread_handle>(sc_get_current_process_b());
+    if ( method_h->next_runnable() != NULL )
+	remove_runnable_method( method_h );
+
+    // CALLER IS THE METHOD TO BE RUN:
+    //
+    // Should never get here, ignore it unless we are debugging.
+
+    if ( method_h == active_method_h )
+    {
+        DEBUG_MSG(DEBUG_NAME,method_h,"self preemption of active method");
+    }
+
+    // THE CALLER IS A METHOD:
+    //
+    //   (a) Set the current process information to our method.
+    //   (b) Invoke our method directly by-passing the run queue.
+    //   (c) Restore the process info to the caller.
+    //   (d) Check to see if the calling method should throw an exception
+    //       because of activity that occurred during the preemption.
+
+    else if ( active_method_h != NULL )
+    {
+	caller_info = m_curr_proc_info;
+        DEBUG_MSG( DEBUG_NAME, method_h,
+	           "preempting active method with method" );
+	sc_get_curr_simcontext()->set_curr_proc( (sc_process_b*)method_h );
+	method_h->run_process();
+	sc_get_curr_simcontext()->set_curr_proc((sc_process_b*)active_method_h);
+	active_method_h->check_for_throws();
+    }
+
+    // CALLER IS A THREAD:
+    //
+    //   (a) Use an invocation thread to execute the method.
+
+    else if ( active_thread_h != NULL )
+    {
+        DEBUG_MSG( DEBUG_NAME, method_h,
+	           "preempting active thread with method" );
+	m_method_invoker_p->invoke_method(method_h);
+    }
+
+    // CALLER IS THE SIMULATOR:
+    //
+    // That is not allowed.
+
+    else
+    {
+	caller_info = m_curr_proc_info;
+        DEBUG_MSG( DEBUG_NAME, method_h,
+	           "preempting no active process with method" );
+	sc_get_curr_simcontext()->set_curr_proc( (sc_process_b*)method_h );
+	method_h->run_process();
+	m_curr_proc_info = caller_info;
+    }
+}
+
+//------------------------------------------------------------------------------
+//"sc_simcontext::requeue_current_process"
+//
+// This method requeues the current process at the beginning of the run queue
+// if it is a thread. This is called by sc_process_handle::throw_it() to assure
+// that a thread that is issuing a throw will execute immediately after the
+// processes it notifies via the throw.
+//------------------------------------------------------------------------------
+void sc_simcontext::requeue_current_process()
+{
+    sc_thread_handle thread_p;
+    thread_p = DCAST<sc_thread_handle>(get_curr_proc_info()->process_handle);
+    if ( thread_p )
+    {
+	execute_thread_next( thread_p );
+    }
+}
+
+//------------------------------------------------------------------------------
+//"sc_simcontext::suspend_current_process"
+//
+// This method suspends the current process if it is a thread. This is called 
+// by sc_process_handle::throw_it() to allow the processes that have received
+// a throw to execute.
+//------------------------------------------------------------------------------
+void sc_simcontext::suspend_current_process()
+{
+    sc_thread_handle thread_p;
+    thread_p = DCAST<sc_thread_handle>(get_curr_proc_info()->process_handle);
+    if ( thread_p )
+    {
+	thread_p->suspend_me(); 
+    }
+}
+
+void
+sc_simcontext::trace_cycle( bool delta_cycle )
+{
+    int size;
+    if( ( size = m_trace_files.size() ) != 0 ) {
+	sc_trace_file** l_trace_files = &m_trace_files[0];
+	int i = size - 1;
+	do {
+	    l_trace_files[i]->cycle( delta_cycle );
+	} while( -- i >= 0 );
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#if 1
+#ifdef PURIFY
+	static sc_simcontext sc_default_global_context;
+	sc_simcontext* sc_curr_simcontext = &sc_default_global_context;
+#else
+	sc_simcontext* sc_curr_simcontext = 0;
+	sc_simcontext* sc_default_global_context = 0;
+#endif
+#else
+// Not MT-safe!
+static sc_simcontext* sc_curr_simcontext = 0;
+
+
+sc_simcontext*
+sc_get_curr_simcontext()
+{
+    if( sc_curr_simcontext == 0 ) {
+#ifdef PURIFY
+        static sc_simcontext sc_default_global_context;
+        sc_curr_simcontext = &sc_default_global_context;
+#else
+        static sc_simcontext* sc_default_global_context = new sc_simcontext;
+        sc_curr_simcontext = sc_default_global_context;
+#endif
+    }
+    return sc_curr_simcontext;
+}
+#endif // 0
+
+// Generates unique names within each module.
+
+const char*
+sc_gen_unique_name( const char* basename_, bool preserve_first )
+{
+    sc_simcontext* simc = sc_get_curr_simcontext();
+    sc_module* curr_module = simc->hierarchy_curr();
+    if( curr_module != 0 ) {
+	return curr_module->gen_unique_name( basename_, preserve_first );
+    } else {
+        sc_process_b* curr_proc_p = sc_get_current_process_b();
+	if ( curr_proc_p )
+	{
+	    return curr_proc_p->gen_unique_name( basename_, preserve_first );
+	}
+	else
+	{
+	    return simc->gen_unique_name( basename_, preserve_first );
+	}
+    }
+}
+
+// Get a handle for the current process
+//
+// Note that this method should not be called if the current process is
+// in the act of being deleted, it will mess up the reference count management
+// of sc_process_b instance the handle represents. Instead, use the a 
+// pointer to the raw sc_process_b instance, which may be acquired via
+// sc_get_current_process_b().
+
+sc_process_handle
+sc_get_current_process_handle()
+{
+    return ( sc_is_running() ) ?
+	sc_process_handle(sc_get_current_process_b()) : 
+	sc_get_last_created_process_handle();
+}
+
+// THE FOLLOWING FUNCTION IS DEPRECATED IN 2.1
+sc_process_b*
+sc_get_curr_process_handle()
+{
+    static bool warn=true;
+    if ( warn )
+    {
+        warn = false;
+        SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
+       "sc_get_curr_process_handle deprecated use sc_get_current_process_handle"
+       );
+    }
+
+    return sc_get_curr_simcontext()->get_curr_proc_info()->process_handle;
+}
+
+// Return indication if there are more processes to execute in this delta phase
+
+bool
+sc_simcontext::pending_activity_at_current_time() const
+{
+    return ( m_delta_events.size() != 0) ||
+           ( m_runnable->is_initialized() && !m_runnable->is_empty() ) ||
+           m_prim_channel_registry->pending_updates();
+}
+
+// Return time of next activity.
+
+sc_time sc_time_to_pending_activity( const sc_simcontext* simc_p ) 
+{
+    // If there is an activity pending at the current time
+    // return a delta of zero.
+    
+    sc_time result=SC_ZERO_TIME; // time of pending activity.
+
+    if ( simc_p->pending_activity_at_current_time() )
+    {
+        return result;
+    }
+
+    // Any activity will take place in the future pick up the next event's time.
+
+    else
+    {
+        result = simc_p->max_time();
+        simc_p->next_time(result);
+        result -= sc_time_stamp();
+    }
+    return result;
+}
+
+// Set the random seed for controlled randomization -- not yet implemented
+
+void
+sc_set_random_seed( unsigned int )
+{
+    SC_REPORT_WARNING( SC_ID_NOT_IMPLEMENTED_,
+		       "void sc_set_random_seed( unsigned int )" );
+}
+
+
+// +----------------------------------------------------------------------------
+// |"sc_start"
+// | 
+// | This function starts, or restarts, the execution of the simulator.
+// |
+// | Arguments:
+// |     duration = the amount of time the simulator should execute.
+// |     p        = event starvation policy.
+// +----------------------------------------------------------------------------
+void
+sc_start( const sc_time& duration, sc_starvation_policy p )
+{
+    sc_simcontext* context_p;      // current simulation context.
+    sc_time        entry_time;     // simulation time upon entry.
+    sc_time        exit_time;      // simulation time to set upon exit.
+    sc_dt::uint64  starting_delta; // delta count upon entry.
+    int            status;         // current simulation status.
+
+    // Set up based on the arguments passed to us:
+
+    context_p = sc_get_curr_simcontext();
+    starting_delta = sc_delta_count();
+    entry_time = context_p->m_curr_time;
+    if ( p == SC_RUN_TO_TIME )
+        exit_time = context_p->m_curr_time + duration;
+
+    // called with duration = SC_ZERO_TIME for the first time
+    static bool init_delta_or_pending_updates =
+         ( starting_delta == 0 && exit_time == SC_ZERO_TIME );
+
+    // If the simulation status is bad issue the appropriate message:
+
+    status = context_p->sim_status();
+    if( status != SC_SIM_OK ) 
+    {
+        if ( status == SC_SIM_USER_STOP )
+            SC_REPORT_ERROR(SC_ID_SIMULATION_START_AFTER_STOP_, "");
+        if ( status == SC_SIM_ERROR )
+            SC_REPORT_ERROR(SC_ID_SIMULATION_START_AFTER_ERROR_, "");
+        return;
+    }
+
+    if ( context_p->m_prim_channel_registry->pending_updates() )
+        init_delta_or_pending_updates = true;
+
+    // If the simulation status is good perform the simulation:
+
+    context_p->simulate( duration );
+
+    // Re-check the status:
+
+    status = context_p->sim_status();
+
+    // Update the current time to the exit time if that is the starvation
+    // policy:
+
+    if ( p == SC_RUN_TO_TIME && !context_p->m_paused && status == SC_SIM_OK )
+    {
+        context_p->m_curr_time = exit_time;
+    }
+
+    // If there was no activity and the simulation clock did not move warn
+    // the user, except if we're in a first sc_start(SC_ZERO_TIME) for
+    // initialisation (only) or there have been pending updates:
+
+    if ( !init_delta_or_pending_updates &&
+         starting_delta == sc_delta_count() &&
+         context_p->m_curr_time == entry_time &&
+         status == SC_SIM_OK )
+    {
+        SC_REPORT_WARNING(SC_ID_NO_SC_START_ACTIVITY_, "");
+    }
+
+    // reset init/update flag for subsequent calls
+    init_delta_or_pending_updates = false;
+}
+
+void
+sc_start()  
+{
+    sc_start( sc_max_time() - sc_time_stamp(),
+              SC_EXIT_ON_STARVATION );
+}
+
+// for backward compatibility with 1.0
+#if 0
+void
+sc_start( double duration )  // in default time units
+{
+    static bool warn_sc_start=true;
+    if ( warn_sc_start )
+    {
+	warn_sc_start = false;
+	SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
+	    "sc_start(double) deprecated, use sc_start(sc_time) or sc_start()");
+    }
+
+    if( duration == -1 )  // simulate forever
+    {
+        sc_start( 
+            sc_time(~sc_dt::UINT64_ZERO, false) - sc_time_stamp() );
+    }
+    else
+    {
+        sc_start( sc_time( duration, true ) );
+    }
+}
+#endif // 
+
+void
+sc_stop()
+{
+    sc_get_curr_simcontext()->stop();
+}
+
+
+// The following function is deprecated in favor of sc_start(SC_ZERO_TIME):
+
+void
+sc_initialize()
+{
+    static bool warning_initialize = true;
+
+    if ( warning_initialize )
+    {
+        warning_initialize = false;
+        SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
+	    "sc_initialize() is deprecated: use sc_start(SC_ZERO_TIME)" );
+    }
+    sc_get_curr_simcontext()->initialize();
+}
+
+// The following function has been deprecated in favor of sc_start(duration):
+
+void
+sc_cycle( const sc_time& duration )
+{
+    static bool warning_cycle = true;
+
+    if ( warning_cycle )
+    {
+        warning_cycle = false;
+        SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
+	    "sc_cycle is deprecated: use sc_start(sc_time)" );
+    }
+    sc_get_curr_simcontext()->cycle( duration );
+}
+
+sc_event* sc_find_event( const char* name )
+{
+    return sc_get_curr_simcontext()->get_object_manager()->find_event( name );
+}
+
+sc_object* sc_find_object( const char* name )
+{
+    return sc_get_curr_simcontext()->get_object_manager()->find_object( name );
+}
+
+
+const sc_time&
+sc_max_time()
+{
+    return sc_get_curr_simcontext()->max_time();
+}
+
+const sc_time&
+sc_time_stamp()
+{
+    return sc_get_curr_simcontext()->time_stamp();
+}
+
+double
+sc_simulation_time()
+{
+    static bool warn_simulation_time=true;
+    if ( warn_simulation_time )
+    {
+        warn_simulation_time=false;
+        SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
+	    "sc_simulation_time() is deprecated use sc_time_stamp()" );
+    }
+    return sc_get_curr_simcontext()->time_stamp().to_default_time_units();
+}
+
+void
+sc_defunct_process_function( sc_module* )
+{
+    // This function is pointed to by defunct sc_thread_process'es and
+    // sc_cthread_process'es. In a correctly constructed world, this
+    // function should never be called; hence the assert.
+    assert( false );
+}
+
+//------------------------------------------------------------------------------
+//"sc_set_stop_mode"
+//
+// This function sets the mode of operation when sc_stop() is called.
+//     mode = SC_STOP_IMMEDIATE or SC_STOP_FINISH_DELTA.
+//------------------------------------------------------------------------------
+void sc_set_stop_mode(sc_stop_mode mode)
+{
+    if ( sc_is_running() )
+    {
+        SC_REPORT_ERROR(SC_ID_STOP_MODE_AFTER_START_,"");
+    }
+    else
+    {
+        switch( mode )
+        {
+          case SC_STOP_IMMEDIATE:
+          case SC_STOP_FINISH_DELTA:
+              stop_mode = mode;
+              break;
+          default:
+              break;
+        }
+    }
+}
+
+sc_stop_mode
+sc_get_stop_mode()
+{
+    return stop_mode;
+}
+
+bool sc_is_unwinding()
+{ 
+    return sc_get_current_process_handle().is_unwinding();
+}
+
+// The IEEE 1666 Standard for 2011 designates that the treatment of
+// certain process control interactions as being "implementation dependent".
+// These interactions are:
+//   (1) What happens when a resume() call is performed on a disabled, 
+//       suspended process.
+//   (2) What happens when sync_reset_on() or sync_reset_off() is called
+//       on a suspended process.
+//   (3) What happens when the value specified in a reset_signal_is()
+//       call changes value while a process is suspended.
+//
+// By default this Proof of Concept implementation reports an error
+// for these interactions. However, the implementation also provides
+// a non-error treatment. The non-error treatment for the interactions is:
+//   (1) A resume() call performed on a disabled, suspended process will
+//       mark the process as no longer suspended, and if it is capable
+//       of execution (not waiting on any events) it will be placed on
+//       the queue of runnable processes. See the state diagram below.
+//   (2) A call to sync_reset_on() or sync_reset_off() will set or clear
+//       the synchronous reset flag. Whether the process is in reset or
+//       not will be determined when the process actually executes by
+//       looking at the flag's value at that time.
+//   (3) If a suspended process has a reset_signal_is() specification
+//       the value of the reset variable at the time of its next execution 
+//       will determine whether it is in reset or not.
+//      
+// TO GET THE NON-ERROR BEHAVIOR SET THE VARIABLE BELOW TO TRUE.
+//
+// This can be done in this source before you build the library, or you
+// can use an assignment as the first statement in your sc_main() function:
+//    sc_core::sc_allow_process_control_corners = true;
+
+bool sc_allow_process_control_corners = false;
+
+// The state transition diagram for the interaction of disable and suspend
+// when sc_allow_process_control_corners is true is shown below:
+//
+// ......................................................................
+// .         ENABLED                    .           DISABLED            .
+// .                                    .                               .
+// .                 +----------+    disable      +----------+          .
+// .   +------------>|          |-------.-------->|          |          .
+// .   |             | runnable |       .         | runnable |          .
+// .   |     +-------|          |<------.---------|          |------+   .
+// .   |     |       +----------+     enable      +----------+      |   .
+// .   |     |          |    ^          .            |    ^         |   .
+// .   |     |  suspend |    | resume   .    suspend |    | resume  |   .
+// .   |     |          V    |          .            V    |         |   .
+// .   |     |       +----------+    disable      +----------+      |   .
+// .   |     |       | suspend  |-------.-------->| suspend  |      |   .
+// . t |   r |       |          |       .         |          |      | r .
+// . r |   u |       |  ready   |<------.---------|  ready   |      | u .
+// . i |   n |       +----------+     enable      +----------+      | n .
+// . g |   / |         ^                .                           | / .
+// . g |   w |  trigger|                .                           | w .
+// . e |   a |         |                .                           | a .
+// . r |   i |       +----------+    disable      +----------+      | i .
+// .   |   t |       | suspend  |-------.-------->| suspend  |      | t .
+// .   |     |       |          |       .         |          |      |   .
+// .   |     |       | waiting  |<------.---------| waiting  |      |   .
+// .   |     |       +----------+     enable      +----------+      |   .
+// .   |     |          |    ^          .            |    ^         |   .
+// .   |     |  suspend |    | resume   .    suspend |    | resume  |   .
+// .   |     |          V    |          .            V    |         |   .
+// .   |     |       +----------+    disable      +----------+      |   .
+// .   |     +------>|          |-------.-------->|          |      |   .
+// .   |             | waiting  |       .         | waiting  |      |   .
+// .   +-------------|          |<------.---------|          |<-----+   .
+// .                 +----------+     enable      +----------+          .
+// .                                    .                               .
+// ......................................................................
+
+// ----------------------------------------------------------------------------
+
+static std::ostream&
+print_status_expression( std::ostream& os, sc_status s );
+
+// utility helper to print a simulation status
+std::ostream& operator << ( std::ostream& os, sc_status s )
+{
+    // print primitive values
+    switch(s)
+    {
+#   define PRINT_STATUS( Status ) \
+      case Status: { os << #Status; } break
+
+      PRINT_STATUS( SC_UNITIALIZED );
+      PRINT_STATUS( SC_ELABORATION );
+      PRINT_STATUS( SC_BEFORE_END_OF_ELABORATION );
+      PRINT_STATUS( SC_END_OF_ELABORATION );
+      PRINT_STATUS( SC_START_OF_SIMULATION );
+
+      PRINT_STATUS( SC_RUNNING );
+      PRINT_STATUS( SC_PAUSED );
+      PRINT_STATUS( SC_STOPPED );
+      PRINT_STATUS( SC_END_OF_SIMULATION );
+
+      PRINT_STATUS( SC_END_OF_INITIALIZATION );
+//      PRINT_STATUS( SC_END_OF_EVALUATION );
+      PRINT_STATUS( SC_END_OF_UPDATE );
+      PRINT_STATUS( SC_BEFORE_TIMESTEP );
+
+      PRINT_STATUS( SC_STATUS_ANY );
+
+#   undef PRINT_STATUS
+    default:
+
+      if( s & SC_STATUS_ANY ) // combination of status bits
+        print_status_expression( os, s );
+      else                    // invalid number, print hex value
+        os << "0x" << std::hex << +s;
+    }
+
+    return os;
+}
+
+// pretty-print a combination of sc_status bits (i.e. a callback mask)
+static std::ostream&
+print_status_expression( std::ostream& os, sc_status s )
+{
+    std::vector<sc_status> bits;
+    unsigned               is_set = SC_ELABORATION;
+
+    // collect bits
+    while( is_set <= SC_STATUS_LAST )
+    {
+        if( s & is_set )
+            bits.push_back( (sc_status)is_set );
+        is_set <<= 1;
+    }
+    if( s & ~SC_STATUS_ANY ) // remaining bits
+        bits.push_back( (sc_status)( s & ~SC_STATUS_ANY ) );
+
+    // print expression
+    std::vector<sc_status>::size_type i=0, n=bits.size();
+    if ( n>1 )
+        os << "(";
+    for( ; i<n-1; ++i )
+        os << bits[i] << "|";
+    os << bits[i];
+    if ( n>1 )
+        os << ")";
+    return os;
+}
+
+} // namespace sc_core
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Ali Dasdan, Synopsys, Inc.
+  Description of Modification: - Added sc_stop() detection into initial_crunch
+                                 and crunch. This makes it possible to exit out
+                                 of a combinational loop using sc_stop().
+
+      Name, Affiliation, Date: Andy Goodrich, Forte Design Systems 20 May 2003
+  Description of Modification: - sc_stop mode
+                               - phase callbacks
+
+      Name, Affiliation, Date: Bishnupriya Bhattacharya, Cadence Design Systems,
+                               25 August 2003
+  Description of Modification: - support for dynamic process
+                               - support for sc export registry
+                               - new member methods elaborate(), 
+				 prepare_to_simulate(), and initial_crunch()
+				 that are invoked by initialize() in that order
+                               - implement sc_get_last_created_process_handle() for use
+                                 before simulation starts
+                               - remove "set_curr_proc(handle)" from 
+                                 register_method_process and 
+                                 register_thread_process - led to bugs
+                               
+      Name, Affiliation, Date: Andy Goodrich, Forte Design Systems 04 Sep 2003
+  Description of Modification: - changed process existence structures to
+				 linked lists to eliminate exponential 
+				 execution problem with using sc_pvector.
+ *****************************************************************************/
+// $Log: sc_simcontext.cpp,v $
+// Revision 1.37  2011/08/29 18:04:32  acg
+//  Philipp A. Hartmann: miscellaneous clean ups.
+//
+// Revision 1.36  2011/08/26 20:46:10  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.35  2011/08/24 22:05:51  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.34  2011/08/04 17:15:28  acg
+//  Andy Goodrich: added documentation to crunch() routine.
+//
+// Revision 1.32  2011/07/24 11:16:36  acg
+//  Philipp A. Hartmann: fix reference counting on deferred deletions of
+//  processes.
+//
+// Revision 1.31  2011/07/01 18:49:07  acg
+//  Andy Goodrich: moved pln() from sc_simcontext.cpp to sc_ver.cpp.
+//
+// Revision 1.30  2011/05/09 04:07:49  acg
+//  Philipp A. Hartmann:
+//    (1) Restore hierarchy in all phase callbacks.
+//    (2) Ensure calls to before_end_of_elaboration.
+//
+// Revision 1.29  2011/04/08 22:39:09  acg
+//  Andy Goodrich: moved method invocation code to sc_method.h so that the
+//  details are hidden from sc_simcontext.
+//
+// Revision 1.28  2011/04/05 20:50:57  acg
+//  Andy Goodrich:
+//    (1) changes to make sure that event(), posedge() and negedge() only
+//        return true if the clock has not moved.
+//    (2) fixes for method self-resumes.
+//    (3) added SC_PRERELEASE_VERSION
+//    (4) removed kernel events from the object hierarchy, added
+//        sc_hierarchy_name_exists().
+//
+// Revision 1.27  2011/04/05 06:14:15  acg
+//  Andy Goodrich: fix typo.
+//
+// Revision 1.26  2011/04/05 06:03:32  acg
+//  Philipp A. Hartmann: added code to set ready to run bit for a suspended
+//  process that does not have dont_initialize specified at simulation
+//  start up.
+//
+// Revision 1.25  2011/04/01 21:31:55  acg
+//  Andy Goodrich: make sure processes suspended before the start of execution
+//  don't get scheduled for initial execution.
+//
+// Revision 1.24  2011/03/28 13:02:52  acg
+//  Andy Goodrich: Changes for disable() interactions.
+//
+// Revision 1.23  2011/03/12 21:07:51  acg
+//  Andy Goodrich: changes to kernel generated event support.
+//
+// Revision 1.22  2011/03/07 17:38:43  acg
+//  Andy Goodrich: tightening up of checks for undefined interaction between
+//  synchronous reset and suspend.
+//
+// Revision 1.21  2011/03/06 19:57:11  acg
+//  Andy Goodrich: refinements for the illegal suspend - synchronous reset
+//  interaction.
+//
+// Revision 1.20  2011/03/06 15:58:50  acg
+//  Andy Goodrich: added escape to turn off process control corner case
+//  checks.
+//
+// Revision 1.19  2011/03/05 04:45:16  acg
+//  Andy Goodrich: moved active process calculation to the sc_simcontext class.
+//
+// Revision 1.18  2011/03/05 01:39:21  acg
+//  Andy Goodrich: changes for named events.
+//
+// Revision 1.17  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.16  2011/02/17 19:53:28  acg
+//  Andy Goodrich: eliminated use of ready_to_run() as part of process control
+//  simplification.
+//
+// Revision 1.15  2011/02/13 21:47:38  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.14  2011/02/11 13:25:24  acg
+//  Andy Goodrich: Philipp A. Hartmann's changes:
+//    (1) Removal of SC_CTHREAD method overloads.
+//    (2) New exception processing code.
+//
+// Revision 1.13  2011/02/08 08:42:50  acg
+//  Andy Goodrich: fix ordering of check for stopped versus paused.
+//
+// Revision 1.12  2011/02/07 19:17:20  acg
+//  Andy Goodrich: changes for IEEE 1666 compatibility.
+//
+// Revision 1.11  2011/02/02 07:18:11  acg
+//  Andy Goodrich: removed toggle() calls for the new crunch() toggle usage.
+//
+// Revision 1.10  2011/02/01 23:01:53  acg
+//  Andy Goodrich: removed dead code.
+//
+// Revision 1.9  2011/02/01 21:11:59  acg
+//  Andy Goodrich:
+//  (1) Use of new toggle_methods() and toggle_threads() run queue methods
+//      to make sure the thread run queue does not execute when allow preempt_me()
+//      is called from an SC_METHOD.
+//  (2) Use of execute_thread_next() to allow thread execution in the current
+//      delta cycle() rather than push_runnable_thread_front which executed
+//      in the following cycle.
+//
+// Revision 1.8  2011/01/25 20:50:37  acg
+//  Andy Goodrich: changes for IEEE 1666 2011.
+//
+// Revision 1.7  2011/01/19 23:21:50  acg
+//  Andy Goodrich: changes for IEEE 1666 2011
+//
+// Revision 1.6  2011/01/18 20:10:45  acg
+//  Andy Goodrich: changes for IEEE1666_2011 semantics.
+//
+// Revision 1.5  2010/11/20 17:10:57  acg
+//  Andy Goodrich: reset processing changes for new IEEE 1666 standard.
+//
+// Revision 1.4  2010/07/22 20:02:33  acg
+//  Andy Goodrich: bug fixes.
+//
+// Revision 1.3  2008/05/22 17:06:26  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.2  2007/09/20 20:32:35  acg
+//  Andy Goodrich: changes to the semantics of throw_it() to match the
+//  specification. A call to throw_it() will immediately suspend the calling
+//  thread until all the throwees have executed. At that point the calling
+//  thread will be restarted before the execution of any other threads.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.21  2006/08/29 23:37:13  acg
+//  Andy Goodrich: Added check for negative time.
+//
+// Revision 1.20  2006/05/26 20:33:16  acg
+//   Andy Goodrich: changes required by additional platform compilers (i.e.,
+//   Microsoft VC++, Sun Forte, HP aCC).
+//
+// Revision 1.19  2006/05/08 17:59:52  acg
+//  Andy Goodrich: added a check before m_curr_time is set to make sure it
+//  is not set to a time before its current value. This will treat
+//  sc_event.notify( ) calls with negative times as calls with a zero time.
+//
+// Revision 1.18  2006/04/20 17:08:17  acg
+//  Andy Goodrich: 3.0 style process changes.
+//
+// Revision 1.17  2006/04/11 23:13:21  acg
+//   Andy Goodrich: Changes for reduced reset support that only includes
+//   sc_cthread, but has preliminary hooks for expanding to method and thread
+//   processes also.
+//
+// Revision 1.16  2006/03/21 00:00:34  acg
+//   Andy Goodrich: changed name of sc_get_current_process_base() to be
+//   sc_get_current_process_b() since its returning an sc_process_b instance.
+//
+// Revision 1.15  2006/03/13 20:26:50  acg
+//  Andy Goodrich: Addition of forward class declarations, e.g.,
+//  sc_reset, to keep gcc 4.x happy.
+//
+// Revision 1.14  2006/02/02 23:42:41  acg
+//  Andy Goodrich: implemented a much better fix to the sc_event_finder
+//  proliferation problem. This new version allocates only a single event
+//  finder for each port for each type of event, e.g., pos(), neg(), and
+//  value_change(). The event finder persists as long as the port does,
+//  which is what the LRM dictates. Because only a single instance is
+//  allocated for each event type per port there is not a potential
+//  explosion of storage as was true in the 2.0.1/2.1 versions.
+//
+// Revision 1.13  2006/02/02 21:29:10  acg
+//  Andy Goodrich: removed the call to sc_event_finder::free_instances() that
+//  was in end_of_elaboration(), leaving only the call in clean(). This is
+//  because the LRM states that sc_event_finder instances are persistent as
+//  long as the sc_module hierarchy is valid.
+//
+// Revision 1.12  2006/02/02 21:09:50  acg
+//  Andy Goodrich: added call to sc_event_finder::free_instances in the clean()
+//  method.
+//
+// Revision 1.11  2006/02/02 20:43:14  acg
+//  Andy Goodrich: Added an existence linked list to sc_event_finder so that
+//  the dynamically allocated instances can be freed after port binding
+//  completes. This replaces the individual deletions in ~sc_bind_ef, as these
+//  caused an exception if an sc_event_finder instance was used more than
+//  once, due to a double freeing of the instance.
+//
+// Revision 1.10  2006/01/31 21:43:26  acg
+//  Andy Goodrich: added comments in constructor to highlight environmental
+//  overrides section.
+//
+// Revision 1.9  2006/01/26 21:04:54  acg
+//  Andy Goodrich: deprecation message changes and additional messages.
+//
+// Revision 1.8  2006/01/25 00:31:19  acg
+//  Andy Goodrich: Changed over to use a standard message id of
+//  SC_ID_IEEE_1666_DEPRECATION for all deprecation messages.
+//
+// Revision 1.7  2006/01/24 20:49:05  acg
+// Andy Goodrich: changes to remove the use of deprecated features within the
+// simulator, and to issue warning messages when deprecated features are used.
+//
+// Revision 1.6  2006/01/19 00:29:52  acg
+// Andy Goodrich: Yet another implementation for signal write checking. This
+// one uses an environment variable SC_SIGNAL_WRITE_CHECK, that when set to
+// DISABLE will disable write checking on signals.
+//
+// Revision 1.5  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+//
+// Revision 1.4  2006/01/03 23:18:44  acg
+// Changed copyright to include 2006.
+//
+// Revision 1.3  2005/12/20 22:11:10  acg
+// Fixed $Log lines.
+//
+// Revision 1.2  2005/12/20 22:02:30  acg
+// Changed where delta cycles are incremented to match IEEE 1666. Added the
+// event_occurred() method to hide how delta cycle comparisions are done within
+// sc_simcontext. Changed the boolean update_phase to an enum that shows all
+// the phases.
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_simcontext.h b/ext/systemc/src/sysc/kernel/sc_simcontext.h
new file mode 100644
index 000000000..997a3f49c
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_simcontext.h
@@ -0,0 +1,903 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_simcontext.h -- Definition of the simulation context class.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+                   Martin Janssen, Synopsys, Inc.
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_SIMCONTEXT_H
+#define SC_SIMCONTEXT_H
+
+#include "sysc/kernel/sc_cmnhdr.h"
+#include "sysc/kernel/sc_process.h"
+#include "sysc/kernel/sc_status.h"
+#include "sysc/kernel/sc_time.h"
+#include "sysc/utils/sc_hash.h"
+#include "sysc/utils/sc_pq.h"
+
+namespace sc_core {
+
+// forward declarations
+
+class sc_cor;
+class sc_cor_pkg;
+class sc_event;
+class sc_event_timed;
+class sc_export_registry;
+class sc_module;
+class sc_module_name;
+class sc_module_registry;
+class sc_name_gen;
+class sc_object;
+class sc_object_manager;
+class sc_phase_callback_registry;
+class sc_process_handle;
+class sc_port_registry;
+class sc_prim_channel_registry;
+class sc_process_table;
+class sc_signal_bool_deval;
+class sc_trace_file;
+class sc_runnable;
+class sc_process_host;
+class sc_method_process;
+class sc_cthread_process;
+class sc_thread_process;
+
+template< typename > class sc_plist;
+typedef sc_plist< sc_process_b* > sc_process_list;
+
+struct sc_curr_proc_info
+{
+    sc_process_b*     process_handle;
+    sc_curr_proc_kind kind;
+    sc_curr_proc_info() : process_handle( 0 ), kind( SC_NO_PROC_ ) {}
+};
+
+typedef const sc_curr_proc_info* sc_curr_proc_handle;
+
+enum sc_stop_mode {          // sc_stop modes:
+    SC_STOP_FINISH_DELTA,
+    SC_STOP_IMMEDIATE
+};
+extern void sc_set_stop_mode( sc_stop_mode mode );
+extern sc_stop_mode sc_get_stop_mode();
+
+enum sc_starvation_policy 
+{
+    SC_EXIT_ON_STARVATION,
+    SC_RUN_TO_TIME
+};
+extern void sc_start();
+extern void sc_start( const sc_time& duration, 
+                      sc_starvation_policy p=SC_RUN_TO_TIME );
+inline void sc_start( int duration, sc_time_unit unit, 
+                      sc_starvation_policy p=SC_RUN_TO_TIME )
+{
+    sc_start( sc_time((double)duration,unit), p );
+}
+
+inline void sc_start( double duration, sc_time_unit unit, 
+                      sc_starvation_policy p=SC_RUN_TO_TIME )
+{
+    sc_start( sc_time(duration,unit), p );
+}
+
+extern void sc_stop();
+
+// friend function declarations
+
+sc_dt::uint64 sc_delta_count();
+const std::vector<sc_event*>& sc_get_top_level_events(
+				const   sc_simcontext* simc_p);
+const std::vector<sc_object*>& sc_get_top_level_objects(
+				const   sc_simcontext* simc_p);
+bool    sc_is_running( const sc_simcontext* simc_p );
+void    sc_pause();
+bool    sc_end_of_simulation_invoked();
+void    sc_start( const sc_time&, sc_starvation_policy );
+bool    sc_start_of_simulation_invoked();
+void    sc_set_time_resolution( double, sc_time_unit );
+sc_time sc_get_time_resolution();
+void    sc_set_default_time_unit( double, sc_time_unit );
+sc_time sc_get_default_time_unit();
+bool    sc_pending_activity_at_current_time( const sc_simcontext* );
+bool    sc_pending_activity_at_future_time( const sc_simcontext* );
+sc_time sc_time_to_pending_activity( const sc_simcontext* );
+
+struct sc_invoke_method; 
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_simcontext
+//
+//  The simulation context.
+// ----------------------------------------------------------------------------
+
+class sc_simcontext
+{
+    friend struct sc_invoke_method; 
+    friend class sc_event;
+    friend class sc_module;
+    friend class sc_object;
+    friend class sc_time;
+    friend class sc_clock;
+    friend class sc_method_process;
+    friend class sc_phase_callback_registry;
+    friend class sc_process_b;
+    friend class sc_process_handle;
+    friend class sc_prim_channel;
+    friend class sc_cthread_process;
+    friend class sc_thread_process;
+    friend sc_dt::uint64 sc_delta_count();
+    friend const std::vector<sc_event*>& sc_get_top_level_events(
+        const sc_simcontext* simc_p);
+    friend const std::vector<sc_object*>& sc_get_top_level_objects(
+        const sc_simcontext* simc_p);
+    friend bool sc_is_running( const sc_simcontext* simc_p );
+    friend void sc_pause();
+    friend bool sc_end_of_simulation_invoked();
+    friend void sc_start( const sc_time&, sc_starvation_policy );
+    friend bool sc_start_of_simulation_invoked();
+    friend void sc_thread_cor_fn(void*);
+    friend sc_time sc_time_to_pending_activity( const sc_simcontext* );
+    friend bool sc_pending_activity_at_current_time( const sc_simcontext* );
+    friend bool sc_pending_activity_at_future_time( const sc_simcontext* );
+
+
+    void init();
+    void clean();
+
+public:
+
+    sc_simcontext();
+    ~sc_simcontext();
+
+    void initialize( bool = false );
+    void cycle( const sc_time& );
+    void simulate( const sc_time& duration );
+    void stop();
+    void end();
+    void reset();
+
+    int sim_status() const;
+    bool elaboration_done() const;
+
+    std::vector<sc_thread_handle>& get_active_invokers();
+
+    sc_object_manager* get_object_manager();
+
+    inline sc_status get_status() const;
+
+    sc_object* active_object();
+
+    void hierarchy_push( sc_module* );
+    sc_module* hierarchy_pop();
+    sc_module* hierarchy_curr() const;
+    sc_object* first_object();
+    sc_object* next_object();
+    sc_object* find_object( const char* name );
+
+    sc_module_registry* get_module_registry();
+    sc_port_registry* get_port_registry();
+    sc_export_registry* get_export_registry();
+    sc_prim_channel_registry* get_prim_channel_registry();
+
+    // to generate unique names for objects in an MT-Safe way
+    const char* gen_unique_name( const char* basename_, 
+                                 bool preserve_first = false 
+                               );
+
+    // process creation
+    sc_process_handle create_cthread_process( 
+    const char* name_p, bool free_host, SC_ENTRY_FUNC method_p, 
+    sc_process_host* host_p, const sc_spawn_options* opt_p );
+
+    sc_process_handle create_method_process( 
+    const char* name_p, bool free_host, SC_ENTRY_FUNC method_p, 
+    sc_process_host* host_p, const sc_spawn_options* opt_p );
+
+    sc_process_handle create_thread_process( 
+    const char* name_p, bool free_host, SC_ENTRY_FUNC method_p, 
+    sc_process_host* host_p, const sc_spawn_options* opt_p );
+
+    sc_curr_proc_handle get_curr_proc_info();
+    sc_object* get_current_writer() const;
+    bool write_check() const;
+    void set_curr_proc( sc_process_b* );
+    void reset_curr_proc();
+
+    int next_proc_id();
+
+    void add_trace_file( sc_trace_file* );
+    void remove_trace_file( sc_trace_file* );
+
+    friend void    sc_set_time_resolution( double, sc_time_unit );
+    friend sc_time sc_get_time_resolution();
+    friend void    sc_set_default_time_unit( double, sc_time_unit );
+    friend sc_time sc_get_default_time_unit();
+
+    const sc_time& max_time() const;
+    const sc_time& time_stamp() const;
+
+    sc_dt::uint64 change_stamp() const;
+    sc_dt::uint64 delta_count() const;
+    bool event_occurred( sc_dt::uint64 last_change_count ) const;
+    bool evaluation_phase() const;
+    bool is_running() const;
+    bool update_phase() const;
+    bool notify_phase() const;
+    bool get_error();
+    void set_error( sc_report* );
+
+    sc_cor_pkg* cor_pkg()
+        { return m_cor_pkg; }
+    sc_cor* next_cor();
+
+    const ::std::vector<sc_object*>& get_child_objects() const;
+
+    void elaborate();
+    void prepare_to_simulate();
+    inline void initial_crunch( bool no_crunch );
+    bool next_time( sc_time& t ) const; 
+    bool pending_activity_at_current_time() const;
+
+private:
+
+    void add_child_event( sc_event* );
+    void add_child_object( sc_object* );
+    void remove_child_event( sc_event* );
+    void remove_child_object( sc_object* );
+
+    void crunch( bool once=false );
+
+    int add_delta_event( sc_event* );
+    void remove_delta_event( sc_event* );
+    void add_timed_event( sc_event_timed* );
+
+    void trace_cycle( bool delta_cycle );
+
+    const ::std::vector<sc_event*>& get_child_events_internal() const;
+    const ::std::vector<sc_object*>& get_child_objects_internal() const;
+
+    void execute_method_next( sc_method_handle );
+    void execute_thread_next( sc_thread_handle );
+
+    sc_method_handle pop_runnable_method();
+    sc_thread_handle pop_runnable_thread();
+
+    void preempt_with( sc_method_handle );
+    inline void preempt_with( sc_thread_handle );
+
+    void push_runnable_method( sc_method_handle );
+    void push_runnable_thread( sc_thread_handle );
+
+    void push_runnable_method_front( sc_method_handle );
+    void push_runnable_thread_front( sc_thread_handle );
+
+    void remove_runnable_method( sc_method_handle );
+    void remove_runnable_thread( sc_thread_handle );
+
+    void requeue_current_process();
+    void suspend_current_process();
+
+    void do_sc_stop_action();
+    void mark_to_collect_process( sc_process_b* zombie_p );
+
+private:
+
+    enum execution_phases {
+        phase_initialize = 0,
+        phase_evaluate,
+        phase_update,
+        phase_notify
+    };
+    sc_object_manager*          m_object_manager;
+
+    sc_module_registry*         m_module_registry;
+    sc_port_registry*           m_port_registry;
+    sc_export_registry*         m_export_registry;
+    sc_prim_channel_registry*   m_prim_channel_registry;
+    sc_phase_callback_registry* m_phase_cb_registry;
+
+    sc_name_gen*                m_name_gen;
+
+    sc_process_table*           m_process_table;
+    sc_curr_proc_info           m_curr_proc_info;
+    sc_object*                  m_current_writer;
+    bool                        m_write_check;
+    int                         m_next_proc_id;
+
+    std::vector<sc_thread_handle> m_active_invokers;
+
+    std::vector<sc_event*>      m_child_events;
+    std::vector<sc_object*>     m_child_objects;
+
+    std::vector<sc_event*>      m_delta_events;
+    sc_ppq<sc_event_timed*>*    m_timed_events;
+
+    std::vector<sc_trace_file*> m_trace_files;
+    bool                        m_something_to_trace;
+
+    sc_runnable*                m_runnable;
+    sc_process_list*            m_collectable;
+
+    sc_time_params*             m_time_params;
+    sc_time                     m_curr_time;
+    mutable sc_time             m_max_time;
+ 
+    sc_invoke_method*           m_method_invoker_p;
+    sc_dt::uint64               m_change_stamp; // "time" change occurred.
+    sc_dt::uint64               m_delta_count;
+    bool                        m_forced_stop;
+    bool                        m_paused;
+    bool                        m_ready_to_simulate;
+    bool                        m_elaboration_done;
+    execution_phases            m_execution_phase;
+    sc_report*                  m_error;
+    bool                        m_in_simulator_control;   
+    bool                        m_end_of_simulation_called;
+    sc_status                   m_simulation_status;
+    bool                        m_start_of_simulation_called;
+
+    sc_cor_pkg*                 m_cor_pkg; // the simcontext's coroutine package
+    sc_cor*                     m_cor;     // the simcontext's coroutine
+
+private:
+
+    // disabled
+    sc_simcontext( const sc_simcontext& );
+    sc_simcontext& operator = ( const sc_simcontext& );
+};
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+// Not MT safe.
+
+#if 1
+extern sc_simcontext* sc_curr_simcontext;
+extern sc_simcontext* sc_default_global_context;
+
+inline sc_simcontext*
+sc_get_curr_simcontext()
+{
+    if( sc_curr_simcontext == 0 ) {
+        sc_default_global_context = new sc_simcontext;
+        sc_curr_simcontext = sc_default_global_context;
+    }
+    return sc_curr_simcontext;
+}
+#else
+    extern sc_simcontext* sc_get_curr_simcontext();
+#endif // 0
+inline sc_status sc_get_status()
+{
+    return sc_get_curr_simcontext()->get_status();
+}
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+inline
+bool
+sc_simcontext::elaboration_done() const
+{
+    return m_elaboration_done;
+}
+
+
+inline sc_status sc_simcontext::get_status() const
+{
+    return m_simulation_status != SC_RUNNING ? 
+                  m_simulation_status :
+		  (m_in_simulator_control ? SC_RUNNING : SC_PAUSED);
+}
+
+inline
+int
+sc_simcontext::sim_status() const
+{
+    if( m_error ) {
+        return SC_SIM_ERROR;
+    }
+    if( m_forced_stop ) {
+        return SC_SIM_USER_STOP;
+    }
+    return SC_SIM_OK;
+}
+
+
+inline
+sc_object_manager*
+sc_simcontext::get_object_manager()
+{
+    return m_object_manager;
+}
+
+inline
+sc_module_registry*
+sc_simcontext::get_module_registry()
+{
+    return m_module_registry;
+}
+
+inline
+sc_port_registry*
+sc_simcontext::get_port_registry()
+{
+    return m_port_registry;
+}
+
+inline
+sc_export_registry*
+sc_simcontext::get_export_registry()
+{
+    return m_export_registry;
+}
+
+inline
+sc_prim_channel_registry*
+sc_simcontext::get_prim_channel_registry()
+{
+    return m_prim_channel_registry;
+}
+
+
+inline
+sc_curr_proc_handle
+sc_simcontext::get_curr_proc_info()
+{
+    return &m_curr_proc_info;
+}
+
+
+inline
+int
+sc_simcontext::next_proc_id()
+{
+    return ( ++ m_next_proc_id );
+}
+
+
+inline
+const sc_time&
+sc_simcontext::max_time() const
+{
+    if ( m_max_time == SC_ZERO_TIME )
+    {
+        m_max_time = sc_time::from_value( ~sc_dt::UINT64_ZERO );
+    }
+    return m_max_time;
+}
+
+inline
+sc_dt::uint64
+sc_simcontext::change_stamp() const
+{
+    return m_change_stamp;
+}
+
+inline
+const sc_time&
+sc_simcontext::time_stamp() const
+{
+    return m_curr_time;
+}
+
+
+inline 
+bool
+sc_simcontext::event_occurred(sc_dt::uint64 last_change_stamp) const
+{
+    return m_change_stamp == last_change_stamp;
+}
+
+inline
+bool
+sc_simcontext::evaluation_phase() const
+{
+    return (m_execution_phase == phase_evaluate) &&
+           m_ready_to_simulate;
+}
+
+inline
+bool
+sc_simcontext::update_phase() const
+{
+    return m_execution_phase == phase_update;
+}
+
+inline
+bool
+sc_simcontext::notify_phase() const
+{
+    return m_execution_phase == phase_notify;
+}
+
+inline
+void
+sc_simcontext::set_error( sc_report* err )
+{
+    delete m_error;
+    m_error = err;
+}
+
+
+inline
+bool
+sc_simcontext::get_error()
+{
+    return m_error != NULL;
+}
+
+inline
+int
+sc_simcontext::add_delta_event( sc_event* e )
+{
+    m_delta_events.push_back( e );
+    return ( m_delta_events.size() - 1 );
+}
+
+inline
+void
+sc_simcontext::add_timed_event( sc_event_timed* et )
+{
+    m_timed_events->insert( et );
+}
+
+inline sc_object* 
+sc_simcontext::get_current_writer() const
+{
+    return m_current_writer;
+}
+
+inline bool 
+sc_simcontext::write_check() const
+{
+    return m_write_check;
+}
+
+// ----------------------------------------------------------------------------
+
+class sc_process_handle;
+sc_process_handle sc_get_current_process_handle();
+
+// Get the current object hierarchy context
+//
+// Returns a pointer the the sc_object (module or process) that
+// would become the parent object of a newly created element
+// of the SystemC object hierarchy, or NULL.
+//
+inline sc_object*
+sc_get_current_object()
+{
+  return sc_get_curr_simcontext()->active_object();
+}
+
+inline
+sc_process_b*
+sc_get_current_process_b()
+{
+    return sc_get_curr_simcontext()->get_curr_proc_info()->process_handle;
+}
+
+// THE FOLLOWING FUNCTION IS DEPRECATED IN 2.1
+extern sc_process_b* sc_get_curr_process_handle();
+
+inline
+sc_curr_proc_kind
+sc_get_curr_process_kind()
+{
+    return sc_get_curr_simcontext()->get_curr_proc_info()->kind;
+}
+
+
+inline int sc_get_simulator_status()
+{
+    return sc_get_curr_simcontext()->sim_status();
+}
+
+
+// Generates unique names within each module.
+extern
+const char*
+sc_gen_unique_name( const char* basename_, bool preserve_first = false );
+
+
+// Set the random seed for controlled randomization -- not yet implemented
+extern
+void
+sc_set_random_seed( unsigned int seed_ );
+
+
+extern void sc_initialize();
+
+extern const sc_time& sc_max_time();    // Get maximum time value.
+extern const sc_time& sc_time_stamp();  // Current simulation time.
+extern double sc_simulation_time();     // Current time in default time units.
+
+inline
+const std::vector<sc_event*>& sc_get_top_level_events(
+    const sc_simcontext* simc_p = sc_get_curr_simcontext() )
+{
+    return simc_p->m_child_events;
+}
+
+inline
+const std::vector<sc_object*>& sc_get_top_level_objects(
+    const sc_simcontext* simc_p = sc_get_curr_simcontext() )
+{
+    return simc_p->m_child_objects;
+}
+
+extern sc_event* sc_find_event( const char* name );
+
+extern sc_object* sc_find_object( const char* name );
+
+inline
+sc_dt::uint64 sc_delta_count()
+{
+    return sc_get_curr_simcontext()->m_delta_count;
+}
+
+inline 
+bool sc_is_running( const sc_simcontext* simc_p = sc_get_curr_simcontext() )
+{
+    return simc_p->m_ready_to_simulate;
+}
+
+bool sc_is_unwinding();
+
+inline void sc_pause()
+{
+    sc_get_curr_simcontext()->m_paused = true;
+}
+
+// Return indication if there are more processes to execute in this delta phase
+
+inline bool sc_pending_activity_at_current_time
+  ( const sc_simcontext* simc_p = sc_get_curr_simcontext() )
+{
+  return simc_p->pending_activity_at_current_time();
+}
+
+// Return indication if there are timed notifications in the future
+
+inline bool sc_pending_activity_at_future_time
+  ( const sc_simcontext* simc_p = sc_get_curr_simcontext() )
+{
+  sc_time ignored;
+  return simc_p->next_time( ignored );
+}
+
+// Return indication if there are processes to run,
+// or notifications in the future
+
+inline bool sc_pending_activity
+  ( const sc_simcontext* simc_p = sc_get_curr_simcontext() )
+{
+  return sc_pending_activity_at_current_time( simc_p )
+      || sc_pending_activity_at_future_time( simc_p );
+}
+
+sc_time
+sc_time_to_pending_activity
+  ( const sc_simcontext* simc_p = sc_get_curr_simcontext() );
+
+
+inline
+bool
+sc_end_of_simulation_invoked()
+{
+    return sc_get_curr_simcontext()->m_end_of_simulation_called;
+}
+
+inline bool sc_hierarchical_name_exists( const char* name )
+{
+    return sc_find_object(name) || sc_find_event(name);
+}
+
+inline
+bool 
+sc_start_of_simulation_invoked()
+{
+    return sc_get_curr_simcontext()->m_start_of_simulation_called;
+}
+
+// The following variable controls whether process control corners should
+// be considered errors or not. See sc_simcontext.cpp for details on what
+// happens if this value is set to true.
+
+extern bool sc_allow_process_control_corners;
+
+} // namespace sc_core
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Andy Goodrich, Forte Design Systems 20 May 2003
+  Description of Modification: - phase callbacks
+                               - sc_stop mode
+
+      Name, Affiliation, Date: Bishnupriya Bhattacharya, Cadence Design Systems,
+                               25 August, 2003
+  Description of Modification: - support for dynamic process
+                               - support for sc export registry
+                               - new member methods elaborate(), 
+                 prepare_to_simulate(), and initial_crunch()
+                 that are invoked by initialize() in that order
+                               - add sc_get_last_created_process_handle() for 
+                 use before simulation starts
+                               
+      Name, Affiliation, Date: Bishnupriya Bhattacharya, Cadence Design Systems,
+                               3 March, 2004
+  Description of Modification: add sc_get_curr_process_kind()
+
+      Name, Affiliation, Date: 
+  Description of Modification: 
+                               
+ *****************************************************************************/
+// $Log: sc_simcontext.h,v $
+// Revision 1.26  2011/09/05 21:20:22  acg
+//  Andy Goodrich: result of automake invocation.
+//
+// Revision 1.25  2011/09/01 15:28:10  acg
+//  Andy Goodrich: the aftermath of automake.
+//
+// Revision 1.24  2011/08/29 18:04:32  acg
+//  Philipp A. Hartmann: miscellaneous clean ups.
+//
+// Revision 1.23  2011/08/26 20:46:10  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.22  2011/08/24 22:05:51  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.21  2011/05/09 04:07:49  acg
+//  Philipp A. Hartmann:
+//    (1) Restore hierarchy in all phase callbacks.
+//    (2) Ensure calls to before_end_of_elaboration.
+//
+// Revision 1.20  2011/04/08 18:26:07  acg
+//  Andy Goodrich: added execute_method_next() to handle method dispatch
+//   for asynchronous notifications that occur outside the evaluation phase.
+//
+// Revision 1.19  2011/04/05 20:50:57  acg
+//  Andy Goodrich:
+//    (1) changes to make sure that event(), posedge() and negedge() only
+//        return true if the clock has not moved.
+//    (2) fixes for method self-resumes.
+//    (3) added SC_PRERELEASE_VERSION
+//    (4) removed kernel events from the object hierarchy, added
+//        sc_hierarchical_name_exists().
+//
+// Revision 1.18  2011/03/20 13:43:23  acg
+//  Andy Goodrich: added async_signal_is() plus suspend() as a corner case.
+//
+// Revision 1.17  2011/03/07 18:25:19  acg
+//  Andy Goodrich: tightening of check for resume on a disabled process to
+//  only produce an error if it is ready to run.
+//
+// Revision 1.16  2011/03/06 15:58:50  acg
+//  Andy Goodrich: added escape to turn off process control corner case
+//  checks.
+//
+// Revision 1.15  2011/03/05 04:45:16  acg
+//  Andy Goodrich: moved active process calculation to the sc_simcontext class.
+//
+// Revision 1.14  2011/03/05 01:39:21  acg
+//  Andy Goodrich: changes for named events.
+//
+// Revision 1.13  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.12  2011/02/13 21:47:38  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.11  2011/02/13 21:34:35  acg
+//  Andy Goodrich: added SC_UNITIALIZED enum value to process status so
+//  its possible to detect throws before initialization.
+//
+// Revision 1.10  2011/02/11 13:25:24  acg
+//  Andy Goodrich: Philipp A. Hartmann's changes:
+//    (1) Removal of SC_CTHREAD method overloads.
+//    (2) New exception processing code.
+//
+// Revision 1.9  2011/02/01 21:18:56  acg
+//  Andy Goodrich: addition of new preempt_with() method used to immediately
+//  throw exceptions from threads.
+//
+// Revision 1.8  2011/01/25 20:50:37  acg
+//  Andy Goodrich: changes for IEEE 1666 2011.
+//
+// Revision 1.7  2011/01/19 23:21:50  acg
+//  Andy Goodrich: changes for IEEE 1666 2011
+//
+// Revision 1.6  2011/01/18 20:10:45  acg
+//  Andy Goodrich: changes for IEEE1666_2011 semantics.
+//
+// Revision 1.5  2010/07/22 20:02:33  acg
+//  Andy Goodrich: bug fixes.
+//
+// Revision 1.4  2009/05/22 16:06:29  acg
+//  Andy Goodrich: process control updates.
+//
+// Revision 1.3  2008/05/22 17:06:26  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.2  2007/09/20 20:32:35  acg
+//  Andy Goodrich: changes to the semantics of throw_it() to match the
+//  specification. A call to throw_it() will immediately suspend the calling
+//  thread until all the throwees have executed. At that point the calling
+//  thread will be restarted before the execution of any other threads.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.13  2006/05/08 18:00:06  acg
+// Andy Goodrich: added David Long's forward declarations for friend
+//   functions, methods, and operators to keep the Microsoft compiler happy.
+//
+// Revision 1.11  2006/04/11 23:13:21  acg
+//   Andy Goodrich: Changes for reduced reset support that only includes
+//   sc_cthread, but has preliminary hooks for expanding to method and thread
+//   processes also.
+//
+// Revision 1.10  2006/03/21 00:00:34  acg
+//   Andy Goodrich: changed name of sc_get_current_process_base() to be
+//   sc_get_current_process_b() since its returning an sc_process_b instance.
+//
+// Revision 1.9  2006/01/26 21:04:54  acg
+//  Andy Goodrich: deprecation message changes and additional messages.
+//
+// Revision 1.8  2006/01/24 20:49:05  acg
+// Andy Goodrich: changes to remove the use of deprecated features within the
+// simulator, and to issue warning messages when deprecated features are used.
+//
+// Revision 1.7  2006/01/19 00:29:52  acg
+// Andy Goodrich: Yet another implementation for signal write checking. This
+// one uses an environment variable SC_SIGNAL_WRITE_CHECK, that when set to
+// DISABLE will disable write checking on signals.
+//
+// Revision 1.6  2006/01/18 21:42:37  acg
+// Andy Goodrich: Changes for check writer support.
+//
+// Revision 1.5  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+//
+// Revision 1.4  2006/01/03 23:18:44  acg
+// Changed copyright to include 2006.
+//
+// Revision 1.3  2005/12/20 22:11:10  acg
+// Fixed $Log lines.
+//
+// Revision 1.2  2005/12/20 22:02:30  acg
+// Changed where delta cycles are incremented to match IEEE 1666. Added the
+// event_occurred() method to hide how delta cycle comparisions are done within
+// sc_simcontext. Changed the boolean update_phase to an enum that shows all
+// the phases.
+
+#endif
diff --git a/ext/systemc/src/sysc/kernel/sc_simcontext_int.h b/ext/systemc/src/sysc/kernel/sc_simcontext_int.h
new file mode 100644
index 000000000..039237f4a
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_simcontext_int.h
@@ -0,0 +1,365 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_simcontext_int.h -- For inline definitions of some utility functions.
+                         DO NOT EXPORT THIS INCLUDE FILE. Include this file
+                         after "sc_process_int.h" so that we can get the base
+                         class right.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_SIMCONTEXT_INT_H
+#define SC_SIMCONTEXT_INT_H
+
+#include "sysc/kernel/sc_simcontext.h"
+#include "sysc/kernel/sc_runnable.h"
+#include "sysc/kernel/sc_runnable_int.h"
+
+// DEBUGGING MACROS:
+//
+// DEBUG_MSG(NAME,P,MSG)
+//     MSG  = message to print
+//     NAME = name that must match the process for the message to print, or
+//            null if the message should be printed unconditionally.
+//     P    = pointer to process message is for, or NULL in which case the
+//            message will not print.
+#if 0
+#   define DEBUG_NAME ""
+#   define DEBUG_MSG(NAME,P,MSG) \
+    { \
+        if ( P && ( (strlen(NAME)==0) || !strcmp(NAME,P->name())) ) \
+          std::cout << "**** " << sc_time_stamp() << " ("  \
+	            << sc_get_current_process_name() << "): " << MSG \
+		    << " - " << P->name() << std::endl; \
+    }
+#else
+#   define DEBUG_MSG(NAME,P,MSG) 
+#endif
+
+
+namespace sc_core {
+
+inline
+const char*
+sc_get_current_process_name()
+{
+    sc_process_b* active_p; // active process to get name of.
+    const char*   result;   // name of active process.
+
+    active_p = sc_get_curr_simcontext()->get_curr_proc_info()->process_handle;
+    if ( active_p )
+        result = active_p->name();
+    else
+        result = "** NONE **";
+    return result;
+}
+
+// We use m_current_writer rather than m_curr_proc_info.process_handle to
+// return the active process for sc_signal<T>::check_write since that lets
+// us turn it off a library compile time, and only incur the overhead at
+// the time of process switches rather than having to interrogate an
+// additional switch every time a signal is written.
+
+inline
+void
+sc_simcontext::set_curr_proc( sc_process_b* process_h )
+{
+    m_curr_proc_info.process_handle = process_h;
+    m_curr_proc_info.kind           = process_h->proc_kind();
+    m_current_writer = m_write_check ? process_h : (sc_object*)0;
+}
+
+inline
+void
+sc_simcontext::reset_curr_proc()
+{
+    m_curr_proc_info.process_handle = 0;
+    m_curr_proc_info.kind           = SC_NO_PROC_;
+    m_current_writer                = 0;
+    sc_process_b::m_last_created_process_p = 0; 
+}
+
+inline
+void
+sc_simcontext::execute_method_next( sc_method_handle method_h )
+{
+    m_runnable->execute_method_next( method_h );
+}
+
+inline
+void
+sc_simcontext::execute_thread_next( sc_thread_handle thread_h )
+{
+    m_runnable->execute_thread_next( thread_h );
+}
+
+// +----------------------------------------------------------------------------
+// |"sc_simcontext::preempt_with"
+// | 
+// | This method executes the supplied thread immediately, suspending the
+// | caller. After executing the supplied thread the caller's execution will
+// | be restored. It is used to allow a thread to immediately throw an 
+// | exception, e.g., when the thread's kill_process() method was called.
+// | There are three cases to consider:
+// |   (1) The caller is a method, e.g., murder by method.
+// |   (2) The caller is another thread instance, e.g., murder by thread.
+// |   (3) The caller is this thread instance, e.g., suicide.
+// |
+// | Arguments:
+// |     thread_h -> thread to be executed.
+// +----------------------------------------------------------------------------
+inline
+void
+sc_simcontext::preempt_with( sc_thread_handle thread_h )
+{
+    sc_thread_handle  active_p;    // active thread or null.
+    sc_curr_proc_info caller_info; // process info for caller.
+
+    // Determine the active process and take the thread to be run off the
+    // run queue, if its there, since we will be explicitly causing its 
+    // execution.
+
+    active_p = DCAST<sc_thread_handle>(sc_get_current_process_b());
+    if ( thread_h->next_runnable() != NULL )
+	remove_runnable_thread( thread_h );
+
+    // THE CALLER IS A METHOD:
+    //
+    //   (a) Set the current process information to our thread.
+    //   (b) If the method was called by an invoker thread push that thread
+    //       onto the front of the run queue, this will cause the method
+    //       to be resumed after this thread waits.
+    //   (c) Invoke our thread directly by-passing the run queue.
+    //   (d) Restore the process info to the caller.
+    //   (e) Check to see if the calling method should throw an exception
+    //       because of activity that occurred during the preemption.
+
+    if ( active_p == NULL )
+    {
+	std::vector<sc_thread_handle>* invokers_p;  // active invokers stack.
+	sc_thread_handle           invoke_thread_p; // latest invocation thread.
+        sc_method_handle           method_p;        // active method.
+
+	method_p = DCAST<sc_method_handle>(sc_get_current_process_b());
+	invokers_p = &get_active_invokers();
+	caller_info = m_curr_proc_info;
+	if ( invokers_p->size() != 0 )
+	{
+	    invoke_thread_p = invokers_p->back();
+	    DEBUG_MSG( DEBUG_NAME, invoke_thread_p, 
+	        "queueing invocation thread to execute next" );
+	    execute_thread_next(invoke_thread_p);
+	}
+        DEBUG_MSG( DEBUG_NAME, thread_h, "preempting method with thread" );
+	set_curr_proc( (sc_process_b*)thread_h );
+	m_cor_pkg->yield( thread_h->m_cor_p );
+	m_curr_proc_info = caller_info; 
+        DEBUG_MSG(DEBUG_NAME, thread_h, "back from preempting method w/thread");
+	method_p->check_for_throws();
+    }
+
+    // CALLER IS A THREAD, BUT NOT THE THREAD TO BE RUN:
+    //
+    //   (a) Push the calling thread onto the front of the runnable queue
+    //       so it be the first thread to be run after this thread.
+    //   (b) Push the thread to be run onto the front of the runnable queue so 
+    //       it will execute when we suspend the calling thread.
+    //   (c) Suspend the active thread.
+
+    else if ( active_p != thread_h )
+    {
+        DEBUG_MSG( DEBUG_NAME, thread_h,
+	           "preempting active thread with thread" );
+        execute_thread_next( active_p );
+	execute_thread_next( thread_h );
+	active_p->suspend_me();
+    }
+
+    // CALLER IS THE THREAD TO BE RUN:
+    //
+    //   (a) Push the thread to be run onto the front of the runnable queue so 
+    //       it will execute when we suspend the calling thread.
+    //   (b) Suspend the active thread.
+
+    else
+    {
+        DEBUG_MSG(DEBUG_NAME,thread_h,"self preemption of active thread");
+	execute_thread_next( thread_h );
+	active_p->suspend_me();
+    }
+}
+
+
+inline
+void
+sc_simcontext::push_runnable_method( sc_method_handle method_h )
+{
+    m_runnable->push_back_method( method_h );
+}
+
+inline
+void
+sc_simcontext::push_runnable_method_front( sc_method_handle method_h )
+{
+    m_runnable->push_front_method( method_h );
+}
+
+inline
+void
+sc_simcontext::push_runnable_thread( sc_thread_handle thread_h )
+{
+    m_runnable->push_back_thread( thread_h );
+}
+
+inline
+void
+sc_simcontext::push_runnable_thread_front( sc_thread_handle thread_h )
+{
+    m_runnable->push_front_thread( thread_h );
+}
+
+
+inline
+sc_method_handle
+sc_simcontext::pop_runnable_method()
+{
+    sc_method_handle method_h = m_runnable->pop_method();
+    if( method_h == 0 ) {
+	reset_curr_proc();
+	return 0;
+    }
+    set_curr_proc( (sc_process_b*)method_h );
+    return method_h;
+}
+
+inline
+sc_thread_handle
+sc_simcontext::pop_runnable_thread()
+{
+    sc_thread_handle thread_h = m_runnable->pop_thread();
+    if( thread_h == 0 ) {
+	reset_curr_proc();
+	return 0;
+    }
+    set_curr_proc( (sc_process_b*)thread_h );
+    return thread_h;
+}
+
+inline
+void
+sc_simcontext::remove_runnable_method( sc_method_handle method_h )
+{
+    m_runnable->remove_method( method_h );
+}
+
+inline
+void
+sc_simcontext::remove_runnable_thread( sc_thread_handle thread_h )
+{
+    m_runnable->remove_thread( thread_h );
+}
+
+inline
+std::vector<sc_thread_handle>&
+sc_simcontext::get_active_invokers()
+{
+    return m_active_invokers;
+}
+
+// ----------------------------------------------------------------------------
+
+extern void sc_defunct_process_function( sc_module* );
+
+
+} // namespace sc_core
+
+#undef DEBUG_MSG
+#undef DEBUG_NAME
+
+// $Log: sc_simcontext_int.h,v $
+// Revision 1.14  2011/08/29 18:04:32  acg
+//  Philipp A. Hartmann: miscellaneous clean ups.
+//
+// Revision 1.13  2011/08/26 20:46:11  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.12  2011/07/29 22:45:06  acg
+//  Andy Goodrich: added invocation of sc_method_process::check_for_throws()
+//  to the preempt_with() code to handle case where the preempting process
+//  causes a throw on the invoking method process.
+//
+// Revision 1.11  2011/04/13 02:45:11  acg
+//  Andy Goodrich: eliminated warning message that occurred if the DEBUG_MSG
+//  macro was used.
+//
+// Revision 1.10  2011/04/11 22:05:48  acg
+//  Andy Goodrich: use the DEBUG_NAME macro in DEBUG_MSG invocations.
+//
+// Revision 1.9  2011/04/10 22:12:32  acg
+//  Andy Goodrich: adding debugging macros.
+//
+// Revision 1.8  2011/04/08 18:26:07  acg
+//  Andy Goodrich: added execute_method_next() to handle method dispatch
+//   for asynchronous notifications that occur outside the evaluation phase.
+//
+// Revision 1.7  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.6  2011/02/13 21:47:38  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.5  2011/02/08 08:17:50  acg
+//  Andy Goodrich: fixed bug in preempt_with() where I was resetting the
+//  process context rather than saving and restoring it.
+//
+// Revision 1.4  2011/02/01 21:12:56  acg
+//  Andy Goodrich: addition of preempt_with() method to allow immediate
+//  execution of threads for throws.
+//
+// Revision 1.3  2011/01/25 20:50:37  acg
+//  Andy Goodrich: changes for IEEE 1666 2011.
+//
+// Revision 1.2  2008/05/22 17:06:26  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.6  2006/05/26 20:33:16  acg
+//   Andy Goodrich: changes required by additional platform compilers (i.e.,
+//   Microsoft VC++, Sun Forte, HP aCC).
+//
+// Revision 1.5  2006/01/19 00:29:52  acg
+// Andy Goodrich: Yet another implementation for signal write checking. This
+// one uses an environment variable SC_SIGNAL_WRITE_CHECK, that when set to
+// DISABLE will disable write checking on signals.
+//
+// Revision 1.4  2006/01/18 21:42:37  acg
+// Andy Goodrich: Changes for check writer support.
+//
+// Revision 1.3  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+
+#endif
diff --git a/ext/systemc/src/sysc/kernel/sc_spawn.h b/ext/systemc/src/sysc/kernel/sc_spawn.h
new file mode 100644
index 000000000..e54886929
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_spawn.h
@@ -0,0 +1,337 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_spawn.h -- Process spawning support.
+
+  Original Authors: Andy Goodrich, Forte Design Systems, 17 June 2003
+                    Stuart Swan, Cadence,
+                    Bishnupriya Bhattacharya, Cadence Design Systems,
+                    25 August, 2003
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#if !defined(sc_spawn_h_INCLUDED)
+#define sc_spawn_h_INCLUDED
+
+#include "sysc/kernel/sc_process_handle.h"
+#include "sysc/kernel/sc_spawn_options.h"
+
+namespace sc_core {
+
+class sc_event;
+class sc_port_base;
+class sc_interface;
+class sc_event_finder;
+class sc_process_b;
+
+//=============================================================================
+// CLASS sc_spawn_object<T>
+//
+// This templated helper class allows an object to provide the execution 
+// semantics for a process via its () operator. An instance of the supplied 
+// execution object will be kept to provide the semantics when the process is 
+// scheduled for execution. The () operator does not return a value. An example 
+// of an object that might be used for this helper function would be void 
+// SC_BOOST bound function or method. 
+//
+// This class is derived from sc_process_host and overloads 
+// sc_process_host::semantics to provide the actual semantic content. 
+//
+//   sc_spawn_object(T object, const char* name, const sc_spawn_options* opt_p)
+//     This is the object instance constructor for this class. It makes a
+//     copy of the supplied object. The tp_call constructor is called
+//     with an indication that this object instance should be reclaimed when
+//     execution completes.
+//         object   =  object whose () operator will be called to provide
+//                     the process semantics.
+//         name_p   =  optional name for object instance, or zero.
+//         opt_p    -> spawn options or zero.
+//
+//   virtual void semantics()
+//     This virtual method provides the execution semantics for its process.
+//     It performs a () operation on m_object.
+//=============================================================================
+template<typename T>
+class sc_spawn_object : public sc_process_host {
+  public:
+    sc_spawn_object( T object) : m_object(object)
+    {
+    }
+
+    virtual void semantics()
+    {
+        m_object();
+    }
+
+  protected:
+    T                        m_object;
+};
+
+
+//------------------------------------------------------------------------------
+//"sc_spawn - semantic object with no return value"
+//
+// This inline function spawns a process for execution. The execution semantics 
+// for the process being spawned will be provided by the supplied object 
+// instance via its () operator. (E.g., a SC_BOOST bound function) 
+// After creating the process it is registered with the simulator.
+//     object   =   object instance providing the execution semantics via its 
+//                  () operator.
+//     name_p   =   optional name for object instance, or zero.
+//     opt_p    ->  optional spawn options for process, or zero for the default.
+//------------------------------------------------------------------------------
+template <typename T>
+inline sc_process_handle sc_spawn( 
+    T object, 
+    const char* name_p = 0,
+    const sc_spawn_options* opt_p = 0)
+{
+    sc_simcontext*      context_p;
+    sc_spawn_object<T>* spawn_p;
+    
+    context_p = sc_get_curr_simcontext();
+    spawn_p = new sc_spawn_object<T>(object);
+    if ( !opt_p || !opt_p->is_method() )
+    {
+            sc_process_handle thread_handle = context_p->create_thread_process( 
+            name_p, true,
+            SC_MAKE_FUNC_PTR(sc_spawn_object<T>,semantics), 
+            spawn_p, opt_p 
+        );
+        return thread_handle;
+    }
+    else
+    {
+            sc_process_handle method_handle = context_p->create_method_process( 
+            name_p, true,
+            SC_MAKE_FUNC_PTR(sc_spawn_object<T>,semantics), 
+            spawn_p, opt_p 
+        );
+        return method_handle;
+    }
+}
+
+//=============================================================================
+// CLASS sc_spawn_object_v<T> for all compilers except HP aCC
+//              or
+// CLASS sc_spawn_object_v<T, R> for HP aCC which tries to match this 
+// one template argument class when the sc_spawn() declared above is
+// invoked with 3 arguments or 2 arguments, and generates compiler errors.
+//
+// This templated helper class allows an object to provide the execution 
+// semantics for a process via its () operator. An instance of the supplied 
+// object will be kept to provide the semantics when the process is scheduled 
+// for execution. The () operator returns a value, which will be stored at the 
+// location specified by the supplied pointer. An example of an object that 
+// might be used for this helper function would be valued SC_BOOST bound 
+// function or method. 
+//
+//   sc_spawn_object_v( typename F::result_type* r_p, T f, const char* name_p,
+//                      const sc_spawn_options* opt_p )
+//       r_p      -> where to place the result of the function invocation.
+//       f        =  information to be executed.
+//       name_p   =  optional name for object instance, or zero.
+//       opt_p    -> optional spawn options for process, or zero for the default
+//     This is the object instance constructor for this class. It makes a
+//     copy of the supplied object. The tp_call constructor is called
+//     with an indication that this object instance should be reclaimed when
+//     execution completes.
+//         result_p -> where to place the value of the () operator.
+//         object   =  object whose () operator will be called to provide
+//                     the process semantics.
+//
+//   virtual void semantics()
+//     This virtual method provides the execution semantics for its process.
+//     It performs a () operation on m_object, placing the result at m_result_p.
+//=============================================================================
+
+//------------------------------------------------------------------------------
+//"sc_spawn_object_v - semantic object with return value"
+//
+// This inline function spawns a process for execution. The execution semantics 
+// for the process being spawned will be provided by the supplied object 
+// instance via its () operator. (E.g., a SC_BOOST bound function) That 
+// operator returns a value, which will be placed in the supplied return 
+// location. 
+// After creating the process it is registered with the simulator.
+//     object   =  object instance providing the execution semantics via its () 
+//                 operator.
+//     r_p      -> where to place the value of the () operator.
+//     name_p   =  optional name for object instance, or zero.
+//     opt_p    -> optional spawn options for process, or zero for the default.
+//------------------------------------------------------------------------------
+
+#if !defined (__HP_aCC)
+
+template<typename T>
+class sc_spawn_object_v : public sc_process_host {
+  public:
+    sc_spawn_object_v( typename T::result_type* r_p, T object ) :
+        m_object(object), m_result_p(r_p)
+    {
+    }
+
+    virtual void semantics()
+    {
+        *m_result_p = m_object();
+    }
+
+  protected:
+    T                        m_object;
+    typename T::result_type* m_result_p;
+};
+
+template <typename T>
+inline sc_process_handle sc_spawn( 
+    typename T::result_type* r_p, 
+    T object, 
+    const char* name_p = 0,
+    const sc_spawn_options* opt_p = 0)
+{
+    sc_simcontext*      context_p;
+    sc_spawn_object_v<T>* spawn_p;
+    
+    context_p = sc_get_curr_simcontext();
+    
+    spawn_p = new sc_spawn_object_v<T>(r_p, object);
+    if ( !opt_p || !opt_p->is_method() )
+    {
+            sc_process_handle thread_handle = context_p->create_thread_process( 
+            name_p, true,
+            SC_MAKE_FUNC_PTR(sc_spawn_object_v<T>,semantics), 
+            spawn_p, opt_p 
+        );
+        return thread_handle;
+    }
+    else
+    {
+            sc_process_handle method_handle = context_p->create_method_process( 
+            name_p, true,
+            SC_MAKE_FUNC_PTR(sc_spawn_object_v<T>,semantics), 
+            spawn_p, opt_p 
+        );
+        return method_handle;
+    }
+}
+
+#else
+// for HP aCC
+template<typename T, typename R>
+class sc_spawn_object_v : public sc_process_host {
+  public:
+    sc_spawn_object_v( R* r_p, T object) :
+        m_object(object), m_result_p(r_p)
+    {
+    }
+
+    virtual void semantics()
+    {
+        *m_result_p = m_object();
+    }
+
+  protected:
+    T  m_object;
+    R* m_result_p;
+};
+
+template <typename T, typename R>
+inline sc_process_handle sc_spawn( 
+    R* r_p, 
+    T object, 
+    const char* name_p = 0,
+    const sc_spawn_options* opt_p = 0)
+{
+    sc_simcontext*      context_p;
+    sc_spawn_object_v<T,R>* spawn_p;
+    
+    context_p = sc_get_curr_simcontext();
+    
+    spawn_p = new sc_spawn_object_v<T,R>(r_p, object);
+    if ( !opt_p || !opt_p->is_method() )
+    {
+            sc_process_handle thread_handle = context_p->create_thread_process( 
+            name_p, true,
+            static_cast<sc_core::SC_ENTRY_FUNC>(
+                &sc_spawn_object_v<T,R>::semantics),
+            spawn_p, opt_p 
+        );
+        return thread_handle;
+    }
+    else
+    {
+            sc_process_handle method_handle = context_p->create_method_process( 
+            name_p, true,
+            static_cast<sc_core::SC_ENTRY_FUNC>(
+                &sc_spawn_object_v<T,R>::semantics), 
+            spawn_p, opt_p 
+        );
+        return method_handle;
+    }
+}
+
+#endif // HP
+
+} // namespace sc_core
+
+// $Log: sc_spawn.h,v $
+// Revision 1.7  2011/08/26 20:46:11  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.6  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.5  2011/02/13 21:47:38  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.4  2011/02/01 21:14:02  acg
+//  Andy Goodrich: formatting.
+//
+// Revision 1.3  2009/07/28 01:10:53  acg
+//  Andy Goodrich: updates for 2.3 release candidate.
+//
+// Revision 1.2  2008/05/22 17:06:26  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.6  2006/05/26 20:33:16  acg
+//   Andy Goodrich: changes required by additional platform compilers (i.e.,
+//   Microsoft VC++, Sun Forte, HP aCC).
+//
+// Revision 1.5  2006/05/08 18:01:44  acg
+//  Andy Goodrich: changed the HP-specific implementations of sc_spawn() to
+//  use a static_cast to create their entry functions rather than the
+//  SC_MAKE_FUNC_PTR macro. The HP preprocessor does not parse template
+//  arguments that contain a comma properly.
+//
+// Revision 1.4  2006/04/11 23:13:21  acg
+//   Andy Goodrich: Changes for reduced reset support that only includes
+//   sc_cthread, but has preliminary hooks for expanding to method and thread
+//   processes also.
+//
+// Revision 1.3  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+
+#endif // !defined(sc_spawn_h_INCLUDED)
diff --git a/ext/systemc/src/sysc/kernel/sc_spawn_options.cpp b/ext/systemc/src/sysc/kernel/sc_spawn_options.cpp
new file mode 100644
index 000000000..c577f1d87
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_spawn_options.cpp
@@ -0,0 +1,124 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_spawn_options.cpp -- Process spawning options implementation.
+
+  Original Authors: Andy Goodrich, Forte Design Systems, 17 June 2003
+                    Stuart Swan, Cadence,
+                    Bishnupriya Bhattacharya, Cadence Design Systems,
+                    25 August, 2003
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+#include "sysc/kernel/sc_spawn_options.h"
+#include "sysc/kernel/sc_reset.h"
+
+namespace sc_core {
+
+// +======================================================================
+// | CLASS sc_spawn_reset_base - Class to do a generic access to an 
+// |                             sc_spawn_rest object instance
+// +======================================================================
+class sc_spawn_reset_base
+{
+  public:
+    sc_spawn_reset_base( bool async, bool level )
+      : m_async( async ), m_level(level)
+    {}
+    virtual ~sc_spawn_reset_base() {}
+    virtual void specify_reset() = 0;
+
+  protected:
+    bool m_async;   // = true if async reset.
+    bool m_level;   // level indicating reset.
+};
+
+// +======================================================================
+// | CLASS sc_spawn_reset<SOURCE>
+// |  - Reset specification for sc_spawn_options.
+// +======================================================================
+template<typename SOURCE>
+class sc_spawn_reset : public sc_spawn_reset_base
+{
+  public:
+    sc_spawn_reset( bool async, const SOURCE& source, bool level )
+      : sc_spawn_reset_base(async, level), m_source(source)
+    {}
+    virtual ~sc_spawn_reset() {}
+    virtual void specify_reset()
+    {
+        sc_reset::reset_signal_is( m_async, m_source, m_level );
+    }
+
+  protected:
+    const SOURCE& m_source; // source of reset signal.
+};
+
+// +======================================================================
+// | CLASS sc_spawn_options (implementation)
+// |
+// +======================================================================
+
+sc_spawn_options::~sc_spawn_options()
+{
+    std::vector<sc_spawn_reset_base*>::size_type resets_n = m_resets.size();
+    for ( std::vector<sc_spawn_reset_base*>::size_type reset_i = 0; reset_i < resets_n; reset_i++ )
+        delete m_resets[reset_i];
+}
+
+#define SC_DEFINE_RESET_SIGNALS( Port )                       \
+  /* asynchronous reset */                                    \
+  void                                                        \
+  sc_spawn_options::                                          \
+    async_reset_signal_is ( const Port & port, bool level )   \
+    {                                                         \
+        m_resets.push_back(                                   \
+            new sc_spawn_reset< Port >(true, port, level) );  \
+    }                                                         \
+  /* sync reset */                                            \
+  void                                                        \
+  sc_spawn_options::                                          \
+    reset_signal_is ( const Port & port, bool level )         \
+    {                                                         \
+        m_resets.push_back(                                   \
+            new sc_spawn_reset< Port >(false, port, level) ); \
+    }
+
+SC_DEFINE_RESET_SIGNALS( sc_in<bool> )
+SC_DEFINE_RESET_SIGNALS( sc_inout<bool> )
+SC_DEFINE_RESET_SIGNALS( sc_out<bool> )
+SC_DEFINE_RESET_SIGNALS( sc_signal_in_if<bool> )
+
+#undef SC_DEFINE_RESET_SIGNALS
+
+void
+sc_spawn_options::specify_resets() const
+{
+    std::vector<sc_spawn_reset_base*>::size_type resets_n; // number of reset specifications to process.
+    resets_n = m_resets.size();
+    for ( std::vector<sc_spawn_reset_base*>::size_type reset_i = 0; reset_i < resets_n; reset_i++ )
+        m_resets[reset_i]->specify_reset();
+}
+
+} // namespace sc_core
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_spawn_options.h b/ext/systemc/src/sysc/kernel/sc_spawn_options.h
new file mode 100644
index 000000000..4c3f64baa
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_spawn_options.h
@@ -0,0 +1,161 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_spawn_options.h -- Process spawning options specification.
+
+  Original Authors: Andy Goodrich, Forte Design Systems, 17 June 2003
+                    Stuart Swan, Cadence,
+                    Bishnupriya Bhattacharya, Cadence Design Systems,
+                    25 August, 2003
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+#if !defined(sc_spawn_options_h_INCLUDED)
+#define sc_spawn_options_h_INCLUDED
+
+#include <vector>
+#include "sysc/communication/sc_export.h"
+#include "sysc/communication/sc_signal_ports.h"
+
+namespace sc_core {
+
+class sc_event;
+class sc_port_base;
+class sc_interface;
+class sc_event_finder;
+class sc_process_b;
+class sc_spawn_reset_base;
+
+//=============================================================================
+// CLASS sc_spawn_options
+//
+//=============================================================================
+class sc_spawn_options {
+    friend class sc_cthread_process;
+    friend class sc_method_process;
+    friend class sc_process_b;
+    friend class sc_thread_process;
+  public:
+    sc_spawn_options() :                  
+        m_dont_initialize(false), m_resets(), m_sensitive_events(),
+        m_sensitive_event_finders(), m_sensitive_interfaces(),
+        m_sensitive_port_bases(), m_spawn_method(false), m_stack_size(0)
+        { }
+
+    ~sc_spawn_options();
+
+    void async_reset_signal_is( const sc_in<bool>&,           bool level );
+    void async_reset_signal_is( const sc_inout<bool>&,        bool level );
+    void async_reset_signal_is( const sc_out<bool>&,          bool level );
+    void async_reset_signal_is( const sc_signal_in_if<bool>&, bool level );
+
+    void reset_signal_is( const sc_in<bool>&,           bool level );
+    void reset_signal_is( const sc_inout<bool>&,        bool level );
+    void reset_signal_is( const sc_out<bool>&,          bool level );
+    void reset_signal_is( const sc_signal_in_if<bool>&, bool level );
+
+    void dont_initialize()   { m_dont_initialize = true; }
+
+    bool is_method() const   { return m_spawn_method; }
+
+    void set_stack_size(int stack_size) { m_stack_size = stack_size; }
+
+    void set_sensitivity(const sc_event* event) 
+        { m_sensitive_events.push_back(event); }
+
+    void set_sensitivity(sc_port_base* port_base)
+        { m_sensitive_port_bases.push_back(port_base); }
+
+    void set_sensitivity(sc_interface* interface_p) 
+        { m_sensitive_interfaces.push_back(interface_p); }
+
+    void set_sensitivity(sc_export_base* export_base) 
+        { m_sensitive_interfaces.push_back(export_base->get_interface()); }
+
+    void set_sensitivity(sc_event_finder* event_finder) 
+        { m_sensitive_event_finders.push_back(event_finder); }
+
+    void spawn_method()                 { m_spawn_method = true; }
+
+  protected:
+    void specify_resets() const;
+
+  private:
+    sc_spawn_options( const sc_spawn_options& );
+    const sc_spawn_options& operator = ( const sc_spawn_options& );
+
+  protected:
+    bool                               m_dont_initialize;         
+    std::vector<sc_spawn_reset_base*>  m_resets;
+    std::vector<const sc_event*>       m_sensitive_events;
+    std::vector<sc_event_finder*>      m_sensitive_event_finders; 
+    std::vector<sc_interface*>         m_sensitive_interfaces;
+    std::vector<sc_port_base*>         m_sensitive_port_bases;
+    bool                               m_spawn_method; // Method not thread.
+    int                                m_stack_size;   // Thread stack size.
+};
+
+} // namespace sc_core
+
+// $Log: sc_spawn_options.h,v $
+// Revision 1.11  2011/08/26 20:46:11  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.10  2011/08/24 22:05:51  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.9  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.8  2011/02/13 21:47:38  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.7  2011/02/07 19:17:20  acg
+//  Andy Goodrich: changes for IEEE 1666 compatibility.
+//
+// Revision 1.6  2010/12/07 20:09:15  acg
+// Andy Goodrich: replaced sc_signal signatures with sc_signal_in_if signatures for reset methods.
+//
+// Revision 1.5  2010/11/20 17:10:57  acg
+//  Andy Goodrich: reset processing changes for new IEEE 1666 standard.
+//
+// Revision 1.4  2009/05/22 16:06:29  acg
+//  Andy Goodrich: process control updates.
+//
+// Revision 1.3  2009/02/28 00:26:58  acg
+//  Andy Goodrich: changed boost name space to sc_boost to allow use with
+//  full boost library applications.
+//
+// Revision 1.2  2008/05/22 17:06:26  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.4  2006/04/20 17:08:17  acg
+//  Andy Goodrich: 3.0 style process changes.
+//
+// Revision 1.3  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+
+#endif // !defined(sc_spawn_options_h_INCLUDED)
diff --git a/ext/systemc/src/sysc/kernel/sc_status.h b/ext/systemc/src/sysc/kernel/sc_status.h
new file mode 100644
index 000000000..1d3b016db
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_status.h
@@ -0,0 +1,83 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_status.h -- Definition of the simulation phases
+
+  Original Author: Philipp A. Hartmann, OFFIS, 2013-02-15
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_STATUS_H_INCLUDED_
+#define SC_STATUS_H_INCLUDED_
+
+#include <iosfwd>
+
+namespace sc_core {
+
+// simulation status codes
+
+const int SC_SIM_OK        = 0;
+const int SC_SIM_ERROR     = 1;
+const int SC_SIM_USER_STOP = 2;
+
+enum sc_status
+{   // sc_get_status values:
+    SC_UNITIALIZED=0x00,                 // initialize() not called yet
+
+    SC_ELABORATION               = 0x01, // during module hierarchy construction
+    SC_BEFORE_END_OF_ELABORATION = 0x02, // during before_end_of_elaboration()
+    SC_END_OF_ELABORATION        = 0x04, // during end_of_elaboration()
+    SC_START_OF_SIMULATION       = 0x08, // during start_of_simulation()
+
+    SC_RUNNING                   = 0x10, // initialization, evaluation or update
+    SC_PAUSED                    = 0x20, // when scheduler stopped by sc_pause()
+    SC_STOPPED                   = 0x40, // when scheduler stopped by sc_stop()
+    SC_END_OF_SIMULATION         = 0x80, // during end_of_simulation()
+
+    // detailed simulation phases (for dynamic callbacks)
+    SC_END_OF_INITIALIZATION     = 0x100, // after initialization
+//    SC_END_OF_EVALUATION         = 0x200, // between eval and update
+    SC_END_OF_UPDATE             = 0x400, // after update/notify phase
+    SC_BEFORE_TIMESTEP           = 0x800, // before next time step
+
+    SC_STATUS_LAST               = SC_BEFORE_TIMESTEP,
+    SC_STATUS_ANY                = 0xdff
+};
+
+// pretty-printing of sc_status values
+std::ostream& operator << ( std::ostream&, sc_status );
+
+} // namespace sc_core
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+#endif /* SC_STATUS_H_INCLUDED_ */
+// Taf!
+
diff --git a/ext/systemc/src/sysc/kernel/sc_thread_process.cpp b/ext/systemc/src/sysc/kernel/sc_thread_process.cpp
new file mode 100644
index 000000000..140096c95
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_thread_process.cpp
@@ -0,0 +1,1127 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_thread_process.cpp -- Thread process implementation
+
+  Original Author: Andy Goodrich, Forte Design Systems, 4 August 2005
+               
+ CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+#include "sysc/kernel/sc_cmnhdr.h"
+#include "sysc/kernel/sc_constants.h"
+#include "sysc/kernel/sc_thread_process.h"
+#include "sysc/kernel/sc_process_handle.h"
+#include "sysc/kernel/sc_simcontext_int.h"
+#include "sysc/kernel/sc_module.h"
+#include "sysc/utils/sc_machine.h"
+
+// DEBUGGING MACROS:
+//
+// DEBUG_MSG(NAME,P,MSG)
+//     MSG  = message to print
+//     NAME = name that must match the process for the message to print, or
+//            null if the message should be printed unconditionally.
+//     P    = pointer to process message is for, or NULL in which case the
+//            message will not print.
+#if 0
+#   define DEBUG_NAME ""
+#   define DEBUG_MSG(NAME,P,MSG) \
+    { \
+        if ( P && ( (strlen(NAME)==0) || !strcmp(NAME,P->name())) ) \
+          std::cout << "**** " << sc_time_stamp() << " ("  \
+	            << sc_get_current_process_name() << "): " << MSG \
+		    << " - " << P->name() << std::endl; \
+    }
+#else
+#   define DEBUG_MSG(NAME,P,MSG) 
+#endif
+
+
+//------------------------------------------------------------------------------
+// user-defined default stack-size
+//------------------------------------------------------------------------------
+#if defined(SC_OVERRIDE_DEFAULT_STACK_SIZE)
+#   define SC_DEFAULT_STACK_SIZE_ SC_OVERRIDE_DEFAULT_STACK_SIZE
+
+//------------------------------------------------------------------------------
+// architecture-specific default stack sizes
+//------------------------------------------------------------------------------
+#elif !defined(SC_USE_PTHREADS) && (defined(__CYGWIN32__) || defined(__CYGWIN32))
+#   define SC_DEFAULT_STACK_SIZE_ 0x50000
+
+#elif defined(SC_LONG_64) || defined(__x86_64__) || defined(__LP64__) || \
+      defined(_M_X64) || defined(_M_AMD64)
+#   define SC_DEFAULT_STACK_SIZE_ 0x40000
+
+#else
+#   define SC_DEFAULT_STACK_SIZE_ 0x20000
+
+#endif // SC_DEFAULT_STACK_SIZE_
+
+
+//------------------------------------------------------------------------------
+// force 16-byte alignment on coroutine entry functions, needed for
+// QuickThreads (32-bit, see also fixes in qt/md/{i386,iX86_64}.[hs]),
+// and MinGW32 / Cygwin32 compilers on Windows platforms
+#if defined(__GNUC__) && !defined(__ICC) && !defined(__x86_64__) && \
+    (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ > 1 )
+# define SC_ALIGNED_STACK_ \
+    __attribute__((force_align_arg_pointer))
+#else
+# define SC_ALIGNED_STACK_ /* empty */
+#endif
+
+
+namespace sc_core {
+
+const int SC_DEFAULT_STACK_SIZE   = SC_DEFAULT_STACK_SIZE_;
+#undef SC_DEFAULT_STACK_SIZE_
+#undef SC_OVERRIDE_DEFAULT_STACK_SIZE
+
+//------------------------------------------------------------------------------
+//"sc_thread_cor_fn"
+// 
+// This function invokes the coroutine for the supplied object instance.
+//------------------------------------------------------------------------------
+SC_ALIGNED_STACK_
+void sc_thread_cor_fn( void* arg )
+{
+    sc_simcontext*   simc_p = sc_get_curr_simcontext();
+    sc_thread_handle thread_h = RCAST<sc_thread_handle>( arg );
+
+    // PROCESS THE THREAD AND PROCESS ANY EXCEPTIONS THAT ARE THROWN:
+
+    while( true ) {
+
+        try {
+            thread_h->semantics();
+        }
+        catch( sc_user ) {
+            continue;
+        }
+        catch( sc_halt ) {
+            ::std::cout << "Terminating process "
+                      << thread_h->name() << ::std::endl;
+        }
+        catch( const sc_unwind_exception& ex ) {
+	    ex.clear();
+            if ( ex.is_reset() ) continue;
+        }
+        catch( ... ) {
+            sc_report* err_p = sc_handle_exception();
+            thread_h->simcontext()->set_error( err_p );
+        }
+        break;
+    }
+
+    sc_process_b*    active_p = sc_get_current_process_b();
+
+    // REMOVE ALL TRACES OF OUR THREAD FROM THE SIMULATORS DATA STRUCTURES:
+
+    thread_h->disconnect_process();
+
+    // IF WE AREN'T ACTIVE MAKE SURE WE WON'T EXECUTE:
+
+    if ( thread_h->next_runnable() != 0 )
+    {
+	simc_p->remove_runnable_thread(thread_h);
+    }
+
+    // IF WE ARE THE ACTIVE PROCESS ABORT OUR EXECUTION:
+
+
+    if ( active_p == (sc_process_b*)thread_h )
+    {
+     
+        sc_core::sc_cor* x = simc_p->next_cor();
+	simc_p->cor_pkg()->abort( x );
+    }
+
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_thread_process::disable_process"
+//
+// This virtual method suspends this process and its children if requested to.
+//     descendants = indicator of whether this process' children should also
+//                   be suspended
+//------------------------------------------------------------------------------
+void sc_thread_process::disable_process(
+    sc_descendant_inclusion_info descendants )
+{     
+
+    // IF NEEDED PROPOGATE THE DISABLE REQUEST THROUGH OUR DESCENDANTS:
+
+    if ( descendants == SC_INCLUDE_DESCENDANTS )
+    {
+        const std::vector<sc_object*>& children = get_child_objects();
+        int                            child_n  = children.size();
+
+        for ( int child_i = 0; child_i < child_n; child_i++ )
+        {
+            sc_process_b* child_p = DCAST<sc_process_b*>(children[child_i]);
+            if ( child_p ) child_p->disable_process(descendants);
+        }
+    }
+
+    // DON'T ALLOW CORNER CASE BY DEFAULT:
+
+    if ( !sc_allow_process_control_corners )
+    {
+	switch( m_trigger_type )
+	{ 
+	  case AND_LIST_TIMEOUT:
+	  case EVENT_TIMEOUT: 
+	  case OR_LIST_TIMEOUT:
+	  case TIMEOUT:
+	    report_error(SC_ID_PROCESS_CONTROL_CORNER_CASE_,
+		         "attempt to disable a thread with timeout wait");
+	    break;
+	  default:
+	    break;
+	}
+    }
+
+    // DISABLE OUR OBJECT INSTANCE:
+
+    m_state = m_state | ps_bit_disabled; 
+
+    // IF THIS CALL IS BEFORE THE SIMULATION DON'T RUN THE THREAD:
+
+    if ( !sc_is_running() ) 
+    {
+	m_state = m_state | ps_bit_ready_to_run;
+        simcontext()->remove_runnable_thread(this);
+    }
+}
+
+//------------------------------------------------------------------------------
+//"sc_thread_process::enable_process"
+//
+// This method resumes the execution of this process, and if requested, its
+// descendants. If the process was suspended and has a resumption pending it 
+// will be dispatched in the next delta cycle. Otherwise the state will be
+// adjusted to indicate it is no longer suspended, but no immediate execution
+// will occur.
+//------------------------------------------------------------------------------
+void sc_thread_process::enable_process(
+    sc_descendant_inclusion_info descendants )
+{
+
+    // IF NEEDED PROPOGATE THE ENABLE REQUEST THROUGH OUR DESCENDANTS:
+
+    if ( descendants == SC_INCLUDE_DESCENDANTS )
+    {
+        const std::vector<sc_object*>& children = get_child_objects();
+        int                            child_n  = children.size();
+
+        for ( int child_i = 0; child_i < child_n; child_i++ )
+        {
+            sc_process_b* child_p = DCAST<sc_process_b*>(children[child_i]);
+            if ( child_p ) child_p->enable_process(descendants);
+        }
+    }
+
+    // ENABLE THIS OBJECT INSTANCE:
+    //
+    // If it was disabled and ready to run then put it on the run queue.
+
+    m_state = m_state & ~ps_bit_disabled; 
+    if ( m_state == ps_bit_ready_to_run && sc_allow_process_control_corners )
+    {
+        m_state = ps_normal;
+	if ( next_runnable() == 0 )
+	    simcontext()->push_runnable_thread(this);
+    }
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_thread_process::kill_process"
+//
+// This method removes this object instance from use. It calls the
+// sc_process_b::kill_process() method to perform low level clean up. Then
+// it aborts this process if it is the active process.
+//------------------------------------------------------------------------------
+void sc_thread_process::kill_process(sc_descendant_inclusion_info descendants )
+{
+
+    // IF THE SIMULATION HAS NOT BEEN INITIALIZED YET THAT IS AN ERROR:
+
+    if ( !sc_is_running() )
+    {
+        report_error( SC_ID_KILL_PROCESS_WHILE_UNITIALIZED_ );
+    }
+
+    // IF NEEDED PROPOGATE THE KILL REQUEST THROUGH OUR DESCENDANTS:
+
+    if ( descendants == SC_INCLUDE_DESCENDANTS )
+    {
+        const std::vector<sc_object*> children = get_child_objects();
+        int                           child_n  = children.size();
+
+        for ( int child_i = 0; child_i < child_n; child_i++ )
+        {
+            sc_process_b* child_p = DCAST<sc_process_b*>(children[child_i]);
+            if ( child_p ) child_p->kill_process(descendants);
+        }
+    }
+
+    // IF THE PROCESS IS CURRENTLY UNWINDING OR IS ALREADY A ZOMBIE
+    // IGNORE THE KILL:
+
+    if ( m_unwinding )
+    {
+        SC_REPORT_WARNING( SC_ID_PROCESS_ALREADY_UNWINDING_, name() );
+        return;
+    }
+
+    if ( m_state & ps_bit_zombie )
+        return;
+
+    // SET UP TO KILL THE PROCESS IF SIMULATION HAS STARTED:
+    //
+    // If the thread does not have a stack don't try the throw!
+
+    if ( sc_is_running() && m_has_stack )
+    {
+        m_throw_status = THROW_KILL;
+        m_wait_cycle_n = 0;
+        simcontext()->preempt_with(this);
+    }
+
+    // IF THE SIMULATION HAS NOT STARTED REMOVE TRACES OF OUR PROCESS FROM 
+    // EVENT QUEUES, ETC.:
+
+    else
+    {
+        disconnect_process();
+    }
+}
+
+//------------------------------------------------------------------------------
+//"sc_thread_process::prepare_for_simulation"
+//
+// This method prepares this object instance for simulation. It calls the
+// coroutine package to create the actual thread.
+//------------------------------------------------------------------------------
+void sc_thread_process::prepare_for_simulation()
+{
+    m_cor_p = simcontext()->cor_pkg()->create( m_stack_size,
+                         sc_thread_cor_fn, this );
+    m_cor_p->stack_protect( true );
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_thread_process::resume_process"
+//
+// This method resumes the execution of this process, and if requested, its
+// descendants. If the process was suspended and has a resumption pending it 
+// will be dispatched in the next delta cycle. Otherwise the state will be
+// adjusted to indicate it is no longer suspended, but no immediate execution
+// will occur.
+//------------------------------------------------------------------------------
+void sc_thread_process::resume_process(
+    sc_descendant_inclusion_info descendants )
+{
+
+    // IF NEEDED PROPOGATE THE RESUME REQUEST THROUGH OUR DESCENDANTS:
+
+    if ( descendants == SC_INCLUDE_DESCENDANTS )
+    {
+        const std::vector<sc_object*>& children = get_child_objects();
+        int                            child_n  = children.size();
+
+        for ( int child_i = 0; child_i < child_n; child_i++ )
+        {
+            sc_process_b* child_p = DCAST<sc_process_b*>(children[child_i]);
+            if ( child_p ) child_p->resume_process(descendants);
+        }
+    }
+
+    // BY DEFAULT THE CORNER CASE IS AN ERROR:
+
+    if ( !sc_allow_process_control_corners && (m_state & ps_bit_disabled) &&
+         (m_state & ps_bit_suspended) )
+    {
+	m_state = m_state & ~ps_bit_suspended;
+        report_error(SC_ID_PROCESS_CONTROL_CORNER_CASE_, 
+	             "call to resume() on a disabled suspended thread");
+    }
+
+    // CLEAR THE SUSPENDED BIT:
+
+    m_state = m_state & ~ps_bit_suspended;
+
+    // RESUME OBJECT INSTANCE IF IT IS READY TO RUN:
+
+    if ( m_state & ps_bit_ready_to_run )
+    {
+	m_state = m_state & ~ps_bit_ready_to_run;
+	if ( next_runnable() == 0 )  
+	    simcontext()->push_runnable_thread(this);
+	remove_dynamic_events();  // order important.
+    }
+}
+
+//------------------------------------------------------------------------------
+//"sc_thread_process::sc_thread_process"
+//
+// This is the object instance constructor for this class.
+//------------------------------------------------------------------------------
+sc_thread_process::sc_thread_process( const char* name_p, bool free_host,
+    SC_ENTRY_FUNC method_p, sc_process_host* host_p, 
+    const sc_spawn_options* opt_p 
+):
+    sc_process_b(
+        name_p ? name_p : sc_gen_unique_name("thread_p"), 
+        true, free_host, method_p, host_p, opt_p),
+    m_cor_p(0), m_monitor_q(), m_stack_size(SC_DEFAULT_STACK_SIZE),
+    m_wait_cycle_n(0)
+{
+
+    // CHECK IF THIS IS AN sc_module-BASED PROCESS AND SIMULATION HAS STARTED:
+
+    if ( DCAST<sc_module*>(host_p) != 0 && sc_is_running() )
+    {
+        report_error( SC_ID_MODULE_THREAD_AFTER_START_ );
+    }
+
+    // INITIALIZE VALUES:
+    //
+    // If there are spawn options use them.
+
+    m_process_kind = SC_THREAD_PROC_;
+
+    if (opt_p) {
+        m_dont_init = opt_p->m_dont_initialize;
+        if ( opt_p->m_stack_size ) m_stack_size = opt_p->m_stack_size;
+
+        // traverse event sensitivity list
+        for (unsigned int i = 0; i < opt_p->m_sensitive_events.size(); i++) {
+            sc_sensitive::make_static_sensitivity(
+                this, *opt_p->m_sensitive_events[i]);
+        }
+
+        // traverse port base sensitivity list
+        for ( unsigned int i = 0; i < opt_p->m_sensitive_port_bases.size(); i++)
+        {
+            sc_sensitive::make_static_sensitivity(
+                this, *opt_p->m_sensitive_port_bases[i]);
+        }
+
+        // traverse interface sensitivity list
+        for ( unsigned int i = 0; i < opt_p->m_sensitive_interfaces.size(); i++)
+        {
+            sc_sensitive::make_static_sensitivity(
+                this, *opt_p->m_sensitive_interfaces[i]);
+        }
+
+        // traverse event finder sensitivity list
+        for ( unsigned int i = 0; i < opt_p->m_sensitive_event_finders.size();
+            i++)
+        {
+            sc_sensitive::make_static_sensitivity(
+                this, *opt_p->m_sensitive_event_finders[i]);
+        }
+
+        // process any reset signal specification:
+
+	opt_p->specify_resets();
+
+    }
+
+    else
+    {
+        m_dont_init = false;
+    }
+
+}
+
+//------------------------------------------------------------------------------
+//"sc_thread_process::~sc_thread_process"
+//
+// This is the object instance constructor for this class.
+//------------------------------------------------------------------------------
+sc_thread_process::~sc_thread_process()
+{
+
+    // DESTROY THE COROUTINE FOR THIS THREAD:
+
+    if( m_cor_p != 0 ) {
+        m_cor_p->stack_protect( false );
+        delete m_cor_p;
+        m_cor_p = 0;
+    }
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_thread_process::signal_monitors"
+//
+// This methods signals the list of monitors for this object instance.
+//------------------------------------------------------------------------------
+void sc_thread_process::signal_monitors(int type)
+{       
+    int mon_n;  // # of monitors present.
+        
+    mon_n = m_monitor_q.size();
+    for ( int mon_i = 0; mon_i < mon_n; mon_i++ )
+        m_monitor_q[mon_i]->signal(this, type);
+}   
+
+
+//------------------------------------------------------------------------------
+//"sc_thread_process::suspend_process"
+//
+// This virtual method suspends this process and its children if requested to.
+//     descendants = indicator of whether this process' children should also
+//                   be suspended
+//------------------------------------------------------------------------------
+void sc_thread_process::suspend_process(
+    sc_descendant_inclusion_info descendants )
+{     
+
+    // IF NEEDED PROPOGATE THE SUSPEND REQUEST THROUGH OUR DESCENDANTS:
+
+    if ( descendants == SC_INCLUDE_DESCENDANTS )
+    {
+        const std::vector<sc_object*>& children = get_child_objects();
+        int                            child_n  = children.size();
+
+        for ( int child_i = 0; child_i < child_n; child_i++ )
+        {
+            sc_process_b* child_p = DCAST<sc_process_b*>(children[child_i]);
+            if ( child_p ) child_p->suspend_process(descendants);
+        }
+    }
+
+    // CORNER CASE CHECKS, THE FOLLOWING ARE ERRORS:
+    //   (a) if this thread has a reset_signal_is specification 
+    //   (b) if this thread is in synchronous reset
+
+    if ( !sc_allow_process_control_corners && m_has_reset_signal )
+    {
+	report_error(SC_ID_PROCESS_CONTROL_CORNER_CASE_,
+		     "attempt to suspend a thread that has a reset signal");
+    }
+    else if ( !sc_allow_process_control_corners && m_sticky_reset )
+    {
+	report_error(SC_ID_PROCESS_CONTROL_CORNER_CASE_,
+		     "attempt to suspend a thread in synchronous reset");
+    }
+
+    // SUSPEND OUR OBJECT INSTANCE:
+    //
+    // (1) If we are on the runnable queue then set suspended and ready_to_run,
+    //     and remove ourselves from the run queue.
+    // (2) If this is a self-suspension then a resume should cause immediate
+    //     scheduling of the process, and we need to call suspend_me() here.
+
+    m_state = m_state | ps_bit_suspended;
+    if ( next_runnable() != 0 ) 
+    {
+	m_state = m_state | ps_bit_ready_to_run;
+	simcontext()->remove_runnable_thread( this );
+    }
+    if ( sc_get_current_process_b() == DCAST<sc_process_b*>(this)  )
+    {
+	m_state = m_state | ps_bit_ready_to_run;
+	suspend_me();
+    }
+}
+
+//------------------------------------------------------------------------------
+//"sc_thread_process::throw_reset"
+//
+// This virtual method is invoked when an reset is to be thrown. The
+// method will cancel any dynamic waits. If the reset is asynchronous it will 
+// queue this object instance to be executed. 
+//------------------------------------------------------------------------------
+void sc_thread_process::throw_reset( bool async )
+{     
+    // IF THE PROCESS IS CURRENTLY UNWINDING OR IS ALREADY A ZOMBIE
+    // IGNORE THE RESET:
+
+    if ( m_unwinding )
+    {
+        SC_REPORT_WARNING( SC_ID_PROCESS_ALREADY_UNWINDING_, name() );
+        return;
+    }
+
+    if ( m_state & ps_bit_zombie )
+        return;
+
+
+    // Set the throw type and clear any pending dynamic events: 
+
+    m_throw_status = async ? THROW_ASYNC_RESET : THROW_SYNC_RESET;
+    m_wait_cycle_n = 0;
+
+    // If this is an asynchronous reset:
+    //
+    //   (a) Cancel any dynamic events 
+    //   (b) Set the thread up for execution:
+    //         (i) If we are in the execution phase do it now.
+    //         (ii) If we are not queue it to execute next when we hit
+    //              the execution phase.
+
+    if ( async ) 
+    {
+        m_state = m_state & ~ps_bit_ready_to_run;
+        remove_dynamic_events();
+	if ( simcontext()->evaluation_phase() )
+	{
+            simcontext()->preempt_with( this );
+	}
+	else
+	{
+	    if ( is_runnable() )
+	        simcontext()->remove_runnable_thread(this);
+	    simcontext()->execute_thread_next(this);
+	}
+    }
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_thread_process::throw_user"
+//
+// This virtual method is invoked when a user exception is to be thrown.
+// If requested it will also throw the exception to the children of this 
+// object instance. The order of dispatch for the processes that are 
+// thrown the exception is from youngest child to oldest child and then
+// this process instance. This means that this instance will be pushed onto
+// the front of the simulator's runnable queue and then the children will
+// be processed recursively.
+//     helper_p    =  helper object to use to throw the exception.
+//     descendants =  indicator of whether this process' children should also
+//                    be suspended
+//------------------------------------------------------------------------------
+void sc_thread_process::throw_user( const sc_throw_it_helper& helper,
+    sc_descendant_inclusion_info descendants )
+{     
+
+    // IF THE SIMULATION IS NOT ACTAULLY RUNNING THIS IS AN ERROR:
+
+    if ( sc_get_status() != SC_RUNNING )
+    {
+        report_error( SC_ID_THROW_IT_WHILE_NOT_RUNNING_ ); 
+    }
+
+    // IF NEEDED PROPOGATE THE THROW REQUEST THROUGH OUR DESCENDANTS:
+
+    if ( descendants == SC_INCLUDE_DESCENDANTS )
+    {
+        const std::vector<sc_object*> children = get_child_objects();
+        int                           child_n  = children.size();
+
+        for ( int child_i = 0; child_i < child_n; child_i++ )
+        {
+            sc_process_b* child_p = DCAST<sc_process_b*>(children[child_i]);
+            if ( child_p )
+	    {
+	        DEBUG_MSG(DEBUG_NAME,child_p,"about to throw user on");
+	        child_p->throw_user(helper, descendants);
+	    }
+        }
+    }
+
+    // IF THE PROCESS IS CURRENTLY UNWINDING IGNORE THE THROW:
+
+    if ( m_unwinding )
+    {
+        SC_REPORT_WARNING( SC_ID_PROCESS_ALREADY_UNWINDING_, name() );
+	return; 
+    }
+
+    // SET UP THE THROW REQUEST FOR THIS OBJECT INSTANCE AND QUEUE IT FOR
+    // EXECUTION:
+
+    if( m_has_stack )
+    {
+        remove_dynamic_events();
+        DEBUG_MSG(DEBUG_NAME,this,"throwing user exception to");
+        m_throw_status = THROW_USER;
+        if ( m_throw_helper_p != 0 ) delete m_throw_helper_p;
+        m_throw_helper_p = helper.clone();
+        simcontext()->preempt_with( this );
+    }
+    else
+    {
+        SC_REPORT_WARNING( SC_ID_THROW_IT_IGNORED_, name() );
+    }
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_thread_process::trigger_dynamic"
+//
+// This method sets up a dynamic trigger on an event.
+//
+// Notes:
+//   (1) This method is identical to sc_method_process::trigger_dynamic(), 
+//       but they cannot be combined as sc_process_b::trigger_dynamic() 
+//       because the signatures things like sc_event::remove_dynamic()
+//       have different overloads for sc_thread_process* and sc_method_process*.
+//       So if you change code here you'll also need to change it in 
+//       sc_method_process.cpp.
+//
+// Result is true if this process should be removed from the event's list,
+// false if not.
+//------------------------------------------------------------------------------
+bool sc_thread_process::trigger_dynamic( sc_event* e )
+{
+    // No time outs yet, and keep gcc happy.
+
+    m_timed_out = false;
+
+    // Escape cases:
+    //   (a) If this thread issued the notify() don't schedule it for
+    //       execution, but leave the sensitivity in place.
+    //   (b) If this thread is already runnable can't trigger an event.
+
+    // not possible for thread processes!
+#if 0 // ! defined( SC_ENABLE_IMMEDIATE_SELF_NOTIFICATIONS )
+    if ( sc_get_current_process_b() == (sc_process_b*)this )
+    {
+        report_immediate_self_notification();
+        return false;
+    }
+#endif // SC_ENABLE_IMMEDIATE_SELF_NOTIFICATIONS
+
+    if( is_runnable() ) 
+        return true;
+
+    // If a process is disabled then we ignore any events, leaving them enabled:
+    //
+    // But if this is a time out event we need to remove both it and the
+    // event that was being waited for.
+
+    if ( m_state & ps_bit_disabled )
+    {
+        if ( e == m_timeout_event_p )
+	{
+	    remove_dynamic_events( true );  
+	    return true;
+	}
+	else
+	{
+	    return false;
+	}
+    }
+
+
+    // Process based on the event type and current process state:
+    //
+    // Every case needs to set 'rc' and continue on to the end of
+    // this method to allow suspend processing to work correctly.
+
+    switch( m_trigger_type ) 
+    {
+      case EVENT: 
+	m_event_p = 0;
+	m_trigger_type = STATIC;
+	break;
+
+      case AND_LIST:
+        -- m_event_count;
+	if ( m_event_count == 0 )
+	{
+	    m_event_list_p->auto_delete();
+	    m_event_list_p = 0;
+	    m_trigger_type = STATIC;
+	}
+	else
+	{
+	    return true;
+	}
+	break;
+
+      case OR_LIST:
+	m_event_list_p->remove_dynamic( this, e );
+	m_event_list_p->auto_delete();
+	m_event_list_p = 0;
+	m_trigger_type = STATIC;
+	break;
+
+      case TIMEOUT: 
+	m_trigger_type = STATIC;
+	break;
+
+      case EVENT_TIMEOUT: 
+        if ( e == m_timeout_event_p )
+	{
+	    m_timed_out = true;
+	    m_event_p->remove_dynamic( this );
+	    m_event_p = 0;
+	    m_trigger_type = STATIC;
+	}
+	else
+	{
+	    m_timeout_event_p->cancel();
+	    m_timeout_event_p->reset();
+	    m_event_p = 0;
+	    m_trigger_type = STATIC;
+	}
+	break;
+
+      case OR_LIST_TIMEOUT:
+        if ( e == m_timeout_event_p )
+	{
+            m_timed_out = true;
+            m_event_list_p->remove_dynamic( this, e ); 
+            m_event_list_p->auto_delete();
+            m_event_list_p = 0; 
+            m_trigger_type = STATIC;
+	}
+
+	else
+	{
+            m_timeout_event_p->cancel();
+            m_timeout_event_p->reset();
+	    m_event_list_p->remove_dynamic( this, e ); 
+	    m_event_list_p->auto_delete();
+	    m_event_list_p = 0; 
+	    m_trigger_type = STATIC;
+	}
+	break;
+      
+      case AND_LIST_TIMEOUT:
+        if ( e == m_timeout_event_p )
+	{
+            m_timed_out = true;
+            m_event_list_p->remove_dynamic( this, e ); 
+            m_event_list_p->auto_delete();
+            m_event_list_p = 0; 
+            m_trigger_type = STATIC;
+	}
+
+	else
+	{
+	    -- m_event_count;
+	    if ( m_event_count == 0 )
+	    {
+		m_timeout_event_p->cancel();
+		m_timeout_event_p->reset();
+		// no need to remove_dynamic
+		m_event_list_p->auto_delete();
+		m_event_list_p = 0; 
+		m_trigger_type = STATIC;
+	    }
+	    else
+	    {
+	        return true;
+	    }
+	}
+	break;
+
+      case STATIC: {
+        // we should never get here, but throw_it() can make it happen.
+	SC_REPORT_WARNING(SC_ID_NOT_EXPECTING_DYNAMIC_EVENT_NOTIFY_, name());
+        return true;
+      }
+    }
+
+    // If we get here then the thread is has satisfied its wait criteria, if 
+    // its suspended mark its state as ready to run. If its not suspended then 
+    // push it onto the runnable queue.
+
+    if ( (m_state & ps_bit_suspended) )
+    {
+	m_state = m_state | ps_bit_ready_to_run;
+    }
+    else
+    {
+        simcontext()->push_runnable_thread(this);
+    }
+
+    return true;
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_set_stack_size"
+//
+//------------------------------------------------------------------------------
+void
+sc_set_stack_size( sc_thread_handle thread_h, std::size_t size )
+{
+    thread_h->set_stack_size( size );
+}
+
+#undef DEBUG_MSG
+#undef DEBUG_NAME
+
+} // namespace sc_core 
+
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_thread_process.cpp,v $
+// Revision 1.57  2011/08/24 22:05:51  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.56  2011/08/07 19:08:04  acg
+//  Andy Goodrich: moved logs to end of file so line number synching works
+//  better between versions.
+//
+// Revision 1.55  2011/08/04 17:16:22  acg
+//  Philipp A. Hartmann: fix handling of child objects in kill routine, need
+//  to use a copy rather than a reference.
+//
+// Revision 1.53  2011/07/29 22:45:38  acg
+//  Philipp A. Hartmann: changes to handle case where a process control
+//  invocation on a child process causes the list of child processes to change.
+//
+// Revision 1.52  2011/07/24 11:27:04  acg
+//  Andy Goodrich: moved the check for unwinding processes until after the
+//  descendants have been processed in throw_user and kill.
+//
+// Revision 1.51  2011/07/24 11:20:03  acg
+//  Philipp A. Hartmann: process control error message improvements:
+//  (1) Downgrade error to warning for re-kills of processes.
+//  (2) Add process name to process messages.
+//  (3) drop some superfluous colons in messages.
+//
+// Revision 1.50  2011/05/09 04:07:49  acg
+//  Philipp A. Hartmann:
+//    (1) Restore hierarchy in all phase callbacks.
+//    (2) Ensure calls to before_end_of_elaboration.
+//
+// Revision 1.49  2011/05/05 17:45:27  acg
+//  Philip A. Hartmann: changes in WIN64 support.
+//  Andy Goodrich: additional DEBUG_MSG instances to trace process handling.
+//
+// Revision 1.48  2011/04/19 15:04:27  acg
+//  Philipp A. Hartmann: clean up SC_ID messages.
+//
+// Revision 1.47  2011/04/19 02:39:09  acg
+//  Philipp A. Hartmann: added checks for additional throws during stack unwinds.
+//
+// Revision 1.46  2011/04/14 22:33:43  acg
+//  Andy Goodrich: added missing checks for a process being a zombie.
+//
+// Revision 1.45  2011/04/13 02:45:11  acg
+//  Andy Goodrich: eliminated warning message that occurred if the DEBUG_MSG
+//  macro was used.
+//
+// Revision 1.44  2011/04/11 22:04:33  acg
+//  Andy Goodrich: use the DEBUG_NAME macro for DEBUG_MSG messages.
+//
+// Revision 1.43  2011/04/10 22:12:32  acg
+//  Andy Goodrich: adding debugging macros.
+//
+// Revision 1.42  2011/04/08 22:40:26  acg
+//  Andy Goodrich: moved the reset event notification code out of throw_reset()
+//  and into suspend_me.
+//
+// Revision 1.41  2011/04/08 18:24:07  acg
+//  Andy Goodrich: fix asynchronous reset dispatch and when the reset_event()
+//  is fired.
+//
+// Revision 1.40  2011/04/05 20:50:57  acg
+//  Andy Goodrich:
+//    (1) changes to make sure that event(), posedge() and negedge() only
+//        return true if the clock has not moved.
+//    (2) fixes for method self-resumes.
+//    (3) added SC_PRERELEASE_VERSION
+//    (4) removed kernel events from the object hierarchy, added
+//        sc_hierarchy_name_exists().
+//
+// Revision 1.39  2011/04/01 22:30:39  acg
+//  Andy Goodrich: change hard assertion to warning for trigger_dynamic()
+//  getting called when there is only STATIC sensitivity. This can result
+//  because of sc_process_handle::throw_it().
+//
+// Revision 1.38  2011/03/23 16:17:52  acg
+//  Andy Goodrich: don't emit an error message for a resume on a disabled
+//  process that is not suspended.
+//
+// Revision 1.37  2011/03/20 13:43:23  acg
+//  Andy Goodrich: added async_signal_is() plus suspend() as a corner case.
+//
+// Revision 1.36  2011/03/08 20:49:31  acg
+//  Andy Goodrich: implement coarse checking for synchronous reset - suspend
+//  interaction.
+//
+// Revision 1.35  2011/03/08 20:32:28  acg
+//  Andy Goodrich: implemented "coarse" checking for undefined process
+//  control interactions.
+//
+// Revision 1.34  2011/03/07 18:25:19  acg
+//  Andy Goodrich: tightening of check for resume on a disabled process to
+//  only produce an error if it is ready to run.
+//
+// Revision 1.33  2011/03/07 17:38:44  acg
+//  Andy Goodrich: tightening up of checks for undefined interaction between
+//  synchronous reset and suspend.
+//
+// Revision 1.32  2011/03/06 23:30:13  acg
+//  Andy Goodrich: refining suspend - sync reset corner case checking so that
+//  the following are error situations:
+//    (1) Calling suspend on a process with a reset_signal_is() specification
+//        or sync_reset_on() is active.
+//    (2) Calling sync_reset_on() on a suspended process.
+//
+// Revision 1.31  2011/03/06 19:57:11  acg
+//  Andy Goodrich: refinements for the illegal suspend - synchronous reset
+//  interaction.
+//
+// Revision 1.30  2011/03/06 16:47:09  acg
+//  Andy Goodrich: changes for testing sync_reset - suspend corner cases.
+//
+// Revision 1.29  2011/03/06 15:59:23  acg
+//  Andy Goodrich: added process control corner case checks.
+//
+// Revision 1.28  2011/03/05 19:44:20  acg
+//  Andy Goodrich: changes for object and event naming and structures.
+//
+// Revision 1.27  2011/02/19 08:30:53  acg
+//  Andy Goodrich: Moved process queueing into trigger_static from
+//  sc_event::notify.
+//
+// Revision 1.26  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.25  2011/02/17 19:54:33  acg
+//  Andy Goodrich:
+//    (1) Changed signature of trigger_dynamic() back to bool, and moved
+//        run queue processing into trigger_dynamic.
+//    (2) Simplified process control usage.
+//
+// Revision 1.24  2011/02/16 22:37:31  acg
+//  Andy Goodrich: clean up to remove need for ps_disable_pending.
+//
+// Revision 1.23  2011/02/14 17:51:40  acg
+//  Andy Goodrich: proper pushing an poppping of the module hierarchy for
+//  start_of_simulation() and end_of_simulation.
+//
+// Revision 1.22  2011/02/13 23:09:58  acg
+//  Andy Goodrich: only remove dynamic events for asynchronous resets.
+//
+// Revision 1.21  2011/02/13 21:47:38  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.20  2011/02/13 21:37:13  acg
+//  Andy Goodrich: removed temporary diagnostic. Also there is
+//  remove_dynamic_events() call in reset code.
+//
+// Revision 1.19  2011/02/13 21:35:09  acg
+//  Andy Goodrich: added error messages for throws before the simulator is
+//  initialized.
+//
+// Revision 1.18  2011/02/11 13:25:24  acg
+//  Andy Goodrich: Philipp A. Hartmann's changes:
+//    (1) Removal of SC_CTHREAD method overloads.
+//    (2) New exception processing code.
+//
+// Revision 1.17  2011/02/08 08:18:16  acg
+//  Andy Goodrich: removed obsolete code.
+//
+// Revision 1.16  2011/02/07 19:17:20  acg
+//  Andy Goodrich: changes for IEEE 1666 compatibility.
+//
+// Revision 1.15  2011/02/04 15:27:36  acg
+//  Andy Goodrich: changes for suspend-resume semantics.
+//
+// Revision 1.14  2011/02/01 23:01:53  acg
+//  Andy Goodrich: removed dead code.
+//
+// Revision 1.13  2011/02/01 21:16:36  acg
+//  Andy Goodrich:
+//  (1) New version of trigger_dynamic() to implement new return codes and
+//      proper processing of events with new dynamic process rules.
+//  (2) Recoding of kill_process(), throw_user() and reset support to
+//      consolidate preemptive thread execution in sc_simcontext::preempt_with().
+//
+// Revision 1.12  2011/01/25 20:50:37  acg
+//  Andy Goodrich: changes for IEEE 1666 2011.
+//
+// Revision 1.11  2011/01/20 16:52:20  acg
+//  Andy Goodrich: changes for IEEE 1666 2011.
+//
+// Revision 1.10  2011/01/19 23:21:50  acg
+//  Andy Goodrich: changes for IEEE 1666 2011
+//
+// Revision 1.9  2011/01/18 20:10:45  acg
+//  Andy Goodrich: changes for IEEE1666_2011 semantics.
+//
+// Revision 1.8  2011/01/06 18:02:16  acg
+//  Andy Goodrich: added check for disabled thread to trigger_dynamic().
+//
+// Revision 1.7  2010/11/20 17:10:57  acg
+//  Andy Goodrich: reset processing changes for new IEEE 1666 standard.
+//
+// Revision 1.6  2010/07/22 20:02:33  acg
+//  Andy Goodrich: bug fixes.
+//
+// Revision 1.5  2009/07/28 01:10:53  acg
+//  Andy Goodrich: updates for 2.3 release candidate.
+//
+// Revision 1.4  2009/05/22 16:06:29  acg
+//  Andy Goodrich: process control updates.
+//
+// Revision 1.3  2008/05/22 17:06:06  acg
+//  Andy Goodrich: formatting and comments.
+//
+// Revision 1.2  2007/09/20 20:32:35  acg
+//  Andy Goodrich: changes to the semantics of throw_it() to match the
+//  specification. A call to throw_it() will immediately suspend the calling
+//  thread until all the throwees have executed. At that point the calling
+//  thread will be restarted before the execution of any other threads.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.8  2006/04/20 17:08:17  acg
+//  Andy Goodrich: 3.0 style process changes.
+//
+// Revision 1.7  2006/04/11 23:13:21  acg
+//   Andy Goodrich: Changes for reduced reset support that only includes
+//   sc_cthread, but has preliminary hooks for expanding to method and thread
+//   processes also.
+//
+// Revision 1.6  2006/03/21 00:00:34  acg
+//   Andy Goodrich: changed name of sc_get_current_process_base() to be
+//   sc_get_current_process_b() since its returning an sc_process_b instance.
+//
+// Revision 1.5  2006/01/26 21:04:55  acg
+//  Andy Goodrich: deprecation message changes and additional messages.
+//
+// Revision 1.4  2006/01/24 20:49:05  acg
+// Andy Goodrich: changes to remove the use of deprecated features within the
+// simulator, and to issue warning messages when deprecated features are used.
+//
+// Revision 1.3  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+//
diff --git a/ext/systemc/src/sysc/kernel/sc_thread_process.h b/ext/systemc/src/sysc/kernel/sc_thread_process.h
new file mode 100644
index 000000000..5e834506a
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_thread_process.h
@@ -0,0 +1,635 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_thread_process.h -- Thread process declarations
+
+  Original Author: Andy Goodrich, Forte Design Systems, 4 August 2005
+               
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#if !defined(sc_thread_process_h_INCLUDED)
+#define sc_thread_process_h_INCLUDED
+
+#include "sysc/kernel/sc_spawn_options.h"
+#include "sysc/kernel/sc_process.h"
+#include "sysc/kernel/sc_cor.h"
+#include "sysc/kernel/sc_event.h"
+#include "sysc/kernel/sc_except.h"
+#include "sysc/kernel/sc_reset.h"
+
+// DEBUGGING MACROS:
+//
+// DEBUG_MSG(NAME,P,MSG)
+//     MSG  = message to print
+//     NAME = name that must match the process for the message to print, or
+//            null if the message should be printed unconditionally.
+//     P    = pointer to process message is for, or NULL in which case the
+//            message will not print.
+#if 0
+#   define DEBUG_NAME ""
+#   define DEBUG_MSG(NAME,P,MSG) \
+    { \
+        if ( P && ( (strlen(NAME)==0) || !strcmp(NAME,P->name())) ) \
+          std::cout << "**** " << sc_time_stamp() << " ("  \
+	            << sc_get_current_process_name() << "): " << MSG \
+		    << " - " << P->name() << std::endl; \
+    }
+#else
+#   define DEBUG_MSG(NAME,P,MSG) 
+#endif
+
+
+namespace sc_core {
+
+// forward references:
+class sc_event_and_list;
+class sc_event_or_list;
+class sc_reset;
+void sc_thread_cor_fn( void* );
+void sc_set_stack_size( sc_thread_handle, std::size_t );
+class sc_event;
+class sc_join;
+class sc_module;
+class sc_process_handle;
+class sc_process_table;
+class sc_simcontext;
+class sc_runnable;
+
+sc_cor* get_cor_pointer( sc_process_b* process_p );
+void sc_set_stack_size( sc_thread_handle thread_h, std::size_t size );
+void wait( sc_simcontext* );
+void wait( const sc_event&, sc_simcontext* );
+void wait( const sc_event_or_list&, sc_simcontext* );
+void wait( const sc_event_and_list&, sc_simcontext* );
+void wait( const sc_time&, sc_simcontext* );
+void wait( const sc_time&, const sc_event&, sc_simcontext* );
+void wait( const sc_time&, const sc_event_or_list&, sc_simcontext* );
+void wait( const sc_time&, const sc_event_and_list&, sc_simcontext* );
+
+//==============================================================================
+// sc_thread_process -
+//
+//==============================================================================
+class sc_thread_process : public sc_process_b {
+    friend void sc_thread_cor_fn( void* );
+    friend void sc_set_stack_size( sc_thread_handle, std::size_t );
+    friend class sc_event;
+    friend class sc_join;
+    friend class sc_module;
+    friend class sc_process_b;
+    friend class sc_process_handle;
+    friend class sc_process_table;
+    friend class sc_simcontext;
+    friend class sc_runnable;
+    friend sc_cor* get_cor_pointer( sc_process_b* process_p );
+
+    friend void wait( sc_simcontext* );
+    friend void wait( const sc_event&, sc_simcontext* );
+    friend void wait( const sc_event_or_list&, sc_simcontext* );
+    friend void wait( const sc_event_and_list&, sc_simcontext* );
+    friend void wait( const sc_time&, sc_simcontext* );
+    friend void wait( const sc_time&, const sc_event&, sc_simcontext* );
+    friend void wait( const sc_time&, const sc_event_or_list&, sc_simcontext* );
+    friend void wait( const sc_time&, const sc_event_and_list&, sc_simcontext*);
+  public:
+    sc_thread_process( const char* name_p, bool free_host, 
+        SC_ENTRY_FUNC method_p, sc_process_host* host_p, 
+        const sc_spawn_options* opt_p );
+
+    virtual const char* kind() const
+        { return "sc_thread_process"; }
+
+  protected:
+    // may not be deleted manually (called from sc_process_b)
+    virtual ~sc_thread_process();
+
+    virtual void disable_process( 
+        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS );
+    virtual void enable_process( 
+        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS );
+    virtual void kill_process(
+        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS );
+    sc_thread_handle next_exist();
+    sc_thread_handle next_runnable();
+    virtual void prepare_for_simulation();
+    virtual void resume_process( 
+        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS );
+    void set_next_exist( sc_thread_handle next_p );
+    void set_next_runnable( sc_thread_handle next_p );
+
+    void set_stack_size( std::size_t size );
+    inline void suspend_me();
+    virtual void suspend_process( 
+        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS );
+    virtual void throw_reset( bool async );
+    virtual void throw_user( const sc_throw_it_helper& helper,
+        sc_descendant_inclusion_info descendants = SC_NO_DESCENDANTS );
+
+    bool trigger_dynamic( sc_event* );
+    inline void trigger_static();
+
+    void wait( const sc_event& );
+    void wait( const sc_event_or_list& );
+    void wait( const sc_event_and_list& );
+    void wait( const sc_time& );
+    void wait( const sc_time&, const sc_event& );
+    void wait( const sc_time&, const sc_event_or_list& );
+    void wait( const sc_time&, const sc_event_and_list& );
+    void wait_cycles( int n=1 );
+
+  protected:
+    void add_monitor( sc_process_monitor* monitor_p );
+    void remove_monitor( sc_process_monitor* monitor_p);
+    void signal_monitors( int type = 0 );
+
+  protected:
+    sc_cor*                          m_cor_p;        // Thread's coroutine.
+    std::vector<sc_process_monitor*> m_monitor_q;    // Thread monitors.
+    std::size_t                      m_stack_size;   // Thread stack size.
+    int                              m_wait_cycle_n; // # of waits to be done.
+
+  private: // disabled
+    sc_thread_process( const sc_thread_process& );
+    const sc_thread_process& operator = ( const sc_thread_process& );
+
+};
+
+//------------------------------------------------------------------------------
+//"sc_thread_process::set_stack_size"
+//
+//------------------------------------------------------------------------------
+inline void sc_thread_process::set_stack_size( std::size_t size )
+{
+    assert( size );
+    m_stack_size = size;
+}
+
+//------------------------------------------------------------------------------
+//"sc_thread_process::suspend_me"
+//
+// This method suspends this object instance in favor of the next runnable
+// process. Upon awakening we check to see if an exception should be thrown. 
+// There are two types of exceptions that can be thrown, synchronous reset
+// and asynchronous reset. At a future time there may be more asynchronous
+// exceptions.  If an asynchronous reset is seen and there is not static reset
+// specified, or the static reset is not active then clear the throw
+// type for the next time this method is called.
+//
+// Notes:
+//   (1) For an explanation of how the reset mechanism works see the top of
+//       the file sc_reset.cpp.
+//   (2) The m_sticky_reset field is used to handle synchronous resets that
+//       are enabled via the sc_process_handle::sync_reset_on() method. These
+//       resets are not generated by a signal, but rather are modal by 
+//       method call: sync_reset_on() - sync_reset_off().
+//------------------------------------------------------------------------------
+inline void sc_thread_process::suspend_me()
+{
+    // remember, if we're currently unwinding
+
+    bool unwinding_preempted = m_unwinding;
+
+    sc_simcontext* simc_p = simcontext();
+    sc_cor*         cor_p = simc_p->next_cor();
+
+    // do not switch, if we're about to execute next (e.g. suicide)
+
+    if( m_cor_p != cor_p )
+    {
+        DEBUG_MSG( DEBUG_NAME , this, "suspending thread");
+        simc_p->cor_pkg()->yield( cor_p );
+        DEBUG_MSG( DEBUG_NAME , this, "resuming thread");
+    }
+
+    // IF THERE IS A THROW TO BE DONE FOR THIS PROCESS DO IT NOW:
+    //
+    // (1) Optimize THROW_NONE for speed as it is the normal case.
+    // (2) If this thread is already unwinding then suspend_me() was
+    //     called from the catch clause to throw an exception on another
+    //     process, so just go back to the catch clause.
+
+    if ( m_throw_status == THROW_NONE ) return;
+
+    if ( m_unwinding ) return;
+
+    switch( m_throw_status )
+    {
+      case THROW_ASYNC_RESET:
+      case THROW_SYNC_RESET:
+        DEBUG_MSG( DEBUG_NAME , this, "throwing reset for");
+	if ( m_reset_event_p ) m_reset_event_p->notify();
+        throw sc_unwind_exception( this, true ); 
+
+      case THROW_USER:
+        DEBUG_MSG( DEBUG_NAME, this, "invoking throw_it for");
+	m_throw_status = m_active_areset_n ? THROW_ASYNC_RESET :
+	                                  (m_active_reset_n ? THROW_SYNC_RESET :
+			                  THROW_NONE);
+        m_throw_helper_p->throw_it();
+	break;
+
+      case THROW_KILL:
+        DEBUG_MSG( DEBUG_NAME, this, "throwing kill for");
+	throw sc_unwind_exception( this, false );
+
+      default: // THROWING_NOW
+        sc_assert( unwinding_preempted );
+        DEBUG_MSG( DEBUG_NAME, this, "restarting thread");
+        break;
+    }
+}
+
+
+//------------------------------------------------------------------------------
+//"sc_thread_process::wait"
+//
+//------------------------------------------------------------------------------
+inline
+void
+sc_thread_process::wait( const sc_event& e )
+{   
+    if( m_unwinding )
+        SC_REPORT_ERROR( SC_ID_WAIT_DURING_UNWINDING_, name() );
+
+    m_event_p = &e; // for cleanup.
+    e.add_dynamic( this );
+    m_trigger_type = EVENT;
+    suspend_me();
+}
+
+inline
+void
+sc_thread_process::wait( const sc_event_or_list& el )
+{   
+    if( m_unwinding )
+        SC_REPORT_ERROR( SC_ID_WAIT_DURING_UNWINDING_, name() );
+
+    el.add_dynamic( this );
+    m_event_list_p = &el;
+    m_trigger_type = OR_LIST;
+    suspend_me();
+}
+
+inline
+void
+sc_thread_process::wait( const sc_event_and_list& el )
+{
+    if( m_unwinding )
+        SC_REPORT_ERROR( SC_ID_WAIT_DURING_UNWINDING_, name() );
+
+    el.add_dynamic( this );
+    m_event_list_p = &el;
+    m_event_count = el.size();
+    m_trigger_type = AND_LIST;
+    suspend_me();
+}
+
+inline
+void
+sc_thread_process::wait( const sc_time& t )
+{
+    if( m_unwinding )
+        SC_REPORT_ERROR( SC_ID_WAIT_DURING_UNWINDING_, name() );
+
+    m_timeout_event_p->notify_internal( t );
+    m_timeout_event_p->add_dynamic( this );
+    m_trigger_type = TIMEOUT;
+    suspend_me();
+}
+
+inline
+void
+sc_thread_process::wait( const sc_time& t, const sc_event& e )
+{
+    if( m_unwinding )
+        SC_REPORT_ERROR( SC_ID_WAIT_DURING_UNWINDING_, name() );
+
+    m_timeout_event_p->notify_internal( t );
+    m_timeout_event_p->add_dynamic( this );
+    e.add_dynamic( this );
+    m_event_p = &e;
+    m_trigger_type = EVENT_TIMEOUT;
+    suspend_me();
+}
+
+inline
+void
+sc_thread_process::wait( const sc_time& t, const sc_event_or_list& el )
+{
+    if( m_unwinding )
+        SC_REPORT_ERROR( SC_ID_WAIT_DURING_UNWINDING_, name() );
+
+    m_timeout_event_p->notify_internal( t );
+    m_timeout_event_p->add_dynamic( this );
+    el.add_dynamic( this );
+    m_event_list_p = &el;
+    m_trigger_type = OR_LIST_TIMEOUT;
+    suspend_me();
+}
+
+inline
+void
+sc_thread_process::wait( const sc_time& t, const sc_event_and_list& el )
+{
+    if( m_unwinding )
+        SC_REPORT_ERROR( SC_ID_WAIT_DURING_UNWINDING_, name() );
+
+    m_timeout_event_p->notify_internal( t );
+    m_timeout_event_p->add_dynamic( this );
+    el.add_dynamic( this );
+    m_event_list_p = &el;
+    m_event_count = el.size();
+    m_trigger_type = AND_LIST_TIMEOUT;
+    suspend_me();
+}
+
+//------------------------------------------------------------------------------
+//"sc_thread_process::wait_cycles"
+//
+// This method suspends this object instance for the specified number of cycles.
+// A cycle is defined as the event the thread is set up to staticly wait on.
+// The field m_wait_cycle_n is set to one less than the number of cycles to
+// be waited for, since the value is tested before being decremented in 
+// the simulation kernel.
+//------------------------------------------------------------------------------
+inline
+void
+sc_thread_process::wait_cycles( int n )
+{   
+    if( m_unwinding )
+        SC_REPORT_ERROR( SC_ID_WAIT_DURING_UNWINDING_, name() );
+
+    m_wait_cycle_n = n-1;
+    suspend_me();
+}
+
+//------------------------------------------------------------------------------
+//"sc_thread_process::miscellaneous support"
+//
+//------------------------------------------------------------------------------
+inline
+void sc_thread_process::add_monitor(sc_process_monitor* monitor_p)
+{
+    m_monitor_q.push_back(monitor_p);
+}
+
+
+inline
+void sc_thread_process::remove_monitor(sc_process_monitor* monitor_p)
+{
+    int mon_n = m_monitor_q.size();
+
+    for ( int mon_i = 0; mon_i < mon_n; mon_i++ )
+    {
+    if  ( m_monitor_q[mon_i] == monitor_p )
+        {
+            m_monitor_q[mon_i] = m_monitor_q[mon_n-1];
+            m_monitor_q.resize(mon_n-1);
+        }
+    }
+}
+
+inline
+void sc_thread_process::set_next_exist(sc_thread_handle next_p)
+{
+    m_exist_p = next_p;
+}
+
+inline
+sc_thread_handle sc_thread_process::next_exist()
+{
+    return (sc_thread_handle)m_exist_p;
+}
+
+inline
+void sc_thread_process::set_next_runnable(sc_thread_handle next_p)
+{
+    m_runnable_p = next_p;
+}
+
+inline
+sc_thread_handle sc_thread_process::next_runnable()
+{
+    return (sc_thread_handle)m_runnable_p;
+}
+
+inline sc_cor* get_cor_pointer( sc_process_b* process_p )
+{
+    sc_thread_handle thread_p = DCAST<sc_thread_handle>(process_p);
+    return thread_p->m_cor_p;
+}
+
+//------------------------------------------------------------------------------
+//"sc_thread_process::trigger_static"
+//
+// This inline method adds the current thread to the queue of runnable
+// processes, if required.  This is the case if the following criteria
+// are met:
+//   (1) The process is in a runnable state.
+//   (2) The process is not already on the run queue.
+//   (3) The process is expecting a static trigger,
+//       dynamic event waits take priority.
+//   (4) The process' static wait count is zero.
+//
+// If the triggering process is the same process, the trigger is
+// ignored as well, unless SC_ENABLE_IMMEDIATE_SELF_NOTIFICATIONS
+// is defined.
+//------------------------------------------------------------------------------
+inline
+void
+sc_thread_process::trigger_static()
+{
+    // No need to try queueing this thread if one of the following is true:
+    //    (a) its disabled
+    //    (b) its already queued for execution
+    //    (c) its waiting on a dynamic event
+    //    (d) its wait count is not satisfied
+
+    if ( (m_state & ps_bit_disabled) || is_runnable() ||
+          m_trigger_type != STATIC )
+        return;
+
+#if ! defined( SC_ENABLE_IMMEDIATE_SELF_NOTIFICATIONS )
+    if( SC_UNLIKELY_( sc_get_current_process_b() == this ) )
+    {
+        report_immediate_self_notification();
+        return;
+    }
+#endif // SC_ENABLE_IMMEDIATE_SELF_NOTIFICATIONS
+
+    if ( m_wait_cycle_n > 0 )
+    {
+        --m_wait_cycle_n;
+        return;
+    }
+
+    // If we get here then the thread is has satisfied its wait criteria, if 
+    // its suspended mark its state as ready to run. If its not suspended then 
+    // push it onto the runnable queue.
+
+    if ( m_state & ps_bit_suspended )
+    {
+        m_state = m_state | ps_bit_ready_to_run;
+    }
+    else
+    {
+	simcontext()->push_runnable_thread(this);
+    }
+}
+
+#undef DEBUG_MSG
+#undef DEBUG_NAME
+
+} // namespace sc_core 
+
+// $Log: sc_thread_process.h,v $
+// Revision 1.30  2011/08/26 20:46:11  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.29  2011/08/24 23:36:12  acg
+//  Andy Goodrich: removed break statements that can never be reached and
+//  which causes warnings in the Greenhills C++ compiler.
+//
+// Revision 1.28  2011/04/14 22:34:27  acg
+//  Andy Goodrich: removed dead code.
+//
+// Revision 1.27  2011/04/13 05:02:18  acg
+//  Andy Goodrich: added missing check to the wake up code in suspend_me()
+//  so that we just return if the call to suspend_me() was issued from a
+//  stack unwinding.
+//
+// Revision 1.26  2011/04/13 02:44:26  acg
+//  Andy Goodrich: added m_unwinding flag in place of THROW_NOW because the
+//  throw status will be set back to THROW_*_RESET if reset is active and
+//  the check for an unwind being complete was expecting THROW_NONE as the
+//  clearing of THROW_NOW.
+//
+// Revision 1.25  2011/04/11 22:05:14  acg
+//  Andy Goodrich: use the DEBUG_NAME macro in DEBUG_MSG invocations.
+//
+// Revision 1.24  2011/04/10 22:12:32  acg
+//  Andy Goodrich: adding debugging macros.
+//
+// Revision 1.23  2011/04/08 22:41:28  acg
+//  Andy Goodrich: added comment pointing to the description of the reset
+//  mechanism in sc_reset.cpp.
+//
+// Revision 1.22  2011/04/08 18:27:33  acg
+//  Andy Goodrich: added check to make sure we don't schedule a running process
+//  because of it issues a notify() it is sensitive to.
+//
+// Revision 1.21  2011/04/05 06:22:38  acg
+//  Andy Goodrich: expanded comment for trigger_static() initial vetting.
+//
+// Revision 1.20  2011/04/01 21:24:57  acg
+//  Andy Goodrich: removed unused code.
+//
+// Revision 1.19  2011/02/19 08:30:53  acg
+//  Andy Goodrich: Moved process queueing into trigger_static from
+//  sc_event::notify.
+//
+// Revision 1.18  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.17  2011/02/17 19:55:58  acg
+//  Andy Goodrich:
+//    (1) Changed signature of trigger_dynamic() back to a bool.
+//    (2) Simplified process control usage.
+//    (3) Changed trigger_static() to recognize process controls and to
+//        do the down-count on wait(N), allowing the elimination of
+//        ready_to_run().
+//
+// Revision 1.16  2011/02/16 22:37:31  acg
+//  Andy Goodrich: clean up to remove need for ps_disable_pending.
+//
+// Revision 1.15  2011/02/13 21:47:38  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.14  2011/02/13 21:35:54  acg
+//  Andy Goodrich: added error for performing a wait() during unwinding.
+//
+// Revision 1.13  2011/02/11 13:25:24  acg
+//  Andy Goodrich: Philipp A. Hartmann's changes:
+//    (1) Removal of SC_CTHREAD method overloads.
+//    (2) New exception processing code.
+//
+// Revision 1.12  2011/02/01 23:01:53  acg
+//  Andy Goodrich: removed dead code.
+//
+// Revision 1.11  2011/02/01 21:18:01  acg
+//  Andy Goodrich:
+//  (1) Changes in throw processing for new process control rules.
+//  (2) Support of new process_state enum values.
+//
+// Revision 1.10  2011/01/25 20:50:37  acg
+//  Andy Goodrich: changes for IEEE 1666 2011.
+//
+// Revision 1.9  2011/01/19 23:21:50  acg
+//  Andy Goodrich: changes for IEEE 1666 2011
+//
+// Revision 1.8  2011/01/18 20:10:45  acg
+//  Andy Goodrich: changes for IEEE1666_2011 semantics.
+//
+// Revision 1.7  2011/01/06 17:59:58  acg
+//  Andy Goodrich: removed debugging output.
+//
+// Revision 1.6  2010/07/22 20:02:33  acg
+//  Andy Goodrich: bug fixes.
+//
+// Revision 1.5  2009/07/28 01:10:53  acg
+//  Andy Goodrich: updates for 2.3 release candidate.
+//
+// Revision 1.4  2009/05/22 16:06:29  acg
+//  Andy Goodrich: process control updates.
+//
+// Revision 1.3  2009/03/12 22:59:58  acg
+//  Andy Goodrich: updates for 2.4 stuff.
+//
+// Revision 1.2  2008/05/22 17:06:06  acg
+//  Andy Goodrich: formatting and comments.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.7  2006/05/08 17:57:13  acg
+//  Andy Goodrich: Added David Long's forward declarations for friend functions
+//  to keep the Microsoft C++ compiler happy.
+//
+// Revision 1.6  2006/04/20 17:08:17  acg
+//  Andy Goodrich: 3.0 style process changes.
+//
+// Revision 1.5  2006/04/11 23:13:21  acg
+//   Andy Goodrich: Changes for reduced reset support that only includes
+//   sc_cthread, but has preliminary hooks for expanding to method and thread
+//   processes also.
+//
+// Revision 1.4  2006/01/24 20:49:05  acg
+// Andy Goodrich: changes to remove the use of deprecated features within the
+// simulator, and to issue warning messages when deprecated features are used.
+//
+// Revision 1.3  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+
+#endif // !defined(sc_thread_process_h_INCLUDED)
diff --git a/ext/systemc/src/sysc/kernel/sc_time.cpp b/ext/systemc/src/sysc/kernel/sc_time.cpp
new file mode 100644
index 000000000..e3fdd5865
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_time.cpp
@@ -0,0 +1,465 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_time.cpp --
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#include <math.h>
+#include <stdio.h>
+
+#include "sysc/kernel/sc_kernel_ids.h"
+#include "sysc/kernel/sc_simcontext.h"
+#include "sysc/kernel/sc_time.h"
+#include "sysc/utils/sc_utils_ids.h"
+
+#if !defined(PRIu64)
+#   if defined(_MSC_VER) || defined(__MINGW32__)
+#       define PRIu64 "I64u"
+#   else
+#       define PRIu64 "llu"
+#   endif
+#endif // PRIu64
+
+#ifdef SC_ENABLE_EARLY_MAXTIME_CREATION
+#  define SC_MAXTIME_ALLOWED_ 1
+#else
+#  define SC_MAXTIME_ALLOWED_ 0
+#endif
+
+namespace sc_core {
+
+static
+double time_values[] = {
+    1,       // fs
+    1e3,     // ps
+    1e6,     // ns
+    1e9,     // us
+    1e12,    // ms
+    1e15     // s
+};
+
+static
+const char* time_units[] = {
+    "fs",
+    "ps",
+    "ns",
+    "us",
+    "ms",
+    "s"
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_time
+//
+//  The time class.
+// ----------------------------------------------------------------------------
+
+// constructors
+
+sc_time::sc_time( double v, sc_time_unit tu )
+: m_value( 0 )
+{
+    if( v != 0 ) {
+	sc_time_params* time_params = sc_get_curr_simcontext()->m_time_params;
+	double scale_fac = time_values[tu] / time_params->time_resolution;
+	// linux bug workaround; don't change next two lines
+	volatile double tmp = v * scale_fac + 0.5;
+	m_value = SCAST<sc_dt::int64>( tmp );
+	time_params->time_resolution_fixed = true;
+    }
+}
+
+sc_time::sc_time( double v, sc_time_unit tu, sc_simcontext* simc )
+: m_value( 0 )
+{
+    if( v != 0 ) {
+	sc_time_params* time_params = simc->m_time_params;
+	double scale_fac = time_values[tu] / time_params->time_resolution;
+	// linux bug workaround; don't change next two lines
+	volatile double tmp = v * scale_fac + 0.5;
+	m_value = SCAST<sc_dt::int64>( tmp );
+	time_params->time_resolution_fixed = true;
+    }
+}
+
+sc_time::sc_time( double v, bool scale )
+: m_value( 0 )
+{
+    static bool warn_constructor=true;
+    if ( warn_constructor ) {
+        warn_constructor=false;
+        SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
+            "deprecated constructor: sc_time(double,bool)");
+    }
+
+    if( v != 0 ) {
+	sc_time_params* time_params = sc_get_curr_simcontext()->m_time_params;
+	if( scale ) {
+	    double scale_fac = sc_dt::uint64_to_double(
+		time_params->default_time_unit );
+	    // linux bug workaround; don't change next two lines
+	    volatile double tmp = v * scale_fac + 0.5;
+	    m_value = SCAST<sc_dt::int64>( tmp );
+	} else {
+	    // linux bug workaround; don't change next two lines
+	    volatile double tmp = v + 0.5;
+	    m_value = SCAST<sc_dt::int64>( tmp );
+	}
+	time_params->time_resolution_fixed = true;
+    }
+}
+
+sc_time::sc_time( value_type v, bool scale )
+: m_value( 0 )
+{
+    static bool warn_constructor=true;
+    if ( warn_constructor ) {
+        warn_constructor=false;
+        SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
+            "deprecated constructor: sc_time(uint64,bool)");
+    }
+
+    if( v != 0 ) {
+	sc_time_params* time_params = sc_get_curr_simcontext()->m_time_params;
+	if( scale ) {
+	    double scale_fac = sc_dt::uint64_to_double(
+		time_params->default_time_unit );
+	    // linux bug workaround; don't change next two lines
+	    volatile double tmp = sc_dt::uint64_to_double( v ) *
+		                  scale_fac + 0.5;
+	    m_value = SCAST<sc_dt::int64>( tmp );
+	} else {
+	    m_value = v;
+	}
+	time_params->time_resolution_fixed = true;
+    }
+}
+
+sc_time
+sc_time::from_value( value_type v )
+{
+    sc_time t;
+    if( v != 0 && !(SC_MAXTIME_ALLOWED_ && v == ~sc_dt::UINT64_ZERO) ) {
+        sc_time_params* time_params = sc_get_curr_simcontext()->m_time_params;
+        time_params->time_resolution_fixed = true;
+    }
+    t.m_value = v;
+    return t;
+}
+
+
+// conversion functions
+
+double
+sc_time::to_default_time_units() const
+{
+    sc_time_params* time_params = sc_get_curr_simcontext()->m_time_params;
+#   if SC_MAXTIME_ALLOWED_
+        if( m_value == 0 )
+            return 0.0;
+        time_params->time_resolution_fixed = true;
+#   endif // SC_MAXTIME_ALLOWED_
+    return ( sc_dt::uint64_to_double( m_value ) /
+	     sc_dt::uint64_to_double( time_params->default_time_unit ) );
+}
+
+double
+sc_time::to_seconds() const
+{
+    sc_time_params* time_params = sc_get_curr_simcontext()->m_time_params;
+#   if SC_MAXTIME_ALLOWED_
+        if( m_value == 0 )
+            return 0.0;
+        time_params->time_resolution_fixed = true;
+#   endif // SC_MAXTIME_ALLOWED_
+    return ( sc_dt::uint64_to_double( m_value ) *
+	     time_params->time_resolution * 1e-15 );
+}
+
+const std::string
+sc_time::to_string() const
+{
+    value_type val = m_value;
+    if( val == 0 ) {
+	return std::string( "0 s" );
+    }
+    sc_time_params* time_params = sc_get_curr_simcontext()->m_time_params;
+#   if SC_MAXTIME_ALLOWED_
+        time_params->time_resolution_fixed = true;
+#   endif // SC_MAXTIME_ALLOWED_
+    value_type tr = SCAST<sc_dt::int64>( time_params->time_resolution );
+    int n = 0;
+    while( ( tr % 10 ) == 0 ) {
+	tr /= 10;
+	n ++;
+    }
+    assert( tr == 1 );
+    while( ( val % 10 ) == 0 ) {
+	val /= 10;
+	n ++;
+    }
+    char buf[BUFSIZ];
+    std::sprintf( buf, "%" PRIu64, val );
+    std::string result( buf );
+    if( n >= 15 ) {
+	for( int i = n - 15; i > 0; -- i ) {
+	    result += "0";
+	}
+	result += " s";
+    } else {
+	for( int i = n % 3; i > 0; -- i ) {
+	    result += "0";
+	}
+	result += " ";
+	result += time_units[n / 3];
+    }
+    return result;
+}
+
+
+// print function
+
+void
+sc_time::print( ::std::ostream& os ) const
+{
+    os << to_string();
+}
+
+
+// ----------------------------------------------------------------------------
+//  STRUCT : sc_time_params
+//
+//  Struct that holds the time resolution and default time unit.
+// ----------------------------------------------------------------------------
+
+sc_time_params::sc_time_params()
+: time_resolution( 1000 ),		// default 1 ps
+  time_resolution_specified( false ),
+  time_resolution_fixed( false ),
+  default_time_unit( 1000 ),		// default 1 ns
+  default_time_unit_specified( false )
+{}
+
+sc_time_params::~sc_time_params()
+{}
+
+
+// ----------------------------------------------------------------------------
+
+// functions for accessing the time resolution and default time unit
+
+void
+sc_set_time_resolution( double v, sc_time_unit tu )
+{
+    // first perform the necessary checks
+
+    // must be positive
+    if( v < 0.0 ) {
+	SC_REPORT_ERROR( SC_ID_SET_TIME_RESOLUTION_, "value not positive" );
+    }
+
+    // must be a power of ten
+    double dummy;
+#if defined( __HP_aCC ) || defined(__ppc__)
+    // aCC seems to have a bug in modf()
+    if( modf( log10( v < 1.0 ? 1.0/v : v ), &dummy ) != 0.0 ) {
+#else
+    if( modf( log10( v ), &dummy ) != 0.0 ) {
+#endif
+	SC_REPORT_ERROR( SC_ID_SET_TIME_RESOLUTION_,
+			 "value not a power of ten" );
+    }
+
+    sc_simcontext* simc = sc_get_curr_simcontext();
+
+    // can only be specified during elaboration
+    if( sc_is_running() ) {
+	SC_REPORT_ERROR( SC_ID_SET_TIME_RESOLUTION_, "simulation running" );
+    }
+
+    sc_time_params* time_params = simc->m_time_params;
+
+    // can be specified only once
+    if( time_params->time_resolution_specified ) {
+	SC_REPORT_ERROR( SC_ID_SET_TIME_RESOLUTION_, "already specified" );
+    }
+
+    // can only be specified before any sc_time is constructed
+    if( time_params->time_resolution_fixed ) {
+	SC_REPORT_ERROR( SC_ID_SET_TIME_RESOLUTION_,
+			 "sc_time object(s) constructed" );
+    }
+
+    // must be larger than or equal to 1 fs
+    volatile double resolution = v * time_values[tu];
+    if( resolution < 1.0 ) {
+	SC_REPORT_ERROR( SC_ID_SET_TIME_RESOLUTION_,
+			 "value smaller than 1 fs" );
+    }
+
+    // recalculate the default time unit
+    volatile double time_unit = sc_dt::uint64_to_double(
+	time_params->default_time_unit ) *
+	( time_params->time_resolution / resolution );
+    if( time_unit < 1.0 ) {
+	SC_REPORT_WARNING( SC_ID_DEFAULT_TIME_UNIT_CHANGED_, 0 );
+	time_params->default_time_unit = 1;
+    } else {
+	time_params->default_time_unit = SCAST<sc_dt::int64>( time_unit );
+    }
+
+    time_params->time_resolution = resolution;
+    time_params->time_resolution_specified = true;
+}
+
+sc_time 
+sc_get_time_resolution()
+{
+    return sc_time::from_value( sc_dt::UINT64_ONE );
+}
+
+
+void
+sc_set_default_time_unit( double v, sc_time_unit tu )
+{
+    static bool warn_default_time_unit=true;
+    if ( warn_default_time_unit )
+    {
+        warn_default_time_unit=false;
+        SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
+	    "deprecated function: sc_set_default_time_unit");
+    }
+    
+    // first perform the necessary checks
+
+    // must be positive
+    if( v < 0.0 ) {
+	SC_REPORT_ERROR( SC_ID_SET_DEFAULT_TIME_UNIT_, "value not positive" );
+    }
+
+    // must be a power of ten
+    double dummy;
+    if( modf( log10( v ), &dummy ) != 0.0 ) {
+	SC_REPORT_ERROR( SC_ID_SET_DEFAULT_TIME_UNIT_,
+			 "value not a power of ten" );
+    }
+
+    sc_simcontext* simc = sc_get_curr_simcontext();
+
+    // can only be specified during elaboration
+    if( sc_is_running() ) {
+	SC_REPORT_ERROR( SC_ID_SET_DEFAULT_TIME_UNIT_, "simulation running" );
+    }
+
+    sc_time_params* time_params = simc->m_time_params;
+
+    // can only be specified before any sc_time is constructed
+    if( time_params->time_resolution_fixed ) {
+        SC_REPORT_ERROR( SC_ID_SET_DEFAULT_TIME_UNIT_,
+                         "sc_time object(s) constructed" );
+    }
+
+    // can be specified only once
+    if( time_params->default_time_unit_specified ) {
+	SC_REPORT_ERROR( SC_ID_SET_DEFAULT_TIME_UNIT_, "already specified" );
+    }
+
+    // must be larger than or equal to the time resolution
+    volatile double time_unit = ( v * time_values[tu] ) /
+	                        time_params->time_resolution;
+    if( time_unit < 1.0 ) {
+	SC_REPORT_ERROR( SC_ID_SET_DEFAULT_TIME_UNIT_,
+			 "value smaller than time resolution" );
+    }
+
+    time_params->default_time_unit = SCAST<sc_dt::int64>( time_unit );
+    time_params->default_time_unit_specified = true;
+}
+
+sc_time
+sc_get_default_time_unit()
+{
+    static bool warn_get_default_time_unit = true;
+    if ( warn_get_default_time_unit )
+    {
+        warn_get_default_time_unit=false;
+        SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
+            "deprecated function: sc_get_default_time_unit");
+    }
+    return sc_time::from_value(
+              sc_get_curr_simcontext()->m_time_params->default_time_unit
+           );
+}
+
+
+// ----------------------------------------------------------------------------
+
+const sc_time SC_ZERO_TIME;
+
+#undef SC_MAXTIME_ALLOWED_
+
+} // namespace sc_core
+
+// $Log: sc_time.cpp,v $
+// Revision 1.7  2011/08/26 20:46:11  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.6  2011/07/24 16:08:36  acg
+//  Philipp A. Hartmann: fix C99 format specifiers for Solaris.
+//
+// Revision 1.5  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.4  2011/02/13 21:47:38  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.3  2011/01/19 23:21:50  acg
+//  Andy Goodrich: changes for IEEE 1666 2011
+//
+// Revision 1.2  2008/05/22 17:06:27  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.6  2006/01/26 21:04:55  acg
+//  Andy Goodrich: deprecation message changes and additional messages.
+//
+// Revision 1.5  2006/01/25 00:31:19  acg
+//  Andy Goodrich: Changed over to use a standard message id of
+//  SC_ID_IEEE_1666_DEPRECATION for all deprecation messages.
+//
+// Revision 1.4  2006/01/24 20:49:05  acg
+// Andy Goodrich: changes to remove the use of deprecated features within the
+// simulator, and to issue warning messages when deprecated features are used.
+//
+// Revision 1.3  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+//
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_time.h b/ext/systemc/src/sysc/kernel/sc_time.h
new file mode 100644
index 000000000..af222dd0f
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_time.h
@@ -0,0 +1,414 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_time.h -- The time class.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-05-21
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#ifndef SC_TIME_H
+#define SC_TIME_H
+
+
+#include "sysc/datatypes/int/sc_nbdefs.h"
+#include "sysc/datatypes/fx/scfx_ieee.h"
+#include "sysc/utils/sc_iostream.h"
+
+namespace sc_core {
+
+class sc_simcontext;
+
+// friend operator declarations
+
+    const sc_time operator + ( const sc_time&, const sc_time& );
+    const sc_time operator - ( const sc_time&, const sc_time& );
+    const sc_time operator * ( const sc_time&, double );
+    const sc_time operator * ( double, const sc_time& );
+    const sc_time operator / ( const sc_time&, double );
+    double        operator / ( const sc_time&, const sc_time& );
+
+
+// ----------------------------------------------------------------------------
+//  ENUM : sc_time_unit
+//
+//  Enumeration of time units.
+// ----------------------------------------------------------------------------
+
+enum sc_time_unit
+{
+    SC_FS = 0,
+    SC_PS,
+    SC_NS,
+    SC_US,
+    SC_MS,
+    SC_SEC
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_time
+//
+//  The time class.
+// ----------------------------------------------------------------------------
+
+class sc_time
+{
+public:
+
+    typedef sc_dt::uint64 value_type;
+
+    // constructors
+
+    sc_time();
+    sc_time( double, sc_time_unit );
+    sc_time( double, sc_time_unit, sc_simcontext* );
+    sc_time( const sc_time& );
+
+    static sc_time from_value( value_type );
+
+    // deprecated, use from_value(v)
+    sc_time( double, bool scale );
+    sc_time( value_type, bool scale );
+
+    // assignment operator
+
+    sc_time& operator = ( const sc_time& );
+
+
+    // conversion functions
+
+    value_type value() const;      // relative to the time resolution
+    double to_double() const;  // relative to the time resolution
+    double to_default_time_units() const;
+    double to_seconds() const;
+    const std::string to_string() const;
+
+
+    // relational operators
+
+    bool operator == ( const sc_time& ) const;
+    bool operator != ( const sc_time& ) const;
+    bool operator <  ( const sc_time& ) const;
+    bool operator <= ( const sc_time& ) const;
+    bool operator >  ( const sc_time& ) const;
+    bool operator >= ( const sc_time& ) const;
+
+
+    // arithmetic operators
+
+    sc_time& operator += ( const sc_time& );
+    sc_time& operator -= ( const sc_time& );
+
+    friend const sc_time operator + ( const sc_time&, const sc_time& );
+    friend const sc_time operator - ( const sc_time&, const sc_time& );
+
+    sc_time& operator *= ( double );
+    sc_time& operator /= ( double );
+    sc_time& operator %= ( const sc_time& );
+
+    friend const sc_time operator * ( const sc_time&, double );
+    friend const sc_time operator * ( double, const sc_time& );
+    friend const sc_time operator / ( const sc_time&, double );
+    friend double        operator / ( const sc_time&, const sc_time& );
+    friend const sc_time operator % ( const sc_time&, const sc_time& );
+
+
+    // print function
+
+    void print( ::std::ostream& os = std::cout ) const;
+
+private:
+
+    value_type m_value;
+};
+
+
+// print operator
+
+inline ::std::ostream& operator << ( ::std::ostream&, const sc_time& );
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+// constructors
+
+inline
+sc_time::sc_time()
+: m_value( 0 )
+{}
+
+inline
+sc_time::sc_time( const sc_time& t )
+: m_value( t.m_value )
+{}
+
+
+// assignment operator
+
+inline
+sc_time&
+sc_time::operator = ( const sc_time& t )
+{
+    m_value = t.m_value;
+    return *this;
+}
+
+
+// conversion functions
+
+inline
+sc_time::value_type
+sc_time::value() const  // relative to the time resolution
+{
+    return m_value;
+}
+
+
+inline
+double
+sc_time::to_double() const  // relative to the time resolution
+{
+    return sc_dt::uint64_to_double( m_value );
+}
+
+
+// relational operators
+
+inline
+bool
+sc_time::operator == ( const sc_time& t ) const
+{
+    return ( m_value == t.m_value );
+}
+
+inline
+bool
+sc_time::operator != ( const sc_time& t ) const
+{
+    return ( m_value != t.m_value );
+}
+
+inline
+bool
+sc_time::operator < ( const sc_time& t ) const
+{
+    return ( m_value < t.m_value );
+}
+
+inline
+bool
+sc_time::operator <= ( const sc_time& t ) const
+{
+    return ( m_value <= t.m_value );
+}
+
+inline
+bool
+sc_time::operator > ( const sc_time& t ) const
+{
+    return ( m_value > t.m_value );
+}
+
+inline
+bool
+sc_time::operator >= ( const sc_time& t ) const
+{
+    return ( m_value >= t.m_value );
+}
+
+
+// arithmetic operators
+
+inline
+sc_time&
+sc_time::operator += ( const sc_time& t )
+{
+    m_value += t.m_value;
+    return *this;
+}
+
+inline
+sc_time&
+sc_time::operator -= ( const sc_time& t )
+{
+    m_value -= t.m_value;
+    return *this;
+}
+
+
+inline
+const sc_time
+operator + ( const sc_time& t1, const sc_time& t2 )
+{
+    return sc_time( t1 ) += t2;
+}
+
+inline
+const sc_time
+operator - ( const sc_time& t1, const sc_time& t2 )
+{
+    return sc_time( t1 ) -= t2;
+}
+
+
+inline
+sc_time&
+sc_time::operator *= ( double d )
+{
+    // linux bug workaround; don't change next two lines
+    volatile double tmp = sc_dt::uint64_to_double( m_value ) * d + 0.5;
+    m_value = SCAST<sc_dt::int64>( tmp );
+    return *this;
+}
+
+inline
+sc_time&
+sc_time::operator /= ( double d )
+{
+    // linux bug workaround; don't change next two lines
+    volatile double tmp = sc_dt::uint64_to_double( m_value ) / d + 0.5;
+    m_value = SCAST<sc_dt::int64>( tmp );
+    return *this;
+}
+
+inline
+sc_time&
+sc_time::operator %= ( const sc_time& t )
+{
+    m_value %= t.m_value;
+    return *this;
+}
+
+inline
+const sc_time
+operator * ( const sc_time& t, double d )
+{
+    sc_time tmp( t );
+    return tmp *= d;
+}
+
+inline
+const sc_time
+operator * ( double d, const sc_time& t )
+{
+    sc_time tmp( t );
+    return tmp *= d;
+}
+
+inline
+const sc_time
+operator / ( const sc_time& t, double d )
+{
+    sc_time tmp( t );
+    return tmp /= d;
+}
+
+inline
+double
+operator / ( const sc_time& t1, const sc_time& t2 )
+{
+    return ( t1.to_double() / t2.to_double() );
+}
+
+inline
+const sc_time
+operator % ( const sc_time& t1, const sc_time& t2 )
+{
+    sc_time tmp(t1);
+    return tmp %= t2;
+}
+
+// print operator
+
+inline
+::std::ostream&
+operator << ( ::std::ostream& os, const sc_time& t )
+{
+    t.print( os );
+    return os;
+}
+
+
+// ----------------------------------------------------------------------------
+//  STRUCT : sc_time_params
+//
+//  Struct that holds the time resolution and default time unit.
+// ----------------------------------------------------------------------------
+
+struct sc_time_params
+{
+    double time_resolution;		// in femto seconds
+    bool   time_resolution_specified;
+    bool   time_resolution_fixed;
+
+    sc_time::value_type default_time_unit;		// in time resolution
+    bool                default_time_unit_specified;
+
+    sc_time_params();
+    ~sc_time_params();
+};
+
+
+// ----------------------------------------------------------------------------
+
+extern const sc_time SC_ZERO_TIME;
+
+
+// functions for accessing the time resolution and default time unit
+
+extern void    sc_set_time_resolution( double, sc_time_unit );
+extern sc_time sc_get_time_resolution();
+
+extern void    sc_set_default_time_unit( double, sc_time_unit );
+extern sc_time sc_get_default_time_unit();
+
+} // namespace sc_core
+
+#endif
+
+// $Log: sc_time.h,v $
+// Revision 1.5  2011/08/26 20:46:11  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.4  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.3  2011/02/13 21:47:38  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.2  2008/05/22 17:06:27  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.4  2006/05/08 18:02:06  acg
+//  Andy Goodrich: added David Long's forward declarations for friend
+//   functions, methods, and operators to keep the Microsoft compiler happy.
+//
+// Revision 1.3  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_ver.cpp b/ext/systemc/src/sysc/kernel/sc_ver.cpp
new file mode 100644
index 000000000..9883cd3bc
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_ver.cpp
@@ -0,0 +1,228 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+    sc_ver.cpp -- copyright information.
+
+    Original Author: Stan Y. Liao, Synopsys, Inc.
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+#include <cstddef>
+#include <cstdlib>
+
+#define SC_DISABLE_API_VERSION_CHECK // for in-library sc_ver.h inclusion
+
+#include "sysc/kernel/sc_ver.h"
+#include "sysc/kernel/sc_kernel_ids.h"
+#include "sysc/utils/sc_iostream.h"
+#include "sysc/utils/sc_report.h"
+
+using std::getenv;
+using std::strcmp;
+using std::cerr;
+using std::endl;
+
+namespace sc_core {
+
+
+static
+const char systemc_version[] =
+    "SystemC " SC_VERSION " --- " __DATE__ " " __TIME__;
+
+const unsigned int sc_version_major = SC_VERSION_MAJOR;
+const unsigned int sc_version_minor = SC_VERSION_MINOR;
+const unsigned int sc_version_patch = SC_VERSION_PATCH;
+const bool         sc_is_prerelease = SC_IS_PRERELEASE;
+
+const std::string  sc_version_originator   = SC_VERSION_ORIGINATOR;
+const std::string  sc_version_release_date = SC_VERSION_RELEASE_DATE;
+const std::string  sc_version_prerelease   = SC_VERSION_PRERELEASE;
+const std::string  sc_version_string       = SC_VERSION;
+const std::string  sc_copyright_string     = SC_COPYRIGHT;
+
+const char*
+sc_copyright()
+{
+    return SC_COPYRIGHT;
+}
+
+
+const char*
+sc_release()
+{
+    return SC_VERSION;
+}
+
+
+const char*
+sc_version()
+{
+    return systemc_version;
+}
+
+
+#if !defined(SC_DISABLE_COPYRIGHT_MESSAGE)
+#  define SC_DISABLE_COPYRIGHT_MESSAGE 0
+#endif
+
+// ----------------------------------------------------------------------------
+
+void
+pln()
+{
+    static bool lnp = SC_DISABLE_COPYRIGHT_MESSAGE;
+    if ( lnp || getenv("SYSTEMC_DISABLE_COPYRIGHT_MESSAGE") != 0 ) 
+        lnp = true;
+    if ( const char * lnp_env = getenv("SC_COPYRIGHT_MESSAGE") ) {
+        lnp = !strcmp( lnp_env, "DISABLE" );
+    }
+    if( ! lnp ) {
+
+        static const char indent[] = "        ";
+        std::string       line;
+        std::stringstream copyright;
+
+        // temporary stream to print copyright line-wise with indentation
+        copyright << sc_copyright();
+
+        cerr << endl;
+        cerr << indent << sc_version() << endl;
+        while( getline( copyright, line ) )
+            cerr << indent << line << endl;
+
+        //  regressions check point
+
+        if( getenv( "SYSTEMC_REGRESSION" ) != 0 ) {
+            cerr << "SystemC Simulation" << endl;
+        }
+
+        lnp = true;
+    }
+}
+
+#define SC_API_PERFORM_CHECK_( Type, Name, Symbol ) \
+  do { \
+    static bool SC_CONCAT_UNDERSCORE_( Name, config_seen ) = false; \
+    static Type SC_CONCAT_UNDERSCORE_( Name, config ); \
+    if( ! SC_CONCAT_UNDERSCORE_( Name, config_seen ) ) { \
+      SC_CONCAT_UNDERSCORE_( Name, config_seen ) = true; \
+      SC_CONCAT_UNDERSCORE_( Name, config ) = Name; \
+    } else if( SC_CONCAT_UNDERSCORE_( Name, config ) != Name ) { \
+      SC_REPORT_FATAL( SC_ID_INCONSISTENT_API_CONFIG_, Symbol ); \
+    } \
+  } while( false )
+
+// THIS CONSTRUCTOR ROOTS OUT OLD OBJECTS AT LINK TIME
+//
+// Each source file which includes sc_ver.h for this SystemC version 
+// will have a static instance of the class sc_api_version_XXX defined 
+// in it. That object instanciation will cause the constructor below 
+// to be invoked. If the version of the SystemC being linked against
+// does not contain the constructor below a linkage error will occur.
+//
+// Some preprocessor switches need to be consistent between the application
+// and the library (e.g. if sizes of classes are affected or other parts of
+// the ABI are affected).  (Some of) these are checked here at link-time as
+// well, by setting template parameters to sc_api_version_XXX, while only
+// one variant is defined here.
+//
+// Some preprocessor switches need to be consistent between different
+// translation units of an application.  Those can't be easily checked
+// during link-time.  Instead, perform a check during run-time by
+// passing the value to the constructor of the api_version_check object.
+
+// const int DEBUG_SYSTEMC_CHECK_           = 1;
+const int SC_DISABLE_VIRTUAL_BIND_CHECK_ = 1;
+
+template<>
+SC_API_VERSION_STRING
+<
+//   & DEBUG_SYSTEMC_CHECK_,
+  & SC_DISABLE_VIRTUAL_BIND_CHECK_
+>
+::SC_API_VERSION_STRING
+(
+  sc_writer_policy default_writer_policy
+)
+{
+  SC_API_PERFORM_CHECK_( sc_writer_policy
+                          , default_writer_policy
+                          , "SC_DEFAULT_WRITER_POLICY" );
+}
+
+} // namespace sc_core
+
+// $Log: sc_ver.cpp,v $
+// Revision 1.14  2011/08/26 21:56:55  acg
+//  Torsten Maehne: use usings rather than absolute namespace addressing.
+//
+// Revision 1.13  2011/08/26 20:46:11  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.12  2011/07/25 10:20:34  acg
+//  Andy Goodrich: check in aftermath of call to automake.
+//
+// Revision 1.11  2011/07/02 12:55:19  acg
+//  Andy Goodrich: automake refresh.
+//
+// Revision 1.10  2011/07/01 18:49:07  acg
+//  Andy Goodrich: moved pln() from sc_simcontext.cpp to sc_ver.cpp.
+//
+// Revision 1.9  2011/07/01 18:33:08  acg
+//  Andy Goodrich: changes for IEEE 1666, removal of macros and use of them.
+//
+// Revision 1.8  2011/04/08 18:27:53  acg
+//  Andy Goodrich: respin of the PoC.
+//
+// Revision 1.7  2011/04/05 20:50:57  acg
+//  Andy Goodrich:
+//    (1) changes to make sure that event(), posedge() and negedge() only
+//        return true if the clock has not moved.
+//    (2) fixes for method self-resumes.
+//    (3) added SC_PRERELEASE_VERSION
+//    (4) removed kernel events from the object hierarchy, added
+//        sc_hierarchy_name_exists().
+//
+// Revision 1.6  2011/02/18 20:27:14  acg
+//  Andy Goodrich: Updated Copyrights.
+//
+// Revision 1.5  2011/02/13 21:47:38  acg
+//  Andy Goodrich: update copyright notice.
+//
+// Revision 1.4  2011/01/18 20:10:45  acg
+//  Andy Goodrich: changes for IEEE1666_2011 semantics.
+//
+// Revision 1.3  2010/11/20 17:10:57  acg
+//  Andy Goodrich: reset processing changes for new IEEE 1666 standard.
+//
+// Revision 1.2  2008/05/22 17:06:27  acg
+//  Andy Goodrich: updated copyright notice to include 2008.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:44:30  acg
+// Added $Log to record CVS changes into the source.
+//
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_ver.h b/ext/systemc/src/sysc/kernel/sc_ver.h
new file mode 100644
index 000000000..34112f9f8
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_ver.h
@@ -0,0 +1,186 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_ver.h -- Version and copyright information.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+ NO AUTOMATIC CHANGE LOG IS GENERATED, EXPLICIT CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+
+#ifndef SC_VER_H
+#define SC_VER_H
+
+#include "sysc/kernel/sc_macros.h"               // SC_CONCAT_UNDERSCORE_
+                                                 // SC_STRINGIFY_HELPER_
+#include "sysc/communication/sc_writer_policy.h" // SC_DEFAULT_WRITER_POLICY
+
+#include <string>
+
+namespace sc_core {
+
+extern const char* sc_copyright();
+extern const char* sc_release();
+extern const char* sc_version();
+
+extern const unsigned int sc_version_major;
+extern const unsigned int sc_version_minor;
+extern const unsigned int sc_version_patch;
+
+extern const std::string  sc_version_originator;
+extern const std::string  sc_version_release_date;
+extern const std::string  sc_version_prerelease;
+extern const bool         sc_is_prerelease;
+extern const std::string  sc_version_string;
+extern const std::string  sc_copyright_string;
+
+#define SYSTEMC_2_3_1
+ 
+#define SYSTEMC_VERSION       20140417
+#define SC_VERSION_ORIGINATOR "Accellera"
+#define SC_VERSION_MAJOR      2
+#define SC_VERSION_MINOR      3
+#define SC_VERSION_PATCH      1
+#define SC_IS_PRERELEASE      0
+
+/// compliancy with IEEE 1666-2011 (see 8.6.5)
+#define IEEE_1666_SYSTEMC     201101L
+
+#define SC_COPYRIGHT                               \
+  "Copyright (c) 1996-2014 by all Contributors,\n" \
+  "ALL RIGHTS RESERVED\n"
+
+
+#define SC_VERSION_RELEASE_DATE \
+  SC_STRINGIFY_HELPER_( SYSTEMC_VERSION )
+
+#if ( SC_IS_PRERELEASE == 1 )
+#  define SC_VERSION_PRERELEASE "pub_rev"
+#  define SC_VERSION \
+    SC_STRINGIFY_HELPER_( SC_VERSION_MAJOR.SC_VERSION_MINOR.SC_VERSION_PATCH ) \
+    "_" SC_VERSION_PRERELEASE "_" SC_VERSION_RELEASE_DATE \
+    "-" SC_VERSION_ORIGINATOR
+#else
+#  define SC_VERSION_PRERELEASE "" // nothing
+#  define SC_VERSION \
+    SC_STRINGIFY_HELPER_( SC_VERSION_MAJOR.SC_VERSION_MINOR.SC_VERSION_PATCH ) \
+    "-" SC_VERSION_ORIGINATOR
+#endif
+
+// THIS CLASS AND STATIC INSTANCE BELOW DETECTS BAD REV OBJECTS AT LINK TIME
+//
+// Each source file which includes this file for the current SystemC version 
+// will have a static instance of the class sc_api_version_XXX defined
+// in it. That object instance will cause the constructor below
+// to be invoked. If the version of the SystemC being linked against
+// does not contain the constructor below a linkage error will occur.
+
+#define SC_API_VERSION_STRING \
+      SC_CONCAT_UNDERSCORE_( sc_api_version, \
+      SC_CONCAT_UNDERSCORE_( SC_VERSION_MAJOR, \
+      SC_CONCAT_UNDERSCORE_( SC_VERSION_MINOR, \
+                             SC_VERSION_PATCH ) ) )
+
+// explicitly avoid macro expansion
+#define SC_API_DEFINED_( Symbol ) \
+  Symbol ## _DEFINED_
+#define SC_API_UNDEFINED_( Symbol ) \
+  Symbol ## _UNDEFINED_
+
+// Some preprocessor switches need to be consistent between the application
+// and the library (e.g. if sizes of classes are affected or other parts of
+// the ABI are affected).  (Some of) these are checked here at link-time as
+// well, by setting template parameters to sc_api_version_XXX, while only
+// one variant is defined in sc_ver.cpp.
+
+#if 0 // don't enforce check of DEBUG_SYSTEMC for now
+// DEBUG_SYSTEMC
+#if defined( DEBUG_SYSTEMC )
+# define DEBUG_SYSTEMC_CHECK_ \
+    SC_CONFIG_DEFINED_(DEBUG_SYSTEMC)
+#else
+# define DEBUG_SYSTEMC_CHECK_ \
+    SC_CONFIG_UNDEFINED_(DEBUG_SYSTEMC)
+#endif
+extern const int DEBUG_SYSTEMC_CHECK_;
+#endif
+
+// SC_DISABLE_VIRTUAL_BIND
+#if defined( SC_DISABLE_VIRTUAL_BIND )
+# define SC_DISABLE_VIRTUAL_BIND_CHECK_ \
+    SC_API_DEFINED_(SC_DISABLE_VIRTUAL_BIND)
+#else
+# define SC_DISABLE_VIRTUAL_BIND_CHECK_ \
+    SC_API_UNDEFINED_(SC_DISABLE_VIRTUAL_BIND)
+#endif
+extern const int SC_DISABLE_VIRTUAL_BIND_CHECK_;
+
+// Some preprocessor switches need to be consistent between different
+// translation units of an application.  Those can't be easily checked
+// during link-time.  Instead, perform a check during run-time by
+// passing the value to the constructor of the api_version_check object.
+
+// Note: Template and constructor parameters are not passed as default
+//       values to avoid ODR violations in the check itself.
+
+template // use pointers for more verbose error messages
+<
+//  const int * DebugSystemC,
+  const int * DisableVirtualBind
+>
+struct SC_API_VERSION_STRING
+{
+  SC_API_VERSION_STRING
+    (
+       // SC_DEFAULT_WRITER_POLICY
+       sc_writer_policy default_writer_policy
+    );
+};
+
+#if !defined( SC_DISABLE_API_VERSION_CHECK ) // disabled in sc_ver.cpp
+static
+SC_API_VERSION_STRING
+<
+//  & DEBUG_SYSTEMC_CHECK_,
+  & SC_DISABLE_VIRTUAL_BIND_CHECK_
+>
+api_version_check
+(
+  SC_DEFAULT_WRITER_POLICY
+);
+#endif // SC_DISABLE_API_VERSION_CHECK
+
+//#undef SC_API_DEFINED_
+//#undef SC_API_UNDEFINED_
+
+} // namespace sc_core
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+#endif
diff --git a/ext/systemc/src/sysc/kernel/sc_wait.cpp b/ext/systemc/src/sysc/kernel/sc_wait.cpp
new file mode 100644
index 000000000..9c9f2bdfb
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_wait.cpp
@@ -0,0 +1,446 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_wait.cpp -- Wait() and related functions.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+                   Martin Janssen, Synopsys, Inc.
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#include "sysc/kernel/sc_except.h"
+#include "sysc/kernel/sc_kernel_ids.h"
+#include "sysc/kernel/sc_cthread_process.h"
+#include "sysc/kernel/sc_thread_process.h"
+#include "sysc/kernel/sc_simcontext_int.h"
+#include "sysc/kernel/sc_wait.h"
+#include "sysc/utils/sc_utils_ids.h"
+
+namespace sc_core {
+
+// static sensitivity for SC_THREADs and SC_CTHREADs
+
+void warn_cthread_wait()
+{
+    static bool warn_wait = true;
+    if ( warn_wait )
+    {
+        warn_wait = false;
+        SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
+	    "all waits except wait() and wait(N)\n" \
+	    "             are deprecated for SC_CTHREAD, " \
+	    "use an SC_THREAD instead");
+    }
+}
+
+void
+wait( sc_simcontext* simc )
+{
+    sc_curr_proc_handle cpi = simc->get_curr_proc_info();
+    switch( cpi->kind ) {
+    case SC_THREAD_PROC_: 
+    case SC_CTHREAD_PROC_: {
+	RCAST<sc_cthread_handle>( cpi->process_handle )->wait_cycles();
+        break;
+    }
+    default:
+	SC_REPORT_ERROR( SC_ID_WAIT_NOT_ALLOWED_, "\n        "
+			 "in SC_METHODs use next_trigger() instead" );
+        break;
+    }
+}
+
+// dynamic sensitivity for SC_THREADs and SC_CTHREADs
+
+void
+wait( const sc_event& e, sc_simcontext* simc )
+{
+    sc_curr_proc_handle cpi = simc->get_curr_proc_info();
+    switch( cpi->kind ) {
+    case SC_THREAD_PROC_: {
+	RCAST<sc_thread_handle>( cpi->process_handle )->wait( e );
+	break;
+    }
+    case SC_CTHREAD_PROC_: {
+        warn_cthread_wait();
+	sc_cthread_handle cthread_h =
+            RCAST<sc_cthread_handle>( cpi->process_handle );
+	cthread_h->wait( e );
+	cthread_h->wait_cycles();
+	break;
+    }
+    default:
+	SC_REPORT_ERROR( SC_ID_WAIT_NOT_ALLOWED_, "\n        "
+			 "in SC_METHODs use next_trigger() instead" );
+        break;
+    }
+}
+
+void
+wait( const sc_event_or_list& el, sc_simcontext* simc )
+{
+    sc_curr_proc_handle cpi = simc->get_curr_proc_info();
+    switch( cpi->kind ) {
+    case SC_THREAD_PROC_: {
+	RCAST<sc_thread_handle>( cpi->process_handle )->wait( el );
+	break;
+    }
+    case SC_CTHREAD_PROC_: {
+        warn_cthread_wait();
+        SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
+	    "wait(event_list) is deprecated for SC_CTHREAD, use SC_THREAD");
+	sc_cthread_handle cthread_h =
+            RCAST<sc_cthread_handle>( cpi->process_handle );
+	cthread_h->wait( el );
+	cthread_h->wait_cycles();
+	break;
+    }
+    default:
+	SC_REPORT_ERROR( SC_ID_WAIT_NOT_ALLOWED_, "\n        "
+			 "in SC_METHODs use next_trigger() instead" );
+        break;
+    }
+}
+
+void
+wait( const sc_event_and_list& el, sc_simcontext* simc )
+{
+    sc_curr_proc_handle cpi = simc->get_curr_proc_info();
+    switch( cpi->kind ) {
+    case SC_THREAD_PROC_: {
+	RCAST<sc_thread_handle>( cpi->process_handle )->wait( el );
+	break;
+    }
+    case SC_CTHREAD_PROC_: {
+        warn_cthread_wait();
+	sc_cthread_handle cthread_h =
+            RCAST<sc_cthread_handle>( cpi->process_handle );
+	cthread_h->wait( el );
+	cthread_h->wait_cycles();
+	break;
+    }
+    default:
+	SC_REPORT_ERROR( SC_ID_WAIT_NOT_ALLOWED_, "\n        "
+			 "in SC_METHODs use next_trigger() instead" );
+        break;
+    }
+}
+
+void
+wait( const sc_time& t, sc_simcontext* simc )
+{
+    sc_curr_proc_handle cpi = simc->get_curr_proc_info();
+    switch( cpi->kind ) {
+    case SC_THREAD_PROC_: {
+	RCAST<sc_thread_handle>( cpi->process_handle )->wait( t );
+	break;
+    }
+    case SC_CTHREAD_PROC_: {
+        warn_cthread_wait();
+	sc_cthread_handle cthread_h =
+            RCAST<sc_cthread_handle>( cpi->process_handle );
+	cthread_h->wait( t );
+	cthread_h->wait_cycles();
+	break;
+    }
+    default:
+	SC_REPORT_ERROR( SC_ID_WAIT_NOT_ALLOWED_, "\n        "
+			 "in SC_METHODs use next_trigger() instead" );
+        break;
+    }
+}
+
+void
+wait( const sc_time& t, const sc_event& e, sc_simcontext* simc )
+{
+    sc_curr_proc_handle cpi = simc->get_curr_proc_info();
+    switch( cpi->kind ) {
+    case SC_THREAD_PROC_: {
+	RCAST<sc_thread_handle>( cpi->process_handle )->wait( t, e );
+	break;
+    }
+    case SC_CTHREAD_PROC_: {
+        warn_cthread_wait();
+	sc_cthread_handle cthread_h =
+            RCAST<sc_cthread_handle>( cpi->process_handle );
+	cthread_h->wait( t, e );
+	cthread_h->wait_cycles();
+	break;
+    }
+    default:
+	SC_REPORT_ERROR( SC_ID_WAIT_NOT_ALLOWED_, "\n        "
+			 "in SC_METHODs use next_trigger() instead" );
+        break;
+    }
+}
+
+void
+wait( const sc_time& t, const sc_event_or_list& el, sc_simcontext* simc )
+{
+    sc_curr_proc_handle cpi = simc->get_curr_proc_info();
+    switch( cpi->kind ) {
+    case SC_THREAD_PROC_: {
+	RCAST<sc_thread_handle>( cpi->process_handle )->wait( t, el );
+	break;
+    }
+    case SC_CTHREAD_PROC_: {
+        warn_cthread_wait();
+	sc_cthread_handle cthread_h =
+            RCAST<sc_cthread_handle>( cpi->process_handle );
+	cthread_h->wait( t, el );
+	cthread_h->wait_cycles();
+	break;
+    }
+    default:
+	SC_REPORT_ERROR( SC_ID_WAIT_NOT_ALLOWED_, "\n        "
+			 "in SC_METHODs use next_trigger() instead" );
+        break;
+    }
+}
+
+void
+wait( const sc_time& t, const sc_event_and_list& el, sc_simcontext* simc )
+{
+    sc_curr_proc_handle cpi = simc->get_curr_proc_info();
+    switch( cpi->kind ) {
+    case SC_THREAD_PROC_: {
+	RCAST<sc_thread_handle>( cpi->process_handle )->wait( t, el );
+	break;
+    }
+    case SC_CTHREAD_PROC_: {
+        warn_cthread_wait();
+	sc_cthread_handle cthread_h =
+            RCAST<sc_cthread_handle>( cpi->process_handle );
+	cthread_h->wait( t, el );
+	cthread_h->wait_cycles();
+	break;
+    }
+    default:
+	SC_REPORT_ERROR( SC_ID_WAIT_NOT_ALLOWED_, "\n        "
+			 "in SC_METHODs use next_trigger() instead" );
+        break;
+    }
+}
+
+
+// static sensitivity for SC_METHODs
+
+void
+next_trigger( sc_simcontext* simc )
+{
+    sc_curr_proc_handle cpi = simc->get_curr_proc_info();
+    if( cpi->kind == SC_METHOD_PROC_ ) {
+	RCAST<sc_method_handle>( cpi->process_handle )->clear_trigger();
+    } else {
+	SC_REPORT_ERROR( SC_ID_NEXT_TRIGGER_NOT_ALLOWED_, "\n        "
+			 "in SC_THREADs and SC_CTHREADs use wait() instead" );
+    }
+}
+
+
+// dynamic sensitivity for SC_METHODs
+
+void
+next_trigger( const sc_event& e, sc_simcontext* simc )
+{
+    sc_curr_proc_handle cpi = simc->get_curr_proc_info();
+    if( cpi->kind == SC_METHOD_PROC_ ) {
+	RCAST<sc_method_handle>( cpi->process_handle )->next_trigger( e );
+    } else {
+	SC_REPORT_ERROR( SC_ID_NEXT_TRIGGER_NOT_ALLOWED_, "\n        "
+			 "in SC_THREADs and SC_CTHREADs use wait() instead" );
+    }
+}
+
+void
+next_trigger( const sc_event_or_list& el, sc_simcontext* simc )
+{
+    sc_curr_proc_handle cpi = simc->get_curr_proc_info();
+    if( cpi->kind == SC_METHOD_PROC_ ) {
+	RCAST<sc_method_handle>( cpi->process_handle )->next_trigger( el );
+    } else {
+	SC_REPORT_ERROR( SC_ID_NEXT_TRIGGER_NOT_ALLOWED_, "\n        "
+			 "in SC_THREADs and SC_CTHREADs use wait() instead" );
+    }
+}
+
+void
+next_trigger( const sc_event_and_list& el, sc_simcontext* simc )
+{
+    sc_curr_proc_handle cpi = simc->get_curr_proc_info();
+    if( cpi->kind == SC_METHOD_PROC_ ) {
+	RCAST<sc_method_handle>( cpi->process_handle )->next_trigger( el );
+    } else {
+	SC_REPORT_ERROR( SC_ID_NEXT_TRIGGER_NOT_ALLOWED_, "\n        "
+			 "in SC_THREADs and SC_CTHREADs use wait() instead" );
+    }
+}
+
+void
+next_trigger( const sc_time& t, sc_simcontext* simc )
+{
+    sc_curr_proc_handle cpi = simc->get_curr_proc_info();
+    if( cpi->kind == SC_METHOD_PROC_ ) {
+	RCAST<sc_method_handle>( cpi->process_handle )->next_trigger( t );
+    } else {
+	SC_REPORT_ERROR( SC_ID_NEXT_TRIGGER_NOT_ALLOWED_, "\n        "
+			 "in SC_THREADs and SC_CTHREADs use wait() instead" );
+    }
+}
+
+void
+next_trigger( const sc_time& t, const sc_event& e, sc_simcontext* simc )
+{
+    sc_curr_proc_handle cpi = simc->get_curr_proc_info();
+    if( cpi->kind == SC_METHOD_PROC_ ) {
+	RCAST<sc_method_handle>( cpi->process_handle )->next_trigger( t, e );
+    } else {
+	SC_REPORT_ERROR( SC_ID_NEXT_TRIGGER_NOT_ALLOWED_, "\n        "
+			 "in SC_THREADs and SC_CTHREADs use wait() instead" );
+    }
+}
+
+void
+next_trigger( const sc_time& t, const sc_event_or_list& el, sc_simcontext* simc)
+{
+    sc_curr_proc_handle cpi = simc->get_curr_proc_info();
+    if( cpi->kind == SC_METHOD_PROC_ ) {
+	RCAST<sc_method_handle>( cpi->process_handle )->next_trigger( t, el );
+    } else {
+	SC_REPORT_ERROR( SC_ID_NEXT_TRIGGER_NOT_ALLOWED_, "\n        "
+			 "in SC_THREADs and SC_CTHREADs use wait() instead" );
+    }
+}
+
+void
+next_trigger(const sc_time& t, const sc_event_and_list& el, sc_simcontext* simc)
+{
+    sc_curr_proc_handle cpi = simc->get_curr_proc_info();
+    if( cpi->kind == SC_METHOD_PROC_ ) {
+	RCAST<sc_method_handle>( cpi->process_handle )->next_trigger( t, el );
+    } else {
+	SC_REPORT_ERROR( SC_ID_NEXT_TRIGGER_NOT_ALLOWED_, "\n        "
+			 "in SC_THREADs and SC_CTHREADs use wait() instead" );
+    }
+}
+
+
+// for SC_METHODs and SC_THREADs and SC_CTHREADs
+
+bool
+timed_out( sc_simcontext* simc )
+{
+    static bool warn_timed_out=true; 
+    if ( warn_timed_out )
+    {
+        warn_timed_out = false;
+        SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
+	    "timed_out() function is deprecated" );
+    }
+
+    sc_curr_proc_handle cpi = simc->get_curr_proc_info();
+    return cpi->process_handle->timed_out();
+}
+
+
+
+// misc.
+
+void
+sc_set_location( const char* file, int lineno, sc_simcontext* simc )
+{
+    sc_curr_proc_handle cpi = simc->get_curr_proc_info();
+    sc_process_b* handle = cpi->process_handle;
+    handle->file = file;
+    handle->lineno = lineno;
+}
+
+} // namespace sc_core
+
+/* 
+$Log: sc_wait.cpp,v $
+Revision 1.6  2011/08/26 20:46:11  acg
+ Andy Goodrich: moved the modification log to the end of the file to
+ eliminate source line number skew when check-ins are done.
+
+Revision 1.5  2011/02/18 20:27:14  acg
+ Andy Goodrich: Updated Copyrights.
+
+Revision 1.4  2011/02/13 21:47:38  acg
+ Andy Goodrich: update copyright notice.
+
+Revision 1.3  2011/01/18 20:10:45  acg
+ Andy Goodrich: changes for IEEE1666_2011 semantics.
+
+Revision 1.2  2008/05/22 17:06:27  acg
+ Andy Goodrich: updated copyright notice to include 2008.
+
+Revision 1.1.1.1  2006/12/15 20:20:05  acg
+SystemC 2.3
+
+Revision 1.7  2006/02/02 20:20:39  acg
+ Andy Goodrich: warnings for SC_THREAD waits.
+
+Revision 1.6  2006/02/01 01:36:54  acg
+ Andy Goodrich: addition of deprecation comments for SC_CTHREAD waits other
+ than wait() and wait(N).
+
+Revision 1.5  2006/01/31 22:17:40  acg
+ Andy Goodrich: added deprecation warnings for SC_CTHREAD waits other than
+ wait() and wait(N).
+
+Revision 1.4  2006/01/25 00:31:20  acg
+ Andy Goodrich: Changed over to use a standard message id of
+ SC_ID_IEEE_1666_DEPRECATION for all deprecation messages.
+
+Revision 1.3  2006/01/24 20:49:05  acg
+Andy Goodrich: changes to remove the use of deprecated features within the
+simulator, and to issue warning messages when deprecated features are used.
+
+Revision 1.2  2006/01/03 23:18:45  acg
+Changed copyright to include 2006.
+
+Revision 1.1.1.1  2005/12/19 23:16:44  acg
+First check in of SystemC 2.1 into its own archive.
+
+Revision 1.10  2005/09/02 19:03:30  acg
+Changes for dynamic processes. Removal of lambda support.
+
+Revision 1.9  2005/07/30 03:45:05  acg
+Changes from 2.1, including changes for sc_process_handle.
+
+Revision 1.8  2005/04/04 00:16:07  acg
+Changes for directory name change to sys from systemc.
+Changes for sc_string going to std::string.
+Changes for sc_pvector going to std::vector.
+Changes for reference pools for bit and part selections.
+Changes for const sc_concatref support.
+
+Revision 1.5  2004/09/27 20:49:10  acg
+Andy Goodrich, Forte Design Systems, Inc.
+   - Added a $Log comment so that CVS checkin comments appear in the
+     checkout source.
+
+*/
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_wait.h b/ext/systemc/src/sysc/kernel/sc_wait.h
new file mode 100644
index 000000000..f598cf4bb
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_wait.h
@@ -0,0 +1,277 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_wait.h -- Wait() and related functions.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+                   Martin Janssen, Synopsys, Inc.
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+#ifndef SC_WAIT_H
+#define SC_WAIT_H
+
+
+#include "sysc/kernel/sc_simcontext.h"
+
+namespace sc_core {
+
+class sc_event;
+class sc_event_and_list;
+class sc_event_or_list;
+class sc_simcontext;
+
+extern sc_simcontext* sc_get_curr_simcontext();
+
+// static sensitivity for SC_THREADs and SC_CTHREADs
+
+extern
+void
+wait( sc_simcontext* = sc_get_curr_simcontext() );
+
+
+// dynamic sensitivity for SC_THREADs and SC_CTHREADs
+
+extern
+void
+wait( const sc_event&,
+      sc_simcontext* = sc_get_curr_simcontext() );
+
+extern
+void
+wait( const sc_event_or_list&,
+      sc_simcontext* = sc_get_curr_simcontext() );
+
+extern
+void
+wait( const sc_event_and_list&,
+      sc_simcontext* = sc_get_curr_simcontext() );
+
+extern
+void
+wait( const sc_time&,
+      sc_simcontext* = sc_get_curr_simcontext() );
+
+inline
+void
+wait( double v, sc_time_unit tu,
+      sc_simcontext* simc = sc_get_curr_simcontext() )
+{
+    wait( sc_time( v, tu, simc ), simc );
+}
+
+extern
+void
+wait( const sc_time&,
+      const sc_event&,
+      sc_simcontext* = sc_get_curr_simcontext() );
+
+inline
+void
+wait( double v, sc_time_unit tu,
+      const sc_event& e,
+      sc_simcontext* simc = sc_get_curr_simcontext() )
+{
+    wait( sc_time( v, tu, simc ), e, simc );
+}
+
+extern
+void
+wait( const sc_time&,
+      const sc_event_or_list&,
+      sc_simcontext* = sc_get_curr_simcontext() );
+
+inline
+void
+wait( double v, sc_time_unit tu,
+      const sc_event_or_list& el,
+      sc_simcontext* simc = sc_get_curr_simcontext() )
+{
+    wait( sc_time( v, tu, simc ), el, simc );
+}
+
+extern
+void
+wait( const sc_time&,
+      const sc_event_and_list&,
+      sc_simcontext* = sc_get_curr_simcontext() );
+
+inline
+void
+wait( double v, sc_time_unit tu,
+      const sc_event_and_list& el,
+      sc_simcontext* simc = sc_get_curr_simcontext() )
+{
+    wait( sc_time( v, tu, simc ), el, simc );
+}
+
+
+// static sensitivity for SC_METHODs
+
+extern
+void
+next_trigger( sc_simcontext* = sc_get_curr_simcontext() );
+
+
+// dynamic sensitivity for SC_METHODs
+
+extern
+void
+next_trigger( const sc_event&,
+	      sc_simcontext* = sc_get_curr_simcontext() );
+
+extern
+void
+next_trigger( const sc_event_or_list&,
+	      sc_simcontext* = sc_get_curr_simcontext() );
+
+extern
+void
+next_trigger( const sc_event_and_list&,
+	      sc_simcontext* = sc_get_curr_simcontext() );
+
+extern
+void
+next_trigger( const sc_time&,
+	      sc_simcontext* = sc_get_curr_simcontext() );
+
+inline
+void
+next_trigger( double v, sc_time_unit tu,
+	      sc_simcontext* simc = sc_get_curr_simcontext() )
+{
+    next_trigger( sc_time( v, tu, simc ), simc );
+}
+
+extern
+void
+next_trigger( const sc_time&,
+	      const sc_event&,
+	      sc_simcontext* = sc_get_curr_simcontext() );
+
+inline
+void
+next_trigger( double v, sc_time_unit tu,
+	      const sc_event& e,
+	      sc_simcontext* simc = sc_get_curr_simcontext() )
+{
+    next_trigger( sc_time( v, tu, simc ), e, simc );
+}
+
+extern
+void
+next_trigger( const sc_time&,
+	      const sc_event_or_list&,
+	      sc_simcontext* = sc_get_curr_simcontext() );
+
+inline
+void
+next_trigger( double v, sc_time_unit tu,
+	      const sc_event_or_list& el,
+	      sc_simcontext* simc = sc_get_curr_simcontext() )
+{
+    next_trigger( sc_time( v, tu, simc ), el, simc );
+}
+
+extern
+void
+next_trigger( const sc_time&,
+	      const sc_event_and_list&,
+	      sc_simcontext* = sc_get_curr_simcontext() );
+
+inline
+void
+next_trigger( double v, sc_time_unit tu,
+	      const sc_event_and_list& el,
+	      sc_simcontext* simc = sc_get_curr_simcontext() )
+{
+    next_trigger( sc_time( v, tu, simc ), el, simc );
+}
+
+
+// for SC_METHODs and SC_THREADs and SC_CTHREADs
+
+extern
+bool
+timed_out( sc_simcontext* = sc_get_curr_simcontext() );
+
+// misc.
+
+extern
+void
+sc_set_location( const char*,
+		 int,
+		 sc_simcontext* = sc_get_curr_simcontext() );
+
+} // namespace sc_core
+
+/*
+$Log: sc_wait.h,v $
+Revision 1.6  2011/08/26 20:46:11  acg
+ Andy Goodrich: moved the modification log to the end of the file to
+ eliminate source line number skew when check-ins are done.
+
+Revision 1.5  2011/02/18 20:27:14  acg
+ Andy Goodrich: Updated Copyrights.
+
+Revision 1.4  2011/02/13 21:47:38  acg
+ Andy Goodrich: update copyright notice.
+
+Revision 1.3  2011/01/18 20:10:45  acg
+ Andy Goodrich: changes for IEEE1666_2011 semantics.
+
+Revision 1.2  2008/05/22 17:06:27  acg
+ Andy Goodrich: updated copyright notice to include 2008.
+
+Revision 1.1.1.1  2006/12/15 20:20:05  acg
+SystemC 2.3
+
+Revision 1.2  2006/01/03 23:18:45  acg
+Changed copyright to include 2006.
+
+Revision 1.1.1.1  2005/12/19 23:16:44  acg
+First check in of SystemC 2.1 into its own archive.
+
+Revision 1.10  2005/07/30 03:45:05  acg
+Changes from 2.1, including changes for sc_process_handle.
+
+Revision 1.9  2005/04/04 00:16:08  acg
+Changes for directory name change to sys from systemc.
+Changes for sc_string going to std::string.
+Changes for sc_pvector going to std::vector.
+Changes for reference pools for bit and part selections.
+Changes for const sc_concatref support.
+
+Revision 1.6  2004/10/13 18:13:22  acg
+sc_ver.h - updated version number. sc_wait.h remove inclusion of
+sysc/kernel/sc_event.h because it is not necessary.
+
+Revision 1.5  2004/09/27 20:49:10  acg
+Andy Goodrich, Forte Design Systems, Inc.
+   - Added a $Log comment so that CVS checkin comments appear in the
+        checkout source.
+
+*/
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_wait_cthread.cpp b/ext/systemc/src/sysc/kernel/sc_wait_cthread.cpp
new file mode 100644
index 000000000..4dee96ed7
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_wait_cthread.cpp
@@ -0,0 +1,169 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_wait_cthread.cpp -- Wait() and related functions for SC_CTHREADs.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+                   Martin Janssen, Synopsys, Inc.
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+
+#include "sysc/kernel/sc_kernel_ids.h"
+#include "sysc/kernel/sc_cthread_process.h"
+#include "sysc/kernel/sc_simcontext_int.h"
+#include "sysc/kernel/sc_wait_cthread.h"
+#include "sysc/communication/sc_port.h"
+#include "sysc/kernel/sc_wait.h"
+namespace sc_core 
+{
+
+// for SC_CTHREADs
+
+void
+halt( sc_simcontext* simc )
+{
+    sc_curr_proc_handle cpi = simc->get_curr_proc_info();
+    switch( cpi->kind ) {
+    case SC_CTHREAD_PROC_: {
+	RCAST<sc_cthread_handle>( cpi->process_handle )->wait_halt();
+	break;
+    }
+    default:
+	SC_REPORT_ERROR( SC_ID_HALT_NOT_ALLOWED_, 0 );
+	break;
+    }
+}
+
+
+void
+wait( int n, sc_simcontext* simc )
+{
+    sc_curr_proc_handle cpi = simc->get_curr_proc_info();
+    if( n <= 0 ) {
+	char msg[BUFSIZ];
+	std::sprintf( msg, "n = %d", n );
+	SC_REPORT_ERROR( SC_ID_WAIT_N_INVALID_, msg );
+    }
+    switch( cpi->kind ) {
+      case SC_THREAD_PROC_: 
+      case SC_CTHREAD_PROC_: 
+	RCAST<sc_cthread_handle>( cpi->process_handle )->wait_cycles( n );
+        break;
+      default:
+        SC_REPORT_ERROR( SC_ID_WAIT_NOT_ALLOWED_, "\n        "
+	                 "in SC_METHODs use next_trigger() instead" );
+        break;
+    }
+}
+
+
+void
+at_posedge( const sc_signal_in_if<bool>& s, sc_simcontext* simc )
+{
+    if( s.read() == true ) 
+        do { wait(simc); } while ( s.read() == true );
+    do { wait(simc); } while ( s.read() == false );
+}
+
+void
+at_posedge( const sc_signal_in_if<sc_dt::sc_logic>& s, sc_simcontext* simc )
+{
+    if( s.read() == '1' ) 
+        do { wait(simc); } while ( s.read() == '1' );
+    do { wait(simc); } while ( s.read() == '0' );
+}
+
+void
+at_negedge( const sc_signal_in_if<bool>& s, sc_simcontext* simc )
+{
+    if( s.read() == false ) 
+        do { wait(simc); } while ( s.read() == false );
+    do { wait(simc); } while ( s.read() == true );
+}
+
+void
+at_negedge( const sc_signal_in_if<sc_dt::sc_logic>& s, sc_simcontext* simc )
+{
+    if( s.read() == '0' ) 
+        do { wait(simc); } while ( s.read() == '0' );
+    do { wait(simc); } while ( s.read() == '1' );
+}
+
+
+} // namespace sc_core
+
+/* 
+$Log: sc_wait_cthread.cpp,v $
+Revision 1.6  2011/08/26 20:46:11  acg
+ Andy Goodrich: moved the modification log to the end of the file to
+ eliminate source line number skew when check-ins are done.
+
+Revision 1.5  2011/02/18 20:27:14  acg
+ Andy Goodrich: Updated Copyrights.
+
+Revision 1.4  2011/02/13 21:47:38  acg
+ Andy Goodrich: update copyright notice.
+
+Revision 1.3  2009/10/14 19:07:42  acg
+ Andy Goodrich: added an error message for wait(n) being called from an
+ SC_METHOD.
+
+Revision 1.2  2008/05/22 17:06:27  acg
+ Andy Goodrich: updated copyright notice to include 2008.
+
+Revision 1.1.1.1  2006/12/15 20:20:05  acg
+SystemC 2.3
+
+Revision 1.3  2006/03/13 20:26:51  acg
+ Andy Goodrich: Addition of forward class declarations, e.g.,
+ sc_reset, to keep gcc 4.x happy.
+
+Revision 1.2  2006/01/03 23:18:45  acg
+Changed copyright to include 2006.
+
+Revision 1.1.1.1  2005/12/19 23:16:44  acg
+First check in of SystemC 2.1 into its own archive.
+
+Revision 1.10  2005/09/15 23:02:18  acg
+Added std:: prefix to appropriate methods and types to get around
+issues with the Edison Front End.
+
+Revision 1.9  2005/09/02 19:03:30  acg
+Changes for dynamic processes. Removal of lambda support.
+
+Revision 1.8  2005/04/04 00:16:08  acg
+Changes for directory name change to sys from systemc.
+Changes for sc_string going to std::string.
+Changes for sc_pvector going to std::vector.
+Changes for reference pools for bit and part selections.
+Changes for const sc_concatref support.
+
+Revision 1.5  2004/09/27 20:49:10  acg
+Andy Goodrich, Forte Design Systems, Inc.
+   - Added a $Log comment so that CVS checkin comments appear in the
+     checkout source.
+
+*/
+
+// Taf!
diff --git a/ext/systemc/src/sysc/kernel/sc_wait_cthread.h b/ext/systemc/src/sysc/kernel/sc_wait_cthread.h
new file mode 100644
index 000000000..a04bfecc1
--- /dev/null
+++ b/ext/systemc/src/sysc/kernel/sc_wait_cthread.h
@@ -0,0 +1,126 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_wait_cthread.h -- Wait() and related functions for SC_CTHREADs.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+                   Martin Janssen, Synopsys, Inc.
+
+  CHANGE LOG AT THE END OF THE FILE
+ *****************************************************************************/
+
+
+#ifndef SC_WAIT_CTHREAD_H
+#define SC_WAIT_CTHREAD_H
+
+
+#include "sysc/kernel/sc_simcontext.h"
+#include "sysc/datatypes/bit/sc_logic.h"
+#include "sysc/communication/sc_signal_ifs.h"
+
+
+namespace sc_core 
+{
+
+// for SC_CTHREADs
+
+extern
+void
+halt( sc_simcontext* = sc_get_curr_simcontext() );
+
+
+extern
+void
+wait( int,
+      sc_simcontext* = sc_get_curr_simcontext() );
+
+
+extern
+void
+at_posedge( const sc_signal_in_if<bool>&,
+	    sc_simcontext* = sc_get_curr_simcontext() );
+
+extern
+void
+at_posedge( const sc_signal_in_if<sc_dt::sc_logic>&,
+	    sc_simcontext* = sc_get_curr_simcontext() );
+
+extern
+void
+at_negedge( const sc_signal_in_if<bool>&,
+	    sc_simcontext* = sc_get_curr_simcontext() );
+
+extern
+void
+at_negedge( const sc_signal_in_if<sc_dt::sc_logic>&,
+	    sc_simcontext* = sc_get_curr_simcontext() );
+
+
+} // namespace sc_core
+
+/* 
+$Log: sc_wait_cthread.h,v $
+Revision 1.6  2011/08/26 20:46:11  acg
+ Andy Goodrich: moved the modification log to the end of the file to
+ eliminate source line number skew when check-ins are done.
+
+Revision 1.5  2011/08/24 22:05:51  acg
+ Torsten Maehne: initialization changes to remove warnings.
+
+Revision 1.4  2011/02/18 20:27:14  acg
+ Andy Goodrich: Updated Copyrights.
+
+Revision 1.3  2011/02/13 21:47:38  acg
+ Andy Goodrich: update copyright notice.
+
+Revision 1.2  2008/05/22 17:06:27  acg
+ Andy Goodrich: updated copyright notice to include 2008.
+
+Revision 1.1.1.1  2006/12/15 20:20:05  acg
+SystemC 2.3
+
+Revision 1.2  2006/01/03 23:18:45  acg
+Changed copyright to include 2006.
+
+Revision 1.1.1.1  2005/12/19 23:16:44  acg
+First check in of SystemC 2.1 into its own archive.
+
+Revision 1.10  2005/09/02 19:03:30  acg
+Changes for dynamic processes. Removal of lambda support.
+
+Revision 1.9  2005/04/04 00:16:08  acg
+Changes for directory name change to sys from systemc.
+Changes for sc_string going to std::string.
+Changes for sc_pvector going to std::vector.
+Changes for reference pools for bit and part selections.
+Changes for const sc_concatref support.
+
+Revision 1.6  2005/01/10 17:52:20  acg
+Addition of namespace specifications.
+
+Revision 1.5  2004/09/27 20:49:10  acg
+Andy Goodrich, Forte Design Systems, Inc.
+   - Added a $Log comment so that CVS checkin comments appear in the
+     checkout source.
+
+*/
+
+#endif
diff --git a/ext/systemc/src/sysc/qt/CHANGES b/ext/systemc/src/sysc/qt/CHANGES
new file mode 100644
index 000000000..1b74921ee
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/CHANGES
@@ -0,0 +1,15 @@
+QuickThreads 002: Changes since QuickThreads 001.
+
+ - Now can be used by C++ programs.
+ - Now *really* works with stacks that grow up.
+ - Supports AXP OSF 2.x cc's varargs.
+ - Supports HP Precision (HP-PA) on workstations and Convex.
+ - Supports assemblers for Intel iX86 ith only '//'-style comments.
+ - Supports Silicon Graphics Irix 5.x with dynamic linking.
+ - Supports System V and Solaris 2.x with no `_' on compiler-generated
+   identifiers; *some* platforms only.
+
+Note: not all "./config" arguments are compatible with QT 001.
+
+
+QuickThreads 001: Base version.
diff --git a/ext/systemc/src/sysc/qt/INSTALL b/ext/systemc/src/sysc/qt/INSTALL
new file mode 100644
index 000000000..5b20f5d5e
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/INSTALL
@@ -0,0 +1,81 @@
+Installation of the `QuickThreads' threads-building toolkit.
+
+* Notice
+
+QuickThreads -- Threads-building toolkit.
+Copyright (c) 1993 by David Keppel
+
+Permission to use, copy, modify and distribute this software and
+its documentation for any purpose and without fee is hereby
+granted, provided that the above copyright notice and this notice
+appear in all copies.  This software is provided as a
+proof-of-concept and for demonstration purposes; there is no
+representation about the suitability of this software for any
+purpose.
+
+
+* Configuration
+
+Configure with
+
+	./config *machtype*
+
+where "*machtype*" is one of the supported target machines.  As of
+October 1994, the supported machines (targets) are:
+
+	axp --	All Digital Equipment Corporation AXP (DEC Alpha)
+		processors, compile with GNU CC
+	axp-osf1 -- AXP running OSF 1.x
+	axp-osf2 -- AXP running OSF 2.x
+	hppa -- HP's PA-RISC 1.1 processor
+	hppa-cnx-spp -- Convex SPP (PA-RISC 1.1 processor)
+	iX86 --	80386, 80486, and 80586-compatible processors
+		See notes below for OS/2.
+	iX86-ss -- 'iX86 for assemblers that use slash-slash ('//')
+		comments.
+	ksr1 --	All KSR processors
+	m88k --	All members of the Motorola 88000 family
+	mips --	MIPS R2000 and R3000 processors
+	mips-irix5 -- Irix 5.xx (use `mips' for Irix 4.xx)
+	sparc-os1 -- V8-compliant SPARC processors using compilers
+		that prefix labels (e.g. "foo" appears as "_foo")
+		Includes Solaris 1 (SunOS 4.X).
+	sparc-os2 -- V8-compliant SPARC processors using compilers
+		that do not prefix labels.  Includes Solaris 2.
+	vax --	All VAX processors
+
+In addition, the target `clean' will deconfigure QuickThreads.
+
+Note that a given machine target may not work on all instances of that
+machine because e.g., the assembler syntax varies from machine to
+machine.
+
+Note also that additions to a processor family may require a new
+target.  So, for example, the `vax' target might not work for all
+future VAX processors if, say, new VAX processors are introduced and
+they use separate floating-point registers.
+
+For OS/2, change `ranlib' to `ar -s', `configure' to `configure.cmd'
+(or was that `config' to `config.cmd'?), and replace the soft links
+(`ln -s') with plain copies.
+
+
+* Build
+
+To build the QuickThreads library, first configure (see above) then
+type `make libqt.a' in the top-level directory.
+
+To build the demonstration threads package, SimpleThreads, type
+`make libstp.a' in the top-level directory.
+
+To build an executable ``stress-test'' and measurement program, type
+`make run' in the top-level directory.  Run `time/raw' to run the
+stress tests.
+
+
+* Installation
+
+Build the QuickThreads library (see above) and then copy `libqt.a' to
+the installation library directory (e.g., /usr/local/lib) and `qt.h'
+and `qtmd.h' to the installation include directory (e.g.,
+/usr/local/include).
diff --git a/ext/systemc/src/sysc/qt/README b/ext/systemc/src/sysc/qt/README
new file mode 100644
index 000000000..b014b91bf
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/README
@@ -0,0 +1,89 @@
+This is a source code distribution for QuickThreads.  QuickThreads is a
+toolkit for building threads packages; it is described in detail in the
+University of Washington CS&E Technical report #93-05-06, available via
+anonymous ftp from `ftp.cs.washington.edu' (128.95.1.4, as of Oct. '94)
+in `tr/1993/05/UW-CSE-93-05-06.PS.Z'.
+
+This distribution shows basic ideas in QuickThreads and elaborates with
+example implementations for a gaggle of machines.  As of October those
+machines included:
+
+	80386 faimly
+	88000 faimily
+	DEC AXP (Alpha) family
+	HP-PA family
+	KSR
+	MIPS family
+	SPARC V8 family
+	VAX family
+
+Configuration, build, and installation are described in INSTALL.
+
+Be aware: that there is no varargs code for the KSR.
+
+The HP-PA port was designed to work with both HP workstations
+and Convex SPP computers. It was generously provided by Uwe Reder
+<uereder@cip.informatik.uni-erlangen.de>. It is part of the ELiTE
+(Erlangen Lightweight Thread Environment) project directed by 
+Frank Bellosa <bellosa@informatik.uni-erlangen.de> at the Operating 
+Systems Department of the University of Erlangen (Germany).
+
+Other contributors include: Weihaw Chuang, Richard O'Keefe,
+Laurent Perron, John Polstra, Shinji Suzuki, Assar Westerlund,
+thanks also to Peter Buhr and Dirk Grunwald.
+
+
+Here is a brief summary:
+
+QuickThreads is a toolkit for building threads packages.  It is my hope
+that you'll find it easier to use QuickThreads normally than to take it
+and modify the raw cswap code to fit your application.  The idea behind
+QuickThreads is that it should make it easy for you to write & retarget
+threads packages.  If you want the routine `t_create' to create threads
+and `t_block' to suspend threads, you write them using the QuickThreads
+`primitive' operations `QT_SP', `QT_INIT', and `QT_BLOCK', that perform
+machine-dependent initialization and blocking, plus code you supply for
+performing the portable operatons.  For example, you might write:
+
+	t_create (func, arg)
+	{
+	  stk = malloc (STKSIZE);
+	  stackbase = QT_SP (stk, STKSIZE);
+	  sp = QT_INIT (stakcbase, func, arg);
+	  qput (runq, sp);
+	}
+
+Threads block by doing something like:
+
+	t_block()
+	{
+	  sp_next = qget (runq);
+	  QT_BLOCK (helper, runq, sp_next);
+	  // wake up again here
+	}
+
+	// called by QT_BLOCK after the old thread has blocked,
+	// puts the old thread on the queue `onq'.
+	helper (sp_old, onq)
+	{
+	  qput (onq, sp_old);
+	}
+
+(Of course) it's actually a bit more complex than that, but the general
+idea is that you write portable code to allocate stacks and enqueue and
+dequeue threads.  Than, to get your threads package up and running on a
+different machine, you just reconfigure QuickThreads and recompile, and
+that's it.
+
+The QuickThreads `distribution' includes a sample threads package (look
+at stp.{c,h}) that is written in terms of QuickThreads operations.  The
+TR mentioned above explains the simple threads package in detail.
+
+
+
+If you do use QuickThreads, I'd like to hear both about what worked for
+you and what didn't work, problems you had, insights gleaned, etc.
+
+Let me know what you think.
+
+David Keppel <pardo@cs.washington.edu>
diff --git a/ext/systemc/src/sysc/qt/README.MISC b/ext/systemc/src/sysc/qt/README.MISC
new file mode 100644
index 000000000..d10e487cf
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/README.MISC
@@ -0,0 +1,56 @@
+Here's some machine-specific informatin for various systems:
+
+m88k on g88.sim
+
+	.g88init:
+		echo (gdb) target sim\n
+		target sim
+		echo (gdb) ecatch all\n
+		ecatch all
+		echo (gdb) break exit\n
+		break exit
+	% vi Makefile		// set CC and AS
+	% setenv MEERKAT /projects/cer/meerkat
+	% set path=($MEERKAT/bin $path)
+	% make run
+	% g88.sim run
+	(g88) run run N		// where `N' is the test number
+
+
+m88k on meerkats, cross compile as above (make run)
+
+	Run w/ g88:
+	%g88 run
+	(g88) source /homes/rivers/robertb/.gdbinit
+	(g88) me
+	which does
+	(g88) set $firstchars=6
+	(g88) set $resetonattach=1
+	(g88) attach /dev/pp0
+	then download
+	(g88) dl
+	and run with
+	(g88) continue
+
+	Really the way to run it is:
+	(g88) source
+	(g88) me
+	(g88) win
+	(g88) dead 1
+	(g88) dead 2
+	(g88) dead 3
+	(g88) dl
+	(g88) cont
+
+	To rerun
+	(g88) init
+	(g88) dl
+
+	To run simulated meerkat:
+	(g88) att sim
+	<<then use normal commands>>
+
+	On 4.5 g88:
+	(g88) target sim memsize
+	instead of attatch
+	(g88) ecatch all	# catch exception before becomes error
diff --git a/ext/systemc/src/sysc/qt/README.PORT b/ext/systemc/src/sysc/qt/README.PORT
new file mode 100644
index 000000000..d56300923
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/README.PORT
@@ -0,0 +1,112 @@
+Date: Tue, 11 Jan 94 13:23:11 -0800
+From: "pardo@cs.washington.edu" <pardo@meitner.cs.washington.edu>
+
+>[What's needed to get `qt' on an i860-based machine?]
+
+Almost certainly "some assembly required" (pun accepted).
+
+To write a cswap port, you need to understand the context switching
+model.  Turn to figure 2 in the QT TR.  Here's about what the assembly
+code looks like to implement that:
+
+	qt_cswap:
+		adjust stack pointer
+		save callee-save registers on to old's stack
+		argument register <- old sp
+		sp <- new sp
+		(*helper)(args...)
+		restore callee-save registers from new's stack
+		unadjust stack pointer
+		return
+
+Once more in slow motion:
+
+	- `old' thread calls context switch routine (new, a0, a1, h)
+	- cswap routine saves registers that have useful values
+	- cswap routine switches to new stack
+	- cswap routine calls helper function (*h)(old, a0, a1)
+	- when helper returns, cswap routine restores registers
+	  that were saved the last time `new' was suspended
+	- cswap routine returns to whatever `new' routine called the
+	  context switch routine
+
+There's a few tricks here.  First, how do you start a thread running
+for the very first time?  Answer is: fake some stuff on the stack
+so it *looks* like it was called from the middle of some routine.
+When the new thread is restarted, it is treated like any other
+thread.  It just so happens that it's never really run before, but
+you can't tell that because the saved state makes it look like like
+it's been run.  The return pc is set to point at a little stub of
+assembly code that loads up registers with the right values and
+then calls `only'.
+
+Second, I advise you to forget about varargs routines (at least
+until you get single-arg routines up and running).
+
+Third, on most machines `qt_abort' is the same as `qt_cswap' except
+that it need not save any callee-save registers.
+
+Fourth, `qt_cswap' needs to save and restore any floating-point
+registers that are callee-save (see your processor handbook).  On
+some machines, *no* floating-point registers are callee-save, so
+`qt_cswap' is exactly the same as the integer-only cswap routine.
+
+I suggest staring at the MIPS code for a few minutes.  It's "mostly"
+generic RISC code, so it gets a lot of the flavor across without
+getting too bogged down in little nitty details.
+
+
+
+Now for a bit more detail:  The stack is laid out to hold callee-save
+registers.  On many machines, I implemented fp cswap as save fp
+regs, call integer cswap, and when integer cswap returns (when the
+thread wakes up again), restore fp regs.
+
+For thread startup, I figure out some callee-save registers that
+I use to hold parameters to the startup routine (`only').  When
+the thread is being started it doesn't have any saved registers
+that need to be restored, but I go ahead and let the integer context
+switch routine restore some registers then "return" to the stub
+code.  The stub code then copies the "callee save" registers to
+argument registers and calls the startup routine.  That keeps the
+stub code pretty darn simple.
+
+For each machine I need to know the machine's procedure calling
+convention before I write a port.  I figure out how many callee-save
+registers are there and allocate enough stack space for those
+registers.  I also figure out how parameters are passed, since I
+will need to call the helper function.  On most RISC machines, I
+just need to put the old sp in the 0'th arg register and then call
+indirect through the 3rd arg register; the 1st and 2nd arg registers
+are already set up correctly.  Likewise, I don't touch the return
+value register between the helper's return and the context switch
+routine's return.
+
+I have a bunch of macros set up to do the stack initialization.
+The easiest way to debug this stuff is to go ahead and write a C
+routine to do stack initialization.  Once you're happy with it you
+can turn it in to a macro.
+
+In general there's a lot of ugly macros, but most of them do simple
+things like return constants, etc.  Any time you're looking at it
+and it looks confusing you just need to remember "this is actually
+simple code, the only tricky thing is calling the helper between
+the stack switch and the new thread's register restore."
+
+
+You will almost certainly need to write the assembly code fragment
+that starts a thread.  You might be able to do a lot of the context
+switch code with `setjmp' and `longjmp', if they *happen* to have
+the "right" implementation.  But getting all the details right (the
+helper can return a value to the new thread's cswap routine caller)
+is probaby trickier than writing code that does the minimum and
+thus doesn't have any extra instructions (or generality) to cause
+problems.
+
+I don't know of any ports besides those included with the source
+code distribution.   If you send me a port I will hapily add it to
+the distribution.
+
+Let me know as you have questions and/or comments.
+
+	;-D on  ( Now *that*'s a switch... )  Pardo
diff --git a/ext/systemc/src/sysc/qt/b.h b/ext/systemc/src/sysc/qt/b.h
new file mode 100644
index 000000000..49e587c77
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/b.h
@@ -0,0 +1,11 @@
+#ifndef B_H
+#define B_H	"$Header: /Users/acg/CVSROOT/systemc-2.3/src/sysc/qt/b.h,v 1.1.1.1 2006/12/15 20:20:06 acg Exp $"
+
+#include "copyright.h"
+
+extern void b_call_reg (int n);
+extern void b_call_imm (int n);
+extern void b_add (int n);
+extern void b_load (int n);
+
+#endif /* ndef B_H */
diff --git a/ext/systemc/src/sysc/qt/config b/ext/systemc/src/sysc/qt/config
new file mode 100755
index 000000000..35d54647f
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/config
@@ -0,0 +1,392 @@
+#! /bin/sh
+
+# set -x
+
+: ${LN_S:="ln -s"}
+
+# rm -f Makefile Makefile.md README.md qtmd.h qtmdb.s qtmdc.c qtmds.s configuration
+rm -f qtmdc.c qtmds.s configuration
+
+case $1 in
+	axp*)
+		: "DEC AXP"
+		case $1 in
+			axp-osf1*)
+				: "Compile using /bin/cc under OSF 1.x."
+#				${LN_S} md/axp.1.Makefile Makefile.md
+				;;
+			axp-osf2*)
+				: "Compile using /bin/cc under OSF 2.x."
+#				${LN_S} md/axp.1.Makefile Makefile.md
+				;;
+			*)
+				: "Compile using GNU CC."
+#				${LN_S} md/axp.Makefile Makefile.md
+				;;
+		esac
+
+#		${LN_S} md/axp.h qtmd.h
+		${LN_S} md/axp.c qtmdc.c
+		${LN_S} md/axp.s qtmds.s
+#		${LN_S} md/axp_b.s qtmdb.s
+#		${LN_S} md/axp.README README.md
+		iter_init=1000000000
+		iter_runone=10000000
+		iter_blockint=10000000
+		iter_blockfloat=10000000
+		iter_vainit0=10000000
+		iter_vainit2=10000000
+		iter_vainit4=10000000
+		iter_vainit8=10000000
+		iter_vastart0=10000000
+		iter_vastart2=10000000
+		iter_vastart4=10000000
+		iter_vastart8=10000000
+		iter_bench_call_reg=10000000
+		iter_bench_call_imm=10000000
+		iter_bench_add=100000000
+		iter_bench_load=100000000
+		;;
+
+       hppa*)
+		: "HP's PA-RISC 1.1 processors."
+
+		case $1 in
+			hppa-cnx-spp*)
+				: "Convex SPP (PA-RISC 1.1 processors)."
+#				${LN_S} md/hppa-cnx.Makefile Makefile.md
+				;;
+			*)
+#				${LN_S} md/hppa.Makefile Makefile.md
+				;;
+		esac
+
+#		${LN_S} md/hppa.h qtmd.h
+#		${LN_S} md/null.c qtmdc.c
+		${LN_S} md/hppa.s qtmds.s
+#		${LN_S} md/hppa_b.s qtmdb.s
+		iter_init=10000000
+		iter_runone=1000000
+		iter_blockint=1000000
+		iter_blockfloat=1000000
+		iter_vainit0=1000000
+		iter_vainit2=1000000
+		iter_vainit4=1000000
+		iter_vainit8=1000000
+		iter_vastart0=1000000
+		iter_vastart2=1000000
+		iter_vastart4=1000000
+		iter_vastart8=1000000
+		iter_bench_call_reg=10000000
+		iter_bench_call_imm=10000000
+		iter_bench_add=100000000
+		iter_bench_load=100000000
+		;;
+
+	x86_64*)
+		case $1 in
+			iX86-ss*)
+				: "Assembler comments '//'"
+				sed 's/\/\*/\/\//' < md/i386_64.s > qtmds.s
+				;;
+				
+			*)
+				${LN_S} md/iX86_64.s qtmds.s
+				;;
+		esac
+		: "Intel X386 64-bit and compatibles"
+#		${LN_S} md/null.c qtmdc.c
+		iter_init=10000000
+		iter_runone=1000000
+		iter_blockint=1000000
+		iter_blockfloat=1000000
+		iter_vainit0=1000000
+		iter_vainit2=1000000
+		iter_vainit4=1000000
+		iter_vainit8=1000000
+		iter_vastart0=1000000
+		iter_vastart2=1000000
+		iter_vastart4=1000000
+		iter_vastart8=1000000
+		iter_bench_call_reg=1000000
+		iter_bench_call_imm=1000000
+		iter_bench_add=100000000
+		iter_bench_load=10000000
+		;;
+
+    iX86*)
+        case $1 in
+            iX86-ss*)
+                : "Assembler comments '//'"
+                sed 's/\/\*/\/\//' < md/i386.s > qtmds.s
+#               sed 's/\/\*/\/\//' < md/i386_b.s > qtmdb.s
+                ;;
+                
+            *)
+                ${LN_S} md/i386.s qtmds.s
+#               ${LN_S} md/i386_b.s qtmdb.s
+                ;;
+        esac
+        : "Intel 80386 and compatibles (not '286...)"
+#       ${LN_S} md/default.Makefile Makefile.md
+#       ${LN_S} md/i386.h qtmd.h
+#       ${LN_S} md/null.c qtmdc.c
+#       ${LN_S} md/i386.README README.md
+        iter_init=10000000
+        iter_runone=1000000
+        iter_blockint=1000000
+        iter_blockfloat=1000000
+        iter_vainit0=1000000
+        iter_vainit2=1000000
+        iter_vainit4=1000000
+        iter_vainit8=1000000
+        iter_vastart0=1000000
+        iter_vastart2=1000000
+        iter_vastart4=1000000
+        iter_vastart8=1000000
+        iter_bench_call_reg=1000000
+        iter_bench_call_imm=1000000
+        iter_bench_add=100000000
+        iter_bench_load=10000000
+        ;;
+
+
+	m68k)
+		: "Motorola 68000 family -- incomplete!"
+#		${LN_S} md/default.Makefile Makefile.md
+#		${LN_S} md/m68k.h qtmd.h
+#		${LN_S} md/null.c qtmdc.c
+		${LN_S} md/m68k.s qtmds.s
+#		${LN_S} md/m68k_b.s qtmdb.s
+#		${LN_S} md/null.README README.md
+		;;
+
+	m88k)
+		: "Motorola 88000 family"
+#		${LN_S} md/m88k.Makefile Makefile.md
+#		${LN_S} md/m88k.h qtmd.h
+		${LN_S} md/m88k.c qtmdc.c
+		${LN_S} md/m88k.s qtmds.s
+#		${LN_S} md/m88k_b.s qtmdb.s
+#		${LN_S} md/null.README README.md
+		iter_init=1000000
+		iter_runone=100000
+		iter_blockint=100000
+		iter_blockfloat=100000
+		iter_vainit0=100000
+		iter_vainit2=100000
+		iter_vainit4=100000
+		iter_vainit8=100000
+		iter_vastart0=100000
+		iter_vastart2=100000
+		iter_vastart4=100000
+		iter_vastart8=100000
+		iter_bench_call_reg=100000000
+		iter_bench_call_imm=100000000
+		iter_bench_add=1000000000
+		iter_bench_load=100000000
+		;;
+
+	mips*)
+		: "MIPS R2000 and R3000."
+
+		case $1 in
+			mips-irix5*)
+				: "Silicon Graphics Irix with dynamic linking"
+				: "Use mips for irix4."
+				${LN_S} md/mips-irix5.s qtmds.s
+				;;
+			*)
+				${LN_S} md/mips.s qtmds.s
+				;;
+		esac
+
+#		${LN_S} md/default.Makefile Makefile.md
+#		${LN_S} md/mips.h qtmd.h
+#		${LN_S} md/null.c qtmdc.c
+#		${LN_S} md/mips_b.s qtmdb.s
+#		${LN_S} md/null.README README.md
+		iter_init=10000000
+		iter_runone=10000000
+		iter_blockint=10000000
+		iter_blockfloat=10000000
+		iter_vainit0=1000000
+		iter_vainit2=1000000
+		iter_vainit4=1000000
+		iter_vainit8=1000000
+		iter_vastart0=1000000
+		iter_vastart2=1000000
+		iter_vastart4=1000000
+		iter_vastart8=1000000
+		iter_bench_call_reg=100000000
+		iter_bench_call_imm=100000000
+		iter_bench_add=1000000000
+		iter_bench_load=100000000
+		;;
+
+	sparc*)
+		: "SPARC processors"
+		case $1 in
+			sparc-os2*)
+				sed 's/_qt_/qt_/' md/sparc.s > qtmds.s
+#				sed 's/_b_/b_/' md/sparc_b.s > qtmdb.s
+#				${LN_S} md/solaris.README README.md
+				;;
+			*)
+				${LN_S} md/sparc.s qtmds.s
+#				${LN_S} md/sparc_b.s qtmdb.s
+#				${LN_S} md/null.README README.md
+				;;
+		esac
+
+ 		${LN_S} md/default.Makefile Makefile.md
+#		${LN_S} md/sparc.h qtmd.h
+#		${LN_S} md/null.c qtmdc.c
+		iter_init=10000000
+		iter_runone=1000000
+		iter_blockint=1000000
+		iter_blockfloat=1000000
+		iter_vainit0=1000000
+		iter_vainit2=1000000
+		iter_vainit4=1000000
+		iter_vainit8=1000000
+		iter_vastart0=1000000
+		iter_vastart2=1000000
+		iter_vastart4=1000000
+		iter_vastart8=1000000
+		iter_bench_call_reg=10000000
+		iter_bench_call_imm=10000000
+		iter_bench_add=100000000
+		iter_bench_load=100000000
+		;;
+
+	vax*)
+		: "DEC VAX processors."
+#		${LN_S} md/default.Makefile Makefile.md
+#		${LN_S} md/vax.h qtmd.h
+#		${LN_S} md/null.c qtmdc.c
+		${LN_S} md/vax.s qtmds.s
+#		${LN_S} md/vax_b.s qtmdb.s
+#		${LN_S} md/null.README README.md
+		iter_init=1000000
+		iter_runone=100000
+		iter_blockint=100000
+		iter_blockfloat=100000
+		iter_vainit0=100000
+		iter_vainit2=100000
+		iter_vainit4=100000
+		iter_vainit8=100000
+		iter_vastart0=100000
+		iter_vastart2=100000
+		iter_vastart4=100000
+		iter_vastart8=100000
+		iter_bench_call_reg=10000000
+		iter_bench_call_imm=10000000
+		iter_bench_add=10000000
+		iter_bench_load=1000000
+		;;
+
+	ksr1)
+		: "Kendall Square Research model KSR-1."
+		: "Varargs is not currently supported."
+#		${LN_S} md/ksr1.Makefile Makefile.md
+#		${LN_S} md/ksr1.h qtmd.h
+#		${LN_S} md/null.c qtmdc.c
+		${LN_S} md/ksr1.s qtmds.s
+#		${LN_S} md/ksr1_b.s qtmdb.s
+#		${LN_S} md/null.README README.md
+		iter_init=1000000
+		iter_runone=100000
+		iter_blockint=100000
+		iter_blockfloat=100000
+		iter_vainit0=100000
+		iter_vainit2=100000
+		iter_vainit4=100000
+		iter_vainit8=100000
+		iter_vastart0=100000
+		iter_vastart2=100000
+		iter_vastart4=100000
+		iter_vastart8=100000
+		iter_bench_call_reg=10000000
+		iter_bench_call_imm=10000000
+		iter_bench_add=10000000
+		iter_bench_load=1000000
+		;;
+
+    powerpc*)
+        : "PowerPC IBM/Motorola processors."
+
+        case $1 in
+			powerpc-apple-macosx*)
+				: "PowerPC using Mach Application Binary Interface"
+                : "NOTICE: Darwin assembler syntax is used:"
+                : "  (i.e. registers are named rx not %rx)"
+                ${LN_S} md/default.Makefile Makefile.md
+#               ${LN_S} md/powerpc_mach.h qtmd.h
+                ${LN_S} md/powerpc_mach.s qtmds.s
+                ;;
+            powerpc-linux*)
+                : "PowerPC using System V Application Binary Interface"
+                : "  (e.g. LinuxPPC)"
+                : "Use powerpc-darwin for MacOS X and other systems based on Mac
+h ABI"
+#               ${LN_S} md/powerpc_sys5.h qtmd.h
+                ${LN_S} md/powerpc_sys5.s qtmds.s
+                ;;
+            *)
+                echo "Unknown configuration"
+                echo "See md/powerpc.README for documentation"
+                echo "Use powerpc-darwin for MacOS X and other systems based on
+Mach ABI"
+                echo "Use powerpc-linux for Linux and other systems based on Sys
+tem V ABI"
+                exit 1
+                ;;
+
+        esac
+
+        ${LN_S} md/powerpc.c qtmdc.c
+        ${LN_S} md/powerpc.README README.md
+        ;;
+
+
+	pthreads*)
+		: Posix thread support rather than Quick threads.
+#		${LN_S} md/hppa.h qtmd.h
+#		${LN_S} md/null.c qtmdc.c
+#		${LN_S} md/null.s qtmds.s
+#		${LN_S} md/hppa_b.s qtmdb.s
+#		cp md/pthreads.Makefile Makefile
+		exit 0
+		;;
+
+	clean)
+		: Deconfigure
+		exit 0
+		;;
+
+	*)
+		echo "Unknown configuration"
+		exit 1
+		;;
+esac
+
+# cat Makefile.md Makefile.base > Makefile
+
+echo set config_machine=$1 >> configuration
+echo set config_init=$iter_init >> configuration
+echo set config_runone=$iter_runone >> configuration
+echo set config_blockint=$iter_blockint >> configuration
+echo set config_blockfloat=$iter_blockfloat >> configuration
+echo set config_vainit0=$iter_vainit0 >> configuration
+echo set config_vainit2=$iter_vainit2 >> configuration
+echo set config_vainit4=$iter_vainit4 >> configuration
+echo set config_vainit8=$iter_vainit8 >> configuration
+echo set config_vastart0=$iter_vastart0 >> configuration
+echo set config_vastart2=$iter_vastart2 >> configuration
+echo set config_vastart4=$iter_vastart4 >> configuration
+echo set config_vastart8=$iter_vastart8 >> configuration
+echo set config_bcall_reg=$iter_bench_call_reg >> configuration
+echo set config_bcall_imm=$iter_bench_call_imm >> configuration
+echo set config_b_add=$iter_bench_add >> configuration
+echo set config_b_load=$iter_bench_load >> configuration
diff --git a/ext/systemc/src/sysc/qt/copyright.h b/ext/systemc/src/sysc/qt/copyright.h
new file mode 100644
index 000000000..8a2361f9e
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/copyright.h
@@ -0,0 +1,12 @@
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
diff --git a/ext/systemc/src/sysc/qt/md/axp.1.Makefile b/ext/systemc/src/sysc/qt/md/axp.1.Makefile
new file mode 100644
index 000000000..86ccd8f42
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/axp.1.Makefile
@@ -0,0 +1,5 @@
+
+#
+# Compiling for the DEC AXP (alpha) with GNU CC or version 1.x of OSF.
+#
+CC	      =	cc -std1 -D__AXP__ -D__OSF1__
diff --git a/ext/systemc/src/sysc/qt/md/axp.2.Makefile b/ext/systemc/src/sysc/qt/md/axp.2.Makefile
new file mode 100644
index 000000000..268636fc9
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/axp.2.Makefile
@@ -0,0 +1,5 @@
+
+#
+# Compiling for the DEC AXP (alpha) with GNU CC or version 2.x of OSF.
+#
+CC	      =	cc -std1 -D__AXP__ -D__OSF2__
diff --git a/ext/systemc/src/sysc/qt/md/axp.Makefile b/ext/systemc/src/sysc/qt/md/axp.Makefile
new file mode 100644
index 000000000..4e6d74da4
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/axp.Makefile
@@ -0,0 +1,5 @@
+
+#
+# GNU CC
+#
+CC	      =	gcc -D__AXP__
diff --git a/ext/systemc/src/sysc/qt/md/axp.README b/ext/systemc/src/sysc/qt/md/axp.README
new file mode 100644
index 000000000..b6a705c07
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/axp.README
@@ -0,0 +1,10 @@
+The handling of varargs is platform-dependent.  Assar Westerlund
+stared at the problem for a while and deduces the following table:
+
+vers / compiler         cc              gcc
+----------------------------------------------------------------------
+1.3                     a0, offset      __base, __offset
+2.0                     _a0, _offset    __base, __offset
+
+The current code should handle both cc and gcc versions, provided
+you configure for the correct compiler.
diff --git a/ext/systemc/src/sysc/qt/md/axp.c b/ext/systemc/src/sysc/qt/md/axp.c
new file mode 100644
index 000000000..268612993
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/axp.c
@@ -0,0 +1,133 @@
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+#include <stdarg.h>
+#include "qt.h"
+
+
+/* Varargs is harder on the AXP.  Parameters are saved on the stack as
+   something like (stack grows down to low memory; low at bottom of
+   picture):
+
+	|  :
+	| arg6
+	+---
+	| iarg5
+	|  :
+	| iarg3		<-- va_list._a0 + va_list._offset
+	|  :
+	| iarg0		<-- va_list._a0
+	+---
+	| farg5
+	|  :
+	| farg0
+	+---
+
+   When some of the arguments have known type, there is no need to
+   save all of them in the struct.  So, for example, if the routine is
+   called
+
+	zork (int a0, float a1, int a2, ...)
+	{
+	  va_list ap;
+	  va_start (ap, a2);
+	  qt_vargs (... &ap ...);
+	}
+
+   then offset is set to 3 * 8 (8 === sizeof machine word) = 24.
+
+   What this means for us is that the user's routine needs to be
+   called with an arg list where some of the words in the `any type'
+   parameter list have to be split and moved up in to the int/fp
+   region.
+
+   Ways in which this can fail:
+    - The user might not know the size of the pushed arguments anyway.
+    - Structures have funny promotion rules.
+    - Probably lots of other things.
+
+   All in all, we never promised varargs would work reliably. */
+
+
+
+#define QUICKTHREADS_VADJ(sp)	(((char *)sp) - QUICKTHREADS_VSTKBASE)
+
+#define QUICKTHREADS_VARGS_MD0(sp, vabytes) \
+   ((qt_t *)(((char *)(sp)) - 6*2*8 - QUICKTHREADS_STKROUNDUP(vabytes)))
+
+extern void qt_vstart(void);
+#define QUICKTHREADS_VARGS_MD1(sp)	(QUICKTHREADS_SPUT (sp, QUICKTHREADS_R26, qt_vstart))
+
+
+/* Different machines use different implementations for varargs.
+   Unfortunately, the code below ``looks in to'' the varargs
+   structure, `va_list', and thus depends on the conventions.
+   The following #defines try to deal with it but don't catch
+   everything. */
+
+#ifdef __GNUC__
+#define _a0		__base
+#define _offset		__offset
+#else
+#ifdef __OSF1__
+#define _a0		a0
+#define _offset		offset
+#endif
+#endif /* def __GNUC__ */
+
+
+  struct qt_t *
+qt_vargs (struct qt_t *qsp, int nbytes, struct va_list *vargs,
+	  void *pt, qt_function_t *startup,
+	  qt_function_t *vuserf, qt_function_t *cleanup)
+{
+  va_list ap;
+  int i;
+  int max;		/* Maximum *words* of args to copy. */
+  int tmove;		/* *Words* of args moved typed->typed. */
+  qt_word_t *sp;
+
+  ap = *(va_list *)vargs;
+  qsp = QUICKTHREADS_VARGS_MD0 (qsp, nbytes);
+  sp = (qt_word_t *)qsp;
+
+  tmove = 6 - ap._offset/sizeof(qt_word_t);
+
+  /* Copy from one typed area to the other. */
+  for (i=0; i<tmove; ++i) {
+    /* Integer args: */
+    sp[i+6] = ((qt_word_t *)(ap._a0 + ap._offset))[i];
+    /* Fp args: */
+    sp[i] = ((qt_word_t *)(ap._a0 + ap._offset))[i-6];
+  }
+
+  max = nbytes/sizeof(qt_word_t);
+
+  /* Copy from the untyped area to the typed area.  Split each arg.
+     in to integer and floating-point save areas. */
+  for (; i<6 && i<max; ++i) {
+    sp[i] = sp[i+6] = ((qt_word_t *)(ap._a0 + ap._offset))[i];
+  }
+
+  /* Copy from the untyped area to the other untyped area. */
+  for (; i<max; ++i) {
+    sp[i+6] = ((qt_word_t *)(ap._a0 + ap._offset))[i];
+  }
+
+  QUICKTHREADS_VARGS_MD1 (QUICKTHREADS_VADJ(sp));
+  QUICKTHREADS_SPUT (QUICKTHREADS_VADJ(sp), QUICKTHREADS_VARGT_INDEX, pt);
+  QUICKTHREADS_SPUT (QUICKTHREADS_VADJ(sp), QUICKTHREADS_VSTARTUP_INDEX, startup);
+  QUICKTHREADS_SPUT (QUICKTHREADS_VADJ(sp), QUICKTHREADS_VUSERF_INDEX, vuserf);
+  QUICKTHREADS_SPUT (QUICKTHREADS_VADJ(sp), QUICKTHREADS_VCLEANUP_INDEX, cleanup);
+  return ((qt_t *)QUICKTHREADS_VADJ(sp));
+}
diff --git a/ext/systemc/src/sysc/qt/md/axp.h b/ext/systemc/src/sysc/qt/md/axp.h
new file mode 100644
index 000000000..3aac9ff1d
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/axp.h
@@ -0,0 +1,160 @@
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+#ifndef QUICKTHREADS_AXP_H
+#define QUICKTHREADS_AXP_H
+
+#define QUICKTHREADS_GROW_DOWN
+
+typedef unsigned long qt_word_t;
+
+
+/* Stack layout on the Alpha:
+
+   Integer:
+
+     Caller-save: r0..r8, r22..r25, r27..r29
+     argument/caller-save: r16..r21
+     callee-save: r9..r15
+     return pc *callee-save*: r26
+     stack pointer: r30
+     zero: r31
+
+   Floating-point:
+
+     Caller-save: f0..f1, f10..f15
+     argument/caller-save: f16..f21, f22..f30
+     callee-save: f2..f9
+     zero: f31
+
+   Non-varargs:
+
+   +---
+   | padding
+   | f9
+   | f8
+   | f7
+   | f6
+   | f5
+   | f4
+   | f3
+   | f2
+   | r26
+   +---
+   | padding
+   | r29
+   | r15
+   | r14
+   | r13
+   | r12	on startup === `only'
+   | r11	on startup === `userf'
+   | r10	on startup === `qt'
+   | r9		on startup === `qu'
+   | r26	on startup === qt_start		<--- qt.sp
+   +---
+
+   Conventions for varargs startup:
+
+   |  :
+   | arg6
+   | iarg5
+   |  :
+   | iarg0
+   | farg5
+   |  :
+   | farg0
+   +---
+   | padding
+   | r29
+   | r15
+   | r14
+   | r13
+   | r12	on startup === `startup'
+   | r11	on startup === `vuserf'
+   | r10	on startup === `cleanup'
+   | r9		on startup === `qt'
+   | r26	on startup === qt_vstart	<--- qt.sp
+   +---
+
+   Note: this is a pretty cheap/sleazy way to get things going,
+   but ``there must be a better way.''  For instance, some varargs
+   parameters could be loaded in to integer registers, or the return
+   address could be stored on top of the stack. */
+
+
+/* Stack must be 16-byte aligned. */
+#define QUICKTHREADS_STKALIGN	(16)
+
+/* How much space is allocated to hold all the crud for
+   initialization: 7 registers times 8 bytes/register. */
+
+#define QUICKTHREADS_STKBASE	(10 * 8)
+#define QUICKTHREADS_VSTKBASE	QUICKTHREADS_STKBASE
+
+
+/* Offsets of various registers. */
+#define QUICKTHREADS_R26	0
+#define QUICKTHREADS_R9	1
+#define QUICKTHREADS_R10	2
+#define QUICKTHREADS_R11	3
+#define QUICKTHREADS_R12	4
+
+
+/* When a never-before-run thread is restored, the return pc points
+   to a fragment of code that starts the thread running.  For
+   non-vargs functions, it just calls the client's `only' function.
+   For varargs functions, it calls the startup, user, and cleanup
+   functions.
+
+   The varargs startup routine always reads 12 8-byte arguments from
+   the stack.  If fewer argumets were pushed, the startup routine
+   would read off the top of the stack.  To prevent errors we always
+   allocate enough space.  When there are fewer args, the preallocated
+   words are simply wasted. */
+
+extern void qt_start(void);
+#define QUICKTHREADS_ARGS_MD(sp)	(QUICKTHREADS_SPUT (sp, QUICKTHREADS_R26, qt_start))
+
+
+/* The AXP uses a struct for `va_list', so pass a pointer to the
+   struct.  This may break some uses of `QUICKTHREADS_VARGS', but then we never
+   claimed it was totally portable. */
+
+typedef void (qt_function_t)(void);
+
+struct qt_t;
+struct va_list;
+extern struct qt_t *qt_vargs (struct qt_t *sp, int nbytes,
+			      struct va_list *vargs, void *pt,
+			      qt_function_t *startup,
+			      qt_function_t *vuserf,
+			      qt_function_t *cleanup);
+
+#define QUICKTHREADS_VARGS(sp, nbytes, vargs, pt, startup, vuserf, cleanup) \
+  (qt_vargs (sp, nbytes, (struct va_list *)(&(vargs)), pt, \
+	     (qt_function_t *) startup, (qt_function_t *)vuserf, \
+	     (qt_function_t *)cleanup));
+
+
+/* The *index* (positive offset) of where to put each value. */
+#define QUICKTHREADS_ONLY_INDEX	(QUICKTHREADS_R12)
+#define QUICKTHREADS_USER_INDEX	(QUICKTHREADS_R11)
+#define QUICKTHREADS_ARGT_INDEX	(QUICKTHREADS_R10)
+#define QUICKTHREADS_ARGU_INDEX	(QUICKTHREADS_R9)
+
+#define QUICKTHREADS_VCLEANUP_INDEX	(QUICKTHREADS_R10)
+#define QUICKTHREADS_VUSERF_INDEX		(QUICKTHREADS_R11)
+#define QUICKTHREADS_VSTARTUP_INDEX	(QUICKTHREADS_R12)
+#define QUICKTHREADS_VARGT_INDEX		(QUICKTHREADS_R9)
+
+#endif /* ndef QUICKTHREADS_AXP_H */
diff --git a/ext/systemc/src/sysc/qt/md/axp.s b/ext/systemc/src/sysc/qt/md/axp.s
new file mode 100644
index 000000000..a84aab2cc
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/axp.s
@@ -0,0 +1,160 @@
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+/* axp.s -- assembly support. */
+
+	.text
+	.align 4
+	.file 2 "axp.s"
+
+	.globl qt_block
+	.globl qt_blocki
+	.globl qt_abort
+	.globl qt_start
+	.globl qt_vstart
+
+	/*
+	** $16: ptr to function to call once curr is suspended
+	**	and control is on r19's stack.
+	** $17: 1'th arg to (*$16)(...).
+	** $18: 2'th arg to (*$16)(...).
+	** $19: sp of thread to resume.
+	**
+	** The helper routine returns a value that is passed on as the
+	** return value from the blocking routine.  Since we don't
+	** touch r0 between the helper's return and the end of
+	** function, we get this behavior for free.
+	*/
+
+	.ent qt_blocki
+qt_blocki:
+	subq $30,80, $30	/* Allocate save area. */
+	stq $26, 0($30)		/* Save registers. */
+	stq  $9, 8($30)
+	stq $10,16($30)
+	stq $11,24($30)
+	stq $12,32($30)
+	stq $13,40($30)
+	stq $14,48($30)
+	stq $15,56($30)
+	stq $29,64($30)
+	.end qt_blocki
+	.ent qt_abort
+qt_abort:
+	addq $16,$31, $27	/* Put argument function in PV. */
+	addq $30,$31, $16	/* Save stack ptr in outgoing arg. */
+	addq $19,$31, $30	/* Set new stack pointer. */
+	jsr $26,($27),0		/* Call helper function. */
+
+	ldq $26, 0($30)		/* Restore registers. */
+	ldq  $9, 8($30)
+	ldq $10,16($30)
+	ldq $11,24($30)
+	ldq $12,32($30)
+	ldq $13,40($30)
+	ldq $14,48($30)
+	ldq $15,56($30)
+	ldq $29,64($30)
+
+	addq $30,80, $30	/* Deallocate save area. */
+	ret $31,($26),1		/* Return, predict===RET. */
+	.end qt_abort
+
+
+	/*
+	** Non-varargs thread startup.
+	*/
+	.ent qt_start
+qt_start:
+	addq $9,$31,  $16	/* Load up `qu'. */
+	addq $10,$31, $17	/* ... user function's `pt'. */
+	addq $11,$31, $18	/* ... user function's `userf'. */
+	addq $12,$31, $27	/* ... set procedure value to `only'. */
+	jsr $26,($27),0		/* Call `only'. */
+
+	jsr $26,qt_error	/* `only' erroniously returned. */
+	.end qt_start
+
+
+	.ent qt_vstart:
+qt_vstart:
+	/* Call startup function. */
+	addq $9,$31, $16	/* Arg0 to `startup'. */
+	addq $12,$31, $27	/* Set procedure value. */
+	jsr $26,($27),0		/* Call `startup'. */
+
+	/* Call user function. */
+	ldt $f16, 0($30)	/* Load fp arg regs. */
+	ldt $f17, 8($30)
+	ldt $f18,16($30)
+	ldt $f19,24($30)
+	ldt $f20,32($30)
+	ldt $f21,40($30)
+	ldq $16,48($30)		/* And integer arg regs. */
+	ldq $17,56($30)
+	ldq $18,64($30)
+	ldq $19,72($30)
+	ldq $20,80($30)
+	ldq $21,88($30)
+	addq $30,96 $30		/* Pop 6*2*8 saved arg regs. */
+	addq $11,$31, $27	/* Set procedure value. */
+	jsr $26,($27),0		/* Call `vuserf'. */
+
+	/* Call cleanup. */
+	addq $9,$31, $16	/* Arg0 to `cleanup'. */
+	addq $0,$31, $17	/* Users's return value is arg1. */
+	addq $10,$31, $27	/* Set procedure value. */
+	jsr $26,($27),0		/* Call `cleanup'. */
+
+	jsr $26,qt_error	/* Cleanup erroniously returned. */
+	.end qt_start
+
+
+	/*
+	** Save calle-save floating-point regs $f2..$f9.
+	** Also save return pc from whomever called us.
+	**
+	** Return value from `qt_block' is the same as the return from
+	** `qt_blocki'.  We get that for free since we don't touch $0
+	** between the return from `qt_blocki' and the return from
+	** `qt_block'.
+	*/
+	.ent qt_block
+qt_block:
+	subq $30,80, $30	/* Allocate a save space. */
+	stq $26, 0($30)		/* Save registers. */
+	stt $f2, 8($30)
+	stt $f3,16($30)
+	stt $f4,24($30)
+	stt $f5,32($30)
+	stt $f6,40($30)
+	stt $f7,48($30)
+	stt $f8,56($30)
+	stt $f9,64($30)
+
+	jsr $26,qt_blocki	/* Call helper. */
+				/* .. who will also restore $gp. */
+
+	ldq $26, 0($30)		/* restore registers. */
+	ldt $f2, 8($30)
+	ldt $f3,16($30)
+	ldt $f4,24($30)
+	ldt $f5,32($30)
+	ldt $f6,40($30)
+	ldt $f7,48($30)
+	ldt $f8,56($30)
+	ldt $f9,64($30)
+
+	addq $30,80, $30	/* Deallcate save space. */
+	ret $31,($26),1		/* Return, predict===RET. */
+	.end qt_block
diff --git a/ext/systemc/src/sysc/qt/md/axp_b.s b/ext/systemc/src/sysc/qt/md/axp_b.s
new file mode 100644
index 000000000..60be726ff
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/axp_b.s
@@ -0,0 +1,111 @@
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+	.text
+	.globl b_call_reg
+	.globl b_call_imm
+	.globl b_add
+	.globl b_load
+
+	.ent b_null
+b_null:
+	ret $31,($18),1
+	.end b_null
+
+	.ent b_call_reg
+b_call_reg:
+	lda $27,b_null
+$L0:
+	jsr $18,($27)
+	jsr $18,($27)
+	jsr $18,($27)
+	jsr $18,($27)
+	jsr $18,($27)
+
+	jsr $18,($27)
+	jsr $18,($27)
+	jsr $18,($27)
+	jsr $18,($27)
+	jsr $18,($27)
+
+	subq $16,1,$16
+	bgt $16,$L0
+
+	ret $31,($26),1
+	.end
+
+
+	.ent b_call_imm
+b_call_imm:
+$L1:
+	jsr $18,b_null
+	jsr $18,b_null
+	jsr $18,b_null
+	jsr $18,b_null
+	jsr $18,b_null
+
+	jsr $18,b_null
+	jsr $18,b_null
+	jsr $18,b_null
+	jsr $18,b_null
+	jsr $18,b_null
+
+	subq $16,1,$16
+	bgt $16,$L1
+
+	ret $31,($26),1
+	.end
+
+
+	.ent b_add
+b_add:
+$L2:
+	addq $31,$31,$31
+	addq $31,$31,$31
+	addq $31,$31,$31
+	addq $31,$31,$31
+	addq $31,$31,$31
+
+	addq $31,$31,$31
+	addq $31,$31,$31
+	addq $31,$31,$31
+	addq $31,$31,$31
+	addq $31,$31,$31
+
+	subq $16,1,$16
+	bgt $16,$L2
+
+	ret $31,($26),1
+	.end
+
+
+	.ent b_load
+b_load:
+$L3:
+	ldq $31,0($30)
+	ldq $31,8($30)
+	ldq $31,16($30)
+	ldq $31,24($30)
+	ldq $31,32($30)
+
+	ldq $31,0($30)
+	ldq $31,8($30)
+	ldq $31,16($30)
+	ldq $31,24($30)
+	ldq $31,32($30)
+
+	subq $16,1,$16
+	bgt $16,$L3
+
+	ret $31,($26),1
+	.end
diff --git a/ext/systemc/src/sysc/qt/md/default.Makefile b/ext/systemc/src/sysc/qt/md/default.Makefile
new file mode 100644
index 000000000..2f3ded151
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/default.Makefile
@@ -0,0 +1,8 @@
+
+#
+# `Normal' configuration.
+#
+CC	      = gcc -ansi -Wall -pedantic
+
+.o.s:
+	as -o $@ $< 
diff --git a/ext/systemc/src/sysc/qt/md/hppa-cnx.Makefile b/ext/systemc/src/sysc/qt/md/hppa-cnx.Makefile
new file mode 100644
index 000000000..bff257d9f
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/hppa-cnx.Makefile
@@ -0,0 +1,9 @@
+# This file (cnx_spp.Makefile) is part of the port of QuickThreads for
+# PA-RISC 1.1 architecture on a Convex SPP.  This file is a machine dependent
+# makefile for QuickThreads.  It was written in 1994 by Uwe Reder
+# (`uereder@cip.informatik.uni-erlangen.de') for the Operating Systems
+# Department (IMMD4) at the University of Erlangen/Nuernberg Germany.
+
+# `Normal' configuration.
+
+CC = /usr/convex/bin/cc
diff --git a/ext/systemc/src/sysc/qt/md/hppa.Makefile b/ext/systemc/src/sysc/qt/md/hppa.Makefile
new file mode 100644
index 000000000..bf770ae3b
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/hppa.Makefile
@@ -0,0 +1,12 @@
+# This file (pa-risc.Makefile) is part of the port of QuickThreads for
+# PA-RISC 1.1 architecture.  This file is a machine dependent makefile
+# for QuickThreads.  It was written in 1994 by Uwe Reder
+# (`uereder@cip.informatik.uni-erlangen.de') for the Operating Systems
+# Department (IMMD4) at the University of Erlangen/Nuernberg Germany.
+
+# `Normal' configuration.
+
+CC = cc -Aa
+
+.s.o:
+	/usr/ccs/bin/as -o $@ $<
diff --git a/ext/systemc/src/sysc/qt/md/hppa.h b/ext/systemc/src/sysc/qt/md/hppa.h
new file mode 100644
index 000000000..fdb9cef93
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/hppa.h
@@ -0,0 +1,196 @@
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+/*
+ * This file (pa-risc.h) is part of the port of QuickThreads for the
+ * PA-RISC 1.1 architecture.  This file is a machine dependent header
+ * file.  It was written in 1994 by Uwe Reder
+ * (`uereder@cip.informatik.uni-erlangen.de') for the Operating Systems
+ * Department (IMMD4) at the University of Erlangen/Nuernberg Germany.
+ */
+
+
+#ifndef QUICKTHREADS_PA_RISC_H
+#define QUICKTHREADS_PA_RISC_H
+
+#if 0
+#include <qt.h>
+#endif
+
+/* size of an integer-register (32 bit) */
+typedef unsigned long qt_word_t;
+
+/* PA-RISC's stack grows up */
+#define QUICKTHREADS_GROW_UP
+
+/* Stack layout on PA-RISC according to PA-RISC Procedure Calling Conventions:
+
+    Callee-save registers are: gr3-gr18, fr12-fr21.
+    Also save gr2, return pointer.
+
+    +---
+    | fr12          Each floating register is a double word (8 bytes).
+    | fr13          Floating registers are only saved if `qt_block' is
+    | fr14          called, in which case it saves the floating-point
+    | fr15          registers then calls `qt_blocki' to save the integer
+    | fr16	    registers.
+    | fr17
+    | fr18
+    | fr19
+    | fr20
+    | fr21
+    | <arg word 3>  fixed arguments (must be allocated; may remain unused)
+    | <arg word 2>
+    | <arg word 1>
+    | <arg word 0>
+    | <LPT>         frame marker
+    | <LPT'>
+    | <RP'>
+    | <Current RP>
+    | <Static Link>
+    | <Clean Up>
+    | <RP''>
+    | <Previous SP>
+    +---
+    | gr3           word each (4 bytes)
+    | gr4
+    | gr5
+    | gr6
+    | gr7
+    | gr8
+    | gr9
+    | gr10
+    | gr11
+    | gr12
+    | gr13
+    | gr14
+    | gr15
+    | gr16
+    | gr17
+    | gr18
+    | <16 bytes filled in (sp has to be 64-bytes aligned)>
+    | <arg word 3>  fixed arguments (must be allocated; may remain unused)
+    | <arg word 2>
+    | <arg word 1>
+    | <arg word 0>
+    | <LPT>         frame marker
+    | <LPT'>
+    | <RP'>
+    | <Current RP>
+    | <Static Link>
+    | <Clean Up>
+    | <RP''>
+    | <Previous SP>
+    +---            <--- sp
+*/
+
+/* When a never-before-run thread is restored, the return pc points
+   to a fragment of code that starts the thread running.  For
+   non-vargs functions, it just calls the client's `only' function.
+   For varargs functions, it calls the startup, user, and cleanup
+   functions. */
+
+/* Note: Procedue Labels on PA-RISC
+
+   <--2--><-------28---------><1-><1->
+   -----------------------------------
+   | SID |    Adress Part    | L | X |
+   -----------------------------------
+
+   On HP-UX the L field is used to flag wheather the procedure
+   label (plabel) is a pointer to an LT entry or to the entry point
+   of the procedure (PA-RISC Procedure Calling Conventions Reference
+   Manual, 5.3.2 Procedure Labels and Dynamic Calls). */
+
+#define QUICKTHREADS_PA_RISC_READ_PLABEL(plabel) \
+    ( (((int)plabel) & 2) ? \
+        ( (*((int *)(((int)plabel) & 0xfffffffc)))) : ((int)plabel) )
+
+/* Stack must be 64 bytes aligned. */
+#define QUICKTHREADS_STKALIGN (64)
+
+/* Internal helper for putting stuff on stack (negative index!). */
+#define QUICKTHREADS_SPUT(top, at, val)   \
+    (((qt_word_t *)(top))[-(at)] = (qt_word_t)(val))
+
+/* Offsets of various registers which are modified on the stack.
+   rp (return-pointer) has to be stored in the frame-marker-area
+   of the "older" stack-segment. */
+
+#define QUICKTHREADS_crp  (12+4+16+5)
+#define QUICKTHREADS_15   (12+4+4)
+#define QUICKTHREADS_16   (12+4+3)
+#define QUICKTHREADS_17   (12+4+2)
+#define QUICKTHREADS_18   (12+4+1)
+
+
+/** This stuff is for NON-VARARGS. **/
+
+/* Stack looks like this (2 stack frames):
+
+    <--- 64-bytes aligned --><------- 64-bytes aligned ------------>
+   |                        ||                                      |
+    <--16--><------48-------><----16*4-----><--16-><------48------->
+   ||      |                ||             |      |                ||
+   ||filler|arg|frame-marker||register-save|filler|arg|frame-marker||
+   ------------------------------------------------------------------
+ */
+
+#define QUICKTHREADS_STKBASE  (16+48+(16*sizeof(qt_word_t))+16+48)
+
+/* The index, relative to sp, of where to put each value. */
+#define QUICKTHREADS_ONLY_INDEX   (QUICKTHREADS_15)
+#define QUICKTHREADS_USER_INDEX   (QUICKTHREADS_16)
+#define QUICKTHREADS_ARGT_INDEX   (QUICKTHREADS_17)
+#define QUICKTHREADS_ARGU_INDEX   (QUICKTHREADS_18)
+
+extern void qt_start(void);
+#define QUICKTHREADS_ARGS_MD(sp)  \
+    (QUICKTHREADS_SPUT (sp, QUICKTHREADS_crp, QUICKTHREADS_PA_RISC_READ_PLABEL(qt_start)))
+
+
+/** This is for VARARGS. **/
+
+#define QUICKTHREADS_VARGS_DEFAULT
+
+/* Stack looks like this (2 stack frames):
+
+    <------ 64-bytes aligned -------><--------- 64-bytes aligned ---------->
+   |                                ||                                      |
+    <---?--><--?---><16><----32-----><----16*4-----><-16--><16><----32----->
+   ||      |       |   |            ||             |      |   |            ||
+   ||filler|varargs|arg|frame-marker||register-save|filler|arg|frame-marker||
+   --------------------------------------------------------------------------
+ */
+
+/* Sp is moved to the end of the first stack frame. */
+#define QUICKTHREADS_VARGS_MD0(sp, vasize) \
+    ((qt_t *)(((char *)sp) + QUICKTHREADS_STKROUNDUP(vasize + 4*4 + 32)))
+
+/* To reach the arguments from the end of the first stack frame use 32
+   as a negative adjustment. */
+#define QUICKTHREADS_VARGS_ADJUST(sp)	((qt_t *)(((char *)sp) - 32))
+
+/* Offset to reach the end of the second stack frame. */
+#define QUICKTHREADS_VSTKBASE	((16*sizeof(qt_word_t)) + 16 + 4*4 + 32)
+
+extern void qt_vstart(void);
+#define QUICKTHREADS_VARGS_MD1(sp) \
+    (QUICKTHREADS_SPUT (sp, QUICKTHREADS_crp, QUICKTHREADS_PA_RISC_READ_PLABEL(qt_vstart)))
+
+#define QUICKTHREADS_VARGT_INDEX      (QUICKTHREADS_15)
+#define QUICKTHREADS_VSTARTUP_INDEX   (QUICKTHREADS_16)
+#define QUICKTHREADS_VUSERF_INDEX     (QUICKTHREADS_17)
+#define QUICKTHREADS_VCLEANUP_INDEX   (QUICKTHREADS_18)
+
+#endif /* ndef QUICKTHREADS_PA_RISC_H */
diff --git a/ext/systemc/src/sysc/qt/md/hppa.s b/ext/systemc/src/sysc/qt/md/hppa.s
new file mode 100644
index 000000000..84d8e875b
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/hppa.s
@@ -0,0 +1,237 @@
+; pa-risc.s -- assembly support.
+
+; QuickThreads -- Threads-building toolkit.
+; Copyright (c) 1993 by David Keppel
+;
+; Permission to use, copy, modify and distribute this software and
+; its documentation for any purpose and without fee is hereby
+; granted, provided that the above copyright notice and this notice
+; appear in all copies.  This software is provided as a
+; proof-of-concept and for demonstration purposes; there is no
+; representation about the suitability of this software for any
+; purpose.
+
+; This file (pa-risc.s) is part of the port of QuickThreads for
+; PA-RISC 1.1 architecture.  This file implements context switches
+; and thread startup.  It was written in 1994 by Uwe Reder
+; (`uereder@cip.informatik.uni-erlangen.de') for the Operating
+; Systems Department (IMMD4) at the University of Erlangen/Nuernberg
+; Germany.
+
+
+; Callee saves general registers gr3..gr18,
+;              floating-point registers fr12..fr21.
+
+            .CODE
+
+            .IMPORT $$dyncall, MILLICODE
+            .IMPORT qt_error, CODE
+
+            .EXPORT qt_blocki, ENTRY
+            .EXPORT qt_block, ENTRY
+            .EXPORT qt_abort, ENTRY
+            .EXPORT qt_start, ENTRY
+            .EXPORT qt_vstart, ENTRY
+
+
+; arg0: ptr to function (helper) to call once curr is suspended
+;       and control is on arg3's stack.
+; arg1: 1'th arg to *arg0.
+; arg2: 2'th arg to *arg0.
+; arg3: sp of new thread.
+
+qt_blocki
+            .PROC
+            .CALLINFO   CALLER, FRAME=0, SAVE_RP, ENTRY_GR=18
+            .ENTRY
+
+            stw         %rp,-20(%sp)    ; save rp to old frame-marker
+
+            stwm        %r3,128(%sp)    ; save callee-saves general registers
+            stw         %r4,-124(%sp)
+            stw         %r5,-120(%sp)
+            stw         %r6,-116(%sp)
+            stw         %r7,-112(%sp)
+            stw         %r8,-108(%sp)
+            stw         %r9,-104(%sp)
+            stw         %r10,-100(%sp)
+            stw         %r11,-96(%sp)
+            stw         %r12,-92(%sp)
+            stw         %r13,-88(%sp)
+            stw         %r14,-84(%sp)
+            stw         %r15,-80(%sp)
+            stw         %r16,-76(%sp)
+            stw         %r17,-72(%sp)
+            stw         %r18,-68(%sp)
+
+qt_abort
+            copy        %arg0,%r22      ; helper to be called by $$dyncall
+            copy        %sp,%arg0       ; pass current sp as arg0 to helper
+            copy        %arg3,%sp       ; set new sp
+
+            .CALL
+            bl          $$dyncall,%mrp  ; call helper
+            copy        %mrp,%rp
+
+            ldw         -68(%sp),%r18   ; restore general registers
+            ldw         -72(%sp),%r17
+            ldw         -76(%sp),%r16
+            ldw         -80(%sp),%r15
+            ldw         -84(%sp),%r14
+            ldw         -88(%sp),%r13
+            ldw         -92(%sp),%r12
+            ldw         -96(%sp),%r11
+            ldw         -100(%sp),%r10
+            ldw         -104(%sp),%r9
+            ldw         -108(%sp),%r8
+            ldw         -112(%sp),%r7
+            ldw         -116(%sp),%r6
+            ldw         -120(%sp),%r5
+            ldw         -124(%sp),%r4
+
+            ldw         -148(%sp),%rp   ; restore return-pointer
+
+            bv          %r0(%rp)        ; return to caller
+            ldwm        -128(%sp),%r3
+
+            .EXIT
+            .PROCEND
+
+
+qt_block
+            .PROC
+            .CALLINFO   CALLER, FRAME=0, SAVE_RP, ENTRY_FR=21
+            .ENTRY
+
+            stw         %rp,-20(%sp)    ; save rp to old frame-marker
+
+            fstds,ma    %fr12,8(%sp)    ; save callee-saves float registers
+            fstds,ma    %fr13,8(%sp)
+            fstds,ma    %fr14,8(%sp)
+            fstds,ma    %fr15,8(%sp)
+            fstds,ma    %fr16,8(%sp)
+            fstds,ma    %fr17,8(%sp)
+            fstds,ma    %fr18,8(%sp)
+            fstds,ma    %fr19,8(%sp)
+            fstds,ma    %fr20,8(%sp)
+            fstds,ma    %fr21,8(%sp)
+
+            .CALL
+            bl          qt_blocki,%rp
+            ldo         48(%sp),%sp
+
+            ldo         -48(%sp),%sp
+
+            fldds,mb    -8(%sp),%fr21   ; restore callee-saves float registers
+            fldds,mb    -8(%sp),%fr20
+            fldds,mb    -8(%sp),%fr19
+            fldds,mb    -8(%sp),%fr18
+            fldds,mb    -8(%sp),%fr17
+            fldds,mb    -8(%sp),%fr16
+            fldds,mb    -8(%sp),%fr15
+            fldds,mb    -8(%sp),%fr14
+            fldds,mb    -8(%sp),%fr13
+
+            ldw         -28(%sp),%rp    ; restore return-pointer
+            
+            bv          %r0(%rp)        ; return to caller.
+            fldds,mb    -8(%sp),%fr12
+            
+            .EXIT
+            .PROCEND
+
+
+qt_start
+            .PROC
+            .CALLINFO   CALLER, FRAME=0
+            .ENTRY
+
+            copy        %r18,%arg0      ; set user arg `pu'.
+            copy        %r17,%arg1      ; ... user function pt.
+            copy        %r16,%arg2      ; ... user function userf.
+                                        ; %r22 is a caller-saves register
+            copy        %r15,%r22       ; function to be called by $$dyncall
+
+            .CALL                       ; in=%r22
+            bl          $$dyncall,%mrp  ; call `only'.
+            copy        %mrp,%rp
+            
+            bl,n        qt_error,%r0    ; `only' erroniously returned.
+
+            .EXIT
+            .PROCEND
+
+
+; Varargs
+;
+; First, call `startup' with the `pt' argument.
+;
+; Next, call the user's function with all arguments.
+; We don't know whether arguments are integers, 32-bit floating-points or
+; even 64-bit floating-points, so we reload all the registers, possibly
+; with garbage arguments.  The thread creator provided non-garbage for
+; the arguments that the callee actually uses, so the callee never gets
+; garbage.
+;
+;            -48    -44    -40    -36    -32
+;             | arg3 | arg2 | arg1 | arg0 |
+;             -----------------------------
+; integers:     arg3   arg2   arg1   arg0
+; 32-bit fps:  farg3  farg2  farg1  farg0
+; 64-bit fps:  <---farg3-->  <---farg1-->
+;
+; Finally, call `cleanup' with the `pt' argument and with the return value
+; from the user's function.  It is an error for `cleanup' to return.
+
+qt_vstart
+            .PROC
+            .CALLINFO   CALLER, FRAME=0
+            .ENTRY
+
+            ; Because the startup function may damage the fixed arguments
+            ; on the stack (PA-RISC Procedure Calling Conventions Reference
+            ; Manual, 2.4 Fixed Arguments Area), we allocate a seperate
+            ; stack frame for it.
+            ldo         64(%sp),%sp
+
+            ; call: void startup(void *pt)
+
+            copy        %r15,%arg0      ; `pt' is arg0 to `startup'.
+            copy        %r16,%r22
+            .CALL
+            bl          $$dyncall,%mrp  ; Call `startup'.
+            copy        %mrp,%rp
+
+            ldo         -64(%sp),%sp
+
+            ; call: void *qt_vuserf_t(...)
+
+            ldw         -36(%sp),%arg0  ; Load args to integer registers.
+            ldw         -40(%sp),%arg1
+            ldw         -44(%sp),%arg2
+            ldw         -48(%sp),%arg3
+            ; Index of fld[w|d]s only ranges from -16 to 15, so we
+            ; take r22 to be our new base register.
+            ldo         -32(%sp),%r22
+            fldws       -4(%r22),%farg0 ; Load args to floating-point registers.
+            fldds       -8(%r22),%farg1
+            fldws       -12(%r22),%farg2
+            fldds       -16(%r22),%farg3
+            copy        %r17,%r22
+            .CALL
+            bl          $$dyncall,%mrp  ; Call `userf'.
+            copy        %mrp,%rp
+
+            ; call: void cleanup(void *pt, void *vuserf_return)
+
+            copy        %r15,%arg0      ; `pt' is arg0 to `cleanup'.
+            copy        %ret0,%arg1     ; Return-value is arg1 to `cleanup'.
+            copy        %r18,%r22
+            .CALL
+            bl          $$dyncall,%mrp  ; Call `cleanup'.
+            copy        %mrp,%rp
+
+            bl,n        qt_error,%r0
+
+            .EXIT
+            .PROCEND
diff --git a/ext/systemc/src/sysc/qt/md/hppa_b.s b/ext/systemc/src/sysc/qt/md/hppa_b.s
new file mode 100644
index 000000000..1b1e8264e
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/hppa_b.s
@@ -0,0 +1,203 @@
+; QuickThreads -- Threads-building toolkit.
+; Copyright (c) 1993 by David Keppel
+
+; Permission to use, copy, modify and distribute this software and
+; its documentation for any purpose and without fee is hereby
+; granted, provided that the above copyright notice and this notice
+; appear in all copies.  This software is provided as a
+; proof-of-concept and for demonstration purposes; there is no
+; representation about the suitability of this software for any
+; purpose.
+
+; This file (pa-risc_b.s) is part of the port of QuickThreads for
+; PA-RISC 1.1 architecture.  It contains assembly-level support for
+; raw processor performance measurement.  It was written in 1994 by
+; Uwe Reder (`uereder@cip.informatik.uni-erlangen.de')
+; for the Operating Systems Department (IMMD4) at the
+; University of Erlangen/Nuernberg Germany.
+
+
+; Note that the number of instructions in the measurement-loops, differ
+; from implementation to implementation. I took eight instructions in a loop
+; for every test (execute eight instructions and loop to the start).
+
+            .CODE
+
+            .IMPORT $global$,DATA
+            .IMPORT $$dyncall,MILLICODE
+            .EXPORT b_call_reg
+            .EXPORT b_call_imm
+            .EXPORT b_add
+            .EXPORT b_load
+
+; Just do nothing, only return to caller. This procedure is called by
+; `b_call_reg' and `b_call_imm'.
+
+b_null
+            .PROC
+            .CALLINFO   NO_CALLS, FRAME=0
+            .ENTRY
+
+            bv,n        %r0(%rp)        ; just return
+
+            .EXIT
+            .PROCEND
+
+; Call the procedure `b_null' with function pointer in a register.
+
+b_call_reg
+            .PROC
+            .CALLINFO   CALLER, FRAME=0
+            .ENTRY
+    
+            stwm        %r3,64(%sp)     ; store r3 (may be used by caller)
+            stw         %rp,-20(%sp)    ; save return-pointer to frame-marker
+
+            addil       LR'to_call-$global$,%r27
+            ldw         RR'to_call-$global$(%r1),%r3
+
+_loop0
+            copy        %r3,%r22        ; copy the procedure label to r22, ...
+            .CALL                       ; ...this is the input to $$dyncall
+            bl          $$dyncall,%mrp  ; call $$dyncall (millicode function)
+            copy        %mrp,%rp        ; remember the return-pointer
+
+            copy        %r3,%r22
+            .CALL
+            bl          $$dyncall,%mrp
+            copy        %mrp,%rp
+
+            copy        %r3,%r22
+            .CALL
+            bl          $$dyncall,%mrp
+            copy        %mrp,%rp
+
+            copy        %r3,%r22
+            .CALL
+            bl          $$dyncall,%mrp
+            copy        %mrp,%rp
+
+            copy        %r3,%r22
+            .CALL
+            bl          $$dyncall,%mrp
+            copy        %mrp,%rp
+
+            copy        %r3,%r22
+            .CALL
+            bl          $$dyncall,%mrp
+            copy        %mrp,%rp
+
+            copy        %r3,%r22
+            .CALL
+            bl          $$dyncall,%mrp
+            copy        %mrp,%rp
+
+            copy        %r3,%r22
+            .CALL
+            bl          $$dyncall,%mrp
+            copy        %mrp,%rp
+
+            addibf,<=   -8,%arg0,_loop0 ; decrement counter by 8 and loop
+            nop
+
+            ldw         -20(%sp),%rp    ; restore return-pointer
+            bv          %r0(%rp)        ; return to caller
+            ldwm        -64(%sp),%r3    ; resore r3 and remove stack frame
+
+            .EXIT
+            .PROCEND
+
+; Call the procedure `b_null' immediate.
+
+b_call_imm
+            .PROC
+            .CALLINFO   CALLER, FRAME=0, SAVE_RP
+            .ENTRY
+
+            ldo         64(%sp),%sp     ; caller needs a stack-frame
+            stw         %rp,-20(%sp)    ; save return-pointer to frame-marker
+
+_loop1
+            bl          b_null,%rp      ; call `b_null' immediate (8 times)
+            nop 
+            bl          b_null,%rp
+            nop
+            bl          b_null,%rp
+            nop
+            bl          b_null,%rp
+            nop
+            bl          b_null,%rp
+            nop
+            bl          b_null,%rp
+            nop
+            bl          b_null,%rp
+            nop
+            bl          b_null,%rp
+            nop
+
+            addibf,<=   -8,%arg0,_loop1 ; decrement counter by 8 and loop
+            nop
+            
+            ldw         -20(%sp),%rp    ; restore return-pointer
+            bv          %r0(%rp)        ; return to caller
+            ldo         -64(%sp),%sp    ; remove stack-frame
+
+            .EXIT
+            .PROCEND
+
+; Copy register-to-register.
+; On PA-RISC this is implemented with an `or'.
+; The `or' is hidden by a pseudo-operation called `copy'.
+
+b_add
+            .PROC
+            .CALLINFO   NO_CALLS, FRAME=0
+            .ENTRY
+
+_loop2
+            copy        %r19,%r20       ; copy register-to-register
+            copy        %r20,%r21       ; use caller-saves registers
+            copy        %r21,%r22
+            copy        %r22,%r21
+            copy        %r21,%r20
+            copy        %r20,%r19
+            copy        %r19,%r20
+            copy        %r20,%r21
+
+            addibf,<=   -8,%arg0,_loop2 ; decrement counter by 8 and loop
+            nop
+
+            bv,n        %r0(%rp)
+
+            .EXIT
+            .PROCEND
+
+; Load memory to a register.
+
+b_load
+            .PROC
+            .CALLINFO   NO_CALLS, FRAME=0
+            .ENTRY
+
+_loop3
+            ldw         -4(%sp),%r22    ; load data from frame-marker
+            ldw         -8(%sp),%r22    ; use a caller-saves register
+            ldw         -12(%sp),%r22
+            ldw         -16(%sp),%r22
+            ldw         -20(%sp),%r22
+            ldw         -24(%sp),%r22
+            ldw         -28(%sp),%r22
+            ldw         -32(%sp),%r22
+
+            addibf,<=   -8,%arg0,_loop3 ; decrement counter by 8 and loop
+            nop
+
+            bv,n        %r0(%rp)
+
+            .EXIT
+            .PROCEND
+
+
+            .ALIGN 8
+to_call
+            .WORD       b_null
diff --git a/ext/systemc/src/sysc/qt/md/i386.README b/ext/systemc/src/sysc/qt/md/i386.README
new file mode 100644
index 000000000..8ffb92198
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/i386.README
@@ -0,0 +1,7 @@
+Note that some machines want labels to have leading underscores,
+while others (e.g. System V) do not.  Thus, several labels appear
+duplicated except for the leading underscore, e.g.
+
+	_qt_cswap:
+	qt_cswap:
+
diff --git a/ext/systemc/src/sysc/qt/md/i386.h b/ext/systemc/src/sysc/qt/md/i386.h
new file mode 100644
index 000000000..04513857e
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/i386.h
@@ -0,0 +1,132 @@
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+#ifndef QUICKTHREADS_386_H
+#define QUICKTHREADS_386_H
+
+typedef unsigned long qt_word_t;
+
+/* Thread's initial stack layout on the i386:
+
+   non-varargs:
+
+   +---
+   | arg[2]	=== `userf' on startup
+   | arg[1]	=== `pt' on startup
+   | arg[0]	=== `pu' on startup
+   +---
+   | ret pc === qt_error
+   +---
+   | ret pc	=== `only' on startup
+   +---
+   | %ebp
+   | %esi
+   | %edi
+   | %ebx				<--- qt_t.sp
+   +---
+
+   When a non-varargs thread is started, it ``returns'' directly to
+   the client's `only' function.
+
+   varargs:
+
+   +---
+   | arg[n-1]
+   | ..
+   | arg[0]
+   +---
+   | ret pc	=== `qt_vstart'
+   +---
+   | %ebp	=== `startup'
+   | %esi	=== `cleanup'
+   | %edi	=== `pt'
+   | %ebx	=== `vuserf'		<--- qt_t.sp
+   +---
+
+   When a varargs thread is started, it ``returns'' to the `qt_vstart'
+   startup code.  The startup code calls the appropriate functions. */
+
+
+/* What to do to start a varargs thread running. */
+extern void qt_vstart (void);
+
+
+/* Hold 4 saved regs plus two return pcs (qt_error, qt_start) plus
+   three args. */
+#define QUICKTHREADS_STKBASE	(13 * 4)
+
+/* Hold 4 saved regs plus one return pc (qt_vstart). */
+#define QUICKTHREADS_VSTKBASE	(5 * 4)
+
+
+/* Stack must be 16-byte aligned at function call instr. (SSE data support) */
+#define QUICKTHREADS_STKALIGN	(16)
+
+
+/* Where to place various arguments. */
+#define QUICKTHREADS_ONLY_INDEX	(QUICKTHREADS_PC)
+#define QUICKTHREADS_USER_INDEX	(QUICKTHREADS_ARG2)
+#define QUICKTHREADS_ARGT_INDEX	(QUICKTHREADS_ARG1)
+#define QUICKTHREADS_ARGU_INDEX	(QUICKTHREADS_ARG0)
+
+#define QUICKTHREADS_VSTARTUP_INDEX	(QUICKTHREADS_EBP)
+#define QUICKTHREADS_VUSERF_INDEX		(QUICKTHREADS_EBX)
+#define QUICKTHREADS_VCLEANUP_INDEX	(QUICKTHREADS_ESI)
+#define QUICKTHREADS_VARGT_INDEX		(QUICKTHREADS_EDI)
+
+
+#define QUICKTHREADS_EBX        0
+#define QUICKTHREADS_EDI        1
+#define QUICKTHREADS_ESI        2
+#define QUICKTHREADS_EBP        3
+#define QUICKTHREADS_POP0       4
+#define QUICKTHREADS_POP1       5
+#define QUICKTHREADS_POP2       6
+#define QUICKTHREADS_PC         7
+/* The following are defined only for non-varargs. */
+#define QUICKTHREADS_POPE       8
+#define QUICKTHREADS_ARG0       9
+#define QUICKTHREADS_ARG1      10
+#define QUICKTHREADS_ARG2      11
+#define QUICKTHREADS_RPC       12
+
+
+/* Stack grows down.  The top of the stack is the first thing to
+   pop off (preincrement, postdecrement). */
+#define QUICKTHREADS_GROW_DOWN
+
+extern void qt_error (void);
+
+/* For correct 16-byte stack alignment (auto-relocatable functions) */
+extern void qt_tramp (void);
+extern void qt_align (void);
+
+/* Push on the error return address and the alignment/trampoline functions. */
+#define QUICKTHREADS_ARGS_MD(sto) \
+  (QUICKTHREADS_SPUT (sto, QUICKTHREADS_POP0, qt_align), \
+   QUICKTHREADS_SPUT (sto, QUICKTHREADS_POP1, qt_align), \
+   QUICKTHREADS_SPUT (sto, QUICKTHREADS_POP2, qt_align), \
+   QUICKTHREADS_SPUT (sto, QUICKTHREADS_POPE, qt_tramp), \
+   QUICKTHREADS_SPUT (sto, QUICKTHREADS_RPC, qt_error))
+
+
+/* When varargs are pushed, allocate space for all the args. */
+#define QUICKTHREADS_VARGS_MD0(sto, nbytes) \
+  ((qt_t *)(((char *)(sto)) - QUICKTHREADS_STKROUNDUP(nbytes)))
+
+#define QUICKTHREADS_VARGS_MD1(sto) \
+  (QUICKTHREADS_SPUT (sto, QUICKTHREADS_PC, qt_vstart))
+
+#define QUICKTHREADS_VARGS_DEFAULT
+
+#endif /* QUICKTHREADS_386_H */
diff --git a/ext/systemc/src/sysc/qt/md/i386.s b/ext/systemc/src/sysc/qt/md/i386.s
new file mode 100644
index 000000000..b5806cd27
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/i386.s
@@ -0,0 +1,119 @@
+/* i386.s -- assembly support. */
+
+/*
+// QuickThreads -- Threads-building toolkit.
+// Copyright (c) 1993 by David Keppel
+//
+// Permission to use, copy, modify and distribute this software and
+// its documentation for any purpose and without fee is hereby
+// granted, provided that the above copyright notice and this notice
+// appear in all copies.  This software is provided as a
+// proof-of-concept and for demonstration purposes; there is no
+// representation about the suitability of this software for any
+// purpose. */
+
+/* NOTE: double-labeled `_name' and `name' for System V compatability.  */
+/* NOTE: Mixed C/C++-style comments used. Sorry! */
+
+/* Callee-save: %esi, %edi, %ebx, %ebp
+// Caller-save: %eax, %ecx
+// Can't tell: %edx (seems to work w/o saving it.)
+//
+// Assignment:
+//
+// See ``i386.h'' for the somewhat unconventional stack layout.  */
+
+
+	.text
+	.align 2
+
+	.globl _qt_abort
+	.globl qt_abort
+	.globl _qt_block
+	.globl qt_block
+	.globl _qt_blocki
+	.globl qt_blocki
+	.globl _qt_align
+	.globl qt_align
+
+/* These all have the type signature
+//
+//	void *blocking (helper, arg0, arg1, new)
+//
+// On procedure entry, the helper is at 4(sp), args at 8(sp) and
+// 12(sp) and the new thread's sp at 16(sp).  It *appears* that the
+// calling convention for the 8X86 requires the caller to save all
+// floating-point registers, this makes our life easy.  */
+
+/* Halt the currently-running thread.  Save it's callee-save regs on
+// to the stack, 32 bytes.  Switch to the new stack (next == 16+32(sp))
+// and call the user function (f == 4+32(sp) with arguments: old sp
+// arg1 (8+32(sp)) and arg2 (12+32(sp)).  When the user function is
+// done, restore the new thread's state and return.
+//
+// `qt_abort' is (currently) an alias for `qt_block' because most of
+// the work is shared.  We could save the insns up to `qt_common' by
+// replicating, but w/o replicating we need an inital subtract (to
+// offset the stack as if it had been a qt_block) and then a jump
+// to qt_common.  For the cost of a jump, we might as well just do
+// all the work.
+//
+// The helper function (4(sp)) can return a void* that is returned
+// by the call to `qt_blockk{,i}'.  Since we don't touch %eax in
+// between, we get that ``for free''.  */
+
+_qt_abort:
+qt_abort:
+_qt_block:
+qt_block:
+_qt_blocki:
+qt_blocki:
+	pushl %ebp		/* Save callee-save, sp-=4. */
+	pushl %esi		/* Save callee-save, sp-=4. */
+	pushl %edi		/* Save callee-save, sp-=4. */
+	pushl %ebx		/* Save callee-save, sp-=4. */
+	movl %esp, %eax		/* Remember old stack pointer. */
+
+qt_common:
+	movl 32(%esp), %esp	/* Move to new thread. */
+	pushl 28(%eax)		/* Push arg 2. */
+	pushl 24(%eax)		/* Push arg 1. */
+	pushl %eax		/* Push arg 0. */
+	movl 20(%eax), %ebx	/* Get function to call. */
+	call *%ebx		/* Call f. */
+	addl $12, %esp		/* Pop args. */
+
+	popl %ebx		/* Restore callee-save, sp+=4. */
+	popl %edi		/* Restore callee-save, sp+=4. */
+	popl %esi		/* Restore callee-save, sp+=4. */
+	popl %ebp		/* Restore callee-save, sp+=4. */
+_qt_align:
+qt_align:
+	ret			/* Resume the stopped function. */
+
+	.globl _qt_tramp
+	.globl qt_tramp
+_qt_tramp:
+qt_tramp:
+	movl 12(%esp), %eax	/* Load 'qt_error' address */
+	sub $4, %esp		/* Align stack pointer to 16-byte boundary */
+	jmp *%eax		/* call 'qt_error' */
+	hlt			/* 'qt_error' never returns */
+
+/* Start a varargs thread. */
+
+	.globl _qt_vstart
+	.globl qt_vstart
+_qt_vstart:
+qt_vstart:
+	pushl %edi		/* Push `pt' arg to `startup'. */
+	call *%ebp		/* Call `startup'. */
+	popl %eax		/* Clean up the stack. */
+
+	call *%ebx		/* Call the user's function. */
+
+	pushl %eax		/* Push return from user's. */
+	pushl %edi		/* Push `pt' arg to `cleanup'. */
+	call *%esi		/* Call `cleanup'. */
+
+	hlt			/* `cleanup' never returns. */
diff --git a/ext/systemc/src/sysc/qt/md/i386_b.s b/ext/systemc/src/sysc/qt/md/i386_b.s
new file mode 100644
index 000000000..32129a5d1
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/i386_b.s
@@ -0,0 +1,30 @@
+/*
+// QuickThreads -- Threads-building toolkit.
+// Copyright (c) 1993 by David Keppel
+//
+// Permission to use, copy, modify and distribute this software and
+// its documentation for any purpose and without fee is hereby
+// granted, provided that the above copyright notice and this notice
+// appear in all copies.  This software is provided as a
+// proof-of-concept and for demonstration purposes; there is no
+// representation about the suitability of this software for any
+// purpose.  */
+
+	.globl _b_call_reg
+	.globl b_call_reg
+	.globl _b_call_imm
+	.globl b_call_imm
+	.globl _b_add
+	.globl b_add
+	.globl _b_load
+	.globl b_load
+
+_b_call_reg:
+b_call_reg:
+_b_call_imm:
+b_call_imm:
+_b_add:
+b_add:
+_b_load:
+b_load:
+	hlt
diff --git a/ext/systemc/src/sysc/qt/md/iX86_64.h b/ext/systemc/src/sysc/qt/md/iX86_64.h
new file mode 100644
index 000000000..97bfe39b4
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/iX86_64.h
@@ -0,0 +1,140 @@
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+#ifndef QUICKTHREADS_X86_64_H
+#define QUICKTHREADS_X86_64_H
+
+typedef unsigned long qt_word_t;
+
+/* Thread's initial stack layout on the iX86_64:
+
+   non-varargs:
+
+   +---
+   | arg[2]	=== `userf' on startup
+   | arg[1]	=== `pt' on startup
+   | arg[0]	=== `pu' on startup
+   +---
+   | ret pc === qt_error
+   +---
+   | ret pc	=== `only' on startup
+   +---
+   | %ebp
+   | %esi
+   | %edi
+   | %ebx				<--- qt_t.sp
+   +---
+
+   When a non-varargs thread is started, it ``returns'' directly to
+   the client's `only' function.
+
+   varargs:
+
+   +---
+   | arg[n-1]
+   | ..
+   | arg[0]
+   +---
+   | ret pc	=== `qt_vstart'
+   +---
+   | %ebp	=== `startup'
+   | %esi	=== `cleanup'
+   | %edi	=== `pt'
+   | %ebx	=== `vuserf'		<--- qt_t.sp
+   +---
+
+   When a varargs thread is started, it ``returns'' to the `qt_vstart'
+   startup code.  The startup code calls the appropriate functions. */
+
+
+/* What to do to start a varargs thread running. */
+extern void qt_vstart (void);
+
+
+/* Hold four return pcs (qt_error, qt_start and twice qt_align)
+   plus ten args and two qt_word_t's for correct alignment. */
+#define QUICKTHREADS_STKBASE	(16 * sizeof(long))
+
+/* Hold 4 saved regs plus one return pc (qt_vstart). */
+#define QUICKTHREADS_VSTKBASE	(5 * sizeof(long))
+
+
+/* Stack must be 16-byte aligned at function call instr. (SSE data support) */
+#define QUICKTHREADS_STKALIGN	(16)
+
+
+/* Where to place various arguments. */
+#define QUICKTHREADS_ONLY_INDEX	(QUICKTHREADS_PC)
+#define QUICKTHREADS_USER_INDEX	(QUICKTHREADS_ARG2)
+#define QUICKTHREADS_ARGT_INDEX	(QUICKTHREADS_ARG1)
+#define QUICKTHREADS_ARGU_INDEX	(QUICKTHREADS_ARG0)
+
+#define QUICKTHREADS_VSTARTUP_INDEX	(QUICKTHREADS_EBP)
+#define QUICKTHREADS_VUSERF_INDEX	(QUICKTHREADS_EBX)
+#define QUICKTHREADS_VCLEANUP_INDEX	(QUICKTHREADS_ESI)
+#define QUICKTHREADS_VARGT_INDEX	(QUICKTHREADS_EDI)
+
+
+/* Stack layout offsets relative to stack at initial stack setup. */
+
+/* Stack alignment         15 */
+#define QUICKTHREADS_RPC   14
+#define QUICKTHREADS_POP0  13
+#define QUICKTHREADS_PC    12
+#define QUICKTHREADS_POP1  11
+#define QUICKTHREADS_RBP   10
+/* Stack alignment          9 */
+#define QUICKTHREADS_R12    8
+#define QUICKTHREADS_R13    7
+#define QUICKTHREADS_R14    6
+#define QUICKTHREADS_R15    5
+#define QUICKTHREADS_RBX    4
+#define QUICKTHREADS_RCX    3
+#define QUICKTHREADS_RDX    2
+#define QUICKTHREADS_RDI    1
+#define QUICKTHREADS_RSI    0
+
+
+/* Arguments to save stack function. */
+
+#define QUICKTHREADS_ARG0 QUICKTHREADS_RDI
+#define QUICKTHREADS_ARG1 QUICKTHREADS_RSI
+#define QUICKTHREADS_ARG2 QUICKTHREADS_RDX
+
+
+/* Stack grows down.  The top of the stack is the first thing to
+   pop off (preincrement, postdecrement). */
+#define QUICKTHREADS_GROW_DOWN
+
+extern void qt_error (void);
+extern void qt_align (void); /* For correct stack alignment */
+
+/* Push on the error return address, force Frame Pointer to 0 and
+   push stack alignment trampoline function.  */
+#define QUICKTHREADS_ARGS_MD(sto) \
+  (QUICKTHREADS_SPUT (sto, QUICKTHREADS_RBP, 0), \
+   QUICKTHREADS_SPUT (sto, QUICKTHREADS_POP0, qt_align), \
+   QUICKTHREADS_SPUT (sto, QUICKTHREADS_POP1, qt_align), \
+   QUICKTHREADS_SPUT (sto, QUICKTHREADS_RPC, qt_error))
+
+
+/* When varargs are pushed, allocate space for all the args. */
+#define QUICKTHREADS_VARGS_MD0(sto, nbytes) \
+  ((qt_t *)(((char *)(sto)) - QUICKTHREADS_STKROUNDUP(nbytes)))
+
+#define QUICKTHREADS_VARGS_MD1(sto) \
+  (QUICKTHREADS_SPUT (sto, QUICKTHREADS_PC, qt_vstart))
+
+#define QUICKTHREADS_VARGS_DEFAULT
+
+#endif /* QUICKTHREADS_X86_64_H */
diff --git a/ext/systemc/src/sysc/qt/md/iX86_64.s b/ext/systemc/src/sysc/qt/md/iX86_64.s
new file mode 100644
index 000000000..a8bcfcd96
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/iX86_64.s
@@ -0,0 +1,74 @@
+/* iX386_64.s -- assembly support. */
+
+/*
+// QuickThreads -- Threads-building toolkit.
+// Copyright (c) 1993 by David Keppel
+//
+// Permission to use, copy, modify and distribute this software and
+// its documentation for any purpose and without fee is hereby
+// granted, provided that the above copyright notice and this notice
+// appear in all copies.  This software is provided as a
+// proof-of-concept and for demonstration purposes; there is no
+// representation about the suitability of this software for any
+// purpose. */
+
+/* 64-bit Intel Architecture Support
+// written by Andy Goodrich, Forte Design Systms, Inc.  */
+
+/* NOTE: double-labeled `_name' and `name' for System V compatability.  */
+/* NOTE: Mixed C/C++-style comments used. Sorry! */
+
+    .text
+    .align 2
+
+    .globl _qt_abort
+    .globl qt_abort
+    .globl _qt_block
+    .globl qt_block
+    .globl _qt_blocki
+    .globl qt_blocki
+    .globl _qt_align
+    .globl qt_align
+
+_qt_abort:
+qt_abort:
+_qt_block:
+qt_block:
+_qt_blocki:
+qt_blocki:
+	                 /* 11 (return address.) */
+        pushq %rbp       /* 10 (push stack frame top.) */
+	movq  %rsp, %rbp /* set new stack frame top. */
+	                 /* save registers. */
+	subq $8, %rsp    /*  9 (Stack alignment) */
+	pushq %r12       /*  8 ... */
+	pushq %r13       /*  7 ... */
+	pushq %r14       /*  6 ... */
+	pushq %r15       /*  5 ... */
+	pushq %rbx       /*  4 ... */
+	pushq %rcx       /*  3 ... (new stack address) */
+	pushq %rdx       /*  2 ... (arg) */
+	pushq %rdi       /*  1 ... (address of save function.) */
+	pushq %rsi       /*  0 ... (cor) */
+
+    movq %rdi, %rax  /* get address of save function. */
+    movq %rsp, %rdi  /* set current stack as save argument. */
+	movq %rcx, %rsp  /* swap stacks. */
+	movq %rcx, %rbp  /* adjust stack frame pointer. */
+	addq $10*8, %rbp /* ... */
+    call *%rax      /* call function to save stack pointer. */
+
+	                /* restore registers. */
+	popq %rsi       /* ... */
+	popq %rdi       /* ... */
+	popq %rdx       /* ... */
+	popq %rcx       /* ... */
+	popq %rbx       /* ... */
+	popq %r15       /* restore registers from new stack. */
+	popq %r14       /* ... */
+	popq %r13       /* ... */
+	popq %r12       /* ... */
+	leave           /* unwind stack. */
+_qt_align:
+qt_align:
+	ret             /* return. */
diff --git a/ext/systemc/src/sysc/qt/md/ksr1.Makefile b/ext/systemc/src/sysc/qt/md/ksr1.Makefile
new file mode 100644
index 000000000..aa195839a
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/ksr1.Makefile
@@ -0,0 +1,6 @@
+
+#
+# KSR1 configuration.
+#
+CC	      = cc -ansi
+
diff --git a/ext/systemc/src/sysc/qt/md/ksr1.h b/ext/systemc/src/sysc/qt/md/ksr1.h
new file mode 100644
index 000000000..b3877505d
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/ksr1.h
@@ -0,0 +1,164 @@
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+#ifndef QUICKTHREADS_KSR1_H
+#define QUICKTHREADS_KSR1_H
+
+/* 
+   Stack layout:
+
+   Registers are saved in strictly low to high order, FPU regs first 
+   (only if qt_block is called), CEU regs second, IPU regs next, with no
+   padding between the groups.
+
+   Callee-save:  f16..f63; c15..c30; i12..i30.
+   Args passed in i2..i5.
+
+   Note: c31 is a private data pointer.  It is not changed on thread
+   swaps with the assumption that it represents per-processor rather
+   than per-thread state.
+
+   Note: i31 is an instruction count register that is updated by the
+   context switch routines.  Like c31, it is not changed on context
+   switches.
+
+   This is what we want on startup:
+
+
+   +------		<-- BOS: Bottom of stack (grows down)
+   | 80 (128 - 48) bytes of padding to a 128-byte boundary
+   +---
+   | only
+   | userf
+   | t
+   | u
+   | qt_start$TXT
+   | (empty)     	<-- qt.sp
+   +------		<-- (BOS - 128)
+
+   This is why we want this on startup:
+   
+   A thread begins running when the restore procedure switches thread stacks
+   and pops a return address off of the top of the new stack (see below
+   for the reason why we explicitly store qt_start$TXT).  The
+   block procedure pushes two jump addresses on a thread's stack before
+   it switches stacks.  The first is the return address for the block
+   procedure, and the second is a restore address.  The return address
+   is used to jump back to the thread that has been switched to;  the
+   restore address is a jump within the block code to restore the registers.
+   Normally, this is just a jump to the next address.  However, on thread
+   startup, this is a jump to qt_start$TXT.  (The block procedure stores
+   the restore address at an offset of 8 bytes from the top of the stack,
+   which is also the offset at which qt_start$TXT is stored on the stacks
+   of new threads.  Hence, when the block procedure switches to a new
+   thread stack, it will initially jump to qt_start$TXT; thereafter,
+   it jumps to the restore code.)
+
+   qt_start$TXT, after it has read the initial data on the new thread's
+   stack and placed it in registers, pops the initial stack frame
+   and gives the thread the entire stack to use for execution.
+
+   The KSR runtime system has an unusual treatment of pointers to
+   functions.  From C, taking the `name' of a function yields a
+   pointer to a _constant block_ and *not* the address of the
+   function.  The zero'th entry in the constant block is a pointer to
+   the function.
+
+   We have to be careful: the restore procedure expects a return
+   address on the top of the stack (pointed to by qt.sp).  This is not
+   a problem when restoring a thread that has run before, since the
+   block routine would have stored the return address on top of the
+   stack.  However, when ``faking up'' a thread start (bootstrapping a
+   thread stack frame), the top of the stack needs to contain a
+   pointer to the code that will start the thread running.
+
+   The pointer to the startup code is *not* `qt_start'.  It is the
+   word *pointed to* by `qt_start'.  Thus, we dereference `qt_start',
+   see QUICKTHREADS_ARGS_MD below.
+
+   On varargs startup (still unimplemented):
+
+   | padding to 128 byte boundary
+   | varargs		<-- padded to a 128-byte-boundary
+   +---
+   | caller's frame, 16 bytes
+   | 80 bytes of padding (frame padded to a 128-byte boundary)
+   +---
+   | cleanup
+   | vuserf
+   | startup
+   | t
+   +---
+   | qt_start		<-- qt.sp
+   +---
+
+   Of a suspended thread:
+
+   +---
+   | caller's frame, 16 bytes
+   | fpu registers 47 regs * 8 bytes/reg 376 bytes
+   | ceu registers 16 regs * 8 bytes/reg 128 bytes
+   | ipu registers 19 regs * 8 bytes/reg 152 bytes
+   |  :
+   | 80 bytes of padding
+   |  :
+   | qt_restore		<-- qt.sp
+   +---
+
+   */
+
+
+#define QUICKTHREADS_STKALIGN	128
+#define QUICKTHREADS_GROW_DOWN
+typedef unsigned long qt_word_t;
+
+#define QUICKTHREADS_STKBASE	QUICKTHREADS_STKALIGN
+#define QUICKTHREADS_VSTKBASE	QUICKTHREADS_STKBASE
+
+extern void qt_start(void);
+/*
+ * See the discussion above for what indexing into a procedure ptr 
+ * does for us (it's lovely, though, isn't it?).
+ *
+ * This assumes that the address of a procedure's code is the
+ * first word in a procedure's constant block.  That's how the manual
+ * says it will be arranged.
+ */
+#define QUICKTHREADS_ARGS_MD(sp)	(QUICKTHREADS_SPUT (sp, 1, ((qt_word_t *)qt_start)[0]))
+
+/* 
+ * The *index* (positive offset) of where to put each value.
+ * See the picture of the stack above that explains the offsets.
+ */
+#define QUICKTHREADS_ONLY_INDEX	(5)
+#define QUICKTHREADS_USER_INDEX	(4)
+#define QUICKTHREADS_ARGT_INDEX	(3)
+#define QUICKTHREADS_ARGU_INDEX	(2)
+
+#define QUICKTHREADS_VARGS_DEFAULT
+#define QUICKTHREADS_VARGS(sp, nb, vargs, pt, startup, vuserf, cleanup) \
+      (qt_vargs (sp, nbytes, &vargs, pt, startup, vuserf, cleanup))
+
+
+#define QUICKTHREADS_VARGS_MD0(sp, vabytes) \
+  ((qt_t *)(((char *)(sp)) - 4*8 - QUICKTHREADS_STKROUNDUP(vabytes)))
+
+extern void qt_vstart(void);
+#define QUICKTHREADS_VARGS_MD1(sp)	(QUICKTHREADS_SPUT (sp, 0, ((qt_word_t *)qt_vstart)[0]))
+
+#define QUICKTHREADS_VCLEANUP_INDEX	(4)
+#define QUICKTHREADS_VUSERF_INDEX		(3)
+#define QUICKTHREADS_VSTARTUP_INDEX	(2)
+#define QUICKTHREADS_VARGT_INDEX		(1)
+
+#endif /* def QUICKTHREADS_KSR1_H */
diff --git a/ext/systemc/src/sysc/qt/md/ksr1.s b/ext/systemc/src/sysc/qt/md/ksr1.s
new file mode 100644
index 000000000..d4d51a0a6
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/ksr1.s
@@ -0,0 +1,424 @@
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+	.file	"ksr1.s"
+	.def	.debug;	.endef
+
+	.align 128
+	.globl qt_blocki
+	.globl qt_blocki$TXT
+	.globl qt_block
+	.globl qt_block$TXT
+	.globl qt_start$TXT
+        .globl qt_start
+	.globl qt_abort$TXT
+	.globl qt_abort
+	.globl qt_vstart
+	.globl qt_vstart$TXT
+
+#
+# KSR convention: on procedure calls, load both the procedure address
+# and a pointer to a constant block.  The address of function `f' is
+# `f$TXT', and the constant block address is `f'.  The constant block
+# has several reserved values:
+#
+#	8 bytes fpu register save mask
+#	4 bytes ipu register save mask
+#	4 bytes ceu register save mask
+#   f:  f$TXT
+#	... whatever you want ... (not quite...read on)
+#
+# Note, by the way, that a pointer to a function is passed as a
+# pointer to the constant area, and the constant area has the text
+# address.
+#
+
+#
+# Procedures that do not return structures prefix their code with
+#
+# proc$TXT:
+#   finop; cxnop
+#   finop; cxnop
+#   <proc code>
+#
+# Calls to those procedures branch to a 16 byte offset (4 instrs) in
+# to the procedure to skip those instructions.
+#
+# Procedures that return structures use a different code prefix:
+#
+# proc$TXT:
+#   finop; beq.qt %rc, %rc, 24		# return value entry
+#   finop; cxnop
+#   finop; movi8 0, %rc			# no return value entry
+#   <proc code>
+#
+# Calls that want the returned structure branch directly to the
+# procedure address.  Callers that don't want (or aren't expecting) a
+# return value branche 16 bytes in to the procedure, which will zero
+# %rc, telling the called procedure not to return a structure.
+#
+
+#
+# On entry:
+#   %i2 -- control block of helper function to run
+#          (dereference to get helper)
+#   %i3 -- a1
+#   %i4 -- a2
+#   %i5 -- sp of new to run
+#
+
+        .data
+	.half 0x0, 0x0, 0x7ffff000, 0x7fff8000
+qt_blocki:
+qt_abort:
+	.word qt_blocki$TXT
+	.word qt_restore$TXT
+
+	.text
+qt_abort$TXT:
+qt_blocki$TXT:
+	finop			; cxnop			# entry prefix
+	finop			; cxnop			# entry prefix
+	add8.ntr 75,%i31,%i31	; movi8 512,%c5		# ICR; stk adjust
+	finop			; ssub8.ntr 0,%sp,%c5,%sp
+	finop			; st8 %fp,504(%sp)	# Save caller's fp
+	finop			; st8 %cp,496(%sp)	# Save caller's cp
+	finop			; ld8 8(%c10),%c5	# ld qt_restore$TXT
+	finop			; st8 %c14,0(%sp)	# Save special ret addr
+	finop			; mov8_8 %c10, %cp	# Our cp
+	finop			; sadd8.ntr 0,%sp,%c5,%fp # Our frame ptr
+	finop			; st8 %c5,8(%sp)	# st qt_restore$TXT
+#
+# CEU registers %c15-%c24, %c26-%c30 (%c14 we restore later)
+#
+	finop			; st8  %c15,456(%sp)
+	finop			; st8  %c16,448(%sp)
+	finop			; st8  %c17,440(%sp)
+	finop			; st8  %c18,432(%sp)
+	finop			; st8  %c19,424(%sp)
+	finop			; st8  %c20,416(%sp)
+	finop			; st8  %c21,408(%sp)
+	finop			; st8  %c22,400(%sp)
+	finop			; st8  %c23,392(%sp)
+	finop			; st8  %c24,384(%sp)
+#
+# %c25 is the Enclosing Frame Pointer (EFP) -- since C doesn't
+# use nested procedures, we ignore it (leaving a gap, though)
+#
+	finop			; st8 %c26,368(%sp)
+	finop			; st8 %c27,360(%sp)
+	finop			; st8 %c28,352(%sp)
+	finop			; st8 %c29,344(%sp)
+	finop			; st8 %c30,336(%sp)
+#
+# IPU registers %i12-%i30
+# 
+	finop			; st8 %i12,328(%sp)
+	finop			; st8 %i13,320(%sp)
+	finop			; st8 %i14,312(%sp)
+	finop			; st8 %i15,304(%sp)
+# (gap to get alignment for st64)
+# -- Doesn't work on version 1.1.3 of the OS
+#	finop			; st64 %i16,256(%sp)
+
+	finop			; st8 %i16,256(%sp)
+	finop			; st8 %i17,248(%sp)
+	finop			; st8 %i18,240(%sp)
+	finop			; st8 %i19,232(%sp)
+	finop			; st8 %i20,224(%sp)
+	finop			; st8 %i21,216(%sp)
+	finop			; st8 %i22,208(%sp)
+	finop			; st8 %i23,200(%sp)
+	finop			; st8 %i24,192(%sp)
+	finop			; st8 %i25,184(%sp)
+	finop			; st8 %i26,176(%sp)
+	finop			; st8 %i27,168(%sp)
+	finop			; st8 %i28,160(%sp)
+	finop			; st8 %i29,152(%sp)
+	finop			; st8 %i30,144(%sp)
+#
+# FPU already saved, or saving not necessary
+#
+
+#
+# Switch to the stack passed in as fourth argument to the block
+# routine (%i5) and call the helper routine passed in as the first
+# argument (%i2).  Note that the address of the helper's constant
+# block is passed in, so we must derefence it to get the helper's text
+# address.
+#
+	finop			; movb8_8 %i2,%c10	# helper's ConstBlock
+	finop			; cxnop			# Delay slot, fill w/
+	finop			; cxnop			# .. 2 st8 from above
+	finop			; ld8 0(%c10),%c4	# load addr of helper
+	finop			; movb8_8 %sp, %i2	# 1st arg to helper
+							# is this stack; other
+							# args remain in regs
+	finop			; movb8_8 %i5,%sp	# switch stacks
+	finop			; jsr %c14,16(%c4)	# call helper
+	movi8 3, %i0		; movi8 0,%c8		# nargs brain dmg
+	finop			; cxnop	
+	finop			; cxnop	
+#
+# Here is where behavior differs for threads being restored and threads
+# being started.  Blocked threads have a pointer to qt_restore$TXT on
+# the top of their stacks; manufactured stacks have a pointer to qt_start$TXT
+# on the top of their stacks.  With this setup, starting threads
+# skip the (unecessary) restore operations.
+#
+# We jump to an offset of 16 to either (1) skip past the two noop pairs
+# at the start of qt_start$TXT, or (2) skip past the two noop pairs
+# after qt_restore$TXT.
+#
+	finop			; ld8 8(%sp),%c4
+	finop			; cxnop
+	finop			; cxnop
+	finop			; jmp 16(%c4)
+qt_restore$TXT:
+	finop			; cxnop
+	finop			; cxnop
+#
+# Point of Restore:
+#
+# The helper funtion will return here.  Any result it has placed in
+# a return register (most likely %i0) will not get overwritten below
+# and will consequently be the return value of the blocking routine.
+#
+
+#
+# CEU registers %c15-%c24, %c26-%c30 (%c14 we restore later)
+#
+	finop			; ld8  456(%sp),%c15
+	finop			; ld8  448(%sp),%c16
+	finop			; ld8  440(%sp),%c17
+	finop			; ld8  432(%sp),%c18
+	finop			; ld8  424(%sp),%c19
+	finop			; ld8  416(%sp),%c20
+	finop			; ld8  408(%sp),%c21
+	finop			; ld8  400(%sp),%c22
+	finop			; ld8  392(%sp),%c23
+	finop			; ld8  384(%sp),%c24
+#
+# %c25 is the Enclosing Frame Pointer (EFP) -- since C doesn't
+# use nested procedures, we ignore it (leaving a gap, though)
+#
+	finop			; ld8 368(%sp),%c26
+	finop			; ld8 360(%sp),%c27
+	finop			; ld8 352(%sp),%c28
+	finop			; ld8 344(%sp),%c29
+	finop			; ld8 336(%sp),%c30
+#
+# IPU registers %i12-%i30
+# 
+	finop			; ld8 328(%sp),%i12
+	finop			; ld8 320(%sp),%i13
+	finop			; ld8 312(%sp),%i14
+	finop			; ld8 304(%sp),%i15
+# (gap to get alignment for ld64)
+# -- Doesn't work on version 1.1.3 of the OS
+#	finop			; ld64 256(%sp),%i16
+
+	finop			; ld8 256(%sp),%i16
+	finop			; ld8 248(%sp),%i17
+	finop			; ld8 240(%sp),%i18
+	finop			; ld8 232(%sp),%i19
+	finop			; ld8 224(%sp),%i20
+	finop			; ld8 216(%sp),%i21
+	finop			; ld8 208(%sp),%i22
+	finop			; ld8 200(%sp),%i23
+	finop			; ld8 192(%sp),%i24
+	finop			; ld8 184(%sp),%i25
+	finop			; ld8 176(%sp),%i26
+	finop			; ld8 168(%sp),%i27
+	finop			; ld8 160(%sp),%i28
+	finop			; ld8 152(%sp),%i29
+	finop			; ld8 144(%sp),%i30
+
+#
+# FPU registers don't need to be loaded, or will be loaded by an
+# enclosing scope (e.g., if this is called by qt_block).
+#
+
+#
+# Load the special registers.  We don't load the stack ptr because
+# the new stack is passed in as an argument, we don't load the EFP
+# because we don't use it, and we load the return address specially
+# off the top of the stack.
+#
+	finop			; ld8 0(%sp),%c14	# return addr
+	finop			; ld8 496(%sp),%cp
+	finop			; ld8 504(%sp),%fp
+
+	finop			; jmp 32(%c14)		# jump back to thread
+	finop			; movi8 512,%c5		# stack adjust
+	finop			; sadd8.ntr 0,%sp,%c5,%sp
+
+        .data
+	.half 0x0, 0x0, 0x7ffff000, 0x7fff8000
+qt_block:
+	.word	qt_block$TXT
+	.word	qt_error
+	.word	qt_error$TXT
+	.word	qt_blocki
+#
+# Handle saving and restoring the FPU regs, relying on qt_blocki
+# to save and restore the remaining registers.
+#
+        .text
+qt_block$TXT:
+	finop			; cxnop			# entry prefix
+	finop			; cxnop			# entry prefix
+
+	add8.ntr 29,%i31,%i31	; movi8 512,%c5		# ICR; stk adjust
+	finop			; ssub8.ntr 0,%sp,%c5,%sp
+	finop			; st8 %fp,504(%sp)	# Save caller's fp
+	finop			; st8 %cp,496(%sp)	# Save caller's cp
+	finop			; st8 %c14,488(%sp)	# store ret addr
+	finop			; sadd8.ntr 0,%sp,%c5,%fp # Our frame ptr
+	finop			; mov8_8 %c10, %cp	# Our cp
+
+#
+# Store 8 registers at once...destination must be a multiple of 64
+#
+	finop			; st64 %f16,384(%sp)
+	finop			; st64 %f24,320(%sp)
+	finop			; st64 %f32,256(%sp)
+	finop			; st64 %f40,192(%sp)
+	finop			; st64 %f48,128(%sp)
+	finop			; st64 %f56,64(%sp)
+
+#
+# Call the integer blocking routine, passing the arguments passed to us
+#
+	finop			; ld8 24(%cp), %c10
+	finop			; cxnop
+	finop			; jsr %c14, qt_blocki$TXT
+	finop			; cxnop
+	finop			; cxnop
+	movi8 4,%i0		; movi8 0,%c8		# nargs brain dmg
+
+#
+# Load 8 registers at once...source must be a multiple of 64
+#
+	finop			; ld64 64(%sp),%f56
+	finop			; ld64 128(%sp),%f48
+	finop			; ld64 192(%sp),%f40
+	finop			; ld64 256(%sp),%f32
+	finop			; ld64 320(%sp),%f24
+	finop			; ld64 384(%sp),%f16
+
+	finop			; ld8 488(%sp),%c14
+	finop			; ld8 496(%sp),%cp
+	finop			; ld8 504(%sp),%fp
+	finop			; jmp 32(%c14)		# jump back to thread
+	finop			; movi8 512,%c5		# stack adjust
+	finop			; sadd8.ntr 0,%sp,%c5,%sp
+
+
+        .data
+	.half 0x0, 0x0, 0x7ffff000, 0x7fff8000
+qt_start:
+	.word qt_start$TXT
+#
+# A new thread is set up to "appear" as if it were executing code at
+# the beginning of qt_start and then it called a blocking routine
+# (qt_blocki).  So when a new thread starts to run, it gets unblocked
+# by the code above and "returns" to `qt_start$TXT' in the
+# restore step of the switch.  Blocked threads jump to 16(qt_restore$TXT),
+# and starting threads jump to 16(qt_start$TXT).
+#
+        .text
+qt_start$TXT:
+	finop			; cxnop			# 
+	finop			; cxnop			# 
+	finop			; ld8 40(%sp),%c10	# `only' constant block
+	finop			; ld8 32(%sp),%i4	# `userf' arg.
+	finop			; ld8 24(%sp),%i3	# `t' arg.
+	finop			; ld8 0(%c10),%c4	# `only' text location
+	finop			; ld8 16(%sp),%i2	# `u' arg.
+	finop			; cxnop
+	finop			; jsr %c14,16(%c4)	# call `only'
+#
+# Pop the frame used to store the thread's initial data
+#
+	finop			; sadd8.ntr 0,%sp,128,%sp
+	finop			; cxnop
+	movi8 2,%i0		; movi8 0,%c8		# nargs brain dmg
+#
+# If we ever return, it's an error.
+#
+	finop			; jmp qt_error$TXT
+	finop			; cxnop
+	finop			; cxnop
+	movi8 0,%i0		; movi8 0,%c8		# nargs brain dmg
+
+
+#
+# This stuff is broken
+#
+        .data
+	.half 0x0, 0x0, 0x7ffff000, 0x7fff8000
+qt_vstart:
+	.word qt_vstart$TXT
+
+	.text
+qt_vstart$TXT:
+	finop			; cxnop			# entry prefix
+	finop			; cxnop			# entry prefix
+	finop			; cxnop
+	finop			; cxnop
+	add8.ntr 11,%i31,%i31	; movi8 512,%c5
+	finop			; ssub8.ntr 0,%sp,%c5,%sp	# fix stack
+	finop			; ld8 8(%sp),%i2	# load `t' as arg to
+	finop			; cxnop			# `startup'
+	finop			; cxnop
+	finop			; ld8 16(%sp),%c10	# `startup' const block
+	finop			; cxnop
+	finop			; cxnop
+	finop			; ld8 0(%c10),%c4	# `startup' text loc.
+	finop			; cxnop
+	finop			; cxnop
+	finop			; jsr %c14,16(%c4)	# call `startup'
+	finop			; cxnop
+	finop			; cxnop
+	movi8 1, %i0		; movi8 0,%c8		# nargs brain dmg
+#
+#	finop			; sadd 0,%sp,128,%sp	# alter stack
+#
+	finop			; ld8 8(%sp),%i2	# load `t' as arg to
+	finop			; ld8 8(%sp),%i2	# load `t' as arg to
+	finop			; ld8 8(%sp),%i2	# load `t' as arg to
+	finop			; ld8 8(%sp),%i2	# load `t' as arg to
+
+	finop			; ld8 32(%sp),%c10	# `only' constant block
+	finop			; ld8 8(%sp),%i2	# `u' arg.
+	finop			; ld8 16(%sp),%i3	# `t' arg.
+	finop			; ld8 0(%c10),%c4	# `only' text location
+	finop			; ld8 24(%sp),%i4	# `userf' arg.
+	finop			; cxnop
+	finop			; jsr %c4,16(%c4)	# call `only'
+	finop			; cxnop
+	finop			; cxnop
+#
+# If the callee ever calls `nargs', the following instruction (pair)
+# will be executed.  However, we don't know when we compile this code
+# how many args are being passed.  So we give our best guess: 0.
+#
+	movi8 0,%i0		; movi8 0,%c8		# nargs brain dmg
+#
+# If we ever return, it's an error.
+#
+	finop			; jmp qt_error$TXT
+	finop			; cxnop
+	finop			; cxnop
+	movi8 0,%i0		; movi8 0,%c8		# nargs brain dmg
diff --git a/ext/systemc/src/sysc/qt/md/ksr1_b.s b/ext/systemc/src/sysc/qt/md/ksr1_b.s
new file mode 100644
index 000000000..80b0c59eb
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/ksr1_b.s
@@ -0,0 +1,49 @@
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+	.file   "ksr1_b.s"
+	.def	.debug;	.endef
+
+        .globl b_call_reg$TXT
+	.globl b_call_reg
+	.globl b_call_imm$TXT
+	.globl b_call_imm
+	.globl b_add$TXT
+	.globl b_add
+	.globl b_load$TXT
+	.globl b_load
+
+
+b_call_reg:
+b_call_imm:
+b_add:
+b_load:
+	.word	b_call_reg$TXT
+	.word	qt_error
+	.word	qt_error$TXT
+
+
+b_call_reg$TXT:
+b_call_imm$TXT:
+b_add$TXT:
+b_load$TXT:
+	finop			; cxnop
+	finop			; cxnop
+	finop			; ld8 16(%cp),%c4
+        finop			; ld8 8(%cp),%cp
+	finop			; cxnop
+	finop			; cxnop
+        finop			; jsr %c4,0(%c4)
+	finop			; cxnop
+	finop			; cxnop
+
diff --git a/ext/systemc/src/sysc/qt/md/m88k.Makefile b/ext/systemc/src/sysc/qt/md/m88k.Makefile
new file mode 100644
index 000000000..608c70690
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/m88k.Makefile
@@ -0,0 +1,6 @@
+
+#
+# Hosted compilers for 88k for Meerkat.
+#
+CC = gcc88 -Dm88k -ansi -pedantic -Wall -fno-builtin
+AS = as88
diff --git a/ext/systemc/src/sysc/qt/md/m88k.c b/ext/systemc/src/sysc/qt/md/m88k.c
new file mode 100644
index 000000000..f2cef00a0
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/m88k.c
@@ -0,0 +1,111 @@
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+#include <stdarg.h>
+#include "qt.h"
+
+/* Varargs is harder on the m88k.  Parameters are saved on the stack as
+   something like (stack grows down to low memory; low at bottom of
+   picture):
+
+	|  :
+	| arg8		<-- va_list.__va_stk
+	+---
+	|  :
+	+---
+	| arg7
+	|  :
+	| iarg0		<-- va_list.__va_reg
+	+---
+	|  :
+	| va_list { __va_arg, __va_stk, __va_reg }
+	|  :
+	+---
+
+   Here, `va_list.__va_arg' is the number of word-size arguments
+   that have already been skipped.  Doubles must be double-arligned.
+
+   What this means for us is that the user's routine needs to be
+   called with an arg list where some of the words in the `__va_stk'
+   part of the parameter list have to be promoted to registers.
+
+   BUG: doubleword register arguments must be double-aligned.  If
+   something is passed as an even # arg and used as an odd # arg or
+   vice-versa, the code in the called routine (in the new thread) that
+   decides how to adjust the index will get it wrong, because it will
+   be expect it to be, say, doubleword aligned and it will really be
+   singleword aligned.
+
+   I'm not sure you can solve this without knowing the types of all
+   the arguments.  All in all, we never promised varargs would work
+   reliably. */
+
+
+
+#define QUICKTHREADS_VADJ(sp)	(((char *)sp) - QUICKTHREADS_VSTKBASE)
+
+/* Always allocate at least enough space for 8 args; waste some space
+   at the base of the stack to ensure the startup routine doesn't read
+   off the end of the stack. */
+
+#define QUICKTHREADS_VARGS_MD0(sp, vabytes) \
+   ((qt_t *)(((char *)(sp)) - 8*4 - QUICKTHREADS_STKROUNDUP(vabytes)))
+
+extern void qt_vstart(void);
+#define QUICKTHREADS_VARGS_MD1(sp)	(QUICKTHREADS_SPUT (sp, QUICKTHREADS_1, qt_vstart))
+
+
+  struct qt_t *
+qt_vargs (struct qt_t *qsp, int nbytes, void *vargs,
+	  void *pt, qt_function_t *startup,
+	  qt_function_t *vuserf, qt_function_t *cleanup)
+{
+  va_list ap;
+  int i;
+  int n;		/* Number of words into original arg list. */
+  qt_word_t *sp;
+  int *reg;		/* Where to read passed-in-reg args. */
+  int *stk;		/* Where to read passed-on-stk args. */
+
+  ap = *(va_list *)vargs;
+  qsp = QUICKTHREADS_VARGS_MD0 (qsp, nbytes);
+  sp = (qt_word_t *)qsp;
+
+  reg = (ap.__va_arg < 8)
+    ? &ap.__va_reg[ap.__va_arg]
+    : 0;
+  stk = &ap.__va_stk[8];
+  n = ap.__va_arg;
+  for (i=0; i<nbytes/sizeof(qt_word_t) && n<8; ++i,++n) {
+    sp[i] = *reg++;
+  }
+  for (; i<nbytes/sizeof(qt_word_t); ++i) {
+    sp[i] = *stk++;
+  }
+
+#ifdef QUICKTHREADS_NDEF
+  for (i=0; i<nbytes/sizeof(qt_word_t); ++i) {
+    sp[i] = (n < 8)
+      ? *reg++
+      : *stk++;
+    ++n;
+  }
+#endif
+
+  QUICKTHREADS_VARGS_MD1 (QUICKTHREADS_VADJ(sp));
+  QUICKTHREADS_SPUT (QUICKTHREADS_VADJ(sp), QUICKTHREADS_VARGT_INDEX, pt);
+  QUICKTHREADS_SPUT (QUICKTHREADS_VADJ(sp), QUICKTHREADS_VSTARTUP_INDEX, startup);
+  QUICKTHREADS_SPUT (QUICKTHREADS_VADJ(sp), QUICKTHREADS_VUSERF_INDEX, vuserf);
+  QUICKTHREADS_SPUT (QUICKTHREADS_VADJ(sp), QUICKTHREADS_VCLEANUP_INDEX, cleanup);
+  return ((qt_t *)QUICKTHREADS_VADJ(sp));
+}
diff --git a/ext/systemc/src/sysc/qt/md/m88k.h b/ext/systemc/src/sysc/qt/md/m88k.h
new file mode 100644
index 000000000..f9cab5327
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/m88k.h
@@ -0,0 +1,159 @@
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+#ifndef QUICKTHREADS_M88K_H
+#define QUICKTHREADS_M88K_H
+
+typedef unsigned long qt_word_t;
+
+#define QUICKTHREADS_GROW_DOWN
+
+/* Stack layout on the mips:
+
+   Callee-save registers are: $16-$23, $30; $f20-$f30.
+   Also save $31, return pc.
+
+   Non-varargs:
+
+   +---
+   | r30 (fp)	on startup === 0
+   | r25
+   | r24
+   | r23
+   | r22
+   | r21
+   | r20
+   | r19
+   | r18
+   | r17	on startup === `only'
+   | r16	on startup === `userf'
+   | r15	on startup === `pt'
+   | r14	on startup === `pu'
+   | r1		on startup === `qt_start'
+   | 0
+   | 0
+   +---
+   | 0
+   | ... (8 regs worth === 32 bytes of homing area)
+   | 0						<--- sp
+   +---
+
+   Conventions for varargs:
+
+   |  :
+   | arg8
+   +---
+   | r30 (fp)	arg7
+   | r25	arg6
+   | r24	arg5
+   | r23	arg4
+   | r22	arg3
+   | r21	arg2
+   | r20	arg1
+   | r19	arg0
+   | r18
+   | r17	on startup === `startup'
+   | r16	on startup === `vuserf'
+   | r15	on startup === `pt'
+   | r14	on startup === `cleanup'
+   | r1		on startup === `qt_vstart'
+   | 0
+   | 0
+   +---
+   | 0
+   | ... (8 regs worth === 32 bytes of homing area)
+   | 0						<--- sp
+   +---
+
+   */
+
+
+/* Stack must be doubleword aligned. */
+#define QUICKTHREADS_STKALIGN	(16)	/* Doubleword aligned. */
+
+/* How much space is allocated to hold all the crud for
+   initialization: saved registers plus padding to keep the stack
+   aligned plus 8 words of padding to use as a `homing area' (for
+   r2-r9) when calling helper functions on the stack of the (not yet
+   started) thread.  The varargs save area is small because it gets
+   overlapped with the top of the parameter list.  In case the
+   parameter list is less than 8 args, QUICKTHREADS_ARGS_MD0 adds some dead
+   space at the top of the stack. */
+
+#define QUICKTHREADS_STKBASE	(16*4 + 8*4)
+#define QUICKTHREADS_VSTKBASE	(8*4 + 8*4)
+
+
+/* Index of various registers. */
+#define QUICKTHREADS_1	(8+2)
+#define QUICKTHREADS_14	(8+3)
+#define QUICKTHREADS_15	(8+4)
+#define QUICKTHREADS_16	(8+5)
+#define QUICKTHREADS_17	(8+6)
+#define QUICKTHREADS_30	(8+15)
+
+
+/* When a never-before-run thread is restored, the return pc points
+   to a fragment of code that starts the thread running.  For
+   non-vargs functions, it sets up arguments and calls the client's
+   `only' function.  For varargs functions, the startup code calls the
+   startup, user, and cleanup functions.
+
+   For non-varargs functions, we set the frame pointer to 0 to
+   null-terminate the call chain.
+
+   For varargs functions, the frame pointer register is used to hold
+   one of the arguments, so that all arguments can be laid out in
+   memory by the conventional `qt_vargs' varargs initialization
+   routine.
+
+   The varargs startup routine always reads 8 words of arguments from
+   the stack.  If there are less than 8 words of arguments, then the
+   arg list could call off the top of the stack.  To prevent fall-off,
+   always allocate 8 words. */
+
+extern void qt_start(void);
+#define QUICKTHREADS_ARGS_MD(sp) \
+  (QUICKTHREADS_SPUT (sp, QUICKTHREADS_1, qt_start), \
+   QUICKTHREADS_SPUT (sp, QUICKTHREADS_30, 0))
+
+
+/* The m88k uses a struct for `va_list', so pass a pointer to the
+   struct. */
+
+typedef void (qt_function_t)(void);
+
+struct qt_t;
+extern struct qt_t *qt_vargs (struct qt_t *sp, int nbytes,
+			      void *vargs, void *pt,
+			      qt_function_t *startup,
+			      qt_function_t *vuserf,
+			      qt_function_t *cleanup);
+
+#define QUICKTHREADS_VARGS(sp, nbytes, vargs, pt, startup, vuserf, cleanup) \
+  (qt_vargs (sp, nbytes, &(vargs), pt, (qt_function_t *)startup, \
+	     (qt_function_t *)vuserf, (qt_function_t *)cleanup))
+
+
+/* The *index* (positive offset) of where to put each value. */
+#define QUICKTHREADS_ONLY_INDEX	(QUICKTHREADS_17)
+#define QUICKTHREADS_USER_INDEX	(QUICKTHREADS_16)
+#define QUICKTHREADS_ARGT_INDEX	(QUICKTHREADS_15)
+#define QUICKTHREADS_ARGU_INDEX	(QUICKTHREADS_14)
+
+#define QUICKTHREADS_VCLEANUP_INDEX	(QUICKTHREADS_14)
+#define QUICKTHREADS_VUSERF_INDEX		(QUICKTHREADS_16)
+#define QUICKTHREADS_VSTARTUP_INDEX	(QUICKTHREADS_17)
+#define QUICKTHREADS_VARGT_INDEX		(QUICKTHREADS_15)
+
+#endif /* ndef QUICKTHREADS_M88K_H */
diff --git a/ext/systemc/src/sysc/qt/md/m88k.s b/ext/systemc/src/sysc/qt/md/m88k.s
new file mode 100644
index 000000000..42467e8d5
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/m88k.s
@@ -0,0 +1,132 @@
+/* m88k.s -- assembly support. */
+
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+/* Callee-save r14..r25, r31(sp), r30(fp).  r1 === return pc.
+ * Argument registers r2..r9, return value r2..r3.
+ *
+ * On startup, restore regs so retpc === call to a function to start.
+ *
+ * We're going to call a function (r2) from within the context switch
+ * routine.  Call it on the new thread's stack on behalf of the old
+ * thread.
+ */
+
+	.globl _qt_block
+	.globl _qt_blocki
+	.globl _qt_abort
+	.globl _qt_start
+	.globl _qt_vstart
+
+	/*
+	** r2: ptr to function to call once curr is suspended
+	**	and control is on r5's stack.
+	** r3: 1'th arg to *r2.
+	** r4: 2'th arg to *r2.
+	** r5: sp of thread to suspend.
+	**
+	** The helper routine returns a value that is passed on as the
+	** return value from the blocking routine.  Since we don't
+	** touch r2 between the helper's return and the end of
+	** function, we get this behavior for free.
+	**
+	** Same entry for integer-only and floating-point, since there
+	** are no separate integer and floating-point registers.
+	**
+	** Each procedure call sets aside a ``home region'' of 8 regs
+	** for r2-r9 for varargs.  For context switches we don't use
+	** the ``home region'' for varargs so use it to save regs.
+	** Allocate 64 bytes of save space -- use 32 bytes of register
+	** save area passed in to us plus 32 bytes we allcated, use
+	** the other 32 bytes for save area for a save area to call
+	** the helper function.
+	*/
+_qt_block:
+_qt_blocki:
+	sub r31, r31,64		/* Allocate reg save space. */
+	st r1, r31,8+32		/* Save callee-save registers. */
+	st r14, r31,12+32
+	st.d r15, r31,16+32
+	st.d r17, r31,24+32
+	st.d r19, r31,32+32
+	st.d r21, r31,40+32
+	st.d r23, r31,48+32
+	st r25, r31,56+32
+	st r30, r31,60+32
+
+_qt_abort:
+	addu r14, r31,0		/* Remember old sp. */
+	addu r31, r5,0		/* Set new sp. */
+	jsr.n r2		/* Call helper. */
+	addu r2, r14,0		/* Pass old sp as an arg0 to helper. */
+
+	ld r1, r31,8+32		/* Restore callee-save registers. */
+	ld r14, r31,12+32
+	ld.d r15, r31,16+32
+	ld.d r17, r31,24+32
+	ld.d r19, r31,32+32
+	ld.d r21, r31,40+32
+	ld.d r23, r31,48+32
+	ld r25, r31,56+32
+	ld r30, r31,60+32
+
+	jmp.n r1		/* Return to new thread's caller. */
+	addu r31, r31,64	/* Free register save space. */
+
+
+	/*
+	** Non-varargs thread startup.
+	** See `m88k.h' for register use conventions.
+	*/
+_qt_start:
+	addu r2, r14,0		/* Set user arg `pu'. */
+	addu r3, r15,0		/* ... user function pt. */
+	jsr.n r17		/* Call `only'. */
+	addu r4, r16,0		/* ... user function userf. */
+
+	bsr _qt_error		/* `only' erroniously returned. */
+
+
+	/*
+	** Varargs thread startup.
+	** See `m88k.h' for register use conventions.
+	**
+	** Call the `startup' function with just argument `pt'.
+	** Then call `vuserf' with 8 register args plus any
+	** stack args.
+	** Then call `cleanup' with `pt' and the return value
+	** from `vuserf'.
+	*/
+_qt_vstart:
+	addu r18, r30,0		/* Remember arg7 to `vuserf'. */
+	addu r30, r0,0		/* Null-terminate call chain. */
+
+	jsr.n r17		/* Call `startup'. */
+	addu r2, r15,0		/* `pt' is arg0 to `startup'. */
+
+	addu r2, r19,0		/* Set arg0. */
+	addu r3, r20,0		/* Set arg1. */
+	addu r4, r21,0		/* Set arg2. */
+	addu r5, r22,0		/* Set arg3. */
+	addu r6, r23,0		/* Set arg4. */
+	addu r7, r24,0		/* Set arg5. */
+	addu r8, r25,0		/* Set arg6. */
+	jsr.n r16		/* Call `vuserf'. */
+	addu r9, r18,0		/* Set arg7. */
+
+	addu r3, r2,0		/* Ret. value is arg1 to `cleanup'. */
+	jsr.n r14		/* Call `cleanup'. */
+	addu r2, r15,0		/* `pt' is arg0 to `cleanup'. */
+
+	bsr _qt_error		/* `cleanup' erroniously returned. */
diff --git a/ext/systemc/src/sysc/qt/md/m88k_b.s b/ext/systemc/src/sysc/qt/md/m88k_b.s
new file mode 100644
index 000000000..1926e6ae8
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/m88k_b.s
@@ -0,0 +1,117 @@
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+	.text
+	.globl _b_call_reg
+	.globl _b_call_imm
+	.globl _b_add
+	.globl _b_load
+
+_b_null:
+	jmp   r1
+
+_b_call_reg:
+	subu r31, r31,8			/* Alloc ret pc save space. */
+	st r1, r31,32			/* Save ret pc. */
+	or.u r3, r0,hi16(_b_null)	/* Put call addr in a reg. */
+	or r3, r3,lo16(_b_null)
+	jsr r3
+L0:
+	jsr r3
+	jsr r3
+	jsr r3
+	jsr.n r3
+	subu r2, r2,5			/* Decrement #of iter to go. */
+	bcnd.n gt0,r2,L0
+	jsr r3
+
+	ld r1, r31,32
+	jmp r1
+
+
+_b_call_imm:
+	subu r31, r31,8			/* Alloc ret pc save space. */
+	st r1, r31,32			/* Save ret pc. */
+	bsr _b_null
+L1:
+	bsr _b_null
+	bsr _b_null
+	bsr _b_null
+	bsr.n _b_null
+	subu r2, r2,5			/* Decrement #of iter to go. */
+	bcnd.n gt0,r2,L1
+	bsr _b_null
+
+	ld r1, r31,32
+	jmp r1
+
+_b_add:
+	add r0, r3,r4
+L2:
+	add r3, r4,r5
+	add r4, r5,r6
+	add r5, r6,r7
+	add r8, r9,r0
+	add r0, r3,r4
+	add r3, r4,r5
+	add r4, r5,r6
+	add r5, r6,r7
+	add r8, r9,r0
+
+	add r0, r3,r4
+	add r3, r4,r5
+	add r4, r5,r6
+	add r5, r6,r7
+	add r8, r9,r0
+	add r0, r3,r4
+	add r3, r4,r5
+	add r4, r5,r6
+	add r5, r6,r7
+	add r8, r9,r0
+
+	subu r2, r2,20			/* Decrement #of iter to go. */
+	bcnd.n gt0,r2,L2
+	add r0, r3,r4
+
+	jmp r1
+
+
+_b_load:
+	ld r0, r31,0
+L3:
+	ld r3, r31,4
+	ld r4, r31,8
+	ld r5, r31,12
+	ld r6, r31,16
+	ld r0, r31,0
+	ld r3, r31,4
+	ld r4, r31,8
+	ld r5, r31,12
+	ld r6, r31,16
+
+	ld r0, r31,0
+	ld r3, r31,4
+	ld r4, r31,8
+	ld r5, r31,12
+	ld r6, r31,16
+	ld r0, r31,0
+	ld r3, r31,4
+	ld r4, r31,8
+	ld r5, r31,12
+	ld r6, r31,16
+
+	subu r2, r2,20			/* Decrement #of iter to go. */
+	bcnd.n gt0,r2,L3
+	ld r0, r31,0
+
+	jmp   r1
diff --git a/ext/systemc/src/sysc/qt/md/mips-irix5.s b/ext/systemc/src/sysc/qt/md/mips-irix5.s
new file mode 100644
index 000000000..234a953ed
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/mips-irix5.s
@@ -0,0 +1,182 @@
+/* mips.s -- assembly support. */
+
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+/* Callee-save $16-$23, $30-$31.
+ *
+ * $25 is used as a procedure value pointer, used to discover constants
+ * in a callee.  Thus, each caller here sets $25 before the call.
+ *
+ * On startup, restore regs so retpc === call to a function to start.
+ * We're going to call a function ($4) from within this routine.
+ * We're passing 3 args, therefore need to allocate 12 extra bytes on
+ * the stack for a save area.  The start routine needs a like 16-byte
+ * save area.  Must be doubleword aligned (_mips r3000 risc
+ * architecture_, gerry kane, pg d-23).
+ */
+
+/*
+ * Modified by Assar Westerlund <assar@sics.se> to support Irix 5.x
+ * calling conventions for dynamically-linked code.
+ */
+
+	/* Make this position-independent code. */
+	.option pic2
+
+	.globl qt_block
+	.globl qt_blocki
+	.globl qt_abort
+	.globl qt_start
+	.globl qt_vstart
+
+	/*
+	** $4: ptr to function to call once curr is suspended
+	**	and control is on $7's stack.
+	** $5: 1'th arg to $4.
+	** $6: 2'th arg to $4
+	** $7: sp of thread to suspend.
+	**
+	** Totally gross hack: The MIPS calling convention reserves
+	** 4 words on the stack for a0..a3.  This routine "ought" to
+	** allocate space for callee-save registers plus 4 words for
+	** the helper function, but instead we use the 4 words
+	** provided by the function that called us (we don't need to
+	** save our argument registers).  So what *appears* to be
+	** allocating only 40 bytes is actually allocating 56, by
+	** using the caller's 16 bytes.
+	**
+	** The helper routine returns a value that is passed on as the
+	** return value from the blocking routine.  Since we don't
+	** touch $2 between the helper's return and the end of
+	** function, we get this behavior for free.
+	*/
+qt_blocki:
+	sub $sp,$sp,40		/* Allocate reg save space. */
+	sw $16, 0+16($sp)
+	sw $17, 4+16($sp)
+	sw $18, 8+16($sp)
+	sw $19,12+16($sp)
+	sw $20,16+16($sp)
+	sw $21,20+16($sp)
+	sw $22,24+16($sp)
+	sw $23,28+16($sp)
+	sw $30,32+16($sp)
+	sw $31,36+16($sp)
+	add $2, $sp,$0		/* $2 <= old sp to pass to func@$4. */
+qt_abort:
+	add $sp, $7,$0		/* $sp <= new sp. */
+	.set noreorder
+	add $25, $4,$0		/* Set helper function procedure value. */
+	jal $31,$25		/* Call helper func@$4 . */
+	add $4, $2,$0		/* $a0 <= pass old sp as a parameter. */
+	.set reorder
+	lw $31,36+16($sp)	/* Restore callee-save regs... */
+	lw $30,32+16($sp)
+	lw $23,28+16($sp)
+	lw $22,24+16($sp)
+	lw $21,20+16($sp)
+	lw $20,16+16($sp)
+	lw $19,12+16($sp)
+	lw $18, 8+16($sp)
+	lw $17, 4+16($sp)
+	lw $16, 0+16($sp)	/* Restore callee-save */
+
+	add $sp,$sp,40		/* Deallocate reg save space. */
+	j $31			/* Return to caller. */
+
+	/*
+	** Non-varargs thread startup.
+	** Note: originally, 56 bytes were allocated on the stack.
+	** The thread restore routine (_blocki/_abort) removed 40
+	** of them, which means there is still 16 bytes for the
+	** argument area required by the MIPS calling convention.
+	*/
+qt_start:
+	add $4, $16,$0		/* Load up user function pu. */
+	add $5, $17,$0		/* ... user function pt. */
+	add $6, $18,$0		/* ... user function userf. */
+	add $25, $19,$0		/* Set `only' procedure value. */
+	jal $31,$25		/* Call `only'. */
+	la $25,qt_error		/* Set `qt_error' procedure value. */
+	j $25
+
+
+	/*
+	** Save calle-save floating-point regs $f20-$f30
+	** See comment in `qt_block' about calling conventinos and
+	** reserved space.  Use the same trick here, but here we
+	** actually have to allocate all the bytes since we have to
+	** leave 4 words leftover for `qt_blocki'.
+	**
+	** Return value from `qt_block' is the same as the return from
+	** `qt_blocki'.  We get that for free since we don't touch $2
+	** between the return from `qt_blocki' and the return from
+	** `qt_block'.
+	*/
+qt_block:
+	sub $sp, $sp,56		/* 6 8-byte regs, saved ret pc, aligned. */
+	swc1 $f20,  0+16($sp)
+	swc1 $f22,  8+16($sp)
+	swc1 $f24, 16+16($sp)
+	swc1 $f26, 24+16($sp)
+	swc1 $f28, 32+16($sp)
+	swc1 $f30, 40+16($sp)
+	sw $31, 48+16($sp)
+	jal qt_blocki
+	lwc1 $f20,  0+16($sp)
+	lwc1 $f22,  8+16($sp)
+	lwc1 $f24, 16+16($sp)
+	lwc1 $f26, 24+16($sp)
+	lwc1 $f28, 32+16($sp)
+	lwc1 $f30, 40+16($sp)
+	lw $31, 48+16($sp)
+	add $sp, $sp,56
+	j $31
+
+
+	/*
+	** First, call `startup' with the `pt' argument.
+	**
+	** Next, call the user's function with all arguments.
+	** Note that we don't know whether args were passed in
+	** integer regs, fp regs, or on the stack (See Gerry Kane
+	** "MIPS R2000 RISC Architecture" pg D-22), so we reload
+	** all the registers, possibly with garbage arguments.
+	**
+	** Finally, call `cleanup' with the `pt' argument and with
+	** the return value from the user's function.  It is an error
+	** for `cleanup' to return.
+	*/
+qt_vstart:
+	add $4, $17,$0		/* `pt' is arg0 to `startup'. */
+	add $25, $18,$0		/* Set `startup' procedure value. */
+	jal $31, $25		/* Call `startup'. */
+
+	add $sp, $sp,16		/* Free extra save space. */
+	lw $4,  0($sp)		/* Load up args. */
+	lw $5,  4($sp)
+	lw $6,  8($sp)
+	lw $7, 12($sp)
+	lwc1 $f12, 0($sp)	/* Load up fp args. */
+	lwc1 $f14, 8($sp)
+	add $25, $19,$0		/* Set `userf' procedure value. */
+	jal $31,$25		/* Call `userf'. */
+
+	add $4, $17,$0		/* `pt' is arg0 to `cleanup'. */
+	add $5, $2,$0		/* Ret. val is arg1 to `cleanup'. */
+	add $25, $16,$0		/* Set `cleanup' procedure value. */
+	jal $31, $25		/* Call `cleanup'. */
+
+	la $25,qt_error		/* Set `qt_error' procedure value. */
+	j $25
diff --git a/ext/systemc/src/sysc/qt/md/mips.h b/ext/systemc/src/sysc/qt/md/mips.h
new file mode 100644
index 000000000..14d109461
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/mips.h
@@ -0,0 +1,134 @@
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+#ifndef QUICKTHREADS_MIPS_H
+#define QUICKTHREADS_MIPS_H
+
+typedef unsigned long qt_word_t;
+
+#define QUICKTHREADS_GROW_DOWN
+
+/* Stack layout on the mips:
+
+   Callee-save registers are: $16-$23, $30; $f20-$f30.
+   Also save $31, return pc.
+
+   Non-varargs:
+
+   +---
+   | $f30	The first clump is only saved if `qt_block'
+   | $f28	is called, in which case it saves the fp regs
+   | $f26	then calls `qt_blocki' to save the int regs.
+   | $f24
+   | $f22
+   | $f20
+   | $31 === return pc in `qt_block'
+   +---
+   | $31 === return pc; on startup == qt_start
+   | $30
+   | $23
+   | $22
+   | $21
+   | $20
+   | $19	on startup === only
+   | $18	on startup === $a2 === userf
+   | $17	on startup === $a1 === pt
+   | $16	on startup === $a0 === pu
+   | <a3>	save area req'd by MIPS calling convention
+   | <a2>	save area req'd by MIPS calling convention
+   | <a1>	save area req'd by MIPS calling convention
+   | <a0>	save area req'd by MIPS calling convention	<--- sp
+   +---
+
+   Conventions for varargs:
+
+   | args ...
+   +---
+   |  :
+   |  :
+   | $21
+   | $20
+   | $19	on startup === `userf'
+   | $18	on startup === `startup'
+   | $17	on startup === `pt'
+   | $16	on startup === `cleanup'
+   | <a3>
+   | <a2>
+   | <a1>
+   | <a0>	<--- sp
+   +---
+
+   Note: if we wanted to, we could muck about and try to get the 4
+   argument registers loaded in to, e.g., $22, $23, $30, and $31,
+   and the return pc in, say, $20.  Then, the first 4 args would
+   not need to be loaded from memory, they could just use
+   register-to-register copies. */
+
+
+/* Stack must be doubleword aligned. */
+#define QUICKTHREADS_STKALIGN	(8)	/* Doubleword aligned. */
+
+/* How much space is allocated to hold all the crud for
+   initialization: $16-$23, $30, $31.  Just do an integer restore,
+   no need to restore floating-point.  Four words are needed for the
+   argument save area for the helper function that will be called for
+   the old thread, just before the new thread starts to run. */
+
+#define QUICKTHREADS_STKBASE	(14 * 4)
+#define QUICKTHREADS_VSTKBASE	QUICKTHREADS_STKBASE
+
+
+/* Offsets of various registers. */
+#define QUICKTHREADS_31	(9+4)
+#define QUICKTHREADS_19	(3+4)
+#define QUICKTHREADS_18	(2+4)
+#define QUICKTHREADS_17	(1+4)
+#define QUICKTHREADS_16	(0+4)
+
+
+/* When a never-before-run thread is restored, the return pc points
+   to a fragment of code that starts the thread running.  For
+   non-vargs functions, it just calls the client's `only' function.
+   For varargs functions, it calls the startup, user, and cleanup
+   functions.
+
+   The varargs startup routine always reads 4 words of arguments from
+   the stack.  If there are less than 4 words of arguments, then the
+   startup routine can read off the top of the stack.  To prevent
+   errors we always allocate 4 words.  If there are more than 3 words
+   of arguments, the 4 preallocated words are simply wasted. */
+
+extern void qt_start(void);
+#define QUICKTHREADS_ARGS_MD(sp)	(QUICKTHREADS_SPUT (sp, QUICKTHREADS_31, qt_start))
+
+#define QUICKTHREADS_VARGS_MD0(sp, vabytes) \
+  ((qt_t *)(((char *)(sp)) - 4*4 - QUICKTHREADS_STKROUNDUP(vabytes)))
+
+extern void qt_vstart(void);
+#define QUICKTHREADS_VARGS_MD1(sp)	(QUICKTHREADS_SPUT (sp, QUICKTHREADS_31, qt_vstart))
+
+#define QUICKTHREADS_VARGS_DEFAULT
+
+
+/* The *index* (positive offset) of where to put each value. */
+#define QUICKTHREADS_ONLY_INDEX	(QUICKTHREADS_19)
+#define QUICKTHREADS_USER_INDEX	(QUICKTHREADS_18)
+#define QUICKTHREADS_ARGT_INDEX	(QUICKTHREADS_17)
+#define QUICKTHREADS_ARGU_INDEX	(QUICKTHREADS_16)
+
+#define QUICKTHREADS_VCLEANUP_INDEX	(QUICKTHREADS_16)
+#define QUICKTHREADS_VUSERF_INDEX		(QUICKTHREADS_19)
+#define QUICKTHREADS_VSTARTUP_INDEX	(QUICKTHREADS_18)
+#define QUICKTHREADS_VARGT_INDEX		(QUICKTHREADS_17)
+
+#endif /* ndef QUICKTHREADS_MIPS_H */
diff --git a/ext/systemc/src/sysc/qt/md/mips.s b/ext/systemc/src/sysc/qt/md/mips.s
new file mode 100644
index 000000000..b074b98dc
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/mips.s
@@ -0,0 +1,164 @@
+/* mips.s -- assembly support. */
+
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+/* Callee-save $16-$23, $30-$31.
+ *
+ * On startup, restore regs so retpc === call to a function to start.
+ * We're going to call a function ($4) from within this routine.
+ * We're passing 3 args, therefore need to allocate 12 extra bytes on
+ * the stack for a save area.  The start routine needs a like 16-byte
+ * save area.  Must be doubleword aligned (_mips r3000 risc
+ * architecture_, gerry kane, pg d-23).
+ */
+
+	.globl qt_block
+	.globl qt_blocki
+	.globl qt_abort
+	.globl qt_start
+	.globl qt_vstart
+
+	/*
+	** $4: ptr to function to call once curr is suspended
+	**	and control is on $7's stack.
+	** $5: 1'th arg to $4.
+	** $6: 2'th arg to $4
+	** $7: sp of thread to suspend.
+	**
+	** Totally gross hack: The MIPS calling convention reserves
+	** 4 words on the stack for a0..a3.  This routine "ought" to
+	** allocate space for callee-save registers plus 4 words for
+	** the helper function, but instead we use the 4 words
+	** provided by the function that called us (we don't need to
+	** save our argument registers).  So what *appears* to be
+	** allocating only 40 bytes is actually allocating 56, by
+	** using the caller's 16 bytes.
+	**
+	** The helper routine returns a value that is passed on as the
+	** return value from the blocking routine.  Since we don't
+	** touch $2 between the helper's return and the end of
+	** function, we get this behavior for free.
+	*/
+qt_blocki:
+	sub $sp,$sp,40		/* Allocate reg save space. */
+	sw $16, 0+16($sp)
+	sw $17, 4+16($sp)
+	sw $18, 8+16($sp)
+	sw $19,12+16($sp)
+	sw $20,16+16($sp)
+	sw $21,20+16($sp)
+	sw $22,24+16($sp)
+	sw $23,28+16($sp)
+	sw $30,32+16($sp)
+	sw $31,36+16($sp)
+	add $2, $sp,$0		/* $2 <= old sp to pass to func@$4. */
+qt_abort:
+	add $sp, $7,$0		/* $sp <= new sp. */
+	.set noreorder
+	jal $31,$4		/* Call helper func@$4 . */
+	add $4, $2,$0		/* $a0 <= pass old sp as a parameter. */
+	.set reorder
+	lw $31,36+16($sp)	/* Restore callee-save regs... */
+	lw $30,32+16($sp)
+	lw $23,28+16($sp)
+	lw $22,24+16($sp)
+	lw $21,20+16($sp)
+	lw $20,16+16($sp)
+	lw $19,12+16($sp)
+	lw $18, 8+16($sp)
+	lw $17, 4+16($sp)
+	lw $16, 0+16($sp)	/* Restore callee-save */
+
+	add $sp,$sp,40		/* Deallocate reg save space. */
+	j $31			/* Return to caller. */
+
+	/*
+	** Non-varargs thread startup.
+	** Note: originally, 56 bytes were allocated on the stack.
+	** The thread restore routine (_blocki/_abort) removed 40
+	** of them, which means there is still 16 bytes for the
+	** argument area required by the MIPS calling convention.
+	*/
+qt_start:
+	add $4, $16,$0		/* Load up user function pu. */
+	add $5, $17,$0		/* ... user function pt. */
+	add $6, $18,$0		/* ... user function userf. */
+	jal $31,$19		/* Call `only'. */
+	j qt_error
+
+
+	/*
+	** Save calle-save floating-point regs $f20-$f30
+	** See comment in `qt_block' about calling conventinos and
+	** reserved space.  Use the same trick here, but here we
+	** actually have to allocate all the bytes since we have to
+	** leave 4 words leftover for `qt_blocki'.
+	**
+	** Return value from `qt_block' is the same as the return from
+	** `qt_blocki'.  We get that for free since we don't touch $2
+	** between the return from `qt_blocki' and the return from
+	** `qt_block'.
+	*/
+qt_block:
+	sub $sp, $sp,56		/* 6 8-byte regs, saved ret pc, aligned. */
+	swc1 $f20,  0+16($sp)
+	swc1 $f22,  8+16($sp)
+	swc1 $f24, 16+16($sp)
+	swc1 $f26, 24+16($sp)
+	swc1 $f28, 32+16($sp)
+	swc1 $f30, 40+16($sp)
+	sw $31, 48+16($sp)
+	jal qt_blocki
+	lwc1 $f20,  0+16($sp)
+	lwc1 $f22,  8+16($sp)
+	lwc1 $f24, 16+16($sp)
+	lwc1 $f26, 24+16($sp)
+	lwc1 $f28, 32+16($sp)
+	lwc1 $f30, 40+16($sp)
+	lw $31, 48+16($sp)
+	add $sp, $sp,56
+	j $31
+
+
+	/*
+	** First, call `startup' with the `pt' argument.
+	**
+	** Next, call the user's function with all arguments.
+	** Note that we don't know whether args were passed in
+	** integer regs, fp regs, or on the stack (See Gerry Kane
+	** "MIPS R2000 RISC Architecture" pg D-22), so we reload
+	** all the registers, possibly with garbage arguments.
+	**
+	** Finally, call `cleanup' with the `pt' argument and with
+	** the return value from the user's function.  It is an error
+	** for `cleanup' to return.
+	*/
+qt_vstart:
+	add $4, $17,$0		/* `pt' is arg0 to `startup'. */
+	jal $31, $18		/* Call `startup'. */
+
+	add $sp, $sp,16		/* Free extra save space. */
+	lw $4,  0($sp)		/* Load up args. */
+	lw $5,  4($sp)
+	lw $6,  8($sp)
+	lw $7, 12($sp)
+	lwc1 $f12, 0($sp)	/* Load up fp args. */
+	lwc1 $f14, 8($sp)
+	jal $31,$19		/* Call `userf'. */
+
+	add $4, $17,$0		/* `pt' is arg0 to `cleanup'. */
+	add $5, $2,$0		/* Ret. val is arg1 to `cleanup'. */
+	jal $31, $16		/* Call `cleanup'. */
+
+	j qt_error
diff --git a/ext/systemc/src/sysc/qt/md/mips_b.s b/ext/systemc/src/sysc/qt/md/mips_b.s
new file mode 100644
index 000000000..5b3740843
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/mips_b.s
@@ -0,0 +1,99 @@
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+	.globl b_call_reg
+	.globl b_call_imm
+	.globl b_add
+	.globl b_load
+
+	.ent b_null
+b_null:
+	j $31
+	.end b_null
+
+	.ent b_call_reg
+b_call_reg:
+	la $5,b_null
+	add $6, $31,0
+$L0:
+	jal $5
+	jal $5
+	jal $5
+	jal $5
+	jal $5
+
+	sub $4, $4,5
+	bgtz $4,$L0
+	j $6
+	.end
+
+
+	.ent b_call_imm
+b_call_imm:
+	add $6, $31,0
+$L1:
+	jal b_null
+	jal b_null
+	jal b_null
+	jal b_null
+	jal b_null
+
+	sub $4, $4,5
+	bgtz $4,$L1
+	j $6
+	.end
+
+
+	.ent b_add
+b_add:
+	add $5, $0,$4
+	add $6, $0,$4
+	add $7, $0,$4
+	add $8, $0,$4
+$L2:
+	sub $4, $4,5
+	sub $5, $5,5
+	sub $6, $6,5
+	sub $7, $7,5
+	sub $8, $8,5
+
+	sub $4, $4,5
+	sub $5, $5,5
+	sub $6, $6,5
+	sub $7, $7,5
+	sub $8, $8,5
+
+	bgtz $4,$L2
+	j $31
+	.end
+
+
+	.ent b_load
+b_load:
+$L3:
+	ld $0, 0($sp)
+	ld $0, 4($sp)
+	ld $0, 8($sp)
+	ld $0, 12($sp)
+	ld $0, 16($sp)
+
+	ld $0, 20($sp)
+	ld $0, 24($sp)
+	ld $0, 28($sp)
+	ld $0, 32($sp)
+	ld $0, 36($sp)
+
+	sub $4, $4,10
+	bgtz $4,$L3
+	j $31
+	.end
diff --git a/ext/systemc/src/sysc/qt/md/null.README b/ext/systemc/src/sysc/qt/md/null.README
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/null.README
diff --git a/ext/systemc/src/sysc/qt/md/null.c b/ext/systemc/src/sysc/qt/md/null.c
new file mode 100644
index 000000000..db1a593ed
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/null.c
@@ -0,0 +1,14 @@
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+char const qtmd_rcsid[] = "$Header: /Users/acg/CVSROOT/systemc-2.3/src/sysc/qt/md/null.c,v 1.1.1.1 2006/12/15 20:20:06 acg Exp $";
diff --git a/ext/systemc/src/sysc/qt/md/null.s b/ext/systemc/src/sysc/qt/md/null.s
new file mode 100644
index 000000000..8a2361f9e
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/null.s
@@ -0,0 +1,12 @@
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
diff --git a/ext/systemc/src/sysc/qt/md/powerpc.README b/ext/systemc/src/sysc/qt/md/powerpc.README
new file mode 100644
index 000000000..b98da8b27
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/powerpc.README
@@ -0,0 +1,27 @@
+
+PowerPC assembly support
+
+
+1) MacOS X, Darwin, MKLinux and other systems based on Mach kernel ABI:
+
+	- Configuration command: ./config powerpc-darwin
+
+	- See documentation inside powerpc_mach.h, powerpc_mach.s, powerpc.c.
+
+
+2) LinuxPPC, and other systems based on System V ABI:
+
+	- Configuration command: ./config powerpc
+
+	- See documentation inside powerpc_sys5.h, powerpc_sys5.s, powerpc.c.
+
+
+Marco Bucci <marco.bucci@inwind.it>
+December 2002
+
+
+ * This software is largely based on the original PowerPC-Linux porting
+ * developed by Ken Aaker <kenaaker@silverbacksystems.com>
+ *
+ * Marco Bucci <marco.bucci@inwind.it>
+ * December 2002
diff --git a/ext/systemc/src/sysc/qt/md/powerpc.c b/ext/systemc/src/sysc/qt/md/powerpc.c
new file mode 100644
index 000000000..fb374f3f2
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/powerpc.c
@@ -0,0 +1,69 @@
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+
+#include <stdarg.h>
+#include "qt.h"
+
+// This static is used to find the end of the stack for variable
+
+static void *qt_sp_bottom_save;
+
+/* We actually don't know how the compiler accomodates arguments in the 
+ * va_list. In some implementation (e.g. Linux PPC) we cannot scan the
+ * list as an array. To avoid this problem, this version of "qt_varg",
+ * retrieves arguments by means of the standard "va_arg" macro defined
+ * in stdargs.h.
+ *
+ * Notice that we still suppose that the number of arguments is given
+ * by nbytes/sizeof(qt_word_t) and we load the stack of "qt_vstart"
+ * assuming that all parameters are alligned to the size of qt_word_t.
+ *
+ * Marco Bucci <marco.bucci@inwind.it>
+ * December 2002
+ */
+
+/*
+
+qt_t *qt_vargs (qt_t *sp, int nbytes, void *vargs,
+	  void *pt, qt_startup_t *startup,
+	  qt_vuserf_t *vuserf, qt_cleanup_t *cleanup)
+	  
+*/
+
+  qt_t *
+qt_vargs_stdarg (qt_t *sp, int nbytes, va_list vargs,
+	  void *pt, qt_startup_t *startup,
+	  qt_vuserf_t *vuserf, qt_cleanup_t *cleanup)
+	  
+	  
+	
+{
+	int i;
+	qt_word_t arg;
+
+	sp = QUICKTHREADS_VARGS_MD0 (sp, nbytes);
+
+	for ( i=0;i<(int)(nbytes/sizeof(qt_word_t)); i++)
+    {
+    	arg = va_arg(vargs, qt_word_t);
+      	QUICKTHREADS_SPUT (QUICKTHREADS_VARGS_ADJUST(sp), i, arg);
+    }
+
+	QUICKTHREADS_VARGS_MD1 (QUICKTHREADS_VADJ(sp));
+	QUICKTHREADS_SPUT (QUICKTHREADS_VADJ(sp), QUICKTHREADS_VARGT_INDEX, pt);
+	QUICKTHREADS_SPUT (QUICKTHREADS_VADJ(sp), QUICKTHREADS_VSTARTUP_INDEX, startup);
+	QUICKTHREADS_SPUT (QUICKTHREADS_VADJ(sp), QUICKTHREADS_VUSERF_INDEX, vuserf);
+	QUICKTHREADS_SPUT (QUICKTHREADS_VADJ(sp), QUICKTHREADS_VCLEANUP_INDEX, cleanup);
+	return ((qt_t *)QUICKTHREADS_VADJ(sp));
+}
diff --git a/ext/systemc/src/sysc/qt/md/powerpc_mach.h b/ext/systemc/src/sysc/qt/md/powerpc_mach.h
new file mode 100644
index 000000000..677808c5c
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/powerpc_mach.h
@@ -0,0 +1,611 @@
+/*
+   + * QuickThreads -- Threads-building toolkit.
+   + * Copyright (c) 1993 by David Keppel
+   + *
+   + * Permission to use, copy, modify and distribute this software and
+   + * its documentation for any purpose and without fee is hereby
+   + * granted, provided that the above copyright notice and this notice
+   + * appear in all copies.  This software is provided as a
+   + * proof-of-concept and for demonstration purposes; there is no
+   + * representation about the suitability of this software for any
+   + * purpose.
+   + *
+
+   + * PowerPC-Mach thread switching module.
+   + * 
+   + * This software is largely based on the original PowerPC-Linux porting
+   + * developed by Ken Aaker <kenaaker@silverbacksystems.com>
+   + * 
+   + * Marco Bucci <marco.bucci@inwind.it>
+   + * December 2002
+   + *
+   + */
+
+
+#ifndef QUICKTHREADS_POWERPC_H
+#define QUICKTHREADS_POWERPC_H
+
+
+/*****************************************************************************
+ *
+ * DESCRIPTION
+ *
+ * This is the QuickThreads switching module implementation for PowerPC 
+ * running under Mach kernel. It was developed and tested under MacOS X, that
+ * is under Darwin (the UNIX-BSD fundation of MacOS X).
+ *
+ * Notice that the Mach PowerPC ABI (Application Binary Interface) [1] is
+ * not the same than System V ABI [2] used by most of the LINUX PowerPC
+ * implementations.
+ *
+ * IMPLEMENTATION NOTES
+ *
+ * 1) Porting on System V ABI
+ * Excluding the variant argument calling convention, Mach and System V ABI
+ * are enough similar and it could be possible to use some simple macro, to
+ * adapt the code for both the ABIs. Actually, the only relevant difference 
+ * is in the linkage area structure and in the position where the Link and
+ * the Condition registers are saved. As to the calling conventions, there
+ * are differences with floating points argument passing and with variant
+ * argument lists. Notice that, on Mach, the caller's stack frame allocates
+ * space to hold all arguments ([1] p.51), while on System V, the caller's
+ * stack frame allocates space to hold just the arguments that don't fit into
+ * registers ([2] p.3.18).
+ *
+ * 2) Variant argument list implementation
+ * Variant argument calling on a RISC machine is not easy to implement since
+ * parameters are passed via registers instead of via stack. In a general
+ * variant argument implementation, the caller's stack must map the whole
+ * parameter list following the rules related to the use of the GPR and FPR
+ * parameter registers and the stack alignment ([1] p.54). 
+ * This implementation is quite simple and not general. It works under the
+ * hypothesis that arguments are 4-bytes aligned integers.
+ *
+ * 3) This heather file organisation
+ * I preferred to not make confusion between macros that are needed (i.e.
+ * directly used) by QuickThreads and internal "implementation" macros. You
+ * will find QuickThreds macros in the end of this header. Sometime they just
+ * refer to an analogous "internal" macro. On the top, there are the macros
+ * that I used to make more clean (I hope) the implementation. I could include
+ * some system heather (as to stack layout definitions, prologs and epilogs,
+ * etc.), but I preferred to have a self-contained heather in order to make
+ * all more clear for mantaining and for possible porting on another ABI.
+ *
+ *
+ * REFERENCES
+ *
+ * [1] - Mach-O Runtime Architecture
+ *       Runtime Concepts and Conventions for Mac OS X Programs
+ *       Preliminary July 2002
+ *
+ * [2] - SYSTEM V APPLICATION BINARY INTERFACE
+ *       PowerPC Processor Supplement
+ *       September 1995
+ *
+ * On MacOS X, more documentation is available by installing the "Developer
+ * Tools". Useful macros and documentation can be found in the system headers
+ * files such as asm.h, asm_help.h etc. (see /usr/architecture/ppc/ or
+ * /System/Library/Frameworks/Kernel.framework/Headers/architecture/ppc/).	
+
+ *****************************************************************************/
+
+/*****************************************************************************
+ *
+ *  PowerPC Mach-O Stack frame (see [1])
+ *  
+  
+                      ................
+                +                          +
+                |                          | reserved
+                +  CALLER'S LINKAGE AREA   +
+                |                          | Caller's LR
+                +                          + 
+                |                          | Caller's CR
+                +                          +
+ backchain ->   |                          | Caller's backchain
+                +==========================+
+                |                          | FPR31
+                +      FPR SAVE AREA       +
+                       ..............
+                +                          +
+                |                          | FPRn
+                +--------------------------+
+                |                          | GPR31
+                +      GPR SAVE AREA       +
+                       ..............
+                +                          +
+                |                          | GPRn
+                +--------------------------+
+                |                          | 
+                +      ALIGNMEBNT PAD      +
+                       ..............
+                +       (if needed)        +
+                |                          |
+                +--------------------------+
+                |                          | 
+                +   LOCAL VARIABLES AREA   +
+                       ..............
+                +                          +
+                |                          |
+                +--------------------------+
+                |                          | PAR(n)
+                +                          +
+                |                          | 
+                +      PARAMETER AREA      +
+                       ..............
+                +      for FUTURE call     +
+                |                          | PAR(1)
+                +                          +
+ SP + 24 ->     |                          | PAR(0)
+                +--------------------------+
+ SP + 20 ->     |                          | Caller's TOC
+                +                          + 
+ SP + 16 ->     |                          | reserved
+                +                          +
+ SP + 12 ->     |                          | reserved
+                +       LINKAGE AREA       +
+ SP + 8 ->      |                          | LR callee-save for FUTURE call
+                +                          + 
+ SP + 4 ->      |                          | CR callee-save for FUTURE call
+                +                          +
+ SP ->          |                          | backchain
+                +==========================+
+                STACK TOP (lower address)
+  
+                     Stack grows down
+                             |
+                             V
+ * NOTE:
+ *
+ * 1) Parameter are allocated in the CALLER's parameter area. This area must
+ * be large enough to hold all parameters regardless if they are or not passed
+ * in registers.
+ *
+ * The caller parameter area is used:
+ * - by the caller, to store parameters to the callee that cannot fit in
+ *  registers (no more parameter registers are available);
+ * - by the callee, to save parameter registers (for istance because they are
+ * needed for a further call).
+ *
+ * Obviously, the callee saves parameter registers, in the location in which
+ * they are mapped on the caller's stack frame. So, be aware that, if
+ * something else is stored in that location, it could be deleted after a call. 
+ *
+ * 2) The callee saves LR and CR in the caller's linkage area. All other
+ * callee's state are saved in its own stack frame.
+ *
+ 
+ *****************************************************************************/ 
+
+
+/*****************************************************************************
+ * 
+ * Stack initialization for a single argument thread
+ *
+
+
+ top + QUICKTHREADS_STKBASE ->           STACK BOTTOM (higher address)
+                               +==========================+
+                               |                          |
+                               +                          +
+                                     ..............
+                               +                          +
+                               |                          |
+                               +--------------------------+
+ top + QUICKTHREADS_ONLY_INDEX * 4 ->    | only param               | PAR(3)
+                               +                          +
+ top + QUICKTHREADS_USER_INDEX * 4 ->    | userf param              | PAR(2)
+                               +                          +
+ top + QUICKTHREADS_ARGT_INDEX * 4 ->    | t param                  | PAR(1)
+                               +                          +
+ top + QUICKTHREADS_ARGU_INDEX * 4 ->    | u param                  | PAR(0)
+                               +--------------------------+
+                               |                          |
+                               +                          +
+                                     ..............
+                               +                          +
+ top + QUICKTHREADS_RETURN_INDEX * 4 ->  | qt_start                 | LR save
+                               +                          +
+                                     ..............
+                               +                          +
+ top + QUICKTHREADS_BLOCKI_FRAME_SIZE -> | top + QUICKTHREADS_STKBASE         | backchain                     
+                               +==========================+
+                               |                          |
+                               +                          +
+                                     ..............
+                               +                          +
+                               |                          |
+                               +--------------------------+
+                               |                          | 
+                               +                          +
+                                     ..............
+                               +                          +
+ top ->                        |top + QUICKTHREADS_BLOCKI_FRAME_SIZE| backchain
+                               +==========================+
+                               STACK TOP (lower address)
+  
+                                    Stack grows down
+                                           |
+                                           V
+
+ *****************************************************************************
+ *
+ * Stack initialization for a variant argument thread
+ *
+
+ bottom ->                     STACK BOTTOM (higher address)
+                               +==========================+
+                               |                          |
+                               +                          +
+                                     ..............
+                               +                          +
+ top + QUICKTHREADS_VSTKBASE ->          | arg(0)                   | PAR(4)
+                               +--------------------------+
+ top + QUICKTHREADS_CLEANUP_INDEX * 4 -> | cleanup param            | PAR(3)
+                               +                          +
+ top + QUICKTHREADS_USER_INDEX * 4 ->    | userf param              | PAR(2)  
+                               +                          +
+ top + QUICKTHREADS_VSTARTUP_INDEX * 4 ->| startup param            | PAR(1)
+                               +                          +
+ top + QUICKTHREADS_ARGT_INDEX * 4 ->    | t param                  | PAR(0)
+                               +--------------------------+
+                               |                          |
+                               +                          +
+                                     ..............
+                               +                          +
+ top + QUICKTHREADS_RETURN_INDEX * 4 ->  | qt_start                 | LR save
+                               +                          +
+                                     ..............
+ top + QUICKTHREADS_BLOCKI_FRAME_SIZE -> | top + QUICKTHREADS_STKBASE         | backchain                     
+                               +==========================+
+                               |                          |
+                               +                          +
+                                     ..............
+                               +                          +
+                               |                          |
+                               +--------------------------+
+                               |                          | 
+                               +                          +
+                                     ..............
+                               +                          +
+ top ->                        |top + QUICKTHREADS_BLOCKI_FRAME_SIZE| backchain
+                               +==========================+
+                               STACK TOP (lower address)
+  
+                                    Stack grows down
+                                          |
+                                          V
+
+* NOTE:
+*
+* Parameters are passed to "qt_start" or to "qt_vstart" putting them into
+* the stack frames of "qt_start" or "qt_vstart" themselves. This not a
+* conventional parameter passing because parameters should be put into the
+* caller's stack, not into the callee's one. Actually  we must consider
+* that as a preload of the parameter area that "qt_start" or "qt_vstart"
+* will use for their own calls.
+*  Be aware of the fact that, during a call, the caller's parameter area is,
+* in a certain sense, volatile. In facts, the callee can save parameter
+* registers on the caller's parameter area.
+*
+ *****************************************************************************/ 
+
+
+/*****************************************************************************
+ 
+   Define PowerPC Mach-O related macros
+ 
+ *****************************************************************************/ 
+
+
+
+typedef unsigned long PPC_W;
+
+/* Stack pointer must always be a multiple of 16 */
+#define	PPC_STACK_INCR	16		
+#define	PPC_ROUND_STACK(length)	\
+	(((length)+PPC_STACK_INCR-1) & ~(PPC_STACK_INCR-1))
+
+
+#define PPC_LINKAGE_AREA 24					
+#define PPC_CR_SAVE 4
+#define PPC_LR_SAVE 8
+
+#define PPC_PARAM_AREA(n) (4*(n))
+
+#define PPC_GPR_SAVE_AREA (4*19)		/* GPR13-GPR31 must be saved */
+#define PPC_FPR_SAVE_AREA (8*18)		/* FPR14-FPR31 must be saved */
+
+/* Define parameter offset on the stack.
+ * NOTICE: Parameters are numbered 0, 1, ..., n. 
+*/
+#define PPC_PAR(i) (PPC_LINKAGE_AREA+(i)*4)
+
+/*****************************************************************************
+ 
+   Define stack frames
+ 
+ *****************************************************************************/ 
+
+
+/* Define the "qt_blocki" and "qt_abort" stack frame. We use the same stack
+ * frame for both. 
+ *
+
+ top + S ->  
+                        +==========================+
+ top + S - 4 ->         |                          | GPR31 
+                        +      GPR SAVE AREA       +
+                               ..............
+                        +                          +
+ top + S - 19 * 4 ->    |                          | GPR13
+                        +--------------------------+
+                        |                          | 
+                        +      ALIGNMEBNT PAD      +
+                               ..............
+                        +       (if needed)        +
+                        |                          |
+                        +--------------------------+
+                        |                          |
+                        +                          +
+                        |                          |
+                        +      PARAMETER AREA      +
+                        |                          |
+                        +                          +
+ top + 24 ->            |                          |
+                        +--------------------------+
+                        |                          |
+                        +       LINKAGE AREA       +
+ top ->                 |                          |
+                        +==========================+
+ */
+
+#define QUICKTHREADS_BLOCKI_FRAME_SIZE \
+	PPC_ROUND_STACK(PPC_LINKAGE_AREA+PPC_PARAM_AREA(4)+PPC_GPR_SAVE_AREA)
+
+/* Offset to the base of the GPR save area. Save from GPR13 to GPR31
+ * increasing address. 
+ */
+#define QUICKTHREADS_BLOCKI_GPR_SAVE(i) (QUICKTHREADS_BLOCKI_FRAME_SIZE-4+(i-31)*4)
+
+
+
+/* Define the "qt_block" stack frame. Notice that since "qt_black" calls
+ * "qt_blocki", GPR registers are saved into "qt_blocki" stack frame.
+ *
+
+ top + S ->  
+                        +==========================+
+ top + S - 8 ->         |                          | FPR31 
+                        +      FPR SAVE AREA       +
+                               ..............
+                        +                          +
+ top + S - 18 * 8 ->    |                          | FPR14
+                        +--------------------------+
+                        |                          | 
+                        +      ALIGNMEBNT PAD      +
+                               ..............
+                        +       (if needed)        +
+                        |                          |
+                        +--------------------------+
+                        |                          |
+                        +                          +
+                        |                          |
+                        +      PARAMETER AREA      +
+                        |                          |
+                        +                          +
+ top + 24 ->            |                          |
+                        +--------------------------+
+                        |                          |
+                        +       LINKAGE AREA       +
+ top ->                 |                          |
+                        +==========================+
+ */
+
+#define QUICKTHREADS_BLOCK_FRAME_SIZE \
+	PPC_ROUND_STACK(PPC_LINKAGE_AREA+PPC_PARAM_AREA(4)+PPC_FPR_SAVE_AREA)
+
+/* Offset to the location where registers are saved.
+ */
+#define QUICKTHREADS_BLOCK_FPR_SAVE(i) (QUICKTHREADS_BLOCK_FRAME_SIZE-8+(i-31)*8)
+
+
+/* Define the "qt_start" frame size. It consists just of the linkage area and 
+ * the parameter area. 
+ *
+
+                        +==========================+
+                        |                          | 
+                        +      ALIGNMEBNT PAD      +
+                               ..............
+                        +       (if needed)        +
+                        |                          |
+                        +--------------------------+
+                        |                          | only par
+                        +                          +
+                        |                          | userf par
+                        +      PARAMETER AREA      +
+                        |                          | t par
+                        +                          +
+ top + 24 ->            |                          | u par
+                        +--------------------------+
+                        |                          |
+                        +       LINKAGE AREA       +
+ top ->                 |                          |
+                        +==========================+
+
+ */
+#define QUICKTHREADS_START_FRAME_SIZE PPC_ROUND_STACK(PPC_LINKAGE_AREA+PPC_PARAM_AREA(4))
+
+
+
+/* Define the "qt_vstart" frame. It consists of the linkage area, the fix parameter 
+ * area, the variant argument list and a local variable area used in "qt_vstart"
+ * implementation.
+ *
+
+ backchain ->  
+                        +==========================+
+ backchain - 4 ->       |                          | 
+                        +   LOCAL VARIABLES AREA   +
+                               ..............
+                        +                          +
+                        |                          |
+                        +--------------------------+
+                        |                          | 
+                        +      ALIGNMEBNT PAD      +
+                               ..............
+                        +       (if needed)        +
+                        |                          |
+                        +--------------------------+
+                        |                          | arg(n)
+                        +                          +
+                        |                          | 
+                        +  VARIABLE ARGUMENT LIST  +
+                               ..............
+                        +      for userf call      +
+                        |                          | arg(1)
+                        +                          +
+ top + 24 + 16 ->       |                          | arg(0)
+                        +--------------------------+
+                        |                          | cleanup par
+                        +                          +
+                        |                          | userf par
+                        +      PARAMETER AREA      +
+                        |                          | startup par
+                        +                          +
+ top + 24 ->            |                          | t par
+                        +--------------------------+
+                        |                          |
+                        +       LINKAGE AREA       +
+ top ->                 |                          |
+                        +==========================+
+
+ */
+#define QUICKTHREADS_VARGS_LOCAL_AREA (4*4)		/* local variable area */
+
+/* The offset the stack will be moved back before to call "userf(...)".
+ * The linckage area must be moved to be adiacent to the part of the variant
+ * argument list that is in the stack.
+ */
+#define QUICKTHREADS_VARGS_BKOFF PPC_PARAM_AREA(4)
+
+#define QUICKTHREADS_VSTART_FRAME_SIZE(varbytes) \
+	PPC_ROUND_STACK(PPC_LINKAGE_AREA+PPC_PARAM_AREA(4)+(varbytes)+ \
+		QUICKTHREADS_VARGS_LOCAL_AREA)
+
+/* Offset to the base of the varian argument list */
+#define QUICKTHREADS_VSTART_LIST_BASE (PPC_LINKAGE_AREA+PPC_PARAM_AREA(4))
+
+
+/* Notice that qt_start and qt_vstart have no parameters, actually their
+ * parameters are written in their stack frame during thread initialization
+ */
+extern void qt_start(void);
+extern void qt_vstart(void);
+
+
+
+/* Offset (in words) of the location where the block routine saves its return
+ * address (i.e. LR). SP points the top of the block routine stack and,
+ * following ppc calling conventions, the return address is saved in the
+ * previous (caller's) stack frame.
+ */
+#define QUICKTHREADS_RETURN_INDEX ((QUICKTHREADS_BLOCKI_FRAME_SIZE+PPC_LR_SAVE)/sizeof(PPC_W))
+
+/* static variable used to get the stack bottom in "VARGS" initialization */
+/* static void *qt_sp_bottom_save; */
+
+#define QUICKTHREADS_ARG_INDEX(i) ((QUICKTHREADS_BLOCKI_FRAME_SIZE+PPC_PAR(i))/sizeof(PPC_W))
+
+/*****************************************************************************
+
+	QuickThreads needed definitions
+
+ *****************************************************************************/
+
+
+#define QUICKTHREADS_GROW_DOWN
+#define QUICKTHREADS_STKALIGN	PPC_STACK_INCR
+typedef PPC_W qt_word_t;
+
+
+/* This macro is used by "QUICKTHREADS_ARGS" to initialize a single argument thread.
+ * - set "qt_start" as the "qt_block" or "qt_blocki" return address;
+ * - set the top of the stack backchain;
+ * - set the next backchain (not needed, but just to be "clean").   
+ */
+#define QUICKTHREADS_ARGS_MD(sp) \
+	(QUICKTHREADS_SPUT (sp, QUICKTHREADS_RETURN_INDEX, qt_start), \
+	QUICKTHREADS_SPUT (sp, 0, sp+QUICKTHREADS_BLOCKI_FRAME_SIZE), \
+	QUICKTHREADS_SPUT (sp, QUICKTHREADS_BLOCKI_FRAME_SIZE/sizeof(PPC_W), \
+		sp+QUICKTHREADS_BLOCKI_FRAME_SIZE+QUICKTHREADS_START_FRAME_SIZE))
+
+
+/* This macro is used by "QUICKTHREADS_VARGS" to initialize a variant argument thread. 
+ * It returns the pointer to the top of the argument list.
+ * We also use it to get the stack bottom via a static variable. This is a bit 
+ * "dirty", it could be better to do it in "qt_vargs", but we don't want change 
+ * anything out of this file.
+ * We need the stack bottom to allocate a local variable area used by
+ * "qt_vstart". 
+ */
+#define QUICKTHREADS_VARGS_MD0(sp, varbytes) \
+  ((qt_sp_bottom_save = sp), \
+  ((qt_t *)(((char *)(sp)) - \
+		(QUICKTHREADS_VSTART_FRAME_SIZE(varbytes)-QUICKTHREADS_VSTART_LIST_BASE))))
+
+
+/* This macro is used by "QUICKTHREADS_VARGS" to initialize a variant argument thread.
+ * - set "qt_start" as the "qt_block" or "qt_blocki" return address;
+ * - set the top of the stackback chain;
+ * - set the next backchain (it points the stack botton).   
+ */
+#define QUICKTHREADS_VARGS_MD1(sp) \
+	(QUICKTHREADS_SPUT (sp, QUICKTHREADS_RETURN_INDEX, qt_vstart), \
+	QUICKTHREADS_SPUT (sp, 0, sp+QUICKTHREADS_BLOCKI_FRAME_SIZE), \
+	QUICKTHREADS_SPUT (sp, (QUICKTHREADS_BLOCKI_FRAME_SIZE)/sizeof(PPC_W), \
+		qt_sp_bottom_save))
+
+
+/* Activate "qt_vargs" as the initialization routine for the variant 
+ * argument threads
+ */ 
+#define QUICKTHREADS_VARGS_DEFAULT 
+
+/* Override "qt_vargs" with "qt_vargs_stdarg".
+ * On LinuxPPC "qt_vargs" doesn't work, "qt_vargs_stdarg" uses a more
+ * standard way to retrieve arguments from the variant list.
+ */
+#define QUICKTHREADS_VARGS(sp, nbytes, vargs, pt, startup, vuserf, cleanup) \
+      ((qt_t *)qt_vargs_stdarg (sp, nbytes, vargs, pt, startup, vuserf, cleanup))
+
+
+/* This macro is used by "QUICKTHREADS_ADJ(sp)" to get the stack top form the stack
+ * bottom during a single argument thread initialization.
+ * It is the space we need to allocate for a single argument thread: the stack 
+ * frame for the block routine ("qt_block" or "qt_blocki") and for "qt_start".
+ */
+#define QUICKTHREADS_STKBASE \
+	(QUICKTHREADS_BLOCKI_FRAME_SIZE+QUICKTHREADS_START_FRAME_SIZE)
+
+/* This macro is used by "QUICKTHREADS_VADJ(sp)" to get the stack top from the base
+ * of the variant argument list during a variant argument thread initialization.
+ */
+#define QUICKTHREADS_VSTKBASE	(QUICKTHREADS_BLOCKI_FRAME_SIZE+QUICKTHREADS_VSTART_LIST_BASE)
+
+/* The *index* (positive offset) of where to put each value. */
+
+#define QUICKTHREADS_ARGU_INDEX	QUICKTHREADS_ARG_INDEX(0)
+#define QUICKTHREADS_ARGT_INDEX	QUICKTHREADS_ARG_INDEX(1)
+#define QUICKTHREADS_USER_INDEX	QUICKTHREADS_ARG_INDEX(2)
+#define QUICKTHREADS_ONLY_INDEX	QUICKTHREADS_ARG_INDEX(3)
+
+
+#define QUICKTHREADS_VARGT_INDEX		QUICKTHREADS_ARG_INDEX(0)
+#define QUICKTHREADS_VSTARTUP_INDEX	QUICKTHREADS_ARG_INDEX(1)
+#define QUICKTHREADS_VUSERF_INDEX		QUICKTHREADS_ARG_INDEX(2)
+#define QUICKTHREADS_VCLEANUP_INDEX	QUICKTHREADS_ARG_INDEX(3)
+
+#endif /* ndef QUICKTHREADS_POWERPC_H */
+
diff --git a/ext/systemc/src/sysc/qt/md/powerpc_mach.s b/ext/systemc/src/sysc/qt/md/powerpc_mach.s
new file mode 100644
index 000000000..63414b05d
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/powerpc_mach.s
@@ -0,0 +1,641 @@
+/* powerpc_mach.s -- assembly support. */
+
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+
+
+ * PowerPC-Mach thread switching module.
+ * Darwin (MacOS X) assembly 
+ * 
+ * NOTICE: Syntax for register names is not the GNU one. Register are
+ * named "rx" and "fx", not "%rx" and "%fx" as usual for the GNU "as" tool.
+ * Darwin "as" tool is based on GNU "as" but follows the "official" PowerPC
+ * syntax.
+ *
+ *
+ * This software is largely based on the original PowerPC-Linux porting
+ * developed by Ken Aaker <kenaaker@silverbacksystems.com>
+ *
+ * Marco Bucci <marco.bucci@inwind.it>
+ * December 2002
+ *
+ */
+
+
+/*
+ * 
+ * PowerPC Register convections:
+ * 
+ *  r0			volatile
+ *  r1			SP
+ *  r2			system reserved
+ *  r3-r4		volatile for parameter passing and function return
+ *  r5-r10		volatile for parameter passing
+ *  r11-r12		volatile
+ *  r13-r14		non volatile registers
+ *  f0			volatile
+ *  f1			volatile for parameter passing and function return	
+ *  f2-f13		volatile for parameter passing
+ *  f14-f31		non volatile
+ * 
+ *  cr2-cr4		non volatile
+ * 
+ * 
+ * See on the heather file for more documentation.
+ *
+ *
+ * 
+ * IMPLEMENTATION NOTES
+ *
+ *
+ * 1) Condition register saving
+ * On most machines, the condition code register is caller-save.
+ * On the PPC, the condition code register is callee-save, so the
+ * thread context switch must preserve it.
+ * 
+ * 
+ * 2) Floating point registers saving
+ * On resuming a thread, floating point registers are or not restored just
+ * depending on which block routine suspended the thread (i.e. regardless
+ * whether "qt_block", "qt_blocki" or "qt_abort" is used to resume it). 
+ * This behaviour is obtained by implementing "qt_block" by means af a nested
+ * call to "qt_blocki". As a result, the blocking of a thread always goes
+ * and returns through "qt_blocki and, if a thread was blocked by "qt_block",
+ * its execution resumes from the floating point restoring code on exit
+ * of "qt_block".
+ *
+ * Thanks to David Keppel that explained me this "simple" trick.
+ *
+ *
+ * 3) C languace code debugging
+ * This software was developed and debugged using the Metrowerks
+ * Code Warrior PPC integrated assembler. It can be still used with the 
+ * Code Warrior compiler by means of the file "powerpc_mach_asm_debug.c"
+ * that include it.
+ * In order to avoid "copy and paste" bugs, and make easyer the maintaining,
+ * I made the minimal changes, so you can find some strange code as:
+ * 
+ *   #if 0
+ *   .if 0
+ *      C code here
+ *   .endif
+ *   #endif
+ *
+ * This is just to embed some C code that is needed by the Code Warrior 
+ * integrated assembler.
+ *
+ *
+ * 4) Assembly constants generation
+ * Constants used in the assembly code are generated by running 
+ * the C code in the sequel (commented). It uses the C macros declared in
+ * the C heather in order to guarantee that the C interface and the assebly
+ * code are "aligned". I avoided the use of an assebler preprocessor since
+ * they are not so standard and moreover using macro espressions makes the 
+ * assembly debugging more difficult.
+ *
+ *
+
+
+#include <iostream>
+#include "powerpc_mach.h"
+
+int main()
+{
+	using namespace std;
+	
+	int i;
+	
+	cout << ".set LR_SAVE, " << PPC_LR_SAVE << endl;
+	cout << ".set CR_SAVE, " << PPC_CR_SAVE << endl;
+	cout << ".set BLOCKI_FSIZE, " << QUICKTHREADS_BLOCKI_FRAME_SIZE << endl;
+	cout << ".set BLOCK_FSIZE, " << QUICKTHREADS_BLOCK_FRAME_SIZE << endl;
+
+	cout << endl;
+	for(i=0; i<12; i++)
+	 	cout << ".set PAR_" << i << ", " << PPC_PAR(i) << endl;
+
+	cout << endl;
+	i = 13;
+	cout << ".set GPR_SAVE_" << i << ", " << QUICKTHREADS_BLOCKI_GPR_SAVE(i) << endl;
+
+	cout << endl;
+	for(i=31; i>13; i--)
+	 	cout << ".set FPR_SAVE_" << i << ", " << QUICKTHREADS_BLOCK_FPR_SAVE(i) << endl;
+
+	cout << endl;
+	cout << ".set VARGS_BKOFF, " << QUICKTHREADS_VARGS_BKOFF << endl;
+
+	
+	cout << endl << endl << endl;
+	
+	for(i=31; i>13; i--)
+	 	cout << "\tstfd\tf" << i << ",FPR_SAVE_" << i << "(r1)" << endl;
+	 	
+	cout << endl;
+	for(i=31; i>13; i--)
+	 	cout << "\tlfd \tf" << i << ",FPR_SAVE_" << i << "(r1)" << endl;
+	 	
+	cout << endl << endl << endl;
+		
+	
+	return 0;
+}
+
+
+ *
+ *
+ *
+ */
+	
+
+#if 0
+
+	.text
+	.align 4
+	
+	.globl qt_block
+	.globl _qt_block
+	.globl qt_blocki
+	.globl _qt_blocki
+	.globl qt_abort
+	.globl _qt_abort
+	.globl qt_start
+	.globl _qt_start
+	.globl qt_vstart
+	.globl _qt_vstart
+
+
+.set LR_SAVE, 8
+.set CR_SAVE, 4
+.set BLOCKI_FSIZE, 128
+.set BLOCK_FSIZE, 192
+
+.set PAR_0, 24
+.set PAR_1, 28
+.set PAR_2, 32
+.set PAR_3, 36
+.set PAR_4, 40
+.set PAR_5, 44
+.set PAR_6, 48
+.set PAR_7, 52
+.set PAR_8, 56
+.set PAR_9, 60
+.set PAR_10, 64
+.set PAR_11, 68
+
+.set GPR_SAVE_13, 52
+
+.set FPR_SAVE_31, 184
+.set FPR_SAVE_30, 176
+.set FPR_SAVE_29, 168
+.set FPR_SAVE_28, 160
+.set FPR_SAVE_27, 152
+.set FPR_SAVE_26, 144
+.set FPR_SAVE_25, 136
+.set FPR_SAVE_24, 128
+.set FPR_SAVE_23, 120
+.set FPR_SAVE_22, 112
+.set FPR_SAVE_21, 104
+.set FPR_SAVE_20, 96
+.set FPR_SAVE_19, 88
+.set FPR_SAVE_18, 80
+.set FPR_SAVE_17, 72
+.set FPR_SAVE_16, 64
+.set FPR_SAVE_15, 56
+.set FPR_SAVE_14, 48
+
+
+/* various offsets used by "qt_varg" */
+.set P_T, PAR_0
+.set P_STARTUP, PAR_1
+.set P_USERF, PAR_2
+.set P_CLEANUP, PAR_3
+		/* the offset used to move back the linkage area to be adiacent to
+		 * the variant argument list  before  calling "userf(...) */
+.set VARGS_BKOFF, 16		/* skip "t", "startup", "userf" and "cleanup" */
+
+		/* location where "t" and "cleanup" are saved (with respect of
+		 * the stack frame base) */
+.set P_T_SAVE, -4
+.set P_CLEANUP_SAVE, -8
+
+#endif
+
+
+
+/* Block the current thread saving all integer non volatile registers and
+ * start a new thread.
+ */
+#if 0
+.if 0
+#endif
+void *qt_blocki (void *helper, void *a0, void *a1, void *newthread);
+asm void *qt_blocki (void *helper, void *a0, void *a1, void *newthread)
+{
+#if 0
+.endif
+#endif
+
+#if 0
+qt_blocki:
+_qt_blocki:
+#endif
+/* prolog code */
+	stwu	r1,-BLOCKI_FSIZE(r1)		/* allocate the stack frame */
+	mflr	r0							/* return addr in r0 */
+	mfcr	r11							/* CR in r11 */
+	stw		r0,LR_SAVE+BLOCKI_FSIZE(r1)	/* save return addr in the stack */
+	stw		r11,CR_SAVE+BLOCKI_FSIZE(r1)	/* save CR in the stack */
+	stmw	r13,GPR_SAVE_13(r1)	 		/* save non-volatile reg */
+
+/* call helper(qt_t *old, void *a0, void *a1) */
+	mtlr	r3				/* "helper" addr in the link reg */
+	mr		r3,r1			/* current thread (i.e. the SP) in arg "old" */
+	mr		r1,r6         	/* swap to the new thread (i.e. to its SP) */
+	blrl								/* jump to "helper" */
+/* the "helper" return value is returned (since r3 is not changed) */
+
+/* epilog code: return to the new thread's "qt_blocki" caller */
+	lmw     r13,GPR_SAVE_13(r1)			/* restore non-volatile reg */
+	lwz		r0,LR_SAVE+BLOCKI_FSIZE(r1)	/* recover return addr */
+	lwz		r11,CR_SAVE+BLOCKI_FSIZE(r1)	/* recover CR */
+	mtlr	r0							/* return address in the link reg */
+	mtcr	r11							/* restore CR */
+	addi    r1,r1,BLOCKI_FSIZE			/* free the stack frame */
+	blr									/* return */
+
+#if 0
+.if 0
+#endif
+}
+#if 0
+.endif
+#endif
+
+
+
+/* Abort the current thread and start a new thread.
+ */
+#if 0
+.if 0
+#endif
+void qt_abort (void *helper, void *a0, void *a1, void *newthread);
+asm void qt_abort (void *helper, void *a0, void *a1, void *newthread)
+{
+#if 0
+.endif
+#endif
+
+#if 0
+qt_abort:
+_qt_abort:
+#endif
+/* prolog code */
+/* there is no prolog. It will never come back */
+
+/* call helper(qt_t *old, void *a0, void *a1) */
+	mtlr	r3					/* "helper" addr in the link reg */
+	mr		r1,r6         		/* swap to the new thread (i.e. to its SP) */
+/* we don't need to set "old", we can pass just garbage. Actually, since r3
+ is not changed, "old" is set to "helper" (don't care) */
+	blrl								/* call "helper" */
+/* the "helper" return value is returned (since r3 is not changed) */
+
+/* epilog code: return to the new thread's "qt_blocki" caller */
+	lmw     r13,GPR_SAVE_13(r1)			/* restore non-volatile reg */
+	lwz		r0,LR_SAVE+BLOCKI_FSIZE(r1)	/* recover return addr */
+	lwz		r11,CR_SAVE+BLOCKI_FSIZE(r1)	/* recover CR */
+	mtlr	r0							/* return address in the link reg */
+	mtcr	r11							/* restore CR */
+	addi    r1,r1,BLOCKI_FSIZE			/* free the stack frame */
+	blr									/* return */
+
+#if 0
+.if 0
+#endif
+}
+#if 0
+.endif
+#endif
+
+
+
+/* Block the current thread saving all non volatile registers and start
+ * a new thread.
+ */
+#if 0
+.if 0
+#endif
+void *qt_block (void *helper, void *a0, void *a1, void *newthread);
+asm void *qt_block (void *helper, void *a0, void *a1, void *newthread)
+{
+#if 0
+.endif
+#endif
+
+# if 0
+qt_block:
+_qt_block:
+#endif
+/* prolog code */
+	stwu	r1,-BLOCK_FSIZE(r1)			/* allocate the stack frame */
+	mflr	r0							/* return addr in r0 */
+	stw		r0,LR_SAVE+BLOCK_FSIZE(r1)	/* save return addr in the stack */
+
+/* save non-volatile fp reg */
+    stfd    f31,FPR_SAVE_31(r1)
+    stfd    f30,FPR_SAVE_30(r1)
+    stfd    f29,FPR_SAVE_29(r1)
+    stfd    f28,FPR_SAVE_28(r1)
+    stfd    f27,FPR_SAVE_27(r1)
+    stfd    f26,FPR_SAVE_26(r1)
+    stfd    f25,FPR_SAVE_25(r1)
+    stfd    f24,FPR_SAVE_24(r1)
+    stfd    f23,FPR_SAVE_23(r1)
+    stfd    f22,FPR_SAVE_22(r1)
+    stfd    f21,FPR_SAVE_21(r1)
+    stfd    f20,FPR_SAVE_20(r1)
+    stfd    f19,FPR_SAVE_19(r1)
+    stfd    f18,FPR_SAVE_18(r1)
+    stfd    f17,FPR_SAVE_17(r1)
+    stfd    f16,FPR_SAVE_16(r1)
+    stfd    f15,FPR_SAVE_15(r1)
+    stfd    f14,FPR_SAVE_14(r1)
+/* block the thread */	
+	bl		qt_blocki
+/* the thread is going to be resumed */
+/* restore non-volatile fp reg */
+    lfd     f31,FPR_SAVE_31(r1)
+    lfd     f30,FPR_SAVE_30(r1)
+    lfd     f29,FPR_SAVE_29(r1)
+    lfd     f28,FPR_SAVE_28(r1)
+    lfd     f27,FPR_SAVE_27(r1)
+    lfd     f26,FPR_SAVE_26(r1)
+    lfd     f25,FPR_SAVE_25(r1)
+    lfd     f24,FPR_SAVE_24(r1)
+    lfd     f23,FPR_SAVE_23(r1)
+    lfd     f22,FPR_SAVE_22(r1)
+    lfd     f21,FPR_SAVE_21(r1)
+    lfd     f20,FPR_SAVE_20(r1)
+    lfd     f19,FPR_SAVE_19(r1)
+    lfd     f18,FPR_SAVE_18(r1)
+    lfd     f17,FPR_SAVE_17(r1)
+    lfd     f16,FPR_SAVE_16(r1)
+    lfd     f15,FPR_SAVE_15(r1)
+    lfd     f14,FPR_SAVE_14(r1)
+	
+	lwz		r0,LR_SAVE+BLOCK_FSIZE(r1)	/* recover return addr */
+	mtlr	r0							/* return address in the link reg */
+	addi    r1,r1,BLOCK_FSIZE			/* free the stack frame */
+	blr									/* return */
+
+#if 0
+.if 0
+#endif
+}
+#if 0
+.endif
+#endif
+
+	
+	
+/* Start a single argument thread using parameters preloaded in the stack
+ * during thread initialization (see comments on stack initialization in the
+ * heather file).
+ *
+ * Executes:
+ *
+ *    only(u, t, userf);
+ */
+#if 0
+.if 0
+#endif
+void qt_start(void);
+asm void qt_start(void)
+{
+#if 0
+.endif
+#endif
+
+#if 0
+qt_start:
+_qt_start:
+#endif
+        lwz     r3,PAR_0(r1)	     	/* "u" in r3 */
+        lwz     r4,PAR_1(r1)	     	/* "t" in r4 */
+        lwz     r5,PAR_2(r1)	     	/* "userf" in r5 */
+        lwz     r6,PAR_3(r1)	     	/* "only" in r6 */
+        mtlr    r6						/* "only" address in the link reg */
+/*  call only(u, t, userf) */
+        blrl                    		/* jump to "only" */
+/* error if it returns */
+        b       _qt_error
+/* dead code (some inline asm "wants" the epilog, or they genetare it) */
+        blr
+
+#if 0
+.if 0
+#endif
+}
+#if 0
+.endif
+#endif
+
+
+
+/* Start a variant argument thread using parameters preloaded in the stack
+ * during thread initialization (see comments on stack initialization in the
+ * heather file).
+ *
+ * Executes:
+ *
+ *    startup(t);
+ *    userf_return = userf(...);
+ *    cleanup(pt, userf_return);
+ *
+
+
+ ***** Stack layout on start *****
+
+
+ backchain ->           STACK BOTTOM (higher address)
+                        +==========================+
+ backchain - 4 ->       |                          | 
+                        +   LOCAL VARIABLES AREA   +
+                               ..............
+                        +                          +
+                        |                          |
+                        +--------------------------+
+                        |                          | 
+                        +      ALIGNMEBNT PAD      +
+                               ..............
+                        +       (if needed)        +
+                        |                          |
+                        +--------------------------+
+                        |                          | arg(n)
+                        +                          +
+                        |                          | 
+                        +  VARIABLE ARGUMENT LIST  +
+                               ..............
+                        +      for userf call      +
+ SP + PAR(5) ->         |                          | arg(1)
+                        +                          +
+ SP + PAR(4) ->         |                          | arg(0)
+                        +--------------------------+
+ SP + PAR(3) ->         |                          | cleanup par
+                        +                          +
+ SP + PAR(2) ->         |                          | userf par
+                        +      PARAMETER AREA      +
+ SP + PAR(1) ->         |                          | startup par
+                        +                          +
+ SP + PAR(0) ->         |                          | t par
+                        +--------------------------+
+                        |                          |
+                        +       LINKAGE AREA       +
+ SP ->                  |                          |
+                        +==========================+
+                         STACK TOP (lower address)
+
+                             Stack grows down
+                                     |
+                                     V
+
+
+
+ ***** Stack layout before call userf *****
+
+
+ backchain ->           STACK BOTTOM (higher address)
+                        +==========================+
+ backchain - 4 ->       |                          | 
+                        +   LOCAL VARIABLES AREA   +
+                               ..............
+                        +                          +
+                        |                          |
+                        +--------------------------+
+                        |                          | 
+                        +      ALIGNMEBNT PAD      +
+                               ..............
+                        +       (if needed)        +
+                        |                          |
+                        +--------------------------+
+                        |                          | arg(n)
+                        +                          +
+                        |                          | 
+                        +  VARIABLE ARGUMENT LIST  +
+                               ..............
+                        +      for userf call      +
+ SP + PAR(1) ->         |                          | arg(1)
+                        +                          +
+ SP + PAR(0) ->         |                          | arg(0)
+                        +--------------------------+
+                        |                          |
+                        +       LINKAGE AREA       +
+ SP ->                  |                          |
+                        +==========================+
+                         STACK TOP (lower address)
+
+                             Stack grows down
+                                     |
+                                     V
+
+
+ * To call "userf(...)", the argument list must be adiacent to the linkage
+ * area. Instead of copy the argument list, we move back the linkage area
+ * (actually, we just increase the SP and copy the backchain). "t" and 
+ * "cleanup" are saved in a local variable area in order to call 
+ * cleanup(pt, userf_return).
+
+*/
+		
+
+#if 0
+.if 0
+#endif
+void qt_vstart(void);
+asm void qt_vstart(void)
+{
+#if 0
+.endif
+#endif
+
+#if 0
+qt_vstart:
+_qt_vstart:
+#endif
+/* NOTICE: the callee routines could save parameter registers in the caller's 
+ * stack parameter area. We put "t" in PAR(0) in such a way, if startup(t) 
+ * will save "t", it will be saved on the same location thus not delething 
+ * any other parameter.
+ */
+
+/* since we will move back the linckage area (to make it adiacent to the 
+ * parameter list), we need to save "t" and "cleanup". We have made room for 
+ * this on the bottom of the stack frame. */
+    
+/* save parameters in the local variable area */
+	lwz		r11,0(r1)				/* get the backchain */
+ 	lwz     r3,P_T(r1)
+ 	lwz     r4,P_CLEANUP(r1)
+	stw		r3,P_T_SAVE(r11)		/* save "pt" */
+	stw		r4,P_CLEANUP_SAVE(r11)	/* save "cleanup" */
+	
+/* call startup(t) */
+    lwz     r5,P_STARTUP(r1)
+	mtlr    r5
+    blrl                    		/* call "startup" */
+
+/* call userf(...) */
+	lwz		r11,0(r1)				/* reload backchain (r11 is volatile) */			
+	lwz		r4,P_USERF(r1)			/* load "userf"  */
+    mtlr    r4						
+
+	/* first eight parameter of the variant list must be copyed in
+	 * GPR3-GPR10. There is a four places offset due to "t", "startup",
+	 * userf" and "cleanup" */
+
+	lwz		r3,PAR_4(r1)        
+	lwz		r4,PAR_5(r1)        
+	lwz		r5,PAR_6(r1)        
+	lwz		r6,PAR_7(r1)        
+	lwz		r7,PAR_8(r1)        
+	lwz		r8,PAR_9(r1)        
+	lwz		r9,PAR_10(r1)        
+	lwz		r10,PAR_11(r1)
+
+
+	/* move the linkage area to be adiacent to the argument list */
+	stw		r11,VARGS_BKOFF(r1)		/* copy backchain */
+	addi	r1,r1,VARGS_BKOFF			/* move back the stack */
+
+	blrl							/* call "userf" */        
+
+/* call qt_cleanup(void *pt, void *vuserf_return) */
+	lwz		r11,0(r1)				/* reload backchain (r11 is volatile) */			
+
+	mr		r4,r3					/* push "userf" return as 2nd parameter */
+	lwz		r3,P_T_SAVE(r11)		/* reload "pt" */
+	lwz		r5,P_CLEANUP_SAVE(r11)	/* reload "cleanup" */
+	mtlr	r5
+	blrl
+	b       _qt_error
+/* dead code (some inline asm "wanst" the epilog, or they genetare it) */
+	blr
+
+#if 0
+.if 0
+#endif
+}
+#if 0
+.endif
+#endif
+
diff --git a/ext/systemc/src/sysc/qt/md/powerpc_mach_b.s b/ext/systemc/src/sysc/qt/md/powerpc_mach_b.s
new file mode 100644
index 000000000..f0fd23fcb
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/powerpc_mach_b.s
@@ -0,0 +1,290 @@
+/* speed test for basic CPU operations  */
+
+
+/* Marco Bucci <marco.bucci@inwind.it> */
+
+/* This code was developed with the Code Warrior integrate ppc assembler.
+ * Macros are use to hide illegal constructs whether you are using a 
+ * "normal" assembler or the "C integrated" assembler.
+ */
+
+#if 0
+
+
+	.text
+	.align 4
+	
+	.globl b_call_reg
+	.globl _b_call_reg
+	.globl b_call_imm
+	.globl _b_call_imm
+	.globl b_add
+	.globl _b_add
+	.globl b_load
+	.globl _b_load
+
+.set fsize, 64
+.set lrsave, 8
+
+#else
+
+#define fsize 64
+#define lrsave 8
+
+#endif
+
+
+
+
+#if 0
+.if 0
+#endif
+asm void b_null(void)
+{
+#if 0
+.endif
+#endif
+
+#if 0
+b_null:
+#endif
+
+	blr
+
+#if 0
+.if 0
+#endif
+}
+#if 0
+.endif
+#endif
+
+
+/* actually the same as the following. How to get "b_null" address?
+ * I didnt find the right sintax or the right way.
+ * I should take the current PC, then the difference to "b_null"
+ * (making the difference beween the labels), perform the sum and go?! 
+ */  
+#if 0
+.if 0
+#endif
+asm void b_call_reg(long n)
+{
+#if 0
+.endif
+#endif
+
+#if 0
+b_call_reg:
+_b_call_reg:
+#endif
+
+	mflr	r0
+	stw		r31,-4(r1)
+	stw		r30,-8(r1)
+	stw		r0,lrsave(r1)
+	stwu	r1,-fsize(r1)
+	mr		r30,r3
+	li		r31,0
+	
+	b		L1
+L0:
+	bl		b_null
+	bl		b_null
+	bl		b_null
+	bl		b_null
+	bl		b_null
+
+	addi       r31,r31,5
+L1:
+	cmpw       r31,r30
+	blt        L0
+	
+	
+	lwz        r0,lrsave+fsize(r1)
+	mtlr       r0
+	lwz        r31,-4+fsize(r1)
+	lwz        r30,-8+fsize(r1)
+	addi       r1,r1,fsize
+	blr
+
+#if 0
+.if 0
+#endif
+}
+#if 0
+.endif
+#endif
+
+
+
+
+#if 0
+.if 0
+#endif
+asm void b_call_imm(long n)
+{
+#if 0
+.endif
+#endif
+
+#if 0
+b_call_imm:
+_b_call_imm:
+#endif
+
+	mflr	r0
+	stw		r31,-4(r1)
+	stw		r30,-8(r1)
+	stw		r0,lrsave(r1)
+	stwu	r1,-fsize(r1)
+	mr		r30,r3
+	li		r31,0
+	
+	b		L3
+L2:
+	bl		b_null
+	bl		b_null
+	bl		b_null
+	bl		b_null
+	bl		b_null
+
+	addi       r31,r31,5
+L3:
+	cmpw       r31,r30
+	blt        L2
+	
+	
+	lwz        r0,lrsave+fsize(r1)
+	mtlr       r0
+	lwz        r31,-4+fsize(r1)
+	lwz        r30,-8+fsize(r1)
+	addi       r1,r1,fsize
+	blr
+
+#if 0
+.if 0
+#endif
+}
+#if 0
+.endif
+#endif
+
+
+
+#if 0
+.if 0
+#endif
+asm void b_add(long n)
+{
+#if 0
+.endif
+#endif
+
+#if 0
+b_add:
+_b_add:
+#endif
+
+	mflr	r0
+	stw		r31,-4(r1)
+	stw		r30,-8(r1)
+	stw		r0,lrsave(r1)
+	stwu	r1,-fsize(r1)
+	mr		r30,r3
+	li		r31,0
+	
+	b		L5
+L4:
+	addi	r3,r3,5
+	addi	r4,r4,5
+	addi	r5,r5,5
+	addi	r6,r6,5
+	addi	r7,r7,5
+
+	addi	r3,r3,5
+	addi	r4,r4,5
+	addi	r5,r5,5
+	addi	r6,r6,5
+	addi	r7,r7,5
+
+	addi       r31,r31,10
+L5:
+	cmpw       r31,r30
+	blt        L4
+	
+	
+	lwz        r0,lrsave+fsize(r1)
+	mtlr       r0
+	lwz        r31,-4+fsize(r1)
+	lwz        r30,-8+fsize(r1)
+	addi       r1,r1,fsize
+	blr
+
+#if 0
+.if 0
+#endif
+}
+#if 0
+.endif
+#endif
+
+
+
+#if 0
+.if 0
+#endif
+asm void b_load(long n)
+{
+#if 0
+.endif
+#endif
+
+#if 0
+b_load:
+_b_load:
+#endif
+
+	mflr	r0
+	stw		r31,-4(r1)
+	stw		r30,-8(r1)
+	stw		r0,lrsave(r1)
+	stwu	r1,-fsize(r1)
+	mr		r30,r3
+	li		r31,0
+	
+	b		L7
+L6:
+	lwz		r3,4(r1)
+	lwz		r4,8(r1)
+	lwz		r5,12(r1)
+	lwz		r6,16(r1)
+	lwz		r7,20(r1)
+
+	lwz		r3,24(r1)
+	lwz		r4,28(r1)
+	lwz		r5,32(r1)
+	lwz		r6,36(r1)
+	lwz		r7,40(r1)
+
+
+	addi       r31,r31,10
+L7:
+	cmpw       r31,r30
+	blt        L6
+	
+	
+	lwz        r0,lrsave+fsize(r1)
+	mtlr       r0
+	lwz        r31,-4+fsize(r1)
+	lwz        r30,-8+fsize(r1)
+	addi       r1,r1,fsize
+	blr
+
+#if 0
+.if 0
+#endif
+}
+#if 0
+.endif
+#endif
diff --git a/ext/systemc/src/sysc/qt/md/powerpc_sys5.h b/ext/systemc/src/sysc/qt/md/powerpc_sys5.h
new file mode 100644
index 000000000..8c0730704
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/powerpc_sys5.h
@@ -0,0 +1,566 @@
+/*
+   + * QuickThreads -- Threads-building toolkit.
+   + * Copyright (c) 1993 by David Keppel
+   + *
+   + * Permission to use, copy, modify and distribute this software and
+   + * its documentation for any purpose and without fee is hereby
+   + * granted, provided that the above copyright notice and this notice
+   + * appear in all copies.  This software is provided as a
+   + * proof-of-concept and for demonstration purposes; there is no
+   + * representation about the suitability of this software for any
+   + * purpose.
+   + *
+
+   + * PowerPC-Sys5 thread switching module.
+   + * 
+   + * This software is largely based on the original PowerPC-Linux porting
+   + * developed by Ken Aaker <kenaaker@silverbacksystems.com>
+   + * 
+   + * Marco Bucci <marco.bucci@inwind.it>
+   + * December 2002
+   + *
+   + */
+
+
+#ifndef QUICKTHREADS_POWERPC_H
+#define QUICKTHREADS_POWERPC_H
+
+
+/*****************************************************************************
+ *
+ * DESCRIPTION
+ *
+ * This is the QuickThreads switching module implementation for PowerPC 
+ * running under System V ABI (Application Binary Interface) [2]. It was
+ * developed by porting the MacOS X version and tested under LinuxPPC.
+ *
+ * Notice that this is not the same than the PowerPC Mach  ABI used by MacOSX
+ * [1].
+ *
+ * IMPLEMENTATION NOTES
+ *
+ * 1) Porting on System V ABI
+ * Excluding the variant argument calling convention, Mach and System V ABI
+ * are enough similar and it could be possible to use some simple macro, to
+ * adapt the code for both the ABIs. Actually, the only relevant difference 
+ * is in the linkage area structure and in the position where the Link and
+ * the Condition registers are saved. As to the calling conventions, there
+ * are differences with floating points argument passing and with variant
+ * argument lists. Notice that, on Mach, the caller's stack frame allocates
+ * space to hold all arguments ([1] p.51), while on System V, the caller's
+ * stack frame allocates space to hold just the arguments that don't fit into
+ * registers ([2] p.3.18).
+ *
+ * 2) Variant argument list implementation
+ * Variant argument calling on a RISC machine is not easy to implement since
+ * parameters are passed via registers instead of via stack. In a general
+ * variant argument implementation, the caller's stack must map the whole
+ * parameter list following the rules related to the use of the GPR and FPR
+ * parameter registers and the stack alignment ([2] p.3-21). 
+ * This implementation is quite simple and not general. It works under the
+ * hypothesis that arguments are 4-bytes aligned integers.
+ *
+ * 3) This heather file organisation
+ * I preferred to not make confusion between macros that are needed (i.e.
+ * directly used) by QuickThreads and internal "implementation" macros. You
+ * will find QuickThreds macros in the end of this header. Sometime they just
+ * refer to an analogous "internal" macro. On the top, there are the macros
+ * that I used to make more clean (I hope) the implementation. I could include
+ * some system heather (as to stack layout definitions, prologs and epilogs,
+ * etc.), but I preferred to have a self-contained heather in order to make
+ * all more clear for mantaining and for possible porting on another ABI.
+ *
+ *
+ * REFERENCES
+ *
+ * [1] - Mach-O Runtime Architecture
+ *       Runtime Concepts and Conventions for Mac OS X Programs
+ *       Preliminary July 2002
+ *
+ * [2] - SYSTEM V APPLICATION BINARY INTERFACE
+ *       PowerPC Processor Supplement
+ *       September 1995
+ *
+
+ *****************************************************************************/
+
+/*****************************************************************************
+ *
+ *  PowerPC System V Stack frame (see [2])
+ *  
+  
+                      ................
+                +                          +
+                |                          | 
+                +--------------------------+
+                |                          | Caller's LR
+                +  CALLER'S LINKAGE AREA   +
+ backchain ->   |                          | Caller's backchain
+                +==========================+
+                |                          | FPR31
+                +      FPR SAVE AREA       +
+                       ..............
+                +                          +
+                |                          | FPRn
+                +--------------------------+
+                |                          | GPR31
+                +      GPR SAVE AREA       +
+                       ..............
+                +                          +
+                |                          | GPRn
+                +--------------------------+
+                |                          | 
+                +      ALIGNMEBNT PAD      +
+                       ..............
+                +       (if needed)        +
+                |                          |
+                +--------------------------+
+                |         CR SAVE          |
+                +--------------------------+
+                |                          | 
+                +   LOCAL VARIABLES AREA   +
+                       ..............
+                +                          +
+                |                          |
+                +--------------------------+
+                |                          | PAR(n-7)
+                +                          +
+                |                          | 
+                +      PARAMETER AREA      +
+                       ..............
+                +      for FUTURE call     +
+                |                          | PAR(9)
+                +                          +
+ SP + 8 ->      |                          | PAR(8)
+                +--------------------------+
+ SP + 4 ->      |                          | LR callee-save for FUTURE call
+                +       LINKAGE AREA       +
+ SP ->          |                          | backchain
+                +==========================+
+                STACK TOP (lower address)
+  
+                     Stack grows down
+                             |
+                             V
+ 
+
+ * NOTE:
+ *
+ * 1) In this figure parameter are supposed to be integer 4-bytes aligned and
+ * are numbered 0, 1, 2,... n.
+ *
+ * 2) Parameter are allocated in the CALLER's parameter area. This area must
+ * be large enough to hold all parameters that cannot fit in registers (no 
+ * more parameter registers are available);
+ *
+ * 3) The callee saves LR in the caller's linkage area. CR as all other
+ * callee's state are saved in its own stack frame.
+ *
+ 
+ *****************************************************************************/ 
+
+
+/*****************************************************************************
+ * 
+ * Stack initialization for a single argument thread
+ *
+
+
+ top + QUICKTHREADS_STKBASE ->           STACK BOTTOM (higher address)
+                               +==========================+
+                               |                          |
+                               +                          +
+                                     ..............
+                               +                          +
+                               |                          |
+                               +--------------------------+
+ top + QUICKTHREADS_ONLY_INDEX * 4 ->    | only param               | PAR(3)
+                               +                          +
+ top + QUICKTHREADS_USER_INDEX * 4 ->    | userf param              | PAR(2)
+                               +                          +
+ top + QUICKTHREADS_ARGT_INDEX * 4 ->    | t param                  | PAR(1)
+                               +                          +
+ top + QUICKTHREADS_ARGU_INDEX * 4 ->    | u param                  | PAR(0)
+                               +--------------------------+
+ top + QUICKTHREADS_RETURN_INDEX * 4 ->  | qt_start                 | LR save
+                               +                          +
+ top + QUICKTHREADS_BLOCKI_FRAME_SIZE -> | top + QUICKTHREADS_STKBASE         | backchain                     
+                               +==========================+
+                               |                          |
+                               +                          +
+                                     ..............
+                               +                          +
+                               |                          |
+                               +--------------------------+
+                               |                          | 
+                               +                          +
+ top ->                        |top + QUICKTHREADS_BLOCKI_FRAME_SIZE| backchain
+                               +==========================+
+                               STACK TOP (lower address)
+  
+                                    Stack grows down
+                                           |
+                                           V
+
+ *****************************************************************************
+ *
+ * Stack initialization for a variant argument thread
+ *
+
+ bottom ->                     STACK BOTTOM (higher address)
+                               +==========================+
+                               |                          |
+                               +                          +
+                                     ..............
+                               +                          +
+ top + QUICKTHREADS_VSTKBASE ->          | arg(0)                   | PAR(4)
+                               +--------------------------+
+ top + QUICKTHREADS_CLEANUP_INDEX * 4 -> | cleanup param            | PAR(3)
+                               +                          +
+ top + QUICKTHREADS_USER_INDEX * 4 ->    | userf param              | PAR(2)  
+                               +                          +
+ top + QUICKTHREADS_VSTARTUP_INDEX * 4 ->| startup param            | PAR(1)
+                               +                          +
+ top + QUICKTHREADS_ARGT_INDEX * 4 ->    | t param                  | PAR(0)
+                               +--------------------------+
+ top + QUICKTHREADS_RETURN_INDEX * 4 ->  | qt_start                 | LR save
+                               +                          +
+ top + QUICKTHREADS_BLOCKI_FRAME_SIZE -> | top + QUICKTHREADS_STKBASE         | backchain                     
+                               +==========================+
+                               |                          |
+                               +                          +
+                                     ..............
+                               +                          +
+                               |                          |
+                               +--------------------------+
+                               |                          | 
+                               +                          +
+ top ->                        |top + QUICKTHREADS_BLOCKI_FRAME_SIZE| backchain
+                               +==========================+
+                               STACK TOP (lower address)
+  
+                                    Stack grows down
+                                          |
+                                          V
+
+* NOTE:
+*
+* Parameters are passed to "qt_start" or to "qt_vstart" putting them into
+* the stack frames of "qt_start" or "qt_vstart" themselves. This not a
+* conventional parameter passing because parameters should be put into the
+* caller's stack, not into the callee's one. Actually  we must consider
+* that as a preload of the parameter area that "qt_start" or "qt_vstart"
+* will use for their own calls.
+*  Be aware of the fact that, during a call, the caller's parameter area is,
+* in a certain sense, volatile. In facts, the callee can save parameter
+* registers on the caller's parameter area.
+*
+ *****************************************************************************/ 
+
+
+/*****************************************************************************
+ 
+   Define PowerPC System V related macros
+ 
+ *****************************************************************************/ 
+
+
+
+typedef unsigned long PPC_W;
+
+/* Stack pointer must always be a multiple of 16 */
+#define	PPC_STACK_INCR	16		
+#define	PPC_ROUND_STACK(length)	\
+	(((length)+PPC_STACK_INCR-1) & ~(PPC_STACK_INCR-1))
+
+
+#define PPC_LINKAGE_AREA 8					
+#define PPC_LR_SAVE 4
+
+#define PPC_PARAM_AREA(n) (4*(n))
+
+#define PPC_GPR_SAVE_AREA (4*19)		/* GPR13-GPR31 must be saved */
+#define PPC_FPR_SAVE_AREA (8*18)		/* FPR14-FPR31 must be saved */
+
+/* Define parameter offset on the stack.
+ * NOTICE: Parameters are numbered 0, 1, ..., n. 
+*/
+#define PPC_PAR(i) (PPC_LINKAGE_AREA+(i)*4)
+
+/*****************************************************************************
+ 
+   Define stack frames
+ 
+ *****************************************************************************/ 
+
+
+/* Define the "qt_blocki" and "qt_abort" stack frame. We use the same stack
+ * frame for both. 
+ *
+
+ top + S ->  
+                        +==========================+
+ top + S - 4 ->         |                          | GPR31 
+                        +      GPR SAVE AREA       +
+                               ..............
+                        +                          +
+ top + S - 19 * 4 ->    |                          | GPR13
+                        +--------------------------+
+                        |                          | 
+                        +      ALIGNMEBNT PAD      +
+                               ..............
+                        +       (if needed)        +
+                        |                          |
+                        +--------------------------+
+ top + 8 ->             |         CR SAVE          |
+                        +--------------------------+
+                        |                          |
+                        +       LINKAGE AREA       +
+ top ->                 |                          |
+                        +==========================+
+ */
+
+#define QUICKTHREADS_BLOCKI_FRAME_SIZE \
+	PPC_ROUND_STACK(PPC_LINKAGE_AREA+4+PPC_GPR_SAVE_AREA)
+	
+#define QUICKTHREADS_BLOCKI_CR_SAVE 8
+
+/* Offset to the base of the GPR save area. Save from GPR13 to GPR31
+ * increasing address. 
+ */
+#define QUICKTHREADS_BLOCKI_GPR_SAVE(i) (QUICKTHREADS_BLOCKI_FRAME_SIZE-4+(i-31)*4)
+
+
+
+/* Define the "qt_block" stack frame. Notice that since "qt_black" calls
+ * "qt_blocki", GPR registers are saved into "qt_blocki" stack frame.
+ *
+
+ top + S ->  
+                        +==========================+
+ top + S - 8 ->         |                          | FPR31 
+                        +      FPR SAVE AREA       +
+                               ..............
+                        +                          +
+ top + S - 18 * 8 ->    |                          | FPR14
+                        +--------------------------+
+                        |                          | 
+                        +      ALIGNMEBNT PAD      +
+                               ..............
+                        +       (if needed)        +
+                        |                          |
+                        +--------------------------+
+                        |                          |
+                        +       LINKAGE AREA       +
+ top ->                 |                          |
+                        +==========================+
+ */
+
+#define QUICKTHREADS_BLOCK_FRAME_SIZE \
+	PPC_ROUND_STACK(PPC_LINKAGE_AREA+PPC_FPR_SAVE_AREA)
+
+/* Offset to the location where registers are saved.
+ */
+#define QUICKTHREADS_BLOCK_FPR_SAVE(i) (QUICKTHREADS_BLOCK_FRAME_SIZE-8+(i-31)*8)
+
+
+/* Define the "qt_start" frame size. It consists just of the linkage area and 
+ * the parameter area. 
+ *
+
+                        +==========================+
+                        |                          | 
+                        +      ALIGNMEBNT PAD      +
+                               ..............
+                        +       (if needed)        +
+                        |                          |
+                        +--------------------------+
+                        |                          | only par
+                        +                          +
+                        |                          | userf par
+                        +      PARAMETER AREA      +
+                        |                          | t par
+                        +                          +
+ top + 8 ->             |                          | u par
+                        +--------------------------+
+                        |                          |
+                        +       LINKAGE AREA       +
+ top ->                 |                          |
+                        +==========================+
+
+ */
+#define QUICKTHREADS_START_FRAME_SIZE PPC_ROUND_STACK(PPC_LINKAGE_AREA+PPC_PARAM_AREA(4))
+
+
+
+/* Define the "qt_vstart" frame. It consists of the linkage area, the fix parameter 
+ * area, the variant argument list and a local variable area used in "qt_vstart"
+ * implementation.
+ *
+
+ backchain ->  
+                        +==========================+
+ backchain - 4 ->       |                          | 
+                        +   LOCAL VARIABLES AREA   +
+                               ..............
+                        +                          +
+                        |                          |
+                        +--------------------------+
+                        |                          | 
+                        +      ALIGNMEBNT PAD      +
+                               ..............
+                        +       (if needed)        +
+                        |                          |
+                        +--------------------------+
+                        |                          | arg(n)
+                        +                          +
+                        |                          | 
+                        +  VARIABLE ARGUMENT LIST  +
+                               ..............
+                        +      for userf call      +
+                        |                          | arg(1)
+                        +                          +
+ top + 8 + 16 ->        |                          | arg(0)
+                        +--------------------------+
+                        |                          | cleanup par
+                        +                          +
+                        |                          | userf par
+                        +      PARAMETER AREA      +
+                        |                          | startup par
+                        +                          +
+ top + 8 ->             |                          | t par
+                        +--------------------------+
+                        |                          |
+                        +       LINKAGE AREA       +
+ top ->                 |                          |
+                        +==========================+
+
+ */
+#define QUICKTHREADS_VARGS_LOCAL_AREA (4*4)		/* local variable area */
+
+/* The offset the stack will be moved back before to call "userf(...)".
+ * The linckage area must be moved to be adiacent to the part of the variant
+ * argument list that is in the stack. Notice that, since the first 8
+ * parameters are passed via registers, the offset is equal to the size of
+ * 4+8 parameters. */
+#define QUICKTHREADS_VARGS_BKOFF PPC_PARAM_AREA(4+8)
+
+#define QUICKTHREADS_VSTART_FRAME_SIZE(varbytes) \
+	PPC_ROUND_STACK(PPC_LINKAGE_AREA+QUICKTHREADS_VARGS_BKOFF+(varbytes)+ \
+		QUICKTHREADS_VARGS_LOCAL_AREA)
+
+/* Offset to the base of the varian argument list */
+#define QUICKTHREADS_VSTART_LIST_BASE (PPC_LINKAGE_AREA+PPC_PARAM_AREA(4))
+
+
+/* Notice that qt_start and qt_vstart have no parameters, actually their
+ * parameters are written in their stack frame during thread initialization
+ */
+extern void qt_start(void);
+extern void qt_vstart(void);
+
+
+
+/* Offset (in words) of the location where the block routine saves its return
+ * address (i.e. LR). SP points the top of the block routine stack and,
+ * following ppc calling conventions, the return address is saved in the
+ * previous (caller's) stack frame.
+ */
+#define QUICKTHREADS_RETURN_INDEX ((QUICKTHREADS_BLOCKI_FRAME_SIZE+PPC_LR_SAVE)/sizeof(PPC_W))
+
+/* static variable used to get the stack bottom in "VARGS" initialization */
+static void *qt_sp_bottom_save;
+
+#define QUICKTHREADS_ARG_INDEX(i) ((QUICKTHREADS_BLOCKI_FRAME_SIZE+PPC_PAR(i))/sizeof(PPC_W))
+
+/*****************************************************************************
+
+	QuickThreads needed definitions
+
+ *****************************************************************************/
+
+
+#define QUICKTHREADS_GROW_DOWN
+#define QUICKTHREADS_STKALIGN	PPC_STACK_INCR
+typedef PPC_W qt_word_t;
+
+
+/* This macro is used by "QUICKTHREADS_ARGS" to initialize a single argument thread.
+ * - set "qt_start" as the "qt_block" or "qt_blocki" return address;
+ * - set the top of the stack backchain;
+ * - set the next backchain (not needed, but just to be "clean").   
+ */
+#define QUICKTHREADS_ARGS_MD(sp) \
+	(QUICKTHREADS_SPUT (sp, QUICKTHREADS_RETURN_INDEX, qt_start), \
+	QUICKTHREADS_SPUT (sp, 0, sp+QUICKTHREADS_BLOCKI_FRAME_SIZE), \
+	QUICKTHREADS_SPUT (sp, QUICKTHREADS_BLOCKI_FRAME_SIZE/sizeof(PPC_W), \
+		sp+QUICKTHREADS_BLOCKI_FRAME_SIZE+QUICKTHREADS_START_FRAME_SIZE))
+
+
+/* This macro is used by "QUICKTHREADS_VARGS" to initialize a variant argument thread. 
+ * It returns the pointer to the top of the argument list.
+ * We also use it to get the stack bottom via a static variable. This is a bit 
+ * "dirty", it could be better to do it in "qt_vargs", but we don't want change 
+ * anything out of this file.
+ * We need the stack bottom to allocate a local variable area used by
+ * "qt_vstart". 
+ */
+#define QUICKTHREADS_VARGS_MD0(sp, varbytes) \
+  ((qt_sp_bottom_save = sp), \
+  ((qt_t *)(((char *)(sp)) - \
+		(QUICKTHREADS_VSTART_FRAME_SIZE(varbytes)-QUICKTHREADS_VSTART_LIST_BASE))))
+
+
+/* This macro is used by "QUICKTHREADS_VARGS" to initialize a variant argument thread.
+ * - set "qt_start" as the "qt_block" or "qt_blocki" return address;
+ * - set the top of the stackback chain;
+ * - set the next backchain (it points the stack botton).   
+ */
+#define QUICKTHREADS_VARGS_MD1(sp) \
+	(QUICKTHREADS_SPUT (sp, QUICKTHREADS_RETURN_INDEX, qt_vstart), \
+	QUICKTHREADS_SPUT (sp, 0, sp+QUICKTHREADS_BLOCKI_FRAME_SIZE), \
+	QUICKTHREADS_SPUT (sp, (QUICKTHREADS_BLOCKI_FRAME_SIZE)/sizeof(PPC_W), \
+		qt_sp_bottom_save))
+
+
+/* Activate "qt_vargs" as the initialization routine for the variant 
+ * argument threads
+ */ 
+#define QUICKTHREADS_VARGS_DEFAULT 
+
+/* Override "qt_vargs" with "qt_vargs_stdarg".
+ * On LinuxPPC "qt_vargs" doesn't work, "qt_vargs_stdarg" uses a more
+ * standard way to retrieve arguments from the variant list.
+ */
+#define QUICKTHREADS_VARGS(sp, nbytes, vargs, pt, startup, vuserf, cleanup) \
+      ((qt_t *)qt_vargs_stdarg (sp, nbytes, vargs, pt, startup, vuserf, cleanup))
+
+
+/* This macro is used by "QUICKTHREADS_ADJ(sp)" to get the stack top form the stack
+ * bottom during a single argument thread initialization.
+ * It is the space we need to allocate for a single argument thread: the stack 
+ * frame for the block routine ("qt_block" or "qt_blocki") and for "qt_start".
+ */
+#define QUICKTHREADS_STKBASE \
+	(QUICKTHREADS_BLOCKI_FRAME_SIZE+QUICKTHREADS_START_FRAME_SIZE)
+
+/* This macro is used by "QUICKTHREADS_VADJ(sp)" to get the stack top from the base
+ * of the variant argument list during a variant argument thread initialization.
+ */
+#define QUICKTHREADS_VSTKBASE	(QUICKTHREADS_BLOCKI_FRAME_SIZE+QUICKTHREADS_VSTART_LIST_BASE)
+
+/* The *index* (positive offset) of where to put each value. */
+
+#define QUICKTHREADS_ARGU_INDEX	QUICKTHREADS_ARG_INDEX(0)
+#define QUICKTHREADS_ARGT_INDEX	QUICKTHREADS_ARG_INDEX(1)
+#define QUICKTHREADS_USER_INDEX	QUICKTHREADS_ARG_INDEX(2)
+#define QUICKTHREADS_ONLY_INDEX	QUICKTHREADS_ARG_INDEX(3)
+
+
+#define QUICKTHREADS_VARGT_INDEX		QUICKTHREADS_ARG_INDEX(0)
+#define QUICKTHREADS_VSTARTUP_INDEX	QUICKTHREADS_ARG_INDEX(1)
+#define QUICKTHREADS_VUSERF_INDEX		QUICKTHREADS_ARG_INDEX(2)
+#define QUICKTHREADS_VCLEANUP_INDEX	QUICKTHREADS_ARG_INDEX(3)
+
+#endif /* ndef QUICKTHREADS_POWERPC_H */
+
diff --git a/ext/systemc/src/sysc/qt/md/powerpc_sys5.s b/ext/systemc/src/sysc/qt/md/powerpc_sys5.s
new file mode 100644
index 000000000..d9dc9332d
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/powerpc_sys5.s
@@ -0,0 +1,639 @@
+/* powerpc-sys5.s -- assembly support. */
+
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+
+
+ * PowerPC-System V thread switching module.
+ * 
+ * This software is largely based on the original PowerPC-Linux porting
+ * developed by Ken Aaker <kenaaker@silverbacksystems.com>
+ *
+ * Marco Bucci <marco.bucci@inwind.it>
+ * December 2002
+ *
+ */
+
+
+/*
+ * 
+ * PowerPC Register convections:
+ * 
+ *  r0			volatile
+ *  r1			SP
+ *  r2			system reserved
+ *  r3-r4		volatile for parameter passing and function return
+ *  r5-r10		volatile for parameter passing
+ *  r11-r12		volatile
+ *  r13-r14		non volatile registers
+ *  f0			volatile
+ *  f1			volatile for parameter passing and function return	
+ *  f2-f13		volatile for parameter passing
+ *  f14-f31		non volatile
+ * 
+ *  cr2-cr4		non volatile
+ * 
+ * 
+ * See on the heather file for more documentation.
+ *
+ *
+ * 
+ * IMPLEMENTATION NOTES
+ *
+ *
+ * 1) Condition register saving
+ * On most machines, the condition code register is caller-save.
+ * On the PPC, the condition code register is callee-save, so the
+ * thread context switch must preserve it.
+ * 
+ * 
+ * 2) Floating point registers saving
+ * On resuming a thread, floating point registers are or not restored just
+ * depending on which block routine suspended the thread (i.e. regardless
+ * whether "qt_block", "qt_blocki" or "qt_abort" is used to resume it). 
+ * This behaviour is obtained by implementing "qt_block" by means af a nested
+ * call to "qt_blocki". As a result, the blocking of a thread always goes
+ * and returns through "qt_blocki and, if a thread was blocked by "qt_block",
+ * its execution resumes from the floating point restoring code on exit
+ * of "qt_block".
+ *
+ * Thanks to David Keppel that explained me this "simple" trick.
+ *
+ *
+ * 3) C languace code debugging
+ * The original version of this software was developed and debugged under
+ * MacOS X using the Metrowerks Code Warrior PPC integrated assembler.
+ * It could be still used with a C inline assembler by means of a suitable
+ * file to include it.
+ * In order to avoid "copy and paste" bugs, and make easyer the maintaining,
+ * I made the minimal changes, so you can find some strange code as:
+ * 
+ *   #if 0
+ *   .if 0
+ *      C code here
+ *   .endif
+ *   #endif
+ *
+ * This is just to embed some C code that is needed by the Code Warrior 
+ * integrated assembler.
+ *
+ *
+ * 4) Assembly constants generation
+ * Constants used in the assembly code are generated by running 
+ * the C code in the sequel (commented). It uses the C macros declared in
+ * the C heather in order to guarantee that the C interface and the assebly
+ * code are "aligned". I avoided the use of an assebler preprocessor since
+ * they are not so standard and moreover using macro espressions makes the 
+ * assembly debugging more difficult.
+ *
+ *
+
+
+#include <iostream>
+#include "powerpc_sys5.h"
+
+int main()
+{
+	using namespace std;
+	
+	int i;
+	
+	cout << ".set LR_SAVE, " << PPC_LR_SAVE << endl;
+	cout << ".set BLOCKI_FSIZE, " << QUICKTHREADS_BLOCKI_FRAME_SIZE << endl;
+	cout << ".set BLOCKI_CR_SAVE, " << QUICKTHREADS_BLOCKI_CR_SAVE << endl;
+	cout << ".set BLOCK_FSIZE, " << QUICKTHREADS_BLOCK_FRAME_SIZE << endl;
+
+	cout << endl;
+	for(i=0; i<12; i++)
+	 	cout << ".set PAR_" << i << ", " << PPC_PAR(i) << endl;
+
+	cout << endl;
+	i = 13;
+	cout << ".set GPR_SAVE_" << i << ", " << QUICKTHREADS_BLOCKI_GPR_SAVE(i) << endl;
+
+	cout << endl;
+	for(i=31; i>13; i--)
+	 	cout << ".set FPR_SAVE_" << i << ", " << QUICKTHREADS_BLOCK_FPR_SAVE(i) << endl;
+
+	cout << endl;
+	cout << ".set VARGS_BKOFF, " << QUICKTHREADS_VARGS_BKOFF << endl;
+	
+	
+	cout << endl << endl << endl;
+	
+	for(i=31; i>13; i--)
+	 	cout << "\tstfd\tf" << i << ",FPR_SAVE_" << i << "(%r1)" << endl;
+	 	
+	cout << endl;
+	for(i=31; i>13; i--)
+	 	cout << "\tlfd \tf" << i << ",FPR_SAVE_" << i << "(%r1)" << endl;
+	 	
+	cout << endl << endl << endl;
+		
+	
+	return 0;
+}
+
+
+
+ *
+ *
+ *
+ */
+	
+
+#if 0
+
+	.text
+	.align 4
+	
+	.globl qt_block
+	.globl _qt_block
+	.globl qt_blocki
+	.globl _qt_blocki
+	.globl qt_abort
+	.globl _qt_abort
+	.globl qt_start
+	.globl _qt_start
+	.globl qt_vstart
+	.globl _qt_vstart
+
+
+.set LR_SAVE, 4
+.set BLOCKI_FSIZE, 96
+.set BLOCKI_CR_SAVE, 8  /* CR is saved into the callee's stack frame */
+.set BLOCK_FSIZE, 160
+
+.set PAR_0, 8
+.set PAR_1, 12
+.set PAR_2, 16
+.set PAR_3, 20
+.set PAR_4, 24
+.set PAR_5, 28
+.set PAR_6, 32
+.set PAR_7, 36
+.set PAR_8, 40
+.set PAR_9, 44
+.set PAR_10, 48
+.set PAR_11, 52
+
+.set GPR_SAVE_13, 20
+
+.set FPR_SAVE_31, 152
+.set FPR_SAVE_30, 144
+.set FPR_SAVE_29, 136
+.set FPR_SAVE_28, 128
+.set FPR_SAVE_27, 120
+.set FPR_SAVE_26, 112
+.set FPR_SAVE_25, 104
+.set FPR_SAVE_24, 96
+.set FPR_SAVE_23, 88
+.set FPR_SAVE_22, 80
+.set FPR_SAVE_21, 72
+.set FPR_SAVE_20, 64
+.set FPR_SAVE_19, 56
+.set FPR_SAVE_18, 48
+.set FPR_SAVE_17, 40
+.set FPR_SAVE_16, 32
+.set FPR_SAVE_15, 24
+.set FPR_SAVE_14, 16
+
+
+
+
+/* various offsets used by "qt_varg" */
+.set P_T, PAR_0
+.set P_STARTUP, PAR_1
+.set P_USERF, PAR_2
+.set P_CLEANUP, PAR_3
+		/* the offset used to move back the linkage area to be adiacent to
+		 * the variant argument list  before  calling "userf(...).
+		 * Skip "t", "startup", "userf", "cleanup" and first
+         * 8 parameters (since they are passed via registers) */
+.set VARGS_BKOFF, 48
+
+		/* location where "t" and "cleanup" are saved (with respect of
+		 * the stack frame base) */
+.set P_T_SAVE, -4
+.set P_CLEANUP_SAVE, -8
+
+#endif
+
+
+
+/* Block the current thread saving all integer non volatile registers and
+ * start a new thread.
+ */
+#if 0
+.if 0
+#endif
+void *qt_blocki (void *helper, void *a0, void *a1, void *newthread);
+asm void *qt_blocki (void *helper, void *a0, void *a1, void *newthread)
+{
+#if 0
+.endif
+#endif
+
+#if 0
+qt_blocki:
+_qt_blocki:
+#endif
+/* prolog code */
+	stwu	%r1,-BLOCKI_FSIZE(%r1)		/* allocate the stack frame */
+	mflr	%r0							/* return addr in r0 */
+	mfcr	%r11							/* CR in r11 */
+	stw		%r0,LR_SAVE+BLOCKI_FSIZE(%r1)	/* save return addr in the stack */
+	stw		%r11,BLOCKI_CR_SAVE(%r1)	/* save CR in the stack */
+	stmw	%r13,GPR_SAVE_13(%r1)	 		/* save non-volatile reg */
+
+/* call helper(qt_t *old, void *a0, void *a1) */
+	mtlr	%r3				/* "helper" addr in the link reg */
+	mr		%r3,%r1			/* current thread (i.e. the SP) in arg "old" */
+	mr		%r1,%r6         	/* swap to the new thread (i.e. to its SP) */
+	blrl								/* jump to "helper" */
+/* the "helper" return value is returned (since r3 is not changed) */
+
+/* epilog code: return to the new thread's "qt_blocki" caller */
+	lmw     %r13,GPR_SAVE_13(%r1)			/* restore non-volatile reg */
+	lwz		%r0,LR_SAVE+BLOCKI_FSIZE(%r1)	/* recover return addr */
+	lwz		%r11,BLOCKI_CR_SAVE(%r1)	/* recover CR */
+	mtlr	%r0							/* return address in the link reg */
+	mtcr	%r11							/* restore CR */
+	addi    %r1,%r1,BLOCKI_FSIZE			/* free the stack frame */
+	blr									/* return */
+
+#if 0
+.if 0
+#endif
+}
+#if 0
+.endif
+#endif
+
+
+
+/* Abort the current thread and start a new thread.
+ */
+#if 0
+.if 0
+#endif
+void qt_abort (void *helper, void *a0, void *a1, void *newthread);
+asm void qt_abort (void *helper, void *a0, void *a1, void *newthread)
+{
+#if 0
+.endif
+#endif
+
+#if 0
+qt_abort:
+_qt_abort:
+#endif
+/* prolog code */
+/* there is no prolog. It will never come back */
+
+/* call helper(qt_t *old, void *a0, void *a1) */
+	mtlr	%r3					/* "helper" addr in the link reg */
+	mr		%r1,%r6         		/* swap to the new thread (i.e. to its SP) */
+/* we don't need to set "old", we can pass just garbage. Actually, since r3
+ is not changed, "old" is set to "helper" (don't care) */
+	blrl								/* call "helper" */
+/* the "helper" return value is returned (since r3 is not changed) */
+
+/* epilog code: return to the new thread's "qt_blocki" caller */
+	lmw     %r13,GPR_SAVE_13(%r1)			/* restore non-volatile reg */
+	lwz		%r0,LR_SAVE+BLOCKI_FSIZE(%r1)	/* recover return addr */
+	lwz		%r11,BLOCKI_CR_SAVE(%r1)	/* recover CR */
+	mtlr	%r0							/* return address in the link reg */
+	mtcr	%r11							/* restore CR */
+	addi    %r1,%r1,BLOCKI_FSIZE			/* free the stack frame */
+	blr									/* return */
+
+#if 0
+.if 0
+#endif
+}
+#if 0
+.endif
+#endif
+
+
+
+/* Block the current thread saving all non volatile registers and start
+ * a new thread.
+ */
+#if 0
+.if 0
+#endif
+void *qt_block (void *helper, void *a0, void *a1, void *newthread);
+asm void *qt_block (void *helper, void *a0, void *a1, void *newthread)
+{
+#if 0
+.endif
+#endif
+
+# if 0
+qt_block:
+_qt_block:
+#endif
+/* prolog code */
+	stwu	%r1,-BLOCK_FSIZE(%r1)			/* allocate the stack frame */
+	mflr	%r0							/* return addr in r0 */
+	stw		%r0,LR_SAVE+BLOCK_FSIZE(%r1)	/* save return addr in the stack */
+
+/* save non-volatile fp reg */
+    stfd    %f31,FPR_SAVE_31(%r1)
+    stfd    %f30,FPR_SAVE_30(%r1)
+    stfd    %f29,FPR_SAVE_29(%r1)
+    stfd    %f28,FPR_SAVE_28(%r1)
+    stfd    %f27,FPR_SAVE_27(%r1)
+    stfd    %f26,FPR_SAVE_26(%r1)
+    stfd    %f25,FPR_SAVE_25(%r1)
+    stfd    %f24,FPR_SAVE_24(%r1)
+    stfd    %f23,FPR_SAVE_23(%r1)
+    stfd    %f22,FPR_SAVE_22(%r1)
+    stfd    %f21,FPR_SAVE_21(%r1)
+    stfd    %f20,FPR_SAVE_20(%r1)
+    stfd    %f19,FPR_SAVE_19(%r1)
+    stfd    %f18,FPR_SAVE_18(%r1)
+    stfd    %f17,FPR_SAVE_17(%r1)
+    stfd    %f16,FPR_SAVE_16(%r1)
+    stfd    %f15,FPR_SAVE_15(%r1)
+    stfd    %f14,FPR_SAVE_14(%r1)
+/* block the thread */	
+	bl		qt_blocki
+/* the thread is going to be resumed */
+/* restore non-volatile fp reg */
+    lfd     %f31,FPR_SAVE_31(%r1)
+    lfd     %f30,FPR_SAVE_30(%r1)
+    lfd     %f29,FPR_SAVE_29(%r1)
+    lfd     %f28,FPR_SAVE_28(%r1)
+    lfd     %f27,FPR_SAVE_27(%r1)
+    lfd     %f26,FPR_SAVE_26(%r1)
+    lfd     %f25,FPR_SAVE_25(%r1)
+    lfd     %f24,FPR_SAVE_24(%r1)
+    lfd     %f23,FPR_SAVE_23(%r1)
+    lfd     %f22,FPR_SAVE_22(%r1)
+    lfd     %f21,FPR_SAVE_21(%r1)
+    lfd     %f20,FPR_SAVE_20(%r1)
+    lfd     %f19,FPR_SAVE_19(%r1)
+    lfd     %f18,FPR_SAVE_18(%r1)
+    lfd     %f17,FPR_SAVE_17(%r1)
+    lfd     %f16,FPR_SAVE_16(%r1)
+    lfd     %f15,FPR_SAVE_15(%r1)
+    lfd     %f14,FPR_SAVE_14(%r1)
+	
+	lwz		%r0,LR_SAVE+BLOCK_FSIZE(%r1)	/* recover return addr */
+	mtlr	%r0							/* return address in the link reg */
+	addi    %r1,%r1,BLOCK_FSIZE			/* free the stack frame */
+	blr									/* return */
+
+#if 0
+.if 0
+#endif
+}
+#if 0
+.endif
+#endif
+
+	
+	
+/* Start a single argument thread using parameters preloaded in the stack
+ * during thread initialization (see comments on stack initialization in the
+ * heather file).
+ *
+ * Executes:
+ *
+ *    only(u, t, userf);
+ */
+#if 0
+.if 0
+#endif
+void qt_start(void);
+asm void qt_start(void)
+{
+#if 0
+.endif
+#endif
+
+#if 0
+qt_start:
+_qt_start:
+#endif
+        lwz     %r3,PAR_0(%r1)	     	/* "u" in r3 */
+        lwz     %r4,PAR_1(%r1)	     	/* "t" in r4 */
+        lwz     %r5,PAR_2(%r1)	     	/* "userf" in r5 */
+        lwz     %r6,PAR_3(%r1)	     	/* "only" in r6 */
+        mtlr    %r6						/* "only" address in the link reg */
+/*  call only(u, t, userf) */
+        blrl                    		/* jump to "only" */
+/* error if it returns */
+        b       qt_error
+/* dead code (some inline asm "wants" the epilog, or they genetare it) */
+        blr
+
+#if 0
+.if 0
+#endif
+}
+#if 0
+.endif
+#endif
+
+
+
+/* Start a variant argument thread using parameters preloaded in the stack
+ * during thread initialization (see comments on stack initialization in the
+ * heather file).
+ *
+ * Executes:
+ *
+ *    startup(t);
+ *    userf_return = userf(...);
+ *    cleanup(pt, userf_return);
+ *
+
+
+ ***** Stack layout on start *****
+
+
+ backchain ->           STACK BOTTOM (higher address)
+                        +==========================+
+ backchain - 4 ->       |                          | 
+                        +   LOCAL VARIABLES AREA   +
+                               ..............
+                        +                          +
+                        |                          |
+                        +--------------------------+
+                        |                          | 
+                        +      ALIGNMEBNT PAD      +
+                               ..............
+                        +       (if needed)        +
+                        |                          |
+                        +--------------------------+
+                        |                          | arg(n)
+                        +                          +
+                        |                          | 
+                        +  VARIABLE ARGUMENT LIST  +
+                               ..............
+                        +      for userf call      +
+ SP + PAR(5) ->         |                          | arg(1)
+                        +                          +
+ SP + PAR(4) ->         |                          | arg(0)
+                        +--------------------------+
+ SP + PAR(3) ->         |                          | cleanup par
+                        +                          +
+ SP + PAR(2) ->         |                          | userf par
+                        +      PARAMETER AREA      +
+ SP + PAR(1) ->         |                          | startup par
+                        +                          +
+ SP + PAR(0) ->         |                          | t par
+                        +--------------------------+
+                        |                          |
+                        +       LINKAGE AREA       +
+ SP ->                  |                          |
+                        +==========================+
+                         STACK TOP (lower address)
+
+                             Stack grows down
+                                     |
+                                     V
+
+
+
+ ***** Stack layout before call userf *****
+
+
+ backchain ->           STACK BOTTOM (higher address)
+                        +==========================+
+ backchain - 4 ->       |                          | 
+                        +   LOCAL VARIABLES AREA   +
+                               ..............
+                        +                          +
+                        |                          |
+                        +--------------------------+
+                        |                          | 
+                        +      ALIGNMEBNT PAD      +
+                               ..............
+                        +       (if needed)        +
+                        |                          |
+                        +--------------------------+
+                        |                          | arg(n)
+                        +                          +
+                        |                          | 
+                        +  VARIABLE ARGUMENT LIST  +
+                               ..............
+                        +      for userf call      +
+ SP + PAR(1) ->         |                          | arg(1)
+                        +                          +
+ SP + PAR(0) ->         |                          | arg(0)
+                        +--------------------------+
+                        |                          |
+                        +       LINKAGE AREA       +
+ SP ->                  |                          |
+                        +==========================+
+                         STACK TOP (lower address)
+
+                             Stack grows down
+                                     |
+                                     V
+
+
+ * To call "userf(...)", the argument list must be adiacent to the linkage
+ * area. Instead of copy the argument list, we move back the linkage area
+ * (actually, we just increase the SP and copy the backchain). "t" and 
+ * "cleanup" are saved in a local variable area in order to call 
+ * cleanup(pt, userf_return).
+
+*/
+		
+
+#if 0
+.if 0
+#endif
+void qt_vstart(void);
+asm void qt_vstart(void)
+{
+#if 0
+.endif
+#endif
+
+#if 0
+qt_vstart:
+_qt_vstart:
+#endif
+/* NOTICE: the callee routines could save parameter registers in the caller's 
+ * stack parameter area. We put "t" in PAR(0) in such a way, if startup(t) 
+ * will save "t", it will be saved on the same location thus not delething 
+ * any other parameter.
+ */
+
+/* since we will move back the linckage area (to make it adiacent to the 
+ * parameter list), we need to save "t" and "cleanup". We have made room for 
+ * this on the bottom of the stack frame. */
+    
+/* save parameters in the local variable area */
+	lwz		%r11,0(%r1)				/* get the backchain */
+ 	lwz     %r3,P_T(%r1)
+ 	lwz     %r4,P_CLEANUP(%r1)
+	stw		%r3,P_T_SAVE(%r11)		/* save "pt" */
+	stw		%r4,P_CLEANUP_SAVE(%r11)	/* save "cleanup" */
+	
+/* call startup(t) */
+    lwz     %r5,P_STARTUP(%r1)
+	mtlr    %r5
+    blrl                    		/* call "startup" */
+
+/* call userf(...) */
+	lwz		%r11,0(%r1)				/* reload backchain (r11 is volatile) */			
+	lwz		%r4,P_USERF(%r1)			/* load "userf"  */
+    mtlr    %r4						
+
+	/* first eight parameter of the variant list must be copyed in
+	 * GPR3-GPR10. There is a four places offset due to "t", "startup",
+	 * userf" and "cleanup" */
+
+	lwz		%r3,PAR_4(%r1)        
+	lwz		%r4,PAR_5(%r1)        
+	lwz		%r5,PAR_6(%r1)        
+	lwz		%r6,PAR_7(%r1)        
+	lwz		%r7,PAR_8(%r1)        
+	lwz		%r8,PAR_9(%r1)        
+	lwz		%r9,PAR_10(%r1)        
+	lwz		%r10,PAR_11(%r1)
+
+
+	/* move the linkage area to be adiacent to the argument list */
+	stw		%r11,VARGS_BKOFF(%r1)		/* copy backchain */
+	addi	%r1,%r1,VARGS_BKOFF			/* move back the stack */
+
+	blrl							/* call "userf" */        
+
+/* call qt_cleanup(void *pt, void *vuserf_return) */
+	lwz		%r11,0(%r1)				/* reload backchain (r11 is volatile) */			
+
+	mr		%r4,%r3					/* push "userf" return as 2nd parameter */
+	lwz		%r3,P_T_SAVE(%r11)		/* reload "pt" */
+	lwz		%r5,P_CLEANUP_SAVE(%r11)	/* reload "cleanup" */
+	mtlr	%r5
+	blrl
+	b       qt_error
+/* dead code (some inline asm "wants" the epilog, or they genetare it) */
+	blr
+
+#if 0
+.if 0
+#endif
+}
+#if 0
+.endif
+#endif
+
diff --git a/ext/systemc/src/sysc/qt/md/powerpc_sys5_b.s b/ext/systemc/src/sysc/qt/md/powerpc_sys5_b.s
new file mode 100644
index 000000000..e57a20e2e
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/powerpc_sys5_b.s
@@ -0,0 +1,290 @@
+/* speed test for basic CPU operations  */
+
+
+/* Marco Bucci <marco.bucci@inwind.it> */
+
+/* This code was developed with the Code Warrior integrate ppc assembler.
+ * Macros are use to hide illegal constructs whether you are using a 
+ * "normal" assembler or the "C integrated" assembler.
+ */
+
+#if 0
+
+
+	.text
+	.align 4
+	
+	.globl b_call_reg
+	.globl _b_call_reg
+	.globl b_call_imm
+	.globl _b_call_imm
+	.globl b_add
+	.globl _b_add
+	.globl b_load
+	.globl _b_load
+
+.set fsize, 64
+.set lrsave, 4
+
+#else
+
+#define fsize 64
+#define lrsave 4
+
+#endif
+
+
+
+
+#if 0
+.if 0
+#endif
+asm void b_null(void)
+{
+#if 0
+.endif
+#endif
+
+#if 0
+b_null:
+#endif
+
+	blr
+
+#if 0
+.if 0
+#endif
+}
+#if 0
+.endif
+#endif
+
+
+/* actually the same as the following. How to get "b_null" address?
+ * I didnt find the right sintax or the right way.
+ * I should take the current PC, then the difference to "b_null"
+ * (making the difference beween the labels), perform the sum and go?! 
+ */  
+#if 0
+.if 0
+#endif
+asm void b_call_reg(long n)
+{
+#if 0
+.endif
+#endif
+
+#if 0
+b_call_reg:
+_b_call_reg:
+#endif
+
+	mflr	%r0
+	stw		%r31,-4(%r1)
+	stw		%r30,-8(%r1)
+	stw		%r0,lrsave(%r1)
+	stwu	%r1,-fsize(%r1)
+	mr		%r30,%r3
+	li		%r31,0
+	
+	b		L1
+L0:
+	bl		b_null
+	bl		b_null
+	bl		b_null
+	bl		b_null
+	bl		b_null
+
+	addi       %r31,%r31,5
+L1:
+	cmpw       %r31,%r30
+	blt        L0
+	
+	
+	lwz        %r0,lrsave+fsize(%r1)
+	mtlr       %r0
+	lwz        %r31,-4+fsize(%r1)
+	lwz        %r30,-8+fsize(%r1)
+	addi       %r1,%r1,fsize
+	blr
+
+#if 0
+.if 0
+#endif
+}
+#if 0
+.endif
+#endif
+
+
+
+
+#if 0
+.if 0
+#endif
+asm void b_call_imm(long n)
+{
+#if 0
+.endif
+#endif
+
+#if 0
+b_call_imm:
+_b_call_imm:
+#endif
+
+	mflr	%r0
+	stw		%r31,-4(%r1)
+	stw		%r30,-8(%r1)
+	stw		%r0,lrsave(%r1)
+	stwu	%r1,-fsize(%r1)
+	mr		%r30,%r3
+	li		%r31,0
+	
+	b		L3
+L2:
+	bl		b_null
+	bl		b_null
+	bl		b_null
+	bl		b_null
+	bl		b_null
+
+	addi       %r31,%r31,5
+L3:
+	cmpw       %r31,%r30
+	blt        L2
+	
+	
+	lwz        %r0,lrsave+fsize(%r1)
+	mtlr       %r0
+	lwz        %r31,-4+fsize(%r1)
+	lwz        %r30,-8+fsize(%r1)
+	addi       %r1,%r1,fsize
+	blr
+
+#if 0
+.if 0
+#endif
+}
+#if 0
+.endif
+#endif
+
+
+
+#if 0
+.if 0
+#endif
+asm void b_add(long n)
+{
+#if 0
+.endif
+#endif
+
+#if 0
+b_add:
+_b_add:
+#endif
+
+	mflr	%r0
+	stw		%r31,-4(%r1)
+	stw		%r30,-8(%r1)
+	stw		%r0,lrsave(%r1)
+	stwu	%r1,-fsize(%r1)
+	mr		%r30,%r3
+	li		%r31,0
+	
+	b		L5
+L4:
+	addi	%r3,%r3,5
+	addi	%r4,%r4,5
+	addi	%r5,%r5,5
+	addi	%r6,%r6,5
+	addi	%r7,%r7,5
+
+	addi	%r3,%r3,5
+	addi	%r4,%r4,5
+	addi	%r5,%r5,5
+	addi	%r6,%r6,5
+	addi	%r7,%r7,5
+
+	addi       %r31,%r31,10
+L5:
+	cmpw       %r31,%r30
+	blt        L4
+	
+	
+	lwz        %r0,lrsave+fsize(%r1)
+	mtlr       %r0
+	lwz        %r31,-4+fsize(%r1)
+	lwz        %r30,-8+fsize(%r1)
+	addi       %r1,%r1,fsize
+	blr
+
+#if 0
+.if 0
+#endif
+}
+#if 0
+.endif
+#endif
+
+
+
+#if 0
+.if 0
+#endif
+asm void b_load(long n)
+{
+#if 0
+.endif
+#endif
+
+#if 0
+b_load:
+_b_load:
+#endif
+
+	mflr	%r0
+	stw		%r31,-4(%r1)
+	stw		%r30,-8(%r1)
+	stw		%r0,lrsave(%r1)
+	stwu	%r1,-fsize(%r1)
+	mr		%r30,%r3
+	li		%r31,0
+	
+	b		L7
+L6:
+	lwz		%r3,4(%r1)
+	lwz		%r4,8(%r1)
+	lwz		%r5,12(%r1)
+	lwz		%r6,16(%r1)
+	lwz		%r7,20(%r1)
+
+	lwz		%r3,24(%r1)
+	lwz		%r4,28(%r1)
+	lwz		%r5,32(%r1)
+	lwz		%r6,36(%r1)
+	lwz		%r7,40(%r1)
+
+
+	addi       %r31,%r31,10
+L7:
+	cmpw       %r31,%r30
+	blt        L6
+	
+	
+	lwz        %r0,lrsave+fsize(%r1)
+	mtlr       %r0
+	lwz        %r31,-4+fsize(%r1)
+	lwz        %r30,-8+fsize(%r1)
+	addi       %r1,%r1,fsize
+	blr
+
+#if 0
+.if 0
+#endif
+}
+#if 0
+.endif
+#endif
diff --git a/ext/systemc/src/sysc/qt/md/pthreads.Makefile b/ext/systemc/src/sysc/qt/md/pthreads.Makefile
new file mode 100644
index 000000000..f722fbe19
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/pthreads.Makefile
@@ -0,0 +1,108 @@
+# Generated automatically from Makefile.in by configure.
+# Makefile.in generated automatically by automake 1.4 from Makefile.am
+
+# Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+
+SHELL = /bin/sh
+
+all: 
+
+mostlyclean-noinstLIBRARIES:
+
+clean-noinstLIBRARIES:
+
+distclean-noinstLIBRARIES:
+
+maintainer-clean-noinstLIBRARIES:
+
+mostlyclean-compile:
+
+clean-compile:
+
+distclean-compile:
+
+maintainer-clean-compile:
+
+tags: 
+
+ID: 
+
+TAGS:
+
+mostlyclean-tags:
+
+clean-tags:
+
+distclean-tags:
+
+maintainer-clean-tags:
+
+distdir: 
+	
+info-am:
+info: 
+dvi-am:
+dvi: dvi-am
+check-am: all-am
+check: check-am
+installcheck-am:
+installcheck: installcheck-am
+install-exec-am:
+install-exec: install-exec-am
+
+install-data-am: install-data-local
+install-data: install-data-am
+
+install-am: all-am
+install: install-am
+uninstall-am: uninstall-local
+uninstall: uninstall-am
+all-am: 
+all-redirect: 
+install-strip:
+installdirs:
+
+
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+
+maintainer-clean-generic:
+mostlyclean-am: 
+
+mostlyclean:
+
+clean-am:
+
+clean:
+
+distclean-am:
+
+distclean:
+
+maintainer-clean-am:
+
+maintainer-clean:
+
+.PHONY:
+
+
+configuration:
+
+clean:
+
+install-data-local:
+
+uninstall-local:
+
diff --git a/ext/systemc/src/sysc/qt/md/solaris.README b/ext/systemc/src/sysc/qt/md/solaris.README
new file mode 100644
index 000000000..04f855c44
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/solaris.README
@@ -0,0 +1,19 @@
+Solaris 2.x is like System V (maybe it *is* System V?) and is different
+from older versions in that it uses no leading underscore for variable
+and function names.  That is, the old convention was:
+
+	foo(){}
+
+got compiled as
+
+		.globl	_foo
+	_foo:
+
+and is now compiled as
+
+		.globl	foo
+	foo:
+
+The `config' script should fix up the older (leading underscore) versions
+of the machine-dependent files to use the newer (no leading underscore)
+calling conventions.
diff --git a/ext/systemc/src/sysc/qt/md/sparc.h b/ext/systemc/src/sysc/qt/md/sparc.h
new file mode 100644
index 000000000..edaf5325e
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/sparc.h
@@ -0,0 +1,140 @@
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+#ifndef QUICKTHREADS_SPARC_H
+#define QUICKTHREADS_SPARC_H
+
+typedef unsigned long qt_word_t;
+
+/* Stack layout on the sparc:
+
+   non-varargs:
+
+   +---
+   | <blank space for alignment>
+   | %o7 == return address -> qt_start
+   | %i7
+   | %i6 == frame pointer -> 0 (NULL-terminated stack frame chain)
+   | %i5 -> only
+   | %i4 -> userf
+   | %i3
+   | %i2 -> pt
+   | %i1 -> pu
+   | %i0
+   | %l7
+   | %l6
+   | %l5
+   | %l4
+   | %l3
+   | %l2
+   | %l1
+   | %l0	<--- qt_t.sp
+   +---
+
+   varargs:
+
+   |  :
+   |  :
+   | argument list
+   | one-word aggregate return pointer
+   +---
+   | <blank space for alignment>
+   | %o7 == return address -> qt_vstart
+   | %i7
+   | %i6 == frame pointer -> 0 (NULL-terminated stack frame chain)
+   | %i5 -> startup
+   | %i4 -> userf
+   | %i3 -> cleanup
+   | %i2 -> pt
+   | %i1
+   | %i0
+   | %l7
+   | %l6
+   | %l5
+   | %l4
+   | %l3
+   | %l2
+   | %l1
+   | %l0	<--- qt_t.sp
+   +---
+
+   */
+
+
+/* What to do to start a thread running. */
+extern void qt_start (void);
+extern void qt_vstart (void);
+
+
+/* Hold 17 saved registers + 1 word for alignment. */
+#define QUICKTHREADS_STKBASE	(18 * 4)
+#define QUICKTHREADS_VSTKBASE	QUICKTHREADS_STKBASE
+
+
+/* Stack must be doubleword aligned. */
+#define QUICKTHREADS_STKALIGN	(8)	/* Doubleword aligned. */
+
+#define QUICKTHREADS_ONLY_INDEX	(QUICKTHREADS_I5)
+#define QUICKTHREADS_USER_INDEX	(QUICKTHREADS_I4)
+#define QUICKTHREADS_ARGT_INDEX	(QUICKTHREADS_I2)
+#define QUICKTHREADS_ARGU_INDEX	(QUICKTHREADS_I1)
+
+#define QUICKTHREADS_VSTARTUP_INDEX	(QUICKTHREADS_I5)
+#define QUICKTHREADS_VUSERF_INDEX		(QUICKTHREADS_I4)
+#define QUICKTHREADS_VCLEANUP_INDEX	(QUICKTHREADS_I3)
+#define QUICKTHREADS_VARGT_INDEX		(QUICKTHREADS_I2)
+
+#define QUICKTHREADS_O7	(16)
+#define QUICKTHREADS_I6	(14)
+#define QUICKTHREADS_I5	(13)
+#define QUICKTHREADS_I4	(12)
+#define QUICKTHREADS_I3	(11)
+#define QUICKTHREADS_I2	(10)
+#define QUICKTHREADS_I1	( 9)
+
+
+/* The thread will ``return'' to the `qt_start' routine to get things
+   going.  The normal return sequence takes us to QUICKTHREADS_O7+8, so we
+   pre-subtract 8.  The frame pointer chain is 0-terminated to prevent
+   the trap handler from chasing off in to random memory when flushing
+   stack windows. */
+
+#define QUICKTHREADS_ARGS_MD(top) \
+    (QUICKTHREADS_SPUT ((top), QUICKTHREADS_O7, ((void *)(((int)qt_start)-8))), \
+     QUICKTHREADS_SPUT ((top), QUICKTHREADS_I6, 0))
+
+
+/* The varargs startup routine always reads 6 words of arguments
+   (6 argument registers) from the stack, offset by one word to
+   allow for an aggregate return area  pointer.  If the varargs
+   routine actually pushed fewer words than that, qt_vstart could read
+   off the top of the stack.  To prevent errors, we always allocate 8
+   words.  The space is often just wasted. */
+
+#define QUICKTHREADS_VARGS_MD0(sp, vabytes) \
+  ((qt_t *)(((char *)(sp)) - 8*4 - QUICKTHREADS_STKROUNDUP(vabytes)))
+
+#define QUICKTHREADS_VARGS_MD1(sp) \
+  (QUICKTHREADS_SPUT (sp, QUICKTHREADS_O7, ((void *)(((int)qt_vstart)-8))))
+
+/* The SPARC has wierdo calling conventions which stores a hidden
+   parameter for returning aggregate values, so the rest of the
+   parameters are shoved up the stack by one place. */
+#define QUICKTHREADS_VARGS_ADJUST(sp)	(((char *)sp)+4)
+
+#define QUICKTHREADS_VARGS_DEFAULT
+
+
+#define QUICKTHREADS_GROW_DOWN
+
+#endif /* ndef QUICKTHREADS_SPARC_H */
diff --git a/ext/systemc/src/sysc/qt/md/sparc.s b/ext/systemc/src/sysc/qt/md/sparc.s
new file mode 100644
index 000000000..d61236b54
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/sparc.s
@@ -0,0 +1,142 @@
+/* sparc.s -- assembly support for the `qt' thread building kit. */
+
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+/* #include <machine/trap.h> */
+
+	.text
+	.align 4
+	.global _qt_blocki
+	.global _qt_block
+	.global _qt_abort
+	.global _qt_start
+	.global _qt_vstart
+
+/* Register assignment:
+// %o0:	incoming `helper' function to call after cswap
+//	also used as outgoing sp of old thread (qt_t *)
+// %o1, %o2:
+//	parameters to `helper' function called after cswap
+// %o3:	sp of new thread
+// %o5: tmp used to save old thread sp, while using %o0
+//	to call `helper' f() after cswap.
+//
+//
+// Aborting a thread is easy if there are no cached register window
+// frames: just switch to the new stack and away we go.  If there are
+// cached register window frames they must all be written back to the
+// old stack before we move to the new stack.  If we fail to do the
+// writeback then the old stack memory can be written with register
+// window contents e.g., after the stack memory has been freed and
+// reused.  
+//
+// If you don't believe this, try setting the frame pointer to zero
+// once we're on the new stack.  This will not affect correctnes
+// otherwise because the frame pointer will eventually get reloaded w/
+// the new thread's frame pointer.  But it will be zero briefly before
+// the reload.  You will eventually (100,000 cswaps later on a small
+// SPARC machine that I tried) get an illegal instruction trap  from
+// the kernel trying to flush a cached window to location 0x0.
+//
+// Solution: flush windows before switching stacks, which invalidates
+// all the other register windows.  We could do the trap
+// conditionally: if we're in the lowest frame of a thread, the fp is
+// zero already so we know there's nothing cached.  But we expect most
+// aborts will be done from a first function that does a `save', so we
+// will rarely save anything and always pay the cost of testing to see
+// if we should flush.
+//
+// All floating-point registers are caller-save, so this routine
+// doesn't need to do anything to save and restore them.
+//
+// `qt_block' and `qt_blocki' return the same value as the value
+// returned by the helper function.  We get this ``for free''
+// since we don't touch the return value register between the
+// return from the helper function and return from qt_block{,i}.
+*/
+
+_qt_block:
+_qt_blocki:
+	sub %sp, 8, %sp		/* Allocate save area for return pc. */
+	st %o7, [%sp+64]	/* Save return pc. */
+_qt_abort:
+	ta 0x03			/* Save locals and ins. */
+	mov %sp, %o5		/* Remember old sp w/o chng ins/locals. */
+	sub %o3, 96, %sp	/* Allocate kwsa, switch stacks. */
+	call %o0, 0		/* Call `helper' routine. */
+	mov %o5, %o0		/* Pass old thread to qt_after_t() */
+				/* .. along w/ args in %o1 & %o2. */
+
+	/* Restore callee-save regs.  The kwsa
+	// is on this stack, so offset all
+	// loads by sizeof(kwsa), 64 bytes.
+	*/
+	ldd [%sp+ 0+96], %l0
+	ldd [%sp+ 8+96], %l2
+	ldd [%sp+16+96], %l4
+	ldd [%sp+24+96], %l6
+	ldd [%sp+32+96], %i0
+	ldd [%sp+40+96], %i2
+	ldd [%sp+48+96], %i4
+	ldd [%sp+56+96], %i6
+	ld [%sp+64+96], %o7	/* Restore return pc. */
+
+	retl			/* Return to address in %o7. */
+	add %sp, 104, %sp	/* Deallocate kwsa, ret pc area. */
+
+
+/* The function calling conventions say there has to be a 1-word area
+// in the caller's stack to hold a pointer to space for aggregate
+// return values.  It also says there should be a 6-word area to hold
+// %o0..%o5 if the callee wants to save them (why?  I don't know...)
+// Round up to 8 words to maintain alignment.
+//
+// Parameter values were stored in callee-save regs and are moved to
+// the parameter registers.
+*/
+_qt_start:
+	mov %i1, %o0		/* `pu': Set up args to `only'. */
+	mov %i2, %o1		/* `pt'. */
+	mov %i4, %o2		/* `userf'. */
+	call %i5, 0		/* Call client function. */
+	sub %sp, 32, %sp	/* Allocate 6-word callee space. */
+
+	call _qt_error, 0	/* `only' erroniously returned. */
+	nop
+
+
+/* Same comments as `_qt_start' about allocating rounded-up 7-word
+// save areas. */
+
+_qt_vstart:
+	sub %sp, 32, %sp	/* Allocate 7-word callee space. */
+	call %i5, 0		/* call `startup'. */
+	mov %i2, %o0		/* .. with argument `pt'. */
+
+	add %sp, 32, %sp	/* Use 7-word space in varargs. */
+	ld [%sp+ 4+64], %o0	/* Load arg0 ... */
+	ld [%sp+ 8+64], %o1
+	ld [%sp+12+64], %o2
+	ld [%sp+16+64], %o3
+	ld [%sp+20+64], %o4
+	call %i4, 0		/* Call `userf'. */
+	ld [%sp+24+64], %o5
+
+				/* Use 6-word space in varargs. */
+	mov %o0, %o1		/* Pass return value from userf */
+	call %i3, 0		/* .. when call `cleanup. */
+	mov %i2, %o0		/* .. along with argument `pt'. */
+
+	call _qt_error, 0	/* `cleanup' erroniously returned. */
+	nop
diff --git a/ext/systemc/src/sysc/qt/md/sparc_b.s b/ext/systemc/src/sysc/qt/md/sparc_b.s
new file mode 100644
index 000000000..cd26672d7
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/sparc_b.s
@@ -0,0 +1,106 @@
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+	.globl _b_call_reg
+	.globl _b_call_imm
+	.globl _b_add
+	.globl _b_load
+
+_b_null:
+	retl
+	nop
+
+_b_call_reg:
+	sethi %hi(_b_null),%o4
+	or %o4,%lo(_b_null),%o4
+	add %o7,%g0, %o3
+L0:
+	call %o4
+	nop
+	call %o4
+	nop
+	call %o4
+	nop
+	call %o4
+	nop
+	call %o4
+	nop
+
+	subcc %o0,1,%o0
+	bg L0
+	nop
+	add %o3,%g0, %o7
+	retl
+	nop
+
+_b_call_imm:
+	sethi %hi(_b_null),%o4
+	or %o4,%lo(_b_null),%o4
+	add %o7,%g0, %o3
+L1:
+	call _b_null
+	call _b_null
+	call _b_null
+	call _b_null
+	call _b_null
+
+	subcc %o0,1,%o0
+	bg L0
+	nop
+	add %o3,%g0, %o7
+	retl
+	nop
+
+
+_b_add:
+	add %o0,%g0,%o1
+	add %o0,%g0,%o2
+	add %o0,%g0,%o3
+	add %o0,%g0,%o4
+L2:
+	sub %o0,5,%o0
+	sub %o1,5,%o1
+	sub %o2,5,%o2
+	sub %o3,5,%o3
+	sub %o4,5,%o4
+
+	subcc %o0,5,%o0
+	sub %o1,5,%o1
+	sub %o2,5,%o2
+	sub %o3,5,%o3
+	sub %o4,5,%o4
+
+	bg L2
+	nop
+	retl
+	nop
+
+
+_b_load:
+	ld [%sp+ 0], %g0
+L3:
+	ld [%sp+ 4],%g0
+	ld [%sp+ 8],%g0
+	ld [%sp+12],%g0
+	ld [%sp+16],%g0
+	ld [%sp+20],%g0
+	ld [%sp+24],%g0
+	ld [%sp+28],%g0
+	ld [%sp+32],%g0
+	ld [%sp+36],%g0
+
+	subcc %o0,10,%o0
+	bg L3
+	ld [%sp+ 0],%g0
+	retl
+	nop
diff --git a/ext/systemc/src/sysc/qt/md/vax.h b/ext/systemc/src/sysc/qt/md/vax.h
new file mode 100644
index 000000000..1948c6fbd
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/vax.h
@@ -0,0 +1,130 @@
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+#ifndef QUICKTHREADS_VAX_H
+#define QUICKTHREADS_VAX_H
+
+typedef unsigned long qt_word_t;
+
+/* Thread's initial stack layout on the VAX:
+
+   non-varargs:
+
+   +---
+   | arg[2]	=== `userf' on startup
+   | arg[1]	=== `pt' on startup
+   | arg[0]	=== `pu' on startup
+   | ...	=== `only' on startup.
+   +---
+   | ret pc	=== `qt_start' on startup
+   | fp		=== 0 on startup
+   | ap		=== 0 on startup
+   | <mask>
+   | 0 (handler)			<--- qt_t.sp
+   +---
+
+   When a non-varargs thread is started, it ``returns'' to the start
+   routine, which calls the client's `only' function.
+
+   The varargs case is clearly bad code.  The various values should be
+   stored in a save area and snarfed in to callee-save registers on
+   startup.  However, it's too painful to figure out the register
+   mask (right now), so do it the slow way.
+
+   +---
+   | arg[n-1]
+   | ..
+   | arg[0]
+   | nargs
+   +---
+   |		=== `cleanup'
+   |		=== `vuserf'
+   |		=== `startup'
+   |		=== `pt'
+   +---
+   | ret pc	=== `qt_start' on startup
+   | fp		=== 0 on startup
+   | ap		=== 0 on startup
+   | <mask>
+   | 0 (handler)			<--- qt_t.sp
+   +---
+
+   When a varargs thread is started, it ``returns'' to the `qt_vstart'
+   startup code.  The startup code pops all the extra arguments, then
+   calls the appropriate functions. */
+
+
+/* What to do to start a thread running. */
+extern void qt_start (void);
+extern void qt_vstart (void);
+
+
+/* Initial call frame for non-varargs and varargs cases. */
+#define QUICKTHREADS_STKBASE	(10 * 4)
+#define QUICKTHREADS_VSTKBASE	(9 * 4)
+
+
+/* Stack "must be" 4-byte aligned.  (Actually, no, but it's
+   easiest and probably fastest to do so.) */
+
+#define QUICKTHREADS_STKALIGN	(4)
+
+
+/* Where to place various arguments. */
+#define QUICKTHREADS_ONLY_INDEX	(5)
+#define QUICKTHREADS_USER_INDEX	(8)
+#define QUICKTHREADS_ARGT_INDEX	(7)
+#define QUICKTHREADS_ARGU_INDEX	(6)
+
+#define QUICKTHREADS_VSTARTUP_INDEX	(6)
+#define QUICKTHREADS_VUSERF_INDEX		(7)
+#define QUICKTHREADS_VCLEANUP_INDEX	(8)
+#define QUICKTHREADS_VARGT_INDEX		(5)
+
+
+/* Stack grows down.  The top of the stack is the first thing to
+   pop off (predecrement, postincrement). */
+#define QUICKTHREADS_GROW_DOWN
+
+
+extern void qt_error (void);
+
+#define QUICKTHREADS_VAX_GMASK_NOREGS	(0)
+
+/* Push on the error return address, null termination to call chains,
+   number of arguments to `only', register save mask (save no
+   registers). */
+
+#define QUICKTHREADS_ARGS_MD(sto) \
+    (QUICKTHREADS_SPUT (sto, 0, 0), \
+     QUICKTHREADS_SPUT (sto, 1, QUICKTHREADS_VAX_GMASK_NOREGS), \
+     QUICKTHREADS_SPUT (sto, 2, 0), \
+     QUICKTHREADS_SPUT (sto, 3, 0), \
+     QUICKTHREADS_SPUT (sto, 4, qt_start))
+
+#define QUICKTHREADS_VARGS_MD0(sto, nbytes) \
+    (QUICKTHREADS_SPUT (sto, (-(nbytes)/4)-1, (nbytes)/4), \
+     ((char *)(((sto)-4) - QUICKTHREADS_STKROUNDUP(nbytes))))
+
+#define QUICKTHREADS_VARGS_ADJUST(sp)	((char *)sp + 4)
+
+#define QUICKTHREADS_VARGS_MD1(sto) \
+    (QUICKTHREADS_SPUT (sto, 0, 0), \
+     QUICKTHREADS_SPUT (sto, 1, QUICKTHREADS_VAX_GMASK_NOREGS), \
+     QUICKTHREADS_SPUT (sto, 2, 0), \
+     QUICKTHREADS_SPUT (sto, 3, 0), \
+     QUICKTHREADS_SPUT (sto, 4, qt_vstart))
+
+#define QUICKTHREADS_VARGS_DEFAULT
+
+#endif /* QUICKTHREADS_VAX_H */
diff --git a/ext/systemc/src/sysc/qt/md/vax.s b/ext/systemc/src/sysc/qt/md/vax.s
new file mode 100644
index 000000000..fed03f043
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/vax.s
@@ -0,0 +1,69 @@
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+	.text
+
+	.globl _qt_abort
+	.globl _qt_block
+	.globl _qt_blocki
+	.globl _qt_start
+	.globl _qt_vstart
+
+
+/*
+// Calls to these routines have the signature
+//
+//	void *block (func, arg1, arg2, newsp)
+//
+// Since the prologue saves 5 registers, nargs, pc, fp, ap, mask, and
+// a condition handler (at sp+0), the first argument is 40=4*10 bytes
+// offset from the stack pointer.
+*/
+_qt_block:
+_qt_blocki:
+_qt_abort:
+	.word 0x7c0		/* Callee-save mask: 5 registers. */
+	movl 56(sp),r1		/* Get stack pointer of new thread. */
+	movl 52(sp),-(r1)	/* Push arg2 */
+	movl 48(sp),-(r1)	/* Push arg1 */
+	movl sp,-(r1)		/* Push arg0 */
+
+	movl 44(sp),r0		/* Get helper to call. */
+	movl r1,sp		/* Move to new thread's stack. */
+	addl3 sp,$12,fp		/* .. including the frame pointer. */
+	calls $3,(r0)		/* Call helper. */
+
+	ret
+
+_qt_start:
+	movl (sp)+,r0		/* Get `only'. */
+	calls $3,(r0)		/* Call `only'. */
+	calls $0,_qt_error	/* `only' erroniously returned. */
+
+
+_qt_vstart:
+	movl (sp)+,r10		/* Get `pt'. */
+	movl (sp)+,r9		/* Get `startup'. */
+	movl (sp)+,r8		/* Get `vuserf'. */
+	movl (sp)+,r7		/* Get `cleanup'. */
+
+	pushl r10		/* Push `qt'. */
+	calls $1,(r9)		/* Call `startup', pop `qt' on return. */
+
+	calls (sp)+,(r8)	/* Call user's function. */
+
+	pushl r0		/* Push `vuserf_retval'. */
+	pushl r10		/* Push `qt'. */
+	calls $2,(r7)		/* Call `cleanup', never return. */
+
+	calls $0,_qt_error	/* `cleanup' erroniously returned. */
diff --git a/ext/systemc/src/sysc/qt/md/vax_b.s b/ext/systemc/src/sysc/qt/md/vax_b.s
new file mode 100644
index 000000000..2db2d4fec
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/vax_b.s
@@ -0,0 +1,92 @@
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+	.text
+	.globl _b_call_reg
+	.globl _b_call_imm
+	.globl _b_add
+	.globl _b_load
+
+_b_null:
+	.word 0x0
+	ret
+
+_b_call_reg:
+	.word 0x0
+	movl 4(ap),r0
+	moval _b_null,r1
+L0:
+	calls $0,(r1)
+	calls $0,(r1)
+	calls $0,(r1)
+	calls $0,(r1)
+	calls $0,(r1)
+
+	subl2 $5,r0
+	bgtr L0
+	ret
+
+
+_b_call_imm:
+	.word 0x0
+	movl 4(ap),r0
+L1:
+	calls $0,_b_null
+	calls $0,_b_null
+	calls $0,_b_null
+	calls $0,_b_null
+	calls $0,_b_null
+
+	subl2 $5,r0
+	bgtr L1
+	ret
+
+
+_b_add:
+	.word 0x0
+	movl 4(ap),r0
+L2:
+	subl2 $1,r0
+	subl2 $1,r0
+	subl2 $1,r0
+	subl2 $1,r0
+	subl2 $1,r0
+
+	subl2 $1,r0
+	subl2 $1,r0
+	subl2 $1,r0
+	subl2 $1,r0
+	subl2 $1,r0
+
+	bgtr L2
+	ret
+
+
+_b_load:
+	.word 0x0
+	movl 4(ap),r0
+L3:
+	movl 0(sp),r1
+	movl 4(sp),r1
+	movl 8(sp),r1
+	movl 12(sp),r1
+	movl 16(sp),r1
+	movl 20(sp),r1
+	movl 24(sp),r1
+	movl 28(sp),r1
+	movl 32(sp),r1
+	movl 36(sp),r1
+
+	subl2 $1,r0
+	bgtr L3
+	ret
diff --git a/ext/systemc/src/sysc/qt/meas.c b/ext/systemc/src/sysc/qt/meas.c
new file mode 100644
index 000000000..3faab3c52
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/meas.c
@@ -0,0 +1,1049 @@
+/* meas.c -- measure qt stuff. */
+
+#include "copyright.h"
+
+/* Need this to get assertions under Mach on the Sequent/i386: */
+#ifdef __i386__
+#define assert(ex) \
+  do { \
+    if (!(ex)) { \
+      fprintf (stderr, "[%s:%d] Assertion " #ex " failed\n", __FILE__, __LINE__); \
+      abort(); \
+    } \
+  } while (0)
+#else
+#include <assert.h>
+#endif
+
+/* This really ought to be defined in some ANSI include file (*I*
+   think...), but it's defined here instead, which leads us to another
+   machine dependency.
+
+   The `iaddr_t' type is an integer representation of a pointer,
+   suited for doing arithmetic on addresses, e.g. to round an address
+   to an alignment boundary. */
+typedef unsigned long iaddr_t;
+
+#include <stdarg.h>	/* For varargs tryout. */
+#include <stdio.h>
+#include "b.h"
+#include "qt.h"
+#include "stp.h"
+
+extern void exit (int status);
+extern int atoi (char const *s);
+extern int fprintf (FILE *out, char const *fmt, ...);
+extern int fputs (char const *s, FILE *fp);
+extern void free (void *sto);
+extern void *malloc (unsigned nbytes);
+extern void perror (char const *s);
+
+void usage (void);
+void tracer(void);
+
+/* Round `v' to be `a'-aligned, assuming `a' is a power of two. */
+#define ROUND(v, a)	(((v) + (a) - 1) & ~((a)-1))
+
+typedef struct thread_t {
+  qt_t *qt;		/* Pointer to thread of function... */
+  void *stk;
+  void *top;		/* Set top of stack if reuse. */
+  struct thread_t *next;
+} thread_t;
+
+
+  static thread_t *
+t_alloc (void)
+{
+  thread_t *t;
+  int ssz = 0x1000;
+
+  t = malloc (sizeof(thread_t));
+  if (!t) {
+    perror ("malloc");
+    exit (1);
+  }
+  assert (ssz > QT_STKBASE);
+  t->stk = malloc (ssz);
+  t->stk = (void *)ROUND (((iaddr_t)t->stk), QT_STKALIGN);
+  if (!t->stk) {
+    perror ("malloc");
+    exit (1);
+  }
+  assert ((((iaddr_t)t->stk) & (QT_STKALIGN-1)) == 0);
+  t->top = QT_SP (t->stk, ssz - QT_STKBASE);
+
+  return (t);
+}
+
+
+  static thread_t *
+t_create (qt_only_t *starter, void *p0, qt_userf_t *f)
+{
+  thread_t *t;
+
+  t = t_alloc();
+  t->qt = QT_ARGS (t->top, p0, t, f, starter);
+  return (t);
+}
+
+
+  static void
+t_free (thread_t *t)
+{
+  free (t->stk);
+  free (t);
+}
+
+
+  static void *
+t_null (qt_t *old, void *p1, void *p2)
+{
+  /* return (garbage); */
+}
+
+
+  static void *
+t_splat (qt_t *old, void *oldp, void *null)
+{
+  *(qt_t **)oldp = old;
+  /* return (garbage); */
+}
+
+
+static char const test01_msg[] =
+  "*QT_SP(sto,sz), QT_ARGS(top,p0,p1,userf,first)";
+
+static char const *test01_descr[] = {
+  "Performs 1 QT_SP and one QT_ARGS per iteration.",
+  NULL
+};
+
+/* This test gives a guess on how long it takes to initalize
+   a thread. */
+
+  static void
+test01 (int n)
+{
+  char stack[QT_STKBASE+QT_STKALIGN];
+  char *stk;
+  qt_t *top;
+
+  stk = (char *)ROUND (((iaddr_t)stack), QT_STKALIGN);
+
+  {
+    int i;
+
+    for (i=0; i<QT_STKBASE; ++i) {
+      stk[i] = 0;
+    }
+  }
+
+  while (n>0) {
+    /* RETVALUSED */
+    top = QT_SP (stk, QT_STKBASE);	QT_ARGS (top, 0, 0, 0, 0);
+#ifdef NDEF
+    top = QT_SP (stk, QT_STKBASE);	QT_ARGS (top, 0, 0, 0, 0);
+    top = QT_SP (stk, QT_STKBASE);	QT_ARGS (top, 0, 0, 0, 0);
+    top = QT_SP (stk, QT_STKBASE);	QT_ARGS (top, 0, 0, 0, 0);
+    top = QT_SP (stk, QT_STKBASE);	QT_ARGS (top, 0, 0, 0, 0);
+
+    top = QT_SP (stk, QT_STKBASE);	QT_ARGS (top, 0, 0, 0, 0);
+    top = QT_SP (stk, QT_STKBASE);	QT_ARGS (top, 0, 0, 0, 0);
+    top = QT_SP (stk, QT_STKBASE);	QT_ARGS (top, 0, 0, 0, 0);
+    top = QT_SP (stk, QT_STKBASE);	QT_ARGS (top, 0, 0, 0, 0);
+    top = QT_SP (stk, QT_STKBASE);	QT_ARGS (top, 0, 0, 0, 0);
+
+    n -= 10;
+#else
+    n -= 1;
+#endif
+  }
+}
+
+
+static char const test02_msg[] = "QT_BLOCKI (0, 0, test02_aux, t->qt)";
+static qt_t *rootthread;
+
+  static void
+test02_aux1 (void *pu, void *pt, qt_userf_t *f)
+{
+  QT_ABORT (t_null, 0, 0, rootthread);
+}
+
+  static void *
+test02_aux2 (qt_t *old, void *farg1, void *farg2)
+{
+  rootthread = old;
+  /* return (garbage); */
+}
+
+  static void
+test02 (int n)
+{
+  thread_t *t;
+
+  while (n>0) {
+  t = t_create (test02_aux1, 0, 0);
+    QT_BLOCKI (test02_aux2, 0, 0, t->qt);
+  t_free (t);
+  t = t_create (test02_aux1, 0, 0);
+    QT_BLOCKI (test02_aux2, 0, 0, t->qt);
+  t_free (t);
+  t = t_create (test02_aux1, 0, 0);
+    QT_BLOCKI (test02_aux2, 0, 0, t->qt);
+  t_free (t);
+  t = t_create (test02_aux1, 0, 0);
+    QT_BLOCKI (test02_aux2, 0, 0, t->qt);
+  t_free (t);
+  t = t_create (test02_aux1, 0, 0);
+    QT_BLOCKI (test02_aux2, 0, 0, t->qt);
+  t_free (t);
+
+    n -= 5;
+  }
+}
+
+
+static char const test03_msg[] = "QT_BLOCKI (...) test vals are right.";
+
+
+/* Called by the thread function when it wants to shut down.
+   Return a value to the main thread. */
+
+  static void *
+test03_aux0 (qt_t *old_is_garbage, void *farg1, void *farg2)
+{
+  assert (farg1 == (void *)5);
+  assert (farg2 == (void *)6);
+  return ((void *)15);		/* Some unlikely value. */
+}
+
+
+/* Called during new thread startup by main thread.  Since the new
+   thread has never run before, return value is ignored. */
+
+  static void *
+test03_aux1 (qt_t *old, void *farg1, void *farg2)
+{
+  assert (old != NULL);
+  assert (farg1 == (void *)5);
+  assert (farg2 == (void *)6);
+  rootthread = old;
+  return ((void *)16);		/* Different than `15'. */
+}
+
+  static void
+test03_aux2 (void *pu, void *pt, qt_userf_t *f)
+{
+  assert (pu == (void *)1);
+  assert (f == (qt_userf_t *)4);
+  QT_ABORT (test03_aux0, (void *)5, (void *)6, rootthread);
+}
+
+  static void
+test03 (int n)
+{
+  thread_t *t;
+  void *rv;
+
+  while (n>0) {
+    t = t_create (test03_aux2, (void *)1, (qt_userf_t *)4);
+    rv = QT_BLOCKI (test03_aux1, (void *)5, (void *)6, t->qt);
+    assert (rv == (void *)15);
+    t_free (t);
+
+    --n;
+  }
+}
+
+
+static char const test04_msg[] = "stp_start w/ no threads.";
+
+  static void
+test04 (int n)
+{
+  while (n>0) {
+    stp_init();	stp_start();
+    stp_init();	stp_start();
+    stp_init();	stp_start();
+    stp_init();	stp_start();
+    stp_init();	stp_start();
+
+    stp_init();	stp_start();
+    stp_init();	stp_start();
+    stp_init();	stp_start();
+    stp_init();	stp_start();
+    stp_init();	stp_start();
+
+    n -= 10;
+  }
+}
+
+
+static char const test05_msg[] = "stp w/ 2 yielding thread.";
+
+  static void
+test05_aux (void *null)
+{
+  stp_yield();
+  stp_yield();
+}
+
+  static void
+test05 (int n)
+{
+  while (n>0) {
+    stp_init();
+    stp_create (test05_aux, 0);
+    stp_create (test05_aux, 0);
+    stp_start();
+
+    --n;
+  }
+}
+
+
+static char const test06_msg[] = "*QT_ARGS(...), QT_BLOCKI one thread";
+
+static char const *test06_descr[] = {
+  "Does a QT_ARGS, QT_BLOCKI to a helper function that saves the",
+  "stack pointer of the main thread, calls an `only' function that",
+  "saves aborts the thread, calling a null helper function.",
+  ":: start/stop = QT_ARGS + QT_BLOCKI + QT_ABORT + 3 procedure calls.",
+  NULL
+};
+
+/* This test initializes a thread, runs it, then returns to the main
+   program, which reinitializes the thread, runs it again, etc.  Each
+   iteration corresponds to 1 init, 1 abort, 1 block. */
+
+static qt_t *test06_sp;
+
+
+  static void
+test06_aux2 (void *null0a, void *null1b, void *null2b, qt_userf_t *null)
+{
+  QT_ABORT (t_null, 0, 0, test06_sp);
+}
+
+
+  static void *
+test06_aux3 (qt_t *sp, void *null0c, void *null1c)
+{
+  test06_sp = sp;
+  /* return (garbage); */
+}
+
+
+  static void
+test06 (int n)
+{
+  thread_t *t;
+
+  t = t_create (0, 0, 0);
+
+  while (n>0) {
+    /* RETVALUSED */
+    QT_ARGS (t->top, 0, 0, 0, test06_aux2);
+    QT_BLOCKI (test06_aux3, 0, 0, t->qt);
+#ifdef NDEF
+    /* RETVALUSED */
+    QT_ARGS (t->top, 0, 0, 0, test06_aux2);
+    QT_BLOCKI (test06_aux3, 0, 0, t->qt);
+
+    /* RETVALUSED */
+    QT_ARGS (t->top, 0, 0, 0, test06_aux2);
+    QT_BLOCKI (test06_aux3, 0, 0, t->qt);
+
+    /* RETVALUSED */
+    QT_ARGS (t->top, 0, 0, 0, test06_aux2);
+    QT_BLOCKI (test06_aux3, 0, 0, t->qt);
+
+    /* RETVALUSED */
+    QT_ARGS (t->top, 0, 0, 0, test06_aux2);
+    QT_BLOCKI (test06_aux3, 0, 0, t->qt);
+
+    n -= 5;
+#else
+    --n;
+#endif
+  }
+}
+
+static char test07_msg[] = "*cswap between threads";
+
+static char const *test07_descr[] = {
+  "Build a chain of threads where each thread has a fixed successor.",
+  "There is no scheduling performed.  Each thread but one is a loop",
+  "that simply blocks with QT_BLOCKI, calling a helper that saves the",
+  "current stack pointer.  The last thread decrements a count, and,",
+  "if zero, aborts back to the main thread.  Else it continues with",
+  "the blocking chain.  The count is divided by the number of threads",
+  "in the chain, so `n' is the number of integer block operations.",
+  ":: integer cswap = QT_BLOCKI + a procedure call.",
+  NULL
+};
+
+/* This test repeatedly blocks a bunch of threads.
+   Each iteration corresponds to one block operation.
+
+   The threads are arranged so that there are TEST07_N-1 of them that
+   run `test07_aux2'.  Each one of those blocks saving it's sp to
+   storage owned by the preceding thread; a pointer to that storage is
+   passed in via `mep'.  Each thread has a handle on it's own storage
+   for the next thread, referenced by `nxtp', and it blocks by passing
+   control to `*nxtp', telling the helper function to save its state
+   in `*mep'.  The last thread in the chain decrements a count and, if
+   it's gone below zero, returns to `test07'; otherwise, it invokes
+   the first thread in the chain. */
+
+static qt_t *test07_heavy;
+
+#define TEST07_N (4)
+
+
+  static void
+test07_aux2 (void *null0, void *mep, void *nxtp, qt_userf_t *null)
+{
+  qt_t *nxt;
+
+  while (1) {
+    nxt = *(qt_t **)nxtp;
+#ifdef NDEF
+    printf ("Helper 0x%p\n", nxtp);
+#endif
+    QT_BLOCKI (t_splat, mep, 0, nxt);
+  }
+}
+
+  static void
+test07_aux3 (void *np, void *mep, void *nxtp, qt_userf_t *null)
+{
+  int n;
+
+  n = *(int *)np;
+  while (1) {
+    n -= TEST07_N;
+    if (n<0) {
+      QT_ABORT (t_splat, mep, 0, test07_heavy);
+    }
+    QT_BLOCKI (t_splat, mep, 0, *(qt_t **)nxtp);
+  }
+}
+
+
+  static void
+test07 (int n)
+{
+  int i;
+  thread_t *t[TEST07_N];
+
+  for (i=0; i<TEST07_N; ++i) {
+    t[i] = t_create (0, 0, 0);
+  }
+  for (i=0; i<TEST07_N-1; ++i) {
+    /* RETVALUSED */
+    QT_ARGS (t[i]->top, 0, &t[i]->qt, &t[i+1]->qt, test07_aux2);
+  }
+  /* RETVALUSED */
+  QT_ARGS (t[i]->top, &n, &t[TEST07_N-1]->qt, &t[0]->qt, test07_aux3);
+  QT_BLOCKI (t_splat, &test07_heavy, 0, t[0]->qt);
+}
+
+
+static char test08_msg[] = "Floating-point cswap between threads";
+
+static char const *test08_descr[] = {
+  "Measure context switch times including floating-point, use QT_BLOCK.",
+  NULL
+};
+
+static qt_t *test08_heavy;
+
+#define TEST08_N (4)
+
+
+  static void
+test08_aux2 (void *null0, void *mep, void *nxtp, qt_userf_t *null)
+{
+  qt_t *nxt;
+
+  while (1) {
+    nxt = *(qt_t **)nxtp;
+    QT_BLOCK (t_splat, mep, 0, nxt);
+  }
+}
+
+  static void
+test08_aux3 (void *np, void *mep, void *nxtp, qt_userf_t *null)
+{
+  int n;
+
+  n = *(int *)np;
+  while (1) {
+    n -= TEST08_N;
+    if (n<0) {
+      QT_ABORT (t_splat, mep, 0, test08_heavy);
+    }
+    QT_BLOCK (t_splat, mep, 0, *(qt_t **)nxtp);
+  }
+}
+
+
+  static void
+test08 (int n)
+{
+  int i;
+  thread_t *t[TEST08_N];
+
+  for (i=0; i<TEST08_N; ++i) {
+    t[i] = t_create (0, 0, 0);
+  }
+  for (i=0; i<TEST08_N-1; ++i) {
+    /* RETVALUSED */
+    QT_ARGS (t[i]->top, 0, &t[i]->qt, &t[i+1]->qt, test08_aux2);
+  }
+  /* RETVALUSED */
+  QT_ARGS (t[i]->top, &n, &t[TEST08_N-1]->qt, &t[0]->qt, test08_aux3);
+  QT_BLOCK (t_splat, &test08_heavy, 0, t[0]->qt);
+}
+
+
+/* Test the varargs procedure calling. */
+
+char const test09_msg[] = { "Start and run threads using varargs." };
+
+thread_t *test09_t0, *test09_t1, *test09_t2, *test09_main;
+
+  thread_t *
+test09_create (qt_startup_t *start, qt_vuserf_t *f,
+	       qt_cleanup_t *cleanup, int nbytes, ...)
+{
+  va_list ap;
+  thread_t *t;
+
+  t = t_alloc();
+  va_start (ap, nbytes);
+  t->qt = QT_VARGS (t->top, nbytes, ap, t, start, f, cleanup);
+  va_end (ap);
+  return (t);
+}
+
+
+  static void
+test09_cleanup (void *pt, void *vuserf_retval)
+{
+  assert (vuserf_retval == (void *)17);
+  QT_ABORT (t_splat, &((thread_t *)pt)->qt, 0,
+	    ((thread_t *)pt)->next->qt);
+}
+
+
+  static void
+test09_start (void *pt)
+{
+}
+
+
+  static void *
+test09_user0 (void)
+{
+  QT_BLOCKI (t_splat, &test09_t0->qt, 0, test09_t1->qt);
+  return ((void *)17);
+}
+
+  static void *
+test09_user2 (int one, int two)
+{
+  assert (one == 1);
+  assert (two == 2);
+  QT_BLOCKI (t_splat, &test09_t1->qt, 0, test09_t2->qt);
+  assert (one == 1);
+  assert (two == 2);
+  return ((void *)17);
+}
+
+  static void *
+test09_user10 (int one, int two, int three, int four, int five,
+	      int six, int seven, int eight, int nine, int ten)
+{
+  assert (one == 1);
+  assert (two == 2);
+  assert (three == 3);
+  assert (four == 4);
+  assert (five == 5);
+  assert (six == 6);
+  assert (seven == 7);
+  assert (eight == 8);
+  assert (nine == 9);
+  assert (ten == 10);
+  QT_BLOCKI (t_splat, &test09_t2->qt, 0, test09_main->qt);
+  assert (one == 1);
+  assert (two == 2);
+  assert (three == 3);
+  assert (four == 4);
+  assert (five == 5);
+  assert (six == 6);
+  assert (seven == 7);
+  assert (eight == 8);
+  assert (nine == 9);
+  assert (ten == 10);
+  return ((void *)17);
+}
+
+
+  void
+test09 (int n)
+{
+  thread_t main;
+
+  test09_main = &main;
+
+  while (--n >= 0) {
+    test09_t0 = test09_create (test09_start, (qt_vuserf_t*)test09_user0,
+			       test09_cleanup, 0);
+    test09_t1 = test09_create (test09_start, (qt_vuserf_t*)test09_user2,
+			       test09_cleanup, 2 * sizeof(qt_word_t), 1, 2);
+    test09_t2 = test09_create (test09_start, (qt_vuserf_t*)test09_user10,
+			       test09_cleanup, 10 * sizeof(qt_word_t),
+			       1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+
+    /* Chaining used by `test09_cleanup' to determine who is next. */
+    test09_t0->next = test09_t1;
+    test09_t1->next = test09_t2;
+    test09_t2->next = test09_main;
+
+    QT_BLOCKI (t_splat, &test09_main->qt, 0, test09_t0->qt);
+    QT_BLOCKI (t_splat, &test09_main->qt, 0, test09_t0->qt);
+
+    t_free (test09_t0);
+    t_free (test09_t1);
+    t_free (test09_t2);
+  }
+}
+
+
+/* Test 10/11/12: time the cost of various number of args. */
+
+char const test10_msg[] = { "*Test varargs init & startup w/ 0 args." };
+
+char const *test10_descr[] = {
+  "Start and stop threads that use variant argument lists (varargs).",
+  "Each thread is initialized by calling a routine that calls",
+  "QT_VARARGS.  Then runs the thread by calling QT_BLOCKI to hald the",
+  "main thread, a helper that saves the main thread's stack pointer,",
+  "a null startup function, a null user function, a cleanup function",
+  "that calls QT_ABORT and restarts the main thread.  Copies no user",
+  "parameters.",
+  ":: varargs start/stop = QT_BLOCKI + QT_ABORT + 6 function calls.",
+  NULL
+};
+
+/* Helper function to send control back to main.
+   Don't save anything. */
+
+
+/* Helper function for starting the varargs thread.  Save the stack
+   pointer of the main thread so we can get back there eventually. */
+
+
+/* Startup function for a varargs thread. */
+
+  static void
+test10_startup (void *pt)
+{
+}
+
+
+/* User function for a varargs thread. */
+
+  static void *
+test10_run (int arg0, ...)
+{
+  /* return (garbage); */
+}
+
+
+/* Cleanup function for a varargs thread.  Send control
+   back to the main thread.  Don't save any state from the thread that
+   is halting. */
+
+  void
+test10_cleanup (void *pt, void *vuserf_retval)
+{
+  QT_ABORT (t_null, 0, 0, ((thread_t *)pt)->qt);
+}
+
+
+  void
+test10_init (thread_t *new, thread_t *next, int nbytes, ...)
+{
+  va_list ap;
+
+  va_start (ap, nbytes);
+  new->qt = QT_VARGS (new->top, nbytes, ap, next, test10_startup,
+		      test10_run, test10_cleanup);
+  va_end (ap);
+}
+
+
+  void
+test10 (int n)
+{
+  thread_t main;
+  thread_t *t;
+
+  t = t_alloc();
+  t->next = &main;
+
+  while (--n >= 0) {
+    test10_init (t, &main, 0);
+    QT_BLOCKI (t_splat, &main.qt, 0, t->qt);
+  }
+  t_free (t);
+}
+
+
+char const test11_msg[] = { "*Test varargs init & startup w/ 2 args." };
+
+char const *test11_descr[] = {
+  "Varargs initialization/run.  Copies 2 user arguments.",
+  ":: varargs 2 start/stop = QT_VARGS(2 args), QT_BLOCKI, QT_ABORT, 6 f() calls.",
+  NULL
+};
+
+
+  void
+test11 (int n)
+{
+  thread_t main;
+  thread_t *t;
+
+  t = t_alloc();
+  t->next = &main;
+
+  while (--n >= 0) {
+    test10_init (t, &main, 2 * sizeof(int), 2, 1);
+    QT_BLOCKI (t_splat, &main.qt, 0, t->qt);
+  }
+  t_free (t);
+}
+
+char const test12_msg[] = { "*Test varargs init & startup w/ 4 args." };
+
+char const *test12_descr[] = {
+  "Varargs initialization/run.  Copies 4 user arguments.",
+  ":: varargs 4 start/stop = QT_VARGS(4 args), QT_BLOCKI, QT_ABORT, 6 f() calls.",
+  NULL
+};
+
+
+  void
+test12 (int n)
+{
+  thread_t main;
+  thread_t *t;
+
+  t = t_alloc();
+  t->next = &main;
+
+  while (--n >= 0) {
+    test10_init (t, &main, 4 * sizeof(int), 4, 3, 2, 1);
+    QT_BLOCKI (t_splat, &main.qt, 0, t->qt);
+  }
+  t_free (t);
+}
+
+
+char const test13_msg[] = { "*Test varargs init & startup w/ 8 args." };
+
+char const *test13_descr[] = {
+  "Varargs initialization/run.  Copies 8 user arguments.",
+  ":: varargs 8 start/stop = QT_VARGS(8 args), QT_BLOCKI, QT_ABORT, 6 f() calls.",
+  NULL
+};
+
+  void
+test13 (int n)
+{
+  thread_t main;
+  thread_t *t;
+
+  t = t_alloc();
+  t->next = &main;
+
+  while (--n >= 0) {
+    test10_init (t, &main, 8 * sizeof(int), 8, 7, 6, 5, 4, 3, 2, 1);
+    QT_BLOCKI (t_splat, &main.qt, 0, t->qt);
+  }
+  t_free (t);
+}
+
+
+char const test14_msg[] = { "*Test varargs initialization w/ 0 args." };
+
+char const *test14_descr[] = {
+  "Varargs initialization without running the thread.  Just calls",
+  "QT_VARGS.",
+  ":: varargs 0 init = QT_VARGS()",
+  NULL
+};
+
+  void
+test14 (int n)
+{
+  thread_t main;
+  thread_t *t;
+
+  t = t_alloc();
+  t->next = &main;
+
+  while (--n >= 0) {
+    test10_init (t, &main, 0 * sizeof(int));
+  }
+  t_free (t);
+}
+
+
+char const test15_msg[] = { "*Test varargs initialization w/ 2 args." };
+
+char const *test15_descr[] = {
+  "Varargs initialization without running the thread.  Just calls",
+  "QT_VARGS.",
+  ":: varargs 2 init = QT_VARGS(2 args)",
+  NULL
+};
+
+  void
+test15 (int n)
+{
+  thread_t main;
+  thread_t *t;
+
+  t = t_alloc();
+  t->next = &main;
+
+  while (--n >= 0) {
+    test10_init (t, &main, 2 * sizeof(int), 2, 1);
+  }
+  t_free (t);
+}
+
+char const test16_msg[] = { "*Test varargs initialization w/ 4 args." };
+
+char const *test16_descr[] = {
+  "Varargs initialization without running the thread.  Just calls",
+  "QT_VARGS.",
+  ":: varargs 4 init = QT_VARGS(4 args)",
+  NULL
+};
+
+
+  void
+test16 (int n)
+{
+  thread_t main;
+  thread_t *t;
+
+  t = t_alloc();
+  t->next = &main;
+
+  while (--n >= 0) {
+    test10_init (t, &main, 4 * sizeof(int), 4, 3, 2, 1);
+  }
+  t_free (t);
+}
+
+
+char const test17_msg[] = { "*Test varargs initialization w/ 8 args." };
+
+char const *test17_descr[] = {
+  "Varargs initialization without running the thread.  Just calls",
+  "QT_VARGS.",
+  ":: varargs 8 init = QT_VARGS(8 args)",
+  NULL
+};
+
+
+  void
+test17 (int n)
+{
+  thread_t main;
+  thread_t *t;
+
+  t = t_alloc();
+  t->next = &main;
+
+  while (--n >= 0) {
+    test10_init (t, &main, 8 * sizeof(int), 8, 7, 6, 5, 4, 3, 2, 1);
+  }
+  t_free (t);
+}
+
+/* Test times for basic machine operations. */
+
+char const test18_msg[] = { "*Call register indirect." };
+char const *test18_descr[] = { NULL };
+
+  void
+test18 (int n)
+{
+  b_call_reg (n);
+}
+
+
+char const test19_msg[] = { "*Call immediate." };
+char const *test19_descr[] = { NULL };
+
+  void
+test19 (int n)
+{
+  b_call_imm (n);
+}
+
+
+char const test20_msg[] = { "*Add register-to-register." };
+char const *test20_descr[] = { NULL };
+
+  void
+test20 (int n)
+{
+  b_add (n);
+}
+
+
+char const test21_msg[] = { "*Load memory to a register." };
+char const *test21_descr[] = { NULL };
+
+  void
+test21 (int n)
+{
+  b_load (n);
+}
+
+/* Driver. */
+
+typedef struct foo_t {
+    char const *msg;	/* Message to print for generic help. */
+    char const **descr;	/* A description of what is done by the test. */
+    void (*f)(int n);
+} foo_t;
+
+
+static foo_t foo[] = {
+  { "Usage:\n", NULL, (void(*)(int n))usage },
+  { test01_msg, test01_descr, test01 },
+  { test02_msg, NULL, test02 },
+  { test03_msg, NULL, test03 },
+  { test04_msg, NULL, test04 },
+  { test05_msg, NULL, test05 },
+  { test06_msg, test06_descr, test06 },
+  { test07_msg, test07_descr, test07 },
+  { test08_msg, test08_descr, test08 },
+  { test09_msg, NULL, test09 },
+  { test10_msg, test10_descr, test10 },
+  { test11_msg, test11_descr, test11 },
+  { test12_msg, test12_descr, test12 },
+  { test13_msg, test13_descr, test13 },
+  { test14_msg, test14_descr, test14 },
+  { test15_msg, test15_descr, test15 },
+  { test16_msg, test16_descr, test16 },
+  { test17_msg, test17_descr, test17 },
+  { test18_msg, test18_descr, test18 },
+  { test19_msg, test19_descr, test19 },
+  { test20_msg, test20_descr, test20 },
+  { test21_msg, test21_descr, test21 },
+  { 0, 0 }
+};
+
+static int tv = 0;
+
+  void
+tracer ()
+{
+
+  fprintf (stderr, "tracer\t%d\n", tv++);
+  fflush (stderr);
+}
+
+  void
+tracer2 (void *val)
+{
+  fprintf (stderr, "tracer2\t%d val=0x%p", tv++, val);
+  fflush (stderr);
+}
+
+
+  void
+describe()
+{
+  int i;
+  FILE *out = stdout;
+
+  for (i=0; foo[i].msg; ++i) {
+    if (foo[i].descr) {
+      int j;
+
+      putc ('\n', out);
+      fprintf (out, "[%d]\n", i);
+      for (j=0; foo[i].descr[j]; ++j) {
+	fputs (foo[i].descr[j], out);
+	putc ('\n', out);
+      }
+    }
+  }
+  exit (0);
+}
+
+
+  void
+usage()
+{
+  int i;
+
+  fputs (foo[0].msg, stderr);
+  for (i=1; foo[i].msg; ++i) {
+    fprintf (stderr, "%2d\t%s\n", i, foo[i].msg);
+  }
+  exit (1);
+}
+
+
+  void
+args (int *which, int *n, int argc, char **argv)
+{
+  static int nfuncs = 0;
+
+  if (argc == 2 && argv[1][0] == '-' && argv[1][1] == 'h') {
+    describe();
+  }
+
+  if (nfuncs == 0) {
+    for (nfuncs=0; foo[nfuncs].msg; ++nfuncs)
+      ;
+  }
+
+  if (argc != 2 && argc != 3) {
+    usage();
+  }
+
+  *which = atoi (argv[1]);
+  if (*which < 0 || *which >= nfuncs) {
+    usage();
+  }
+  *n = (argc == 3)
+    ? atoi (argv[2])
+    : 1;
+}
+
+
+  int
+main (int argc, char **argv)
+{
+  int which, n;
+  args (&which, &n, argc, argv);
+  (*(foo[which].f))(n);
+  exit (0);
+  return (0);
+}
diff --git a/ext/systemc/src/sysc/qt/qt.c b/ext/systemc/src/sysc/qt/qt.c
new file mode 100644
index 000000000..204d38397
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/qt.c
@@ -0,0 +1,56 @@
+#include "copyright.h"
+#include "qt.h"
+
+// static void *qt_sp_bottom_save;
+
+#ifdef QT_VARGS_DEFAULT
+
+/* If the stack grows down, `vargs' is a pointer to the lowest
+   address in the block of arguments.  If the stack grows up, it is a
+   pointer to the highest address in the block. */
+
+  qt_t *
+qt_vargs (qt_t *sp, int nbytes, void *vargs,
+	  void *pt, qt_startup_t *startup,
+	  qt_vuserf_t *vuserf, qt_cleanup_t *cleanup)
+{
+  int i;
+
+  sp = QT_VARGS_MD0 (sp, nbytes);
+#ifdef QT_GROW_UP
+    for (i=nbytes/sizeof(qt_word_t); i>0; --i) {
+      QT_SPUT (QT_VARGS_ADJUST(sp), i, ((qt_word_t *)vargs)[-i]);
+    }
+#else
+    for (i=nbytes/sizeof(qt_word_t); i>0; --i) {
+      QT_SPUT (QT_VARGS_ADJUST(sp), i-1, ((qt_word_t *)vargs)[i-1]);
+    }
+#endif
+
+  QT_VARGS_MD1 (QT_VADJ(sp));
+  QT_SPUT (QT_VADJ(sp), QT_VARGT_INDEX, pt);
+  QT_SPUT (QT_VADJ(sp), QT_VSTARTUP_INDEX, startup);
+  QT_SPUT (QT_VADJ(sp), QT_VUSERF_INDEX, vuserf);
+  QT_SPUT (QT_VADJ(sp), QT_VCLEANUP_INDEX, cleanup);
+  return ((qt_t *)QT_VADJ(sp));
+}
+#endif /* def QT_VARGS_DEFAULT */
+
+#ifdef __cplusplus
+extern "C"
+#endif
+  void
+qt_null (void)
+{
+}
+
+#ifdef __cplusplus
+extern "C"
+#endif
+  void
+qt_error (void)
+{
+  extern void abort(void);
+
+  abort();
+}
diff --git a/ext/systemc/src/sysc/qt/qt.h b/ext/systemc/src/sysc/qt/qt.h
new file mode 100644
index 000000000..40a9f531b
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/qt.h
@@ -0,0 +1,192 @@
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+#ifndef QUICKTHREADS_QT_H
+#define QUICKTHREADS_QT_H
+
+#if !defined(SC_USE_PTHREADS)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <sysc/qt/qtmd.h>
+
+
+/* A QuickThreads thread is represented by it's current stack pointer.
+   To restart a thread, you merely need pass the current sp (qt_t*) to
+   a QuickThreads primitive.  `qt_t*' is a location on the stack.  To
+   improve type checking, represent it by a particular struct. */
+
+typedef struct qt_t {
+  char dummy;
+} qt_t;
+
+
+/* Alignment is guaranteed to be a power of two. */
+#ifndef QUICKTHREADS_STKALIGN
+  #error "Need to know the machine-dependent stack alignment."
+#endif
+
+#define QUICKTHREADS_STKROUNDUP(bytes) \
+  (((bytes)+QUICKTHREADS_STKALIGN) & ~(QUICKTHREADS_STKALIGN-1))
+
+
+/* Find ``top'' of the stack, space on the stack. */
+#ifndef QUICKTHREADS_SP
+#ifdef QUICKTHREADS_GROW_DOWN
+#define QUICKTHREADS_SP(sto, size)	((qt_t *)(&((char *)(sto))[(size)]))
+#endif
+#ifdef QUICKTHREADS_GROW_UP
+#define QUICKTHREADS_SP(sto, size)	((qt_t *)(sto))
+#endif
+#if !defined(QUICKTHREADS_SP)
+  #error "QUICKTHREADS_QT_H: Stack must grow up or down!"
+#endif
+#endif
+
+
+/* The type of the user function:
+   For non-varargs, takes one void* function.
+   For varargs, takes some number of arguments. */
+typedef void *(qt_userf_t)(void *pu);
+typedef void *(qt_vuserf_t)(int arg0, ...);
+
+/* For non-varargs, just call a client-supplied function,
+   it does all startup and cleanup, and also calls the user's
+   function. */
+typedef void (qt_only_t)(void *pu, void *pt, qt_userf_t *userf);
+
+/* For varargs, call `startup', then call the user's function,
+   then call `cleanup'. */
+typedef void (qt_startup_t)(void *pt);
+typedef void (qt_cleanup_t)(void *pt, void *vuserf_return);
+
+
+/* Internal helper for putting stuff on stack. */
+#ifndef QUICKTHREADS_SPUT
+#define QUICKTHREADS_SPUT(top, at, val)	\
+    (((qt_word_t *)(top))[(at)] = (qt_word_t)(val))
+#endif
+
+
+/* Push arguments for the non-varargs case. */
+#ifndef QUICKTHREADS_ARGS
+
+#ifndef QUICKTHREADS_ARGS_MD
+#define QUICKTHREADS_ARGS_MD (0)
+#endif
+
+#ifndef QUICKTHREADS_STKBASE
+  #error "Need to know the machine-dependent stack allocation."
+#endif
+
+/* All things are put on the stack relative to the final value of
+   the stack pointer. */
+#ifdef QUICKTHREADS_GROW_DOWN
+#define QUICKTHREADS_ADJ(sp)	(((char *)sp) - QUICKTHREADS_STKBASE)
+#else
+#define QUICKTHREADS_ADJ(sp)	(((char *)sp) + QUICKTHREADS_STKBASE)
+#endif
+
+#define QUICKTHREADS_ARGS(sp, pu, pt, userf, only) \
+    (QUICKTHREADS_ARGS_MD (QUICKTHREADS_ADJ(sp)), \
+     QUICKTHREADS_SPUT (QUICKTHREADS_ADJ(sp), QUICKTHREADS_ONLY_INDEX, only), \
+     QUICKTHREADS_SPUT (QUICKTHREADS_ADJ(sp), QUICKTHREADS_USER_INDEX, userf), \
+     QUICKTHREADS_SPUT (QUICKTHREADS_ADJ(sp), QUICKTHREADS_ARGT_INDEX, pt), \
+     QUICKTHREADS_SPUT (QUICKTHREADS_ADJ(sp), QUICKTHREADS_ARGU_INDEX, pu), \
+     ((qt_t *)QUICKTHREADS_ADJ(sp)))
+
+#endif
+
+
+/* Push arguments for the varargs case.
+   Has to be a function call because initialization is an expression
+   and we need to loop to copy nbytes of stuff on to the stack.
+   But that's probably OK, it's not terribly cheap, anyway. */
+
+#ifdef QUICKTHREADS_VARGS_DEFAULT
+#ifndef QUICKTHREADS_VARGS_MD0
+#define QUICKTHREADS_VARGS_MD0(sp, vasize)	(sp)
+#endif
+#ifndef QUICKTHREADS_VARGS_MD1
+#define QUICKTHREADS_VARGS_MD1(sp)	do { ; } while (0)
+#endif
+
+#ifndef QUICKTHREADS_VSTKBASE
+  #error "Need base stack size for varargs functions."
+#endif
+
+/* Sometimes the stack pointer needs to munged a bit when storing
+   the list of arguments. */
+#ifndef QUICKTHREADS_VARGS_ADJUST
+#define QUICKTHREADS_VARGS_ADJUST(sp)	(sp)
+#endif
+
+/* All things are put on the stack relative to the final value of
+   the stack pointer. */
+#ifdef QUICKTHREADS_GROW_DOWN
+#define QUICKTHREADS_VADJ(sp)	(((char *)sp) - QUICKTHREADS_VSTKBASE)
+#else
+#define QUICKTHREADS_VADJ(sp)	(((char *)sp) + QUICKTHREADS_VSTKBASE)
+#endif
+
+extern qt_t *qt_vargs (qt_t *sp, int nbytes, void *vargs,
+		       void *pt, qt_startup_t *startup,
+		       qt_vuserf_t *vuserf, qt_cleanup_t *cleanup);
+
+#ifndef QUICKTHREADS_VARGS
+#define QUICKTHREADS_VARGS(sp, nbytes, vargs, pt, startup, vuserf, cleanup) \
+      (qt_vargs (sp, nbytes, vargs, pt, startup, vuserf, cleanup))
+#endif
+
+#endif
+
+
+/* Save the state of the thread and call the helper function
+   using the stack of the new thread. */
+typedef void *(qt_helper_t)(qt_t *old, void *a0, void *a1);
+typedef void *(qt_block_t)(qt_helper_t *helper, void *a0, void *a1,
+			  qt_t *newthread);
+
+/* Rearrange the parameters so that things passed to the helper
+   function are already in the right argument registers. */
+#ifndef QUICKTHREADS_ABORT
+extern void *qt_abort (qt_helper_t *h, void *a0, void *a1, qt_t *newthread);
+/* The following does, technically, `return' a value, but the
+   user had better not rely on it, since the function never
+   returns. */ 
+#define QUICKTHREADS_ABORT(h, a0, a1, newthread) \
+    do { qt_abort (h, a0, a1, newthread); } while (0)
+#endif
+
+#ifndef QUICKTHREADS_BLOCK
+extern void *qt_block (qt_helper_t *h, void *a0, void *a1,
+		       qt_t *newthread);
+#define QUICKTHREADS_BLOCK(h, a0, a1, newthread) \
+    (qt_block (h, a0, a1, newthread))
+#endif
+
+#ifndef QUICKTHREADS_BLOCKI
+extern void *qt_blocki (qt_helper_t *h, void *a0, void *a1,
+			qt_t *newthread);
+#define QUICKTHREADS_BLOCKI(h, a0, a1, newthread) \
+    (qt_blocki (h, a0, a1, newthread))
+#endif
+
+#ifdef __cplusplus
+}		/* Match `extern "C" {' at top. */
+#endif
+
+#endif // !defined(SC_USE_PTHREADS)
+#endif /* ndef QUICKTHREADS_H */
diff --git a/ext/systemc/src/sysc/qt/qtmd.h b/ext/systemc/src/sysc/qt/qtmd.h
new file mode 100644
index 000000000..f33203815
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/qtmd.h
@@ -0,0 +1,13 @@
+#if defined( __sparc ) || defined( __sparc__ )
+#include "sysc/qt/md/sparc.h"
+#elif defined( __hppa )
+#include "sysc/qt/md/hppa.h"
+#elif defined( __x86_64__ )
+#include "sysc/qt/md/iX86_64.h"
+#elif defined( __i386 )
+#include "sysc/qt/md/i386.h"
+#elif defined( __ppc__ )
+#include "sysc/qt/md/powerpc_mach.h"
+#elif defined( __powerpc )
+#include "sysc/qt/md/powerpc_sys5.h"
+#endif
diff --git a/ext/systemc/src/sysc/qt/stp.c b/ext/systemc/src/sysc/qt/stp.c
new file mode 100644
index 000000000..bfacc893b
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/stp.c
@@ -0,0 +1,199 @@
+#include "copyright.h"
+#include "qt.h"
+#include "stp.h"
+
+#ifndef NULL
+#define NULL	0
+#endif
+
+#define STP_STKSIZE (0x1000)
+
+/* `alignment' must be a power of 2. */
+#define STP_STKALIGN(sp, alignment) \
+  ((void *)((((qt_word_t)(sp)) + (alignment) - 1) & ~((alignment)-1)))
+
+
+/* The notion of a thread is merged with the notion of a queue.
+   Thread stuff: thread status (sp) and stuff to use during
+   (re)initialization.  Queue stuff: next thread in the queue
+   (next). */
+
+struct stp_t {
+  qt_t *sp;              /* QuickThreads handle. */
+  void *sto;             /* `malloc'-allocated stack. */
+  struct stp_t *next;    /* Next thread in the queue. */
+};
+
+
+/* A queue is a circular list of threads.  The queue head is a
+   designated list element.  If this is a uniprocessor-only
+   implementation we can store the `main' thread in this, but in a
+   multiprocessor there are several `heavy' threads but only one run
+   queue.  A fancier implementation might have private run queues,
+   which would lead to a simpler (trivial) implementation */
+
+typedef struct stp_q_t {
+  stp_t t;
+  stp_t *tail;
+} stp_q_t;
+
+
+/* Helper functions. */
+
+extern void *malloc (unsigned size);
+extern void perror (char const *msg);
+extern void free (void *sto);
+
+  void *
+xmalloc (unsigned size)
+{
+  void *sto;
+
+  sto = malloc (size);
+  if (!sto) {
+    perror ("malloc");
+    exit (1);
+  }
+  return (sto);
+}
+
+/* Queue access functions. */
+
+  static void
+stp_qinit (stp_q_t *q)
+{
+  q->t.next = q->tail = &q->t;
+}
+
+
+  static stp_t *
+stp_qget (stp_q_t *q)
+{
+  stp_t *t;
+
+  t = q->t.next;
+  q->t.next = t->next;
+  if (t->next == &q->t) {
+    if (t == &q->t) {		/* If it was already empty .. */
+      return (NULL);		/* .. say so. */
+    }
+    q->tail = &q->t;		/* Else now it is empty. */
+  }
+  return (t);
+}
+
+
+  static void
+stp_qput (stp_q_t *q, stp_t *t)
+{
+  q->tail->next = t;
+  t->next = &q->t;
+  q->tail = t;
+}
+
+
+/* Thread routines. */
+
+static stp_q_t stp_global_runq;	/* A queue of runable threads. */
+static stp_t stp_global_main;   /* Thread for the process. */
+static stp_t *stp_global_curr;	/* Currently-executing thread. */
+
+static void *stp_starthelp (qt_t *old, void *ignore0, void *ignore1);
+static void stp_only (void *pu, void *pt, qt_userf_t *f);
+static void *stp_aborthelp (qt_t *sp, void *old, void *null);
+static void *stp_yieldhelp (qt_t *sp, void *old, void *blockq);
+
+
+  void
+stp_init()
+{
+  stp_qinit (&stp_global_runq);
+}
+
+
+  void
+stp_start()
+{
+  stp_t *next;
+
+  while ((next = stp_qget (&stp_global_runq)) != NULL) {
+    stp_global_curr = next;
+    QT_BLOCK (stp_starthelp, 0, 0, next->sp);
+  }
+}
+
+
+  static void *
+stp_starthelp (qt_t *old, void *ignore0, void *ignore1)
+{
+  stp_global_main.sp = old;
+  stp_qput (&stp_global_runq, &stp_global_main);
+  /* return (garbage); */
+}
+
+
+  void
+stp_create (stp_userf_t *f, void *pu)
+{
+  stp_t *t;
+  void *sto;
+
+  t = xmalloc (sizeof(stp_t));
+  t->sto = xmalloc (STP_STKSIZE);
+  sto = STP_STKALIGN (t->sto, QT_STKALIGN);
+  t->sp = QT_SP (sto, STP_STKSIZE - QT_STKALIGN);
+  t->sp = QT_ARGS (t->sp, pu, t, (qt_userf_t *)f, stp_only);
+  stp_qput (&stp_global_runq, t);
+}
+
+
+  static void
+stp_only (void *pu, void *pt, qt_userf_t *f)
+{
+  stp_global_curr = (stp_t *)pt;
+  (*(stp_userf_t *)f)(pu);
+  stp_abort();
+  /* NOTREACHED */
+}
+
+
+  void
+stp_abort (void)
+{
+  stp_t *old, *newthread;
+
+  newthread = stp_qget (&stp_global_runq);
+  old = stp_global_curr;
+  stp_global_curr = newthread;
+  QT_ABORT (stp_aborthelp, old, (void *)NULL, newthread->sp);
+}
+
+
+  static void *
+stp_aborthelp (qt_t *sp, void *old, void *null)
+{
+  free (((stp_t *)old)->sto);
+  free (old);
+  /* return (garbage); */
+}
+
+
+  void
+stp_yield()
+{
+  stp_t *old, *newthread;
+
+  newthread = stp_qget (&stp_global_runq);
+  old = stp_global_curr;
+  stp_global_curr = newthread;
+  QT_BLOCK (stp_yieldhelp, old, &stp_global_runq, newthread->sp);
+}
+
+
+  static void *
+stp_yieldhelp (qt_t *sp, void *old, void *blockq)
+{
+  ((stp_t *)old)->sp = sp;
+  stp_qput ((stp_q_t *)blockq, (stp_t *)old);
+  /* return (garbage); */
+}
diff --git a/ext/systemc/src/sysc/qt/stp.h b/ext/systemc/src/sysc/qt/stp.h
new file mode 100644
index 000000000..1220e47e2
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/stp.h
@@ -0,0 +1,51 @@
+#ifndef STP_H
+#define STP_H
+
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+typedef struct stp_t stp_t;
+
+/* Each thread starts by calling a user-supplied function of this
+   type. */
+
+typedef void (stp_userf_t)(void *p0);
+
+/* Call this before any other primitives. */
+extern void stp_init();
+
+/* When one or more threads are created by the main thread,
+   the system goes multithread when this is called.  It is done
+   (no more runable threads) when this returns. */
+
+extern void stp_start (void);
+
+/* Create a thread and make it runable.  When the thread starts
+   running it will call `f' with arguments `p0' and `p1'. */
+
+extern void stp_create (stp_userf_t *f, void *p0);
+
+/* The current thread stops running but stays runable.
+   It is an error to call `stp_yield' before `stp_start'
+   is called or after `stp_start' returns. */
+
+extern void stp_yield (void);
+
+/* Like `stp_yield' but the thread is discarded.  Any intermediate
+   state is lost.  The thread can also terminate by simply
+   returning. */
+
+extern void stp_abort (void);
+
+
+#endif /* ndef STP_H */
diff --git a/ext/systemc/src/sysc/qt/time/README.time b/ext/systemc/src/sysc/qt/time/README.time
new file mode 100644
index 000000000..4bb190e18
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/time/README.time
@@ -0,0 +1,17 @@
+The program `raw', when run in `..' runs the program `run' produced
+from `meas.c'.  It produces a raw output file (see `../tmp/*.raw').
+`raw' will die with an error if run in the current directory.  Note
+that some versions of `time' produce output in an unexpected format;
+edit them by hand.
+
+`prim', `init', `cswap' and `go' produce formatted table entries used
+in the documentation (in `../doc').  For example, from `..',
+
+	foreach i (tmp/*.raw)
+	  time/prim $i
+	end
+
+See notes in the QuickThreads document about the applicability of
+these microbenchmark measurements -- in general, you can expect all
+QuickThreads operations to be a bit slower when used in a real
+application.
diff --git a/ext/systemc/src/sysc/qt/time/assim b/ext/systemc/src/sysc/qt/time/assim
new file mode 100755
index 000000000..6c4c52183
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/time/assim
@@ -0,0 +1,42 @@
+#! /bin/awk -f
+
+BEGIN {
+  nmach = 0;
+
+  init_test = "1";
+  abort_test = "6";
+  blocki_test = "7";
+  block_test = "8";
+}
+
+{
+  mach = $1
+  test = $2
+  iter = $3
+  time = $6 + $8
+
+  if (machi[mach] == 0) {
+    machn[nmach] = mach;
+    machi[mach] = 1;
+    ++nmach;
+  }
+
+  us_per_op = time / iter * 1000000
+  times[mach "_" test] = us_per_op;
+}
+
+
+END {
+  for (i=0; i<nmach; ++i) {
+    m = machn[i];
+    init = times[m "_" init_test];
+    printf ("init %s | %f\n", m, init);
+
+    init_abort_blocki = times[m "_" abort_test];
+    abort_blocki = init_abort_blocki - init;
+    blocki = times[m "_" blocki_test];
+    abort = abort_blocki - blocki;
+    blockf = times[m "_" block_test];
+    printf ("swap %s | %f | %f | %f\n", m, abort, blocki, blockf);
+  }
+}
diff --git a/ext/systemc/src/sysc/qt/time/cswap b/ext/systemc/src/sysc/qt/time/cswap
new file mode 100755
index 000000000..0ec811bcd
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/time/cswap
@@ -0,0 +1,37 @@
+#! /bin/awk -f
+
+BEGIN {
+  purpose = "report time used by int only and int+fp cswaps";
+
+  nmach = 0;
+
+  test_int = "7";
+  test_fp = "8";
+}
+
+{
+  mach = $1
+  test = $2
+  iter = $3
+  time = $6 + $8
+
+  if (machi[mach] == 0) {
+    machn[nmach] = mach;
+    machi[mach] = 1;
+    ++nmach;
+  }
+
+  us_per_op = time / iter * 1000000
+  times[mach "_" test] = us_per_op;
+}
+
+
+END {
+  for (i=0; i<nmach; ++i) {
+    m = machn[i];
+
+    integer = times[m "_" test_int];
+    fp = times[m "_" test_fp];
+    printf ("%s|%3.1f|%3.1f\n", m, integer, fp);
+  }
+}
diff --git a/ext/systemc/src/sysc/qt/time/go b/ext/systemc/src/sysc/qt/time/go
new file mode 100755
index 000000000..489d53882
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/time/go
@@ -0,0 +1,43 @@
+#! /bin/awk -f
+
+BEGIN {
+  purpose = "report times used for init/start/stop";
+
+  nmach = 0;
+
+  test_single = "6";
+  test_v0 = "10";
+  test_v2 = "11";
+  test_v4 = "12";
+  test_v8 = "13";
+}
+
+{
+  mach = $1
+  test = $2
+  iter = $3
+  time = $6 + $8
+
+  if (machi[mach] == 0) {
+    machn[nmach] = mach;
+    machi[mach] = 1;
+    ++nmach;
+  }
+
+  us_per_op = time / iter * 1000000
+  times[mach "_" test] = us_per_op;
+}
+
+
+END {
+  for (i=0; i<nmach; ++i) {
+    m = machn[i];
+
+    single = times[m "_" test_single];
+    v0 = times[m "_" test_v0];
+    v2 = times[m "_" test_v2];
+    v4 = times[m "_" test_v4];
+    v8 = times[m "_" test_v8];
+    printf ("%s|%3.1f|%3.1f|%3.1f|%3.1f|%3.1f\n", m, single, v0, v2, v4, v8);
+  }
+}
diff --git a/ext/systemc/src/sysc/qt/time/init b/ext/systemc/src/sysc/qt/time/init
new file mode 100755
index 000000000..8bcbf3428
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/time/init
@@ -0,0 +1,42 @@
+#! /bin/awk -f
+
+BEGIN {
+  purpose = "Report time used to initialize a thread."
+  nmach = 0;
+
+  test_single = "1";
+  test_v0 = "14";
+  test_v2 = "15";
+  test_v4 = "16";
+  test_v8 = "17";
+}
+
+{
+  mach = $1
+  test = $2
+  iter = $3
+  time = $6 + $8
+
+  if (machi[mach] == 0) {
+    machn[nmach] = mach;
+    machi[mach] = 1;
+    ++nmach;
+  }
+
+  us_per_op = time / iter * 1000000
+  times[mach "_" test] = us_per_op;
+}
+
+
+END {
+  for (i=0; i<nmach; ++i) {
+    m = machn[i];
+
+    single = times[m "_" test_single];
+    v0 = times[m "_" test_v0];
+    v2 = times[m "_" test_v2];
+    v4 = times[m "_" test_v4];
+    v8 = times[m "_" test_v8];
+    printf ("%s|%3.1f|%3.1f|%3.1f|%3.1f|%3.1f\n", m, single, v0, v2, v4, v8);
+  }
+}
diff --git a/ext/systemc/src/sysc/qt/time/prim b/ext/systemc/src/sysc/qt/time/prim
new file mode 100755
index 000000000..22b323f6f
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/time/prim
@@ -0,0 +1,41 @@
+#! /bin/awk -f
+
+BEGIN {
+  purpose = "report times for microbenchmarks"
+
+  nmach = 0;
+
+  test_callind = "18";
+  test_callimm = "18";
+  test_addreg = "20";
+  test_loadreg = "21";
+}
+
+{
+  mach = $1
+  test = $2
+  iter = $3
+  time = $6 + $8
+
+  if (machi[mach] == 0) {
+    machn[nmach] = mach;
+    machi[mach] = 1;
+    ++nmach;
+  }
+
+  ns_per_op = time / iter * 1000000
+  times[mach "_" test] = ns_per_op;
+}
+
+
+END {
+  for (i=0; i<nmach; ++i) {
+    m = machn[i];
+
+    ind = times[m "_" test_callind];
+    imm = times[m "_" test_callimm];
+    add = times[m "_" test_addreg];
+    load = times[m "_" test_loadreg];
+    printf ("%s|%1.3f|%1.3f|%1.3f|%1.3f\n", m, ind, imm, add, load);
+  }
+}
diff --git a/ext/systemc/src/sysc/qt/time/raw b/ext/systemc/src/sysc/qt/time/raw
new file mode 100755
index 000000000..96ae10ad1
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/time/raw
@@ -0,0 +1,58 @@
+#! /bin/csh
+
+rm -f timed
+
+set init=1
+set runone=6
+set blockint=7
+set blockfloat=8
+set vainit0=14
+set vainit2=15
+set vainit4=16
+set vainit8=17
+set vastart0=10
+set vastart2=11
+set vastart4=12
+set vastart8=13
+set bench_regcall=18
+set bench_immcall=19
+set bench_add=20
+set bench_load=21
+
+source configuration
+
+echo -n $config_machine $init $config_init
+/bin/time run $init $config_init
+echo -n $config_machine $runone $config_runone
+/bin/time run $runone $config_runone
+echo -n $config_machine $blockint $config_blockint
+/bin/time run $blockint $config_blockint
+echo -n $config_machine $blockfloat $config_blockfloat
+/bin/time run $blockfloat $config_blockfloat
+
+echo -n $config_machine $vainit0 $config_vainit0
+/bin/time run $vainit0 $config_vainit0
+echo -n $config_machine $vainit2 $config_vainit2
+/bin/time run $vainit2 $config_vainit2
+echo -n $config_machine $vainit4 $config_vainit4
+/bin/time run $vainit4 $config_vainit4
+echo -n $config_machine $vainit8 $config_vainit8
+/bin/time run $vainit8 $config_vainit8
+
+echo -n $config_machine $vastart0 $config_vastart0
+/bin/time run $vastart0 $config_vastart0
+echo -n $config_machine $vastart2 $config_vastart2
+/bin/time run $vastart2 $config_vastart2
+echo -n $config_machine $vastart4 $config_vastart4
+/bin/time run $vastart4 $config_vastart4
+echo -n $config_machine $vastart8 $config_vastart8
+/bin/time run $vastart8 $config_vastart8
+
+echo -n $config_machine $bench_regcall $config_bcall_reg
+/bin/time run $bench_regcall $config_bcall_reg
+echo -n $config_machine $bench_immcall $config_bcall_imm
+/bin/time run $bench_immcall $config_bcall_imm
+echo -n $config_machine $bench_add $config_b_add
+/bin/time run $bench_add $config_b_add
+echo -n $config_machine $bench_load $config_b_load
+/bin/time run $bench_load $config_b_load
diff --git a/ext/systemc/src/sysc/systemc.pc.in b/ext/systemc/src/sysc/systemc.pc.in
new file mode 100644
index 000000000..63d2e3cb7
--- /dev/null
+++ b/ext/systemc/src/sysc/systemc.pc.in
@@ -0,0 +1,41 @@
+#  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+#  more contributor license agreements.  See the NOTICE file distributed
+#  with this work for additional information regarding copyright ownership.
+#  Accellera licenses this file to you under the Apache License, Version 2.0
+#  (the "License"); you may not use this file except in compliance with the
+#  License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+#  implied.  See the License for the specific language governing
+#  permissions and limitations under the License.
+#
+# -------------------------------------------------------------------------
+#
+# systemc.pc.in --
+#    pkg-config definition file (template) for SystemC
+#    (http://www.freedesktop.org/wiki/Software/pkg-config/)
+#
+# Author: Philipp A. Hartmann, OFFIS, 2013-05-07
+#
+# Note: The "real" definition (systemc.pc) is generated by "configure"
+#       during the build configuration.
+#
+# -------------------------------------------------------------------------
+#
+TARGET_ARCH=@TARGET_ARCH@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libarchdir=@libdir@@LIB_ARCH_SUFFIX@
+includedir=@includedir@
+
+Name: @PACKAGE_NAME@
+Description: Accellera @PACKAGE_NAME@ proof-of-concept library
+Version: @PACKAGE_VERSION@
+URL: @PACKAGE_URL@
+Libs: -L${libarchdir} -l@PACKAGE@
+Libs.private: @PKGCONFIG_LDPRIV@
+Cflags: @PKGCONFIG_CFLAGS@ @PKGCONFIG_DEFINES@ -I${includedir}
diff --git a/ext/systemc/src/sysc/tracing/sc_trace.cpp b/ext/systemc/src/sysc/tracing/sc_trace.cpp
new file mode 100644
index 000000000..09a2fa3b2
--- /dev/null
+++ b/ext/systemc/src/sysc/tracing/sc_trace.cpp
@@ -0,0 +1,217 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_trace.cpp - Functions for tracing signals and variables.
+
+  Original Author: Abhijit Ghosh, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+   Acknowledgement: The tracing mechanism is based on the tracing
+   mechanism developed at Infineon (formerly Siemens HL). Though this
+   code is somewhat different, the basics are identical to what was
+   originally contributed by Infineon.  The contribution of Infineon
+   in the development of this tracing technology is hereby
+   acknowledged.
+
+ *****************************************************************************/
+
+#include <stdarg.h>
+#include <stdio.h>
+
+#include "sysc/tracing/sc_trace.h"
+#include "sysc/tracing/sc_tracing_ids.h"
+#include "sysc/communication/sc_signal_ifs.h"
+#include "sysc/utils/sc_report.h"
+#include "sysc/utils/sc_utils_ids.h"
+
+namespace sc_core {
+
+// Trace file common functions.
+
+sc_trace_file::sc_trace_file()
+{
+  /* Intentionally blank */
+}
+
+void tprintf(sc_trace_file* tf,  const char* format, ...)
+{
+    static char buffer[4096];
+    va_list ap;
+    va_start(ap, format);
+    (void) vsprintf(buffer, format, ap);
+    va_end(ap);
+    if (tf) tf->write_comment(buffer);
+}
+
+void sc_trace_file::space(int)
+{
+  /* Intentionally blank */
+}
+
+void sc_trace_file::delta_cycles(bool)
+{
+  /* Intentionally blank */
+}
+
+
+void
+sc_trace( sc_trace_file* tf,
+	  const sc_signal_in_if<char>& object,
+	  const std::string& name,
+	  int width )
+{
+    if( tf ) {
+	tf->trace( object.read(), name, width );
+    }
+}
+
+void
+sc_trace( sc_trace_file* tf,
+	  const sc_signal_in_if<short>& object,
+	  const std::string& name,
+	  int width )
+{
+    if( tf ) {
+	tf->trace( object.read(), name, width );
+    }
+}
+
+void
+sc_trace( sc_trace_file* tf,
+	  const sc_signal_in_if<int>& object,
+	  const std::string& name,
+	  int width )
+{
+    if( tf ) {
+	tf->trace( object.read(), name, width );
+    }
+}
+
+void
+sc_trace( sc_trace_file* tf,
+	  const sc_signal_in_if<long>& object,
+	  const std::string& name,
+	  int width )
+{
+    if( tf ) {
+	tf->trace( object.read(), name, width );
+    }
+}
+
+
+void
+sc_trace(sc_trace_file* /* not used */,
+	 const void* /* not used */,
+	 const std::string& name)
+{
+    SC_REPORT_WARNING( SC_ID_TRACING_OBJECT_IGNORED_, name.c_str() );
+}
+
+
+
+void double_to_special_int64(double in, unsigned* high, unsigned* low)
+{
+    double invar = in;
+    if(invar > 5e17) invar = 5e17; // Saturation limit
+    if(invar < 0.0) invar = 0.0;
+    invar += .5;
+    *high = (unsigned)(invar / 1e9);
+    double rest = invar - 1e9 * (*high);
+    if(rest < 0) *low = 0;
+    else *low = (unsigned)rest;
+}
+
+
+// ----------------------------------------------------------------------------
+
+#define DEFN_TRACE_FUNC_REF_A(tp)                                             \
+void                                                                          \
+sc_trace( sc_trace_file* tf, const tp& object, const std::string& name ) \
+{                                                                             \
+    if( tf ) {                                                                \
+	tf->trace( object, name );                                            \
+    }                                                                         \
+}
+
+#define DEFN_TRACE_FUNC_PTR_A(tp)                                             \
+void                                                                          \
+sc_trace( sc_trace_file* tf, const tp* object, const std::string& name ) \
+{                                                                             \
+    if( tf ) {                                                                \
+	tf->trace( *object, name );                                           \
+    }                                                                         \
+}
+
+#define DEFN_TRACE_FUNC_A(tp)                                                 \
+DEFN_TRACE_FUNC_REF_A(tp)                                                     \
+DEFN_TRACE_FUNC_PTR_A(tp)
+
+
+DEFN_TRACE_FUNC_A( sc_dt::sc_bit )
+DEFN_TRACE_FUNC_A( sc_dt::sc_logic )
+
+DEFN_TRACE_FUNC_A( sc_dt::sc_int_base )
+DEFN_TRACE_FUNC_A( sc_dt::sc_uint_base )
+DEFN_TRACE_FUNC_A( sc_dt::sc_signed )
+DEFN_TRACE_FUNC_A( sc_dt::sc_unsigned )
+
+DEFN_TRACE_FUNC_REF_A( sc_dt::sc_bv_base )
+DEFN_TRACE_FUNC_REF_A( sc_dt::sc_lv_base )
+
+
+#undef DEFN_TRACE_FUNC_REF_A
+#undef DEFN_TRACE_FUNC_PTR_A
+#undef DEFN_TRACE_FUNC_A
+
+
+void
+sc_trace( sc_trace_file* tf,
+	  const unsigned int& object,
+	  const std::string& name,
+	  const char** enum_literals )
+{
+    static bool warn_sc_trace_literals=true;
+    if ( warn_sc_trace_literals )
+    {
+        warn_sc_trace_literals=false;
+        SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_,
+            "tracing of enumerated literals is deprecated" );
+    }
+
+    if( tf ) tf->trace( object, name, enum_literals );
+}
+
+} // namespace sc_core
+
+// Taf!
diff --git a/ext/systemc/src/sysc/tracing/sc_trace.h b/ext/systemc/src/sysc/tracing/sc_trace.h
new file mode 100644
index 000000000..256e430a7
--- /dev/null
+++ b/ext/systemc/src/sysc/tracing/sc_trace.h
@@ -0,0 +1,397 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_trace.h - Functions for tracing signals and variables.
+
+  Author: Abhijit Ghosh, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+   Acknowledgement: The tracing mechanism is based on the tracing
+   mechanism developed at Infineon (formerly Siemens HL). Though this
+   code is somewhat different, the basics are identical to what was
+   originally contributed by Infineon.  The contribution of Infineon
+   in the development of this tracing technology is hereby
+   acknowledged.
+
+ *****************************************************************************/
+
+#ifndef SC_TRACE_H
+#define SC_TRACE_H
+
+#include <cstdio>
+
+#include "sysc/datatypes/int/sc_nbdefs.h"
+#include "sysc/kernel/sc_time.h"
+
+// Some forward declarations
+namespace sc_dt
+{
+    class sc_bit;
+    class sc_logic;
+    class sc_bv_base;
+    class sc_lv_base;
+    class sc_signed;
+    class sc_unsigned;
+    class sc_int_base;
+    class sc_uint_base;
+    class sc_fxval;
+    class sc_fxval_fast;
+    class sc_fxnum;
+    class sc_fxnum_fast;
+}
+
+namespace sc_core {
+
+class sc_time;
+
+template <class T> class sc_signal_in_if;
+
+
+// Base class for all kinds of trace files. 
+
+class sc_trace_file
+{
+    friend class sc_simcontext;
+    
+public:
+
+    // Constructor
+    sc_trace_file();
+    
+    // All functions are pure virtual because they need to be defined by the
+    // particular tracing mechanism
+
+
+#define DECL_TRACE_METHOD_A(tp)                                               \
+    virtual void trace( const tp& object,                                     \
+			const std::string& name ) = 0;
+
+#define DECL_TRACE_METHOD_B(tp)                                               \
+    virtual void trace( const tp& object,                                     \
+			const std::string& name,                                     \
+			int width ) = 0;
+
+
+    DECL_TRACE_METHOD_A( bool )
+    DECL_TRACE_METHOD_A( sc_dt::sc_bit )
+    DECL_TRACE_METHOD_A( sc_dt::sc_logic )
+
+    DECL_TRACE_METHOD_B( unsigned char )
+    DECL_TRACE_METHOD_B( unsigned short )
+    DECL_TRACE_METHOD_B( unsigned int )
+    DECL_TRACE_METHOD_B( unsigned long )
+    DECL_TRACE_METHOD_B( char )
+    DECL_TRACE_METHOD_B( short )
+    DECL_TRACE_METHOD_B( int )
+    DECL_TRACE_METHOD_B( long )
+    DECL_TRACE_METHOD_B( sc_dt::int64 )
+    DECL_TRACE_METHOD_B( sc_dt::uint64 )
+
+    DECL_TRACE_METHOD_A( float )
+    DECL_TRACE_METHOD_A( double )
+    DECL_TRACE_METHOD_A( sc_dt::sc_int_base )
+    DECL_TRACE_METHOD_A( sc_dt::sc_uint_base )
+    DECL_TRACE_METHOD_A( sc_dt::sc_signed )
+    DECL_TRACE_METHOD_A( sc_dt::sc_unsigned )
+
+    DECL_TRACE_METHOD_A( sc_dt::sc_fxval )
+    DECL_TRACE_METHOD_A( sc_dt::sc_fxval_fast )
+    DECL_TRACE_METHOD_A( sc_dt::sc_fxnum )
+    DECL_TRACE_METHOD_A( sc_dt::sc_fxnum_fast )
+
+    DECL_TRACE_METHOD_A( sc_dt::sc_bv_base )
+    DECL_TRACE_METHOD_A( sc_dt::sc_lv_base )
+
+
+#undef DECL_TRACE_METHOD_A
+#undef DECL_TRACE_METHOD_B
+
+    // Trace an enumerated object - where possible output the enumeration
+    // literals in the trace file. Enum literals is a null terminated array
+    // of null terminated char* literal strings.
+    virtual void trace( const unsigned int& object,
+			const std::string& name,
+			const char** enum_literals ) = 0;
+
+    // Output a comment to the trace file
+    virtual void write_comment( const std::string& comment ) = 0;
+
+    // Set the amount of space before next column
+    // (For most formats this does nothing)
+    virtual void space( int n );
+
+    // Also trace transitions between delta cycles if flag is true.
+    virtual void delta_cycles( bool flag );
+
+    // Set time unit.
+    virtual void set_time_unit( double v, sc_time_unit tu )=0;
+
+protected:
+
+    // Write trace info for cycle
+    virtual void cycle( bool delta_cycle ) = 0;
+
+    // Flush results and close file
+    virtual ~sc_trace_file()
+	{ /* Intentionally blank */ }
+};
+
+/*****************************************************************************/
+
+// Now comes all the SystemC defined tracing functions.
+// We define two sc_trace() versions for scalar types; one where the object to
+// be traced is passed as a reference and the other where a pointer to the
+// tracing object is passed.
+
+#define DECL_TRACE_FUNC_REF_A(tp)     \
+void                                  \
+sc_trace( sc_trace_file* tf,          \
+	  const tp& object,               \
+	  const std::string& name );
+
+#define DECL_TRACE_FUNC_PTR_A(tp)     \
+void                                  \
+sc_trace( sc_trace_file* tf,          \
+	  const tp* object,               \
+	  const std::string& name );        \
+
+#define DECL_TRACE_FUNC_A(tp)         \
+DECL_TRACE_FUNC_REF_A(tp)             \
+DECL_TRACE_FUNC_PTR_A(tp)
+
+
+DECL_TRACE_FUNC_A( sc_dt::sc_bit )
+DECL_TRACE_FUNC_A( sc_dt::sc_logic )
+
+DECL_TRACE_FUNC_A( sc_dt::sc_int_base )
+DECL_TRACE_FUNC_A( sc_dt::sc_uint_base )
+DECL_TRACE_FUNC_A( sc_dt::sc_signed )
+DECL_TRACE_FUNC_A( sc_dt::sc_unsigned )
+
+DECL_TRACE_FUNC_REF_A( sc_dt::sc_bv_base )
+DECL_TRACE_FUNC_REF_A( sc_dt::sc_lv_base )
+
+
+#undef DECL_TRACE_FUNC_REF_A
+#undef DECL_TRACE_FUNC_PTR_A
+#undef DECL_TRACE_FUNC_A
+
+
+// ----------------------------------------------------------------------------
+
+#define DEFN_TRACE_FUNC_REF_A(tp)                                             \
+inline                                                                        \
+void                                                                          \
+sc_trace( sc_trace_file* tf, const tp& object, const std::string& name ) \
+{                                                                             \
+    if( tf ) {                                                                \
+	tf->trace( object, name );                                            \
+    }                                                                         \
+}
+
+#define DEFN_TRACE_FUNC_PTR_A(tp)                                             \
+inline                                                                        \
+void                                                                          \
+sc_trace( sc_trace_file* tf, const tp* object, const std::string& name ) \
+{                                                                             \
+    if( tf ) {                                                                \
+	tf->trace( *object, name );                                           \
+    }                                                                         \
+}
+
+#define DEFN_TRACE_FUNC_A(tp)                                                 \
+DEFN_TRACE_FUNC_REF_A(tp)                                                     \
+DEFN_TRACE_FUNC_PTR_A(tp)
+
+
+#define DEFN_TRACE_FUNC_REF_B(tp)                                             \
+inline                                                                        \
+void                                                                          \
+sc_trace( sc_trace_file* tf, const tp& object, const std::string& name,  \
+          int width = 8 * sizeof( tp ) )                                      \
+{                                                                             \
+    if( tf ) {                                                                \
+	tf->trace( object, name, width );                                     \
+    }                                                                         \
+}
+
+#define DEFN_TRACE_FUNC_PTR_B(tp)                                             \
+inline                                                                        \
+void                                                                          \
+sc_trace( sc_trace_file* tf, const tp* object, const std::string& name,  \
+          int width = 8 * sizeof( tp ) )                                      \
+{                                                                             \
+    if( tf ) {                                                                \
+	tf->trace( *object, name, width );                                    \
+    }                                                                         \
+}
+
+
+#define DEFN_TRACE_FUNC_B(tp)                                                 \
+DEFN_TRACE_FUNC_REF_B(tp)                                                     \
+DEFN_TRACE_FUNC_PTR_B(tp)
+
+
+DEFN_TRACE_FUNC_A( bool )
+DEFN_TRACE_FUNC_A( float )
+DEFN_TRACE_FUNC_A( double )
+
+DEFN_TRACE_FUNC_B( unsigned char )
+DEFN_TRACE_FUNC_B( unsigned short )
+DEFN_TRACE_FUNC_B( unsigned int )
+DEFN_TRACE_FUNC_B( unsigned long )
+DEFN_TRACE_FUNC_B( char )
+DEFN_TRACE_FUNC_B( short )
+DEFN_TRACE_FUNC_B( int )
+DEFN_TRACE_FUNC_B( long )
+DEFN_TRACE_FUNC_B( sc_dt::int64 )
+DEFN_TRACE_FUNC_B( sc_dt::uint64 )
+
+
+#undef DEFN_TRACE_FUNC_REF_A
+#undef DEFN_TRACE_FUNC_PTR_A
+#undef DEFN_TRACE_FUNC_A
+
+#undef DEFN_TRACE_FUNC_REF_B
+#undef DEFN_TRACE_FUNC_PTR_B
+#undef DEFN_TRACE_FUNC_B
+
+
+template <class T> 
+inline
+void
+sc_trace( sc_trace_file* tf,
+	  const sc_signal_in_if<T>& object,
+	  const std::string& name )
+{
+    sc_trace( tf, object.read(), name );
+}
+
+template< class T >
+inline
+void
+sc_trace( sc_trace_file* tf,
+	  const sc_signal_in_if<T>& object,
+	  const char* name )
+{
+    sc_trace( tf, object.read(), name );
+}
+
+
+// specializations for signals of type char, short, int, long
+
+void sc_trace( sc_trace_file* tf,
+	       const sc_signal_in_if<char>& object,
+	       const std::string& name,
+	       int width );
+
+void sc_trace( sc_trace_file* tf,
+	       const sc_signal_in_if<short>& object,
+	       const std::string& name,
+	       int width );
+
+void sc_trace( sc_trace_file* tf,
+	       const sc_signal_in_if<int>& object,
+	       const std::string& name,
+	       int width );
+
+void sc_trace( sc_trace_file* tf,
+	       const sc_signal_in_if<long>& object,
+	       const std::string& name,
+	       int width );
+
+
+// 1. non-template function is better than template
+// 2. more-specialized template is better than less-specialized
+// 3. no partial specialization for template functions
+
+
+// Trace an enumerated object - where possible output the enumeration literals
+// in the trace file. Enum literals is a null terminated array of null
+// terminated char* literal strings.
+
+void
+sc_trace( sc_trace_file* tf,
+	  const unsigned int& object,
+	  const std::string& name,
+	  const char** enum_literals );
+
+
+// Dummy function for arbitrary types of value, does nothing
+
+extern void sc_trace( sc_trace_file* tf,
+		      const void* object,
+		      const std::string& name );
+
+
+// Turn on/off delta cycle tracing on trace file `tf'.
+// Default is to turn on delta cycle tracing.
+
+inline
+void
+sc_trace_delta_cycles( sc_trace_file* tf, bool on = true )
+{
+    if( tf ) tf->delta_cycles( on );
+}
+
+
+// Output a comment to the trace file
+
+inline
+void
+sc_write_comment( sc_trace_file* tf, const std::string& comment )
+{
+    if( tf ) tf->write_comment( comment );
+}
+
+
+// Equivalent of std::fprintf for trace files!
+
+void tprintf( sc_trace_file* tf,  const char* format, ... );
+
+// ----------------------------------------------------------------------------
+// Create VCD file
+extern sc_trace_file *sc_create_vcd_trace_file(const char* name);
+extern void sc_close_vcd_trace_file( sc_trace_file* tf );
+
+
+// ----------------------------------------------------------------------------
+// Create WIF file
+extern sc_trace_file *sc_create_wif_trace_file(const char *name);
+extern void sc_close_wif_trace_file( sc_trace_file* tf );
+
+} // namespace sc_core
+
+#endif // SC_TRACE_H
+// Taf
diff --git a/ext/systemc/src/sysc/tracing/sc_trace_file_base.cpp b/ext/systemc/src/sysc/tracing/sc_trace_file_base.cpp
new file mode 100644
index 000000000..4f4345468
--- /dev/null
+++ b/ext/systemc/src/sysc/tracing/sc_trace_file_base.cpp
@@ -0,0 +1,273 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_trace_file_base.cpp - Shared internal tracing implementation
+
+  Original Author: Philipp A. Hartmann, OFFIS, 2013-11-15
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+/*****************************************************************************
+
+   Acknowledgement: The tracing mechanism is based on the tracing
+   mechanism developed at Infineon (formerly Siemens HL). Though this
+   code is somewhat different, and significantly enhanced, the basics
+   are identical to what was originally contributed by Infineon.  The
+   contribution of Infineon in the development of this tracing
+   technology is hereby acknowledged.
+
+ *****************************************************************************/
+
+#include <ctime>
+
+#include "sysc/tracing/sc_trace_file_base.h"
+#include "sysc/kernel/sc_simcontext.h"
+#include "sysc/kernel/sc_simcontext_int.h"
+
+#if SC_TRACING_PHASE_CALLBACKS_
+#  include "sysc/kernel/sc_object_int.h"
+#endif
+
+namespace sc_core {
+
+bool sc_trace_file_base::tracing_initialized_ = false;
+
+
+sc_trace_file_base::sc_trace_file_base( const char* name, const char* extension )
+  : sc_trace_file()
+#if SC_TRACING_PHASE_CALLBACKS_
+  , sc_object( sc_gen_unique_name("$$$$kernel_tracefile$$$$") )
+#endif
+  , fp(0)
+  , timescale_unit()
+  , timescale_set_by_user(false)
+  , filename_() 
+  , initialized_(false)
+  , trace_delta_cycles_(false)
+{
+    if( !name || !*name ) {
+        SC_REPORT_ERROR( SC_ID_TRACING_FOPEN_FAILED_, "no name given" );
+        return;
+    } else {
+        std::stringstream ss;
+        ss << name << "." << extension;
+        ss.str().swap( filename_ );
+    }
+
+#if SC_TRACING_PHASE_CALLBACKS_ == 1
+    // remove from hierarchy
+    sc_object::detach();
+    // register regular (non-delta) callbacks
+    sc_object::register_simulation_phase_callback(
+        // Note: Usually, one would expect to dump the initial values
+        //       of the traced variables at the end of the initialization
+        //       phase.  The "non-callback" implementation dumps those
+        //       values only after the first delta cycle, though.
+        // SC_END_OF_INITIALIZATION |
+        SC_BEFORE_TIMESTEP |
+        SC_PAUSED | SC_STOPPED
+    );
+#else // explicitly register with simcontext
+    sc_get_curr_simcontext()->add_trace_file( this );
+#endif
+}
+
+sc_trace_file_base::~sc_trace_file_base()
+{
+    if( fp )
+        fclose(fp);
+
+#if SC_TRACING_PHASE_CALLBACKS_ == 0
+    // unregister from simcontext
+    sc_get_curr_simcontext()->remove_trace_file( this );
+#endif
+}
+
+/*****************************************************************************/
+// simulation phase callback based trigger
+//
+//  The tracing updates are triggered
+//    (- at the end of the initialization phase [disabled for now])
+//    - before an update of the simulation time
+//    - before returning to sc_start (via sc_pause() or sc_stop())
+//    - after an update phase (if delta cycles need to be traced)
+//
+#if SC_TRACING_PHASE_CALLBACKS_
+void
+sc_trace_file_base::simulation_phase_callback()
+{
+    // delta cycle is traced at the end of an update phase
+    cycle( simcontext()->get_status() == SC_END_OF_UPDATE );
+}
+#endif // SC_TRACING_PHASE_CALLBACKS_
+
+/*****************************************************************************/
+
+bool
+sc_trace_file_base::initialize()
+{
+    if( initialized_ )
+      return false;
+
+    initialized_ = true;
+
+    if( !tracing_initialized_ ) {
+        tracing_initialized_ = true;
+        bool running_regression = ( getenv( "SYSTEMC_REGRESSION" ) != NULL );
+
+        // hide some messages during regression
+        if( running_regression ) {
+          sc_report_handler::set_actions( SC_ID_TRACING_TIMESCALE_DEFAULT_
+                                        , SC_INFO,    SC_DO_NOTHING );
+          sc_report_handler::set_actions( SC_ID_TRACING_VCD_DUPLICATE_TIME_
+                                        , SC_WARNING, SC_DO_NOTHING );
+        }
+    }
+
+    // open trace file
+    if(!fp) open_fp();
+
+    // setup timescale
+    if( !timescale_set_by_user )
+    {
+        timescale_unit = sc_get_time_resolution().to_seconds();
+
+        std::stringstream ss;
+        ss << sc_get_time_resolution() << " (" << filename_ << ")";
+        SC_REPORT_INFO( SC_ID_TRACING_TIMESCALE_DEFAULT_
+                      , ss.str().c_str() );
+    }
+
+    // initialize derived tracing implementation class (VCD/WIF)
+    do_initialize();
+
+    return initialized_;
+}
+
+void
+sc_trace_file_base::open_fp()
+{
+    sc_assert( !fp );
+    fp = fopen( filename(), "w" );
+    if( !fp ) {
+        SC_REPORT_ERROR( SC_ID_TRACING_FOPEN_FAILED_, filename() );
+        std::terminate(); // can't recover from here
+    }
+}
+
+void
+sc_trace_file_base::delta_cycles( bool flag )
+{
+    trace_delta_cycles_ = flag;
+#if SC_TRACING_PHASE_CALLBACKS_
+    if( trace_delta_cycles_ ) {
+        sc_object::register_simulation_phase_callback( SC_END_OF_UPDATE );
+    } else {
+        sc_object::unregister_simulation_phase_callback( SC_END_OF_UPDATE );
+    }
+#endif
+}
+
+void
+sc_trace_file_base::set_time_unit( double v, sc_time_unit tu )
+{
+    if( initialized_ )
+    {
+        std::stringstream ss;
+        ss << filename_ << "\n"
+           "\tTimescale unit cannot be changed once tracing has begun.\n"
+           "\tTo change the scale, create a new trace file.";
+        SC_REPORT_ERROR( SC_ID_TRACING_ALREADY_INITIALIZED_
+                       , ss.str().c_str() );
+        return;
+    }
+
+    switch ( tu )
+    {
+      case SC_FS:  v = v * 1e-15; break;
+      case SC_PS:  v = v * 1e-12; break;
+      case SC_NS:  v = v * 1e-9;  break;
+      case SC_US:  v = v * 1e-6;  break;
+      case SC_MS:  v = v * 1e-3;  break;
+      case SC_SEC:                break;
+      default: {
+            std::stringstream ss;
+            ss << "unknown time unit:" << tu
+               << " (" << filename_ << ")";
+            SC_REPORT_WARNING( SC_ID_TRACING_TIMESCALE_UNIT_
+                             , ss.str().c_str() );
+        }
+    }
+
+    timescale_set_by_user = true;
+    timescale_unit = v;
+
+    // EMIT ADVISORY MESSAGE ABOUT CHANGE IN TIME SCALE:
+    {
+      std::stringstream ss;
+      ss << sc_time( timescale_unit, SC_SEC )
+         << " (" << filename_ << ")";
+      SC_REPORT_INFO( SC_ID_TRACING_TIMESCALE_UNIT_, ss.str().c_str() );
+    }
+}
+
+bool
+sc_trace_file_base::add_trace_check( const std::string & name ) const
+{
+    if( !initialized_ ) return true;
+
+    std::stringstream ss;
+    ss << "sc_trace() failed:\n"
+         "\tNo traces can be added to "
+         "'" << filename_  << "'"
+         " once trace recording has started.\n"
+         "\tTo add tracing of '" << name << "', create a new trace file.";
+
+    SC_REPORT_ERROR( SC_ID_TRACING_ALREADY_INITIALIZED_
+                   , ss.str().c_str() );
+    return false;
+}
+
+// obtain formatted time string
+std::string localtime_string()
+{
+    char buf[200];
+    time_t long_time;
+    time(&long_time);
+    struct tm* p_tm = localtime(&long_time);
+    strftime(buf, 199, "%b %d, %Y       %H:%M:%S", p_tm);
+    return buf;
+}
+
+
+} // namespace sc_core
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+// Taf!
diff --git a/ext/systemc/src/sysc/tracing/sc_trace_file_base.h b/ext/systemc/src/sysc/tracing/sc_trace_file_base.h
new file mode 100644
index 000000000..c0217266f
--- /dev/null
+++ b/ext/systemc/src/sysc/tracing/sc_trace_file_base.h
@@ -0,0 +1,140 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_trace_file_base.h - Shared internal tracing implementation
+
+  Original Author: Philipp A. Hartmann, OFFIS, 2013-11-15
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+/*****************************************************************************
+
+   Acknowledgement: The tracing mechanism is based on the tracing
+   mechanism developed at Infineon (formerly Siemens HL). Though this
+   code is somewhat different, and significantly enhanced, the basics
+   are identical to what was originally contributed by Infineon.  The
+   contribution of Infineon in the development of this tracing
+   technology is hereby acknowledged.
+
+ *****************************************************************************/
+
+#ifndef SC_TRACE_FILE_BASE_H_INCLUDED_
+#define SC_TRACE_FILE_BASE_H_INCLUDED_
+
+#include <cstdio>
+
+// use callback-based tracing implementation
+#if defined( SC_ENABLE_SIMULATION_PHASE_CALLBACKS_TRACING )
+#  define SC_TRACING_PHASE_CALLBACKS_ 1
+#  include "sysc/kernel/sc_object.h"
+#else
+#  define SC_TRACING_PHASE_CALLBACKS_ 0
+#endif
+
+#include "sysc/tracing/sc_trace.h"
+#include "sysc/tracing/sc_tracing_ids.h"
+
+namespace sc_core {
+
+// shared implementation of trace files
+class sc_trace_file_base
+  : public sc_trace_file
+#if SC_TRACING_PHASE_CALLBACKS_
+  , private sc_object // to be used as callback target
+#endif
+{
+public:
+    const char* filename() const
+      { return filename_.c_str(); }
+
+    bool delta_cycles() const
+      { return trace_delta_cycles_; }
+
+    // Also trace transitions between delta cycles if flag is true.
+    virtual void delta_cycles(bool flag);
+
+    // set a user-define timescale unit for the trace file
+    virtual void set_time_unit( double v, sc_time_unit tu);
+
+protected:
+    sc_trace_file_base( const char* name, const char* extension );
+
+    // returns true, iff initialization has been performed
+    bool initialize();
+    // ensure that file has been opened (needed for early write_comment())
+    void open_fp();
+    // perform format specific initialization
+    virtual void do_initialize() = 0;
+
+    // returns true, if new trace objects can still be added
+    // (i.e. trace file is not yet initialized)
+    bool add_trace_check( const std::string& name ) const;
+
+    // Flush results and close file.
+    virtual ~sc_trace_file_base();
+
+#if SC_TRACING_PHASE_CALLBACKS_
+private:
+    virtual void simulation_phase_callback();
+#endif // SC_TRACING_PHASE_CALLBACKS_
+
+protected:
+    FILE* fp;                          // pointer to the trace file
+    double      timescale_unit;        // in seconds
+    bool        timescale_set_by_user; // = true means set by user
+
+private:
+    std::string filename_;             // name of the file (for reporting)
+    bool        initialized_;          // tracing started?
+    bool        trace_delta_cycles_;   // also trace delta transitions?
+
+    static bool tracing_initialized_;  // shared setup of tracing implementation
+
+private: // disabled
+    sc_trace_file_base( const sc_trace_file_base& ) /* = delete */;
+    sc_trace_file_base& operator=( const sc_trace_file_base& ) /* = delete */;
+
+}; // class sc_trace_file_base
+
+// -----------------------------------------------------------------------
+
+// Convert double time to 64-bit integer
+
+void double_to_special_int64( double in, unsigned* high, unsigned* low );
+
+// obtain formatted time string
+std::string localtime_string();
+
+} // namespace sc_core
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+#endif // SC_TRACE_FILE_BASE_H_INCLUDED_
+// Taf!
diff --git a/ext/systemc/src/sysc/tracing/sc_tracing_ids.h b/ext/systemc/src/sysc/tracing/sc_tracing_ids.h
new file mode 100644
index 000000000..dacdb9451
--- /dev/null
+++ b/ext/systemc/src/sysc/tracing/sc_tracing_ids.h
@@ -0,0 +1,79 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_tracing_ids.h -- Report ids for the tracing code.
+
+  Original Author: Philipp A. Hartmann, OFFIS, 2013-11-17
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+#ifndef SC_TRACING_IDS_H
+#define SC_TRACING_IDS_H
+
+// ----------------------------------------------------------------------------
+//  Report ids (tracing)
+//
+//  Report ids in the range of 700-799.
+// ----------------------------------------------------------------------------
+
+#ifndef SC_DEFINE_MESSAGE
+#define SC_DEFINE_MESSAGE(id,unused1,unused2) \
+    namespace sc_core { extern const char id[]; }
+#endif
+
+SC_DEFINE_MESSAGE( SC_ID_TRACING_FOPEN_FAILED_,         701,
+                   "cannot open tracefile for writing" )
+
+SC_DEFINE_MESSAGE( SC_ID_TRACING_TIMESCALE_DEFAULT_,    702,
+                  "default timescale unit used for tracing" )
+SC_DEFINE_MESSAGE( SC_ID_TRACING_TIMESCALE_UNIT_,       703,
+                   "tracing timescale unit set" )
+SC_DEFINE_MESSAGE( SC_ID_TRACING_VCD_DELTA_CYCLE_,      704,
+   "VCD delta cycle tracing with pseudo timesteps (1 unit)" )
+/* unused IDs 705-709 */
+SC_DEFINE_MESSAGE( SC_ID_TRACING_OBJECT_IGNORED_,       710,
+                   "object cannot not be traced" )
+SC_DEFINE_MESSAGE( SC_ID_TRACING_OBJECT_NAME_FILTERED_, 711,
+                   "traced object name filtered" )
+SC_DEFINE_MESSAGE( SC_ID_TRACING_INVALID_ENUM_VALUE_,   712,
+                "traced value of enumerated type undefined" )
+SC_DEFINE_MESSAGE( SC_ID_TRACING_VCD_DUPLICATE_TIME_,   713,
+  "multiple VCD tracing cycles with the same time detected" )
+SC_DEFINE_MESSAGE( SC_ID_TRACING_VCD_REVERSED_TIME_,    714,
+             "VCD tracing cycle with falling time detected" )
+/* unused IDs 715-719 */
+SC_DEFINE_MESSAGE( SC_ID_TRACING_ALREADY_INITIALIZED_,  720,
+                   "sc_trace_file already initialized" )
+
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+#endif // SC_TRACING_IDS_H
+// Taf!
diff --git a/ext/systemc/src/sysc/tracing/sc_vcd_trace.cpp b/ext/systemc/src/sysc/tracing/sc_vcd_trace.cpp
new file mode 100644
index 000000000..616d6274d
--- /dev/null
+++ b/ext/systemc/src/sysc/tracing/sc_vcd_trace.cpp
@@ -0,0 +1,2175 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_vcd_trace.cpp - Implementation of VCD tracing.
+
+  Original Author - Abhijit Ghosh, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Ali Dasdan, Synopsys, Inc.
+  Description of Modification: - Replaced 'width' of sc_(u)int with their
+                                 'bitwidth()'.
+    
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+   Acknowledgement: The tracing mechanism is based on the tracing
+   mechanism developed at Infineon (formerly Siemens HL). Though this
+   code is somewhat different, and significantly enhanced, the basics
+   are identical to what was originally contributed by Infineon.  The
+   contribution of Infineon in the development of this tracing
+   technology is hereby acknowledged.
+
+ *****************************************************************************/
+
+
+#include <cstdlib>
+#include <string.h>
+#include <vector>
+
+#define SC_DISABLE_API_VERSION_CHECK // for in-library sc_ver.h inclusion
+
+#include "sysc/kernel/sc_simcontext.h"
+#include "sysc/kernel/sc_ver.h"
+#include "sysc/datatypes/bit/sc_bit.h"
+#include "sysc/datatypes/bit/sc_logic.h"
+#include "sysc/datatypes/bit/sc_lv_base.h"
+#include "sysc/datatypes/int/sc_signed.h"
+#include "sysc/datatypes/int/sc_unsigned.h"
+#include "sysc/datatypes/int/sc_int_base.h"
+#include "sysc/datatypes/int/sc_uint_base.h"
+#include "sysc/datatypes/fx/fx.h"
+#include "sysc/tracing/sc_vcd_trace.h"
+
+namespace sc_core {
+
+// Forward declarations for functions that come later in the file
+// Map sc_dt::sc_logic to printable VCD
+static char map_sc_logic_state_to_vcd_state(char in_char);
+
+// Remove name problems associated with [] in vcd names
+static void remove_vcd_name_problems(vcd_trace const* vcd, std::string& name);
+
+const char* vcd_types[vcd_trace_file::VCD_LAST]={"wire","real"};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : vcd_trace
+//
+//  Base class for VCD traces.
+// ----------------------------------------------------------------------------
+
+class vcd_trace
+{
+public:
+
+    vcd_trace(const std::string& name_, const std::string& vcd_name_);
+
+    // Needs to be pure virtual as has to be defined by the particular
+    // type being traced
+    virtual void write(FILE* f) = 0;
+    
+    virtual void set_width();
+
+    static const char* strip_leading_bits(const char* originalbuf);
+
+    // Comparison function needs to be pure virtual too
+    virtual bool changed() = 0;
+
+    // Make this virtual as some derived classes may overwrite
+    virtual void print_variable_declaration_line(FILE* f);
+
+    void compose_data_line(char* rawdata, char* compdata);
+    std::string compose_line(const std::string& data);
+
+    virtual ~vcd_trace();
+
+    const std::string name;
+    const std::string vcd_name;
+    const char* vcd_var_typ_name;
+    int bit_width; 
+};
+
+
+vcd_trace::vcd_trace(const std::string& name_, const std::string& vcd_name_)
+: name(name_), vcd_name(vcd_name_), vcd_var_typ_name(0), bit_width(0)
+{
+    /* Intentionally blank */
+}
+        
+void
+vcd_trace::compose_data_line(char* rawdata, char* compdata)
+{
+    sc_assert(rawdata != compdata);
+
+    if(bit_width == 0)
+    {
+        compdata[0] = '\0';
+    }
+    else
+    {
+        if(bit_width == 1)
+        {
+            compdata[0] = rawdata[0];
+            strcpy(&(compdata[1]), vcd_name.c_str());
+        }
+        else
+        {
+            const char* effective_begin = strip_leading_bits(rawdata);
+            std::sprintf(compdata, "b%s %s", effective_begin, vcd_name.c_str());
+        }
+    }
+}
+
+// same as above but not that ugly
+std::string
+vcd_trace::compose_line(const std::string& data)
+{
+  if(bit_width == 0)
+    return "";
+  if(bit_width == 1)
+    return data + vcd_name;
+  return std::string("b")+strip_leading_bits(data.c_str())+" "+vcd_name;
+}
+
+void
+vcd_trace::print_variable_declaration_line(FILE* f)
+{
+    char buf[2000];
+
+    if ( bit_width <= 0 )
+    {
+        std::stringstream ss;
+        ss << "'" << name << "' has 0 bits";
+        SC_REPORT_ERROR( SC_ID_TRACING_OBJECT_IGNORED_
+                       , ss.str().c_str() );
+        return;
+    }
+
+    std::string namecopy = name; 
+    remove_vcd_name_problems(this, namecopy);
+    if ( bit_width == 1 )
+    {
+        std::sprintf(buf, "$var %s  % 3d  %s  %s       $end\n",
+                     vcd_var_typ_name,
+                     bit_width,
+                     vcd_name.c_str(),
+                     namecopy.c_str());
+    }
+    else
+    {
+        std::sprintf(buf, "$var %s  % 3d  %s  %s [%d:0]  $end\n",
+                     vcd_var_typ_name,
+                     bit_width,
+                     vcd_name.c_str(),
+                     namecopy.c_str(),
+                     bit_width-1);
+    }
+    std::fputs(buf, f);
+}
+
+void
+vcd_trace::set_width()
+{
+  /* Intentionally Blank, should be defined for each type separately */
+}
+
+const char*
+vcd_trace::strip_leading_bits(const char* originalbuf)
+{
+    //*********************************************************************
+    // - Remove multiple leading 0,z,x, and replace by only one
+    // - For example,
+    //    b000z100    -> b0z100
+    //    b00000xxx   -> b0xxx
+    //    b000        -> b0
+    //    bzzzzz1     -> bz1
+    //    bxxxz10     -> xz10
+    // - For leading 0's followed by 1, remove all leading 0's
+    //    b0000010101 -> b10101  
+
+    const char* position = originalbuf;
+
+    if( strlen(originalbuf) < 2 ||
+	(originalbuf[0] != 'z' && originalbuf[0] != 'x' &&
+	 originalbuf[0] != '0' ))
+      return originalbuf;
+
+    char first_char = *position;
+    while(*position == first_char)
+    {
+        position++;
+    }
+
+    if(first_char == '0' && *position == '1')
+        return position;
+    // else
+    return position-1;
+}
+
+vcd_trace::~vcd_trace()
+{
+  /* Intentionally Blank */
+}
+
+
+template <class T>
+class vcd_T_trace : public vcd_trace
+{
+  public:
+
+    vcd_T_trace( const T& object_,
+		 const std::string& name_,
+		 const std::string& vcd_name_,
+		 vcd_trace_file::vcd_enum type_ )
+    : vcd_trace( name_, vcd_name_ ),
+      object( object_ ),
+      old_value( object_ )
+    {
+        vcd_var_typ_name = vcd_types[type_];
+    }
+
+    void write( FILE* f )
+    {
+        std::fprintf( f, "%s", compose_line( object.to_string() ).c_str() );
+        old_value = object;
+    }
+
+    bool changed()
+        { return !(object == old_value); }
+
+    void set_width()
+        { bit_width = object.length(); }
+
+protected:
+
+    const T& object;
+    T        old_value;
+};
+
+typedef vcd_T_trace<sc_dt::sc_bv_base> vcd_sc_bv_trace;
+typedef vcd_T_trace<sc_dt::sc_lv_base> vcd_sc_lv_trace;
+
+// Trace sc_dt::sc_bv_base (sc_dt::sc_bv)
+void
+vcd_trace_file::trace(
+    const sc_dt::sc_bv_base& object, const std::string& name)
+{
+   traceT(object,name);
+}   
+
+// Trace sc_dt::sc_lv_base (sc_dt::sc_lv)
+void
+vcd_trace_file::trace(
+    const sc_dt::sc_lv_base& object, const std::string& name)
+{
+   traceT(object,name);
+}
+
+/*****************************************************************************/
+
+class vcd_bool_trace : public vcd_trace {
+public:
+    vcd_bool_trace(const bool& object_,
+		   const std::string& name_,
+		   const std::string& vcd_name_);
+    void write(FILE* f);
+    bool changed();
+
+protected:
+    const bool& object;
+    bool old_value;
+};
+
+vcd_bool_trace::vcd_bool_trace(const bool& object_,
+			       const std::string& name_,
+			       const std::string& vcd_name_)
+: vcd_trace(name_, vcd_name_), object(object_), old_value(object_)
+{
+    vcd_var_typ_name = "wire";
+    bit_width = 1;
+}
+
+bool
+vcd_bool_trace::changed()
+{
+    return object != old_value;
+}
+
+void
+vcd_bool_trace::write(FILE* f)
+{
+    if (object == true) std::fputc('1', f);
+    else std::fputc('0', f);
+
+    std::fprintf(f,"%s", vcd_name.c_str());
+
+    old_value = object;
+}
+
+//*****************************************************************************
+
+class vcd_sc_bit_trace : public vcd_trace {
+public:
+    vcd_sc_bit_trace(const sc_dt::sc_bit& , const std::string& , 
+    	const std::string& );
+    void write(FILE* f);
+    bool changed();
+
+protected:
+    const sc_dt::sc_bit& object;
+    sc_dt::sc_bit old_value;
+};
+
+vcd_sc_bit_trace::vcd_sc_bit_trace( const sc_dt::sc_bit& object_,
+				    const std::string& name,
+				    const std::string& vcd_name)
+: vcd_trace(name, vcd_name), object( object_ ), old_value( object_ )
+{
+    vcd_var_typ_name = "wire";
+    bit_width = 1;
+}
+
+bool
+vcd_sc_bit_trace::changed()
+{
+    return object != old_value;
+}
+
+void
+vcd_sc_bit_trace::write(FILE* f)
+{
+    if (object == true) std::fputc('1', f);
+    else std::fputc('0', f);
+
+    std::fprintf(f,"%s", vcd_name.c_str());
+
+    old_value = object;
+}
+
+/*****************************************************************************/
+
+class vcd_sc_logic_trace : public vcd_trace {
+public:
+    vcd_sc_logic_trace(const sc_dt::sc_logic& object_,
+		       const std::string& name_,
+		       const std::string& vcd_name_);
+    void write(FILE* f);
+    bool changed();
+
+protected:    
+    const sc_dt::sc_logic& object;
+    sc_dt::sc_logic old_value;
+};
+
+
+vcd_sc_logic_trace::vcd_sc_logic_trace(const sc_dt::sc_logic& object_,
+				       const std::string& name_,
+				       const std::string& vcd_name_) 
+: vcd_trace(name_, vcd_name_), object(object_), old_value(object_)
+{
+    vcd_var_typ_name = "wire";
+    bit_width = 1;
+}
+
+
+bool
+vcd_sc_logic_trace::changed()
+{
+    return object != old_value;
+}
+
+
+void
+vcd_sc_logic_trace::write(FILE* f)
+{
+    char out_char;
+    out_char = map_sc_logic_state_to_vcd_state(object.to_char());
+    std::fputc(out_char, f); 
+
+    std::fprintf(f,"%s", vcd_name.c_str());
+
+    old_value = object;
+}
+
+
+/*****************************************************************************/
+
+class vcd_sc_unsigned_trace : public vcd_trace {
+public:
+    vcd_sc_unsigned_trace(const sc_dt::sc_unsigned& object,
+			  const std::string& name_,
+			  const std::string& vcd_name_);
+    void write(FILE* f);
+    bool changed();
+    void set_width();
+
+protected:    
+    const sc_dt::sc_unsigned& object;
+    sc_dt::sc_unsigned old_value;
+};
+
+
+vcd_sc_unsigned_trace::vcd_sc_unsigned_trace(const sc_dt::sc_unsigned& object_,
+					     const std::string& name_,
+					     const std::string& vcd_name_) 
+: vcd_trace(name_, vcd_name_), object(object_), old_value(object_.length())
+// The last may look strange, but is correct
+{
+    vcd_var_typ_name = "wire";
+    old_value = object;
+}
+
+bool
+vcd_sc_unsigned_trace::changed()
+{
+    return object != old_value;
+}
+
+void
+vcd_sc_unsigned_trace::write(FILE* f)
+{
+    static std::vector<char> compdata(1024), rawdata(1024);
+    typedef std::vector<char>::size_type size_t;
+
+    if ( compdata.size() < (size_t)object.length() ) {
+        size_t sz = ( (size_t)object.length() + 4096 ) & (~(size_t)(4096-1));
+        std::vector<char>( sz ).swap( compdata ); // resize without copying values
+        std::vector<char>( sz ).swap( rawdata );
+    }
+    char *rawdata_ptr  = &rawdata[0];
+
+    for (int bitindex = object.length() - 1; bitindex >= 0; --bitindex) {
+        *rawdata_ptr++ = "01"[object[bitindex].to_bool()];
+    }
+    *rawdata_ptr = '\0';
+    compose_data_line(&rawdata[0], &compdata[0]);
+
+    std::fputs(&compdata[0], f);
+    old_value = object;
+}
+
+void
+vcd_sc_unsigned_trace::set_width()
+{
+    bit_width = object.length();
+}
+
+
+/*****************************************************************************/
+
+class vcd_sc_signed_trace : public vcd_trace {
+public:
+    vcd_sc_signed_trace(const sc_dt::sc_signed& object,
+			const std::string& name_,
+			const std::string& vcd_name_);
+    void write(FILE* f);
+    bool changed();
+    void set_width();
+
+protected:    
+    const sc_dt::sc_signed& object;
+    sc_dt::sc_signed old_value;
+};
+
+
+vcd_sc_signed_trace::vcd_sc_signed_trace(const sc_dt::sc_signed& object_,
+					 const std::string& name_,
+					 const std::string& vcd_name_) 
+: vcd_trace(name_, vcd_name_), object(object_), old_value(object_.length())
+{
+    vcd_var_typ_name = "wire";
+    old_value = object;
+}
+
+bool
+vcd_sc_signed_trace::changed()
+{
+    return object != old_value;
+}
+
+void
+vcd_sc_signed_trace::write(FILE* f)
+{
+    static std::vector<char> compdata(1024), rawdata(1024);
+    typedef std::vector<char>::size_type size_t;
+
+    if ( compdata.size() < (size_t)object.length() ) {
+        size_t sz = ( (size_t)object.length() + 4096 ) & (~(size_t)(4096-1));
+        std::vector<char>( sz ).swap( compdata ); // resize without copying values
+        std::vector<char>( sz ).swap( rawdata );
+    }
+    char *rawdata_ptr  = &rawdata[0];
+
+    for (int bitindex = object.length() - 1; bitindex >= 0; --bitindex) {
+        *rawdata_ptr++ = "01"[object[bitindex].to_bool()];
+    }
+    *rawdata_ptr = '\0';
+    compose_data_line(&rawdata[0], &compdata[0]);
+
+    std::fputs(&compdata[0], f);
+    old_value = object;
+}
+
+void
+vcd_sc_signed_trace::set_width()
+{
+    bit_width = object.length();
+}
+
+/*****************************************************************************/
+
+class vcd_sc_uint_base_trace : public vcd_trace {
+public:
+    vcd_sc_uint_base_trace(const sc_dt::sc_uint_base& object,
+			   const std::string& name_,
+			   const std::string& vcd_name_);
+    void write(FILE* f);
+    bool changed();
+    void set_width();
+
+protected:    
+    const sc_dt::sc_uint_base& object;
+    sc_dt::sc_uint_base old_value;
+};
+
+
+vcd_sc_uint_base_trace::vcd_sc_uint_base_trace(
+                                          const sc_dt::sc_uint_base& object_,
+					  const std::string& name_,
+					  const std::string& vcd_name_)
+: vcd_trace(name_, vcd_name_), object(object_), old_value(object_.length())
+// The last may look strange, but is correct
+{
+    vcd_var_typ_name = "wire";
+    old_value = object;
+}
+
+bool
+vcd_sc_uint_base_trace::changed()
+{
+    return object != old_value;
+}
+
+void
+vcd_sc_uint_base_trace::write(FILE* f)
+{
+    char rawdata[1000], *rawdata_ptr = rawdata;
+    char compdata[1000];
+
+    int bitindex;
+    for (bitindex = object.length()-1; bitindex >= 0; --bitindex) {
+        *rawdata_ptr++ = "01"[object[bitindex].to_bool()];
+    }
+    *rawdata_ptr = '\0';
+    compose_data_line(rawdata, compdata);
+
+    std::fputs(compdata, f);
+    old_value = object;
+}
+
+void
+vcd_sc_uint_base_trace::set_width()
+{
+    bit_width = object.length();
+}
+
+
+/*****************************************************************************/
+
+class vcd_sc_int_base_trace : public vcd_trace {
+public:
+    vcd_sc_int_base_trace(const sc_dt::sc_int_base& object,
+			  const std::string& name_,
+			  const std::string& vcd_name_);
+    void write(FILE* f);
+    bool changed();
+    void set_width();
+
+protected:    
+    const sc_dt::sc_int_base& object;
+    sc_dt::sc_int_base old_value;
+};
+
+
+vcd_sc_int_base_trace::vcd_sc_int_base_trace(const sc_dt::sc_int_base& object_,
+					     const std::string& name_,
+					     const std::string& vcd_name_) 
+: vcd_trace(name_, vcd_name_), object(object_), old_value(object_.length())
+{
+    vcd_var_typ_name = "wire";
+    old_value = object;
+}
+
+bool
+vcd_sc_int_base_trace::changed()
+{
+    return object != old_value;
+}
+
+void
+vcd_sc_int_base_trace::write(FILE* f)
+{
+    char rawdata[1000], *rawdata_ptr = rawdata;
+    char compdata[1000];
+
+    int bitindex;
+    for (bitindex = object.length()-1; bitindex >= 0; --bitindex) {
+        *rawdata_ptr++ = "01"[object[bitindex].to_bool()];
+    }
+    *rawdata_ptr = '\0';
+    compose_data_line(rawdata, compdata);
+
+    std::fputs(compdata, f);
+    old_value = object;
+}
+
+void
+vcd_sc_int_base_trace::set_width()
+{
+    bit_width = object.length();
+}
+
+
+/*****************************************************************************/
+
+class vcd_sc_fxval_trace : public vcd_trace
+{
+public:
+
+    vcd_sc_fxval_trace( const sc_dt::sc_fxval& object,
+			const std::string& name_,
+			const std::string& vcd_name_ );
+    void write( FILE* f );
+    bool changed();
+
+protected:
+
+    const sc_dt::sc_fxval& object;
+    sc_dt::sc_fxval old_value;
+
+};
+
+vcd_sc_fxval_trace::vcd_sc_fxval_trace( const sc_dt::sc_fxval& object_,
+				        const std::string& name_,
+					const std::string& vcd_name_ )
+: vcd_trace( name_, vcd_name_ ),
+  object( object_ ), old_value( object_ )
+{
+    vcd_var_typ_name = "real";
+    bit_width = 1;
+}
+
+bool
+vcd_sc_fxval_trace::changed()
+{
+    return object != old_value;
+}
+
+void
+vcd_sc_fxval_trace::write( FILE* f )
+{
+    std::fprintf( f, "r%.16g %s", object.to_double(), vcd_name.c_str() );
+    old_value = object;
+}
+
+/*****************************************************************************/
+
+class vcd_sc_fxval_fast_trace : public vcd_trace
+{
+public:
+
+    vcd_sc_fxval_fast_trace( const sc_dt::sc_fxval_fast& object,
+			     const std::string& name_,
+			     const std::string& vcd_name_ );
+    void write( FILE* f );
+    bool changed();
+
+protected:
+
+    const sc_dt::sc_fxval_fast& object;
+    sc_dt::sc_fxval_fast old_value;
+
+};
+
+vcd_sc_fxval_fast_trace::vcd_sc_fxval_fast_trace( 
+                                        const sc_dt::sc_fxval_fast& object_,
+					const std::string& name_,
+					const std::string& vcd_name_ )
+: vcd_trace( name_, vcd_name_ ),
+  object( object_ ), old_value( object_ )
+{
+    vcd_var_typ_name = "real";
+    bit_width = 1;
+}
+
+bool
+vcd_sc_fxval_fast_trace::changed()
+{
+    return object != old_value;
+}
+
+void
+vcd_sc_fxval_fast_trace::write( FILE* f )
+{
+    std::fprintf( f, "r%.16g %s", object.to_double(), vcd_name.c_str() );
+    old_value = object;
+}
+
+/*****************************************************************************/
+
+class vcd_sc_fxnum_trace : public vcd_trace
+{
+public:
+
+    vcd_sc_fxnum_trace( const sc_dt::sc_fxnum& object,
+			const std::string& name_,
+			const std::string& vcd_name_ );
+    void write( FILE* f );
+    bool changed();
+    void set_width();
+
+protected:
+
+    const sc_dt::sc_fxnum& object;
+    sc_dt::sc_fxnum old_value;
+
+};
+
+vcd_sc_fxnum_trace::vcd_sc_fxnum_trace( const sc_dt::sc_fxnum& object_,
+				        const std::string& name_,
+					const std::string& vcd_name_ )
+: vcd_trace( name_, vcd_name_ ),
+  object( object_ ),
+  old_value( object_.m_params.type_params(),
+	     object_.m_params.enc(),
+	     object_.m_params.cast_switch(),
+	     0 )
+{
+    vcd_var_typ_name = "wire";
+    old_value = object;
+}
+
+bool
+vcd_sc_fxnum_trace::changed()
+{
+    return object != old_value;
+}
+
+void
+vcd_sc_fxnum_trace::write( FILE* f )
+{
+    static std::vector<char> compdata(1024), rawdata(1024);
+    typedef std::vector<char>::size_type size_t;
+
+    if ( compdata.size() < (size_t)object.wl() ) {
+        size_t sz = ( (size_t)object.wl() + 4096 ) & (~(size_t)(4096-1));
+        std::vector<char>( sz ).swap( compdata ); // resize without copying values
+        std::vector<char>( sz ).swap( rawdata );
+    }
+    char *rawdata_ptr  = &rawdata[0];
+
+    for(int bitindex = object.wl() - 1; bitindex >= 0; -- bitindex )
+    {
+        *rawdata_ptr ++ = "01"[object[bitindex]];
+    }
+    *rawdata_ptr = '\0';
+    compose_data_line( &rawdata[0], &compdata[0] );
+
+    std::fputs( &compdata[0], f );
+    old_value = object;
+}
+
+void
+vcd_sc_fxnum_trace::set_width()
+{
+    bit_width = object.wl();
+}
+
+/*****************************************************************************/
+
+class vcd_sc_fxnum_fast_trace : public vcd_trace
+{
+public:
+
+    vcd_sc_fxnum_fast_trace( const sc_dt::sc_fxnum_fast& object,
+			     const std::string& name_,
+			     const std::string& vcd_name_ );
+    void write( FILE* f );
+    bool changed();
+    void set_width();
+
+protected:
+
+    const sc_dt::sc_fxnum_fast& object;
+    sc_dt::sc_fxnum_fast old_value;
+
+};
+
+vcd_sc_fxnum_fast_trace::vcd_sc_fxnum_fast_trace( 
+                                        const sc_dt::sc_fxnum_fast& object_,
+					const std::string& name_,
+					const std::string& vcd_name_ )
+: vcd_trace( name_, vcd_name_ ),
+  object( object_ ),
+  old_value( object_.m_params.type_params(),
+	     object_.m_params.enc(),
+	     object_.m_params.cast_switch(),
+	     0 )
+{
+    vcd_var_typ_name = "wire";
+    old_value = object;
+}
+
+bool
+vcd_sc_fxnum_fast_trace::changed()
+{
+    return object != old_value;
+}
+
+void
+vcd_sc_fxnum_fast_trace::write( FILE* f )
+{
+    static std::vector<char> compdata(1024), rawdata(1024);
+    typedef std::vector<char>::size_type size_t;
+
+    if ( compdata.size() < (size_t)object.wl() ) {
+        size_t sz = ( (size_t)object.wl() + 4096 ) & (~(size_t)(4096-1));
+        std::vector<char>( sz ).swap( compdata ); // resize without copying values
+        std::vector<char>( sz ).swap( rawdata );
+    }
+    char *rawdata_ptr  = &rawdata[0];
+
+    for(int bitindex = object.wl() - 1; bitindex >= 0; -- bitindex )
+    {
+        *rawdata_ptr ++ = "01"[object[bitindex]];
+    }
+    *rawdata_ptr = '\0';
+    compose_data_line( &rawdata[0], &compdata[0] );
+
+    std::fputs( &compdata[0], f );
+    old_value = object;
+}
+
+void
+vcd_sc_fxnum_fast_trace::set_width()
+{
+    bit_width = object.wl();
+}
+
+
+/*****************************************************************************/
+
+class vcd_unsigned_int_trace : public vcd_trace {
+public:
+    vcd_unsigned_int_trace(const unsigned& object,
+			   const std::string& name_,
+			   const std::string& vcd_name_,
+			   int width_);
+    void write(FILE* f);
+    bool changed();
+
+protected:
+    const unsigned& object;
+    unsigned old_value;
+    unsigned mask; 
+};
+
+
+vcd_unsigned_int_trace::vcd_unsigned_int_trace(
+                                            const unsigned& object_,
+					    const std::string& name_,
+					    const std::string& vcd_name_,
+					    int width_) 
+: vcd_trace(name_, vcd_name_), object(object_), old_value( object_ ),
+  mask((unsigned)-1)
+{
+    bit_width = width_;
+    if (bit_width < 32) mask = ~(-1 << bit_width);
+
+    vcd_var_typ_name = "wire";
+}
+
+
+bool
+vcd_unsigned_int_trace::changed()
+{
+    return object != old_value;
+}
+
+
+void
+vcd_unsigned_int_trace::write(FILE* f)
+{
+    char rawdata[1000];
+    char compdata[1000];
+    int bitindex;
+
+    // Check for overflow
+    if ((object & mask) != object) {
+        for (bitindex = 0; bitindex < bit_width; bitindex++){
+            rawdata[bitindex] = 'x';
+        }
+    }
+    else{
+        unsigned bit_mask = 1 << (bit_width-1);
+        for (bitindex = 0; bitindex < bit_width; bitindex++) {
+            rawdata[bitindex] = (object & bit_mask)? '1' : '0';
+            bit_mask = bit_mask >> 1;
+        }
+    }
+    rawdata[bitindex] = '\0';
+    compose_data_line(rawdata, compdata);
+    std::fputs(compdata, f);
+    old_value = object;
+}
+
+/*****************************************************************************/
+
+class vcd_unsigned_short_trace : public vcd_trace {
+public:
+    vcd_unsigned_short_trace(const unsigned short& object,
+			     const std::string& name_,
+			     const std::string& vcd_name_,
+			     int width_);
+    void write(FILE* f);
+    bool changed();
+
+protected:
+    const unsigned short& object;
+    unsigned short old_value;
+    unsigned short mask; 
+};
+
+
+vcd_unsigned_short_trace::vcd_unsigned_short_trace(
+                                        const unsigned short& object_,
+					const std::string& name_,
+					const std::string& vcd_name_,
+					int width_) 
+: vcd_trace(name_, vcd_name_), object(object_), old_value(object_), mask(0xffff)
+{
+    bit_width = width_;
+    if (bit_width < 16) mask = (unsigned short)~(-1 << bit_width);
+
+    vcd_var_typ_name = "wire";
+}
+
+
+bool
+vcd_unsigned_short_trace::changed()
+{
+    return object != old_value;
+}
+
+
+void
+vcd_unsigned_short_trace::write(FILE* f)
+{
+    char rawdata[1000];
+    char compdata[1000];
+    int bitindex;
+
+    // Check for overflow
+    if ((object & mask) != object) {
+        for (bitindex = 0; bitindex < bit_width; bitindex++){
+            rawdata[bitindex] = 'x';
+        }
+    }
+    else{
+        unsigned bit_mask = 1 << (bit_width-1);
+        for (bitindex = 0; bitindex < bit_width; bitindex++) {
+            rawdata[bitindex] = (object & bit_mask)? '1' : '0';
+            bit_mask = bit_mask >> 1;
+        }
+    }
+    rawdata[bitindex] = '\0';
+    compose_data_line(rawdata, compdata);
+    std::fputs(compdata, f);
+    old_value = object;
+}
+
+/*****************************************************************************/
+
+class vcd_unsigned_char_trace : public vcd_trace {
+public:
+    vcd_unsigned_char_trace(const unsigned char& object,
+			    const std::string& name_,
+			    const std::string& vcd_name_,
+			    int width_);
+    void write(FILE* f);
+    bool changed();
+
+protected:
+    const unsigned char& object;
+    unsigned char old_value;
+    unsigned char mask; 
+};
+
+
+vcd_unsigned_char_trace::vcd_unsigned_char_trace(
+                                const unsigned char& object_,
+				const std::string& name_,
+				const std::string& vcd_name_,
+				int width_)
+: vcd_trace(name_, vcd_name_), object(object_), old_value(object_), mask(0xff)
+{
+    bit_width = width_;
+    if (bit_width < 8) mask = (unsigned char)~(-1 << bit_width);
+    vcd_var_typ_name = "wire";
+}
+
+
+bool vcd_unsigned_char_trace::changed()
+{
+    return object != old_value;
+}
+
+
+void vcd_unsigned_char_trace::write(FILE* f)
+{
+    char rawdata[1000];
+    char compdata[1000];
+    int bitindex;
+
+    // Check for overflow
+    if ((object & mask) != object) {
+        for (bitindex = 0; bitindex < bit_width; bitindex++){
+            rawdata[bitindex] = 'x';
+        }
+    }
+    else{
+        unsigned bit_mask = 1 << (bit_width-1);
+        for (bitindex = 0; bitindex < bit_width; bitindex++) {
+            rawdata[bitindex] = (object & bit_mask)? '1' : '0';
+            bit_mask = bit_mask >> 1;
+        }
+    }
+    rawdata[bitindex] = '\0';
+    compose_data_line(rawdata, compdata);
+    std::fputs(compdata, f);
+    old_value = object;
+}
+
+/*****************************************************************************/
+
+class vcd_unsigned_long_trace : public vcd_trace {
+public:
+    vcd_unsigned_long_trace(const unsigned long& object,
+			    const std::string& name_,
+			    const std::string& vcd_name_,
+			    int width_);
+    void write(FILE* f);
+    bool changed();
+
+protected:
+    const unsigned long& object;
+    unsigned long old_value;
+    unsigned long mask; 
+};
+
+
+vcd_unsigned_long_trace::vcd_unsigned_long_trace(
+                                const unsigned long& object_,
+				const std::string& name_,
+				const std::string& vcd_name_,
+				int width_)
+: vcd_trace(name_, vcd_name_), object(object_), old_value(object_), 
+  mask((unsigned long)-1)
+{
+    bit_width = width_;
+    if ( bit_width < (int)(sizeof(unsigned long)*8) ) 
+        mask = ~(-1L << bit_width);
+
+    vcd_var_typ_name = "wire";
+}
+
+
+bool vcd_unsigned_long_trace::changed()
+{
+    return object != old_value;
+}
+
+
+void vcd_unsigned_long_trace::write(FILE* f)
+{
+    char rawdata[1000];
+    char compdata[1000];
+    int bitindex;
+
+    // Check for overflow
+    if ((object & mask) != object) {
+        for (bitindex = 0; bitindex < bit_width; bitindex++){
+            rawdata[bitindex] = 'x';
+        }
+    }
+    else{
+        unsigned long bit_mask = 1ul << (bit_width-1);
+        for (bitindex = 0; bitindex < bit_width; bitindex++) {
+            rawdata[bitindex] = (object & bit_mask)? '1' : '0';
+            bit_mask = bit_mask >> 1;
+        }
+    }
+    rawdata[bitindex] = '\0';
+    compose_data_line(rawdata, compdata);
+    std::fputs(compdata, f);
+    old_value = object;
+}
+
+/*****************************************************************************/
+
+class vcd_signed_int_trace : public vcd_trace {
+public:
+    vcd_signed_int_trace(const int& object,
+			 const std::string& name_,
+			 const std::string& vcd_name_,
+			 int width_);
+    void write(FILE* f);
+    bool changed();
+
+protected:
+    const int& object;
+    int old_value;
+    unsigned mask; 
+};
+
+
+vcd_signed_int_trace::vcd_signed_int_trace(const signed& object_,
+					   const std::string& name_,
+					   const std::string& vcd_name_,
+					   int width_)
+: vcd_trace(name_, vcd_name_), object(object_), old_value(object_),  
+  mask((unsigned)-1)
+{
+    bit_width = width_;
+    if (bit_width < 32) mask = ~(-1 << bit_width);
+
+    vcd_var_typ_name = "wire";
+}
+
+
+bool vcd_signed_int_trace::changed()
+{
+    return object != old_value;
+}
+
+
+void vcd_signed_int_trace::write(FILE* f)
+{
+    char rawdata[1000];
+    char compdata[1000];
+    int bitindex;
+
+    // Check for overflow
+    if (((unsigned) object & mask) != (unsigned) object) {
+        for (bitindex = 0; bitindex < bit_width; bitindex++){
+            rawdata[bitindex] = 'x';
+        }
+    }
+    else{
+        unsigned bit_mask = 1 << (bit_width-1);
+        for (bitindex = 0; bitindex < bit_width; bitindex++) {
+            rawdata[bitindex] = (object & bit_mask)? '1' : '0';
+            bit_mask = bit_mask >> 1;
+        }
+    }
+    rawdata[bitindex] = '\0';
+    compose_data_line(rawdata, compdata);
+    std::fputs(compdata, f);
+    old_value = object;
+}
+
+/*****************************************************************************/
+
+class vcd_signed_short_trace : public vcd_trace {
+public:
+    vcd_signed_short_trace(const short& object,
+			   const std::string& name_,
+			   const std::string& vcd_name_,
+			   int width_);
+    void write(FILE* f);
+    bool changed();
+
+protected:
+    const short& object;
+    short old_value;
+    unsigned short mask; 
+};
+
+
+vcd_signed_short_trace::vcd_signed_short_trace(
+					const short& object_,
+					const std::string& name_,
+					const std::string& vcd_name_,
+					int width_)
+: vcd_trace(name_, vcd_name_), object(object_), old_value(object_), mask(0xffff)
+{
+    bit_width = width_;
+    if (bit_width < 16) mask = (unsigned short)~(-1 << bit_width);
+
+    vcd_var_typ_name = "wire";
+}
+
+
+bool vcd_signed_short_trace::changed()
+{
+    return object != old_value;
+}
+
+
+void vcd_signed_short_trace::write(FILE* f)
+{
+    char rawdata[1000];
+    char compdata[1000];
+    int bitindex;
+
+    // Check for overflow
+    if (((unsigned short) object & mask) != (unsigned short) object) {
+        for (bitindex = 0; bitindex < bit_width; bitindex++){
+            rawdata[bitindex] = 'x';
+        }
+    }
+    else{
+        unsigned bit_mask = 1 << (bit_width-1);
+        for (bitindex = 0; bitindex < bit_width; bitindex++) {
+            rawdata[bitindex] = (object & bit_mask)? '1' : '0';
+            bit_mask = bit_mask >> 1;
+        }
+    }
+    rawdata[bitindex] = '\0';
+    compose_data_line(rawdata, compdata);
+    std::fputs(compdata, f);
+    old_value = object;
+}
+
+/*****************************************************************************/
+
+class vcd_signed_char_trace : public vcd_trace {
+public:
+    vcd_signed_char_trace(const char& object,
+			  const std::string& name_,
+			  const std::string& vcd_name_,
+			  int width_);
+    void write(FILE* f);
+    bool changed();
+
+protected:
+    const char& object;
+    char old_value;
+    unsigned char mask; 
+};
+
+
+vcd_signed_char_trace::vcd_signed_char_trace(const char& object_,
+					     const std::string& name_,
+					     const std::string& vcd_name_,
+					     int width_)
+: vcd_trace(name_, vcd_name_), object(object_), old_value(object_), mask(0xff)
+{
+    bit_width = width_;
+    if (bit_width < 8) mask = (unsigned char)~(-1 << bit_width);
+
+    vcd_var_typ_name = "wire";
+}
+
+
+bool vcd_signed_char_trace::changed()
+{
+    return object != old_value;
+}
+
+
+void vcd_signed_char_trace::write(FILE* f)
+{
+    char rawdata[1000];
+    char compdata[1000];
+    int bitindex;
+
+    // Check for overflow
+    if (((unsigned char) object & mask) != (unsigned char) object) {
+        for (bitindex = 0; bitindex < bit_width; bitindex++){
+            rawdata[bitindex] = 'x';
+        }
+    }
+    else{
+        unsigned bit_mask = 1 << (bit_width-1);
+        for (bitindex = 0; bitindex < bit_width; bitindex++) {
+            rawdata[bitindex] = (object & bit_mask)? '1' : '0';
+            bit_mask = bit_mask >> 1;
+        }
+    }
+    rawdata[bitindex] = '\0';
+    compose_data_line(rawdata, compdata);
+    std::fputs(compdata, f);
+    old_value = object;
+}
+
+/*****************************************************************************/
+
+class vcd_int64_trace : public vcd_trace {
+public:
+    vcd_int64_trace(const sc_dt::int64& object,
+			  const std::string& name_,
+			  const std::string& vcd_name_,
+			  int width_);
+    void write(FILE* f);
+    bool changed();
+
+protected:
+    const sc_dt::int64& object;
+    sc_dt::int64 old_value;
+    sc_dt::uint64 mask; 
+};
+
+
+vcd_int64_trace::vcd_int64_trace(const sc_dt::int64& object_,
+					     const std::string& name_,
+					     const std::string& vcd_name_,
+					     int width_)
+: vcd_trace(name_, vcd_name_), object(object_), old_value(object_), 
+  mask((sc_dt::uint64)-1)
+{
+    bit_width = width_;
+    if (bit_width < 64)  mask = ~(mask << bit_width);
+    vcd_var_typ_name = "wire";
+}
+
+
+bool vcd_int64_trace::changed()
+{
+    return object != old_value;
+}
+
+
+void vcd_int64_trace::write(FILE* f)
+{
+    char rawdata[1000];
+    char compdata[1000];
+    int bitindex;
+
+    // Check for overflow
+    if (((sc_dt::uint64) object & mask) != (sc_dt::uint64) object) 
+	{
+        for (bitindex = 0; bitindex < bit_width; bitindex++)
+		{
+            rawdata[bitindex] = 'x';
+        }
+    }
+    else
+	{
+        sc_dt::uint64 bit_mask = 1;
+        bit_mask = bit_mask << (bit_width-1);
+        for (bitindex = 0; bitindex < bit_width; bitindex++) {
+            rawdata[bitindex] = (object & bit_mask)? '1' : '0';
+            bit_mask = bit_mask >> 1;
+        }
+    }
+    rawdata[bitindex] = '\0';
+    compose_data_line(rawdata, compdata);
+    std::fputs(compdata, f);
+    old_value = object;
+}
+
+
+/*****************************************************************************/
+
+class vcd_uint64_trace : public vcd_trace {
+public:
+    vcd_uint64_trace(const sc_dt::uint64& object,
+		     const std::string& name_,
+		     const std::string& vcd_name_,
+		     int width_);
+    void write(FILE* f);
+    bool changed();
+
+protected:
+    const sc_dt::uint64& object;
+    sc_dt::uint64 old_value;
+    sc_dt::uint64 mask; 
+};
+
+
+vcd_uint64_trace::vcd_uint64_trace(  const sc_dt::uint64& object_,
+				     const std::string& name_,
+				     const std::string& vcd_name_,
+				     int width_)
+: vcd_trace(name_, vcd_name_), object(object_), old_value(object_),
+  mask((sc_dt::uint64)-1)
+{
+    bit_width = width_;
+    if ( bit_width < 64 ) mask = ~(mask << bit_width);
+    vcd_var_typ_name = "wire";
+}
+
+
+bool vcd_uint64_trace::changed()
+{
+    return object != old_value;
+}
+
+
+void vcd_uint64_trace::write(FILE* f)
+{
+    char rawdata[1000];
+    char compdata[1000];
+    int bitindex;
+
+    // Check for overflow
+    if ((object & mask) != object) 
+	{
+        for (bitindex = 0; bitindex < bit_width; bitindex++){
+            rawdata[bitindex] = 'x';
+        }
+    }
+    else
+	{
+        sc_dt::uint64 bit_mask = 1;
+        bit_mask = bit_mask << (bit_width-1);
+        for (bitindex = 0; bitindex < bit_width; bitindex++) 
+		{
+            rawdata[bitindex] = (object & bit_mask)? '1' : '0';
+            bit_mask = bit_mask >> 1;
+        }
+    }
+    rawdata[bitindex] = '\0';
+    compose_data_line(rawdata, compdata);
+    std::fputs(compdata, f);
+    old_value = object;
+}
+
+
+/*****************************************************************************/
+
+class vcd_signed_long_trace : public vcd_trace {
+public:
+    vcd_signed_long_trace(const long& object,
+			  const std::string& name_,
+			  const std::string& vcd_name_,
+			  int width_);
+    void write(FILE* f);
+    bool changed();
+
+protected:
+    const long& object;
+    long old_value;
+    unsigned long mask; 
+};
+
+
+vcd_signed_long_trace::vcd_signed_long_trace(const long& object_,
+					     const std::string& name_,
+					     const std::string& vcd_name_,
+					     int width_)
+: vcd_trace(name_, vcd_name_), object(object_), old_value(object_),
+  mask((unsigned long)-1)
+{
+    bit_width = width_;
+    if ( bit_width < (int)(sizeof(long)*8) ) 
+        mask = ~(-1L << bit_width);
+    vcd_var_typ_name = "wire";
+}
+
+
+bool vcd_signed_long_trace::changed()
+{
+    return object != old_value;
+}
+
+
+void vcd_signed_long_trace::write(FILE* f)
+{
+    char rawdata[1000];
+    char compdata[1000];
+    int bitindex;
+
+    // Check for overflow
+    if (((unsigned long) object & mask) != (unsigned long) object) {
+        for (bitindex = 0; bitindex < bit_width; bitindex++){
+            rawdata[bitindex] = 'x';
+        }
+    }
+    else{
+        unsigned long bit_mask = 1ul << (bit_width-1);
+        for (bitindex = 0; bitindex < bit_width; bitindex++) {
+            rawdata[bitindex] = (object & bit_mask)? '1' : '0';
+            bit_mask = bit_mask >> 1;
+        }
+    }
+    rawdata[bitindex] = '\0';
+    compose_data_line(rawdata, compdata);
+    std::fputs(compdata, f);
+    old_value = object;
+}
+
+
+/*****************************************************************************/
+
+class vcd_float_trace : public vcd_trace {
+public:
+    vcd_float_trace(const float& object,
+		    const std::string& name_,
+		    const std::string& vcd_name_);
+    void write(FILE* f);
+    bool changed();
+
+protected:    
+    const float& object;
+    float old_value;
+};
+
+vcd_float_trace::vcd_float_trace(const float& object_,
+				 const std::string& name_,
+				 const std::string& vcd_name_)
+: vcd_trace(name_, vcd_name_), object(object_)
+{
+    vcd_var_typ_name = "real";
+    bit_width = 1;
+    old_value = object;
+}
+
+bool vcd_float_trace::changed()
+{
+    return object != old_value;
+}
+
+void vcd_float_trace::write(FILE* f)
+{
+    std::fprintf(f, "r%.16g %s", object, vcd_name.c_str());
+    old_value = object;
+}
+
+/*****************************************************************************/
+
+class vcd_double_trace : public vcd_trace {
+public:
+    vcd_double_trace(const double& object,
+		     const std::string& name_,
+		     const std::string& vcd_name_);
+    void write(FILE* f);
+    bool changed();
+
+protected:    
+    const double& object;
+    double old_value;
+};
+
+vcd_double_trace::vcd_double_trace(const double& object_,
+				   const std::string& name_,
+				   const std::string& vcd_name_)
+: vcd_trace(name_, vcd_name_), object(object_), old_value(object_)
+{
+    vcd_var_typ_name = "real";
+    bit_width = 1;
+}
+
+bool vcd_double_trace::changed()
+{
+    return object != old_value;
+}
+
+void vcd_double_trace::write(FILE* f)
+{
+    std::fprintf(f, "r%.16g %s", object, vcd_name.c_str());
+    old_value = object;
+}
+
+
+/*****************************************************************************/
+
+class vcd_enum_trace : public vcd_trace {
+public:
+    vcd_enum_trace(const unsigned& object_,
+		   const std::string& name_,
+		   const std::string& vcd_name_,
+		   const char** enum_literals);
+    void write(FILE* f);
+    bool changed();
+
+protected:
+    const unsigned& object;
+    unsigned old_value;
+    unsigned mask;
+    const char** literals;
+    unsigned nliterals;
+};
+
+
+vcd_enum_trace::vcd_enum_trace(const unsigned& object_,
+			       const std::string& name_,
+			       const std::string& vcd_name_,
+			       const char** enum_literals_)
+: vcd_trace(name_, vcd_name_), object(object_), old_value(object_),
+  mask(0xffffffff), literals(enum_literals_), nliterals(0)
+{
+    // find number of bits required to represent enumeration literal - counting loop
+    for (nliterals = 0; enum_literals_[nliterals]; nliterals++) continue;
+
+    // Figure out number of bits required to represent the number of literals
+    bit_width = 0;
+    unsigned shifted_maxindex = nliterals-1;
+    while(shifted_maxindex != 0){
+        shifted_maxindex >>= 1;
+        bit_width++;
+    }
+
+    // Set the mask
+    if (bit_width < 32) {
+      mask = ~(-1 << bit_width);
+    } else {
+      mask = 0xffffffff;
+    }
+
+    vcd_var_typ_name = "wire";
+}       
+
+bool vcd_enum_trace::changed()
+{
+    return object != old_value;
+}
+
+void vcd_enum_trace::write(FILE* f)
+{
+    char rawdata[1000];
+    char compdata[1000];
+    int bitindex;
+
+    // Check for overflow
+    if ((object & mask) != object) {
+        for (bitindex = 0; bitindex < bit_width; bitindex++){
+            rawdata[bitindex] = 'x';
+        }
+    } else {
+        unsigned long bit_mask = 1ul << (bit_width-1);
+        for (bitindex = 0; bitindex < bit_width; bitindex++) {
+            rawdata[bitindex] = (object & bit_mask)? '1' : '0';
+            bit_mask = bit_mask >> 1;
+        }
+    }
+    rawdata[bitindex] = '\0';
+    compose_data_line(rawdata, compdata);
+    std::fputs(compdata, f);
+    old_value = object;
+}
+
+
+/*****************************************************************************
+           vcd_trace_file functions
+ *****************************************************************************/
+
+vcd_trace_file::vcd_trace_file(const char *name)
+  : sc_trace_file_base( name, "vcd" )
+  , vcd_name_index(0)
+  , previous_time_units_low(0)
+  , previous_time_units_high(0)
+  , traces()
+{}
+
+
+void
+vcd_trace_file::do_initialize()
+{
+    char buf[2000];
+
+    //date:
+    std::fprintf(fp, "$date\n     %s\n$end\n\n", localtime_string().c_str() );
+
+    //version:
+    std::fprintf(fp, "$version\n %s\n$end\n\n", sc_version());
+
+    //timescale:
+    static struct SC_TIMESCALE_TO_TEXT {
+        double       unit;
+        const char*  text;
+    } timescale_to_text [] = {
+        { sc_time(1, SC_FS).to_seconds(), "1 fs" },
+        { sc_time(10, SC_FS).to_seconds(), "10 fs" },
+        { sc_time(100, SC_FS).to_seconds(),"100 fs" },
+        { sc_time(1, SC_PS).to_seconds(),  "1 ps" },
+        { sc_time(10, SC_PS).to_seconds(), "10 ps" },
+        { sc_time(100, SC_PS).to_seconds(),"100 ps" },
+        { sc_time(1, SC_NS).to_seconds(),  "1 ns" },
+        { sc_time(10, SC_NS).to_seconds(), "10 ns" },
+        { sc_time(100, SC_NS).to_seconds(),"100 ns" },
+        { sc_time(1, SC_US).to_seconds(),  "1 us" },
+        { sc_time(10, SC_US).to_seconds(), "10 us" },
+        { sc_time(100, SC_US).to_seconds(),"100 us" },
+        { sc_time(1, SC_MS).to_seconds(),  "1 ms" },
+        { sc_time(10, SC_MS).to_seconds(), "10 ms" },
+        { sc_time(100, SC_MS).to_seconds(),"100 ms" },
+        { sc_time(1, SC_SEC).to_seconds(),  "1 sec" },
+        { sc_time(10, SC_SEC).to_seconds(), "10 sec" },
+        { sc_time(100, SC_SEC).to_seconds(),"100 sec" }
+    };
+    static int timescale_to_text_n =
+        sizeof(timescale_to_text)/sizeof(SC_TIMESCALE_TO_TEXT);
+
+    for ( int time_i = 0; time_i < timescale_to_text_n; time_i++ )
+    {
+        if (timescale_unit == timescale_to_text[time_i].unit)
+        {
+            std::fprintf(fp,"$timescale\n     %s\n$end\n\n",
+                timescale_to_text[time_i].text);
+            break;
+        }
+    }
+
+    // Create a dummy scope
+    std::fputs("$scope module SystemC $end\n", fp);
+
+    //variable definitions:
+    for (int i = 0; i < (int)traces.size(); i++) {
+        vcd_trace* t = traces[i];
+        t->set_width(); // needed for all vectors
+        t->print_variable_declaration_line(fp);
+    }
+
+    std::fputs("$upscope $end\n", fp);
+
+    std::fputs("$enddefinitions  $end\n\n", fp);
+
+    // double inittime = sc_simulation_time();
+    double inittime = sc_time_stamp().to_seconds();
+    
+    std::sprintf(buf,
+            "All initial values are dumped below at time "
+            "%g sec = %g timescale units.",
+            inittime, inittime/timescale_unit
+            );
+    write_comment(buf);
+
+    double_to_special_int64(inittime/timescale_unit,
+                            &previous_time_units_high,
+                            &previous_time_units_low );
+
+
+    std::fputs("$dumpvars\n",fp);
+    for (int i = 0; i < (int)traces.size(); i++) {
+        traces[i]->write(fp);
+        std::fputc('\n', fp);
+    }
+    std::fputs("$end\n\n", fp);
+}
+
+
+// ----------------------------------------------------------------------------
+
+#define DEFN_TRACE_METHOD(tp)                                                 \
+void                                                                          \
+vcd_trace_file::trace(const tp& object_, const std::string& name_)            \
+{                                                                             \
+    if( add_trace_check(name_) )                                              \
+        traces.push_back( new vcd_ ## tp ## _trace( object_,                  \
+                                                    name_,                    \
+                                                    obtain_name() ) );        \
+}
+
+DEFN_TRACE_METHOD(bool)
+DEFN_TRACE_METHOD(float)
+DEFN_TRACE_METHOD(double)
+
+#undef DEFN_TRACE_METHOD
+#define DEFN_TRACE_METHOD(tp)                                                 \
+void                                                                          \
+vcd_trace_file::trace(const sc_dt::tp& object_, const std::string& name_)     \
+{                                                                             \
+    if( add_trace_check(name_) )                                              \
+        traces.push_back( new vcd_ ## tp ## _trace( object_,                  \
+                                                    name_,                    \
+                                                    obtain_name() ) );        \
+}
+
+DEFN_TRACE_METHOD(sc_bit)
+DEFN_TRACE_METHOD(sc_logic)
+
+DEFN_TRACE_METHOD(sc_signed)
+DEFN_TRACE_METHOD(sc_unsigned)
+DEFN_TRACE_METHOD(sc_int_base)
+DEFN_TRACE_METHOD(sc_uint_base)
+
+DEFN_TRACE_METHOD(sc_fxval)
+DEFN_TRACE_METHOD(sc_fxval_fast)
+DEFN_TRACE_METHOD(sc_fxnum)
+DEFN_TRACE_METHOD(sc_fxnum_fast)
+
+#undef DEFN_TRACE_METHOD
+
+
+#define DEFN_TRACE_METHOD_SIGNED(tp)                                          \
+void                                                                          \
+vcd_trace_file::trace( const tp&          object_,                            \
+                       const std::string& name_,                              \
+                       int                width_ )                            \
+{                                                                             \
+    if( add_trace_check(name_) )                                              \
+        traces.push_back( new vcd_signed_ ## tp ## _trace( object_,           \
+                                                           name_,             \
+                                                           obtain_name(),     \
+                                                           width_ ) );        \
+}
+
+#define DEFN_TRACE_METHOD_UNSIGNED(tp)                                        \
+void                                                                          \
+vcd_trace_file::trace( const unsigned tp& object_,                            \
+                       const std::string& name_,                              \
+                       int                width_ )                            \
+{                                                                             \
+    if( add_trace_check(name_) )                                              \
+        traces.push_back( new vcd_unsigned_ ## tp ## _trace( object_,         \
+                                                             name_,           \
+                                                             obtain_name(),   \
+                                                             width_ ) );      \
+}
+
+DEFN_TRACE_METHOD_SIGNED(char)
+DEFN_TRACE_METHOD_SIGNED(short)
+DEFN_TRACE_METHOD_SIGNED(int)
+DEFN_TRACE_METHOD_SIGNED(long)
+
+DEFN_TRACE_METHOD_UNSIGNED(char)
+DEFN_TRACE_METHOD_UNSIGNED(short)
+DEFN_TRACE_METHOD_UNSIGNED(int)
+DEFN_TRACE_METHOD_UNSIGNED(long)
+
+#undef DEFN_TRACE_METHOD_SIGNED
+#undef DEFN_TRACE_METHOD_UNSIGNED
+
+#define DEFN_TRACE_METHOD_LONG_LONG(tp)                                       \
+void                                                                          \
+vcd_trace_file::trace( const sc_dt::tp&   object_,                            \
+                       const std::string& name_,                              \
+                       int                width_ )                            \
+{                                                                             \
+    if( add_trace_check(name_) )                                              \
+        traces.push_back( new vcd_ ## tp ## _trace( object_,                  \
+                                                    name_,                    \
+                                                    obtain_name(),            \
+                                                    width_ ) );               \
+}
+
+DEFN_TRACE_METHOD_LONG_LONG(int64)
+DEFN_TRACE_METHOD_LONG_LONG(uint64)
+
+#undef DEFN_TRACE_METHOD_LONG_LONG
+
+void
+vcd_trace_file::trace( const unsigned&    object_,
+                       const std::string& name_,
+                       const char**       enum_literals_ )
+{
+    if( add_trace_check(name_) )
+        traces.push_back( new vcd_enum_trace( object_,
+                                              name_,
+                                              obtain_name(),
+                                              enum_literals_ ) );
+}
+
+
+void
+vcd_trace_file::write_comment(const std::string& comment)
+{
+    if(!fp) open_fp();
+    //no newline in comments allowed, as some viewers may crash
+    std::fputs("$comment\n", fp);
+    std::fputs(comment.c_str(), fp);
+    std::fputs("\n$end\n\n", fp);
+}
+
+void
+vcd_trace_file::cycle(bool this_is_a_delta_cycle)
+{
+    unsigned this_time_units_high, this_time_units_low;
+
+    // Just to make g++ shut up in the optimized mode
+    this_time_units_high = this_time_units_low = 0;
+
+    // Trace delta cycles only when enabled
+    if (!delta_cycles() && this_is_a_delta_cycle) return;
+
+    // Check for initialization
+    if( initialize() ) {
+        return;
+    };
+
+
+    double now_units = sc_time_stamp().to_seconds() / timescale_unit;
+    unsigned now_units_high, now_units_low;
+    double_to_special_int64(now_units, &now_units_high, &now_units_low );
+
+    bool now_later_than_previous_time = false;
+    if( (now_units_low > previous_time_units_low 
+        && now_units_high == previous_time_units_high)
+        || now_units_high > previous_time_units_high){
+        now_later_than_previous_time = true;
+    }
+
+    bool now_equals_previous_time = false;
+    if(now_later_than_previous_time){
+        this_time_units_high = now_units_high;
+        this_time_units_low = now_units_low;
+    } else {
+        if( now_units_low == previous_time_units_low
+	    && now_units_high == previous_time_units_high){
+	    now_equals_previous_time = true;
+            this_time_units_high = now_units_high;
+            this_time_units_low = now_units_low;
+	}
+    }
+
+    // Since VCD does not understand 0 time progression, we have to fake
+    // delta cycles with progressing time by one unit
+    if(this_is_a_delta_cycle){
+        this_time_units_high = previous_time_units_high;
+        this_time_units_low = previous_time_units_low + 1;
+        if(this_time_units_low == 1000000000){
+            this_time_units_high++;
+            this_time_units_low=0;
+        }
+        static bool warned = false;
+        if(!warned){
+            SC_REPORT_INFO( SC_ID_TRACING_VCD_DELTA_CYCLE_
+                          , sc_time( timescale_unit, SC_SEC )
+                              .to_string().c_str() );
+            warned = true;
+        }
+    }
+
+
+    // Not a delta cycle and time has not progressed
+    if( ! this_is_a_delta_cycle && now_equals_previous_time &&
+	( now_units_high != 0 || now_units_low != 0 ) ) {
+	// Don't print the message at time zero
+        static bool warned = false;
+        if( ! warned ) {
+            std::stringstream ss;
+            ss << "units count: " << now_units_low << "\n"
+               "\tWaveform viewers will only show the states of the last one.\n"
+               "\tUse `tracefile->set_time_unit(double, sc_time_unit);'"
+                  " to increase the time resolution.";
+            SC_REPORT_WARNING( SC_ID_TRACING_VCD_DUPLICATE_TIME_
+                             , ss.str().c_str() );
+            // warned = true;
+        }
+    }
+
+    // Not a delta cycle and time has gone backward
+    // This will happen with large number of delta cycles between two real
+    // advances of time
+    if(!this_is_a_delta_cycle && !now_equals_previous_time && 
+        !now_later_than_previous_time){
+        static bool warned = false;
+        if(!warned) {
+            std::stringstream ss;
+            ss << "units count (" 
+               << previous_time_units_low << "->" << now_units_low << ")\n"
+               "\tThis can occur when delta cycling is activated."
+                  " Cycles with falling time are not shown.\n"
+               "\tUse `tracefile->set_time_unit(double, sc_time_unit);'"
+                  " to increase the time resolution.";
+            SC_REPORT_WARNING( SC_ID_TRACING_VCD_DUPLICATE_TIME_
+                             , ss.str().c_str() );
+            // warned = true;
+        }
+        // Note that we don't set this_time_units_high/low to any value only
+        // in this case because we are not going to do any tracing. In the
+        // optimized mode, the compiler complains because of this. Therefore,
+        // we include the lines at the very beginning of this function to make
+        // the compiler shut up.
+        return; 
+    }
+
+    // Now do the actual printing 
+    bool time_printed = false;
+    vcd_trace* const* const l_traces = &traces[0];
+    for (int i = 0; i < (int)traces.size(); i++) {
+        vcd_trace* t = l_traces[i];
+        if(t->changed()){
+            if(time_printed == false){
+                char buf[200];
+                if(this_time_units_high){
+                    std::sprintf(buf, "#%u%09u", this_time_units_high, this_time_units_low);
+                }
+                else{ 
+                    std::sprintf(buf, "#%u", this_time_units_low);
+                }
+                std::fputs(buf, fp);
+                std::fputc('\n', fp);
+                time_printed = true;
+            }
+
+	    // Write the variable
+            t->write(fp);
+            std::fputc('\n', fp);
+        }
+    }
+    // Put another newline after all values are printed
+    if(time_printed) std::fputc('\n', fp);
+
+    if(time_printed){
+        // We update previous_time_units only when we print time because
+        // this field stores the previous time that was printed, not the
+        // previous time this function was called
+        previous_time_units_high = this_time_units_high;
+        previous_time_units_low = this_time_units_low;
+    }
+}
+
+#if 0
+void
+vcd_trace_file::create_vcd_name(std::string* p_destination)
+{
+    obtain_name.swap( *p_destination );
+}
+#endif
+
+// Create a VCD name for a variable
+std::string
+vcd_trace_file::obtain_name()
+{
+    const char first_type_used = 'a';
+    const int used_types_count = 'z' - 'a' + 1;
+    int result;
+
+    result = vcd_name_index;
+    char char6 = (char)(vcd_name_index % used_types_count);
+
+    result = result / used_types_count;
+    char char5 = (char)(result % used_types_count);
+
+    result = result / used_types_count;
+    char char4 = (char)(result % used_types_count);
+
+    result = result / used_types_count;
+    char char3 = (char)(result % used_types_count);
+
+    result = result / used_types_count;
+    char char2 = (char)(result % used_types_count);
+
+    char buf[20];
+    std::sprintf(buf, "%c%c%c%c%c",
+            char2 + first_type_used,
+            char3 + first_type_used,
+            char4 + first_type_used,
+            char5 + first_type_used,
+            char6 + first_type_used);
+    vcd_name_index++;
+    return std::string(buf);
+}
+
+vcd_trace_file::~vcd_trace_file()
+{
+    for( int i = 0; i < (int)traces.size(); i++ ) {
+        vcd_trace* t = traces[i];
+        delete t;
+    }
+}
+
+
+// Functions specific to VCD tracing
+
+static char
+map_sc_logic_state_to_vcd_state(char in_char)
+{
+    char out_char;
+
+    switch(in_char){
+        case 'U':
+        case 'X': 
+        case 'W':
+        case 'D':
+            out_char = 'x';
+            break;
+        case '0':
+        case 'L':
+            out_char = '0';
+            break;
+        case  '1':
+        case  'H': 
+            out_char = '1';
+            break;
+        case  'Z': 
+            out_char = 'z';
+            break;
+        default:
+            out_char = '?';
+    }
+
+    return out_char;
+}
+
+
+
+
+static
+void
+remove_vcd_name_problems(vcd_trace const* vcd, std::string& name)
+{
+    static bool warned = false;
+    bool braces_removed = false;
+    for (unsigned int i = 0; i< name.length(); i++) {
+      if (name[i] == '[') {
+	name[i] = '(';
+	braces_removed = true;
+      }
+      else if (name[i] == ']') {
+	name[i] = ')';
+	braces_removed = true;
+      }
+    }
+
+    if(braces_removed && !warned){
+        std::stringstream ss;
+        ss << vcd->name << ":\n"
+            "\tTraced objects found with name containing [], which may be\n"
+            "\tinterpreted by the waveform viewer in unexpected ways.\n"
+            "\tSo the [] is automatically replaced by ().";
+
+        SC_REPORT_WARNING( SC_ID_TRACING_OBJECT_NAME_FILTERED_
+                         , ss.str().c_str() );
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+sc_trace_file*
+sc_create_vcd_trace_file(const char * name)
+{
+    sc_trace_file * tf = new vcd_trace_file(name);
+    return tf;
+}
+
+void
+sc_close_vcd_trace_file( sc_trace_file* tf )
+{
+    vcd_trace_file* vcd_tf = static_cast<vcd_trace_file*>(tf);
+    delete vcd_tf; 
+}
+
+} // namespace sc_core
diff --git a/ext/systemc/src/sysc/tracing/sc_vcd_trace.h b/ext/systemc/src/sysc/tracing/sc_vcd_trace.h
new file mode 100644
index 000000000..760949ffb
--- /dev/null
+++ b/ext/systemc/src/sysc/tracing/sc_vcd_trace.h
@@ -0,0 +1,228 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_vcd_trace.h - Implementation of VCD tracing.
+
+  Original Author - Abhijit Ghosh, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+   Acknowledgement: The tracing mechanism is based on the tracing
+   mechanism developed at Infineon (formerly Siemens HL). Though this
+   code is somewhat different, and significantly enhanced, the basics
+   are identical to what was originally contributed by Infineon.  The
+   contribution of Infineon in the development of this tracing
+   technology is hereby acknowledged.
+
+ *****************************************************************************/
+
+#ifndef SC_VCD_TRACE_H
+#define SC_VCD_TRACE_H
+
+#include "sysc/tracing/sc_trace_file_base.h"
+
+namespace sc_core {
+
+class vcd_trace;  // defined in vcd_trace.cpp
+template<class T> class vcd_T_trace;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : vcd_trace_file
+//
+//  ...
+// ----------------------------------------------------------------------------
+
+class vcd_trace_file
+  : public sc_trace_file_base
+{
+public:
+
+    enum vcd_enum {VCD_WIRE=0, VCD_REAL=1, VCD_LAST};
+
+	// sc_set_vcd_time_unit is deprecated.
+#if 0 // deprecated
+    inline void sc_set_vcd_time_unit(int exponent10_seconds)
+    	{ set_time_unit(exponent10_seconds); }
+#endif
+
+    // Create a Vcd trace file.
+    // `Name' forms the base of the name to which `.vcd' is added.
+    vcd_trace_file(const char *name);
+
+    // Flush results and close file.
+    ~vcd_trace_file();
+
+protected:
+
+    // These are all virtual functions in sc_trace_file and
+    // they need to be defined here.
+
+    // Trace a boolean object (single bit)
+     void trace(const bool& object, const std::string& name);
+
+    // Trace a sc_bit object (single bit)
+    virtual void trace( const sc_dt::sc_bit& object, 
+	    const std::string& name);
+
+    // Trace a sc_logic object (single bit)
+     void trace(const sc_dt::sc_logic& object, const std::string& name);
+    
+    // Trace an unsigned char with the given width
+     void trace(const unsigned char& object, const std::string& name, 
+     	int width);
+
+    // Trace an unsigned short with the given width
+     void trace(const unsigned short& object, const std::string& name, 
+     	int width);
+
+    // Trace an unsigned int with the given width
+     void trace(const unsigned int& object, const std::string& name, 
+     	int width);
+
+    // Trace an unsigned long with the given width
+     void trace(const unsigned long& object, const std::string& name, 
+     	int width);
+
+    // Trace a signed char with the given width
+     void trace(const char& object, const std::string& name, int width);
+
+    // Trace a signed short with the given width
+     void trace(const short& object, const std::string& name, int width);
+
+    // Trace a signed int with the given width
+     void trace(const int& object, const std::string& name, int width);
+
+    // Trace a signed long with the given width
+     void trace(const long& object, const std::string& name, int width);
+    
+    // Trace an int64 with a given width
+     void trace(const sc_dt::int64& object, const std::string& name, 
+         int width);
+
+    // Trace a uint64 with a given width
+     void trace(const sc_dt::uint64& object, const std::string& name, 
+         int width);
+
+    // Trace a float
+     void trace(const float& object, const std::string& name);
+
+    // Trace a double
+     void trace(const double& object, const std::string& name);
+
+    // Trace sc_dt::sc_uint_base
+     void trace (const sc_dt::sc_uint_base& object, 
+	 	const std::string& name);
+
+    // Trace sc_dt::sc_int_base
+     void trace (const sc_dt::sc_int_base& object, 
+	 	const std::string& name);
+
+    // Trace sc_dt::sc_unsigned
+     void trace (const sc_dt::sc_unsigned& object, 
+	 	const std::string& name);
+
+    // Trace sc_dt::sc_signed
+     void trace (const sc_dt::sc_signed& object, const std::string& name);
+
+    // Trace sc_dt::sc_fxval
+    void trace( const sc_dt::sc_fxval& object, const std::string& name );
+
+    // Trace sc_dt::sc_fxval_fast
+    void trace( const sc_dt::sc_fxval_fast& object, 
+		const std::string& name );
+
+    // Trace sc_dt::sc_fxnum
+    void trace( const sc_dt::sc_fxnum& object, const std::string& name );
+
+    // Trace sc_dt::sc_fxnum_fast
+    void trace( const sc_dt::sc_fxnum_fast& object, 
+		const std::string& name );
+
+    template<class T>
+    void traceT(const T& object, const std::string& name, 
+    	vcd_enum type=VCD_WIRE)
+    {
+        if( add_trace_check(name) )
+            traces.push_back(new vcd_T_trace<T>( object, name
+                                               , obtain_name(),type) );
+    }
+
+   // Trace sc_dt::sc_bv_base (sc_dt::sc_bv)
+    virtual void trace(const sc_dt::sc_bv_base& object, 
+		const std::string& name);
+
+    // Trace sc_dt::sc_lv_base (sc_dt::sc_lv)
+    virtual void trace(const sc_dt::sc_lv_base& object, 
+	    const std::string& name);
+    // Trace an enumerated object - where possible output the enumeration literals
+    // in the trace file. Enum literals is a null terminated array of null
+    // terminated char* literal strings.
+     void trace(const unsigned& object, const std::string& name, 
+     	const char** enum_literals);
+
+    // Output a comment to the trace file
+     void write_comment(const std::string& comment);
+
+    // Write trace info for cycle.
+     void cycle(bool delta_cycle);
+
+private:
+
+#if SC_TRACING_PHASE_CALLBACKS_
+    // avoid hidden overload warnings
+    virtual void trace( sc_trace_file* ) const { sc_assert(false); }
+#endif // SC_TRACING_PHASE_CALLBACKS_
+
+    // Initialize the VCD tracing
+    virtual void do_initialize();
+
+    unsigned vcd_name_index;           // Number of variables traced
+
+    unsigned previous_time_units_low;  // Previous time unit as 64-bit integer
+    unsigned previous_time_units_high;
+
+public:
+
+    // Array to store the variables traced
+    std::vector<vcd_trace*> traces;
+
+    // Create VCD names for each variable
+    std::string obtain_name();
+
+};
+
+} // namespace sc_core
+
+#endif // SC_VCD_TRACE_H
+// Taf!
diff --git a/ext/systemc/src/sysc/tracing/sc_wif_trace.cpp b/ext/systemc/src/sysc/tracing/sc_wif_trace.cpp
new file mode 100644
index 000000000..b2bacee7d
--- /dev/null
+++ b/ext/systemc/src/sysc/tracing/sc_wif_trace.cpp
@@ -0,0 +1,1911 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_wif_trace.cpp - Implementation of WIF tracing.
+
+  Original Author - Abhijit Ghosh, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Ali Dasdan, Synopsys, Inc.
+  Description of Modification: - Replaced 'width' of sc_(u)int with their
+                                 'bitwidth()'.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+   Acknowledgement: The tracing mechanism is based on the tracing
+   mechanism developed at Infineon (formerly Siemens HL). Though this
+   code is somewhat different, and significantly enhanced, the basics
+   are identical to what was originally contributed by Infineon.  The
+   contribution of Infineon in the development of this tracing
+   technology is hereby acknowledged.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+   Instead of creating the binary WIF format, we create the ASCII
+   WIF format which can be converted to the binary format using
+   a2wif (utility that comes with VSS from Synopsys). This way, 
+   a user who does not have Synopsys VSS can still create WIF 
+   files, but they can only be viewed by users who have VSS.
+
+ *****************************************************************************/
+
+
+#include <cstdlib>
+#include <vector>
+
+#define SC_DISABLE_API_VERSION_CHECK // for in-library sc_ver.h inclusion
+
+#include "sysc/kernel/sc_simcontext.h"
+#include "sysc/kernel/sc_ver.h"
+#include "sysc/datatypes/bit/sc_bit.h"
+#include "sysc/datatypes/bit/sc_logic.h"
+#include "sysc/datatypes/bit/sc_lv_base.h"
+#include "sysc/datatypes/int/sc_signed.h"
+#include "sysc/datatypes/int/sc_unsigned.h"
+#include "sysc/datatypes/int/sc_int_base.h"
+#include "sysc/datatypes/int/sc_uint_base.h"
+#include "sysc/datatypes/fx/fx.h"
+#include "sysc/tracing/sc_wif_trace.h"
+
+namespace sc_core {
+
+// Forward declarations for functions that come later in the file
+static char map_sc_logic_state_to_wif_state(char in_char);
+
+const char* wif_names[wif_trace_file::WIF_LAST] = {"BIT","MVL","real"};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : wif_trace
+//
+//  Base class for WIF traces.
+// ----------------------------------------------------------------------------
+
+class wif_trace
+{
+public:
+
+    wif_trace(const std::string& name_, const std::string& wif_name_);
+
+    // Needs to be pure virtual as has to be defined by the particular
+    // type being traced
+    virtual void write(FILE* f) = 0;
+    
+    virtual void set_width();
+
+    // Comparison function needs to be pure virtual too
+    virtual bool changed() = 0;
+
+    // Got to declare this virtual as this will be overwritten
+    // by one base class
+    virtual void print_variable_declaration_line(FILE* f);
+
+    virtual ~wif_trace();
+
+    const std::string name;     // Name of the variable
+    const std::string wif_name; // Name of the variable in WIF file
+    const char* wif_type;     // WIF data type
+    int bit_width; 
+};
+
+
+wif_trace::wif_trace(const std::string& name_, 
+	const std::string& wif_name_)
+        : name(name_), wif_name(wif_name_), wif_type(0), bit_width(-1) 
+{
+    /* Intentionally blank */
+}
+
+void
+wif_trace::print_variable_declaration_line( FILE* f )
+{
+    if( bit_width < 0 )
+    {
+        std::stringstream ss;
+        ss << "'" << name << "' has < 0 bits";
+        SC_REPORT_ERROR( SC_ID_TRACING_OBJECT_IGNORED_
+                       , ss.str().c_str() );
+        return;
+    }
+
+    std::fprintf( f, "declare  %s   \"%s\"  %s  ",
+                  wif_name.c_str(), name.c_str(), wif_type );
+
+    if( bit_width > 0 ) {
+        std::fprintf( f, "0 %d ", bit_width - 1 );
+    }
+    std::fprintf( f, "variable ;\n" );
+    std::fprintf( f, "start_trace %s ;\n", wif_name.c_str() );
+}
+
+void
+wif_trace::set_width()
+{
+    /* Intentionally Blank, should be defined for each type separately */
+}
+
+wif_trace::~wif_trace()
+{
+    /* Intentionally Blank */
+}
+
+// Classes for tracing individual data types
+
+/*****************************************************************************/
+
+class wif_uint64_trace: public wif_trace {
+public:
+    wif_uint64_trace(const sc_dt::uint64& object_,
+                const std::string& name_,
+                const std::string& wif_name_,
+                int width_);
+    void write(FILE* f);
+    bool changed();
+
+protected:
+    const sc_dt::uint64& object;
+    sc_dt::uint64 old_value;
+    sc_dt::uint64 mask; 
+};
+
+
+wif_uint64_trace::wif_uint64_trace(const sc_dt::uint64& object_,
+                         const std::string& name_,
+                         const std::string& wif_name_,
+                         int width_) 
+: wif_trace(name_, wif_name_), object(object_), old_value(object_),
+  mask(static_cast<sc_dt::uint64>(-1))
+{
+    bit_width = width_;
+    if (bit_width < (int)(sizeof(sc_dt::uint64)*BITS_PER_BYTE))
+        mask = ~(mask << bit_width);
+    wif_type = "BIT";
+}
+
+
+bool wif_uint64_trace::changed()
+{
+    return object != old_value;
+}
+
+
+void wif_uint64_trace::write(FILE* f)
+{
+    char buf[1000];
+    int bitindex;
+
+    // Check for overflow
+    if ((object & mask) != object) 
+    {
+        for (bitindex = 0; bitindex < bit_width; bitindex++)
+        {
+            buf[bitindex]='0';
+        }
+    }
+    else
+    {
+        sc_dt::uint64 bit_mask = 1;
+        bit_mask = bit_mask << (bit_width-1);
+        for (bitindex = 0; bitindex < bit_width; bitindex++) 
+        {
+            buf[bitindex] = (object & bit_mask)? '1' : '0';
+            bit_mask = bit_mask >> 1;
+        }
+    }
+    buf[bitindex] = '\0';
+    std::fprintf(f, "assign %s \"%s\" ;\n", wif_name.c_str(), buf); 
+    old_value = object;
+}
+
+/*****************************************************************************/
+
+class wif_int64_trace: public wif_trace {
+public:
+    wif_int64_trace(const sc_dt::int64& object_,
+                const std::string& name_,
+                const std::string& wif_name_,
+                int width_);
+    void write(FILE* f);
+    bool changed();
+
+protected:
+    const sc_dt::int64& object;
+    sc_dt::int64 old_value;
+    sc_dt::uint64 mask; 
+};
+
+
+wif_int64_trace::wif_int64_trace(const sc_dt::int64& object_,
+                         const std::string& name_,
+                         const std::string& wif_name_,
+                         int width_) 
+: wif_trace(name_, wif_name_), object(object_), old_value(object_),
+  mask(static_cast<sc_dt::uint64>(-1))
+{
+    bit_width = width_;
+    if (bit_width < (int)(sizeof(sc_dt::int64)*BITS_PER_BYTE))
+        mask = ~(mask << bit_width);
+    wif_type = "BIT";
+}
+
+
+bool wif_int64_trace::changed()
+{
+    return object != old_value;
+}
+
+
+void wif_int64_trace::write(FILE* f)
+{
+    char buf[1000];
+    int bitindex;
+
+    // Check for overflow
+    if ((object & mask) != (sc_dt::uint64)object) 
+    {
+        for (bitindex = 0; bitindex < bit_width; bitindex++)
+        {
+            buf[bitindex]='0';
+        }
+    }
+    else
+    {
+        sc_dt::uint64 bit_mask = 1;
+        bit_mask = bit_mask << (bit_width-1);
+        for (bitindex = 0; bitindex < bit_width; bitindex++) 
+        {
+            buf[bitindex] = (object & bit_mask)? '1' : '0';
+            bit_mask = bit_mask >> 1;
+        }
+    }
+    buf[bitindex] = '\0';
+    std::fprintf(f, "assign %s \"%s\" ;\n", wif_name.c_str(), buf); 
+    old_value = object;
+}
+
+/*****************************************************************************/
+
+class wif_bool_trace
+: public wif_trace
+{
+public:
+
+    wif_bool_trace( const bool& object_,
+		    const std::string& name_,
+		    const std::string& wif_name_ );
+    void write( FILE* f );
+    bool changed();
+
+protected:    
+
+    const bool& object;
+    bool        old_value;
+};
+
+wif_bool_trace::wif_bool_trace( const bool& object_,
+				const std::string& name_,
+				const std::string& wif_name_ )
+: wif_trace( name_, wif_name_ ), object( object_ ), old_value( object_ )
+{
+    bit_width = 0;
+    wif_type = "BIT";
+}
+
+bool
+wif_bool_trace::changed()
+{
+    return object != old_value;
+}
+
+void
+wif_bool_trace::write( FILE* f )
+{
+    if( object == true ) {
+	std::fprintf( f, "assign %s \'1\' ;\n", wif_name.c_str() );
+    } else {
+	std::fprintf( f, "assign %s \'0\' ;\n", wif_name.c_str() );
+    }
+    old_value = object;
+}
+
+//*****************************************************************************
+
+class wif_sc_bit_trace : public wif_trace {
+public:
+    wif_sc_bit_trace(const sc_dt::sc_bit& object_, 
+                     const std::string& name_,
+                     const std::string& wif_name_);
+    void write(FILE* f);
+    bool changed();
+
+protected:    
+    const sc_dt::sc_bit& object;
+    sc_dt::sc_bit old_value;
+};
+
+wif_sc_bit_trace::wif_sc_bit_trace(const sc_dt::sc_bit& object_,
+				   const std::string& name_,
+				   const std::string& wif_name_)
+: wif_trace(name_, wif_name_), object(object_), old_value(object_)
+{
+    bit_width = 0;
+    wif_type = "BIT";
+}
+
+bool wif_sc_bit_trace::changed()
+{
+    return object != old_value;
+}
+
+void wif_sc_bit_trace::write(FILE* f)
+{
+    if (object == true) {
+        std::fprintf(f, "assign %s \'1\' ;\n", wif_name.c_str());
+    } else {
+	std::fprintf(f, "assign %s \'0\' ;\n", wif_name.c_str());
+    }
+    old_value = object;
+}
+
+/*****************************************************************************/
+
+class wif_sc_logic_trace: public wif_trace {
+public:
+    wif_sc_logic_trace(const sc_dt::sc_logic& object_,
+		       const std::string& name_,
+		       const std::string& wif_name_);
+    void write(FILE* f);
+    bool changed();
+
+protected:    
+    const sc_dt::sc_logic& object;
+    sc_dt::sc_logic old_value;
+};
+
+
+wif_sc_logic_trace::wif_sc_logic_trace(const sc_dt::sc_logic& object_,
+				       const std::string& name_,
+				       const std::string& wif_name_) 
+: wif_trace(name_, wif_name_), object(object_), old_value(object_)
+{
+    bit_width = 0;
+    wif_type = "MVL";
+}
+
+
+bool wif_sc_logic_trace::changed()
+{
+    return object != old_value;
+}
+
+
+void wif_sc_logic_trace::write(FILE* f)
+{
+    char wif_char;
+    std::fprintf(f, "assign %s \'", wif_name.c_str());
+    wif_char = map_sc_logic_state_to_wif_state(object.to_char());
+    std::fputc(wif_char, f); 
+    std::fprintf(f,"\' ;\n");
+    old_value = object;
+}
+
+
+/*****************************************************************************/
+
+class wif_sc_unsigned_trace: public wif_trace {
+public:
+    wif_sc_unsigned_trace(const sc_dt::sc_unsigned& object_,
+			  const std::string& name_,
+			  const std::string& wif_name_);
+    void write(FILE* f);
+    bool changed();
+    void set_width();
+
+protected:    
+    const sc_dt::sc_unsigned& object;
+    sc_dt::sc_unsigned old_value;
+};
+
+
+wif_sc_unsigned_trace::wif_sc_unsigned_trace(const sc_dt::sc_unsigned& object_,
+					     const std::string& name_,
+					     const std::string& wif_name_) 
+: wif_trace(name_, wif_name_), object(object_), old_value(object_.length())
+{
+    old_value = object;
+    wif_type = "BIT";
+}
+
+bool wif_sc_unsigned_trace::changed()
+{
+    return object != old_value;
+}
+
+void wif_sc_unsigned_trace::write(FILE* f)
+{
+    static std::vector<char> buf(1024);
+    typedef std::vector<char>::size_type size_t;
+
+    if ( buf.size() < (size_t)object.length() ) {
+        size_t sz = ( (size_t)object.length() + 4096 ) & (~(size_t)(4096-1));
+        std::vector<char>( sz ).swap( buf ); // resize without copying values
+    }
+    char *buf_ptr = &buf[0];
+
+    for(int bitindex = object.length() - 1; bitindex >= 0; --bitindex) {
+        *buf_ptr++ = "01"[object[bitindex].to_bool()];
+    }
+    *buf_ptr = '\0';
+    std::fprintf(f, "assign %s \"%s\" ;\n", wif_name.c_str(), &buf[0]);
+    old_value = object;
+}
+
+void wif_sc_unsigned_trace::set_width()
+{
+    bit_width = object.length();
+}
+
+
+/*****************************************************************************/
+
+class wif_sc_signed_trace: public wif_trace {
+public:
+    wif_sc_signed_trace(const sc_dt::sc_signed& object_,
+			const std::string& name_,
+			const std::string& wif_name_);
+    void write(FILE* f);
+    bool changed();
+    void set_width();
+
+protected:    
+    const sc_dt::sc_signed& object;
+    sc_dt::sc_signed old_value;
+};
+
+
+wif_sc_signed_trace::wif_sc_signed_trace(const sc_dt::sc_signed& object_,
+					 const std::string& name_,
+					 const std::string& wif_name_) 
+: wif_trace(name_, wif_name_), object(object_), old_value(object_.length())
+{
+    old_value = object;
+    wif_type = "BIT";
+}
+
+bool wif_sc_signed_trace::changed()
+{
+    return object != old_value;
+}
+
+void wif_sc_signed_trace::write(FILE* f)
+{
+    static std::vector<char> buf(1024);
+    typedef std::vector<char>::size_type size_t;
+
+    if ( buf.size() < (size_t)object.length() ) {
+        size_t sz = ( (size_t)object.length() + 4096 ) & (~(size_t)(4096-1));
+        std::vector<char>( sz ).swap( buf ); // resize without copying values
+    }
+    char *buf_ptr = &buf[0];
+
+    for(int bitindex = object.length() - 1; bitindex >= 0; --bitindex) {
+        *buf_ptr++ = "01"[object[bitindex].to_bool()];
+    }
+    *buf_ptr = '\0';
+
+    std::fprintf(f, "assign %s \"%s\" ;\n", wif_name.c_str(), &buf[0]);
+    old_value = object;
+}
+
+void wif_sc_signed_trace::set_width()
+{
+    bit_width = object.length();
+}
+
+/*****************************************************************************/
+
+class wif_sc_uint_base_trace: public wif_trace {
+public:
+    wif_sc_uint_base_trace(const sc_dt::sc_uint_base& object_,
+			   const std::string& name_,
+			   const std::string& wif_name_);
+    void write(FILE* f);
+    bool changed();
+    void set_width();
+
+protected:    
+    const sc_dt::sc_uint_base& object;
+    sc_dt::sc_uint_base old_value;
+};
+
+
+wif_sc_uint_base_trace::wif_sc_uint_base_trace(
+                                          const sc_dt::sc_uint_base& object_,
+					  const std::string& name_,
+					  const std::string& wif_name_)
+: wif_trace(name_, wif_name_), object(object_), old_value(object_.length())
+{
+    old_value = object;
+    wif_type = "BIT";
+}
+
+bool wif_sc_uint_base_trace::changed()
+{
+    return object != old_value;
+}
+
+void wif_sc_uint_base_trace::write(FILE* f)
+{
+    char buf[1000], *buf_ptr = buf;
+
+    int bitindex;
+    for(bitindex = object.length() - 1; bitindex >= 0; --bitindex) {
+        *buf_ptr++ = "01"[object[bitindex].to_bool()];
+    }
+    *buf_ptr = '\0';
+    std::fprintf(f, "assign %s \"%s\" ;\n", wif_name.c_str(), buf); 
+    old_value = object;
+}
+
+void wif_sc_uint_base_trace::set_width()
+{
+    bit_width = object.length();
+}
+
+
+/*****************************************************************************/
+
+class wif_sc_int_base_trace: public wif_trace {
+public:
+    wif_sc_int_base_trace(const sc_dt::sc_int_base& object_,
+			  const std::string& name_,
+			  const std::string& wif_name_);
+    void write(FILE* f);
+    bool changed();
+    void set_width();
+
+protected:    
+    const sc_dt::sc_int_base& object;
+    sc_dt::sc_int_base old_value;
+};
+
+
+wif_sc_int_base_trace::wif_sc_int_base_trace(const sc_dt::sc_int_base& object_,
+					     const std::string& name_,
+					     const std::string& wif_name_) 
+: wif_trace(name_, wif_name_), object(object_), old_value(object_.length())
+{
+    old_value = object;
+    wif_type = "BIT";
+}
+
+bool wif_sc_int_base_trace::changed()
+{
+    return object != old_value;
+}
+
+void wif_sc_int_base_trace::write(FILE* f)
+{
+    char buf[1000], *buf_ptr = buf;
+
+    int bitindex;
+    for(bitindex = object.length() - 1; bitindex >= 0; --bitindex) {
+        *buf_ptr++ = "01"[object[bitindex].to_bool()];
+    }
+    *buf_ptr = '\0';
+
+    std::fprintf(f, "assign %s \"%s\" ;\n", wif_name.c_str(), buf); 
+    old_value = object;
+}
+
+void wif_sc_int_base_trace::set_width()
+{
+    bit_width = object.length();
+}
+
+
+/*****************************************************************************/
+
+class wif_sc_fxval_trace: public wif_trace
+{
+public:
+
+    wif_sc_fxval_trace( const sc_dt::sc_fxval& object_,
+			const std::string& name_,
+			const std::string& wif_name_ );
+    void write( FILE* f );
+    bool changed();
+
+protected:
+
+    const sc_dt::sc_fxval& object;
+    sc_dt::sc_fxval old_value;
+
+};
+
+wif_sc_fxval_trace::wif_sc_fxval_trace( const sc_dt::sc_fxval& object_,
+				        const std::string& name_,
+					const std::string& wif_name_ )
+: wif_trace( name_, wif_name_ ), object( object_ ), old_value( object_ )
+{
+    bit_width = 0;
+    wif_type = "real";
+}
+
+bool
+wif_sc_fxval_trace::changed()
+{
+    return object != old_value;
+}
+
+void
+wif_sc_fxval_trace::write( FILE* f )
+{
+    std::fprintf( f, "assign  %s %f ; \n", wif_name.c_str(), object.to_double() );
+    old_value = object;
+}
+
+/*****************************************************************************/
+
+class wif_sc_fxval_fast_trace: public wif_trace
+{
+public:
+
+    wif_sc_fxval_fast_trace( const sc_dt::sc_fxval_fast& object_,
+			     const std::string& name_,
+			     const std::string& wif_name_ );
+    void write( FILE* f );
+    bool changed();
+
+protected:
+
+    const sc_dt::sc_fxval_fast& object;
+    sc_dt::sc_fxval_fast old_value;
+
+};
+
+wif_sc_fxval_fast_trace::wif_sc_fxval_fast_trace( 
+                                const sc_dt::sc_fxval_fast& object_,
+				const std::string& name_,
+				const std::string& wif_name_ )
+: wif_trace(name_, wif_name_), object( object_ ), old_value( object_ )
+{
+    bit_width = 0;
+    wif_type = "real";
+}
+
+bool
+wif_sc_fxval_fast_trace::changed()
+{
+    return object != old_value;
+}
+
+void
+wif_sc_fxval_fast_trace::write( FILE* f )
+{
+    std::fprintf( f, "assign  %s %f ; \n", wif_name.c_str(), object.to_double() );
+    old_value = object;
+}
+
+/*****************************************************************************/
+
+class wif_sc_fxnum_trace: public wif_trace
+{
+public:
+
+    wif_sc_fxnum_trace( const sc_dt::sc_fxnum& object_,
+			const std::string& name_,
+			const std::string& wif_name_ );
+    void write( FILE* f );
+    bool changed();
+    void set_width();
+
+protected:
+
+    const sc_dt::sc_fxnum& object;
+    sc_dt::sc_fxnum old_value;
+
+};
+
+wif_sc_fxnum_trace::wif_sc_fxnum_trace( const sc_dt::sc_fxnum& object_,
+				        const std::string& name_,
+					const std::string& wif_name_ )
+: wif_trace( name_, wif_name_ ),
+  object( object_ ),
+  old_value( object_.m_params.type_params(),
+	     object_.m_params.enc(),
+	     object_.m_params.cast_switch(),
+	     0 )
+{
+    old_value = object;
+    wif_type = "BIT";
+}
+
+bool
+wif_sc_fxnum_trace::changed()
+{
+    return object != old_value;
+}
+
+void
+wif_sc_fxnum_trace::write( FILE* f )
+{
+    static std::vector<char> buf(1024);
+    typedef std::vector<char>::size_type size_t;
+
+    if ( buf.size() < (size_t)object.wl() ) {
+        size_t sz = ( (size_t)object.wl() + 4096 ) & (~(size_t)(4096-1));
+        std::vector<char>( sz ).swap( buf ); // resize without copying values
+    }
+    char *buf_ptr = &buf[0];
+
+    for(int bitindex = object.wl() - 1; bitindex >= 0; --bitindex)
+    {
+        *buf_ptr ++ = "01"[object[bitindex]];
+    }
+    *buf_ptr = '\0';
+
+    std::fprintf( f, "assign %s \"%s\" ;\n", wif_name.c_str(), &buf[0]);
+    old_value = object;
+}
+
+void
+wif_sc_fxnum_trace::set_width()
+{
+    bit_width = object.wl();
+}
+
+/*****************************************************************************/
+
+class wif_sc_fxnum_fast_trace: public wif_trace
+{
+public:
+
+    wif_sc_fxnum_fast_trace( const sc_dt::sc_fxnum_fast& object_,
+			     const std::string& name_,
+			     const std::string& wif_name_ );
+    void write( FILE* f );
+    bool changed();
+    void set_width();
+
+protected:
+
+    const sc_dt::sc_fxnum_fast& object;
+    sc_dt::sc_fxnum_fast old_value;
+
+};
+
+wif_sc_fxnum_fast_trace::wif_sc_fxnum_fast_trace( 
+				const sc_dt::sc_fxnum_fast& object_,
+				const std::string& name_,
+				const std::string& wif_name_ )
+: wif_trace( name_, wif_name_ ),
+  object( object_ ),
+  old_value( object_.m_params.type_params(),
+	     object_.m_params.enc(),
+	     object_.m_params.cast_switch(),
+	     0 )
+{
+    old_value = object;
+    wif_type = "BIT";
+}
+
+bool
+wif_sc_fxnum_fast_trace::changed()
+{
+    return object != old_value;
+}
+
+void
+wif_sc_fxnum_fast_trace::write( FILE* f )
+{
+    static std::vector<char> buf(1024);
+    typedef std::vector<char>::size_type size_t;
+
+    if ( buf.size() < (size_t)object.wl() ) {
+        size_t sz = ( (size_t)object.wl() + 4096 ) & (~(size_t)(4096-1));
+        std::vector<char>( sz ).swap( buf ); // resize without copying values
+    }
+    char *buf_ptr = &buf[0];
+
+    for(int bitindex = object.wl() - 1; bitindex >= 0; --bitindex)
+    {
+        *buf_ptr ++ = "01"[object[bitindex]];
+    }
+    *buf_ptr = '\0';
+
+    std::fprintf( f, "assign %s \"%s\" ;\n", wif_name.c_str(), &buf[0]);
+    old_value = object;
+}
+
+void
+wif_sc_fxnum_fast_trace::set_width()
+{
+    bit_width = object.wl();
+}
+
+
+/*****************************************************************************/
+
+class wif_unsigned_int_trace: public wif_trace {
+public:
+    wif_unsigned_int_trace(const unsigned& object_,
+			   const std::string& name_,
+			   const std::string& wif_name_, int width_);
+    void write(FILE* f);
+    bool changed();
+
+protected:
+    const unsigned& object;
+    unsigned old_value;
+    unsigned mask; 
+};
+
+
+wif_unsigned_int_trace::wif_unsigned_int_trace(const unsigned& object_,
+					   const std::string& name_,
+					   const std::string& wif_name_,
+					   int width_) 
+: wif_trace(name_, wif_name_), object(object_), old_value(object_),
+  mask(0xffffffff)
+{
+    bit_width = width_;
+    if (bit_width < 32) {
+        mask = ~(-1 << bit_width);
+    }
+
+    wif_type = "BIT";
+}
+
+
+bool wif_unsigned_int_trace::changed()
+{
+    return object != old_value;
+}
+
+
+void wif_unsigned_int_trace::write(FILE* f)
+{
+    char buf[1000];
+    int bitindex;
+
+    // Check for overflow
+    if ((object & mask) != object) {
+        for (bitindex = 0; bitindex < bit_width; bitindex++){
+            buf[bitindex] = '0';
+        }
+    }
+    else{
+        unsigned bit_mask = 1 << (bit_width-1);
+        for (bitindex = 0; bitindex < bit_width; bitindex++) {
+            buf[bitindex] = (object & bit_mask)? '1' : '0';
+            bit_mask = bit_mask >> 1;
+        }
+    }
+    buf[bitindex] = '\0';
+    std::fprintf(f, "assign %s \"%s\" ;\n", wif_name.c_str(), buf); 
+    old_value = object;
+}
+
+
+/*****************************************************************************/
+
+class wif_unsigned_short_trace: public wif_trace {
+public:
+    wif_unsigned_short_trace(const unsigned short& object_,
+			     const std::string& name_,
+			     const std::string& wif_name_,
+			     int width_);
+    void write(FILE* f);
+    bool changed();
+
+protected:
+    const unsigned short& object;
+    unsigned short old_value;
+    unsigned short mask; 
+};
+
+
+wif_unsigned_short_trace::wif_unsigned_short_trace(
+	const unsigned short& object_,
+       const std::string& name_,
+       const std::string& wif_name_,
+       int width_) 
+: wif_trace(name_, wif_name_), object(object_), old_value(object_), mask(0xffff)
+{
+    bit_width = width_;
+    if (bit_width < 16) {
+        mask = (unsigned short)~(-1 << bit_width);
+    }
+
+    wif_type = "BIT";
+}
+
+
+bool wif_unsigned_short_trace::changed()
+{
+    return object != old_value;
+}
+
+
+void wif_unsigned_short_trace::write(FILE* f)
+{
+    char buf[1000];
+    int bitindex;
+
+    // Check for overflow
+    if ((object & mask) != object) {
+        for (bitindex = 0; bitindex < bit_width; bitindex++){
+            buf[bitindex]='0';
+        }
+    }
+    else{
+        unsigned bit_mask = 1 << (bit_width-1);
+        for (bitindex = 0; bitindex < bit_width; bitindex++) {
+            buf[bitindex] = (object & bit_mask)? '1' : '0';
+            bit_mask = bit_mask >> 1;
+        }
+    }
+    buf[bitindex] = '\0';
+    std::fprintf(f, "assign %s \"%s\" ;\n", wif_name.c_str(), buf); 
+    old_value = object;
+}
+
+/*****************************************************************************/
+
+class wif_unsigned_char_trace: public wif_trace {
+public:
+    wif_unsigned_char_trace(const unsigned char& object_,
+			    const std::string& name_,
+			    const std::string& wif_name_,
+			    int width_);
+    void write(FILE* f);
+    bool changed();
+
+protected:
+    const unsigned char& object;
+    unsigned char old_value;
+    unsigned char mask; 
+};
+
+
+wif_unsigned_char_trace::wif_unsigned_char_trace(const unsigned char& object_,
+					 const std::string& name_,
+					 const std::string& wif_name_,
+					 int width_) 
+: wif_trace(name_, wif_name_), object(object_), old_value(object_), mask(0xff)
+{
+    bit_width = width_;
+    if (bit_width < 8) {
+        mask = (unsigned char)~(-1 << bit_width);
+    }
+
+    wif_type = "BIT";
+}
+
+
+bool wif_unsigned_char_trace::changed()
+{
+    return object != old_value;
+}
+
+
+void wif_unsigned_char_trace::write(FILE* f)
+{
+    char buf[1000];
+    int bitindex;
+
+    // Check for overflow
+    if ((object & mask) != object) {
+        for (bitindex = 0; bitindex < bit_width; bitindex++){
+            buf[bitindex]='0';
+        }
+    }
+    else{
+        unsigned bit_mask = 1 << (bit_width-1);
+        for (bitindex = 0; bitindex < bit_width; bitindex++) {
+            buf[bitindex] = (object & bit_mask)? '1' : '0';
+            bit_mask = bit_mask >> 1;
+        }
+    }
+    buf[bitindex] = '\0';
+    std::fprintf(f, "assign %s \"%s\" ;\n", wif_name.c_str(), buf); 
+    old_value = object;
+}
+
+/*****************************************************************************/
+
+class wif_unsigned_long_trace: public wif_trace {
+public:
+    wif_unsigned_long_trace(const unsigned long& object_,
+			    const std::string& name_,
+			    const std::string& wif_name_,
+			    int width_);
+    void write(FILE* f);
+    bool changed();
+
+protected:
+    const unsigned long& object;
+    unsigned long old_value;
+    unsigned long mask; 
+};
+
+
+wif_unsigned_long_trace::wif_unsigned_long_trace(const unsigned long& object_,
+					     const std::string& name_,
+					     const std::string& wif_name_,
+					     int width_) 
+: wif_trace(name_, wif_name_), object(object_), old_value(object_),
+  mask((unsigned long)-1L)
+{
+    bit_width = width_;
+    if (bit_width < (int)(sizeof(unsigned long)*BITS_PER_BYTE)) {
+        mask = ~(-1L << bit_width);
+    }
+
+    wif_type = "BIT";
+}
+
+
+bool wif_unsigned_long_trace::changed()
+{
+    return object != old_value;
+}
+
+
+void wif_unsigned_long_trace::write(FILE* f)
+{
+    char buf[1000];
+    int bitindex;
+
+    // Check for overflow
+    if ((object & mask) != object) {
+        for (bitindex = 0; bitindex < bit_width; bitindex++){
+            buf[bitindex]='0';
+        }
+    }
+    else{
+        unsigned long bit_mask = 1ul << (bit_width-1);
+        for (bitindex = 0; bitindex < bit_width; bitindex++) {
+            buf[bitindex] = (object & bit_mask)? '1' : '0';
+            bit_mask = bit_mask >> 1;
+        }
+    }
+    buf[bitindex] = '\0';
+    std::fprintf(f, "assign %s \"%s\" ;\n", wif_name.c_str(), buf); 
+    old_value = object;
+}
+
+/*****************************************************************************/
+
+class wif_signed_int_trace: public wif_trace {
+public:
+    wif_signed_int_trace(const int& object_,
+			 const std::string& name_,
+			 const std::string& wif_name_,
+			 int width_);
+    void write(FILE* f);
+    bool changed();
+
+protected:
+    const int& object;
+    int old_value;
+    unsigned mask; 
+};
+
+
+wif_signed_int_trace::wif_signed_int_trace(const signed& object_,
+					   const std::string& name_,
+					   const std::string& wif_name_,
+					   int width_) 
+: wif_trace(name_, wif_name_), object(object_), old_value(object_),
+  mask(0xffffffff)
+{
+    bit_width = width_;
+    if (bit_width < 32) {
+        mask = ~(-1 << bit_width);
+    }
+
+    wif_type = "BIT";
+}
+
+
+bool wif_signed_int_trace::changed()
+{
+    return object != old_value;
+}
+
+
+void wif_signed_int_trace::write(FILE* f)
+{
+    char buf[1000];
+    int bitindex;
+
+    // Check for overflow
+    if (((unsigned) object & mask) != (unsigned) object) {
+        for (bitindex = 0; bitindex < bit_width; bitindex++){
+            buf[bitindex]='0';
+        }
+    }
+    else{
+        unsigned bit_mask = 1 << (bit_width-1);
+        for (bitindex = 0; bitindex < bit_width; bitindex++) {
+            buf[bitindex] = (object & bit_mask)? '1' : '0';
+            bit_mask = bit_mask >> 1;
+        }
+    }
+    buf[bitindex] = '\0';
+    std::fprintf(f, "assign %s \"%s\" ;\n", wif_name.c_str(), buf); 
+    old_value = object;
+}
+
+/*****************************************************************************/
+
+class wif_signed_short_trace: public wif_trace {
+public:
+    wif_signed_short_trace(const short& object_,
+			   const std::string& name_,
+			   const std::string& wif_name_,
+			   int width_);
+    void write(FILE* f);
+    bool changed();
+
+protected:
+    const short& object;
+    short old_value;
+    unsigned short mask; 
+};
+
+
+wif_signed_short_trace::wif_signed_short_trace(const short& object_,
+					   const std::string& name_,
+					   const std::string& wif_name_,
+					   int width_) 
+: wif_trace(name_, wif_name_), object(object_), old_value(object_), mask(0xffff)
+{
+    bit_width = width_;
+    if (bit_width < 16) {
+        mask = (unsigned short)~(-1 << bit_width);
+    }
+
+    wif_type = "BIT";
+}
+
+
+bool wif_signed_short_trace::changed()
+{
+    return object != old_value;
+}
+
+
+void wif_signed_short_trace::write(FILE* f)
+{
+    char buf[1000];
+    int bitindex;
+
+    // Check for overflow
+    if (((unsigned short) object & mask) != (unsigned short) object) {
+        for (bitindex = 0; bitindex < bit_width; bitindex++){
+            buf[bitindex]='0';
+        }
+    }
+    else{
+        unsigned bit_mask = 1 << (bit_width-1);
+        for (bitindex = 0; bitindex < bit_width; bitindex++) {
+            buf[bitindex] = (object & bit_mask)? '1' : '0';
+            bit_mask = bit_mask >> 1;
+        }
+    }
+    buf[bitindex] = '\0';
+    std::fprintf(f, "assign %s \"%s\" ;\n", wif_name.c_str(), buf); 
+    old_value = object;
+}
+
+/*****************************************************************************/
+
+class wif_signed_char_trace: public wif_trace {
+public:
+    wif_signed_char_trace(const char& object_,
+			  const std::string& name_,
+			  const std::string& wif_name_,
+			  int width_);
+    void write(FILE* f);
+    bool changed();
+
+protected:
+    const char& object;
+    char old_value;
+    unsigned char mask; 
+};
+
+
+wif_signed_char_trace::wif_signed_char_trace(const char& object_,
+					     const std::string& name_,
+					     const std::string& wif_name_,
+					     int width_) 
+: wif_trace(name_, wif_name_), object(object_), old_value(object_), mask(0xff)
+{
+    bit_width = width_;
+    if (bit_width < 8) {
+        mask = (unsigned char)~(-1 << bit_width);
+    }
+
+    wif_type = "BIT";
+}
+
+
+bool wif_signed_char_trace::changed()
+{
+    return object != old_value;
+}
+
+
+void wif_signed_char_trace::write(FILE* f)
+{
+    char buf[1000];
+    int bitindex;
+
+    // Check for overflow
+    if (((unsigned char) object & mask) != (unsigned char) object) {
+        for (bitindex = 0; bitindex < bit_width; bitindex++){
+            buf[bitindex]='0';
+        }
+    }
+    else{
+        unsigned bit_mask = 1 << (bit_width-1);
+        for (bitindex = 0; bitindex < bit_width; bitindex++) {
+            buf[bitindex] = (object & bit_mask)? '1' : '0';
+            bit_mask = bit_mask >> 1;
+        }
+    }
+    buf[bitindex] = '\0';
+    std::fprintf(f, "assign %s \"%s\" ;\n", wif_name.c_str(), buf); 
+    old_value = object;
+}
+
+/*****************************************************************************/
+
+class wif_signed_long_trace: public wif_trace {
+public:
+    wif_signed_long_trace(const long& object_,
+			  const std::string& name_,
+			  const std::string& wif_name_,
+			  int width_);
+    void write(FILE* f);
+    bool changed();
+
+protected:
+    const long& object;
+    long old_value;
+    unsigned long mask; 
+};
+
+
+wif_signed_long_trace::wif_signed_long_trace(const long& object_,
+					     const std::string& name_,
+					     const std::string& wif_name_,
+					     int width_) 
+: wif_trace(name_, wif_name_), object(object_), old_value(object_),
+  mask((unsigned long)-1L)
+{
+    bit_width = width_;
+    if (bit_width < (int)(sizeof(long)*BITS_PER_BYTE)) {
+        mask = ~(-1L << bit_width);
+    }
+
+    wif_type = "BIT";
+}
+
+
+bool wif_signed_long_trace::changed()
+{
+    return object != old_value;
+}
+
+
+void wif_signed_long_trace::write(FILE* f)
+{
+    char buf[1000];
+    int bitindex;
+
+    // Check for overflow
+    if (((unsigned long) object & mask) != (unsigned long) object) {
+        for (bitindex = 0; bitindex < bit_width; bitindex++){
+            buf[bitindex]='0';
+        }
+    } else {
+        unsigned long bit_mask = 1ul << (bit_width-1);
+        for (bitindex = 0; bitindex < bit_width; bitindex++) {
+            buf[bitindex] = (object & bit_mask)? '1' : '0';
+            bit_mask = bit_mask >> 1;
+        }
+    }
+    buf[bitindex] = '\0';
+    std::fprintf(f, "assign %s \"%s\" ;\n", wif_name.c_str(), buf); 
+    old_value = object;
+}
+
+
+/*****************************************************************************/
+
+class wif_float_trace: public wif_trace {
+public:
+    wif_float_trace(const float& object_,
+		    const std::string& name_,
+		    const std::string& wif_name_);
+    void write(FILE* f);
+    bool changed();
+
+protected:    
+    const float& object;
+    float old_value;
+};
+
+wif_float_trace::wif_float_trace(const float& object_,
+				 const std::string& name_,
+				 const std::string& wif_name_)
+: wif_trace(name_, wif_name_), object(object_), old_value(object_)
+{
+    bit_width = 0;
+    wif_type = "real";
+}
+
+bool wif_float_trace::changed()
+{
+    return object != old_value;
+}
+
+void wif_float_trace::write(FILE* f)
+{
+    std::fprintf(f,"assign  %s %f ; \n", wif_name.c_str(), object);
+    old_value = object;
+}
+
+/*****************************************************************************/
+
+class wif_double_trace: public wif_trace {
+public:
+    wif_double_trace(const double& object_,
+		     const std::string& name_,
+		     const std::string& wif_name_);
+    void write(FILE* f);
+    bool changed();
+
+protected:    
+    const double& object;
+    double old_value;
+};
+
+wif_double_trace::wif_double_trace(const double& object_,
+				   const std::string& name_,
+				   const std::string& wif_name_)
+: wif_trace(name_, wif_name_), object(object_), old_value(object_)
+{
+    bit_width = 0;
+    wif_type = "real";
+}
+
+bool wif_double_trace::changed()
+{
+    return object != old_value;
+}
+
+void wif_double_trace::write(FILE* f)
+{
+    std::fprintf(f,"assign  %s %f ; \n", wif_name.c_str(), object);
+    old_value = object;
+}
+
+
+/*****************************************************************************/
+
+class wif_enum_trace : public wif_trace {
+public:
+    wif_enum_trace(const unsigned& object_,
+		   const std::string& name_,
+		   const std::string& wif_name_,
+		   const char** enum_literals);
+    void write(FILE* f);
+    bool changed();
+    // Hides the definition of the same (virtual) function in wif_trace
+    void print_variable_declaration_line(FILE* f);
+
+protected:
+    const unsigned& object;
+    unsigned old_value;
+    
+    const char** literals;
+    unsigned nliterals;
+    std::string type_name;
+
+    ~wif_enum_trace();
+};
+
+
+wif_enum_trace::wif_enum_trace(const unsigned& object_,
+			       const std::string& name_,
+			       const std::string& wif_name_,
+			       const char** enum_literals_) 
+: wif_trace(name_, wif_name_), object(object_), old_value(object_),
+  literals(enum_literals_), nliterals(0), type_name(name_ + "__type__")
+{
+    // find number of enumeration literals - counting loop
+    for (nliterals = 0; enum_literals_[nliterals]; nliterals++) continue;
+
+    bit_width = 0;
+    wif_type = type_name.c_str();
+}       
+
+void wif_enum_trace::print_variable_declaration_line(FILE* f)
+{
+    std::fprintf(f, "type scalar \"%s\" enum ", wif_type);
+
+    for (unsigned i = 0; i < nliterals; i++)
+      std::fprintf(f, "\"%s\", ", literals[i]);
+    std::fprintf(f, "\"SC_WIF_UNDEF\" ;\n");
+
+    std::fprintf(f, "declare  %s   \"%s\"  \"%s\" ",
+	    wif_name.c_str(), name.c_str(), wif_type);
+    std::fprintf(f, "variable ;\n");
+    std::fprintf(f, "start_trace %s ;\n", wif_name.c_str());
+}
+
+bool wif_enum_trace::changed()
+{
+    return object != old_value;
+}
+
+void wif_enum_trace::write(FILE* f)
+{
+    static bool warning_issued = false;
+    const char* lit;
+
+    if (object >= nliterals) { // Note unsigned value is always greater than 0
+        if (!warning_issued) {
+            SC_REPORT_WARNING( SC_ID_TRACING_INVALID_ENUM_VALUE_ 
+                             , name.c_str() );
+            warning_issued = true;
+        }
+        lit = "SC_WIF_UNDEF";
+    }
+    else
+    {
+        lit = literals[object];
+    }
+    std::fprintf( f, "assign %s \"%s\" ;\n", wif_name.c_str(), lit );
+    old_value = object;
+}
+
+wif_enum_trace::~wif_enum_trace()
+{
+    /* Intentionally blank */
+}
+
+
+template <class T>
+class wif_T_trace
+: public wif_trace
+{
+public:
+
+    wif_T_trace( const T& object_,
+		 const std::string& name_,
+		 const std::string& wif_name_,
+		 wif_trace_file::wif_enum type_ )
+    : wif_trace( name_, wif_name_),
+      object( object_ ),
+      old_value( object_ )
+    {  wif_type = wif_names[type_]; }
+
+    void write( FILE* f )
+    {
+       std::fprintf( f,
+		"assign %s \"%s\" ;\n",
+		wif_name.c_str(),
+		object.to_string().c_str() );
+       old_value = object;
+    }
+
+    bool changed()
+        { return !(object == old_value); }
+
+    void set_width()
+        { bit_width = object.length(); }
+
+protected:
+
+    const T& object;
+    T        old_value;
+};
+
+typedef wif_T_trace<sc_dt::sc_bv_base> wif_sc_bv_trace;
+typedef wif_T_trace<sc_dt::sc_lv_base> wif_sc_lv_trace;
+
+
+//***********************************************************************
+//           wif_trace_file functions
+//***********************************************************************
+
+
+wif_trace_file::wif_trace_file(const char * name)
+  : sc_trace_file_base( name, "awif" )
+  , wif_name_index(0)
+  , previous_time_units_low(0)
+  , previous_time_units_high(0)
+  , previous_time(0.0)
+  , traces()
+{}
+
+
+void wif_trace_file::do_initialize()
+{
+    char buf[2000];
+
+    // init
+    std::fprintf(fp, "init ;\n\n");
+
+    //timescale:
+    if     (timescale_unit == 1e-15) std::sprintf(buf,"0");
+    else if(timescale_unit == 1e-14) std::sprintf(buf,"1");
+    else if(timescale_unit == 1e-13) std::sprintf(buf,"2");
+    else if(timescale_unit == 1e-12) std::sprintf(buf,"3");
+    else if(timescale_unit == 1e-11) std::sprintf(buf,"4");
+    else if(timescale_unit == 1e-10) std::sprintf(buf,"5");
+    else if(timescale_unit == 1e-9)  std::sprintf(buf,"6");
+    else if(timescale_unit == 1e-8)  std::sprintf(buf,"7");
+    else if(timescale_unit == 1e-7)  std::sprintf(buf,"8");
+    else if(timescale_unit == 1e-6)  std::sprintf(buf,"9");
+    else if(timescale_unit == 1e-5)  std::sprintf(buf,"10");
+    else if(timescale_unit == 1e-4)  std::sprintf(buf,"11");
+    else if(timescale_unit == 1e-3)  std::sprintf(buf,"12");
+    else if(timescale_unit == 1e-2)  std::sprintf(buf,"13");
+    else if(timescale_unit == 1e-1)  std::sprintf(buf,"14");
+    else if(timescale_unit == 1e0)   std::sprintf(buf,"15");
+    else if(timescale_unit == 1e1)   std::sprintf(buf,"16");
+    else if(timescale_unit == 1e2)   std::sprintf(buf,"17");
+    std::fprintf(fp,"header  %s \"%s\" ;\n\n", buf, sc_version());
+
+    std::fprintf(fp, "comment \"ASCII WIF file produced on date:  %s\" ;\n"
+                , localtime_string().c_str());
+ 
+    //version:
+    std::fprintf(fp, "comment \"Created by %s\" ;\n", sc_version());
+    //conversion info
+    std::fprintf(fp, "comment \"Convert this file to binary WIF format using a2wif\" ;\n\n");
+
+    // Define the two types we need to represent bool and sc_logic
+    std::fprintf(fp, "type scalar \"BIT\" enum '0', '1' ;\n");
+    std::fprintf(fp, "type scalar \"MVL\" enum '0', '1', 'X', 'Z', '?' ;\n");
+    std::fprintf(fp, "\n");
+
+    //variable definitions:
+    int i;
+    for (i = 0; i < (int)traces.size(); i++) {
+        wif_trace* t = traces[i];
+        t->set_width(); //needed for all vectors
+        t->print_variable_declaration_line(fp);
+    }
+
+    double inittime = sc_time_stamp().to_seconds();
+    previous_time = inittime/timescale_unit;
+
+    // Dump all values at initial time
+    std::sprintf(buf,
+            "All initial values are dumped below at time "
+            "%g sec = %g timescale units.",
+            inittime,
+            inittime/timescale_unit
+            );
+    write_comment(buf);
+
+    double_to_special_int64(inittime/timescale_unit,
+			    &previous_time_units_high,
+			    &previous_time_units_low );
+
+    for (i = 0; i < (int)traces.size(); i++) {
+        wif_trace* t = traces[i];
+        t->write(fp);
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#define DEFN_TRACE_METHOD(tp)                                                 \
+void                                                                          \
+wif_trace_file::trace( const tp& object_, const std::string& name_ )          \
+{                                                                             \
+    if( add_trace_check(name_) )                                              \
+        traces.push_back( new wif_ ## tp ## _trace( object_,                  \
+                                                    name_,                    \
+                                                    obtain_name() ) );        \
+}
+
+DEFN_TRACE_METHOD(bool)
+DEFN_TRACE_METHOD(float)
+DEFN_TRACE_METHOD(double)
+
+#undef DEFN_TRACE_METHOD
+#define DEFN_TRACE_METHOD(tp)                                                 \
+void                                                                          \
+wif_trace_file::trace(const sc_dt::tp& object_, const std::string& name_)     \
+{                                                                             \
+    if( add_trace_check(name_) )                                              \
+        traces.push_back( new wif_ ## tp ## _trace( object_,                  \
+                                                    name_,                    \
+                                                    obtain_name() ) );        \
+}
+
+DEFN_TRACE_METHOD(sc_bit)
+DEFN_TRACE_METHOD(sc_logic)
+
+DEFN_TRACE_METHOD(sc_signed)
+DEFN_TRACE_METHOD(sc_unsigned)
+DEFN_TRACE_METHOD(sc_int_base)
+DEFN_TRACE_METHOD(sc_uint_base)
+
+DEFN_TRACE_METHOD(sc_fxval)
+DEFN_TRACE_METHOD(sc_fxval_fast)
+DEFN_TRACE_METHOD(sc_fxnum)
+DEFN_TRACE_METHOD(sc_fxnum_fast)
+
+#undef DEFN_TRACE_METHOD
+
+
+#define DEFN_TRACE_METHOD_SIGNED(tp)                                          \
+void                                                                          \
+wif_trace_file::trace( const tp&          object_,                            \
+                       const std::string& name_,                              \
+                       int                width_ )                            \
+{                                                                             \
+    if( add_trace_check(name_) )                                              \
+        traces.push_back( new wif_signed_ ## tp ## _trace( object_,           \
+                                                           name_,             \
+                                                           obtain_name(),     \
+                                                           width_ ) );        \
+}
+
+#define DEFN_TRACE_METHOD_UNSIGNED(tp)                                        \
+void                                                                          \
+wif_trace_file::trace( const unsigned tp& object_,                            \
+                       const std::string& name_,                              \
+                       int                width_ )                            \
+{                                                                             \
+    if( add_trace_check(name_) )                                              \
+        traces.push_back( new wif_unsigned_ ## tp ## _trace( object_,         \
+                                                             name_,           \
+                                                             obtain_name(),   \
+                                                             width_ ) );      \
+}
+
+DEFN_TRACE_METHOD_SIGNED(char)
+DEFN_TRACE_METHOD_SIGNED(short)
+DEFN_TRACE_METHOD_SIGNED(int)
+DEFN_TRACE_METHOD_SIGNED(long)
+
+DEFN_TRACE_METHOD_UNSIGNED(char)
+DEFN_TRACE_METHOD_UNSIGNED(short)
+DEFN_TRACE_METHOD_UNSIGNED(int)
+DEFN_TRACE_METHOD_UNSIGNED(long)
+
+#undef DEFN_TRACE_METHOD_SIGNED
+#undef DEFN_TRACE_METHOD_UNSIGNED
+
+
+#define DEFN_TRACE_METHOD_LONG_LONG(tp)                                       \
+void                                                                          \
+wif_trace_file::trace( const sc_dt::tp&   object_,                            \
+                       const std::string& name_,                              \
+                       int                width_ )                            \
+{                                                                             \
+    if( add_trace_check(name_) )                                              \
+        traces.push_back( new wif_ ## tp ## _trace( object_,                  \
+                                                    name_,                    \
+                                                    obtain_name(),            \
+                                                    width_ ) );               \
+}
+
+DEFN_TRACE_METHOD_LONG_LONG(int64)
+DEFN_TRACE_METHOD_LONG_LONG(uint64)
+#undef DEFN_TRACE_METHOD_LONG_LONG
+
+void
+wif_trace_file::trace( const unsigned& object_,
+		       const std::string& name_,
+		       const char** enum_literals_ )
+{
+    if( add_trace_check(name_) )
+        traces.push_back( new wif_enum_trace( object_,
+                                              name_,
+                                              obtain_name(),
+                                              enum_literals_ ) );
+}
+
+void
+wif_trace_file::trace( const sc_dt::sc_bv_base& object_, 
+    const std::string& name_ )
+{
+   traceT( object_, name_, WIF_BIT );
+}
+
+void
+wif_trace_file::trace( const sc_dt::sc_lv_base& object_, 
+    const std::string& name_ )
+{
+   traceT( object_, name_, WIF_MVL );
+}
+
+
+void
+wif_trace_file::write_comment(const std::string& comment)
+{
+    if(!fp) open_fp();
+    //no newline in comments allowed
+    std::fprintf(fp, "comment \"%s\" ;\n", comment.c_str());
+}
+
+
+void
+wif_trace_file::cycle(bool this_is_a_delta_cycle)
+{
+    unsigned now_units_high, now_units_low;
+
+    // Trace delta cycles only when enabled
+    if (!delta_cycles() && this_is_a_delta_cycle) return;
+
+    // Check for initialization
+    if( initialize() ) {
+        return;
+    };
+
+    // double now_units = sc_simulation_time() / timescale_unit;
+    double now_units = sc_time_stamp().to_seconds() / timescale_unit;
+    
+    double_to_special_int64(now_units, &now_units_high, &now_units_low );
+
+    // Now do the real stuff
+    unsigned delta_units_high, delta_units_low;
+    double diff_time;
+    diff_time = now_units - previous_time;
+    double_to_special_int64(diff_time, &delta_units_high, &delta_units_low);
+    if (this_is_a_delta_cycle && (diff_time == 0.0))
+	delta_units_low++; // Increment time for delta cycle simulation
+    // Note that in the last statement above, we are assuming no more
+    // than 2^32 delta cycles - seems realistic
+    
+    bool time_printed = false;
+    wif_trace* const* const l_traces = &traces[0];
+    for (int i = 0; i < (int)traces.size(); i++) {
+        wif_trace* t = l_traces[i];
+        if(t->changed()){
+            if(time_printed == false){
+                if(delta_units_high){
+                    std::fprintf(fp, "delta_time %u%09u ;\n", delta_units_high,
+			    delta_units_low);
+                }
+                else{ 
+                    std::fprintf(fp, "delta_time %u ;\n", delta_units_low);
+                }
+                time_printed = true;
+            }
+
+	    // Write the variable
+            t->write(fp);
+        }
+    }
+
+    if(time_printed) {
+        std::fprintf(fp, "\n");     // Put another newline
+	// We update previous_time_units only when we print time because
+	// this field stores the previous time that was printed, not the
+	// previous time this function was called
+	previous_time_units_high = now_units_high;
+	previous_time_units_low = now_units_low;
+	previous_time = now_units;
+    }
+}
+
+#if 0
+void
+wif_trace_file::create_wif_name(std::string* ptr_to_str)
+{
+  obtain_name().swap(*ptr_to_str);
+}
+#endif
+
+// Create a WIF name for a variable
+std::string
+wif_trace_file::obtain_name()
+{
+    char buf[32];
+    std::sprintf( buf, "O%d", wif_name_index ++ );
+    return buf;
+}
+
+wif_trace_file::~wif_trace_file()
+{
+    for( int i = 0; i < (int)traces.size(); i++ ) {
+        wif_trace* t = traces[i];
+        delete t;
+    }
+}
+
+// Map sc_logic values to values understandable by WIF
+static char
+map_sc_logic_state_to_wif_state(char in_char)
+{
+    char out_char;
+
+    switch(in_char){
+        case 'U':
+        case 'X': 
+        case 'W':
+        case 'D':
+            out_char = 'X';
+            break;
+        case '0':
+        case 'L':
+            out_char = '0';
+            break;
+        case  '1':
+        case  'H': 
+            out_char = '1';
+            break;
+        case  'Z': 
+            out_char = 'Z';
+            break;
+        default:
+            out_char = '?';
+    }
+    return out_char;
+}
+
+// ----------------------------------------------------------------------------
+
+// Create the trace file
+sc_trace_file*
+sc_create_wif_trace_file(const char * name)
+{
+    sc_trace_file *tf = new wif_trace_file(name);
+    return tf;
+}
+
+
+void
+sc_close_wif_trace_file( sc_trace_file* tf )
+{
+    wif_trace_file* wif_tf = static_cast<wif_trace_file*>(tf);
+    delete wif_tf;
+}
+
+} // namespace sc_core
diff --git a/ext/systemc/src/sysc/tracing/sc_wif_trace.h b/ext/systemc/src/sysc/tracing/sc_wif_trace.h
new file mode 100644
index 000000000..b4de46e1b
--- /dev/null
+++ b/ext/systemc/src/sysc/tracing/sc_wif_trace.h
@@ -0,0 +1,222 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_wif_trace.h - Implementation of WIF tracing.
+
+  Original Author - Abhijit Ghosh, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+   Acknowledgement: The tracing mechanism is based on the tracing
+   mechanism developed at Infineon (formerly Siemens HL). Though this
+   code is somewhat different, and significantly enhanced, the basics
+   are identical to what was originally contributed by Infineon.
+   The contribution of Infineon in the development of this tracing
+   technology is hereby acknowledged.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+   Instead of creating the binary WIF format, we create the ASCII
+   WIF format which can be converted to the binary format using
+   a2wif (utility that comes with VSS from Synopsys). This way, 
+   a user who does not have Synopsys VSS can still create WIF 
+   files, but the files can only be viewed by users who have VSS.
+
+ *****************************************************************************/
+
+#ifndef SC_WIF_TRACE_H
+#define SC_WIF_TRACE_H
+
+#include <cstdio>
+#include "sysc/datatypes/int/sc_nbdefs.h"
+#include "sysc/tracing/sc_trace_file_base.h"
+
+namespace sc_core {
+
+class wif_trace;  // defined in wif_trace.cc
+template<class T> class wif_T_trace;
+
+class wif_trace_file
+  : public sc_trace_file_base
+{
+public:
+    enum wif_enum {WIF_BIT=0, WIF_MVL=1, WIF_REAL=2, WIF_LAST};
+
+    // Create a wif trace file.
+    // `Name' forms the base of the name to which `.awif' is added.
+    explicit wif_trace_file(const char *name);
+
+    ~wif_trace_file();
+
+protected:
+    // These are all virtual functions in sc_trace_file and
+    // they need to be defined here.
+
+    // Trace a boolean object (single bit)
+     void trace(const bool& object, const std::string& name);
+
+    // Trace a sc_bit object (single bit)
+     void trace(const sc_dt::sc_bit& object, const std::string& name);
+
+    // Trace a sc_logic object (single bit)
+     void trace(const sc_dt::sc_logic& object, const std::string& name);
+    
+    // Trace an unsigned char with the given width
+     void trace(const unsigned char& object, const std::string& name, 
+	int width);
+
+    // Trace an unsigned short with the given width
+     void trace(const unsigned short& object, const std::string& name, 
+         int width);
+
+    // Trace an unsigned int with the given width
+     void trace(const unsigned int& object, const std::string& name, 
+         int width);
+
+    // Trace an unsigned long with the given width
+     void trace(const unsigned long& object, const std::string& name, 
+         int width);
+
+    // Trace a signed char with the given width
+     void trace(const char& object, const std::string& name, int width);
+
+    // Trace a signed short with the given width
+     void trace(const short& object, const std::string& name, int width);
+
+    // Trace a signed int with the given width
+     void trace(const int& object, const std::string& name, int width);
+
+    // Trace a signed long with the given width
+     void trace(const long& object, const std::string& name, int width);
+    
+    // Trace a signed long long with the given width
+     void trace(const sc_dt::int64& object, const std::string& name, 
+         int width);
+    
+    // Trace an usigned long long with the given width
+     void trace(const sc_dt::uint64& object, const std::string& name, 
+         int width);
+    
+    // Trace a float
+     void trace(const float& object, const std::string& name);
+
+    // Trace a double
+     void trace(const double& object, const std::string& name);
+
+    // Trace sc_unsigned
+     void trace (const sc_dt::sc_unsigned& object, 
+	 const std::string& name);
+
+    // Trace sc_signed
+     void trace (const sc_dt::sc_signed& object, 
+	 const std::string& name);
+
+    // Trace sc_uint_base
+     void trace (const sc_dt::sc_uint_base& object, 
+         const std::string& name);
+
+    // Trace sc_int_base
+     void trace (const sc_dt::sc_int_base& object, const std::string& name);
+
+    // Trace sc_fxval
+    void trace( const sc_dt::sc_fxval& object, const std::string& name );
+
+    // Trace sc_fxval_fast
+    void trace( const sc_dt::sc_fxval_fast& object, 
+    	const std::string& name );
+
+    // Trace sc_fxnum
+    void trace( const sc_dt::sc_fxnum& object, const std::string& name );
+
+    // Trace sc_fxnum_fast
+    void trace( const sc_dt::sc_fxnum_fast& object, 
+    	const std::string& name );
+
+    template<class T>
+    void traceT(const T& object, const std::string& name, wif_enum type)
+    {
+        if( add_trace_check(name) )
+            traces.push_back( new wif_T_trace<T>( object, name
+                                                , obtain_name(),type ) );
+    }
+
+    // Trace sc_bv_base (sc_bv)
+    virtual void trace( const sc_dt::sc_bv_base& object, 
+    	const std::string& name );
+
+    // Trace sc_lv_base (sc_lv)
+    virtual void trace( const sc_dt::sc_lv_base& object, 
+    	const std::string& name );
+
+    // Trace an enumerated object - where possible output the enumeration literals
+    // in the trace file. Enum literals is a null terminated array of null
+    // terminated char* literal strings.
+     void trace(const unsigned& object, const std::string& name, 
+         const char** enum_literals);
+
+    // Output a comment to the trace file
+     void write_comment(const std::string& comment);
+
+    // Write trace info for cycle.
+     void cycle(bool delta_cycle);
+
+private:
+
+#if SC_TRACING_PHASE_CALLBACKS_
+    // avoid hidden overload warnings
+    virtual void trace( sc_trace_file* ) const { sc_assert(false); }
+#endif // SC_TRACING_PHASE_CALLBACKS_
+
+    // Initialize the tracing mechanism
+    virtual void do_initialize();
+
+    unsigned wif_name_index;           // Number of variables traced
+
+    unsigned previous_time_units_low;  // Previous time as 64 bit integer
+    unsigned previous_time_units_high;
+    double   previous_time;            // Previous time as a double
+
+public:
+    // Create wif names for each variable
+    std::string obtain_name();
+
+    // Array to store the variables traced
+    std::vector<wif_trace*> traces;
+};
+
+} //  namespace sc_core
+
+#endif // SC_WIF_TRACE_H
+// Taf!
diff --git a/ext/systemc/src/sysc/utils/sc_hash.cpp b/ext/systemc/src/sysc/utils/sc_hash.cpp
new file mode 100644
index 000000000..fc97fe416
--- /dev/null
+++ b/ext/systemc/src/sysc/utils/sc_hash.cpp
@@ -0,0 +1,670 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_hash.cpp -- Implementation of a chained hash table with MTF
+                 (move-to-front).
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+#include <assert.h>
+#include <stdlib.h> // duplicate (c)stdlib.h headers for Solaris
+#include <cstdlib>
+#include <cstddef>
+#include <string.h>
+
+#include "sysc/kernel/sc_cmnhdr.h"
+#include "sysc/utils/sc_hash.h"
+#include "sysc/utils/sc_mempool.h"
+
+namespace sc_core {
+
+// we can't assume global availability of uintptr_t,
+// approximate it by size_t
+typedef std::size_t uintptr_t;
+
+const double PHASH_DEFAULT_GROW_FACTOR     = 2.0;
+
+class sc_phash_elem {
+    friend class sc_phash_base;
+    friend class sc_phash_base_iter;
+
+private:
+    void* key;
+    void* contents;
+    sc_phash_elem* next;
+
+    sc_phash_elem( void* k, void* c, sc_phash_elem* n )
+        : key(k), contents(c), next(n) { }
+    sc_phash_elem() : key(0), contents(0), next(0) { }
+    ~sc_phash_elem() { }
+
+    static void* operator new(std::size_t sz) 
+        { return sc_mempool::allocate(sz); }
+    static void operator delete(void* p, std::size_t sz) 
+        { sc_mempool::release(p, sz);      }
+};
+
+
+sc_phash_base::sc_phash_base(
+    void* def,
+    int size,
+    int density,
+    double grow,
+    bool reorder,
+    unsigned (*hash_fn)(const void*),
+    int (*cmp_fn)(const void*, const void*)
+) :
+    default_value(def), num_bins(0), num_entries(0), max_density(density),
+    reorder_flag(reorder), grow_factor(grow), bins(0), hash(hash_fn), 
+    cmpr(cmp_fn)
+{
+    if (size <= 0)
+        size = PHASH_DEFAULT_INIT_TABLE_SIZE;
+    else if ((size % 2) == 0)
+        size += 1;
+    num_bins = size;
+    bins = new sc_phash_elem*[size];
+    for (int i = 0; i < size; ++i)
+        bins[i] = 0;
+}
+
+void
+sc_phash_base::set_cmpr_fn(cmpr_fn_t c)
+{
+    cmpr = c;
+}
+
+void
+sc_phash_base::set_hash_fn(hash_fn_t h)
+{
+    hash = h;
+}
+
+sc_phash_base::~sc_phash_base()
+{
+    sc_phash_elem* ptr;
+    sc_phash_elem* next;
+
+    for (int i = 0; i < num_bins; ++i) {
+        ptr = bins[i];
+        while (ptr != 0) {
+            next = ptr->next;
+            delete ptr;
+            ptr = next;
+        }
+    }
+    delete[] bins;
+}
+
+void
+sc_phash_base::rehash()
+{
+    sc_phash_elem* ptr;
+    sc_phash_elem* next;
+    sc_phash_elem** old_bins = bins;
+
+    int old_num_bins = num_bins;
+    unsigned hash_val;
+
+    num_bins = (int) (grow_factor * old_num_bins);
+    if (num_bins % 2 == 0)
+        ++num_bins;
+
+    num_entries = 0;
+    bins = new sc_phash_elem*[num_bins];
+    memset( bins, 0, sizeof(sc_phash_elem*) * num_bins );
+
+    for (int i = 0; i < old_num_bins; ++i) {
+        ptr = old_bins[i];
+        while (ptr != 0) {
+            next = ptr->next;
+            hash_val = do_hash(ptr->key);
+            ptr->next = bins[hash_val];
+            bins[hash_val] = ptr;
+            ++num_entries;
+            ptr = next;
+        }
+    }
+    delete[] old_bins;
+}
+
+sc_phash_elem*
+sc_phash_base::find_entry_q( unsigned hash_val, const void* key, sc_phash_elem*** plast )
+{
+    sc_phash_elem** last = &(bins[hash_val]);
+    sc_phash_elem*  ptr  = *last;
+
+    /* The (ptr->key != key) here is meant by the "q" */
+    while ((ptr != 0) && (ptr->key != key)) {
+        /*                         ^^ right here */
+        last = &(ptr->next);
+        ptr  = *last;
+    }
+    if ((ptr != 0) && reorder_flag) {
+        *last = ptr->next;
+        ptr->next = bins[hash_val];
+        bins[hash_val] = ptr;
+        last = &(bins[hash_val]);
+    }
+    if (plast) *plast = last;
+    return ptr;
+}
+
+sc_phash_elem*
+sc_phash_base::find_entry_c( unsigned hash_val, const void* key, sc_phash_elem*** plast )
+{
+    sc_phash_elem** last = &(bins[hash_val]);
+    sc_phash_elem*  ptr  = *last;
+
+    while ((ptr != 0) && ((*cmpr)(ptr->key, key) != 0)) {
+        last = &(ptr->next);
+        ptr = *last;
+    }
+        /* Bring to front */
+    if ((ptr != 0) && reorder_flag) {
+        *last = ptr->next;
+        ptr->next = bins[hash_val];
+        bins[hash_val] = ptr;
+        last = &(bins[hash_val]);
+    }
+    if (plast) *plast = last;
+    return ptr;
+}
+
+sc_phash_elem*
+sc_phash_base::add_direct( void* key, void* contents, unsigned hash_val )
+{
+    if (num_entries / num_bins >= max_density) {
+        rehash();
+        hash_val = do_hash(key);
+    }
+
+    sc_phash_elem* new_entry = new sc_phash_elem(key, contents, bins[hash_val]);
+    bins[hash_val] = new_entry;
+    ++num_entries;
+    return new_entry;
+}
+
+void
+sc_phash_base::erase()
+{
+    for (int i = 0; i < num_bins; ++i) {
+        sc_phash_elem* ptr = bins[i];
+        while (ptr != 0) {
+            sc_phash_elem* next = ptr->next;
+            delete ptr;
+            ptr = next;
+            --num_entries;
+        }
+        bins[i] = 0;
+    }
+    assert(num_entries == 0);
+}
+
+void
+sc_phash_base::erase(void (*kfree)(void*))
+{
+    for (int i = 0; i < num_bins; ++i) {
+        sc_phash_elem* ptr = bins[i];
+        while (ptr != 0) {
+            sc_phash_elem* next = ptr->next;
+            (*kfree)(ptr->key);
+            delete ptr;
+            ptr = next;
+            --num_entries;
+        }
+        bins[i] = 0;
+    }
+    assert(num_entries == 0);
+}
+
+void
+sc_phash_base::copy( const sc_phash_base* b )
+{
+    erase();
+    iterator iter((sc_phash_base*) b);  /* cast away the const */
+    for ( ; ! iter.empty(); iter++)
+        insert( iter.key(), iter.contents() );
+}
+
+void
+sc_phash_base::copy(const sc_phash_base& b, void* (*kdup)(const void*), void (*kfree)(void*))
+{
+    erase(kfree);
+    iterator iter((sc_phash_base&) b);
+    for ( ; ! iter.empty(); iter++)
+        insert( (*kdup)(iter.key()), iter.contents() );
+}
+
+int
+sc_phash_base::insert( void* k, void* c )
+{
+    unsigned hash_val = do_hash(k);
+    sc_phash_elem* ptr = find_entry( hash_val, k );
+    if (ptr == 0) {
+        (void) add_direct(k, c, hash_val);
+        return 0;
+    }
+    else {
+        ptr->contents = c;
+        return 1;
+    }
+}
+
+int
+sc_phash_base::insert( void* k, void* c, void* (*kdup)(const void*) )
+{
+    unsigned hash_val = do_hash(k);
+    sc_phash_elem* ptr = find_entry( hash_val, k );
+    if (ptr == 0) {
+        (void) add_direct((*kdup)(k), c, hash_val);
+        return 0;
+    }
+    else {
+        ptr->contents = c;
+        return 1;
+    }
+}
+
+int
+sc_phash_base::insert_if_not_exists( void* k, void* c )
+{
+    unsigned hash_val = do_hash(k);
+    sc_phash_elem* ptr = find_entry( hash_val, k );
+    if (ptr == 0) {
+        (void) add_direct( k, c, hash_val );
+        return 0;
+    }
+    else
+        return 1;
+}
+
+int
+sc_phash_base::insert_if_not_exists( void* k, void* c, void* (*kdup)(const void*) )
+{
+    unsigned hash_val = do_hash(k);
+    sc_phash_elem* ptr = find_entry( hash_val, k );
+    if (ptr == 0) {
+        (void) add_direct( (*kdup)(k), c, hash_val );
+        return 0;
+    }
+    else
+        return 1;
+}
+
+int
+sc_phash_base::remove( const void* k )
+{
+    unsigned hash_val = do_hash(k);
+    sc_phash_elem** last;
+    sc_phash_elem*  ptr = find_entry( hash_val, k, &last );
+
+    if (ptr == 0)
+        return 0;
+
+    assert(*last == ptr);
+    *last = ptr->next;
+    delete ptr;
+    --num_entries;
+    return 1;
+}
+
+int
+sc_phash_base::remove( const void* k, void** pk, void** pc )
+{
+    unsigned hash_val = do_hash(k);
+    sc_phash_elem** last;
+    sc_phash_elem*  ptr = find_entry( hash_val, k, &last );
+
+    if (ptr == 0) {
+        *pk = 0;
+        *pc = 0;
+        return 0;
+    }
+    else {
+        *pk = ptr->key;
+        *pc = ptr->contents;
+    }
+
+    assert(*last == ptr);
+    *last = ptr->next;
+    delete ptr;
+    --num_entries;
+    return 1;
+}
+
+int
+sc_phash_base::remove(const void* k, void (*kfree)(void*))
+{
+    void* rk;
+    void* rc;
+    if (remove(k, &rk, &rc)) {
+        (*kfree)(rk);
+        return 1;
+    }
+    else
+        return 0;
+}
+
+int
+sc_phash_base::remove_by_contents( const void* c )
+{
+    sc_phash_elem** last;
+    sc_phash_elem*  ptr;
+
+    int num_removed = 0;
+    for (int i = 0; i < num_bins; ++i) {
+        last = &(bins[i]);
+        ptr = *last;
+        while (ptr != 0) {
+            if (ptr->contents != c) {
+                last = &(ptr->next);
+                ptr  = *last;
+            }
+            else {
+                *last = ptr->next;
+                delete ptr;
+                ptr = *last;
+                --num_entries;
+                ++num_removed;
+            }
+        }
+    }
+    return num_removed;
+}
+
+int
+sc_phash_base::remove_by_contents( bool (*predicate)(const void* c, void* arg), void* arg )
+{
+    sc_phash_elem** last;
+    sc_phash_elem*  ptr;
+
+    int num_removed = 0;
+    for (int i = 0; i < num_bins; ++i) {
+        last = &(bins[i]);
+        ptr = *last;
+        while (ptr != 0) {
+            if (! (*predicate)(ptr->contents, arg)) {
+                last = &(ptr->next);
+                ptr  = *last;
+            }
+            else {
+                *last = ptr->next;
+                delete ptr;
+                ptr = *last;
+                --num_entries;
+                ++num_removed;
+            }
+        }
+    }
+    return num_removed;
+}
+
+int
+sc_phash_base::remove_by_contents( const void* c, void (*kfree)(void*) )
+{
+    sc_phash_elem** last;
+    sc_phash_elem*  ptr;
+
+    int num_removed = 0;
+    for (int i = 0; i < num_bins; ++i) {
+        last = &(bins[i]);
+        ptr = *last;
+        while (ptr != 0) {
+            if (ptr->contents != c) {
+                last = &(ptr->next);
+                ptr  = *last;
+            }
+            else {
+                *last = ptr->next;
+                (*kfree)(ptr->key);
+                delete ptr;
+                ptr = *last;
+                --num_entries;
+                ++num_removed;
+            }
+        }
+    }
+    return num_removed;
+}
+
+int
+sc_phash_base::remove_by_contents( bool (*predicate)(const void*, void*), void* arg, void (*kfree)(void*))
+{
+    sc_phash_elem** last;
+    sc_phash_elem*  ptr;
+
+    int num_removed = 0;
+    for (int i = 0; i < num_bins; ++i) {
+        last = &(bins[i]);
+        ptr = *last;
+        while (ptr != 0) {
+            if (! (*predicate)(ptr->contents, arg)) {
+                last = &(ptr->next);
+                ptr  = *last;
+            }
+            else {
+                *last = ptr->next;
+                (*kfree)(ptr->key);
+                delete ptr;
+                ptr = *last;
+                --num_entries;
+                ++num_removed;
+            }
+        }
+    }
+    return num_removed;
+}
+
+int
+sc_phash_base::lookup( const void* k, void** c_ptr ) const
+{
+    unsigned hash_val = do_hash(k);
+    sc_phash_elem* ptr = find_entry( hash_val, k );
+    if (ptr == 0) {
+        if (c_ptr != 0) *c_ptr = default_value;
+        return 0;
+    }
+    else {
+        if (c_ptr != 0) *c_ptr = ptr->contents;
+        return 1;
+    }
+}
+
+void*
+sc_phash_base::operator[]( const void* key ) const
+{
+    void* contents;
+    lookup( key, &contents );
+    return contents;
+}
+
+/***************************************************************************/
+
+void
+sc_phash_base_iter::reset( sc_phash_base* t )
+{
+    table = t;
+    index = 0;
+    entry = 0;
+    next  = 0;
+
+    for (int i = index; i < table->num_bins; ++i) {
+        if (table->bins[i] != 0) {
+            index = i + 1;
+            last  = &(table->bins[i]);
+            entry = *last;
+            next  = entry->next;
+            break;
+        }
+    }
+}
+
+bool
+sc_phash_base_iter::empty() const
+{
+    return (entry == 0);
+}
+
+void
+sc_phash_base_iter::step()
+{
+    if (entry) {
+        last = &(entry->next);
+    }
+    entry = next;
+    if (! entry) {
+        for (int i = index; i < table->num_bins; ++i) {
+            if (table->bins[i] != 0) {
+                index = i + 1;
+                last = &(table->bins[i]);
+                entry = *last;
+                next = entry->next;
+                break;
+            }
+        }
+    }
+    else {
+        next = entry->next;
+    }
+}
+
+void
+sc_phash_base_iter::remove()
+{
+    delete entry;
+    *last = next;
+    entry = 0;
+    --table->num_entries;
+    step();
+}
+
+void
+sc_phash_base_iter::remove(void (*kfree)(void*))
+{
+    (*kfree)(entry->key);
+    delete entry;
+    *last = next;
+    entry = 0;
+    --table->num_entries;
+    step();
+}
+
+void*
+sc_phash_base_iter::key() const
+{
+    return entry->key;
+}
+
+void*
+sc_phash_base_iter::contents() const
+{
+    return entry->contents;
+}
+
+void*
+sc_phash_base_iter::set_contents( void* c )
+{
+    return entry->contents = c;
+}
+
+/****************************************************************************/
+
+unsigned 
+default_ptr_hash_fn(const void* p)
+{
+    return static_cast<unsigned>(((uintptr_t)(p) >> 2) * 2654435789U);
+
+}
+
+unsigned
+default_int_hash_fn(const void* p)
+{
+    return static_cast<unsigned>((uintptr_t)(p) * 3141592661U);
+}
+
+
+unsigned
+default_str_hash_fn(const void* p)
+{
+    if (!p) return 0;
+
+    const char* x = (const char*) p;
+    unsigned int h = 0;
+    unsigned int g;
+
+    while (*x != 0) {
+        h = (h << 4) + *x++;
+        if ((g = h & 0xf0000000) != 0)
+            h = (h ^ (g >> 24)) ^ g;
+    }
+    return h;
+}
+
+int
+sc_strhash_cmp( const void* a, const void* b )
+{
+    return strcmp( (const char*) a, (const char*) b );
+}
+
+void*
+sc_strhash_kdup(const void* k)
+{
+    char* result = (char*) malloc( strlen((const char*)k)+1 );
+    strcpy(result, (const char*) k);
+    return result;
+}
+
+void
+sc_strhash_kfree(void* k)
+{
+    if (k) free((char*) k);
+}
+ } // namespace sc_core
+
+// $Log: sc_hash.cpp,v $
+// Revision 1.5  2011/08/26 20:42:30  acg
+//  Andy Goodrich:
+//    (1) Replaced strdup with new and strcpy to eliminate issue with the
+//        Greenhills compiler.
+//    (2) Moved modification log to the end of the file to eliminate line
+//        skew when check-ins are done.
+//
+// Revision 1.4  2011/08/24 22:05:56  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.3  2011/05/05 17:46:04  acg
+//  Philip A. Hartmann: changes in "swap" support.
+//
+// Revision 1.2  2011/02/18 20:38:43  acg
+//  Andy Goodrich: Updated Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:06  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:10  acg
+// Andy Goodrich: Added $Log command so that CVS comments are reproduced in
+// the source.
+
+// taf
diff --git a/ext/systemc/src/sysc/utils/sc_hash.h b/ext/systemc/src/sysc/utils/sc_hash.h
new file mode 100644
index 000000000..14f8ee980
--- /dev/null
+++ b/ext/systemc/src/sysc/utils/sc_hash.h
@@ -0,0 +1,460 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_hash.cpp -- Implementation of a chained hash table with MTF
+                 (move-to-front).
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+#ifndef SC_HASH_H
+#define SC_HASH_H
+
+
+namespace sc_core {
+
+extern unsigned default_int_hash_fn(const void*);
+extern unsigned default_ptr_hash_fn(const void*);
+extern unsigned default_str_hash_fn(const void*);
+
+class sc_phash_elem;
+class sc_phash_base_iter;
+template<class K, class C>  //template class 
+class sc_pdhash_iter;       //decl. -- Amit
+
+const int    PHASH_DEFAULT_MAX_DENSITY     = 5;
+const int    PHASH_DEFAULT_INIT_TABLE_SIZE = 11;
+extern const double PHASH_DEFAULT_GROW_FACTOR;
+const bool   PHASH_DEFAULT_REORDER_FLAG    = true;
+
+class sc_phash_base {
+    friend class sc_phash_base_iter;
+
+    typedef sc_phash_base_iter iterator;
+
+public:
+    typedef unsigned (*hash_fn_t)(const void*);
+    typedef int (*cmpr_fn_t)(const void*, const void*);
+
+protected:
+    void*    default_value;
+    int      num_bins;
+    int      num_entries;
+    int      max_density;
+    int      reorder_flag;
+    double   grow_factor;
+
+    sc_phash_elem** bins;
+
+    hash_fn_t hash;
+    cmpr_fn_t cmpr;
+
+    void rehash();
+    unsigned do_hash(const void* key) const { return (*hash)(key) % num_bins; }
+
+    sc_phash_elem* add_direct(void* key, void* contents, unsigned hash_val);
+    sc_phash_elem* find_entry_c(unsigned hv, const void* k, sc_phash_elem*** plast);
+    sc_phash_elem* find_entry_q(unsigned hv, const void* k, sc_phash_elem*** plast);
+    sc_phash_elem* find_entry(unsigned hv, const void* k, sc_phash_elem*** plast=0) const
+    {
+      /* Got rid of member func. pointer and replaced with if-else  */
+      /* Amit (5/14/99)                                             */
+      if( cmpr == 0 )
+        return ((sc_phash_base*)this)->find_entry_q( hv, k, plast );
+      else 
+	return ((sc_phash_base*)this)->find_entry_c( hv, k, plast );
+    }
+
+public:
+    sc_phash_base( void* def       = 0,
+                   int    size     = PHASH_DEFAULT_INIT_TABLE_SIZE,
+                   int    density  = PHASH_DEFAULT_MAX_DENSITY,
+                   double grow     = PHASH_DEFAULT_GROW_FACTOR,
+                   bool   reorder  = PHASH_DEFAULT_REORDER_FLAG,    
+                   hash_fn_t hash_fn = default_ptr_hash_fn,
+                   cmpr_fn_t cmpr_fn = 0                             );
+    ~sc_phash_base();
+
+    void set_cmpr_fn(cmpr_fn_t);
+    void set_hash_fn(hash_fn_t);
+
+    bool empty() const { return (num_entries == 0); }
+    unsigned count() const { return num_entries; }
+
+    void erase();
+    void erase(void (*kfree)(void*));
+    void copy( const sc_phash_base* );
+    void copy( const sc_phash_base& b ) { copy(&b); }
+    void copy( const sc_phash_base& b, void* (*kdup)(const void*), void (*kfree)(void*));
+    int insert( void* k, void* c );
+    int insert( void* k ) { return insert(k, default_value); }
+    int insert( void* k, void* c, void* (*kdup)(const void*) );
+    int insert_if_not_exists(void* k, void* c);
+    int insert_if_not_exists(void* k) { return insert_if_not_exists(k, default_value); }
+    int insert_if_not_exists(void* k, void* c, void* (*kdup)(const void*));
+    int remove(const void* k);
+    int remove(const void* k, void** pk, void** pc);
+    int remove(const void* k, void (*kfree)(void*));
+    int remove_by_contents(const void* c);
+    int remove_by_contents(bool (*predicate)(const void*, void*), void* arg);
+    int remove_by_contents(const void* c, void (*kfree)(void*));
+    int remove_by_contents(bool (*predicate)(const void*, void*), void* arg, void (*kfree)(void*));
+    int lookup(const void* k, void** pc) const;
+    bool contains(const void* k) const { return (lookup(k, 0) != 0); }
+    void* operator[](const void* key) const;
+};
+
+class sc_phash_base_iter {
+protected:
+    sc_phash_base*  table;
+    sc_phash_elem*  entry;
+    sc_phash_elem*  next;
+    sc_phash_elem** last;
+    int             index;
+
+public:
+    void reset(sc_phash_base* t);
+    void reset(sc_phash_base& t) { reset(&t); }
+
+    sc_phash_base_iter(sc_phash_base* t)
+    : table(t), entry(0), next(0), last(0), index(0)
+        { reset(t); }
+    sc_phash_base_iter(sc_phash_base& t)
+    : table(&t), entry(0), next(0), last(0), index(0)
+        { reset(t); }
+    ~sc_phash_base_iter() { }
+
+    bool empty() const;
+    void step();
+    void operator++(int) { step(); }
+    void remove();
+    void remove(void (*kfree)(void*));
+    void* key() const;
+    void* contents() const;
+    void* set_contents(void* c);
+};
+
+template< class K, class C >
+class sc_phash_iter;
+
+template< class K, class C >
+class sc_phash : public sc_phash_base {
+    friend class sc_phash_iter<K,C>;
+
+public:
+    typedef sc_phash_iter<K,C> iterator;
+
+    sc_phash( C def = (C) 0,
+              int size    = PHASH_DEFAULT_INIT_TABLE_SIZE,
+              int density = PHASH_DEFAULT_MAX_DENSITY,
+              double grow = PHASH_DEFAULT_GROW_FACTOR,
+              bool reorder = PHASH_DEFAULT_REORDER_FLAG,
+              hash_fn_t hash_fn = default_ptr_hash_fn,
+              cmpr_fn_t cmpr_fn = 0                          )
+        : sc_phash_base((void*) def, size, density, grow, reorder, hash_fn, cmpr_fn) { }
+    ~sc_phash() { }
+
+    void copy(const sc_phash<K,C>* b) { sc_phash_base::copy(b); }
+    void copy(const sc_phash<K,C>& b) { sc_phash_base::copy(b); }
+    void copy(const sc_phash<K,C>& b, void* (*kdup)(const void*), void (*kfree)(void*)) { sc_phash_base::copy(b, kdup, kfree); }
+
+    int insert(K k, C c) { return sc_phash_base::insert((void*) k, (void*) c); }
+    int insert(K k) { return sc_phash_base::insert((void*) k, default_value); }
+    int insert(K k, C c, void* (*kdup)(const void*)) { return sc_phash_base::insert((void*) k, (void*) c, kdup); }
+    int insert_if_not_exists(K k, C c)
+    {
+        return sc_phash_base::insert_if_not_exists((void*) k, (void*) c);
+    }
+    int insert_if_not_exists(K k)
+    {
+        return sc_phash_base::insert_if_not_exists((void*) k, default_value);
+    }
+    int insert_if_not_exists(K k, C c, void* (*kdup)(const void*))
+    {
+        return sc_phash_base::insert_if_not_exists((void*) k, (void*) c, kdup);
+    }
+    int remove(K k) { return sc_phash_base::remove((const void*) k); }
+    int remove(K k, K* pk, C* pc)
+    {
+        return sc_phash_base::remove((const void*) k, (void**) pk, (void**) pc);
+    }
+    int remove(K k, void (*kfree)(void*))
+    {
+        return sc_phash_base::remove((const void*) k, kfree);
+    }
+    int remove_by_contents(C c)
+    {
+        return sc_phash_base::remove_by_contents((const void*) c);
+    }
+    int remove_by_contents(bool (*predicate)(const void*, void*), void* arg)
+    {
+        return sc_phash_base::remove_by_contents(predicate, arg);
+    }
+    int remove_by_contents(const void* c, void (*kfree)(void*))
+    {
+        return sc_phash_base::remove_by_contents(c, kfree);
+    }
+    int remove_by_contents(bool (*predicate)(const void*, void*), void* arg, void (*kfree)(void*))
+    {
+        return sc_phash_base::remove_by_contents(predicate, arg, kfree);
+    }
+    int lookup(K k, C* pc) const
+    {
+        return sc_phash_base::lookup((const void*) k, (void**) pc);
+    }
+    bool contains(K k) const
+    {
+        return sc_phash_base::contains((const void*) k);
+    }
+    C operator[](K k) const
+    {
+        return (C) sc_phash_base::operator[]((const void*) k);
+    }
+};
+
+
+template< class K, class C >
+class sc_phash_iter : public sc_phash_base_iter {
+public:
+    sc_phash_iter(sc_phash<K,C>* t) : sc_phash_base_iter(t) { }
+    sc_phash_iter(sc_phash<K,C>& t) : sc_phash_base_iter(t) { }
+    ~sc_phash_iter() { }
+
+    void reset(sc_phash<K,C>* t) { sc_phash_base_iter::reset(t); }
+    void reset(sc_phash<K,C>& t) { sc_phash_base_iter::reset(t); }
+
+    K key()      const { return (K) sc_phash_base_iter::key();      }
+    C contents() const { return (C) sc_phash_base_iter::contents(); }
+    C set_contents(C c)
+    {
+        return (C) sc_phash_base_iter::set_contents((void*) c);
+    }
+};
+
+
+
+
+
+template< class K, class C >
+class sc_pdhash : public sc_phash_base {
+    friend class sc_pdhash_iter<K,C>;
+
+private:
+    void* (*kdup)(const void*); //eliminated braces around void* -- Amit
+    void (*kfree)(void*);
+
+public:
+    typedef sc_pdhash_iter<K,C> iterator;
+    sc_pdhash( C def = (C) 0,
+              int size    = PHASH_DEFAULT_INIT_TABLE_SIZE,
+              int density = PHASH_DEFAULT_MAX_DENSITY,
+              double grow = PHASH_DEFAULT_GROW_FACTOR,
+              bool reorder = PHASH_DEFAULT_REORDER_FLAG,
+              hash_fn_t hash_fn = (hash_fn_t) 0, // defaults added --
+              cmpr_fn_t cmpr_fn = (cmpr_fn_t) 0, // Amit
+              void* (*kdup_fn)(const void*) = 0,
+              void (*kfree_fn)(void*)  = 0 )
+        : sc_phash_base((void*) def, size, density, grow, reorder, hash_fn, cmpr_fn)
+    {
+        kdup = kdup_fn;
+        kfree = kfree_fn;
+    }
+    ~sc_pdhash()
+    {
+        erase();
+    }
+    void erase()
+    {
+        sc_phash_base::erase(kfree);
+    }
+    void copy(const sc_pdhash<K,C>& b) { sc_phash_base::copy(b, kdup, kfree); }
+    int insert(K k, C c) { return sc_phash_base::insert((void*) k, (void*) c, kdup); }
+    int insert(K k) { return sc_phash_base::insert((void*) k, default_value, kdup); }
+    int insert_if_not_exists(K k, C c)
+    {
+        return sc_phash_base::insert_if_not_exists((void*) k, (void*) c, kdup);
+    }
+    int insert_if_not_exists(K k)
+    {
+        return sc_phash_base::insert_if_not_exists((void*) k, default_value, kdup);
+    }
+    int remove(K k) { return sc_phash_base::remove((const void*) k, kfree); }
+    int remove(K k, K* pk, C* pc)
+    {
+        return sc_phash_base::remove((const void*) k, (void**) pk, (void**) pc);
+    }
+    int remove_by_contents(C c)
+    {
+        return sc_phash_base::remove_by_contents((const void*) c, kfree);
+    }
+    int remove_by_contents(bool (*predicate)(const void*, void*), void* arg)
+    {
+        return sc_phash_base::remove_by_contents(predicate, arg, kfree);
+    }
+    int lookup(K k, C* pc) const
+    {
+        return sc_phash_base::lookup((const void*) k, (void**) pc);
+    }
+    bool contains(K k) const
+    {
+        return sc_phash_base::contains((const void*) k);
+    }
+    C operator[](K k) const
+    {
+        return (C) sc_phash_base::operator[]((const void*) k);
+    }
+};
+
+template< class K, class C >
+class sc_pdhash_iter : public sc_phash_base_iter {
+public:
+    sc_pdhash_iter(sc_pdhash<K,C>* t) : sc_phash_base_iter(t) { }
+    sc_pdhash_iter(sc_pdhash<K,C>& t) : sc_phash_base_iter(t) { }
+    ~sc_pdhash_iter() { }
+
+    void reset(sc_pdhash<K,C>* t) { sc_phash_base_iter::reset(t); }
+    void reset(sc_pdhash<K,C>& t) { sc_phash_base_iter::reset(t); }
+
+    void remove() { sc_phash_base_iter::remove(((sc_pdhash<K,C>*) table)->kfree); }
+    K key()      const { return (K) sc_phash_base_iter::key();      }
+    C contents() const { return (C) sc_phash_base_iter::contents(); }
+    C set_contents(C c)
+    {
+        return (C) sc_phash_base_iter::set_contents((void*) c);
+    }
+};
+
+extern int sc_strhash_cmp( const void*, const void* );
+extern void sc_strhash_kfree(void*);
+extern void* sc_strhash_kdup(const void*);
+
+template< class C >      // template class decl.
+class sc_strhash_iter;   // --Amit
+
+template< class C >
+class sc_strhash : public sc_phash_base {
+    friend class sc_strhash_iter<C>;
+
+public:
+    typedef sc_strhash_iter<C> iterator;
+
+    sc_strhash( C def = (C) 0,
+                int size    = PHASH_DEFAULT_INIT_TABLE_SIZE,
+                int density = PHASH_DEFAULT_MAX_DENSITY,
+                double grow = PHASH_DEFAULT_GROW_FACTOR,
+                bool reorder = PHASH_DEFAULT_REORDER_FLAG,
+                unsigned (*hash_fn)(const void*) = default_str_hash_fn,
+                int (*cmpr_fn)(const void*, const void*) = sc_strhash_cmp )
+        : sc_phash_base((void*) def, size, density, grow, reorder, hash_fn, cmpr_fn)
+    {
+
+    }
+    ~sc_strhash()
+    {
+        erase();
+    }
+
+    void erase() { sc_phash_base::erase(sc_strhash_kfree); }
+    void copy(const sc_strhash<C>* b) { sc_phash_base::copy(*b, sc_strhash_kdup, sc_strhash_kfree); }
+    void copy(const sc_strhash<C>& b) { sc_phash_base::copy(b, sc_strhash_kdup, sc_strhash_kfree); }
+
+    int insert(char* k, C c) { return sc_phash_base::insert((void*) k, (void*) c, sc_strhash_kdup); }
+    int insert(char* k) { return sc_phash_base::insert((void*) k, default_value, sc_strhash_kdup); }
+    int insert_if_not_exists(char* k, C c)
+    {
+        return sc_phash_base::insert_if_not_exists((void*) k, (void*) c, sc_strhash_kdup);
+    }
+    int insert_if_not_exists(char* k)
+    {
+        return sc_phash_base::insert_if_not_exists((void*) k, default_value, sc_strhash_kdup);
+    }
+    int remove(const char* k) { return sc_phash_base::remove((const void*) k, sc_strhash_kfree); }
+    int remove(const char* k, char** pk, C* pc)
+    {
+        return sc_phash_base::remove((const void*) k, (void**) pk, (void**) pc);
+    }
+    int remove_by_contents(C c)
+    {
+        return sc_phash_base::remove_by_contents((const void*) c, sc_strhash_kfree);
+    }
+    int remove_by_contents(bool (*predicate)(const void*, void*), void* arg)
+    {
+        return sc_phash_base::remove_by_contents(predicate, arg, sc_strhash_kfree);
+    }
+    int lookup(const char* k, C* pc) const
+    {
+        return sc_phash_base::lookup((const void*) k, (void** )pc);
+    }
+    bool contains(const char* k) const
+    {
+        return sc_phash_base::contains((const void*) k);
+    }
+    C operator[](const char* k) const
+    {
+        return (C) sc_phash_base::operator[]((const void*) k);
+    }
+};
+
+template<class C>
+class sc_strhash_iter : public sc_phash_base_iter {
+public:
+    sc_strhash_iter ( sc_strhash<C>* t ) : sc_phash_base_iter(t) { }
+    sc_strhash_iter ( sc_strhash<C>& t ) : sc_phash_base_iter(t) { }
+    ~sc_strhash_iter() { }
+
+    void reset ( sc_strhash<C>* t ) { sc_phash_base_iter::reset(t); }
+    void reset ( sc_strhash<C>& t ) { sc_phash_base_iter::reset(t); }
+
+    void remove() { sc_phash_base_iter::remove(sc_strhash_kfree); }
+    const char* key()   { return (const char*) sc_phash_base_iter::key(); }
+    C contents()  { return (C) sc_phash_base_iter::contents(); }
+    C set_contents(C c)
+    {
+        return (C) sc_phash_base_iter::set_contents((void*) c);
+    }
+};
+
+} // namespace sc_core
+
+// $Log: sc_hash.h,v $
+// Revision 1.5  2011/08/29 18:04:32  acg
+//  Philipp A. Hartmann: miscellaneous clean ups.
+//
+// Revision 1.4  2011/08/26 20:46:16  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.3  2011/08/24 22:05:56  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.2  2011/02/18 20:38:43  acg
+//  Andy Goodrich: Updated Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:06  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:10  acg
+// Andy Goodrich: Added $Log command so that CVS comments are reproduced in
+// the source.
+
+#endif
diff --git a/ext/systemc/src/sysc/utils/sc_iostream.h b/ext/systemc/src/sysc/utils/sc_iostream.h
new file mode 100644
index 000000000..4f19d511e
--- /dev/null
+++ b/ext/systemc/src/sysc/utils/sc_iostream.h
@@ -0,0 +1,91 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_iostream.h - Portable iostream header file wrapper.
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+  Note: Deprecated in the meantime, since all supported
+        compilers are supposed to have a working C++
+        standard library.
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+#ifndef SC_IOSTREAM_H
+#define SC_IOSTREAM_H
+
+#include <ios>
+#include <iostream>
+#include <sstream>
+#include <fstream>
+#include <cstddef>
+#include <cstring>
+
+// We use typedefs for istream and ostream here to get around some finickiness
+// from aCC:
+
+namespace sc_dt {
+
+typedef ::std::istream systemc_istream;
+typedef ::std::ostream systemc_ostream;
+
+} // namespace sc_dt
+
+// shortcuts that save some typing
+
+#ifdef CCAST
+#    undef CCAST
+#endif
+#define CCAST       const_cast
+
+#ifdef DCAST
+#    undef DCAST
+#endif
+#define DCAST     dynamic_cast
+
+#ifdef RCAST
+#    undef RCAST
+#endif
+#define RCAST reinterpret_cast
+
+#ifdef SCAST
+#    undef SCAST
+#endif
+#define SCAST      static_cast
+
+// $Log: sc_iostream.h,v $
+// Revision 1.3  2011/08/26 20:46:18  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.2  2011/02/18 20:38:43  acg
+//  Andy Goodrich: Updated Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:06  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:10  acg
+// Andy Goodrich: Added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#endif // !defined(SC_IOSTREAM_H)
diff --git a/ext/systemc/src/sysc/utils/sc_list.cpp b/ext/systemc/src/sysc/utils/sc_list.cpp
new file mode 100644
index 000000000..88998fbe9
--- /dev/null
+++ b/ext/systemc/src/sysc/utils/sc_list.cpp
@@ -0,0 +1,343 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_list.cpp -- Simple implementation of a doubly linked list.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+
+#include <assert.h>
+#include <cstddef>
+
+#include "sysc/kernel/sc_cmnhdr.h"
+#include "sysc/utils/sc_iostream.h"
+#include "sysc/utils/sc_list.h"
+#include "sysc/utils/sc_mempool.h"
+#include "sysc/utils/sc_report.h"
+#include "sysc/utils/sc_utils_ids.h"
+
+namespace sc_core {
+
+class sc_plist_elem {
+    friend class sc_plist_base_iter;
+    friend class sc_plist_base;
+
+private:
+    sc_plist_elem() : data(0), prev(0), next(0) 
+    {}
+    sc_plist_elem( void* d, sc_plist_elem* p, sc_plist_elem* n ) :
+        data(d), prev(p), next(n) 
+    {}
+    ~sc_plist_elem()
+    {}
+
+    static void* operator new(std::size_t sz)            { return sc_mempool::allocate(sz); }
+    static void operator delete(void* p, std::size_t sz) { sc_mempool::release(p, sz);      }
+    
+    void* data;
+    sc_plist_elem* prev;
+    sc_plist_elem* next;
+};
+
+sc_plist_base::sc_plist_base() : head(0), tail(0) {}
+
+sc_plist_base::~sc_plist_base()
+{
+    handle_t p;
+    for( handle_t h = head; h != 0; h = p ) {
+        p = h->next;
+        delete h;
+    }
+}
+
+void
+sc_plist_base::erase_all()
+{
+    handle_t p;
+    for( handle_t h = head; h != 0; h = p ) {
+        p = h->next;
+        delete h;
+    }
+    head = 0;
+    tail = 0;
+}
+
+int
+sc_plist_base::size() const
+{
+    int n = 0;
+    for( handle_t h = head; h != 0; h = h->next ) {
+        n++;
+    }
+    return n;
+}
+
+sc_plist_base::handle_t
+sc_plist_base::push_back( void* d )
+{
+    handle_t q = new sc_plist_elem( d, tail, 0 );
+    if (tail) {
+        tail->next = q;
+        tail = q;
+    }
+    else {
+        head = tail = q;
+    }
+    return q;
+}
+
+sc_plist_base::handle_t
+sc_plist_base::push_front( void* d )
+{
+    handle_t q = new sc_plist_elem( d, (sc_plist_elem*) 0, head );
+    if (head) {
+        head->prev = q;
+        head = q;
+    }
+    else {
+        head = tail = q;
+    }
+    return q;
+}
+
+void*
+sc_plist_base::pop_back()
+{
+    handle_t q = tail;
+    void* d = q->data;
+    tail = tail->prev;
+    delete q;
+    if (tail != 0) {
+        tail->next = 0;
+    }
+    else {
+        head = 0;
+    }
+    return d;
+}
+
+void*
+sc_plist_base::pop_front()
+{
+    handle_t q = head;
+    void* d = q->data;
+    head = head->next;
+    delete q;
+    if (head != 0) {
+        head->prev = 0;
+    }
+    else {
+        tail = 0;
+    }
+    return d;
+}
+
+sc_plist_base::handle_t
+sc_plist_base::insert_before( handle_t h, void* d )
+{
+    if (h == 0) {
+        return push_back(d);
+    }
+    else {
+        handle_t q = new sc_plist_elem( d, h->prev, h );
+        h->prev->next = q;
+        h->prev = q;
+        return q;
+    }
+}
+
+sc_plist_base::handle_t
+sc_plist_base::insert_after( handle_t h, void* d )
+{
+    if (h == 0) {
+        return push_front(d);
+    }
+    else {
+        handle_t q = new sc_plist_elem( d, h, h->next );
+        h->next->prev = q;
+        h->next = q;
+        return q;
+    }
+}
+
+void*
+sc_plist_base::remove( handle_t h )
+{
+    if (h == head)
+        return pop_front();
+    else if (h == tail)
+        return pop_back();
+    else {
+        void* d = h->data;
+        h->prev->next = h->next;
+        h->next->prev = h->prev;
+        delete h;
+        return d;
+    }
+}
+
+void*
+sc_plist_base::get( handle_t h ) const
+{
+    return h->data;
+}
+
+void
+sc_plist_base::set( handle_t h, void* d )
+{
+    h->data = d;
+}
+
+void
+sc_plist_base::mapcar( sc_plist_map_fn f, void* arg )
+{
+    for (handle_t h = head; h != 0; h = h->next) {
+        f( h->data, arg );
+    }
+}
+
+void*
+sc_plist_base::front() const
+{
+
+   if (head) {			
+        return head->data;
+    }				
+    else {
+      SC_REPORT_ERROR( SC_ID_FRONT_ON_EMPTY_LIST_ , 0 );
+      // never reached
+      return 0;
+    }
+}
+
+void*
+sc_plist_base::back() const
+{
+   if (tail) {
+        return tail->data;
+    }
+    else {
+      SC_REPORT_ERROR( SC_ID_BACK_ON_EMPTY_LIST_, 0 );
+      // never reached
+      return 0;
+    }
+}
+
+
+
+sc_plist_base_iter::sc_plist_base_iter( sc_plist_base* l, bool from_tail ) :
+    lst(l), ptr( from_tail ? l->tail : l->head )
+{
+}
+
+void
+sc_plist_base_iter::reset( sc_plist_base* l, bool from_tail )
+{
+    lst = l;
+    if (from_tail) {
+        ptr = l->tail;
+    }
+    else {
+        ptr = l->head;
+    }
+}
+
+sc_plist_base_iter::~sc_plist_base_iter()
+{
+
+}
+
+bool
+sc_plist_base_iter::empty() const
+{
+    return ptr == 0;
+}
+
+void
+sc_plist_base_iter::operator++(int)
+{
+    ptr = ptr->next;
+}
+
+void
+sc_plist_base_iter::operator--(int)
+{
+    ptr = ptr->prev;
+}
+
+void*
+sc_plist_base_iter::get() const
+{
+    return ptr->data;
+}
+
+void
+sc_plist_base_iter::set( void* d )
+{
+    ptr->data = d;
+}
+
+void
+sc_plist_base_iter::remove()
+{
+    sc_plist_base::handle_t nptr = ptr->next;
+    lst->remove(ptr);
+    ptr = nptr;
+}
+
+void
+sc_plist_base_iter::remove(int direction)
+{
+    sc_plist_base::handle_t nptr = (direction == 1) ? ptr->next : ptr->prev;
+    lst->remove(ptr);
+    ptr = nptr;
+}
+
+void
+sc_plist_base_iter::set_handle( sc_plist_elem* h )
+{
+    ptr = h;
+}
+
+} // namespace sc_core
+
+// $Log: sc_list.cpp,v $
+// Revision 1.4  2011/08/26 20:46:18  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.3  2011/08/24 22:05:56  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.2  2011/02/18 20:38:43  acg
+//  Andy Goodrich: Updated Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:06  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:10  acg
+// Andy Goodrich: Added $Log command so that CVS comments are reproduced in
+// the source.
+
+// taf
diff --git a/ext/systemc/src/sysc/utils/sc_list.h b/ext/systemc/src/sysc/utils/sc_list.h
new file mode 100644
index 000000000..40f4c92af
--- /dev/null
+++ b/ext/systemc/src/sysc/utils/sc_list.h
@@ -0,0 +1,188 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_list.h -- Simple implementation of a doubly linked list.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+
+#ifndef SC_LIST_H
+#define SC_LIST_H
+
+namespace sc_core {
+
+//Some forward declarations
+class sc_plist_elem;
+template<class T> class sc_plist_iter; 
+
+typedef void (*sc_plist_map_fn)( void* data, void* arg );
+
+class sc_plist_base {
+    friend class sc_plist_base_iter;
+
+public:
+    sc_plist_base();
+    ~sc_plist_base();
+    
+    typedef sc_plist_elem* handle_t;
+
+    handle_t push_back(void* d);
+    handle_t push_front(void* d);
+    void* pop_back();
+    void* pop_front();
+    handle_t insert_before(handle_t h, void* d);
+    handle_t insert_after(handle_t h, void* d);
+    void* remove(handle_t h);
+    void* get(handle_t h) const;
+    void set(handle_t h, void* d);
+    void mapcar( sc_plist_map_fn f, void* arg );
+
+    void* front() const;
+    void* back() const;
+
+    void erase_all();
+    bool empty() const { return (head == 0); }
+    int size() const;
+
+private:
+    handle_t head;
+    handle_t tail;
+};
+
+
+class sc_plist_base_iter {
+public:
+    typedef sc_plist_elem* handle_t;
+    
+    sc_plist_base_iter( sc_plist_base* l, bool from_tail = false );
+    ~sc_plist_base_iter();
+
+    void reset( sc_plist_base* l, bool from_tail = false );
+    bool empty() const;
+    void operator++(int);
+    void operator--(int);
+    void* get() const;
+    void  set(void* d);
+    void remove();
+    void remove(int direction);
+
+    void set_handle(handle_t h);
+    handle_t get_handle() const { return ptr; }
+    
+private:
+    sc_plist_base* lst;
+    sc_plist_elem* ptr;
+};
+
+/*---------------------------------------------------------------------------*/
+
+template< class T >
+class sc_plist : public sc_plist_base {
+    friend class sc_plist_iter <T>;
+
+public:
+    typedef sc_plist_iter<T> iterator;
+
+    sc_plist() { } 
+    ~sc_plist() { } 
+
+    handle_t push_back(T d)  { return sc_plist_base::push_back((void*)d);  }
+    handle_t push_front(T d) { return sc_plist_base::push_front((void*)d); }
+    T pop_back()           { return (T) sc_plist_base::pop_back(); }
+    T pop_front()          { return (T) sc_plist_base::pop_front(); }
+    handle_t insert_before(handle_t h, T d) 
+    {
+        return sc_plist_base::insert_before(h, (void*) d);
+    }
+    handle_t insert_after(handle_t h, T d)
+    {
+        return sc_plist_base::insert_after(h, (void*) d);
+    }
+    T remove(handle_t h)
+    {
+        return (T)sc_plist_base::remove(h);
+    }
+    T get(handle_t h) const { return (T)sc_plist_base::get(h); }
+    void set(handle_t h, T d) { sc_plist_base::set(h, (void*)d); }
+
+    T front() const { return (T)sc_plist_base::front(); }
+    T back() const { return (T)sc_plist_base::back(); }
+};
+
+template< class T >
+class sc_plist_iter : public sc_plist_base_iter {
+public:
+    sc_plist_iter( sc_plist<T>* l, bool from_tail = false )
+        : sc_plist_base_iter( l, from_tail )
+    {
+
+    }
+    sc_plist_iter( sc_plist<T>& l, bool from_tail = false )
+        : sc_plist_base_iter( &l, from_tail )
+    {
+
+    }
+    ~sc_plist_iter()
+    {
+
+    }
+
+    void reset( sc_plist<T>* l, bool from_tail = false )
+    {
+        sc_plist_base_iter::reset( l, from_tail );
+    }
+    void reset( sc_plist<T>& l, bool from_tail = false )
+    {
+        sc_plist_base_iter::reset( &l, from_tail );
+    }
+
+    T operator*() const { return (T) sc_plist_base_iter::get(); }
+    T get() const     { return (T) sc_plist_base_iter::get(); }
+    void set(T d)     { sc_plist_base_iter::set((void*) d); }
+};
+
+} // namespace sc_core
+
+// $Log: sc_list.h,v $
+// Revision 1.5  2011/09/01 15:16:50  acg
+//  Philipp A. Hartmann: revert unnecessary virtual destructors.
+//
+// Revision 1.4  2011/08/26 20:46:18  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.3  2011/08/24 22:05:56  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.2  2011/02/18 20:38:44  acg
+//  Andy Goodrich: Updated Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:06  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:10  acg
+// Andy Goodrich: Added $Log command so that CVS comments are reproduced in
+// the source.
+
+#endif
diff --git a/ext/systemc/src/sysc/utils/sc_machine.h b/ext/systemc/src/sysc/utils/sc_machine.h
new file mode 100644
index 000000000..1939b0c99
--- /dev/null
+++ b/ext/systemc/src/sysc/utils/sc_machine.h
@@ -0,0 +1,81 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_machine.h -- Machine-dependent Environment Settings
+
+  Original Author: Andy Goodrich, Forte Design Systems, Inc.
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+
+#ifndef SC_MACHINE_H
+#define SC_MACHINE_H
+
+#include <climits>
+//#include "sysc/packages/boost/detail/endian.hpp"
+
+// We stripped the boost include and assume a build on x86
+#define SC_BOOST_LITTLE_ENDIAN
+
+// ----------------------------------------------------------------------------
+//  Little or big endian machine?
+// ----------------------------------------------------------------------------
+
+#if defined( SC_BOOST_LITTLE_ENDIAN )
+#   define SC_LITTLE_ENDIAN
+#elif defined( SC_BOOST_BIG_ENDIAN )
+#   define SC_BIG_ENDIAN
+#else
+#   error "Could not detect the endianness of the CPU."
+#endif
+
+// ----------------------------------------------------------------------------
+//  Are long data types 32-bit or 64-bit?
+// ----------------------------------------------------------------------------
+
+#if ULONG_MAX > 0xffffffffUL
+#   define SC_LONG_64
+#endif
+
+// $Log: sc_machine.h,v $
+// Revision 1.5  2011/08/26 22:58:23  acg
+//  Torsten Maehne: changes for endian detection.
+//
+// Revision 1.4  2011/08/26 20:46:18  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.3  2011/02/18 20:38:44  acg
+//  Andy Goodrich: Updated Copyright notice.
+//
+// Revision 1.2  2010/09/06 16:35:09  acg
+//  Andy Goodrich: changed i386 to __i386__ in ifdef.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:06  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:10  acg
+// Andy Goodrich: Added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#endif // !defined(SC_MACHINE_H)
diff --git a/ext/systemc/src/sysc/utils/sc_mempool.cpp b/ext/systemc/src/sysc/utils/sc_mempool.cpp
new file mode 100644
index 000000000..7369c12a0
--- /dev/null
+++ b/ext/systemc/src/sysc/utils/sc_mempool.cpp
@@ -0,0 +1,338 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_mempool.cpp - Memory pools for small objects.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+
+
+
+//  <sc_mempool> is a class that manages the memory for small objects,
+//  of sizes <increment>, 2 * <increment>, ..., <num_pools> *
+//  <increment>.  When a memory request of <k> bytes is made through
+//  the memory pool, the smallest pool <j> such that <j> * <increment>
+//  >= <k> is used.  The default values of <increment> and <num_pools>
+//  are 8 and 8, respectively.  Each pool has an allocator, that
+//  simply keeps a free list of cells, and allocate new blocks
+//  whenever necessary.  We are relying on malloc() to return a
+//  properly aligned memory blocks.  Note that the memory blocks
+//  allocated by the mempool are never freed.  Thus, if purify is
+//  used, we may get MIU (memory-in-use) warnings.  To disable this,
+//  set the environment variable SYSTEMC_MEMPOOL_DONT_USE to 1.
+
+
+static const char* dont_use_envstring = "SYSTEMC_MEMPOOL_DONT_USE";
+static bool use_default_new = false;
+
+
+#include <stdio.h>
+#include <stdlib.h> // duplicate (c)stdlib.h headers for Solaris
+#include <cstdlib>
+#include "sysc/utils/sc_mempool.h"
+
+namespace sc_core {
+
+//  An allocator is one that handles a particular size.  It keeps a
+//  <free_list> from which a cell may be allocated quickly if there
+//  is one available.  If no cell is available from <free_list>, then
+//  the allocator tries to find whether space is available from the
+//  most-recently-allocated block, as pointed to by <next_avail>.  If
+//  so, then the cell pointed to by <next_avail> is returned, while
+//  <next_avail> is advanced.  If <next_avail> now points beyond
+//  the current block, then it's reset to 0.  On the other hand,
+//  if <next_avail> was 0 when a request to the block is made, then
+//  a new block is allocated by calling system malloc(), and the new
+//  block becomes the head of <block_list>.
+
+
+class sc_allocator {
+    friend class sc_mempool;
+
+public:
+    sc_allocator( int blksz, int cellsz );
+    ~sc_allocator();
+    void* allocate();
+    void release(void* p);
+    
+    void display_statistics();
+
+private:
+    union link {
+        link* next;
+        double align;          // alignment required.
+    };
+
+    int block_size;            // size of each block in bytes,
+                               // including the link
+    int cell_size;             // size of each cell in bytes
+
+    char* block_list;
+    link* free_list;
+    char* next_avail;
+
+    int total_alloc;
+    int total_freed;
+    int free_list_alloc;
+};
+
+sc_allocator::sc_allocator( int blksz, int cellsz )
+  : block_size(sizeof(link) + (((blksz - 1) / cellsz) + 1) * cellsz),
+    cell_size(cellsz), block_list(0), free_list(0), next_avail(0),
+    total_alloc(0), total_freed(0), free_list_alloc(0)
+{}
+
+sc_allocator::~sc_allocator()
+{
+    // Shouldn't free the block_list, since global objects that use
+    // the memory pool may not have been destroyed yet ...
+    // Let it leak, let it leak, let it leak ...
+}
+
+void*
+sc_allocator::allocate()
+{
+    void* result = 0;
+    total_alloc++;
+    if (free_list != 0) {
+        free_list_alloc++;
+        result = free_list;
+        free_list = free_list->next;
+        return result;
+    }
+    else if (next_avail != 0) {
+        result = next_avail;
+        next_avail += cell_size;
+        // next_avail goes beyond the block
+        if (next_avail >= block_list + block_size)
+            next_avail = 0;
+        return result;
+    }
+    else {  // (next_avail == 0)
+        link* new_block = (link*) malloc(block_size);  // need alignment?
+        new_block->next = (link*) block_list;
+        block_list = (char*) new_block;
+        result = (block_list + sizeof(link));
+        // Assume that the block will hold more than one cell ... why
+        // wouldn't it?
+        next_avail = ((char*) result) + cell_size;
+        return result;
+    }
+}
+
+void
+sc_allocator::release(void* p)
+{
+    total_freed++;
+    ((link*) p)->next = free_list;
+    free_list = (link*) p;
+}
+
+void
+sc_allocator::display_statistics()
+{
+    int nblocks = 0;
+    for (link* b = (link*) block_list; b != 0; b = b->next)
+        nblocks++;
+    printf("size %3d: %2d block(s), %3d requests (%3d from free list), %3d freed.\n",
+           cell_size, nblocks, total_alloc, free_list_alloc, total_freed);
+}
+
+
+static const int cell_sizes[] = {
+/* 0 */   0,
+/* 1 */   8,
+/* 2 */  16,
+/* 3 */  24,
+/* 4 */  32,
+/* 5 */  48,
+/* 6 */  64,
+/* 7 */  80,
+/* 8 */  96,
+/* 9 */ 128
+};
+
+static const int cell_size_to_allocator[] = {
+/*  0 */    0,
+/*  1 */    1,
+/*  2 */    2,
+/*  3 */    3,
+/*  4 */    4,
+/*  5 */    5,
+/*  6 */    5,
+/*  7 */    6,
+/*  8 */    6,
+/*  9 */    7,
+/* 10 */    7,
+/* 11 */    8,
+/* 12 */    8,
+/* 13 */    9,
+/* 14 */    9,
+/* 15 */    9,
+/* 16 */    9
+};
+
+
+class sc_mempool_int {
+    friend class sc_mempool;
+
+public:
+    sc_mempool_int(int blksz, int npools, int incr);
+    ~sc_mempool_int();
+    void* do_allocate(std::size_t);
+    void  do_release(void*, std::size_t);
+
+    void display_statistics();
+    
+private:
+    sc_allocator** allocators;
+    int num_pools;
+    int increment;
+    int max_size;
+};
+
+
+static bool
+compute_use_default_new()
+{
+    const char* e = getenv(dont_use_envstring);
+    return (e != 0) && (atoi(e) != 0);
+}
+
+sc_mempool_int::sc_mempool_int(int blksz, int npools, int incr) :
+    allocators(0), num_pools(0), increment(0), max_size(0)
+{
+    use_default_new = compute_use_default_new();
+    if (! use_default_new) {
+        num_pools = npools;
+        increment = incr;
+        max_size = cell_sizes[sizeof(cell_sizes)/sizeof(cell_sizes[0]) - 1];
+        allocators = new sc_allocator*[npools + 1];
+        for (int i = 1; i <= npools; ++i)
+            allocators[i] = new sc_allocator(blksz, cell_sizes[i]);
+        allocators[0] = allocators[1];
+    }
+}
+
+sc_mempool_int::~sc_mempool_int()
+{
+    for (int i = 1; i <= num_pools; ++i)
+        delete allocators[i];
+    delete[] allocators;
+}
+
+static sc_mempool_int* the_mempool = 0;
+
+void*
+sc_mempool_int::do_allocate(std::size_t sz)
+{
+    int which_allocator = cell_size_to_allocator[(sz - 1) / increment + 1];
+    void* p = allocators[which_allocator]->allocate();
+    return p;
+}
+
+void
+sc_mempool_int::do_release(void* p, std::size_t sz)
+{
+    int which_allocator = cell_size_to_allocator[(sz - 1) / increment + 1];
+    allocators[which_allocator]->release(p);
+}
+
+void
+sc_mempool_int::display_statistics()
+{
+    printf("*** Memory Pool Statistics ***\n");
+    for (int i = 1; i <= num_pools; ++i)
+        allocators[i]->display_statistics();
+}
+
+/****************************************************************************/
+
+void*
+sc_mempool::allocate(std::size_t sz)
+{
+    if (use_default_new)
+        return ::operator new(sz);
+
+    if (the_mempool == 0) {
+        use_default_new = compute_use_default_new();
+        if (use_default_new)
+            return ::operator new(sz);
+
+        // Note that the_mempool is never freed.  This is going to cause
+        // memory leaks when the program exits.
+        the_mempool = new sc_mempool_int( 1984, sizeof(cell_sizes)/sizeof(cell_sizes[0]) - 1, 8 );
+    }
+
+    if (sz > (unsigned) the_mempool->max_size)
+        return ::operator new(sz);
+
+    return the_mempool->do_allocate(sz);
+}
+
+void
+sc_mempool::release(void* p, std::size_t sz)
+{
+    if (p) {
+        
+        if (use_default_new || sz > (unsigned) the_mempool->max_size) {
+            ::operator delete(p);
+            return;
+        }
+
+        the_mempool->do_release(p, sz);
+    }
+}
+
+void
+sc_mempool::display_statistics()
+{
+    if (the_mempool && !use_default_new) {
+        the_mempool->display_statistics();
+    } else {
+        printf("SystemC info: no memory allocation was done through the memory pool.\n");
+    }
+}
+
+} // namespace sc_core
+
+// $Log: sc_mempool.cpp,v $
+// Revision 1.4  2011/08/26 20:46:18  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.3  2011/08/24 22:05:56  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.2  2011/02/18 20:38:44  acg
+//  Andy Goodrich: Updated Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:06  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:10  acg
+// Andy Goodrich: Added $Log command so that CVS comments are reproduced in
+// the source.
+
+// taf
diff --git a/ext/systemc/src/sysc/utils/sc_mempool.h b/ext/systemc/src/sysc/utils/sc_mempool.h
new file mode 100644
index 000000000..1c053ae1c
--- /dev/null
+++ b/ext/systemc/src/sysc/utils/sc_mempool.h
@@ -0,0 +1,93 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_mempool.h - Memory pools for small objects.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+#ifndef SC_MEMPOOL_H
+#define SC_MEMPOOL_H
+
+
+#include "sysc/utils/sc_iostream.h"
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_mempool
+//
+//  ...
+// ----------------------------------------------------------------------------
+
+class sc_mempool
+{
+public:
+
+    static void* allocate( std::size_t sz );
+    static void release( void* p, std::size_t sz );
+    static void display_statistics();
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_mpobject
+//
+//  ...
+// ----------------------------------------------------------------------------
+
+class sc_mpobject
+{
+public:
+
+    static void* operator new( std::size_t sz )
+	{ return sc_mempool::allocate( sz ); }
+
+    static void operator delete( void* p, std::size_t sz )
+	{ sc_mempool::release( p, sz ); }
+
+    static void* operator new[]( std::size_t sz )
+	{ return sc_mempool::allocate( sz ); }
+
+    static void operator delete[]( void* p, std::size_t sz )
+	{ sc_mempool::release( p, sz ); }
+};
+
+} // namespace sc_core
+
+// $Log: sc_mempool.h,v $
+// Revision 1.3  2011/08/26 20:46:18  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.2  2011/02/18 20:38:44  acg
+//  Andy Goodrich: Updated Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:06  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:11  acg
+// Andy Goodrich: Added $Log command so that CVS comments are reproduced in
+// the source.
+
+#endif
diff --git a/ext/systemc/src/sysc/utils/sc_pq.cpp b/ext/systemc/src/sysc/utils/sc_pq.cpp
new file mode 100644
index 000000000..d20580ca5
--- /dev/null
+++ b/ext/systemc/src/sysc/utils/sc_pq.cpp
@@ -0,0 +1,133 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_pq.cpp - Simple heap implementation of priority queue.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+// $Log: sc_pq.cpp,v $
+// Revision 1.4  2011/08/26 20:46:18  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+
+#include "sysc/utils/sc_pq.h"
+
+namespace sc_core {
+
+sc_ppq_base::sc_ppq_base( int sz, int (*cmp)( const void*, const void* ) )
+    : m_heap(0), m_size_alloc( sz ), m_heap_size( 0 ), m_compar( cmp )
+{
+    // m_size_alloc must be at least 2, otherwise resizing doesn't work
+    if( m_size_alloc < 2 ) {
+	m_size_alloc = 2;
+    }
+    // allocate
+    m_heap = new void*[m_size_alloc + 1];
+    // initialize
+    for( int i = 0; i < m_size_alloc; ++ i ) {
+	m_heap[i] = 0;
+    }
+}
+
+sc_ppq_base::~sc_ppq_base()
+{
+    delete[] m_heap;
+}
+
+void*
+sc_ppq_base::extract_top()
+{
+    assert( m_heap_size > 0 );
+    void* topelem = m_heap[1];
+    m_heap[1] = m_heap[m_heap_size];
+    m_heap_size --;
+    heapify( 1 );
+    return topelem;
+}
+
+void
+sc_ppq_base::insert( void* elem )
+{
+    m_heap_size ++;
+    int i = m_heap_size;
+
+    // resize the heap in case there's not enough memory
+    if( m_heap_size > m_size_alloc ) {
+        m_size_alloc += m_size_alloc / 2;
+        void** new_heap = new void*[m_size_alloc + 1];
+        for( int j = 1; j < m_heap_size; ++ j ) {
+            new_heap[j] = m_heap[j];
+        }
+        delete[] m_heap;
+        m_heap = new_heap;
+    }
+
+    while( (i > 1) && (m_compar( m_heap[parent( i )], elem ) < 0) ) {
+        m_heap[i] = m_heap[parent( i )];
+        i = parent( i );
+    }
+    m_heap[i] = elem;
+}
+
+void
+sc_ppq_base::heapify( int i )
+{
+    int l;
+    while( l = left( i ), l <= m_heap_size ) {
+        int largest = (m_compar( m_heap[l], m_heap[i] ) > 0) ? l : i;
+
+        int r = right( i );
+        if( (r <= m_heap_size) &&
+	    (m_compar( m_heap[r], m_heap[largest] ) > 0) ) {
+            largest = r;
+	}
+
+        if( largest != i ) {
+            void* tmp = m_heap[i];
+            m_heap[i] = m_heap[largest];
+            m_heap[largest] = tmp;
+            i = largest;
+        } else {
+            break;
+	}
+    }
+}
+
+} // namespace sc_core
+
+// Revision 1.3  2011/08/24 22:05:56  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.2  2011/02/18 20:38:44  acg
+//  Andy Goodrich: Updated Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:06  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:11  acg
+// Andy Goodrich: Added $Log command so that CVS comments are reproduced in
+// the source.
+
+// taf
diff --git a/ext/systemc/src/sysc/utils/sc_pq.h b/ext/systemc/src/sysc/utils/sc_pq.h
new file mode 100644
index 000000000..51ed54f4a
--- /dev/null
+++ b/ext/systemc/src/sysc/utils/sc_pq.h
@@ -0,0 +1,154 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_pq.h -- A simple priority queue (which can be used to model multiple 
+             clocks). From Cormen-Leiserson-Rivest, Ch.7.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+#ifndef SC_PQ_H
+#define SC_PQ_H
+
+
+#include <cassert>
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_ppq_base
+//
+//  Priority queue base class.
+// ----------------------------------------------------------------------------
+
+class sc_ppq_base
+{
+public:
+
+    typedef int (*compare_fn_t)( const void*, const void* );
+
+    sc_ppq_base( int sz, compare_fn_t cmp );
+
+    ~sc_ppq_base();
+
+    void* top() const
+	{ return m_heap[1]; }
+
+    void* extract_top();
+
+    void insert( void* elem );
+
+    int size() const
+	{ return m_heap_size; }
+
+    bool empty() const
+	{ return (m_heap_size == 0); }
+
+protected:
+
+    int parent( int i ) const
+	{ return i >> 1; }
+
+    int left( int i ) const
+	{ return i << 1; }
+
+    int right( int i ) const
+	{ return (i << 1) + 1; }
+
+    void heapify( int i );
+
+private:
+
+    void**       m_heap;
+    int          m_size_alloc;
+    int          m_heap_size;
+    compare_fn_t m_compar;
+};
+
+
+// ----------------------------------------------------------------------------
+//  CLASS TEMPLATE : sc_ppq<T>
+//
+//  This class is a simple implementation of a priority queue based on
+//  binary heaps. The class is templatized on its data type. A comparison
+//  function needs to be supplied.
+// ----------------------------------------------------------------------------
+
+template <class T>
+class sc_ppq
+    : public sc_ppq_base
+{
+public:
+
+    // constructor - specify the maximum size of the queue and
+    // give a comparison function.
+
+    sc_ppq( int sz, compare_fn_t cmp )
+        : sc_ppq_base( sz, cmp )
+	{}
+
+    ~sc_ppq()
+	{}
+
+    // returns the value of the top element in the priority queue.
+    T top() const
+	{ return (T) sc_ppq_base::top(); }
+
+    // pops the first element of the priority queue.
+
+    T extract_top()
+	{ return (T) sc_ppq_base::extract_top(); }
+
+    // insert a new element to the priority queue.
+
+    void insert( T elem )
+	{ sc_ppq_base::insert( (void*) elem ); }
+
+    // size() and empty() are inherited.
+};
+
+} // namespace sc_core
+
+// $Log: sc_pq.h,v $
+// Revision 1.5  2011/08/29 18:04:32  acg
+//  Philipp A. Hartmann: miscellaneous clean ups.
+//
+// Revision 1.4  2011/08/26 20:46:18  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.3  2011/08/24 22:05:56  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.2  2011/02/18 20:38:44  acg
+//  Andy Goodrich: Updated Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:06  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:11  acg
+// Andy Goodrich: Added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#endif
diff --git a/ext/systemc/src/sysc/utils/sc_pvector.h b/ext/systemc/src/sysc/utils/sc_pvector.h
new file mode 100644
index 000000000..3c0e127c9
--- /dev/null
+++ b/ext/systemc/src/sysc/utils/sc_pvector.h
@@ -0,0 +1,187 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_vector.h -- Simple implementation of a vector class.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+#ifndef SC_VECTOR_H
+#define SC_VECTOR_H
+
+#include <vector>
+
+namespace sc_core {
+
+extern "C" {
+  typedef int (*CFT)( const void*, const void* );
+} 
+
+
+// #define ACCESS(I) m_vector.at(I) // index checking
+#define ACCESS(I) m_vector[I]
+#define ADDR_ACCESS(I) (m_vector.size() != 0 ? &m_vector[I] : 0 )
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_pvector<T>
+//
+//  Simple vector class.
+// ----------------------------------------------------------------------------
+
+template< class T >
+class sc_pvector
+{
+public:
+
+    typedef const T* const_iterator;
+    typedef       T* iterator;
+	// typedef typename ::std::vector<T>::const_iterator const_iterator;
+	// typedef typename ::std::vector<T>::iterator       iterator;
+
+    sc_pvector( int alloc_n = 0 )
+	{
+	}
+
+    sc_pvector( const sc_pvector<T>& rhs )
+	: m_vector( rhs.m_vector )
+	{}
+
+    ~sc_pvector()
+	{}
+
+
+    std::size_t size() const
+	{ return m_vector.size(); }
+
+
+    iterator begin()
+        { return (iterator) ADDR_ACCESS(0); }
+
+    const_iterator begin() const
+        { return (const_iterator) ADDR_ACCESS(0); }
+
+    iterator end()
+        { return static_cast<iterator> (ADDR_ACCESS(m_vector.size())); }
+
+    const_iterator end() const
+    { 
+        return static_cast<const_iterator> (ADDR_ACCESS(m_vector.size()));
+    }
+
+
+    sc_pvector<T>& operator = ( const sc_pvector<T>& rhs )
+	{ m_vector = rhs.m_vector; return *this; }
+
+
+    T& operator [] ( unsigned int i )
+	{ 
+	    if ( i >= m_vector.size() ) m_vector.resize(i+1);
+	    return (T&) m_vector.operator [] ( i );
+	}
+
+    const T& operator [] ( unsigned int i ) const
+	{ 
+	    if ( i >= m_vector.size() ) m_vector.resize(i+1);
+	    return (const T&) m_vector.operator [] ( i );
+	}
+
+    T& fetch( int i )
+	{ return ACCESS(i); }
+
+    const T& fetch( int i ) const
+	{ return (const T&) ACCESS(i); }
+
+
+    T* raw_data()
+	{ return (T*) &ACCESS(0); }
+
+    const T* raw_data() const
+	{ return (const T*) &ACCESS(0); }
+
+
+    operator const ::std::vector<T>& () const
+        { return m_vector; }
+
+    void push_back( T item )
+	{ m_vector.push_back( item ); }
+
+
+    void erase_all()
+	{ m_vector.resize(0); }
+
+    void sort( CFT compar )
+	{qsort( (void*)&m_vector[0], m_vector.size(), sizeof(void*), compar );}
+
+    /* These methods have been added from Ptr_Array */
+    
+    void put( T item, int i )
+	{ ACCESS(i) = item; }
+
+    void decr_count()
+	{ m_vector.resize(m_vector.size()-1); }
+
+    void decr_count( int k )
+	{ m_vector.resize(m_vector.size()-k); }
+
+
+
+  protected:
+    mutable ::std::vector<T> m_vector;    // Actual vector of pointers.
+};
+
+#undef ACCESS
+#undef ADDR_ACCESS
+
+} // namespace sc_core
+
+// $Log: sc_pvector.h,v $
+// Revision 1.4  2011/08/26 20:46:19  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.3  2011/02/18 20:38:44  acg
+//  Andy Goodrich: Updated Copyright notice.
+//
+// Revision 1.2  2011/01/20 16:52:21  acg
+//  Andy Goodrich: changes for IEEE 1666 2011.
+//
+// Revision 1.1  2010/12/07 20:11:45  acg
+//  Andy Goodrich: moved sc_pvector class to new header file to allow the
+//  use of sc_vector.h for Philipp Hartmann's new sc_vector class.
+//
+// Revision 1.4  2010/08/03 17:52:15  acg
+//   Andy Goodrich: fix signature for size() method of sc_pvector.
+//
+// Revision 1.3  2008/10/09 21:20:33  acg
+//  Andy Goodrich: fixed the way the end() methods calculate their results.
+//  I had incorrectly cut and pasted code from the begin() method.
+//
+// Revision 1.2  2007/01/17 22:44:34  acg
+//  Andy Goodrich: fix for Microsoft compiler.
+//
+// Revision 1.3  2006/01/13 18:53:11  acg
+// Andy Goodrich: Added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#endif
diff --git a/ext/systemc/src/sysc/utils/sc_report.cpp b/ext/systemc/src/sysc/utils/sc_report.cpp
new file mode 100644
index 000000000..378d45cde
--- /dev/null
+++ b/ext/systemc/src/sysc/utils/sc_report.cpp
@@ -0,0 +1,330 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_report.cpp -- Run-time logging and reporting facilities
+
+  Interface design by SystemC Verification Working Group.
+  Implementation by Alex Riesen, Synopsys Inc.
+  Original implementation by Martin Janssen, Synopsys Inc.
+  Reference implementation by Cadence Design Systems, Inc., 2002-09-23:
+  Norris Ip, Dean Shea, John Rose, Jasvinder Singh, William Paulsen,
+  John Pierce, Rachida Kebichi, Ted Elkind, David Bailey.
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "sysc/kernel/sc_process.h"
+#include "sysc/kernel/sc_simcontext_int.h"
+#include "sysc/utils/sc_stop_here.h"
+#include "sysc/utils/sc_report.h"
+#include "sysc/utils/sc_utils_ids.h"
+#include <algorithm> // std::swap
+
+namespace sc_core {
+
+
+static void sc_deprecated_report_ids(const char* method)
+{
+    static bool warn_report_ids_deprecated=true;
+    if ( warn_report_ids_deprecated )
+    {
+        std::string message;
+	message = "integer report ids are deprecated, use string values: ";
+	message += method;
+        warn_report_ids_deprecated=false;
+	SC_REPORT_INFO(SC_ID_IEEE_1666_DEPRECATION_, message.c_str());
+    }
+}
+
+static char empty_str[] = "";
+static inline char * empty_dup(const char * p)
+{
+    if ( p && *p )
+    {
+        char* result;
+        result = (char*)malloc(strlen(p)+1);
+        strcpy(result, p);
+        return result;
+    }
+    else
+    {
+        return empty_str;
+    }
+}
+
+sc_report::sc_report() 
+: severity(SC_INFO),
+  md(0),
+  msg(empty_dup(0)),
+  file(empty_dup(0)),
+  line(0),
+  timestamp(new sc_time(sc_time_stamp())),
+  process(0),
+  m_verbosity_level(SC_MEDIUM),
+  m_what(empty_dup(0))
+{
+}
+
+sc_report::sc_report(sc_severity severity_,
+		     const sc_msg_def* md_,
+		     const char* msg_,
+		     const char* file_,
+		     int line_,
+		     int verbosity_level)
+: severity(severity_),
+  md(md_),
+  msg(empty_dup(msg_)),
+  file(empty_dup(file_)),
+  line(line_),
+  timestamp(new sc_time(sc_time_stamp())),
+  process(sc_get_current_process_b()),
+  m_verbosity_level(verbosity_level),
+  m_what( empty_dup( sc_report_compose_message(*this).c_str() ) )
+{
+}
+
+sc_report::sc_report(const sc_report& other)
+: std::exception(other),
+  severity(other.severity),
+  md(other.md),
+  msg(empty_dup(other.msg)),
+  file(empty_dup(other.file)),
+  line(other.line),
+  timestamp(new sc_time(*other.timestamp)),
+  process(other.process),
+  m_verbosity_level(other.m_verbosity_level),
+  m_what(empty_dup(other.m_what))
+{
+}
+
+sc_report & sc_report::operator=(const sc_report& other)
+{
+    sc_report copy(other);
+    swap( copy );
+    return *this;
+}
+
+void
+sc_report::swap( sc_report & that )
+{
+    using std::swap;
+    swap( severity,          that.severity );
+    swap( md,                that.md );
+    swap( msg,               that.msg );
+    swap( file,              that.file );
+    swap( line,              that.line );
+    swap( timestamp,         that.timestamp );
+    swap( process,           that.process );
+    swap( m_verbosity_level, that.m_verbosity_level );
+    swap( m_what,            that.m_what );
+} 
+
+sc_report::~sc_report() throw()
+{
+    if ( file != empty_str )
+	free(file);
+    if ( msg != empty_str )
+	free(msg);
+    delete timestamp;
+    if ( m_what != empty_str )
+    free(m_what);
+}
+
+const char * sc_report::get_msg_type() const
+{
+    return md->msg_type;
+}
+
+//
+// backward compatibility with 2.0+
+//
+
+static bool warnings_are_errors = false;
+static const char unknown_id[] = "unknown id";
+
+void sc_report_handler::report(sc_severity severity_,
+			       int         id_,
+			       const char* msg_,
+			       const char* file_,
+			       int         line_ )
+{
+    sc_msg_def * md = sc_report_handler::mdlookup(id_);
+
+    if ( !md )
+    {
+	md = sc_report_handler::add_msg_type(unknown_id);
+	md->id = id_;
+    }
+
+    if ( severity_ == SC_WARNING && warnings_are_errors )
+	severity_ = SC_ERROR;
+
+    sc_actions actions = execute(md, severity_);
+    sc_report rep(severity_, md, msg_, file_, line_);
+
+    if ( actions & SC_CACHE_REPORT )
+	cache_report(rep);
+
+    if ( severity_ == SC_ERROR )
+	actions |= SC_THROW;
+    else if ( severity_ == SC_FATAL )
+	actions |= SC_ABORT;
+
+    handler(rep, actions);
+}
+
+void sc_report::register_id( int id, const char* msg )
+{
+    sc_deprecated_report_ids("sc_report::register_id()");
+    if( id < 0 ) {
+	SC_REPORT_ERROR( SC_ID_REGISTER_ID_FAILED_,
+			 "invalid report id" );
+    }
+    if( msg == 0 ) {
+	SC_REPORT_ERROR( SC_ID_REGISTER_ID_FAILED_,
+			 "invalid report message" );
+    }
+    sc_msg_def * md = sc_report_handler::mdlookup(id);
+
+    if ( !md )
+	md = sc_report_handler::add_msg_type(msg);
+
+    if ( !md ) {
+	SC_REPORT_ERROR( SC_ID_REGISTER_ID_FAILED_,
+			 "report_map insertion error" );
+    }
+
+    if( md->id != -1 ) {
+	if( strcmp( msg, md->msg_type ) != 0 ) {
+	    SC_REPORT_ERROR( SC_ID_REGISTER_ID_FAILED_,
+			     "report id already exists" );
+	}
+	return;
+    }
+    md->id = id;
+}
+
+const char* sc_report::get_message( int id )
+{
+    sc_deprecated_report_ids("sc_report::get_message()");
+    sc_msg_def* md = sc_report_handler::mdlookup(id);
+
+    return md ? md->msg_type: unknown_id;
+}
+
+bool sc_report::is_suppressed( int id )
+{
+    sc_deprecated_report_ids("sc_report::is_suppressed()");
+    sc_msg_def* md = sc_report_handler::mdlookup(id);
+
+    return md ? md->actions == SC_DO_NOTHING: false; // only do-nothing set
+}
+
+void sc_report::suppress_id(int id_, bool suppress)
+{
+    sc_deprecated_report_ids("sc_report::suppress_id()");
+    sc_msg_def* md = sc_report_handler::mdlookup(id_);
+
+    if ( md )
+	md->actions = suppress ? SC_DO_NOTHING: SC_UNSPECIFIED;
+}
+
+void sc_report::suppress_infos(bool suppress)
+{
+    sc_deprecated_report_ids("sc_report::supress_infos");
+    sc_report_handler::sev_actions[SC_INFO] =
+	suppress ? SC_DO_NOTHING: SC_DEFAULT_INFO_ACTIONS;
+}
+
+void sc_report::suppress_warnings(bool suppress)
+{
+    sc_deprecated_report_ids("sc_report::suppress_warnings");
+    sc_report_handler::sev_actions[SC_WARNING] =
+	suppress ? SC_DO_NOTHING: SC_DEFAULT_WARNING_ACTIONS;
+}
+
+void sc_report::make_warnings_errors(bool flag)
+{
+    sc_deprecated_report_ids("sc_report::make_warnings_errors");
+    warnings_are_errors = flag;
+}
+
+int sc_report::get_id() const
+{
+    return md->id;
+}
+
+} // namespace sc_core
+
+// $Log: sc_report.cpp,v $
+// Revision 1.8  2011/08/29 18:04:32  acg
+//  Philipp A. Hartmann: miscellaneous clean ups.
+//
+// Revision 1.7  2011/08/26 20:43:01  acg
+//  Andy Goodrich:
+//    (1) Replaced strdup with new and strcpy to eliminate issue with the
+//        Greenhills compiler.
+//    (2) Moved modification log to the end of the file to eliminate line
+//        skew when check-ins are done.
+//
+// Revision 1.6  2011/08/24 22:05:56  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.5  2011/05/05 17:46:04  acg
+//  Philip A. Hartmann: changes in "swap" support.
+//
+// Revision 1.4  2011/03/23 16:16:48  acg
+//  Andy Goodrich: finish message verbosity support.
+//
+// Revision 1.3  2011/02/18 20:38:44  acg
+//  Andy Goodrich: Updated Copyright notice.
+//
+// Revision 1.2  2011/02/01 23:02:05  acg
+//  Andy Goodrich: IEEE 1666 2011 changes.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:06  acg
+// SystemC 2.3
+//
+// Revision 1.7  2006/03/21 00:00:37  acg
+//   Andy Goodrich: changed name of sc_get_current_process_base() to be
+//   sc_get_current_process_b() since its returning an sc_process_b instance.
+//
+// Revision 1.6  2006/01/25 00:31:27  acg
+//  Andy Goodrich: Changed over to use a standard message id of
+//  SC_ID_IEEE_1666_DEPRECATION for all deprecation messages.
+//
+// Revision 1.5  2006/01/24 22:02:30  acg
+//  Andy Goodrich: switch deprecated features warnings to use a single message
+//  id, SC_ID_IEEE_1666_DEPRECATION_.
+//
+// Revision 1.4  2006/01/24 20:53:41  acg
+// Andy Goodrich: added warnings indicating that use of integer ids in reports
+// is deprecated. Added tracing/sc_trace_ids.h to message list.
+//
+// Revision 1.3  2006/01/13 18:53:11  acg
+// Andy Goodrich: Added $Log command so that CVS comments are reproduced in
+// the source.
+
+// taf
diff --git a/ext/systemc/src/sysc/utils/sc_report.h b/ext/systemc/src/sysc/utils/sc_report.h
new file mode 100644
index 000000000..f76bef71f
--- /dev/null
+++ b/ext/systemc/src/sysc/utils/sc_report.h
@@ -0,0 +1,299 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_report.h -- Run-time logging and reporting facilities
+
+  Interface design by SystemC Verification Working Group.
+  Implementation by Alex Riesen, Synopsys Inc.
+  Original implementation by Martin Janssen, Synopsys Inc.
+  Reference implementation by Cadence Design Systems, Inc., 2002-09-23:
+  Norris Ip, Dean Shea, John Rose, Jasvinder Singh, William Paulsen,
+  John Pierce, Rachida Kebichi, Ted Elkind, David Bailey.
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+#ifndef SC_REPORT_H
+#define SC_REPORT_H 1
+
+#include <exception>
+#include <string>
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  ENUM : sc_severity
+//
+//  Enumeration of possible exception severity levels
+// ----------------------------------------------------------------------------
+
+enum sc_severity {
+    SC_INFO = 0,        // informative only
+    SC_WARNING, // indicates potentially incorrect condition
+    SC_ERROR,   // indicates a definite problem
+    SC_FATAL,   // indicates a problem from which we cannot recover
+    SC_MAX_SEVERITY
+};
+
+typedef unsigned sc_actions;
+
+// ----------------------------------------------------------------------------
+//  ENUM : sc_verbosity
+//
+//  Enumeration of message verbosity.
+// ----------------------------------------------------------------------------
+
+ enum sc_verbosity { 
+     SC_NONE = 0, 
+     SC_LOW = 100, 
+     SC_MEDIUM = 200, 
+     SC_HIGH = 300,
+     SC_FULL = 400, 
+     SC_DEBUG = 500
+ };
+
+// ----------------------------------------------------------------------------
+//  ENUM : 
+//
+//  Enumeration of actions on an exception (implementation specific)
+// ----------------------------------------------------------------------------
+
+enum {
+    SC_UNSPECIFIED  = 0x0000, // look for lower-priority rule
+    SC_DO_NOTHING   = 0x0001, // take no action (ignore if other bits set)
+    SC_THROW        = 0x0002, // throw an exception
+    SC_LOG          = 0x0004, // add report to report log
+    SC_DISPLAY      = 0x0008, // display report to screen
+    SC_CACHE_REPORT = 0x0010, // save report to cache
+    SC_INTERRUPT    = 0x0020, // call sc_interrupt_here(...)
+    SC_STOP         = 0x0040, // call sc_stop()
+    SC_ABORT        = 0x0080  // call abort()
+};
+
+class sc_object;
+class sc_time;
+struct sc_msg_def;
+class sc_report;
+class sc_report_handler;
+const std::string sc_report_compose_message( const sc_report& );
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_report
+//
+//  Exception reporting
+// ----------------------------------------------------------------------------
+
+class sc_report : public std::exception
+{
+    friend class sc_report_handler;
+    friend sc_report* sc_handle_exception();
+
+    sc_report(); // used internally by sc_handle_exception
+
+public:
+
+    sc_report(const sc_report&);
+
+    sc_report & operator=(const sc_report&);
+
+    virtual ~sc_report() throw();
+
+    const char * get_msg_type() const;
+
+    const char * get_msg() const
+	{ return msg; }
+
+    sc_severity get_severity() const
+	{ return severity; }
+
+    const char * get_file_name() const
+	{ return file; }
+
+    int get_line_number() const
+	{ return line; }
+
+    const sc_time & get_time() const
+	{ return *timestamp; }
+
+    const char* get_process_name() const;
+
+    int get_verbosity() const { return m_verbosity_level; }
+
+    bool valid () const
+        {
+	    return process != 0;
+	}
+
+    virtual const char* what() const throw()
+        { 
+	    return m_what;
+	}
+
+    void swap( sc_report& );
+
+protected:
+
+    sc_report(sc_severity,
+	      const sc_msg_def*,
+	      const char* msg,
+	      const char* file,
+	      int line,
+	      int verbosity_level=SC_MEDIUM);
+
+    sc_severity        severity;
+    const sc_msg_def*  md;
+    char*              msg;
+    char*              file;
+    int                line;
+    sc_time*           timestamp;
+    sc_object*         process;
+    int                m_verbosity_level;
+    char*              m_what;
+
+public:  // backward compatibility with 2.0+
+
+    static const char* get_message(int id);
+    static bool is_suppressed(int id);
+    static void make_warnings_errors(bool);
+    static void register_id(int id, const char* msg);
+    static void suppress_id(int id, bool); // only for info or warning
+    static void suppress_infos(bool);
+    static void suppress_warnings(bool);
+
+    int get_id() const;
+};
+typedef std::exception sc_exception;
+
+#define SC_DEFAULT_INFO_ACTIONS \
+   (::sc_core::SC_LOG | ::sc_core::SC_DISPLAY)
+#define SC_DEFAULT_WARNING_ACTIONS \
+   (::sc_core::SC_LOG | ::sc_core::SC_DISPLAY)
+#define SC_DEFAULT_ERROR_ACTIONS \
+   (::sc_core::SC_LOG | ::sc_core::SC_CACHE_REPORT | ::sc_core::SC_THROW)
+#define SC_DEFAULT_FATAL_ACTIONS \
+   (::sc_core::SC_LOG | ::sc_core::SC_DISPLAY | \
+    ::sc_core::SC_CACHE_REPORT | ::sc_core::SC_ABORT)
+
+
+// ----------------------------------------------------------------------------
+//  Report macros.
+//
+//  Use these macros to report an info, warning, error, or fatal.
+// ----------------------------------------------------------------------------
+
+#define SC_REPORT_INFO( msg_type, msg )    \
+    ::sc_core::sc_report_handler::report(  \
+            ::sc_core::SC_INFO, msg_type, msg, __FILE__, __LINE__ )
+
+#define SC_REPORT_INFO_VERB( msg_type, msg, verbosity )   \
+    ::sc_core::sc_report_handler::report(                 \
+            ::sc_core::SC_INFO, msg_type, msg, verbosity, \
+                               __FILE__ , __LINE__ )
+
+#define SC_REPORT_WARNING( msg_type, msg ) \
+    ::sc_core::sc_report_handler::report(  \
+            ::sc_core::SC_WARNING, msg_type, msg, __FILE__, __LINE__ )
+
+#define SC_REPORT_ERROR( msg_type, msg )  \
+    ::sc_core::sc_report_handler::report( \
+            ::sc_core::SC_ERROR, msg_type, msg, __FILE__, __LINE__ )
+
+#define SC_REPORT_FATAL( msg_type, msg )  \
+    ::sc_core::sc_report_handler::report( \
+            ::sc_core::SC_FATAL, msg_type, msg, __FILE__, __LINE__ )
+
+// ----------------------------------------------------------------------------
+//  MACRO : sc_assert(expr)
+//
+//  Like assert(), but additionally prints the current process name
+//  and simulation time, if the simulation is running.
+// ----------------------------------------------------------------------------
+
+#ifdef NDEBUG
+
+#define sc_assert(expr) \
+ ((void) 0)
+
+#else
+
+#define sc_assert(expr) \
+ ((void)((expr) ? 0 :   \
+     (SC_REPORT_FATAL( ::sc_core::SC_ID_ASSERTION_FAILED_, #expr ), 0)))
+
+#endif // NDEBUG
+
+extern const char SC_ID_UNKNOWN_ERROR_[];
+extern const char SC_ID_WITHOUT_MESSAGE_[];
+extern const char SC_ID_NOT_IMPLEMENTED_[];
+extern const char SC_ID_INTERNAL_ERROR_[];
+extern const char SC_ID_ASSERTION_FAILED_[];
+extern const char SC_ID_OUT_OF_BOUNDS_[];
+
+// backward compatibility with 2.0+
+extern const char SC_ID_REGISTER_ID_FAILED_[];
+
+} // namespace sc_core
+
+#include "sysc/utils/sc_report_handler.h"
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Alex Riesen, Synopsys Inc., Jan 28, 2003
+  Description of Modification: Implementation for SytemC 2.1
+
+ *****************************************************************************/
+
+// $Log: sc_report.h,v $
+// Revision 1.8  2011/08/26 20:46:19  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.7  2011/05/05 17:46:04  acg
+//  Philip A. Hartmann: changes in "swap" support.
+//
+// Revision 1.6  2011/04/19 02:39:44  acg
+//  Andy Goodrich: set proper name for get_verbosity().
+//
+// Revision 1.5  2011/03/23 16:16:48  acg
+//  Andy Goodrich: finish message verbosity support.
+//
+// Revision 1.4  2011/02/18 20:38:44  acg
+//  Andy Goodrich: Updated Copyright notice.
+//
+// Revision 1.3  2011/02/01 23:02:05  acg
+//  Andy Goodrich: IEEE 1666 2011 changes.
+//
+// Revision 1.2  2008/05/20 20:42:50  acg
+//  Andy Goodrich: added sc_core namespace prefix for ID value in sc_assert()
+//  macro.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:06  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:11  acg
+// Andy Goodrich: Added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#endif // SC_REPORT_H
diff --git a/ext/systemc/src/sysc/utils/sc_report_handler.cpp b/ext/systemc/src/sysc/utils/sc_report_handler.cpp
new file mode 100644
index 000000000..0de71a18b
--- /dev/null
+++ b/ext/systemc/src/sysc/utils/sc_report_handler.cpp
@@ -0,0 +1,799 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_report_handler.cpp - 
+
+  Original Author: Alex Riesen, Synopsys, Inc.
+  see also sc_report.cpp
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+#include <cstdio>
+#include <stdlib.h>
+#include <string.h>
+
+#include "sysc/utils/sc_iostream.h"
+#include "sysc/kernel/sc_process.h"
+#include "sysc/kernel/sc_simcontext_int.h"
+#include "sysc/utils/sc_stop_here.h"
+#include "sysc/utils/sc_report_handler.h"
+#include "sysc/utils/sc_report.h"
+
+namespace std {}
+
+namespace sc_core {
+
+int sc_report_handler::verbosity_level = SC_MEDIUM;
+
+// not documented, but available
+const std::string sc_report_compose_message(const sc_report& rep)
+{
+    static const char * severity_names[] = {
+	"Info", "Warning", "Error", "Fatal"
+    };
+    std::string str;
+
+    str += severity_names[rep.get_severity()];
+    str += ": ";
+
+    if ( rep.get_id() >= 0 ) // backward compatibility with 2.0+
+    {
+	char idstr[64];
+	std::sprintf(idstr, "(%c%d) ",
+		"IWEF"[rep.get_severity()], rep.get_id());
+	str += idstr;
+    }
+    str += rep.get_msg_type();
+
+    if( *rep.get_msg() )
+    {
+	str += ": ";
+	str += rep.get_msg();
+    }
+    if( rep.get_severity() > SC_INFO )
+    {
+        char line_number_str[16];
+	str += "\nIn file: ";
+	str += rep.get_file_name();
+	str += ":";
+	std::sprintf(line_number_str, "%d", rep.get_line_number());
+	str += line_number_str;
+	sc_simcontext* simc = sc_get_curr_simcontext();
+
+	if( simc && sc_is_running() )
+	{
+	    const char* proc_name = rep.get_process_name();
+
+	    if( proc_name )
+	    {
+		str += "\nIn process: ";
+		str += proc_name;
+		str += " @ ";
+		str += rep.get_time().to_string();
+	    }
+	}
+    }
+
+    return str;
+}
+bool sc_report_close_default_log();
+
+static ::std::ofstream* log_stream = 0;
+static
+struct auto_close_log
+{
+    ~auto_close_log()
+    {
+	sc_report_close_default_log();
+    }
+} auto_close;
+
+const char* sc_report::get_process_name() const
+{
+	return process ? process->name() : 0;
+}
+
+
+//
+// The official handler of the exception reporting
+//
+
+void sc_report_handler::default_handler(const sc_report& rep,
+					const sc_actions& actions)
+{
+    if ( actions & SC_DISPLAY )
+	::std::cout << ::std::endl << sc_report_compose_message(rep) << 
+		::std::endl;
+
+    if ( (actions & SC_LOG) && get_log_file_name() )
+    {
+	if ( !log_stream )
+	    log_stream = new ::std::ofstream(get_log_file_name()); // ios::trunc
+
+	*log_stream << rep.get_time() << ": "
+	    << sc_report_compose_message(rep) << ::std::endl;
+    }
+    if ( actions & SC_STOP )
+    {
+	sc_stop_here(rep.get_msg_type(), rep.get_severity());
+	sc_stop();
+    }
+    if ( actions & SC_INTERRUPT )
+	sc_interrupt_here(rep.get_msg_type(), rep.get_severity());
+
+    if ( actions & SC_ABORT )
+	abort();
+
+    if ( actions & SC_THROW ) {
+        sc_process_b* proc_p = sc_get_current_process_b();
+        if( proc_p && proc_p->is_unwinding() )
+            proc_p->clear_unwinding();
+        throw rep; 
+    }
+}
+
+// not documented, but available
+bool sc_report_close_default_log()
+{
+    delete log_stream;
+    sc_report_handler::set_log_file_name(NULL);
+
+    if ( !log_stream )
+	return false;
+
+    log_stream = 0;
+    return true;
+}
+
+int sc_report_handler::get_count(sc_severity severity_) 
+{ 
+   return sev_call_count[severity_]; 
+} 
+
+int sc_report_handler::get_count(const char* msg_type_) 
+{ 
+    sc_msg_def * md = mdlookup(msg_type_); 
+
+    if ( !md ) 
+        md = add_msg_type(msg_type_); 
+
+    return md->call_count; 
+} 
+
+int sc_report_handler::get_count(const char* msg_type_, sc_severity severity_) 
+{ 
+    sc_msg_def * md = mdlookup(msg_type_); 
+
+    if ( !md ) 
+        md = add_msg_type(msg_type_); 
+
+    return md->sev_call_count[severity_]; 
+} 
+
+
+//
+// CLASS: sc_report_handler
+// implementation
+//
+
+sc_msg_def * sc_report_handler::mdlookup(const char * msg_type_)
+{
+    if( !msg_type_ ) // if msg_type is NULL, report unknown error
+        msg_type_ = SC_ID_UNKNOWN_ERROR_;
+
+    for ( msg_def_items * item = messages; item; item = item->next )
+    {
+	for ( int i = 0; i < item->count; ++i )
+	    if ( !strcmp(msg_type_, item->md[i].msg_type) )
+		return item->md + i;
+    }
+    return 0;
+}
+
+// The calculation of actions to be executed
+sc_actions sc_report_handler::execute(sc_msg_def* md, sc_severity severity_)
+{
+    sc_actions actions = md->sev_actions[severity_]; // high prio
+
+    if ( SC_UNSPECIFIED == actions ) // middle prio
+	actions = md->actions;
+
+    if ( SC_UNSPECIFIED == actions ) // the lowest prio
+	actions = sev_actions[severity_];
+
+    actions &= ~suppress_mask; // higher than the high prio
+    actions |= force_mask; // higher than above, and the limit is the highest
+
+    unsigned * limit = 0;
+    unsigned * call_count = 0;
+
+    // just increment counters and check for overflow
+    if ( md->sev_call_count[severity_] < UINT_MAX )
+	md->sev_call_count[severity_]++;
+    if ( md->call_count < UINT_MAX )
+	md->call_count++;
+    if ( sev_call_count[severity_] < UINT_MAX )
+	sev_call_count[severity_]++;
+
+    if ( md->limit_mask & (1 << (severity_ + 1)) )
+    {
+	limit = md->sev_limit + severity_;
+	call_count = md->sev_call_count + severity_;
+    }
+    if ( !limit && (md->limit_mask & 1) )
+    {
+	limit = &md->limit;
+	call_count = &md->call_count;
+    }
+    if ( !limit )
+    {
+	limit = sev_limit + severity_;
+	call_count = sev_call_count + severity_;
+    }
+    if ( *limit == 0 )
+    {
+	// stop limit disabled
+    }
+    else if ( *limit != UINT_MAX )
+    {
+	if ( *call_count >= *limit )
+	    actions |= SC_STOP; // force sc_stop()
+    }
+    return actions;
+}
+
+void sc_report_handler::report( sc_severity severity_, 
+                                const char* msg_type_, 
+				const char* msg_, 
+				int verbosity_, 
+				const char* file_, 
+				int line_ )
+{
+    sc_msg_def * md = mdlookup(msg_type_);
+
+    // If the severity of the report is SC_INFO and the specified verbosity 
+    // level is greater than the maximum verbosity level of the simulator then 
+    // return without any action.
+
+    if ( (severity_ == SC_INFO) && (verbosity_ > verbosity_level) ) return;
+
+    // Process the report:
+
+    if ( !md )
+	md = add_msg_type(msg_type_);
+
+    sc_actions actions = execute(md, severity_);
+    sc_report rep(severity_, md, msg_, file_, line_, verbosity_);
+
+    if ( actions & SC_CACHE_REPORT )
+	cache_report(rep);
+
+    handler(rep, actions);
+}
+
+void sc_report_handler::report(sc_severity severity_,
+			       const char * msg_type_,
+			       const char * msg_,
+			       const char * file_,
+			       int line_)
+{
+    sc_msg_def * md = mdlookup(msg_type_);
+
+    // If the severity of the report is SC_INFO and the maximum verbosity
+    // level is less than SC_MEDIUM return without any action.
+
+    if ( (severity_ == SC_INFO) && (SC_MEDIUM > verbosity_level) ) return;
+
+    // Process the report:
+
+
+    if ( !md )
+	md = add_msg_type(msg_type_);
+
+    sc_actions actions = execute(md, severity_);
+    sc_report rep(severity_, md, msg_, file_, line_);
+
+    if ( actions & SC_CACHE_REPORT )
+	cache_report(rep);
+
+    handler(rep, actions);
+}
+
+// The following method is never called by the simulator.
+
+void sc_report_handler::initialize()
+{
+#if 0 // actually, i do not know whether we have to reset these.
+    suppress();
+    force();
+    set_actions(SC_INFO,    SC_DEFAULT_INFO_ACTIONS);
+    set_actions(SC_WARNING, SC_DEFAULT_WARNING_ACTIONS);
+    set_actions(SC_ERROR,   SC_DEFAULT_ERROR_ACTIONS);
+    set_actions(SC_FATAL,   SC_DEFAULT_FATAL_ACTIONS);
+#endif
+
+    sev_call_count[SC_INFO]    = 0;
+    sev_call_count[SC_WARNING] = 0;
+    sev_call_count[SC_ERROR]   = 0;
+    sev_call_count[SC_FATAL]   = 0;
+
+    msg_def_items * items = messages;
+
+    while ( items != &msg_terminator )
+    {
+	for ( int i = 0; i < items->count; ++i )
+	{
+	    items->md[i].call_count = 0;
+	    items->md[i].sev_call_count[SC_INFO]    = 0;
+	    items->md[i].sev_call_count[SC_WARNING] = 0;
+	    items->md[i].sev_call_count[SC_ERROR]   = 0;
+	    items->md[i].sev_call_count[SC_FATAL]   = 0;
+	}
+	items = items->next;
+    }
+
+    // PROCESS ANY ENVIRONMENTAL OVERRIDES:
+
+    const char* deprecation_warn = std::getenv("SC_DEPRECATION_WARNINGS");
+    if ( (deprecation_warn!=0) && !strcmp(deprecation_warn,"DISABLE") )
+    {
+        set_actions("/IEEE_Std_1666/deprecated", SC_DO_NOTHING);
+    }
+}
+
+// free the sc_msg_def's allocated by add_msg_type
+// (or implicit msg_type registration: set_actions, abort_after)
+// clear last_global_report.
+void sc_report_handler::release()
+{
+    delete last_global_report;
+    last_global_report = 0;
+    sc_report_close_default_log();
+
+    msg_def_items * items = messages, * newitems = &msg_terminator;
+    messages = &msg_terminator;
+
+    while ( items != &msg_terminator )
+    {
+	for ( int i = 0; i < items->count; ++i )
+	    if ( items->md[i].msg_type == items->md[i].msg_type_data )
+		free(items->md[i].msg_type_data);
+
+	msg_def_items * prev = items;
+	items = items->next;
+
+	if ( prev->allocated )
+	{
+	    delete [] prev->md;
+	    delete prev;
+	}
+	else
+	{
+	    prev->next = newitems;
+	    newitems = prev;
+	}
+    }
+    messages = newitems;
+}
+
+sc_msg_def * sc_report_handler::add_msg_type(const char * msg_type_)
+{
+    sc_msg_def * md = mdlookup(msg_type_);
+    int          msg_type_len;
+
+    if ( md )
+	return md;
+
+    msg_def_items * items = new msg_def_items;
+
+    if ( !items )
+	return 0;
+
+    items->count = 1;
+    items->md = new sc_msg_def[items->count];
+
+    if ( !items->md )
+    {
+	delete items;
+	return 0;
+    }
+    memset(items->md, 0, sizeof(sc_msg_def) * items->count);
+    msg_type_len = strlen(msg_type_);
+    if ( msg_type_len > 0 )
+    {
+	items->md->msg_type_data = (char*) malloc(msg_type_len+1);
+	strcpy( items->md->msg_type_data, msg_type_ );
+	items->md->id = -1; // backward compatibility with 2.0+
+    }
+    else
+    {
+	delete items->md;
+	delete items;
+	return 0;
+    }
+    items->md->msg_type = items->md->msg_type_data;
+    add_static_msg_types(items);
+    items->allocated = true;
+
+    return items->md;
+}
+
+void sc_report_handler::add_static_msg_types(msg_def_items * items)
+{
+    items->allocated = false;
+    items->next = messages;
+    messages = items;
+}
+
+sc_actions sc_report_handler::set_actions(sc_severity severity_,
+					  sc_actions actions_)
+{
+    sc_actions old = sev_actions[severity_];
+    sev_actions[severity_] = actions_;
+    return old;
+}
+
+sc_actions sc_report_handler::set_actions(const char * msg_type_,
+					  sc_actions actions_)
+{
+    sc_msg_def * md = mdlookup(msg_type_);
+
+    if ( !md )
+	md = add_msg_type(msg_type_);
+
+    sc_actions old = md->actions;
+    md->actions = actions_;
+
+    return old;
+}
+
+sc_actions sc_report_handler::set_actions(const char * msg_type_,
+					  sc_severity severity_,
+					  sc_actions actions_)
+{
+    sc_msg_def * md = mdlookup(msg_type_);
+
+    if ( !md )
+	md = add_msg_type(msg_type_);
+
+    sc_actions old = md->sev_actions[severity_];
+    md->sev_actions[severity_] = actions_;
+
+    return old;
+}
+
+int sc_report_handler::stop_after(sc_severity severity_, int limit)
+{
+    int old = sev_limit[severity_];
+
+    sev_limit[severity_] = limit < 0 ? UINT_MAX: (unsigned) limit;
+
+    return old;
+}
+
+int sc_report_handler::stop_after(const char * msg_type_, int limit)
+{
+    sc_msg_def * md = mdlookup(msg_type_);
+
+    if ( !md )
+	md = add_msg_type(msg_type_);
+
+    int old = md->limit_mask & 1 ? md->limit: UINT_MAX;
+
+    if ( limit < 0 )
+	md->limit_mask &= ~1;
+    else
+    {
+	md->limit_mask |= 1;
+	md->limit = limit;
+    }
+    return old;
+}
+
+int sc_report_handler::stop_after(const char * msg_type_,
+				  sc_severity severity_,
+				  int limit)
+{
+    sc_msg_def * md = mdlookup(msg_type_);
+
+    if ( !md )
+	md = add_msg_type(msg_type_);
+
+    int mask = 1 << (severity_ + 1);
+    int old = md->limit_mask & mask ?  md->sev_limit[severity_]: UINT_MAX;
+
+    if ( limit < 0 )
+	md->limit_mask &= ~mask;
+    else
+    {
+	md->limit_mask |= mask;
+	md->sev_limit[severity_] = limit;
+    }
+    return old;
+}
+
+sc_actions sc_report_handler::suppress(sc_actions mask)
+{
+    sc_actions old = suppress_mask;
+    suppress_mask = mask;
+    return old;
+}
+
+sc_actions sc_report_handler::suppress()
+{
+    return suppress(0);
+}
+
+sc_actions sc_report_handler::force(sc_actions mask)
+{
+    sc_actions old = force_mask;
+    force_mask = mask;
+    return old;
+}
+
+sc_actions sc_report_handler::force()
+{
+    return force(0);
+}
+
+sc_report_handler_proc
+sc_report_handler::set_handler(sc_report_handler_proc handler_)
+{
+    sc_report_handler_proc old = handler;
+    handler = handler_ ? handler_: &sc_report_handler::default_handler;
+    return old;
+}
+
+sc_report_handler_proc
+sc_report_handler::get_handler()
+{
+    return handler;
+}
+
+sc_report* sc_report_handler::get_cached_report()
+{
+    sc_process_b * proc = sc_get_current_process_b();
+
+    if ( proc )
+	return proc->get_last_report();
+
+    return last_global_report;
+}
+
+void sc_report_handler::clear_cached_report()
+{
+    sc_process_b * proc = sc_get_current_process_b();
+
+    if ( proc )
+	proc->set_last_report(0);
+    else
+    {
+	delete last_global_report;
+	last_global_report = 0;
+    }
+}
+
+sc_actions sc_report_handler::get_new_action_id()
+{
+    for ( sc_actions p = 1; p; p <<= 1 )
+    {
+	if ( !(p & available_actions) ) // free
+	{
+	    available_actions |= p;
+	    return p;
+	}
+    }
+    return SC_UNSPECIFIED;
+}
+
+bool sc_report_handler::set_log_file_name(const char* name_)
+{
+    if ( !name_ )
+    {
+	free(log_file_name);
+	log_file_name = 0;
+	return false;
+    }
+    if ( log_file_name )
+	return false;
+
+    log_file_name = (char*)malloc(strlen(name_)+1);
+    strcpy(log_file_name, name_);
+    return true;
+}
+
+const char * sc_report_handler::get_log_file_name()
+{
+    return log_file_name;
+}
+
+void sc_report_handler::cache_report(const sc_report& rep)
+{
+    sc_process_b * proc = sc_get_current_process_b();
+    if ( proc )
+	proc->set_last_report(new sc_report(rep));
+    else
+    {
+	delete last_global_report;
+	last_global_report = new sc_report(rep);
+    }
+}
+
+//
+// backward compatibility with 2.0+
+//
+
+sc_msg_def * sc_report_handler::mdlookup(int id)
+{
+    for ( msg_def_items * item = messages; item; item = item->next )
+    {
+	for ( int i = 0; i < item->count; ++i )
+	    if ( id == item->md[i].id )
+		return item->md + i;
+    }
+    return 0;
+}
+
+int sc_report_handler::get_verbosity_level() { return verbosity_level; }
+
+int sc_report_handler::set_verbosity_level( int level )
+{
+    int result = verbosity_level;
+    verbosity_level = level;
+    return result;
+}
+
+//
+// CLASS: sc_report_handler
+// static variables
+//
+
+sc_actions sc_report_handler::suppress_mask = 0;
+sc_actions sc_report_handler::force_mask = 0;
+
+sc_actions sc_report_handler::sev_actions[SC_MAX_SEVERITY] =
+{
+    /* info  */ SC_DEFAULT_INFO_ACTIONS,
+    /* warn  */ SC_DEFAULT_WARNING_ACTIONS,
+    /* error */ SC_DEFAULT_ERROR_ACTIONS,
+    /* fatal */ SC_DEFAULT_FATAL_ACTIONS
+};
+
+// Note that SC_FATAL has a limit of 1 by default
+
+sc_actions sc_report_handler::sev_limit[SC_MAX_SEVERITY] =
+{
+    UINT_MAX, UINT_MAX, UINT_MAX, UINT_MAX
+};
+sc_actions sc_report_handler::sev_call_count[SC_MAX_SEVERITY] = { 0, 0, 0, 0 };
+
+sc_report* sc_report_handler::last_global_report = NULL;
+sc_actions sc_report_handler::available_actions =
+    SC_DO_NOTHING |
+    SC_THROW |
+    SC_LOG |
+    SC_DISPLAY |
+    SC_CACHE_REPORT |
+    SC_INTERRUPT |
+    SC_STOP |
+    SC_ABORT;
+
+sc_report_handler_proc sc_report_handler::handler =
+    &sc_report_handler::default_handler;
+
+char * sc_report_handler::log_file_name = 0;
+
+sc_report_handler::msg_def_items * sc_report_handler::messages =
+    &sc_report_handler::msg_terminator;
+
+
+//
+// predefined messages
+//
+
+const char SC_ID_REGISTER_ID_FAILED_[] = "register_id failed";
+const char SC_ID_UNKNOWN_ERROR_[]      = "unknown error";
+const char SC_ID_WITHOUT_MESSAGE_[]    = "";
+const char SC_ID_NOT_IMPLEMENTED_[]    = "not implemented";
+const char SC_ID_INTERNAL_ERROR_[]     = "internal error";
+const char SC_ID_ASSERTION_FAILED_[]   = "assertion failed";
+const char SC_ID_OUT_OF_BOUNDS_[]      = "out of bounds";
+
+#define DEFINE_MSG(id,n)                                                     \
+    {                                                                        \
+	(id),                                                                \
+	0u, {0u}, /* actions */                                              \
+	0u, {0u}, 0u, /* limits */                                           \
+	0u, {0u}, NULL, /* call counters */                                  \
+	n                                                                    \
+    }
+
+static sc_msg_def default_msgs[] = {
+    DEFINE_MSG(SC_ID_REGISTER_ID_FAILED_, 800),
+    DEFINE_MSG(SC_ID_UNKNOWN_ERROR_, 0),
+    DEFINE_MSG(SC_ID_WITHOUT_MESSAGE_, 1),
+    DEFINE_MSG(SC_ID_NOT_IMPLEMENTED_, 2),
+    DEFINE_MSG(SC_ID_INTERNAL_ERROR_, 3),
+    DEFINE_MSG(SC_ID_ASSERTION_FAILED_, 4),
+    DEFINE_MSG(SC_ID_OUT_OF_BOUNDS_, 5)
+};
+
+sc_report_handler::msg_def_items sc_report_handler::msg_terminator =
+{
+    default_msgs,
+    sizeof(default_msgs)/sizeof(*default_msgs),
+    false,
+    NULL
+};
+
+} // namespace sc_core
+
+// $Log: sc_report_handler.cpp,v $
+// Revision 1.9  2011/08/29 18:04:32  acg
+//  Philipp A. Hartmann: miscellaneous clean ups.
+//
+// Revision 1.8  2011/08/26 20:46:19  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.7  2011/08/07 19:08:08  acg
+//  Andy Goodrich: moved logs to end of file so line number synching works
+//  better between versions.
+//
+// Revision 1.6  2011/08/07 18:56:03  acg
+//  Philipp A. Hartmann: added cast to ? : to eliminate clang warning message.
+//
+// Revision 1.5  2011/03/23 16:16:49  acg
+//  Andy Goodrich: finish message verbosity support.
+//
+// Revision 1.4  2011/02/18 20:38:44  acg
+//  Andy Goodrich: Updated Copyright notice.
+//
+// Revision 1.3  2011/02/11 13:25:55  acg
+//  Andy Goodrich: Philipp's changes for sc_unwind_exception.
+//
+// Revision 1.2  2011/02/01 23:02:05  acg
+//  Andy Goodrich: IEEE 1666 2011 changes.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:06  acg
+// SystemC 2.3
+//
+// Revision 1.7  2006/05/26 20:35:52  acg
+//  Andy Goodrich: removed debug message that should not have been left in.
+//
+// Revision 1.6  2006/03/21 00:00:37  acg
+//   Andy Goodrich: changed name of sc_get_current_process_base() to be
+//   sc_get_current_process_b() since its returning an sc_process_b instance.
+//
+// Revision 1.5  2006/01/31 21:42:07  acg
+//  Andy Goodrich: Added checks for SC_DEPRECATED_WARNINGS being defined as
+//  DISABLED. If so, we turn off the /IEEE_Std_1666/deprecated message group.
+//
+// Revision 1.4  2006/01/26 21:08:17  acg
+//  Andy Goodrich: conversion to use sc_is_running instead of deprecated
+//  sc_simcontext::is_running()
+//
+// Revision 1.3  2006/01/13 18:53:11  acg
+// Andy Goodrich: Added $Log command so that CVS comments are reproduced in
+// the source.
+
+// Taf!
diff --git a/ext/systemc/src/sysc/utils/sc_report_handler.h b/ext/systemc/src/sysc/utils/sc_report_handler.h
new file mode 100644
index 000000000..799985a1f
--- /dev/null
+++ b/ext/systemc/src/sysc/utils/sc_report_handler.h
@@ -0,0 +1,197 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_report_handler.h - 
+
+  Original Author: Alex Riesen, Synopsys, Inc.
+  see also sc_report.h
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+#ifndef SC_REPORT_HANDLER_H
+#define SC_REPORT_HANDLER_H
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  STRUCT : sc_msg_def
+//
+//  Exception message definition structure
+// ----------------------------------------------------------------------------
+
+struct sc_msg_def
+{
+    const char*  msg_type;
+    sc_actions   actions;
+    sc_actions   sev_actions[SC_MAX_SEVERITY];
+    unsigned     limit;
+    unsigned     sev_limit[SC_MAX_SEVERITY];
+    unsigned     limit_mask; // 0 - limit, 1..4 - sev_limit
+    unsigned     call_count;
+    unsigned     sev_call_count[SC_MAX_SEVERITY];
+    char*        msg_type_data;
+
+    int          id; // backward compatibility with 2.0+
+};
+
+typedef void (* sc_report_handler_proc)(const sc_report&, const sc_actions &);
+class sc_report;
+extern bool sc_report_close_default_log();
+class sc_report_handler
+{
+public:
+    static void report(sc_severity,
+		       const char* msg_type,
+		       const char* msg,
+		       const char* file,
+		       int line);
+
+    static void report( sc_severity, 
+                        const char* msg_type, 
+			const char* msg, 
+                        int verbosity, 
+			const char* file, 
+			int line );
+
+    static sc_actions set_actions(sc_severity,
+				  sc_actions = SC_UNSPECIFIED);
+
+    static sc_actions set_actions(const char * msg_type,
+				  sc_actions = SC_UNSPECIFIED);
+
+    static sc_actions set_actions(const char * msg_type,
+				  sc_severity,
+				  sc_actions = SC_UNSPECIFIED);
+
+    static int stop_after(sc_severity, int limit = -1);
+    static int stop_after(const char* msg_type, int limit = -1);
+    static int stop_after(const char* msg_type, sc_severity, int limit = -1);
+
+    static sc_actions suppress(sc_actions);
+    static sc_actions suppress();
+    static sc_actions force(sc_actions);
+    static sc_actions force();
+
+    static int get_count(sc_severity severity_);
+    static int get_count(const char* msg_type_);
+    static int get_count(const char* msg_type_, sc_severity severity_);
+
+    static int get_verbosity_level();
+    static int set_verbosity_level( int level );
+
+
+    static void initialize(); // just reset counters
+    static void release(); // initialize() needed for reports after it
+
+    static sc_report_handler_proc set_handler(sc_report_handler_proc);
+    static sc_report_handler_proc get_handler();
+    // use set_handler(NULL); to restore default handler
+    static void default_handler(const sc_report&, const sc_actions&);
+
+    static sc_actions get_new_action_id();
+
+    static sc_report* get_cached_report();
+    static void clear_cached_report();
+
+    // if filename is NULL, the previous log file name will be removed.
+    // The provider of a report_handler supposed to handle this.
+    // Return false if filename is not NULL and filename is already set.
+    static bool set_log_file_name(const char* filename);
+    static const char* get_log_file_name();
+
+public: // private, actually
+
+    struct msg_def_items
+    {
+	sc_msg_def*     md;        // have to point to sc_msg_def-s
+	int             count;     // set to number of items in md[]
+	bool            allocated; // used internally, previous value ignored
+	msg_def_items*  next;      // used internally, previous value ignored
+    };
+
+    static void add_static_msg_types(msg_def_items *);
+    static sc_msg_def* add_msg_type(const char * msg_type);
+
+protected:
+
+    static void cache_report(const sc_report&);
+    static sc_actions execute(sc_msg_def*, sc_severity);
+
+    static sc_actions   suppress_mask;
+    static sc_actions   force_mask;
+    static sc_actions   sev_actions[SC_MAX_SEVERITY];
+    static unsigned     sev_limit[SC_MAX_SEVERITY];
+    static unsigned     sev_call_count[SC_MAX_SEVERITY];
+    static sc_report*   last_global_report;
+    static sc_actions   available_actions;
+    static char*        log_file_name;
+    static int          verbosity_level;
+
+    static msg_def_items*  messages;
+    static msg_def_items   msg_terminator;
+
+    static sc_report_handler_proc  handler;
+
+    static sc_msg_def* mdlookup(const char* msg_type);
+
+private: // backward compatibility with 2.0+
+
+    friend class sc_report;
+    static sc_msg_def* mdlookup(int id);
+
+public:
+
+    static void report(sc_severity,
+		       int         id,
+		       const char* add_msg,
+		       const char* file,
+		       int         line);
+
+};
+
+} // namespace sc_core
+
+// $Log: sc_report_handler.h,v $
+// Revision 1.5  2011/08/26 20:46:19  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.4  2011/03/23 16:16:49  acg
+//  Andy Goodrich: finish message verbosity support.
+//
+// Revision 1.3  2011/02/18 20:38:44  acg
+//  Andy Goodrich: Updated Copyright notice.
+//
+// Revision 1.2  2011/02/01 23:02:05  acg
+//  Andy Goodrich: IEEE 1666 2011 changes.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:06  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:11  acg
+// Andy Goodrich: Added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/utils/sc_stop_here.cpp b/ext/systemc/src/sysc/utils/sc_stop_here.cpp
new file mode 100644
index 000000000..614b03dd0
--- /dev/null
+++ b/ext/systemc/src/sysc/utils/sc_stop_here.cpp
@@ -0,0 +1,124 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_stop_here.cpp -- Function provided for debugging purposes.
+                      This file is always compiled in debug mode, such that
+                      setting a breakpoint at this function can help locate
+                      the cause of a SystemC error or warning.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-11-14
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+#include "sysc/utils/sc_stop_here.h"
+
+
+namespace sc_core {
+
+static const char* info_id    = 0;
+static const char* warning_id = 0;
+static const char* error_id   = 0;
+static const char* fatal_id   = 0;
+
+// ----------------------------------------------------------------------------
+//  FUNCTION : sc_interrupt_here
+//
+//  Debugging aid for warning, error, and fatal reports.
+//  This function *cannot* be inlined.
+// ----------------------------------------------------------------------------
+
+void
+sc_interrupt_here( const char* id, sc_severity severity )
+{
+    // you can set a breakpoint at some of the lines below, either to
+    // interrupt with any severity, or to interrupt with a specific severity
+
+    switch( severity ) {
+      case SC_INFO: 
+	info_id = id;
+	break;
+      case SC_WARNING: 
+	warning_id = id;
+	break;
+      case SC_ERROR: 
+	error_id = id;
+	break;
+      default:
+      case SC_FATAL: 
+	fatal_id = id;
+	break;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  FUNCTION : sc_stop_here
+//
+//  Debugging aid for warning, error, and fatal reports.
+//  This function *cannot* be inlined.
+// ----------------------------------------------------------------------------
+
+void
+sc_stop_here( const char* id, sc_severity severity )
+{
+    // you can set a breakpoint at some of the lines below, either to
+    // stop with any severity, or to stop with a specific severity
+
+    switch( severity ) {
+      case SC_INFO: 
+	info_id = id;
+	break;
+      case SC_WARNING: 
+	warning_id = id;
+	break;
+      case SC_ERROR: 
+	error_id = id;
+	break;
+      default:
+      case SC_FATAL: 
+	fatal_id = id;
+	break;
+    }
+}
+
+} // namespace sc_core
+
+// $Log: sc_stop_here.cpp,v $
+// Revision 1.4  2011/08/26 21:49:08  acg
+//  Philipp A. Hartmann: eliminate compiler warning by moving static variables
+//  out of functions.
+//
+// Revision 1.3  2011/08/26 20:46:19  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.2  2011/02/18 20:38:44  acg
+//  Andy Goodrich: Updated Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:06  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:11  acg
+// Andy Goodrich: Added $Log command so that CVS comments are reproduced in
+// the source.
+
+// Taf!
diff --git a/ext/systemc/src/sysc/utils/sc_stop_here.h b/ext/systemc/src/sysc/utils/sc_stop_here.h
new file mode 100644
index 000000000..8d8dca412
--- /dev/null
+++ b/ext/systemc/src/sysc/utils/sc_stop_here.h
@@ -0,0 +1,82 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_stop_here.h -- Function provided for debugging purposes.
+                    This file is always compiled in debug mode, such that
+                    setting a breakpoint at this function can help locate
+                    the cause of a SystemC error or warning.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2001-11-14
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+// $Log: sc_stop_here.h,v $
+// Revision 1.3  2011/08/26 20:46:19  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+#ifndef SC_STOP_HERE_H
+#define SC_STOP_HERE_H
+
+
+#include "sysc/utils/sc_report.h"
+
+
+namespace sc_core {
+
+// ----------------------------------------------------------------------------
+//  FUNCTION : sc_interrupt_here
+//
+//  Debugging aid for interrupt warning, error, and fatal reports.
+// ----------------------------------------------------------------------------
+
+extern
+void
+sc_interrupt_here( const char* id, sc_severity severity );
+
+
+// ----------------------------------------------------------------------------
+//  FUNCTION : sc_stop_here
+//
+//  Debugging aid for warning, error, and fatal reports.
+// ----------------------------------------------------------------------------
+
+extern
+void
+sc_stop_here( const char* id, sc_severity severity );
+
+} // namespace sc_core
+
+#endif
+
+// Revision 1.2  2011/02/18 20:38:44  acg
+//  Andy Goodrich: Updated Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:06  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:11  acg
+// Andy Goodrich: Added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+// Taf!
diff --git a/ext/systemc/src/sysc/utils/sc_string.cpp b/ext/systemc/src/sysc/utils/sc_string.cpp
new file mode 100644
index 000000000..25c788a59
--- /dev/null
+++ b/ext/systemc/src/sysc/utils/sc_string.cpp
@@ -0,0 +1,612 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_string.cpp -- Implementation of a simple string class.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+#include <assert.h>
+#include <ctype.h>
+#include <cstdio>
+#include <stdarg.h>
+#include <string.h>
+
+#include "sysc/utils/sc_iostream.h"
+#include "sysc/utils/sc_string.h"
+#include "sysc/utils/sc_utils_ids.h"
+
+namespace sc_dt {
+
+inline static int
+sc_roundup( int n, int m )
+{
+    return ((n - 1) / m + 1) * m;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_string_rep
+//
+//  Reference counting string implementation class.
+// ----------------------------------------------------------------------------
+
+class sc_string_rep
+{
+    friend class sc_string_old;
+    friend ::std::ostream& operator<<( ::std::ostream&, const sc_string_old& );
+    friend ::std::istream& operator>>( ::std::istream&, sc_string_old& );
+    friend sc_string_old operator+( const char*, const sc_string_old& );
+
+    sc_string_rep( int size = 16 ) :
+        ref_count(1), alloc( sc_roundup( size, 16 ) ), str( new char[alloc] )
+    {
+        *str = '\0';
+    }
+
+    sc_string_rep( const char* s ) : ref_count(1), alloc(0), str(0)
+    {
+        if (s) {
+            alloc = 1 + strlen(s);
+            str = strcpy( new char[alloc], s );
+        }
+        else {
+            alloc = 16;
+            str = strcpy( new char[alloc], "" );
+        }
+    }
+
+    sc_string_rep( const char* s, int n); // get first n chars from the string
+
+    ~sc_string_rep()
+    {
+        assert( ref_count == 0 );
+        delete[] str;
+    }
+
+    void resize( int new_size );
+    void set_string( const char* s );
+
+    int ref_count;
+    int alloc;
+    char* str;
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+sc_string_rep::sc_string_rep( const char* s, int n) :
+    ref_count(1), alloc(0), str(0)
+{
+    if (s && n>0) {
+        alloc = 1 + n;
+        str = strncpy( new char[alloc], s,n );
+        str[n] = 00;
+    }
+    else {
+        alloc = 16;
+        str = strcpy( new char[alloc], "" );
+    }
+}
+
+void
+sc_string_rep::resize( int new_size )
+{
+    if (new_size <= alloc) return;
+    alloc = sc_roundup( new_size, 16 );
+    char* new_str = strcpy( new char[alloc], str );
+    delete[] str;
+    str = new_str;
+}
+
+void
+sc_string_rep::set_string( const char* s )
+{
+    int len = strlen(s);
+    resize( len + 1 );
+    strcpy( str, s );
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_string_old
+//
+//  String class (yet another).
+// ----------------------------------------------------------------------------
+
+// constructors
+
+sc_string_old::sc_string_old( int size ) : rep( new sc_string_rep(size) )
+{
+}
+
+sc_string_old::sc_string_old( const char* s ) : rep( new sc_string_rep(s) )
+{
+}
+
+sc_string_old::sc_string_old( const char* s, int n ) : 
+    rep( new sc_string_rep( s, n ) )
+{
+}
+
+sc_string_old::sc_string_old( const sc_string_old& s ) : rep( s.rep )
+{
+    rep->ref_count ++;
+}
+
+sc_string_old::sc_string_old( sc_string_rep* r ) : rep(r)
+{
+}
+
+
+// destructor
+
+sc_string_old::~sc_string_old()
+{
+    if( -- (rep->ref_count) == 0 ) {
+        delete rep;
+    }
+}
+
+
+int
+sc_string_old::length() const
+{
+    return strlen(rep->str);
+}
+
+sc_string_old
+sc_string_old::operator+( const char* s ) const
+{
+    int len = length();
+    sc_string_rep* r = new sc_string_rep( len + strlen(s) + 1 );
+    strcpy( r->str, rep->str );
+    strcpy( r->str + len, s );
+    return sc_string_old(r);
+}
+
+sc_string_old sc_string_old::operator+(char c) const
+{
+    int len = length();
+    sc_string_rep* r = new sc_string_rep( len + 2 );
+    strcpy( r->str, rep->str );
+    r->str[len] = c;
+    r->str[len+1] = 00;
+    return sc_string_old(r);
+}
+
+sc_string_old
+operator+( const char* s, const sc_string_old& t )
+{
+    int len = strlen(s);
+    sc_string_rep* r = new sc_string_rep( len + t.length() + 1 );
+    strcpy( r->str, s );
+    strcpy( r->str + len, t );
+    return sc_string_old(r);
+}
+
+sc_string_old
+sc_string_old::operator+( const sc_string_old& s ) const
+{
+    int len = length();
+    sc_string_rep* r = new sc_string_rep( len + s.length() + 1 );
+    strcpy( r->str, rep->str );
+    strcpy( r->str + len, s.rep->str );
+    return sc_string_old(r);
+}
+
+sc_string_old&
+sc_string_old::operator=( const char* s )
+{
+    if (rep->ref_count > 1) {
+        --rep->ref_count;
+        rep = new sc_string_rep(s);
+    }
+    else {
+        rep->set_string(s);
+    }
+    return *this;
+}
+
+sc_string_old&
+sc_string_old::operator=( const sc_string_old& s )
+{
+    if (&s == this)
+        return *this;
+    if (--(rep->ref_count) == 0)
+        delete rep;
+    rep = s.rep;
+    rep->ref_count++;
+    return *this;
+}
+
+sc_string_old&
+sc_string_old::operator+=( const char* s )
+{
+    int oldlen = length();
+    int slen   = strlen(s);
+    if (rep->ref_count > 1) {
+        sc_string_rep* oldrep = rep;
+        --rep->ref_count;
+        rep = new sc_string_rep( oldlen + slen + 1 );
+        strcpy( rep->str, oldrep->str );
+        strcpy( rep->str + oldlen, s );
+    }
+    else {
+        rep->resize( oldlen + slen + 1 );
+        strcpy( rep->str + oldlen, s );
+    }
+    return *this;
+}
+
+sc_string_old& sc_string_old::operator+=(char c)
+{
+    int oldlen = length();
+    if (rep->ref_count > 1) {
+        sc_string_rep* oldrep = rep;
+        --rep->ref_count;
+        rep = new sc_string_rep( oldlen + 2 );
+        strcpy( rep->str, oldrep->str );
+        rep->str[oldlen]=c;
+        rep->str[oldlen+1]=00;
+    }
+    else {
+        rep->resize( oldlen + 2 );
+        rep->str[oldlen]=c;
+        rep->str[oldlen+1]=00;
+    }
+    return *this;
+}
+
+sc_string_old&
+sc_string_old::operator+=( const sc_string_old& s )
+{
+    return this->operator+=( s.rep->str );
+}
+
+int
+sc_string_old::cmp( const char* s ) const
+{
+    return strcmp( rep->str, s );
+}
+
+int
+sc_string_old::cmp( const sc_string_old& s ) const
+{
+    return strcmp( rep->str, s.rep->str );
+}
+
+const char* sc_string_old::c_str() const
+{
+  return rep->str;
+}
+
+// get substring
+sc_string_old sc_string_old::substr(int first,int last) const
+{
+  if(first<0 || last<0 || first>last || first>=length() || last>=length())
+    return "";
+  return sc_string_old(rep->str+first, last-first+1);
+}
+
+
+sc_string_old sc_string_old::make_str(long n) // convert integer to string
+{
+  char buf[32];
+  ::std::sprintf(buf,"%ld",n);
+  return sc_string_old(buf);
+}
+
+
+#define DEFINE_RELOP(op) \
+bool sc_string_old::operator op( const char* s ) const \
+{						\
+    return strcmp( rep->str, s ) op 0;		\
+}						\
+bool sc_string_old::operator op( const sc_string_old& s ) const \
+{						\
+    return strcmp( rep->str, s.rep->str ) op 0;	\
+}
+
+DEFINE_RELOP(==)
+DEFINE_RELOP(!=)
+DEFINE_RELOP(<)
+DEFINE_RELOP(<=)
+DEFINE_RELOP(>)
+DEFINE_RELOP(>=)
+
+sc_string_old::operator const char*() const
+{
+    return rep->str;
+}
+
+char
+sc_string_old::operator[]( int i ) const
+{
+    return rep->str[i];
+}
+
+char& sc_string_old::operator[]( int i )
+{
+    if (rep->ref_count > 1) {
+        rep->ref_count--;
+        rep = new sc_string_rep(rep->str);
+    }
+    return rep->str[i];
+}
+
+void
+sc_string_old::set( int i, char c )
+{
+    if (rep->ref_count > 1) {
+        rep->ref_count--;
+        rep = new sc_string_rep(rep->str);
+    }
+    rep->str[i] = c;
+}
+
+#if defined(_MSC_VER)
+   // Windows provides safer implementation
+#  define sc_vsnprintf _vsnprintf
+#else
+#  define sc_vsnprintf vsnprintf
+#endif
+
+sc_string_old sc_string_old::to_string(const char* format, ...)
+{
+   va_list argptr;
+   sc_string_old result;
+   char buffer[1024]; // static string buffer
+   buffer[1023]=000;
+
+   va_start(argptr, format);
+   int cnt = sc_vsnprintf(buffer, 1024, format, argptr);
+   if(cnt>1023) // string too long
+   {
+     int buf_size = 1024;
+     const int max_size = 65000;
+     char* buf = 0; // dynamic string buffer
+     do
+     {
+       delete[] buf;
+       buf_size*=2;
+       buf = new char[buf_size];
+       cnt = sc_vsnprintf(buf, buf_size, format, argptr);
+     }
+     while( buf_size<max_size && cnt>=buf_size);
+     if(cnt>=buf_size)
+     {
+       // string is longer the the maximum buffer size (max_size)
+       SC_REPORT_WARNING( sc_core::SC_ID_STRING_TOO_LONG_, "truncated" );
+       buf[buf_size-1] = 000;
+     }
+     result = buf;
+     delete[] buf;
+   }
+   else
+     result = buffer;
+
+   va_end(argptr);
+
+   return result;
+}
+
+void
+sc_string_old::print( ::std::ostream& os ) const
+{
+    os << rep->str;
+}
+
+void sc_string_old::test(int position)const
+{
+	if(position<0 || position>=length())
+		SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, "sc_string_old::test" );
+}
+
+// TODO: conveniece formatting functions for common types
+//       e.g. sc_string_old("a=%d, s is %s").fmt(1).fmt("string")
+//       should produce a=1, s is string
+//       it should be safe: if less arguments specified
+//       it should print %specifier; extra arguments should be ignored
+//       if the type of the argument is incompatible with format 
+//       specifier it should be ignored
+//
+
+unsigned
+sc_string_old::fmt_length()const
+{
+    unsigned result=0;
+    if((*this)[0]!='%')
+	return 0;
+    else
+	result++;
+    if(is_delimiter("-+0 #",result)) // flags
+	result++;
+    while(is_delimiter("0123456789*",result)) // width
+	result++;
+    if(rep->str[result]=='.') // precision
+    {
+	result++;
+	unsigned old_result = result;
+	while(is_delimiter("0123456789*",result)) result++;
+	if(old_result == result) //error in format
+	    return 0;
+    }
+    if(is_delimiter("hlL",result)) result++; // I64 is not supported
+    if(is_delimiter("cCdiouxXeEfgGnpsS",result)) 
+	result++;
+    else // error in format
+	return 0;
+    return result;
+}
+
+sc_string_old&
+sc_string_old::fmt(const sc_string_old& s)
+{
+    return fmt(s.c_str());
+}
+
+int
+sc_string_old::pos( const sc_string_old& sub_string ) const
+{
+    int sub_len = sub_string.length();
+    if( sub_len == 0 ) {
+        return 0; // empty string always matches
+    }
+    int ind = 0;
+    int len = length();
+    bool found = false;
+    while( ind < len && ! found )
+    {
+        found = ( sub_string == substr( ind, ind + sub_len - 1 ) );
+        ++ ind;
+    }
+    if( found ) {
+        return -- ind;
+    } else {
+        return -1;
+    }
+}
+
+sc_string_old&
+sc_string_old::remove(unsigned index, unsigned length)
+{
+    test((int)index);
+    if(length!=0)
+	(*this) = substr(0,index-1) + substr(index+length,this->length()-1);
+    return *this;
+}
+
+sc_string_old&
+sc_string_old::insert(const sc_string_old& sub_string, unsigned index)
+{
+    if(index>(unsigned)length())   
+	SC_REPORT_ERROR( sc_core::SC_ID_OUT_OF_BOUNDS_, "sc_string_old::insert" );
+    return (*this) = substr(0,index-1)+sub_string+substr(index,length()-1);
+}
+
+bool
+sc_string_old::is_delimiter(const sc_string_old& str, unsigned index)const
+{
+    test((int)index);
+    return str.contains(rep->str[index]);
+}
+
+bool
+sc_string_old::contains(char c)const
+{
+    int len = length();
+    int i=0;
+    bool found = false;
+    while(!found && i<len)
+	found = rep->str[i++]==c;
+    return found;
+}
+
+sc_string_old
+sc_string_old::uppercase()const
+{
+    int len = length();
+    sc_string_old temp(*this);
+    for(int i=0; i<len; i++)
+    {
+	char c = temp.rep->str[i];
+	if(c>='a' && c<='z')
+	    temp.rep->str[i] = static_cast<char>( c-32 );
+    }
+    return temp;
+}
+
+sc_string_old
+sc_string_old::lowercase()const
+{
+    int len = length();
+    sc_string_old temp(*this);
+    for(int i=0; i<len; i++)
+    {
+	char c = temp.rep->str[i];
+	if(c>='A' && c<='Z')
+	    temp.rep->str[i] = static_cast<char>( c+32 );
+    }
+    return temp;
+}
+
+
+// ----------------------------------------------------------------------------
+
+::std::istream&
+operator >> ( ::std::istream& is, sc_string_old& s )
+{
+    if( s.rep->ref_count > 1 ) {
+        -- s.rep->ref_count;
+        s.rep = new sc_string_rep;
+    }
+
+    int i = 0;
+    char* p = s.rep->str;
+    char c;
+
+    // skip white spaces
+    while( is.get( c ) && isspace( c ) )
+        ;
+
+    for( ; is.good() && ! isspace( c ); is.get( c ) ) {
+        if( i > s.rep->alloc - 2 ) {
+	    s.rep->str[i] = '\0';
+            s.rep->resize( (int) (s.rep->alloc * 1.5) );
+            p = s.rep->str + i;
+        }
+        *p ++ = c;
+        i ++;
+    }
+    *p = '\0';
+
+    return is;
+}
+ } // namespace sc_dt
+
+// $Log: sc_string.cpp,v $
+// Revision 1.6  2011/08/29 18:04:32  acg
+//  Philipp A. Hartmann: miscellaneous clean ups.
+//
+// Revision 1.5  2011/08/26 22:49:42  acg
+//  Torsten Maehne: remove redudant assignment.
+//
+// Revision 1.4  2011/08/26 20:46:19  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.3  2011/08/24 22:05:56  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.2  2011/02/18 20:38:44  acg
+//  Andy Goodrich: Updated Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:06  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:11  acg
+// Andy Goodrich: Added $Log command so that CVS comments are reproduced in
+// the source.
+
+// taf
diff --git a/ext/systemc/src/sysc/utils/sc_string.h b/ext/systemc/src/sysc/utils/sc_string.h
new file mode 100644
index 000000000..cf225ef1e
--- /dev/null
+++ b/ext/systemc/src/sysc/utils/sc_string.h
@@ -0,0 +1,254 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_string.h -- Implementation of a simple string class.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+// $Log: sc_string.h,v $
+// Revision 1.3  2011/08/26 20:46:19  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+#ifndef SC_STRING_H
+#define SC_STRING_H
+
+
+#include "sysc/utils/sc_iostream.h"
+#include "sysc/utils/sc_report.h"
+
+namespace sc_dt {
+	class sc_string_old;
+}
+
+#ifdef SC_USE_SC_STRING_OLD
+	typedef sc_dt::sc_string_old sc_string;
+#endif
+#ifdef SC_USE_STD_STRING
+	typedef ::std::string sc_string;
+#endif
+
+namespace sc_dt {
+
+// forward class declarations
+class sc_string_rep;
+
+// friend operator declarations
+sc_string_old operator + ( const char* s, const sc_string_old& t );
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_string
+//
+//  String class (yet another).
+// ----------------------------------------------------------------------------
+
+class sc_string_old
+{
+    friend systemc_ostream& operator << (systemc_ostream& os, const sc_string_old& a);
+    friend systemc_istream& operator >> ( systemc_istream& is, sc_string_old& a );
+
+public:
+
+    //  constructors
+
+    explicit sc_string_old( int size = 16 );
+    sc_string_old( const char* s );
+    sc_string_old( const char* s, int n ); // get first n chars from the string
+    sc_string_old( const sc_string_old& s );
+
+
+    // destructor
+
+    ~sc_string_old();
+
+
+    // concatenation and assignment
+
+    sc_string_old& operator = ( const char* s );
+    sc_string_old& operator = ( const sc_string_old& s );
+
+    sc_string_old& operator += ( const char* s );
+    sc_string_old& operator += ( char c );
+    sc_string_old& operator += ( const sc_string_old& s );
+
+    sc_string_old operator + ( const char* s ) const;
+    sc_string_old operator + ( char c ) const;
+    sc_string_old operator + ( const sc_string_old& s ) const;
+
+    friend sc_string_old operator + ( const char* s, const sc_string_old& t );
+
+
+    // returns substring [first,last]
+
+    sc_string_old substr( int first, int last ) const;
+
+
+    // string comparison operators
+
+    bool operator == ( const char* s ) const;
+    bool operator != ( const char* s ) const;
+    bool operator <  ( const char* s ) const;
+    bool operator <= ( const char* s ) const;
+    bool operator >  ( const char* s ) const;
+    bool operator >= ( const char* s ) const;
+    bool operator == ( const sc_string_old& s ) const;
+    bool operator != ( const sc_string_old& s ) const;
+    bool operator <  ( const sc_string_old& s ) const;
+    bool operator <= ( const sc_string_old& s ) const;
+    bool operator >  ( const sc_string_old& s ) const;
+    bool operator >= ( const sc_string_old& s ) const;
+
+    //
+    // returns length of the string (excluding trailing \0)
+    //
+    int length() const;
+
+    //
+    // returns c-style string
+    //
+    const char* c_str() const;
+    //
+    // returns c-style string
+    //
+    operator const char*() const;
+    //
+    // returns character at "index" position
+    //
+    char operator[](int index) const;
+    //
+    // l-value subscript
+    //
+    char& operator[](int index);
+
+    // formatted string (see printf description)
+    static sc_string_old to_string(const char* format, ...);
+    //
+    //       conveniece formatting functions for common types
+    //       e.g. sc_string_old("a=%d, s is %s").fmt(1).fmt("string")
+    //       should produce: a=1, s is string
+    //       it should be safe: if less arguments specified
+    //       it should print %specifier; extra arguments should be ignored
+    // TODO: if the type of the argument is incompatible with format
+    //       specifier it should be ignored
+    //
+    // must have it inlined because of some compilers
+    template<class T> sc_string_old& fmt(const T& t)
+	{
+	    // search %
+	    int index;
+	    int last_char = length()-1;
+	    sc_string_old temp(*this);
+	    do
+	    {
+		index = temp.pos("%");
+		if(index == last_char)
+		    return *this;
+		temp = substr(index,last_char);
+	    } while(temp[0] != '%');
+	    int f_len = (int)temp.fmt_length(); // length of format field
+	    temp = to_string(substr(0,index+f_len-1).c_str(),t);
+	    return (*this) = temp + substr(index+f_len,last_char);
+	}
+    sc_string_old& fmt(const sc_string_old& s);
+    //
+    // find position of substring in this string
+    // returns -1 if not found
+    //
+    int pos(const sc_string_old& sub_string)const;
+    //
+    // remove "count" characters from "index"
+    //
+    sc_string_old& remove(unsigned index, unsigned length);
+    //
+    // insert "substring" before "index"
+    //
+    sc_string_old& insert(const sc_string_old& sub_string, unsigned index);
+    //
+    // returns true if the character at byte index in this string matches
+    // any character in the delimiters string
+    //
+    bool is_delimiter(const sc_string_old& str, unsigned index)const;
+    //
+    // returns true if string contains the character
+    //
+    bool contains(char c)const;
+    //
+    // produce upper case string from this one
+    //
+    sc_string_old uppercase()const;
+    //
+    // produce lower case string from this one
+    //
+    sc_string_old lowercase()const;
+    //
+    // legacy methods
+    //
+    static sc_string_old make_str(long n);
+    void set( int index, char c );
+    int cmp( const char* s ) const;
+    int cmp( const sc_string_old& s ) const;
+
+
+    void print( systemc_ostream& os = ::std::cout ) const;
+
+private:
+
+    sc_string_old( sc_string_rep* r );
+
+    sc_string_rep* rep;
+
+    void test(int position)const;
+    unsigned fmt_length()const;
+};
+
+
+// IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
+
+inline
+systemc_ostream&
+operator << ( systemc_ostream& os, const sc_string_old& a )
+{
+    a.print( os );
+    return os;
+}
+
+} // namespace sc_dt
+
+// Revision 1.2  2011/02/18 20:38:44  acg
+//  Andy Goodrich: Updated Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:06  acg
+// SystemC 2.3
+//
+// Revision 1.4  2006/05/08 17:50:51  acg
+//   Andy Goodrich: added David Long's forward declarations for friend
+//   functions, methods, and operators to keep the Microsoft compiler happy.
+//
+// Revision 1.3  2006/01/13 18:53:11  acg
+// Andy Goodrich: Added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#endif
diff --git a/ext/systemc/src/sysc/utils/sc_temporary.h b/ext/systemc/src/sysc/utils/sc_temporary.h
new file mode 100644
index 000000000..321994aad
--- /dev/null
+++ b/ext/systemc/src/sysc/utils/sc_temporary.h
@@ -0,0 +1,228 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_temporary.h -- Temporary value pool classes.
+
+  Original Author: Andy Goodrich, Forte Design Systems, Inc.
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+#ifndef SC_TEMPORARY_H
+#define SC_TEMPORARY_H
+
+#include <cstddef>                // std::size_t
+
+namespace sc_core {
+
+//------------------------------------------------------------------------------
+// sc_byte_heap - CLASS MANAGING A TEMPORARY HEAP OF BYTES
+//
+// This facility implements a heap of temporary byte allocations. Once an 
+// request has been allocated it is not freed. However the entire heap 
+// wraps and the storage is reused. This means that no allocations should
+// be assumed as permanent. Allocations are double-word aligned. This is
+// raw storage, so objects which contain virtual methods cannot be allocated
+// with this object. See the sc_vpool object for that type of storage 
+// allocation.
+//
+// char* allocate( int size )
+//   This method returns a pointer to block of size bytes. The block
+//   returned is the next available one in the heap. If the current heap
+//   cannot fullfil the request it will be rewound and storage allocated from
+//   its start. All allocations start on an 8-byte boundary.
+//       size = number of bytes to be allocated.
+//
+// void initialize( int heap_size=0x100000 )
+//   This method allocates the storage to be managed. If there is already
+//   a block of storage under management it is freed. If no argument is
+//   provided for the heap size, a megabyte will be allocated.
+//       heap_size = number of bytes to allocate for the heap.
+//
+// unsigned int length()
+//   This method returns the size of this object's heap in bytes.
+//
+// sc_byte_heap()
+//   This is the non-initialized object instance constructor. It does not 
+//   allocate the heap storage, that is done by the initialize() method.
+//
+// sc_byte_heap(int)
+//   This is the initializing object instance constructor. It does allocates
+//   a heap of the specified number of bytes.
+//       heap_size = number of bytes to allocate for the heap.
+//------------------------------------------------------------------------------
+class sc_byte_heap {
+  public:
+    char*  m_bgn_p;  // Beginning of heap storage.
+    char*  m_end_p;  // End of heap storage.
+    char*  m_next_p; // Next heap location to be allocated.
+
+    inline char* allocate( std::size_t bytes_n )
+    {
+        char*   result_p;
+        bytes_n = (bytes_n + 7) & ((std::size_t)(-8));
+        result_p = m_next_p;
+        m_next_p += bytes_n;
+        if ( m_next_p >= m_end_p )
+        {
+            result_p = m_bgn_p;
+            m_next_p = m_bgn_p + bytes_n;
+        }
+        return result_p; 
+    }
+
+    inline void initialize( std::size_t heap_size=0x100000 )
+    {
+        delete [] m_bgn_p;
+        m_bgn_p = new char[heap_size];
+        m_end_p = &m_bgn_p[heap_size];
+        m_next_p = m_bgn_p;
+    }
+
+	inline std::size_t length()
+	{
+		return (std::size_t)(m_end_p - m_bgn_p);
+	}
+
+	inline sc_byte_heap() : 
+	    m_bgn_p(0), m_end_p(0), m_next_p(0)
+	{
+	}
+
+		inline sc_byte_heap( std::size_t heap_size ) :
+	    m_bgn_p(0), m_end_p(0), m_next_p(0)
+	{
+		initialize( heap_size );
+	}
+
+	inline ~sc_byte_heap()
+	{
+		delete [] m_bgn_p;
+	}
+
+};
+
+
+//------------------------------------------------------------------------------
+// sc_vpool<T> - CLASS MANAGING A TEMPORARY VECTOR OF CLASS T INSTANCES
+//
+// This class implements a fixed pool of objects contained in a vector. These
+// objects are allocated via the allocate() method. An index, m_pool_i, 
+// indicates the next object to be allocated. The vector is a power of 2 in
+// size, and this fact is used to wrap the list when m_pool_i reaches the
+// end of the vector.  
+// 
+// sc_vpool( int log2, T* pool_p=0 )
+//   This is the object instance constructor for this class. It configures
+//   the object to manage a vector of 2**log2 entries. If a vector is 
+//   not supplied one will be allocated.
+//     log2   =  the log base two of the size of the vector.
+//     pool_p -> vector of 2**log2 entries to be managed or 0.
+//
+// ~sc_vpool()
+//   This is the object instance destructor for this class. It frees the
+//   block of storage which was being managed.
+//
+// T* allocate()
+//   This method returns the address of the next entry in the vector, m_pool_p, 
+//   pointed to by the index, m_pool_i, and updates that index. The index
+//   update consists of adding 1 to m_pool_i and masking it by m_wrap.
+// 
+// void reset()
+//   This method resets the allocation index, m_pool_i, to point to the start
+//   of the vector of objects under management. This call is not usually made
+//   since there are a fixed number of entries and the index wraps. However,
+//   for diagnostics tests it is convenient to be able to reset to the start
+//   of the vector.
+//
+// int size()
+//   This method returns the number of object instances contained in the
+//   vector being managed by this object instance.
+//------------------------------------------------------------------------------
+template<class T>
+class sc_vpool {
+  protected:
+	std::size_t m_pool_i;	// Index of next entry to m_pool_m to provide.
+	T*          m_pool_p;	// Vector of temporaries.
+	std::size_t m_wrap;		// Mask to wrap vector index.
+
+  public:
+	inline sc_vpool( int log2, T* pool_p=0 );
+	inline ~sc_vpool();
+	inline T* allocate();
+	inline void reset();
+	inline std::size_t size();
+};
+
+template<class T> sc_vpool<T>::sc_vpool( int log2, T* pool_p )
+  : m_pool_i( 0 )
+  , m_pool_p( pool_p ? pool_p : new T[static_cast<std::size_t>(1) << log2] )
+  , m_wrap( ~(static_cast<std::size_t>(-1) << log2) )
+{
+	// if ( log2 > 32 ) SC_REPORT_ERROR(SC_ID_POOL_SIZE_, "");
+}
+
+template<class T> sc_vpool<T>::~sc_vpool()
+{
+	// delete [] m_pool_p;
+}
+
+template<class T> T* sc_vpool<T>::allocate()
+{
+	T* result_p;	// Entry to return.
+
+	result_p = &m_pool_p[m_pool_i];
+	m_pool_i = (m_pool_i + 1) & m_wrap;
+	return result_p;
+}
+
+template<class T> void sc_vpool<T>::reset()
+{
+	m_pool_i = 0;
+}
+
+template<class T> std::size_t sc_vpool<T>::size()
+{
+	return m_wrap + 1;
+}
+
+} // namespace sc_core
+
+// $Log: sc_temporary.h,v $
+// Revision 1.4  2011/08/26 20:46:19  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.3  2011/08/24 22:05:56  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.2  2011/02/18 20:38:44  acg
+//  Andy Goodrich: Updated Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:06  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:11  acg
+// Andy Goodrich: Added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#endif // SC_TEMPORARY_H
diff --git a/ext/systemc/src/sysc/utils/sc_utils_ids.cpp b/ext/systemc/src/sysc/utils/sc_utils_ids.cpp
new file mode 100644
index 000000000..3492692b3
--- /dev/null
+++ b/ext/systemc/src/sysc/utils/sc_utils_ids.cpp
@@ -0,0 +1,147 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_utils_ids.cpp -- Report ids for the utils code.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2002-01-17
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+
+#include <cstdlib>
+#include <cstring>
+
+#include "sysc/utils/sc_report.h"
+
+
+namespace sc_core {
+#define SC_DEFINE_MESSAGE(id,unused,text) extern const char id[] = text;
+#include "sysc/utils/sc_utils_ids.h"
+#include "sysc/kernel/sc_kernel_ids.h"
+#include "sysc/communication/sc_communication_ids.h"
+#include "sysc/datatypes/bit/sc_bit_ids.h"
+#include "sysc/datatypes/fx/sc_fx_ids.h"
+#include "sysc/datatypes/int/sc_int_ids.h"
+#include "sysc/tracing/sc_tracing_ids.h"
+#undef SC_DEFINE_MESSAGE
+
+
+static sc_msg_def texts[] = {
+#define SC_DEFINE_MESSAGE(id,n,unused) \
+    { (id), 0u, {0u}, 0u, {0u}, 0u, 0u, {0u}, 0, n },
+
+#undef SC_UTILS_IDS_H
+#include "sysc/utils/sc_utils_ids.h"
+
+#undef SC_KERNEL_IDS_H
+#include "sysc/kernel/sc_kernel_ids.h"
+
+#undef SC_COMMUNICATION_IDS_H
+#include "sysc/communication/sc_communication_ids.h"
+
+#undef SC_BIT_IDS_H
+#include "sysc/datatypes/bit/sc_bit_ids.h"
+
+#undef SC_FX_IDS_H
+#include "sysc/datatypes/fx/sc_fx_ids.h"
+
+#undef SC_INT_IDS_H
+#include "sysc/datatypes/int/sc_int_ids.h"
+
+#undef SC_TRACING_IDS_H
+#include "sysc/tracing/sc_tracing_ids.h"
+
+#undef SC_DEFINE_MESSAGE
+};
+static sc_report_handler::msg_def_items items = {
+    texts, sizeof(texts)/sizeof(*texts), false, 0
+};
+
+static
+int initialize()
+{
+    sc_report_handler::add_static_msg_types(&items);
+
+    // PROCESS ANY ENVIRONMENTAL OVERRIDES:
+
+    const char* deprecation_warn = std::getenv("SC_DEPRECATION_WARNINGS");
+    if ( (deprecation_warn!=0) && !std::strcmp(deprecation_warn,"DISABLE") )
+    {
+        sc_report_handler::set_actions( SC_ID_IEEE_1666_DEPRECATION_
+                                      , SC_DO_NOTHING);
+    }
+    return 42;
+}
+
+static int forty_two = initialize();
+
+} // namespace sc_core
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+  Alex Riesen, Synopsys, Inc., 2003-02-02
+  ported to SystemC 2.1 exception reporting.
+    
+ *****************************************************************************/
+
+
+// $Log: sc_utils_ids.cpp,v $
+// Revision 1.5  2011/08/26 20:46:19  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.4  2011/02/18 20:38:44  acg
+//  Andy Goodrich: Updated Copyright notice.
+//
+// Revision 1.3  2009/02/28 00:27:57  acg
+//  Andy Goodrich: includes for C++ library types to keep compiler happy.
+//
+// Revision 1.2  2008/05/20 20:43:21  acg
+//  Andy Goodrich: Added includes <cstdlib> and <cstring> to pick up their
+//  declarations.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:06  acg
+// SystemC 2.3
+//
+// Revision 1.6  2006/01/31 21:42:07  acg
+//  Andy Goodrich: Added checks for SC_DEPRECATED_WARNINGS being defined as
+//  DISABLED. If so, we turn off the /IEEE_Std_1666/deprecated message group.
+//
+// Revision 1.5  2006/01/24 21:59:59  acg
+//  Andy Goodrich: removed sc_trace_ids.h since its only message has been
+//  replaced by SC_ID_IEEE_1666_DEPRECATION_ message.
+//
+// Revision 1.4  2006/01/24 20:53:41  acg
+// Andy Goodrich: added warnings indicating that use of integer ids in reports
+// is deprecated. Added tracing/sc_trace_ids.h to message list.
+//
+// Revision 1.3  2006/01/13 18:53:11  acg
+// Andy Goodrich: Added $Log command so that CVS comments are reproduced in
+// the source.
+
+// Taf!
diff --git a/ext/systemc/src/sysc/utils/sc_utils_ids.h b/ext/systemc/src/sysc/utils/sc_utils_ids.h
new file mode 100644
index 000000000..811878280
--- /dev/null
+++ b/ext/systemc/src/sysc/utils/sc_utils_ids.h
@@ -0,0 +1,113 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_utils_ids.h -- Report ids for the utils code.
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2002-01-17
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+#ifndef SC_UTILS_IDS_H
+#define SC_UTILS_IDS_H
+
+// ----------------------------------------------------------------------------
+//  Report ids (utils)
+//
+//  Report ids in the range of 800-899.
+// ----------------------------------------------------------------------------
+
+#ifndef SC_DEFINE_MESSAGE
+#define SC_DEFINE_MESSAGE(id,unused1,unused2) \
+    namespace sc_core { extern const char id[]; }
+namespace sc_core {
+    extern const char SC_ID_REGISTER_ID_FAILED_[]; // in sc_report_handler.cpp
+}
+#endif
+
+SC_DEFINE_MESSAGE(SC_ID_STRING_TOO_LONG_,
+		  801, "string is too long")
+SC_DEFINE_MESSAGE(SC_ID_FRONT_ON_EMPTY_LIST_,
+		  802, "attempt to take front() on an empty list")
+SC_DEFINE_MESSAGE(SC_ID_BACK_ON_EMPTY_LIST_,
+		  803, "attempt to take back() on an empty list")
+SC_DEFINE_MESSAGE(SC_ID_IEEE_1666_DEPRECATION_,
+		  804, "/IEEE_Std_1666/deprecated" )
+SC_DEFINE_MESSAGE(SC_ID_VECTOR_INIT_CALLED_TWICE_,
+                  805, "sc_vector::init has already been called" )
+SC_DEFINE_MESSAGE(SC_ID_VECTOR_INIT_INVALID_CONTEXT_,
+                  806, "sc_vector::init called from invalid object context" )
+SC_DEFINE_MESSAGE(SC_ID_VECTOR_BIND_EMPTY_,
+                  807, "sc_vector::bind called with empty range" )
+SC_DEFINE_MESSAGE(SC_ID_VECTOR_NONOBJECT_ELEMENTS_,
+                  808, "sc_vector::get_elements called for element type "
+                       "not derived from sc_object" )
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+    
+  Alex Riesen, Synopsys, Inc., 2003-02-02
+  ported to SystemC 2.1 exception reporting.
+    
+ *****************************************************************************/
+
+// $Log: sc_utils_ids.h,v $
+// Revision 1.5  2011/08/26 20:46:20  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.4  2011/02/18 20:38:44  acg
+//  Andy Goodrich: Updated Copyright notice.
+//
+// Revision 1.3  2011/02/14 17:54:25  acg
+//  Andy Goodrich: Philipp's addition of early bind checks.
+//
+// Revision 1.2  2010/12/07 20:10:19  acg
+// Andy Goodrich: messages for new sc_vector class.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:06  acg
+// SystemC 2.3
+//
+// Revision 1.6  2006/01/25 00:31:27  acg
+//  Andy Goodrich: Changed over to use a standard message id of
+//  SC_ID_IEEE_1666_DEPRECATION for all deprecation messages.
+//
+// Revision 1.5  2006/01/24 22:01:35  acg
+//  Andy Goodrich: consolidated all IEEE 1666 compliance messages to use the
+//  SC_ID_IEEE_1666_DEPRECATION_ message type.
+//
+// Revision 1.4  2006/01/24 20:53:41  acg
+// Andy Goodrich: added warnings indicating that use of integer ids in reports
+// is deprecated. Added tracing/sc_trace_ids.h to message list.
+//
+// Revision 1.3  2006/01/13 18:53:11  acg
+// Andy Goodrich: Added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#endif
+
+// Taf!
diff --git a/ext/systemc/src/sysc/utils/sc_vector.cpp b/ext/systemc/src/sysc/utils/sc_vector.cpp
new file mode 100644
index 000000000..e42fba02e
--- /dev/null
+++ b/ext/systemc/src/sysc/utils/sc_vector.cpp
@@ -0,0 +1,178 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_vector.cpp - A vector of named (SystemC) objects (modules, ports, channels)
+
+  Original Author: Philipp A. Hartmann, OFFIS
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+
+#include "sc_vector.h"
+
+#include "sysc/utils/sc_hash.h"
+#include "sysc/utils/sc_list.h"
+#include "sysc/utils/sc_utils_ids.h"
+
+#include "sysc/kernel/sc_simcontext.h"
+#include "sysc/kernel/sc_object_manager.h"
+
+#include <sstream>
+
+namespace sc_core {
+
+sc_vector_base::sc_vector_base()
+  : sc_object( sc_gen_unique_name("vector") )
+  , vec_()
+  , objs_vec_()
+{}
+
+std::vector< sc_object* > const &
+sc_vector_base::get_elements() const
+{
+  if( !objs_vec_ )
+    objs_vec_ = new std::vector< sc_object* >;
+
+  if( objs_vec_->size() || !size() )
+    return *objs_vec_;
+
+  objs_vec_->reserve( size() );
+  for( const_iterator it=begin(); it != end(); ++it )
+    if( sc_object* obj = object_cast(*it) )
+      objs_vec_->push_back( obj );
+
+  return *objs_vec_;
+}
+
+sc_object*
+sc_vector_base::implicit_cast( ... ) const
+{
+  SC_REPORT_ERROR( SC_ID_VECTOR_NONOBJECT_ELEMENTS_, name() );
+  return NULL;
+}
+
+void
+sc_vector_base::check_index( size_type i ) const
+{
+  if( i>=size() )
+  {
+    std::stringstream str;
+    str << name()
+        << "[" << i << "] >= size() = " << size();
+    SC_REPORT_ERROR( SC_ID_OUT_OF_BOUNDS_, str.str().c_str() );
+  }
+}
+
+bool
+sc_vector_base::check_init( size_type n ) const
+{
+  if ( !n )
+    return false;
+
+  if( size() ) // already filled
+  {
+    std::stringstream str;
+    str << name()
+        << ", size=" << size()
+        << ", requested size=" << n;
+    SC_REPORT_ERROR( SC_ID_VECTOR_INIT_CALLED_TWICE_
+                   , str.str().c_str() );
+    return false;
+  }
+
+  sc_simcontext* simc = simcontext();
+  sc_assert( simc == sc_get_curr_simcontext() );
+
+  sc_object* parent_p = simc->active_object();
+  if( parent_p != get_parent_object() )
+  {
+    std::stringstream str;
+    str << name() << ": expected "
+        << ( get_parent_object()
+              ? get_parent_object()->name() : "<top-level>" )
+        << ", got "
+        << ( parent_p ? parent_p->name() : "<top-level>" );
+
+    SC_REPORT_ERROR( SC_ID_VECTOR_INIT_INVALID_CONTEXT_
+                   , str.str().c_str() );
+    return false;
+  }
+
+  return true;
+}
+
+void
+sc_vector_base::report_empty_bind( const char* kind_, bool dst_empty_ ) const
+{
+  std::stringstream str;
+
+  str << "target `" << name() << "' "
+      << "(" << kind_ << ") ";
+
+  if( !size() ) {
+    str << "not initialised yet";
+  } else if ( dst_empty_ ) {
+    str << "empty range given";
+  } else {
+    str << "empty destination range given";
+  }
+
+  SC_REPORT_WARNING( SC_ID_VECTOR_BIND_EMPTY_, str.str().c_str() );
+}
+
+std::string
+sc_vector_base::make_name( const char* prefix, size_type /* idx */ )
+{
+  // TODO: How to handle name clashes due to interleaved vector
+  //       creation and init()?
+  //       sc_vector< foo > v1, v2;
+  //       v1.name() == "vector", v2.name() == "vector_0"
+  //       v1.init( 1 ); -> v1[0].name() == "vector_0" -> clash
+  return sc_gen_unique_name( prefix );
+}
+
+} // namespace sc_core
+
+// $Log: sc_vector.cpp,v $
+// Revision 1.6  2011/08/26 20:46:20  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.5  2011/04/01 22:35:19  acg
+//  Andy Goodrich: spelling fix.
+//
+// Revision 1.4  2011/03/28 13:03:09  acg
+//  Andy Goodrich: Philipp's latest update.
+//
+// Revision 1.3  2011/03/23 16:16:28  acg
+//  Philipp A. Hartmann: rebase implementation on void*
+//      - supports virtual inheritance from sc_object again
+//      - build up get_elements result on demand
+//      - still requires element type to be derived from sc_object
+//
+// Revision 1.2  2011/02/14 17:54:25  acg
+//  Andy Goodrich: Philipp's addition of early bind checks.
+//
+// Revision 1.1  2011/02/13 21:54:14  acg
+//  Andy Goodrich: turn on embedding of cvs log records.
+
+// Taf!
diff --git a/ext/systemc/src/sysc/utils/sc_vector.h b/ext/systemc/src/sysc/utils/sc_vector.h
new file mode 100644
index 000000000..2afbaf45e
--- /dev/null
+++ b/ext/systemc/src/sysc/utils/sc_vector.h
@@ -0,0 +1,724 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_vector.h - A vector of named (SystemC) objects (modules, ports, channels)
+
+  Original Author: Philipp A. Hartmann, OFFIS
+
+  CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+#ifndef SC_VECTOR_H_INCLUDED_
+#define SC_VECTOR_H_INCLUDED_
+
+#include <vector>
+#include <iterator>
+#include <string>
+#include <algorithm> // std::swap
+
+#include "sysc/kernel/sc_object.h"
+#include <type_traits>
+
+//#define SC_VECTOR_HEADER_ONLY_
+
+namespace sc_core {
+namespace sc_meta {
+
+  using ::std::enable_if;
+  using ::std::remove_const;
+  using ::std::is_same;
+  using ::std::is_const;
+
+  template< typename CT, typename T >
+  struct is_more_const {
+    static constexpr bool value
+       = ( is_same< typename remove_const<CT>::type
+                 , typename remove_const<T>::type
+                 >::value
+          && ( is_const<CT>::value >= is_const<T>::value ) );
+  };
+
+} // namespace sc_meta
+
+// forward declarations
+template< typename T >              class sc_vector;
+template< typename T, typename MT > class sc_vector_assembly;
+template< typename T, typename MT > class sc_vector_iter;
+
+// implementation-defined
+template< typename Container, typename ArgumentIterator >
+typename Container::iterator
+sc_vector_do_bind( Container & cont
+                 , ArgumentIterator  first
+                 , ArgumentIterator  last
+                 , typename Container::iterator from );
+
+// implementation-defined
+template< typename Container, typename ArgumentIterator >
+typename Container::iterator
+sc_vector_do_operator_paren( Container & cont
+                           , ArgumentIterator  first
+                           , ArgumentIterator  last
+                           , typename Container::iterator from );
+
+class sc_vector_base
+  : public sc_object
+{
+
+  template<typename,typename> friend class sc_vector_assembly;
+  template<typename,typename> friend class sc_vector_iter;
+
+public:
+
+  typedef std::vector< void* >          storage_type;
+  typedef storage_type::size_type       size_type;
+  typedef storage_type::difference_type difference_type;
+
+  const char * kind() const { return "sc_vector"; }
+
+  std::vector<sc_object*> const & get_elements() const;
+
+  size_type size() const
+    { return vec_.size(); }
+
+protected:
+
+  // begin implementation defined
+
+  typedef storage_type::iterator        iterator;
+  typedef storage_type::const_iterator  const_iterator;
+
+  sc_vector_base();
+
+  sc_vector_base( const char* prefix )
+    : sc_object( prefix )
+    , vec_()
+    , objs_vec_(0)
+  {}
+
+  ~sc_vector_base()
+    { delete objs_vec_; }
+
+  void * & at( size_type i )
+    { return vec_[i]; }
+
+  void const * at( size_type i ) const
+    { return vec_[i]; }
+
+  void reserve( size_type n )
+    { vec_.reserve(n); }
+
+  void clear()
+    { vec_.clear(); }
+
+  void push_back( void* item )
+    { vec_.push_back(item); }
+
+  void check_index( size_type i ) const;
+  bool check_init( size_type n )  const;
+
+  static std::string make_name( const char* prefix, size_type index );
+
+  iterator begin() { return vec_.begin(); }
+  iterator end()   { return vec_.end();   }
+
+  const_iterator begin() const { return vec_.begin(); }
+  const_iterator end()   const { return vec_.end();   }
+
+  virtual sc_object* object_cast( void* ) const = 0;
+
+  sc_object* implicit_cast( sc_object* p ) const { return p; }
+  sc_object* implicit_cast( ... /* incompatible */ )  const;
+
+public: 
+
+  void report_empty_bind( const char* kind_, bool dst_range_ ) const;
+
+private:
+  storage_type vec_;
+  mutable std::vector< sc_object* >* objs_vec_;
+
+  // disabled
+  sc_vector_base( const sc_vector_base& );
+  sc_vector_base& operator=( const sc_vector_base& );
+
+}; // sc_vector_base
+
+// iterator access adapters
+template< typename ElementType >
+struct sc_direct_access
+{
+  typedef ElementType  element_type;
+  typedef element_type type;
+  typedef typename sc_meta::remove_const<type>::type plain_type;
+
+  typedef sc_direct_access< type >             policy;
+  typedef sc_direct_access< plain_type >       non_const_policy;
+  typedef sc_direct_access< const plain_type > const_policy;
+
+  sc_direct_access(){}
+  sc_direct_access( const non_const_policy& ) {}
+  // convert from any policy to (const) direct policy
+  template <typename U>
+  sc_direct_access(const U&,
+                   typename sc_meta::enable_if<sc_meta::is_more_const<
+                     type,
+                     typename U::policy::element_type>::value>::type* = NULL)
+  {}
+
+  type* get( type* this_ ) const
+    { return this_; }
+};
+
+// iterator access adapters
+template< typename ElementType
+        , typename AccessType   >
+class sc_member_access
+{
+  public:
+    template< typename, typename > friend class sc_member_access;
+
+    typedef ElementType element_type;
+    typedef AccessType  access_type;
+    typedef access_type (ElementType::*member_type);
+    typedef access_type type;
+    typedef typename sc_meta::remove_const<type>::type plain_type;
+    typedef typename sc_meta::remove_const<ElementType>::type plain_elem_type;
+
+    typedef sc_member_access< element_type, access_type > policy;
+    typedef sc_member_access< plain_elem_type, plain_type >
+      non_const_policy;
+    typedef sc_member_access< const plain_elem_type, const plain_type >
+      const_policy;
+  
+    sc_member_access( member_type ptr )
+      : ptr_(ptr) {}
+  
+    sc_member_access( const non_const_policy& other )
+      : ptr_(other.ptr_)
+    {}
+  
+    access_type * get( element_type* this_ ) const
+      { return &(this_->*ptr_); }
+  
+  private:
+    member_type ptr_;
+}; // sc_member_access
+  
+
+template< typename ElementType
+        , typename AccessPolicy = sc_direct_access<ElementType> >
+class sc_vector_iter
+  : public std::iterator< std::random_access_iterator_tag
+                        , typename AccessPolicy::type >
+  , private AccessPolicy
+{
+  typedef ElementType  element_type;
+  typedef typename AccessPolicy::policy            access_policy;
+  typedef typename AccessPolicy::non_const_policy  non_const_policy;
+  typedef typename AccessPolicy::const_policy      const_policy;
+  typedef typename access_policy::type access_type;
+
+  typedef typename sc_meta::remove_const<ElementType>::type plain_type;
+  typedef const plain_type                                  const_plain_type;
+
+  friend class sc_vector< plain_type >;
+  template< typename, typename > friend class sc_vector_assembly;
+  template< typename, typename > friend class sc_vector_iter;
+
+  typedef std::iterator< std::random_access_iterator_tag, access_type > base_type;
+  typedef sc_vector_iter               this_type;
+  typedef sc_vector<plain_type>        vector_type;
+  typedef sc_vector_base::storage_type storage_type;
+
+  // select correct base-type iterator
+  template< typename U > struct select_iter
+    { typedef typename storage_type::iterator       type; };
+  template< typename U > struct select_iter< const U >
+    { typedef typename storage_type::const_iterator type; };
+
+  typedef typename select_iter<ElementType>::type          raw_iterator;
+  typedef sc_vector_iter< const_plain_type, const_policy > const_iterator;
+
+  // underlying vector iterator
+
+  raw_iterator it_;
+
+  sc_vector_iter( raw_iterator it, access_policy acc = access_policy() )
+    : access_policy(acc), it_(it) {}
+
+  access_policy const & get_policy() const { return *this; }
+
+public:
+  // interface for Random Access Iterator category,
+  // see ISO/IEC 14882:2003(E), 24.1 [lib.iterator.requirements]
+
+  typedef typename base_type::difference_type difference_type;
+  typedef typename base_type::reference       reference;
+  typedef typename base_type::pointer         pointer;
+
+  sc_vector_iter() : access_policy(), it_() {}
+
+  // iterator conversions to more const, and/or direct iterators
+  template< typename OtherElement, typename OtherPolicy >
+  sc_vector_iter( const sc_vector_iter<OtherElement, OtherPolicy>& it
+      , typename sc_meta::enable_if<sc_meta::is_more_const<
+                     element_type,
+                     typename OtherPolicy::element_type>::value>::type* = NULL)
+    : access_policy( it.get_policy() ), it_( it.it_ )
+  {}
+
+  // step
+  this_type& operator++(){ ++it_; return *this; }
+  this_type& operator--(){ --it_; return *this; }
+  this_type  operator++(int){ this_type old(*this); ++it_; return old; }
+  this_type  operator--(int){ this_type old(*this); --it_; return old; }
+
+  // advance
+  this_type  operator+( difference_type n ) const
+    { return this_type( it_ + n, get_policy()); }
+  this_type  operator-( difference_type n ) const
+    { return this_type( it_ - n, get_policy()); }
+
+  this_type& operator+=( difference_type n ) { it_+=n; return *this; }
+  this_type& operator-=( difference_type n ) { it_-=n; return *this; }
+
+  // relations
+  bool operator== ( const this_type& that ) const { return it_ == that.it_; }
+  bool operator!= ( const this_type& that ) const { return it_ != that.it_; }
+  bool operator<= ( const this_type& that ) const { return it_ <= that.it_; }
+  bool operator>= ( const this_type& that ) const { return it_ >= that.it_; }
+  bool operator<  ( const this_type& that ) const { return it_ < that.it_; }
+  bool operator>  ( const this_type& that ) const { return it_ > that.it_; }
+
+  // dereference
+  reference operator*() const
+    { return *access_policy::get( static_cast<element_type*>(*it_) ); }
+  pointer   operator->() const
+    { return access_policy::get( static_cast<element_type*>(*it_) ); }
+  reference operator[]( difference_type n ) const
+    { return *access_policy::get( static_cast<element_type*>(it_[n]) ); }
+
+  // distance
+  difference_type operator-( this_type const& that ) const
+    { return it_-that.it_; }
+
+}; // sc_vector_iter
+
+template< typename T >
+class sc_vector
+  : public sc_vector_base
+{
+  typedef sc_vector_base base_type;
+  typedef sc_vector<T>   this_type;
+
+public:
+  typedef T element_type;
+  typedef sc_vector_iter< element_type >       iterator;
+  typedef sc_vector_iter< const element_type > const_iterator;
+
+  sc_vector(){}
+
+  explicit sc_vector( const char* prefix )
+    : base_type( prefix )
+  {}
+
+  explicit sc_vector( const char* prefix, size_type n )
+    : base_type( prefix )
+    { init(n); }
+
+  template< typename Creator >
+  sc_vector( const char* prefix, size_type n, Creator creator )
+    : base_type( prefix )
+  {
+    init( n, creator );
+  }
+
+  virtual ~sc_vector();
+
+  element_type& operator[]( size_type i )
+    { return *static_cast<element_type*>( base_type::at(i) ); }
+
+  element_type& at( size_type i )
+    { check_index(i); return (*this)[i]; }
+
+  const element_type& operator[]( size_type i ) const
+    { return *static_cast<element_type const *>( base_type::at(i) ); }
+
+  const element_type& at( size_type i ) const
+    { check_index(i); return (*this)[i]; }
+
+  void init( size_type n )
+    { init( n, &this_type::create_element ); }
+
+  template< typename Creator >
+  void init( size_type n, Creator c );
+
+  static element_type * create_element( const char* prefix, size_type index );
+
+  iterator begin() { return base_type::begin(); }
+  iterator end()   { return base_type::end();   }
+
+  const_iterator begin()  const { return base_type::begin(); }
+  const_iterator end()    const { return base_type::end(); }
+
+  const_iterator cbegin() const { return base_type::begin(); }
+  const_iterator cend()   const { return base_type::end(); }
+
+  template< typename ContainerType, typename ArgumentType >
+  iterator bind( sc_vector_assembly<ContainerType,ArgumentType> c )
+    { return bind( c.begin(), c.end() ); }
+
+  template< typename BindableContainer >
+  iterator bind( BindableContainer & c )
+    { return bind( c.begin(), c.end() ); }
+
+  template< typename BindableIterator >
+  iterator bind( BindableIterator first, BindableIterator last )
+    { return bind( first, last, this->begin() ); }
+
+  template< typename BindableIterator >
+  iterator bind( BindableIterator first, BindableIterator last
+               , iterator from )
+    { return sc_vector_do_bind( *this, first, last, from ); }
+
+  template< typename ContainerType, typename ArgumentType >
+  iterator operator()( sc_vector_assembly<ContainerType,ArgumentType> c )
+    { return operator()( c.begin(), c.end() ); }
+
+  template< typename ArgumentContainer >
+  iterator operator()( ArgumentContainer & c )
+    { return operator()( c.begin(), c.end() ); }
+
+  template< typename ArgumentIterator >
+  iterator operator()( ArgumentIterator first, ArgumentIterator last )
+    { return operator()( first, last, this->begin() ); }
+
+  template< typename ArgumentIterator >
+  iterator operator()( ArgumentIterator first, ArgumentIterator last
+                     , iterator from )
+    { return sc_vector_do_operator_paren( *this, first, last, from ); }
+
+  // member-wise access
+
+  template< typename MT >
+  sc_vector_assembly<T,MT> assemble( MT (T::*member_ptr) )
+    { return sc_vector_assembly<T,MT>( *this, member_ptr ); }
+
+protected:
+
+  void clear();
+
+  virtual sc_object* object_cast( void* p ) const
+    { return implicit_cast( static_cast<element_type*>(p) ); }
+
+};
+
+template< typename T, typename MT >
+class sc_vector_assembly
+{
+  template< typename U > friend class sc_vector;
+
+public:
+
+  typedef sc_vector<T> base_type;
+
+  typedef sc_vector_iter< T, sc_member_access<T, MT> >          iterator;
+  typedef sc_vector_iter< const T
+                        , sc_member_access<const T, const MT> > const_iterator;
+
+  typedef T  element_type;
+  typedef MT access_type;
+
+  typedef typename base_type::size_type       size_type;
+  typedef typename base_type::difference_type difference_type;
+  typedef typename iterator::reference        reference;
+  typedef typename iterator::pointer          pointer;
+  typedef typename const_iterator::reference  const_reference;
+  typedef typename const_iterator::pointer    const_pointer;
+
+
+  typedef access_type (T::*member_type);
+
+  const char* name() const { return vec_->name(); }
+  const char* kind() const { return "sc_vector_assembly"; }
+
+  iterator begin()
+    { return iterator( (*vec_).begin().it_, ptr_ ); }
+  iterator end()
+    { return iterator( (*vec_).end().it_, ptr_ ); }
+
+  const_iterator cbegin() const
+    { return const_iterator( (*vec_).cbegin().it_, ptr_ ); }
+  const_iterator cend() const
+    { return const_iterator( (*vec_).cend().it_, ptr_ ); }
+
+  const_iterator begin() const
+    { return const_iterator( (*vec_).begin().it_, ptr_ ); }
+  const_iterator end()   const
+    { return const_iterator( (*vec_).end().it_, ptr_ ); }
+
+  size_type size() const { return vec_->size(); }
+  const std::vector< sc_object* > & get_elements() const;
+
+  reference operator[]( size_type idx )
+    { return (*vec_)[idx].*ptr_; }
+  reference at( size_type idx )
+    { return vec_->at(idx).*ptr_; }
+  const_reference operator[]( size_type idx ) const
+    { return (*vec_)[idx].*ptr_; }
+  const_reference at( size_type idx ) const
+    { return vec_->at(idx).*ptr_; }
+
+  template< typename ContainerType, typename ArgumentType >
+  iterator bind( sc_vector_assembly<ContainerType,ArgumentType> c )
+    { return bind( c.begin(), c.end() ); }
+
+  template< typename BindableContainer >
+  iterator bind( BindableContainer & c )
+    { return bind( c.begin(), c.end() ); }
+
+  template< typename BindableIterator >
+  iterator bind( BindableIterator first, BindableIterator last )
+    { return bind( first, last, this->begin() ); }
+
+  template< typename BindableIterator >
+  iterator bind( BindableIterator first, BindableIterator last
+               , iterator from )
+    { return sc_vector_do_bind( *this, first, last, from ); }
+
+  template< typename BindableIterator >
+  iterator bind( BindableIterator first, BindableIterator last
+               , typename base_type::iterator from )
+    { return bind( first, last, iterator(from.it_, ptr_) ); }
+
+  template< typename ContainerType, typename ArgumentType >
+  iterator operator()( sc_vector_assembly<ContainerType,ArgumentType> c )
+    { return operator()( c.begin(), c.end() ); }
+
+  template< typename ArgumentContainer >
+  iterator operator()( ArgumentContainer & c )
+    { return operator()( c.begin(), c.end() ); }
+
+  template< typename ArgumentIterator >
+  iterator operator()( ArgumentIterator first, ArgumentIterator last )
+    { return operator()( first, last, this->begin() ); }
+
+  template< typename ArgumentIterator >
+  iterator operator()( ArgumentIterator first, ArgumentIterator last
+                     , iterator from )
+    { return sc_vector_do_operator_paren( *this, first, last, from ); }
+
+  template< typename ArgumentIterator >
+  iterator operator()( ArgumentIterator first, ArgumentIterator last
+                     , typename base_type::iterator from )
+    { return operator()( first, last, iterator(from.it_, ptr_) ); }
+
+  sc_vector_assembly( const sc_vector_assembly & other )
+    : vec_( other.vec_ )
+    , ptr_( other.ptr_ )
+    , child_vec_(0)
+  {}
+
+  sc_vector_assembly& operator=( sc_vector_assembly other_copy )
+  {
+    swap( other_copy );
+    return *this;
+  }
+
+  void swap( sc_vector_assembly & that )
+  {
+    using std::swap;
+    swap( vec_,       that.vec_ );
+    swap( ptr_,       that.ptr_ );
+    swap( child_vec_, that.child_vec_ );
+  }
+
+  void report_empty_bind( const char* kind_, bool dst_empty_ ) const
+    { vec_->report_empty_bind( kind_, dst_empty_ ); }
+
+  ~sc_vector_assembly()
+    { delete child_vec_; }
+
+private:
+
+  sc_vector_assembly( base_type & v, member_type ptr )
+    : vec_(&v)
+    , ptr_(ptr)
+    , child_vec_(0)
+  {}
+
+  sc_object* object_cast( pointer p ) const
+    { return vec_->implicit_cast( p ); }
+
+  base_type * vec_;
+  member_type ptr_;
+
+  mutable std::vector< sc_object* >* child_vec_;
+};
+
+template< typename T, typename MT >
+sc_vector_assembly<T,MT>
+sc_assemble_vector( sc_vector<T> & vec, MT (T::*ptr) )
+{
+  return vec.assemble( ptr );
+}
+
+template< typename T >
+typename sc_vector<T>::element_type *
+sc_vector<T>::create_element( const char* name, size_type /* idx */ )
+{
+  return new T( name );
+}
+
+template< typename T >
+template< typename Creator >
+void
+sc_vector<T>::init( size_type n, Creator c )
+{
+  if ( base_type::check_init(n) )
+  {
+    base_type::reserve( n );
+    try
+    {
+      for ( size_type i = 0; i<n; ++i )
+      {
+        // this workaround is needed for SystemC 2.2/2.3 sc_bind
+        std::string  name  = make_name( basename(), i );
+        const char*  cname = name.c_str();
+
+        void* p = c( cname, i ) ; // call Creator
+        base_type::push_back(p);
+      }
+    }
+    catch ( ... )
+    {
+      clear();
+      throw;
+    }
+  }
+}
+
+template< typename T >
+void
+sc_vector<T>::clear()
+{
+  size_type i = size();
+  while ( i --> 0 )
+  {
+    delete &( (*this)[i] );
+    base_type::at(i) = 0;
+  }
+  base_type::clear();
+}
+
+template< typename Container, typename ArgumentIterator >
+typename Container::iterator
+sc_vector_do_bind( Container & cont
+                 , ArgumentIterator  first
+                 , ArgumentIterator  last
+                 , typename Container::iterator from )
+{
+  typename Container::iterator end = cont.end();
+
+  if( !cont.size() || from == end || first == last )
+      cont.report_empty_bind( cont.kind(), from == end );
+
+  while( from!=end && first != last )
+    (*from++).bind( *first++ );
+  return from;
+}
+
+template< typename Container, typename ArgumentIterator >
+typename Container::iterator
+sc_vector_do_operator_paren( Container& cont
+                           , ArgumentIterator  first
+                           , ArgumentIterator  last
+                           , typename Container::iterator from )
+{
+  typename Container::iterator end = cont.end();
+
+  if( !cont.size() || from == end || first == last )
+      cont.report_empty_bind( cont.kind(), from == end );
+
+  while( from!=end && first != last )
+    (*from++)( *first++ );
+  return from;
+}
+
+template< typename T >
+sc_vector<T>::~sc_vector()
+{
+  clear();
+}
+
+template< typename T, typename MT >
+std::vector< sc_object* > const &
+sc_vector_assembly<T,MT>::get_elements() const
+{
+  if( !child_vec_ )
+    child_vec_ = new std::vector< sc_object* >;
+
+  if( child_vec_->size() || !size() )
+    return *child_vec_;
+
+  child_vec_->reserve( size() );
+  for( const_iterator it=begin(); it != end(); ++it )
+    if( sc_object * obj = object_cast( const_cast<MT*>(&*it) ) )
+      child_vec_->push_back( obj );
+
+  return *child_vec_;
+}
+
+} // namespace sc_core
+#undef SC_RPTYPE_
+#undef SC_ENABLE_IF_
+
+// $Log: sc_vector.h,v $
+// Revision 1.17  2011/08/26 20:46:20  acg
+//  Andy Goodrich: moved the modification log to the end of the file to
+//  eliminate source line number skew when check-ins are done.
+//
+// Revision 1.16  2011/07/25 10:21:17  acg
+//  Andy Goodrich: check in aftermath of call to automake.
+//
+// Revision 1.15  2011/04/02 00:04:32  acg
+//  Philipp A. Hartmann: fix distance from member iterators, and
+//  add iterator conversions.
+//
+// Revision 1.14  2011/04/01 22:35:19  acg
+//  Andy Goodrich: spelling fix.
+//
+// Revision 1.13  2011/03/28 13:03:09  acg
+//  Andy Goodrich: Philipp's latest update.
+//
+// Revision 1.12  2011/03/23 16:16:28  acg
+//  Philipp A. Hartmann: rebase implementation on void*
+//      - supports virtual inheritance from sc_object again
+//      - build up get_elements result on demand
+//      - still requires element type to be derived from sc_object
+//
+// Revision 1.11  2011/02/19 16:46:36  acg
+//  Andy Goodrich: finally get the update from Philipp correct!
+//
+
+#endif // SC_VECTOR_H_INCLUDED_
+// Taf!
diff --git a/ext/systemc/src/systemc b/ext/systemc/src/systemc
new file mode 100644
index 000000000..ec37d6a3c
--- /dev/null
+++ b/ext/systemc/src/systemc
@@ -0,0 +1,128 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  systemc - Top-level namespace-based include file for the SystemC library.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Andy Goodrich, Forte Design Systems, 31 Mar 2005
+  Description of Modification: This is the old systemc.h without usings.
+
+ *****************************************************************************/
+
+// $Log: systemc,v $
+// Revision 1.6  2011/08/04 17:12:07  acg
+//  Andy Goodrich: moved systemc and systemc.h back to src level because
+//  of MSVC not doing an install.
+//
+// Revision 1.1  2011/07/02 13:26:48  acg
+//  Andy Goodrich: moved header files up one level.
+//
+// Revision 1.4  2011/02/18 20:28:27  acg
+//  Andy Goodrich: Updated Copyright.
+//
+// Revision 1.3  2011/01/20 16:52:09  acg
+//  Andy Goodrich: changes for IEEE 1666 2011.
+//
+// Revision 1.2  2009/11/17 19:57:51  acg
+//  Andy Goodrich: changes for boost.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.5  2006/04/11 23:11:16  acg
+//   Andy Goodrich: remove inclusions that exposed sc_method_process,
+//   sc_thread_process, and sc_cthread_process internals.
+//
+// Revision 1.4  2006/01/25 00:48:29  acg
+//  Andy Goodrich: added capture of CVS logging messages in the source.
+//
+
+#ifndef SYSTEMC_INCLUDED
+#define SYSTEMC_INCLUDED
+
+// include this file first
+#include "sysc/kernel/sc_cmnhdr.h"
+
+#include "sysc/kernel/sc_externs.h"
+#include "sysc/kernel/sc_except.h"
+#include "sysc/kernel/sc_module.h"
+#include "sysc/kernel/sc_simcontext.h"
+#include "sysc/kernel/sc_process_handle.h"
+#include "sysc/kernel/sc_ver.h"
+
+#include "sysc/communication/sc_buffer.h"
+#include "sysc/communication/sc_clock.h"
+#include "sysc/communication/sc_clock_ports.h"
+#include "sysc/communication/sc_event_queue.h"
+#include "sysc/communication/sc_export.h"
+#include "sysc/communication/sc_fifo.h"
+#include "sysc/communication/sc_fifo_ports.h"
+#include "sysc/communication/sc_mutex.h"
+#include "sysc/communication/sc_semaphore.h"
+#include "sysc/communication/sc_signal.h"
+#include "sysc/communication/sc_signal_ports.h"
+
+#include "sysc/communication/sc_signal_resolved.h"
+#include "sysc/communication/sc_signal_resolved_ports.h"
+#include "sysc/communication/sc_signal_rv.h"
+#include "sysc/communication/sc_signal_rv_ports.h"
+
+#include "sysc/datatypes/bit/sc_bit.h"
+#include "sysc/datatypes/bit/sc_logic.h"
+#include "sysc/datatypes/bit/sc_bv.h"
+#include "sysc/datatypes/bit/sc_lv.h"
+
+#include "sysc/datatypes/int/sc_bigint.h"
+#include "sysc/datatypes/int/sc_biguint.h"
+#include "sysc/datatypes/int/sc_int.h"
+#include "sysc/datatypes/int/sc_uint.h"
+
+#include "sysc/datatypes/misc/sc_concatref.h" 
+
+#ifdef SC_INCLUDE_FX
+#   include "sysc/datatypes/fx/fx.h"
+#endif // SC_INCLUDE_FX
+
+#include "sysc/tracing/sc_trace.h"
+
+#include "sysc/utils/sc_iostream.h"
+#include "sysc/utils/sc_utils_ids.h"
+
+#include "sysc/utils/sc_pvector.h"
+#include "sysc/utils/sc_vector.h"
+
+#endif // !defined(SYSTEMC_INCLUDED)
+
+#ifdef SC_INCLUDE_DYNAMIC_PROCESSES
+#    include "sysc/kernel/sc_dynamic_processes.h"
+#endif // SC_INCLUDE_DYNAMIC_PROCESSES
+
+#ifdef SC_USE_SC_STRING_OLD
+#    include "sysc/utils/sc_string.h"
+#endif // SC_USE_SC_STRING_OLD
diff --git a/ext/systemc/src/systemc.h b/ext/systemc/src/systemc.h
new file mode 100644
index 000000000..ccc1285eb
--- /dev/null
+++ b/ext/systemc/src/systemc.h
@@ -0,0 +1,348 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  systemc.h - Top-level include file for the SystemC library with usings.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Andy Goodrich, Forte Design Systems, 31 Mar 2005
+  Description of Modification: Changes for namespace support.
+
+ *****************************************************************************/
+
+#ifndef SYSTEMC_H
+#define SYSTEMC_H
+
+// INCLUDE SYSTEM (std) DEFINITIONS:
+
+#include <cassert>
+#include <climits>
+#include <cmath> // math.h?
+#include <cstddef>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <exception>
+#include <fstream>
+#include <iostream>
+#include <memory>
+#include <string>
+#if defined(__sun) || defined(__sun__)
+#   include <inttypes.h>
+#elif !defined(WIN32) && !defined(_WIN32)
+#   include <stdint.h>
+#endif
+#include <typeinfo>
+#include <utility>
+#include <vector>
+
+// USINGS FOR I/O STREAM SUPPORT:
+
+    using std::ios;
+    using std::streambuf;
+    using std::streampos;
+    using std::streamsize;
+    using std::iostream;
+    using std::istream;
+    using std::ostream;
+    using std::cin;
+    using std::cout;
+    using std::cerr;
+    using std::endl;
+    using std::flush;
+    using std::dec;
+    using std::hex;
+    using std::oct;
+    using std::noshowbase;
+    using std::showbase;
+
+    using std::fstream;
+    using std::ifstream;
+    using std::ofstream;
+
+//  from <cstdio>:
+
+    using std::size_t;
+    using std::FILE;
+    using std::fpos_t;
+    using std::fclose;
+    using std::clearerr;
+
+    using std::remove;
+    using std::rename;
+    using std::tmpfile;
+    using std::tmpnam;
+    using std::fflush;
+    using std::fopen;
+    using std::freopen;
+    using std::setbuf;
+    using std::setvbuf;
+    using std::fprintf;
+    using std::fscanf;
+    using std::printf;
+    using std::scanf;
+    using std::sprintf;
+    using std::sscanf;
+    using std::vfprintf;
+    using std::vprintf;
+    using std::vsprintf;
+    using std::fgetc;
+    using std::fgets;
+    using std::fputc;
+    using std::fputs;
+    using std::getc;
+    using std::getchar;
+    using std::gets;
+    using std::putc;
+    using std::putchar;
+    using std::puts;
+    using std::ungetc;
+    using std::fread;
+    using std::fwrite;
+    using std::fgetpos;
+    using std::fseek;
+    using std::fsetpos;
+    using std::ftell;
+    using std::rewind;
+    using std::feof;
+    using std::ferror;
+    using std::perror;
+
+//  from <cstdlib>:
+
+    using std::div_t;
+    using std::ldiv_t;
+
+    using std::atof;
+    using std::atoi;
+    using std::atol;
+    using std::strtod;
+    using std::strtol;
+    using std::strtoul;
+    using std::rand;
+    using std::srand;
+    using std::calloc;
+    using std::free;
+    using std::malloc;
+    using std::realloc;
+    using std::abort;
+    using std::atexit;
+    using std::exit;
+    using std::getenv;
+    using std::system;
+    using std::bsearch;
+    using std::qsort;
+    using std::abs;
+    using std::div;
+    using std::labs;
+    using std::ldiv;
+    using std::mblen;
+    using std::mbtowc;
+    using std::mbstowcs;
+#if !defined(__CYGWIN__) && !defined(__CYGWIN32)
+    using std::wctomb;
+    using std::wcstombs;
+#endif
+
+//  from <cstring>:
+
+    using std::memcpy;
+    using std::memmove;
+    using std::strcpy;
+    using std::strncpy;
+    using std::strcat;
+    using std::strncat;
+    using std::memcmp;
+    using std::strcmp;
+    using std::strcoll;
+    using std::strncmp;
+    using std::strxfrm;
+    using std::memchr;
+    using std::strchr;
+    using std::strcspn;
+    using std::strpbrk;
+    using std::strrchr;
+    using std::strspn;
+    using std::strstr;
+    using std::strtok;
+    using std::memset;
+    using std::strerror;
+    using std::strlen;
+
+// deprecated strstream support
+#if defined( SC_INCLUDE_STRSTREAM )
+#include <strstream>
+
+    using std::strstream;
+    using std::strstreambuf;
+    using std::istrstream;
+    using std::ostrstream;
+
+#endif // SC_INCLUDE_STRSTREAM
+
+// INCLUDE SYSTEMC DEFINITIONS for sc_dt AND sc_core NAMESPACES:
+
+#include "systemc"
+
+// USINGS FOR THE sc_dt NAMESPACE:
+
+using sc_dt::SC_BIN;
+using sc_dt::SC_BIN_SM;
+using sc_dt::SC_BIN_US;
+using sc_dt::SC_CSD;
+using sc_dt::SC_DEC;
+using sc_dt::SC_HEX;
+using sc_dt::SC_HEX_SM;
+using sc_dt::SC_HEX_US;
+using sc_dt::SC_LOGIC_0;
+using sc_dt::SC_LOGIC_1;
+using sc_dt::SC_LOGIC_X;
+using sc_dt::SC_LOGIC_Z;
+using sc_dt::SC_NOBASE;
+using sc_dt::SC_OCT;
+using sc_dt::SC_OCT_SM;
+using sc_dt::SC_OCT_US;
+using sc_dt::int64;
+using sc_dt::sc_abs;
+using sc_dt::sc_bigint;
+using sc_dt::sc_biguint;
+using sc_dt::sc_bit;
+using sc_dt::sc_bv;
+using sc_dt::sc_bv_base;
+using sc_dt::sc_digit;
+using sc_dt::sc_int;
+using sc_dt::sc_int_base;
+using sc_dt::sc_io_show_base;
+using sc_dt::sc_length_context;
+using sc_dt::sc_length_param;
+using sc_dt::sc_logic;
+using sc_dt::sc_lv;
+using sc_dt::sc_lv_base;
+using sc_dt::sc_max;
+using sc_dt::sc_min;
+using sc_dt::sc_numrep;
+using sc_dt::sc_signed;
+using sc_dt::sc_uint;
+using sc_dt::sc_uint_base;
+using sc_dt::sc_unsigned;
+using sc_dt::uint64;
+// #ifdef SC_DT_DEPRECATED
+using sc_dt::sc_logic_0;
+using sc_dt::sc_logic_1;
+using sc_dt::sc_logic_Z;
+using sc_dt::sc_logic_X;
+// #endif
+
+#ifdef SC_INCLUDE_FX
+    using sc_dt::sc_fxnum;
+    using sc_dt::sc_fxnum_bitref;
+    using sc_dt::sc_fxnum_fast;
+    using sc_dt::sc_fix;
+    using sc_dt::sc_fix_fast;
+    using sc_dt::sc_ufix;
+    using sc_dt::sc_ufix_fast;
+    using sc_dt::sc_fixed;
+    using sc_dt::sc_fixed_fast;
+    using sc_dt::sc_ufixed;
+    using sc_dt::sc_ufixed_fast;
+    using sc_dt::sc_fxval;
+    using sc_dt::sc_fxval_fast;
+    using sc_dt::sc_fxcast_switch;
+    using sc_dt::sc_fxcast_context;
+    using sc_dt::sc_fxtype_params;
+    using sc_dt::sc_fxtype_context;
+    using sc_dt::sc_q_mode;
+    using sc_dt::SC_RND;
+    using sc_dt::SC_RND_ZERO;
+    using sc_dt::SC_RND_MIN_INF;
+    using sc_dt::SC_RND_INF;
+    using sc_dt::SC_RND_CONV;
+    using sc_dt::SC_TRN;
+    using sc_dt::SC_TRN_ZERO;
+    using sc_dt::sc_o_mode;
+    using sc_dt::SC_SAT;
+    using sc_dt::SC_SAT_ZERO;
+    using sc_dt::SC_SAT_SYM;
+    using sc_dt::SC_WRAP;
+    using sc_dt::SC_WRAP_SM;
+    using sc_dt::sc_switch;
+    using sc_dt::SC_OFF;
+    using sc_dt::SC_ON;
+    using sc_dt::sc_fmt;
+    using sc_dt::SC_F;
+    using sc_dt::SC_E;
+    using sc_dt::sc_context_begin;
+    using sc_dt::SC_NOW;
+    using sc_dt::SC_LATER;
+#endif // SC_INCLUDE_FX
+
+#if 0 // defined( _MSC_VER ) // supported versions of MSVC should support ADL
+
+    using sc_dt::equal;
+    using sc_dt::not_equal;
+    using sc_dt::b_not;
+    using sc_dt::b_and;
+    using sc_dt::b_or;
+    using sc_dt::b_xor;
+    using sc_dt::lrotate;
+    using sc_dt::rrotate;
+    using sc_dt::reverse;
+    using sc_dt::concat;
+    using sc_dt::and_reduce;
+    using sc_dt::or_reduce;
+    using sc_dt::xor_reduce;
+    using sc_dt::nand_reduce;
+    using sc_dt::nor_reduce;
+    using sc_dt::xnor_reduce;
+
+#endif // defined( _MSC_VER )
+
+
+// USINGS FOR sc_core:
+//
+// The explicit using for ::sc_core::wait is to remove an ambiguity with
+// the constructor for the system's union wait on Unix and Linux. This
+// causes problems with aCC, so users of aCC should explicitly select
+// the SystemC wait functions using ::sc_core::wait(...). This is actually
+// a good idea for SystemC programmers in general.
+
+using namespace sc_core;
+
+#if !defined( __HP_aCC )
+    using ::sc_core::wait;
+#endif // !defined( __HP_aCC )
+
+#ifdef SC_USE_SC_STRING_OLD
+	using   sc_dt::sc_string_old;
+	typedef sc_dt::sc_string_old sc_string;
+#endif
+#ifdef SC_USE_STD_STRING
+	typedef ::std::string sc_string;
+#endif
+
+#endif
diff --git a/ext/systemc/src/tlm b/ext/systemc/src/tlm
new file mode 100644
index 000000000..b4fb9fe70
--- /dev/null
+++ b/ext/systemc/src/tlm
@@ -0,0 +1,33 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __TLM_HEADER__
+#define __TLM_HEADER__
+
+#include <systemc>    // main SystemC header
+
+#include "tlm_core/tlm_2/tlm_version.h"
+#include "tlm_core/tlm_1/tlm_analysis/tlm_analysis.h"
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_req_rsp.h"
+#include "tlm_core/tlm_2/tlm_2_interfaces/tlm_2_interfaces.h"
+#include "tlm_core/tlm_2/tlm_generic_payload/tlm_generic_payload.h"
+#include "tlm_core/tlm_2/tlm_sockets/tlm_sockets.h"
+#include "tlm_core/tlm_2/tlm_quantum/tlm_quantum.h"
+
+#endif /* TLM_HEADER_INCLUDED_ */
diff --git a/ext/systemc/src/tlm.h b/ext/systemc/src/tlm.h
new file mode 100644
index 000000000..36d6263ea
--- /dev/null
+++ b/ext/systemc/src/tlm.h
@@ -0,0 +1,22 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+// kept for backwards compatibility
+
+#include "tlm"
diff --git a/ext/systemc/src/tlm_core/tlm.pc.in b/ext/systemc/src/tlm_core/tlm.pc.in
new file mode 100644
index 000000000..2d3e55c7a
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm.pc.in
@@ -0,0 +1,38 @@
+#  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+#  more contributor license agreements.  See the NOTICE file distributed
+#  with this work for additional information regarding copyright ownership.
+#  Accellera licenses this file to you under the Apache License, Version 2.0
+#  (the "License"); you may not use this file except in compliance with the
+#  License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+#  implied.  See the License for the specific language governing
+#  permissions and limitations under the License.
+#
+# -------------------------------------------------------------------------
+#
+# tlm.pc.in --
+#    pkg-config definition file (template) for TLM-2.0
+#    (http://www.freedesktop.org/wiki/Software/pkg-config/)
+#
+# Author: Philipp A. Hartmann, OFFIS, 2013-05-07
+#
+# Note: The "real" definition (tlm.pc) is generated by "configure"
+#       during the build configuration.
+#
+# -------------------------------------------------------------------------
+#
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+includedir=@includedir@
+
+Name: TLM-2.0
+Description: Accellera TLM-2.0 proof-of-concept library
+Version: @TLM_PACKAGE_VERSION@
+URL: @PACKAGE_URL@
+Requires: systemc >= 2.1.v1
+Cflags: -I${includedir}
diff --git a/ext/systemc/src/tlm_core/tlm_1/README.txt b/ext/systemc/src/tlm_core/tlm_1/README.txt
new file mode 100644
index 000000000..c7e1c5e1f
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/README.txt
@@ -0,0 +1,97 @@
+TLM-1.0 header files
+====================
+
+Dir: include/tlm_core/tlm_1/
+
+SubDirs: tlm_analysis/
+	 tlm_req_rsp/
+
+Files: README.txt
+
+
+Comments
+========
+
+User code should only #include the tlm or tlm.h header file in the include/
+directory and avoid including any of the include files in this directory
+directly.  All objects defined in this file hierarchy are in the tlm namespace.
+
+The header files are organizated, by subdirectory, as follows:
+
+
+tlm_analysis/ 
+--------------
+
+This contains the analysis interfaces, ports, and fifos. These files were not
+part of the original TLM-1.0 release, but have been grouped with TLM-1.0 in this
+release of TLM-2.0
+
+Files:
+  tlm_analysis.h        (includes the other header files in this directory )
+  tlm_analysis_fifo.h   (defines tlm_analysis_fifo )
+  tlm_analysis_if.h     (defines tlm_analysis_if and tlm_delayed_analysis_if )
+  tlm_analysis_port.h   (defines tlm_analysis_port )
+  tlm_analysis_triple.h (defines tlm_analysis_triple )
+  tlm_write_if.h        (defines tlm_write_if and tlm_delayed_write_if )
+
+
+tlm_req_rsp/
+------------
+
+This provides support for TLM modeling based on a request/response pair that 
+are passed by value. This is the original TLM 1.0 standard, with the addition 
+of an overloading of the blocking transport method with pass-by-reference arguments.
+
+Files:
+  tlm_req_rsp.h  (includes the key header files from the other directories)
+
+  tlm_1_interfaces/
+      tlm_core_ifs.h          (defines the TLM 1.0 core interfaces:
+					tlm_transport_if
+					tlm_blocking_get_if
+					tlm_blocking_put_if
+					tlm_nonblocking_get_if
+					tlm_nonblocking_put_if
+					tlm_get_if 
+					tlm_put_if 
+					tlm_blocking_peek_if
+					tlm_nonblocking_peek_if
+					tlm_peek_if 
+					tlm_blocking_get_peek_if 
+					tlm_nonblocking_get_peek_if 
+					tlm_get_peek_if              )     
+      tlm_fifo_ifs.h	     ( defines the TLM1.0 fifo interfaces:
+					tlm_fifo_debug_if			
+					tlm_fifo_put_if
+					tlm_fifo_get_if
+					tlm_fifo_config_size_if )
+      tlm_master_slave_ifs.h ( defines the TLM1.0 master slave interfaces:
+					tlm_blocking_master_if
+					tlm_blocking_slave_if
+					tlm_nonblocking_master_if
+					tlm_nonblocking_slave_if 
+					tlm_master_if 
+					tlm_slave_if )
+      tlm_tag.h	             ( defines tlm_tag )
+
+  tlm_ports/
+      tlm_nonblocking_port.h (defines tlm_nonblocking_put_port, 
+                                      tlm_nonblocking_get_port and
+				      tlm_nonblocking_peek_port )
+      tlm_event_finder.h     (defines tlm_event_finder_t )
+
+  tlm_channels/
+      tlm_fifo/
+          tlm_fifo.h         (defines tlm_fifo, includes the other files )
+          tlm_fifo_peek.h    (defines peek and poke interfaces for tlm_fifo )
+          tlm_fifo_put_get.h (defines put and get interfaces for tlm_fifo )
+          tlm_fifo_resize.h  (defines expand, reduce, bound and unbound
+	                      interfaces for tlm_fifo )
+          circular_buffer.h  (defines circular buffer used by tlm_fifo )
+      tlm_req_rsp_channels/
+          tlm_req_rsp_channels.h (defines tlm_req_rsp_channel and
+	  			          tlm_transport_channel )
+          tlm_put_get_imp.h      (contains implementatins used by the channels)
+
+  tlm_adapters/
+  	tlm_adapters.h  (defines transport_to_master and tlm_slave_to_transport)
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis.h b/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis.h
new file mode 100644
index 000000000..777f7141a
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis.h
@@ -0,0 +1,33 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __TLM_ANALYSIS_H__
+#define __TLM_ANALYSIS_H__
+
+
+#include "tlm_core/tlm_1/tlm_analysis/tlm_write_if.h"
+#include "tlm_core/tlm_1/tlm_analysis/tlm_analysis_if.h"
+
+#include "tlm_core/tlm_1/tlm_analysis/tlm_analysis_triple.h"
+#include "tlm_core/tlm_1/tlm_analysis/tlm_analysis_port.h"
+#include "tlm_core/tlm_1/tlm_analysis/tlm_analysis_fifo.h"
+
+#endif 
+
+
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis_fifo.h b/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis_fifo.h
new file mode 100644
index 000000000..1f01b2a8e
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis_fifo.h
@@ -0,0 +1,54 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __TLM_ANALYSIS_FIFO_H__
+#define __TLM_ANALYSIS_FIFO_H__
+
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo.h"
+#include "tlm_core/tlm_1/tlm_analysis/tlm_analysis_if.h"
+#include "tlm_core/tlm_1/tlm_analysis/tlm_analysis_triple.h"
+
+namespace tlm {
+
+template< typename T >
+class tlm_analysis_fifo :
+  public tlm_fifo< T > ,
+  public virtual tlm_analysis_if< T > ,
+  public virtual tlm_analysis_if< tlm_analysis_triple< T > > {
+
+ public:
+
+ // analysis fifo is an unbounded tlm_fifo
+
+  tlm_analysis_fifo( const char *nm ) : tlm_fifo<T>( nm , -16 ) {}
+  tlm_analysis_fifo() : tlm_fifo<T>( -16 ) {}
+
+  void write( const tlm_analysis_triple<T> &t ) {
+    nb_put( t );
+  }
+
+  void write( const T &t ) {
+    nb_put( t );
+  }
+
+};
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis_if.h b/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis_if.h
new file mode 100644
index 000000000..bc24fee54
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis_if.h
@@ -0,0 +1,39 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __TLM_ANALYSIS_IF_H__
+#define __TLM_ANALYSIS_IF_H__
+
+#include "tlm_core/tlm_1/tlm_analysis/tlm_write_if.h"
+
+namespace tlm {
+
+template < typename T >
+class tlm_analysis_if : public virtual tlm_write_if<T>
+{
+};
+
+template < typename T >
+class tlm_delayed_analysis_if : public virtual tlm_delayed_write_if<T>
+{
+};
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis_port.h b/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis_port.h
new file mode 100644
index 000000000..999092538
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis_port.h
@@ -0,0 +1,84 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __TLM_ANALYSIS_PORT_H__
+#define __TLM_ANALYSIS_PORT_H__
+
+#include "tlm_core/tlm_1/tlm_analysis/tlm_analysis_if.h"
+#include <deque>
+#include <algorithm>
+
+namespace tlm {
+
+
+template < typename T>
+class tlm_analysis_port :
+  public sc_core::sc_object ,
+  public virtual tlm_analysis_if< T >
+{
+ public:
+  tlm_analysis_port() : sc_core::sc_object() {}
+  tlm_analysis_port( const char *nm ) : sc_core::sc_object( nm ) {}
+
+  // bind and () work for both interfaces and analysis ports, since
+  // analysis ports implement the analysis interface
+
+  virtual void bind( tlm_analysis_if<T> &_if ) {
+    m_interfaces.push_back( &_if );
+  }
+
+  void operator() ( tlm_analysis_if<T> &_if ) { bind( _if ); }
+
+  virtual bool unbind( tlm_analysis_if<T> &_if ) {
+
+    typename std::deque< tlm_analysis_if<T> * >::iterator i
+      = std::remove( m_interfaces.begin(), m_interfaces.end(), &_if );
+
+    if( i != m_interfaces.end() ) {
+      m_interfaces.erase(i, m_interfaces.end() );
+      return 1;
+    }
+
+    return 0;
+
+  }
+
+  void write( const T &t ) {
+    typename std::deque< tlm_analysis_if<T> * >::iterator i;
+
+    for( i = m_interfaces.begin();
+   i != m_interfaces.end();
+   i++ ) {
+
+      (*i)->write( t );
+
+    }
+
+  }
+
+ private:
+  std::deque< tlm_analysis_if<T> * > m_interfaces;
+
+};
+
+} // namespace tlm
+
+#endif
+
+
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis_triple.h b/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis_triple.h
new file mode 100644
index 000000000..f65a25a2e
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_analysis_triple.h
@@ -0,0 +1,53 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __TLM_ANALYSIS_TRIPLE_H__
+#define __TLM_ANALYSIS_TRIPLE_H__
+
+//#include <systemc>
+
+namespace tlm {
+
+template< typename T>
+struct tlm_analysis_triple {
+
+  sc_core::sc_time start_time;
+  T transaction;
+  sc_core::sc_time end_time;
+
+  tlm_analysis_triple() {}
+
+  tlm_analysis_triple( const tlm_analysis_triple &triple ) {
+    start_time = triple.start_time;
+    transaction = triple.transaction;
+    end_time = triple.end_time;
+  }
+
+  tlm_analysis_triple( const T &t ) {
+    transaction = t;
+  }
+
+  operator T() { return transaction; }
+  operator const T &() const { return transaction; }
+
+};
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_write_if.h b/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_write_if.h
new file mode 100644
index 000000000..b66a591bc
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_analysis/tlm_write_if.h
@@ -0,0 +1,42 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __TLM_WRITE_IF_H__
+#define __TLM_WRITE_IF_H__
+
+#include <systemc>
+
+namespace tlm {
+
+template <typename T>
+class tlm_write_if : public virtual sc_core::sc_interface {
+public:
+  virtual void write(const T& t) = 0;
+};
+
+template <typename T>
+class tlm_delayed_write_if : public virtual sc_core::sc_interface {
+public:
+  virtual void write(const T& t, const sc_core::sc_time& time) = 0;
+};
+
+} // namespace tlm
+
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_core_ifs.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_core_ifs.h
new file mode 100644
index 000000000..4c1340338
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_core_ifs.h
@@ -0,0 +1,149 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+//
+// Note to the LRM writer : This is the core of the TLM standard
+//
+
+
+#ifndef __TLM_CORE_IFS_H__
+#define __TLM_CORE_IFS_H__
+
+//#include <systemc>
+
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_tag.h"
+
+namespace tlm {
+
+// bidirectional blocking interfaces
+
+template < typename REQ , typename RSP >
+class tlm_transport_if : public virtual sc_core::sc_interface
+{
+public:
+  virtual RSP transport( const REQ & ) = 0;
+
+  virtual void transport( const REQ &req , RSP &rsp ) {
+    rsp = transport( req );
+  }
+
+};
+
+
+// uni-directional blocking interfaces
+
+template < typename T >
+class tlm_blocking_get_if : public virtual sc_core::sc_interface
+{
+public:
+  virtual T get( tlm_tag<T> *t = 0 ) = 0;
+  virtual void get( T &t ) { t = get(); }
+
+};
+
+template < typename T >
+class tlm_blocking_put_if : public virtual sc_core::sc_interface
+{
+public:
+  virtual void put( const T &t ) = 0;
+};
+
+// uni-directional non blocking interfaces
+
+template < typename T >
+class tlm_nonblocking_get_if : public virtual sc_core::sc_interface
+{
+public:
+  virtual bool nb_get( T &t ) = 0;
+  virtual bool nb_can_get( tlm_tag<T> *t = 0 ) const = 0;
+  virtual const sc_core::sc_event &ok_to_get( tlm_tag<T> *t = 0 ) const = 0;
+};
+
+template < typename T >
+class tlm_nonblocking_put_if : public virtual sc_core::sc_interface
+{
+public:
+  virtual bool nb_put( const T &t ) = 0;
+  virtual bool nb_can_put( tlm_tag<T> *t = 0 ) const = 0;
+  virtual const sc_core::sc_event &ok_to_put( tlm_tag<T> *t = 0 ) const = 0;
+};
+
+
+// combined uni-directional blocking and non blocking
+
+template < typename T >
+class tlm_get_if :
+  public virtual tlm_blocking_get_if< T > ,
+  public virtual tlm_nonblocking_get_if< T > {};
+
+template < typename T >
+class tlm_put_if :
+  public virtual tlm_blocking_put_if< T > ,
+  public virtual tlm_nonblocking_put_if< T > {};
+
+
+// peek interfaces
+
+template < typename T >
+class tlm_blocking_peek_if : public virtual sc_core::sc_interface
+{
+public:
+  virtual T peek( tlm_tag<T> *t = 0 ) const = 0;
+  virtual void peek( T &t ) const { t = peek(); }
+
+};
+
+template < typename T >
+class tlm_nonblocking_peek_if : public virtual sc_core::sc_interface
+{
+public:
+  virtual bool nb_peek( T &t ) const = 0;
+  virtual bool nb_can_peek( tlm_tag<T> *t = 0 ) const = 0;
+  virtual const sc_core::sc_event &ok_to_peek( tlm_tag<T> *t = 0 ) const = 0;
+};
+
+template < typename T >
+class tlm_peek_if :
+  public virtual tlm_blocking_peek_if< T > ,
+  public virtual tlm_nonblocking_peek_if< T > {};
+
+// get_peek interfaces
+
+template < typename T >
+class tlm_blocking_get_peek_if :
+  public virtual tlm_blocking_get_if<T> ,
+  public virtual tlm_blocking_peek_if<T> {};
+
+template < typename T >
+class tlm_nonblocking_get_peek_if :
+  public virtual tlm_nonblocking_get_if<T> ,
+  public virtual tlm_nonblocking_peek_if<T> {};
+
+
+template < typename T >
+class tlm_get_peek_if :
+  public virtual tlm_get_if<T> ,
+  public virtual tlm_peek_if<T> ,
+  public virtual tlm_blocking_get_peek_if<T> ,
+  public virtual tlm_nonblocking_get_peek_if<T>
+  {};
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_fifo_ifs.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_fifo_ifs.h
new file mode 100644
index 000000000..d9b2b985b
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_fifo_ifs.h
@@ -0,0 +1,85 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+//
+// Note to the LRM writer : These interfaces are channel specific interfaces
+// useful in the context of tlm_fifo.
+//
+
+#ifndef __TLM_FIFO_IFS_H__
+#define __TLM_FIFO_IFS_H__
+
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_core_ifs.h"
+
+namespace tlm {
+
+//
+// Fifo specific interfaces
+//
+
+// Fifo Debug Interface
+
+template< typename T >
+class tlm_fifo_debug_if : public virtual sc_core::sc_interface
+{
+public:
+  virtual int used() const = 0;
+  virtual int size() const = 0;
+  virtual void debug() const = 0;
+
+  //
+  // non blocking peek and poke - no notification
+  //
+  // n is index of data :
+  // 0 <= n < size(), where 0 is most recently written, and size() - 1
+  // is oldest ie the one about to be read.
+  //
+
+  virtual bool nb_peek( T & , int n ) const = 0;
+  virtual bool nb_poke( const T & , int n = 0 ) = 0;
+
+};
+
+// fifo interfaces = extended + debug
+
+template < typename T >
+class tlm_fifo_put_if :
+  public virtual tlm_put_if<T> ,
+  public virtual tlm_fifo_debug_if<T> {};
+
+template < typename T >
+class tlm_fifo_get_if :
+  public virtual tlm_get_peek_if<T> ,
+  public virtual tlm_fifo_debug_if<T> {};
+
+class tlm_fifo_config_size_if : public virtual sc_core::sc_interface
+{
+public:
+  virtual void nb_expand( unsigned int n = 1 ) = 0;
+  virtual void nb_unbound( unsigned int n = 16 ) = 0;
+
+  virtual bool nb_reduce( unsigned int n = 1 ) = 0;
+  virtual bool nb_bound( unsigned int n ) = 0;
+
+};
+
+} // namespace tlm
+
+#endif
+
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_master_slave_ifs.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_master_slave_ifs.h
new file mode 100644
index 000000000..5bac3c877
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_master_slave_ifs.h
@@ -0,0 +1,73 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __TLM_MASTER_SLAVE_IFS_H__
+#define __TLM_MASTER_SLAVE_IFS_H__
+
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_core_ifs.h"
+
+namespace tlm {
+
+//
+// req/rsp combined interfaces
+//
+
+// blocking
+
+template < typename REQ , typename RSP>
+class tlm_blocking_master_if :
+  public virtual tlm_blocking_put_if< REQ > ,
+  public virtual tlm_blocking_get_peek_if< RSP > {};
+
+template < typename REQ , typename RSP>
+class tlm_blocking_slave_if :
+  public virtual tlm_blocking_put_if< RSP > ,
+  public virtual tlm_blocking_get_peek_if< REQ > {};
+
+// nonblocking
+
+template < typename REQ , typename RSP >
+class tlm_nonblocking_master_if :
+  public virtual tlm_nonblocking_put_if< REQ > ,
+  public virtual tlm_nonblocking_get_peek_if< RSP > {};
+
+template < typename REQ , typename RSP >
+class tlm_nonblocking_slave_if :
+  public virtual tlm_nonblocking_put_if< RSP > ,
+  public virtual tlm_nonblocking_get_peek_if< REQ > {};
+
+// combined
+
+template < typename REQ , typename RSP >
+class tlm_master_if :
+  public virtual tlm_put_if< REQ > ,
+  public virtual tlm_get_peek_if< RSP > ,
+  public virtual tlm_blocking_master_if< REQ , RSP > ,
+  public virtual tlm_nonblocking_master_if< REQ , RSP > {};
+
+template < typename REQ , typename RSP >
+class tlm_slave_if :
+  public virtual tlm_put_if< RSP > ,
+  public virtual tlm_get_peek_if< REQ > ,
+  public virtual tlm_blocking_slave_if< REQ , RSP > ,
+  public virtual tlm_nonblocking_slave_if< REQ , RSP > {};
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_tag.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_tag.h
new file mode 100644
index 000000000..230b77d17
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_tag.h
@@ -0,0 +1,31 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+//
+// Note to the LRM writer : This is part of the core TLM standard
+//
+
+#ifndef __TLM_TAG_H__
+#define __TLM_TAG_H__
+
+namespace tlm {
+template<class  T> class tlm_tag {};
+}
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_adapters/tlm_adapters.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_adapters/tlm_adapters.h
new file mode 100644
index 000000000..13207187a
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_adapters/tlm_adapters.h
@@ -0,0 +1,105 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __TLM_ADAPTERS_H__
+#define __TLM_ADAPTERS_H__
+
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_master_slave_ifs.h"
+
+namespace tlm {
+
+template< typename REQ , typename RSP >
+class tlm_transport_to_master :
+  public sc_core::sc_module ,
+  public virtual tlm_transport_if< REQ , RSP >
+{
+public:
+  sc_core::sc_export< tlm_transport_if< REQ , RSP > > target_export;
+  sc_core::sc_port< tlm_master_if< REQ , RSP > > master_port;
+
+  tlm_transport_to_master( sc_core::sc_module_name nm ) :
+    sc_core::sc_module( nm ) {
+
+    target_export( *this );
+
+  }
+
+  tlm_transport_to_master() :
+    sc_core::sc_module( sc_core::sc_module_name( sc_core::sc_gen_unique_name( "transport_to_master" ) ) ){
+
+    target_export( *this );
+
+  }
+
+  RSP transport( const REQ &req ) {
+
+    mutex.lock();
+
+    master_port->put( req );
+    rsp = master_port->get();
+
+    mutex.unlock();
+    return rsp;
+
+  }
+
+private:
+  sc_core::sc_mutex mutex;
+  RSP rsp;
+
+};
+
+template< typename REQ , typename RSP >
+class tlm_slave_to_transport : public sc_core::sc_module
+{
+public:
+
+  SC_HAS_PROCESS( tlm_slave_to_transport );
+
+  sc_core::sc_port< tlm_slave_if< REQ , RSP > > slave_port;
+  sc_core::sc_port< tlm_transport_if< REQ , RSP > > initiator_port;
+
+  tlm_slave_to_transport( sc_core::sc_module_name nm ) : sc_core::sc_module( nm )
+  {}
+
+  tlm_slave_to_transport() :
+    sc_core::sc_module( sc_core::sc_module_name( sc_core::sc_gen_unique_name("slave_to_transport") ) )
+  {}
+
+private:
+  void run() {
+
+    REQ req;
+    RSP rsp;
+
+    while( true ) {
+
+     slave_port->get( req );
+     rsp = initiator_port->transport( req );
+     slave_port->put( rsp );
+
+    }
+
+  }
+
+};
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/circular_buffer.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/circular_buffer.h
new file mode 100644
index 000000000..68c3c2c1f
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/circular_buffer.h
@@ -0,0 +1,268 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+//
+// To the LRM writer : this class is purely an artifact of the implementation.
+//
+
+#ifndef __CIRCULAR_BUFFER_H__
+#define __CIRCULAR_BUFFER_H__
+
+#include <iostream>
+
+namespace tlm {
+
+template < typename T >
+class circular_buffer
+{
+public:
+
+  explicit
+  circular_buffer( int size = 0 );
+  ~circular_buffer();
+
+  void resize( int size );
+  void clear();
+
+  T read();
+  void write( const T & );
+
+  bool is_empty() const { return used() == 0; }
+  bool is_full() const { return free() == 0; }
+
+  int size() const { return m_size; }
+  int used() const { return m_used; }
+  int free() const { return m_free; }
+
+  const T& read_data() const
+    { return buf_read( m_buf, m_ri ); }
+
+  const T& peek_data( int i ) const
+    { return buf_read( m_buf, (m_ri + i) % size() ); }
+
+  T & poke_data( int i )
+    { return buf_read( m_buf , (m_wi + i) % size() ); }
+
+  void debug() const;
+
+private:
+  void increment_write_pos( int i = 1 );
+  void increment_read_pos( int i = 1 );
+
+  void init();
+
+  circular_buffer( const circular_buffer<T> &b );              // disabled
+  circular_buffer<T> &operator=( const circular_buffer<T> & ); // disabled
+
+  void* buf_alloc( int size );
+  void  buf_free( void*& buf );
+  void  buf_write( void* buf, int n, const T & t );
+  T&    buf_read( void* buf, int n ) const;
+  void  buf_clear( void* buf, int n );
+
+private:
+  int    m_size;                   // size of the buffer
+  void*  m_buf;                    // the buffer
+  int    m_free;                   // number of free spaces
+  int    m_used;                   // number of used spaces
+  int    m_ri;                     // index of next read
+  int    m_wi;                     // index of next write
+
+};
+
+template< typename T >
+void
+circular_buffer<T>::debug() const
+{
+
+  std::cout << "Buffer debug" << std::endl;
+  std::cout << "Size : " << size() << std::endl;
+  std::cout << "Free/Used " << free() << "/" << used() << std::endl;
+  std::cout << "Indices : r/w = " << m_ri << "/" << m_wi << std::endl;
+
+  if( is_empty() ) {
+
+    std::cout << "empty" << std::endl;
+
+  }
+
+  if( is_full() ) {
+
+    std::cout << "full" << std::endl;
+
+  }
+
+  std::cout << "Data : " << std::endl;
+  for( int i = 0; i < used(); i++ ) {
+
+    std::cout << peek_data( i ) << std::endl;
+
+  }
+
+
+}
+
+template < typename T >
+circular_buffer<T>::circular_buffer( int size )
+  : m_size(size)
+  , m_buf(0)
+{
+  init();
+
+}
+
+template < typename T >
+void
+circular_buffer<T>::clear()
+{
+  for( int i=0; i < used(); i++ ) {
+    buf_clear( m_buf, i );
+  }
+  m_free = m_size;
+  m_used = m_ri = m_wi = 0;
+}
+
+template < typename T >
+circular_buffer<T>::~circular_buffer()
+{
+  clear();
+  buf_free( m_buf );
+}
+
+template < typename T >
+void
+circular_buffer<T>::resize( int size )
+{
+
+  int i;
+  void * new_buf = buf_alloc(size);
+
+  for( i = 0; i < size && i < used(); i++ ) {
+
+    buf_write( new_buf, i, peek_data( i ) );
+    buf_clear( m_buf, (m_ri + i) % m_size );
+
+  }
+
+  buf_free( m_buf );
+
+  m_size = size;
+  m_ri   = 0;
+  m_wi   = i % m_size;
+  m_used = i;
+  m_free = m_size - m_used;
+
+  m_buf  = new_buf;
+}
+
+
+template < typename T >
+void
+circular_buffer<T>::init() {
+
+  if( m_size > 0 ) {
+    m_buf = buf_alloc( m_size );
+  }
+
+  m_free = m_size;
+  m_used = 0;
+  m_ri = 0;
+  m_wi = 0;
+
+}
+
+template < typename T >
+T
+circular_buffer<T>::read()
+{
+  T t = read_data();
+
+  buf_clear( m_buf, m_ri );
+  increment_read_pos();
+
+  return t;
+}
+
+template < typename T >
+void
+circular_buffer<T>::write( const T &t )
+{
+  buf_write( m_buf, m_wi, t );
+  increment_write_pos();
+}
+
+
+template < typename T >
+void
+circular_buffer<T>::increment_write_pos( int i ) {
+
+  m_wi = ( m_wi + i ) % m_size;
+  m_used += i;
+  m_free -= i;
+
+}
+
+template < typename T >
+void
+circular_buffer<T>::increment_read_pos( int i ) {
+
+  m_ri = ( m_ri + i ) % m_size;
+  m_used -= i;
+  m_free += i;
+
+}
+
+template < typename T >
+inline void*
+circular_buffer<T>::buf_alloc( int size )
+    { return new unsigned char[ size * sizeof(T) ]; }
+
+template < typename T >
+inline void
+circular_buffer<T>::buf_free( void* & buf )
+    { delete [] static_cast<unsigned char*>(buf); buf = 0; }
+
+template < typename T >
+inline void
+circular_buffer<T>::buf_write( void* buf, int n, const T & t )
+{
+  T* p = static_cast<T*>(buf) + n;
+  new (p) T(t);
+}
+
+template < typename T >
+inline T&
+circular_buffer<T>::buf_read( void* buf, int n ) const
+{
+  T* p = static_cast<T*>(buf) + n;
+  return *p;
+}
+
+template < typename T >
+inline void
+circular_buffer<T>::buf_clear( void* buf, int n )
+{
+  T* p = static_cast<T*>(buf) + n;
+  p->~T();
+}
+
+} // namespace tlm
+
+#endif
+
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo.h
new file mode 100644
index 000000000..7b44a32ee
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo.h
@@ -0,0 +1,263 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __TLM_FIFO_H__
+#define __TLM_FIFO_H__
+
+//
+// This implements put, get and peek
+//
+// It also implements 0 and infinite size fifos - but the size
+// zero fifos aren't rendezvous like zero length fifos, they simply are both
+// full and empty at the same time.
+//
+// The size can be dynamically changed using the resize interface
+//
+// To get an infinite fifo use a -ve size in the constructor.
+// The absolute value of the size is taken as the starting size of the
+// actual physical buffer.
+//
+
+//#include <systemc>
+
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_fifo_ifs.h"
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/circular_buffer.h"
+
+namespace tlm {
+
+template <typename T>
+class tlm_fifo :
+  public virtual tlm_fifo_get_if<T>,
+  public virtual tlm_fifo_put_if<T>,
+  public sc_core::sc_prim_channel
+{
+public:
+
+    // constructors
+
+    explicit tlm_fifo( int size_ = 1 )
+      : sc_core::sc_prim_channel( sc_core::sc_gen_unique_name( "fifo" ) ) {
+
+      init( size_ );
+
+    }
+
+    explicit tlm_fifo( const char* name_, int size_ = 1 )
+      : sc_core::sc_prim_channel( name_ ) {
+
+      init( size_ );
+
+    }
+
+    // destructor
+
+    virtual ~tlm_fifo() {}
+
+    // tlm get interface
+
+    T get( tlm_tag<T> * = 0 );
+
+    bool nb_get( T& );
+    bool nb_can_get( tlm_tag<T> * = 0 ) const;
+    const sc_core::sc_event &ok_to_get( tlm_tag<T> * = 0 ) const {
+      return m_data_written_event;
+    }
+
+    // tlm peek interface
+
+    T peek( tlm_tag<T> * = 0 ) const;
+
+    bool nb_peek( T& ) const;
+    bool nb_can_peek( tlm_tag<T> * = 0 ) const;
+    const sc_core::sc_event &ok_to_peek( tlm_tag<T> * = 0 ) const {
+      return m_data_written_event;
+    }
+
+    // tlm put interface
+
+    void put( const T& );
+
+    bool nb_put( const T& );
+    bool nb_can_put( tlm_tag<T> * = 0 ) const;
+
+    const sc_core::sc_event& ok_to_put( tlm_tag<T> * = 0 ) const {
+      return m_data_read_event;
+    }
+
+    // resize if
+
+    void nb_expand( unsigned int n = 1 );
+    void nb_unbound( unsigned int n = 16 );
+
+    bool nb_reduce( unsigned int n = 1 );
+    bool nb_bound( unsigned int n );
+
+    // debug interface
+
+    bool nb_peek( T & , int n ) const;
+    bool nb_poke( const T & , int n = 0 );
+
+    int used() const {
+      return m_num_readable - m_num_read;
+    }
+
+    int size() const {
+      return m_size;
+    }
+
+    void debug() const {
+
+      if( is_empty() ) std::cout << "empty" << std::endl;
+      if( is_full() ) std::cout << "full" << std::endl;
+
+      std::cout << "size " << size() << " - " << used() << " used "
+                << std::endl;
+      std::cout << "readable " << m_num_readable
+                << std::endl;
+      std::cout << "written/read " << m_num_written << "/" << m_num_read
+                << std::endl;
+
+    }
+
+    // support functions
+
+    static const char* const kind_string;
+
+    const char* kind() const
+        { return kind_string; }
+
+
+protected:
+    sc_core::sc_event &read_event( tlm_tag<T> * = 0 ) {
+      return m_data_read_event;
+    }
+
+protected:
+
+    void update();
+
+    // support methods
+
+    void init( int );
+
+protected:
+
+    circular_buffer<T> buffer;
+
+    int m_size;                  // logical size of fifo
+
+    int m_num_readable;          // #samples readable
+    int m_num_read;          // #samples read during this delta cycle
+    int m_num_written;           // #samples written during this delta cycle
+    bool m_expand;               // has an expand occurred during this delta cycle ?
+    int m_num_read_no_notify;    // #samples read without notify during this delta cycle
+
+    sc_core::sc_event m_data_read_event;
+    sc_core::sc_event m_data_written_event;
+
+private:
+
+    // disabled
+    tlm_fifo( const tlm_fifo<T>& );
+    tlm_fifo& operator = ( const tlm_fifo<T>& );
+
+    //
+    // use nb_can_get() and nb_can_put() rather than the following two
+    // private functions
+    //
+
+    bool is_empty() const {
+      return used() == 0;
+    }
+
+    bool is_full() const {
+      //return size() == m_num_readable + m_num_written; // Old buggy code
+      if( size() < 0 )
+        return false;
+      else
+        return size() <= m_num_readable + m_num_written;
+    }
+
+};
+
+template <typename T>
+const char* const tlm_fifo<T>::kind_string = "tlm_fifo";
+
+
+/******************************************************************
+//
+// init and update
+//
+******************************************************************/
+
+template< typename T >
+inline
+void
+tlm_fifo<T>::init( int size_ ) {
+
+  if( size_ > 0 ) {
+    buffer.resize( size_ );
+  }
+
+  else if( size_ < 0 ) {
+    buffer.resize( -size_ );
+  }
+
+  else {
+    buffer.resize( 16 );
+  }
+
+  m_size = size_;
+  m_num_readable = 0;
+  m_num_read = 0;
+  m_num_written = 0;
+  m_expand = false;
+  m_num_read_no_notify = false;
+
+}
+
+template < typename T>
+inline
+void
+tlm_fifo<T>::update()
+{
+    if( m_num_read > m_num_read_no_notify || m_expand ) {
+  m_data_read_event.notify( sc_core::SC_ZERO_TIME );
+    }
+
+    if( m_num_written > 0 ) {
+  m_data_written_event.notify( sc_core::SC_ZERO_TIME );
+    }
+
+    m_expand = false;
+    m_num_read = 0;
+    m_num_written = 0;
+    m_num_readable = buffer.used();
+    m_num_read_no_notify = 0;
+
+}
+
+} // namespace tlm
+
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_put_get.h"
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_peek.h"
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_resize.h"
+
+#endif
+
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_peek.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_peek.h
new file mode 100644
index 000000000..e856c5657
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_peek.h
@@ -0,0 +1,98 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __TLM_FIFO_PEEK_H__
+#define __TLM_FIFO_PEEK_H__
+
+namespace tlm {
+
+template < typename T>
+inline
+T
+tlm_fifo<T>::peek( tlm_tag<T> * ) const {
+
+  while( is_empty() ) {
+
+    // call free-standing sc_core::wait(),
+    // since sc_prim_channel::wait(.) is not const
+
+    sc_core::wait( m_data_written_event );
+  }
+
+  return buffer.read_data();
+
+}
+
+template < typename T>
+inline
+bool
+tlm_fifo<T>::nb_peek( T &t ) const {
+
+  if( used() < 1 ) {
+    return false;
+  }
+
+  t = buffer.peek_data( 0 );
+  return true;
+
+}
+
+template < typename T>
+inline
+bool
+tlm_fifo<T>::nb_peek( T &t , int n ) const {
+
+  if( n >= used() || n < -1 ) {
+    return false;
+  }
+
+  if( n == -1 ) {
+    n = used() - 1;
+  }
+
+  t = buffer.peek_data( n );
+  return true;
+
+}
+
+template< typename T >
+inline
+bool
+tlm_fifo<T>::nb_can_peek( tlm_tag<T> * ) const
+{
+  return !is_empty();
+}
+
+template < typename T>
+inline
+bool
+tlm_fifo<T>::nb_poke( const T &t , int n ) {
+
+  if( n >= used() || n < 0 ) {
+    return false;
+  }
+
+  buffer.poke_data( n ) = t;
+  return true;
+
+}
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_put_get.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_put_get.h
new file mode 100644
index 000000000..2728e0394
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_put_get.h
@@ -0,0 +1,140 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __TLM_FIFO_PUT_GET_IF_H__
+#define __TLM_FIFO_PUT_GET_IF_H__
+
+namespace tlm {
+
+/******************************************************************
+//
+// get interface
+//
+******************************************************************/
+
+template <typename T>
+inline
+T
+tlm_fifo<T>::get( tlm_tag<T> * )
+{
+
+  while( is_empty() ) {
+    wait( m_data_written_event );
+  }
+
+  m_num_read ++;
+  request_update();
+
+  return buffer.read();
+
+}
+
+// non-blocking read
+
+template <typename T>
+inline
+bool
+tlm_fifo<T>::nb_get( T& val_ )
+{
+
+  if( is_empty() ) {
+    return false;
+  }
+
+  m_num_read ++;
+  request_update();
+
+  val_ = buffer.read();
+
+  return true;
+
+}
+
+template <typename T>
+inline
+bool
+tlm_fifo<T>::nb_can_get( tlm_tag<T> * ) const {
+
+  return !is_empty();
+
+}
+
+
+/******************************************************************
+//
+// put interface
+//
+******************************************************************/
+
+template <typename T>
+inline
+void
+tlm_fifo<T>::put( const T& val_ )
+{
+    while( is_full() ) {
+  wait( m_data_read_event );
+    }
+
+    if( buffer.is_full() ) {
+
+      buffer.resize( buffer.size() * 2 );
+
+    }
+
+    m_num_written ++;
+    buffer.write( val_ );
+
+    request_update();
+}
+
+template <typename T>
+inline
+bool
+tlm_fifo<T>::nb_put( const T& val_ )
+{
+
+  if( is_full() ) {
+    return false;
+  }
+
+  if( buffer.is_full() ) {
+
+    buffer.resize( buffer.size() * 2 );
+
+  }
+
+  m_num_written ++;
+  buffer.write( val_ );
+  request_update();
+
+  return true;
+}
+
+template < typename T >
+inline
+bool
+tlm_fifo<T>::nb_can_put( tlm_tag<T> * ) const {
+
+  return !is_full();
+
+}
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_resize.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_resize.h
new file mode 100644
index 000000000..39932fea1
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo_resize.h
@@ -0,0 +1,93 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __TLM_FIFO_RESIZE_H__
+#define __TLM_FIFO_RESIZE_H__
+
+/******************************************************************
+//
+// resize interface
+//
+******************************************************************/
+
+namespace tlm {
+
+template < typename T>
+inline
+void
+tlm_fifo<T>::nb_expand( unsigned int n ) {
+
+  if( m_size >= 0 ) {
+    m_expand = true;
+    m_size += n;
+    request_update();
+  }
+}
+
+template < typename T>
+inline
+void
+tlm_fifo<T>::nb_unbound( unsigned int n ) {
+
+  m_expand = true;
+  m_size = -n;
+
+  if( buffer.size() < static_cast<int>( n ) ) {
+    buffer.resize( n );
+  }
+
+  request_update();
+
+}
+
+template < typename T>
+inline
+bool
+tlm_fifo<T>::nb_reduce( unsigned int n ) {
+
+  if( m_size < 0 ) {
+    return false;
+  }
+
+  return nb_bound( size() - n );
+
+}
+
+template < typename T>
+inline
+bool
+tlm_fifo<T>::nb_bound( unsigned int new_size ) {
+
+  bool ret = true;
+
+  if( static_cast<int>( new_size ) < used() ) {
+
+    new_size = used();
+    ret = false;
+
+  }
+
+  m_size = new_size;
+  return ret;
+
+}
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_req_rsp_channels/tlm_put_get_imp.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_req_rsp_channels/tlm_put_get_imp.h
new file mode 100644
index 000000000..36dbd21d6
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_req_rsp_channels/tlm_put_get_imp.h
@@ -0,0 +1,114 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+//
+// To the LRM writer : these classes are purely artifacts of the implementation.
+//
+
+#ifndef __TLM_PUT_GET_IMP_H__
+#define __TLM_PUT_GET_IMP_H__
+
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_master_slave_ifs.h"
+
+namespace tlm {
+
+template < typename PUT_DATA , typename GET_DATA>
+class tlm_put_get_imp :
+  private virtual tlm_put_if< PUT_DATA > ,
+  private virtual tlm_get_peek_if< GET_DATA >
+{
+public:
+  tlm_put_get_imp( tlm_put_if<PUT_DATA> &p ,
+       tlm_get_peek_if<GET_DATA> &g ) :
+    put_fifo( p ) , get_fifo( g ) {}
+
+  // put interface
+
+  void put( const PUT_DATA &t ) { put_fifo.put( t ); }
+
+  bool nb_put( const PUT_DATA &t ) { return put_fifo.nb_put( t ); }
+  bool nb_can_put( tlm_tag<PUT_DATA> *t = 0 ) const {
+    return put_fifo.nb_can_put( t );
+  }
+  const sc_core::sc_event &ok_to_put( tlm_tag<PUT_DATA> *t = 0 ) const {
+    return put_fifo.ok_to_put( t );
+  }
+
+  // get interface
+
+  GET_DATA get( tlm_tag<GET_DATA> * = 0 ) { return get_fifo.get(); }
+
+  bool nb_get( GET_DATA &t ) { return get_fifo.nb_get( t ); }
+
+  bool nb_can_get( tlm_tag<GET_DATA> *t = 0 ) const {
+    return get_fifo.nb_can_get( t );
+  }
+
+  virtual const sc_core::sc_event &ok_to_get( tlm_tag<GET_DATA> *t = 0 ) const {
+    return get_fifo.ok_to_get( t );
+  }
+
+  // peek interface
+
+  GET_DATA peek( tlm_tag<GET_DATA> * = 0 ) const { return get_fifo.peek(); }
+
+  bool nb_peek( GET_DATA &t ) const { return get_fifo.nb_peek( t ); }
+
+  bool nb_can_peek( tlm_tag<GET_DATA> *t = 0 ) const {
+    return get_fifo.nb_can_peek( t );
+  }
+
+  virtual const sc_core::sc_event &ok_to_peek( tlm_tag<GET_DATA> *t = 0 ) const {
+    return get_fifo.ok_to_peek( t );
+  }
+
+private:
+  tlm_put_if<PUT_DATA> &put_fifo;
+  tlm_get_peek_if<GET_DATA> &get_fifo;
+};
+
+template < typename REQ , typename RSP >
+class tlm_master_imp :
+  private tlm_put_get_imp< REQ , RSP > ,
+  public virtual tlm_master_if< REQ , RSP >
+{
+public:
+
+  tlm_master_imp( tlm_put_if<REQ> &req ,
+                  tlm_get_peek_if<RSP> &rsp ) :
+    tlm_put_get_imp<REQ,RSP>( req , rsp ) {}
+
+};
+
+template < typename REQ , typename RSP >
+class tlm_slave_imp :
+  private tlm_put_get_imp< RSP , REQ > ,
+  public virtual tlm_slave_if< REQ , RSP >
+{
+public:
+
+  tlm_slave_imp( tlm_get_peek_if<REQ> &req ,
+                 tlm_put_if<RSP> &rsp ) :
+    tlm_put_get_imp<RSP,REQ>( rsp  , req ) {}
+
+};
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_req_rsp_channels/tlm_req_rsp_channels.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_req_rsp_channels/tlm_req_rsp_channels.h
new file mode 100644
index 000000000..7bd5652f7
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_req_rsp_channels/tlm_req_rsp_channels.h
@@ -0,0 +1,155 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __TLM_REQ_RSP_CHANNELS_H__
+#define __TLM_REQ_RSP_CHANNELS_H__
+
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_adapters/tlm_adapters.h"
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_fifo/tlm_fifo.h"
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_req_rsp_channels/tlm_put_get_imp.h"
+
+namespace tlm {
+
+template < typename REQ , typename RSP ,
+     typename REQ_CHANNEL = tlm_fifo<REQ> ,
+     typename RSP_CHANNEL = tlm_fifo<RSP> >
+
+class tlm_req_rsp_channel : public sc_core::sc_module
+{
+public:
+  // uni-directional slave interface
+
+  sc_core::sc_export< tlm_fifo_get_if< REQ > > get_request_export;
+  sc_core::sc_export< tlm_fifo_put_if< RSP > > put_response_export;
+
+  // uni-directional master interface
+
+  sc_core::sc_export< tlm_fifo_put_if< REQ > > put_request_export;
+  sc_core::sc_export< tlm_fifo_get_if< RSP > > get_response_export;
+
+  // master / slave interfaces
+
+  sc_core::sc_export< tlm_master_if< REQ , RSP > > master_export;
+  sc_core::sc_export< tlm_slave_if< REQ , RSP > > slave_export;
+
+
+  tlm_req_rsp_channel( int req_size = 1 , int rsp_size = 1 ) :
+    sc_core::sc_module( sc_core::sc_module_name( sc_core::sc_gen_unique_name("tlm_req_rsp_channel") ) ) ,
+    request_fifo( req_size ) ,
+    response_fifo( rsp_size ) ,
+    master( request_fifo , response_fifo ) ,
+    slave( request_fifo , response_fifo )
+  {
+
+    bind_exports();
+
+  }
+
+  tlm_req_rsp_channel( sc_core::sc_module_name module_name ,
+           int req_size = 1 , int rsp_size = 1 ) :
+    sc_core::sc_module( module_name  ) ,
+    request_fifo( req_size ) ,
+    response_fifo( rsp_size ) ,
+    master( request_fifo , response_fifo ) ,
+    slave( request_fifo , response_fifo )
+  {
+
+    bind_exports();
+
+  }
+
+private:
+  void bind_exports() {
+
+    put_request_export( request_fifo );
+    get_request_export( request_fifo );
+
+    put_response_export( response_fifo );
+    get_response_export( response_fifo );
+
+    master_export( master );
+    slave_export( slave );
+
+  }
+
+protected:
+  REQ_CHANNEL request_fifo;
+  RSP_CHANNEL response_fifo;
+
+  tlm_master_imp< REQ , RSP > master;
+  tlm_slave_imp< REQ , RSP > slave;
+};
+
+template < typename REQ , typename RSP ,
+     typename REQ_CHANNEL = tlm_fifo<REQ> ,
+     typename RSP_CHANNEL = tlm_fifo<RSP> >
+class tlm_transport_channel : public sc_core::sc_module
+{
+public:
+
+  // master transport interface
+
+  sc_core::sc_export< tlm_transport_if< REQ , RSP > > target_export;
+
+  // slave interfaces
+
+  sc_core::sc_export< tlm_fifo_get_if< REQ > > get_request_export;
+  sc_core::sc_export< tlm_fifo_put_if< RSP > > put_response_export;
+
+  sc_core::sc_export< tlm_slave_if< REQ , RSP > > slave_export;
+
+  tlm_transport_channel() :
+    sc_core::sc_module( sc_core::sc_module_name( sc_core::sc_gen_unique_name("transport_channel" ) ) ) ,
+    target_export("target_export") ,
+    req_rsp( "req_rsp" , 1 , 1 ) ,
+    t2m("ts2m")
+  {
+    do_binding();
+  }
+
+  tlm_transport_channel( sc_core::sc_module_name nm ) :
+    sc_core::sc_module( nm ) ,
+    target_export("target_export") ,
+    req_rsp( "req_rsp" , 1 , 1 ) ,
+    t2m("tsm" )
+  {
+    do_binding();
+  }
+
+private:
+  void do_binding() {
+
+    target_export( t2m.target_export );
+
+    t2m.master_port( req_rsp.master_export );
+
+    get_request_export( req_rsp.get_request_export );
+    put_response_export( req_rsp.put_response_export );
+    slave_export( req_rsp.slave_export );
+
+  }
+
+  tlm_req_rsp_channel< REQ , RSP , REQ_CHANNEL , RSP_CHANNEL > req_rsp;
+  tlm_transport_to_master< REQ , RSP > t2m;
+
+};
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_ports/tlm_event_finder.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_ports/tlm_event_finder.h
new file mode 100644
index 000000000..60874ce91
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_ports/tlm_event_finder.h
@@ -0,0 +1,94 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __TLM_EVENT_FINDER_H__
+#define __TLM_EVENT_FINDER_H__
+
+//#include <systemc>
+
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_tag.h"
+
+namespace tlm {
+
+template <class IF , class T>
+class tlm_event_finder_t
+: public sc_core::sc_event_finder
+{
+public:
+
+    // constructor
+
+    tlm_event_finder_t( const sc_core::sc_port_base& port_,
+                        const sc_core::sc_event& (IF::*event_method_) ( tlm_tag<T> * ) const )
+        : sc_core::sc_event_finder( port_ ), m_event_method( event_method_ )
+        {}
+
+    // destructor (does nothing)
+
+    virtual ~tlm_event_finder_t()
+        {}
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+    virtual const sc_core::sc_event& find_event( sc_core::sc_interface* if_p = 0 ) const;
+#else
+    virtual const sc_core::sc_event& find_event() const;
+#endif
+
+private:
+
+    const sc_core::sc_event& (IF::*m_event_method) ( tlm_tag<T> * ) const;
+
+private:
+
+    // disabled
+    tlm_event_finder_t();
+    tlm_event_finder_t( const tlm_event_finder_t<IF,T>& );
+    tlm_event_finder_t<IF,T>& operator = ( const tlm_event_finder_t<IF,T>& );
+};
+
+
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+template <class IF , class T>
+inline
+const sc_core::sc_event&
+tlm_event_finder_t<IF,T>::find_event( sc_core::sc_interface* if_p ) const
+{
+    const IF* iface = ( if_p ) ? dynamic_cast<const IF*>( if_p ) :
+                                 dynamic_cast<const IF*>( port().get_interface() );
+    if( iface == 0 ) {
+  report_error( sc_core::SC_ID_FIND_EVENT_, "port is not bound" );
+    }
+    return (const_cast<IF*>( iface )->*m_event_method) ( 0 );
+}
+#else
+template <class IF , class T>
+inline
+const sc_core::sc_event&
+tlm_event_finder_t<IF,T>::find_event() const
+{
+    const IF* iface = dynamic_cast<const IF*>( port().get_interface() );
+    if( iface == 0 ) {
+  report_error( sc_core::SC_ID_FIND_EVENT_, "port is not bound" );
+    }
+    return (const_cast<IF*>( iface )->*m_event_method) ( 0 );
+}
+#endif
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_ports/tlm_nonblocking_port.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_ports/tlm_nonblocking_port.h
new file mode 100644
index 000000000..0af1e3487
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_ports/tlm_nonblocking_port.h
@@ -0,0 +1,91 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __TLM_NONBLOCKING_PORT_H__
+#define __TLM_NONBLOCKING_PORT_H__
+
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_core_ifs.h"
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_ports/tlm_event_finder.h"
+
+namespace tlm {
+
+template < typename T >
+class tlm_nonblocking_get_port :
+public sc_core::sc_port< tlm_nonblocking_get_if< T > , 1 >
+{
+public:
+  typedef tlm_nonblocking_get_if<T> get_if_type;
+
+  tlm_nonblocking_get_port( const char *port_name ) :
+    sc_core::sc_port< tlm_nonblocking_get_if< T > , 1 >( port_name ) {}
+
+  sc_core::sc_event_finder& ok_to_get() const {
+
+    return *new tlm_event_finder_t< get_if_type , T >(
+       *this,
+       &get_if_type::ok_to_get );
+
+  }
+
+};
+
+template < typename T >
+class tlm_nonblocking_peek_port :
+public sc_core::sc_port< tlm_nonblocking_peek_if< T > , 1 >
+{
+public:
+  typedef tlm_nonblocking_peek_if<T> peek_if_type;
+
+  tlm_nonblocking_peek_port( const char *port_name ) :
+    sc_core::sc_port< tlm_nonblocking_peek_if< T > , 1 >( port_name ) {}
+
+  sc_core::sc_event_finder& ok_to_peek() const {
+
+    return *new tlm_event_finder_t< peek_if_type , T >(
+       *this,
+       &peek_if_type::ok_to_peek );
+
+  }
+
+};
+
+
+template < typename T >
+class tlm_nonblocking_put_port :
+public sc_core::sc_port< tlm_nonblocking_put_if< T > , 1 >
+{
+public:
+  typedef tlm_nonblocking_put_if<T> put_if_type;
+
+  tlm_nonblocking_put_port( const char *port_name ) :
+    sc_core::sc_port< tlm_nonblocking_put_if< T > , 1 >( port_name ) {}
+
+  sc_core::sc_event_finder& ok_to_put() const {
+
+    return *new tlm_event_finder_t< put_if_type , T >(
+             *this,
+       &put_if_type::ok_to_put );
+
+  }
+
+};
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_req_rsp.h b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_req_rsp.h
new file mode 100644
index 000000000..88f1d0e8c
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_1/tlm_req_rsp/tlm_req_rsp.h
@@ -0,0 +1,37 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __TLM_REQ_RSP_H__
+#define __TLM_REQ_RSP_H__
+
+// The unannotated TLM interfaces
+
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_core_ifs.h"
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_1_interfaces/tlm_master_slave_ifs.h"
+
+// The channels : tlm_fifo, tlm_transport_channel and tlm_req_rsp_channel
+
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_channels/tlm_req_rsp_channels/tlm_req_rsp_channels.h"
+
+// Some non blocking ports to provide static sensitivity
+
+#include "tlm_core/tlm_1/tlm_req_rsp/tlm_ports/tlm_nonblocking_port.h"
+
+
+#endif /* __TLM_REQ_RSP_H__ */
diff --git a/ext/systemc/src/tlm_core/tlm_2/README.txt b/ext/systemc/src/tlm_core/tlm_2/README.txt
new file mode 100644
index 000000000..cb02af2d8
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/README.txt
@@ -0,0 +1,111 @@
+TLM-2.0 interoperability layer header files
+===========================================
+
+Dir: include/tlm_core/tlm_2/
+
+SubDirs: tlm_2_interfaces/
+	 tlm_generic_payload/
+	 tlm_quantum/
+	 tlm_sockets
+
+Files: README.txt
+       tlm_version.h
+
+
+Comments
+========
+
+User code should only #include the tlm or tlm.h header file in the include/
+directory and avoid including any of the include files in this directory
+directly. All objects defined in this file hierarchy are in the tlm namespace.
+
+tlm_version.h contains the definitions for the version string and integer values
+
+The header files are organizated, by subdirectory, as follows:
+
+
+tlm_2_interfaces/
+-----------------
+
+Contains the TLM-2.0 core interfaces
+
+Files:
+      tlm_2_interfaces.h (includes the other header files in this directory )
+      tlm_fw_bw_ifs.h    (defines the TLM 2.0 interface API's:
+					tlm_fw_nonblocking_transport_if
+					tlm_bw_nonblocking_transport_if
+					tlm_blocking_transport_if
+					tlm_fw_direct_mem_if
+					tlm_bw_direct_mem_if
+					tlm_transport_dbg_if
+			  the enumeration type
+			   		tlm_sync_enum
+			  and the TLM 2.0 standard interfaces using the API's
+			   		tlm_fw_transport_if
+					tlm_bw_transport_if )
+      tlm_dmi.h          (defines tlm_dmi)
+
+
+tlm_generic_payload/
+--------------------
+
+Contains the TLM-2.0 generic payload and associated classes and helper functions
+
+Files:
+      tlm_generic_payload.h ( includes the other header files in this directory)
+      tlm_gp.h              (defines the TLM 2.0 generic payload classes:
+      					tlm_generic_payload
+					tlm_extension
+					tlm_extension_base
+					tlm_mm_interface
+			     and the enumeration types
+			    		tlm_command
+					tlm_response_status  ) 
+      tlm_array.h           (defines array class used by the extention 
+      			     mechanism )
+      tlm_endian_conv.h     (defines the implementation for the endianness 
+      			     helper functions:
+			    		tlm_to_hostendian_generic()
+					tlm_from_hostendian_generic()
+					tlm_to_hostendian_word()
+					tlm_from_hostendian_word()
+					tlm_to_hostendian_aligned()
+					tlm_from_hostendian_aligned()
+					tlm_to_hostendian_single()
+					tlm_from_hostendian_single()  )
+					  
+      tlm_helpers.h         (defines the helper functions to determine the
+      			     hostendianness:
+					get_host_endianness()
+					host_has_little_endianness()
+					has_host_endianness()
+			     and defines the enumeration type:
+			     		tlm_endianness	
+      tlm_phase.h           (defines tlm_phase as an extendable enum type)
+
+
+tlm_sockets/
+------------
+
+Contains the standard TLM-2.0 initiator and target sockets (which are used as
+the base classes for the convenience sockets in tlm_utils)
+
+Files:
+      tlm_sockets.h          (includes the other header files in this directory)
+      tlm_initiator_socket.h (defines the initiator sockets:
+					tlm_initiator_socket_base
+					tlm_initiator_socket_b
+					tlm_initiator_socket
+      tlm_target_socket.h    (defines the target sockets:
+					tlm_target_socket_base
+					tlm_target_socket_b
+					tlm_target_socket
+
+
+tlm_quantum/
+------------
+This contains the global quantum. (The quantum keeper is in tlm_utils)
+
+Files:
+  tlm_quantum.h        ( includes the other header file in this directory )
+  tlm_global_quantum.h ( defines tlm_global_quantum ) 
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_2_interfaces/tlm_2_interfaces.h b/ext/systemc/src/tlm_core/tlm_2/tlm_2_interfaces/tlm_2_interfaces.h
new file mode 100644
index 000000000..8a0c543c8
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_2_interfaces/tlm_2_interfaces.h
@@ -0,0 +1,27 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __TLM_2_INTERFACES_H__
+#define __TLM_2_INTERFACES_H__
+
+#include "tlm_core/tlm_2/tlm_2_interfaces/tlm_dmi.h"
+#include "tlm_core/tlm_2/tlm_2_interfaces/tlm_fw_bw_ifs.h"
+
+#endif
+
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_2_interfaces/tlm_dmi.h b/ext/systemc/src/tlm_core/tlm_2/tlm_2_interfaces/tlm_dmi.h
new file mode 100644
index 000000000..d7c3304eb
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_2_interfaces/tlm_dmi.h
@@ -0,0 +1,114 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __TLM_DMI_H__
+#define __TLM_DMI_H__
+
+#include <systemc>
+
+namespace tlm {
+
+class tlm_dmi
+{
+  public:
+
+  // Enum for indicating the access granted to the initiator. 
+  // The initiator uses gp.m_command to indicate it intention (read/write)
+  //  The target is allowed to promote DMI_ACCESS_READ or DMI_ACCESS_WRITE
+  //  requests to dmi_access_read_write.
+
+  enum dmi_access_e
+  { DMI_ACCESS_NONE       = 0x00                               // no access
+  , DMI_ACCESS_READ       = 0x01                               // read access
+  , DMI_ACCESS_WRITE      = 0x02                               // write access
+  , DMI_ACCESS_READ_WRITE = DMI_ACCESS_READ | DMI_ACCESS_WRITE // read/write access
+  };
+  
+  tlm_dmi (void)
+  {
+    init();
+  }
+  
+  void init (void)
+  {
+    m_dmi_ptr           = 0x0;
+    m_dmi_start_address = 0x0;
+    m_dmi_end_address   = (sc_dt::uint64)(-1);
+    m_dmi_access        = DMI_ACCESS_NONE;
+    m_dmi_read_latency  = sc_core::SC_ZERO_TIME;
+    m_dmi_write_latency = sc_core::SC_ZERO_TIME;
+  }
+  
+  unsigned char*    get_dmi_ptr           (void) const {return m_dmi_ptr;}
+  sc_dt::uint64     get_start_address     (void) const {return m_dmi_start_address;}
+  sc_dt::uint64     get_end_address       (void) const {return m_dmi_end_address;}
+  sc_core::sc_time  get_read_latency      (void) const {return m_dmi_read_latency;}
+  sc_core::sc_time  get_write_latency     (void) const {return m_dmi_write_latency;}
+  dmi_access_e      get_granted_access    (void) const {return m_dmi_access;}
+  bool              is_none_allowed       (void) const {return m_dmi_access == DMI_ACCESS_NONE;}
+  bool              is_read_allowed       (void) const {return (m_dmi_access & DMI_ACCESS_READ) == DMI_ACCESS_READ;}
+  bool              is_write_allowed      (void) const {return (m_dmi_access & DMI_ACCESS_WRITE) == DMI_ACCESS_WRITE;}
+  bool              is_read_write_allowed (void) const {return (m_dmi_access & DMI_ACCESS_READ_WRITE) == DMI_ACCESS_READ_WRITE;}
+
+  void              set_dmi_ptr           (unsigned char* p)   {m_dmi_ptr = p;}
+  void              set_start_address     (sc_dt::uint64 addr) {m_dmi_start_address = addr;}
+  void              set_end_address       (sc_dt::uint64 addr) {m_dmi_end_address = addr;}
+  void              set_read_latency      (sc_core::sc_time t) {m_dmi_read_latency = t;}
+  void              set_write_latency     (sc_core::sc_time t) {m_dmi_write_latency = t;}
+  void              set_granted_access    (dmi_access_e a)     {m_dmi_access = a;}
+  void              allow_none            (void)               {m_dmi_access = DMI_ACCESS_NONE;}
+  void              allow_read            (void)               {m_dmi_access = DMI_ACCESS_READ;}
+  void              allow_write           (void)               {m_dmi_access = DMI_ACCESS_WRITE;}
+  void              allow_read_write      (void)               {m_dmi_access = DMI_ACCESS_READ_WRITE;}
+
+  private:
+
+  // If the forward call is successful, the target returns the dmi_ptr,
+  // which must point to the data element corresponding to the
+  // dmi_start_address. The data is organized as a byte array with the
+  // endianness of the target (endianness member of the tlm_dmi struct).
+  
+  unsigned char*   m_dmi_ptr;
+  
+  // The absolute start and end addresses of the DMI region. If the decoder
+  // logic in the interconnect changes the address field e.g. by masking, the
+  // interconnect is responsible to transform the relative address back to an
+  // absolute address again.
+  
+  sc_dt::uint64    m_dmi_start_address;
+  sc_dt::uint64    m_dmi_end_address;
+
+  // Granted access
+  
+  dmi_access_e     m_dmi_access;
+
+  // These members define the latency of read/write transactions. The
+  // initiator must initialize these members to zero before requesting a
+  // dmi pointer, because both the interconnect as well as the target can
+  // add to the total transaction latency.
+  // Depending on the 'type' attribute only one, or both of these attributes
+  // will be valid.
+  
+  sc_core::sc_time m_dmi_read_latency;
+  sc_core::sc_time m_dmi_write_latency;
+};
+
+} // namespace tlm
+
+#endif /* TLM_DMI_HEADER */
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_2_interfaces/tlm_fw_bw_ifs.h b/ext/systemc/src/tlm_core/tlm_2/tlm_2_interfaces/tlm_fw_bw_ifs.h
new file mode 100644
index 000000000..59e81c658
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_2_interfaces/tlm_fw_bw_ifs.h
@@ -0,0 +1,223 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __TLM_FW_BW_IFS_H__
+#define __TLM_FW_BW_IFS_H__
+
+#include <systemc>
+#include "tlm_core/tlm_2/tlm_generic_payload/tlm_generic_payload.h"
+#include "tlm_core/tlm_2/tlm_2_interfaces/tlm_dmi.h"
+
+namespace tlm {
+
+enum tlm_sync_enum { TLM_ACCEPTED, TLM_UPDATED, TLM_COMPLETED };
+
+////////////////////////////////////////////////////////////////////////////
+// Basic interfaces
+////////////////////////////////////////////////////////////////////////////
+template <typename TRANS = tlm_generic_payload,
+          typename PHASE = tlm_phase>
+class tlm_fw_nonblocking_transport_if : public virtual sc_core::sc_interface {
+public:
+  virtual tlm_sync_enum nb_transport_fw(TRANS& trans,
+                                        PHASE& phase,
+                                        sc_core::sc_time& t) = 0;
+};
+
+template <typename TRANS = tlm_generic_payload,
+          typename PHASE = tlm_phase>
+class tlm_bw_nonblocking_transport_if : public virtual sc_core::sc_interface {
+public:
+  virtual tlm_sync_enum nb_transport_bw(TRANS& trans,
+                                        PHASE& phase,
+                                        sc_core::sc_time& t) = 0;
+};
+
+template <typename TRANS = tlm_generic_payload>
+class tlm_blocking_transport_if : public virtual sc_core::sc_interface {
+public:
+  virtual void b_transport(TRANS& trans,
+                           sc_core::sc_time& t) = 0;
+};
+
+//////////////////////////////////////////////////////////////////////////
+// DMI interfaces for getting and invalidating DMI pointers:
+//////////////////////////////////////////////////////////////////////////
+
+// The semantics of the forward interface are as follows:
+//
+// - An initiator that wants to get direct access to a target's memory region
+//   can call the get_direct_mem_ptr method with the 'trans' parameter set to
+//   the address that it wants to gain access to. It sets the trans.m_command
+//   to specify if the initiator intended use (read or write)
+//   to the target's DMI region. The initiator is responsible for calling the
+//   method with a freshly initialized tlm_dmi object either by using a newly
+//   constructed object, or by calling an existing object's init() method.
+// - Although a reference to a complete 'TRANS' type is passed to the get_
+//   direct_mem_ptr call, only the address command, and extension fields are of
+//   interest in most cases.
+// - Read and write ranges are not necessarily identical. If they are, a target
+//   can specify that the range is valid for all accesses with the tlm_data
+//   m_type attribute in the.
+// - The interconnect, if any, needs to decode the address and forward the
+//   call to the corresponding target. It needs to handle the address exactly
+//   as the target would expect on a transaction call, e.g. mask the address
+//   according to the target's address width.
+// - If the target supports DMI access for the given address, it sets the
+//   data fields in the DMI struct and returns true.
+// - If a target does not support DMI access it needs to return false.
+//   The target can either set the correct address range in the DMI struct
+//   to indicate the memory region where DMI is disallowed, or it can specify
+//   the complete address range if it doesn't know it's memory range. In this
+//   case the interconnect is responsible for clipping the address range to
+//   the correct range that the target serves.
+// - The interconnect must always translate the addresses to the initiator's
+//   address space. This must be the inverse operation of what the
+//   interconnect needed to do when forwarding the call. In case the
+//   component wants to change any member of the tlm_dmi object, e.g. for
+//   its own latency to the target's latency, it must only do so *after* the
+//   target has been called. The target is always allowed to overwrite all
+//   values in the tlm_dmi object.
+// - In case the slave returned with an invalid region the bus/interconnect
+//   must fill in the complete address region for the particular slave in the
+//   DMI data structure.
+//
+// DMI hint optimization:
+//
+// Initiators may use the DMI hint in the tlm_generic_payload to avoid
+// unnecessary DMI attempts. The recommended sequence of interface
+// method calls would be:
+//
+// - The initiator first tries to check if it has a valid DMI region for the
+//   address that it wants to access next.
+// - If not, it performs a normal transaction.
+// - If the DMI hint in this transaction is true, the initiator can try and
+//   get the DMI region.
+//
+// Note that the DMI hint optimization is completely optional and every
+// initiator model is free to ignore the DMI hint. However, a target is
+// required to set the DMI hint to true if a DMI request on the given address
+// with the given transaction type (read or write) would have succeeded.
+
+template <typename TRANS = tlm_generic_payload>
+class tlm_fw_direct_mem_if : public virtual sc_core::sc_interface
+{
+public:
+  virtual bool get_direct_mem_ptr(TRANS& trans,
+                                  tlm_dmi&  dmi_data) = 0;
+};
+
+// The semantics of the backwards call is as follows:
+//
+// - An interconnect component or a target is required to invalidate all
+//   affected DMI regions whenever any change in the regions take place.
+//   The exact rule is that a component must invalidate all those DMI regions
+//   that it already reported, if it would answer the same DMI request
+//   with any member of the tlm_dmi data structure set differently.
+// - An interconnect component must forward the invalidate_direct_mem_ptr call
+//   to all initiators that could potentially have a DMI pointer to the region
+//   specified in the method arguments. A safe implementation is to call
+//   every attached initiator.
+// - An interconnect component must transform the address region of an
+//   incoming invalidate_direct_mem_ptr to the corresponding address space
+//   for the initiators. Basically, this is the same address transformation
+//   that the interconnect does on the DMI ranges on the forward direction.
+// - Each initiator must check if it has a pointer to the given region and
+//   throw this away. It is recommended that the initiator throws away all DMI
+//   regions that have any overlap with the given regions, but this is not a
+//   hard requirement.
+//
+// - A full DMI pointer invalidation, e.g. for a bus remap can be signaled
+//   by setting the range: 0x0 - 0xffffffffffffffffull = (sc_dt::uint64)-1
+// - An initiator must throw away all DMI pointers in this case.
+//
+// - Under no circumstances a model is allowed to call the get_direct_mem_ptr
+//   from within the invalidate_direct_mem_ptr method, directly or indirectly.
+//
+class tlm_bw_direct_mem_if : public virtual sc_core::sc_interface
+{
+public:
+  virtual void invalidate_direct_mem_ptr(sc_dt::uint64 start_range,
+                                         sc_dt::uint64 end_range) = 0;
+};
+
+/////////////////////////////////////////////////////////////////////
+// debug interface for memory access
+/////////////////////////////////////////////////////////////////////
+//
+// This interface can be used to gain access to a targets memory or registers
+// in a non-intrusive manner. No side effects, waits or event notifications
+// must happen in the course of the method.
+//
+// Semantics:
+// - The initiator calls the transport_dbg method with transaction 'trans' as
+//   argument. The commonly used parts of trans for debug are:
+//   . address: The start address that it wants to peek or poke.
+//   . length:  The number of bytes that it requests to read or write.
+//   . command: Indicates a read or write access.
+//   . data:    A pointer to the initiator-allocated data buffer, which must
+//              be at least num_bytes large. The data is always organized in
+//              the endianness of the machine.
+//   . extensions: Any extension that could affect the transaction.
+// - The interconnect, if any, will decode the address and forward the call to
+//   the appropriate target.
+// - The target must return the number of successfully transmitted bytes, where
+//   this number must be <= num_bytes. Thus, a target can safely return 0 if it
+//   does not support debug transactions.
+//
+template <typename TRANS = tlm_generic_payload>
+class tlm_transport_dbg_if : public virtual sc_core::sc_interface
+{
+public:
+  // The return value of defines the number of bytes successfully
+  // transferred.
+  virtual unsigned int transport_dbg(TRANS& trans) = 0;
+};
+
+////////////////////////////////////////////////////////////////////////////
+// Combined interfaces
+////////////////////////////////////////////////////////////////////////////
+
+struct tlm_base_protocol_types
+{
+  typedef tlm_generic_payload tlm_payload_type;
+  typedef tlm_phase tlm_phase_type;
+};
+
+// The forward interface:
+template <typename TYPES = tlm_base_protocol_types>
+class tlm_fw_transport_if
+  : public virtual tlm_fw_nonblocking_transport_if<typename TYPES::tlm_payload_type,
+                                                   typename TYPES::tlm_phase_type>
+  , public virtual tlm_blocking_transport_if<typename TYPES::tlm_payload_type>
+  , public virtual tlm_fw_direct_mem_if<typename TYPES::tlm_payload_type>
+  , public virtual tlm_transport_dbg_if<typename TYPES::tlm_payload_type>
+{};
+
+// The backward interface:
+template <typename TYPES = tlm_base_protocol_types>
+class tlm_bw_transport_if
+  : public virtual tlm_bw_nonblocking_transport_if<typename TYPES::tlm_payload_type,
+                                                   typename TYPES::tlm_phase_type>
+  , public virtual tlm_bw_direct_mem_if
+{};
+
+} // namespace tlm
+
+#endif /* __TLM_FW_BW_IFS_H__ */
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_array.h b/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_array.h
new file mode 100644
index 000000000..297dd3fe4
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_array.h
@@ -0,0 +1,125 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __TLM_ARRAY_H__
+#define __TLM_ARRAY_H__
+
+#include <systemc>
+#include <exception>
+// unused for the time being: #include <cassert>
+
+namespace tlm {
+
+//
+// To the LRM writer: the below class is an artifact of the tlm_generic_payload
+//                    implementation and not part of the core TLM standard
+//
+
+
+// This implements a lean and fast array class that supports array expansion on
+// request. The class is primarily used in the tlm_generic_payload class for
+// storing the pointers to the extensions.
+//
+// Individual array elements can be accessed through the [] operators, and the
+// array length is returned by the size() method.
+//
+// The size can be dynamically expanded using the expand(uint) method. There
+// is no shrinking mechanism implemented, because the extension mechanism
+// does not require this feature. Bear in mind that calling the expand method
+// may invalidate all direct pointers into the array.
+
+
+//the tlm_array shall always be used with T=tlm_extension_base*
+template <typename T>
+class tlm_array
+  : private std::vector<T>
+{
+    typedef std::vector<T>                base_type;
+    typedef typename base_type::size_type size_type;
+public:
+
+    // constructor:
+    tlm_array(size_type size = 0, T const & default_value = T() )
+        : base_type(size,default_value)
+        , m_entries()
+        , m_default(default_value)
+    {
+        //m_entries.reserve(size); // optional
+    }
+
+    // copy constructor:
+    // tlm_array(const tlm_array& orig) = default;
+
+    // destructor:
+    // ~tlm_array() = default;
+
+    // operators for dereferencing:
+    using base_type::operator[];
+
+    // array size:
+    using base_type::size;
+
+    // expand the array if needed:
+    void expand(size_type new_size)
+    {
+        if (new_size > size())
+        {
+            base_type::resize(new_size);
+            //m_entries.reserve(new_size); // optional
+        }
+    }
+
+    static const char* const kind_string;
+    const char* kind() const { return kind_string; }
+
+    //this function shall get a pointer to a array slot
+    // it stores this slot in a cache of active slots
+    void insert_in_cache(T* p)
+    {
+        //assert( (p-&(*this)[0]) < size() );
+        m_entries.push_back( p-&(*this)[0] );
+    }
+
+    //this functions clears all active slots of the array
+    void free_entire_cache()
+    {
+        while(m_entries.size())
+        {
+            if ((*this)[m_entries.back()])      //we make sure no one cleared the slot manually
+              (*this)[m_entries.back()]->free();//...and then we call free on the content of the slot
+            (*this)[m_entries.back()]=0;        //afterwards we set the slot to NULL
+            m_entries.pop_back();
+        }
+    }
+
+protected:
+    std::vector<size_type> m_entries;
+    T m_default;
+
+    // disabled:
+    tlm_array& operator=(const tlm_array<T>&);
+};
+
+
+template <typename T>
+const char* const tlm_array<T>::kind_string = "tlm_array";
+
+} // namespace tlm
+
+#endif /* __TLM_ARRAY_H__ */
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_endian_conv.h b/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_endian_conv.h
new file mode 100644
index 000000000..648115554
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_endian_conv.h
@@ -0,0 +1,792 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+
+#ifndef __TLM_ENDIAN_CONV_H__
+#define __TLM_ENDIAN_CONV_H__
+
+#include <systemc>
+#include "tlm_core/tlm_2/tlm_generic_payload/tlm_gp.h"
+
+
+namespace tlm {
+
+
+/*
+Tranaction-Level Modelling
+Endianness Helper Functions
+
+DESCRIPTION
+A set of functions for helping users to get the endianness
+right in their TLM models of system initiators.  These functions are
+for use within an initiator.  They can not be used as-is outside
+an initiator because the extension used to store context will not work
+if cascaded, and they do not respect the generic payload mutability
+rules.  However this code may be easily copied and adapted for use
+in bridges, etc..
+
+These functions are not compulsory.  There are other legitimate ways to
+achieve the same functionality.  If extra information is available at
+compile time about the nature of an initiator's transactions, this can
+be exploited to accelerate simulations by creating further functions
+similar to those in this file.  In general a functional transaction can be
+described in more than one way by a TLM-2 GP object.
+
+The functions convert the endianness of a GP object, either on request or
+response.  They should only be used when the initiator's endianness
+does not match the host's endianness.  They assume 'arithmetic mode'
+meaning that within a data word the byte order is always host-endian.
+For non-arithmetic mode initiators they can be used with a data word
+size of 1 byte.
+
+All the functions are templates, for example:
+
+template<class DATAWORD> inline void
+  to_hostendian_generic(tlm_generic_payload *txn, int sizeof_databus)
+
+The template parameter provides the data word width.  Having this as a class
+makes it easy to use it for copy and swap operations within the functions.
+If the assignment operator for this class is overloaded, the endianness
+conversion function may not have the desired effect.
+
+All the functions have the same signature except for different names.
+
+The principle is that a function to_hostendian_convtype() is called when the
+initiator-endian transaction is created, and the matching function
+from_hostendian_convtype() is called when the transaction is completed, for
+example before read data can be used.  In some cases the from_ function is
+redundant but an empty function is provided anyway.  It is strongly
+recommended that the from_ function is called, in case it ceases to be
+redundant in future versions of this code.
+
+No context needs to be managed outside the two functions, except that they
+must be called with the same template parameter and the same bus width.
+
+For initiator models that can not easily manage this context information,
+a single entry point for the from_ function is provided, which will be
+a little slower than calling the correct from_ function directly, as
+it can not be inlined.
+
+All functions assume power-of-2 bus and data word widths.
+
+Functions offered:
+
+0) A pair of functions that work for almost all TLM2 GP transactions.  The
+only limitations are that data and bus widths should be powers of 2, and that
+the data length should be an integer number of streaming widths and that the
+streaming width should be an integer number of data words.
+These functions always allocate new data and byte enable buffers and copy
+data one byte at a time.
+  tlm_to_hostendian_generic(tlm_generic_payload *txn, int sizeof_databus)
+  tlm_from_hostendian_generic(tlm_generic_payload *txn, int sizeof_databus)
+
+1) A pair of functions that work for all transactions regardless of data and
+bus data sizes and address alignment except for the the following
+limitations:
+- byte-enables are supported only when byte-enable granularity is no finer
+than the data word (every data word is wholly enabled or wholly disabled)
+- byte-enable-length is not supported (if byte enables are present, the byte
+enable length must be equal to the data length).
+- streaming width is not supported
+- data word wider than bus word is not supported
+A new data buffer and a new byte enable buffer are always allocated.  Byte
+enables are assumed to be needed even if not required for the original
+(unconverted) transaction.  Data is copied to the new buffer on request
+(for writes) or on response (for reads).  Copies are done word-by-word
+where possible.
+  tlm_to_hostendian_word(tlm_generic_payload *txn, int sizeof_databus)
+  tlm_from_hostendian_word(tlm_generic_payload *txn, int sizeof_databus)
+
+2) If the original transaction is both word and bus-aligned then this pair of
+functions can be used.  It will complete faster than the generic function
+because the data reordering function is much simpler and no address
+conversion is required.
+The following limitations apply:
+- byte-enables are supported only when byte-enable granularity is no finer
+than the data word (every data word is wholly enabled or wholly disabled)
+- byte-enable-length is not supported (if byte enables are present, the byte
+enable length must be equal to the data length).
+- streaming width is not supported
+- data word wider than bus word is not supported
+- the transaction must be an integer number of bus words
+- the address must be aligned to the bus width
+  tlm_to_hostendian_aligned(tlm_generic_payload *txn, int sizeof_databus)
+  tlm_from_hostendian_aligned(tlm_generic_payload *txn, int sizeof_databus)
+
+3) For single word transactions that don't cross a bus word boundary it
+is always safe to work in-place and the conversion is very simple.  Again,
+streaming width and byte-enable length are not supported, and byte-enables
+may not changes within a data word.
+  tlm_to_hostendian_single(tlm_generic_payload *txn, int sizeof_databus)
+  tlm_from_hostendian_single(tlm_generic_payload *txn, int sizeof_databus)
+
+4) A single entry point for accessing the correct from_ function without
+needing to store context.
+  tlm_from_hostendian(tlm_generic_payload *txn)
+*/
+
+
+
+#ifndef uchar
+#define uchar unsigned char
+#else
+#define TLM_END_CONV_DONT_UNDEF_UCHAR
+#endif
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Generic Utilities
+
+class tlm_endian_context;
+class tlm_endian_context_pool {
+  public:
+    tlm_endian_context *first;
+    inline tlm_endian_context_pool();
+    inline ~tlm_endian_context_pool();
+    inline tlm_endian_context *pop();
+    inline void push(tlm_endian_context *c);
+};
+static tlm_endian_context_pool global_tlm_endian_context_pool;
+
+// an extension to keep the information needed for reconversion of response
+class tlm_endian_context : public tlm_extension<tlm_endian_context> {
+  public:
+    tlm_endian_context() : dbuf_size(0), bebuf_size(0) {}
+    ~tlm_endian_context() {
+      if(dbuf_size > 0) delete [] new_dbuf;
+      if(bebuf_size > 0) delete [] new_bebuf;
+    }
+
+    sc_dt::uint64 address;     // used by generic, word
+    sc_dt::uint64 new_address;     // used by generic
+    uchar *data_ptr;     // used by generic, word, aligned
+    uchar *byte_enable;  // used by word
+    int length;         // used by generic, word
+    int stream_width;   // used by generic
+
+    // used by common entry point on response
+    void (*from_f)(tlm_generic_payload *txn, unsigned int sizeof_databus);
+    int sizeof_databus;
+
+    // reordering buffers for data and byte-enables
+    uchar *new_dbuf, *new_bebuf;
+    int dbuf_size, bebuf_size;
+    void establish_dbuf(int len) {
+      if(len <= dbuf_size) return;
+      if(dbuf_size > 0) delete [] new_dbuf;
+      new_dbuf = new uchar[len];
+      dbuf_size = len;
+    }
+    void establish_bebuf(int len) {
+      if(len <= bebuf_size) return;
+      if(bebuf_size > 0) delete [] new_bebuf;
+      new_bebuf = new uchar[len];
+      bebuf_size = len;
+    }
+
+    // required for extension management
+    void free() {
+      global_tlm_endian_context_pool.push(this);
+    }
+    tlm_extension_base* clone() const {return 0;}
+    void copy_from(tlm_extension_base const &) {return;}
+
+    // for pooling
+    tlm_endian_context *next;
+};
+// Assumptions about transaction contexts:
+// 1) only the address attribute of a transaction
+// is mutable.  all other attributes are unchanged from the request to
+// response side conversion.
+// 2) the conversion functions in this file do not respect the mutability
+// rules and do not put the transaction back into its original state after
+// completion.  so if the initiator has any cleaning up to do (eg of byte
+// enable buffers), it needs to store its own context.  the transaction
+// returned to the initiator may contain pointers to data and byte enable
+// that can/must not be deleted.
+// 3) the conversion functions in this file use an extension to store
+// context information.  they do not remove this extension.  the initiator
+// should not remove it unless it deletes the generic payload
+// object.
+
+inline tlm_endian_context *establish_context(tlm_generic_payload *txn) {
+  tlm_endian_context *tc = txn->get_extension<tlm_endian_context>();
+  if(tc == 0) {
+    tc = global_tlm_endian_context_pool.pop();
+    txn->set_extension(tc);
+  }
+  return tc;
+}
+
+inline tlm_endian_context_pool::tlm_endian_context_pool() : first(0) {}
+
+inline tlm_endian_context_pool::~tlm_endian_context_pool() {
+  while(first != 0) {
+    tlm_endian_context *next = first->next;
+    delete first;
+    first = next;
+  }
+}
+
+tlm_endian_context *tlm_endian_context_pool::pop() {
+  if(first == 0) return new tlm_endian_context;
+  tlm_endian_context *r = first;
+  first = first->next;
+  return r;
+}
+
+void tlm_endian_context_pool::push(tlm_endian_context *c) {
+  c->next = first;
+  first = c;
+}
+
+
+// a set of constants for efficient filling of byte enables
+template<class D> class tlm_bool {
+  public:
+    static D TLM_TRUE;
+    static D TLM_FALSE;
+    static D make_uchar_array(uchar c) {
+      D d;
+      uchar *tmp = (uchar *)(&d);
+      for(ptrdiff_t i=0; i!=sizeof(D); i++) tmp[i] = c;  // 64BITFIX negligable risk but easy fix //
+      return d;
+    }
+    // also provides an syntax-efficient tester, using a
+    // copy constuctor and an implicit cast to boolean
+    tlm_bool(D &d) : b(*((uchar*)&d) != TLM_BYTE_DISABLED) {}
+    operator bool() const {return b;}
+  private:
+    bool b;
+};
+
+template<class D> D tlm_bool<D>::TLM_TRUE
+  = tlm_bool<D>::make_uchar_array(TLM_BYTE_ENABLED);
+template<class D> D tlm_bool<D>::TLM_FALSE
+  = tlm_bool<D>::make_uchar_array(TLM_BYTE_DISABLED);
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+// function set (0): Utilities
+inline void copy_db0(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
+  *dest1 = *src1;
+  *dest2 = *src2;
+}
+
+inline void copy_dbtrue0(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
+  *dest1 = *src1;
+  *dest2 = TLM_BYTE_ENABLED;
+}
+
+inline void copy_btrue0(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
+  *dest2 = TLM_BYTE_ENABLED;
+}
+
+inline void copy_b0(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
+  *dest2 = *src2;
+}
+
+inline void copy_dbyb0(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
+  if(*dest2 == TLM_BYTE_ENABLED) *src1 = *dest1;
+}
+
+
+template<class D,
+  void COPY(uchar *he_d, uchar *he_b, uchar *ie_d, uchar *ie_b)>
+inline void loop_generic0(int new_len, int new_stream_width,
+  int orig_stream_width, int sizeof_databus,
+  sc_dt::uint64 orig_start_address, sc_dt::uint64 new_start_address, int be_length,
+  uchar *ie_data, uchar *ie_be, uchar *he_data, uchar *he_be) {
+
+  for(int orig_sword = 0, new_sword = 0; new_sword < new_len;
+      new_sword += new_stream_width, orig_sword += orig_stream_width) {
+
+    sc_dt::uint64 ie_addr = orig_start_address;
+    for(int orig_dword = orig_sword;
+      orig_dword < orig_sword + orig_stream_width; orig_dword += sizeof(D)) {
+
+      for(int curr_byte = orig_dword + sizeof(D) - 1;
+          curr_byte >= orig_dword; curr_byte--) {
+
+        ptrdiff_t he_index = ((ie_addr++) ^ (sizeof_databus - 1))
+          - new_start_address + new_sword;  // 64BITFIX //
+        COPY(ie_data+curr_byte,
+             ie_be+(curr_byte % be_length),  // 64BITRISK no risk of overflow, always positive //
+             he_data+he_index, he_be+he_index);
+      }
+    }
+  }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// function set (0): Response
+template<class DATAWORD> inline void
+tlm_from_hostendian_generic(tlm_generic_payload *txn, unsigned int sizeof_databus) {
+  if(txn->is_read()) {
+    tlm_endian_context *tc = txn->template get_extension<tlm_endian_context>();
+    loop_generic0<DATAWORD, &copy_dbyb0>(txn->get_data_length(),
+      txn->get_streaming_width(), tc->stream_width, sizeof_databus, tc->address,
+      tc->new_address, txn->get_data_length(), tc->data_ptr, 0, txn->get_data_ptr(),
+      txn->get_byte_enable_ptr());
+  }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// function set (0): Request
+template<class DATAWORD> inline void
+tlm_to_hostendian_generic(tlm_generic_payload *txn, unsigned int sizeof_databus) {
+  tlm_endian_context *tc = establish_context(txn);
+  tc->from_f = &(tlm_from_hostendian_generic<DATAWORD>);
+  tc->sizeof_databus = sizeof_databus;
+
+  // calculate new size:  nr stream words multiplied by big enough stream width
+  int s_width = txn->get_streaming_width();
+  int length = txn->get_data_length();
+  if(s_width >= length) s_width = length;
+  int nr_stream_words = length/s_width;
+
+  // find out in which bus word the stream word starts and ends
+  sc_dt::uint64 new_address = (txn->get_address() & ~(sizeof_databus - 1));
+  sc_dt::uint64 end_address = ((txn->get_address() + s_width - 1)
+    & ~(sizeof_databus - 1));
+
+  int new_stream_width = end_address - new_address + sizeof_databus;
+  int new_length = new_stream_width * nr_stream_words;
+
+  // store context
+  tc->data_ptr = txn->get_data_ptr();
+  tc->address = txn->get_address();
+  tc->new_address = new_address;
+  tc->stream_width = s_width;
+  uchar *orig_be = txn->get_byte_enable_ptr();
+  int orig_be_length = txn->get_byte_enable_length();
+
+  // create data and byte-enable buffers
+  txn->set_address(new_address);
+  tc->establish_dbuf(new_length);
+  txn->set_data_ptr(tc->new_dbuf);
+  tc->establish_bebuf(new_length);
+  txn->set_byte_enable_ptr(tc->new_bebuf);
+  memset(txn->get_byte_enable_ptr(), TLM_BYTE_DISABLED, new_length);
+  txn->set_streaming_width(new_stream_width);
+  txn->set_data_length(new_length);
+  txn->set_byte_enable_length(new_length);
+
+  // copy data and/or byte enables
+  if(txn->is_write()) {
+    if(orig_be == 0) {
+      loop_generic0<DATAWORD, &copy_dbtrue0>(new_length,
+        new_stream_width, s_width, sizeof_databus, tc->address,
+        new_address, new_length, tc->data_ptr, 0, txn->get_data_ptr(),
+        txn->get_byte_enable_ptr());
+    } else {
+      loop_generic0<DATAWORD, &copy_db0>(new_length,
+        new_stream_width, s_width, sizeof_databus, tc->address,
+        new_address, orig_be_length, tc->data_ptr, orig_be, txn->get_data_ptr(),
+        txn->get_byte_enable_ptr());
+    }
+  } else { // read transaction
+    if(orig_be == 0) {
+      loop_generic0<DATAWORD, &copy_btrue0>(new_length,
+        new_stream_width, s_width, sizeof_databus, tc->address,
+        new_address, new_length, tc->data_ptr, 0, txn->get_data_ptr(),
+        txn->get_byte_enable_ptr());
+    } else {
+      loop_generic0<DATAWORD, &copy_b0>(new_length,
+        new_stream_width, s_width, sizeof_databus, tc->address,
+        new_address, orig_be_length, tc->data_ptr, orig_be, txn->get_data_ptr(),
+        txn->get_byte_enable_ptr());
+    }
+  }
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+// function set (1): Utilities
+template<class D>
+inline void copy_d1(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
+  *((D *)dest1) = *((D *)src1);
+  *((D *)dest2) = tlm_bool<D>::TLM_TRUE;
+}
+
+template<class D>
+inline void copy_db1(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
+  *((D *)dest1) = *((D *)src1);
+  *((D *)dest2) = *((D *)src2);
+}
+
+template<class D>
+inline void true_b1(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
+  *((D *)dest2) = tlm_bool<D>::TLM_TRUE;
+}
+
+template<class D>
+inline void copy_b1(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
+  *((D *)dest2) = *((D *)src2);
+}
+
+template<class D>
+inline void copy_dbyb1(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
+  if(*src2 != TLM_BYTE_DISABLED)  *((D *)src1) = *((D *)dest1);
+}
+
+template<class D>
+inline void copy_dbytrue1(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
+  *((D *)src1) = *((D *)dest1);
+}
+
+template<class D> inline void false_b1(uchar *dest1) {
+  *((D *)dest1) = tlm_bool<D>::TLM_FALSE;
+}
+
+template<class D> inline void no_b1(uchar *dest1) {
+}
+
+template<class D,
+         void COPY(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2),
+         void COPYuchar(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2),
+         void FILLFALSE(uchar *dest1), void FILLFALSEuchar(uchar *dest1)>
+inline int loop_word1(
+  int bytes_left, int len0, int lenN, int sizeof_databus,
+  uchar *start, uchar *end, uchar *src, uchar *bsrc, uchar *dest, uchar *bdest) {
+  ptrdiff_t d2b_src = bsrc - src;  // 64BITFIX was int //
+  ptrdiff_t d2b_dest = bdest - dest;  // 64BITFIX was int //
+  uchar *original_dest = dest;
+
+  while(true) {
+    // len0 bytes at start of a bus word
+    if((src >= start) && (src < end)) {
+      for(int i=0; i<len0; i++) {
+        COPYuchar(src, src+d2b_src, dest, dest+d2b_dest);
+        src++;
+        dest++;
+      }
+      bytes_left -= len0;
+      if(bytes_left <= 0) return int(dest - original_dest);
+    } else {
+      for(int i=0; i<len0; i++) {
+        FILLFALSEuchar(dest+d2b_dest);
+        src++;
+        dest++;
+      }
+    }
+    src -= 2 * sizeof(D);
+
+    // sequence of full data word fragments
+    for(unsigned int i=1; i<sizeof_databus/sizeof(D); i++) {
+      if((src >= start) && (src < end)) {
+        COPY(src, src+d2b_src, dest, dest+d2b_dest);
+        bytes_left -= sizeof(D);
+      } else {
+        FILLFALSE(dest+d2b_dest);
+      }
+      dest += sizeof(D);
+      if(bytes_left <= 0) return int(dest - original_dest);
+      src -= sizeof(D);
+    }
+
+    // lenN bytes at end of bus word
+    if((src >= start) && (src < end)) {
+      for(int i=0; i<lenN; i++) {
+        COPYuchar(src, src+d2b_src, dest, dest+d2b_dest);
+        src++;
+        dest++;
+      }
+      bytes_left -= lenN;
+      if(bytes_left <= 0) return int(dest - original_dest);
+    } else {
+      for(int i=0; i<lenN; i++) {
+        FILLFALSEuchar(dest+d2b_dest);
+        src++;
+        dest++;
+      }
+    }
+    src += 2 * sizeof_databus;
+  }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// function set (1): Response
+template<class DATAWORD> inline void
+tlm_from_hostendian_word(tlm_generic_payload *txn, unsigned int sizeof_databus) {
+  if(txn->is_read()) {
+    tlm_endian_context *tc = txn->template get_extension<tlm_endian_context>();
+    sc_dt::uint64 b_mask = sizeof_databus - 1;
+    int d_mask = sizeof(DATAWORD) - 1;
+    int a_offset = static_cast<int>(tc->address & b_mask);
+    int len0 = (sizeof_databus - a_offset) & d_mask;
+    int lenN = sizeof(DATAWORD) - len0;
+    uchar *d_start = tc->data_ptr;
+    uchar *d_end = ptrdiff_t(tc->length) + d_start;  // 64BITFIX probably redundant //
+    uchar *d = ptrdiff_t(((sizeof_databus - a_offset) & ~d_mask) + lenN) + d_start;  // 64BITFIX probably redundant //
+
+    // iterate over transaction copying data qualified by byte-enables
+    if(tc->byte_enable == 0) {
+      loop_word1<DATAWORD, &copy_dbytrue1<DATAWORD>,
+        &copy_dbytrue1<uchar>, &no_b1<DATAWORD>, &no_b1<uchar> >(
+        tc->length, len0, lenN, sizeof_databus, d_start, d_end, d,
+        0, txn->get_data_ptr(), 0);
+    } else {
+      loop_word1<DATAWORD, &copy_dbyb1<DATAWORD>,
+        &copy_dbyb1<uchar>, &no_b1<DATAWORD>, &no_b1<uchar> >(
+        tc->length, len0, lenN, sizeof_databus, d_start, d_end, d,
+        tc->byte_enable - d_start + d, txn->get_data_ptr(), 0);
+    }
+  }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// function set (1): Request
+template<class DATAWORD> inline void
+tlm_to_hostendian_word(tlm_generic_payload *txn, unsigned int sizeof_databus) {
+  tlm_endian_context *tc = establish_context(txn);
+  tc->from_f = &(tlm_from_hostendian_word<DATAWORD>);
+  tc->sizeof_databus = sizeof_databus;
+
+  sc_dt::uint64 b_mask = sizeof_databus - 1;
+  int d_mask = sizeof(DATAWORD) - 1;
+  sc_dt::uint64 a_aligned = txn->get_address() & ~b_mask;
+  int a_offset = static_cast<int>(txn->get_address() & b_mask);
+  int len0 = (sizeof_databus - a_offset) & d_mask;
+  int lenN = sizeof(DATAWORD) - len0;
+  uchar *d_start = txn->get_data_ptr();
+  uchar *d_end = ptrdiff_t(txn->get_data_length()) + d_start;  // 64BITFIX probably redundant //
+  uchar *d = ptrdiff_t(((sizeof_databus - a_offset) & ~d_mask) + lenN) + d_start;  // 64BITFIX probably redundant //
+
+  // create new data and byte enable buffers
+  int long_enough = txn->get_data_length() + 2 * sizeof_databus;
+  tc->establish_dbuf(long_enough);
+  uchar *new_data = tc->new_dbuf;
+  tc->establish_bebuf(long_enough);
+  uchar *new_be = tc->new_bebuf;
+
+  if(txn->is_read()) {
+    tc->data_ptr = d_start;
+    tc->address = txn->get_address();
+    tc->byte_enable = txn->get_byte_enable_ptr();
+    tc->length = txn->get_data_length();
+    if(txn->get_byte_enable_ptr() == 0) {
+      // iterate over transaction creating new byte enables from all-true
+      txn->set_data_length(loop_word1<DATAWORD, &true_b1<DATAWORD>,
+        &true_b1<uchar>, &false_b1<DATAWORD>, &false_b1<uchar> >(
+        txn->get_data_length(), len0, lenN, sizeof_databus,
+        d_start, d_end, d, 0, new_data, new_be));
+    } else {
+      // iterate over transaction copying byte enables
+      txn->set_data_length(loop_word1<DATAWORD, &copy_b1<DATAWORD>,
+        &copy_b1<uchar>, &false_b1<DATAWORD>, &false_b1<uchar> >(
+        txn->get_data_length(), len0, lenN, sizeof_databus, d_start, d_end,
+        d, txn->get_byte_enable_ptr() - d_start + d, new_data, new_be));
+    }
+  } else {
+    // WRITE
+    if(txn->get_byte_enable_ptr() == 0) {
+      // iterate over transaction copying data and creating new byte-enables
+      txn->set_data_length(loop_word1<DATAWORD, &copy_d1<DATAWORD>,
+        &copy_d1<uchar>, &false_b1<DATAWORD>, &false_b1<uchar> >(
+        txn->get_data_length(), len0, lenN, sizeof_databus,
+        d_start, d_end, d, 0, new_data, new_be));
+    } else {
+      // iterate over transaction copying data and byte-enables
+      txn->set_data_length(loop_word1<DATAWORD, &copy_db1<DATAWORD>,
+        &copy_db1<uchar>, &false_b1<DATAWORD>, &false_b1<uchar> >(
+        txn->get_data_length(), len0, lenN, sizeof_databus, d_start, d_end,
+        d, txn->get_byte_enable_ptr() - d_start + d, new_data, new_be));
+    }
+  }
+  txn->set_byte_enable_length(txn->get_data_length());
+  txn->set_streaming_width(txn->get_data_length());
+  txn->set_data_ptr(new_data);
+  txn->set_byte_enable_ptr(new_be);
+  txn->set_address(a_aligned);
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+// function set (2): Utilities
+template<class D> inline void copy_d2(D *src1, D *src2, D *dest1, D *dest2) {
+  *dest1 = *src1;
+}
+
+template<class D> inline void copy_db2(D *src1, D *src2, D *dest1, D *dest2) {
+  *dest1 = *src1;
+  *dest2 = *src2;
+}
+
+template<class D>
+inline void copy_dbyb2(D *src1, D *src2, D *dest1, D *dest2) {
+  if(tlm_bool<D>(*src2)) *dest1 = *src1;
+}
+
+template<class D, void COPY(D *src1, D *src2, D *dest1, D *dest2)>
+inline void loop_aligned2(D *src1, D *src2, D *dest1, D *dest2,
+    int words, int words_per_bus) {
+  ptrdiff_t src1to2 = (char *)src2 - (char *)src1;  // 64BITFIX was int and operands were cast to int //
+  ptrdiff_t dest1to2 = (char *)dest2 - (char *)dest1;  // 64BITFIX was int and operands were cast to int //
+
+  D *done = src1 + ptrdiff_t(words);  // 64BITFIX //
+  D *bus_start = src1;
+  src1 += ptrdiff_t(words_per_bus - 1);  // 64BITFIX //
+
+  while(true) {
+    COPY(src1, (D *)(src1to2+(char *)src1), dest1, (D *)(dest1to2+(char *)dest1));   // 64BITFIX //
+    dest1++;
+    if((--src1) < bus_start) {
+      bus_start += ptrdiff_t(words_per_bus);  // 64BITFIX //
+      if(bus_start == done) break;
+      src1 = bus_start + ptrdiff_t(words_per_bus - 1);  // 64BITFIX //
+    }
+  }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// function set (2): Response
+template<class DATAWORD> inline void
+tlm_from_hostendian_aligned(tlm_generic_payload *txn, unsigned int sizeof_databus) {
+  int words_per_bus = sizeof_databus/sizeof(DATAWORD);
+  if(words_per_bus == 1) return;
+  int words = (txn->get_data_length())/sizeof(DATAWORD);
+  tlm_endian_context *tc = txn->template get_extension<tlm_endian_context>();
+
+  if(txn->get_byte_enable_ptr() == 0) {
+    // no byte enables
+    if(txn->is_read()) {
+      // RD without byte enables.  Copy data to original buffer
+      loop_aligned2<DATAWORD, &copy_d2<DATAWORD> >(
+        (DATAWORD *)(txn->get_data_ptr()),
+        0, (DATAWORD *)(tc->data_ptr), 0, words, words_per_bus);
+    }
+  } else {
+    // byte enables present
+    if(txn->is_read()) {
+      // RD with byte enables.  Copy data qualified by byte-enables
+      loop_aligned2<DATAWORD, &copy_dbyb2<DATAWORD> >(
+        (DATAWORD *)(txn->get_data_ptr()),
+        (DATAWORD *)(txn->get_byte_enable_ptr()),
+        (DATAWORD *)(tc->data_ptr), 0, words, words_per_bus);
+    }
+  }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// function set (2): Request
+template<class DATAWORD> inline void
+tlm_to_hostendian_aligned(tlm_generic_payload *txn, unsigned int sizeof_databus) {
+  tlm_endian_context *tc = establish_context(txn);
+  tc->from_f = &(tlm_from_hostendian_aligned<DATAWORD>);
+  tc->sizeof_databus = sizeof_databus;
+
+  int words_per_bus = sizeof_databus/sizeof(DATAWORD);
+  if(words_per_bus == 1) return;
+  int words = (txn->get_data_length())/sizeof(DATAWORD);
+
+  DATAWORD *original_be = (DATAWORD *)(txn->get_byte_enable_ptr());
+  DATAWORD *original_data = (DATAWORD *)(txn->get_data_ptr());
+
+  // always allocate a new data buffer
+  tc->establish_dbuf(txn->get_data_length());
+  txn->set_data_ptr(tc->new_dbuf);
+
+  if(original_be == 0) {
+    // no byte enables
+    if(txn->is_write()) {
+      // WR no byte enables.  Copy data
+      loop_aligned2<DATAWORD, &copy_d2<DATAWORD> >(original_data, 0,
+        (DATAWORD *)(txn->get_data_ptr()), 0,
+        words, words_per_bus);
+    } else {
+      // RD no byte enables.  Save original data pointer
+      tc->data_ptr = (uchar *)original_data;
+    }
+  } else {
+    // byte enables present
+    // allocate a new buffer for them
+    tc->establish_bebuf(txn->get_data_length());
+    txn->set_byte_enable_ptr(tc->new_bebuf);
+    txn->set_byte_enable_length(txn->get_data_length());
+
+    if(txn->is_write()) {
+      // WR with byte enables.  Copy data and BEs
+      loop_aligned2<DATAWORD, &copy_db2<DATAWORD> >(original_data, original_be,
+        (DATAWORD *)(txn->get_data_ptr()),
+        (DATAWORD *)(txn->get_byte_enable_ptr()), words, words_per_bus);
+    } else {
+      // RD with byte enables.  Save original data pointer
+      tc->data_ptr = (uchar *)original_data;
+      // Copy byte enables to new buffer
+      loop_aligned2<DATAWORD, &copy_d2<DATAWORD> >(original_be, 0,
+        (DATAWORD *)(txn->get_byte_enable_ptr()), 0,
+        words, words_per_bus);
+    }
+  }
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+// function set (3): Response
+template<class DATAWORD> inline void
+tlm_from_hostendian_single(tlm_generic_payload *txn, unsigned int sizeof_databus) {
+  // nothing needs to be done here
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// function set (3): Request
+template<class DATAWORD> inline void
+tlm_to_hostendian_single(tlm_generic_payload *txn, unsigned int sizeof_databus) {
+  tlm_endian_context *tc = establish_context(txn);
+  tc->from_f = &(tlm_from_hostendian_single<DATAWORD>);
+  tc->sizeof_databus = sizeof_databus;
+
+  // only need to change the address, always safe to work in-place
+  sc_dt::uint64 mask = sizeof_databus-1;
+  sc_dt::uint64 a = txn->get_address();
+  txn->set_address((a & ~mask) |
+    (sizeof_databus - (a & mask) - sizeof(DATAWORD)));
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+// helper function which works for all responses
+inline void tlm_from_hostendian(tlm_generic_payload *txn) {
+  tlm_endian_context *tc = txn->get_extension<tlm_endian_context>();
+  (*(tc->from_f))(txn, tc->sizeof_databus);
+}
+
+
+#ifndef TLM_END_CONV_DONT_UNDEF_UCHAR
+#undef uchar
+#endif
+
+}  // namespace tlm
+
+
+#endif  // multiple-inclusion protection
+
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_generic_payload.h b/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_generic_payload.h
new file mode 100644
index 000000000..3e25e56f2
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_generic_payload.h
@@ -0,0 +1,29 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __TLM_GENERIC_PAYLOAD_H__
+#define __TLM_GENERIC_PAYLOAD_H__
+
+#include "tlm_core/tlm_2/tlm_generic_payload/tlm_helpers.h"
+#include "tlm_core/tlm_2/tlm_generic_payload/tlm_phase.h"
+#include "tlm_core/tlm_2/tlm_generic_payload/tlm_gp.h"
+#include "tlm_core/tlm_2/tlm_generic_payload/tlm_endian_conv.h"
+
+#endif
+
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_gp.h b/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_gp.h
new file mode 100644
index 000000000..965e059ab
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_gp.h
@@ -0,0 +1,642 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+// 12-Jan-2009  John Aynsley  Bug fix. has_mm() and get_ref_count() should both be const
+// 23-Mar-2009  John Aynsley  Add method update_original_from()
+// 20-Apr-2009  John Aynsley  Bug fix for 64-bit machines: unsigned long int -> unsigned int
+//  5-May-2011  JA and Philipp Hartmann  Add tlm_gp_option, set_gp_option, get_gp_option
+// 11-May-2011  John Aynsley  Add run-time check to release()
+
+
+#ifndef __TLM_GP_H__
+#define __TLM_GP_H__
+
+#include <systemc>
+#include "tlm_core/tlm_2/tlm_generic_payload/tlm_array.h"
+
+namespace tlm {
+
+class
+tlm_generic_payload;
+
+class tlm_mm_interface {
+public:
+  virtual void free(tlm_generic_payload*) = 0;
+  virtual ~tlm_mm_interface() {}
+};
+
+//---------------------------------------------------------------------------
+// Classes and helper functions for the extension mechanism
+//---------------------------------------------------------------------------
+// Helper function:
+inline unsigned int max_num_extensions(bool increment=false)
+{
+    static unsigned int max_num = 0;
+    if (increment) ++max_num;
+    return max_num;
+}
+
+// This class can be used for storing pointers to the extension classes, used
+// in tlm_generic_payload:
+class tlm_extension_base
+{
+public:
+    virtual tlm_extension_base* clone() const = 0;
+    virtual void free() { delete this; }
+    virtual void copy_from(tlm_extension_base const &) = 0;
+protected:
+    virtual ~tlm_extension_base() {}
+    static unsigned int register_extension()
+    {
+        return (max_num_extensions(true) - 1);
+    };
+};
+
+// Base class for all extension classes, derive your extension class in
+// the following way:
+// class my_extension : public tlm_extension<my_extension> { ...
+// This triggers proper extension registration during C++ static
+// contruction time. my_extension::ID will hold the unique index in the
+// tlm_generic_payload::m_extensions array.
+template <typename T>
+class tlm_extension : public tlm_extension_base
+{
+public:
+    virtual tlm_extension_base* clone() const = 0;
+    virtual void copy_from(tlm_extension_base const &ext) = 0; //{assert(typeid(this)==typeid(ext)); assert(ID === ext.ID); assert(0);}
+    virtual ~tlm_extension() {}
+    const static unsigned int ID;
+};
+
+template <typename T>
+const
+unsigned int tlm_extension<T>::ID = tlm_extension_base::register_extension();
+
+//---------------------------------------------------------------------------
+// enumeration types
+//---------------------------------------------------------------------------
+enum tlm_command {
+    TLM_READ_COMMAND,
+    TLM_WRITE_COMMAND,
+    TLM_IGNORE_COMMAND
+};
+
+enum tlm_response_status {
+    TLM_OK_RESPONSE = 1,
+    TLM_INCOMPLETE_RESPONSE = 0,
+    TLM_GENERIC_ERROR_RESPONSE = -1,
+    TLM_ADDRESS_ERROR_RESPONSE = -2,
+    TLM_COMMAND_ERROR_RESPONSE = -3,
+    TLM_BURST_ERROR_RESPONSE = -4,
+    TLM_BYTE_ENABLE_ERROR_RESPONSE = -5
+};
+
+enum tlm_gp_option {
+    TLM_MIN_PAYLOAD,
+    TLM_FULL_PAYLOAD,
+    TLM_FULL_PAYLOAD_ACCEPTED
+};
+
+#define TLM_BYTE_DISABLED 0x0
+#define TLM_BYTE_ENABLED 0xff
+
+//---------------------------------------------------------------------------
+// The generic payload class:
+//---------------------------------------------------------------------------
+class tlm_generic_payload {
+
+public:
+    //---------------
+    // Constructors
+    //---------------
+
+    // Default constructor
+    tlm_generic_payload()
+        : m_address(0)
+        , m_command(TLM_IGNORE_COMMAND)
+        , m_data(0)
+        , m_length(0)
+        , m_response_status(TLM_INCOMPLETE_RESPONSE)
+        , m_dmi(false)
+        , m_byte_enable(0)
+        , m_byte_enable_length(0)
+        , m_streaming_width(0)
+        , m_gp_option(TLM_MIN_PAYLOAD)
+        , m_extensions(max_num_extensions())
+        , m_mm(0)
+        , m_ref_count(0)
+    {
+    }
+
+    explicit tlm_generic_payload(tlm_mm_interface* mm)
+        : m_address(0)
+        , m_command(TLM_IGNORE_COMMAND)
+        , m_data(0)
+        , m_length(0)
+        , m_response_status(TLM_INCOMPLETE_RESPONSE)
+        , m_dmi(false)
+        , m_byte_enable(0)
+        , m_byte_enable_length(0)
+        , m_streaming_width(0)
+        , m_gp_option(TLM_MIN_PAYLOAD)
+        , m_extensions(max_num_extensions())
+        , m_mm(mm)
+        , m_ref_count(0)
+    {
+    }
+
+    void acquire(){assert(m_mm != 0); m_ref_count++;}
+    void release(){assert(m_mm != 0 && m_ref_count > 0); if (--m_ref_count==0) m_mm->free(this);}
+    int get_ref_count() const {return m_ref_count;}
+    void set_mm(tlm_mm_interface* mm) { m_mm = mm; }
+    bool has_mm() const { return m_mm != 0; }
+
+    void reset(){
+      //should the other members be reset too?
+      m_gp_option = TLM_MIN_PAYLOAD;
+      m_extensions.free_entire_cache();
+    };
+
+
+private:
+    //disabled copy ctor and assignment operator.
+    // Copy constructor
+    tlm_generic_payload(const tlm_generic_payload& x)
+        : m_address(x.get_address())
+        , m_command(x.get_command())
+        , m_data(x.get_data_ptr())
+        , m_length(x.get_data_length())
+        , m_response_status(x.get_response_status())
+        , m_dmi(x.is_dmi_allowed())
+        , m_byte_enable(x.get_byte_enable_ptr())
+        , m_byte_enable_length(x.get_byte_enable_length())
+        , m_streaming_width(x.get_streaming_width())
+        , m_gp_option(x.m_gp_option)
+        , m_extensions(max_num_extensions())
+    {
+        // copy all extensions
+        for(unsigned int i=0; i<m_extensions.size(); i++)
+        {
+            m_extensions[i] = x.get_extension(i);
+        }
+    }
+
+    // Assignment operator
+    tlm_generic_payload& operator= (const tlm_generic_payload& x)
+    {
+        m_command =            x.get_command();
+        m_address =            x.get_address();
+        m_data =               x.get_data_ptr();
+        m_length =             x.get_data_length();
+        m_response_status =    x.get_response_status();
+        m_byte_enable =        x.get_byte_enable_ptr();
+        m_byte_enable_length = x.get_byte_enable_length();
+        m_streaming_width =    x.get_streaming_width();
+        m_gp_option =          x.get_gp_option();
+        m_dmi =                x.is_dmi_allowed();
+
+        // extension copy: all extension arrays must be of equal size by
+        // construction (i.e. it must either be constructed after C++
+        // static construction time, or the resize_extensions() method must
+        // have been called prior to using the object)
+        for(unsigned int i=0; i<m_extensions.size(); i++)
+        {
+            m_extensions[i] = x.get_extension(i);
+        }
+        return (*this);
+    }
+public:
+    // non-virtual deep-copying of the object
+    void deep_copy_from(const tlm_generic_payload & other)
+    {
+        m_command =            other.get_command();
+        m_address =            other.get_address();
+        m_length =             other.get_data_length();
+        m_response_status =    other.get_response_status();
+        m_byte_enable_length = other.get_byte_enable_length();
+        m_streaming_width =    other.get_streaming_width();
+        m_gp_option =          other.get_gp_option();
+        m_dmi =                other.is_dmi_allowed();
+
+        // deep copy data
+        // there must be enough space in the target transaction!
+        if(m_data && other.m_data)
+        {
+            memcpy(m_data, other.m_data, m_length);
+        }
+        // deep copy byte enables
+        // there must be enough space in the target transaction!
+        if(m_byte_enable && other.m_byte_enable)
+        {
+            memcpy(m_byte_enable, other.m_byte_enable, m_byte_enable_length);
+        }
+        // deep copy extensions (sticky and non-sticky)
+        for(unsigned int i=0; i<other.m_extensions.size(); i++)
+        {
+            if(other.m_extensions[i])
+            {                       //original has extension i
+                if(!m_extensions[i])
+                {                   //We don't: clone.
+                    tlm_extension_base *ext = other.m_extensions[i]->clone();
+                    if(ext)     //extension may not be clonable.
+                    {
+                        if(has_mm())
+                        {           //mm can take care of removing cloned extensions
+                            set_auto_extension(i, ext);
+                        }
+                        else
+                        {           // no mm, user will call free_all_extensions().
+                            set_extension(i, ext);
+                        }
+                    }
+                }
+                else
+                {                   //We already have such extension. Copy original over it.
+                    m_extensions[i]->copy_from(*other.m_extensions[i]);
+                }
+            }
+        }
+    }
+
+    // To update the state of the original generic payload from a deep copy
+    // Assumes that "other" was created from the original by calling deep_copy_from
+    // Argument use_byte_enable_on_read determines whether to use or ignores byte enables
+    // when copying back the data array on a read command
+
+    void update_original_from(const tlm_generic_payload & other,
+                              bool use_byte_enable_on_read = true)
+    {
+        // Copy back extensions that are present on the original
+        update_extensions_from(other);
+
+        // Copy back the response status and DMI hint attributes
+        m_response_status = other.get_response_status();
+        m_dmi             = other.is_dmi_allowed();
+
+        // Copy back the data array for a read command only
+        // deep_copy_from allowed null pointers, and so will we
+        // We assume the arrays are the same size
+        // We test for equal pointers in case the original and the copy share the same array
+
+        if(is_read() && m_data && other.m_data && m_data != other.m_data)
+        {
+            if (m_byte_enable && use_byte_enable_on_read)
+            {
+                if (m_byte_enable_length == 8 && m_length % 8 == 0 )
+                {
+                    // Optimized implementation copies 64-bit words by masking
+                    for (unsigned int i = 0; i < m_length; i += 8)
+                    {
+                        typedef sc_dt::uint64* u;
+                        *reinterpret_cast<u>(&m_data[i]) &= ~*reinterpret_cast<u>(m_byte_enable);
+                        *reinterpret_cast<u>(&m_data[i]) |= *reinterpret_cast<u>(&other.m_data[i]) &
+                                                            *reinterpret_cast<u>(m_byte_enable);
+                    }
+                }
+                else if (m_byte_enable_length == 4 && m_length % 4 == 0 )
+                {
+                    // Optimized implementation copies 32-bit words by masking
+                    for (unsigned int i = 0; i < m_length; i += 4)
+                    {
+                        typedef unsigned int* u;
+                        *reinterpret_cast<u>(&m_data[i]) &= ~*reinterpret_cast<u>(m_byte_enable);
+                        *reinterpret_cast<u>(&m_data[i]) |= *reinterpret_cast<u>(&other.m_data[i]) &
+                                                            *reinterpret_cast<u>(m_byte_enable);
+                    }
+                }
+                else
+                    // Unoptimized implementation
+                    for (unsigned int i = 0; i < m_length; i++)
+                        if ( m_byte_enable[i % m_byte_enable_length] )
+                            m_data[i] = other.m_data[i];
+            }
+            else
+              memcpy(m_data, other.m_data, m_length);
+        }
+    }
+
+    void update_extensions_from(const tlm_generic_payload & other)
+    {
+        // deep copy extensions that are already present
+        for(unsigned int i=0; i<other.m_extensions.size(); i++)
+        {
+            if(other.m_extensions[i])
+            {                       //original has extension i
+                if(m_extensions[i])
+                {                   //We have it too. copy.
+                    m_extensions[i]->copy_from(*other.m_extensions[i]);
+                }
+            }
+        }
+    }
+
+    // Free all extensions. Useful when reusing a cloned transaction that doesn't have memory manager.
+    // normal and sticky extensions are freed and extension array cleared.
+    void free_all_extensions()
+    {
+        m_extensions.free_entire_cache();
+        for(unsigned int i=0; i<m_extensions.size(); i++)
+        {
+            if(m_extensions[i])
+            {
+                m_extensions[i]->free();
+                m_extensions[i] = 0;
+            }
+        }
+    }
+    //--------------
+    // Destructor
+    //--------------
+    virtual ~tlm_generic_payload() {
+        for(unsigned int i=0; i<m_extensions.size(); i++)
+            if(m_extensions[i]) m_extensions[i]->free();
+    }
+
+    //----------------
+    // API (including setters & getters)
+    //---------------
+
+    // Command related method
+    bool                 is_read() const {return (m_command == TLM_READ_COMMAND);}
+    void                 set_read() {m_command = TLM_READ_COMMAND;}
+    bool                 is_write() const {return (m_command == TLM_WRITE_COMMAND);}
+    void                 set_write() {m_command = TLM_WRITE_COMMAND;}
+    tlm_command          get_command() const {return m_command;}
+    void                 set_command(const tlm_command command) {m_command = command;}
+
+    // Address related methods
+    sc_dt::uint64        get_address() const {return m_address;}
+    void                 set_address(const sc_dt::uint64 address) {m_address = address;}
+
+    // Data related methods
+    unsigned char*       get_data_ptr() const {return m_data;}
+    void                 set_data_ptr(unsigned char* data) {m_data = data;}
+
+    // Transaction length (in bytes) related methods
+    unsigned int         get_data_length() const {return m_length;}
+    void                 set_data_length(const unsigned int length) {m_length = length;}
+
+    // Response status related methods
+    bool                 is_response_ok() const {return (m_response_status > 0);}
+    bool                 is_response_error() const {return (m_response_status <= 0);}
+    tlm_response_status  get_response_status() const {return m_response_status;}
+    void                 set_response_status(const tlm_response_status response_status)
+        {m_response_status = response_status;}
+    std::string          get_response_string() const
+    {
+        switch(m_response_status)
+        {
+        case TLM_OK_RESPONSE:            return "TLM_OK_RESPONSE";
+        case TLM_INCOMPLETE_RESPONSE:    return "TLM_INCOMPLETE_RESPONSE";
+        case TLM_GENERIC_ERROR_RESPONSE: return "TLM_GENERIC_ERROR_RESPONSE";
+        case TLM_ADDRESS_ERROR_RESPONSE: return "TLM_ADDRESS_ERROR_RESPONSE";
+        case TLM_COMMAND_ERROR_RESPONSE: return "TLM_COMMAND_ERROR_RESPONSE";
+        case TLM_BURST_ERROR_RESPONSE:   return "TLM_BURST_ERROR_RESPONSE";
+        case TLM_BYTE_ENABLE_ERROR_RESPONSE: return "TLM_BYTE_ENABLE_ERROR_RESPONSE";
+        }
+        return "TLM_UNKNOWN_RESPONSE";
+    }
+
+    // Streaming related methods
+    unsigned int         get_streaming_width() const {return m_streaming_width;}
+    void                 set_streaming_width(const unsigned int streaming_width) {m_streaming_width = streaming_width; }
+
+    // Byte enable related methods
+    unsigned char*       get_byte_enable_ptr() const {return m_byte_enable;}
+    void                 set_byte_enable_ptr(unsigned char* byte_enable){m_byte_enable = byte_enable;}
+    unsigned int         get_byte_enable_length() const {return m_byte_enable_length;}
+    void                 set_byte_enable_length(const unsigned int byte_enable_length){m_byte_enable_length = byte_enable_length;}
+
+    // This is the "DMI-hint" a slave can set this to true if it
+    // wants to indicate that a DMI request would be supported:
+    void                 set_dmi_allowed(bool dmi_allowed) { m_dmi = dmi_allowed; }
+    bool                 is_dmi_allowed() const { return m_dmi; }
+
+    // Use full set of attributes in DMI/debug?
+    tlm_gp_option get_gp_option() const { return m_gp_option; }
+    void          set_gp_option( const tlm_gp_option gp_opt ) { m_gp_option = gp_opt; }
+
+private:
+
+    /* --------------------------------------------------------------------- */
+    /* Generic Payload attributes:                                           */
+    /* --------------------------------------------------------------------- */
+    /* - m_command         : Type of transaction. Three values supported:    */
+    /*                       - TLM_WRITE_COMMAND                             */
+    /*                       - TLM_READ_COMMAND                              */
+    /*                       - TLM_IGNORE_COMMAND                            */
+    /* - m_address         : Transaction base address (byte-addressing).     */
+    /* - m_data            : When m_command = TLM_WRITE_COMMAND contains a   */
+    /*                       pointer to the data to be written in the target.*/
+    /*                       When m_command = TLM_READ_COMMAND contains a    */
+    /*                       pointer where to copy the data read from the    */
+    /*                       target.                                         */
+    /* - m_length          : Total number of bytes of the transaction.       */
+    /* - m_response_status : This attribute indicates whether an error has   */
+    /*                       occurred during the transaction.                */
+    /*                       Values supported are:                           */
+    /*                       - TLM_OK_RESP                                   */
+    /*                       - TLM_INCOMPLETE_RESP                           */
+    /*                       - TLM_GENERIC_ERROR_RESP                        */
+    /*                       - TLM_ADDRESS_ERROR_RESP                        */
+    /*                       - TLM_COMMAND_ERROR_RESP                        */
+    /*                       - TLM_BURST_ERROR_RESP                          */
+    /*                       - TLM_BYTE_ENABLE_ERROR_RESP                    */
+    /*                                                                       */
+    /* - m_byte_enable     : It can be used to create burst transfers where  */
+    /*                    the address increment between each beat is greater */
+    /*                    than the word length of each beat, or to place     */
+    /*                    words in selected byte lanes of a bus.             */
+    /* - m_byte_enable_length : For a read or a write command, the target    */
+    /*                    interpret the byte enable length attribute as the  */
+    /*                    number of elements in the bytes enable array.      */
+    /* - m_streaming_width  :                                                */
+    /* --------------------------------------------------------------------- */
+
+    sc_dt::uint64        m_address;
+    tlm_command          m_command;
+    unsigned char*       m_data;
+    unsigned int         m_length;
+    tlm_response_status  m_response_status;
+    bool                 m_dmi;
+    unsigned char*       m_byte_enable;
+    unsigned int         m_byte_enable_length;
+    unsigned int         m_streaming_width;
+    tlm_gp_option        m_gp_option;
+
+public:
+
+    /* --------------------------------------------------------------------- */
+    /* Dynamic extension mechanism:                                          */
+    /* --------------------------------------------------------------------- */
+    /* The extension mechanism is intended to enable initiator modules to    */
+    /* optionally and transparently add data fields to the                   */
+    /* tlm_generic_payload. Target modules are free to check for extensions  */
+    /* and may or may not react to the data in the extension fields. The     */
+    /* definition of the extensions' semantics is solely in the              */
+    /* responsibility of the user.                                           */
+    /*                                                                       */
+    /* The following rules apply:                                            */
+    /*                                                                       */
+    /* - Every extension class must be derived from tlm_extension, e.g.:     */
+    /*     class my_extension : public tlm_extension<my_extension> { ... }   */
+    /*                                                                       */
+    /* - A tlm_generic_payload object should be constructed after C++        */
+    /*   static initialization time. This way it is guaranteed that the      */
+    /*   extension array is of sufficient size to hold all possible          */
+    /*   extensions. Alternatively, the initiator module can enforce a valid */
+    /*   extension array size by calling the resize_extensions() method      */
+    /*   once before the first transaction with the payload object is        */
+    /*   initiated.                                                          */
+    /*                                                                       */
+    /* - Initiators should use the the set_extension(e) or clear_extension(e)*/
+    /*   methods for manipulating the extension array. The type of the       */
+    /*   argument must be a pointer to the specific registered extension     */
+    /*   type (my_extension in the above example) and is used to             */
+    /*   automatically locate the appropriate index in the array.            */
+    /*                                                                       */
+    /* - Targets can check for a specific extension by calling               */
+    /*   get_extension(e). e will point to zero if the extension is not      */
+    /*   present.                                                            */
+    /*                                                                       */
+    /* --------------------------------------------------------------------- */
+
+    // Stick the pointer to an extension into the vector, return the
+    // previous value:
+    template <typename T> T* set_extension(T* ext)
+    {
+        return static_cast<T*>(set_extension(T::ID, ext));
+    }
+
+    // non-templatized version with manual index:
+    tlm_extension_base* set_extension(unsigned int index,
+                                      tlm_extension_base* ext)
+    {
+        tlm_extension_base* tmp = m_extensions[index];
+        m_extensions[index] = ext;
+        return tmp;
+    }
+
+    // Stick the pointer to an extension into the vector, return the
+    // previous value and schedule its release
+    template <typename T> T* set_auto_extension(T* ext)
+    {
+        return static_cast<T*>(set_auto_extension(T::ID, ext));
+    }
+
+    // non-templatized version with manual index:
+    tlm_extension_base* set_auto_extension(unsigned int index,
+                                           tlm_extension_base* ext)
+    {
+        tlm_extension_base* tmp = m_extensions[index];
+        m_extensions[index] = ext;
+        if (!tmp) m_extensions.insert_in_cache(&m_extensions[index]);
+        assert(m_mm != 0);
+        return tmp;
+    }
+
+    // Check for an extension, ext will point to 0 if not present
+    template <typename T> void get_extension(T*& ext) const
+    {
+        ext = get_extension<T>();
+    }
+    template <typename T> T* get_extension() const
+    {
+        return static_cast<T*>(get_extension(T::ID));
+    }
+    // Non-templatized version with manual index:
+    tlm_extension_base* get_extension(unsigned int index) const
+    {
+        return m_extensions[index];
+    }
+
+    //this call just removes the extension from the txn but does not
+    // call free() or tells the MM to do so
+    // it return false if there was active MM so you are now in an unsafe situation
+    // recommended use: when 100% sure there is no MM
+    template <typename T> void clear_extension(const T* ext)
+    {
+        clear_extension<T>();
+    }
+
+    //this call just removes the extension from the txn but does not
+    // call free() or tells the MM to do so
+    // it return false if there was active MM so you are now in an unsafe situation
+    // recommended use: when 100% sure there is no MM
+    template <typename T> void clear_extension()
+    {
+        clear_extension(T::ID);
+    }
+
+    //this call removes the extension from the txn and does
+    // call free() or tells the MM to do so when the txn is finally done
+    // recommended use: when not sure there is no MM
+    template <typename T> void release_extension(T* ext)
+    {
+        release_extension<T>();
+    }
+
+    //this call removes the extension from the txn and does
+    // call free() or tells the MM to do so when the txn is finally done
+    // recommended use: when not sure there is no MM
+    template <typename T> void release_extension()
+    {
+        release_extension(T::ID);
+    }
+
+private:
+    // Non-templatized version with manual index
+    void clear_extension(unsigned int index)
+    {
+        m_extensions[index] = static_cast<tlm_extension_base*>(0);
+    }
+    // Non-templatized version with manual index
+    void release_extension(unsigned int index)
+    {
+        if (m_mm)
+        {
+            m_extensions.insert_in_cache(&m_extensions[index]);
+        }
+        else
+        {
+            m_extensions[index]->free();
+            m_extensions[index] = static_cast<tlm_extension_base*>(0);
+        }
+    }
+
+public:
+    // Make sure the extension array is large enough. Can be called once by
+    // an initiator module (before issuing the first transaction) to make
+    // sure that the extension array is of correct size. This is only needed
+    // if the initiator cannot guarantee that the generic payload object is
+    // allocated after C++ static construction time.
+    void resize_extensions()
+    {
+        m_extensions.expand(max_num_extensions());
+    }
+
+private:
+    tlm_array<tlm_extension_base*> m_extensions;
+    tlm_mm_interface*              m_mm;
+    unsigned int                   m_ref_count;
+};
+
+} // namespace tlm
+
+#endif /* __TLM_GP_H__ */
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_helpers.h b/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_helpers.h
new file mode 100644
index 000000000..da3abb4f9
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_helpers.h
@@ -0,0 +1,80 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/* ---------------------------------------------------------------------------------------
+ @file tlm_helpers.h
+ 
+ @brief
+ 
+  Original Authors:
+    Charles Wilson, ESLX
+    
+--------------------------------------------------------------------------------------- */
+
+#ifndef __TLM_HELPERS_H__
+#define __TLM_HELPERS_H__
+
+//#include <sys/param.h>
+//#include <cstring>
+
+namespace tlm {
+
+enum tlm_endianness { TLM_UNKNOWN_ENDIAN, TLM_LITTLE_ENDIAN, TLM_BIG_ENDIAN };
+
+inline tlm_endianness get_host_endianness(void)
+{
+  static tlm_endianness host_endianness = TLM_UNKNOWN_ENDIAN;
+  
+  if (host_endianness == TLM_UNKNOWN_ENDIAN) {
+    unsigned int number = 1;
+    unsigned char *p_msb_or_lsb = (unsigned char*)&number;
+
+    host_endianness = (p_msb_or_lsb[0] == 0) ? TLM_BIG_ENDIAN : TLM_LITTLE_ENDIAN;
+  }
+  return host_endianness;
+}
+
+inline bool host_has_little_endianness(void)
+{
+  static tlm_endianness host_endianness = TLM_UNKNOWN_ENDIAN;
+  static bool host_little_endian = false;
+  
+  if (host_endianness == TLM_UNKNOWN_ENDIAN) {
+    unsigned int number = 1;
+    unsigned char *p_msb_or_lsb = (unsigned char*)&number;
+
+    host_little_endian = (p_msb_or_lsb[0] == 0) ? false : true;
+  }
+
+  return host_little_endian;
+}
+
+inline bool has_host_endianness(tlm_endianness endianness)
+{
+  if (host_has_little_endianness()) {
+    return endianness == TLM_LITTLE_ENDIAN;
+
+  } else {
+    return endianness == TLM_BIG_ENDIAN;
+  }
+} 
+
+} // namespace tlm
+
+#endif /* __TLM_HELPERS_H__ */
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_phase.h b/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_phase.h
new file mode 100644
index 000000000..af0a278c9
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_generic_payload/tlm_phase.h
@@ -0,0 +1,87 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __TLM_PHASE_H__
+#define __TLM_PHASE_H__
+
+#include <string>
+#include <iostream>
+#include <vector>
+
+namespace tlm {
+
+//enum tlm_phase { BEGIN_REQ, END_REQ, BEGIN_RESP, END_RESP };
+  
+enum tlm_phase_enum { UNINITIALIZED_PHASE=0, BEGIN_REQ=1, END_REQ, BEGIN_RESP, END_RESP };
+
+inline unsigned int create_phase_number(){
+  static unsigned int number=END_RESP+1;
+  return number++;
+}
+
+inline std::vector<const char*>& get_phase_name_vec(){
+  static std::vector<const char*> phase_name_vec(END_RESP+1, (const char*)NULL);
+  return phase_name_vec;
+}
+
+class tlm_phase{
+public:
+  tlm_phase(): m_id(0) {}
+  tlm_phase(unsigned int id): m_id(id){}
+  tlm_phase(const tlm_phase_enum& standard): m_id((unsigned int) standard){}
+  tlm_phase& operator=(const tlm_phase_enum& standard){m_id=(unsigned int)standard; return *this;}
+  operator unsigned int() const{return m_id;}
+  
+private:
+  unsigned int m_id;  
+};
+
+inline
+std::ostream& operator<<(std::ostream& s, const tlm_phase& p){
+  switch ((unsigned int)p){
+    case UNINITIALIZED_PHASE: s<<"UNINITIALIZED_PHASE"; break;
+    case BEGIN_REQ:  s<<"BEGIN_REQ"; break;
+    case END_REQ:    s<<"END_REQ"; break;
+    case BEGIN_RESP: s<<"BEGIN_RESP"; break;
+    case END_RESP:   s<<"END_RESP"; break;
+    default:
+      s<<get_phase_name_vec()[(unsigned int)p]; return s;      
+  }
+  return s;
+}
+  
+#define TLM_DECLARE_EXTENDED_PHASE(name_arg) \
+class tlm_phase_##name_arg:public tlm::tlm_phase{ \
+public:\
+static const tlm_phase_##name_arg& get_phase(){static tlm_phase_##name_arg tmp; return tmp;}\
+private:\
+tlm_phase_##name_arg():tlm::tlm_phase(tlm::create_phase_number()){tlm::get_phase_name_vec().push_back(get_char_##name_arg());};\
+tlm_phase_##name_arg(const tlm_phase_##name_arg&); \
+tlm_phase_##name_arg& operator=(const tlm_phase_##name_arg&); \
+static inline const char* get_char_##name_arg(){static const char* tmp=#name_arg; return tmp;} \
+}; \
+static const tlm_phase_##name_arg& name_arg=tlm_phase_##name_arg::get_phase()
+
+// for backwards-compatibility
+#define DECLARE_EXTENDED_PHASE(NameArg) \
+    TLM_DECLARE_EXTENDED_PHASE( NameArg )
+
+} // namespace tlm
+
+#endif /* TLM_PHASE_HEADER */
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_quantum/tlm_global_quantum.h b/ext/systemc/src/tlm_core/tlm_2/tlm_quantum/tlm_global_quantum.h
new file mode 100644
index 000000000..eb36a898e
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_quantum/tlm_global_quantum.h
@@ -0,0 +1,97 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __TLM_GLOBAL_QUANTUM_H__
+#define __TLM_GLOBAL_QUANTUM_H__
+
+#include <systemc>
+
+namespace tlm {
+
+//
+// tlm_global_quantum class
+//
+// The global quantum is the maximum time an initiator can run ahead of
+// systemC time. All initiators should synchronize on timingpoints that
+// are multiples of the global quantum value.
+//
+// sc_set_time_resolution can only be called before the first
+// sc_time object is created. This means that after setting the
+// global quantum it will not be possible to call sc_set_time_resolution.
+// If sc_set_time_resolution must be called this must be done before
+// the global quantum is set.
+//
+
+class tlm_global_quantum
+{
+public:
+  //
+  // Returns a reference to the tlm_global_quantum singleton
+  //
+  static tlm_global_quantum& instance()
+  {
+    static tlm_global_quantum instance_;
+    return instance_;
+  }
+
+public:
+
+  //
+  // Setter/getter for the global quantum
+  //
+  void set(const sc_core::sc_time& t)
+  {
+    m_global_quantum = t;
+  }
+
+  const sc_core::sc_time& get() const
+  {
+    return m_global_quantum;
+  }
+
+  //
+  // This function will calculate the maximum value for the next local
+  // quantum for an initiator. All initiators should synchronize on
+  // integer multiples of the global quantum value. The value for the
+  // local quantum of an initiator can be smaller, but should never be
+  // greater than the value returned by this method.
+  //
+  sc_core::sc_time compute_local_quantum()
+  {
+    if (m_global_quantum != sc_core::SC_ZERO_TIME) {
+      const sc_core::sc_time current = sc_core::sc_time_stamp();
+      const sc_core::sc_time g_quant = m_global_quantum;
+      return g_quant - (current % g_quant);
+    } else {
+      return sc_core::SC_ZERO_TIME;
+    }
+  }
+
+protected:
+  tlm_global_quantum() : m_global_quantum(sc_core::SC_ZERO_TIME)
+  {
+  }
+
+protected:
+  sc_core::sc_time m_global_quantum;
+};
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_quantum/tlm_quantum.h b/ext/systemc/src/tlm_core/tlm_2/tlm_quantum/tlm_quantum.h
new file mode 100644
index 000000000..c5138ab06
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_quantum/tlm_quantum.h
@@ -0,0 +1,25 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __TLM_QUANTUM_H__
+#define __TLM_QUANTUM_H__
+
+#include "tlm_core/tlm_2/tlm_quantum/tlm_global_quantum.h"
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_sockets/tlm_initiator_socket.h b/ext/systemc/src/tlm_core/tlm_2/tlm_sockets/tlm_initiator_socket.h
new file mode 100644
index 000000000..3dd42e806
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_sockets/tlm_initiator_socket.h
@@ -0,0 +1,252 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __TLM_INITIATOR_SOCKET_H__
+#define __TLM_INITIATOR_SOCKET_H__
+
+//#include <systemc>
+#include "tlm_core/tlm_2/tlm_2_interfaces/tlm_fw_bw_ifs.h"
+
+namespace tlm {
+
+
+template <unsigned int BUSWIDTH = 32,
+          typename FW_IF = tlm_fw_transport_if<>,
+          typename BW_IF = tlm_bw_transport_if<> >
+class tlm_base_initiator_socket_b
+{
+public:
+  virtual ~tlm_base_initiator_socket_b() {}
+
+  virtual sc_core::sc_port_b<FW_IF> &       get_base_port() = 0;
+  virtual sc_core::sc_port_b<FW_IF> const & get_base_port() const = 0;
+  virtual                    BW_IF  &       get_base_interface() = 0;
+  virtual                    BW_IF  const & get_base_interface() const = 0;
+  virtual sc_core::sc_export<BW_IF> &       get_base_export() = 0;
+  virtual sc_core::sc_export<BW_IF> const & get_base_export() const = 0;
+};
+
+
+template <unsigned int BUSWIDTH,
+          typename FW_IF,
+          typename BW_IF> class tlm_base_target_socket_b;
+
+template <unsigned int BUSWIDTH,
+          typename FW_IF,
+          typename BW_IF,
+          int N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+          ,sc_core::sc_port_policy POL
+#endif
+          > class tlm_base_target_socket;
+
+template <unsigned int BUSWIDTH = 32,
+          typename FW_IF = tlm_fw_transport_if<>,
+          typename BW_IF = tlm_bw_transport_if<>,
+          int N = 1
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+          ,sc_core::sc_port_policy POL = sc_core::SC_ONE_OR_MORE_BOUND
+#endif
+          >
+class tlm_base_initiator_socket : public tlm_base_initiator_socket_b<BUSWIDTH, FW_IF, BW_IF>,
+                                  public sc_core::sc_port<FW_IF, N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+                                                        , POL
+#endif
+                                                    >
+
+{
+public:
+  typedef FW_IF                                 fw_interface_type;
+  typedef BW_IF                                 bw_interface_type;
+  typedef sc_core::sc_port<fw_interface_type, N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+                                            , POL
+#endif
+                                            >   port_type;
+
+  typedef sc_core::sc_export<bw_interface_type> export_type;
+
+  typedef tlm_base_target_socket_b<BUSWIDTH,
+                                   fw_interface_type,
+                                   bw_interface_type> base_target_socket_type;
+  typedef tlm_base_initiator_socket_b<BUSWIDTH,
+                                      fw_interface_type,
+                                      bw_interface_type> base_type;
+
+  template <unsigned int, typename, typename, int
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+           ,sc_core::sc_port_policy
+#endif
+           >
+  friend class tlm_base_target_socket;
+
+public:
+  tlm_base_initiator_socket()
+  : port_type(sc_core::sc_gen_unique_name("tlm_base_initiator_socket"))
+  , m_export(sc_core::sc_gen_unique_name("tlm_base_initiator_socket_export"))
+  {
+  }
+
+  explicit tlm_base_initiator_socket(const char* name)
+  : port_type(name)
+  , m_export(sc_core::sc_gen_unique_name((std::string(name) + "_export").c_str()))
+  {
+  }
+
+  virtual const char* kind() const
+  {
+    return "tlm_base_initiator_socket";
+  }
+
+  unsigned int get_bus_width() const
+  {
+    return BUSWIDTH;
+  }
+
+  //
+  // Bind initiator socket to target socket
+  // - Binds the port of the initiator socket to the export of the target
+  //   socket
+  // - Binds the port of the target socket to the export of the initiator
+  //   socket
+  //
+  virtual void bind(base_target_socket_type& s)
+  {
+    // initiator.port -> target.export
+    (get_base_port())(s.get_base_interface());
+    // target.port -> initiator.export
+    (s.get_base_port())(get_base_interface());
+  }
+
+  void operator() (base_target_socket_type& s)
+  {
+    bind(s);
+  }
+
+  //
+  // Bind initiator socket to initiator socket (hierarchical bind)
+  // - Binds both the export and the port
+  //
+  virtual void bind(base_type& s)
+  {
+    // port
+    (get_base_port())(s.get_base_port());
+    // export
+    (s.get_base_export())(get_base_export());
+  }
+
+  void operator() (base_type& s)
+  {
+    bind(s);
+  }
+
+  //
+  // Bind interface to socket
+  // - Binds the interface to the export of this socket
+  //
+  virtual void bind(bw_interface_type& ifs)
+  {
+    (get_base_export())(ifs);
+  }
+
+  void operator() (bw_interface_type& s)
+  {
+    bind(s);
+  }
+
+  // Implementation of pure virtual functions of base class
+  virtual sc_core::sc_port_b<FW_IF> &       get_base_port()
+    { return *this; }
+  virtual sc_core::sc_port_b<FW_IF> const & get_base_port() const
+    { return *this; }
+
+  virtual                    BW_IF  &       get_base_interface()
+    { return m_export; }
+  virtual                    BW_IF  const & get_base_interface() const
+#if !( defined(IEEE_1666_SYSTEMC) && IEEE_1666_SYSTEMC >= 201101L )
+    { return const_cast<export_type &>(m_export); }
+#else
+    { return m_export; }
+#endif
+
+  virtual sc_core::sc_export<BW_IF> &       get_base_export()
+    { return m_export; }
+  virtual sc_core::sc_export<BW_IF> const & get_base_export() const
+    { return m_export; }
+
+protected:
+  export_type m_export;
+};
+
+//
+// Convenience socket classes
+//
+
+template <unsigned int BUSWIDTH = 32,
+          typename TYPES = tlm_base_protocol_types,
+          int N = 1
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+          ,sc_core::sc_port_policy POL = sc_core::SC_ONE_OR_MORE_BOUND
+#endif
+          >
+class tlm_initiator_socket :
+  public tlm_base_initiator_socket <BUSWIDTH,
+                               tlm_fw_transport_if<TYPES>,
+                               tlm_bw_transport_if<TYPES>,
+                               N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+                               ,POL
+#endif
+                              >
+{
+public:
+  tlm_initiator_socket() :
+    tlm_base_initiator_socket<BUSWIDTH,
+                         tlm_fw_transport_if<TYPES>,
+                         tlm_bw_transport_if<TYPES>,
+                         N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+                         ,POL
+#endif
+                         >()
+  {
+  }
+
+  explicit tlm_initiator_socket(const char* name) :
+    tlm_base_initiator_socket<BUSWIDTH,
+                         tlm_fw_transport_if<TYPES>,
+                         tlm_bw_transport_if<TYPES>,
+                         N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+                         ,POL
+#endif
+                         >(name)
+  {
+  }
+
+  virtual const char* kind() const
+  {
+    return "tlm_initiator_socket";
+  }
+};
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_sockets/tlm_sockets.h b/ext/systemc/src/tlm_core/tlm_2/tlm_sockets/tlm_sockets.h
new file mode 100644
index 000000000..013e29286
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_sockets/tlm_sockets.h
@@ -0,0 +1,26 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __TLM_SOCKETS_H__
+#define __TLM_SOCKETS_H__
+
+#include "tlm_core/tlm_2/tlm_sockets/tlm_initiator_socket.h"
+#include "tlm_core/tlm_2/tlm_sockets/tlm_target_socket.h"
+
+#endif /* __TLM_SOCKETS_H__ */
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_sockets/tlm_target_socket.h b/ext/systemc/src/tlm_core/tlm_2/tlm_sockets/tlm_target_socket.h
new file mode 100644
index 000000000..4ed29f62a
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_sockets/tlm_target_socket.h
@@ -0,0 +1,275 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __TLM_TARGET_SOCKET_H__
+#define __TLM_TARGET_SOCKET_H__
+
+//#include <systemc>
+#include "tlm_core/tlm_2/tlm_2_interfaces/tlm_fw_bw_ifs.h"
+
+
+namespace tlm {
+
+template <unsigned int BUSWIDTH = 32,
+          typename FW_IF = tlm_fw_transport_if<>,
+          typename BW_IF = tlm_bw_transport_if<> >
+class tlm_base_target_socket_b
+{
+public:
+  virtual ~tlm_base_target_socket_b() {}
+
+  virtual sc_core::sc_port_b<BW_IF> & get_base_port() = 0;
+  virtual sc_core::sc_export<FW_IF> & get_base_export() = 0;
+  virtual                    FW_IF  & get_base_interface() = 0;
+};
+
+template <unsigned int BUSWIDTH,
+          typename FW_IF,
+          typename BW_IF> class tlm_base_initiator_socket_b;
+
+template <unsigned int BUSWIDTH,
+          typename FW_IF,
+          typename BW_IF,
+          int N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+          ,sc_core::sc_port_policy POL
+#endif
+          > class tlm_base_initiator_socket;
+
+template <unsigned int BUSWIDTH = 32,
+          typename FW_IF = tlm_fw_transport_if<>,
+          typename BW_IF = tlm_bw_transport_if<>,
+          int N = 1
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+          ,sc_core::sc_port_policy POL = sc_core::SC_ONE_OR_MORE_BOUND
+#endif
+          >
+class tlm_base_target_socket : public tlm_base_target_socket_b<BUSWIDTH, FW_IF, BW_IF>,
+                               public sc_core::sc_export<FW_IF>
+{
+public:
+  typedef FW_IF                                 fw_interface_type;
+  typedef BW_IF                                 bw_interface_type;
+  typedef sc_core::sc_port<bw_interface_type, N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+                                            , POL
+#endif
+                                            >   port_type;
+
+  typedef sc_core::sc_export<fw_interface_type> export_type;
+  typedef tlm_base_initiator_socket_b<BUSWIDTH,
+                                      fw_interface_type,
+                                      bw_interface_type>  base_initiator_socket_type;
+
+  typedef tlm_base_target_socket_b<BUSWIDTH,
+                                   fw_interface_type,
+                                   bw_interface_type> base_type;
+
+  template <unsigned int, typename, typename, int
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+                               ,sc_core::sc_port_policy
+#endif
+
+           >
+  friend class tlm_base_initiator_socket;
+
+public:
+  tlm_base_target_socket()
+  : export_type(sc_core::sc_gen_unique_name("tlm_base_target_socket"))
+  , m_port(sc_core::sc_gen_unique_name("tlm_base_target_socket_port"))
+  {
+  }
+
+  explicit tlm_base_target_socket(const char* name)
+  : export_type(name)
+  , m_port(sc_core::sc_gen_unique_name((std::string(name) + "_port").c_str()))
+  {
+  }
+
+  virtual const char* kind() const
+  {
+    return "tlm_base_target_socket";
+  }
+
+  unsigned int get_bus_width() const
+  {
+    return BUSWIDTH;
+  }
+
+  //
+  // Bind target socket to initiator socket
+  // - Binds the port of the initiator socket to the export of the target
+  //   socket
+  // - Binds the port of the target socket to the export of the initiator
+  //   socket
+  //
+  virtual void bind(base_initiator_socket_type& s)
+  {
+    // initiator.port -> target.export
+    (s.get_base_port())(get_base_interface());
+    // target.port -> initiator.export
+    get_base_port()(s.get_base_interface());
+  }
+
+  void operator() (base_initiator_socket_type& s)
+  {
+    bind(s);
+  }
+
+  //
+  // Bind target socket to target socket (hierarchical bind)
+  // - Binds both the export and the port
+  //
+  virtual void bind(base_type& s)
+  {
+    // export
+    (get_base_export())(s.get_base_export());
+    // port
+    (s.get_base_port())(get_base_port());
+  }
+
+  void operator() (base_type& s)
+  {
+    bind(s);
+  }
+
+  //
+  // Bind interface to socket
+  // - Binds the interface to the export
+  //
+  virtual void bind(fw_interface_type& ifs)
+  {
+    export_type* exp = &get_base_export();
+    if( this == exp ) {
+      export_type::bind( ifs ); // non-virtual function call
+    } else {
+      exp->bind( ifs );
+    }
+  }
+
+  void operator() (fw_interface_type& s)
+  {
+    bind(s);
+  }
+
+  //
+  // Forward to 'size()' of port class
+  //
+  int size() const
+  {
+    return m_port.size();
+  }
+
+  //
+  // Forward to 'operator->()' of port class
+  //
+  bw_interface_type* operator->()
+  {
+    return m_port.operator->();
+  }
+
+  //
+  // Forward to 'operator[]()' of port class
+  //
+  bw_interface_type* operator[](int i)
+  {
+    return m_port.operator[](i);
+  }
+
+  // Implementation of pure virtual functions of base class
+
+  virtual sc_core::sc_port_b<BW_IF> &       get_base_port()
+    { return m_port; }
+  virtual sc_core::sc_port_b<BW_IF> const & get_base_port() const
+    { return m_port; }
+
+  virtual                    FW_IF  &       get_base_interface()
+    { return *this; }
+  virtual                    FW_IF  const & get_base_interface() const
+#if !( defined(IEEE_1666_SYSTEMC) && IEEE_1666_SYSTEMC >= 201101L )
+    { return *const_cast<export_type*>(static_cast<export_type const*>(this)); }
+#else
+    { return *this; }
+#endif
+
+  virtual sc_core::sc_export<FW_IF> &       get_base_export()
+    { return *this; }
+  virtual sc_core::sc_export<FW_IF> const & get_base_export() const
+    { return *this; }
+
+protected:
+  port_type m_port;
+};
+
+
+//
+// Convenience blocking and non-blocking socket classes
+//
+
+template <unsigned int BUSWIDTH = 32,
+          typename TYPES = tlm_base_protocol_types,
+          int N = 1
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+          ,sc_core::sc_port_policy POL = sc_core::SC_ONE_OR_MORE_BOUND
+#endif
+          >
+class tlm_target_socket :
+  public tlm_base_target_socket <BUSWIDTH,
+                            tlm_fw_transport_if<TYPES>,
+                            tlm_bw_transport_if<TYPES>,
+                            N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+                            ,POL
+#endif
+                            >
+{
+public:
+  tlm_target_socket() :
+    tlm_base_target_socket<BUSWIDTH,
+                      tlm_fw_transport_if<TYPES>,
+                      tlm_bw_transport_if<TYPES>,
+                      N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+                      ,POL
+#endif
+                      >()
+  {
+  }
+
+  explicit tlm_target_socket(const char* name) :
+    tlm_base_target_socket<BUSWIDTH,
+                      tlm_fw_transport_if<TYPES>,
+                      tlm_bw_transport_if<TYPES>,
+                      N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+                      ,POL
+#endif
+                      >(name)
+  {
+  }
+
+  virtual const char* kind() const
+  {
+    return "tlm_target_socket";
+  }
+};
+
+} // namespace tlm
+
+#endif
diff --git a/ext/systemc/src/tlm_core/tlm_2/tlm_version.h b/ext/systemc/src/tlm_core/tlm_2/tlm_version.h
new file mode 100644
index 000000000..e9b7a6569
--- /dev/null
+++ b/ext/systemc/src/tlm_core/tlm_2/tlm_version.h
@@ -0,0 +1,180 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/* ---------------------------------------------------------------------------------------
+ @file tlm_version.h
+
+ @brief TLM version header
+
+  Original Author:
+    Charles Wilson, XtremeEDA Corporation
+
+ @description
+  This header contains preprocessor and compiler symbols to allow for the determination
+   of the TLM version information. This conforms to IEEE 1666-2005 section 8.5.5 - 8.5.7
+   .
+   The following are provided:
+   .
+   preprocessor: TLM_VERSION_MAJOR        numeric
+                 TLM_VERSION_MINOR        numeric
+                 TLM_VERSION_PATCH        numeric
+                 TLM_VERSION_ORIGINATOR   string       ([A-Z][a-z][0-9]_)
+                 TLM_VERSION_RELEASE_DATE ISO8601 date (YYYYMMDD)
+                 TLM_VERSION_PRERELEASE   string       ([A-Z][a-z][0-9]_)
+                 TLM_IS_PRERELEASE        bool         (1,0)
+                 TLM_VERSION              string       {2.0.0_DR3-TLMWG}
+                 TLM_COPYRIGHT            string
+   .
+   compiler:     tlm_version_major        const unsigned int
+                 tlm_version_minor        const unsigned int
+                 tlm_version_patch        const unsigned int
+                 tlm_version_originator   const std::string
+                 tlm_version_release_date const std::string
+                 tlm_version_prerelease   const std::string
+                 tlm_is_prerelease        const bool
+                 tlm_version              const string
+                 tlm_copyright            const string
+   .
+   accessors:    inline const char* tlm_release   (void)
+                 inline const char* tlm_version   (void)
+                 inline const char* tlm_copyright (void)
+
+--------------------------------------------------------------------------------------- */
+
+#ifndef __TLM_VERSION_H__
+#define __TLM_VERSION_H__
+
+namespace tlm
+{
+
+#define TLM_VERSION_MAJOR                   2           ///< version major level ( numeric )
+#define TLM_VERSION_MINOR                   0           ///< version minor level ( numeric )
+#define TLM_VERSION_PATCH                   3           ///< version patch level ( numeric )
+#define TLM_VERSION_ORIGINATOR              "Accellera" ///< TLM creator string
+#define TLM_VERSION_SEPARATOR               "."         ///< version string separator
+
+#define TLM_IS_PRERELEASE                   0           ///< pre-release flag ( 1 / 0 )
+
+#if TLM_IS_PRERELEASE
+#    define TLM_VERSION_PRERELEASE          "pub_rev"   ///< pre-release version string
+#else
+#    define TLM_VERSION_PRERELEASE          ""          ///< pre-release version string
+#endif
+
+#define TLM_VERSION_RELEASE_YEAR            "2013"      ///< release year  ( YYYY )
+#define TLM_VERSION_RELEASE_MONTH           "12"        ///< release month ( MM )
+#define TLM_VERSION_RELEASE_DAY             "15"        ///< release day   ( DD )
+
+#define TLM_COPYRIGHT \
+  "Copyright (c) 1996-" TLM_VERSION_RELEASE_YEAR " by all Contributors\n" \
+  "ALL RIGHTS RESERVED"
+
+/************************** do not modify below this line *******************************/
+
+/******************************* preprocessor symbols ***********************************/
+
+#define TLM_VERSION_RELEASE_DATE            TLM_VERSION_RELEASE_YEAR \
+                                            TLM_VERSION_RELEASE_MONTH \
+                                            TLM_VERSION_RELEASE_DAY
+
+#define TLM_VERSION_STR(x)                  TLM_VERSION_STR_HELPER(x)
+#define TLM_VERSION_STR_HELPER(x)           #x
+
+#define TLM_VERSION_STRING_MAJOR            TLM_VERSION_STR(TLM_VERSION_MAJOR)
+#define TLM_VERSION_STRING_MINOR            TLM_VERSION_STR(TLM_VERSION_MINOR)
+#define TLM_VERSION_STRING_PATCH            TLM_VERSION_STR(TLM_VERSION_PATCH)
+
+#define TLM_VERSION_STRING_MMP              TLM_VERSION_STRING_MAJOR TLM_VERSION_SEPARATOR \
+                                            TLM_VERSION_STRING_MINOR TLM_VERSION_SEPARATOR \
+                                            TLM_VERSION_STRING_PATCH
+
+#define TLM_VERSION_STRING_PRE_START        "_"
+#define TLM_VERSION_STRING_PRE_END          "-"
+
+#if ( TLM_IS_PRERELEASE == 1 )
+
+#define TLM_VERSION_STRING_PRERELEASE       TLM_VERSION_PRERELEASE
+#define TLM_VERSION_STRING_RELEASE_DATE     ""
+
+#else   /* TLM_IS_PRERELEASE == 1 */
+
+#define TLM_VERSION_STRING_PRERELEASE       ""
+#define TLM_VERSION_STRING_RELEASE_DATE     TLM_VERSION_RELEASE_DATE
+
+#endif  /* TLM_IS_PRERELEASE == 1 */
+
+#define TLM_VERSION_STRING                  TLM_VERSION_STRING_MMP \
+                                            TLM_VERSION_STRING_PRE_START \
+                                            TLM_VERSION_STRING_PRERELEASE \
+                                            TLM_VERSION_STRING_PRE_END \
+                                            TLM_VERSION_ORIGINATOR
+
+#define TLM_VERSION_STRING_2                "TLM " \
+                                            TLM_VERSION_STRING_MMP \
+                                            " --- " \
+                                            TLM_VERSION_RELEASE_YEAR \
+                                            "-" \
+                                            TLM_VERSION_RELEASE_MONTH \
+                                            "-" \
+                                            TLM_VERSION_RELEASE_DAY
+
+#define TLM_VERSION                         TLM_VERSION_STRING
+
+/********************************* compiler symbols **************************************/
+
+const unsigned int tlm_version_major        ( TLM_VERSION_MAJOR               );
+const unsigned int tlm_version_minor        ( TLM_VERSION_MINOR               );
+const unsigned int tlm_version_patch        ( TLM_VERSION_PATCH               );
+
+const bool         tlm_is_prerelease        ( TLM_IS_PRERELEASE               );
+
+const std::string  tlm_version_string       ( TLM_VERSION_STRING              );
+const std::string  tlm_version_originator   ( TLM_VERSION_ORIGINATOR          );
+const std::string  tlm_version_prerelease   ( TLM_VERSION_PRERELEASE          );
+const std::string  tlm_version_release_date ( TLM_VERSION_STRING_RELEASE_DATE );
+const std::string  tlm_copyright_string     ( TLM_COPYRIGHT                   );
+const std::string  tlm_version_string_2     ( TLM_VERSION_STRING_2            );
+
+inline const char*
+tlm_release
+( void
+)
+{
+  return tlm_version_string.c_str ();
+}
+
+inline const char*
+tlm_version
+( void
+)
+{
+  return tlm_version_string_2.c_str ();
+}
+
+inline const char*
+tlm_copyright
+( void
+)
+{
+  return tlm_copyright_string.c_str ();
+}
+
+} // namespace tlm
+
+#endif /* __TLM_VERSION_H__ */
diff --git a/ext/systemc/src/tlm_utils/README.txt b/ext/systemc/src/tlm_utils/README.txt
new file mode 100644
index 000000000..8be587bdf
--- /dev/null
+++ b/ext/systemc/src/tlm_utils/README.txt
@@ -0,0 +1,85 @@
+
+TLM-2.0 standard utilities
+==========================
+
+Dir: include/tlm_utils
+
+SubDirs:
+
+Files: README.txt
+       instance_specific_extensions.h
+       multi_passthrough_initiator_socket.h
+       multi_passthrough_target_socket.h
+       multi_socket_bases.h
+       peq_with_get.h
+       simple_initiator_socket.h
+       simple_target_socket.h
+       peq_with_cb_and_phase.h
+       passthrough_target_socket.h
+       tlm_quantumkeeper.h
+
+
+Comments
+========
+
+This directory contains a number of ease-of-use and convenience implementations
+for the interoperability standard. All objects defined in the header files of
+this directory are contained in the tlm_util namespace.
+There is no tlm_utils.h header files containing all includes in order to avoid
+additional dependencies for TLM 2.0
+
+Files:
+  simple_initiator_socket.h
+     version of an initiator socket that has a default implementation of all
+     interfaces and allows to register an implementation for any of the
+     interfaces to the socket, either unique interfaces or tagged interfaces
+     (carrying an additional id)
+
+  simple_target_socket.h
+     version of a target socket that has a default implementation of all
+     interfaces and allows to register an implementation for any of the
+     interfaces to the socket, either unique interfaces or tagged interfaces
+     (carrying an additional id)
+     This socket allows to register only 1 of the transport interfaces
+     (blocking or non-blocking) and implements a conversion in case the
+     socket is used on the other interface
+
+  passthrough_target_socket.h
+     version of a target socket that has a default implementation of all
+     interfaces and allows to register an implementation for any of the
+     interfaces to the socket.
+
+  multi_passthrough_initiator_socket.h
+     an implementation of a socket that allows to bind multiple targets to the
+     same initiator socket. Implements a mechanism to allow to identify in the
+     backward path through which index of the socket the call passed through
+
+  multi_passthrough_target_socket.h
+     an implementation of a socket that allows to bind multiple initiators to
+     the same target socket. Implements a mechanism to allow to identify in the
+     forward path through which index of the socket the call passed through
+
+  multi_socket_bases.h
+     contains base class definitions used by the multi_passthrough sockets
+
+  peq_with_get.h
+     payload event queue (PEQ) implementation using a pull interface.
+     Has a get_next_transaction API that returns the transaction that is
+     scheduled in the event queue
+
+  peq_with_cb_and_phase.h
+     another payload event queue, this one with a push interface (callback
+     mechanism ). Allows to register a callback that will be called whenever
+     the event in the event queue is triggered, the callback gets transaction
+     and phase as arguments
+
+  instance_specific_extensions.h
+     is an implementation for adding extentions in the generic payload that
+     are specific to an instance along the path of a transaction, to allow that
+     extentions of the same type can be used by the different blocks along
+     the path of the transaction
+
+  tlm_quantumkeeper.h
+     is an convenience object used to keep track of the local time in
+     an initiator (how much it has run ahead of the SystemC time), to
+     synchronize with SystemC time etc.
diff --git a/ext/systemc/src/tlm_utils/instance_specific_extensions.h b/ext/systemc/src/tlm_utils/instance_specific_extensions.h
new file mode 100644
index 000000000..b17b86219
--- /dev/null
+++ b/ext/systemc/src/tlm_utils/instance_specific_extensions.h
@@ -0,0 +1,306 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+ 
+/*
+Instance specific extensions, are extension that only a single instance of a module
+may access. They are invisible to all other modules; they are private to this
+instance so to speak.
+
+As they are only of value to a certain instance, this instance knows very well
+when it needs them and when it does not need them any longer (usually when
+a transaction passes through a module for the last time).
+It does not have to care if anyone else in the system may still have a
+reference to the transaction as this one is not able to access the extension
+anyway.
+Therefore the instance is obliged to call set_extension when it wants to add a
+private extension and clear_extension when it does not need it any more.
+
+To get access to an instance specifc extension the module must own a so called
+instance_specific_extension_accessor that provides the exclusive access rights.
+Assuming the instance_specific_extension_accessor of a given module is called m_accessor
+and the transaction of which the private extension is about to be accessed
+is called txn, then the calls have to be
+
+m_accessor(txn).set_extension(...);
+or
+m_accessor(txn).clear_extension(...);
+
+The owner of the private extension is responsible to allocate/deallocate
+the extension before/after setting/clearing the extension.
+*/
+ 
+#ifndef __INSTANCE_SPECIFIC_EXTENSIONS_H__
+#define __INSTANCE_SPECIFIC_EXTENSIONS_H__
+
+#include <tlm>
+
+namespace tlm_utils {
+
+//Helper to do the numbering of private extension accessors
+inline unsigned int max_num_ispex_accessors(bool increment=false)
+{
+    static unsigned int max_num = 0;
+    if (increment) ++max_num;
+    return max_num;
+}
+
+//Helper to do the index generation for private extensions
+inline unsigned int max_num_ispex(bool increment=false)
+{
+    static unsigned int max_num = 0;
+    if (increment) ++max_num;
+    return max_num;
+}
+
+//The private extension base. Similar to normal extension base, but without clone and free
+class ispex_base
+{
+public:
+    virtual ~ispex_base() {}
+protected:
+    static unsigned int register_private_extension()
+    {
+        return (max_num_ispex(true) - 1);
+    };
+};
+
+//The templated private extension. Similar to normal extension
+template <typename T>
+class
+instance_specific_extension : public ispex_base{
+public:
+    virtual ~instance_specific_extension() {}
+    const static unsigned int priv_id;
+};
+
+template <typename T>
+const
+unsigned int instance_specific_extension<T>::priv_id = ispex_base::register_private_extension();
+
+
+//this thing is basically a snippet of the generic_payload
+// it contains all the extension specific code (the extension API so to speak)
+// the differences are:
+// - it calls back to its owner whenever a real (==non-NULL) extension gets set for the first time
+// - it calls back to its owner whenever a living (==non-NULL) extension gets cleared
+template<typename U>
+class instance_specific_extensions_per_accessor{
+public:
+
+  typedef void (U::*cb)();
+
+  instance_specific_extensions_per_accessor(U* container, cb inc, cb dec): m_container(container), m_inc(inc), m_dec(dec){
+  }
+
+  template <typename T> T* set_extension(T* ext)
+  {
+      resize_extensions();
+      T* tmp = static_cast<T*>(m_extensions[T::priv_id]);
+      m_extensions[T::priv_id] = static_cast<ispex_base*>(ext);
+      if (!tmp && ext) (m_container->*m_inc)();
+      return tmp;
+  }
+  // non-templatized version with manual index:
+  ispex_base* set_extension(unsigned int index,
+                                    ispex_base* ext)
+  {
+      resize_extensions();
+      ispex_base* tmp = m_extensions[index];
+      m_extensions[index] = ext;
+      if (!tmp && ext) (m_container->*m_inc)();
+      return tmp;
+  }
+
+  // Check for an extension, ext will point to 0 if not present
+  template <typename T> void get_extension(T*& ext) const
+  {
+      ext = static_cast<T*>(m_extensions[T::priv_id]);
+  }
+  // Non-templatized version:
+   ispex_base* get_extension(unsigned int index) const
+  {
+      return m_extensions[index];
+  }
+
+  // Clear extension, the argument is needed to find the right index:
+  template <typename T> void clear_extension(const T* ext)
+  {
+      resize_extensions();
+      if (m_extensions[T::priv_id]) (m_container->*m_dec)();
+      m_extensions[T::priv_id] = static_cast<ispex_base*>(0);
+  }
+  // Non-templatized version with manual index
+  void clear_extension(unsigned int index)
+  {
+      if (index < m_extensions.size())
+      {
+          if (m_extensions[index]) (m_container->*m_dec)();
+          m_extensions[index] = static_cast<ispex_base*>(0);
+      }
+  }
+
+  // Make sure the extension array is large enough. Can be called once by
+  // an initiator module (before issuing the first transaction) to make
+  // sure that the extension array is of correct size. This is only needed
+  // if the initiator cannot guarantee that the generic payload object is
+  // allocated after C++ static construction time.
+  void resize_extensions()
+  {
+      m_extensions.expand(max_num_ispex());
+  }
+  
+private:
+  tlm::tlm_array<ispex_base*> m_extensions;
+  U* m_container;
+  cb m_inc, m_dec;
+  
+};
+
+class instance_specific_extension_container;
+
+
+//the pool for the container, plain as can be
+class instance_specific_extension_container_pool{
+  friend class instance_specific_extension_carrier;
+  friend class instance_specific_extension_container;
+  instance_specific_extension_container_pool() : unused(NULL){}
+  inline ~instance_specific_extension_container_pool();
+  inline static instance_specific_extension_container_pool& get_ispexcont_pool(){ static instance_specific_extension_container_pool tmp; return tmp;}
+  inline instance_specific_extension_container* create();
+  inline void free(instance_specific_extension_container*);
+  
+  instance_specific_extension_container* unused;
+};
+
+class instance_specific_extension_carrier;
+
+//this thing contains the vector of extensions per accessor
+//which can be really large so this one should be pool allocated
+// therefore it keeps a use_count of itself to automatically free itself
+// - to this end it provides callbacks to the extensions per accessor
+//   to increment and decrement the use_count
+class instance_specific_extension_container{
+  friend class instance_specific_extension_container_pool;
+  friend class instance_specific_extension_accessor;
+  friend class instance_specific_extension_carrier;
+  
+  instance_specific_extension_container(): use_count(0), next(NULL){resize();}
+  
+  void resize(){
+    m_ispex_per_accessor.resize(max_num_ispex_accessors());
+    for (unsigned int i=0; i<m_ispex_per_accessor.size(); i++) {
+      m_ispex_per_accessor[i]=new instance_specific_extensions_per_accessor<instance_specific_extension_container>(this, 
+                                                                                   &instance_specific_extension_container::inc_use_count, 
+                                                                                   &instance_specific_extension_container::dec_use_count
+                                                                                   );
+      m_ispex_per_accessor[i]->resize_extensions();
+    }
+  }
+ 
+  ~instance_specific_extension_container(){
+    for (unsigned int i=0; i<m_ispex_per_accessor.size(); i++) delete m_ispex_per_accessor[i];
+  }
+ 
+  void inc_use_count(){use_count++;}
+  inline void dec_use_count();
+  
+  std::vector<instance_specific_extensions_per_accessor<instance_specific_extension_container>* > m_ispex_per_accessor; 
+  unsigned int use_count;
+  tlm::tlm_generic_payload* my_txn;
+  instance_specific_extension_carrier* my_carrier;
+  instance_specific_extension_container* next; //for pooling
+};
+
+
+inline instance_specific_extension_container_pool::~instance_specific_extension_container_pool(){
+  while(unused) { instance_specific_extension_container* tmp=unused; unused=unused->next; delete tmp;}
+}
+
+instance_specific_extension_container* instance_specific_extension_container_pool::create(){
+  if (!unused) {unused=new instance_specific_extension_container();}
+  instance_specific_extension_container* tmp=unused;
+  unused=unused->next;
+  return tmp; 
+}
+
+void instance_specific_extension_container_pool::free(instance_specific_extension_container* cont){
+  cont->next=unused;
+  unused=cont;
+}
+
+//This is the class that actually sits in the extension array
+//we keep this small since that one gets allocated and deallocated all the times
+class instance_specific_extension_carrier: public tlm::tlm_extension<instance_specific_extension_carrier>{
+  friend class instance_specific_extension_accessor;
+
+public:
+  instance_specific_extension_carrier(){
+    m_container=instance_specific_extension_container_pool::get_ispexcont_pool().create();
+    m_container->my_carrier=this;
+  }
+  
+  virtual tlm::tlm_extension_base* clone() const {
+    //we don't clone since private info is instance specific and associated to a given txn (the original)
+    //so the deep copied txn will be virgin in terms of private info
+    return NULL;
+  }
+  void copy_from(tlm::tlm_extension_base const &){return;}
+  void free(){return;}
+private:
+  instance_specific_extension_container* m_container;
+};
+
+inline void instance_specific_extension_container::dec_use_count(){
+  if ((--use_count)==0) { //if this container isn't used any more
+    instance_specific_extension_container_pool::get_ispexcont_pool().free(this);  //we send it back to our pool
+    //we have to do that manually, as we cannot rely on the fact that there is MM in the txn
+    my_txn->clear_extension(my_carrier); //and remove it from the transaction's extension array
+    delete my_carrier;
+  }
+}
+
+
+//This class 'hides' all the instance specific extension stuff from the user
+// he instantiates one of those (e.g. instance_specific_extension_accessor extAcc;) and can then access
+// the private extensions
+//    extAcc(txn).extensionAPIFnCall()
+//  where extensionAPIFnCall is set_extension, get_extension, clear_extension,...
+class instance_specific_extension_accessor{
+public:
+  instance_specific_extension_accessor(): m_index(max_num_ispex_accessors(true)-1){}
+  
+  template<typename T>
+  inline instance_specific_extensions_per_accessor<instance_specific_extension_container>& operator()(T& txn){
+    instance_specific_extension_carrier* carrier;
+    txn.get_extension(carrier);
+    if (!carrier){
+      carrier=new instance_specific_extension_carrier();
+      carrier->m_container->my_txn=&txn;
+      txn.set_extension(carrier);
+    }
+    return *(carrier->m_container->m_ispex_per_accessor[m_index]);
+  }
+  
+protected:
+  unsigned int m_index;
+};
+
+}
+
+#endif
diff --git a/ext/systemc/src/tlm_utils/multi_passthrough_initiator_socket.h b/ext/systemc/src/tlm_utils/multi_passthrough_initiator_socket.h
new file mode 100644
index 000000000..6404d84bb
--- /dev/null
+++ b/ext/systemc/src/tlm_utils/multi_passthrough_initiator_socket.h
@@ -0,0 +1,299 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+#ifndef __MULTI_PASSTHROUGH_INITIATOR_SOCKET_H__
+#define __MULTI_PASSTHROUGH_INITIATOR_SOCKET_H__
+
+#include "multi_socket_bases.h"
+
+namespace tlm_utils {
+
+/*
+This class implements a trivial multi initiator socket.
+The triviality refers to the fact that the socket does not
+do blocking to non-blocking or non-blocking to blocking conversions.
+
+It allows to connect multiple targets to this socket.
+The user has to register callbacks for the bw interface methods
+he likes to use. The callbacks are basically equal to the bw interface
+methods but carry an additional integer that indicates to which
+index of this socket the calling target is connected.
+*/
+template <typename MODULE,
+          unsigned int BUSWIDTH = 32,
+          typename TYPES = tlm::tlm_base_protocol_types,
+          unsigned int N=0
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+          ,sc_core::sc_port_policy POL = sc_core::SC_ONE_OR_MORE_BOUND
+#endif
+          >
+class multi_passthrough_initiator_socket: public multi_init_base< BUSWIDTH,
+                                                        TYPES,
+                                                        N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+                                                        ,POL
+#endif
+                                                        >
+{
+
+public:
+
+  //typedefs
+  //  tlm 2.0 types for nb_transport
+  typedef typename TYPES::tlm_payload_type              transaction_type;
+  typedef typename TYPES::tlm_phase_type                phase_type;
+  typedef tlm::tlm_sync_enum                            sync_enum_type;
+
+  //  typedefs to keep the fn ptr notations short
+  typedef sync_enum_type (MODULE::*nb_cb)(int,
+                                         transaction_type&,
+                                         phase_type&,
+                                         sc_core::sc_time&);
+  typedef void (MODULE::*dmi_cb)(int, sc_dt::uint64, sc_dt::uint64);
+
+  typedef multi_init_base<BUSWIDTH,
+                        TYPES,
+                        N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+                        ,POL
+#endif
+                        > base_type;
+
+  typedef typename base_type::base_target_socket_type base_target_socket_type;
+
+  //CTOR
+  multi_passthrough_initiator_socket()
+      : base_type(sc_core::sc_gen_unique_name("multi_passthrough_initiator_socket"))
+      , m_hierarch_bind(0)
+      , m_beoe_disabled(false)
+      , m_dummy(42)
+  {
+  }
+
+  //CTOR
+  multi_passthrough_initiator_socket(const char* name)
+      : base_type(name)
+      , m_hierarch_bind(0)
+      , m_beoe_disabled(false)
+      , m_dummy(42)
+  {
+  }
+
+  ~multi_passthrough_initiator_socket(){
+    //clean up everything allocated by 'new'
+    for (unsigned int i=0; i<m_binders.size(); i++) delete m_binders[i];
+  }
+
+  //simple helpers for warnings an errors to shorten in code notation
+  void display_warning(const std::string& text) const {
+    std::stringstream s;
+    s<<"WARNING in instance "<<base_type::name()<<": "<<text;
+    SC_REPORT_WARNING("/OSCI_TLM-2/multi_socket", s.str().c_str());
+  }
+
+  void display_error(const std::string& text) const {
+    std::stringstream s;
+    s<<"ERROR in instance "<<base_type::name()<<": "<<text;
+    SC_REPORT_ERROR("/OSCI_TLM-2/multi_socket", s.str().c_str());
+  }
+
+
+  //register callback for nb transport of bw interface
+  void register_nb_transport_bw(MODULE* mod,
+                              sync_enum_type (MODULE::*cb)(int,
+                                                           transaction_type&,
+                                                           phase_type&,
+                                                           sc_core::sc_time&))
+  {
+    //warn if there already is a callback
+    if (!m_nb_f.empty()){
+      display_warning("NBTransport_bw callback already registered.");
+      return;
+    }
+
+    //set the functor
+    m_nb_f.set_function(mod, cb);
+  }
+
+  //register callback for dmi function of bw interface
+  void register_invalidate_direct_mem_ptr(MODULE* mod,
+                             void (MODULE::*cb)(int, sc_dt::uint64, sc_dt::uint64))
+  {
+    //warn if there already is a callback
+    if (!m_dmi_f.empty()){
+      display_warning("InvalidateDMI callback already registered.");
+      return;
+    }
+
+    //set the functor
+    m_dmi_f.set_function(mod, cb);
+  }
+
+  //Override virtual functions of the tlm_initiator_socket:
+  // this function is called whenever an sc_port (as part of a target socket)
+  //  wants to bind to the export of the underlying tlm_initiator_socket
+  //At this time a callback binder is created an returned to the sc_port
+  // of the target socket, so that it binds to the callback binder
+  virtual tlm::tlm_bw_transport_if<TYPES>& get_base_interface()
+  {
+    m_binders.push_back(new callback_binder_bw<TYPES>(m_binders.size()));
+    return *m_binders[m_binders.size()-1];
+  }
+
+  // const overload not allowed for multi-sockets
+  virtual const tlm::tlm_bw_transport_if<TYPES>& get_base_interface() const
+  {
+    display_error("'get_base_interface()' const not allowed for multi-sockets.");
+    return base_type::get_base_interface();
+  }
+
+  //Override virtual functions of the tlm_initiator_socket:
+  // this function is called whenever an sc_export (as part of a initiator socket)
+  //  wants to bind to the export of the underlying tlm_initiator_socket
+  //   i.e. a hierarchical bind takes place
+  virtual sc_core::sc_export<tlm::tlm_bw_transport_if<TYPES> >& get_base_export()
+  {
+    if (!m_beoe_disabled) //we are not bound hierarchically
+      base_type::m_export.bind(m_dummy);  //so we bind the dummy to avoid a SystemC error
+    return base_type::get_base_export(); //and then return our own export so that the hierarchical binding is set up properly
+  }
+
+  virtual const sc_core::sc_export<tlm::tlm_bw_transport_if<TYPES> >& get_base_export() const
+  {
+    return base_type::get_base_export();
+  }
+
+  //bind against a target socket
+  virtual void bind(base_target_socket_type& s)
+  {
+    //error if this socket is already bound hierarchically
+    if (m_hierarch_bind)
+      display_error("Already hierarchically bound.");
+
+    base_type::bind(s); //satisfy systemC, leads to a call to get_base_interface()
+
+    //try to cast the target socket into a fw interface
+    sc_core::sc_export<tlm::tlm_fw_transport_if<TYPES> >* p_ex_s=dynamic_cast<sc_core::sc_export<tlm::tlm_fw_transport_if<TYPES> >*>(&s);
+    if (!p_ex_s) display_error("Multi socket not bound to tlm_socket.");
+
+    //try a cast into a multi sockets
+    multi_to_multi_bind_base<TYPES>* test=dynamic_cast<multi_to_multi_bind_base<TYPES>*> (p_ex_s);
+    if (test) //did we just do a multi-multi bind??
+      //if that is the case the multi target socket must have just created a callback binder
+      // which we want to get from it.
+      //Moreover, we also just created one, which we will pass to it.
+      m_sockets.push_back(test->get_last_binder(m_binders[m_binders.size()-1]));
+    else{  // if not just bind normally
+      sc_core::sc_export<tlm::tlm_fw_transport_if<TYPES> >& ex_s=*p_ex_s;
+      m_sockets.push_back(&((tlm::tlm_fw_transport_if<TYPES>&)ex_s)); //store the interface we are bound against
+    }
+  }
+
+  //operator notation for direct bind
+  void operator() (base_target_socket_type& s)
+  {
+    bind(s);
+  }
+
+  //SystemC standard callback before end of elaboration
+  void before_end_of_elaboration(){
+    //if our export hasn't been bound yet (due to a hierarch binding)
+    // we bind it now to avoid a SystemC error.
+    //We must do that, because it is legal not to register a callback on this socket
+    // as the user might only use b_transport
+    if (!base_type::m_export.get_interface()){
+      base_type::m_export.bind(m_dummy);
+    }
+
+    //'break' here if the socket was told not to do callback binding
+    if (m_beoe_disabled) return;
+
+    //get the callback binders of the top of the hierachical bind chain
+    // NOTE: this could be the same socket if there is no hierachical bind
+    std::vector<callback_binder_bw<TYPES>* >& binders=get_hierarch_bind()->get_binders();
+
+    //get the interfaces bound to the top of the hierachical bind chain
+    // NOTE: this could be the same socket if there is no hierachical bind
+    m_used_sockets=get_hierarch_bind()->get_sockets();
+
+    //register the callbacks of this socket with the callback binders
+    // we just got from the top of the hierachical bind chain
+    for (unsigned int i=0; i<binders.size(); i++) {
+      binders[i]->set_callbacks(m_nb_f, m_dmi_f);
+    }
+  }
+
+  //
+  // Bind multi initiator socket to multi initiator socket (hierarchical bind)
+  //
+  virtual void bind(base_type& s)
+  {
+    if (m_binders.size()) //a multi socket is either bound hierarchically or directly
+      display_error("Socket already directly bound.");
+    if (m_hierarch_bind){
+      display_warning("Socket already bound hierarchically. Bind attempt ignored.");
+      return;
+    }
+
+    //remember to which socket we are hierarchically bound and disable it,
+    // so that it won't try to register callbacks itself
+    s.disable_cb_bind();
+    m_hierarch_bind=&s;
+    base_type::bind(s); //satisfy SystemC
+  }
+
+  //operator notation for hierarchical bind
+  void operator() (base_type& s)
+  {
+    bind(s);
+  }
+
+  //get access to sub port
+  tlm::tlm_fw_transport_if<TYPES>* operator[](int i){return m_used_sockets[i];}
+
+  //get the number of bound targets
+  // NOTE: this is only valid at end of elaboration!
+  unsigned int size() {return get_hierarch_bind()->get_sockets().size();}
+
+protected:
+  //implementation of base class interface
+  base_type* get_hierarch_bind(){if (m_hierarch_bind) return m_hierarch_bind->get_hierarch_bind(); else return this;}
+  void disable_cb_bind(){ m_beoe_disabled=true;}
+  std::vector<callback_binder_bw<TYPES>* >& get_binders(){return m_binders;}
+  std::vector<tlm::tlm_fw_transport_if<TYPES>*>& get_sockets(){return m_sockets;}
+  //vector of connected sockets
+  std::vector<tlm::tlm_fw_transport_if<TYPES>*> m_sockets;
+  std::vector<tlm::tlm_fw_transport_if<TYPES>*> m_used_sockets;
+  //vector of binders that convert untagged interface into tagged interface
+  std::vector<callback_binder_bw<TYPES>*> m_binders;
+
+  base_type*  m_hierarch_bind; //pointer to hierarchical bound multi port
+  bool m_beoe_disabled;  // bool that remembers whether this socket shall bind callbacks or not
+  callback_binder_bw<TYPES> m_dummy; //a callback binder that is bound to the underlying export
+                                     // in case there was no real bind
+
+  //callbacks as functors
+  // (allows to pass the callback to another socket that does not know the type of the module that owns
+  //  the callbacks)
+  typename callback_binder_bw<TYPES>::nb_func_type  m_nb_f;
+  typename callback_binder_bw<TYPES>::dmi_func_type m_dmi_f;
+};
+
+}
+
+#endif
diff --git a/ext/systemc/src/tlm_utils/multi_passthrough_target_socket.h b/ext/systemc/src/tlm_utils/multi_passthrough_target_socket.h
new file mode 100644
index 000000000..03270f7a1
--- /dev/null
+++ b/ext/systemc/src/tlm_utils/multi_passthrough_target_socket.h
@@ -0,0 +1,340 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+#ifndef __MULTI_PASSTHROUGH_TARGET_SOCKET_H__
+#define __MULTI_PASSTHROUGH_TARGET_SOCKET_H__
+
+#include "tlm_utils/multi_socket_bases.h"
+#include <sstream>
+
+namespace tlm_utils {
+
+/*
+This class implements a trivial multi target socket.
+The triviality refers to the fact that the socket does not
+do blocking to non-blocking or non-blocking to blocking conversions.
+
+It allows to connect multiple initiators to this socket.
+The user has to register callbacks for the fw interface methods
+he likes to use. The callbacks are basically equal to the fw interface
+methods but carry an additional integer that indicates to which
+index of this socket the calling initiator is connected.
+*/
+template <typename MODULE,
+          unsigned int BUSWIDTH = 32,
+          typename TYPES = tlm::tlm_base_protocol_types,
+          unsigned int N=0
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+          ,sc_core::sc_port_policy POL = sc_core::SC_ONE_OR_MORE_BOUND
+#endif
+          >
+class multi_passthrough_target_socket: public multi_target_base< BUSWIDTH,
+                                                        TYPES,
+                                                        N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+                                                        ,POL
+#endif
+                                                        >
+                              , public multi_to_multi_bind_base<TYPES>
+{
+
+public:
+
+  //typedefs
+  //  tlm 2.0 types for nb_transport
+  typedef typename TYPES::tlm_payload_type              transaction_type;
+  typedef typename TYPES::tlm_phase_type                phase_type;
+  typedef tlm::tlm_sync_enum                            sync_enum_type;
+
+  //  typedefs to keep the fn ptr notations short
+  typedef sync_enum_type (MODULE::*nb_cb)(int, transaction_type&, phase_type&, sc_core::sc_time&);
+  typedef void (MODULE::*b_cb)(int, transaction_type&, sc_core::sc_time&);
+  typedef unsigned int (MODULE::*dbg_cb)(int, transaction_type& txn);
+  typedef bool (MODULE::*dmi_cb)(int, transaction_type& txn, tlm::tlm_dmi& dmi);
+
+  typedef multi_target_base<BUSWIDTH,
+                        TYPES,
+                        N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+                        ,POL
+#endif
+                        > base_type;
+
+  typedef typename base_type::base_initiator_socket_type base_initiator_socket_type;
+
+  //CTOR
+  multi_passthrough_target_socket()
+      : base_type(sc_core::sc_gen_unique_name("multi_passthrough_target_socket"))
+      , m_hierarch_bind(0)
+      , m_eoe_disabled(false)
+      , m_export_callback_created(false)
+  {
+  }
+
+  //CTOR
+  multi_passthrough_target_socket(const char* name)
+      : base_type(name)
+      , m_hierarch_bind(0)
+      , m_eoe_disabled(false)
+      , m_export_callback_created(false)
+  {
+  }
+
+  ~multi_passthrough_target_socket(){
+    //clean up everything allocated by 'new'
+    for (unsigned int i=0; i<m_binders.size(); i++) delete m_binders[i];
+  }
+
+  //simple helpers for warnings an errors to shorten in code notation
+  void display_warning(const std::string& text) const {
+    std::stringstream s;
+    s<<"WARNING in instance "<<base_type::name()<<": "<<text;
+    SC_REPORT_WARNING("/OSCI_TLM-2/multi_socket", s.str().c_str());
+  }
+
+  void display_error(const std::string& text) const {
+    std::stringstream s;
+    s<<"ERROR in instance "<<base_type::name()<<": "<<text;
+    SC_REPORT_ERROR("/OSCI_TLM-2/multi_socket", s.str().c_str());
+  }
+
+  void check_export_binding()
+  {
+    //if our export hasn't been bound yet (due to a hierarch binding)
+    //  we bind it now.
+    //We do that here as the user of the target port HAS to bind at least on callback,
+    //otherwise the socket was useless. Nevertheless, the target socket may still
+    // stay unbound afterwards.
+    if (!sc_core::sc_export<tlm::tlm_fw_transport_if<TYPES> >::get_interface())
+    {
+      // We bind to a callback_binder that will be used as the first interface
+      // i.e. calls to the sc_export will have the same ID as calls from the first initator
+      // socket bound
+      callback_binder_fw<TYPES> * binder;
+
+      if (m_binders.size() == 0)
+      {
+        binder = new callback_binder_fw<TYPES>(m_binders.size());
+        m_binders.push_back(binder);
+        m_export_callback_created = true;
+      }
+      else
+      {
+        binder = m_binders[0];
+      }
+
+      sc_core::sc_export<tlm::tlm_fw_transport_if<TYPES> >::bind(*binder);
+    }
+  }
+
+  //register callback for nb transport of fw interface
+  void register_nb_transport_fw(MODULE* mod,
+                              nb_cb cb)
+  {
+    check_export_binding();
+
+    //warn if there already is a callback
+    if (!m_nb_f.empty()){
+      display_warning("NBTransport_bw callback already registered.");
+      return;
+    }
+
+    //set the functor
+    m_nb_f.set_function(mod, cb);
+  }
+
+  //register callback for b transport of fw interface
+  void register_b_transport(MODULE* mod,
+                              b_cb cb)
+  {
+    check_export_binding();
+
+    //warn if there already is a callback
+    if (!m_b_f.empty()){
+      display_warning("BTransport callback already registered.");
+      return;
+    }
+
+    //set the functor
+    m_b_f.set_function(mod, cb);
+  }
+
+  //register callback for debug transport of fw interface
+  void register_transport_dbg(MODULE* mod,
+                              dbg_cb cb)
+  {
+    check_export_binding();
+
+    //warn if there already is a callback
+    if (!m_dbg_f.empty()){
+      display_warning("DebugTransport callback already registered.");
+      return;
+    }
+
+    //set the functor
+    m_dbg_f.set_function(mod, cb);
+  }
+
+  //register callback for DMI of fw interface
+  void register_get_direct_mem_ptr(MODULE* mod,
+                                   dmi_cb cb)
+  {
+    check_export_binding();
+
+    //warn if there already is a callback
+    if (!m_dmi_f.empty()){
+      display_warning("DMI callback already registered.");
+      return;
+    }
+
+    //set the functor
+    m_dmi_f.set_function(mod, cb);
+  }
+
+
+  //Override virtual functions of the tlm_target_socket:
+  // this function is called whenever an sc_port (as part of a init socket)
+  //  wants to bind to the export of the underlying tlm_target_socket
+  //At this time a callback binder is created an returned to the sc_port
+  // of the init socket, so that it binds to the callback binder
+  virtual tlm::tlm_fw_transport_if<TYPES>& get_base_interface()
+  {
+    //error if this socket is already bound hierarchically
+    if (m_hierarch_bind) display_error("Socket already bound hierarchically.");
+
+    if (!m_export_callback_created)
+      m_binders.push_back(new callback_binder_fw<TYPES>(m_binders.size()));
+    else
+      m_export_callback_created = false;
+
+    return *m_binders[m_binders.size()-1];
+  }
+
+  // const overload not allowed for multi-sockets
+  virtual const tlm::tlm_fw_transport_if<TYPES>& get_base_interface() const
+  {
+    display_error("'get_base_interface()' const not allowed for multi-sockets.");
+    return base_type::get_base_interface();
+  }
+
+  //just return the export of the underlying tlm_target_socket in case of a hierarchical bind
+  virtual sc_core::sc_export<tlm::tlm_fw_transport_if<TYPES> >& get_base_export()
+  {
+    return *this;
+  }
+
+  //just return the export of the underlying tlm_target_socket in case of a hierarchical bind
+  virtual const sc_core::sc_export<tlm::tlm_fw_transport_if<TYPES> >& get_base_export() const
+  {
+    return base_type::get_base_export();
+  }
+
+  //the standard end of elaboration callback
+  void end_of_elaboration(){
+    //'break' here if the socket was told not to do callback binding
+    if (m_eoe_disabled) return;
+
+    //get the callback binders and the multi binds of the top of the hierachical bind chain
+    // NOTE: this could be the same socket if there is no hierachical bind
+    std::vector<callback_binder_fw<TYPES>* >& binders=get_hierarch_bind()->get_binders();
+    std::map<unsigned int, tlm::tlm_bw_transport_if<TYPES>*>&  multi_binds=get_hierarch_bind()->get_multi_binds();
+
+    //iterate over all binders
+    for (unsigned int i=0; i<binders.size(); i++) {
+      binders[i]->set_callbacks(m_nb_f, m_b_f, m_dmi_f, m_dbg_f); //set the callbacks for the binder
+      if (multi_binds.find(i)!=multi_binds.end()) //check if this connection is multi-multi
+        //if so remember the interface
+        m_sockets.push_back(multi_binds[i]);
+      else{ //if we are bound to a normal socket
+        //get the calling port and try to cast it into a tlm socket base
+        base_initiator_socket_type* test=dynamic_cast<base_initiator_socket_type*>(binders[i]->get_other_side());
+        if (!test){display_error("Not bound to tlm_socket.");}
+        m_sockets.push_back(&test->get_base_interface()); //remember the interface
+      }
+    }
+  }
+
+  //
+  // Bind multi target socket to multi target socket (hierarchical bind)
+  //
+  virtual void bind(base_type& s)
+  {
+    //warn if already bound hierarchically
+    if (m_eoe_disabled){
+      display_warning("Socket already bound hierarchically. Bind attempt ignored.");
+      return;
+    }
+
+    //disable our own end of elaboration call
+    disable_cb_bind();
+
+    //inform the bound target socket that it is bound hierarchically now
+    s.set_hierarch_bind((base_type*)this);
+    base_type::bind(s); //satisfy SystemC
+  }
+
+  //operator notation for hierarchical bind
+  void operator() (base_type& s)
+  {
+    bind(s);
+  }
+
+  //get access to sub port
+  tlm::tlm_bw_transport_if<TYPES>* operator[](int i){return m_sockets[i];}
+
+  //get number of bound initiators
+  // NOTE: this is only valid at end of elaboration!
+  unsigned int size(){return get_hierarch_bind()->get_binders().size();}
+
+protected:
+  //implementation of base class interface
+  base_type* get_hierarch_bind(){if (m_hierarch_bind) return m_hierarch_bind->get_hierarch_bind(); else return this;}
+  std::map<unsigned int, tlm::tlm_bw_transport_if<TYPES>*>&  get_multi_binds(){return m_multi_binds;}
+  void set_hierarch_bind(base_type* h){m_hierarch_bind=h;}
+  tlm::tlm_fw_transport_if<TYPES>* get_last_binder(tlm::tlm_bw_transport_if<TYPES>* other){
+    m_multi_binds[m_binders.size()-1]=other;
+    return m_binders[m_binders.size()-1];
+  }
+
+  //map that stores to which index a multi init socket is connected
+  // and the interface of the multi init socket
+  std::map<unsigned int, tlm::tlm_bw_transport_if<TYPES>*> m_multi_binds;
+
+  void disable_cb_bind(){ m_eoe_disabled=true;}
+  std::vector<callback_binder_fw<TYPES>* >& get_binders(){return m_binders;}
+  //vector of connected sockets
+  std::vector<tlm::tlm_bw_transport_if<TYPES>*> m_sockets;
+  //vector of binders that convert untagged interface into tagged interface
+  std::vector<callback_binder_fw<TYPES>*> m_binders;
+
+  base_type*  m_hierarch_bind; //pointer to hierarchical bound multi port
+  bool m_eoe_disabled; //bool that diables callback bindings at end of elaboration
+  bool m_export_callback_created; // bool to indicate that a callback has already been created for export binding
+
+  //callbacks as functors
+  // (allows to pass the callback to another socket that does not know the type of the module that owns
+  //  the callbacks)
+  typename callback_binder_fw<TYPES>::nb_func_type    m_nb_f;
+  typename callback_binder_fw<TYPES>::b_func_type     m_b_f;
+  typename callback_binder_fw<TYPES>::debug_func_type m_dbg_f;
+  typename callback_binder_fw<TYPES>::dmi_func_type   m_dmi_f;
+};
+
+}
+
+#endif
diff --git a/ext/systemc/src/tlm_utils/multi_socket_bases.h b/ext/systemc/src/tlm_utils/multi_socket_bases.h
new file mode 100644
index 000000000..457398495
--- /dev/null
+++ b/ext/systemc/src/tlm_utils/multi_socket_bases.h
@@ -0,0 +1,418 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __MULTI_SOCKET_BASES_H__
+#define __MULTI_SOCKET_BASES_H__
+
+#include <systemc>
+#include <tlm>
+
+#include <map>
+#include <sstream>
+
+namespace tlm_utils {
+
+template <typename signature>
+struct fn_container{
+  signature function;
+};
+
+#define TLM_DEFINE_FUNCTOR(name) \
+template <typename MODULE, typename TRAITS> \
+inline TLM_RET_VAL static_##name( void* mod \
+                                       , void* fn \
+                                       , int index \
+                                       , TLM_FULL_ARG_LIST) \
+{ \
+  typedef fn_container<TLM_RET_VAL (MODULE::*)(int, TLM_FULL_ARG_LIST)> fn_container_type; \
+  MODULE* tmp_mod=static_cast<MODULE*>(mod); \
+  fn_container_type* tmp_cb =static_cast<fn_container_type*> (fn); \
+  return (tmp_mod->*(tmp_cb->function))(index, TLM_ARG_LIST_WITHOUT_TYPES); \
+}\
+\
+template <typename MODULE, typename TRAITS> \
+inline void delete_fn_container_of_##name(void* fn) \
+{ \
+  typedef fn_container<TLM_RET_VAL (MODULE::*)(int, TLM_FULL_ARG_LIST)> fn_container_type; \
+  fn_container_type* tmp_cb =static_cast<fn_container_type*> (fn); \
+  if (tmp_cb) delete tmp_cb;\
+} \
+\
+template <typename TRAITS> \
+class name##_functor{ \
+public: \
+  typedef typename TRAITS::tlm_payload_type payload_type; \
+  typedef typename TRAITS::tlm_phase_type   phase_type; \
+  typedef TLM_RET_VAL (*call_fn)(void*,void*, int, TLM_FULL_ARG_LIST); \
+  typedef void (*del_fn)(void*); \
+\
+  name##_functor(): m_fn(0), m_del_fn(0), m_mod(0), m_mem_fn(0){} \
+  ~name##_functor(){if (m_del_fn) (*m_del_fn)(m_mem_fn);}  \
+\
+  template <typename MODULE> \
+  void set_function(MODULE* mod, TLM_RET_VAL (MODULE::*cb)(int, TLM_FULL_ARG_LIST)){ \
+    typedef fn_container<TLM_RET_VAL (MODULE::*)(int, TLM_FULL_ARG_LIST)> fn_container_type; \
+    m_fn=&static_##name<MODULE,TRAITS>;\
+    m_del_fn=&delete_fn_container_of_##name<MODULE,TRAITS>;\
+    m_del_fn(m_mem_fn); \
+    fn_container_type* tmp= new fn_container_type(); \
+    tmp->function=cb; \
+    m_mod=static_cast<void*>(mod); \
+    m_mem_fn=static_cast<void*>(tmp); \
+  } \
+  \
+  TLM_RET_VAL operator()(int index, TLM_FULL_ARG_LIST){ \
+    return m_fn(m_mod,m_mem_fn, index, TLM_ARG_LIST_WITHOUT_TYPES); \
+  } \
+\
+  bool empty(){return (m_mod==0 || m_mem_fn==0 || m_fn==0);}\
+\
+protected: \
+  call_fn m_fn;\
+  del_fn m_del_fn; \
+  void* m_mod; \
+  void* m_mem_fn; \
+private: \
+  name##_functor& operator=(const name##_functor&); \
+}
+
+
+#define TLM_RET_VAL tlm::tlm_sync_enum
+#define TLM_FULL_ARG_LIST typename TRAITS::tlm_payload_type& txn, typename TRAITS::tlm_phase_type& ph, sc_core::sc_time& t
+#define TLM_ARG_LIST_WITHOUT_TYPES txn,ph,t
+TLM_DEFINE_FUNCTOR(nb_transport);
+#undef TLM_RET_VAL
+#undef TLM_FULL_ARG_LIST
+#undef TLM_ARG_LIST_WITHOUT_TYPES
+
+#define TLM_RET_VAL void
+#define TLM_FULL_ARG_LIST typename TRAITS::tlm_payload_type& txn, sc_core::sc_time& t
+#define TLM_ARG_LIST_WITHOUT_TYPES txn,t
+TLM_DEFINE_FUNCTOR(b_transport);
+#undef TLM_RET_VAL
+#undef TLM_FULL_ARG_LIST
+#undef TLM_ARG_LIST_WITHOUT_TYPES
+
+#define TLM_RET_VAL unsigned int
+#define TLM_FULL_ARG_LIST typename TRAITS::tlm_payload_type& txn
+#define TLM_ARG_LIST_WITHOUT_TYPES txn
+TLM_DEFINE_FUNCTOR(debug_transport);
+#undef TLM_RET_VAL
+#undef TLM_FULL_ARG_LIST
+#undef TLM_ARG_LIST_WITHOUT_TYPES
+
+#define TLM_RET_VAL bool
+#define TLM_FULL_ARG_LIST typename TRAITS::tlm_payload_type& txn, tlm::tlm_dmi& dmi
+#define TLM_ARG_LIST_WITHOUT_TYPES txn,dmi
+TLM_DEFINE_FUNCTOR(get_dmi_ptr);
+#undef TLM_RET_VAL
+#undef TLM_FULL_ARG_LIST
+#undef TLM_ARG_LIST_WITHOUT_TYPES
+
+#define TLM_RET_VAL void
+#define TLM_FULL_ARG_LIST sc_dt::uint64 l, sc_dt::uint64 u
+#define TLM_ARG_LIST_WITHOUT_TYPES l,u
+TLM_DEFINE_FUNCTOR(invalidate_dmi);
+#undef TLM_RET_VAL
+#undef TLM_FULL_ARG_LIST
+#undef TLM_ARG_LIST_WITHOUT_TYPES
+
+#undef TLM_DEFINE_FUNCTOR
+
+/*
+This class implements the fw interface.
+It allows to register a callback for each of the fw interface methods.
+The callbacks simply forward the fw interface call, but add the id (an int)
+of the callback binder to the signature of the call.
+*/
+template <typename TYPES>
+class callback_binder_fw: public tlm::tlm_fw_transport_if<TYPES>{
+  public:
+    //typedefs according to the used TYPES class
+    typedef typename TYPES::tlm_payload_type              transaction_type;
+    typedef typename TYPES::tlm_phase_type                phase_type;  
+    typedef tlm::tlm_sync_enum                            sync_enum_type;
+  
+    //typedefs for the callbacks
+    typedef nb_transport_functor<TYPES>    nb_func_type;
+    typedef b_transport_functor<TYPES>     b_func_type;
+    typedef debug_transport_functor<TYPES> debug_func_type;
+    typedef get_dmi_ptr_functor<TYPES>     dmi_func_type;
+
+    //ctor: an ID is needed to create a callback binder
+    callback_binder_fw(int id): m_id(id), m_nb_f(0), m_b_f(0), m_dbg_f(0), m_dmi_f(0), m_caller_port(0) {
+    }
+
+    //the nb_transport method of the fw interface
+    sync_enum_type nb_transport_fw(transaction_type& txn,
+                                phase_type& p,
+                                sc_core::sc_time& t){
+      //check if a callback is registered
+      if ((m_nb_f == 0) || (m_nb_f && m_nb_f->empty())) {
+        //std::cerr<<"No function registered"<<std::endl;
+        SC_REPORT_ERROR("/OSCI_TLM-2/multi_socket","Call to nb_transport_fw without a registered callback for nb_transport_fw.");
+      }
+      else
+        return (*m_nb_f)(m_id, txn, p, t); //do the callback
+      return tlm::TLM_ACCEPTED; //unreachable
+    }
+    
+    //the b_transport method of the fw interface
+    void b_transport(transaction_type& trans,sc_core::sc_time& t){
+      //check if a callback is registered
+      if ((m_b_f == 0) || (m_b_f && m_b_f->empty())) {
+        SC_REPORT_ERROR("/OSCI_TLM-2/multi_socket","Call to b_transport without a registered callback for b_transport.");
+      }
+      else
+        (*m_b_f)(m_id, trans,t); //do the callback
+    }
+    
+    //the DMI method of the fw interface
+    bool get_direct_mem_ptr(transaction_type& trans, tlm::tlm_dmi&  dmi_data){
+      //check if a callback is registered
+      if ((m_dmi_f == 0) && (m_dmi_f && m_dmi_f->empty())) {
+        dmi_data.allow_none();
+        dmi_data.set_start_address(0x0);
+        dmi_data.set_end_address((sc_dt::uint64)-1);
+        return false;
+      }
+      else
+        return (*m_dmi_f)(m_id, trans,dmi_data); //do the callback
+    }
+    
+    //the debug method of the fw interface
+    unsigned int transport_dbg(transaction_type& trans){
+      //check if a callback is registered
+      if ((m_dbg_f == 0) || (m_dbg_f && m_dbg_f->empty())) {
+        return 0;
+      }
+      else
+        return (*m_dbg_f)(m_id, trans); //do the callback
+    }
+    
+    //the SystemC standard callback register_port:
+    // - called when a port if bound to the interface
+    // - allowd to find out who is bound to that callback binder
+    void register_port(sc_core::sc_port_base& b, const char* name){
+      m_caller_port=&b;
+    }
+    
+    //register callbacks for all fw interface methods at once
+    void set_callbacks(nb_func_type& cb1, b_func_type& cb2, dmi_func_type& cb3, debug_func_type& cb4){
+      m_nb_f=&cb1;
+      m_b_f=&cb2;
+      m_dmi_f=&cb3;
+      m_dbg_f=&cb4;
+    }
+    
+    //getter method to get the port that is bound to that callback binder
+    // NOTE: this will only return a valid value at end of elaboration
+    //  (but not before end of elaboration!)
+    sc_core::sc_port_base* get_other_side(){return m_caller_port;}
+    
+  private:
+    //the ID of the callback binder
+    int m_id; 
+    
+    //the callbacks
+    nb_func_type* m_nb_f; 
+    b_func_type*  m_b_f;
+    debug_func_type* m_dbg_f;
+    dmi_func_type* m_dmi_f;
+    
+    //the port bound to that callback binder
+    sc_core::sc_port_base* m_caller_port;   
+};
+
+/*
+This class implements the bw interface.
+It allows to register a callback for each of the bw interface methods.
+The callbacks simply forward the bw interface call, but add the id (an int)
+of the callback binder to the signature of the call.
+*/
+template <typename TYPES>
+class callback_binder_bw: public tlm::tlm_bw_transport_if<TYPES>{
+  public:
+    //typedefs according to the used TYPES class
+    typedef typename TYPES::tlm_payload_type              transaction_type;
+    typedef typename TYPES::tlm_phase_type                phase_type;  
+    typedef tlm::tlm_sync_enum                            sync_enum_type;
+  
+    //typedefs for the callbacks
+    typedef nb_transport_functor<TYPES>   nb_func_type;
+    typedef invalidate_dmi_functor<TYPES> dmi_func_type;
+
+    //ctor: an ID is needed to create a callback binder
+    callback_binder_bw(int id): m_id(id), m_nb_f(0), m_dmi_f(0) {
+    }
+
+    //the nb_transport method of the bw interface
+    sync_enum_type nb_transport_bw(transaction_type& txn,
+                                phase_type& p,
+                                sc_core::sc_time& t){
+      //check if a callback is registered
+      if ((m_nb_f == 0) || (m_nb_f && m_nb_f->empty())) {
+        SC_REPORT_ERROR("/OSCI_TLM-2/multi_socket","Call to nb_transport_bw without a registered callback for nb_transport_bw");
+      }
+      else
+        return (*m_nb_f)(m_id, txn, p, t); //do the callback
+      return tlm::TLM_ACCEPTED; //unreachable
+    }
+    
+    //the DMI method of the bw interface
+    void invalidate_direct_mem_ptr(sc_dt::uint64 l, sc_dt::uint64 u){
+      //check if a callback is registered
+      if ((m_dmi_f == 0) || (m_dmi_f && m_dmi_f->empty())) {
+        return;
+      }
+      else
+        (*m_dmi_f)(m_id,l,u); //do the callback
+    }
+
+    //register callbacks for all bw interface methods at once
+    void set_callbacks(nb_func_type& cb1, dmi_func_type& cb2){
+      m_nb_f=&cb1;
+      m_dmi_f=&cb2;
+    }
+    
+  private:
+    //the ID of the callback binder
+    int m_id;
+    //the callbacks
+    nb_func_type* m_nb_f;
+    dmi_func_type* m_dmi_f;
+};
+
+
+/*
+This class forms the base for multi initiator sockets.
+It enforces a multi initiator socket to implement all functions
+needed to do hierarchical bindings.
+*/
+template <unsigned int BUSWIDTH = 32,
+          typename TYPES = tlm::tlm_base_protocol_types,
+          unsigned int N=0
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+          ,sc_core::sc_port_policy POL = sc_core::SC_ONE_OR_MORE_BOUND
+#endif
+          >
+class multi_init_base: public tlm::tlm_initiator_socket<BUSWIDTH,
+                                                  TYPES,
+                                                  N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+                                                  ,POL
+#endif
+                                                  >{
+public:
+  //typedef for the base type: the standard tlm initiator socket
+  typedef tlm::tlm_initiator_socket<BUSWIDTH,
+                              TYPES,
+                              N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+                              ,POL
+#endif
+                              > base_type;
+  
+  //this method shall disable the code that does the callback binding
+  // that registers callbacks to binders
+  virtual void disable_cb_bind()=0;
+  
+  //this method shall return the multi_init_base to which the
+  // multi_init_base is bound hierarchically
+  //  If the base is not bound hierarchically it shall return a pointer to itself
+  virtual multi_init_base* get_hierarch_bind()=0;
+  
+  //this method shall return a vector of the callback binders of multi initiator socket
+  virtual std::vector<callback_binder_bw<TYPES>* >& get_binders()=0;
+  
+  //this method shall return a vector of all target interfaces bound to this multi init socket
+  virtual std::vector<tlm::tlm_fw_transport_if<TYPES>*>&  get_sockets()=0;
+  
+  //ctor and dtor
+  virtual ~multi_init_base(){}
+  multi_init_base():base_type(sc_core::sc_gen_unique_name("multi_init_base")){}
+  multi_init_base(const char* name):base_type(name){}
+};
+
+/*
+This class forms the base for multi target sockets.
+It enforces a multi target socket to implement all functions
+needed to do hierarchical bindings.
+*/
+template <unsigned int BUSWIDTH = 32,
+          typename TYPES = tlm::tlm_base_protocol_types,
+          unsigned int N=0
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+          ,sc_core::sc_port_policy POL = sc_core::SC_ONE_OR_MORE_BOUND
+#endif
+          >
+class multi_target_base: public tlm::tlm_target_socket<BUSWIDTH, 
+                                                TYPES,
+                                                N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)                                                
+                                                ,POL
+#endif
+                                                >{
+public:
+  //typedef for the base type: the standard tlm target socket
+  typedef tlm::tlm_target_socket<BUSWIDTH, 
+                              TYPES,
+                              N
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+                              ,POL
+#endif
+                              > base_type;
+  
+  //this method shall return the multi_init_base to which the
+  // multi_init_base is bound hierarchically
+  //  If the base is not bound hierarchically it shall return a pointer to itself                                                
+  virtual multi_target_base* get_hierarch_bind()=0;
+  
+  //this method shall inform the multi target socket that it is bound
+  // hierarchically and to which other multi target socket it is bound hierarchically
+  virtual void set_hierarch_bind(multi_target_base*)=0;
+  
+  //this method shall return a vector of the callback binders of multi initiator socket
+  virtual std::vector<callback_binder_fw<TYPES>* >& get_binders()=0;
+  
+  //this method shall return a map of all multi initiator sockets that are bound to this multi target
+  // the key of the map is the index at which the multi initiator i bound, while the value
+  //  is the interface of the multi initiator socket that is bound at that index
+  virtual std::map<unsigned int, tlm::tlm_bw_transport_if<TYPES>*>&  get_multi_binds()=0;
+  
+  //ctor and dtor
+  virtual ~multi_target_base(){}
+  multi_target_base():base_type(sc_core::sc_gen_unique_name("multi_target_base")){}
+  multi_target_base(const char* name):base_type(name){}
+};
+
+/*
+All multi sockets must additionally derive from this class.
+It enforces a multi socket to implement a function 
+needed to do multi init to multi target bindings.
+*/
+template <typename TYPES>
+class multi_to_multi_bind_base{
+public:
+  virtual ~multi_to_multi_bind_base(){}
+  virtual tlm::tlm_fw_transport_if<TYPES>* get_last_binder(tlm::tlm_bw_transport_if<TYPES>*)=0;
+};
+
+}
+#endif
diff --git a/ext/systemc/src/tlm_utils/passthrough_target_socket.h b/ext/systemc/src/tlm_utils/passthrough_target_socket.h
new file mode 100644
index 000000000..1a3b14df7
--- /dev/null
+++ b/ext/systemc/src/tlm_utils/passthrough_target_socket.h
@@ -0,0 +1,479 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __PASSTHROUGH_TARGET_SOCKET_H__
+#define __PASSTHROUGH_TARGET_SOCKET_H__
+
+#include <tlm>
+#include <sstream>
+
+namespace tlm_utils {
+
+template <typename MODULE,
+          unsigned int BUSWIDTH = 32,
+          typename TYPES = tlm::tlm_base_protocol_types>
+class passthrough_target_socket :
+  public tlm::tlm_target_socket<BUSWIDTH, TYPES>
+{
+public:
+  typedef typename TYPES::tlm_payload_type              transaction_type;
+  typedef typename TYPES::tlm_phase_type                phase_type;
+  typedef tlm::tlm_sync_enum                            sync_enum_type;
+  typedef tlm::tlm_fw_transport_if<TYPES>               fw_interface_type;
+  typedef tlm::tlm_bw_transport_if<TYPES>               bw_interface_type;
+  typedef tlm::tlm_target_socket<BUSWIDTH, TYPES>       base_type;
+
+public:
+  passthrough_target_socket() :
+    base_type(sc_core::sc_gen_unique_name("passthrough_target_socket")),
+    m_process(this->name())
+  {
+    bind(m_process);
+  }
+
+  explicit passthrough_target_socket(const char* n) :
+    base_type(n),
+    m_process(this->name())
+  {
+    bind(m_process);
+  }
+
+  using tlm::tlm_target_socket<BUSWIDTH, TYPES>::bind;
+
+  // REGISTER_XXX
+  void register_nb_transport_fw(MODULE* mod,
+                                sync_enum_type (MODULE::*cb)(transaction_type&,
+                                                             phase_type&,
+                                                             sc_core::sc_time&))
+  {
+    m_process.set_nb_transport_ptr(mod, cb);
+  }
+
+  void register_b_transport(MODULE* mod,
+                            void (MODULE::*cb)(transaction_type&,
+                                               sc_core::sc_time&))
+  {
+    m_process.set_b_transport_ptr(mod, cb);
+  }
+
+  void register_transport_dbg(MODULE* mod,
+                              unsigned int (MODULE::*cb)(transaction_type&))
+  {
+    m_process.set_transport_dbg_ptr(mod, cb);
+  }
+
+  void register_get_direct_mem_ptr(MODULE* mod,
+                                   bool (MODULE::*cb)(transaction_type&,
+                                                      tlm::tlm_dmi&))
+  {
+    m_process.set_get_direct_mem_ptr(mod, cb);
+  }
+
+private:
+  class process : public tlm::tlm_fw_transport_if<TYPES>
+  {
+  public:
+    typedef sync_enum_type (MODULE::*NBTransportPtr)(transaction_type&,
+                                                     phase_type&,
+                                                     sc_core::sc_time&);
+    typedef void (MODULE::*BTransportPtr)(transaction_type&,
+                                            sc_core::sc_time&);
+    typedef unsigned int (MODULE::*TransportDbgPtr)(transaction_type&);
+    typedef bool (MODULE::*GetDirectMem_ptr)(transaction_type&,
+                                               tlm::tlm_dmi&);
+      
+    process(const std::string& name) :
+      m_name(name),
+      m_mod(0),
+      m_nb_transport_ptr(0),
+      m_b_transport_ptr(0),
+      m_transport_dbg_ptr(0),
+      m_get_direct_mem_ptr(0)
+    {
+    }
+  
+    void set_nb_transport_ptr(MODULE* mod, NBTransportPtr p)
+    {
+      if (m_nb_transport_ptr) {
+        std::stringstream s;
+        s << m_name << ": non-blocking callback allready registered";
+        SC_REPORT_WARNING("/OSCI_TLM-2/passthrough_socket",s.str().c_str());
+
+      } else {
+        assert(!m_mod || m_mod == mod);
+        m_mod = mod;
+        m_nb_transport_ptr = p;
+      }
+    }
+
+    void set_b_transport_ptr(MODULE* mod, BTransportPtr p)
+    {
+      if (m_b_transport_ptr) {
+        std::stringstream s;
+        s << m_name << ": blocking callback allready registered";
+        SC_REPORT_WARNING("/OSCI_TLM-2/passthrough_socket",s.str().c_str());
+      } else {
+        assert(!m_mod || m_mod == mod);
+        m_mod = mod;
+        m_b_transport_ptr = p;
+      }
+    }
+
+    void set_transport_dbg_ptr(MODULE* mod, TransportDbgPtr p)
+    {
+      if (m_transport_dbg_ptr) {
+        std::stringstream s;
+        s << m_name << ": debug callback allready registered";
+        SC_REPORT_WARNING("/OSCI_TLM-2/passthrough_socket",s.str().c_str());
+      } else {
+        assert(!m_mod || m_mod == mod);
+        m_mod = mod;
+        m_transport_dbg_ptr = p;
+      }
+    }
+
+    void set_get_direct_mem_ptr(MODULE* mod, GetDirectMem_ptr p)
+    {
+      if (m_get_direct_mem_ptr) {
+        std::stringstream s;
+        s << m_name << ": get DMI pointer callback allready registered";
+        SC_REPORT_WARNING("/OSCI_TLM-2/passthrough_socket",s.str().c_str());
+      } else {
+        assert(!m_mod || m_mod == mod);
+        m_mod = mod;
+        m_get_direct_mem_ptr = p;
+      }
+    }
+
+    sync_enum_type nb_transport_fw(transaction_type& trans,
+                                   phase_type& phase,
+                                   sc_core::sc_time& t)
+    {
+      if (m_nb_transport_ptr) {
+        // forward call
+        assert(m_mod);
+        return (m_mod->*m_nb_transport_ptr)(trans, phase, t);
+
+      } else {
+        std::stringstream s;
+        s << m_name << ": no non-blocking callback registered";
+        SC_REPORT_ERROR("/OSCI_TLM-2/passthrough_socket",s.str().c_str());
+      }
+      return tlm::TLM_ACCEPTED;   ///< unreachable code
+    }
+
+    void b_transport(transaction_type& trans, sc_core::sc_time& t)
+    {
+      if (m_b_transport_ptr) {
+        // forward call
+        assert(m_mod);
+        return (m_mod->*m_b_transport_ptr)(trans, t);
+
+      } else {
+        std::stringstream s;
+        s << m_name << ": no blocking callback registered";
+        SC_REPORT_ERROR("/OSCI_TLM-2/passthrough_socket",s.str().c_str());
+      }
+    }
+
+    unsigned int transport_dbg(transaction_type& trans)
+    {
+      if (m_transport_dbg_ptr) {
+        // forward call
+        assert(m_mod);
+        return (m_mod->*m_transport_dbg_ptr)(trans);
+
+      } else {
+        // No debug support
+        return 0;
+      }
+    }
+
+    bool get_direct_mem_ptr(transaction_type& trans,
+                            tlm::tlm_dmi&  dmi_data)
+    {
+      if (m_get_direct_mem_ptr) {
+        // forward call
+        assert(m_mod);
+        return (m_mod->*m_get_direct_mem_ptr)(trans, dmi_data);
+
+      } else {
+        // No DMI support
+        dmi_data.allow_read_write();
+        dmi_data.set_start_address(0x0);
+        dmi_data.set_end_address((sc_dt::uint64)-1);
+        return false;
+      }
+    }
+
+  private:
+    const std::string m_name;
+    MODULE* m_mod;
+    NBTransportPtr m_nb_transport_ptr;
+    BTransportPtr m_b_transport_ptr;
+    TransportDbgPtr m_transport_dbg_ptr;
+    GetDirectMem_ptr m_get_direct_mem_ptr;
+  };
+
+private:
+  process m_process;
+};
+
+//ID Tagged version
+template <typename MODULE,
+          unsigned int BUSWIDTH = 32,
+          typename TYPES = tlm::tlm_base_protocol_types>
+class passthrough_target_socket_tagged :
+  public tlm::tlm_target_socket<BUSWIDTH, TYPES>
+{
+public:
+  typedef typename TYPES::tlm_payload_type              transaction_type;
+  typedef typename TYPES::tlm_phase_type                phase_type;
+  typedef tlm::tlm_sync_enum                            sync_enum_type;
+  typedef tlm::tlm_fw_transport_if<TYPES>               fw_interface_type;
+  typedef tlm::tlm_bw_transport_if<TYPES>               bw_interface_type;
+  typedef tlm::tlm_target_socket<BUSWIDTH, TYPES>       base_type;
+
+public:
+  passthrough_target_socket_tagged() :
+    base_type(sc_core::sc_gen_unique_name("passthrough_target_socket_tagged")),
+    m_process(this->name())
+  {
+    bind(m_process);
+  }
+
+  explicit passthrough_target_socket_tagged(const char* n) :
+    base_type(n),
+    m_process(this->name())
+  {
+    bind(m_process);
+  }
+
+  using tlm::tlm_target_socket<BUSWIDTH, TYPES>::bind;
+
+  // REGISTER_XXX
+  void register_nb_transport_fw(MODULE* mod,
+                                sync_enum_type (MODULE::*cb)(int id,
+                                                             transaction_type&,
+                                                             phase_type&,
+                                                             sc_core::sc_time&),
+                                int id)
+  {
+    m_process.set_nb_transport_ptr(mod, cb);
+    m_process.set_nb_transport_user_id(id);
+  }
+
+  void register_b_transport(MODULE* mod,
+                            void (MODULE::*cb)(int id,
+                                               transaction_type&,
+                                               sc_core::sc_time&),
+                            int id)
+  {
+    m_process.set_b_transport_ptr(mod, cb);
+    m_process.set_b_transport_user_id(id);
+  }
+
+  void register_transport_dbg(MODULE* mod,
+                              unsigned int (MODULE::*cb)(int id,
+                                                         transaction_type&),
+                              int id)
+  {
+    m_process.set_transport_dbg_ptr(mod, cb);
+    m_process.set_transport_dbg_user_id(id);
+  }
+
+  void register_get_direct_mem_ptr(MODULE* mod,
+                                   bool (MODULE::*cb)(int id,
+                                                      transaction_type&,
+                                                      tlm::tlm_dmi&),
+                                   int id)
+  {
+    m_process.set_get_direct_mem_ptr(mod, cb);
+    m_process.set_get_dmi_user_id(id);
+  }
+
+private:
+  class process : public tlm::tlm_fw_transport_if<TYPES>
+  {
+  public:
+    typedef sync_enum_type (MODULE::*NBTransportPtr)(int id,
+                                                     transaction_type&,
+                                                     phase_type&,
+                                                     sc_core::sc_time&);
+    typedef void (MODULE::*BTransportPtr)(int id,
+                                          transaction_type&,
+                                          sc_core::sc_time&);
+    typedef unsigned int (MODULE::*TransportDbgPtr)(int id,
+                                                    transaction_type&);
+    typedef bool (MODULE::*GetDirectMem_ptr)(int id,
+                                             transaction_type&,
+                                             tlm::tlm_dmi&);
+      
+    process(const std::string& name) :
+      m_name(name),
+      m_mod(0),
+      m_nb_transport_ptr(0),
+      m_b_transport_ptr(0),
+      m_transport_dbg_ptr(0),
+      m_get_direct_mem_ptr(0),
+      m_nb_transport_user_id(0),
+      m_b_transport_user_id(0),
+      m_transport_dbg_user_id(0),
+      m_get_dmi_user_id(0)
+    {
+    }
+
+    void set_nb_transport_user_id(int id) { m_nb_transport_user_id = id; }
+    void set_b_transport_user_id(int id) { m_b_transport_user_id = id; }
+    void set_transport_dbg_user_id(int id) { m_transport_dbg_user_id = id; }
+    void set_get_dmi_user_id(int id) { m_get_dmi_user_id = id; }
+
+    void set_nb_transport_ptr(MODULE* mod, NBTransportPtr p)
+    {
+      if (m_nb_transport_ptr) {
+        std::stringstream s;
+        s << m_name << ": non-blocking callback allready registered";
+        SC_REPORT_WARNING("/OSCI_TLM-2/passthrough_socket",s.str().c_str());
+      } else {
+        assert(!m_mod || m_mod == mod);
+        m_mod = mod;
+        m_nb_transport_ptr = p;
+      }
+    }
+
+    void set_b_transport_ptr(MODULE* mod, BTransportPtr p)
+    {
+      if (m_b_transport_ptr) {
+        std::stringstream s;
+        s << m_name << ": blocking callback allready registered";
+        SC_REPORT_WARNING("/OSCI_TLM-2/passthrough_socket",s.str().c_str());
+      } else {
+        assert(!m_mod || m_mod == mod);
+        m_mod = mod;
+        m_b_transport_ptr = p;
+      }
+    }
+
+    void set_transport_dbg_ptr(MODULE* mod, TransportDbgPtr p)
+    {
+      if (m_transport_dbg_ptr) {
+        std::stringstream s;
+        s << m_name << ": debug callback allready registered";
+        SC_REPORT_WARNING("/OSCI_TLM-2/passthrough_socket",s.str().c_str());
+      } else {
+        assert(!m_mod || m_mod == mod);
+        m_mod = mod;
+        m_transport_dbg_ptr = p;
+      }
+    }
+
+    void set_get_direct_mem_ptr(MODULE* mod, GetDirectMem_ptr p)
+    {
+      if (m_get_direct_mem_ptr) {
+        std::stringstream s;
+        s << m_name << ": get DMI pointer callback allready registered";
+        SC_REPORT_WARNING("/OSCI_TLM-2/passthrough_socket",s.str().c_str());
+      } else {
+        assert(!m_mod || m_mod == mod);
+        m_mod = mod;
+        m_get_direct_mem_ptr = p;
+      }
+    }
+
+    sync_enum_type nb_transport_fw(transaction_type& trans,
+                                   phase_type& phase,
+                                   sc_core::sc_time& t)
+    {
+      if (m_nb_transport_ptr) {
+        // forward call
+        assert(m_mod);
+        return (m_mod->*m_nb_transport_ptr)(m_nb_transport_user_id, trans, phase, t);
+
+      } else {
+        std::stringstream s;
+        s << m_name << ": no non-blocking callback registered";
+        SC_REPORT_ERROR("/OSCI_TLM-2/passthrough_socket",s.str().c_str());
+      }
+      return tlm::TLM_ACCEPTED;   ///< unreachable code
+    }
+
+    void b_transport(transaction_type& trans, sc_core::sc_time& t)
+    {
+      if (m_b_transport_ptr) {
+        // forward call
+        assert(m_mod);
+        return (m_mod->*m_b_transport_ptr)(m_b_transport_user_id, trans, t);
+
+      } else {
+        std::stringstream s;
+        s << m_name << ": no blocking callback registered";
+        SC_REPORT_ERROR("/OSCI_TLM-2/passthrough_socket",s.str().c_str());
+      }
+    }
+
+    unsigned int transport_dbg(transaction_type& trans)
+    {
+      if (m_transport_dbg_ptr) {
+        // forward call
+        assert(m_mod);
+        return (m_mod->*m_transport_dbg_ptr)(m_transport_dbg_user_id, trans);
+
+      } else {
+        // No debug support
+        return 0;
+      }
+    }
+
+    bool get_direct_mem_ptr(transaction_type& trans,
+                            tlm::tlm_dmi&  dmi_data)
+    {
+      if (m_get_direct_mem_ptr) {
+        // forward call
+        assert(m_mod);
+        return (m_mod->*m_get_direct_mem_ptr)(m_get_dmi_user_id, trans, dmi_data);
+
+      } else {
+        // No DMI support
+        dmi_data.allow_read_write();
+        dmi_data.set_start_address(0x0);
+        dmi_data.set_end_address((sc_dt::uint64)-1);
+        return false;
+      }
+    }
+
+  private:
+    const std::string m_name;
+    MODULE* m_mod;
+    NBTransportPtr m_nb_transport_ptr;
+    BTransportPtr m_b_transport_ptr;
+    TransportDbgPtr m_transport_dbg_ptr;
+    GetDirectMem_ptr m_get_direct_mem_ptr;
+    int m_nb_transport_user_id;
+    int m_b_transport_user_id;
+    int m_transport_dbg_user_id;
+    int m_get_dmi_user_id;
+  };
+
+private:
+  process m_process;
+};
+
+}
+
+#endif
diff --git a/ext/systemc/src/tlm_utils/peq_with_cb_and_phase.h b/ext/systemc/src/tlm_utils/peq_with_cb_and_phase.h
new file mode 100644
index 000000000..60f96e6bd
--- /dev/null
+++ b/ext/systemc/src/tlm_utils/peq_with_cb_and_phase.h
@@ -0,0 +1,301 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+// 12-Jan-2009  John Aynsley  Bug fix. Phase argument to notify should be const
+// 20-Mar-2009  John Aynsley  Add cancel_all() method
+
+
+#ifndef __PEQ_WITH_CB_AND_PHASE_H__
+#define __PEQ_WITH_CB_AND_PHASE_H__
+
+#ifndef SC_INCLUDE_DYNAMIC_PROCESSES // needed for sc_spawn
+#  define SC_INCLUDE_DYNAMIC_PROCESSES
+#endif
+
+#include <vector>
+#include <systemc>
+#include <tlm>
+
+namespace tlm_utils {
+
+template <typename PAYLOAD>
+class time_ordered_list
+{
+public:
+  struct element
+  {
+    struct element  *next;
+    PAYLOAD p;
+    sc_core::sc_time t;
+    sc_dt::uint64 d;
+    element(PAYLOAD& p, sc_core::sc_time t, sc_dt::uint64 d): p(p),t(t),d(d) {}
+    element(){}
+  };
+
+  element *nill;
+  element *empties;
+  element *list;
+  unsigned int size;
+
+  time_ordered_list()
+    : nill(new element()),
+      empties(NULL),
+      list(nill),
+      size(0)
+  {
+  }
+
+  ~time_ordered_list() {
+    reset();
+    while(empties){
+      struct element *e=empties->next;
+      delete empties;
+      empties=e;
+    }
+    delete nill;
+  }
+
+  void reset() {
+    while(size) {
+      delete_top();
+    }
+  }
+
+  void insert(const PAYLOAD& p, sc_core::sc_time t) {
+    if (!empties) {
+      empties=new struct element();
+      empties->next=NULL;
+    }
+
+    struct element *e=empties;
+    empties=empties->next;
+    e->p=p;
+    e->t=t;
+    e->d=sc_core::sc_delta_count();
+
+    struct element * ancestor=nill;
+    struct element * iterator=list;
+    while (iterator!=nill && iterator->t<=t){
+      ancestor=iterator;
+      iterator=iterator->next;
+    }
+    if (ancestor==nill){
+      e->next=list;
+      list=e;
+    }
+    else {
+      e->next=iterator;
+      ancestor->next=e;
+    }
+    size++;
+  }
+
+  void delete_top(){
+    if (list != nill) {
+      struct element *e=list;
+      list=list->next;
+      e->next=empties;
+      empties=e;
+      size--;
+    }
+  }
+
+  unsigned int get_size()
+  {
+    return size;
+  }
+
+  PAYLOAD &top()
+  {
+    return list->p;
+  }
+  sc_core::sc_time top_time()
+  {
+    return list->t;
+  }
+
+  sc_dt::uint64& top_delta()
+  {
+    return list->d;
+  }
+
+  sc_core::sc_time next_time()
+  {
+    return list->next->t;
+  }
+};
+
+//---------------------------------------------------------------------------
+/**
+ * An event queue that can contain any number of pending
+ * notifications. Each notification have an associate payload.
+ */
+//---------------------------------------------------------------------------
+template<typename OWNER,typename TYPES=tlm::tlm_base_protocol_types>
+class peq_with_cb_and_phase:
+  public sc_core::sc_object
+{
+
+  typedef typename TYPES::tlm_payload_type tlm_payload_type;
+  typedef typename TYPES::tlm_phase_type   tlm_phase_type;
+  typedef std::pair<tlm_payload_type*, tlm_phase_type> PAYLOAD;
+  typedef void (OWNER::*cb)(tlm_payload_type&, const tlm_phase_type&);
+
+  class delta_list{
+  public:
+    delta_list(){
+      reset();
+      entries.resize(100);
+    }
+
+    inline void insert(const PAYLOAD& p){
+      if (size==entries.size()){
+        entries.resize(entries.size()*2);
+      }
+      entries[size++]=p;
+    }
+
+    inline PAYLOAD& get(){
+      return entries[out++];
+    }
+
+    inline bool next(){
+      return out<size;
+    }
+
+    inline void reset(){
+      size=0;
+      out=0;
+    }
+  public:
+    unsigned int size;
+  private:
+    std::vector<PAYLOAD> entries;
+    unsigned int out;
+  };
+
+public:
+
+  peq_with_cb_and_phase(OWNER* _owner, cb _cb)
+    :sc_core::sc_object( sc_core::sc_gen_unique_name( "peq_with_cb_and_phase" ) )
+    ,m_owner(_owner)
+    ,m_cb(_cb)
+  {
+    sc_core::sc_spawn_options opts;
+    opts.spawn_method();
+    opts.set_sensitivity(&m_e);
+    opts.dont_initialize();
+    sc_core::sc_spawn(sc_bind(&peq_with_cb_and_phase::fec, this),
+                      sc_core::sc_gen_unique_name("fec"), &opts);
+  }
+
+  peq_with_cb_and_phase(const char* _name, OWNER* _owner,cb _cb)
+    : sc_core::sc_object( _name )
+    ,m_owner(_owner)
+    ,m_cb(_cb)
+  {
+    sc_core::sc_spawn_options opts;
+    opts.spawn_method();
+    opts.set_sensitivity(&m_e);
+    opts.dont_initialize();
+    sc_core::sc_spawn(sc_bind(&peq_with_cb_and_phase::fec, this),
+                      sc_core::sc_gen_unique_name("fec"), &opts);
+  }
+
+  ~peq_with_cb_and_phase(){}
+
+  void notify (tlm_payload_type& t, const tlm_phase_type& p, const sc_core::sc_time& when){
+    //t.aquire();
+    if (when==sc_core::SC_ZERO_TIME) {
+      if (sc_core::sc_delta_count() & (sc_dt::uint64)0x1) //uneven delta cycle so delta delay is for even cylce
+        m_even_delta.insert(PAYLOAD(&t,p));
+      else
+        m_uneven_delta.insert(PAYLOAD(&t,p)); //even delta cycle so delta delay is for uneven delta
+      m_e.notify(sc_core::SC_ZERO_TIME);
+    }
+    else {
+      m_ppq.insert(PAYLOAD(&t,p),  when + sc_core::sc_time_stamp() );
+      m_e.notify(when); // note, this will only over-right the "newest" event.
+    }
+  }
+
+  void notify (tlm_payload_type& t, const tlm_phase_type& p){
+    m_immediate_yield.insert(PAYLOAD(&t,p));
+    m_e.notify(); // immediate notification
+  }
+
+  // Cancel all events from the event queue
+  void cancel_all() {
+    m_ppq.reset();
+    m_uneven_delta.reset();
+    m_even_delta.reset();
+    m_immediate_yield.reset();
+    m_e.cancel();
+  }
+
+private:
+
+  void fec(){
+    //immediate yield notifications
+    while(m_immediate_yield.next()) {PAYLOAD& tmp=m_immediate_yield.get(); (m_owner->*m_cb)(*tmp.first, tmp.second);} //tmp.first->release();}
+    m_immediate_yield.reset();
+
+    //delta notifications
+    if (sc_core::sc_delta_count() & (sc_dt::uint64) 0x1) {//uneven delta so put out all payloads for uneven delta
+      while (m_uneven_delta.next()) {PAYLOAD& tmp=m_uneven_delta.get(); (m_owner->*m_cb)(*tmp.first, tmp.second);} //tmp.first->release();}
+      m_uneven_delta.reset();
+      if (m_even_delta.size) m_e.notify(sc_core::SC_ZERO_TIME);
+    }
+    else {
+      while (m_even_delta.next()) {PAYLOAD& tmp=m_even_delta.get(); (m_owner->*m_cb)(*tmp.first, tmp.second);} //tmp.first->release();}
+      m_even_delta.reset();
+      if (m_uneven_delta.size) m_e.notify(sc_core::SC_ZERO_TIME);
+    }
+    if (!m_ppq.get_size()) return; //there were only delta notification
+
+    //timed notifications
+    const sc_core::sc_time now=sc_core::sc_time_stamp();
+    sc_core::sc_time top=m_ppq.top_time();
+
+    while(m_ppq.get_size() && top==now) { // push all active ones into target
+      PAYLOAD& tmp=m_ppq.top();
+      (m_owner->*m_cb)(*tmp.first, tmp.second); //tmp.first->release();}
+      m_ppq.delete_top();
+      top=m_ppq.top_time();
+    }
+    if ( m_ppq.get_size()) {
+      m_e.notify( top - now) ;
+    }
+
+  }
+
+  OWNER* m_owner;
+  cb     m_cb;
+
+  time_ordered_list<PAYLOAD> m_ppq;
+  delta_list m_uneven_delta;
+  delta_list m_even_delta;
+  delta_list m_immediate_yield;
+
+  sc_core::sc_event m_e;   // default event
+};
+
+}
+
+#endif // __PEQ_WITH_CB_AND_PHASE_H__
diff --git a/ext/systemc/src/tlm_utils/peq_with_get.h b/ext/systemc/src/tlm_utils/peq_with_get.h
new file mode 100644
index 000000000..5c85f25d5
--- /dev/null
+++ b/ext/systemc/src/tlm_utils/peq_with_get.h
@@ -0,0 +1,94 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+// 12-Jan-2009  John Aynsley  Bug fix. sc_time argument to notify should be const
+// 20-Mar-2009  John Aynsley  Add cancel_all() method
+
+
+#ifndef __PEQ_WITH_GET_H__
+#define __PEQ_WITH_GET_H__
+
+#include <systemc>
+//#include <tlm>
+#include <map>
+
+namespace tlm_utils {
+
+template <class PAYLOAD>
+class peq_with_get : public sc_core::sc_object
+{
+public:
+  typedef PAYLOAD transaction_type;
+  typedef std::pair<const sc_core::sc_time, transaction_type*> pair_type;
+
+public:
+  peq_with_get(const char* name) : sc_core::sc_object(name)
+  {
+  }
+
+  void notify(transaction_type& trans, const sc_core::sc_time& t)
+  {
+    m_scheduled_events.insert(pair_type(t + sc_core::sc_time_stamp(), &trans));
+    m_event.notify(t);
+  }
+
+  void notify(transaction_type& trans)
+  {
+    m_scheduled_events.insert(pair_type(sc_core::sc_time_stamp(), &trans));
+    m_event.notify(); // immediate notification
+  }
+
+  // needs to be called until it returns 0
+  transaction_type* get_next_transaction()
+  {
+    if (m_scheduled_events.empty()) {
+      return 0;
+    }
+
+    sc_core::sc_time now = sc_core::sc_time_stamp();
+    if (m_scheduled_events.begin()->first <= now) {
+      transaction_type* trans = m_scheduled_events.begin()->second;
+      m_scheduled_events.erase(m_scheduled_events.begin());
+      return trans;
+    }
+
+    m_event.notify(m_scheduled_events.begin()->first - now);
+
+    return 0;
+  }
+
+  sc_core::sc_event& get_event()
+  {
+    return m_event;
+  }
+
+  // Cancel all events from the event queue
+  void cancel_all() {
+    m_scheduled_events.clear();
+    m_event.cancel();
+  }
+
+private:
+  std::multimap<const sc_core::sc_time, transaction_type*> m_scheduled_events;
+  sc_core::sc_event m_event;
+};
+
+}
+
+#endif
diff --git a/ext/systemc/src/tlm_utils/simple_initiator_socket.h b/ext/systemc/src/tlm_utils/simple_initiator_socket.h
new file mode 100644
index 000000000..4609fd885
--- /dev/null
+++ b/ext/systemc/src/tlm_utils/simple_initiator_socket.h
@@ -0,0 +1,292 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+#ifndef __SIMPLE_INITIATOR_SOCKET_H__
+#define __SIMPLE_INITIATOR_SOCKET_H__
+
+#include <tlm>
+#include <sstream>
+
+namespace tlm_utils {
+
+template <typename MODULE,
+          unsigned int BUSWIDTH = 32,
+          typename TYPES = tlm::tlm_base_protocol_types>
+class simple_initiator_socket :
+  public tlm::tlm_initiator_socket<BUSWIDTH, TYPES>
+{
+public:
+  typedef typename TYPES::tlm_payload_type              transaction_type;
+  typedef typename TYPES::tlm_phase_type                phase_type;
+  typedef tlm::tlm_sync_enum                            sync_enum_type;
+  typedef tlm::tlm_fw_transport_if<TYPES>               fw_interface_type;
+  typedef tlm::tlm_bw_transport_if<TYPES>               bw_interface_type;
+  typedef tlm::tlm_initiator_socket<BUSWIDTH, TYPES>    base_type;
+
+public:
+  simple_initiator_socket() :
+    base_type(sc_core::sc_gen_unique_name("simple_initiator_socket")),
+    m_process(this->name())
+  {
+    this->m_export.bind(m_process);
+  }
+
+  explicit simple_initiator_socket(const char* n) :
+    base_type(n),
+    m_process(this->name())
+  {
+    this->m_export.bind(m_process);
+  }
+
+  void register_nb_transport_bw(MODULE* mod,
+                                sync_enum_type (MODULE::*cb)(transaction_type&,
+                                                             phase_type&,
+                                                             sc_core::sc_time&))
+  {
+    m_process.set_transport_ptr(mod, cb);
+  }
+
+  void register_invalidate_direct_mem_ptr(MODULE* mod,
+                                          void (MODULE::*cb)(sc_dt::uint64, sc_dt::uint64))
+  {
+    m_process.set_invalidate_direct_mem_ptr(mod, cb);
+  }
+
+private:
+  class process : public tlm::tlm_bw_transport_if<TYPES>
+  {
+  public:
+    typedef sync_enum_type (MODULE::*TransportPtr)(transaction_type&,
+                                                   phase_type&,
+                                                   sc_core::sc_time&);
+    typedef void (MODULE::*InvalidateDirectMemPtr)(sc_dt::uint64,
+                                                   sc_dt::uint64);
+      
+    process(const std::string& name) :
+      m_name(name),
+      m_mod(0),
+      m_transport_ptr(0),
+      m_invalidate_direct_mem_ptr(0)
+    {
+    }
+  
+    void set_transport_ptr(MODULE* mod, TransportPtr p)
+    {
+      if (m_transport_ptr) {
+        std::stringstream s;
+        s << m_name << ": non-blocking callback allready registered";
+        SC_REPORT_WARNING("/OSCI_TLM-2/simple_socket",s.str().c_str());
+      } else {
+        assert(!m_mod || m_mod == mod);
+        m_mod = mod;
+        m_transport_ptr = p;
+      }
+    }
+
+    void set_invalidate_direct_mem_ptr(MODULE* mod, InvalidateDirectMemPtr p)
+    {
+      if (m_invalidate_direct_mem_ptr) {
+        std::stringstream s;
+        s << m_name << ": invalidate DMI callback allready registered";
+        SC_REPORT_WARNING("/OSCI_TLM-2/simple_socket",s.str().c_str());
+      } else {
+        assert(!m_mod || m_mod == mod);
+        m_mod = mod;
+        m_invalidate_direct_mem_ptr = p;
+      }
+    }
+
+    sync_enum_type nb_transport_bw(transaction_type& trans, phase_type& phase, sc_core::sc_time& t)
+    {
+      if (m_transport_ptr) {
+        // forward call
+        assert(m_mod);
+        return (m_mod->*m_transport_ptr)(trans, phase, t);
+
+      } else {
+        std::stringstream s;
+        s << m_name << ": no transport callback registered";
+        SC_REPORT_ERROR("/OSCI_TLM-2/simple_socket",s.str().c_str());
+      }
+      return tlm::TLM_ACCEPTED;   ///< unreachable code
+    }
+
+    void invalidate_direct_mem_ptr(sc_dt::uint64 start_range,
+                                   sc_dt::uint64 end_range)
+    {
+      if (m_invalidate_direct_mem_ptr) {
+        // forward call
+        assert(m_mod);
+        (m_mod->*m_invalidate_direct_mem_ptr)(start_range, end_range);
+      }
+    }
+
+  private:
+    const std::string m_name;
+    MODULE* m_mod;
+    TransportPtr m_transport_ptr;
+    InvalidateDirectMemPtr m_invalidate_direct_mem_ptr;
+  };
+
+private:
+  process m_process;
+};
+
+// Tagged version
+
+template <typename MODULE,
+          unsigned int BUSWIDTH = 32,
+          typename TYPES = tlm::tlm_base_protocol_types>
+class simple_initiator_socket_tagged :
+  public tlm::tlm_initiator_socket<BUSWIDTH, TYPES>
+{
+public:
+  typedef typename TYPES::tlm_payload_type              transaction_type;
+  typedef typename TYPES::tlm_phase_type                phase_type;
+  typedef tlm::tlm_sync_enum                            sync_enum_type;
+  typedef tlm::tlm_fw_transport_if<TYPES>               fw_interface_type;
+  typedef tlm::tlm_bw_transport_if<TYPES>               bw_interface_type;
+  typedef tlm::tlm_initiator_socket<BUSWIDTH, TYPES>    base_type;
+
+public:
+  simple_initiator_socket_tagged() :
+    base_type(sc_core::sc_gen_unique_name("simple_initiator_socket_tagged")),
+    m_process(this->name())
+  {
+    this->m_export.bind(m_process);
+  }
+
+  explicit simple_initiator_socket_tagged(const char* n) :
+    base_type(n),
+    m_process(this->name())
+  {
+    this->m_export.bind(m_process);
+  }
+
+  void register_nb_transport_bw(MODULE* mod,
+                                sync_enum_type (MODULE::*cb)(int,
+                                                             transaction_type&,
+                                                             phase_type&,
+                                                             sc_core::sc_time&),
+                                int id)
+  {
+    m_process.set_transport_ptr(mod, cb);
+    m_process.set_transport_user_id(id);
+  }
+
+  void register_invalidate_direct_mem_ptr(MODULE* mod,
+                                          void (MODULE::*cb)(int, sc_dt::uint64, sc_dt::uint64),
+                                           int id)
+  {
+    m_process.set_invalidate_direct_mem_ptr(mod, cb);
+    m_process.set_invalidate_dmi_user_id(id);
+  }
+
+private:
+  class process : public tlm::tlm_bw_transport_if<TYPES>
+  {
+  public:
+    typedef sync_enum_type (MODULE::*TransportPtr)(int,
+                                                   transaction_type&,
+                                                   phase_type&,
+                                                   sc_core::sc_time&);
+    typedef void (MODULE::*InvalidateDirectMemPtr)(int,
+                                                   sc_dt::uint64,
+                                                   sc_dt::uint64);
+      
+    process(const std::string& name) :
+      m_name(name),
+      m_mod(0),
+      m_transport_ptr(0),
+      m_invalidate_direct_mem_ptr(0),
+      m_transport_user_id(0),
+      m_invalidate_direct_mem_user_id(0)
+    {
+    }
+  
+    void set_transport_user_id(int id) { m_transport_user_id = id; }
+    void set_invalidate_dmi_user_id(int id) { m_invalidate_direct_mem_user_id = id; }
+
+    void set_transport_ptr(MODULE* mod, TransportPtr p)
+    {
+      if (m_transport_ptr) {
+        std::stringstream s;
+        s << m_name << ": non-blocking callback allready registered";
+        SC_REPORT_WARNING("/OSCI_TLM-2/simple_socket",s.str().c_str());
+      } else {
+        assert(!m_mod || m_mod == mod);
+        m_mod = mod;
+        m_transport_ptr = p;
+      }
+    }
+
+    void set_invalidate_direct_mem_ptr(MODULE* mod, InvalidateDirectMemPtr p)
+    {
+      if (m_invalidate_direct_mem_ptr) {
+        std::stringstream s;
+        s << m_name << ": invalidate DMI callback allready registered";
+        SC_REPORT_WARNING("/OSCI_TLM-2/simple_socket",s.str().c_str());
+      } else {
+        assert(!m_mod || m_mod == mod);
+        m_mod = mod;
+        m_invalidate_direct_mem_ptr = p;
+      }
+    }
+
+    sync_enum_type nb_transport_bw(transaction_type& trans, phase_type& phase, sc_core::sc_time& t)
+    {
+      if (m_transport_ptr) {
+        // forward call
+        assert(m_mod);
+        return (m_mod->*m_transport_ptr)(m_transport_user_id, trans, phase, t);
+
+      } else {
+        std::stringstream s;
+        s << m_name << ": no transport callback registered";
+        SC_REPORT_ERROR("/OSCI_TLM-2/simple_socket",s.str().c_str());
+      }
+      return tlm::TLM_ACCEPTED;   ///< unreachable code
+    }
+
+    void invalidate_direct_mem_ptr(sc_dt::uint64 start_range,
+                                   sc_dt::uint64 end_range)
+    {
+      if (m_invalidate_direct_mem_ptr) {
+        // forward call
+        assert(m_mod);
+        (m_mod->*m_invalidate_direct_mem_ptr)(m_invalidate_direct_mem_user_id, start_range, end_range);
+      }
+    }
+
+  private:
+    const std::string m_name;
+    MODULE* m_mod;
+    TransportPtr m_transport_ptr;
+    InvalidateDirectMemPtr m_invalidate_direct_mem_ptr;
+    int m_transport_user_id;
+    int m_invalidate_direct_mem_user_id;
+  };
+
+private:
+  process m_process;
+};
+
+}
+
+#endif
diff --git a/ext/systemc/src/tlm_utils/simple_target_socket.h b/ext/systemc/src/tlm_utils/simple_target_socket.h
new file mode 100644
index 000000000..34ed1a7f4
--- /dev/null
+++ b/ext/systemc/src/tlm_utils/simple_target_socket.h
@@ -0,0 +1,1114 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+// *****************************************************************************
+// Modified by John Aynsley, Doulos, Feb 2009,
+// Fix a bug in simple_target_socket and simple_target_socket_tagged
+// with the addition of one new line of code in each:  wait(*e);
+// *****************************************************************************
+
+// *****************************************************************************
+// Modified by John Aynsley on behalf of Robert Guenzel, May 2011,
+// Fix a bug in simple_target_socket and simple_target_socket_tagged
+// with the addition of one new line of code in each:  wait(t);
+// *****************************************************************************
+
+
+#ifndef __SIMPLE_TARGET_SOCKET_H__
+#define __SIMPLE_TARGET_SOCKET_H__
+
+#ifndef SC_INCLUDE_DYNAMIC_PROCESSES // needed for sc_spawn
+#  define SC_INCLUDE_DYNAMIC_PROCESSES
+#endif
+
+#include <systemc>
+#include <tlm>
+#include "tlm_utils/peq_with_get.h"
+#include <sstream>
+
+namespace tlm_utils {
+
+template <typename MODULE,
+          unsigned int BUSWIDTH = 32,
+          typename TYPES = tlm::tlm_base_protocol_types>
+class simple_target_socket :
+  public tlm::tlm_target_socket<BUSWIDTH, TYPES>
+{
+  friend class fw_process;
+  friend class bw_process;
+public:
+  typedef typename TYPES::tlm_payload_type              transaction_type;
+  typedef typename TYPES::tlm_phase_type                phase_type;
+  typedef tlm::tlm_sync_enum                            sync_enum_type;
+  typedef tlm::tlm_fw_transport_if<TYPES>               fw_interface_type;
+  typedef tlm::tlm_bw_transport_if<TYPES>               bw_interface_type;
+  typedef tlm::tlm_target_socket<BUSWIDTH, TYPES>       base_type;
+
+public:
+  simple_target_socket() :
+    base_type(sc_core::sc_gen_unique_name("simple_target_socket")),
+    m_fw_process(this),
+    m_bw_process(this)
+  {
+    bind(m_fw_process);
+  }
+
+  explicit simple_target_socket(const char* n) :
+    base_type(n),
+    m_fw_process(this),
+    m_bw_process(this)
+  {
+    bind(m_fw_process);
+  }
+
+  using tlm::tlm_target_socket<BUSWIDTH, TYPES>::bind;
+
+  // bw transport must come thru us.
+  tlm::tlm_bw_transport_if<TYPES> * operator ->() {return &m_bw_process;}
+
+  // REGISTER_XXX
+  void register_nb_transport_fw(MODULE* mod,
+                                sync_enum_type (MODULE::*cb)(transaction_type&,
+                                                             phase_type&,
+                                                             sc_core::sc_time&))
+  {
+    assert(!sc_core::sc_get_curr_simcontext()->elaboration_done());
+    m_fw_process.set_nb_transport_ptr(mod, cb);
+  }
+
+  void register_b_transport(MODULE* mod,
+                            void (MODULE::*cb)(transaction_type&,
+                                               sc_core::sc_time&))
+  {
+    assert(!sc_core::sc_get_curr_simcontext()->elaboration_done());
+    m_fw_process.set_b_transport_ptr(mod, cb);
+  }
+
+  void register_transport_dbg(MODULE* mod,
+                              unsigned int (MODULE::*cb)(transaction_type&))
+  {
+    assert(!sc_core::sc_get_curr_simcontext()->elaboration_done());
+    m_fw_process.set_transport_dbg_ptr(mod, cb);
+  }
+
+  void register_get_direct_mem_ptr(MODULE* mod,
+                                   bool (MODULE::*cb)(transaction_type&,
+                                                      tlm::tlm_dmi&))
+  {
+    assert(!sc_core::sc_get_curr_simcontext()->elaboration_done());
+    m_fw_process.set_get_direct_mem_ptr(mod, cb);
+  }
+
+private:
+  //make call on bw path.
+  sync_enum_type bw_nb_transport(transaction_type &trans, phase_type &phase, sc_core::sc_time &t)
+  {
+    return base_type::operator ->()->nb_transport_bw(trans, phase, t);
+  }
+
+  void bw_invalidate_direct_mem_ptr(sc_dt::uint64 s,sc_dt::uint64 e)
+  {
+    base_type::operator ->()->invalidate_direct_mem_ptr(s, e);
+  }
+
+  //Helper class to handle bw path calls
+  // Needed to detect transaction end when called from b_transport.
+  class bw_process : public tlm::tlm_bw_transport_if<TYPES>
+  {
+  public:
+    bw_process(simple_target_socket *p_own) : m_owner(p_own)
+    {
+    }
+
+    sync_enum_type nb_transport_bw(transaction_type &trans, phase_type &phase, sc_core::sc_time &t)
+    {
+      typename std::map<transaction_type*, sc_core::sc_event *>::iterator it;
+
+      it = m_owner->m_pending_trans.find(&trans);
+      if(it == m_owner->m_pending_trans.end()) {
+        // Not a blocking call, forward.
+        return m_owner->bw_nb_transport(trans, phase, t);
+
+      } else {
+        if (phase == tlm::END_REQ) {
+          m_owner->m_end_request.notify(sc_core::SC_ZERO_TIME);
+          return tlm::TLM_ACCEPTED;
+
+        } else if (phase == tlm::BEGIN_RESP) {
+          if (m_owner->m_current_transaction == &trans) {
+            m_owner->m_end_request.notify(sc_core::SC_ZERO_TIME);
+          }
+          //TODO: add response-accept delay?
+          it->second->notify(t);
+          m_owner->m_pending_trans.erase(it);
+          return tlm::TLM_COMPLETED;
+
+        } else {
+          assert(0); exit(1);
+        }
+
+//        return tlm::TLM_COMPLETED;  //Should not reach here
+      }
+    }
+
+    void invalidate_direct_mem_ptr(sc_dt::uint64 s,sc_dt::uint64 e)
+    {
+      return m_owner->bw_invalidate_direct_mem_ptr(s, e);
+    }
+
+  private:
+    simple_target_socket *m_owner;
+  };
+
+  class fw_process : public tlm::tlm_fw_transport_if<TYPES>,
+                    public tlm::tlm_mm_interface
+  {
+  public:
+    typedef sync_enum_type (MODULE::*NBTransportPtr)(transaction_type&,
+                                                     phase_type&,
+                                                     sc_core::sc_time&);
+    typedef void (MODULE::*BTransportPtr)(transaction_type&,
+                                          sc_core::sc_time&);
+    typedef unsigned int (MODULE::*TransportDbgPtr)(transaction_type&);
+    typedef bool (MODULE::*GetDirectMemPtr)(transaction_type&,
+                                            tlm::tlm_dmi&);
+
+    fw_process(simple_target_socket *p_own) :
+      m_name(p_own->name()),
+      m_owner(p_own),
+      m_mod(0),
+      m_nb_transport_ptr(0),
+      m_b_transport_ptr(0),
+      m_transport_dbg_ptr(0),
+      m_get_direct_mem_ptr(0),
+      m_peq(sc_core::sc_gen_unique_name("m_peq")),
+      m_response_in_progress(false)
+    {
+      sc_core::sc_spawn_options opts;
+      opts.set_sensitivity(&m_peq.get_event());
+      sc_core::sc_spawn(sc_bind(&fw_process::b2nb_thread, this),
+                        sc_core::sc_gen_unique_name("b2nb_thread"), &opts);
+    }
+
+    void set_nb_transport_ptr(MODULE* mod, NBTransportPtr p)
+    {
+      if (m_nb_transport_ptr) {
+        std::stringstream s;
+        s << m_name << ": non-blocking callback allready registered";
+        SC_REPORT_WARNING("/OSCI_TLM-2/simple_socket",s.str().c_str());
+      } else {
+        assert(!m_mod || m_mod == mod);
+        m_mod = mod;
+        m_nb_transport_ptr = p;
+      }
+    }
+
+    void set_b_transport_ptr(MODULE* mod, BTransportPtr p)
+    {
+      if (m_b_transport_ptr) {
+        std::stringstream s;
+        s << m_name << ": blocking callback allready registered";
+        SC_REPORT_WARNING("/OSCI_TLM-2/simple_socket",s.str().c_str());
+      } else {
+        assert(!m_mod || m_mod == mod);
+        m_mod = mod;
+        m_b_transport_ptr = p;
+      }
+    }
+
+    void set_transport_dbg_ptr(MODULE* mod, TransportDbgPtr p)
+    {
+      if (m_transport_dbg_ptr) {
+        std::stringstream s;
+        s << m_name << ": debug callback allready registered";
+        SC_REPORT_WARNING("/OSCI_TLM-2/simple_socket",s.str().c_str());
+      } else {
+        assert(!m_mod || m_mod == mod);
+        m_mod = mod;
+        m_transport_dbg_ptr = p;
+      }
+    }
+
+    void set_get_direct_mem_ptr(MODULE* mod, GetDirectMemPtr p)
+    {
+      if (m_get_direct_mem_ptr) {
+        std::stringstream s;
+        s << m_name << ": get DMI pointer callback allready registered";
+        SC_REPORT_WARNING("/OSCI_TLM-2/simple_socket",s.str().c_str());
+      } else {
+        assert(!m_mod || m_mod == mod);
+        m_mod = mod;
+        m_get_direct_mem_ptr = p;
+      }
+    }
+// Interface implementation
+    sync_enum_type nb_transport_fw(transaction_type& trans,
+                                   phase_type& phase,
+                                   sc_core::sc_time& t)
+    {
+      if (m_nb_transport_ptr) {
+        // forward call
+        assert(m_mod);
+        return (m_mod->*m_nb_transport_ptr)(trans, phase, t);
+
+      } else if (m_b_transport_ptr) {
+        if (phase == tlm::BEGIN_REQ) {
+          // prepare thread to do blocking call
+          process_handle_class * ph = m_process_handle.get_handle(&trans);
+
+          if (!ph) { // create new dynamic process
+            ph = new process_handle_class(&trans);
+            m_process_handle.put_handle(ph);
+
+            sc_core::sc_spawn_options opts;
+            opts.dont_initialize();
+            opts.set_sensitivity(&ph->m_e);
+
+            sc_core::sc_spawn(sc_bind(&fw_process::nb2b_thread,this, ph),
+                            sc_core::sc_gen_unique_name("nb2b_thread"), &opts);
+          }
+
+          ph->m_e.notify(t);
+          return tlm::TLM_ACCEPTED;
+
+        } else if (phase == tlm::END_RESP) {
+          m_response_in_progress = false;
+          m_end_response.notify(t);
+          return tlm::TLM_COMPLETED;
+
+        } else {
+          assert(0); exit(1);
+//          return tlm::TLM_COMPLETED;   ///< unreachable code
+        }
+
+      } else {
+        std::stringstream s;
+        s << m_name << ": no non-blocking transport callback registered";
+        SC_REPORT_ERROR("/OSCI_TLM-2/simple_socket",s.str().c_str());
+      }
+      return tlm::TLM_ACCEPTED;   ///< unreachable code
+    }
+
+    void b_transport(transaction_type& trans, sc_core::sc_time& t)
+    {
+      if (m_b_transport_ptr) {
+        // forward call
+        assert(m_mod);
+        (m_mod->*m_b_transport_ptr)(trans, t);
+        return;
+
+      } else if (m_nb_transport_ptr) {
+        m_peq.notify(trans, t);
+        t = sc_core::SC_ZERO_TIME;
+
+        mm_end_event_ext mm_ext;
+        const bool mm_added = !trans.has_mm();
+
+        if (mm_added) {
+          trans.set_mm(this);
+          trans.set_auto_extension(&mm_ext);
+          trans.acquire();
+        }
+
+        // wait until transaction is finished
+        sc_core::sc_event end_event;
+        m_owner->m_pending_trans[&trans] = &end_event;
+        sc_core::wait(end_event);
+
+        if (mm_added) {
+          // release will not delete the transaction, it will notify mm_ext.done
+          trans.release();
+          if (trans.get_ref_count()) {
+            sc_core::wait(mm_ext.done);
+          }
+          trans.set_mm(0);
+        }
+
+      } else {
+        std::stringstream s;
+        s << m_name << ": no blocking transport callback registered";
+        SC_REPORT_ERROR("/OSCI_TLM-2/simple_socket",s.str().c_str());
+      }
+    }
+
+    unsigned int transport_dbg(transaction_type& trans)
+    {
+      if (m_transport_dbg_ptr) {
+        // forward call
+        assert(m_mod);
+        return (m_mod->*m_transport_dbg_ptr)(trans);
+
+      } else {
+        // No debug support
+        return 0;
+      }
+    }
+
+    bool get_direct_mem_ptr(transaction_type& trans,
+                            tlm::tlm_dmi&  dmi_data)
+    {
+      if (m_get_direct_mem_ptr) {
+        // forward call
+        assert(m_mod);
+        return (m_mod->*m_get_direct_mem_ptr)(trans, dmi_data);
+
+      } else {
+        // No DMI support
+        dmi_data.allow_read_write();
+        dmi_data.set_start_address(0x0);
+        dmi_data.set_end_address((sc_dt::uint64)-1);
+        return false;
+      }
+    }
+
+  private:
+
+// dynamic process handler for nb2b conversion
+
+    class process_handle_class {
+    public:
+      explicit process_handle_class(transaction_type * trans)
+        : m_trans(trans),m_suspend(false) {}
+
+      transaction_type*  m_trans;
+      sc_core::sc_event  m_e;
+      bool m_suspend;
+    };
+
+    class process_handle_list {
+    public:
+      process_handle_list() {}
+
+      ~process_handle_list() {
+        for( typename std::vector<process_handle_class*>::iterator
+               it=v.begin(), end = v.end(); it != end; ++it )
+          delete *it;
+      }
+
+      process_handle_class* get_handle(transaction_type *trans)
+      {
+        typename std::vector<process_handle_class*>::iterator it;
+
+        for(it = v.begin(); it != v.end(); it++) {
+          if ((*it)->m_suspend) {  // found suspended dynamic process, re-use it
+            (*it)->m_trans   = trans; // replace to new one
+            (*it)->m_suspend = false;
+            return *it;
+          }
+        }
+        return NULL; // no suspended process
+      }
+
+      void put_handle(process_handle_class* ph)
+      {
+        v.push_back(ph);
+      }
+
+    private:
+      std::vector<process_handle_class*> v;
+    };
+
+    process_handle_list m_process_handle;
+
+
+    void nb2b_thread(process_handle_class* h)
+    {
+
+      while(1) {
+        transaction_type *trans = h->m_trans;
+        sc_core::sc_time t = sc_core::SC_ZERO_TIME;
+
+        // forward call
+        assert(m_mod);
+        (m_mod->*m_b_transport_ptr)(*trans, t);
+
+        sc_core::wait(t);
+
+        // return path
+        while (m_response_in_progress) {
+          sc_core::wait(m_end_response);
+        }
+        t = sc_core::SC_ZERO_TIME;
+        phase_type phase    = tlm::BEGIN_RESP;
+        sync_enum_type sync = m_owner->bw_nb_transport(*trans, phase, t);
+        if ( !(sync == tlm::TLM_COMPLETED ||
+              (sync == tlm::TLM_UPDATED && phase == tlm::END_RESP)) ) {
+          m_response_in_progress = true;
+        }
+
+        // suspend until next transaction
+        h->m_suspend = true;
+        sc_core::wait();
+      }
+    }
+
+    void b2nb_thread()
+    {
+      while (true) {
+        sc_core::wait(m_peq.get_event());
+
+        transaction_type* trans;
+        while ((trans = m_peq.get_next_transaction())!=0) {
+          assert(m_mod);
+          assert(m_nb_transport_ptr);
+          phase_type phase = tlm::BEGIN_REQ;
+          sc_core::sc_time t = sc_core::SC_ZERO_TIME;
+
+          switch ((m_mod->*m_nb_transport_ptr)(*trans, phase, t)) {
+          case tlm::TLM_COMPLETED:
+          {
+            // notify transaction is finished
+            typename std::map<transaction_type*, sc_core::sc_event *>::iterator it =
+              m_owner->m_pending_trans.find(trans);
+            assert(it != m_owner->m_pending_trans.end());
+            it->second->notify(t);
+            m_owner->m_pending_trans.erase(it);
+            break;
+          }
+
+          case tlm::TLM_ACCEPTED:
+          case tlm::TLM_UPDATED:
+            switch (phase) {
+            case tlm::BEGIN_REQ:
+              m_owner->m_current_transaction = trans;
+              sc_core::wait(m_owner->m_end_request);
+              m_owner->m_current_transaction = 0;
+              break;
+
+            case tlm::END_REQ:
+              sc_core::wait(t);
+              break;
+
+            case tlm::BEGIN_RESP:
+            {
+              phase = tlm::END_RESP;
+              sc_core::wait(t);  // This line is a bug fix added in TLM-2.0.2
+              t = sc_core::SC_ZERO_TIME;
+              (m_mod->*m_nb_transport_ptr)(*trans, phase, t);
+
+              // notify transaction is finished
+              typename std::map<transaction_type*, sc_core::sc_event *>::iterator it =
+                m_owner->m_pending_trans.find(trans);
+              assert(it != m_owner->m_pending_trans.end());
+              it->second->notify(t);
+              m_owner->m_pending_trans.erase(it);
+              break;
+            }
+
+            default:
+              assert(0); exit(1);
+            };
+            break;
+
+          default:
+            assert(0); exit(1);
+          };
+        }
+      }
+    }
+
+    void free(tlm::tlm_generic_payload* trans)
+    {
+      mm_end_event_ext* ext = trans->template get_extension<mm_end_event_ext>();
+      assert(ext);
+      // notif event first before freeing extensions (reset)
+      ext->done.notify();
+      trans->reset();
+    }
+
+  private:
+    struct mm_end_event_ext : public tlm::tlm_extension<mm_end_event_ext>
+    {
+      tlm::tlm_extension_base* clone() const { return NULL; }
+      void free() {}
+      void copy_from(tlm::tlm_extension_base const &) {}
+      sc_core::sc_event done;
+    };
+
+  private:
+    const std::string m_name;
+    simple_target_socket *m_owner;
+    MODULE* m_mod;
+    NBTransportPtr m_nb_transport_ptr;
+    BTransportPtr m_b_transport_ptr;
+    TransportDbgPtr m_transport_dbg_ptr;
+    GetDirectMemPtr m_get_direct_mem_ptr;
+    peq_with_get<transaction_type> m_peq;
+    bool m_response_in_progress;
+    sc_core::sc_event m_end_response;
+  };
+
+private:
+  fw_process m_fw_process;
+  bw_process m_bw_process;
+  std::map<transaction_type*, sc_core::sc_event *> m_pending_trans;
+  sc_core::sc_event m_end_request;
+  transaction_type* m_current_transaction;
+};
+
+//ID Tagged version
+template <typename MODULE,
+          unsigned int BUSWIDTH = 32,
+          typename TYPES = tlm::tlm_base_protocol_types>
+class simple_target_socket_tagged :
+  public tlm::tlm_target_socket<BUSWIDTH, TYPES>
+{
+  friend class fw_process;
+  friend class bw_process;
+public:
+  typedef typename TYPES::tlm_payload_type              transaction_type;
+  typedef typename TYPES::tlm_phase_type                phase_type;
+  typedef tlm::tlm_sync_enum                            sync_enum_type;
+  typedef tlm::tlm_fw_transport_if<TYPES>               fw_interface_type;
+  typedef tlm::tlm_bw_transport_if<TYPES>               bw_interface_type;
+  typedef tlm::tlm_target_socket<BUSWIDTH, TYPES>       base_type;
+
+public:
+  simple_target_socket_tagged() :
+    base_type(sc_core::sc_gen_unique_name("simple_target_socket_tagged")),
+    m_fw_process(this),
+    m_bw_process(this)
+  {
+    bind(m_fw_process);
+  }
+
+  explicit simple_target_socket_tagged(const char* n) :
+    base_type(n),
+    m_fw_process(this),
+    m_bw_process(this)
+  {
+    bind(m_fw_process);
+  }
+
+  using tlm::tlm_target_socket<BUSWIDTH, TYPES>::bind;
+
+  // bw transport must come thru us.
+  tlm::tlm_bw_transport_if<TYPES> * operator ->() {return &m_bw_process;}
+
+  // REGISTER_XXX
+  void register_nb_transport_fw(MODULE* mod,
+                                sync_enum_type (MODULE::*cb)(int id,
+                                                             transaction_type&,
+                                                             phase_type&,
+                                                             sc_core::sc_time&),
+                                int id)
+  {
+    assert(!sc_core::sc_get_curr_simcontext()->elaboration_done());
+    m_fw_process.set_nb_transport_ptr(mod, cb);
+    m_fw_process.set_nb_transport_user_id(id);
+  }
+
+  void register_b_transport(MODULE* mod,
+                            void (MODULE::*cb)(int id,
+                                               transaction_type&,
+                                               sc_core::sc_time&),
+                            int id)
+  {
+    assert(!sc_core::sc_get_curr_simcontext()->elaboration_done());
+    m_fw_process.set_b_transport_ptr(mod, cb);
+    m_fw_process.set_b_transport_user_id(id);
+  }
+
+  void register_transport_dbg(MODULE* mod,
+                              unsigned int (MODULE::*cb)(int id,
+                                                         transaction_type&),
+                              int id)
+  {
+    assert(!sc_core::sc_get_curr_simcontext()->elaboration_done());
+    m_fw_process.set_transport_dbg_ptr(mod, cb);
+    m_fw_process.set_transport_dbg_user_id(id);
+  }
+
+  void register_get_direct_mem_ptr(MODULE* mod,
+                                   bool (MODULE::*cb)(int id,
+                                                      transaction_type&,
+                                                      tlm::tlm_dmi&),
+                                   int id)
+  {
+    assert(!sc_core::sc_get_curr_simcontext()->elaboration_done());
+    m_fw_process.set_get_direct_mem_ptr(mod, cb);
+    m_fw_process.set_get_dmi_user_id(id);
+  }
+
+private:
+  //make call on bw path.
+  sync_enum_type bw_nb_transport(transaction_type &trans, phase_type &phase, sc_core::sc_time &t)
+  {
+    return base_type::operator ->()->nb_transport_bw(trans, phase, t);
+  }
+
+  void bw_invalidate_direct_mem_ptr(sc_dt::uint64 s,sc_dt::uint64 e)
+  {
+    base_type::operator ->()->invalidate_direct_mem_ptr(s, e);
+  }
+
+  //Helper class to handle bw path calls
+  // Needed to detect transaction end when called from b_transport.
+  class bw_process : public tlm::tlm_bw_transport_if<TYPES>
+  {
+  public:
+    bw_process(simple_target_socket_tagged *p_own) : m_owner(p_own)
+    {
+    }
+
+    sync_enum_type nb_transport_bw(transaction_type &trans, phase_type &phase, sc_core::sc_time &t)
+    {
+      typename std::map<transaction_type*, sc_core::sc_event *>::iterator it;
+
+      it = m_owner->m_pending_trans.find(&trans);
+      if(it == m_owner->m_pending_trans.end()) {
+        // Not a blocking call, forward.
+        return m_owner->bw_nb_transport(trans, phase, t);
+
+      } else {
+        if (phase == tlm::END_REQ) {
+          m_owner->m_end_request.notify(sc_core::SC_ZERO_TIME);
+          return tlm::TLM_ACCEPTED;
+
+        } else if (phase == tlm::BEGIN_RESP) {
+          if (m_owner->m_current_transaction == &trans) {
+            m_owner->m_end_request.notify(sc_core::SC_ZERO_TIME);
+          }
+          //TODO: add response-accept delay?
+          it->second->notify(t);
+          m_owner->m_pending_trans.erase(it);
+          return tlm::TLM_COMPLETED;
+
+        } else {
+          assert(0); exit(1);
+        }
+
+//        return tlm::TLM_COMPLETED;  //Should not reach here
+      }
+    }
+
+    void invalidate_direct_mem_ptr(sc_dt::uint64 s,sc_dt::uint64 e)
+    {
+      return m_owner->bw_invalidate_direct_mem_ptr(s, e);
+    }
+
+  private:
+    simple_target_socket_tagged *m_owner;
+  };
+
+  class fw_process : public tlm::tlm_fw_transport_if<TYPES>,
+                     public tlm::tlm_mm_interface
+  {
+  public:
+    typedef sync_enum_type (MODULE::*NBTransportPtr)(int id,
+                                                     transaction_type&,
+                                                     phase_type&,
+                                                     sc_core::sc_time&);
+    typedef void (MODULE::*BTransportPtr)(int id,
+                                          transaction_type&,
+                                          sc_core::sc_time&);
+    typedef unsigned int (MODULE::*TransportDbgPtr)(int id,
+                                                    transaction_type&);
+    typedef bool (MODULE::*GetDirectMemPtr)(int id,
+                                            transaction_type&,
+                                            tlm::tlm_dmi&);
+
+    fw_process(simple_target_socket_tagged *p_own) :
+      m_name(p_own->name()),
+      m_owner(p_own),
+      m_mod(0),
+      m_nb_transport_ptr(0),
+      m_b_transport_ptr(0),
+      m_transport_dbg_ptr(0),
+      m_get_direct_mem_ptr(0),
+      m_nb_transport_user_id(0),
+      m_b_transport_user_id(0),
+      m_transport_dbg_user_id(0),
+      m_get_dmi_user_id(0),
+      m_peq(sc_core::sc_gen_unique_name("m_peq")),
+      m_response_in_progress(false)
+    {
+      sc_core::sc_spawn_options opts;
+      opts.set_sensitivity(&m_peq.get_event());
+      sc_core::sc_spawn(sc_bind(&fw_process::b2nb_thread, this),
+                        sc_core::sc_gen_unique_name("b2nb_thread"), &opts);
+    }
+
+    void set_nb_transport_user_id(int id) { m_nb_transport_user_id = id; }
+    void set_b_transport_user_id(int id) { m_b_transport_user_id = id; }
+    void set_transport_dbg_user_id(int id) { m_transport_dbg_user_id = id; }
+    void set_get_dmi_user_id(int id) { m_get_dmi_user_id = id; }
+
+    void set_nb_transport_ptr(MODULE* mod, NBTransportPtr p)
+    {
+      if (m_nb_transport_ptr) {
+        std::stringstream s;
+        s << m_name << ": non-blocking callback allready registered";
+        SC_REPORT_WARNING("/OSCI_TLM-2/simple_socket",s.str().c_str());
+      } else {
+        assert(!m_mod || m_mod == mod);
+        m_mod = mod;
+        m_nb_transport_ptr = p;
+      }
+    }
+
+    void set_b_transport_ptr(MODULE* mod, BTransportPtr p)
+    {
+      if (m_b_transport_ptr) {
+        std::stringstream s;
+        s << m_name << ": blocking callback allready registered";
+        SC_REPORT_WARNING("/OSCI_TLM-2/simple_socket",s.str().c_str());
+      } else {
+        assert(!m_mod || m_mod == mod);
+        m_mod = mod;
+        m_b_transport_ptr = p;
+      }
+    }
+
+    void set_transport_dbg_ptr(MODULE* mod, TransportDbgPtr p)
+    {
+      if (m_transport_dbg_ptr) {
+        std::stringstream s;
+        s << m_name << ": debug callback allready registered";
+        SC_REPORT_WARNING("/OSCI_TLM-2/simple_socket",s.str().c_str());
+      } else {
+        assert(!m_mod || m_mod == mod);
+        m_mod = mod;
+        m_transport_dbg_ptr = p;
+      }
+    }
+
+    void set_get_direct_mem_ptr(MODULE* mod, GetDirectMemPtr p)
+    {
+      if (m_get_direct_mem_ptr) {
+        std::stringstream s;
+        s << m_name << ": get DMI pointer callback allready registered";
+        SC_REPORT_WARNING("/OSCI_TLM-2/simple_socket",s.str().c_str());
+      } else {
+        assert(!m_mod || m_mod == mod);
+        m_mod = mod;
+        m_get_direct_mem_ptr = p;
+      }
+    }
+// Interface implementation
+    sync_enum_type nb_transport_fw(transaction_type& trans,
+                                   phase_type& phase,
+                                   sc_core::sc_time& t)
+    {
+      if (m_nb_transport_ptr) {
+        // forward call
+        assert(m_mod);
+        return (m_mod->*m_nb_transport_ptr)(m_nb_transport_user_id, trans, phase, t);
+
+      } else if (m_b_transport_ptr) {
+        if (phase == tlm::BEGIN_REQ) {
+
+          // prepare thread to do blocking call
+          process_handle_class * ph = m_process_handle.get_handle(&trans);
+
+          if (!ph) { // create new dynamic process
+            ph = new process_handle_class(&trans);
+            m_process_handle.put_handle(ph);
+
+            sc_core::sc_spawn_options opts;
+            opts.dont_initialize();
+            opts.set_sensitivity(&ph->m_e);
+
+            sc_core::sc_spawn(sc_bind(&fw_process::nb2b_thread, this, ph),
+                            sc_core::sc_gen_unique_name("nb2b_thread"), &opts);
+          }
+
+          ph->m_e.notify(t);
+          return tlm::TLM_ACCEPTED;
+
+        } else if (phase == tlm::END_RESP) {
+          m_response_in_progress = false;
+          m_end_response.notify(t);
+          return tlm::TLM_COMPLETED;
+
+        } else {
+          assert(0); exit(1);
+//          return tlm::TLM_COMPLETED;   ///< unreachable code
+        }
+
+      } else {
+        std::stringstream s;
+        s << m_name << ": no non-blocking transport callback registered";
+        SC_REPORT_ERROR("/OSCI_TLM-2/simple_socket",s.str().c_str());
+      }
+      return tlm::TLM_ACCEPTED;   ///< unreachable code
+    }
+
+    void b_transport(transaction_type& trans, sc_core::sc_time& t)
+    {
+      if (m_b_transport_ptr) {
+        // forward call
+        assert(m_mod);
+        (m_mod->*m_b_transport_ptr)(m_b_transport_user_id, trans, t);
+        return;
+
+      } else if (m_nb_transport_ptr) {
+        m_peq.notify(trans, t);
+        t = sc_core::SC_ZERO_TIME;
+
+        mm_end_event_ext mm_ext;
+        const bool mm_added = !trans.has_mm();
+
+        if (mm_added){
+          trans.set_mm(this);
+          trans.set_auto_extension(&mm_ext);
+          trans.acquire();
+        }
+
+        // wait until transaction is finished
+        sc_core::sc_event end_event;
+        m_owner->m_pending_trans[&trans] = &end_event;
+        sc_core::wait(end_event);
+
+        if (mm_added) {
+          // release will not delete the transaction, it will notify mm_ext.done
+          trans.release();
+          if (trans.get_ref_count()) {
+            sc_core::wait(mm_ext.done);
+          }
+          trans.set_mm(0);
+        }
+
+      } else {
+        std::stringstream s;
+        s << m_name << ": no transport callback registered";
+        SC_REPORT_ERROR("/OSCI_TLM-2/simple_socket",s.str().c_str());
+      }
+    }
+
+    unsigned int transport_dbg(transaction_type& trans)
+    {
+      if (m_transport_dbg_ptr) {
+        // forward call
+        assert(m_mod);
+        return (m_mod->*m_transport_dbg_ptr)(m_transport_dbg_user_id, trans);
+
+      } else {
+        // No debug support
+        return 0;
+      }
+    }
+
+    bool get_direct_mem_ptr(transaction_type& trans,
+                            tlm::tlm_dmi&  dmi_data)
+    {
+      if (m_get_direct_mem_ptr) {
+        // forward call
+        assert(m_mod);
+        return (m_mod->*m_get_direct_mem_ptr)(m_get_dmi_user_id, trans, dmi_data);
+
+      } else {
+        // No DMI support
+        dmi_data.allow_read_write();
+        dmi_data.set_start_address(0x0);
+        dmi_data.set_end_address((sc_dt::uint64)-1);
+        return false;
+      }
+    }
+
+  private:
+// dynamic process handler for nb2b conversion
+
+    class process_handle_class {
+    public:
+      explicit process_handle_class(transaction_type * trans)
+        : m_trans(trans),m_suspend(false){}
+
+      transaction_type*  m_trans;
+      sc_core::sc_event  m_e;
+      bool m_suspend;
+    };
+
+    class process_handle_list {
+    public:
+      process_handle_list() {}
+
+      ~process_handle_list() {
+        for( typename std::vector<process_handle_class*>::iterator
+               it=v.begin(), end = v.end(); it != end; ++it )
+          delete *it;
+      }
+
+      process_handle_class* get_handle(transaction_type *trans)
+      {
+        typename std::vector<process_handle_class*>::iterator it;
+
+        for(it = v.begin(); it != v.end(); it++) {
+          if ((*it)->m_suspend) {  // found suspended dynamic process, re-use it
+            (*it)->m_trans   = trans; // replace to new one
+            (*it)->m_suspend = false;
+            return *it;
+          }
+        }
+        return NULL; // no suspended process
+      }
+
+      void put_handle(process_handle_class* ph)
+      {
+        v.push_back(ph);
+      }
+
+    private:
+      std::vector<process_handle_class*> v;
+    };
+
+    process_handle_list m_process_handle;
+
+    void nb2b_thread(process_handle_class* h)
+    {
+
+      while(1) {
+        transaction_type * trans = h->m_trans;
+        sc_core::sc_time t = sc_core::SC_ZERO_TIME;
+
+        // forward call
+        assert(m_mod);
+        (m_mod->*m_b_transport_ptr)(m_b_transport_user_id, *trans, t);
+
+        sc_core::wait(t);
+
+        // return path
+        while (m_response_in_progress) {
+          sc_core::wait(m_end_response);
+        }
+        t = sc_core::SC_ZERO_TIME;
+        phase_type phase    = tlm::BEGIN_RESP;
+        sync_enum_type sync = m_owner->bw_nb_transport(*trans, phase, t);
+        if ( !(sync == tlm::TLM_COMPLETED ||
+              (sync == tlm::TLM_UPDATED && phase == tlm::END_RESP)) ) {
+          m_response_in_progress = true;
+        }
+
+        // suspend until next transaction
+        h->m_suspend = true;
+        sc_core::wait();
+      }
+    }
+
+    void b2nb_thread()
+    {
+      while (true) {
+        sc_core::wait(m_peq.get_event());
+
+        transaction_type* trans;
+        while ((trans = m_peq.get_next_transaction())!=0) {
+          assert(m_mod);
+          assert(m_nb_transport_ptr);
+          phase_type phase = tlm::BEGIN_REQ;
+          sc_core::sc_time t = sc_core::SC_ZERO_TIME;
+
+          switch ((m_mod->*m_nb_transport_ptr)(m_nb_transport_user_id, *trans, phase, t)) {
+          case tlm::TLM_COMPLETED:
+          {
+            // notify transaction is finished
+            typename std::map<transaction_type*, sc_core::sc_event *>::iterator it =
+              m_owner->m_pending_trans.find(trans);
+            assert(it != m_owner->m_pending_trans.end());
+            it->second->notify(t);
+            m_owner->m_pending_trans.erase(it);
+            break;
+          }
+
+          case tlm::TLM_ACCEPTED:
+          case tlm::TLM_UPDATED:
+            switch (phase) {
+            case tlm::BEGIN_REQ:
+              m_owner->m_current_transaction = trans;
+              sc_core::wait(m_owner->m_end_request);
+              m_owner->m_current_transaction = 0;
+              break;
+
+            case tlm::END_REQ:
+              sc_core::wait(t);
+              break;
+
+            case tlm::BEGIN_RESP:
+            {
+              phase = tlm::END_RESP;
+              sc_core::wait(t);  // This line is a bug fix added in TLM-2.0.2
+              t = sc_core::SC_ZERO_TIME;
+              (m_mod->*m_nb_transport_ptr)(m_nb_transport_user_id, *trans, phase, t);
+
+              // notify transaction is finished
+              typename std::map<transaction_type*, sc_core::sc_event *>::iterator it =
+                m_owner->m_pending_trans.find(trans);
+              assert(it != m_owner->m_pending_trans.end());
+              it->second->notify(t);
+              m_owner->m_pending_trans.erase(it);
+              break;
+            }
+
+            default:
+              assert(0); exit(1);
+            };
+            break;
+
+          default:
+            assert(0); exit(1);
+          };
+        }
+      }
+    }
+
+    void free(tlm::tlm_generic_payload* trans)
+    {
+      mm_end_event_ext* ext = trans->template get_extension<mm_end_event_ext>();
+      assert(ext);
+      // notif event first before freeing extensions (reset)
+      ext->done.notify();
+      trans->reset();
+    }
+
+  private:
+    struct mm_end_event_ext : public tlm::tlm_extension<mm_end_event_ext>
+    {
+      tlm::tlm_extension_base* clone() const { return NULL; }
+      void free() {}
+      void copy_from(tlm::tlm_extension_base const &) {}
+      sc_core::sc_event done;
+    };
+
+  private:
+    const std::string m_name;
+    simple_target_socket_tagged *m_owner;
+    MODULE* m_mod;
+    NBTransportPtr m_nb_transport_ptr;
+    BTransportPtr m_b_transport_ptr;
+    TransportDbgPtr m_transport_dbg_ptr;
+    GetDirectMemPtr m_get_direct_mem_ptr;
+    int m_nb_transport_user_id;
+    int m_b_transport_user_id;
+    int m_transport_dbg_user_id;
+    int m_get_dmi_user_id;
+    peq_with_get<transaction_type> m_peq;
+    bool m_response_in_progress;
+    sc_core::sc_event m_end_response;
+  };
+
+private:
+  fw_process m_fw_process;
+  bw_process m_bw_process;
+  std::map<transaction_type*, sc_core::sc_event *> m_pending_trans;
+  sc_core::sc_event m_end_request;
+  transaction_type* m_current_transaction;
+};
+
+}
+
+#endif
diff --git a/ext/systemc/src/tlm_utils/tlm2_base_protocol_checker.h b/ext/systemc/src/tlm_utils/tlm2_base_protocol_checker.h
new file mode 100755
index 000000000..3dbca9e49
--- /dev/null
+++ b/ext/systemc/src/tlm_utils/tlm2_base_protocol_checker.h
@@ -0,0 +1,1055 @@
+
+// Filename: tlm2_base_protocol_checker.h
+
+//----------------------------------------------------------------------
+//  Copyright (c) 2008-2013 by Doulos Ltd.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//  http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//----------------------------------------------------------------------
+
+// Author: John Aynsley, Doulos
+
+// Version  1, 11 July 2008
+// Version  2, 16 July 2008  Only generate ref_count > 1 warning from 1st checker of path
+// Version  3, 17 July 2008  Support compilation under SystemC 2.1.v1
+// Version  4, 12 Aug  2008  Add header #include <map>
+// Version  5, 08 Sep  2008  Fix bugs in message text
+// Version  6, 01 Aug  2010  Update messages to refer to OSCI TLM-2.0 LRM of July 2009
+// Version  7, 25 Oct  2011  Minor bug fix for certain compilers: replace u_char with uchar_t
+// Version  8, 02 Nov  2011  Support the endianness conversion functions by excluding the
+//                           tlm_endian_context extension from the protocol checks
+// Version  9, 17 Aug  2012  Fix LRM reference on line 805 (should be 8.2.11 a) [NOT YET RELEASED]
+// Version 10,  3 Jan  2013  Updated messages to refer to IEEE Std 1666-2011, the combined SystemC + TLM-2.0 LRM
+//                           Added checks related to the generic payload option attribute
+// Version 11, 14 Mar  2016  Fix minor bug - start_phase should be a copy, not a reference
+
+// TLM-2.0 Base Protocol Compliance Checker
+
+/*
+Instantiate this checker module in-line between initiator and target, initiator and interconnect,
+or interconnect and target by binding the target_socket and initiator_socket
+Binding two checkers either side of an interconnect component, or interleaving a series of
+checkers with interconnect components, will enable some deeper checks as against having just
+a single checker
+
+For example
+
+  Initiator *initiator;
+  Bus       *bus;
+  Memory    *memory;
+  ...
+  initiator->socket.bind(bus->target_socket);
+  bus->initiator_socket.bind(memory->socket);
+
+might become
+
+  tlm_utils::tlm2_base_protocol_checker<32> *checker1;
+  tlm_utils::tlm2_base_protocol_checker<32> *checker2;
+  ...
+  initiator->socket.bind(checker1->target_socket);
+  checker1->initiator_socket.bind(bus->target_socket);
+  bus->initiator_socket.bind(checker2->target_socket);
+  checker2->initiator_socket.bind(memory->socket);
+
+
+GENERAL FEATURES OF THE BASE PROTOCOL CHECKER
+
+The checks are relatively expensive, hence by default the number of checks is limited.
+A maximum number can be set explicitly by calling set_num_checks(max)
+Checking can be deactivated at any time by calling set_num_checks(0)
+All checkers decrement a single global count, because having some checkers running and
+others not can cause bogus violation reports
+It is not permitted to turn checks on by calling set_num_checks() once checking has been
+deactivated, because this could cause bogus violation reports
+
+The DMI and debug checks are unaffected by the num_checks count (because they are cheap)
+
+The error messages contain User Manual references
+
+The checker is designed to be used with a transaction pool: otherwise it could consume
+a lot of memory. The checker keeps a local copy of each transaction object
+Failures are reported with a severity of SC_ERROR. The actions may be overridden by calling:
+   sc_report_handler::set_actions("tlm2_protocol_checker", ...);
+
+SPECIFIC CHECKS
+
+nb_transport: phase sequence BEGIN_REQ -> END_REQ -> BEGIN_RESP -> END_RESP
+Must not have two outstanding requests or responses (exclusion rules)
+Must not have decreasing timing annotations on calls to or returns from nb_transport_fw/bw
+Phase extensions permitted and ignored
+Must not call b_transport during nb_transport phase sequence and vice-versa
+
+nb_transport: memory manager must be set
+nb_transport: reference count must be non-zero
+First checker in BEGIN_REQ path should see ref_count == 1 (warning only)
+An interconnect component that sets a memory manager should also clear it
+An interconnect component that sets extensions with no memory manager should also clear them
+(Does not bother with these memory manager checks for DMI and debug)
+
+Transaction object must be properly initialized
+Many generic payload attributes must not be modified during the transaction lifetime
+Transaction object must not be re-allocated for a new transaction while still in use
+DMI descriptor must be properly initialized
+Debug transaction must be properly initialized
+Debug byte count must be less than data_length
+
+Checks that require multiple checkers to be instantiated along a transaction path:
+The BEGIN_RESP path must be the reverse of the BEGIN_REQ path
+Transaction object must not be sent with BEGIN_REQ while participating in a previous response
+Interconnect component must not set response status attribute to TLM_OK_RESPONSE
+Interconnect component must not modify data array on the response path
+
+Generic payload option attribute (IEEE Std 1666-2011, SystemC 2.3.x)
+gp_option must be properly initialized and only used for DMI and debug transport
+When gp_option is used, other gp attributes must be initalized and used as per the transport interfaces
+*/
+
+
+// ******************** PREAMBLE ********************
+
+
+#ifndef __tlm2_base_protocol_checker__
+#define __tlm2_base_protocol_checker__
+
+#include "systemc"
+using std::cout;
+using std::endl;
+using std::dec;
+using std::hex;
+
+#include "tlm.h"
+#include <sstream>
+#include <map>
+
+
+namespace tlm_utils {
+
+
+// Number of checks remaining
+const  sc_dt::uint64 default_num_checks = 100000;
+static sc_dt::uint64 num_checks = default_num_checks;
+
+
+// Types used when building a trace of the transaction path
+typedef unsigned char uchar_t;
+typedef std::deque<sc_core::sc_module*> deque_t;
+
+struct path_t {
+  path_t () { response_in_progress = false; ok_response = false; resp_data_ptr = 0; }
+
+  bool      response_in_progress;
+  bool      ok_response;
+  deque_t   path;
+  uchar_t*  resp_data_ptr;  // Copy of data on response path
+};
+
+// Global variable used for checks involving multiple checkers along a transaction path
+static std::map<tlm::tlm_generic_payload*, path_t> shared_map;
+
+
+// ******************** CLASS DEFINITION ********************
+
+
+template <unsigned int  BUSWIDTH = 32>
+class tlm2_base_protocol_checker
+
+: public sc_core::sc_module
+, public tlm::tlm_fw_transport_if<tlm::tlm_base_protocol_types>
+, public tlm::tlm_bw_transport_if<tlm::tlm_base_protocol_types>
+{
+public:
+
+  // Instantiate and bind checker inline between an existing pair of initiator and target sockets
+
+  tlm::tlm_target_socket   <BUSWIDTH, tlm::tlm_base_protocol_types, 1> target_socket;
+  tlm::tlm_initiator_socket<BUSWIDTH, tlm::tlm_base_protocol_types, 1> initiator_socket;
+
+  SC_CTOR(tlm2_base_protocol_checker)
+  : m_request_in_progress(0), m_response_in_progress(0)
+  {
+    target_socket   .bind( *this );
+    initiator_socket.bind( *this );
+  }
+
+
+  // Access methods for num_checks count
+
+  static void set_num_checks(sc_dt::uint64 n) {
+    if (num_checks == 0)
+      SC_REPORT_FATAL("tlm2_protocol_checker", "Method set_num_checks called after checking has stopped due to maximum number of checks being reached");
+    num_checks = n;
+  }
+
+  static sc_dt::uint64 get_num_checks() { return num_checks; }
+
+
+  // TLM-2.0 interface methods for initiator and target sockets, instrumented with checks
+
+  virtual tlm::tlm_sync_enum nb_transport_fw(
+    tlm::tlm_generic_payload& trans, tlm::tlm_phase& phase, sc_core::sc_time& delay)
+  {
+    tlm::tlm_phase start_phase = phase;
+
+    if (num_checks)
+      nb_transport_fw_pre_checks( trans, phase, delay );
+
+    tlm::tlm_sync_enum status;
+    status = initiator_socket->nb_transport_fw( trans, phase, delay );
+
+    if (num_checks)
+      nb_transport_fw_post_checks( trans, start_phase, phase, delay, status );
+
+    return status;
+  }
+
+  virtual tlm::tlm_sync_enum nb_transport_bw(
+    tlm::tlm_generic_payload& trans, tlm::tlm_phase& phase, sc_core::sc_time& delay)
+  {
+    if (num_checks)
+      nb_transport_bw_pre_checks( trans, phase, delay );
+
+    tlm::tlm_sync_enum status;
+    status = target_socket->nb_transport_bw( trans, phase, delay );
+
+    if (num_checks)
+      nb_transport_bw_post_checks( trans, phase, delay, status );
+
+    return status;
+  }
+
+  virtual void b_transport( tlm::tlm_generic_payload& trans, sc_core::sc_time& delay )
+  {
+    if (num_checks)
+      b_transport_pre_checks( trans, delay );
+
+    initiator_socket->b_transport( trans, delay );
+
+    if (num_checks)
+      b_transport_post_checks( trans, delay );
+  }
+
+  virtual bool get_direct_mem_ptr(tlm::tlm_generic_payload& trans,
+                                  tlm::tlm_dmi&  dmi_data)
+  {
+    get_direct_mem_ptr_pre_checks( trans, dmi_data );
+
+    bool status;
+    status = initiator_socket->get_direct_mem_ptr( trans, dmi_data );
+
+    get_direct_mem_ptr_post_checks( trans, dmi_data );
+    return status;
+  }
+
+  virtual void invalidate_direct_mem_ptr(sc_dt::uint64 start_range,
+                                         sc_dt::uint64 end_range)
+  {
+    target_socket->invalidate_direct_mem_ptr(start_range, end_range);
+  }
+
+  virtual unsigned int transport_dbg(tlm::tlm_generic_payload& trans)
+  {
+    transport_dbg_pre_checks( trans );
+
+    unsigned int count;
+    count = initiator_socket->transport_dbg( trans );
+
+    transport_dbg_post_checks( trans, count );
+    return count;
+  }
+
+
+private:
+  void b_transport_pre_checks( tlm::tlm_generic_payload& trans, sc_core::sc_time& delay);
+
+  void b_transport_post_checks( tlm::tlm_generic_payload& trans, sc_core::sc_time& delay);
+
+  void nb_transport_fw_pre_checks(
+      tlm::tlm_generic_payload& trans, tlm::tlm_phase& phase, sc_core::sc_time& delay);
+
+  void nb_transport_fw_post_checks(
+      tlm::tlm_generic_payload& trans, tlm::tlm_phase& start_phase, tlm::tlm_phase& phase,
+      sc_core::sc_time& delay, tlm::tlm_sync_enum status);
+
+  void nb_transport_bw_pre_checks(
+      tlm::tlm_generic_payload& trans, tlm::tlm_phase& phase, sc_core::sc_time& delay);
+
+  void nb_transport_bw_post_checks(
+      tlm::tlm_generic_payload& trans, tlm::tlm_phase& phase, sc_core::sc_time& delay,
+      tlm::tlm_sync_enum status);
+
+  void nb_transport_response_checks(
+      tlm::tlm_generic_payload& trans, tlm::tlm_phase& phase, sc_core::sc_time& delay,
+      const char* txt2, const char* txt3, const char* txt4);
+
+  void check_initial_state(       tlm::tlm_generic_payload& trans, const char* txt2 );
+  void check_trans_not_modified(  tlm::tlm_generic_payload& trans, const char* txt2 );
+  void check_response_path(       tlm::tlm_generic_payload& trans, const char* txt2 );
+  void remember_gp_option(        tlm::tlm_generic_payload& trans );
+
+  void get_direct_mem_ptr_pre_checks( tlm::tlm_generic_payload& trans, tlm::tlm_dmi& dmi_data );
+
+  void get_direct_mem_ptr_post_checks( tlm::tlm_generic_payload& trans, tlm::tlm_dmi& dmi_data );
+
+  void transport_dbg_pre_checks( tlm::tlm_generic_payload& trans );
+
+  void transport_dbg_post_checks( tlm::tlm_generic_payload& trans, unsigned int count );
+
+  void tlm2error( tlm::tlm_generic_payload& trans, const char* ref, bool warning = false  );
+
+private:
+
+  struct state_t {
+    state_t() { b_call = 0; ph = tlm::UNINITIALIZED_PHASE; gp = 0; }
+
+    bool                      has_mm;
+    unsigned int              b_call;    // Number of b_transport calls in progress
+    tlm::tlm_phase            ph;
+    sc_core::sc_time          time;      // Current time + annotated delay
+    tlm::tlm_generic_payload* gp;        // Points to new data and byte enable buffers
+    uchar_t*                  data_ptr;  // Stores original pointers
+    uchar_t*                  byte_enable_ptr;
+  };
+
+  // Transaction state for the specific hop where this checker is inlined
+  std::map<tlm::tlm_generic_payload*, state_t> m_map;
+
+  // Flags for exclusion rules
+  tlm::tlm_generic_payload* m_request_in_progress;
+  tlm::tlm_generic_payload* m_response_in_progress;
+
+  std::ostringstream txt;
+
+};
+
+
+
+// ******************** MEMBER FUNCTION DEFINITIONS ********************
+
+
+#define BOILERPLATE \
+template <unsigned int BUSWIDTH> \
+void tlm2_base_protocol_checker<BUSWIDTH>::
+
+
+BOILERPLATE
+b_transport_pre_checks(
+    tlm::tlm_generic_payload& trans, sc_core::sc_time& delay)
+{
+  ++ m_map[&trans].b_call;
+
+  if ( trans.has_mm() && trans.get_ref_count() == 0)
+  {
+    txt << "Transaction passed to b_transport with memory manager and reference count of 0";
+    tlm2error(trans, "14.5 t)");
+  }
+  check_initial_state(trans, "b_transport");
+
+#if !(defined SYSTEMC_VERSION & SYSTEMC_VERSION <= 20050714)
+  if (sc_core::sc_get_current_process_handle().proc_kind() == sc_core::SC_METHOD_PROC_)
+  {
+    txt << "b_transport called from method process";
+    tlm2error(trans, "11.1.1.4 b)");
+  }
+#endif
+
+  if (m_map[&trans].ph > 0 && m_map[&trans].ph < 4)
+  {
+    txt << "b_transport called during a sequence of nb_transport calls";
+    tlm2error(trans, "15.2.10 c)");
+  }
+}
+
+
+BOILERPLATE
+b_transport_post_checks(
+    tlm::tlm_generic_payload& trans, sc_core::sc_time& delay)
+{
+  check_response_path(trans, "b_transport");
+  check_trans_not_modified(trans, "b_transport");
+  -- m_map[&trans].b_call;
+}
+
+
+BOILERPLATE
+nb_transport_fw_pre_checks(
+    tlm::tlm_generic_payload& trans, tlm::tlm_phase& phase, sc_core::sc_time& delay)
+{
+  if ( !trans.has_mm() )
+  {
+    txt << "Transaction passed to nb_transport_fw with no memory manager set";
+    tlm2error(trans, "14.5 i)");
+  }
+  if ( trans.get_ref_count() == 0)
+  {
+    txt << "Transaction passed to nb_transport_fw with reference count of 0";
+    tlm2error(trans, "14.5 t)");
+  }
+
+  switch (phase)
+  {
+    case tlm::BEGIN_REQ:
+      check_initial_state(trans, "nb_transport_fw");
+
+      if (m_map[&trans].ph > 0 &&  m_map[&trans].ph < 4) // END_RESP -> BEGIN_REQ is legal
+      {
+        txt << "Phase " << phase << " sent out-of-sequence on forward path, detected in nb_transport_fw";
+        tlm2error(trans, "15.2.4");
+      }
+
+      if (m_request_in_progress)
+      {
+        txt << "Transaction violates BEGIN_REQ exclusion rule, detected in nb_transport_fw";
+        tlm2error(trans, "15.2.6 e)");
+      }
+      m_request_in_progress = &trans;
+
+      if (m_map[&trans].b_call)
+      {
+        txt << "nb_transport_fw called during a b_transport call";
+        tlm2error(trans, "15.2.10 c)");
+      }
+      break;
+
+    case tlm::END_REQ:
+    case tlm::BEGIN_RESP:
+    case tlm::UNINITIALIZED_PHASE:
+      txt << "Phase " << phase << " sent on forward path, detected in nb_transport_fw";
+      tlm2error(trans, " 15.2.3 c)");
+      break;
+
+    case tlm::END_RESP:
+      if (m_map[&trans].ph != tlm::BEGIN_RESP)
+      {
+        txt << "Phase " << phase << " sent out-of-sequence on forward path, detected in nb_transport_fw";
+        tlm2error(trans, "15.2.4");
+      }
+      m_response_in_progress = 0;
+      break;
+  }
+
+  if (phase < 5)  // Ignore extended phases
+    m_map[&trans].ph = phase;
+
+  if (sc_core::sc_time_stamp() + delay < m_map[&trans].time)
+  {
+    txt << "nb_transport_fw called with decreasing timing annotation:"
+        << " delay = " << delay
+        << ", sc_time_stamp() + delay from previous call = " << m_map[&trans].time;
+    tlm2error(trans, "15.2.7 c)");
+  }
+  m_map[&trans].time = sc_core::sc_time_stamp() + delay;
+}
+
+
+BOILERPLATE
+nb_transport_fw_post_checks(
+    tlm::tlm_generic_payload& trans, tlm::tlm_phase& start_phase, tlm::tlm_phase& phase,
+    sc_core::sc_time& delay, tlm::tlm_sync_enum status)
+{
+  if (status == tlm::TLM_UPDATED)
+  {
+    nb_transport_response_checks(
+        trans, phase, delay, "(forward) return", "Return from nb_transport_fw", "nb_transport_fw");
+  }
+  else if (status == tlm::TLM_COMPLETED)
+  {
+    if (start_phase == tlm::BEGIN_REQ)
+      check_response_path(trans, "nb_transport_fw");
+    m_request_in_progress = 0;
+    m_map[&trans].ph = tlm::UNINITIALIZED_PHASE;
+  }
+
+  // Transaction object should not be re-allocated, even during the END_RESP phase
+  //if (phase != tlm::END_RESP)
+  {
+    std::ostringstream txt;
+    txt << "nb_transport_fw, phase = " << phase;
+    check_trans_not_modified(trans, txt.str().c_str());
+  }
+}
+
+
+BOILERPLATE
+nb_transport_bw_pre_checks(
+    tlm::tlm_generic_payload& trans, tlm::tlm_phase& phase, sc_core::sc_time& delay)
+{
+  if ( !trans.has_mm() )
+  {
+    txt << "Transaction passed to nb_transport_bw with no memory manager set";
+    tlm2error(trans, "14.5 i)");
+  }
+  if ( trans.get_ref_count() == 0)
+  {
+    txt << "Transaction passed to nb_transport_bw with reference count of 0";
+    tlm2error(trans, "14.5 t)");
+  }
+  nb_transport_response_checks(
+      trans, phase, delay, "backward", "nb_transport_bw called", "nb_transport_bw");
+}
+
+
+BOILERPLATE
+nb_transport_bw_post_checks(
+    tlm::tlm_generic_payload& trans, tlm::tlm_phase& phase, sc_core::sc_time& delay,
+    tlm::tlm_sync_enum status)
+{
+  if (status == tlm::TLM_UPDATED)
+  {
+    switch (phase)
+    {
+      case tlm::BEGIN_REQ:
+        txt << "Phase " << phase << " sent out-of-sequence on (backward) return path, detected in nb_transport_bw";
+        tlm2error(trans, "15.2.4");
+        break;
+
+      case tlm::END_REQ:
+      case tlm::BEGIN_RESP:
+      case tlm::UNINITIALIZED_PHASE:
+        txt << "Phase " << phase << " sent on (backward) return path, detected in nb_transport_bw";
+        tlm2error(trans, "15.2.3 c)");
+        break;
+
+      case tlm::END_RESP:
+        if (m_map[&trans].ph != tlm::BEGIN_RESP)
+        {
+          txt << "Phase " << phase << " sent out-of-sequence on (backward) return path, detected in nb_transport_bw";
+          tlm2error(trans, "15.2.4");
+        }
+
+        m_response_in_progress = 0;
+        break;
+    }
+
+    if (phase < 5)  // Ignore extended phases
+      m_map[&trans].ph = phase;
+
+    if (sc_core::sc_time_stamp() + delay < m_map[&trans].time)
+    {
+      txt << "Return from nb_transport_bw with decreasing timing annotation:"
+          << " delay = " << delay
+          << ", sc_time_stamp() + delay from previous call = " << m_map[&trans].time;
+      tlm2error(trans, "15.2.7 c)");
+    }
+    m_map[&trans].time = sc_core::sc_time_stamp() + delay;
+  }
+  else if (status == tlm::TLM_COMPLETED)
+  {
+    m_response_in_progress = 0;
+    m_map[&trans].ph = tlm::UNINITIALIZED_PHASE;
+  }
+
+  // Transaction object should not be re-allocated, even during the END_RESP phase
+  //if (phase != tlm::END_RESP)
+  {
+    std::ostringstream txt;
+    txt << "nb_transport_bw, phase = " << phase;
+    check_trans_not_modified(trans, txt.str().c_str());
+  }
+}
+
+
+BOILERPLATE
+nb_transport_response_checks(
+    tlm::tlm_generic_payload& trans, tlm::tlm_phase& phase, sc_core::sc_time& delay,
+    const char* txt2, const char* txt3, const char* txt4)
+{
+  if (trans.is_response_ok())
+    if (shared_map[&trans].response_in_progress && !shared_map[&trans].ok_response)
+    {
+      txt << "Interconnect component sets response status attribute to TLM_OK_RESPONSE"
+          << ", detected in " << txt4;
+      tlm2error(trans, "14.7");
+
+    }
+
+  switch (phase)
+  {
+    case tlm::BEGIN_REQ:
+    case tlm::END_RESP:
+    case tlm::UNINITIALIZED_PHASE:
+      txt << "Phase " << phase << " sent on " << txt2 << " path"
+          << ", detected in " << txt4;
+      tlm2error(trans, "15.2.3 c)");
+      break;
+
+    case tlm::END_REQ:
+      if (m_map[&trans].ph != tlm::BEGIN_REQ)
+      {
+        txt << "Phase " << phase << " sent out-of-sequence on " << txt2 << " path"
+            << ", detected in " << txt4;
+        tlm2error(trans, "15.2.4");
+      }
+
+      m_request_in_progress = 0;
+      break;
+
+    case tlm::BEGIN_RESP:
+      if (m_map[&trans].ph != tlm::BEGIN_REQ && m_map[&trans].ph != tlm::END_REQ)
+      {
+        txt << "Phase " << phase << " sent out-of-sequence on " << txt2 << " path"
+            << ", detected in " << txt4;
+        tlm2error(trans, "15.2.4");
+      }
+
+      if (&trans == m_request_in_progress)
+        m_request_in_progress = 0;
+
+      if (m_response_in_progress)
+      {
+        txt << "Transaction violates BEGIN_RESP exclusion rule"
+            << ", detected in " << txt4;
+        tlm2error(trans, "15.2.6 f)");
+      }
+      m_response_in_progress = &trans;
+
+      check_response_path(trans, txt4);
+      break;
+  }
+
+  if (phase < 5)  // Ignore extended phases
+    m_map[&trans].ph = phase;
+
+  if (sc_core::sc_time_stamp() + delay < m_map[&trans].time)
+  {
+    txt << txt3 << " with decreasing timing annotation:"
+        << " delay = " << delay
+        << ", sc_time_stamp() + delay from previous call = " << m_map[&trans].time;
+    tlm2error(trans, "15.2.7 c)");
+  }
+  m_map[&trans].time = sc_core::sc_time_stamp() + delay;
+}
+
+
+BOILERPLATE
+check_initial_state(
+    tlm::tlm_generic_payload& trans, const char* txt2 )
+{
+  if (num_checks > 0)
+  {
+    --num_checks;
+    if (num_checks == 0)
+      SC_REPORT_INFO("tlm2_protocol_checker", "Checkers deactivated after executing the set number of checks");
+  }
+
+  if ( trans.has_mm() && trans.get_ref_count() > 1 && shared_map[&trans].path.empty() )
+  {
+    txt << "New transaction passed to " << txt2 << " with reference count = "
+        << trans.get_ref_count();
+    tlm2error(trans, "14.5 t)", true);
+  }
+  if (trans.get_data_ptr() == 0 && trans.get_command() != tlm::TLM_IGNORE_COMMAND)
+  {
+    txt << "Transaction not properly initialized: data_ptr == 0, detected in " << txt2;
+    tlm2error(trans, "14.11 e)");
+  }
+  if (trans.get_data_length() == 0 && trans.get_command() != tlm::TLM_IGNORE_COMMAND)
+  {
+    txt << "Transaction not properly initialized: data_langth == 0, detected in " << txt2;
+    tlm2error(trans, "14.12 d)");
+  }
+  if (trans.get_byte_enable_ptr() != 0 && trans.get_byte_enable_length() == 0)
+  {
+    txt << "Transaction not properly initialized: "
+        << "byte_enable_ptr != 0 and byte_enable_length == 0, detected in " << txt2;
+    tlm2error(trans, "14.14 f)");
+  }
+  if (trans.get_streaming_width() == 0)
+  {
+    txt << "Transaction not properly initialized: streaming_width == 0, detected in " << txt2;
+    tlm2error(trans, "14.15 f)");
+  }
+  if (trans.is_dmi_allowed())
+  {
+    txt << "Transaction not properly initialized: dmi_allowed == true, detected in " << txt2;
+    tlm2error(trans, "14.16");
+  }
+  if (trans.get_response_status() != tlm::TLM_INCOMPLETE_RESPONSE)
+  {
+    txt << "Transaction not properly initialized: response_status != TLM_INCOMPLETE_RESPONSE, detected in " << txt2;
+    tlm2error(trans, "14.17 e)");
+  }
+  if (trans.get_gp_option() != tlm::TLM_MIN_PAYLOAD)
+  {
+    txt << "Transaction not properly initialized: gp_option != TLM_MIN_PAYLOAD, detected in " << txt2;
+    tlm2error(trans, "14.8 g)");
+  }
+
+  // Setup clones of transaction and buffers in map
+  tlm::tlm_generic_payload* gp = m_map[&trans].gp;
+  if (gp == 0)
+    gp = new tlm::tlm_generic_payload;  // Memory leak: transactions are never cleared from map
+  else
+  {
+    delete [] gp->get_data_ptr();
+    gp->free_all_extensions();
+  }
+  gp->set_data_ptr( new uchar_t[trans.get_data_length()] );
+  m_map[&trans].data_ptr = trans.get_data_ptr();
+
+  if (gp->get_byte_enable_ptr())
+    delete [] gp->get_byte_enable_ptr();
+  if (trans.get_byte_enable_ptr())
+    gp->set_byte_enable_ptr( new uchar_t[trans.get_byte_enable_length()] );
+  else
+    gp->set_byte_enable_ptr(0);
+  m_map[&trans].byte_enable_ptr = trans.get_byte_enable_ptr();
+
+  gp->deep_copy_from(trans);
+  m_map[&trans].gp = gp;
+  m_map[&trans].time = sc_core::SC_ZERO_TIME;
+  m_map[&trans].has_mm = trans.has_mm();
+
+  // Store request path checker sequence
+  if (shared_map[&trans].resp_data_ptr)
+  {
+    delete [] shared_map[&trans].resp_data_ptr;
+    shared_map[&trans].resp_data_ptr = 0;
+  }
+  if (shared_map[&trans].response_in_progress)
+  {
+    txt << "Transaction object sent with BEGIN_REQ while still being used on a previous response path, detected in " << txt2;
+    tlm2error(trans, "14.5 x)");
+  }
+  shared_map[&trans].ok_response = false;
+  shared_map[&trans].path.push_back(this);
+}
+
+
+BOILERPLATE
+remember_gp_option(
+    tlm::tlm_generic_payload& trans)
+{
+  // Setup clone of transaction in map in order to check gp_option only
+  tlm::tlm_generic_payload* gp = m_map[&trans].gp;
+  if (gp == 0)
+    gp = new tlm::tlm_generic_payload;  // Memory leak: transactions are never cleared from map
+  gp->set_gp_option( trans.get_gp_option() );
+  m_map[&trans].gp = gp;
+}
+
+
+BOILERPLATE
+check_trans_not_modified(
+    tlm::tlm_generic_payload& trans, const char* txt2 )
+{
+  tlm::tlm_generic_payload* init = m_map[&trans].gp;
+
+  if (trans.get_command() != init->get_command())
+  {
+    txt << "Command attribute modified during transaction lifetime, detected in " << txt2;
+    tlm2error(trans, "14.7");
+  }
+  if (trans.get_data_ptr() != m_map[&trans].data_ptr)
+  {
+    txt << "Data pointer attribute modified during transaction lifetime, detected in " << txt2;
+    tlm2error(trans, "14.7");
+  }
+  if (trans.get_data_length() != init->get_data_length())
+  {
+    txt << "Data length attribute modified during transaction lifetime, detected in " << txt2;
+    tlm2error(trans, "14.7");
+  }
+  if (trans.get_command() == tlm::TLM_WRITE_COMMAND)
+    for (unsigned int i = 0; i < init->get_data_length(); i++)
+      if (trans.get_data_ptr()[i] != init->get_data_ptr()[i])
+      {
+        txt << "Data array modified during transaction lifetime, detected in " << txt2;
+        tlm2error(trans, "14.7");
+      }
+  if (trans.get_byte_enable_ptr() != m_map[&trans].byte_enable_ptr)
+  {
+    txt << "Byte enable pointer attribute modified during transaction lifetime, detected in " << txt2;
+    tlm2error(trans, "14.7");
+  }
+  if (trans.get_byte_enable_length() != init->get_byte_enable_length())
+  {
+    txt << "Byte enable length attribute modified during transaction lifetime, detected in " << txt2;
+    tlm2error(trans, "14.7");
+  }
+  if (trans.get_byte_enable_ptr())
+    for (unsigned int i = 0; i < init->get_byte_enable_length(); i++)
+      if (trans.get_byte_enable_ptr()[i] != init->get_byte_enable_ptr()[i])
+      {
+        txt << "Byte enable array modified during transaction lifetime, detected in " << txt2;
+        tlm2error(trans, "14.7");
+      }
+  if (trans.get_streaming_width() != init->get_streaming_width())
+  {
+    txt << "Streaming width attribute modified during transaction lifetime, detected in " << txt2;
+    tlm2error(trans, "14.7");
+  }
+  if (init->get_gp_option() == tlm::TLM_MIN_PAYLOAD && trans.get_gp_option() != tlm::TLM_MIN_PAYLOAD)
+  {
+    txt << "Generic payload option attribute modified during transaction lifetime, detected in " << txt2;
+    tlm2error(trans, "14.8 g)");
+  }
+  if ( !m_map[&trans].has_mm )
+  {
+    if (trans.has_mm())
+    {
+      txt << "Interconnect component sets a memory manager, but does not clear it on return, detected in " << txt2;
+      tlm2error(trans, "14.5 aa)");
+    }
+
+    for (unsigned int i = 0; i < tlm::max_num_extensions(); i++)
+      // Exclude tlm_endian_context extension from the check because it is not cloned in m_map
+      if (i != tlm::tlm_endian_context::ID)
+        if (trans.get_extension(i))
+          if ( !m_map[&trans].gp->get_extension(i) )
+          {
+            txt << "Extension set (index = " << i << ") without also being deleted in the absence of a memory manager, detected in " << txt2;
+            tlm2error(trans, "14.5 aa)");
+          }
+  }
+
+  uchar_t* resp_data_ptr = shared_map[&trans].resp_data_ptr;
+  if (resp_data_ptr)
+    for (unsigned int i = 0; i < trans.get_data_length(); i++)
+      if (trans.get_data_ptr()[i] != resp_data_ptr[i])
+      {
+        txt << "Transaction data array modified in interconnect component on response path, detected in " << txt2;
+        tlm2error(trans, "14.7");
+      }
+}
+
+
+BOILERPLATE
+check_response_path(
+    tlm::tlm_generic_payload& trans, const char* txt2 )
+{
+  if ( !shared_map[&trans].path.empty() )
+  {
+    if ( this != shared_map[&trans].path.back() )
+    {
+      txt << "BEGIN_RESP path is not the reverse of the BEGIN_REQ path.";
+      txt << "\nBEGIN_REQ path includes these checkers: -> ";
+      deque_t path = shared_map[&trans].path;
+      for (deque_t::iterator i = path.begin(); i < path.end(); i++)
+        txt << (*i)->name() << " -> ";
+      txt << "\nDetected in " << txt2;
+      tlm2error(trans, "15.2.11 a)");
+    }
+    shared_map[&trans].path.pop_back();
+    shared_map[&trans].response_in_progress = !shared_map[&trans].path.empty();
+    shared_map[&trans].ok_response = trans.is_response_ok();
+
+    // Create a copy of the data array for comparison on the response path
+    if ( !shared_map[&trans].resp_data_ptr )
+    {
+      shared_map[&trans].resp_data_ptr = new uchar_t[trans.get_data_length()];
+      memcpy(shared_map[&trans].resp_data_ptr, trans.get_data_ptr(), trans.get_data_length());
+    }
+  }
+}
+
+
+BOILERPLATE
+get_direct_mem_ptr_pre_checks(
+    tlm::tlm_generic_payload& trans, tlm::tlm_dmi& dmi_data )
+{
+  remember_gp_option(trans);
+
+  if (dmi_data.get_dmi_ptr() != 0)
+  {
+    txt << "DMI descriptor not properly initialized: dmi_ptr != 0";
+    tlm2error(trans, "11.2.5 f)");
+  }
+  if (!dmi_data.is_none_allowed())
+  {
+    txt << "DMI descriptor not properly initialized: granted_access != DMI_ACCESS_NONE";
+    tlm2error(trans, "11.2.5 a)");
+  }
+  if (dmi_data.get_start_address() != 0)
+  {
+    txt << "DMI descriptor not properly initialized: start_address != 0";
+    tlm2error(trans, "11.2.5 u)");
+  }
+  if (dmi_data.get_end_address() != (sc_dt::uint64)(-1))
+  {
+    txt << "DMI descriptor not properly initialized: end_address != 0";
+    tlm2error(trans, "11.2.5 u)");
+  }
+  if (dmi_data.get_read_latency() != sc_core::SC_ZERO_TIME)
+  {
+    txt << "DMI descriptor not properly initialized: read_latency != SC_ZERO_TIME";
+    tlm2error(trans, "11.2.5 ac)");
+  }
+  if (dmi_data.get_write_latency() != sc_core::SC_ZERO_TIME)
+  {
+    txt << "DMI descriptor not properly initialized: write_latency != SC_ZERO_TIME";
+    tlm2error(trans, "11.2.5 ac)");
+  }
+
+  if (trans.get_gp_option() == tlm::TLM_FULL_PAYLOAD)
+  {
+    /*
+    if (trans.is_dmi_allowed())  // Would be rather brutal to flag dmi_allowed as an arror for a DMI transaction!
+    {
+      txt << "DMI transaction not properly initialized: dmi_allowed == true";
+      tlm2error(trans, "14.8 e) & 14.16");
+    }
+	*/
+    if (trans.get_response_status() != tlm::TLM_INCOMPLETE_RESPONSE)
+    {
+      txt << "DMI transaction not properly initialized: response_status != TLM_INCOMPLETE_RESPONSE";
+      tlm2error(trans, "14.8 e) & 14.17 e)");
+    }
+  }
+  else if (trans.get_gp_option() == tlm::TLM_FULL_PAYLOAD_ACCEPTED)
+  {
+    txt << "DMI transaction not properly initialized: gp_option == TLM_FULL_PAYLOAD_ACCEPTED";
+    tlm2error(trans, "14.8 c) & e) & j)");
+  }
+}
+
+
+BOILERPLATE
+get_direct_mem_ptr_post_checks( tlm::tlm_generic_payload& trans, tlm::tlm_dmi& dmi_data )
+{
+  tlm::tlm_generic_payload* init = m_map[&trans].gp;
+
+  if (init->get_gp_option() == tlm::TLM_MIN_PAYLOAD && trans.get_gp_option() != tlm::TLM_MIN_PAYLOAD)
+  {
+    txt << "DMI transaction gp_option attribute value TLM_MIN_PAYLOAD modified during transaction lifetime";
+    tlm2error(trans, "14.8 h)");
+  }
+  else if (init->get_gp_option() == tlm::TLM_FULL_PAYLOAD && trans.get_gp_option() == tlm::TLM_MIN_PAYLOAD)
+  {
+    txt << "DMI transaction gp_option attribute value changed from TLM_FULL_PAYLOAD to TLM_MIN_PAYLOAD";
+    tlm2error(trans, "14.8 j)");
+  }
+}
+
+
+BOILERPLATE
+transport_dbg_pre_checks( tlm::tlm_generic_payload& trans )
+{
+  remember_gp_option(trans);
+
+  if (trans.get_data_length() > 0 && trans.get_data_ptr() == 0)
+  {
+    txt << "Debug transaction has data_ptr == 0";
+    tlm2error(trans, "11.3.4 l)");
+  }
+
+  if (trans.get_gp_option() == tlm::TLM_FULL_PAYLOAD)
+  {
+    if (trans.get_byte_enable_ptr() != 0 && trans.get_byte_enable_length() == 0)
+    {
+      txt << "Debug transaction not properly initialized: "
+          << "byte_enable_ptr != 0 and byte_enable_length == 0";
+      tlm2error(trans, "14.8 f) & 14.14 f)");
+    }
+    if (trans.get_streaming_width() == 0)
+    {
+      txt << "Debug transaction not properly initialized: streaming_width == 0";
+      tlm2error(trans, "14.8 f) & 14.15 f)");
+    }
+    if (trans.is_dmi_allowed())
+    {
+      txt << "Debug transaction not properly initialized: dmi_allowed == true";
+      tlm2error(trans, "14.8 f) & 14.16");
+    }
+    if (trans.get_response_status() != tlm::TLM_INCOMPLETE_RESPONSE)
+    {
+      txt << "Debug transaction not properly initialized: response_status != TLM_INCOMPLETE_RESPONSE";
+      tlm2error(trans, "14.8 f) & 14.17 e)");
+    }
+  }
+  else if (trans.get_gp_option() == tlm::TLM_FULL_PAYLOAD_ACCEPTED)
+  {
+    txt << "Debug transaction not properly initialized: gp_option == TLM_FULL_PAYLOAD_ACCEPTED";
+    tlm2error(trans, "14.8 c) & f) & l)");
+  }}
+
+
+BOILERPLATE
+transport_dbg_post_checks( tlm::tlm_generic_payload& trans, unsigned int count )
+{
+  tlm::tlm_generic_payload* init = m_map[&trans].gp;
+
+  if (trans.get_data_length() > 0 && trans.get_data_ptr() == 0)
+  {
+    txt << "Debug transaction has data_ptr == 0";
+    tlm2error(trans, "11.3.4 l)");
+  }
+  if (count > trans.get_data_length())
+  {
+    txt << "Count returned from transport_dbg is greater than data_length";
+    tlm2error(trans, "11.3.4 s)");
+  }
+
+  if (init->get_gp_option() == tlm::TLM_MIN_PAYLOAD && trans.get_gp_option() != tlm::TLM_MIN_PAYLOAD)
+  {
+    txt << "Debug transaction gp_option attribute value TLM_MIN_PAYLOAD modified during transaction lifetime";
+    tlm2error(trans, "14.8 h)");
+  }
+  else if (init->get_gp_option() == tlm::TLM_FULL_PAYLOAD && trans.get_gp_option() == tlm::TLM_MIN_PAYLOAD)
+  {
+    txt << "Debug transaction gp_option attribute value changed from TLM_FULL_PAYLOAD to TLM_MIN_PAYLOAD";
+    tlm2error(trans, "14.8 l)");
+  }}
+
+
+BOILERPLATE
+tlm2error( tlm::tlm_generic_payload& trans, const char* ref, bool warning )
+{
+  txt << "\n\nRefer to IEEE Std 1666-2011, clause " << ref;
+  txt << "\n\nChecker instance: " << this->name();
+  txt << "\n\nTransaction details:";
+  txt << "\n  has_mm             = " << dec << trans.has_mm() << " (bool)";
+  txt << "\n  ref_count          = " << dec << trans.get_ref_count() << " (int)";
+  txt << "\n\n  gp_option          = " <<
+      (trans.get_gp_option() == tlm::TLM_MIN_PAYLOAD  ? "TLM_MIN_PAYLOAD"
+	  :trans.get_gp_option() == tlm::TLM_FULL_PAYLOAD ? "TLM_FULL_PAYLOAD"
+	                                                  : "TLM_FULL_PAYLOAD_ACCEPTED");
+  txt << "\n  command            = " <<
+     (trans.get_command() == tlm::TLM_READ_COMMAND  ? "TLM_READ_COMMAND"
+     :trans.get_command() == tlm::TLM_WRITE_COMMAND ? "TLM_WRITE_COMMAND"
+                                                    : "TLM_IGNORE_COMMAND");
+  txt << "\n  address            = " << hex << trans.get_address() << " (hex)";
+  txt << "\n  data_ptr           = " << hex
+      << reinterpret_cast<int*>(trans.get_data_ptr()) << " (hex)";
+  txt << "\n  data_length        = " << hex << trans.get_data_length() << " (hex)";
+  txt << "\n  streaming_width    = " << hex << trans.get_streaming_width() << " (hex)";
+  txt << "\n  byte_enable_ptr    = " << hex
+      << reinterpret_cast<int*>(trans.get_byte_enable_ptr()) << " (hex)";
+  txt << "\n  byte_enable_length = " << hex << trans.get_byte_enable_length() << " (hex)";
+  txt << "\n  dmi_allowed        = " << dec << trans.is_dmi_allowed() << " (bool)";
+  txt << "\n  response_status    = " << trans.get_response_string();
+
+  bool extensions_present = false;
+  for (unsigned int i = 0; i < tlm::max_num_extensions(); i++)
+  {
+    tlm::tlm_extension_base* ext = trans.get_extension(i);
+    if (ext)
+    {
+      if (!extensions_present)
+        txt << "\n\n  extensions:";
+      txt << "\n    index = " << i << "   type = " << typeid(*ext).name();
+      extensions_present = true;
+    }
+  }
+
+  txt << "\n\n";
+  if (warning)
+    SC_REPORT_WARNING("tlm2_protocol_checker", txt.str().c_str());
+  else
+    SC_REPORT_ERROR("tlm2_protocol_checker", txt.str().c_str());
+}
+
+
+
+} // namespace tlm_utils
+
+#endif // __tlm2_base_protocol_checker__
diff --git a/ext/systemc/src/tlm_utils/tlm_quantumkeeper.h b/ext/systemc/src/tlm_utils/tlm_quantumkeeper.h
new file mode 100644
index 000000000..ed211665f
--- /dev/null
+++ b/ext/systemc/src/tlm_utils/tlm_quantumkeeper.h
@@ -0,0 +1,172 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+// 20-Mar-2009  John Aynsley  Add set_and_sync() method
+
+
+#ifndef __TLM_QUANTUMKEEPER_H__
+#define __TLM_QUANTUMKEEPER_H__
+
+#include "tlm_core/tlm_2/tlm_quantum/tlm_global_quantum.h"
+
+namespace tlm_utils {
+
+  //
+  // tlm_quantumkeeper class
+  //
+  // The tlm_quantumkeeper class is used to keep track of the local time in
+  // an initiator (how much it has run ahead of the SystemC time), to
+  // synchronize with SystemC time etc.
+  //
+  class tlm_quantumkeeper
+  {
+  public:
+    //
+    // Static setters/getters for the global quantum value.
+    //
+    // The global quantum is the maximum time an initiator can run ahead of
+    // systemC time. All initiators will synchronize on timingpoints that are
+    // multiples of the global quantum value.
+    //
+    static void set_global_quantum(const sc_core::sc_time& t)
+    {
+      tlm::tlm_global_quantum::instance().set(t);
+    }
+
+    static const sc_core::sc_time& get_global_quantum()
+    {
+      return tlm::tlm_global_quantum::instance().get();
+    }
+
+  public:
+    tlm_quantumkeeper() :
+      m_next_sync_point(sc_core::SC_ZERO_TIME),
+      m_local_time(sc_core::SC_ZERO_TIME)
+    {
+    }
+
+    virtual ~tlm_quantumkeeper() {}
+
+    //
+    // Increment the local time (the time the initiator is ahead of the
+    // systemC time) After incrementing the local time an initiator should
+    // check (with the need_sync method) if a sync is required.
+    //
+    virtual void inc(const sc_core::sc_time& t)
+    {
+      m_local_time += t;
+    }
+
+    //
+    // Sets the local time (the time the initiator is ahead of the
+    // systemC time) After changing the local time an initiator should
+    // check (with the need_sync method) if a sync is required.
+    //
+    virtual void set(const sc_core::sc_time& t)
+    {
+      m_local_time = t;
+    }
+
+    //
+    // Checks if a sync to systemC is required for this initiator. This will
+    // be the case if the local time becomes greater than the local (current)
+    // quantum value for this initiator.
+    //
+    virtual bool need_sync() const
+    {
+      return sc_core::sc_time_stamp() + m_local_time >= m_next_sync_point;
+    }
+
+    //
+    // Synchronize to systemC. This call will do a wait for the time the
+    // initiator was running ahead of systemC time and reset the
+    // tlm_quantumkeeper.
+    //
+    virtual void sync()
+    {
+      sc_core::wait(m_local_time);
+      reset();
+    }
+
+    //
+    // Non-virtual convenience method to set the local time and sync only if needed
+    //
+    void set_and_sync(const sc_core::sc_time& t)
+    {
+      set(t);
+      if (need_sync())
+        sync();
+    }
+
+    //
+    // Resets the local time to SC_ZERO_TIME and computes the value of the
+    // next local quantum. This method should be called by an initiator after
+    // a wait because of a synchronization request by a target (TLM_ACCEPTED,
+    // or TLM_UPDATED).
+    //
+    virtual void reset()
+    {
+      m_local_time = sc_core::SC_ZERO_TIME;
+      m_next_sync_point = sc_core::sc_time_stamp() + compute_local_quantum();
+    }
+
+    //
+    // Helper function to get the current systemC time, taken the local time
+    // into account. The current systemC time is calculated as the time
+    // returned by sc_time_stamp incremeneted with the time the initiator is
+    // running ahead.
+    //
+    virtual sc_core::sc_time get_current_time() const
+    {
+      return sc_core::sc_time_stamp() + m_local_time;
+    }
+
+    //
+    // Helper functions to get the time the initiator is running ahead of
+    // systenC (local time). This time should be passed to a target in the
+    // nb_transport call
+    //
+    virtual sc_core::sc_time get_local_time() const
+    {
+      return m_local_time;
+    }
+
+  protected:
+    //
+    // Calculate the next local quantum for this initiator.
+    //
+    // The method can be overloaded in a derived object if an initiator wants
+    // to use another local quantum. This derived object should also take the
+    // global quantum into account. It's local quantum should not be set to a
+    // value that is larger than the quantum returned by the
+    // compute_local_quantum of the tlm_global_quantum singleton.
+    //
+    virtual sc_core::sc_time compute_local_quantum()
+    {
+      return tlm::tlm_global_quantum::instance().compute_local_quantum();
+    }
+
+  protected:
+    sc_core::sc_time m_next_sync_point;
+    sc_core::sc_time m_local_time;
+  };
+
+} // namespace tlm
+
+#endif