soc_desc: new version of the desc file format

Fix qeditor to use the old soc_desc_v1.
Port hwstub_shell to the new description format.

Change-Id: I9fefbff534bfaa5c3603bb3dd8307a2b76e88cfc

22 files changed, 3959 insertions, 861 deletions

diff --git a/utils/hwstub/tools/Makefile b/utils/hwstub/tools/Makefile
index f718300623..868ddcca79 100644
--- a/utils/hwstub/tools/Makefile
+++ b/utils/hwstub/tools/Makefile
@@ -2,9 +2,10 @@ CC=gcc
 CXX=g++
 LD=g++
 HWSTUB_LIB_DIR=../lib
+REGTOOLS_INCLUDE_DIR=../../regtools/include
 REGTOOLS_LIB_DIR=../../regtools/lib
-CFLAGS=-Wall -O2 `pkg-config --cflags libusb-1.0` -std=c99 -g -I$(HWSTUB_LIB_DIR) -I$(REGTOOLS_LIB_DIR) `pkg-config --cflags lua5.2`
-CXXFLAGS=-Wall -O2 `pkg-config --cflags libusb-1.0` -g -I$(HWSTUB_LIB_DIR) -I$(REGTOOLS_LIB_DIR) `pkg-config --cflags lua5.2`
+CFLAGS=-Wall -O2 `pkg-config --cflags libusb-1.0` -std=c99 -g -I$(HWSTUB_LIB_DIR) -I$(REGTOOLS_INCLUDE_DIR) `pkg-config --cflags lua5.2`
+CXXFLAGS=-Wall -O2 `pkg-config --cflags libusb-1.0` -g -I$(HWSTUB_LIB_DIR) -I$(REGTOOLS_INCLUDE_DIR) `pkg-config --cflags lua5.2`
 LDFLAGS=`pkg-config --libs libusb-1.0`  `pkg-config --libs lua5.2` -lreadline -L$(HWSTUB_LIB_DIR) -L$(REGTOOLS_LIB_DIR) -lsocdesc -lhwstub `xml2-config --libs`
 EXEC=hwstub_shell hwstub_load
 SRC=$(wildcard *.c)
diff --git a/utils/hwstub/tools/hwstub_shell.cpp b/utils/hwstub/tools/hwstub_shell.cpp
index f59ca8b82a..dd5c20b471 100644
--- a/utils/hwstub/tools/hwstub_shell.cpp
+++ b/utils/hwstub/tools/hwstub_shell.cpp
@@ -28,11 +28,14 @@
 #include <readline/history.h>
 #include <lua.hpp>
 #include <unistd.h>
+#include "soc_desc_v1.hpp"
 #include "soc_desc.hpp"
 extern "C" {
 #include "prompt.h"
 }
 
+using namespace soc_desc_v1;
+
 #if LUA_VERSION_NUM < 502
 #warning You need at least lua 5.2
 #endif
@@ -51,6 +54,44 @@ struct hwstub_pp_desc_t g_hwdev_pp;
 lua_State *g_lua;
 
 /**
+ * debug
+ */
+
+void print_context(const std::string& file, const soc_desc::error_context_t& ctx)
+{
+    for(size_t j = 0; j < ctx.count(); j++)
+    {
+        soc_desc::error_t e = ctx.get(j);
+        switch(e.level())
+        {
+            case soc_desc::error_t::INFO: printf("[INFO]"); break;
+            case soc_desc::error_t::WARNING: printf("[WARN]"); break;
+            case soc_desc::error_t::FATAL: printf("[FATAL]"); break;
+            default: printf("[UNK]"); break;
+        }
+        if(e.location().size() != 0)
+            printf(" (%s) %s:", file.c_str(), e.location().c_str());
+        printf(" %s\n", e.message().c_str());
+    }
+}
+
+void my_lua_print_stack(lua_State *state = 0, int up_to = 0)
+{
+    if(state == 0)
+        state = g_lua;
+    up_to = lua_gettop(state) - up_to;
+    printf("stack:");
+    for(int i = -1; i >= -up_to; i--)
+    {
+        if(lua_isstring(state, i))
+            printf(" <%s>", lua_tostring(state, i));
+        else
+            printf(" [%s]", lua_typename(state, lua_type(state, i)));
+    }
+    printf("\n");
+}
+
+/**
  * hw specific
  */
 
@@ -449,7 +490,7 @@ int my_lua_write_field(lua_State *state)
     soc_addr_t addr = lua_tounsigned(state, lua_upvalueindex(1));
     soc_word_t shift = lua_tounsigned(state, lua_upvalueindex(2));
     soc_word_t mask = lua_tounsigned(state, lua_upvalueindex(3));
-    bool is_sct = lua_toboolean(state, lua_upvalueindex(5));
+    char op = lua_tounsigned(state, lua_upvalueindex(5));
 
     soc_word_t value = mask;
     if(n == 1)
@@ -469,10 +510,17 @@ int my_lua_write_field(lua_State *state)
         value &= mask;
     }
 
-    if(!is_sct)
-        value = value << shift | (hw_read32(state, addr) & ~(mask << shift));
+    soc_word_t old_value = hw_read32(state, addr);
+    if(op == 'w')
+        value = value << shift | (old_value & ~(mask << shift));
+    else if(op == 's')
+        value = old_value | value << shift;
+    else if(op == 'c')
+        value = old_value & ~(value << shift);
+    else if(op == 't')
+        value = old_value ^ (value << shift);
     else
-        value <<= shift;
+        luaL_error(state, "write_field() internal error");
 
     hw_write32(state, addr, value);
     return 0;
@@ -501,222 +549,240 @@ int my_lua_sct_reg(lua_State *state)
     return 0;
 }
 
-void my_lua_create_field(soc_addr_t addr, const soc_reg_field_t& field, bool sct)
+/* lua stack on entry/exit: <reg table> */
+void my_lua_create_field(soc_addr_t addr, soc_desc::field_ref_t field)
 {
+    soc_desc::field_t *f = field.get();
+    /** create field table */
     lua_newtable(g_lua);
+    /* lua stack: <field table> <reg table> */
 
-    lua_pushstring(g_lua, field.name.c_str());
+    /** create various characteristics */
+    lua_pushstring(g_lua, f->name.c_str());
+    /* lua stack: <name> <field table> ... */
     lua_setfield(g_lua, -2, "name");
+    /* lua stack: <field table> ... */
 
     lua_pushunsigned(g_lua, addr);
+    /* lua stack: <addr> <field table> ... */
     lua_setfield(g_lua, -2, "addr");
+    /* lua stack: <field table> ... */
 
-    lua_pushboolean(g_lua, sct);
-    lua_setfield(g_lua, -2, "sct");
-
-    lua_pushunsigned(g_lua, field.first_bit);
-    lua_setfield(g_lua, -2, "first_bit");
+    lua_pushunsigned(g_lua, f->pos);
+    /* lua stack: <pos> <field table> ... */
+    lua_setfield(g_lua, -2, "pos");
+    /* lua stack: <field table> ... */
 
-    lua_pushunsigned(g_lua, field.last_bit);
-    lua_setfield(g_lua, -2, "last_bit");
+    lua_pushunsigned(g_lua, f->width);
+    /* lua stack: <width> <field table> ... */
+    lua_setfield(g_lua, -2, "width");
+    /* lua stack: <field table> ... */
 
-    lua_pushunsigned(g_lua, field.bitmask());
+    lua_pushunsigned(g_lua, f->bitmask());
+    /* lua stack: <bm> <field table> ... */
     lua_setfield(g_lua, -2, "bitmask");
+    /* lua stack: <field table> ... */
 
-    soc_word_t local_bitmask = field.bitmask() >> field.first_bit;
+    soc_word_t local_bitmask = f->bitmask() >> f->pos;
     lua_pushunsigned(g_lua, local_bitmask);
+    /* lua stack: <local_bm> <field table> ... */
     lua_setfield(g_lua, -2, "local_bitmask");
+    /* lua stack: <field table> ... */
 
+    /** create read routine */
     lua_pushunsigned(g_lua, addr);
-    lua_pushunsigned(g_lua, field.first_bit);
+    lua_pushunsigned(g_lua, f->pos);
     lua_pushunsigned(g_lua, local_bitmask);
+    /* lua stack: <local_bm> <pos> <addr> <field table> ... */
     lua_pushcclosure(g_lua, my_lua_read_field, 3);
+    /* lua stack: <my_lua_read_field> <field table> ... */
     lua_setfield(g_lua, -2, "read");
+    /* lua stack: <field table> ... */
 
-    lua_pushunsigned(g_lua, addr);
-    lua_pushunsigned(g_lua, field.first_bit);
-    lua_pushunsigned(g_lua, local_bitmask);
-    lua_pushvalue(g_lua, -4);
-    lua_pushboolean(g_lua, false);
-    lua_pushcclosure(g_lua, my_lua_write_field, 5);
-    lua_setfield(g_lua, -2, "write");
-
-    if(sct)
+    /** create write/set/clr/tog routines */
+    static const char *name[] = {"write", "set", "clr", "tog"};
+    static const char arg[] = {'w', 's', 'c', 't'};
+    for(int i = 0; i < 4; i++)
     {
-        lua_pushunsigned(g_lua, addr + 4);
-        lua_pushunsigned(g_lua, field.first_bit);
+        lua_pushunsigned(g_lua, addr);
+        lua_pushunsigned(g_lua, f->pos);
         lua_pushunsigned(g_lua, local_bitmask);
+        /* lua stack: <local_bm> <pos> <addr> <field table> ... */
         lua_pushvalue(g_lua, -4);
-        lua_pushboolean(g_lua, true);
+        /* lua stack: <field table> <local_bm> <pos> <addr> <field table> ... */
+        lua_pushunsigned(g_lua, arg[i]);
+        /* lua stack: <'wsct'> <field table> <local_bm> <pos> <addr> <field table> ... */
         lua_pushcclosure(g_lua, my_lua_write_field, 5);
-        lua_setfield(g_lua, -2, "set");
-
-        lua_pushunsigned(g_lua, addr + 8);
-        lua_pushunsigned(g_lua, field.first_bit);
-        lua_pushunsigned(g_lua, local_bitmask);
-        lua_pushvalue(g_lua, -4);
-        lua_pushboolean(g_lua, true);
-        lua_pushcclosure(g_lua, my_lua_write_field, 5);
-        lua_setfield(g_lua, -2, "clr");
-
-        lua_pushunsigned(g_lua, addr + 12);
-        lua_pushunsigned(g_lua, field.first_bit);
-        lua_pushunsigned(g_lua, local_bitmask);
-        lua_pushvalue(g_lua, -4);
-        lua_pushboolean(g_lua, true);
-        lua_pushcclosure(g_lua, my_lua_write_field, 5);
-        lua_setfield(g_lua, -2, "tog");
+        /* lua stack: <my_lua_write_field> <field table> ... */
+        lua_setfield(g_lua, -2, name[i]);
+        /* lua stack: <field table> ... */
     }
 
-    for(size_t i = 0; i < field.value.size(); i++)
+    /** create values */
+    for(size_t i = 0; i < f->enum_.size(); i++)
     {
-        lua_pushunsigned(g_lua, field.value[i].value);
-        lua_setfield(g_lua, -2, field.value[i].name.c_str());
+        lua_pushunsigned(g_lua, f->enum_[i].value);
+        /* lua stack: <value> <field table> ... */
+        lua_setfield(g_lua, -2, f->enum_[i].name.c_str());
+        /* lua stack: <field table> ... */
     }
+
+    /** register field */
+    lua_setfield(g_lua, -2, f->name.c_str());
+    /* lua stack: <reg table> */
 }
 
-void my_lua_create_reg(soc_addr_t addr, size_t index, const soc_reg_t& reg)
+/* lua stack on entry/exit: <inst table> */
+void my_lua_create_reg(soc_addr_t addr, soc_desc::register_ref_t reg)
 {
-    lua_newtable(g_lua);
-
-    lua_pushstring(g_lua, reg.addr[index].name.c_str());
-    lua_setfield(g_lua, -2, "name");
-
-    lua_pushunsigned(g_lua, addr + reg.addr[index].addr);
-    lua_setfield(g_lua, -2, "addr");
-
-    lua_pushboolean(g_lua, !!(reg.flags & REG_HAS_SCT));
-    lua_setfield(g_lua, -2, "sct");
-
-    lua_pushunsigned(g_lua, addr + reg.addr[index].addr);
+    if(!reg.valid())
+        return;
+    /** create read/write routine */
+    lua_pushunsigned(g_lua, addr);
+    /* lua stack: <addr> <inst table> */
     lua_pushcclosure(g_lua, my_lua_read_reg, 1);
+    /* lua stack: <my_lua_read_reg> <inst table> */
     lua_setfield(g_lua, -2, "read");
+    /* lua stack: <inst table> */
 
-    lua_pushunsigned(g_lua, addr + reg.addr[index].addr);
+    lua_pushunsigned(g_lua, addr);
+    /* lua stack: <addr> <inst table> */
     lua_pushcclosure(g_lua, my_lua_write_reg, 1);
+    /* lua stack: <my_lua_read_reg> <inst table> */
     lua_setfield(g_lua, -2, "write");
+    /* lua stack: <inst table> */
 
-    if(reg.flags & REG_HAS_SCT)
+    /** create set/clr/tog helpers */
+    static const char *name[] = {"set", "clr", "tog"};
+    static const char arg[] = {'s', 'c', 't'};
+    for(int i = 0; i < 3; i++)
     {
-        lua_pushunsigned(g_lua, addr + reg.addr[index].addr + 4);
-        lua_pushcclosure(g_lua, my_lua_write_reg, 1);
-        lua_setfield(g_lua, -2, "set");
+        lua_pushunsigned(g_lua, addr);
+        /* lua stack: <addr> <inst table> */
+        lua_pushunsigned(g_lua, arg[i]);
+        /* lua stack: <'s'/'c'/'t'> <addr> <inst table> */
+        lua_pushcclosure(g_lua, my_lua_sct_reg, 2);
+        /* lua stack: <my_lua_sct_reg> <inst table> */
+        lua_setfield(g_lua, -2, name[i]);
+        /* lua stack: <inst table> */
+    }
 
-        lua_pushunsigned(g_lua, addr + reg.addr[index].addr + 8);
-        lua_pushcclosure(g_lua, my_lua_write_reg, 1);
-        lua_setfield(g_lua, -2, "clr");
+    /** create fields */
+    std::vector< soc_desc::field_ref_t > fields = reg.fields();
+    for(size_t i = 0; i < fields.size(); i++)
+        my_lua_create_field(addr, fields[i]);
+}
 
-        lua_pushunsigned(g_lua, addr + reg.addr[index].addr + 12);
-        lua_pushcclosure(g_lua, my_lua_write_reg, 1);
-        lua_setfield(g_lua, -2, "tog");
-    }
-    else
+/* lua stack on entry/exit: <parent table> */
+void my_lua_create_instances(const std::vector< soc_desc::node_inst_t >& inst)
+{
+    for(size_t i = 0; i < inst.size(); i++)
     {
-        lua_pushunsigned(g_lua, addr + reg.addr[index].addr);
-        lua_pushunsigned(g_lua, 's');
-        lua_pushcclosure(g_lua, my_lua_sct_reg, 2);
-        lua_setfield(g_lua, -2, "set");
+        /** if the instance is indexed, find the instance table, otherwise create it */
+        if(inst[i].is_indexed())
+        {
+            /** try to get the instance table, otherwise create it */
+            lua_getfield(g_lua, -1, inst[i].name().c_str());
+            /* lua stack: <index table> <parent table> */
+            if(lua_isnil(g_lua, -1))
+            {
+                lua_pop(g_lua, 1);
+                lua_newtable(g_lua);
+                /* lua stack: <index table> <parent table> */
+                lua_pushvalue(g_lua, -1);
+                /* lua stack: <index table> <index table> <parent table> */
+                lua_setfield(g_lua, -3, inst[i].name().c_str());
+                /* lua stack: <index table> <parent table> */
+            }
+            lua_pushinteger(g_lua, inst[i].index());
+            /* lua stack: <index> <index table> <parent table> */
+        }
 
-        lua_pushunsigned(g_lua, addr + reg.addr[index].addr);
-        lua_pushunsigned(g_lua, 'c');
-        lua_pushcclosure(g_lua, my_lua_sct_reg, 2);
-        lua_setfield(g_lua, -2, "clr");
+        /** create a new table for the instance */
+        lua_newtable(g_lua);
+        /* lua stack: <instance table> [<index> <index table>] <parent table> */
 
-        lua_pushunsigned(g_lua, addr + reg.addr[index].addr);
-        lua_pushunsigned(g_lua, 't');
-        lua_pushcclosure(g_lua, my_lua_sct_reg, 2);
-        lua_setfield(g_lua, -2, "tog");
-    }
+        /** create name and desc fields */
+        lua_pushstring(g_lua, inst[i].node().get()->name.c_str());
+        /* lua stack: <node name> <instance table> ... */
+        lua_setfield(g_lua, -2, "name");
+        /* lua stack: <instance table> ... */
 
-    for(size_t i = 0; i < reg.field.size(); i++)
-    {
-        my_lua_create_field(addr + reg.addr[index].addr, reg.field[i],
-            reg.flags & REG_HAS_SCT);
-        lua_setfield(g_lua, -2, reg.field[i].name.c_str());
-    }
-}
+        lua_pushstring(g_lua, inst[i].node().get()->desc.c_str());
+        /* lua stack: <node desc> <instance table> ... */
+        lua_setfield(g_lua, -2, "desc");
+        /* lua stack: <instance table> ... */
 
-void my_lua_create_dev(size_t index, const soc_dev_t& dev)
-{
-    lua_newtable(g_lua);
+        lua_pushstring(g_lua, inst[i].node().get()->title.c_str());
+        /* lua stack: <node title> <instance table> ... */
+        lua_setfield(g_lua, -2, "title");
+        /* lua stack: <instance table> ... */
 
-    lua_pushstring(g_lua, dev.addr[index].name.c_str());
-    lua_setfield(g_lua, -2, "name");
+        lua_pushunsigned(g_lua, inst[i].addr());
+        /* lua stack: <node addr> <instance table> ... */
+        lua_setfield(g_lua, -2, "addr");
+        /* lua stack: <instance table> ... */
 
-    lua_pushunsigned(g_lua, dev.addr[index].addr);
-    lua_setfield(g_lua, -2, "addr");
+        /** create register */
+        my_lua_create_reg(inst[i].addr(), inst[i].node().reg());
 
-    for(size_t i = 0; i < dev.reg.size(); i++)
-    {
-        bool table = dev.reg[i].addr.size() > 1;
-        if(table)
-            lua_newtable(g_lua);
-        else
-            lua_pushnil(g_lua);
+        /** create subinstances */
+        my_lua_create_instances(inst[i].children());
+        /* lua stack: <instance table> [<index> <index table>] <parent table> */
 
-        for(size_t k = 0; k < dev.reg[i].addr.size(); k++)
+        if(inst[i].is_indexed())
         {
-            my_lua_create_reg(dev.addr[index].addr, k, dev.reg[i]);
-            if(table)
-            {
-                lua_pushinteger(g_lua, k);
-                lua_pushvalue(g_lua, -2);
-                lua_settable(g_lua, -4);
-            }
-            lua_setfield(g_lua, -3, dev.reg[i].addr[k].name.c_str());
+            /* lua stack: <instance table> <index> <index table> <parent table> */
+            lua_settable(g_lua, -3);
+            /* lua stack: <index table> <parent table> */
+            lua_pop(g_lua, 1);
         }
-
-        if(table)
-            lua_setfield(g_lua, -2, dev.reg[i].name.c_str());
         else
-            lua_pop(g_lua, 1);
+        {
+            /* lua stack: <instance table> <parent table> */
+            lua_setfield(g_lua, -2, inst[i].name().c_str());
+        }
+        /* lua stack: <parent table> */
     }
 }
 
