ctags.rb 1.0.19 → 1.1.3

data/ext/vendor/ctags/parsers/meta-cpreprocessor.h

@@ -0,0 +1,109 @@
+/*
+*   Copyright (c) 1998-2002, Darren Hiebert
+*
+*   This source code is released for free distribution under the terms of the
+*   GNU General Public License version 2 or (at your option) any later version.
+*
+*   External interface to get.c
+*/
+#ifndef CTAGS_MAIN_GET_H
+#define CTAGS_MAIN_GET_H
+
+/*
+*   INCLUDE FILES
+*/
+#include "general.h"  /* must always come first */
+#include "types.h"
+#include "vstring.h"
+
+/*
+*   MACROS
+*/
+/*  Is the character valid as a character of a C identifier?
+ *  VMS allows '$' in identifiers.
+ */
+#define cppIsident(c)  (isalnum(c) || (c) == '_' || (c) == '$')
+
+/*  Is the character valid as the first character of a C identifier?
+ *  C++ allows '~' in destructors.
+ *  VMS allows '$' in identifiers.
+ */
+#define cppIsident1(c)  ( ((c >= 0) && (c < 0x80) && isalpha(c)) \
+		       || (c) == '_' || (c) == '~' || (c) == '$')
+/* NOTE about isident1 profitability
+
+   Doing the same as isascii before passing value to isalpha
+   ----------------------------------------------------------
+   cppGetc() can return the value out of range of char.
+   cppGetc calls skipToEndOfString and skipToEndOfString can
+   return STRING_SYMBOL(== 338).
+
+   Depending on the platform, isalpha(338) returns different value .
+   As far as Fedora22, it returns 0. On Windows 2010, it returns 1.
+
+   man page on Fedora 22 says:
+
+       These functions check whether c, which must have the value of an
+       unsigned char or EOF, falls into a certain character class
+       according to the specified locale.
+
+   isascii is for suitable to verify the range of input. However, it
+   is not portable enough. */
+
+#define RoleTemplateUndef { true, "undef", "undefined" }
+
+#define RoleTemplateSystem { true, "system", "system header" }
+#define RoleTemplateLocal  { true, "local", "local header" }
+
+/*
+*   FUNCTION PROTOTYPES
+*/
+extern bool cppIsBraceFormat (void);
+extern unsigned int cppGetDirectiveNestLevel (void);
+
+extern void cppInit (const bool state,
+		     const bool hasAtLiteralStrings,
+		     const bool hasCxxRawLiteralStrings,
+		     const bool hasSingleQuoteLiteralNumbers,
+		     const kindOption *defineMacroKind,
+		     int macroUndefRoleIndex,
+		     const kindOption *headerKind,
+		     int headerSystemRoleIndex, int headerLocalRoleIndex);
+extern void cppTerminate (void);
+extern void cppBeginStatement (void);
+extern void cppEndStatement (void);
+extern void cppUngetc (const int c);
+extern void cppUngetString(const char * string,int len);
+extern int cppGetc (void);
+extern int cppSkipOverCComment (void);
+
+#define CPP_MACRO_REPLACEMENT_FLAG_VARARGS 1
+#define CPP_MACRO_REPLACEMENT_FLAG_STRINGIFY 2
+
+typedef struct sCppMacroReplacementPartInfo {
+	int parameterIndex; /* -1 if this part is a constant */
+	int flags;
+	vString * constant; /* not NULL only if parameterIndex != -1 */
+	struct sCppMacroReplacementPartInfo * next;
+} cppMacroReplacementPartInfo;
+
+typedef struct sCppMacroInfo {
+	bool hasParameterList; /* true if the macro has a trailing () */
+	cppMacroReplacementPartInfo * replacements;
+} cppMacroInfo;
+
+extern const cppMacroInfo * cppFindMacro (const char *const name);
+
+/*
+* Build a replacement string for the specified macro.
+* If the macro has parameters, they will be used.
+* Parameters not found in the list will be assumed to be empty.
+* May return NULL or equivalently an empty replacement string.
+*/
+extern vString * cppBuildMacroReplacement(
+		const cppMacroInfo * macro,
+		const char ** parameters, /* may be NULL */
+		int parameterCount
+	);
+
+#endif  /* CTAGS_MAIN_GET_H */

data/ext/vendor/ctags/parsers/meta-iniconf.h

@@ -0,0 +1,48 @@
+/*
+*
+*   Copyright (c) 2000-2001, Darren Hiebert
+*
+*   This source code is released for free distribution under the terms of the
+*   GNU General Public License version 2 or (at your option) any later version.
+*
+*   This module contains functions for generating tags for ini/config files.
+*/
+
+/*
+ *  This is based on geany's conf.c:
+ * --------------------------------
+ * commit 3af538fa65f8b17897259080db8144b1edc43470
+ * Author: Enrico Tröger <enrico.troeger@uvena.de>
+ * Date:   Sun Nov 27 20:39:57 2005 +0000
+ *
+ * added tag support for filetype Conf
+lang *
+ *
+ * git-svn-id: https://geany.svn.sourceforge.net/svnroot/geany/trunk@15 ea778897-0a13-0410-b9d1-a72fbfd435f5
+ *
+ */
+
+#ifndef CTAGS_INITCONF_H
+#define CTAGS_INITCONF_H
+
+#include "general.h"
+
+#include "types.h"
+
+
+typedef void (*iniconfCallback) (const char *section, const char *key, const char *value, void *userData);
+
+
+struct iniconfParserClient {
+	langType lang;
+	void *data;
+
+	void* (* inputStart) (void);
+	bool (* probeLanguage) (const char *section, const char *key, const char *value);
+	iniconfCallback handleInputData;
+};
+
+extern void registerIniconfParserClient (struct iniconfParserClient *client);
+extern void runIniconfParser (const iniconfCallback callback, void* userData);
+
+#endif

