changeset 137:9a9dcae45e08

Misc support file changes
author David Bryant <bagnose@gmail.com>
date Sun, 30 Sep 2012 15:25:11 +0930
parents 752676232e4b
children a1c2b56cb44d
files nobuild/Boboptions nobuild/ctags.patch nobuild/docutils-plantuml.patch nobuild/dot-Xresources nobuild/dot-bashrc
diffstat 5 files changed, 985 insertions(+), 173 deletions(-) [+]
line wrap: on
line diff
--- a/nobuild/Boboptions	Wed Sep 26 17:36:31 2012 +0930
+++ b/nobuild/Boboptions	Sun Sep 30 15:25:11 2012 +0930
@@ -1,14 +1,11 @@
 DEXTERNALS = std core glib gdk gtk gtkc cairo ;
-C++FLAGS = -fPIC -pedantic -Werror -Wall -Wno-long-long -Wundef -Wredundant-decls -O1 -DACRES_DEBUG=1 -DACRES_INTEGRATE=1 -fno-omit-frame-pointer -ggdb3 -pthread -DGTKMM_MACRO_SHADOW_ERROR -DGTKMM_DISABLE_DEPRECATED -DGDKMM_DISABLE_DEPRECATED -DGLIBMM_DISABLE_DEPRECATED -DGDK_DISABLE_DEPRECATED -DG_DISABLE_DEPRECATED -DLIBSIGC_DISABLE_DEPRECATED -DGTK_DISABLE_DEPRECATED -DGSEAL_ENABLE -DUSE_ECW_CHARTING_RASTER_SOURCE -Woverloaded-virtual -Wsign-promo -Wctor-dtor-privacy -Wnon-virtual-dtor ;
+C++FLAGS = -fPIC -pedantic -Werror -Wall -Wno-long-long -Wundef -Wredundant-decls -O1 -DACRES_DEBUG=1 -DACRES_INTEGRATE=1 -fno-omit-frame-pointer -ggdb3 -Woverloaded-virtual -Wsign-promo -Wctor-dtor-privacy -Wnon-virtual-dtor ;
 ARCHITECTURES = ;
-LINKFLAGS = -lstdc++ -rdynamic -L/opt/acacia/ecw/lib ;
+LINKFLAGS = -lstdc++ -rdynamic ;
 VALID_ARCHITECTURES = CentOS-4 Ubuntu CentOS-5 ;
-ZIP = /usr/bin/zip ;
 PROJECT-PACKAGE = doodle ;