-bool my_lua_import_soc(const soc_t& soc)
+bool my_lua_import_soc(soc_desc::soc_t& soc)
 {
+    /** remember old stack index to check for unbalanced stack at the end */
     int oldtop = lua_gettop(g_lua);
 
+    /** find hwstub.soc table */
     lua_getglobal(g_lua, "hwstub");
+    /* lua stack: <hwstub table> */
     lua_getfield(g_lua, -1, "soc");
+    /* lua stack: <hwstub.soc table> <hwstub table> */
 
+    /** create a new table for the soc */
     lua_newtable(g_lua);
+    /* lua stack: <soc table> <hwstub.soc table> <hwstub table> */
 
+    /** create name and desc fields */
     lua_pushstring(g_lua, soc.name.c_str());
+    /* lua stack: <soc name> <soc table> <hwstub.soc table> <hwstub table> */
     lua_setfield(g_lua, -2, "name");
+    /* lua stack: <soc table> <hwstub.soc table> <hwstub table> */
 
     lua_pushstring(g_lua, soc.desc.c_str());
+    /* lua stack: <soc desc> <soc table> <hwstub.soc table> <hwstub table> */
     lua_setfield(g_lua, -2, "desc");
+    /* lua stack: <soc table> <hwstub.soc table> <hwstub table> */
 
-    for(size_t i = 0; i < soc.dev.size(); i++)
-    {
-        bool table = soc.dev[i].addr.size() > 1;
-        if(table)
-            lua_newtable(g_lua);
-        else
-            lua_pushnil(g_lua);
-
-        for(size_t k = 0; k < soc.dev[i].addr.size(); k++)
-        {
-            my_lua_create_dev(k, soc.dev[i]);
-            if(table)
-            {
-                lua_pushinteger(g_lua, k + 1);
-                lua_pushvalue(g_lua, -2);
-                lua_settable(g_lua, -4);
-            }
-            lua_setfield(g_lua, -3, soc.dev[i].addr[k].name.c_str());
-        }
-
-        if(table)
-            lua_setfield(g_lua, -2, soc.dev[i].name.c_str());
-        else
-            lua_pop(g_lua, 1);
-    }
+    /** create instances */
+    soc_desc::soc_ref_t rsoc(&soc);
+    my_lua_create_instances(rsoc.root_inst().children());
+    /* lua stack: <soc table> <hwstub.soc table> <hwstub table> */
 
+    /** put soc table at hwstub.soc.<soc name> */
     lua_setfield(g_lua, -2, soc.name.c_str());
+    /* lua stack: <hwstub.soc table> <hwstub table> */
 
     lua_pop(g_lua, 2);
+    /* lua stack: <> */
 
     if(lua_gettop(g_lua) != oldtop)
     {
@@ -726,7 +792,7 @@ bool my_lua_import_soc(const soc_t& soc)
     return true;
 }
 
-bool my_lua_import_soc(const std::vector< soc_t >& socs)
+bool my_lua_import_soc(std::vector< soc_desc::soc_t >& socs)
 {
     for(size_t i = 0; i < socs.size(); i++)
     {
@@ -803,15 +869,17 @@ int main(int argc, char **argv)
     }
 
     // load register descriptions
-    std::vector< soc_t > socs;
+    std::vector< soc_desc::soc_t > socs;
     for(int i = optind; i < argc; i++)
     {
-        socs.push_back(soc_t());
-        if(!soc_desc_parse_xml(argv[i], socs[socs.size() - 1]))
+        socs.push_back(soc_desc::soc_t());
+        soc_desc::error_context_t ctx;
+        if(!soc_desc::parse_xml(argv[i], socs[socs.size() - 1], ctx))
         {
-            printf("Cannot load description '%s'\n", argv[i]);
-            return 2;
+            printf("Cannot load description file '%s'\n", argv[i]);
+            socs.pop_back();
         }
+        print_context(argv[i], ctx);
     }
 
     // create usb context
diff --git a/utils/regtools/Makefile b/utils/regtools/Makefile
index 5e3feafd01..fed5d8c8e5 100644
--- a/utils/regtools/Makefile
+++ b/utils/regtools/Makefile
@@ -2,8 +2,9 @@ DEFINES=
 CC?=gcc
 CXX?=g++
 LD?=g++
-CFLAGS=-g -std=c99 -Wall $(DEFINES) -Ilib
-CXXFLAGS=-g -Wall $(DEFINES) -Ilib
+INCLUDE=-Iinclude/
+CFLAGS=-g -std=c99 -Wall $(DEFINES) $(INCLUDE)
+CXXFLAGS=-g -Wall $(DEFINES) $(INCLUDE)
 LDFLAGS=-Llib -lsocdesc `xml2-config --libs`
 SRC=$(wildcard *.c)
 SRCXX=$(wildcard *.cpp)
diff --git a/utils/regtools/desc/regs-example-v1.xml b/utils/regtools/desc/regs-example-v1.xml
new file mode 100644
index 0000000000..4f3cf81ff2
--- /dev/null
+++ b/utils/regtools/desc/regs-example-v1.xml
@@ -0,0 +1,91 @@
+<?xml version="1.0"?>
+<soc name="imx233" desc="i.MX233">
+  <dev name="APBH" long_name="APHB DMA" desc="AHB-to-APBH Bridge with DMA" version="3.2.0">
+    <addr name="APBH" addr="0x80004000"/>
+    <reg name="CTRL0" desc="" sct="yes">
+      <addr name="CTRL0" addr="0x0"/>
+      <field name="SFTRST" desc="" bitrange="31:31"/>
+      <field name="CLKGATE" desc="" bitrange="30:30"/>
+      <field name="AHB_BURST8_EN" desc="" bitrange="29:29"/>
+      <field name="APB_BURST4_EN" desc="" bitrange="28:28"/>
+      <field name="RSVD0" desc="" bitrange="27:24"/>
+      <field name="RESET_CHANNEL" desc="" bitrange="23:16">
+        <value name="SSP1" value="0x2" desc=""/>
+        <value name="SSP2" value="0x4" desc=""/>
+        <value name="ATA" value="0x10" desc=""/>
+        <value name="NAND0" value="0x10" desc=""/>
+        <value name="NAND1" value="0x20" desc=""/>
+        <value name="NAND2" value="0x40" desc=""/>
+        <value name="NAND3" value="0x80" desc=""/>
+      </field>
+      <field name="CLKGATE_CHANNEL" desc="" bitrange="15:8">
+        <value name="SSP1" value="0x2" desc=""/>
+        <value name="SSP2" value="0x4" desc=""/>
+        <value name="ATA" value="0x10" desc=""/>
+        <value name="NAND0" value="0x10" desc=""/>
+        <value name="NAND1" value="0x20" desc=""/>
+        <value name="NAND2" value="0x40" desc=""/>
+        <value name="NAND3" value="0x80" desc=""/>
+      </field>
+      <field name="FREEZE_CHANNEL" desc="" bitrange="7:0">
+        <value name="SSP1" value="0x2" desc=""/>
+        <value name="SSP2" value="0x4" desc=""/>
+        <value name="ATA" value="0x10" desc=""/>
+        <value name="NAND0" value="0x10" desc=""/>
+        <value name="NAND1" value="0x20" desc=""/>
+        <value name="NAND2" value="0x40" desc=""/>
+        <value name="NAND3" value="0x80" desc=""/>
+      </field>
+    </reg>
+    <reg name="CTRL1" desc="" sct="yes">
+      <addr name="CTRL1" addr="0x10"/>
+      <field name="RSVD1" desc="" bitrange="31:24"/>
+      <field name="CH_CMDCMPLT_IRQ_EN" desc="" bitrange="23:16"/>
+      <field name="RSVD0" desc="" bitrange="15:8"/>
+      <field name="CH_CMDCMPLT_IRQ" desc="" bitrange="7:0"/>
+    </reg>
+    <reg name="CHn_CMD" desc="">
+      <formula string="0x60+n*0x70"/>
+      <addr name="CH0_CMD" addr="0x60"/>
+      <addr name="CH1_CMD" addr="0xd0"/>
+      <addr name="CH2_CMD" addr="0x140"/>
+      <addr name="CH3_CMD" addr="0x1b0"/>
+      <addr name="CH4_CMD" addr="0x220"/>
+      <addr name="CH5_CMD" addr="0x290"/>
+      <addr name="CH6_CMD" addr="0x300"/>
+      <addr name="CH7_CMD" addr="0x370"/>
+      <field name="XFER_COUNT" desc="" bitrange="31:16"/>
+      <field name="CMDWORDS" desc="" bitrange="15:12"/>
+      <field name="RSVD1" desc="" bitrange="11:9"/>
+      <field name="HALTONTERMINATE" desc="" bitrange="8:8"/>
+      <field name="WAIT4ENDCMD" desc="" bitrange="7:7"/>
+      <field name="SEMAPHORE" desc="" bitrange="6:6"/>
+      <field name="NANDWAIT4READY" desc="" bitrange="5:5"/>
+      <field name="NANDLOCK" desc="" bitrange="4:4"/>
+      <field name="IRQONCMPLT" desc="" bitrange="3:3"/>
+      <field name="CHAIN" desc="" bitrange="2:2"/>
+      <field name="COMMAND" desc="" bitrange="1:0">
+        <value name="NO_DMA_XFER" value="0x0" desc=""/>
+        <value name="DMA_WRITE" value="0x1" desc=""/>
+        <value name="DMA_READ" value="0x2" desc=""/>
+        <value name="DMA_SENSE" value="0x3" desc=""/>
+      </field>
+    </reg>
+  </dev>
+  <dev name="SAIF" long_name="Sync Audio Interface" desc="Sync Audio Interface (SAIF)" version="3.2.0">
+    <addr name="SAIF1" addr="0x80042000"/>
+    <addr name="SAIF2" addr="0x80046000"/>
+    <reg name="DATA" desc="" sct="yes">
+      <addr name="DATA" addr="0x20"/>
+      <field name="PCM_RIGHT" desc="" bitrange="31:16"/>
+      <field name="PCM_LEFT" desc="" bitrange="15:0"/>
+    </reg>
+    <reg name="VERSION" desc="">
+      <addr name="VERSION" addr="0x30"/>
+      <field name="MAJOR" desc="" bitrange="31:24"/>
+      <field name="MINOR" desc="" bitrange="23:16"/>
+      <field name="STEP" desc="" bitrange="15:0"/>
+    </reg>
+  </dev>
+</soc>
+ 
diff --git a/utils/regtools/desc/regs-example.xml b/utils/regtools/desc/regs-example.xml
new file mode 100644
index 0000000000..6fb8f759fe
--- /dev/null
+++ b/utils/regtools/desc/regs-example.xml
@@ -0,0 +1,153 @@
+<?xml version="1.0"?>
+<soc version="2">
+    <name>vsoc</name>
+    <title>Virtual SOC</title>
+    <desc>Virtual SoC is a nice and powerful chip.</desc>
+    <author>Amaury Pouly</author>
+    <isa>ARM</isa>
+    <version>0.5</version>
+    <node>
+        <name>int</name>
+        <title>Interrupt Collector</title>
+        <desc>The interrupt collector controls the routing of interrupt to the processor</desc>
+        <instance>
+            <name>ICOLL</name>
+            <title>Interrupt collector</title>
+            <address>0x80000000</address>
+        </instance>
+        <node>
+            <name>status</name>
+            <access>read-only</access>
+            <title>Interrupt status register</title>
+            <instance>
+                <name>STATUS</name>
+                <address>0x4</address>
+            </instance>
+            <register>
+                <width>8</width>
+                <field>
+                    <name>VDDIO_BO</name>
+                    <desc>VDDIO brownout interrupt status</desc>
+                    <position>0</position>
+                </field>
+            </register>
+        </node>
+        <node>
+            <name>enable</name>
+            <title>Interrupt enable register</title>
+            <instance>
+                <name>ENABLE</name>
+                <address>0x8</address>
+            </instance>
+            <register>
+                <width>16</width>
+                <field>
+                    <name>VDDIO_BO</name>
+                    <desc>VDDIO brownout interrupt enable</desc>
+                    <position>0</position>
+                    <width>2</width>
+                    <enum>
+                        <name>DISABLED</name>
+                        <desc>Interrupt is disabled</desc>
+                        <value>0</value>
+                    </enum>
+                    <enum>
+                        <name>ENABLED</name>
+                        <desc>Interrupt is enabled</desc>
+                        <value>1</value>
+                    </enum>
+                    <enum>
+                        <name>NMI</name>
+                        <desc>Interrupt is non-maskable</desc>
+                        <value>2</value>
+                    </enum>
+                </field>
+            </register>
+            <variant>
+                <type>set</type>
+                <offset>4</offset>
+            </variant>
+            <variant>
+                <type>clr</type>
+                <offset>8</offset>
+            </variant>
+        </node>
+    </node>
+    <node>
+        <name>gpio</name>
+        <title>GPIO controller</title>
+        <desc>A GPIO controller manages several ports</desc>
+        <instance>
+            <name>CPU_GPIO</name>
+            <title>CPU GPIO controller 1 through 3</title>
+            <range>
+                <first>1</first>
+                <count>3</count>
+                <formula variable="n">0x80001000+(n-1)*0x1000</formula>
+            </range>
+        </instance>
+        <instance>
+            <name>COP_GPIO</name>
+            <title>Companion processor GPIO controller</title>
+            <desc>Although the companion processor GPIO controller is accessible from the CPU, it incurs an extra penalty on the bus</desc>
+            <address>0x90000000</address>
+        </instance>
+        <node>
+            <name>port</name>
+            <title>GPIO port</title>
+            <instance>
+                <name>PORT</name>
+                <range>
+                    <first>0</first>
+                    <count>4</count>
+                    <base>0</base>
+                    <stride>0x100</stride>
+                </range>
+            </instance>
+            <node>
+                <name>input</name>
+                <title>Input register</title>
+                <instance>
+                    <name>IN</name>
+                    <address>0</address>
+                </instance>
+                <register>
+                    <width>8</width>
+                    <field>
+                        <name>VALUE</name>
+                        <position>0</position>
+                        <width>8</width>
+                    </field>
+                </register>
+            </node>
+            <node>
+                <name>output_enable</name>
+                <title>Output enable register</title>
+                <instance>
+                    <name>OE</name>
+                    <address>0x10</address>
+                </instance>
+                <register>
+                    <width>8</width>
+                    <field>
+                        <name>ENABLE</name>
+                        <position>0</position>
+                        <width>8</width>
+                    </field>
+                </register>
+                <variant>
+                    <type>set</type>
+                    <address>4</address>
+                </variant>
+                <variant>
+                    <type>clr</type>
+                    <address>8</address>
+                </variant>
+                <variant>
+                    <type>mask</type>
+                    <address>12</address>
+                </variant>
+            </node>
+        </node>
+    </node>
+</soc>
\ No newline at end of file
diff --git a/utils/regtools/desc/XML.txt b/utils/regtools/desc/spec-1.0.txt
index 3c28154a1f..3c28154a1f 100644
--- a/utils/regtools/desc/XML.txt
+++ b/utils/regtools/desc/spec-1.0.txt
diff --git a/utils/regtools/desc/spec-2.0.txt b/utils/regtools/desc/spec-2.0.txt
new file mode 100644
index 0000000000..79b9f6be44
--- /dev/null
+++ b/utils/regtools/desc/spec-2.0.txt
@@ -0,0 +1,373 @@
+This file describes the format of the register map based on XML, version 2.0.
+
+1) Overview
+-----------
+
+1.1) Nodes and instances
+------------------------
+
+This specification is based on the concept of "nodes". Nodes are containers
+which can contain other nodes and/or a register. Each node can have one or more
+addresses (addresses are always relative to the parent node). The idea is that
+this hierarchy of nodes generates a number of addresses recursively. The example
+below outlines this idea:
+
+<node>
+  <name>N</name>
+  <instance>
+    <name>A</name>
+    <address>X</address>
+  </instance>
+  <instance>
+    <name>B</name>
+    <address>Y</address>
+  </instance>
+  <!-- HERE -->
+</node>
+
+This example creates one node named N and two instances named A and B,
+at respective addresses X and Y. This means that all subnodes of this node will
+have two copies: one relative to X, which path will be prefixed by "A", and
+one relative to Y, which path will be prefixed by "B".
+This example below explores this idea in details:
+
+  <!-- HERE -->
+  <node>
+    <name>S_N</name>
+    <instance>
+      <name>C</name>
+      <address>U</address>
+    </instance>
+    <instance>
+      <name>D</name>
+      <address>V</address>
+    </instance>
+  </node>
+
+In this example, N generates two copies of the sub-node S_N.
+The sub-node S_N generates two instances C and D. The whole hierarchy thus generates
+four instances:
+- A.C at X+U
+- A.D at X+V
+- B.C at Y+U
+- B.D at Y+V
+
+As a note for later, notice that there really are two hierarchies in parallel:
+- the node hierarchy: it is composed of N and N.S_N
+- the instance hierarchy: it is made up of A, B, A.C, A.D, B.C and B.D
+
+1.2) Ranges
+-----------
+
+To make things more useful, in particular in case of multiple copies of a register,
+we introduce the concept of range addresses with an example:
+
+<node>
+  <name>N</name>
+  <instance>
+    <name>A</name>
+    <range>
+      <first>1</first>
+      <count>5</count>
+      <base>0x1000</base>
+      <stride>0x100</stride>
+    </range>
+  </instance>
+  <node>
+    <name>NN</name>
+    <instance>
+      <name>E</name>
+      <address>0x4</address>
+    </instance>
+  </node>
+</node>
+
+A range describes a contiguous set of adresses, indexed by a number. One can
+specify the first number in the range, and the number of copies. In the case
+of a regular pattern (base + n * stride), we can specify a stride
+to compute the address of the next copy. In this example, the top-level
+nodes generates five copies which path is A[1], A[2], ..., A[5]
+and which addresses are 0x1000+1*0x100, 0x1000+2*0x100, ..., 0x1000+5*0x100.
+If we add the sub-node to the picture, for each copy we create a instance E
+we offset 0x4 from the parent. Overall this generates 5 instances:
+- A[1].E at 0x1000+1*0x100+0x4 = 0x1104
+- A[2].E at 0x1000+2*0x100+0x4 = 0x1204
+- A[3].E at 0x1000+3*0x100+0x4 = 0x1304
+- A[4].E at 0x1000+4*0x100+0x4 = 0x1404
+- A[5].E at 0x1000+5*0x100+0x4 = 0x1504
+Note that the intermediate path also define instances, so there are 5 additional
+instances in reality:
+- A[1] at 0x1100
+- A[2] at 0x1200
+- A[3] at 0x1300
+- A[4] at 0x1400
+- A[5] at 0x1500
+
+For the record, there is a more general way of specifying a range when it does
+not follow a nice regular pattern. One can specify a formula where the parameter
+is the index. There are no restrictions on the formula except that it must use
+usual arithmetic operators. The example below illustrate such a use:
+
+<node>
+  <name>N</name>
+  <instance>
+    <name>F</name>
+    <range>
+      <first>0</first>
+      <count>4</count>
+      <formula variable="n">0x50+(n/2)*0x100+(n%2)*0x10</formula>
+    </range>
+  </instance>
+</node>
+
+In this example we generate four nodes F[0], ..., F[3] with a formula. Here "/"
+is the euclidian division and "%" is the modulo operator. Note the use of an
+attribute to specify which variable represents the index. The generated addresses
+are:
+- F[0] at 0x50+(0/2)*0x100+(0%2)*0x10 = 0x50
+- F[1] at 0x50+(1/2)*0x100+(1%2)*0x10 = 0x50+0x10 = 0x60
+- F[2] at 0x50+(2/2)*0x100+(2%2)*0x10 = 0x50+0x100 = 0x150
+- F[3] at 0x50+(3/2)*0x100+(3%2)*0x10 = 0x50+0x100+0x10 = 0x160
+
+1.3) Node description
+---------------------
+
+For documentation purposes, node can of course carry some description, as well
+as instances. More precisely, nodes can have a title, that is a short description
+very much like a chapter title, and a description, this is a free form and potentially
+lengthy description of the node. Instances too can have a title and a description.
+The following example illustrates this:
+
+<node>
+  <name>icoll</name>
+  <title>DMA Controller</title>
+  <desc>The DMA controller provides uniform DMA facilities to transfer data from
+        and to peripherals. It uses memory-mapped tables and support chained
+        transfers.</desc>
+  <instance>
+    <name>AHB_DMAC</name>
+    <address>0x80000000</address>
+    <title>AHB DMA Controller</title>
+    <desc>The AHB DMA controller provides DMA facilities for the peripherals
+          on the AHB bus like the SSP and PIX engines.</desc>
+  </instance>
+  <instance>
+    <name>APB_DMAC</name>
+    <address>0x8001000</address>
+    <title>APB DMA Controller</title>
+    <desc>The APB DMA controller provides DMA facilities for the peripherals
+          on the APB bus like the I2C and PCM engines.</desc>
+  </instance>
+</node>
+
+1.4) Register description
+--------------------------
+
+The goal of the register description is of course to describe registers!
+To see how registers relate to the node hierarchy, see 1.5, this section focuses
+only the description only.
+
+A register carries a lot of information, which is organise logically. A register
+can have a width, in bits. By default registers are assumed to be 32-bit wide.
+The most useful feature of register description is to describe the fields of
+the registers. Each field has a name, a start position and a width. Fields
+can also carry a description. Finally, each field can specify enumerated values,
+that is named values, for convenience. Enumerated values have a name, a value
+and an optional description. The example below illustrates all these concepts:
+
+<register>
+  <width>8</width>
+  <field>
+    <name>MODE</name>
+    <desc>Interrupt mode</desc>
+    <position>0</position>
+    <width>2</width>
+    <enum>
+      <name>DISABLED</name>
+      <desc>Interrupt is disabled</desc>
+      <value>0</value>
+    </enum>
+    <enum>
+      <name>ENABLED</name>
+      <desc>Interrupt is enabled</desc>
+      <value>1</value>
+    </enum>
+    <enum>
+      <name>NMI</name>
+      <desc>Interrupt is non-maskable</desc>
+      <value>2</value>
+    </enum>
+  </field>
+  <field>
+    <name>PRIORITY</name>
+    <desc>Interrupt priority, lower values are more prioritized.</desc>
+    <position>2</position>
+    <width>2</width>
+  </field>
+  <field>
+    <name>ARM_MODE</name>
+    <desc>Select between ARM's FIQ and IRQ mode</desc>
+    <position>4</position>
+    <width>1</width>
+    <enum>
+      <name>IRQ</name>
+      <value>0</value>
+    </enum>
+    <enum>
+      <name>FIQ</name>
+      <value>1</value>
+    </enum>
+  </field>
+</register>
+
+In this example, the 8-bit registers has three fields:
+- MODE(1:0): it has three named values DISABLED(0), ENABLED(1) and NMI(2)
+- PRIORITY(2:1): it has no named values
+- ARM_MODE(3): it has two named values IRQ(0) and FIQ(1)
+
+1.5) Register inheritance
+-------------------------
+
+The node hierarchy specifies instances, that is pairs of (path,address),
+and the register description describes the internal of a register. The placement
+of the register descriptions in the node hierarchy will specify which registers
+can be found at each address. More precisely, if a node contains a register
+description, it means that this node's and all sub-nodes' instances are registers
+following the description. It is forbidden for a node to contain a register
+description if one of its parents already contains one. The example below
+will make this concept clearer (for readability, we omitted some of the tags):
+
+<node>
+  <name>dma</name>
+  <instance><name>DMAC</name><address>0x80000000</address></instance>
+  <node>
+    <instance><name>PCM_CHAN</name><address>0x0</address></instance>
+    <instance><name>I2C_CHAN</name><address>0x10</address></instance>
+    <register><!--- blabla --></register>
+    <node>
+      <name>sct</name>
+      <instance><name>SET</name><address>0x4</address></instance>
+      <instance><name>CLR</name><address>0x8</address></instance>
+      <instance><name>TOG</name><address>0xC</address></instance>
+    </node>
+  </node>
+</node>
+
+This example describes one register (let's call it blabla) and 9 instances:
+- DMAC at 0x80000000, no register
+- DMAC.PCM_CHAN at 0x80000000, register blabla
+- DMAC.PCM_CHAN.SET at 0x80000004, register blabla
+- DMAC.PCM_CHAN.CLR at 0x80000008, register blabla
+- DMAC.PCM_CHAN.TOG at 0x8000000C, register blabla
+- DMAC.I2C_CHAN at 0x80000010, register blabla
+- DMAC.I2C_CHAN.SET at 0x80000014, register blabla
+- DMAC.I2C_CHAN.CLR at 0x80000018, register blabla
+- DMAC.I2C_CHAN.TOG at 0x8000001C, register blabla
+
+1.6) Soc description
+--------------------
+
+The description file must also specify some information about the system-on-chip
+itself. The entire description, including nodes, is contained in a "soc" tag
+which must at least specify the soc name. It can optionally specify the title
+and description, as well as the author(s) of the description, the ISA and
+the version.
+
+<soc>
+  <name>vsoc</name>
+  <title>Virtual SOC</title>
+  <desc>Virtual SoC is a nice and powerful chip.</desc>
+  <author>Amaury Pouly</author>
+  <isa>ARM</isa>
+  <version>0.5</version>
+  <!-- put nodes below -->
+</soc>
+
+2) Specification
+----------------
+
+Root
+----
+As any XML document, the content of the file should be enclosed in a "xml" tag.
+The root element must be "soc" tag.
+
+Example:
+<?xml version="1.0"?>
+<!-- desc -->
+</xml>
+
+Element: soc
+------------
+It must contain the following tags:
+- name: name of soc, only made of alphanumerical characters
+It can contain at most one of each of the following tags:
+- title: one line description of the soc
+- desc: free form description of the soc
+- isa: instruction set assembly
+- version: version of the description
+It can contain any number of the following tags:
+- author: author of the description
+- node: node description
+
+Element: node
+-------------
+It must contain the following tags:
+- name: name of node, only made of alphanumerical characters
+It can contain at most one of each of the following tags:
+- title: one line description of the node
+- desc: free form description of the node
+- register: register description
+It can contain any number of the following tags:
+- instance: author of the description
+- node: node description
+
+Element: instance
+-----------------
+It must contain the following tags:
+- name: name of instance, only made of alphanumerical characters
+It can contain at most one of each of the following tags:
+- title: one line description of the instance
+- desc: free form description of the instance
+- address: address for a single instance (non-negative number)
+- range: address range for multiple instances
+Note that address and range are mutually exclusive, and at least one of them
+must exists.
+
+Element: range
+--------------
+It must contain the following tags:
+- first: index of the first instance (non-negative number)
+- count: number of instances (positive number)
+It can contain at most one of each of the following tags:
+- base: base address (non-negative number)
+- stride: stride (number)
+- formula: free-form formula, must have a "variable" attribute
+Note that stride and formula are mutually exclusive, and at least one of them
+must exists. If stride is specified and base is omitted, it is taken to be 0.
+
+Element: register
+-----------------
+It can contain at most one of each of the following tags:
+- width: width in bits (positive number)
+It can contain any number of the following tags:
+- field: field description
+
+Element: field
+--------------
+It must contain the following tags:
+- name: name of field, only made of alphanumerical characters
+- position: least significant bit
+It can contain at most one of each of the following tags:
+- desc: free form description of the instance
+- width: width in bits
+It can contain any number of the following tags:
+- enum: enumerated value
+If the width is not specified, it is assumed to be 1.
+
+Element: enum
+-------------
+It must contain the following tags:
+- name: name of field, only made of alphanumerical characters
+- value: value (non-negative, must fit into the field's width)
+It can contain at most one of each of the following tags:
+- desc: free form description of the instance
\ No newline at end of file
diff --git a/utils/regtools/headergen.cpp b/utils/regtools/headergen_v1.cpp
index 046e8b2fd8..7b38366d5d 100644
--- a/utils/regtools/headergen.cpp
+++ b/utils/regtools/headergen_v1.cpp
@@ -18,7 +18,7 @@
  * KIND, either express or implied.
  *
  ****************************************************************************/ 
-#include "soc_desc.hpp"
+#include "soc_desc_v1.hpp"
 #include <stdio.h>
 #include <stdlib.h>
 #include <algorithm>
@@ -28,6 +28,8 @@
 #include <sys/types.h>
 #include <getopt.h>
 
+using namespace soc_desc_v1;
+
 #define HEADERGEN_VERSION   "2.1.8"
 
 #define error(...) do{ fprintf(stderr, __VA_ARGS__); exit(1); } while(0)
@@ -721,7 +723,7 @@ int main(int argc, char **argv)
     for(int i = optind; i < argc - 1; i++)
     {
         soc_t s;
-        if(!soc_desc_parse_xml(argv[i], s))
+        if(!parse_xml(argv[i], s))
         {
             printf("Cannot parse %s\n", argv[i]);
             return 1;
diff --git a/utils/regtools/include/soc_desc.hpp b/utils/regtools/include/soc_desc.hpp
new file mode 100644
index 0000000000..66f2e3b6e1
--- /dev/null
+++ b/utils/regtools/include/soc_desc.hpp
@@ -0,0 +1,384 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id$
+ *
+ * Copyright (C) 2014 by Amaury Pouly
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/  
+#ifndef __SOC_DESC__
+#define __SOC_DESC__
+
+#include <stdint.h>
+#include <vector>
+#include <list>
+#include <string>
+#include <map>
+
+namespace soc_desc
+{
+
+const size_t MAJOR_VERSION = 2;
+const size_t MINOR_VERSION = 0;
+const size_t REVISION_VERSION = 0;
+
+/** Typedef for SoC types: word, address and flags */
+typedef uint32_t soc_addr_t;
+typedef uint32_t soc_word_t;
+typedef int soc_id_t;
+
+/** Error class */
+class error_t
+{
+public:
+    enum level_t
+    {
+        INFO,
+        WARNING,
+        FATAL
+    };
+    error_t(level_t lvl, const std::string& loc, const std::string& msg)
+        :m_level(lvl), m_loc(loc), m_msg(msg) {}
+    level_t level() const { return m_level; }
+    std::string location() const { return m_loc; }
+    std::string message() const { return m_msg; }
+protected:
+    level_t m_level;
+    std::string m_loc, m_msg;
+};
+
+/** Error context to log errors */
+class error_context_t
+{
+public:
+    void add(const error_t& err) { m_list.push_back(err); }
+    size_t count() const { return m_list.size(); }
+    error_t get(size_t i) const { return m_list[i]; }
+protected:
+    std::vector< error_t > m_list;
+};
+
+/**
+ * Bare representation of the format
+ */
+
+/** Enumerated value (aka named value), represents a special value for a field */
+struct enum_t
+{
+    soc_id_t id; /** ID (must be unique among field enums) */
+    std::string name; /** Name (must be unique among field enums) */
+    std::string desc; /** Optional description of the meaning of this value */
+    soc_word_t value; /** Value of the field */
+};
+
+/** Register field information */
+struct field_t
+{
+    soc_id_t id; /** ID (must be unique among register fields) */
+    std::string name; /** Name (must be unique among register fields) */
+    std::string desc; /** Optional description of the field */
+    size_t pos; /** Position of the least significant bit */
+    size_t width; /** Width of the field in bits  */
+    std::vector< enum_t > enum_; /** List of special values */
+
+    /** Returns the bit mask of the field within the register */
+    soc_word_t bitmask() const
+    {
+        // WARNING beware of the case where width is 32
+        if(width == 32)
+            return 0xffffffff;
+        else
+            return ((1 << width) - 1) << pos;
+    }
+
+    /** Extract field value from register value */
+    soc_word_t extract(soc_word_t reg_val) const
+    {
+        return (reg_val & bitmask()) >> pos;
+    }
+
+    /** Replace the field value in a register value */
+    soc_word_t replace(soc_word_t reg_val, soc_word_t field_val) const
+    {
+        return (reg_val & ~bitmask()) | ((field_val << pos) & bitmask());
+    }
+
+    /** Return field value index, or -1 if none */
+    int find_value(soc_word_t v) const
+    {
+        for(size_t i = 0; i < enum_.size(); i++)
+            if(enum_[i].value == v)
+                return i;
+        return -1;
+    }
+};
+
+/** Register information */
+struct register_t
+{
+    size_t width; /** Size in bits */
+    std::vector< field_t > field; /** List of fields */
+};
+
+/** Node address range information */
+struct range_t
+{
+    enum type_t
+    {
+        STRIDE, /** Addresses are given by a base address and a stride */
+        FORMULA /** Addresses are given by a formula */
+    };
+
+    type_t type; /** Range type */
+    size_t first; /** First index in the range */
+    size_t count; /** Number of indexes in the range */
+    soc_word_t base; /** Base address (for STRIDE) */
+    soc_word_t stride; /** Stride value (for STRIDE) */
+    std::string formula; /** Formula (for FORMULA) */
+    std::string variable; /** Formula variable name (for FORMULA) */
+};
+
+/** Node instance information */
+struct instance_t
+{
+    enum type_t
+    {
+        SINGLE, /** There is a single instance at a specified address */
+        RANGE /** There are multiple addresses forming a range */
+    };
+
+    soc_id_t id; /** ID (must be unique among node instances) */
+    std::string name; /** Name (must be unique among node instances) */
+    std::string title; /** Optional instance human name */
+    std::string desc; /** Optional description of the instance */
+    type_t type; /** Instance type */
+    soc_word_t addr; /** Address (for SINGLE) */
+    range_t range; /** Range (for RANGE) */
+};
+
+/** Node information */
+struct node_t
+{
+    soc_id_t id; /** ID (must be unique among nodes) */
+    std::string name; /** Name (must be unique for the among nodes) */
+    std::string title; /** Optional node human name */
+    std::string desc; /** Optional description of the node */
+    std::vector< register_t> register_; /** Optional register */
+    std::vector< instance_t> instance; /** List of instances */
+    std::vector< node_t > node; /** List of sub-nodes */
+};
+
+/** System-on-chip information */
+struct soc_t
+{
+    std::string name; /** Codename of the SoC */
+    std::string title; /** Human name of the SoC */
+    std::string desc; /** Optional description of the SoC */
+    std::string isa; /** Instruction Set Assembly */
+    std::string version; /** Description version */
+    std::vector< std::string > author; /** List of authors of the description */
+    std::vector< node_t > node; /** List of nodes */
+};
+
+/** Parse a SoC description from a XML file, put it into <soc>. */
+bool parse_xml(const std::string& filename, soc_t& soc, error_context_t& error_ctx);
+/** Write a SoC description to a XML file, overwriting it. A file can contain
+ * multiple Soc descriptions */
+bool produce_xml(const std::string& filename, const soc_t& soc, error_context_t& error_ctx);
+/** Formula parser: try to parse and evaluate a formula with some variables */
+bool evaluate_formula(const std::string& formula,
+    const std::map< std::string, soc_word_t>& var, soc_word_t& result,
+    const std::string& loc, error_context_t& error_ctx);
+
+/**
+ * Convenience API to manipulate the format
+ *
+ * The idea is that *_ref_t objects are stable pointers: they stay valid even
+ * when the underlying soc changes. In particular:
+ * - modifying any structure data (except id fields) preserves all references
+ * - removing a structure invalidates all references pointing to this structure
+ *   and its children
+ * - adding any structure preserves all references
+ * These references can be used to get pointers to the actual data
+ * of the representation when it needs to be read or write.
+ */
+
+class soc_ref_t;
+class node_ref_t;
+class register_ref_t;
+class field_ref_t;
+class node_inst_t;
+
+/** SoC reference */
+class soc_ref_t
+{
+    soc_t *m_soc; /* pointer to the soc */
+public:
+     /** Builds an invalid reference */
+    soc_ref_t();
+     /** Builds a reference to a soc */
+    soc_ref_t(soc_t *soc);
+    /** Checks whether this reference is valid */
+    bool valid() const;
+    /** Returns a pointer to the soc */
+    soc_t *get() const;
+    /** Returns a reference to the root node */
+    node_ref_t root() const;
+    /** Returns a reference to the root node instance */
+    node_inst_t root_inst() const;
+    /** Compare this reference to another */
+    bool operator==(const soc_ref_t& r) const;
+    inline bool operator!=(const soc_ref_t& r) const { return !operator==(r); }
+};
+
+/** SoC node reference
+ * NOTE: the root soc node is presented as a node with empty path */
+class node_ref_t
+{
+    friend class soc_ref_t;
+    friend class node_inst_t;
+    soc_ref_t m_soc; /* reference to the soc */
+    std::vector< soc_id_t > m_path; /* path from the root */
+
+    node_ref_t(soc_ref_t soc);
+    node_ref_t(soc_ref_t soc, const std::vector< soc_id_t >& path);
+public:
+    /** Builds an invalid reference */
+    node_ref_t();
+    /** Check whether this reference is valid */
+    bool valid() const;
+    /** Check whether this reference is the root node */
+    bool is_root() const;
+    /** Returns a pointer to the node, or 0 if invalid or root */
+    node_t *get() const;
+    /** Returns a reference to the soc */
+    soc_ref_t soc() const;
+    /** Returns a reference to the parent node */
+    node_ref_t parent() const;
+    /** Returns a reference to the register (which may be on a parent node) */
+    register_ref_t reg() const;
+    /** Returns a list of references to the sub-nodes */
+    std::vector< node_ref_t > children() const;
+    /** Returns a reference to a specific child */
+    node_ref_t child(const std::string& name) const;
+    /** Returns the path of the node, as the list of node names from the root */
+    std::vector< std::string > path() const;
+    /** Returns the name of the node */
+    std::string name() const;
+    /** Compare this reference to another */
+    bool operator==(const node_ref_t& r) const;
+    inline bool operator!=(const node_ref_t& r) const { return !operator==(r); }
+};
+
+/** SoC register reference */
+class register_ref_t
+{
+    friend class node_ref_t;
+    node_ref_t m_node; /* reference to the node owning the register */
+
+    register_ref_t(node_ref_t node);
+public:
+    /** Builds an invalid reference */
+    register_ref_t();
+    /** Check whether this reference is valid/exists */
+    bool valid() const;
+    /** Returns a pointer to the register, or 0 */
+    register_t *get() const;
+    /** Returns a reference to the node containing the register */
+    node_ref_t node() const;
+    /** Returns a list of references to the fields of the register */
+    std::vector< field_ref_t > fields() const;
+    /** Returns a reference to a particular field */
+    field_ref_t field(const std::string& name) const;
+    /** Compare this reference to another */
+    bool operator==(const register_ref_t& r) const;
+    inline bool operator!=(const register_ref_t& r) const { return !operator==(r); }
+};
+
+/** SoC register field reference */
+class field_ref_t
+{
+    friend class register_ref_t;
+    register_ref_t m_reg; /* reference to the register */
+    soc_id_t m_id; /* field name */
+
+    field_ref_t(register_ref_t reg, soc_id_t id);
+public:
+    /** Builds an invalid reference */
+    field_ref_t();
+    /** Check whether this reference is valid/exists */
+    bool valid() const;
+    /** Returns a pointer to the field, or 0 */
+    field_t *get() const;
+    /** Returns a reference to the register containing the field */
+    register_ref_t reg() const;
+    /** Compare this reference to another */
+    bool operator==(const field_ref_t& r) const;
+    inline bool operator!=(const field_ref_t& r) const { return !operator==(r); }
+};
+
+/** SoC node instance
+ * NOTE: the root soc node is presented as a node with a single instance at 0 */
+class node_inst_t
+{
+    friend class node_ref_t;
+    friend class soc_ref_t;
+    node_ref_t m_node; /* reference to the node */
+    std::vector< soc_id_t > m_id_path; /* list of instance IDs */
+    std::vector< size_t > m_index_path; /* list of instance indexes */
+
+    node_inst_t(soc_ref_t soc);
+    node_inst_t(node_ref_t soc, const std::vector< soc_id_t >& path,
+        const std::vector< size_t >& indexes);
+public:
+    /** Builds an invalid reference */
+    node_inst_t();
+    /** Check whether this instance is valid/exists */
+    bool valid() const;
+    /** Returns a reference to the soc */
+    soc_ref_t soc() const;
+    /** Returns a reference to the node */
+    node_ref_t node() const;
+    /** Check whether this reference is the root node instance */
+    bool is_root() const;
+    /** Returns a reference to the parent instance */
+    node_inst_t parent() const;
+     /** Returns a pointer to the instance of the node, or 0 */
+    instance_t *get() const;
+    /** Returns the address of this instance */
+    soc_addr_t addr() const;
+    /** Returns an instance to a child of this node's instance. If the subnode
+     * instance is a range, the returned reference is invalid */
+    node_inst_t child(const std::string& name) const;
+    /** Returns an instance to a child of this node's instance with a range index.
+     * If the subnode is not not a range or if the index is out of bounds,
+     * the returned reference is invalid */
+    node_inst_t child(const std::string& name, size_t index) const;
+    /** Returns a list of all instances of subnodes of this node's instance */
+    std::vector< node_inst_t > children() const;
+    /** Returns the name of the instance */
+    std::string name() const;
+    /** Checks whether this instance is indexed */
+    bool is_indexed() const;
+    /** Returns the index of the instance */
+    size_t index() const;
+    /** Compare this reference to another */
+    bool operator==(const node_inst_t& r) const;
+    inline bool operator!=(const node_inst_t& r) const { return !operator==(r); }
+};
+
+} // soc_desc
+
+#endif /* __SOC_DESC__ */
diff --git a/utils/regtools/lib/soc_desc.hpp b/utils/regtools/include/soc_desc_v1.hpp
index bb8eb4ba8d..33368e88d4 100644
--- a/utils/regtools/lib/soc_desc.hpp
+++ b/utils/regtools/include/soc_desc_v1.hpp
@@ -18,8 +18,8 @@
  * KIND, either express or implied.
  *
  ****************************************************************************/  
-#ifndef __SOC_DESC__
-#define __SOC_DESC__
+#ifndef __SOC_DESC_V1__
+#define __SOC_DESC_V1__
 
 #include <stdint.h>
 #include <vector>
@@ -45,13 +45,12 @@
  * ignores the position of the WORD_LENGTH field in the register.
  */
 
-#define SOCDESC_VERSION_MAJOR   1
-#define SOCDESC_VERSION_MINOR   4
-#define SOCDESC_VERSION_REV     1
+namespace soc_desc_v1
+{
 
-#define SOCDESC_VERSION__(maj,min,rev) #maj"."#min"."#rev
-#define SOCDESC_VERSION_(maj,min,rev) SOCDESC_VERSION__(maj,min,rev)
-#define SOCDESC_VERSION SOCDESC_VERSION_(SOCDESC_VERSION_MAJOR,SOCDESC_VERSION_MINOR,SOCDESC_VERSION_REV)
+const size_t MAJOR_VERSION = 1;
+const size_t MINOR_VERSION = 4;
+const size_t REVISION_VERSION = 1;
 
 /**
  * Typedef for SoC types: word, address and flags */
@@ -211,18 +210,21 @@ struct soc_t
 };
 
 /** Parse a SoC description from a XML file, append it to <soc>. */
-bool soc_desc_parse_xml(const std::string& filename, soc_t& soc);
+bool parse_xml(const std::string& filename, soc_t& soc);
 /** Write a SoC description to a XML file, overwriting it. A file can contain
  * multiple Soc descriptions */
-bool soc_desc_produce_xml(const std::string& filename, const soc_t& soc);
+bool produce_xml(const std::string& filename, const soc_t& soc);
 /** Normalise a soc description by reordering elemnts so that:
  * - devices are sorted by first name
  * - registers are sorted by first address
  * - fields are sorted by last bit
  * - values are sorted by value */
-void soc_desc_normalize(soc_t& soc);
-/** Formula parser: try to parse and evaluate a formula to a specific value of 'n' */
-bool soc_desc_evaluate_formula(const std::string& formula,
-    const std::map< std::string, soc_word_t>& var, soc_word_t& result, std::string& error);
+void normalize(soc_t& soc);
+/** Formula parser: try to parse and evaluate a formula with some variables */
+bool evaluate_formula(const std::string& formula,
+    const std::map< std::string, soc_word_t>& var, soc_word_t& result,
+    std::string& error);
+
+} // soc_desc_v1
 
-#endif /* __SOC_DESC__ */
\ No newline at end of file
+#endif /* __SOC_DESC_V1__ */
\ No newline at end of file
diff --git a/utils/regtools/lib/Makefile b/utils/regtools/lib/Makefile
index 08021ef941..d7d6c1b07a 100644
--- a/utils/regtools/lib/Makefile
+++ b/utils/regtools/lib/Makefile
@@ -1,18 +1,15 @@
 CC?=gcc
 CXX?=g++
 AR?=ar
-CFLAGS=-Wall -O2 `xml2-config --cflags` -std=c99 -g -fPIC
-CXXFLAGS=-Wall -O2 `xml2-config --cflags` -g -fPIC
+INCLUDE=../include/
+CXXFLAGS=-Wall -O2 `xml2-config --cflags` -g -fPIC -I$(INCLUDE)
 LIB=libsocdesc.a
 SRC=$(wildcard *.c)
 SRCXX=$(wildcard *.cpp)
-OBJ=$(SRC:.c=.o) $(SRCXX:.cpp=.o)
+OBJ=$(SRCXX:.cpp=.o)
 
 all: $(LIB) $(EXEC)
 
-%.o: %.c
-        $(CC) $(CFLAGS) -c -o $@ $<
-
 %.o: %.cpp
         $(CXX) $(CXXFLAGS) -c -o $@ $<
 
diff --git a/utils/regtools/lib/formula.cpp b/utils/regtools/lib/formula.cpp
new file mode 100644
index 0000000000..1a6b16c773
--- /dev/null
+++ b/utils/regtools/lib/formula.cpp
@@ -0,0 +1,214 @@
+#include "soc_desc.hpp"
+#include <cstdarg>
+#include <cstdio>
+
+using namespace soc_desc;
+
+namespace soc_desc
+{
+
+namespace
+{
+
+struct formula_evaluator
+{
+    std::string formula;
+    size_t pos;
+    error_context_t& ctx;
+    std::string m_loc;
+
+    bool err(const char *fmt, ...)
+    {
+        char buffer[256];
+        va_list args;
+        va_start(args, fmt);
+        vsnprintf(buffer,sizeof(buffer), fmt, args);
+        va_end(args);
+        ctx.add(error_t(error_t::FATAL, m_loc, buffer));
+        return false;
+    }
+
+    formula_evaluator(const std::string& s, error_context_t& ctx):pos(0),ctx(ctx)
+    {
+        for(size_t i = 0; i < s.size(); i++)
+            if(!isspace(s[i]))
+                formula.push_back(s[i]);
+    }
+
+    void set_location(const std::string& loc)
+    {
+        m_loc = loc;
+    }
+
+    void adv()
+    {
+        pos++;
+    }
+
+    char cur()
+    {
+        return end() ? 0 : formula[pos];
+    }
+
+    bool end()
+    {
+        return pos >= formula.size();
+    }
+
+    bool parse_digit(char c, int basis, soc_word_t& res)
+    {
+        c = tolower(c);
+        if(isdigit(c))
+        {
+            res = c - '0';
+            return true;
+        }
+        if(basis == 16 && isxdigit(c))
+        {
+            res = c + 10 - 'a';
+            return true;
+        }
+        return false;
+    }
+
+    bool parse_signed(soc_word_t& res)
+    {
+        char op = cur();
+        if(op == '+' || op == '-')
+        {
+            adv();
+            if(!parse_signed(res))
+                return false;
+            if(op == '-')
+                res *= -1;
+            return true;
+        }
+        else if(op == '(')
+        {
+            adv();
+            if(!parse_expression(res))
+                return false;
+            if(cur() != ')')
+                return err("expected ')', got '%c'", cur());
+            adv();
+            return true;
+        }
+        else if(isdigit(op))
+        {
+            res = op - '0';
+            adv();
+            int basis = 10;
+            if(op == '0' && cur() == 'x')
+            {
+                basis = 16;
+                adv();
+            }
+            soc_word_t digit = 0;
+            while(parse_digit(cur(), basis, digit))
+            {
+                res = res * basis + digit;
+                adv();
+            }
+            return true;
+        }
+        else if(isalpha(op) || op == '_')
+        {
+            std::string name;
+            while(isalnum(cur()) || cur() == '_')
+            {
+                name.push_back(cur());
+                adv();
+            }
+            return get_variable(name, res);
+        }
+        else
+            return err("express signed expression, got '%c'", op);
+    }
+
+    bool parse_term(soc_word_t& res)
+    {
+        if(!parse_signed(res))
+            return false;
+        while(cur() == '*' || cur() == '/' || cur() == '%')
+        {
+            char op = cur();
+            adv();
+            soc_word_t tmp;
+            if(!parse_signed(tmp))
+                return false;
+            if(op == '*')
+                res *= tmp;
+            else if(tmp != 0)
+                res = op == '/' ? res / tmp : res % tmp;
+            else
+                return err("division by 0");
+        }
+        return true;
+    }
+
+    bool parse_expression(soc_word_t& res)
+    {
+        if(!parse_term(res))
+            return false;
+        while(!end() && (cur() == '+' || cur() == '-'))
+        {
+            char op = cur();
+            adv();
+            soc_word_t tmp;
+            if(!parse_term(tmp))
+                return false;
+            if(op == '+')
+                res += tmp;
+            else
+                res -= tmp;
+        }
+        return true;
+    }
+
+    bool parse(soc_word_t& res)
+    {
+        bool ok = parse_expression(res);
+        if(ok && !end())
+            err("unexpected character '%c'", cur());
+        return ok && end();
+    }
+
+    virtual bool get_variable(std::string name, soc_word_t& res)
+    {
+        return err("unknown variable '%s'", name.c_str());
+    }
+};
+
+struct my_evaluator : public formula_evaluator
+{
+    const std::map< std::string, soc_word_t>& var;
+
+    my_evaluator(const std::string& formula, const std::map< std::string, soc_word_t>& _var,
+        error_context_t& ctx)
+        :formula_evaluator(formula, ctx), var(_var) {}
+
+    virtual bool get_variable(std::string name, soc_word_t& res)
+    {
+        std::map< std::string, soc_word_t>::const_iterator it = var.find(name);
+        if(it == var.end())
+            return formula_evaluator::get_variable(name, res);
+        else
+        {
+            res = it->second;
+            return true;
+        }
+    }
+};
+
+}
+
+bool evaluate_formula(const std::string& formula,
+    const std::map< std::string, soc_word_t>& var, soc_word_t& result,
+    const std::string& loc, error_context_t& error)
+{
+    my_evaluator e(formula, var, error);
+    e.set_location(loc);
+    return e.parse(result);
+}
+
+} // soc_desc
diff --git a/utils/regtools/lib/soc_desc.cpp b/utils/regtools/lib/soc_desc.cpp
index 90e4e0eb81..4e0e46f00e 100644
--- a/utils/regtools/lib/soc_desc.cpp
+++ b/utils/regtools/lib/soc_desc.cpp
@@ -7,7 +7,7 @@
  *                     \/            \/     \/    \/            \/
  * $Id$
  *
- * Copyright (C) 2012 by Amaury Pouly
+ * Copyright (C) 2014 by Amaury Pouly
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -27,261 +27,429 @@
 #include <string.h>
 #include <algorithm>
 #include <cctype>
+#include <sstream>
+#include <limits>
+
+namespace soc_desc
+{
+
+/**
+ * Parser
+ */
 
 #define XML_CHAR_TO_CHAR(s) ((const char *)(s))
 
 #define BEGIN_ATTR_MATCH(attr) \
     for(xmlAttr *a = attr; a; a = a->next) {
 
-#define MATCH_X_ATTR(attr_name, hook, ...) \
+#define MATCH_UNIQUE_ATTR(attr_name, val, has, parse_fn, ctx) \
     if(strcmp(XML_CHAR_TO_CHAR(a->name), attr_name) == 0) { \
-        std::string s; \
-        if(!parse_text_attr(a, s) || !hook(s, __VA_ARGS__)) \
-            return false; \
+        if(has) \
+            return parse_not_unique_attr_error(a, ctx); \
+        has = true; \
+        xmlChar *str = NULL; \
+        if(!parse_text_attr_internal(a, str, ctx) || !parse_fn(a, val, str, ctx)) \
+            ret = false; \
     }
 
-#define SOFT_MATCH_X_ATTR(attr_name, hook, ...) \
-    if(strcmp(XML_CHAR_TO_CHAR(a->name), attr_name) == 0) { \
-        std::string s; \
-        if(parse_text_attr(a, s)) \
-            hook(s, __VA_ARGS__); \
-    }
-
-#define SOFT_MATCH_SCT_ATTR(attr_name, var) \
-    SOFT_MATCH_X_ATTR(attr_name, validate_sct_hook, var)
-
-#define MATCH_TEXT_ATTR(attr_name, var) \
-    MATCH_X_ATTR(attr_name, validate_string_hook, var)
-
-#define MATCH_UINT32_ATTR(attr_name, var) \
-    MATCH_X_ATTR(attr_name, validate_uint32_hook, var)
-
-#define MATCH_BITRANGE_ATTR(attr_name, first, last) \
-    MATCH_X_ATTR(attr_name, validate_bitrange_hook, first, last)
-
 #define END_ATTR_MATCH() \
     }
 
 #define BEGIN_NODE_MATCH(node) \
     for(xmlNode *sub = node; sub; sub = sub->next) {
 
-#define MATCH_ELEM_NODE(node_name, array, parse_fn) \
+#define MATCH_ELEM_NODE(node_name, array, parse_fn, ctx) \
     if(sub->type == XML_ELEMENT_NODE && strcmp(XML_CHAR_TO_CHAR(sub->name), node_name) == 0) { \
         array.resize(array.size() + 1); \
-        if(!parse_fn(sub, array.back())) \
-            return false; \
+        if(!parse_fn(sub, array.back(), ctx)) \
+            ret = false; \
+        array.back().id = array.size(); \
     }
 
-#define SOFT_MATCH_ELEM_NODE(node_name, array, parse_fn) \
+#define MATCH_TEXT_NODE(node_name, array, parse_fn, ctx) \
     if(sub->type == XML_ELEMENT_NODE && strcmp(XML_CHAR_TO_CHAR(sub->name), node_name) == 0) { \
+        if(!is_real_text_node(sub)) \
+            return parse_not_text_error(sub, ctx); \
+        xmlChar *content = xmlNodeGetContent(sub); \
         array.resize(array.size() + 1); \
-        if(!parse_fn(sub, array.back())) \
-            array.pop_back(); \
+        ret = ret &&  parse_fn(sub, array.back(), content, ctx); \
+        xmlFree(content); \
+    }
+
+#define MATCH_UNIQUE_ELEM_NODE(node_name, val, has, parse_fn, ctx) \
+    if(sub->type == XML_ELEMENT_NODE && strcmp(XML_CHAR_TO_CHAR(sub->name), node_name) == 0) { \
+        if(has) \
+            return parse_not_unique_error(sub, ctx); \
+        has = true; \
+        if(!parse_fn(sub, val, ctx)) \
+            ret = false; \
+    }
+
+#define MATCH_UNIQUE_TEXT_NODE(node_name, val, has, parse_fn, ctx) \
+    if(sub->type == XML_ELEMENT_NODE && strcmp(XML_CHAR_TO_CHAR(sub->name), node_name) == 0) { \
+        if(has) \
+            return parse_not_unique_error(sub, ctx); \
+        if(!is_real_text_node(sub)) \
+            return parse_not_text_error(sub, ctx); \
+        has = true; \
+        xmlChar *content = xmlNodeGetContent(sub); \
+        ret = ret && parse_fn(sub, val, content, ctx); \
+        xmlFree(content); \
     }
 
 #define END_NODE_MATCH() \
     }
 
+#define CHECK_HAS(node, node_name, has, ctx) \
+    if(!has) \
+        ret = ret && parse_missing_error(node, node_name, ctx);
+
+#define CHECK_HAS_ATTR(node, attr_name, has, ctx) \
+    if(!has) \
+        ret = ret && parse_missing_attr_error(node, attr_name, ctx);
+
 namespace
 {
 
-bool validate_string_hook(const std::string& str, std::string& s)
+bool is_real_text_node(xmlNode *node)
 {
-    s = str;
+    for(xmlNode *sub = node->children; sub; sub = sub->next)
+        if(sub->type != XML_TEXT_NODE && sub->type != XML_ENTITY_REF_NODE)
+            return false;
     return true;
 }
 
-bool validate_sct_hook(const std::string& str, soc_reg_flags_t& flags)
+std::string xml_loc(xmlNode *node)
 {
-    if(str == "yes") flags |= REG_HAS_SCT;
-    else if(str != "no") return false;
-    return true;
+    std::ostringstream oss;
+    oss << "line " << node->line;
+    return oss.str();
 }
 
-bool validate_unsigned_long_hook(const std::string& str, unsigned long& s)
+std::string xml_loc(xmlAttr *attr)
 {
-    char *end;
-    s = strtoul(str.c_str(), &end, 0);
-    return *end == 0;
+    return xml_loc(attr->parent);
 }
 
-bool validate_uint32_hook(const std::string& str, uint32_t& s)
+template<typename T>
+bool add_error(error_context_t& ctx, error_t::level_t lvl, T *node,
+    const std::string& msg)
 {
-    unsigned long u;
-    if(!validate_unsigned_long_hook(str, u)) return false;
-#if ULONG_MAX > 0xffffffff
-    if(u > 0xffffffff) return false;
-#endif
-    s = u;
-    return true;
+    ctx.add(error_t(lvl, xml_loc(node), msg));
+    return false;
 }
 
-bool validate_bitrange_hook(const std::string& str, unsigned& first, unsigned& last)
+template<typename T>
+bool add_fatal(error_context_t& ctx, T *node, const std::string& msg)
 {
-    unsigned long a, b;
-    size_t sep = str.find(':');
-    if(sep == std::string::npos) return false;
-    if(!validate_unsigned_long_hook(str.substr(0, sep), a)) return false;
-    if(!validate_unsigned_long_hook(str.substr(sep + 1), b)) return false;
-    if(a > 31 || b > 31 || a < b) return false;
-    first = b;
-    last = a;
-    return true;
+    return add_error(ctx, error_t::FATAL, node, msg);
 }
 
-bool parse_text_attr(xmlAttr *attr, std::string& s)
+template<typename T>
+bool add_warning(error_context_t& ctx, T *node, const std::string& msg)
 {
-    if(attr->children != attr->last)
-        return false;
-    if(attr->children->type != XML_TEXT_NODE)
-        return false;
-    s = XML_CHAR_TO_CHAR(attr->children->content);
-    return true;
+    return add_error(ctx, error_t::WARNING, node, msg);
 }
 
-bool parse_value_elem(xmlNode *node, soc_reg_field_value_t& value)
+bool parse_wrong_version_error(xmlNode *node, error_context_t& ctx)
 {
-    BEGIN_ATTR_MATCH(node->properties)
-        MATCH_TEXT_ATTR("name", value.name)
-        MATCH_UINT32_ATTR("value", value.value)
-        MATCH_TEXT_ATTR("desc", value.desc)
-    END_ATTR_MATCH()
+    std::ostringstream oss;
+    oss << "unknown version, only version " << MAJOR_VERSION << " is supported";
+    return add_fatal(ctx, node, oss.str());
+}
 
-    return true;
+bool parse_not_unique_error(xmlNode *node, error_context_t& ctx)
+{
+    std::ostringstream oss;
+    oss << "there must be a unique <" << XML_CHAR_TO_CHAR(node->name) << "> element";
+    if(node->parent->name)
+        oss << " in <" << XML_CHAR_TO_CHAR(node->parent->name) << ">";
+    else
+        oss << " at root level";
+    return add_fatal(ctx, node, oss.str());
 }
 
-bool parse_field_elem(xmlNode *node, soc_reg_field_t& field)
+bool parse_not_unique_attr_error(xmlAttr *attr, error_context_t& ctx)
 {
-    BEGIN_ATTR_MATCH(node->properties)
-        MATCH_TEXT_ATTR("name", field.name)
-        MATCH_BITRANGE_ATTR("bitrange", field.first_bit, field.last_bit)
-        MATCH_TEXT_ATTR("desc", field.desc)
-    END_ATTR_MATCH()
+    std::ostringstream oss;
+    oss << "there must be a unique " << XML_CHAR_TO_CHAR(attr->name) << " attribute";
+    oss << " in <" << XML_CHAR_TO_CHAR(attr->parent->name) << ">";
+    return add_fatal(ctx, attr, oss.str());
+}
 
-    BEGIN_NODE_MATCH(node->children)
-        SOFT_MATCH_ELEM_NODE("value", field.value, parse_value_elem)
-    END_NODE_MATCH()
+bool parse_missing_error(xmlNode *node, const char *name, error_context_t& ctx)
+{
+    std::ostringstream oss;
+    oss << "missing <" << name << "> element";
+    if(node->parent->name)
+        oss << " in <" << XML_CHAR_TO_CHAR(node->parent->name) << ">";
+    else
+        oss << " at root level";
+    return add_fatal(ctx, node, oss.str());
+}
 
-    return true;
+bool parse_missing_attr_error(xmlNode *node, const char *name, error_context_t& ctx)
+{
+    std::ostringstream oss;
+    oss << "missing " << name << " attribute";
+    oss << " in <" << XML_CHAR_TO_CHAR(node->name) << ">";
+    return add_fatal(ctx, node, oss.str());
 }
 
-bool parse_reg_addr_elem(xmlNode *node, soc_reg_addr_t& addr)
+bool parse_conflict_error(xmlNode *node, const char *name1, const char *name2,
+    error_context_t& ctx)
 {
-    BEGIN_ATTR_MATCH(node->properties)
-        MATCH_TEXT_ATTR("name", addr.name)
-        MATCH_UINT32_ATTR("addr", addr.addr)
-    END_ATTR_MATCH()
+    std::ostringstream oss;
+    oss << "conflicting <" << name1 << "> and <" << name2 << "> elements";
+    if(node->parent->name)
+        oss << " in <" << XML_CHAR_TO_CHAR(node->parent->name) << ">";
+    else
+        oss << " at root level";
+    return add_fatal(ctx, node, oss.str());
+}
 
-    return true;
+bool parse_not_text_error(xmlNode *node, error_context_t& ctx)
+{
+    return add_fatal(ctx, node, "this is not a text element");
 }
 
-bool parse_reg_formula_elem(xmlNode *node, soc_reg_formula_t& formula)
+bool parse_not_text_attr_error(xmlAttr *attr, error_context_t& ctx)
 {
-    BEGIN_ATTR_MATCH(node->properties)
-        MATCH_TEXT_ATTR("string", formula.string)
-    END_ATTR_MATCH()
+    return add_fatal(ctx, attr, "this is not a text attribute");
+}
 
-    formula.type = REG_FORMULA_STRING;
+bool parse_text_elem(xmlNode *node, std::string& name, xmlChar *content, error_context_t& ctx)
+{
+    name = XML_CHAR_TO_CHAR(content);
+    return true;
+}
 
+bool parse_name_elem(xmlNode *node, std::string& name, xmlChar *content, error_context_t& ctx)
+{
+    name = XML_CHAR_TO_CHAR(content);
+    if(name.size() == 0)
+        return add_fatal(ctx, node, "name cannot be empty");
+    for(size_t i = 0; i < name.size(); i++)
+        if(!isalnum(name[i]) && name[i] != '_')
+            return add_fatal(ctx, node, "name must only contain alphanumeric characters or _");
     return true;
 }
 
-bool parse_add_trivial_addr(const std::string& str, soc_reg_t& reg)
+template<typename T, typename U>
+bool parse_unsigned_text(U *node, T& res, xmlChar *content, error_context_t& ctx)
 {
-    soc_reg_addr_t a;
-    a.name = reg.name;
-    if(!validate_uint32_hook(str, a.addr))
-        return false;
-    reg.addr.push_back(a);
+    char *end;
+    unsigned long uns = strtoul(XML_CHAR_TO_CHAR(content), &end, 0);
+    if(*end != 0)
+        return add_fatal(ctx, node, "content must be an unsigned integer");
+    res = uns;
+    if(res != uns)
+        return add_fatal(ctx, node, "value does not fit into allowed range");
     return true;
 }
 
-bool parse_reg_elem(xmlNode *node, soc_reg_t& reg)
+template<typename T>
+bool parse_unsigned_elem(xmlNode *node, T& res, xmlChar *content, error_context_t& ctx)
 {
-    std::list< soc_reg_formula_t > formulas;
-    BEGIN_ATTR_MATCH(node->properties)
-        MATCH_TEXT_ATTR("name", reg.name)
-        SOFT_MATCH_SCT_ATTR("sct", reg.flags)
-        SOFT_MATCH_X_ATTR("addr", parse_add_trivial_addr, reg)
-        MATCH_TEXT_ATTR("desc", reg.desc)
-    END_ATTR_MATCH()
+    return parse_unsigned_text(node, res, content, ctx);
+}
 
-    BEGIN_NODE_MATCH(node->children)
-        MATCH_ELEM_NODE("addr", reg.addr, parse_reg_addr_elem)
-        MATCH_ELEM_NODE("formula", formulas, parse_reg_formula_elem)
-        MATCH_ELEM_NODE("field", reg.field, parse_field_elem)
-    END_NODE_MATCH()
+template<typename T>
+bool parse_unsigned_attr(xmlAttr *attr, T& res, xmlChar *content, error_context_t& ctx)
+{
+    return parse_unsigned_text(attr, res, content, ctx);
+}
 
-    if(formulas.size() > 1)
-    {
-        fprintf(stderr, "Only one formula is allowed per register\n");
+bool parse_text_attr_internal(xmlAttr *attr, xmlChar*& res, error_context_t& ctx)
+{
+    if(attr->children != attr->last)
         return false;
-    }
-    if(formulas.size() == 1)
-        reg.formula = formulas.front();
-
+    if(attr->children->type != XML_TEXT_NODE)
+        return parse_not_text_attr_error(attr, ctx);
+    res = attr->children->content;
     return true;
 }
 
-bool parse_dev_addr_elem(xmlNode *node, soc_dev_addr_t& addr)
+bool parse_text_attr(xmlAttr *attr, std::string& res, xmlChar *content, error_context_t& ctx)
 {
-    BEGIN_ATTR_MATCH(node->properties)
-        MATCH_TEXT_ATTR("name", addr.name)
-        MATCH_UINT32_ATTR("addr", addr.addr)
-    END_ATTR_MATCH()
-
+    res = XML_CHAR_TO_CHAR(content);
     return true;
 }
 
-bool parse_dev_elem(xmlNode *node, soc_dev_t& dev)
+bool parse_enum_elem(xmlNode *node, enum_t& reg, error_context_t& ctx)
 {
-    BEGIN_ATTR_MATCH(node->properties)
-        MATCH_TEXT_ATTR("name", dev.name)
-        MATCH_TEXT_ATTR("long_name", dev.long_name)
-        MATCH_TEXT_ATTR("desc", dev.desc)
-        MATCH_TEXT_ATTR("version", dev.version)
-    END_ATTR_MATCH()
+    bool ret = true;
+    bool has_name = false, has_value = false, has_desc = false;
+    BEGIN_NODE_MATCH(node->children)
+        MATCH_UNIQUE_TEXT_NODE("name", reg.name, has_name, parse_name_elem, ctx)
+        MATCH_UNIQUE_TEXT_NODE("value", reg.value, has_value, parse_unsigned_elem, ctx)
+        MATCH_UNIQUE_TEXT_NODE("desc", reg.desc, has_desc, parse_text_elem, ctx)
+    END_NODE_MATCH()
+    CHECK_HAS(node, "name", has_name, ctx)
+    CHECK_HAS(node, "value", has_value, ctx)
+    return ret;
+}
 
+bool parse_field_elem(xmlNode *node, field_t& field, error_context_t& ctx)
+{
+    bool ret = true;
+    bool has_name = false, has_pos = false, has_desc = false, has_width = false;
     BEGIN_NODE_MATCH(node->children)
-        MATCH_ELEM_NODE("addr", dev.addr, parse_dev_addr_elem)
-        MATCH_ELEM_NODE("reg", dev.reg, parse_reg_elem)
+        MATCH_UNIQUE_TEXT_NODE("name", field.name, has_name, parse_name_elem, ctx)
+        MATCH_UNIQUE_TEXT_NODE("position", field.pos, has_pos, parse_unsigned_elem, ctx)
+        MATCH_UNIQUE_TEXT_NODE("width", field.width, has_width, parse_unsigned_elem, ctx)
+        MATCH_UNIQUE_TEXT_NODE("desc", field.desc, has_desc, parse_text_elem, ctx)
+        MATCH_ELEM_NODE("enum", field.enum_, parse_enum_elem, ctx)
     END_NODE_MATCH()
+    CHECK_HAS(node, "name", has_name, ctx)
+    CHECK_HAS(node, "position", has_pos, ctx)
+    if(!has_width)
+        field.width = 1;
+    return ret;
+}
 
-    return true;
+bool parse_register_elem(xmlNode *node, register_t& reg, error_context_t& ctx)
+{
+    bool ret = true;
+    bool has_width = false;
+    BEGIN_NODE_MATCH(node->children)
+        MATCH_UNIQUE_TEXT_NODE("width", reg.width, has_width, parse_unsigned_elem, ctx)
+        MATCH_ELEM_NODE("field", reg.field, parse_field_elem, ctx)
+    END_NODE_MATCH()
+    if(!has_width)
+        reg.width = 32;
+    return ret;
 }
 
-bool parse_soc_elem(xmlNode *node, soc_t& soc)
+bool parse_formula_elem(xmlNode *node, range_t& range, error_context_t& ctx)
 {
+    bool ret = true;
+    bool has_var = false;
     BEGIN_ATTR_MATCH(node->properties)
-        MATCH_TEXT_ATTR("name", soc.name)
-        MATCH_TEXT_ATTR("desc", soc.desc)
-    END_ATTR_MATCH()
+        MATCH_UNIQUE_ATTR("variable", range.variable, has_var, parse_text_attr, ctx)
+    END_NODE_MATCH()
+    CHECK_HAS_ATTR(node, "variable", has_var, ctx)
+    return ret;
+}
 
+bool parse_range_elem(xmlNode *node, range_t& range, error_context_t& ctx)
+{
+    bool ret = true;
+    bool has_first = false, has_count = false, has_stride = false, has_base = false;
+    bool has_formula = false, has_formula_attr = false;
     BEGIN_NODE_MATCH(node->children)
-        MATCH_ELEM_NODE("dev", soc.dev, parse_dev_elem)
+        MATCH_UNIQUE_TEXT_NODE("first", range.first, has_first, parse_unsigned_elem, ctx)
+        MATCH_UNIQUE_TEXT_NODE("count", range.count, has_count, parse_unsigned_elem, ctx)
+        MATCH_UNIQUE_TEXT_NODE("base", range.base, has_base, parse_unsigned_elem, ctx)
+        MATCH_UNIQUE_TEXT_NODE("stride", range.stride, has_stride, parse_unsigned_elem, ctx)
+        MATCH_UNIQUE_ELEM_NODE("formula", range, has_formula_attr, parse_formula_elem, ctx)
+        MATCH_UNIQUE_TEXT_NODE("formula", range.formula, has_formula, parse_text_elem, ctx)
     END_NODE_MATCH()
+    CHECK_HAS(node, "first", has_first, ctx)
+    CHECK_HAS(node, "count", has_count, ctx)
+    if(!has_base && !has_formula)
+        ret = ret && parse_missing_error(node, "base> or <formula", ctx);
+    if(has_base && has_formula)
+        return parse_conflict_error(node, "base", "formula", ctx);
+    if(has_base)
+        CHECK_HAS(node, "stride", has_stride, ctx)
+    if(has_stride && !has_base)
+        ret = ret && parse_conflict_error(node, "stride", "formula", ctx);
+    if(has_stride)
+        range.type = range_t::STRIDE;
+    else
+        range.type = range_t::FORMULA;
+    return ret;
+}
 
-    return true;
+bool parse_instance_elem(xmlNode *node, instance_t& inst, error_context_t& ctx)
+{
+    bool ret = true;
+    bool has_name = false, has_title = false, has_desc = false, has_range = false;
+    bool has_address = false;
+    BEGIN_NODE_MATCH(node->children)
+        MATCH_UNIQUE_TEXT_NODE("name", inst.name, has_name, parse_name_elem, ctx)
+        MATCH_UNIQUE_TEXT_NODE("title", inst.title, has_title, parse_text_elem, ctx)
+        MATCH_UNIQUE_TEXT_NODE("desc", inst.desc, has_desc, parse_text_elem, ctx)
+        MATCH_UNIQUE_TEXT_NODE("address", inst.addr, has_address, parse_unsigned_elem, ctx)
+        MATCH_UNIQUE_ELEM_NODE("range", inst.range, has_range, parse_range_elem, ctx)
+    END_NODE_MATCH()
+    CHECK_HAS(node, "name", has_name, ctx)
+    if(!has_address && !has_range)
+        ret = ret && parse_missing_error(node, "address> or <range", ctx);
+    if(has_address && has_range)
+        ret = ret && parse_conflict_error(node, "address", "range", ctx);
+    if(has_address)
+        inst.type = instance_t::SINGLE;
+    else
+        inst.type = instance_t::RANGE;
+    return ret;
 }
 
-bool parse_root_elem(xmlNode *node, soc_t& soc)
+bool parse_node_elem(xmlNode *node_, node_t& node, error_context_t& ctx)
 {
-    std::vector< soc_t > socs;
-    BEGIN_NODE_MATCH(node)
-        MATCH_ELEM_NODE("soc", socs, parse_soc_elem)
+    bool ret = true;
+    register_t reg;
+    bool has_title = false, has_desc = false, has_register = false, has_name = false;
+    BEGIN_NODE_MATCH(node_->children)
+        MATCH_UNIQUE_TEXT_NODE("name", node.name, has_name, parse_name_elem, ctx)
+        MATCH_UNIQUE_TEXT_NODE("title", node.title, has_title, parse_text_elem, ctx)
+        MATCH_UNIQUE_TEXT_NODE("desc", node.desc, has_desc, parse_text_elem, ctx)
+        MATCH_UNIQUE_ELEM_NODE("register", reg, has_register, parse_register_elem, ctx)
+        MATCH_ELEM_NODE("node", node.node, parse_node_elem, ctx)
+        MATCH_ELEM_NODE("instance", node.instance, parse_instance_elem, ctx)
     END_NODE_MATCH()
-    if(socs.size() != 1)
+    CHECK_HAS(node_, "name", has_name, ctx)
+    CHECK_HAS(node_, "instance", !node.instance.empty(), ctx)
+    if(has_register)
+        node.register_.push_back(reg);
+    return ret;
+}
+
+bool parse_soc_elem(xmlNode *node, soc_t& soc, error_context_t& ctx)
+{
+    bool ret = true;
+    bool has_name = false, has_title = false, has_desc = false, has_version = false;
+    bool has_isa = false;
+    BEGIN_NODE_MATCH(node->children)
+        MATCH_UNIQUE_TEXT_NODE("name", soc.name, has_name, parse_name_elem, ctx)
+        MATCH_UNIQUE_TEXT_NODE("title", soc.title, has_title, parse_text_elem, ctx)
+        MATCH_UNIQUE_TEXT_NODE("desc", soc.desc, has_desc, parse_text_elem, ctx)
+        MATCH_UNIQUE_TEXT_NODE("version", soc.version, has_version, parse_text_elem, ctx)
+        MATCH_UNIQUE_TEXT_NODE("isa", soc.isa, has_isa, parse_text_elem, ctx)
+        MATCH_TEXT_NODE("author", soc.author, parse_text_elem, ctx)
+        MATCH_ELEM_NODE("node", soc.node, parse_node_elem, ctx)
+    END_NODE_MATCH()
+    CHECK_HAS(node, "name", has_name, ctx)
+    return ret;
+}
+
+bool parse_root_elem(xmlNode *node, soc_t& soc, error_context_t& ctx)
+{
+    size_t ver = 0;
+    bool ret = true;
+    bool has_soc = false, has_version = false;
+    BEGIN_ATTR_MATCH(node->properties)
+        MATCH_UNIQUE_ATTR("version", ver, has_version, parse_unsigned_attr, ctx)
+    END_ATTR_MATCH()
+    if(!has_version)
     {
-        fprintf(stderr, "A description file must contain exactly one soc element\n");
+        ctx.add(error_t(error_t::FATAL, xml_loc(node), "no version attribute, is this a v1 file ?"));
         return false;
     }
-    soc = socs[0];
-    return true;
+    if(ver != MAJOR_VERSION)
+        return parse_wrong_version_error(node, ctx);
+    BEGIN_NODE_MATCH(node)
+        MATCH_UNIQUE_ELEM_NODE("soc", soc, has_soc, parse_soc_elem, ctx)
+    END_NODE_MATCH()
+    CHECK_HAS(node, "soc", has_soc, ctx)
+    return ret;
 }
 
 }
 
-bool soc_desc_parse_xml(const std::string& filename, soc_t& socs)
+bool parse_xml(const std::string& filename, soc_t& soc,
+    error_context_t& error_ctx)
 {
     LIBXML_TEST_VERSION
 
@@ -290,156 +458,207 @@ bool soc_desc_parse_xml(const std::string& filename, soc_t& socs)
         return false;
 
     xmlNodePtr root_element = xmlDocGetRootElement(doc);
-    bool ret = parse_root_elem(root_element, socs);
+    bool ret = parse_root_elem(root_element, soc, error_ctx);
 
     xmlFreeDoc(doc);
 
     return ret;
 }
 
+/**
+ * Producer
+ */
+
 namespace
 {
 
-int produce_field(xmlTextWriterPtr writer, const soc_reg_field_t& field)
+#define SAFE(x) \
+    do{ \
+        if((x) < 0) { \
+            std::ostringstream oss; \
+            oss << __FILE__ << ":" << __LINE__; \
+            ctx.add(error_t(error_t::FATAL, oss.str(), "write error")); \
+            return -1; \
+        } \
+    }while(0)
+
+int produce_range(xmlTextWriterPtr writer, const range_t& range, error_context_t& ctx)
 {
-#define SAFE(x) if((x) < 0) return -1;
-    /* <field> */
-    SAFE(xmlTextWriterStartElement(writer, BAD_CAST "field"));
-    /* name */
-    SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "name", BAD_CAST field.name.c_str()));
-    /* desc */
-    SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "desc", BAD_CAST field.desc.c_str()));
-    /* bitrange */
-    SAFE(xmlTextWriterWriteFormatAttribute(writer, BAD_CAST "bitrange", "%d:%d",
-        field.last_bit, field.first_bit));
-    /* values */
-    for(size_t i = 0; i < field.value.size(); i++)
+    /* <range> */
+    SAFE(xmlTextWriterStartElement(writer, BAD_CAST "range"));
+    /* <first/> */
+    SAFE(xmlTextWriterWriteFormatElement(writer, BAD_CAST "first", "%lu", range.first));
+    /* <count/> */
+    SAFE(xmlTextWriterWriteFormatElement(writer, BAD_CAST "count", "%lu", range.count));
+    /* <base/><stride/> */
+    if(range.type == range_t::STRIDE)
     {
-        /* <value> */
-        SAFE(xmlTextWriterStartElement(writer, BAD_CAST "value"));
-        /* name */
-        SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "name", BAD_CAST field.value[i].name.c_str()));
-        /* value */
-        SAFE(xmlTextWriterWriteFormatAttribute(writer, BAD_CAST "value", "0x%x", field.value[i].value));
-        /* name */
-        SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "desc", BAD_CAST field.value[i].desc.c_str()));
-        /* </value> */
-        SAFE(xmlTextWriterEndElement(writer));
+        SAFE(xmlTextWriterWriteFormatElement(writer, BAD_CAST "base", "0x%x", range.base));
+        SAFE(xmlTextWriterWriteFormatElement(writer, BAD_CAST "stride", "0x%x", range.stride));
     }