data/ext/vendor/ctags/parsers/meta-m4.h

@@ -0,0 +1,56 @@
+/*
+*   Copyright (c) 2016, Masatake YAMATO
+*
+*   This source code is released for free distribution under the terms of the
+*   GNU General Public License version 2 or (at your option) any later version.
+*
+*   This module contains functions for generating tags for makefiles.
+*/
+
+#ifndef CTAGS_PARSER_M4_H
+#define CTAGS_PARSER_M4_H
+
+/*
+*   INCLUDE FILES
+*/
+#include "general.h"  /* must always come first */
+#include "types.h"
+#include "vstring.h"
+
+struct m4HandleTokenResult
+{
+	int index;
+	bool consumed;
+};
+
+struct m4ParserClient
+{
+	langType lang;
+	void *data;
+
+	const char quoteOpen;
+	const char quoteClose;
+
+	/* Do something for new input file. Returned value is stored to
+	   `data' field. */
+	void*   (* inputStart) (void);
+	bool (* doesStartLineComment) (int c, const char *token, void *data);
+	bool (* doesStartStringLiteral) (int c, void *data);
+
+	/* If the token is the part of the language the parser deals with,
+	   return true. This can be called before `inputStart' method. */
+	bool (* probeLanguage) (const char* token);
+
+	struct m4HandleTokenResult (* handleMacro) (const char* token, void *data);
+
+	struct m4ParserClient *host; /* Used internally */
+};
+
+/* The entry points for m4 meta parser */
+extern void registerM4ParserClient (const char *hostLang, struct m4ParserClient *client);
+extern void runM4Parser (langType lang);
+
+/* Helpers functions */
+extern bool readM4MacroArgument(vString *const arg);
+
+#endif

data/ext/vendor/ctags/parsers/meta-make.h

@@ -0,0 +1,30 @@
+/*
+*   Copyright (c) 2016, Masatake YAMATO
+*
+*   This source code is released for free distribution under the terms of the
+*   GNU General Public License version 2 or (at your option) any later version.
+*
+*   This module contains functions for generating tags for makefiles.
+*/
+
+#ifndef CTAGS_PARSER_MAKE_H
+#define CTAGS_PARSER_MAKE_H
+
+/*
+*   INCLUDE FILES
+*/
+#include "general.h"  /* must always come first */
+#include "vstring.h"
+
+struct makeParserClient {
+	void (* valuesFound) (struct makeParserClient*, vString *name, void *data);
+	void (* directiveFound) (struct makeParserClient*, vString *name, void *data);
+	void (* newMacro) (struct makeParserClient*,
+			   vString *const name,
+			   bool withDefineDirective,
+			   bool appending, void *data);
+};
+
+extern void runMakeParser (struct makeParserClient *client, void *data);
+
+#endif

data/ext/vendor/ctags/parsers/meta-yaml.h

@@ -0,0 +1,37 @@
+/*
+ *
+ *   Copyright (c) 2016, Masatake YAMATO
+ *   Copyright (c) 2016, Red Hat, K.K.
+ *
+ *   This source code is released for free distribution under the terms of the
+ *   GNU General Public License version 2 or (at your option) any later version.
+ *
+ */
+
+#ifndef CTAGS_YAML__H
+#define CTAGS_YAML__H
+
+#include "general.h"
+#include "types.h"
+
+#ifdef HAVE_LIBYAML
+#include <yaml.h>
+#else
+#define yaml_token_t void
+#endif
+
+typedef void (* yamlCallback) (yaml_token_t *token, void *data);
+
+struct yamlParserClient {
+	langType lang;
+	yamlCallback callback;
+	void* (* inputStart) (void);
+	void  (* inputEnd) (void*);
+	void *data;
+};
+
+extern void registerYamlParserClient (struct yamlParserClient *client);
+extern void runYamlParser (const yamlCallback callback, void* userData);
+extern void attachYamlPosition (tagEntryInfo *tag, yaml_token_t *token, bool asEndPosition);
+
+#endif

data/ext/vendor/ctags/parsers/myrddin.c