-RST2HTML = /usr/bin/rst2html ;
-HEADERS = /usr/include/libxml2 /usr/include/libpng12 /usr/include/freetype2 /usr/include/gtkmm-2.4 /usr/lib/x86_64-linux-gnu/gtkmm-2.4/include /usr/include/atkmm-1.6 /usr/include/giomm-2.4 /usr/lib/x86_64-linux-gnu/giomm-2.4/include /usr/include/pangomm-1.4 /usr/lib/x86_64-linux-gnu/pangomm-1.4/include /usr/include/gtk-2.0 /usr/include/gtk-unix-print-2.0 /usr/include/gdkmm-2.4 /usr/lib/x86_64-linux-gnu/gdkmm-2.4/include /usr/include/atk-1.0 /usr/include/glibmm-2.4 /usr/lib/x86_64-linux-gnu/glibmm-2.4/include /usr/include/glib-2.0 /usr/lib/x86_64-linux-gnu/glib-2.0/include /usr/include/sigc++-2.0 /usr/lib/x86_64-linux-gnu/sigc++-2.0/include /usr/include/cairomm-1.0 /usr/lib/x86_64-linux-gnu/cairomm-1.0/include /usr/include/pango-1.0 /usr/include/cairo /usr/include/pixman-1 /usr/lib/x86_64-linux-gnu/gtk-2.0/include /usr/include/gdk-pixbuf-2.0 /usr/include/gio-unix-2.0/ /usr/include/gtkglext-1.0 /usr/lib/gtkglext-1.0/include /usr/include/gstreamer-0.10 /usr/include/gstreamermm-0.10 /usr/lib/gstreamermm-0.10/include /usr/include/libxml++-2.6 /usr/lib/libxml++-2.6/include /usr/include/neon /opt/acacia/ecw/include ;
-IMAGE_MAGICK_CONVERT = /usr/bin/convert ;
-DFLAGS = -w -wi -gc -I~/source/d/vcs/svn/gtkD-trunk/src ;
-CCFLAGS = -fPIC -pedantic -Werror -Wall -Wno-long-long -Wundef -Wredundant-decls -O1 -DACRES_DEBUG=1 -DACRES_INTEGRATE=1 -fno-omit-frame-pointer -ggdb3 -pthread -DGTKMM_MACRO_SHADOW_ERROR -DGTKMM_DISABLE_DEPRECATED -DGDKMM_DISABLE_DEPRECATED -DGLIBMM_DISABLE_DEPRECATED -DGDK_DISABLE_DEPRECATED -DG_DISABLE_DEPRECATED -DLIBSIGC_DISABLE_DEPRECATED -DGTK_DISABLE_DEPRECATED -DGSEAL_ENABLE -DUSE_ECW_CHARTING_RASTER_SOURCE ;
-ECW_LIBRARIES = NCSEcw NCSUtil NCSCnet ;
-DLINKFLAGS = -L-L/home/daveb/source/d/vcs/svn/gtkD-trunk -L-lgtkd -L-ldl ;
+CCFLAGS = -fPIC -pedantic -Werror -Wall -Wno-long-long -Wundef -Wredundant-decls -O1 -DACRES_DEBUG=1 -DACRES_INTEGRATE=1 -fno-omit-frame-pointer -ggdb3 ;
+#DFLAGS = -w -wi -gc -I~/source/d/gtkD-trunk/src ;
+#DFLAGS = -w -wi -gc -I~/source/d/GtkD/src ;
+DFLAGS = -w -wi -gc -Isrc/gtk ;
+DLINKFLAGS = -L-L/home/dbryant/source/d/GtkD ;
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/nobuild/ctags.patch	Sun Sep 30 15:25:11 2012 +0930
@@ -0,0 +1,711 @@
+diff -u ctags-5.8.orig//c.c ctags-5.8//c.c
+--- ctags-5.8.orig//c.c	2009-07-05 06:02:43.000000000 +0200
++++ ctags-5.8//c.c	2010-05-22 02:40:25.657027772 +0200
+@@ -59,7 +59,7 @@
+  */
+ typedef enum eKeywordId {
+ 	KEYWORD_NONE = -1,
+-	KEYWORD_ATTRIBUTE, KEYWORD_ABSTRACT,
++	KEYWORD_ALIAS, KEYWORD_ATTRIBUTE, KEYWORD_ABSTRACT,
+ 	KEYWORD_BOOLEAN, KEYWORD_BYTE, KEYWORD_BAD_STATE, KEYWORD_BAD_TRANS,
+ 	KEYWORD_BIND, KEYWORD_BIND_VAR, KEYWORD_BIT,
+ 	KEYWORD_CASE, KEYWORD_CATCH, KEYWORD_CHAR, KEYWORD_CLASS, KEYWORD_CONST,
+@@ -91,7 +91,19 @@
+ 	KEYWORD_UINT, KEYWORD_ULONG, KEYWORD_UNION, KEYWORD_UNSIGNED, KEYWORD_USHORT,
+ 	KEYWORD_USING,
+ 	KEYWORD_VIRTUAL, KEYWORD_VOID, KEYWORD_VOLATILE,
+-	KEYWORD_WCHAR_T, KEYWORD_WHILE
++	KEYWORD_WCHAR_T, KEYWORD_WHILE,
++    KEYWORD_ALIGN, KEYWORD_ASM, KEYWORD_ASSERT, KEYWORD_AUTO, 
++    KEYWORD_BODY, KEYWORD_BOOL, KEYWORD_BREAK, KEYWORD_CAST, 
++    KEYWORD_CDOUBLE, KEYWORD_CENT, KEYWORD_CFLOAT, KEYWORD_CONTINUE, 
++    KEYWORD_CREAL, KEYWORD_DCHAR, KEYWORD_DEBUG, 
++    KEYWORD_DEPRECATED, KEYWORD_EXPORT, KEYWORD_FALSE, KEYWORD_FINALLY, 
++    KEYWORD_FOREACH_REVERSE, KEYWORD_IDOUBLE, KEYWORD_IFLOAT, 
++    KEYWORD_IN, KEYWORD_INVARIANT, KEYWORD_IREAL, KEYWORD_IS, 
++    KEYWORD_LAZY, KEYWORD_MIXIN, KEYWORD_MODULE, KEYWORD_NULL, 
++    KEYWORD_OUT, KEYWORD_PRAGMA, KEYWORD_REAL, KEYWORD_SCOPE, 
++    KEYWORD_SUPER, KEYWORD_TRUE, KEYWORD_TYPEID, KEYWORD_TYPEOF, 
++    KEYWORD_UBYTE, KEYWORD_UCENT, KEYWORD_UNITTEST, KEYWORD_VERSION, 
++    KEYWORD_WCHAR, KEYWORD_WITH
+ } keywordId;
+ 
+ /*  Used to determine whether keyword is valid for the current language and
+@@ -100,7 +112,7 @@
+ typedef struct sKeywordDesc {
+ 	const char *name;
+ 	keywordId id;
+-	short isValid [5]; /* indicates languages for which kw is valid */
++	short isValid [6]; /* indicates languages for which kw is valid */
+ } keywordDesc;
+ 
+ /*  Used for reporting the type of object parsed by nextToken ().
+@@ -115,7 +127,7 @@
+ 	TOKEN_DOUBLE_COLON,  /* double colon indicates nested-name-specifier */
+ 	TOKEN_KEYWORD,
+ 	TOKEN_NAME,          /* an unknown name */
+-	TOKEN_PACKAGE,       /* a Java package name */
++	TOKEN_PACKAGE,       /* a Java package name / a D module name */
+ 	TOKEN_PAREN_NAME,    /* a single name in parentheses */
+ 	TOKEN_SEMICOLON,     /* the semicolon character */
+ 	TOKEN_SPEC,          /* a storage class specifier, qualifier, type, etc. */
+@@ -140,15 +152,19 @@
+ 	DECL_ENUM,
+ 	DECL_EVENT,
+ 	DECL_FUNCTION,
++	DECL_FUNCTION_TEMPLATE,
+ 	DECL_IGNORE,         /* non-taggable "declaration" */
+ 	DECL_INTERFACE,
++	DECL_MIXIN,
+ 	DECL_NAMESPACE,
+ 	DECL_NOMANGLE,       /* C++ name demangling block */
+ 	DECL_PACKAGE,
+ 	DECL_PROGRAM,        /* Vera program */
+ 	DECL_STRUCT,
+ 	DECL_TASK,           /* Vera task */
++	DECL_TEMPLATE,
+ 	DECL_UNION,
++	DECL_VERSION, /* D conditional compile */
+ 	DECL_COUNT
+ } declType;
+ 
+@@ -218,10 +234,12 @@
+ 	TAG_EVENT,       /* event */
+ 	TAG_FIELD,       /* field (Java) */
+ 	TAG_FUNCTION,    /* function definition */
++	TAG_FUNCTION_TEMPLATE, /* D function template */
+ 	TAG_INTERFACE,   /* interface declaration */
+ 	TAG_LOCAL,       /* local variable definition */
+ 	TAG_MEMBER,      /* structure, class or interface member */
+ 	TAG_METHOD,      /* method declaration */
++	TAG_MIXIN, 		 /* D mixin */
+ 	TAG_NAMESPACE,   /* namespace name */
+ 	TAG_PACKAGE,     /* package name */
+ 	TAG_PROGRAM,     /* program name */
+@@ -230,9 +248,11 @@
+ 	TAG_STRUCT,      /* structure name */
+ 	TAG_TASK,        /* task name */
+ 	TAG_TYPEDEF,     /* typedef name */
++	TAG_TEMPLATE, 	 /* d template name */
+ 	TAG_UNION,       /* union name */
+ 	TAG_VARIABLE,    /* variable definition */
+ 	TAG_EXTERN_VAR,  /* external variable declaration */
++	TAG_VERSION, 	/* conditional template compilation */
+ 	TAG_COUNT        /* must be last */
+ } tagType;
+ 
+@@ -255,6 +275,7 @@
+ static langType Lang_c;
+ static langType Lang_cpp;
+ static langType Lang_csharp;
++static langType Lang_d;
+ static langType Lang_java;
+ static langType Lang_vera;
+ static vString *Signature;
+@@ -267,9 +288,9 @@
+ typedef enum {
+ 	CK_UNDEFINED = -1,
+ 	CK_CLASS, CK_DEFINE, CK_ENUMERATOR, CK_FUNCTION,
+-	CK_ENUMERATION, CK_LOCAL, CK_MEMBER, CK_NAMESPACE, CK_PROTOTYPE,
+-	CK_STRUCT, CK_TYPEDEF, CK_UNION, CK_VARIABLE,
+-	CK_EXTERN_VARIABLE
++	CK_ENUMERATION, CK_LOCAL, CK_MEMBER, CK_MODULE, CK_NAMESPACE, CK_PROTOTYPE,
++	CK_STRUCT, CK_TYPEDEF, CK_TEMPLATE, CK_UNION, CK_VARIABLE,
++	CK_EXTERN_VARIABLE, CK_MIXIN, CK_VERSION
+ } cKind;
+ 
+ static kindOption CKinds [] = {
+@@ -280,13 +301,17 @@
+ 	{ TRUE,  'g', "enum",       "enumeration names"},
+ 	{ FALSE, 'l', "local",      "local variables"},
+ 	{ TRUE,  'm', "member",     "class, struct, and union members"},
++	{ TRUE,  'M', "module", 	"module"},
+ 	{ TRUE,  'n', "namespace",  "namespaces"},
+ 	{ FALSE, 'p', "prototype",  "function prototypes"},
+ 	{ TRUE,  's', "struct",     "structure names"},
+ 	{ TRUE,  't', "typedef",    "typedefs"},
++	{ TRUE,  'T', "template", 	"templates"},
+ 	{ TRUE,  'u', "union",      "union names"},
+ 	{ TRUE,  'v', "variable",   "variable definitions"},
+ 	{ FALSE, 'x', "externvar",  "external and forward variable declarations"},
++	{ TRUE,  'X', "mixin", 		"mixin"},
++	{ TRUE,  'V', "version", 	"conditional compilation"}
+ };
+ 
+ typedef enum {
+@@ -356,110 +381,155 @@
+ };
+ 
+ static const keywordDesc KeywordTable [] = {
+-	/*                                              C++            */
+-	/*                                       ANSI C  |  C# Java    */
+-	/*                                            |  |  |  |  Vera */
+-	/* keyword          keyword ID                |  |  |  |  |    */
+-	{ "__attribute__",  KEYWORD_ATTRIBUTE,      { 1, 1, 1, 0, 0 } },
+-	{ "abstract",       KEYWORD_ABSTRACT,       { 0, 0, 1, 1, 0 } },
+-	{ "bad_state",      KEYWORD_BAD_STATE,      { 0, 0, 0, 0, 1 } },
+-	{ "bad_trans",      KEYWORD_BAD_TRANS,      { 0, 0, 0, 0, 1 } },
+-	{ "bind",           KEYWORD_BIND,           { 0, 0, 0, 0, 1 } },
+-	{ "bind_var",       KEYWORD_BIND_VAR,       { 0, 0, 0, 0, 1 } },
+-	{ "bit",            KEYWORD_BIT,            { 0, 0, 0, 0, 1 } },
+-	{ "boolean",        KEYWORD_BOOLEAN,        { 0, 0, 0, 1, 0 } },
+-	{ "byte",           KEYWORD_BYTE,           { 0, 0, 0, 1, 0 } },
+-	{ "case",           KEYWORD_CASE,           { 1, 1, 1, 1, 0 } },
+-	{ "catch",          KEYWORD_CATCH,          { 0, 1, 1, 0, 0 } },
+-	{ "char",           KEYWORD_CHAR,           { 1, 1, 1, 1, 0 } },
+-	{ "class",          KEYWORD_CLASS,          { 0, 1, 1, 1, 1 } },
+-	{ "const",          KEYWORD_CONST,          { 1, 1, 1, 1, 0 } },
+-	{ "constraint",     KEYWORD_CONSTRAINT,     { 0, 0, 0, 0, 1 } },
+-	{ "coverage_block", KEYWORD_COVERAGE_BLOCK, { 0, 0, 0, 0, 1 } },
+-	{ "coverage_def",   KEYWORD_COVERAGE_DEF,   { 0, 0, 0, 0, 1 } },
+-	{ "do",             KEYWORD_DO,             { 1, 1, 1, 1, 0 } },
+-	{ "default",        KEYWORD_DEFAULT,        { 1, 1, 1, 1, 0 } },
+-	{ "delegate",       KEYWORD_DELEGATE,       { 0, 0, 1, 0, 0 } },
+-	{ "delete",         KEYWORD_DELETE,         { 0, 1, 0, 0, 0 } },
+-	{ "double",         KEYWORD_DOUBLE,         { 1, 1, 1, 1, 0 } },
+-	{ "else",           KEYWORD_ELSE,           { 1, 1, 1, 1, 0 } },
+-	{ "enum",           KEYWORD_ENUM,           { 1, 1, 1, 1, 1 } },
+-	{ "event",          KEYWORD_EVENT,          { 0, 0, 1, 0, 1 } },
+-	{ "explicit",       KEYWORD_EXPLICIT,       { 0, 1, 1, 0, 0 } },
+-	{ "extends",        KEYWORD_EXTENDS,        { 0, 0, 0, 1, 1 } },
+-	{ "extern",         KEYWORD_EXTERN,         { 1, 1, 1, 0, 1 } },
+-	{ "final",          KEYWORD_FINAL,          { 0, 0, 0, 1, 0 } },
+-	{ "float",          KEYWORD_FLOAT,          { 1, 1, 1, 1, 0 } },
+-	{ "for",            KEYWORD_FOR,            { 1, 1, 1, 1, 0 } },
+-	{ "foreach",        KEYWORD_FOREACH,        { 0, 0, 1, 0, 0 } },
+-	{ "friend",         KEYWORD_FRIEND,         { 0, 1, 0, 0, 0 } },
+-	{ "function",       KEYWORD_FUNCTION,       { 0, 0, 0, 0, 1 } },
+-	{ "goto",           KEYWORD_GOTO,           { 1, 1, 1, 1, 0 } },
+-	{ "if",             KEYWORD_IF,             { 1, 1, 1, 1, 0 } },
+-	{ "implements",     KEYWORD_IMPLEMENTS,     { 0, 0, 0, 1, 0 } },
+-	{ "import",         KEYWORD_IMPORT,         { 0, 0, 0, 1, 0 } },
+-	{ "inline",         KEYWORD_INLINE,         { 0, 1, 0, 0, 0 } },
+-	{ "inout",          KEYWORD_INOUT,          { 0, 0, 0, 0, 1 } },
+-	{ "input",          KEYWORD_INPUT,          { 0, 0, 0, 0, 1 } },
+-	{ "int",            KEYWORD_INT,            { 1, 1, 1, 1, 0 } },
+-	{ "integer",        KEYWORD_INTEGER,        { 0, 0, 0, 0, 1 } },
+-	{ "interface",      KEYWORD_INTERFACE,      { 0, 0, 1, 1, 1 } },
+-	{ "internal",       KEYWORD_INTERNAL,       { 0, 0, 1, 0, 0 } },
+-	{ "local",          KEYWORD_LOCAL,          { 0, 0, 0, 0, 1 } },
+-	{ "long",           KEYWORD_LONG,           { 1, 1, 1, 1, 0 } },
+-	{ "m_bad_state",    KEYWORD_M_BAD_STATE,    { 0, 0, 0, 0, 1 } },
+-	{ "m_bad_trans",    KEYWORD_M_BAD_TRANS,    { 0, 0, 0, 0, 1 } },
+-	{ "m_state",        KEYWORD_M_STATE,        { 0, 0, 0, 0, 1 } },
+-	{ "m_trans",        KEYWORD_M_TRANS,        { 0, 0, 0, 0, 1 } },
+-	{ "mutable",        KEYWORD_MUTABLE,        { 0, 1, 0, 0, 0 } },
+-	{ "namespace",      KEYWORD_NAMESPACE,      { 0, 1, 1, 0, 0 } },
+-	{ "native",         KEYWORD_NATIVE,         { 0, 0, 0, 1, 0 } },
+-	{ "new",            KEYWORD_NEW,            { 0, 1, 1, 1, 0 } },
+-	{ "newcov",         KEYWORD_NEWCOV,         { 0, 0, 0, 0, 1 } },
+-	{ "operator",       KEYWORD_OPERATOR,       { 0, 1, 1, 0, 0 } },
+-	{ "output",         KEYWORD_OUTPUT,         { 0, 0, 0, 0, 1 } },
+-	{ "overload",       KEYWORD_OVERLOAD,       { 0, 1, 0, 0, 0 } },
+-	{ "override",       KEYWORD_OVERRIDE,       { 0, 0, 1, 0, 0 } },
+-	{ "package",        KEYWORD_PACKAGE,        { 0, 0, 0, 1, 0 } },
+-	{ "packed",         KEYWORD_PACKED,         { 0, 0, 0, 0, 1 } },
+-	{ "port",           KEYWORD_PORT,           { 0, 0, 0, 0, 1 } },
+-	{ "private",        KEYWORD_PRIVATE,        { 0, 1, 1, 1, 0 } },
+-	{ "program",        KEYWORD_PROGRAM,        { 0, 0, 0, 0, 1 } },
+-	{ "protected",      KEYWORD_PROTECTED,      { 0, 1, 1, 1, 1 } },
+-	{ "public",         KEYWORD_PUBLIC,         { 0, 1, 1, 1, 1 } },
+-	{ "register",       KEYWORD_REGISTER,       { 1, 1, 0, 0, 0 } },
+-	{ "return",         KEYWORD_RETURN,         { 1, 1, 1, 1, 0 } },
+-	{ "shadow",         KEYWORD_SHADOW,         { 0, 0, 0, 0, 1 } },
+-	{ "short",          KEYWORD_SHORT,          { 1, 1, 1, 1, 0 } },
+-	{ "signed",         KEYWORD_SIGNED,         { 1, 1, 0, 0, 0 } },
+-	{ "state",          KEYWORD_STATE,          { 0, 0, 0, 0, 1 } },
+-	{ "static",         KEYWORD_STATIC,         { 1, 1, 1, 1, 1 } },
+-	{ "string",         KEYWORD_STRING,         { 0, 0, 1, 0, 1 } },
+-	{ "struct",         KEYWORD_STRUCT,         { 1, 1, 1, 0, 0 } },
+-	{ "switch",         KEYWORD_SWITCH,         { 1, 1, 1, 1, 0 } },
+-	{ "synchronized",   KEYWORD_SYNCHRONIZED,   { 0, 0, 0, 1, 0 } },
+-	{ "task",           KEYWORD_TASK,           { 0, 0, 0, 0, 1 } },
+-	{ "template",       KEYWORD_TEMPLATE,       { 0, 1, 0, 0, 0 } },
+-	{ "this",           KEYWORD_THIS,           { 0, 1, 1, 1, 0 } },
+-	{ "throw",          KEYWORD_THROW,          { 0, 1, 1, 1, 0 } },
+-	{ "throws",         KEYWORD_THROWS,         { 0, 0, 0, 1, 0 } },
+-	{ "trans",          KEYWORD_TRANS,          { 0, 0, 0, 0, 1 } },
+-	{ "transition",     KEYWORD_TRANSITION,     { 0, 0, 0, 0, 1 } },
+-	{ "transient",      KEYWORD_TRANSIENT,      { 0, 0, 0, 1, 0 } },
+-	{ "try",            KEYWORD_TRY,            { 0, 1, 1, 0, 0 } },
+-	{ "typedef",        KEYWORD_TYPEDEF,        { 1, 1, 1, 0, 1 } },
+-	{ "typename",       KEYWORD_TYPENAME,       { 0, 1, 0, 0, 0 } },
+-	{ "uint",           KEYWORD_UINT,           { 0, 0, 1, 0, 0 } },
+-	{ "ulong",          KEYWORD_ULONG,          { 0, 0, 1, 0, 0 } },
+-	{ "union",          KEYWORD_UNION,          { 1, 1, 0, 0, 0 } },
+-	{ "unsigned",       KEYWORD_UNSIGNED,       { 1, 1, 1, 0, 0 } },
+-	{ "ushort",         KEYWORD_USHORT,         { 0, 0, 1, 0, 0 } },
+-	{ "using",          KEYWORD_USING,          { 0, 1, 1, 0, 0 } },
+-	{ "virtual",        KEYWORD_VIRTUAL,        { 0, 1, 1, 0, 1 } },
+-	{ "void",           KEYWORD_VOID,           { 1, 1, 1, 1, 1 } },
+-	{ "volatile",       KEYWORD_VOLATILE,       { 1, 1, 1, 1, 0 } },
+-	{ "wchar_t",        KEYWORD_WCHAR_T,        { 1, 1, 1, 0, 0 } },
+-	{ "while",          KEYWORD_WHILE,          { 1, 1, 1, 1, 0 } }
++     /*                                 	    C++	   D          */
++     /*                                      ANSI C  |  C# | Java    */
++     /* 			                  |  |  |  |  |  Vera */
++     /* keyword		keyword ID	          |  |  |  |  |  |    */
++     { "__attribute__",	KEYWORD_ATTRIBUTE,	{ 1, 1, 1, 1, 0, 0 } },
++     { "abstract",	KEYWORD_ABSTRACT,	{ 0, 0, 1, 1, 1, 0 } },
++     { "alias",		KEYWORD_ALIAS,		{ 0, 0, 0, 1, 0, 0 } },
++     { "align",		KEYWORD_ALIGN,		{ 0, 0, 0, 1, 0, 0 } },
++     { "asm",		KEYWORD_ASM,		{ 0, 0, 0, 1, 0, 0 } },
++     { "assert",	KEYWORD_ASSERT,		{ 0, 0, 0, 1, 0, 0 } },
++     { "auto",		KEYWORD_AUTO,		{ 0, 0, 0, 1, 0, 0 } },
++     { "bad_state",	KEYWORD_BAD_STATE,	{ 0, 0, 0, 0, 0, 1 } },
++     { "bad_trans",	KEYWORD_BAD_TRANS,	{ 0, 0, 0, 0, 0, 1 } },
++     { "bind",		KEYWORD_BIND,		{ 0, 0, 0, 0, 0, 1 } },
++     { "bind_var",	KEYWORD_BIND_VAR,	{ 0, 0, 0, 0, 0, 1 } },
++     { "bit",		KEYWORD_BIT,		{ 0, 0, 0, 0, 0, 1 } },
++     { "body",		KEYWORD_BODY,		{ 0, 0, 0, 1, 0, 0 } },
++     { "bool",		KEYWORD_BOOL,		{ 0, 0, 0, 1, 0, 0 } },
++     { "boolean",	KEYWORD_BOOLEAN,	{ 0, 0, 0, 0, 1, 0 } },
++     { "break", 	KEYWORD_BREAK,		{ 0, 0, 0, 1, 0, 0 } },
++     { "byte",		KEYWORD_BYTE,		{ 0, 0, 0, 1, 1, 0 } },
++     { "case",		KEYWORD_CASE,		{ 1, 1, 1, 1, 1, 0 } },
++     { "cast",		KEYWORD_CAST,		{ 0, 0, 0, 1, 0, 0 } },
++     { "catch",		KEYWORD_CATCH,		{ 0, 1, 1, 1, 0, 0 } },
++     { "cdouble",	KEYWORD_CDOUBLE,	{ 0, 0, 0, 1, 0, 0 } },
++     { "cent",		KEYWORD_CENT,		{ 0, 0, 0, 1, 0, 0 } },
++     { "cfloat",	KEYWORD_CFLOAT,		{ 0, 0, 0, 1, 0, 0 } },
++     { "char",		KEYWORD_CHAR,		{ 1, 1, 1, 1, 1, 0 } },
++     { "class",		KEYWORD_CLASS,		{ 0, 1, 1, 1, 1, 1 } },
++     { "const",		KEYWORD_CONST,		{ 1, 1, 1, 1, 1, 0 } },
++     { "constraint",	KEYWORD_CONSTRAINT,	{ 0, 0, 0, 0, 0, 1 } },
++     { "continue",	KEYWORD_CONTINUE,	{ 0, 0, 0, 1, 0, 0 } },
++     { "coverage_block", KEYWORD_COVERAGE_BLOCK, { 0, 0, 0, 0, 0, 1 } },
++     { "coverage_def",	KEYWORD_COVERAGE_DEF,	{ 0, 0, 0, 0, 0, 1 } },
++     { "creal",		KEYWORD_CREAL,		{ 0, 0, 0, 1, 0, 0 } },
++     { "dchar",		KEYWORD_DCHAR,		{ 0, 0, 0, 1, 0, 0 } },
++     { "debug",		KEYWORD_DEBUG,		{ 0, 0, 0, 1, 0, 0 } },
++     { "default",	KEYWORD_DEFAULT,	{ 1, 1, 1, 1, 1, 0 } },
++     { "delegate",	KEYWORD_DELEGATE,	{ 0, 0, 1, 1, 0, 0 } },
++     { "delete",	KEYWORD_DELETE,		{ 0, 0, 0, 1, 0, 0 } },
++     { "deprecated",	KEYWORD_DEPRECATED,	{ 0, 0, 0, 1, 0, 0 } },
++     { "do",		KEYWORD_DO,		{ 1, 1, 1, 1, 1, 0 } },
++     { "double",	KEYWORD_DOUBLE,		{ 1, 1, 1, 1, 1, 0 } },
++     { "else",		KEYWORD_ELSE,		{ 1, 1, 1, 1, 1, 0 } },
++     { "enum",		KEYWORD_ENUM,		{ 1, 1, 1, 1, 0, 1 } },
++     { "event",		KEYWORD_EVENT,		{ 0, 0, 1, 0, 0, 1 } },
++     { "explicit",	KEYWORD_EXPLICIT,	{ 0, 1, 1, 1, 0, 0 } },
++     { "export",	KEYWORD_EXPORT,		{ 0, 0, 0, 1, 0, 0 } },
++     { "extends",	KEYWORD_EXTENDS,	{ 0, 0, 0, 0, 1, 1 } },
++     { "extern",	KEYWORD_EXTERN,		{ 1, 1, 1, 1, 0, 1 } },
++     { "false",		KEYWORD_FALSE,		{ 0, 0, 0, 1, 0, 0 } },
++     { "final",		KEYWORD_FINAL,		{ 0, 0, 0, 1, 1, 0 } },
++     { "finally",	KEYWORD_FINALLY,	{ 0, 0, 0, 1, 0, 0 } },
++     { "float",		KEYWORD_FLOAT,		{ 1, 1, 1, 1, 1, 0 } },
++     { "for",		KEYWORD_FOR,		{ 1, 1, 1, 1, 1, 0 } },
++     { "foreach",	KEYWORD_FOREACH,	{ 0, 0, 1, 1, 0, 0 } },
++     { "foreach_reverse", KEYWORD_FOREACH_REVERSE, { 0, 0, 0, 1, 0, 0 } },
++     { "friend",	KEYWORD_FRIEND,		{ 0, 1, 0, 1, 0, 0 } },
++     { "function",	KEYWORD_FUNCTION,	{ 0, 0, 0, 1, 0, 1 } },
++     { "goto",		KEYWORD_GOTO,		{ 1, 1, 1, 1, 1, 0 } },
++     { "idouble",	KEYWORD_IDOUBLE,	{ 0, 0, 0, 1, 0, 0 } },
++     { "if",		KEYWORD_IF,		{ 1, 1, 1, 1, 1, 0 } },
++     { "ifloat",	KEYWORD_IFLOAT,		{ 0, 0, 0, 1, 0, 0 } },
++     { "implements",	KEYWORD_IMPLEMENTS,	{ 0, 0, 0, 0, 1, 0 } },
++     { "import",	KEYWORD_IMPORT,		{ 0, 0, 0, 1, 1, 0 } },
++     { "in",		KEYWORD_IN,		{ 0, 0, 0, 1, 0, 0 } },
++     { "inline",	KEYWORD_INLINE,		{ 0, 1, 0, 1, 0, 0 } },
++     { "inout",		KEYWORD_INOUT,		{ 0, 0, 0, 1, 0, 1 } },
++     { "input",		KEYWORD_INPUT,		{ 0, 0, 0, 0, 0, 1 } },
++     { "int",		KEYWORD_INT,		{ 1, 1, 1, 1, 1, 0 } },
++     { "integer",	KEYWORD_INTEGER,	{ 0, 0, 0, 0, 0, 1 } },
++     { "interface",	KEYWORD_INTERFACE,	{ 0, 0, 1, 1, 1, 1 } },
++     { "internal",	KEYWORD_INTERNAL,	{ 0, 0, 1, 0, 0, 0 } },
++     { "invariant",	KEYWORD_INVARIANT,	{ 0, 0, 0, 1, 0, 0 } },
++     { "ireal",		KEYWORD_IREAL,		{ 0, 0, 0, 1, 0, 0 } },
++     { "is",		KEYWORD_IS,		{ 0, 0, 0, 1, 0, 0 } },
++     { "lazy",		KEYWORD_LAZY,		{ 0, 0, 0, 1, 0, 0 } },
++     { "local",		KEYWORD_LOCAL,		{ 0, 0, 0, 0, 0, 1 } },
++     { "long",		KEYWORD_LONG,		{ 1, 1, 1, 1, 1, 0 } },
++     { "m_bad_state",	KEYWORD_M_BAD_STATE,	{ 0, 0, 0, 0, 0, 1 } },
++     { "m_bad_trans",	KEYWORD_M_BAD_TRANS,	{ 0, 0, 0, 0, 0, 1 } },
++     { "m_state",	KEYWORD_M_STATE,	{ 0, 0, 0, 0, 0, 1 } },
++     { "m_trans",	KEYWORD_M_TRANS,	{ 0, 0, 0, 0, 0, 1 } },
++     { "mixin",		KEYWORD_MIXIN,		{ 0, 0, 0, 1, 0, 0 } },
++     { "module",	KEYWORD_MODULE,		{ 0, 0, 0, 1, 0, 0 } },
++     { "mutable",	KEYWORD_MUTABLE,	{ 0, 1, 0, 1, 0, 0 } },
++     { "namespace",	KEYWORD_NAMESPACE,	{ 0, 1, 1, 1, 0, 0 } },
++     { "native",	KEYWORD_NATIVE,		{ 0, 0, 0, 0, 1, 0 } },
++     { "new",		KEYWORD_NEW,		{ 0, 1, 1, 1, 1, 0 } },
++     { "newcov",	KEYWORD_NEWCOV,		{ 0, 0, 0, 0, 0, 1 } },
++     { "null",		KEYWORD_NULL,		{ 0, 0, 0, 1, 0, 0 } },
++     { "operator",	KEYWORD_OPERATOR,	{ 0, 1, 1, 1, 0, 0 } },
++     { "out",		KEYWORD_OUT,		{ 0, 0, 0, 1, 0, 0 } },
++     { "output",	KEYWORD_OUTPUT,		{ 0, 0, 0, 0, 0, 1 } },
++     { "overload",	KEYWORD_OVERLOAD,	{ 0, 1, 0, 1, 0, 0 } },
++     { "override",	KEYWORD_OVERRIDE,	{ 0, 0, 1, 1, 0, 0 } },
++     { "package",	KEYWORD_PACKAGE,	{ 0, 0, 0, 1, 1, 0 } },
++     { "packed",	KEYWORD_PACKED,		{ 0, 0, 0, 0, 0, 1 } },
++     { "port",		KEYWORD_PORT,		{ 0, 0, 0, 0, 0, 1 } },
++     { "pragma",	KEYWORD_PRAGMA,		{ 0, 0, 0, 1, 0, 0 } },
++     { "private",	KEYWORD_PRIVATE,	{ 0, 1, 1, 1, 1, 0 } },
++     { "program",	KEYWORD_PROGRAM,	{ 0, 0, 0, 0, 0, 1 } },
++     { "protected",	KEYWORD_PROTECTED,	{ 0, 1, 1, 1, 1, 1 } },
++     { "public",	KEYWORD_PUBLIC,		{ 0, 1, 1, 1, 1, 1 } },
++     { "real",		KEYWORD_REAL,		{ 0, 0, 0, 1, 0, 0 } },
++     { "register",	KEYWORD_REGISTER,	{ 1, 1, 0, 1, 0, 0 } },
++     { "return",	KEYWORD_RETURN,		{ 1, 1, 1, 1, 1, 0 } },
++     { "scope",		KEYWORD_SCOPE,		{ 0, 0, 0, 1, 0, 0 } },
++     { "shadow",	KEYWORD_SHADOW,		{ 0, 0, 0, 0, 0, 1 } },
++     { "short",		KEYWORD_SHORT,		{ 1, 1, 1, 1, 1, 0 } },
++     { "signed",	KEYWORD_SIGNED,		{ 1, 1, 0, 1, 0, 0 } },
++     { "state",		KEYWORD_STATE,		{ 0, 0, 0, 0, 0, 1 } },
++     { "static",	KEYWORD_STATIC,		{ 1, 1, 1, 1, 1, 1 } },
++     { "string",	KEYWORD_STRING,		{ 0, 0, 1, 0, 0, 1 } },
++     { "struct",	KEYWORD_STRUCT,		{ 1, 1, 1, 1, 0, 0 } },
++     { "super",		KEYWORD_SUPER,		{ 0, 0, 0, 1, 0, 0 } },
++     { "switch",	KEYWORD_SWITCH,		{ 1, 1, 1, 1, 1, 0 } },
++     { "synchronized",	KEYWORD_SYNCHRONIZED,	{ 0, 0, 0, 1, 1, 0 } },
++     { "task",		KEYWORD_TASK,		{ 0, 0, 0, 0, 0, 1 } },
++     { "template",	KEYWORD_TEMPLATE,	{ 0, 1, 0, 1, 0, 0 } },
++     { "this",		KEYWORD_THIS,		{ 0, 1, 1, 1, 1, 0 } },
++     { "throw",		KEYWORD_THROW,		{ 0, 1, 1, 1, 1, 0 } },
++     { "throws",	KEYWORD_THROWS,		{ 0, 0, 0, 0, 1, 0 } },
++     { "trans",		KEYWORD_TRANS,		{ 0, 0, 0, 0, 0, 1 } },
++     { "transient",	KEYWORD_TRANSIENT,	{ 0, 0, 0, 0, 1, 0 } },
++     { "transition",	KEYWORD_TRANSITION,	{ 0, 0, 0, 0, 0, 1 } },
++     { "true",		KEYWORD_TRUE,		{ 0, 0, 0, 1, 0, 0 } },
++     { "try",		KEYWORD_TRY,		{ 0, 1, 1, 1, 0, 0 } },
++     { "typedef",	KEYWORD_TYPEDEF,	{ 1, 1, 1, 1, 0, 1 } },
++     { "typeid",	KEYWORD_TYPEID,		{ 0, 0, 0, 1, 0, 0 } },
++     { "typename",	KEYWORD_TYPENAME,	{ 0, 1, 0, 1, 0, 0 } },
++     { "typeof",	KEYWORD_TYPEOF,		{ 0, 0, 0, 1, 0, 0 } },
++     { "ubyte",		KEYWORD_UBYTE,		{ 0, 0, 0, 1, 0, 0 } },
++     { "ucent",		KEYWORD_UCENT,		{ 0, 0, 0, 1, 0, 0 } },
++     { "uint",		KEYWORD_UINT,		{ 0, 0, 1, 1, 0, 0 } },
++     { "ulong",		KEYWORD_ULONG,		{ 0, 0, 1, 1, 0, 0 } },
++     { "union",		KEYWORD_UNION,		{ 1, 1, 0, 1, 0, 0 } },
++     { "unittest",	KEYWORD_UNITTEST,	{ 0, 0, 0, 1, 0, 0 } },
++     { "unsigned",	KEYWORD_UNSIGNED,	{ 1, 1, 1, 1, 0, 0 } },
++     { "ushort",	KEYWORD_USHORT,		{ 0, 0, 1, 1, 0, 0 } },
++     { "using",		KEYWORD_USING,		{ 0, 1, 1, 1, 0, 0 } },
++     { "version",	KEYWORD_VERSION,	{ 0, 0, 0, 1, 0, 0 } },
++     { "virtual",	KEYWORD_VIRTUAL,	{ 0, 1, 1, 1, 0, 1 } },
++     { "void",		KEYWORD_VOID,		{ 1, 1, 1, 1, 1, 1 } },
++     { "volatile",	KEYWORD_VOLATILE,	{ 1, 1, 1, 1, 1, 0 } },
++     { "wchar",		KEYWORD_WCHAR,		{ 0, 0, 0, 1, 0, 0 } },
++     { "wchar_t",	KEYWORD_WCHAR_T,	{ 1, 1, 1, 1, 0, 0 } },
++     { "while",		KEYWORD_WHILE,		{ 1, 1, 1, 1, 1, 0 } },
++     { "with",		KEYWORD_WITH,		{ 0, 0, 0, 1, 0, 0 } },
+ };
+ 
+ /*
+@@ -595,7 +665,7 @@
+ 	static const char *const names [] = {
+ 		"?", "base", "class", "enum", "event", "function", "ignore",
+ 		"interface", "namespace", "no mangle", "package", "program",
+-		"struct", "task", "union",
++		"struct", "task", "union", "version"
+ 	};
+ 	Assert (sizeof (names) / sizeof (names [0]) == DECL_COUNT);
+ 	Assert ((int) declaration < DECL_COUNT);
+@@ -671,6 +741,8 @@
+ 		case KEYWORD_NAMESPACE:
+ 		case KEYWORD_STRUCT:
+ 		case KEYWORD_UNION:
++		case KEYWORD_VERSION:
++		case KEYWORD_TEMPLATE:
+ 			result = TRUE;
+ 			break;
+ 
+@@ -690,6 +762,7 @@
+ 		case DECL_NAMESPACE:
+ 		case DECL_STRUCT:
+ 		case DECL_UNION:
++		case DECL_TEMPLATE:
+ 			result = TRUE;
+ 			break;
+ 
+@@ -725,6 +798,8 @@
+ 		case DECL_CLASS:
+ 			if (isLanguage (Lang_java))
+ 				accessDefault = ACCESS_DEFAULT;
++			else if(isLanguage(Lang_d))
++				accessDefault = ACCESS_PUBLIC;
+ 			else
+ 				accessDefault = ACCESS_PRIVATE;
+ 			break;
+@@ -807,13 +882,17 @@
+ 		case TAG_FUNCTION:   result = CK_FUNCTION;    break;
+ 		case TAG_LOCAL:      result = CK_LOCAL;       break;
+ 		case TAG_MEMBER:     result = CK_MEMBER;      break;
++		case TAG_PACKAGE: 	 result = CK_MODULE;	  break;
+ 		case TAG_NAMESPACE:  result = CK_NAMESPACE;   break;
+ 		case TAG_PROTOTYPE:  result = CK_PROTOTYPE;   break;
+ 		case TAG_STRUCT:     result = CK_STRUCT;      break;
+ 		case TAG_TYPEDEF:    result = CK_TYPEDEF;     break;
++		case TAG_TEMPLATE: 	 result = CK_TEMPLATE; 	  break;
+ 		case TAG_UNION:      result = CK_UNION;       break;
+ 		case TAG_VARIABLE:   result = CK_VARIABLE;    break;
++		case TAG_MIXIN:		 result = CK_MIXIN; 	  break;
+ 		case TAG_EXTERN_VAR: result = CK_EXTERN_VARIABLE; break;
++		case TAG_VERSION:    result = CK_VERSION;     break;
+ 
+ 		default: Assert ("Bad C tag type" == NULL); break;
+ 	}
+@@ -938,12 +1017,15 @@
+ 		case DECL_ENUM:         type = TAG_ENUM;        break;
+ 		case DECL_EVENT:        type = TAG_EVENT;       break;
+ 		case DECL_FUNCTION:     type = TAG_FUNCTION;    break;
++		case DECL_FUNCTION_TEMPLATE: type = TAG_FUNCTION_TEMPLATE; break;
+ 		case DECL_INTERFACE:    type = TAG_INTERFACE;   break;
+ 		case DECL_NAMESPACE:    type = TAG_NAMESPACE;   break;
+ 		case DECL_PROGRAM:      type = TAG_PROGRAM;     break;
+ 		case DECL_TASK:         type = TAG_TASK;        break;
++		case DECL_TEMPLATE: 	type = TAG_TEMPLATE; 	break;
+ 		case DECL_STRUCT:       type = TAG_STRUCT;      break;
+ 		case DECL_UNION:        type = TAG_UNION;       break;
++		case DECL_VERSION: 		type = TAG_VERSION; 	break;
+ 
+ 		default: Assert ("Unexpected declaration" == NULL); break;
+ 	}
+@@ -962,7 +1044,7 @@
+ 
+ static void addContextSeparator (vString *const scope)
+ {
+-	if (isLanguage (Lang_c)  ||  isLanguage (Lang_cpp))
++	if (isLanguage (Lang_c)  ||  isLanguage (Lang_cpp) || isLanguage(Lang_d))
+ 		vStringCatS (scope, "::");
+ 	else if (isLanguage (Lang_java) || isLanguage (Lang_csharp))
+ 		vStringCatS (scope, ".");
+@@ -980,6 +1062,7 @@
+ 		default: break;
+ 
+ 		case TAG_FUNCTION:
++		case TAG_TEMPLATE:
+ 		case TAG_METHOD:
+ 		case TAG_PROTOTYPE:
+ 			if (vStringLength (Signature) > 0)
+@@ -1252,6 +1335,8 @@
+ 		case DECL_PROGRAM:
+ 		case DECL_STRUCT:
+ 		case DECL_UNION:
++		case DECL_TEMPLATE:
++		case DECL_VERSION:
+ 			qualifyCompoundTag (st, nameToken);
+ 			break;
+ 		default: break;
+@@ -1535,6 +1620,34 @@
+ 	}
+ }
+ 
++static void readVersionName (tokenInfo *const token, const int firstChar)
++{
++	vString *const name = token->name;
++	int c = firstChar;
++
++	initToken (token);
++
++	while (isident (c))
++	{
++		vStringPut (name, c);
++		c = cppGetc ();
++	}
++	vStringTerminate (name);
++    cppGetc ();
++}
++
++static void readVersion (statementInfo *const st)
++{
++    tokenInfo *const token = activeToken (st);
++	Assert (isType (token, TOKEN_KEYWORD));
++    skipToNonWhite ();
++	readVersionName (token, cppGetc ());
++	token->type = TOKEN_NAME;
++	st->declaration = DECL_VERSION;
++	st->gotName = TRUE;
++	st->haveQualifyingName = TRUE;
++}
++
+ static void processName (statementInfo *const st)
+ {
+ 	Assert (isType (activeToken (st), TOKEN_NAME));
+@@ -1744,6 +1857,7 @@
+ 		case KEYWORD_LOCAL:     setAccess (st, ACCESS_LOCAL);           break;
+ 		case KEYWORD_LONG:      st->declaration = DECL_BASE;            break;
+ 		case KEYWORD_OPERATOR:  readOperator (st);                      break;
++		case KEYWORD_MIXIN:		st->declaration = DECL_MIXIN; 			break;
+ 		case KEYWORD_PRIVATE:   setAccess (st, ACCESS_PRIVATE);         break;
+ 		case KEYWORD_PROGRAM:   st->declaration = DECL_PROGRAM;         break;
+ 		case KEYWORD_PROTECTED: setAccess (st, ACCESS_PROTECTED);       break;
+@@ -1760,17 +1874,23 @@
+ 		case KEYWORD_USING:     skipStatement (st);                     break;
+ 		case KEYWORD_VOID:      st->declaration = DECL_BASE;            break;
+ 		case KEYWORD_VOLATILE:  st->declaration = DECL_BASE;            break;
++		case KEYWORD_VERSION:	readVersion(st); 						break;
+ 		case KEYWORD_VIRTUAL:   st->implementation = IMP_VIRTUAL;       break;
+ 		case KEYWORD_WCHAR_T:   st->declaration = DECL_BASE;            break;
+-		
++		case KEYWORD_TEMPLATE: 	
++			if(isLanguage(Lang_d))
++				st->declaration = DECL_TEMPLATE;
++			break;
+ 		case KEYWORD_NAMESPACE: readPackageOrNamespace (st, DECL_NAMESPACE); break;
++		case KEYWORD_MODULE:
+ 		case KEYWORD_PACKAGE:   readPackageOrNamespace (st, DECL_PACKAGE);   break;
+ 		
+ 		case KEYWORD_EVENT:
+ 			if (isLanguage (Lang_csharp))
+ 				st->declaration = DECL_EVENT;
+ 			break;
+-
++		
++		case KEYWORD_ALIAS:
+ 		case KEYWORD_TYPEDEF:
+ 			reinitStatement (st, FALSE);
+ 			st->scope = SCOPE_TYPEDEF;
+@@ -1941,7 +2061,7 @@
+ 						vStringCat (Signature, token->name);
+ 					}
+ 					break;
+-
++				case KEYWORD_ALIAS:
+ 				case KEYWORD_CATCH:
+ 				case KEYWORD_CLASS:
+ 				case KEYWORD_EXPLICIT:
+@@ -2317,6 +2437,10 @@
+ 			st->gotParenName = TRUE;
+ 			if (! (c == '('  &&  info.nestedArgs))
+ 				st->isPointer = info.isPointer;
++			//if( c == '(' && isType (prev, TOKEN_NAME)){
++			//	st->declaration = DECL_FUNCTION_TEMPLATE;
++			//	copyToken (st->blockName, prev);
++			//}
+ 		}
+ 		else if (! st->gotArgs  &&  info.isParamList)
+ 		{
+@@ -2377,7 +2501,7 @@
+ 	else
+ 	{
+ 		cppUngetc (c);
+-		if ((isLanguage (Lang_cpp) || isLanguage (Lang_csharp))  &&
++		if ((isLanguage (Lang_cpp) || isLanguage (Lang_csharp) || isLanguage(Lang_d))  &&
+ 			inheritingDeclaration (st->declaration))
+ 		{
+ 			readParents (st, ':');
+@@ -2641,6 +2765,9 @@
+ {
+ 	switch (st->declaration)
+ 	{
++		case DECL_TEMPLATE:
++		case DECL_VERSION:
++			st->inFunction = FALSE;
+ 		case DECL_CLASS:
+ 		case DECL_ENUM:
+ 		case DECL_INTERFACE:
+@@ -2671,12 +2798,14 @@
+ 	const tokenInfo *const token = activeToken (st);
+ 	const tokenInfo *const prev  = prevToken (st, 1);
+ 	const tokenInfo *const prev2 = prevToken (st, 2);
+-
++	const tokenInfo *const prev3 = prevToken (st, 3);
+ 	switch (token->type)
+ 	{
+ 		case TOKEN_NAME:
+ 			if (insideEnumBody (st))
+ 				qualifyEnumeratorTag (st, token);
++			if (st->declaration == DECL_MIXIN)
++				makeTag (token, st, FALSE, TAG_MIXIN);
+ 			break;
+ #if 0
+ 		case TOKEN_PACKAGE:
+@@ -2687,17 +2816,27 @@
+ 		case TOKEN_BRACE_OPEN:
+ 			if (isType (prev, TOKEN_ARGS))
+ 			{
+-				if (st->haveQualifyingName)
++                if (st->declaration == DECL_TEMPLATE)
++                    qualifyBlockTag (st, prev2);
++                else if (st->declaration == DECL_FUNCTION_TEMPLATE) {
++                    qualifyFunctionTag (st, st->blockName);
++				}
++				else if (st->haveQualifyingName)
+ 				{
+-					if (! isLanguage (Lang_vera))
++					if (! isLanguage (Lang_vera) && st->declaration != DECL_CLASS)
+ 						st->declaration = DECL_FUNCTION;
+ 					if (isType (prev2, TOKEN_NAME))
+ 						copyToken (st->blockName, prev2);
+-					qualifyFunctionTag (st, prev2);
++					
++					if( st->declaration == DECL_CLASS)
++						qualifyBlockTag (st, prev2);
++					else
++						qualifyFunctionTag (st, prev2);
+ 				}
+ 			}
+ 			else if (isContextualStatement (st) ||
+ 					st->declaration == DECL_NAMESPACE ||
++					st->declaration == DECL_VERSION ||
+ 					st->declaration == DECL_PROGRAM)
+ 			{
+ 				if (isType (prev, TOKEN_NAME))
+@@ -2838,7 +2977,6 @@
+ 	Lang_c = language;
+ 	buildKeywordHash (language, 0);
+ }
+-
+ static void initializeCppParser (const langType language)
+ {
+ 	Lang_cpp = language;
+@@ -2851,16 +2989,23 @@
+ 	buildKeywordHash (language, 2);
+ }
+ 
++static void initializeDParser (const langType language)
++{
++	Lang_d = language;
++	buildKeywordHash (language, 3);
++}
++
++
+ static void initializeJavaParser (const langType language)
+ {
+ 	Lang_java = language;
+-	buildKeywordHash (language, 3);
++	buildKeywordHash (language, 4);
+ }
+ 
+ static void initializeVeraParser (const langType language)
+ {
+ 	Lang_vera = language;
+-	buildKeywordHash (language, 4);
++	buildKeywordHash (language, 5);
+ }
+ 
+ extern parserDefinition* CParser (void)
+@@ -2875,6 +3020,18 @@
+ 	return def;
+ }
+ 
++extern parserDefinition* DParser (void)
++{
++     static const char *const extensions [] = { "d", NULL };
++     parserDefinition* def = parserNew ("D");
++     def->kinds      = CKinds;
++     def->kindCount  = KIND_COUNT (CKinds);
++     def->extensions = extensions;
++     def->parser2    = findCTags;
++     def->initialize = initializeDParser;
++	return def;
++} 
++ 
+ extern parserDefinition* CppParser (void)
+ {
+ 	static const char *const extensions [] = {
+Gemeinsame Unterverzeichnisse: ctags-5.8.orig//gnu_regex und ctags-5.8//gnu_regex.
+diff -u ctags-5.8.orig//parsers.h ctags-5.8//parsers.h
+--- ctags-5.8.orig//parsers.h	2009-07-07 05:40:51.000000000 +0200
++++ ctags-5.8//parsers.h	2010-05-22 02:29:02.777030096 +0200
+@@ -26,6 +26,7 @@
+ 	CppParser, \
+ 	CsharpParser, \
+ 	CobolParser, \
++	DParser,\
+ 	DosBatchParser, \
+ 	EiffelParser, \
+ 	ErlangParser, \
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/nobuild/docutils-plantuml.patch	Sun Sep 30 15:25:11 2012 +0930
@@ -0,0 +1,108 @@
+Index: docutils/parsers/rst/directives/__init__.py
+===================================================================
+--- docutils/parsers/rst/directives/__init__.py	(revision 7515)
++++ docutils/parsers/rst/directives/__init__.py	(working copy)
+@@ -19,6 +19,7 @@
+ 
+ 
+ _directive_registry = {
++      'uml': ('uml', 'Uml'),
+       'attention': ('admonitions', 'Attention'),
+       'caution': ('admonitions', 'Caution'),
+       'code': ('body', 'CodeBlock'),
+Index: docutils/parsers/rst/directives/uml.py
+===================================================================
+--- docutils/parsers/rst/directives/uml.py	(revision 0)
++++ docutils/parsers/rst/directives/uml.py	(working copy)
+@@ -0,0 +1,64 @@
++# Author: mauriciocap <mauriciocap@gmail.com>
++# Copyright: inherited from docutils.sf.net
++# MCAP
++
++"""
++Directive to generate uml diagrams using plantuml
++
++Options:
++  - path: prefix without extension (e.g. "images/login" will generate images/login.txt and images/login.png" ). Files will usualy be OVERWRITEN. But: if no content is specified and .txt file exists, png will be generated from this txt
++"""
++
++__docformat__ = 'reStructuredText'
++
++from docutils.parsers.rst.directives.images import Image
++from docutils.parsers.rst import directives
++from docutils._compat import b
++import os
++
++import sys
++
++class Uml(Image):
++    required_arguments = 0
++    optional_arguments = 1
++    option_spec = Image.option_spec.copy()
++    has_content = True
++
++    def run(self):
++        fname= "uml/%06d" % self.lineno #A: default
++        if (len(self.arguments)>0):
++            fname= self.arguments[0]
++        #A: path contains the path for the txt and image without extension
++        (fnameOutDir, fnameBase)= os.path.split(fname)
++        txtFname= fname+".txt"
++        imgFname= fname+".png"
++        if self.content:
++            os.path.isdir(fnameOutDir) or os.mkdir(fnameOutDir)
++            #A: fnameOutDir exists, BUT only ONE level will be created
++            fo= open(txtFname,"wb")
++            fo.write(b('@startuml\n'))
++            try:
++                fo.write(b(self.state_machine.document.settings.plantuml_hdr+'\n'))
++            except AttributeError:
++                pass
++
++            fo.write(b('\n'.join(self.content)))
++
++            fo.write(b("\n@enduml\n"))
++            fo.close()
++            #A: txt file OVERWRITEN!
++        if (not self.state.document.settings.file_insertion_enabled):
++            warning = self.state_machine.reporter.warning(
++              'File and URL access deactivated; ignoring "%s" '
++              'directive.' % self.name, nodes.literal_block(
++                    self.block_text, self.block_text), line=self.lineno)
++            return [warning]
++
++        plantumlCmd= "plantuml %s"
++        try:
++            plantumlCmd= self.state_machine.document.settings.plantuml_cmd
++        except AttributeError:
++            pass
++        os.system(plantumlCmd % txtFname)
++        self.arguments= [imgFname]
++        return Image.run(self)
+Index: docutils/parsers/rst/languages/en.py
+===================================================================
+--- docutils/parsers/rst/languages/en.py	(revision 7515)
++++ docutils/parsers/rst/languages/en.py	(working copy)
+@@ -51,6 +51,7 @@
+       #'imagemap': 'imagemap',
+       'image': 'image',
+       'figure': 'figure',
++      'uml': 'uml', #MCAP
+       'include': 'include',
+       'raw': 'raw',
+       'replace': 'replace',
+Index: go.sh
+===================================================================
+--- go.sh	(revision 0)
++++ go.sh	(working copy)
+@@ -0,0 +1,3 @@
++#!/bin/bash
++
++./setup.py build --force && ./setup.py install --prefix=${HOME}/local
+
+Property changes on: go.sh
+___________________________________________________________________
+Added: svn:executable
+## -0,0 +1 ##
++*
+\ No newline at end of property
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/nobuild/dot-Xresources	Sun Sep 30 15:25:11 2012 +0930
@@ -0,0 +1,95 @@
+! scrollbar style - rxvt (default), plain (most compact), next, or xterm
+URxvt.scrollstyle:          plain
+URxvt.secondaryScroll:      true
+URxvt*scrollBar_right:      true
+
+!URxvt.font:                 xft:Source Code Pro:size=10
+!URxvt.boldFont:             xft:Source Sans Pro:size=10
+!URxvt.italicFont:           xft:Source Sans Pro:size=10
+!URxvt.boldItalicFont:       xft:Source Sans Pro:size=10
+
+URxvt.font:                 xft:inconsolata:size=12
+!URxvt.boldFont:             xft:inconsolata:bold:size=12
+!URxvt.italicFont:           xft:inconsolata:bold:size=12
+!URxvt.boldItalicFont:       xft:inconsolata:bold:size=12
+
+!URxvt.font:                 xft:mensch:size=10
+!URxvt.boldFont:             xft:mensch:bold:size=10
+!URxvt.font:                 xft:DejaVu Sans Mono:pixelsize=15:antialias=true:hinting=true
+!URxvt*boldFont:             xft:DejaVu Sans Mono:bold:pixelsize=15:antialias=true:hinting=true
+!URxvt*font:                 xft:Bitstream Vera Sans Mono:pixelsize=14:antialias=true:hinting=true
+!URxvt*boldFont:             xft:Bitstream Vera Sans Mono:bold:pixelsize=14:antialias=true:hinting=true
+!URxvt*font:                 xft:Liberation Mono:pixelsize=13:antialias=true:hinting=true
+!URxvt*boldFont:             xft:Liberation Mono:bold:pixelsize=13:antialias=true:hinting=true
+!URxvt*font:                 xft:terminus:pixelsize=15
+!URxvt*boldFont:             xft:terminus:bold:pixelsize=15
+!URxvt*font:                 -*-courier-medium-r-normal-*-14-*-*-*-*-*-iso8859-1
+!URxvt*boldFont:             -*-courier-bold-r-normal-*-14-*-*-*-*-*-iso8859-1
+
+!URxvt.termName:             screen-256color
+
+URxvt.saveLines:            8192
+URxvt.geometry:             80x50
+URxvt.visualBell:           true
+
+URxvt.cutchars:             "()*,<>[]{}|:"
+
+URxvt.pointerBlank:         true
+URxvt.pointerBlankDelay:    1
+
+! Underline cursor (instead of solid)
+URxvt.cursorUnderline:      false
+
+URxvt.perl-ext-common:      default,matcher
+URxvt.urlLauncher:          firefox
+URxvt.matcher.button:       3
+
+URxvt.internalBorder:       1
+URxvt.externalBorder:       0
+
+!URxvt.perl-ext-common:      default,tabbed
+
+!URxvt.depth: 32
+!URxvt.transparent: true
+! URxvt.shading: 0 to 99 darkens, 101 to 200 lightens
+!URxvt.shading: 170
+
+URxvt.pointerColor:         #000000
+URxvt.pointerColor2:        #aaaaaa
+! cursor background
+URxvt.cursorColor:          #ff55ff
+! cursor foreground (ie, color of text behind cursor)
+URxvt.cursorColor2:         #000000
+! foreground during inverted selection (vim visual select) !!!!!!!  URxvt.throughColor:         #ff2222
+! background during non-inverted selection (mouse selection)
+URxvt.highlightColor:       #333333
+! foreground during non-inverted selection (mouse selection)
+!URxvt.highlightTextColor:   #ff0000
+! underline
+URxvt.underlineColor:       #ffff00
+! default background
+URxvt.background:           #0e0e18
+! default text
+URxvt.foreground:           #ffffee
+URxvt.color0:               #000000
+URxvt.color1:               #dc74d1
+URxvt.color2:               #0eb8c7
+URxvt.color3:               #dfe37e
+URxvt.color4:               Cyan3
+URxvt.color5:               #9e88f0
+URxvt.color6:               #73f7ff
+URxvt.color7:               #e1dddd
+URxvt.color8:               #8b8f93
+URxvt.color9:               #dc74d1
+URxvt.color10:              #0eb8c7
+URxvt.color11:              #dfe37e
+! ls directory
+URxvt.color12:              #3333ff
+URxvt.color13:              #9e88f0
+URxvt.color14:              #73f7ff
+URxvt.color15:              #e1dddd
+! Can also do colorBD and colorUL
+
+URxvt.scrollColor:          #999999
+URxvt.borderColor:          #222222
+!URxvt.troughColor:          #ff0000
--- a/nobuild/dot-bashrc	Wed Sep 26 17:36:31 2012 +0930
+++ b/nobuild/dot-bashrc	Sun Sep 30 15:25:11 2012 +0930
@@ -1,173 +1,25 @@
-# ~/.bashrc: executed by bash(1) for non-login shells.
-# see /usr/share/doc/bash/examples/startup-files (in the package bash-doc)
-# for examples
+#
+# ~/.bashrc
+#
 
 # If not running interactively, don't do anything
-[ -z "$PS1" ] && return
-
-# don't put duplicate lines in the history. See bash(1) for more options
-# ... or force ignoredups and ignorespace
-HISTCONTROL=ignoredups:ignorespace
-
-# append to the history file, don't overwrite it
-shopt -s histappend
-
-# for setting history length see HISTSIZE and HISTFILESIZE in bash(1)
-HISTSIZE=1000
-HISTFILESIZE=2000
-
-# check the window size after each command and, if necessary,
-# update the values of LINES and COLUMNS.
-shopt -s checkwinsize
-
-# make less more friendly for non-text input files, see lesspipe(1)
-[ -x /usr/bin/lesspipe ] && eval "$(SHELL=/bin/sh lesspipe)"
-
-# set variable identifying the chroot you work in (used in the prompt below)
-if [ -z "$debian_chroot" ] && [ -r /etc/debian_chroot ]; then
-    debian_chroot=$(cat /etc/debian_chroot)
-fi
-
-# set a fancy prompt (non-color, unless we know we "want" color)
-case "$TERM" in
-    xterm-color) color_prompt=yes;;
-esac
+[[ $- != *i* ]] && return
 
-# uncomment for a colored prompt, if the terminal has the capability; turned
-# off by default to not distract the user: the focus in a terminal window
-# should be on the output of commands, not on the prompt
-force_color_prompt=yes
-
-if [ -n "$force_color_prompt" ]; then
-    if [ -x /usr/bin/tput ] && tput setaf 1 >&/dev/null; then
-	# We have color support; assume it's compliant with Ecma-48
-	# (ISO/IEC-6429). (Lack of such support is extremely rare, and such
-	# a case would tend to support setf rather than setaf.)
-	color_prompt=yes
-    else
-	color_prompt=
-    fi
-fi
-
-if [ "$color_prompt" = yes ]; then
-    PS1='${debian_chroot:+($debian_chroot)}\[\033[01;32m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\]\$ '
-else
-    PS1='${debian_chroot:+($debian_chroot)}\u@\h:\w\$ '
-fi
-unset color_prompt force_color_prompt
-
-# If this is an xterm set the title to user@host:dir
-case "$TERM" in
-xterm*|rxvt*)
-    PS1="\[\e]0;${debian_chroot:+($debian_chroot)}\u@\h: \w\a\]$PS1"
-    ;;
-*)
-    ;;
-esac
+alias ls='ls --color=auto'
+PS1='[\u@\h \W]\$ '
 
-# enable color support of ls and also add handy aliases
-if [ -x /usr/bin/dircolors ]; then
-    test -r ~/.dircolors && eval "$(dircolors -b ~/.dircolors)" || eval "$(dircolors -b)"
-    alias ls='ls --color=auto'
-    #alias dir='dir --color=auto'
-    #alias vdir='vdir --color=auto'
-
-    alias grep='grep --color=auto'
-    alias fgrep='fgrep --color=auto'
-    alias egrep='egrep --color=auto'
-fi
-
-# some more ls aliases
-#alias ll='ls -alF'
-#alias la='ls -A'
-#alias l='ls -CF'
-
-# Add an "alert" alias for long running commands.  Use like so:
-#   sleep 10; alert
-alias alert='notify-send --urgency=low -i "$([ $? = 0 ] && echo terminal || echo error)" "$(history|tail -n1|sed -e '\''s/^\s*[0-9]\+\s*//;s/[;&|]\s*alert$//'\'')"'
-
-# Alias definitions.
-# You may want to put all your additions into a separate file like
-# ~/.bash_aliases, instead of adding them here directly.
-# See /usr/share/doc/bash-doc/examples in the bash-doc package.
-
-if [ -f ~/.bash_aliases ]; then
-    . ~/.bash_aliases
-fi
-
-# enable programmable completion features (you don't need to enable
-# this, if it's already enabled in /etc/bash.bashrc and /etc/profile
-# sources /etc/bash.bashrc).
-if [ -f /etc/bash_completion ] && ! shopt -oq posix; then
-    . /etc/bash_completion
-fi
-
-alias mv='mv -i'
-alias cp='cp -i'
-alias ls='ls --color=auto'
-alias grep='grep --color=auto'
-#alias w2do='w2do --colour'
-alias word='wine /home/daveb/.wine/drive_c/Program\ Files/Microsoft\ Office/OFFICE11/WINWORD.EXE > /dev/null 2>&1'
-alias mr='mr -ptq'
-
-setup_local() {
-    local LOCAL=$1
-    shift
-    PATH="${LOCAL}/bin:${PATH}"
-
-    for i in $*; do
-        case "$i" in
-        pk)
-            export PKG_CONFIG_PATH="${LOCAL}/lib/pkgconfig:${PKG_CONFIG_PATH}"
-            ;;
-        ld)
-            export LD_LIBRARY_PATH="${LOCAL}/lib:${LD_LIBRARY_PATH}"
-            ;;
-        py)
-            export PYTHONPATH="${LOCAL}/lib/python2.6/site-packages:${PYTHONPATH}"
-            ;;
-        ac)
-            export ACLOCAL_FLAGS="-I ${LOCAL}/share/aclocal ${ACLOCAL_FLAGS}"
-            ;;
-        *)
-            echo "Unhandled flag in setup_local: $i"
-            ;;
-        esac
-    done
+# Generate new tags file
+# ctags --list-kinds=c
+#   --c-kinds=+px-d -> prototypes and external variable declarations to the default set of tag kinds, but exclude macros
+# cscope
+#  -b  -> build the cross-reference only, ie don't run CLI
+#  -i- -> file list given on stdin
+retags () {
+    find . -regextype posix-awk -type f -regex ".*\.(h|c|cc|cpp)" | ctags -L- --extra=+f --c-kinds=+pxdm -f TAGS ;
+    find . -regextype posix-awk -type f -regex ".*\.(h|c|cc|cpp)" | cscope -b -i- ;
 }
 