-    /* </field> */
-    SAFE(xmlTextWriterEndElement(writer));
-#undef SAFE
-    return 0;
-}
-
-int produce_reg(xmlTextWriterPtr writer, const soc_reg_t& reg)
-{
-#define SAFE(x) if((x) < 0) return -1;
-    /* <reg> */
-    SAFE(xmlTextWriterStartElement(writer, BAD_CAST "reg"));
-    /* name */
-    SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "name", BAD_CAST reg.name.c_str()));
-    /* name */
-    SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "desc", BAD_CAST reg.desc.c_str()));
-    /* flags */
-    if(reg.flags & REG_HAS_SCT)
-        SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "sct", BAD_CAST "yes"));
-    /* formula */
-    if(reg.formula.type != REG_FORMULA_NONE)
+    /* <formula> */
+    else if(range.type == range_t::FORMULA)
     {
         /* <formula> */
         SAFE(xmlTextWriterStartElement(writer, BAD_CAST "formula"));
-        switch(reg.formula.type)
-        {
-            case REG_FORMULA_STRING:
-                SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "string", 
-                    BAD_CAST reg.formula.string.c_str()));
-                break;
-            default:
-                break;
-        }
+        /* variable */
+        SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "variable", BAD_CAST range.variable.c_str()));
+        /* content */
+        SAFE(xmlTextWriterWriteString(writer, BAD_CAST range.formula.c_str()));
         /* </formula> */
         SAFE(xmlTextWriterEndElement(writer));
     }