@@ -0,0 +1,51 @@
+/*
+ *   Copyright (c) 2016, Ori Bernstein
+ *
+ *   This source code is released for free distribution under the terms of the
+ *   GNU General Public License version 2 or (at your option) any later version.
+ *
+ *   This module contains functions for generating tags for Myrddin language
+ *   files. (https://myrlang.org)
+ */
+
+/*
+ *   INCLUDE FILES
+ */
+#include "general.h"  /* must always come first */
+#include "parse.h"
+
+static tagRegexTable myrddinTagRegexTable [] = {
+	/* const foo = {; function literal } */
+	{"^([ \t]*extern)?[ \t]*const[ \t]+([a-zA-Z_][a-zA-Z0-9_]*)[ \t]*=[ \t]\\{",
+		"\\2", "f,function,functions", NULL},
+	/* const foo = initializer */
+	{"^([ \t]*extern)?[ \t]*const[ \t]+([a-zA-Z_][a-zA-Z0-9_]*)[ \t]*(=[ \t][^{].*)?$",
+		"\\2", "c,constant,constants", NULL},
+	/* var foo = initializer */
+	{"^([ \t]*extern)?[ \t]*var[ \t]+([a-zA-Z_][a-zA-Z0-9_]*)",
+		"\\2", "v,var,variables", NULL},
+	/* type foo = name */
+	{"^[ \t]*type[ \t]+([a-zA-Z_][a-zA-Z0-9_]*)[ \t]*=",
+		"\\1", "t,type,types", NULL},
+	/* trait foo = trait-defn ;; */
+	{"^[ \t]*trait[ \t]+([a-zA-Z_][a-zA-Z0-9_]*)[ \t]*=",
+		"\\1", "r,trait,traits", NULL},
+	/* pkg foo = declarations ;; */
+	{"^[ \t]*pkg[ \t]+([a-zA-Z_][a-zA-Z0-9_]*)",
+		"\\1", "p,pkg,packages", NULL},
+};
+
+/*
+ *   FUNCTION DEFINITIONS
+ */
+
+extern parserDefinition *MyrddinParser (void)
+{
+	static const char *const extensions [] = { "myr", NULL };
+	parserDefinition* const def = parserNew ("Myrddin");
+	def->extensions = extensions;
+	def->tagRegexTable = myrddinTagRegexTable;
+	def->tagRegexCount = ARRAY_SIZE (myrddinTagRegexTable);
+	def->method     = METHOD_NOT_CRAFTED|METHOD_REGEX;
+	return def;
+}

data/ext/vendor/ctags/parsers/objc.c