-setup_local "${HOME}/local/inkscape" ld
-#setup_local "${HOME}/local/wine"
-#setup_local "${HOME}/local/gimp"
-#setup_local "/opt/acacia/ace"
-#setup_local "${HOME}/local/gstreamer"
-#setup_local "${HOME}/local/e"
-#setup_local "/opt/acacia/legacy/aesop"
-#setup_local "/opt/acacia/legacy/eugene-1.0"
-#setup_local "/opt/acacia/legacy/scimers"
-PATH="${HOME}/source/d/dmd/bin:${PATH}"
-#PATH="/opt/Adobe/Reader9/bin:${PATH}"
-
-export EDITOR="vim"
-#export CC="colorgcc"
-
-# ACE/TAO support
-
-#export ACE_ROOT="/opt/acacia/ace"
-#export TAO_ROOT="${ACE_ROOT}/TAO"
-#export LD_LIBRARY_PATH="${ACE_ROOT}/lib:${LD_LIBRARY_PATH}"
-#export CPATH="${ACE_ROOT}/include"
-#PATH="${ACE_ROOT}/bin:${PATH}"
-
-# Android support
-#PATH=${PATH}:${HOME}/android-sdk-linux_86/tools
-
-#
-# Functions
-#
-
 # Support for setting the title of the terminal tab