-    /* addresses */
-    for(size_t i = 0; i < reg.addr.size(); i++)
-    {
-        /* <addr> */
-        SAFE(xmlTextWriterStartElement(writer, BAD_CAST "addr"));
-        /* name */
-        SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "name", BAD_CAST reg.addr[i].name.c_str()));
-        /* addr */
-        SAFE(xmlTextWriterWriteFormatAttribute(writer, BAD_CAST "addr", "0x%x", reg.addr[i].addr));
-        /* </addr> */
-        SAFE(xmlTextWriterEndElement(writer));
-    }
+    /* </range> */
+    SAFE(xmlTextWriterEndElement(writer));
+
+    return 0;
+}
+
+int produce_instance(xmlTextWriterPtr writer, const instance_t& inst, error_context_t& ctx)
+{
+    /* <instance> */
+    SAFE(xmlTextWriterStartElement(writer, BAD_CAST "instance"));
+    /* <name/> */
+    SAFE(xmlTextWriterWriteElement(writer, BAD_CAST "name", BAD_CAST inst.name.c_str()));
+    /* <title/> */
+    if(!inst.title.empty())
+        SAFE(xmlTextWriterWriteElement(writer, BAD_CAST "title", BAD_CAST inst.title.c_str()));
+    /* <desc/> */
+    if(!inst.desc.empty())
+        SAFE(xmlTextWriterWriteElement(writer, BAD_CAST "desc", BAD_CAST inst.desc.c_str()));
+    /* <address/> */
+    if(inst.type == instance_t::SINGLE)
+        SAFE(xmlTextWriterWriteFormatElement(writer, BAD_CAST "address", "0x%x", inst.addr));
+    /* <range/> */
+    else if(inst.type == instance_t::RANGE)
+        SAFE(produce_range(writer, inst.range, ctx));
+    /* </instance> */
+    SAFE(xmlTextWriterEndElement(writer));
+    return 0;
+}
+
+int produce_enum(xmlTextWriterPtr writer, const enum_t& enum_, error_context_t& ctx)
+{
+    /* <enum> */
+    SAFE(xmlTextWriterStartElement(writer, BAD_CAST "enum"));
+    /* <name/> */
+    SAFE(xmlTextWriterWriteElement(writer, BAD_CAST "name", BAD_CAST enum_.name.c_str()));
+    /* <desc/> */
+    if(!enum_.desc.empty())
+        SAFE(xmlTextWriterWriteElement(writer, BAD_CAST "desc", BAD_CAST enum_.desc.c_str()));
+    /* <value/> */
+    SAFE(xmlTextWriterWriteFormatElement(writer, BAD_CAST "value", "0x%x", enum_.value));
+    /* </enum> */
+    SAFE(xmlTextWriterEndElement(writer));
+    return 0;
+}
+
+int produce_field(xmlTextWriterPtr writer, const field_t& field, error_context_t& ctx)
+{
+    /* <field> */
+    SAFE(xmlTextWriterStartElement(writer, BAD_CAST "field"));
+    /* <name/> */
+    SAFE(xmlTextWriterWriteElement(writer, BAD_CAST "name", BAD_CAST field.name.c_str()));
+    /* <desc/> */
+    if(!field.desc.empty())
+        SAFE(xmlTextWriterWriteElement(writer, BAD_CAST "desc", BAD_CAST field.desc.c_str()));
+    /* <position/> */
+    SAFE(xmlTextWriterWriteFormatElement(writer, BAD_CAST "position", "%lu", field.pos));
+    /* <width/> */
+    if(field.width != 1)
+        SAFE(xmlTextWriterWriteFormatElement(writer, BAD_CAST "width", "%lu", field.width));
+    /* enums */
+    for(size_t i = 0; i < field.enum_.size(); i++)
+        SAFE(produce_enum(writer, field.enum_[i], ctx));
+    /* </field> */
+    SAFE(xmlTextWriterEndElement(writer));
+    return 0;
+}
+
+int produce_register(xmlTextWriterPtr writer, const register_t& reg, error_context_t& ctx)
+{
+    /* <register> */
+    SAFE(xmlTextWriterStartElement(writer, BAD_CAST "register"));
+    /* <width/> */
+    if(reg.width != 32)
+        SAFE(xmlTextWriterWriteFormatElement(writer, BAD_CAST "width", "%lu", reg.width));
     /* fields */
     for(size_t i = 0; i < reg.field.size(); i++)
-        produce_field(writer, reg.field[i]);
-    /* </reg> */
+        SAFE(produce_field(writer, reg.field[i], ctx));
+    /* </register> */
     SAFE(xmlTextWriterEndElement(writer));
-#undef SAFE
     return 0;
 }
 