@@ -0,0 +1,1130 @@
+
+/*
+*   Copyright (c) 2010, Vincent Berthoux
+*
+*   This source code is released for free distribution under the terms of the
+*   GNU General Public License version 2 or (at your option) any later version.
+*
+*   This module contains functions for generating tags for Objective C
+*   language files.
+*/
+/*
+*   INCLUDE FILES
+*/
+#include "general.h"	/* must always come first */
+
+#include <string.h>
+
+#include "keyword.h"
+#include "entry.h"
+#include "options.h"
+#include "read.h"
+#include "routines.h"
+#include "selectors.h"
+#include "vstring.h"
+
+typedef enum {
+	K_INTERFACE,
+	K_IMPLEMENTATION,
+	K_PROTOCOL,
+	K_METHOD,
+	K_CLASSMETHOD,
+	K_VAR,
+	K_FIELD,
+	K_FUNCTION,
+	K_PROPERTY,
+	K_TYPEDEF,
+	K_STRUCT,
+	K_ENUM,
+	K_MACRO
+} objcKind;
+
+static kindOption ObjcKinds[] = {
+	{true, 'i', "interface", "class interface"},
+	{true, 'I', "implementation", "class implementation"},
+	{true, 'P', "protocol", "Protocol"},
+	{true, 'm', "method", "Object's method"},
+	{true, 'c', "class", "Class' method"},
+	{true, 'v', "var", "Global variable"},
+	{true, 'F', "field", "Object field"},
+	{true, 'f', "function", "A function"},
+	{true, 'p', "property", "A property"},
+	{true, 't', "typedef", "A type alias"},
+	{true, 's', "struct", "A type structure"},
+	{true, 'e', "enum", "An enumeration"},
+	{true, 'M', "macro", "A preprocessor macro"},
+};
+
+typedef enum {
+	ObjcTYPEDEF,
+	ObjcSTRUCT,
+	ObjcENUM,
+	ObjcIMPLEMENTATION,
+	ObjcINTERFACE,
+	ObjcPROTOCOL,
+	ObjcENCODE,
+	ObjcSYNCHRONIZED,
+	ObjcSELECTOR,
+	ObjcPROPERTY,
+	ObjcEND,
+	ObjcDEFS,
+	ObjcCLASS,
+	ObjcPRIVATE,
+	ObjcPACKAGE,
+	ObjcPUBLIC,
+	ObjcPROTECTED,
+	ObjcSYNTHESIZE,
+	ObjcDYNAMIC,
+	ObjcOPTIONAL,
+	ObjcREQUIRED,
+	ObjcSTRING,
+	ObjcIDENTIFIER,
+
+	Tok_COMA,	/* ',' */
+	Tok_PLUS,	/* '+' */
+	Tok_MINUS,	/* '-' */
+	Tok_PARL,	/* '(' */
+	Tok_PARR,	/* ')' */
+	Tok_CurlL,	/* '{' */
+	Tok_CurlR,	/* '}' */
+	Tok_SQUAREL,	/* '[' */
+	Tok_SQUARER,	/* ']' */
+	Tok_semi,	/* ';' */
+	Tok_dpoint,	/* ':' */
+	Tok_Sharp,	/* '#' */
+	Tok_Backslash,	/* '\\' */
+	Tok_EOL,	/* '\r''\n' */
+	Tok_any,
+
+	Tok_EOF	/* END of file */
+} objcKeyword;
+
+typedef objcKeyword objcToken;
+
+static const keywordTable objcKeywordTable[] = {
+	{"typedef", ObjcTYPEDEF},
+	{"struct", ObjcSTRUCT},
+	{"enum", ObjcENUM},
+	{"@implementation", ObjcIMPLEMENTATION},
+	{"@interface", ObjcINTERFACE},
+	{"@protocol", ObjcPROTOCOL},
+	{"@encode", ObjcENCODE},
+	{"@property", ObjcPROPERTY},
+	{"@synchronized", ObjcSYNCHRONIZED},
+	{"@selector", ObjcSELECTOR},
+	{"@end", ObjcEND},
+	{"@defs", ObjcDEFS},
+	{"@class", ObjcCLASS},
+	{"@private", ObjcPRIVATE},
+	{"@package", ObjcPACKAGE},
+	{"@public", ObjcPUBLIC},
+	{"@protected", ObjcPROTECTED},
+	{"@synthesize", ObjcSYNTHESIZE},
+	{"@dynamic", ObjcDYNAMIC},
+	{"@optional", ObjcOPTIONAL},
+	{"@required", ObjcREQUIRED},
+};
+
+static langType Lang_ObjectiveC;
+
+/*//////////////////////////////////////////////////////////////////
+//// lexingInit             */
+typedef struct _lexingState {
+	vString *name;	/* current parsed identifier/operator */
+	const unsigned char *cp;	/* position in stream */
+} lexingState;
+
+/*//////////////////////////////////////////////////////////////////////
+//// Lexing                                     */
+static bool isNum (char c)
+{
+	return c >= '0' && c <= '9';
+}
+
+static bool isLowerAlpha (char c)
+{
+	return c >= 'a' && c <= 'z';
+}
+
+static bool isUpperAlpha (char c)
+{
+	return c >= 'A' && c <= 'Z';
+}
+
+static bool isAlpha (char c)
+{
+	return isLowerAlpha (c) || isUpperAlpha (c);
+}
+
+static bool isIdent (char c)
+{
+	return isNum (c) || isAlpha (c) || c == '_';
+}
+
+static bool isSpace (char c)
+{
+	return c == ' ' || c == '\t';
+}
+
+/* return true if it end with an end of line */
+static void eatWhiteSpace (lexingState * st)
+{
+	const unsigned char *cp = st->cp;
+	while (isSpace (*cp))
+		cp++;
+
+	st->cp = cp;
+}
+
+static void eatString (lexingState * st)
+{
+	bool lastIsBackSlash = false;
+	bool unfinished = true;
+	const unsigned char *c = st->cp + 1;
+
+	while (unfinished)
+	{
+		/* end of line should never happen.
+		 * we tolerate it */
+		if (c == NULL || c[0] == '\0')
+			break;
+		else if (*c == '"' && !lastIsBackSlash)
+			unfinished = false;
+		else
+			lastIsBackSlash = *c == '\\';
+
+		c++;
+	}
+
+	st->cp = c;
+}
+
+static void eatComment (lexingState * st)
+{
+	bool unfinished = true;
+	bool lastIsStar = false;
+	const unsigned char *c = st->cp + 2;
+
+	while (unfinished)
+	{
+		/* we've reached the end of the line..
+		 * so we have to reload a line... */
+		if (c == NULL || *c == '\0')
+		{
+			st->cp = readLineFromInputFile ();
+			/* WOOPS... no more input...
+			 * we return, next lexing read
+			 * will be null and ok */
+			if (st->cp == NULL)
+				return;
+			c = st->cp;
+		}
+		/* we've reached the end of the comment */
+		else if (*c == '/' && lastIsStar)
+			unfinished = false;
+		else
+		{
+			lastIsStar = '*' == *c;
+			c++;
+		}
+	}
+
+	st->cp = c;
+}
+
+static void readIdentifier (lexingState * st)
+{
+	const unsigned char *p;
+	vStringClear (st->name);
+
+	/* first char is a simple letter */
+	if (isAlpha (*st->cp) || *st->cp == '_')
+		vStringPut (st->name, (int) *st->cp);
+
+	/* Go till you get identifier chars */
+	for (p = st->cp + 1; isIdent (*p); p++)
+		vStringPut (st->name, (int) *p);
+
+	st->cp = p;
+}
+
+/* read the @something directives */
+static void readIdentifierObjcDirective (lexingState * st)
+{
+	const unsigned char *p;
+	vStringClear (st->name);
+
+	/* first char is a simple letter */
+	if (*st->cp == '@')
+		vStringPut (st->name, (int) *st->cp);
+
+	/* Go till you get identifier chars */
+	for (p = st->cp + 1; isIdent (*p); p++)
+		vStringPut (st->name, (int) *p);
+
+	st->cp = p;
+}
+
+/* The lexer is in charge of reading the file.
+ * Some of sub-lexer (like eatComment) also read file.
+ * lexing is finished when the lexer return Tok_EOF */
+static objcKeyword lex (lexingState * st)
+{
+	int retType;
+
+	/* handling data input here */
+	while (st->cp == NULL || st->cp[0] == '\0')
+	{
+		st->cp = readLineFromInputFile ();
+		if (st->cp == NULL)
+			return Tok_EOF;
+
+		return Tok_EOL;
+	}
+
+	if (isAlpha (*st->cp))
+	{
+		readIdentifier (st);
+		retType = lookupKeyword (vStringValue (st->name), Lang_ObjectiveC);
+
+		if (retType == -1)	/* If it's not a keyword */
+		{
+			return ObjcIDENTIFIER;
+		}
+		else
+		{
+			return retType;
+		}
+	}
+	else if (*st->cp == '@')
+	{
+		readIdentifierObjcDirective (st);
+		retType = lookupKeyword (vStringValue (st->name), Lang_ObjectiveC);
+
+		if (retType == -1)	/* If it's not a keyword */
+		{
+			return Tok_any;
+		}
+		else
+		{
+			return retType;
+		}
+	}
+	else if (isSpace (*st->cp))
+	{
+		eatWhiteSpace (st);
+		return lex (st);
+	}
+	else
+		switch (*st->cp)
+		{
+		case '(':
+			st->cp++;
+			return Tok_PARL;
+
+		case '\\':
+			st->cp++;
+			return Tok_Backslash;
+
+		case '#':
+			st->cp++;
+			return Tok_Sharp;
+
+		case '/':
+			if (st->cp[1] == '*')	/* ergl, a comment */
+			{
+				eatComment (st);
+				return lex (st);
+			}
+			else if (st->cp[1] == '/')
+			{
+				st->cp = NULL;
+				return lex (st);
+			}
+			else
+			{
+				st->cp++;
+				return Tok_any;
+			}
+			break;
+
+		case ')':
+			st->cp++;
+			return Tok_PARR;
+		case '{':
+			st->cp++;
+			return Tok_CurlL;
+		case '}':
+			st->cp++;
+			return Tok_CurlR;
+		case '[':
+			st->cp++;
+			return Tok_SQUAREL;
+		case ']':
+			st->cp++;
+			return Tok_SQUARER;
+		case ',':
+			st->cp++;
+			return Tok_COMA;
+		case ';':
+			st->cp++;
+			return Tok_semi;
+		case ':':
+			st->cp++;
+			return Tok_dpoint;
+		case '"':
+			eatString (st);
+			return Tok_any;
+		case '+':
+			st->cp++;
+			return Tok_PLUS;
+		case '-':
+			st->cp++;
+			return Tok_MINUS;
+
+		default:
+			st->cp++;
+			break;
+		}
+
+	/* default return if nothing is recognized,
+	 * shouldn't happen, but at least, it will
+	 * be handled without destroying the parsing. */
+	return Tok_any;
+}
+
+/*//////////////////////////////////////////////////////////////////////
+//// Parsing                                    */
+typedef void (*parseNext) (vString * const ident, objcToken what);
+
+/********** Helpers */
+/* This variable hold the 'parser' which is going to
+ * handle the next token */
+static parseNext toDoNext;
+
+/* Special variable used by parser eater to
+ * determine which action to put after their
+ * job is finished. */
+static parseNext comeAfter;
+
+/* Used by some parsers detecting certain token
+ * to revert to previous parser. */
+static parseNext fallback;
+
+
+/********** Grammar */
+static void globalScope (vString * const ident, objcToken what);
+static void parseMethods (vString * const ident, objcToken what);
+static void parseImplemMethods (vString * const ident, objcToken what);
+static vString *tempName = NULL;
+static vString *parentName = NULL;
+static objcKind parentType = K_INTERFACE;
+
+/* used to prepare tag for OCaml, just in case their is a need to
+ * add additional information to the tag. */
+static void prepareTag (tagEntryInfo * tag, vString const *name, objcKind kind)
+{
+	initTagEntry (tag, vStringValue (name), &(ObjcKinds[kind]));
+
+	if (parentName != NULL)
+	{
+		tag->extensionFields.scopeKind = &(ObjcKinds[parentType]);
+		tag->extensionFields.scopeName = vStringValue (parentName);
+	}
+}
+
+static void pushEnclosingContext (const vString * parent, objcKind type)
+{
+	vStringCopy (parentName, parent);
+	parentType = type;
+}
+
+static void popEnclosingContext (void)
+{
+	vStringClear (parentName);
+}
+
+/* Used to centralise tag creation, and be able to add
+ * more information to it in the future */
+static void addTag (vString * const ident, int kind)
+{
+	tagEntryInfo toCreate;
+
+	if (! ObjcKinds[kind].enabled)
+		return;
+
+	prepareTag (&toCreate, ident, kind);
+	makeTagEntry (&toCreate);
+}
+
+static objcToken waitedToken, fallBackToken;
+
+/* Ignore everything till waitedToken and jump to comeAfter.
+ * If the "end" keyword is encountered break, doesn't remember
+ * why though. */
+static void tillToken (vString * const ident CTAGS_ATTR_UNUSED, objcToken what)
+{
+	if (what == waitedToken)
+		toDoNext = comeAfter;
+}
+
+static void tillTokenOrFallBack (vString * const ident CTAGS_ATTR_UNUSED, objcToken what)
+{
+	if (what == waitedToken)
+		toDoNext = comeAfter;
+	else if (what == fallBackToken)
+	{
+		toDoNext = fallback;
+	}
+}
+
+static int ignoreBalanced_count = 0;
+static void ignoreBalanced (vString * const ident CTAGS_ATTR_UNUSED, objcToken what)
+{
+
+	switch (what)
+	{
+	case Tok_PARL:
+	case Tok_CurlL:
+	case Tok_SQUAREL:
+		ignoreBalanced_count++;
+		break;
+
+	case Tok_PARR:
+	case Tok_CurlR:
+	case Tok_SQUARER:
+		ignoreBalanced_count--;
+		break;
+
+	default:
+		/* don't care */
+		break;
+	}
+
+	if (ignoreBalanced_count == 0)
+		toDoNext = comeAfter;
+}
+
+static void parseFields (vString * const ident, objcToken what)
+{
+	switch (what)
+	{
+	case Tok_CurlR:
+		toDoNext = &parseMethods;
+		break;
+
+	case Tok_SQUAREL:
+	case Tok_PARL:
+		toDoNext = &ignoreBalanced;
+		comeAfter = &parseFields;
+		break;
+
+		/* we got an identifier, keep track of it */
+	case ObjcIDENTIFIER:
+		vStringCopy (tempName, ident);
+		break;
+
+		/* our last kept identifier must be our variable name =) */
+	case Tok_semi:
+		addTag (tempName, K_FIELD);
+		vStringClear (tempName);
+		break;
+
+	default:
+		/* NOTHING */
+		break;
+	}
+}
+
+static objcKind methodKind;
+
+
+static vString *fullMethodName;
+static vString *prevIdent;
+
+static void parseMethodsName (vString * const ident, objcToken what)
+{
+	switch (what)
+	{
+	case Tok_PARL:
+		toDoNext = &tillToken;
+		comeAfter = &parseMethodsName;
+		waitedToken = Tok_PARR;
+		break;
+
+	case Tok_dpoint:
+		vStringCat (fullMethodName, prevIdent);
+		vStringPut (fullMethodName, ':');
+		vStringClear (prevIdent);
+		break;
+
+	case ObjcIDENTIFIER:
+		vStringCopy (prevIdent, ident);
+		break;
+
+	case Tok_CurlL:
+	case Tok_semi:
+		/* method name is not simple */
+		if (vStringLength (fullMethodName) != '\0')
+		{
+			addTag (fullMethodName, methodKind);
+			vStringClear (fullMethodName);
+		}
+		else
+			addTag (prevIdent, methodKind);
+
+		toDoNext = &parseMethods;
+		parseImplemMethods (ident, what);
+		vStringClear (prevIdent);
+		break;
+
+	default:
+		break;
+	}
+}
+
+static void parseMethodsImplemName (vString * const ident, objcToken what)
+{
+	switch (what)
+	{
+	case Tok_PARL:
+		toDoNext = &tillToken;
+		comeAfter = &parseMethodsImplemName;
+		waitedToken = Tok_PARR;
+		break;
+
+	case Tok_dpoint:
+		vStringCat (fullMethodName, prevIdent);
+		vStringPut (fullMethodName, ':');
+		vStringClear (prevIdent);
+		break;
+
+	case ObjcIDENTIFIER:
+		vStringCopy (prevIdent, ident);
+		break;
+
+	case Tok_CurlL:
+	case Tok_semi:
+		/* method name is not simple */
+		if (vStringLength (fullMethodName) != '\0')
+		{
+			addTag (fullMethodName, methodKind);
+			vStringClear (fullMethodName);
+		}
+		else
+			addTag (prevIdent, methodKind);
+
+		toDoNext = &parseImplemMethods;
+		parseImplemMethods (ident, what);
+		vStringClear (prevIdent);
+		break;
+
+	default:
+		break;
+	}
+}
+
+static void parseImplemMethods (vString * const ident, objcToken what)
+{
+	switch (what)
+	{
+	case Tok_PLUS:	/* + */
+		toDoNext = &parseMethodsImplemName;
+		methodKind = K_CLASSMETHOD;
+		break;
+
+	case Tok_MINUS:	/* - */
+		toDoNext = &parseMethodsImplemName;
+		methodKind = K_METHOD;
+		break;
+
+	case ObjcEND:	/* @end */
+		popEnclosingContext ();
+		toDoNext = &globalScope;
+		break;
+
+	case Tok_CurlL:	/* { */
+		toDoNext = &ignoreBalanced;
+		ignoreBalanced (ident, what);
+		comeAfter = &parseImplemMethods;
+		break;
+
+	default:
+		break;
+	}
+}
+
+static void parseProperty (vString * const ident, objcToken what)
+{
+	switch (what)
+	{
+	case Tok_PARL:
+		toDoNext = &tillToken;
+		comeAfter = &parseProperty;
+		waitedToken = Tok_PARR;
+		break;
+
+		/* we got an identifier, keep track of it */
+	case ObjcIDENTIFIER:
+		vStringCopy (tempName, ident);
+		break;
+
+		/* our last kept identifier must be our variable name =) */
+	case Tok_semi:
+		addTag (tempName, K_PROPERTY);
+		vStringClear (tempName);
+		toDoNext = &parseMethods;
+		break;
+
+	default:
+		break;
+	}
+}
+
+static void parseMethods (vString * const ident CTAGS_ATTR_UNUSED, objcToken what)
+{
+	switch (what)
+	{
+	case Tok_PLUS:	/* + */
+		toDoNext = &parseMethodsName;
+		methodKind = K_CLASSMETHOD;
+		break;
+
+	case Tok_MINUS:	/* - */
+		toDoNext = &parseMethodsName;
+		methodKind = K_METHOD;
+		break;
+
+	case ObjcPROPERTY:
+		toDoNext = &parseProperty;
+		break;
+
+	case ObjcEND:	/* @end */
+		popEnclosingContext ();
+		toDoNext = &globalScope;
+		break;
+
+	case Tok_CurlL:	/* { */
+		toDoNext = &parseFields;
+		break;
+
+	default:
+		break;
+	}
+}
+
+
+static void parseProtocol (vString * const ident, objcToken what)
+{
+	if (what == ObjcIDENTIFIER)
+	{
+		pushEnclosingContext (ident, K_PROTOCOL);
+		addTag (ident, K_PROTOCOL);
+	}
+	toDoNext = &parseMethods;
+}
+
+static void parseImplementation (vString * const ident, objcToken what)
+{
+	if (what == ObjcIDENTIFIER)
+	{
+		addTag (ident, K_IMPLEMENTATION);
+		pushEnclosingContext (ident, K_IMPLEMENTATION);
+	}
+	toDoNext = &parseImplemMethods;
+}
+
+static void parseInterface (vString * const ident, objcToken what)
+{
+	if (what == ObjcIDENTIFIER)
+	{
+		addTag (ident, K_INTERFACE);
+		pushEnclosingContext (ident, K_INTERFACE);
+	}
+
+	toDoNext = &parseMethods;
+}
+
+static void parseStructMembers (vString * const ident, objcToken what)
+{
+	static parseNext prev = NULL;
+
+	if (prev != NULL)
+	{
+		comeAfter = prev;
+		prev = NULL;
+	}
+
+	switch (what)
+	{
+	case ObjcIDENTIFIER:
+		vStringCopy (tempName, ident);
+		break;
+
+	case Tok_semi:	/* ';' */
+		addTag (tempName, K_FIELD);
+		vStringClear (tempName);
+		break;
+
+		/* some types are complex, the only one
+		 * we will loose is the function type.
+		 */
+	case Tok_CurlL:	/* '{' */
+	case Tok_PARL:	/* '(' */
+	case Tok_SQUAREL:	/* '[' */
+		toDoNext = &ignoreBalanced;
+		prev = comeAfter;
+		comeAfter = &parseStructMembers;
+		ignoreBalanced (ident, what);
+		break;
+
+	case Tok_CurlR:
+		toDoNext = comeAfter;
+		break;
+
+	default:
+		/* don't care */
+		break;
+	}
+}
+
+/* Called just after the struct keyword */
+static bool parseStruct_gotName = false;
+static void parseStruct (vString * const ident, objcToken what)
+{
+	switch (what)
+	{
+	case ObjcIDENTIFIER:
+		if (!parseStruct_gotName)
+		{
+			addTag (ident, K_STRUCT);
+			pushEnclosingContext (ident, K_STRUCT);
+			parseStruct_gotName = true;
+		}
+		else
+		{
+			parseStruct_gotName = false;
+			popEnclosingContext ();
+			toDoNext = comeAfter;
+			comeAfter (ident, what);
+		}
+		break;
+
+	case Tok_CurlL:
+		toDoNext = &parseStructMembers;
+		break;
+
+		/* maybe it was just a forward declaration
+		 * in which case, we pop the context */
+	case Tok_semi:
+		if (parseStruct_gotName)
+			popEnclosingContext ();
+
+		toDoNext = comeAfter;
+		comeAfter (ident, what);
+		break;
+
+	default:
+		/* we don't care */
+		break;
+	}
+}
+
+/* Parse enumeration members, ignoring potential initialization */
+static parseNext parseEnumFields_prev = NULL;
+static void parseEnumFields (vString * const ident, objcToken what)
+{
+	if (parseEnumFields_prev != NULL)
+	{
+		comeAfter = parseEnumFields_prev;
+		parseEnumFields_prev = NULL;
+	}
+
+	switch (what)
+	{
+	case ObjcIDENTIFIER:
+		addTag (ident, K_ENUM);
+		parseEnumFields_prev = comeAfter;
+		waitedToken = Tok_COMA;
+		/* last item might not have a coma */
+		fallBackToken = Tok_CurlR;
+		fallback = comeAfter;
+		comeAfter = parseEnumFields;
+		toDoNext = &tillTokenOrFallBack;
+		break;
+
+	case Tok_CurlR:
+		toDoNext = comeAfter;
+		popEnclosingContext ();
+		break;
+
+	default:
+		/* don't care */
+		break;
+	}
+}
+
+/* parse enum ... { ... */
+static bool parseEnum_named = false;
+static void parseEnum (vString * const ident, objcToken what)
+{
+	switch (what)
+	{
+	case ObjcIDENTIFIER:
+		if (!parseEnum_named)
+		{
+			addTag (ident, K_ENUM);
+			pushEnclosingContext (ident, K_ENUM);
+			parseEnum_named = true;
+		}
+		else
+		{
+			parseEnum_named = false;
+			popEnclosingContext ();
+			toDoNext = comeAfter;
+			comeAfter (ident, what);
+		}
+		break;
+
+	case Tok_CurlL:	/* '{' */
+		toDoNext = &parseEnumFields;
+		parseEnum_named = false;
+		break;
+
+	case Tok_semi:	/* ';' */
+		if (parseEnum_named)
+			popEnclosingContext ();
+		toDoNext = comeAfter;
+		comeAfter (ident, what);
+		break;
+
+	default:
+		/* don't care */
+		break;
+	}
+}
+
+/* Parse something like
+ * typedef .... ident ;
+ * ignoring the defined type but in the case of struct,
+ * in which case struct are parsed.
+ */
+static void parseTypedef (vString * const ident, objcToken what)
+{
+	switch (what)
+	{
+	case ObjcSTRUCT:
+		toDoNext = &parseStruct;
+		comeAfter = &parseTypedef;
+		break;
+
+	case ObjcENUM:
+		toDoNext = &parseEnum;
+		comeAfter = &parseTypedef;
+		break;
+
+	case ObjcIDENTIFIER:
+		vStringCopy (tempName, ident);
+		break;
+
+	case Tok_semi:	/* ';' */
+		addTag (tempName, K_TYPEDEF);
+		vStringClear (tempName);
+		toDoNext = &globalScope;
+		break;
+
+	default:
+		/* we don't care */
+		break;
+	}
+}
+
+static bool ignorePreprocStuff_escaped = false;
+static void ignorePreprocStuff (vString * const ident CTAGS_ATTR_UNUSED, objcToken what)
+{
+	switch (what)
+	{
+	case Tok_Backslash:
+		ignorePreprocStuff_escaped = true;
+		break;
+
+	case Tok_EOL:
+		if (ignorePreprocStuff_escaped)
+		{
+			ignorePreprocStuff_escaped = false;
+		}
+		else
+		{
+			toDoNext = &globalScope;
+		}
+		break;
+
+	default:
+		ignorePreprocStuff_escaped = false;
+		break;
+	}
+}
+
+static void parseMacroName (vString * const ident, objcToken what)
+{
+	if (what == ObjcIDENTIFIER)
+		addTag (ident, K_MACRO);
+
+	toDoNext = &ignorePreprocStuff;
+}
+
+static void parsePreproc (vString * const ident, objcToken what)
+{
+	switch (what)
+	{
+	case ObjcIDENTIFIER:
+		if (strcmp (vStringValue (ident), "define") == 0)
+			toDoNext = &parseMacroName;
+		else
+			toDoNext = &ignorePreprocStuff;
+		break;
+
+	default:
+		toDoNext = &ignorePreprocStuff;
+		break;
+	}
+}
+
+/* Handle the "strong" top levels, all 'big' declarations
+ * happen here */
+static void globalScope (vString * const ident, objcToken what)
+{
+	switch (what)
+	{
+	case Tok_Sharp:
+		toDoNext = &parsePreproc;
+		break;
+
+	case ObjcSTRUCT:
+		toDoNext = &parseStruct;
+		comeAfter = &globalScope;
+		break;
+
+	case ObjcIDENTIFIER:
+		/* we keep track of the identifier if we
+		 * come across a function. */
+		vStringCopy (tempName, ident);
+		break;
+
+	case Tok_PARL:
+		/* if we find an opening parenthesis it means we
+		 * found a function (or a macro...) */
+		addTag (tempName, K_FUNCTION);
+		vStringClear (tempName);
+		comeAfter = &globalScope;
+		toDoNext = &ignoreBalanced;
+		ignoreBalanced (ident, what);
+		break;
+
+	case ObjcINTERFACE:
+		toDoNext = &parseInterface;
+		break;
+
+	case ObjcIMPLEMENTATION:
+		toDoNext = &parseImplementation;
+		break;
+
+	case ObjcPROTOCOL:
+		toDoNext = &parseProtocol;
+		break;
+
+	case ObjcTYPEDEF:
+		toDoNext = parseTypedef;
+		comeAfter = &globalScope;
+		break;
+
+	case Tok_CurlL:
+		comeAfter = &globalScope;
+		toDoNext = &ignoreBalanced;
+		ignoreBalanced (ident, what);
+		break;
+
+	case ObjcEND:
+	case ObjcPUBLIC:
+	case ObjcPROTECTED:
+	case ObjcPRIVATE:
+
+	default:
+		/* we don't care */
+		break;
+	}
+}
+
+/*////////////////////////////////////////////////////////////////
+//// Deal with the system                                       */
+
+static void findObjcTags (void)
+{
+	vString *name = vStringNew ();
+	lexingState st;
+	objcToken tok;
+
+	parentName = vStringNew ();
+	tempName = vStringNew ();
+	fullMethodName = vStringNew ();
+	prevIdent = vStringNew ();
+
+	/* (Re-)initialize state variables, this might be a second file */
+	comeAfter = NULL;
+	fallback = NULL;
+	parentType = K_INTERFACE;
+	ignoreBalanced_count = 0;
+	methodKind = 0;
+	parseStruct_gotName = false;
+	parseEnumFields_prev = NULL;
+	parseEnum_named = false;
+	ignorePreprocStuff_escaped = false;
+
+	st.name = vStringNew ();
+	st.cp = readLineFromInputFile ();
+	toDoNext = &globalScope;
+	tok = lex (&st);
+	while (tok != Tok_EOF)
+	{
+		(*toDoNext) (st.name, tok);
+		tok = lex (&st);
+	}
+	vStringDelete(st.name);
+
+	vStringDelete (name);
+	vStringDelete (parentName);
+	vStringDelete (tempName);
+	vStringDelete (fullMethodName);
+	vStringDelete (prevIdent);
+	parentName = NULL;
+	tempName = NULL;
+	prevIdent = NULL;
+	fullMethodName = NULL;
+}
+
+static void objcInitialize (const langType language)
+{
+	Lang_ObjectiveC = language;
+}
+
+extern parserDefinition *ObjcParser (void)
+{
+	static const char *const extensions[] = { "mm", "m", "h",
+						  NULL };
+	static const char *const aliases[] = { "objc", "objective-c",
+					       NULL };
+	static selectLanguage selectors[] = { selectByObjectiveCAndMatLabKeywords,
+					      selectByObjectiveCKeywords,
+					      NULL };
+	parserDefinition *def = parserNewFull ("ObjectiveC", KIND_FILE_ALT);
+	def->kinds = ObjcKinds;
+	def->kindCount = ARRAY_SIZE (ObjcKinds);
+	def->extensions = extensions;
+	def->aliases = aliases;
+	def->parser = findObjcTags;
+	def->initialize = objcInitialize;
+	def->selectLanguage = selectors;
+	def->keywordTable = objcKeywordTable;
+	def->keywordCount = ARRAY_SIZE (objcKeywordTable);
+	return def;
+}