# HG changeset patch # User David Bryant # Date 1348984511 -34200 # Node ID 9a9dcae45e084c44c02353b62a8da62df35fb043 # Parent 752676232e4b0bacc0151955b5b908d8b14fe172 Misc support file changes diff -r 752676232e4b -r 9a9dcae45e08 nobuild/Boboptions --- 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 ; diff -r 752676232e4b -r 9a9dcae45e08 nobuild/ctags.patch --- /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, \ + diff -r 752676232e4b -r 9a9dcae45e08 nobuild/docutils-plantuml.patch --- /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 ++# 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 diff -r 752676232e4b -r 9a9dcae45e08 nobuild/dot-Xresources --- /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 diff -r 752676232e4b -r 9a9dcae45e08 nobuild/dot-bashrc --- 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/"