-int produce_dev(xmlTextWriterPtr writer, const soc_dev_t& dev)
+int produce_node(xmlTextWriterPtr writer, const node_t& node, error_context_t& ctx)
 {
-#define SAFE(x) if((x) < 0) return -1;
-    /* <dev> */
-    SAFE(xmlTextWriterStartElement(writer, BAD_CAST "dev"));
-    /* name */
-    SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "name", BAD_CAST dev.name.c_str()));
-    /* long_name */
-    SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "long_name", BAD_CAST dev.long_name.c_str()));
-    /* desc */
-    SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "desc", BAD_CAST dev.desc.c_str()));
-    /* version */
-    SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "version", BAD_CAST dev.version.c_str()));
-    /* addresses */
-    for(size_t i = 0; i < dev.addr.size(); i++)
-    {
-        /* <addr> */
-        SAFE(xmlTextWriterStartElement(writer, BAD_CAST "addr"));
-        /* name */
-        SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "name", BAD_CAST dev.addr[i].name.c_str()));
-        /* addr */
-        SAFE(xmlTextWriterWriteFormatAttribute(writer, BAD_CAST "addr", "0x%x", dev.addr[i].addr));
-        /* </addr> */
-        SAFE(xmlTextWriterEndElement(writer));
-    }
-    /* registers */
-    for(size_t i = 0; i < dev.reg.size(); i++)
-        produce_reg(writer, dev.reg[i]);
-    /* </dev> */
+    /* <node> */
+    SAFE(xmlTextWriterStartElement(writer, BAD_CAST "node"));
+    /* <name/> */
+    SAFE(xmlTextWriterWriteElement(writer, BAD_CAST "name", BAD_CAST node.name.c_str()));
+    /* <title/> */
+    if(!node.title.empty())
+        SAFE(xmlTextWriterWriteElement(writer, BAD_CAST "title", BAD_CAST node.title.c_str()));
+    /* <desc/> */
+    if(!node.desc.empty())
+        SAFE(xmlTextWriterWriteElement(writer, BAD_CAST "desc", BAD_CAST node.desc.c_str()));
+    /* instances */
+    for(size_t i = 0; i < node.instance.size(); i++)
+        SAFE(produce_instance(writer, node.instance[i], ctx));
+    /* register */
+    for(size_t i = 0; i < node.register_.size(); i++)
+        SAFE(produce_register(writer, node.register_[i], ctx));
+    /* nodes */
+    for(size_t i = 0; i < node.node.size(); i++)
+        SAFE(produce_node(writer, node.node[i], ctx));
+    /* </node> */
     SAFE(xmlTextWriterEndElement(writer));
-#undef SAFE
     return 0;
 }
 
+#undef SAFE
+
 }
 
-bool soc_desc_produce_xml(const std::string& filename, const soc_t& soc)
+bool produce_xml(const std::string& filename, const soc_t& soc, error_context_t& ctx)
 {
     LIBXML_TEST_VERSION
 
+    std::ostringstream oss;
     xmlTextWriterPtr writer = xmlNewTextWriterFilename(filename.c_str(), 0);
     if(writer == NULL)
         return false;
-#define SAFE(x) if((x) < 0) goto  Lerr
+#define SAFE(x) do{if((x) < 0) goto  Lerr;}while(0)
     SAFE(xmlTextWriterSetIndent(writer, 1));
-    SAFE(xmlTextWriterSetIndentString(writer, BAD_CAST "  "));
+    SAFE(xmlTextWriterSetIndentString(writer, BAD_CAST "    "));
     /* <xml> */
     SAFE(xmlTextWriterStartDocument(writer, NULL, NULL, NULL));
     /* <soc> */
     SAFE(xmlTextWriterStartElement(writer, BAD_CAST "soc"));
-    /* name */
-    SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "name", BAD_CAST soc.name.c_str()));
-    /* desc */
-    SAFE(xmlTextWriterWriteAttribute(writer,  BAD_CAST "desc", BAD_CAST soc.desc.c_str()));
-    /* devices */
-    for(size_t i = 0; i < soc.dev.size(); i++)
-        SAFE(produce_dev(writer, soc.dev[i]));
-    /* end <soc> */
+    /* version */
+    oss << MAJOR_VERSION;
+    SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "version", BAD_CAST oss.str().c_str()));
+    /* <name/> */
+    SAFE(xmlTextWriterWriteElement(writer, BAD_CAST "name", BAD_CAST soc.name.c_str()));
+    /* <title/> */
+    if(!soc.title.empty())
+        SAFE(xmlTextWriterWriteElement(writer, BAD_CAST "title", BAD_CAST soc.title.c_str()));
+    /* <desc/> */
+    if(!soc.desc.empty())
+        SAFE(xmlTextWriterWriteElement(writer, BAD_CAST "desc", BAD_CAST soc.desc.c_str()));
+    /* <author/> */
+    for(size_t i = 0; i < soc.author.size(); i++)
+        SAFE(xmlTextWriterWriteElement(writer, BAD_CAST "author", BAD_CAST soc.author[i].c_str()));
+    /* <isa/> */
+    if(!soc.isa.empty())
+        SAFE(xmlTextWriterWriteElement(writer, BAD_CAST "isa", BAD_CAST soc.isa.c_str()));
+    /* <version/> */
+    if(!soc.version.empty())
+        SAFE(xmlTextWriterWriteElement(writer, BAD_CAST "version", BAD_CAST soc.version.c_str()));
+    /* nodes */
+    for(size_t i = 0; i < soc.node.size(); i++)
+        SAFE(produce_node(writer, soc.node[i], ctx));
+    /* </soc> */
     SAFE(xmlTextWriterEndElement(writer));
     /* </xml> */
     SAFE(xmlTextWriterEndDocument(writer));
@@ -451,520 +670,500 @@ Lerr:
     return false;
 }
 
-namespace
+/**
+ * soc_ref_t
+ */
+
+soc_ref_t::soc_ref_t():m_soc(0)
 {
+}
 
-struct soc_sorter
+soc_ref_t::soc_ref_t(soc_t *soc):m_soc(soc)
 {
-    bool operator()(const soc_dev_t& a, const soc_dev_t& b) const
-    {
-        return a.name < b.name;
-    }
+}
 
-    bool operator()(const soc_dev_addr_t& a, const soc_dev_addr_t& b) const
-    {
-        return a.name < b.name;
-    }
+bool soc_ref_t::valid() const
+{
+    return get() != 0;
+}
 
-    bool operator()(const soc_reg_t& a, const soc_reg_t& b) const
-    {
-        soc_addr_t aa = a.addr.size() > 0 ? a.addr[0].addr : 0;
-        soc_addr_t ab = b.addr.size() > 0 ? b.addr[0].addr : 0;
-        return aa < ab;
-    }
+soc_t *soc_ref_t::get()  const
+{
+    return m_soc;
+}
 
-    bool operator()(const soc_reg_addr_t& a, const soc_reg_addr_t& b) const
-    {
-        return a.addr < b.addr;
-    }
+bool soc_ref_t::operator==(const soc_ref_t& ref) const
+{
+    return m_soc == ref.m_soc;
+}
 
-    bool operator()(const soc_reg_field_t& a, const soc_reg_field_t& b) const
-    {
-        return a.last_bit > b.last_bit;
-    }
+node_ref_t soc_ref_t::root() const
+{
+    return node_ref_t(*this);
+}
 
-    bool operator()(const soc_reg_field_value_t a, const soc_reg_field_value_t& b) const
-    {
-        return a.value < b.value;
-    }
-};
+node_inst_t soc_ref_t::root_inst() const
+{
+    return node_inst_t(*this);
+}
 
-void normalize(soc_reg_field_t& field)
+/**
+ * node_ref_t */
+
+node_ref_t::node_ref_t(soc_ref_t soc):m_soc(soc)
 {
-    std::sort(field.value.begin(), field.value.end(), soc_sorter());
 }
 
-void normalize(soc_reg_t& reg)
+node_ref_t::node_ref_t(soc_ref_t soc, const std::vector< soc_id_t >& path)
+    :m_soc(soc), m_path(path)
 {
-    std::sort(reg.addr.begin(), reg.addr.end(), soc_sorter());
-    std::sort(reg.field.begin(), reg.field.end(), soc_sorter());
-    for(size_t i = 0; i < reg.field.size(); i++)
-        normalize(reg.field[i]);
 }
 
-void normalize(soc_dev_t& dev)
+node_ref_t::node_ref_t()
 {
-    std::sort(dev.addr.begin(), dev.addr.end(), soc_sorter());
-    std::sort(dev.reg.begin(), dev.reg.end(), soc_sorter());
-    for(size_t i = 0; i < dev.reg.size(); i++)
-        normalize(dev.reg[i]);
 }
 
+bool node_ref_t::valid() const
+{
+    return (m_soc.valid() && is_root()) || get() != 0;
 }
 
-void soc_desc_normalize(soc_t& soc)
+bool node_ref_t::is_root() const
 {
-    std::sort(soc.dev.begin(), soc.dev.end(), soc_sorter());
-    for(size_t i = 0; i < soc.dev.size(); i++)
-        normalize(soc.dev[i]);
+    return m_path.empty();
 }
 
 namespace
 {
-    soc_error_t make_error(soc_error_level_t lvl, std::string at, std::string what)
-    {
-        soc_error_t err;
-        err.level = lvl;
-        err.location = at;
-        err.message = what;
-        return err;
-    }
 
-    soc_error_t make_warning(std::string at, std::string what)
-    {
-        return make_error(SOC_ERROR_WARNING, at, what);
-    }
-
-    soc_error_t make_fatal(std::string at, std::string what)
-    {
-        return make_error(SOC_ERROR_FATAL, at, what);
-    }
+std::vector< node_t > *get_children(node_ref_t node)
+{
+    if(node.is_root())
+        return &node.soc().get()->node;
+    node_t *n = node.get();
+    return n == 0 ? 0 : &n->node;
+}
 
-    soc_error_t prefix(soc_error_t err, const std::string& prefix_at)
-    {
-        err.location = prefix_at + "." + err.location;
-        return err;
-    }
+node_t *get_child(std::vector< node_t > *nodes, soc_id_t id)
+{
+    if(nodes == 0)
+        return 0;
+    for(size_t i = 0; i < nodes->size(); i++)
+        if((*nodes)[i].id == id)
+            return &(*nodes)[i];
+    return 0;
+}
 
-    void add_errors(std::vector< soc_error_t >& errors,
-        const std::vector< soc_error_t >& new_errors, const std::string& prefix_at)
-    {
-        for(size_t i = 0; i < new_errors.size(); i++)
-            errors.push_back(prefix(new_errors[i], prefix_at));
-    }
+node_t *get_child(std::vector< node_t > *nodes, const std::string& name)
+{
+    if(nodes == 0)
+        return 0;
+    for(size_t i = 0; i < nodes->size(); i++)
+        if((*nodes)[i].name == name)
+            return &(*nodes)[i];
+    return 0;
+}
 
-    std::vector< soc_error_t > no_error()
-    {
-        std::vector< soc_error_t > s;
-        return s;
-    }
+}
 
-    std::vector< soc_error_t > one_error(const soc_error_t& err)
+/* NOTE: valid() is implemented using get() != 0, so don't use it in get() ! */
+node_t *node_ref_t::get() const
+{
+    if(!soc().valid())
+        return 0;
+    /* we could do it recursively but it would make plenty of copies */
+    node_t *n = 0;
+    std::vector< node_t > *nodes = &soc().get()->node;
+    for(size_t i = 0; i < m_path.size(); i++)
     {
-        std::vector< soc_error_t > s;
-        s.push_back(err);
-        return s;
+        n = get_child(nodes, m_path[i]);
+        if(n == 0)
+            return 0;
+        nodes = &n->node;
     }
+    return n;
+}
 
-    bool name_valid(char c)
-    {
-        return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') ||
-            (c >= 'A' && c <= 'Z') || c == '_';
-    }
+soc_ref_t node_ref_t::soc() const
+{
+    return m_soc;
+}
 
-    bool name_valid(const std::string& s)
-    {
-        for(size_t i = 0; i < s.size(); i++)
-            if(!name_valid(s[i]))
-                return false;
-        return true;
-    }
+node_ref_t node_ref_t::parent() const
+{
+    std::vector< soc_id_t > path = m_path;
+    if(!path.empty())
+        path.pop_back();
+    return node_ref_t(m_soc, path);
 }
 
-std::vector< soc_error_t > soc_reg_field_value_t::errors(bool recursive)
+register_ref_t node_ref_t::reg() const
 {
-    (void) recursive;
-    if(name.size() == 0)
-        return one_error(make_fatal(name, "empty name"));
-    else if(!name_valid(name))
-        return one_error(make_fatal(name, "invalid name"));
+    node_t *n = get();
+    if(n == 0)
+        return register_ref_t();
+    if(n->register_.empty())
+        return parent().reg();
     else
-        return no_error();
+        return register_ref_t(*this);
 }
 
-std::vector< soc_error_t > soc_reg_field_t::errors(bool recursive)
+node_ref_t node_ref_t::child(const std::string& name) const
 {
-    std::vector< soc_error_t >  err;
-    std::string at(name);
-    if(name.size() == 0)
-        err.push_back(make_fatal(at, "empty name"));
-    else if(!name_valid(name))
-        err.push_back(make_fatal(at, "invalid name"));
-    if(last_bit > 31)
-        err.push_back(make_fatal(at, "last bit is greater than 31"));
-    if(first_bit > last_bit)
-        err.push_back(make_fatal(at, "last bit is greater than first bit"));
-    for(size_t i = 0; i < value.size(); i++)
+    /* check the node exists */
+    node_t *n = get_child(get_children(*this), name);
+    if(n == 0)
+        return node_ref_t();
+    std::vector< soc_id_t > path = m_path;
+    path.push_back(n->id);
+    return node_ref_t(m_soc, path);
+}
+
+std::vector< node_ref_t > node_ref_t::children() const
+{
+    std::vector< node_ref_t > nodes;
+    std::vector< node_t > *children = get_children(*this);
+    if(children == 0)
+        return nodes;
+    for(size_t i = 0; i < children->size(); i++)
     {
-        for(size_t j = 0; j < value.size(); j++)
+        std::vector< soc_id_t > path = m_path;
+        path.push_back((*children)[i].id);
+        nodes.push_back(node_ref_t(m_soc, path));
+    }
+    return nodes;
+}
+
+std::vector< std::string > node_ref_t::path() const
+{
+    std::vector< std::string > path;
+    if(!soc().valid())
+        return path;
+    /* we could do it recursively but this is more efficient */
+    node_t *n = 0;
+    std::vector< node_t > *nodes = &soc().get()->node;
+    for(size_t i = 0; i < m_path.size(); i++)
+    {
+        n = get_child(nodes, m_path[i]);
+        if(n == 0)
         {
-            if(i == j)
-                continue;
-            if(value[i].name == value[j].name)
-                err.push_back(prefix(make_fatal(value[i].name, 
-                    "there are several values with the same name"), at));
-            if(value[i].value == value[j].value)
-                err.push_back(prefix(make_warning(value[i].name, 
-                    "there are several values with the same value"), at));
+            path.clear();
+            return path;
         }
-        if(value[i].value > (bitmask() >> first_bit))
-            err.push_back(prefix(make_warning(at, "value doesn't fit into the field"), value[i].name));
-        if(recursive)
-            add_errors(err, value[i].errors(true), at);
+        path.push_back(n->name);
+        nodes = &n->node;
     }
-    return err;
+    return path;
 }
 
-std::vector< soc_error_t > soc_reg_addr_t::errors(bool recursive)
+std::string node_ref_t::name() const
 {
-    (void) recursive;
-    if(name.size() == 0)
-        return one_error(make_fatal("", "empty name"));
-    else if(!name_valid(name))
-        return one_error(make_fatal(name, "invalid name"));
-    else
-        return no_error();
+    node_t *n = get();
+    return n == 0 ? "" : n->name;
 }
 
-std::vector< soc_error_t > soc_reg_formula_t::errors(bool recursive)
+bool node_ref_t::operator==(const node_ref_t& ref) const
 {
-    (void) recursive;
-    if(type == REG_FORMULA_STRING && string.size() == 0)
-        return one_error(make_fatal("", "empty string formula"));
-    else
-        return no_error();
+    return m_soc == ref.m_soc && m_path == ref.m_path;
 }
 
-namespace
+/**
+ * register_ref_t
+ */
+
+register_ref_t::register_ref_t(node_ref_t node)
+    :m_node(node)
 {
+}
 
-bool field_overlap(const soc_reg_field_t& a, const soc_reg_field_t& b)
+register_ref_t::register_ref_t()
 {
-    return !(a.first_bit > b.last_bit || b.first_bit > a.last_bit);
 }
 
+bool register_ref_t::valid() const
+{
+    return get() != 0;
 }
 
-std::vector< soc_error_t > soc_reg_t::errors(bool recursive)
+register_t *register_ref_t::get() const
 {
-    std::vector< soc_error_t >  err;
-    std::string at(name);
-    if(name.size() == 0)
-        err.push_back(make_fatal(at, "empty name"));
-    else if(!name_valid(name))
-        err.push_back(make_fatal(at, "invalid name"));
-    for(size_t i = 0; i < addr.size(); i++)
-    {
-        for(size_t j = 0; j < addr.size(); j++)
-        {
-            if(i == j)
-                continue;
-            if(addr[i].name == addr[j].name)
-                err.push_back(prefix(make_fatal(addr[i].name, 
-                    "there are several instances with the same name"), at));
-            if(addr[i].addr == addr[j].addr)
-                err.push_back(prefix(make_fatal(addr[i].name, 
-                    "there are several instances with the same address"), at));
-        }
-        if(recursive)
-            add_errors(err, addr[i].errors(true), at);
-    }
-    if(recursive)
-        add_errors(err, formula.errors(true), at);
-    for(size_t i = 0; i < field.size(); i++)
-    {
-        for(size_t j = 0; j < field.size(); j++)
-        {
-            if(i == j)
-                continue;
-            if(field[i].name == field[j].name)
-                err.push_back(prefix(make_fatal(field[i].name, 
-                    "there are several fields with the same name"), at));
-            if(field_overlap(field[i], field[j]))
-                err.push_back(prefix(make_fatal(field[i].name, 
-                    "there are overlapping fields"), at));
-        }
-        if(recursive)
-            add_errors(err, field[i].errors(true), at);
-    }
-    return err;
+    node_t *n = m_node.get();
+    if(n == 0 || n->register_.empty())
+        return 0;
+    return &n->register_[0];
 }
 