-# This is broken:
 function title() {
     unset PROMPT_COMMAND
     echo -ne "\033]0;$1\007"
@@ -216,3 +68,52 @@
     done
     echo "${result}"
 }
+
+# Support for local perl modules
+export PERL_LOCAL_LIB_ROOT="${HOME}/local";
+export PERL_MB_OPT="--install_base ${HOME}/local";
+export PERL_MM_OPT="INSTALL_BASE=${HOME}/local";
+export PERL5LIB="${HOME}/local/lib/perl5/x86_64-linux-gnu-thread-multi:${HOME}/local/lib/perl5";
+
+# Support for local python modules
+export PYTHONPATH="${HOME}/local/lib/python3.2/site-packages:/usr/lib/python3.2/site-packages"
+
+# Support for local binaries
+PATH=${HOME}/local/bin:${PATH}
+
+# Support for dmd compiler
+PATH="${HOME}/source/d/dmd/bin64:${PATH}"
+
+export GREP_OPTIONS="--color"
+export EDITOR="vim"
+export PAGER="less"
+
+alias cp="cp -i"
+alias mv="mv -i"
+alias grep='grep --color=auto'
+
+HISTIGNORE="&:ls:[bf]g:exit"
+HISTSIZE=10000
+HISTFILESIZE=20000
+HISTCONTROL=erasedups:ignorespace
+shopt -s cmdhist
+#shopt -s emacs
+shopt -s histappend
+
+# check the window size after each command and, if necessary,
+# update the values of LINES and COLUMNS.
+shopt -s checkwinsize
+
+stty -ixon          # disable flow control so CTRL-s works in bash history
+
+# https://bbs.archlinux.org/viewtopic.php?id=50885
+#PS1='\[\e[1;35m\]\u\[\e[m\] \[\e[1;34m\]\W\[\e[m\] \[\e[1;31m\]> \[\e[0m\]'
+PS1='\n\[\033[0;32m\]\u@\h \[\033[1;33m\]\w\n\[\033[0m\]> '
+#PS1='\[\033[1;31m\]\W/\[\033[0m\] '
+#PS1='[\[\033[1;36m\]\u\[\033[0m\]@\h \W]\$ '
+#PS1='\[\e[0;36m\]\h\[\e[m\]-\[\e[0;37m\]\u\[\e[m\]\[\e[0;37m\] \w:\n> '
+
+PS2='\\ '
+
+#echo "some unicode: ? ? ? ? ? ? "
+#echo "URL: http://slashdot.org/"