-std::vector< soc_error_t > soc_dev_addr_t::errors(bool recursive)
+node_ref_t register_ref_t::node() const
 {
-    (void) recursive;
-    if(name.size() == 0)
-        return one_error(make_fatal("", "empty name"));
-    else if(!name_valid(name))
-        return one_error(make_fatal(name, "invalid name"));
-    else
-        return no_error();
+    return m_node;
 }
 
-std::vector< soc_error_t > soc_dev_t::errors(bool recursive)
+std::vector< field_ref_t > register_ref_t::fields() const
 {
-    std::vector< soc_error_t >  err;
-    std::string at(name);
-    if(name.size() == 0)
-        err.push_back(make_fatal(at, "empty name"));
-    else if(!name_valid(name))
-        err.push_back(make_fatal(at, "invalid name"));
-    for(size_t i = 0; i < addr.size(); i++)
-    {
-        for(size_t j = 0; j < addr.size(); j++)
-        {
-            if(i == j)
-                continue;
-            if(addr[i].name == addr[j].name)
-                err.push_back(prefix(make_fatal(addr[i].name, 
-                    "there are several instances with the same name"), at));
-            if(addr[i].addr == addr[j].addr)
-                err.push_back(prefix(make_fatal(addr[i].name, 
-                    "there are several instances with the same address"), at));
-        }
-        if(recursive)
-            add_errors(err, addr[i].errors(true), at);
-    }
-    for(size_t i = 0; i < reg.size(); i++)
-    {
-        for(size_t j = 0; j < reg.size(); j++)
-        {
-            if(i == j)
-                continue;
-            if(reg[i].name == reg[j].name)
-                err.push_back(prefix(make_fatal(reg[i].name, 
-                    "there are several registers with the same name"), at));
-        }
-        if(recursive)
-            add_errors(err, reg[i].errors(true), at);
-    }
-    return err;
+    std::vector< field_ref_t > fields;
+    register_t *r = get();
+    if(r == 0)
+        return fields;
+    for(size_t i = 0; i < r->field.size(); i++)
+        fields.push_back(field_ref_t(*this, r->field[i].id));
+    return fields;
 }
 
-std::vector< soc_error_t > soc_t::errors(bool recursive)
+field_ref_t register_ref_t::field(const std::string& name) const
 {
-    std::vector< soc_error_t >  err;
-    std::string at(name);
-    for(size_t i = 0; i < dev.size(); i++)
-    {
-        for(size_t j = 0; j < dev.size(); j++)
-        {
-            if(i == j)
-                continue;
-            if(dev[i].name == dev[j].name)
-                err.push_back(prefix(make_fatal(dev[i].name, 
-                    "there are several devices with the same name"), at));
-        }
-        if(recursive)
-            add_errors(err, dev[i].errors(true), at);
-    }
-    return err;
+    register_t *r = get();
+    if(r == 0)
+        return field_ref_t();
+    for(size_t i = 0; i < r->field.size(); i++)
+        if(r->field[i].name == name)
+            return field_ref_t(*this, r->field[i].id);
+    return field_ref_t();
 }
 
-namespace
+/**
+ * field_ref_t
+ */
+
+field_ref_t::field_ref_t(register_ref_t reg, soc_id_t id)
+    :m_reg(reg), m_id(id)
 {
+}
 
-struct formula_evaluator
+field_ref_t::field_ref_t()
 {
-    std::string formula;
-    size_t pos;
-    std::string error;
+}
 
-    bool err(const char *fmt, ...)
-    {
-        char buffer[256];
-        va_list args;
-        va_start(args, fmt);
-        vsnprintf(buffer,sizeof(buffer), fmt, args);
-        va_end(args);
-        error = buffer;
-        return false;
-    }
+bool field_ref_t::valid() const
+{
+    return get() != 0;
+}
 
-    formula_evaluator(const std::string& s):pos(0)
-    {
-        for(size_t i = 0; i < s.size(); i++)
-            if(!isspace(s[i]))
-                formula.push_back(s[i]);
-    }
+field_t *field_ref_t::get() const
+{
+    register_t *reg = m_reg.get();
+    if(reg == 0)
+        return 0;
+    for(size_t i = 0; i < reg->field.size(); i++)
+        if(reg->field[i].id == m_id)
+            return &reg->field[i];
+    return 0;
+}
 
-    void adv()
-    {
-        pos++;
-    }
+register_ref_t field_ref_t::reg() const
+{
+    return m_reg;
+}
 
-    char cur()
-    {
-        return end() ? 0 : formula[pos];
-    }
+/**
+ * node_inst_t
+ */
 
-    bool end()
-    {
-        return pos >= formula.size();
-    }
+namespace
+{
+
+const size_t INST_NO_INDEX = std::numeric_limits<std::size_t>::max();
 
-    bool parse_digit(char c, int basis, soc_word_t& res)
+bool get_inst_addr(range_t& range, size_t index, soc_addr_t& addr)
+{
+    if(index < range.first || index >= range.first + range.count)
+        return false;
+    switch(range.type)
     {
-        c = tolower(c);
-        if(isdigit(c))
-        {
-            res = c - '0';
+        case range_t::STRIDE:
+            addr += range.base + (index - range.first) * range.stride;
             return true;
-        }
-        if(basis == 16 && isxdigit(c))
+        case range_t::FORMULA:
         {
-            res = c + 10 - 'a';
+            soc_word_t res;
+            std::map< std::string, soc_word_t > vars;
+            vars[range.variable] = index;
+            error_context_t ctx;
+            if(!evaluate_formula(range.formula, vars, res, "", ctx))
+                return false;
+            addr += res;
             return true;
         }
-        return err("invalid digit '%c'", c);
+        default:
+            return false;
     }
+}
 
-    bool parse_signed(soc_word_t& res)
+bool get_inst_addr(instance_t *inst, size_t index, soc_addr_t& addr)
+{
+    if(inst == 0)
+        return false;
+    switch(inst->type)
     {
-        char op = cur();
-        if(op == '+' || op == '-')
-        {
-            adv();
-            if(!parse_signed(res))
+        case instance_t::SINGLE:
+            if(index != INST_NO_INDEX)
                 return false;
-            if(op == '-')
-                res *= -1;
+            addr += inst->addr;
             return true;
-        }
-        else if(op == '(')
-        {
-            adv();
-            if(!parse_expression(res))
+        case instance_t::RANGE:
+            if(index == INST_NO_INDEX)
                 return false;
-            if(cur() != ')')
-                return err("expected ')', got '%c'", cur());
-            adv();
-            return true;
-        }
-        else if(isdigit(op))
-        {
-            res = op - '0';
-            adv();
-            int basis = 10;
-            if(op == '0' && cur() == 'x')
-            {
-                basis = 16;
-                adv();
-            }
-            soc_word_t digit = 0;
-            while(parse_digit(cur(), basis, digit))
-            {
-                res = res * basis + digit;
-                adv();
-            }
-            return true;
-        }
-        else if(isalpha(op) || op == '_')
-        {
-            std::string name;
-            while(isalnum(cur()) || cur() == '_')
-            {
-                name.push_back(cur());
-                adv();
-            }
-            return get_variable(name, res);
-        }
-        else
-            return err("express signed expression, got '%c'", op);
-    }
-
-    bool parse_term(soc_word_t& res)
-    {
-        if(!parse_signed(res))
+            return get_inst_addr(inst->range, index, addr);
+        default:
             return false;
-        while(cur() == '*' || cur() == '/' || cur() == '%')
-        {
-            char op = cur();
-            adv();
-            soc_word_t tmp;
-            if(!parse_signed(tmp))
-                return false;
-            if(op == '*')
-                res *= tmp;
-            else if(tmp != 0)
-                res = op == '/' ? res / tmp : res % tmp;
-            else
-                return err("division by 0");
-        }
-        return true;
     }
+}
 
-    bool parse_expression(soc_word_t& res)
-    {
-        if(!parse_term(res))
-            return false;
-        while(!end() && (cur() == '+' || cur() == '-'))
-        {
-            char op = cur();
-            adv();
-            soc_word_t tmp;
-            if(!parse_term(tmp))
-                return false;
-            if(op == '+')
-                res += tmp;
-            else
-                res -= tmp;
-        }
-        return true;
-    }
+}
 
-    bool parse(soc_word_t& res, std::string& _error)
-    {
-        bool ok = parse_expression(res);
-        if(ok && !end())
-            err("unexpected character '%c'", cur());
-        _error = error;
-        return ok && end();
-    }
+node_inst_t::node_inst_t(soc_ref_t soc)
+    :m_node(soc.root())
+{
+}
 
-    virtual bool get_variable(std::string name, soc_word_t& res)
-    {
-        return err("unknown variable '%s'", name.c_str());
-    }
-};
+node_inst_t::node_inst_t(node_ref_t node, const std::vector< soc_id_t >& ids,
+        const std::vector< size_t >& indexes)
+    :m_node(node), m_id_path(ids), m_index_path(indexes)
+{
+}
 
-struct my_evaluator : public formula_evaluator
+node_inst_t::node_inst_t()
 {
-    const std::map< std::string, soc_word_t>& var;
+}
 
-    my_evaluator(const std::string& formula, const std::map< std::string, soc_word_t>& _var)
-        :formula_evaluator(formula), var(_var) {}
+bool node_inst_t::valid() const
+{
+    return is_root() || get() != 0;
+}
 
-    virtual bool get_variable(std::string name, soc_word_t& res)
+node_ref_t node_inst_t::node() const
+{
+    return m_node;
+}
+
+soc_ref_t node_inst_t::soc() const
+{
+    return m_node.soc();
+}
+
+bool node_inst_t::is_root() const
+{
+    return m_node.is_root();
+}
+
+node_inst_t node_inst_t::parent() const
+{
+    std::vector< soc_id_t > ids = m_id_path;
+    std::vector< size_t > indexes = m_index_path;
+    if(!ids.empty())
+        ids.pop_back();
+    if(!indexes.empty())
+        indexes.pop_back();
+    return node_inst_t(m_node.parent(), ids, indexes);
+}
+
+instance_t *node_inst_t::get() const
+{
+    node_t *n = m_node.get();
+    if(n == 0)
+        return 0;
+    for(size_t i = 0; i < n->instance.size(); i++)
+        if(n->instance[i].id == m_id_path.back())
+            return &n->instance[i];
+    return 0;
+}
+
+soc_addr_t node_inst_t::addr() const
+{
+    if(is_root())
+        return 0;
+    soc_addr_t addr = parent().addr();
+    if(!get_inst_addr(get(), m_index_path.back(), addr))
+        return 0;
+    return addr;
+}
+
+node_inst_t node_inst_t::child(const std::string& name) const
+{
+    return child(name, INST_NO_INDEX);
+}
+
+
+node_inst_t node_inst_t::child(const std::string& name, size_t index) const
+{
+    std::vector< node_t > *nodes = get_children(m_node);
+    if(nodes == 0)
+        return node_inst_t();
+    node_ref_t child_node = m_node;
+    for(size_t i = 0; i < nodes->size(); i++)
     {
-        std::map< std::string, soc_word_t>::const_iterator it = var.find(name);
-        if(it == var.end())
-            return formula_evaluator::get_variable(name, res);
-        else
+        node_t& node = (*nodes)[i];
+        child_node.m_path.push_back(node.id);
+        for(size_t j = 0; j < node.instance.size(); j++)
         {
-            res = it->second;
-            return true;
+            if(node.instance[j].name != name)
+                continue;
+            std::vector< soc_id_t > ids = m_id_path;
+            std::vector< size_t > indexes = m_index_path;
+            ids.push_back(node.instance[j].id);
+            ids.push_back(index);
+            return node_inst_t(child_node, ids, indexes);
         }
+        child_node.m_path.pop_back();
     }
-};
+    return node_inst_t();
+}
+
+std::vector< node_inst_t > node_inst_t::children() const
+{
+    std::vector< node_inst_t > list;
+    std::vector< node_t > *nodes = get_children(m_node);
+    std::vector< soc_id_t > n_path = m_id_path;
+    std::vector< size_t > i_path = m_index_path;
+    if(nodes == 0)
+        return list;
+    node_ref_t child_node = m_node;
+    for(size_t i = 0; i < nodes->size(); i++)
+    {
+        node_t& node = (*nodes)[i];
+        child_node.m_path.push_back(node.id);
+        for(size_t j = 0; j < node.instance.size(); j++)
+        {
+            instance_t& inst = node.instance[j];
+            n_path.push_back(inst.id);
+            switch(inst.type)
+            {
+                case instance_t::SINGLE:
+                    i_path.push_back(INST_NO_INDEX);
+                    list.push_back(node_inst_t(child_node, n_path, i_path));
+                    i_path.pop_back();
+                    break;
+                case instance_t::RANGE:
+                    for(size_t i = 0; i < inst.range.count; i++)
+                    {
+                        i_path.push_back(inst.range.first + i);
+                        list.push_back(node_inst_t(child_node, n_path, i_path));
+                        i_path.pop_back();
+                    }
+                    break;
+                default:
+                    break;
+            }
+            n_path.pop_back();
+        }
+        child_node.m_path.pop_back();
+    }
+    return list;
+}
+
+std::string node_inst_t::name() const
+{
+    instance_t *inst = get();
+    return inst == 0 ? "" : inst->name;
+}
 
+bool node_inst_t:: is_indexed() const
+{
+    return !m_index_path.empty() && m_index_path.back() != INST_NO_INDEX;
 }
 
-bool soc_desc_evaluate_formula(const std::string& formula,
-    const std::map< std::string, soc_word_t>& var, soc_word_t& result, std::string& error)
+size_t node_inst_t::index() const
 {
-    my_evaluator e(formula, var);
-    return e.parse(result, error);
+    return m_index_path.empty() ? INST_NO_INDEX : m_index_path.back();
 }
 
 /** WARNING we need to call xmlInitParser() to init libxml2 but it needs to
@@ -982,4 +1181,7 @@ public:
 };
 
 xml_parser_init __xml_parser_init;
-}
\ No newline at end of file
+}
+
+} // soc_desc_v1
+
diff --git a/utils/regtools/lib/soc_desc_v1.cpp b/utils/regtools/lib/soc_desc_v1.cpp
new file mode 100644
index 0000000000..d585485493
--- /dev/null
+++ b/utils/regtools/lib/soc_desc_v1.cpp
@@ -0,0 +1,990 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id$
+ *
+ * Copyright (C) 2012 by Amaury Pouly
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+#include "soc_desc_v1.hpp"
+#include <libxml/parser.h>
+#include <libxml/tree.h>
+#include <libxml/xmlsave.h>
+#include <libxml/xmlwriter.h>
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+#include <cctype>
+
+namespace soc_desc_v1
+{
+
+#define XML_CHAR_TO_CHAR(s) ((const char *)(s))
+
+#define BEGIN_ATTR_MATCH(attr) \
+    for(xmlAttr *a = attr; a; a = a->next) {
+
+#define MATCH_X_ATTR(attr_name, hook, ...) \
+    if(strcmp(XML_CHAR_TO_CHAR(a->name), attr_name) == 0) { \
+        std::string s; \
+        if(!parse_text_attr(a, s) || !hook(s, __VA_ARGS__)) \
+            return false; \
+    }
+
+#define SOFT_MATCH_X_ATTR(attr_name, hook, ...) \
+    if(strcmp(XML_CHAR_TO_CHAR(a->name), attr_name) == 0) { \
+        std::string s; \
+        if(parse_text_attr(a, s)) \
+            hook(s, __VA_ARGS__); \
+    }
+
+#define SOFT_MATCH_SCT_ATTR(attr_name, var) \
+    SOFT_MATCH_X_ATTR(attr_name, validate_sct_hook, var)
+
+#define MATCH_TEXT_ATTR(attr_name, var) \
+    MATCH_X_ATTR(attr_name, validate_string_hook, var)
+
+#define MATCH_UINT32_ATTR(attr_name, var) \
+    MATCH_X_ATTR(attr_name, validate_uint32_hook, var)
+
+#define MATCH_BITRANGE_ATTR(attr_name, first, last) \
+    MATCH_X_ATTR(attr_name, validate_bitrange_hook, first, last)
+
+#define END_ATTR_MATCH() \
+    }
+
+#define BEGIN_NODE_MATCH(node) \
+    for(xmlNode *sub = node; sub; sub = sub->next) {
+
+#define MATCH_ELEM_NODE(node_name, array, parse_fn) \
+    if(sub->type == XML_ELEMENT_NODE && strcmp(XML_CHAR_TO_CHAR(sub->name), node_name) == 0) { \
+        array.resize(array.size() + 1); \
+        if(!parse_fn(sub, array.back())) \
+            return false; \
+    }
+
+#define SOFT_MATCH_ELEM_NODE(node_name, array, parse_fn) \
+    if(sub->type == XML_ELEMENT_NODE && strcmp(XML_CHAR_TO_CHAR(sub->name), node_name) == 0) { \
+        array.resize(array.size() + 1); \
+        if(!parse_fn(sub, array.back())) \
+            array.pop_back(); \
+    }
+
+#define END_NODE_MATCH() \
+    }
+
+namespace
+{
+
+bool validate_string_hook(const std::string& str, std::string& s)
+{
+    s = str;
+    return true;
+}
+
+bool validate_sct_hook(const std::string& str, soc_reg_flags_t& flags)
+{
+    if(str == "yes") flags |= REG_HAS_SCT;
+    else if(str != "no") return false;
+    return true;
+}
+
+bool validate_unsigned_long_hook(const std::string& str, unsigned long& s)
+{
+    char *end;
+    s = strtoul(str.c_str(), &end, 0);
+    return *end == 0;
+}
+
+bool validate_uint32_hook(const std::string& str, uint32_t& s)
+{
+    unsigned long u;
+    if(!validate_unsigned_long_hook(str, u)) return false;
+#if ULONG_MAX > 0xffffffff
+    if(u > 0xffffffff) return false;
+#endif
+    s = u;
+    return true;
+}
+
+bool validate_bitrange_hook(const std::string& str, unsigned& first, unsigned& last)
+{
+    unsigned long a, b;
+    size_t sep = str.find(':');
+    if(sep == std::string::npos) return false;
+    if(!validate_unsigned_long_hook(str.substr(0, sep), a)) return false;
+    if(!validate_unsigned_long_hook(str.substr(sep + 1), b)) return false;
+    if(a > 31 || b > 31 || a < b) return false;
+    first = b;
+    last = a;
+    return true;
+}
+
+bool parse_text_attr(xmlAttr *attr, std::string& s)
+{
+    if(attr->children != attr->last)
+        return false;
+    if(attr->children->type != XML_TEXT_NODE)
+        return false;
+    s = XML_CHAR_TO_CHAR(attr->children->content);
+    return true;
+}
+
+bool parse_value_elem(xmlNode *node, soc_reg_field_value_t& value)
+{
+    BEGIN_ATTR_MATCH(node->properties)
+        MATCH_TEXT_ATTR("name", value.name)
+        MATCH_UINT32_ATTR("value", value.value)
+        MATCH_TEXT_ATTR("desc", value.desc)
+    END_ATTR_MATCH()
+
+    return true;
+}
+
+bool parse_field_elem(xmlNode *node, soc_reg_field_t& field)
+{
+    BEGIN_ATTR_MATCH(node->properties)
+        MATCH_TEXT_ATTR("name", field.name)
+        MATCH_BITRANGE_ATTR("bitrange", field.first_bit, field.last_bit)
+        MATCH_TEXT_ATTR("desc", field.desc)
+    END_ATTR_MATCH()
+
+    BEGIN_NODE_MATCH(node->children)
+        SOFT_MATCH_ELEM_NODE("value", field.value, parse_value_elem)
+    END_NODE_MATCH()
+
+    return true;
+}
+
+bool parse_reg_addr_elem(xmlNode *node, soc_reg_addr_t& addr)
+{
+    BEGIN_ATTR_MATCH(node->properties)
+        MATCH_TEXT_ATTR("name", addr.name)
+        MATCH_UINT32_ATTR("addr", addr.addr)
+    END_ATTR_MATCH()
+
+    return true;
+}
+
+bool parse_reg_formula_elem(xmlNode *node, soc_reg_formula_t& formula)
+{
+    BEGIN_ATTR_MATCH(node->properties)
+        MATCH_TEXT_ATTR("string", formula.string)
+    END_ATTR_MATCH()
+
+    formula.type = REG_FORMULA_STRING;
+
+    return true;
+}
+
+bool parse_add_trivial_addr(const std::string& str, soc_reg_t& reg)
+{
+    soc_reg_addr_t a;
+    a.name = reg.name;
+    if(!validate_uint32_hook(str, a.addr))
+        return false;
+    reg.addr.push_back(a);
+    return true;
+}
+
+bool parse_reg_elem(xmlNode *node, soc_reg_t& reg)
+{
+    std::list< soc_reg_formula_t > formulas;
+    BEGIN_ATTR_MATCH(node->properties)
+        MATCH_TEXT_ATTR("name", reg.name)
+        SOFT_MATCH_SCT_ATTR("sct", reg.flags)
+        SOFT_MATCH_X_ATTR("addr", parse_add_trivial_addr, reg)
+        MATCH_TEXT_ATTR("desc", reg.desc)
+    END_ATTR_MATCH()
+
+    BEGIN_NODE_MATCH(node->children)
+        MATCH_ELEM_NODE("addr", reg.addr, parse_reg_addr_elem)
+        MATCH_ELEM_NODE("formula", formulas, parse_reg_formula_elem)
+        MATCH_ELEM_NODE("field", reg.field, parse_field_elem)
+    END_NODE_MATCH()
+
+    if(formulas.size() > 1)
+    {
+        fprintf(stderr, "Only one formula is allowed per register\n");
+        return false;
+    }
+    if(formulas.size() == 1)
+        reg.formula = formulas.front();
+
+    return true;
+}
+
+bool parse_dev_addr_elem(xmlNode *node, soc_dev_addr_t& addr)
+{
+    BEGIN_ATTR_MATCH(node->properties)
+        MATCH_TEXT_ATTR("name", addr.name)
+        MATCH_UINT32_ATTR("addr", addr.addr)
+    END_ATTR_MATCH()
+
+    return true;
+}
+
+bool parse_dev_elem(xmlNode *node, soc_dev_t& dev)
+{
+    BEGIN_ATTR_MATCH(node->properties)
+        MATCH_TEXT_ATTR("name", dev.name)
+        MATCH_TEXT_ATTR("long_name", dev.long_name)
+        MATCH_TEXT_ATTR("desc", dev.desc)
+        MATCH_TEXT_ATTR("version", dev.version)
+    END_ATTR_MATCH()
+
+    BEGIN_NODE_MATCH(node->children)
+        MATCH_ELEM_NODE("addr", dev.addr, parse_dev_addr_elem)
+        MATCH_ELEM_NODE("reg", dev.reg, parse_reg_elem)
+    END_NODE_MATCH()
+
+    return true;
+}
+
+bool parse_soc_elem(xmlNode *node, soc_t& soc)
+{
+    BEGIN_ATTR_MATCH(node->properties)
+        MATCH_TEXT_ATTR("name", soc.name)
+        MATCH_TEXT_ATTR("desc", soc.desc)
+    END_ATTR_MATCH()
+
+    BEGIN_NODE_MATCH(node->children)
+        MATCH_ELEM_NODE("dev", soc.dev, parse_dev_elem)
+    END_NODE_MATCH()
+
+    return true;
+}
+
+bool parse_root_elem(xmlNode *node, soc_t& soc)
+{
+    std::vector< soc_t > socs;
+    BEGIN_NODE_MATCH(node)
+        MATCH_ELEM_NODE("soc", socs, parse_soc_elem)
+    END_NODE_MATCH()
+    if(socs.size() != 1)
+    {
+        fprintf(stderr, "A description file must contain exactly one soc element\n");
+        return false;
+    }
+    soc = socs[0];
+    return true;
+}
+
+}
+
+bool parse_xml(const std::string& filename, soc_t& socs)
+{
+    LIBXML_TEST_VERSION
+
+    xmlDocPtr doc = xmlReadFile(filename.c_str(), NULL, 0);
+    if(doc == NULL)
+        return false;
+
+    xmlNodePtr root_element = xmlDocGetRootElement(doc);
+    bool ret = parse_root_elem(root_element, socs);
+
+    xmlFreeDoc(doc);
+
+    return ret;
+}
+
+namespace
+{
+
+int produce_field(xmlTextWriterPtr writer, const soc_reg_field_t& field)
+{
+#define SAFE(x) if((x) < 0) return -1;
+    /* <field> */
+    SAFE(xmlTextWriterStartElement(writer, BAD_CAST "field"));
+    /* name */
+    SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "name", BAD_CAST field.name.c_str()));
+    /* desc */
+    SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "desc", BAD_CAST field.desc.c_str()));
+    /* bitrange */
+    SAFE(xmlTextWriterWriteFormatAttribute(writer, BAD_CAST "bitrange", "%d:%d",
+        field.last_bit, field.first_bit));
+    /* values */
+    for(size_t i = 0; i < field.value.size(); i++)
+    {
+        /* <value> */
+        SAFE(xmlTextWriterStartElement(writer, BAD_CAST "value"));
+        /* name */
+        SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "name", BAD_CAST field.value[i].name.c_str()));
+        /* value */
+        SAFE(xmlTextWriterWriteFormatAttribute(writer, BAD_CAST "value", "0x%x", field.value[i].value));
+        /* name */
+        SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "desc", BAD_CAST field.value[i].desc.c_str()));
+        /* </value> */
+        SAFE(xmlTextWriterEndElement(writer));
+    }
+    /* </field> */
+    SAFE(xmlTextWriterEndElement(writer));
+#undef SAFE
+    return 0;
+}
+
+int produce_reg(xmlTextWriterPtr writer, const soc_reg_t& reg)
+{
+#define SAFE(x) if((x) < 0) return -1;
+    /* <reg> */
+    SAFE(xmlTextWriterStartElement(writer, BAD_CAST "reg"));
+    /* name */
+    SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "name", BAD_CAST reg.name.c_str()));
+    /* name */
+    SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "desc", BAD_CAST reg.desc.c_str()));
+    /* flags */
+    if(reg.flags & REG_HAS_SCT)
+        SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "sct", BAD_CAST "yes"));
+    /* formula */
+    if(reg.formula.type != REG_FORMULA_NONE)
+    {
+        /* <formula> */
+        SAFE(xmlTextWriterStartElement(writer, BAD_CAST "formula"));
+        switch(reg.formula.type)
+        {
+            case REG_FORMULA_STRING:
+                SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "string", 
+                    BAD_CAST reg.formula.string.c_str()));
+                break;
+            default:
+                break;
+        }
+        /* </formula> */
+        SAFE(xmlTextWriterEndElement(writer));
+    }
+    /* addresses */
+    for(size_t i = 0; i < reg.addr.size(); i++)
+    {
+        /* <addr> */
+        SAFE(xmlTextWriterStartElement(writer, BAD_CAST "addr"));
+        /* name */
+        SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "name", BAD_CAST reg.addr[i].name.c_str()));
+        /* addr */
+        SAFE(xmlTextWriterWriteFormatAttribute(writer, BAD_CAST "addr", "0x%x", reg.addr[i].addr));
+        /* </addr> */
+        SAFE(xmlTextWriterEndElement(writer));
+    }
+    /* fields */
+    for(size_t i = 0; i < reg.field.size(); i++)
+        produce_field(writer, reg.field[i]);
+    /* </reg> */
+    SAFE(xmlTextWriterEndElement(writer));
+#undef SAFE
+    return 0;
+}
+
+int produce_dev(xmlTextWriterPtr writer, const soc_dev_t& dev)
+{
+#define SAFE(x) if((x) < 0) return -1;
+    /* <dev> */
+    SAFE(xmlTextWriterStartElement(writer, BAD_CAST "dev"));
+    /* name */
+    SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "name", BAD_CAST dev.name.c_str()));
+    /* long_name */
+    SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "long_name", BAD_CAST dev.long_name.c_str()));
+    /* desc */
+    SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "desc", BAD_CAST dev.desc.c_str()));
+    /* version */
+    SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "version", BAD_CAST dev.version.c_str()));
+    /* addresses */
+    for(size_t i = 0; i < dev.addr.size(); i++)
+    {
+        /* <addr> */
+        SAFE(xmlTextWriterStartElement(writer, BAD_CAST "addr"));
+        /* name */
+        SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "name", BAD_CAST dev.addr[i].name.c_str()));
+        /* addr */
+        SAFE(xmlTextWriterWriteFormatAttribute(writer, BAD_CAST "addr", "0x%x", dev.addr[i].addr));
+        /* </addr> */
+        SAFE(xmlTextWriterEndElement(writer));
+    }
+    /* registers */
+    for(size_t i = 0; i < dev.reg.size(); i++)
+        produce_reg(writer, dev.reg[i]);
+    /* </dev> */
+    SAFE(xmlTextWriterEndElement(writer));
+#undef SAFE
+    return 0;
+}
+
+}
+
+bool produce_xml(const std::string& filename, const soc_t& soc)
+{
+    LIBXML_TEST_VERSION
+
+    xmlTextWriterPtr writer = xmlNewTextWriterFilename(filename.c_str(), 0);
+    if(writer == NULL)
+        return false;
+#define SAFE(x) if((x) < 0) goto  Lerr
+    SAFE(xmlTextWriterSetIndent(writer, 1));
+    SAFE(xmlTextWriterSetIndentString(writer, BAD_CAST "  "));
+    /* <xml> */
+    SAFE(xmlTextWriterStartDocument(writer, NULL, NULL, NULL));
+    /* <soc> */
+    SAFE(xmlTextWriterStartElement(writer, BAD_CAST "soc"));
+    /* name */
+    SAFE(xmlTextWriterWriteAttribute(writer, BAD_CAST "name", BAD_CAST soc.name.c_str()));
+    /* desc */
+    SAFE(xmlTextWriterWriteAttribute(writer,  BAD_CAST "desc", BAD_CAST soc.desc.c_str()));
+    /* devices */
+    for(size_t i = 0; i < soc.dev.size(); i++)
+        SAFE(produce_dev(writer, soc.dev[i]));
+    /* end <soc> */
+    SAFE(xmlTextWriterEndElement(writer));
+    /* </xml> */
+    SAFE(xmlTextWriterEndDocument(writer));
+    xmlFreeTextWriter(writer);
+    return true;
+#undef SAFE
+Lerr:
+    xmlFreeTextWriter(writer);
+    return false;
+}
+
+namespace
+{
+
+struct soc_sorter
+{
+    bool operator()(const soc_dev_t& a, const soc_dev_t& b) const
+    {
+        return a.name < b.name;
+    }
+
+    bool operator()(const soc_dev_addr_t& a, const soc_dev_addr_t& b) const
+    {
+        return a.name < b.name;
+    }
+
+    bool operator()(const soc_reg_t& a, const soc_reg_t& b) const
+    {
+        soc_addr_t aa = a.addr.size() > 0 ? a.addr[0].addr : 0;
+        soc_addr_t ab = b.addr.size() > 0 ? b.addr[0].addr : 0;
+        return aa < ab;
+    }
+
+    bool operator()(const soc_reg_addr_t& a, const soc_reg_addr_t& b) const
+    {
+        return a.addr < b.addr;
+    }
+
+    bool operator()(const soc_reg_field_t& a, const soc_reg_field_t& b) const
+    {
+        return a.last_bit > b.last_bit;
+    }
+
+    bool operator()(const soc_reg_field_value_t a, const soc_reg_field_value_t& b) const
+    {
+        return a.value < b.value;
+    }
+};
+
+void normalize(soc_reg_field_t& field)
+{
+    std::sort(field.value.begin(), field.value.end(), soc_sorter());
+}
+
+void normalize(soc_reg_t& reg)
+{
+    std::sort(reg.addr.begin(), reg.addr.end(), soc_sorter());
+    std::sort(reg.field.begin(), reg.field.end(), soc_sorter());
+    for(size_t i = 0; i < reg.field.size(); i++)
+        normalize(reg.field[i]);
+}
+
+void normalize(soc_dev_t& dev)
+{
+    std::sort(dev.addr.begin(), dev.addr.end(), soc_sorter());
+    std::sort(dev.reg.begin(), dev.reg.end(), soc_sorter());
+    for(size_t i = 0; i < dev.reg.size(); i++)
+        normalize(dev.reg[i]);
+}
+
+}
+
+void normalize(soc_t& soc)
+{
+    std::sort(soc.dev.begin(), soc.dev.end(), soc_sorter());
+    for(size_t i = 0; i < soc.dev.size(); i++)
+        normalize(soc.dev[i]);
+}
+
+namespace
+{
+    soc_error_t make_error(soc_error_level_t lvl, std::string at, std::string what)
+    {
+        soc_error_t err;
+        err.level = lvl;
+        err.location = at;
+        err.message = what;
+        return err;
+    }
+
+    soc_error_t make_warning(std::string at, std::string what)
+    {
+        return make_error(SOC_ERROR_WARNING, at, what);
+    }
+
+    soc_error_t make_fatal(std::string at, std::string what)
+    {
+        return make_error(SOC_ERROR_FATAL, at, what);
+    }
+
+    soc_error_t prefix(soc_error_t err, const std::string& prefix_at)
+    {
+        err.location = prefix_at + "." + err.location;
+        return err;
+    }
+
+    void add_errors(std::vector< soc_error_t >& errors,
+        const std::vector< soc_error_t >& new_errors, const std::string& prefix_at)
+    {
+        for(size_t i = 0; i < new_errors.size(); i++)
+            errors.push_back(prefix(new_errors[i], prefix_at));
+    }
+
+    std::vector< soc_error_t > no_error()
+    {
+        std::vector< soc_error_t > s;
+        return s;
+    }
+
+    std::vector< soc_error_t > one_error(const soc_error_t& err)
+    {
+        std::vector< soc_error_t > s;
+        s.push_back(err);
+        return s;
+    }
+
+    bool name_valid(char c)
+    {
+        return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') ||
+            (c >= 'A' && c <= 'Z') || c == '_';
+    }
+
+    bool name_valid(const std::string& s)
+    {
+        for(size_t i = 0; i < s.size(); i++)
+            if(!name_valid(s[i]))
+                return false;
+        return true;
+    }
+}
+
+std::vector< soc_error_t > soc_reg_field_value_t::errors(bool recursive)
+{
+    (void) recursive;
+    if(name.size() == 0)
+        return one_error(make_fatal(name, "empty name"));
+    else if(!name_valid(name))
+        return one_error(make_fatal(name, "invalid name"));
+    else
+        return no_error();
+}
+
+std::vector< soc_error_t > soc_reg_field_t::errors(bool recursive)
+{
+    std::vector< soc_error_t >  err;
+    std::string at(name);
+    if(name.size() == 0)
+        err.push_back(make_fatal(at, "empty name"));
+    else if(!name_valid(name))
+        err.push_back(make_fatal(at, "invalid name"));
+    if(last_bit > 31)
+        err.push_back(make_fatal(at, "last bit is greater than 31"));
+    if(first_bit > last_bit)
+        err.push_back(make_fatal(at, "last bit is greater than first bit"));
+    for(size_t i = 0; i < value.size(); i++)
+    {
+        for(size_t j = 0; j < value.size(); j++)
+        {
+            if(i == j)
+                continue;
+            if(value[i].name == value[j].name)
+                err.push_back(prefix(make_fatal(value[i].name, 
+                    "there are several values with the same name"), at));
+            if(value[i].value == value[j].value)
+                err.push_back(prefix(make_warning(value[i].name, 
+                    "there are several values with the same value"), at));
+        }
+        if(value[i].value > (bitmask() >> first_bit))
+            err.push_back(prefix(make_warning(at, "value doesn't fit into the field"), value[i].name));
+        if(recursive)
+            add_errors(err, value[i].errors(true), at);
+    }
+    return err;
+}
+
+std::vector< soc_error_t > soc_reg_addr_t::errors(bool recursive)
+{
+    (void) recursive;
+    if(name.size() == 0)
+        return one_error(make_fatal("", "empty name"));
+    else if(!name_valid(name))
+        return one_error(make_fatal(name, "invalid name"));
+    else
+        return no_error();
+}
+
+std::vector< soc_error_t > soc_reg_formula_t::errors(bool recursive)
+{
+    (void) recursive;
+    if(type == REG_FORMULA_STRING && string.size() == 0)
+        return one_error(make_fatal("", "empty string formula"));
+    else
+        return no_error();
+}
+
+namespace
+{
+
+bool field_overlap(const soc_reg_field_t& a, const soc_reg_field_t& b)
+{
+    return !(a.first_bit > b.last_bit || b.first_bit > a.last_bit);
+}
+
+}
+
+std::vector< soc_error_t > soc_reg_t::errors(bool recursive)
+{
+    std::vector< soc_error_t >  err;
+    std::string at(name);
+    if(name.size() == 0)
+        err.push_back(make_fatal(at, "empty name"));
+    else if(!name_valid(name))
+        err.push_back(make_fatal(at, "invalid name"));
+    for(size_t i = 0; i < addr.size(); i++)
+    {
+        for(size_t j = 0; j < addr.size(); j++)
+        {
+            if(i == j)
+                continue;
+            if(addr[i].name == addr[j].name)
+                err.push_back(prefix(make_fatal(addr[i].name, 
+                    "there are several instances with the same name"), at));
+            if(addr[i].addr == addr[j].addr)
+                err.push_back(prefix(make_fatal(addr[i].name, 
+                    "there are several instances with the same address"), at));
+        }
+        if(recursive)
+            add_errors(err, addr[i].errors(true), at);
+    }
+    if(recursive)
+        add_errors(err, formula.errors(true), at);
+    for(size_t i = 0; i < field.size(); i++)
+    {
+        for(size_t j = 0; j < field.size(); j++)
+        {
+            if(i == j)
+                continue;
+            if(field[i].name == field[j].name)
+                err.push_back(prefix(make_fatal(field[i].name, 
+                    "there are several fields with the same name"), at));
+            if(field_overlap(field[i], field[j]))
+                err.push_back(prefix(make_fatal(field[i].name, 
+                    "there are overlapping fields"), at));
+        }
+        if(recursive)
+            add_errors(err, field[i].errors(true), at);
+    }
+    return err;
+}
+
+std::vector< soc_error_t > soc_dev_addr_t::errors(bool recursive)
+{
+    (void) recursive;
+    if(name.size() == 0)
+        return one_error(make_fatal("", "empty name"));
+    else if(!name_valid(name))
+        return one_error(make_fatal(name, "invalid name"));
+    else
+        return no_error();
+}
+
+std::vector< soc_error_t > soc_dev_t::errors(bool recursive)
+{
+    std::vector< soc_error_t >  err;
+    std::string at(name);
+    if(name.size() == 0)
+        err.push_back(make_fatal(at, "empty name"));
+    else if(!name_valid(name))
+        err.push_back(make_fatal(at, "invalid name"));
+    for(size_t i = 0; i < addr.size(); i++)
+    {
+        for(size_t j = 0; j < addr.size(); j++)
+        {
+            if(i == j)
+                continue;
+            if(addr[i].name == addr[j].name)
+                err.push_back(prefix(make_fatal(addr[i].name, 
+                    "there are several instances with the same name"), at));
+            if(addr[i].addr == addr[j].addr)
+                err.push_back(prefix(make_fatal(addr[i].name, 
+                    "there are several instances with the same address"), at));
+        }
+        if(recursive)
+            add_errors(err, addr[i].errors(true), at);
+    }
+    for(size_t i = 0; i < reg.size(); i++)
+    {
+        for(size_t j = 0; j < reg.size(); j++)
+        {
+            if(i == j)
+                continue;
+            if(reg[i].name == reg[j].name)
+                err.push_back(prefix(make_fatal(reg[i].name, 
+                    "there are several registers with the same name"), at));
+        }
+        if(recursive)
+            add_errors(err, reg[i].errors(true), at);
+    }
+    return err;
+}
+
+std::vector< soc_error_t > soc_t::errors(bool recursive)
+{
+    std::vector< soc_error_t >  err;
+    std::string at(name);
+    for(size_t i = 0; i < dev.size(); i++)
+    {
+        for(size_t j = 0; j < dev.size(); j++)
+        {
+            if(i == j)
+                continue;
+            if(dev[i].name == dev[j].name)
+                err.push_back(prefix(make_fatal(dev[i].name, 
+                    "there are several devices with the same name"), at));
+        }
+        if(recursive)
+            add_errors(err, dev[i].errors(true), at);
+    }
+    return err;
+}
+
+namespace
+{
+
+struct formula_evaluator
+{
+    std::string formula;
+    size_t pos;
+    std::string error;
+
+    bool err(const char *fmt, ...)
+    {
+        char buffer[256];
+        va_list args;
+        va_start(args, fmt);
+        vsnprintf(buffer,sizeof(buffer), fmt, args);
+        va_end(args);
+        error = buffer;
+        return false;
+    }
+
+    formula_evaluator(const std::string& s):pos(0)
+    {
+        for(size_t i = 0; i < s.size(); i++)
+            if(!isspace(s[i]))
+                formula.push_back(s[i]);
+    }
+
+    void adv()
+    {
+        pos++;
+    }
+
+    char cur()
+    {
+        return end() ? 0 : formula[pos];
+    }
+
+    bool end()
+    {
+        return pos >= formula.size();
+    }
+
+    bool parse_digit(char c, int basis, soc_word_t& res)
+    {
+        c = tolower(c);
+        if(isdigit(c))
+        {
+            res = c - '0';
+            return true;
+        }
+        if(basis == 16 && isxdigit(c))
+        {
+            res = c + 10 - 'a';
+            return true;
+        }
+        return err("invalid digit '%c'", c);
+    }
+
+    bool parse_signed(soc_word_t& res)
+    {
+        char op = cur();
+        if(op == '+' || op == '-')
+        {
+            adv();
+            if(!parse_signed(res))
+                return false;
+            if(op == '-')
+                res *= -1;
+            return true;
+        }
+        else if(op == '(')
+        {
+            adv();
+            if(!parse_expression(res))
+                return false;
+            if(cur() != ')')
+                return err("expected ')', got '%c'", cur());
+            adv();
+            return true;
+        }
+        else if(isdigit(op))
+        {
+            res = op - '0';
+            adv();
+            int basis = 10;
+            if(op == '0' && cur() == 'x')
+            {
+                basis = 16;
+                adv();
+            }
+            soc_word_t digit = 0;
+            while(parse_digit(cur(), basis, digit))
+            {
+                res = res * basis + digit;
+                adv();
+            }
+            return true;
+        }
+        else if(isalpha(op) || op == '_')
+        {
+            std::string name;
+            while(isalnum(cur()) || cur() == '_')
+            {
+                name.push_back(cur());
+                adv();
+            }
+            return get_variable(name, res);
+        }
+        else
+            return err("express signed expression, got '%c'", op);
+    }
+
+    bool parse_term(soc_word_t& res)
+    {
+        if(!parse_signed(res))
+            return false;
+        while(cur() == '*' || cur() == '/' || cur() == '%')
+        {
+            char op = cur();
+            adv();
+            soc_word_t tmp;
+            if(!parse_signed(tmp))
+                return false;
+            if(op == '*')
+                res *= tmp;
+            else if(tmp != 0)
+                res = op == '/' ? res / tmp : res % tmp;
+            else
+                return err("division by 0");
+        }
+        return true;
+    }
+
+    bool parse_expression(soc_word_t& res)
+    {
+        if(!parse_term(res))
+            return false;
+        while(!end() && (cur() == '+' || cur() == '-'))
+        {
+            char op = cur();
+            adv();
+            soc_word_t tmp;
+            if(!parse_term(tmp))
+                return false;
+            if(op == '+')
+                res += tmp;
+            else
+                res -= tmp;
+        }
+        return true;
+    }
+
+    bool parse(soc_word_t& res, std::string& _error)
+    {
+        bool ok = parse_expression(res);
+        if(ok && !end())
+            err("unexpected character '%c'", cur());
+        _error = error;
+        return ok && end();
+    }
+
+    virtual bool get_variable(std::string name, soc_word_t& res)
+    {
+        return err("unknown variable '%s'", name.c_str());
+    }
+};
+
+struct my_evaluator : public formula_evaluator
+{
+    const std::map< std::string, soc_word_t>& var;
+
+    my_evaluator(const std::string& formula, const std::map< std::string, soc_word_t>& _var)
+        :formula_evaluator(formula), var(_var) {}
+
+    virtual bool get_variable(std::string name, soc_word_t& res)
+    {
+        std::map< std::string, soc_word_t>::const_iterator it = var.find(name);
+        if(it == var.end())
+            return formula_evaluator::get_variable(name, res);
+        else
+        {
+            res = it->second;
+            return true;
+        }
+    }
+};
+
+}
+
+bool evaluate_formula(const std::string& formula,
+    const std::map< std::string, soc_word_t>& var, soc_word_t& result, std::string& error)
+{
+    my_evaluator e(formula, var);
+    return e.parse(result, error);
+}
+
+/** WARNING we need to call xmlInitParser() to init libxml2 but it needs to
+ * called from the main thread, which is a super strong requirement, so do it
+ * using a static constructor */
+namespace
+{
+class xml_parser_init
+{
+public:
+    xml_parser_init()
+    {
+        xmlInitParser();
+    }
+};
+
+xml_parser_init __xml_parser_init;
+}
+
+} // soc_desc_v1
diff --git a/utils/regtools/qeditor/backend.cpp b/utils/regtools/qeditor/backend.cpp
index 7091a0c77f..cbaff7370d 100644
--- a/utils/regtools/qeditor/backend.cpp
+++ b/utils/regtools/qeditor/backend.cpp
@@ -35,8 +35,8 @@ SocFile::SocFile()
 SocFile::SocFile(const QString& filename)
     :m_filename(filename)
 {
-    m_valid = soc_desc_parse_xml(filename.toStdString(), m_soc);
-    soc_desc_normalize(m_soc);
+    m_valid = parse_xml(filename.toStdString(), m_soc);
+    normalize(m_soc);
 }
 
 bool SocFile::IsValid()
diff --git a/utils/regtools/qeditor/backend.h b/utils/regtools/qeditor/backend.h
index b2f53c9ed5..934c1c359b 100644
--- a/utils/regtools/qeditor/backend.h
+++ b/utils/regtools/qeditor/backend.h
@@ -29,7 +29,11 @@
 #ifdef HAVE_HWSTUB
 #include "hwstub.h"
 #endif
-#include "soc_desc.hpp"
+#include "soc_desc_v1.hpp"
+
+/* we don't want to import the entire soc_desc except for a few selected
+ * pieces */
+using namespace soc_desc_v1;
 
 class IoBackend : public QObject
 {
diff --git a/utils/regtools/qeditor/mainwindow.cpp b/utils/regtools/qeditor/mainwindow.cpp
index 9cea728d6e..b44306d701 100644
--- a/utils/regtools/qeditor/mainwindow.cpp
+++ b/utils/regtools/qeditor/mainwindow.cpp
@@ -161,12 +161,14 @@ void MainWindow::OnQuit()
 
 void MainWindow::OnAbout()
 {
+    QString soc_desc_ver = QString("%1.%2.%3").arg(MAJOR_VERSION)
+        .arg(MINOR_VERSION).arg(REVISION_VERSION);
     QMessageBox::about(this, "About", 
         "<h1>QEditor</h1>"
         "<h2>Version "APP_VERSION"</h2>"
         "<p>Written by Amaury Pouly</p>"
         "<p>Libraries:</p>"
-        "<ul><li>soc_desc: "SOCDESC_VERSION"</li>"
+        "<ul><li>soc_desc: " + soc_desc_ver + "</li>"
 #ifdef HAVE_HWSTUB
         "<li>hwstub: "HWSTUB_VERSION"</li>"
 #else
diff --git a/utils/regtools/qeditor/qeditor.pro b/utils/regtools/qeditor/qeditor.pro
index eecc0aba3f..265cc93171 100644
--- a/utils/regtools/qeditor/qeditor.pro
+++ b/utils/regtools/qeditor/qeditor.pro
@@ -5,14 +5,14 @@ HEADERS += mainwindow.h backend.h regtab.h analyser.h settings.h \
 SOURCES += main.cpp mainwindow.cpp regtab.cpp backend.cpp analyser.cpp \
     std_analysers.cpp settings.cpp utils.cpp regdisplaypanel.cpp regedit.cpp
 LIBS += -L../lib/ -lsocdesc -lxml2
-INCLUDEPATH += ../lib/ ../../hwstub/lib
+INCLUDEPATH += ../include/ ../../hwstub/lib
 DEPENDPATH += ../
 
 libsocdesc.commands = cd ../lib && make
 QMAKE_EXTRA_TARGETS += libsocdesc
 PRE_TARGETDEPS += libsocdesc
 
-VERSION = 2.0.4
+VERSION = 2.1.0
 
 DEFINES += APP_VERSION=\\\"$$VERSION\\\"
 
diff --git a/utils/regtools/qeditor/regedit.cpp b/utils/regtools/qeditor/regedit.cpp
index 851e054eb0..8b4bfb7c49 100644
--- a/utils/regtools/qeditor/regedit.cpp
+++ b/utils/regtools/qeditor/regedit.cpp
@@ -421,7 +421,7 @@ void RegEditPanel::OnFormulaGenerate(bool checked)
         map["n"] = n;
         std::string err;
         soc_word_t res;
-        if(!soc_desc_evaluate_formula(formula, map, res, err))
+        if(!evaluate_formula(formula, map, res, err))
         {
             qDebug() << "Cannot evaluator " << QString::fromStdString(formula) 
                 << "for n=" << n << ": " << QString::fromStdString(err);
@@ -1051,8 +1051,8 @@ void RegEdit::OnNew()
 
 bool RegEdit::SaveSocFile(const QString& filename)
 {
-    soc_desc_normalize(m_cur_socfile.GetSoc());
-    if(!soc_desc_produce_xml(filename.toStdString(), m_cur_socfile.GetSoc()))
+    normalize(m_cur_socfile.GetSoc());
+    if(!produce_xml(filename.toStdString(), m_cur_socfile.GetSoc()))
     {
         QMessageBox::warning(this, "The description was not saved",
             "There was an error when saving the file");
diff --git a/utils/regtools/qeditor/utils.cpp b/utils/regtools/qeditor/utils.cpp
index e4a872ed49..2ee1bc6db5 100644
--- a/utils/regtools/qeditor/utils.cpp
+++ b/utils/regtools/qeditor/utils.cpp
@@ -1004,7 +1004,7 @@ void MyTextEditor::SetReadOnly(bool en)
     if(en)
         m_toolbar->hide();
     else
-        m_toolbar->hide();
+        m_toolbar->show();
     m_edit->setReadOnly(en);
 }
 
diff --git a/utils/regtools/swiss_knife.cpp b/utils/regtools/swiss_knife.cpp
new file mode 100644
index 0000000000..eaa2519a27
--- /dev/null
+++ b/utils/regtools/swiss_knife.cpp
@@ -0,0 +1,612 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id$
+ *
+ * Copyright (C) 2014 by Amaury Pouly
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+#include "soc_desc.hpp"
+#include "soc_desc_v1.hpp"
+#include <stdio.h>
+#include <stdlib.h>
+#include <map>
+#include <set>
+#include <cstring>
+
+using namespace soc_desc;
+
+void print_context(const error_context_t& ctx)
+{
+    for(size_t j = 0; j < ctx.count(); j++)
+    {
+        error_t e = ctx.get(j);
+        switch(e.level())
+        {
+            case error_t::INFO: printf("[INFO]"); break;
+            case error_t::WARNING: printf("[WARN]"); break;
+            case error_t::FATAL: printf("[FATAL]"); break;
+            default: printf("[UNK]"); break;
+        }
+        if(e.location().size() != 0)
+            printf(" %s:", e.location().c_str());
+        printf(" %s\n", e.message().c_str());
+    }
+}
+
+bool convert_v1_to_v2(const soc_desc_v1::soc_reg_field_value_t& in, enum_t& out, error_context_t& ctx)
+{
+    out.name = in.name;
+    out.desc = in.desc;
+    out.value = in.value;
+    return true;
+}
+
+bool convert_v1_to_v2(const soc_desc_v1::soc_reg_field_t& in, field_t& out, error_context_t& ctx)
+{
+    out.name = in.name;
+    out.desc = in.desc;
+    out.pos = in.first_bit;
+    out.width = in.last_bit - in.first_bit + 1;
+    out.enum_.resize(in.value.size());
+    for(size_t i = 0; i < in.value.size(); i++)
+            if(!convert_v1_to_v2(in.value[i], out.enum_[i], ctx))
+                return false;
+    return true;
+}
+
+bool convert_v1_to_v2(const soc_desc_v1::soc_reg_addr_t& in, instance_t& out, error_context_t& ctx)
+{
+    out.name = in.name;
+    out.type = instance_t::SINGLE;
+    out.addr = in.addr;
+    return true;
+}
+
+bool convert_v1_to_v2(const soc_desc_v1::soc_reg_formula_t& in, range_t& out, error_context_t& ctx)
+{
+    out.type = range_t::FORMULA;
+    out.formula = in.string;
+    out.variable = "n";
+    return true;
+}
+
+bool convert_v1_to_v2(const soc_desc_v1::soc_reg_t& in, node_t& out, error_context_t& ctx,
+    std::string _loc)
+{
+    std::string loc = _loc + "." + in.name;
+    out.name = in.name;
+    out.desc = in.desc;
+    if(in.formula.type == soc_desc_v1::REG_FORMULA_NONE)
+    {
+        out.instance.resize(in.addr.size());
+        for(size_t i = 0; i < in.addr.size(); i++)
+            if(!convert_v1_to_v2(in.addr[i], out.instance[i], ctx))
+                return false;
+    }
+    else
+    {
+        out.instance.resize(1);
+        out.instance[0].name = in.name;
+        out.instance[0].type = instance_t::RANGE;
+        out.instance[0].range.first = 0;
+        out.instance[0].range.count = in.addr.size();
+        /* check if formula is base/stride */
+        bool is_stride = true;
+        soc_word_t base = 0, stride = 0;
+        if(in.addr.size() <= 1)
+        {
+            ctx.add(error_t(error_t::WARNING, loc,
+                "register uses a formula but has only one instance"));
+            is_stride = false;
+        }
+        else
+        {
+            base = in.addr[0].addr;
+            stride = in.addr[1].addr - base;
+            for(size_t i = 0; i < in.addr.size(); i++)
+                if(base + i * stride != in.addr[i].addr)
+                    is_stride = false;
+        }
+
+        if(is_stride)
+        {
+            ctx.add(error_t(error_t::INFO, loc, "promoted formula to base/stride"));
+            out.instance[0].range.type = range_t::STRIDE;
+            out.instance[0].range.base = base;
+            out.instance[0].range.stride = stride;
+        }
+        else if(!convert_v1_to_v2(in.formula, out.instance[0].range, ctx))
+            return false;
+    }
+    out.register_.resize(1);
+    out.register_[0].width = 32;
+    out.register_[0].field.resize(in.field.size());
+    for(size_t i = 0; i < in.field.size(); i++)
+        if(!convert_v1_to_v2(in.field[i], out.register_[0].field[i], ctx))
+            return false;
+    /* sct */
+    if(in.flags & soc_desc_v1::REG_HAS_SCT)
+    {
+        out.node.resize(1);
+        out.node[0].name = "SCT";
+        out.node[0].instance.resize(3);
+        const char *names[3] = {"SET", "CLR", "TOG"};
+        for(size_t i = 0; i < 3; i++)
+        {
+            out.node[0].instance[i].name = names[i];
+            out.node[0].instance[i].type = instance_t::SINGLE;
+            out.node[0].instance[i].addr = 4 + i *4;
+        }
+    }
+    return true;
+}
+
+bool convert_v1_to_v2(const soc_desc_v1::soc_dev_addr_t& in, instance_t& out, error_context_t& ctx)
+{
+    out.name = in.name;
+    out.type = instance_t::SINGLE;
+    out.addr = in.addr;
+    return true;
+}
+
+bool convert_v1_to_v2(const soc_desc_v1::soc_dev_t& in, node_t& out, error_context_t& ctx,
+    std::string _loc)
+{
+    std::string loc = _loc + "." + in.name;
+    if(!in.version.empty())
+        ctx.add(error_t(error_t::INFO, loc, "dropped version"));
+    out.name = in.name;
+    out.title = in.long_name;
+    out.desc = in.desc;
+    out.instance.resize(in.addr.size());
+    for(size_t i = 0; i < in.addr.size(); i++)
+        if(!convert_v1_to_v2(in.addr[i], out.instance[i], ctx))
+            return false;
+    out.node.resize(in.reg.size());
+    for(size_t i = 0; i < in.reg.size(); i++)
+        if(!convert_v1_to_v2(in.reg[i], out.node[i], ctx, loc))
+            return false;
+    return true;
+}
+
+bool convert_v1_to_v2(const soc_desc_v1::soc_t& in, soc_t& out, error_context_t& ctx)
+{
+    out.name = in.name;
+    out.title = in.desc;
+    out.node.resize(in.dev.size());
+    for(size_t i = 0; i < in.dev.size(); i++)
+        if(!convert_v1_to_v2(in.dev[i], out.node[i], ctx, in.name))
+            return false;
+    return true;
+}
+
+int do_convert(int argc, char **argv)
+{
+    if(argc != 2)
+        return printf("convert mode expects two arguments\n");
+    soc_desc_v1::soc_t soc;
+    if(!soc_desc_v1::parse_xml(argv[0], soc))
+        return printf("cannot read file '%s'\n", argv[0]);
+    error_context_t ctx;
+    soc_t new_soc;
+    if(!convert_v1_to_v2(soc, new_soc, ctx))
+    {
+        print_context(ctx);
+        return printf("cannot convert from v1 to v2\n");
+    }
+    if(!produce_xml(argv[1], new_soc, ctx))
+    {
+        print_context(ctx);
+        return printf("cannot write file '%s'\n", argv[1]);
+    }
+    print_context(ctx);
+    return 0;
+}
+
+int do_read(int argc, char **argv)
+{
+    for(int i = 0; i < argc; i++)
+    {
+        error_context_t ctx;
+        soc_t soc;
+        bool ret = parse_xml(argv[i], soc, ctx);
+        if(ctx.count() != 0)
+            printf("In file %s:\n", argv[i]);
+        print_context(ctx);
+        if(!ret)
+        {
+            printf("cannot parse file '%s'\n", argv[i]);
+            continue;
+        }
+    }
+    return 0;
+}
+
+int do_eval(int argc, char **argv)
+{
+    std::map< std::string, soc_word_t > map;
+    for(int i = 0; i < argc; i++)
+    {
+        std::string formula(argv[i]);
+        soc_word_t result;
+        if(strcmp(argv[i], "--var") == 0)
+        {
+            if(i + 1 >= argc)
+                break;
+            i++;
+            std::string str(argv[i]);
+            size_t pos = str.find('=');
+            if(pos == std::string::npos)
+            {
+                printf("invalid variable string '%s'\n", str.c_str());
+                continue;
+            }
+            std::string name = str.substr(0, pos);
+            std::string val = str.substr(pos + 1);
+            char *end;
+            soc_word_t v = strtoul(val.c_str(), &end, 0);
+            if(*end)
+            {
+                printf("invalid variable string '%s'\n", str.c_str());
+                continue;
+            }
+            printf("%s = %#lx\n", name.c_str(), (unsigned long)v);
+            map[name] = v;
+            continue;
+        }
+        error_context_t ctx;
+        if(!evaluate_formula(formula, map, result, "", ctx))
+        {
+            print_context(ctx);
+            printf("cannot parse '%s'\n", formula.c_str());
+        }
+        else
+            printf("result: %lu (%#lx)\n", (unsigned long)result, (unsigned long)result);
+    }
+    return 0;
+}
+
+int do_write(int argc, char **argv)
+{
+    if(argc != 2)
+        return printf("write mode expects two arguments\n");
+    soc_t soc;
+    error_context_t ctx;
+    if(!parse_xml(argv[0], soc, ctx))
+    {
+        print_context(ctx);
+        return printf("cannot read file '%s'\n", argv[0]);
+    }
+    if(!produce_xml(argv[1], soc, ctx))
+    {
+        print_context(ctx);
+        return printf("cannot write file '%s'\n", argv[1]);
+    }
+    print_context(ctx);
+    return 0;
+}
+
+void check_name(const std::string& path, const std::string& name, error_context_t& ctx)
+{
+    if(name.empty())
+        ctx.add(error_t(error_t::FATAL, path, "name is empty"));
+    for(size_t i = 0; i < name.size(); i++)
+        if(!isalnum(name[i]) && name[i] != '_')
+            ctx.add(error_t(error_t::FATAL, path, "name '" + name +
+                "' must only contain alphanumeric characters or '_'"));
+}
+
+void check_instance(const std::string& _path, const instance_t& inst, error_context_t& ctx)
+{
+    std::string path = _path + "." + inst.name;
+    check_name(path, inst.name, ctx);
+    if(inst.type == instance_t::RANGE)
+    {
+        if(inst.range.type == range_t::FORMULA)
+        {
+            check_name(path + ".<formula variable>", inst.range.variable, ctx);
+            /* try to parse formula */
+            std::map< std::string, soc_word_t> var;
+            var[inst.range.variable] = inst.range.first;
+            soc_word_t res;
+            if(!evaluate_formula(inst.range.formula, var, res, path + ".<formula>", ctx))
+                ctx.add(error_t(error_t::FATAL, path + ".<formula>",
+                    "cannot evaluate formula"));
+        }
+    }
+}
+
+void check_field(const std::string& _path, const field_t& field, error_context_t& ctx)
+{
+    std::string path = _path + "." + field.name;
+    check_name(path, field.name, ctx);
+    if(field.width == 0)
+        ctx.add(error_t(error_t::WARNING, path, "field has width 0"));
+    soc_word_t max = field.bitmask() >> field.pos;
+    std::set< std::string > names;
+    std::map< soc_word_t, std::string > map;
+    for(size_t i = 0; i < field.enum_.size(); i++)
+    {
+        soc_word_t v = field.enum_[i].value;
+        std::string n = field.enum_[i].name;
+        std::string path_ = path + "." + n;
+        check_name(path_, n, ctx);
+        if(v > max)
+            ctx.add(error_t(error_t::FATAL, path_, "value does not fit into the field"));
+        if(names.find(n) != names.end())
+            ctx.add(error_t(error_t::FATAL, path, "duplicate name '" + n + "' in enums"));
+        names.insert(n);
+        if(map.find(v) != map.end())
+            ctx.add(error_t(error_t::WARNING, path, "'" + n + "' and '" + map[v] + "' have the same value"));
+        map[v] = n;
+    }
+}
+
+void check_register(const std::string& _path, const soc_desc::register_t& reg, error_context_t& ctx)
+{
+    std::string path = _path + ".<register>";
+    if(reg.width != 8 && reg.width != 16 && reg.width != 32)
+        ctx.add(error_t(error_t::WARNING, path, "width is not 8, 16 or 32"));
+    for(size_t i = 0; i < reg.field.size(); i++)
+        check_field(path, reg.field[i], ctx);
+    std::set< std::string > names;
+    soc_word_t bitmap = 0;
+    for(size_t i = 0; i < reg.field.size(); i++)
+    {
+        std::string n = reg.field[i].name;
+        if(names.find(n) != names.end())
+            ctx.add(error_t(error_t::FATAL, path, "duplicate name '" + n + "' in fields"));
+        if(reg.field[i].pos + reg.field[i].width > reg.width)
+            ctx.add(error_t(error_t::FATAL, path, "field '" + n + "' does not fit into the register"));
+        names.insert(n);
+        if(bitmap & reg.field[i].bitmask())
+        {
+            /* find the duplicate to ease debugging */
+            for(size_t j = 0; j < i; j++)
+                if(reg.field[j].bitmask() & reg.field[i].bitmask())
+                    ctx.add(error_t(error_t::FATAL, path, "overlap between fields '" +
+                        reg.field[j].name + "' and '" + n + "'"));
+        }
+        bitmap |= reg.field[i].bitmask();
+    }
+}
+
+void check_nodes(const std::string& path, const std::vector< node_t >& nodes,
+    error_context_t& ctx);
+
+void check_node(const std::string& _path, const node_t& node, error_context_t& ctx)
+{
+    std::string path = _path + "." + node.name;
+    check_name(_path, node.name, ctx);
+    if(node.instance.empty())
+        ctx.add(error_t(error_t::FATAL, path, "subnode with no instances"));
+    for(size_t j = 0; j < node.instance.size(); j++)
+        check_instance(path, node.instance[j], ctx);
+    for(size_t i = 0; i < node.register_.size(); i++)
+        check_register(path, node.register_[i], ctx);
+    check_nodes(path, node.node, ctx);
+}
+
+void check_nodes(const std::string& path, const std::vector< node_t >& nodes,
+    error_context_t& ctx)
+{
+    for(size_t i = 0; i < nodes.size(); i++)
+        check_node(path, nodes[i], ctx);
+    /* gather all instance names */
+    std::set< std::string > names;
+    for(size_t i = 0; i < nodes.size(); i++)
+        for(size_t j = 0; j < nodes[i].instance.size(); j++)
+        {
+            std::string n = nodes[i].instance[j].name;
+            if(names.find(n) != names.end())
+                ctx.add(error_t(error_t::FATAL, path, "duplicate instance name '" +
+                    n + "' in subnodes"));
+            names.insert(n);
+        }
+    /* gather all node names */
+    names.clear();
+    for(size_t i = 0; i < nodes.size(); i++)
+    {
+        std::string n = nodes[i].name;
+        if(names.find(n) != names.end())
+            ctx.add(error_t(error_t::FATAL, path, "duplicate node name '" + n +
+                "' in subnodes"));
+        names.insert(n);
+    }
+}
+
+void do_check(soc_t& soc, error_context_t& ctx)
+{
+    check_name(soc.name, soc.name, ctx);
+    check_nodes(soc.name, soc.node, ctx);
+}
+
+int do_check(int argc, char **argv)
+{
+    for(int i = 0; i < argc; i++)
+    {
+        error_context_t ctx;
+        soc_t soc;
+        bool ret = parse_xml(argv[i], soc, ctx);
+        if(ret)
+            do_check(soc, ctx);
+        if(ctx.count() != 0)
+            printf("In file %s:\n", argv[i]);
+        print_context(ctx);
+        if(!ret)
+        {
+            printf("cannot parse file '%s'\n", argv[i]);
+            continue;
+        }
+    }
+    return 0;
+}
+
+const unsigned DUMP_NODES = 1 << 0;
+const unsigned DUMP_INSTANCES = 1 << 1;
+const unsigned DUMP_VERBOSE = 1 << 2;
+const unsigned DUMP_REGISTERS = 1 << 3;
+
+void print_path(node_ref_t node, bool nl = true)
+{
+    printf("%s", node.soc().get()->name.c_str());
+    std::vector< std::string > path = node.path();
+    for(size_t i = 0; i < path.size(); i++)
+        printf(".%s", path[i].c_str());
+    if(nl)
+        printf("\n");
+}
+
+void print_inst(node_inst_t inst, bool end = true)
+{
+    if(!inst.is_root())
+    {
+        print_inst(inst.parent(), false);
+        printf(".%s", inst.name().c_str());
+        if(inst.is_indexed())
+            printf("[%u]", (unsigned)inst.index());
+    }
+    else
+    {
+        printf("%s", inst.soc().get()->name.c_str());
+    }
+    if(end)
+        printf(" @ %#x\n", inst.addr());
+}
+
+void print_reg(register_ref_t reg, unsigned flags)
+{
+    if(!(flags & DUMP_REGISTERS))
+        return;
+    node_ref_t node = reg.node();
+    soc_desc::register_t *r = reg.get();
+    print_path(node, false);
+    printf(":width=%u\n", (unsigned)r->width);
+    std::vector< field_ref_t > fields = reg.fields();
+    for(size_t i = 0; i < fields.size(); i++)
+    {
+        field_t *f = fields[i].get();
+        print_path(node, false);
+        if(f->width == 1)
+            printf(":[%u]=", (unsigned)f->pos);
+        else
+            printf(":[%u-%u]=", (unsigned)(f->pos + f->width - 1), (unsigned)f->pos);
+        printf("%s\n", f->name.c_str());
+    }
+}
+
+void do_dump(node_ref_t node, unsigned flags)
+{
+    print_path(node);
+    if(node.reg().node() == node)
+        print_reg(node.reg(), flags);
+    std::vector< node_ref_t > children = node.children();
+    for(size_t i = 0; i < children.size(); i++)
+        do_dump(children[i], flags);
+}
+
+void do_dump(node_inst_t inst, unsigned flags)
+{
+    print_inst(inst);
+    std::vector< node_inst_t > children = inst.children();
+    for(size_t i = 0; i < children.size(); i++)
+        do_dump(children[i], flags);
+}
+
+void do_dump(soc_t& soc, unsigned flags)
+{
+    soc_ref_t ref(&soc);
+    if(flags & DUMP_NODES)
+        do_dump(ref.root(), flags);
+    if(flags & DUMP_INSTANCES)
+        do_dump(ref.root_inst(), flags);
+}
+
+int do_dump(int argc, char **argv)
+{
+    unsigned flags = 0;
+    int i = 0;
+    for(; i < argc; i++)
+    {
+        if(strcmp(argv[i], "--nodes") == 0)
+            flags |= DUMP_NODES;
+        else if(strcmp(argv[i], "--instances") == 0)
+            flags |= DUMP_INSTANCES;
+        else if(strcmp(argv[i], "--verbose") == 0)
+            flags |= DUMP_VERBOSE;
+        else if(strcmp(argv[i], "--registers") == 0)
+            flags |= DUMP_REGISTERS;
+        else
+            break;
+    }
+    if(i == argc)
+    {
+        printf("you must specify at least one file\n");
+        return 1;
+    }
+    for(; i < argc; i++)
+    {
+        error_context_t ctx;
+        soc_t soc;
+        bool ret = parse_xml(argv[i], soc, ctx);
+        if(ret)
+            do_dump(soc, flags);
+        if(ctx.count() != 0)
+            printf("In file %s:\n", argv[i]);
+        print_context(ctx);
+        if(!ret)
+        {
+            printf("cannot parse file '%s'\n", argv[i]);
+            continue;
+        }
+    }
+    return 0;
+}
+
+void usage()
+{
+    printf("usage: swiss_knife <mode> [options]\n");
+    printf("modes:\n");
+    printf("  read <files...>\n");
+    printf("  write <read file> <write file>\n");
+    printf("  eval [<formula>|--var <name>=<val>]...\n");
+    printf("  convert <input file> <output file>\n");
+    printf("  check <files...>\n");
+    printf("  dump [--nodes] [--instances] [--registers] [--verbose] <files...>\n");
+    exit(1);
+}
+
+int main(int argc, char **argv)
+{
+    if(argc < 2)
+        usage();
+    std::string mode = argv[1];
+    if(mode == "read")
+        return do_read(argc - 2, argv +  2);
+    else if(mode == "write")
+        return do_write(argc - 2, argv +  2);
+    else if(mode == "eval")
+        return do_eval(argc - 2, argv +  2);
+    else if(mode == "convert")
+        return do_convert(argc - 2, argv +  2);
+    else if(mode == "check")
+        return do_check(argc - 2, argv +  2);
+    else if(mode == "dump")
+        return do_dump(argc - 2, argv +  2);
+    else
+        usage();
+    return 0;
+}
\ No newline at end of file
diff --git a/utils/regtools/tester.cpp b/utils/regtools/tester_v1.cpp
index 1beba5fe9b..3ece431531 100644
--- a/utils/regtools/tester.cpp
+++ b/utils/regtools/tester_v1.cpp
@@ -18,12 +18,14 @@
  * KIND, either express or implied.
  *
  ****************************************************************************/
-#include "soc_desc.hpp"
+#include "soc_desc_v1.hpp"
 #include <stdio.h>
 #include <stdlib.h>
 #include <map>
 #include <cstring>
 
+using namespace soc_desc_v1;
+
 template< typename T >
 bool build_map(const char *type, const std::vector< T >& vec,
     std::map< std::string, size_t >& map)
@@ -244,9 +246,9 @@ int do_compare(int argc, char **argv)
     if(argc != 2)
         return printf("compare mode expects two arguments\n");
     soc_t soc[2];
-    if(!soc_desc_parse_xml(argv[0], soc[0]))
+    if(!parse_xml(argv[0], soc[0]))
         return printf("cannot read file '%s'\n", argv[0]);
-    if(!soc_desc_parse_xml(argv[1], soc[1]))
+    if(!parse_xml(argv[1], soc[1]))
         return printf("cannot read file '%s'\n", argv[1]);
     if(compare_soc(soc[0], soc[1]))
         printf("Files are identical.\n");
@@ -258,9 +260,9 @@ int do_write(int argc, char **argv)
     if(argc != 2)
         return printf("write mode expects two arguments\n");
     soc_t soc;
-    if(!soc_desc_parse_xml(argv[0], soc))
+    if(!parse_xml(argv[0], soc))
         return printf("cannot read file '%s'\n", argv[0]);
-    if(!soc_desc_produce_xml(argv[1], soc))
+    if(!produce_xml(argv[1], soc))
         return printf("cannot write file '%s'\n", argv[1]);
     return 0;
 }
@@ -270,7 +272,7 @@ int do_check(int argc, char **argv)
     for(int i = 0; i < argc; i++)
     {
         soc_t soc;
-        if(!soc_desc_parse_xml(argv[i], soc))
+        if(!parse_xml(argv[i], soc))
         {
             printf("cannot read file '%s'\n", argv[i]);
             continue;
@@ -325,7 +327,7 @@ int do_eval(int argc, char **argv)
             map[name] = v;
             continue;
         }
-        if(!soc_desc_evaluate_formula(formula, map, result, error))
+        if(!evaluate_formula(formula, map, result, error))
             printf("error: %s\n", error.c_str());
         else
             printf("result: %lu (%#lx)\n", (unsigned long)result, (unsigned long)result);