[geany/geany] ec6e23: Add new upstream candidate Flex parser - Commits

27 Apr 2019


      Branch:      refs/heads/master
Author:      Colomban Wendling ban@herbesfolles.org
Committer:   Colomban Wendling ban@herbesfolles.org
Date:        Sat, 27 Apr 2019 12:59:30 UTC
Commit:      ec6e2320dd48bb4043b9d373c05ac24b97e3d7f5
             https://github.com/geany/geany/commit/ec6e2320dd48bb4043b9d373c05ac24b97e3d7...
Log Message:
-----------
Add new upstream candidate Flex parser
See: https://github.com/universal-ctags/ctags/pull/2084
This import has 3 difference with upstream, not to use newer API than
current Geany has, and to workaround current limitations of Geany ctags
calls: imports are enabled by default and don't have a specific role.
Modified Paths:
--------------
    ctags/Makefile.am
    ctags/main/parsers.h
    ctags/parsers/actionscript.c
    ctags/parsers/flex.c
    src/symbols.c
    src/tagmanager/tm_parser.c
    tests/ctags/Makefile.am
    tests/ctags/actionscript/as-first-token.as
    tests/ctags/actionscript/as-first-token.as.tags
    tests/ctags/actionscript/classes.as
    tests/ctags/actionscript/classes.as.tags
    tests/ctags/actionscript/const.as
    tests/ctags/actionscript/const.as.tags
    tests/ctags/actionscript/const2.as
    tests/ctags/actionscript/const2.as.tags
    tests/ctags/actionscript/method-attributes.as
    tests/ctags/actionscript/method-attributes.as.tags
    tests/ctags/actionscript/packages.as
    tests/ctags/actionscript/packages.as.tags
    tests/ctags/actionscript/sampler.as
    tests/ctags/actionscript/sampler.as.tags
Modified: ctags/Makefile.am
2 lines changed, 1 insertions(+), 1 deletions(-)
===================================================================
@@ -11,7 +11,6 @@ noinst_LTLIBRARIES = libctags.la
 parsers = \
    parsers/abaqus.c \
    parsers/abc.c \
-	parsers/actionscript.c \
    parsers/asciidoc.c \
    parsers/asm.c \
    parsers/basic.c \
@@ -22,6 +21,7 @@ parsers = \
    parsers/diff.c \
    parsers/docbook.c \
    parsers/erlang.c \
+	parsers/flex.c \
    parsers/fortran.c \
    parsers/go.c \
    parsers/haskell.c \
Modified: ctags/main/parsers.h
2 lines changed, 1 insertions(+), 1 deletions(-)
===================================================================
@@ -50,7 +50,7 @@
    GLSLParser, \
    MatLabParser, \
    ValaParser, \
-	ActionScriptParser, \
+	FlexParser, \
    NsisParser, \
    MarkdownParser, \
    Txt2tagsParser, \
Modified: ctags/parsers/actionscript.c
99 lines changed, 0 insertions(+), 99 deletions(-)
===================================================================
@@ -1,99 +0,0 @@
-/*
-*   $Id: actionscript.c,v 1.1 2004/01/03 03:59:19 svoisen Exp $
-*
-*   Original file copyright (c) 2004, Sean Voisen
-*
-*	Modified October 8, 2007 By Mike Fahy (VeryVito) of www.turdhead.com
-*		- Added initial AS3 support
-*		- Threw in some "TODO" and "NOTE" bits
-*
-*	Modified October 9, 2007 By Ali Rantakari of hasseg.org:
-*		- Added more allowed AS3 attribute keywords (override, final, internal
-* 		  etc...) for classes, getters & setters, variables
-*		- Allowed varying versions of "note" and "todo" spellings
-*		- Allowed points (.) in package names so that they would display the
-* 		  whole package name instead of just the first level
-* 		- Added interfaces matching support
-* 		- Reformatted some name parameters:
-*			- Getters and setters: display either "get" or "set" in front
-*			  of the property name
-*			- Todos & notes: made the name be the text that comes after the
-*			  "todo" or "note" text
-*			- Variables: Moved the variable type after the name and separated
-*			  them with " : " according to ActionScript syntax
-*	Modified March 6, 2009 by Chris Macksey (cmacksey@users.sourceforge.net)
-*	    - Tweaked to work better with Geany
-*
-*   This source code is released for free distribution under the terms of the
-*   GNU General Public License.
-*
-*   This module contains functions for generating tags for ActionScript language
-*   files.
-*/
-
-/*
-*   INCLUDE FILES
-*/
-#include "general.h"	/* must always come first */
-#include "parse.h"
-#include "routines.h"
-
-static tagRegexTable actionscriptTagRegexTable[] = {
-	/* Functions */
-    {"^[ \t]*[(private|public|static|protected|internal|final|override)( \t)]*function[ \t]+([A-Za-z0-9_]+)[ \t]*\(([^\{]*)",
-	    "\1 (\2", "f,function,functions,methods", NULL, NULL},
-
-	/* Getters and setters */
-	{"^[ \t]*[(public|static|internal|final|override)( \t)]*function[ \t]+(set|get)[ \t]+([A-Za-z0-9_]+)[ \t]*\(",
-		"\2 \1", "l,field,fields", NULL, NULL},
-
-	/* Variables */
-	{"^[ \t]*[(private|public|static|protected|internal)( \t)]*var[ \t]+([A-Za-z0-9_]+)([ \t]*\:[ \t]*([A-Za-z0-9_]+))*[ \t]*",
-		"\1 \: \3", "v,variable,variables", NULL, NULL},
-
-	/* Constants */
-	{"^[ \t]*[(private|public|static|protected|internal)( \t)]*const[ \t]+([A-Za-z0-9_]+)([ \t]*\:[ \t]*([A-Za-z0-9_]+))*[ \t]*",
-		"\1 : \3", "m,macro,macros", NULL, NULL},
-
-	/* Classes */
-	{"^[ \t]*[(private|public|static|dynamic|final|internal)( \t)]*class[ \t]+([A-Za-z0-9_]+)[ \t]*([^\{]*)",
-		"\1 (\2)", "c,class,classes", NULL, NULL},
-
-	/* Interfaces */
-	{"^[ \t]*[(private|public|static|dynamic|final|internal)( \t)]*interface[ \t]+([A-Za-z0-9_]+)[ \t]*([^\{]*)",
-		"\1 (\2)", "i,interface,interfaces", NULL, NULL},
-
-	/* Packages */
-	{"^[ \t]*[(private|public|static)( \t)]*package[ \t]+([A-Za-z0-9_.]+)[ \t]*",
-		"\1", "p,package", NULL, NULL},
-
-	/* Notes */
-	{"\/\/[ \t]*(NOTE|note|Note)[ \t]*\:*(.*)",
-		"\2", "o,other", NULL, NULL},
-
-	/* Todos */
-	{"\/\/[ \t]*(TODO|todo|ToDo|Todo)[ \t]*\:*(.*)",
-		"\2", "o,other", NULL, NULL},
-
-	/* Prototypes (Put this in for AS1 compatibility...) */
-    {".*\.prototype\.([A-Za-z0-9 ]+)[ \t]*\=([ \t]*)function( [ \t]?)*\(",
-	    "\1", "r,prototype", NULL, NULL}
-};
-
-/*
-*   FUNCTION DEFINITIONS
-*
-*/
-
-/* Create parser definition structure */
-extern parserDefinition* ActionScriptParser (void)
-{
-	static const char *const extensions [] = { "as", NULL };
-	parserDefinition *const def = parserNew ("ActionScript");
-	def->extensions = extensions;
-	def->tagRegexTable = actionscriptTagRegexTable;
-	def->tagRegexCount = ARRAY_SIZE (actionscriptTagRegexTable);
-	def->method     = METHOD_NOT_CRAFTED|METHOD_REGEX;
-	return def;
-}
-
Modified: ctags/parsers/flex.c
2636 lines changed, 2636 insertions(+), 0 deletions(-)
===================================================================
@@ -0,0 +1,2636 @@
+/*
+ *	 Copyright (c) 2008, David Fishburn
+ *
+ *	 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 Adobe languages.
+ *	 There are a number of different ones, but this will begin with:
+ *	     Flex
+ *	         MXML files (*.mMacromedia XML)
+ *	         ActionScript files (*.as)
+ *
+ *	 The ActionScript code was copied from the JavaScript parser, with some
+ *	 adaptations e.g. for classes and type specifiers.
+ *
+ *	 Flex 3 language reference
+ *		 http://livedocs.adobe.com/flex/3/langref/index.html
+ * 		 https://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/language...
+ * 		 https://www.adobe.com/devnet/actionscript/learning/as3-fundamentals/packages...
+ */
+
+/*
+ *	 INCLUDE FILES
+ */
+#include "general.h"	/* must always come first */
+#include <ctype.h>	/* to define isalpha () */
+#ifdef DEBUG
+#include <stdio.h>
+#endif
+
+#include "debug.h"
+#include "entry.h"
+#include "keyword.h"
+#include "parse.h"
+#include "read.h"
+#include "routines.h"
+#include "vstring.h"
+#include "strlist.h"
+
+/*
+ *	 MACROS
+ */
+#define isType(token,t)		(bool) ((token)->type == (t))
+#define isKeyword(token,k)	(bool) ((token)->keyword == (k))
+#define isEOF(token) (isType ((token), TOKEN_EOF))
+#define isIdentChar(c) \
+	(isalpha (c) || isdigit (c) || (c) == '$' || \
+		(c) == '@' || (c) == '_' || (c) == '#' || \
+		(c) >= 0x80)
+
+/*
+ *	 DATA DECLARATIONS
+ */
+
+/*
+ * Tracks class and function names already created
+ */
+static stringList *ClassNames;
+static stringList *FunctionNames;
+
+/*	Used to specify type of keyword.
+*/
+enum eKeywordId {
+	KEYWORD_function,
+	KEYWORD_capital_function,
+	KEYWORD_object,
+	KEYWORD_capital_object,
+	KEYWORD_prototype,
+	KEYWORD_var,
+	KEYWORD_const,
+	KEYWORD_new,
+	KEYWORD_this,
+	KEYWORD_for,
+	KEYWORD_while,
+	KEYWORD_do,
+	KEYWORD_if,
+	KEYWORD_else,
+	KEYWORD_switch,
+	KEYWORD_try,
+	KEYWORD_catch,
+	KEYWORD_finally,
+	KEYWORD_return,
+	KEYWORD_public,
+	KEYWORD_private,
+	KEYWORD_protected,
+	KEYWORD_internal,
+	KEYWORD_final,
+	KEYWORD_native,
+	KEYWORD_dynamic,
+	KEYWORD_class,
+	KEYWORD_interface,
+	KEYWORD_package,
+	KEYWORD_extends,
+	KEYWORD_static,
+	KEYWORD_implements,
+	KEYWORD_get,
+	KEYWORD_set,
+	KEYWORD_import,
+	KEYWORD_id,
+	KEYWORD_name,
+	KEYWORD_script,
+	KEYWORD_cdata,
+	KEYWORD_mx,
+	KEYWORD_fx,
+	KEYWORD_override
+};
+typedef int keywordId; /* to allow KEYWORD_NONE */
+
+typedef enum eTokenType {
+	TOKEN_UNDEFINED,
+	TOKEN_EOF,
+	TOKEN_CHARACTER,
+	TOKEN_CLOSE_PAREN,
+	TOKEN_SEMICOLON,
+	TOKEN_COLON,
+	TOKEN_COMMA,
+	TOKEN_KEYWORD,
+	TOKEN_OPEN_PAREN,
+	TOKEN_IDENTIFIER,
+	TOKEN_STRING,
+	TOKEN_PERIOD,
+	TOKEN_OPEN_CURLY,
+	TOKEN_CLOSE_CURLY,
+	TOKEN_EQUAL_SIGN,
+	TOKEN_EXCLAMATION,
+	TOKEN_FORWARD_SLASH,
+	TOKEN_OPEN_SQUARE,
+	TOKEN_CLOSE_SQUARE,
+	TOKEN_OPEN_MXML,
+	TOKEN_CLOSE_MXML,
+	TOKEN_CLOSE_SGML,
+	TOKEN_LESS_THAN,
+	TOKEN_GREATER_THAN,
+	TOKEN_QUESTION_MARK,
+	TOKEN_OPEN_NAMESPACE,
+	TOKEN_POSTFIX_OPERATOR,
+	TOKEN_STAR,
+	TOKEN_BINARY_OPERATOR
+} tokenType;
+
+typedef struct sTokenInfo {
+	tokenType		type;
+	keywordId		keyword;
+	vString *		string;
+	vString *		scope;
+	unsigned long 	lineNumber;
+	MIOPos 			filePosition;
+	int				nestLevel;
+	bool			ignoreTag;
+	bool			isClass;
+} tokenInfo;
+
+/*
+ *	DATA DEFINITIONS
+ */
+static tokenType LastTokenType;
+static tokenInfo *NextToken;
+
+static langType Lang_flex;
+
+typedef enum {
+	FLEXTAG_FUNCTION,
+	FLEXTAG_CLASS,
+	FLEXTAG_INTERFACE,
+	FLEXTAG_PACKAGE,
+	FLEXTAG_METHOD,
+	FLEXTAG_PROPERTY,
+	FLEXTAG_VARIABLE,
+	FLEXTAG_LOCALVAR,
+	FLEXTAG_CONST,
+	FLEXTAG_IMPORT,
+	FLEXTAG_MXTAG,
+	FLEXTAG_COUNT
+} flexKind;
+
+typedef enum {
+	FLEX_IMPORT_ROLE_IMPORTED,
+} flexImportRole;
+
+static roleDefinition FlexImportRoles [] = {
+	{ true, "import", "imports" },
+};
+
+static kindDefinition FlexKinds [] = {
+	{ true,  'f', "function",	  "functions"		   },
+	{ true,  'c', "class",		  "classes"			   },
+	{ true,  'i', "interface",	  "interfaces"		   },
+	{ true,  'P', "package",	  "packages"		   },
+	{ true,  'm', "method",		  "methods"			   },
+	{ true,  'p', "property",	  "properties"		   },
+	{ true,  'v', "variable",	  "global variables"   },
+	{ /*false*/ true, 'l', "localvar",	  "local variables"   },
+	{ true,  'C', "constant",	  "constants"		   },
+	{ true,  'I', "import",		  "imports",
+	  .referenceOnly = true, ATTACH_ROLES (FlexImportRoles) },
+	{ true,  'x', "mxtag",		  "mxtags" 			   }
+};
+
+/*	Used to determine whether keyword is valid for the token language and
+ *	what its ID is.
+ */
+static const keywordTable FlexKeywordTable [] = {
+	/* keyword		keyword ID */
+	{ "function",	KEYWORD_function			},
+	{ "Function",	KEYWORD_capital_function	},
+	{ "object",		KEYWORD_object				},
+	{ "Object",		KEYWORD_capital_object		},
+	{ "prototype",	KEYWORD_prototype			},
+	{ "var",		KEYWORD_var					},
+	{ "const",		KEYWORD_const				},
+	{ "new",		KEYWORD_new					},
+	{ "this",		KEYWORD_this				},
+	{ "for",		KEYWORD_for					},
+	{ "while",		KEYWORD_while				},
+	{ "do",			KEYWORD_do					},
+	{ "if",			KEYWORD_if					},
+	{ "else",		KEYWORD_else				},
+	{ "switch",		KEYWORD_switch				},
+	{ "try",		KEYWORD_try					},
+	{ "catch",		KEYWORD_catch				},
+	{ "finally",	KEYWORD_finally				},
+	{ "return",		KEYWORD_return				},
+	{ "public",		KEYWORD_public				},
+	{ "private",	KEYWORD_private				},
+	{ "protected",	KEYWORD_protected			},
+	{ "internal",	KEYWORD_internal			},
+	{ "final",		KEYWORD_final				},
+	{ "native",		KEYWORD_native				},
+	{ "dynamic",	KEYWORD_dynamic				},
+	{ "class",		KEYWORD_class				},
+	{ "interface",	KEYWORD_interface			},
+	{ "package",	KEYWORD_package				},
+	{ "extends",	KEYWORD_extends				},
+	{ "static",		KEYWORD_static				},
+	{ "implements",	KEYWORD_implements			},
+	{ "get",		KEYWORD_get					},
+	{ "set",		KEYWORD_set					},
+	{ "import",		KEYWORD_import				},
+	{ "id",			KEYWORD_id					},
+	{ "name",		KEYWORD_name				},
+	{ "script",		KEYWORD_script				},
+	{ "cdata",		KEYWORD_cdata				},
+	{ "mx",			KEYWORD_mx					},
+	{ "fx",			KEYWORD_fx					},
+	{ "override",	KEYWORD_override			}
+};
+
+/*
+ *	 FUNCTION DEFINITIONS
+ */
+
+/* Recursive functions */
+static void parseFunction (tokenInfo *const token);
+static bool parseBlock (tokenInfo *const token, const vString *const parentScope);
+static bool parseLine (tokenInfo *const token);
+static bool parseActionScript (tokenInfo *const token, bool readNext);
+static bool parseMXML (tokenInfo *const token);
+
+static tokenInfo *newToken (void)
+{
+	tokenInfo *const token = xMalloc (1, tokenInfo);
+
+	token->type			= TOKEN_UNDEFINED;
+	token->keyword		= KEYWORD_NONE;
+	token->string		= vStringNew ();
+	token->scope		= vStringNew ();
+	token->nestLevel	= 0;
+	token->isClass		= false;
+	token->ignoreTag	= false;
+	token->lineNumber   = getInputLineNumber ();
+	token->filePosition = getInputFilePosition ();
+
+	return token;
+}
+
+static void deleteToken (tokenInfo *const token)
+{
+	vStringDelete (token->string);
+	vStringDelete (token->scope);
+	eFree (token);
+}
+
+static void copyToken (tokenInfo *const dest, tokenInfo *const src,
+                       bool const include_non_read_info)
+{
+	dest->lineNumber = src->lineNumber;
+	dest->filePosition = src->filePosition;
+	dest->type = src->type;
+	dest->keyword = src->keyword;
+	dest->isClass = src->isClass;
+	vStringCopy(dest->string, src->string);
+	if (include_non_read_info)
+	{
+		dest->nestLevel = src->nestLevel;
+		vStringCopy(dest->scope, src->scope);
+	}
+}
+
+/*
+ *	 Tag generation functions
+ */
+
+static vString *buildQualifiedName (const tokenInfo *const token)
+{
+	vString *qualified = vStringNew ();
+
+	if (vStringLength (token->scope) > 0)
+	{
+		vStringCopy (qualified, token->scope);
+		vStringPut (qualified, '.');
+	}
+	vStringCat (qualified, token->string);
+
+	return qualified;
+}
+
+static void makeConstTag (tokenInfo *const token, const flexKind kind)
+{
+	if (FlexKinds [kind].enabled && ! token->ignoreTag )
+	{
+		const char *const name = vStringValue (token->string);
+		tagEntryInfo e;
+		int role = ROLE_INDEX_DEFINITION;
+
+		/* Geany diff: reftags are not enabled but should be
+		if (kind == FLEXTAG_IMPORT)
+			role = FLEX_IMPORT_ROLE_IMPORTED;
+		*/
+
+		initRefTagEntry (&e, name, kind, role);
+
+		e.lineNumber   = token->lineNumber;
+		e.filePosition = token->filePosition;
+
+		if ( vStringLength(token->scope) > 0 )
+		{
+			/* FIXME: proper parent type */
+			flexKind parent_kind = FLEXTAG_CLASS;
+
+			/*
+			 * If we're creating a function (and not a method),
+			 * guess we're inside another function
+			 */
+			if (kind == FLEXTAG_FUNCTION)
+				parent_kind = FLEXTAG_FUNCTION;
+			/* mxtags can only be nested inside other mxtags */
+			else if (kind == FLEXTAG_MXTAG)
+				parent_kind = kind;
+
+			e.extensionFields.scopeKindIndex = parent_kind;
+			e.extensionFields.scopeName = vStringValue (token->scope);
+		}
+
+		makeTagEntry (&e);
+
+		/* make qualified tags for compatibility if requested */
+		if (isXtagEnabled (XTAG_QUALIFIED_TAGS))
+		{
+			vString *qualified = buildQualifiedName (token);
+
+			markTagExtraBit (&e, XTAG_QUALIFIED_TAGS);
+			e.name = vStringValue (qualified);
+			makeTagEntry (&e);
+			vStringDelete (qualified);
+		}
+	}
+}
+
+static void makeFlexTag (tokenInfo *const token, flexKind kind)
+{
+	if (FlexKinds [kind].enabled && ! token->ignoreTag )
+	{
+	DebugStatement (
+			debugPrintf (DEBUG_PARSE
+				, "\n makeFlexTag start: token isClass:%d  scope:%s  name:%s\n"
+				, token->isClass
+				, vStringValue(token->scope)
+				, vStringValue(token->string)
+				);
+			);
+		if (kind == FLEXTAG_FUNCTION && token->isClass )
+		{
+			kind = FLEXTAG_METHOD;
+		}
+		makeConstTag (token, kind);
+	}
+}
+
+static void makeClassTag (tokenInfo *const token)
+{
+	if ( ! token->ignoreTag )
+	{
+		vString *fulltag = buildQualifiedName (token);
+
+		if ( ! stringListHas(ClassNames, vStringValue (fulltag)) )
+		{
+			stringListAdd (ClassNames, vStringNewCopy (fulltag));
+			makeFlexTag (token, FLEXTAG_CLASS);
+		}
+		vStringDelete (fulltag);
+	}
+}
+
+static void makeMXTag (tokenInfo *const token)
+{
+	if ( ! token->ignoreTag )
+	{
+		makeFlexTag (token, FLEXTAG_MXTAG);
+	}
+}
+
+static void makeFunctionTag (tokenInfo *const token)
+{
+	if ( ! token->ignoreTag )
+	{
+		vString *fulltag = buildQualifiedName (token);
+
+		if ( ! stringListHas(FunctionNames, vStringValue (fulltag)) )
+		{
+			stringListAdd (FunctionNames, vStringNewCopy (fulltag));
+			makeFlexTag (token, FLEXTAG_FUNCTION);
+		}
+		vStringDelete (fulltag);
+	}
+}
+
+/*
+ *	 Parsing functions
+ */
+
+static void parseString (vString *const string, const int delimiter)
+{
+	bool end = false;
+	while (! end)
+	{
+		int c = getcFromInputFile ();
+		if (c == EOF)
+			end = true;
+		else if (c == '\')
+		{
+			c = getcFromInputFile(); /* This maybe a ' or ". */
+			vStringPut(string, c);
+		}
+		else if (c == delimiter)
+			end = true;
+		else
+			vStringPut (string, c);
+	}
+}
+
+/*	Read a C identifier beginning with "firstChar" and places it into
+ *	"name".
+ */
+static void parseIdentifier (vString *const string, const int firstChar)
+{
+	int c = firstChar;
+	Assert (isIdentChar (c));
+	do
+	{
+		vStringPut (string, c);
+		c = getcFromInputFile ();
+	} while (isIdentChar (c));
+	ungetcToInputFile (c);		/* unget non-identifier character */
+}
+
+static void readTokenFull (tokenInfo *const token, bool include_newlines)
+{
+	int c;
+	int i;
+	bool newline_encountered = false;
+
+	/* if we've got a token held back, emit it */
+	if (NextToken)
+	{
+		copyToken (token, NextToken, false);
+		deleteToken (NextToken);
+		NextToken = NULL;
+		return;
+	}
+
+	token->type			= TOKEN_UNDEFINED;
+	token->keyword		= KEYWORD_NONE;
+	vStringClear (token->string);
+
+getNextChar:
+	i = 0;
+	do
+	{
+		c = getcFromInputFile ();
+		if (include_newlines && (c == '\r' || c == '\n'))
+			newline_encountered = true;
+		i++;
+	}
+	while (c == '\t' || c == ' ' || c == '\r' || c == '\n');
+
+	token->lineNumber   = getInputLineNumber ();
+	token->filePosition = getInputFilePosition ();
+
+	switch (c)
+	{
+		case EOF: token->type = TOKEN_EOF;					break;
+		case '(': token->type = TOKEN_OPEN_PAREN;			break;
+		case ')': token->type = TOKEN_CLOSE_PAREN;			break;
+		case ';': token->type = TOKEN_SEMICOLON;			break;
+		case ',': token->type = TOKEN_COMMA;				break;
+		case '.': token->type = TOKEN_PERIOD;				break;
+		case ':': token->type = TOKEN_COLON;				break;
+		case '{': token->type = TOKEN_OPEN_CURLY;			break;
+		case '}': token->type = TOKEN_CLOSE_CURLY;			break;
+		case '=': token->type = TOKEN_EQUAL_SIGN;			break;
+		case '[': token->type = TOKEN_OPEN_SQUARE;			break;
+		case ']': token->type = TOKEN_CLOSE_SQUARE;			break;
+		case '?': token->type = TOKEN_QUESTION_MARK;		break;
+
+		case '+':
+		case '-':
+			{
+				int d = getcFromInputFile ();
+				if (d == c) /* ++ or -- */
+					token->type = TOKEN_POSTFIX_OPERATOR;
+				else
+				{
+					ungetcToInputFile (d);
+					token->type = TOKEN_BINARY_OPERATOR;
+				}
+				break;
+			}
+
+		case '*':
+			token->type = TOKEN_STAR;
+			break;
+		case '%':
+		case '^':
+		case '|':
+		case '&':
+			token->type = TOKEN_BINARY_OPERATOR;
+			break;
+
+		case ''':
+		case '"':
+				  token->type = TOKEN_STRING;
+				  parseString (token->string, c);
+				  token->lineNumber = getInputLineNumber ();
+				  token->filePosition = getInputFilePosition ();
+				  break;
+
+		case '\':
+				  c = getcFromInputFile ();
+				  if (c != '\'  && c != '"'  &&  !isspace (c))
+					  ungetcToInputFile (c);
+				  token->type = TOKEN_CHARACTER;
+				  token->lineNumber = getInputLineNumber ();
+				  token->filePosition = getInputFilePosition ();
+				  break;
+
+		case '/':
+				  {
+					  int d = getcFromInputFile ();
+					  if ( (d != '*') &&		/* is this the start of a comment? */
+							  (d != '/') &&		/* is a one line comment? */
+							  (d != '>') )		/* is this a close XML tag? */
+					  {
+						  ungetcToInputFile (d);
+						  token->type = TOKEN_FORWARD_SLASH;
+						  token->lineNumber = getInputLineNumber ();
+						  token->filePosition = getInputFilePosition ();
+					  }
+					  else
+					  {
+						  if (d == '*')
+						  {
+							  do
+							  {
+								  skipToCharacterInInputFile ('*');
+								  c = getcFromInputFile ();
+								  if (c == '/')
+									  break;
+								  else
+									  ungetcToInputFile (c);
+							  } while (c != EOF);
+							  goto getNextChar;
+						  }
+						  else if (d == '/')	/* is this the start of a comment?  */
+						  {
+							  skipToCharacterInInputFile ('\n');
+							  /* if we care about newlines, put it back so it is seen */
+							  if (include_newlines)
+								  ungetcToInputFile ('\n');
+							  goto getNextChar;
+						  }
+						  else if (d == '>')	/* is this the start of a comment?  */
+						  {
+							  token->type = TOKEN_CLOSE_SGML;
+							  token->lineNumber = getInputLineNumber ();
+							  token->filePosition = getInputFilePosition ();
+						  }
+					  }
+					  break;
+				  }
+
+		case '<':
+				  {
+					  /*
+					   * An XML comment looks like this
+					   *   <!-- anything over multiple lines -->
+					   */
+					  int d = getcFromInputFile ();
+
+					  if ( (d != '!' )  && 		/* is this the start of a comment? */
+					       (d != '/' )  &&	 	/* is this the start of a closing mx tag */
+					       (d != 'm' )  &&  	/* is this the start of a mx tag */
+					       (d != 'f' )  &&  	/* is this the start of a fx tag */
+					       (d != 's' )    ) 	/* is this the start of a spark tag */
+					  {
+						  ungetcToInputFile (d);
+						  token->type = TOKEN_LESS_THAN;
+						  token->lineNumber = getInputLineNumber ();
+						  token->filePosition = getInputFilePosition ();
+						  break;
+					  }
+					  else
+					  {
+						  if (d == '!')
+						  {
+							  int e = getcFromInputFile ();
+							  if ( e != '-' ) 		/* is this the start of a comment? */
+							  {
+								  ungetcToInputFile (e);
+								  ungetcToInputFile (d);
+								  token->type = TOKEN_LESS_THAN;
+								  token->lineNumber = getInputLineNumber ();
+								  token->filePosition = getInputFilePosition ();
+							  }
+							  else
+							  {
+								  if (e == '-')
+								  {
+									  int f = getcFromInputFile ();
+									  if ( f != '-' ) 		/* is this the start of a comment? */
+									  {
+										  ungetcToInputFile (f);
+										  ungetcToInputFile (e);
+										  ungetcToInputFile (d);
+										  token->type = TOKEN_LESS_THAN;
+										  token->lineNumber = getInputLineNumber ();
+										  token->filePosition = getInputFilePosition ();
+									  }
+									  else
+									  {
+										  if (f == '-')
+										  {
+											  do
+											  {
+												  skipToCharacterInInputFile ('-');
+												  c = getcFromInputFile ();
+												  if (c == '-')
+												  {
+													  d = getcFromInputFile ();
+													  if (d == '>')
+														  break;
+													  else
+													  {
+														  ungetcToInputFile (d);
+														  ungetcToInputFile (c);
+													  }
+													  break;
+												  }
+												  else
+													  ungetcToInputFile (c);
+											  } while (c != EOF && c != '\0');
+											  goto getNextChar;
+										  }
+									  }
+								  }
+							  }
+						  }
+						  else if (d == 'm' || d == 'f' || d == 's' )
+						  {
+							  int e = getcFromInputFile ();
+							  if ( (d == 'm' || d == 'f') && e != 'x' ) 		/* continuing an mx or fx tag */
+							  {
+								  ungetcToInputFile (e);
+								  ungetcToInputFile (d);
+								  token->type = TOKEN_LESS_THAN;
+								  token->lineNumber = getInputLineNumber ();
+								  token->filePosition = getInputFilePosition ();
+								  break;
+							  }
+							  else
+							  {
+								  if ( (d == 'm' || d == 'f') && e == 'x' )
+								  {
+									  int f = getcFromInputFile ();
+									  if ( f != ':' ) 		/* start of the tag */
+									  {
+										  ungetcToInputFile (f);
+										  ungetcToInputFile (e);
+										  ungetcToInputFile (d);
+										  token->type = TOKEN_LESS_THAN;
+										  token->lineNumber = getInputLineNumber ();
+										  token->filePosition = getInputFilePosition ();
+										  break;
+									  }
+									  else
+									  {
+										  token->type = TOKEN_OPEN_MXML;
+										  token->lineNumber = getInputLineNumber ();
+										  token->filePosition = getInputFilePosition ();
+										  break;
+									  }
+								  }
+								  if ( d == 's' && e == ':')    /* continuing a spark tag */
+								  {
+									  token->type = TOKEN_OPEN_MXML;
+									  token->lineNumber = getInputLineNumber ();
+									  token->filePosition = getInputFilePosition ();
+									  break;
+								  }
+								  else
+								  {
+									  ungetcToInputFile (e);
+									  ungetcToInputFile (d);
+									  token->type = TOKEN_LESS_THAN;
+									  token->lineNumber = getInputLineNumber ();
+									  token->filePosition = getInputFilePosition ();
+									  break;
+								  }
+							  }
+						  }
+						  else if (d == '/')
+						  {
+							  int e = getcFromInputFile ();
+							  if ( !(e == 'm' || e == 'f' || e == 's' ))
+							  {
+								  ungetcToInputFile (e);
+								  ungetcToInputFile (d);
+								  token->type = TOKEN_LESS_THAN;
+								  token->lineNumber = getInputLineNumber ();
+								  token->filePosition = getInputFilePosition ();
+								  break;
+							  }
+							  else
+							  {
+								  int f = getcFromInputFile ();
+								  if ( (e == 'm' || e == 'f') && f != 'x' ) 		/* continuing an mx or fx tag */
+								  {
+									  ungetcToInputFile (f);
+									  ungetcToInputFile (e);
+									  token->type = TOKEN_LESS_THAN;
+									  token->lineNumber = getInputLineNumber ();
+									  token->filePosition = getInputFilePosition ();
+									  break;
+								  }
+								  else
+								  {
+									  if (f == 'x')
+									  {
+										  int g = getcFromInputFile ();
+										  if ( g != ':' ) 		/* is this the start of a comment? */
+										  {
+											  ungetcToInputFile (g);
+											  ungetcToInputFile (f);
+											  ungetcToInputFile (e);
+											  token->type = TOKEN_LESS_THAN;
+											  token->lineNumber = getInputLineNumber ();
+											  token->filePosition = getInputFilePosition ();
+											  break;
+										  }
+										  else
+										  {
+											  token->type = TOKEN_CLOSE_MXML;
+											  token->lineNumber = getInputLineNumber ();
+											  token->filePosition = getInputFilePosition ();
+											  break;
+										  }
+									  }
+									  if ( e == 's' && f == ':')    /* continuing a spark tag */
+									  {
+										  token->type = TOKEN_CLOSE_MXML;
+										  token->lineNumber = getInputLineNumber ();
+										  token->filePosition = getInputFilePosition ();
+										  break;
+									  }
+									  else
+									  {
+										  ungetcToInputFile (f);
+										  ungetcToInputFile (e);
+										  token->type = TOKEN_LESS_THAN;
+										  token->lineNumber = getInputLineNumber ();
+										  token->filePosition = getInputFilePosition ();
+										  break;
+									  }
+								  }
+							  }
+						  }
+					  }
+					  break;
+				  }
+
+		case '>':
+				  token->type = TOKEN_GREATER_THAN;
+				  token->lineNumber = getInputLineNumber ();
+				  token->filePosition = getInputFilePosition ();
+				  break;
+
+		case '!':
+				  token->type = TOKEN_EXCLAMATION;
+				  /*token->lineNumber = getInputLineNumber ();
+				  token->filePosition = getInputFilePosition ();*/
+				  break;
+
+		default:
+				  if (! isIdentChar (c))
+					  token->type = TOKEN_UNDEFINED;
+				  else
+				  {
+					  parseIdentifier (token->string, c);
+					  token->lineNumber = getInputLineNumber ();
+					  token->filePosition = getInputFilePosition ();
+					  token->keyword = lookupCaseKeyword (vStringValue (token->string), Lang_flex);
+					  if (isKeyword (token, KEYWORD_NONE))
+						  token->type = TOKEN_IDENTIFIER;
+					  else
+						  token->type = TOKEN_KEYWORD;
+				  }
+				  break;
+	}
+
+	if (include_newlines && newline_encountered)
+	{
+		/* This isn't strictly correct per the standard, but following the
+		 * real rules means understanding all statements, and that's not
+		 * what the parser currently does.  What we do here is a guess, by
+		 * avoiding inserting semicolons that would make the statement on
+		 * the left or right obviously invalid.  Hopefully this should not
+		 * have false negatives (e.g. should not miss insertion of a semicolon)
+		 * but might have false positives (e.g. it will wrongfully emit a
+		 * semicolon sometimes, i.e. for the newline in "foo\n(bar)").
+		 * This should however be mostly harmless as we only deal with
+		 * newlines in specific situations where we know a false positive
+		 * wouldn't hurt too bad. */
+
+		/* these already end a statement, so no need to duplicate it */
+		#define IS_STMT_SEPARATOR(t) ((t) == TOKEN_SEMICOLON    || \
+		                              (t) == TOKEN_EOF          || \
+		                              (t) == TOKEN_COMMA        || \
+		                              (t) == TOKEN_OPEN_CURLY)
+		/* these cannot be the start or end of a statement */
+		#define IS_BINARY_OPERATOR(t) ((t) == TOKEN_EQUAL_SIGN      || \
+		                               (t) == TOKEN_COLON           || \
+		                               (t) == TOKEN_PERIOD          || \
+		                               (t) == TOKEN_STAR            || \
+		                               (t) == TOKEN_FORWARD_SLASH   || \
+		                               (t) == TOKEN_QUESTION_MARK   || \
+		                               (t) == TOKEN_LESS_THAN       || \
+		                               (t) == TOKEN_GREATER_THAN    || \
+		                               (t) == TOKEN_BINARY_OPERATOR)
+
+		if (! IS_STMT_SEPARATOR(LastTokenType) &&
+		    ! IS_STMT_SEPARATOR(token->type) &&
+		    ! IS_BINARY_OPERATOR(LastTokenType) &&
+		    ! IS_BINARY_OPERATOR(token->type) &&
+		    /* these cannot be followed by a semicolon */
+		    ! (LastTokenType == TOKEN_OPEN_PAREN ||
+		       LastTokenType == TOKEN_OPEN_SQUARE))
+		{
+			/* hold the token... */
+			Assert (NextToken == NULL);
+			NextToken = newToken ();
+			copyToken (NextToken, token, false);
+
+			/* ...and emit a semicolon instead */
+			token->type		= TOKEN_SEMICOLON;
+			token->keyword	= KEYWORD_NONE;
+			vStringClear (token->string);
+		}
+
+		#undef IS_STMT_SEPARATOR
+		#undef IS_BINARY_OPERATOR
+	}
+
+	LastTokenType = token->type;
+}
+
+static void readToken (tokenInfo *const token)
+{
+	readTokenFull (token, false);
+}
+
+/*
+ *	 Token parsing functions
+ */
+
+static void skipArgumentList (tokenInfo *const token, bool include_newlines)
+{
+	int nest_level = 0;
+
+	if (isType (token, TOKEN_OPEN_PAREN))	/* arguments? */
+	{
+		nest_level++;
+		while (nest_level > 0 && ! isType (token, TOKEN_EOF))
+		{
+			readToken (token);
+			if (isType (token, TOKEN_OPEN_PAREN))
+				nest_level++;
+			else if (isType (token, TOKEN_CLOSE_PAREN))
+				nest_level--;
+		}
+		readTokenFull (token, include_newlines);
+	}
+}
+
+static void skipArrayList (tokenInfo *const token, bool include_newlines)
+{
+	int nest_level = 0;
+
+	/*
+	 * Handle square brackets
+	 *	 var name[1]
+	 * So we must check for nested open and closing square brackets
+	 */
+
+	if (isType (token, TOKEN_OPEN_SQUARE))	/* arguments? */
+	{
+		nest_level++;
+		while (nest_level > 0 && ! isType (token, TOKEN_EOF))
+		{
+			readToken (token);
+			if (isType (token, TOKEN_OPEN_SQUARE))
+				nest_level++;
+			else if (isType (token, TOKEN_CLOSE_SQUARE))
+				nest_level--;
+		}
+		readTokenFull (token, include_newlines);
+	}
+}
+
+static void addContext (tokenInfo* const parent, const tokenInfo* const child)
+{
+	if (vStringLength (parent->string) > 0)
+	{
+		vStringPut (parent->string, '.');
+	}
+	vStringCat (parent->string, child->string);
+}
+
+static void addToScope (tokenInfo* const token, const vString* const extra)
+{
+	if (vStringLength (token->scope) > 0)
+	{
+		vStringPut (token->scope, '.');
+	}
+	vStringCat (token->scope, extra);
+}
+
+/*
+ *	 Scanning functions
+ */
+
+static bool findCmdTerm (tokenInfo *const token, bool include_newlines,
+						 bool include_commas)
+{
+	/*
+	 * Read until we find either a semicolon or closing brace.
+	 * Any nested braces will be handled within.
+	 */
+	while (! isType (token, TOKEN_SEMICOLON) &&
+		   ! isType (token, TOKEN_CLOSE_CURLY) &&
+		   ! (include_commas && isType (token, TOKEN_COMMA)) &&
+		   ! isType (token, TOKEN_EOF))
+	{
+		/* Handle nested blocks */
+		if ( isType (token, TOKEN_OPEN_CURLY))
+		{
+			parseBlock (token, NULL);
+			readTokenFull (token, include_newlines);
+		}
+		else if ( isType (token, TOKEN_OPEN_PAREN) )
+		{
+			skipArgumentList(token, include_newlines);
+		}
+		else if ( isType (token, TOKEN_OPEN_SQUARE) )
+		{
+			skipArrayList(token, include_newlines);
+		}
+		else
+		{
+			readTokenFull (token, include_newlines);
+		}
+	}
+
+	return isType (token, TOKEN_SEMICOLON);
+}
+
+static void parseSwitch (tokenInfo *const token)
+{
+	/*
+	 * switch (expression) {
+	 * case value1:
+	 *	   statement;
+	 *	   break;
+	 * case value2:
+	 *	   statement;
+	 *	   break;
+	 * default : statement;
+	 * }
+	 */
+
+	readToken (token);
+
+	if (isType (token, TOKEN_OPEN_PAREN))
+	{
+		skipArgumentList(token, false);
+	}
+
+	if (isType (token, TOKEN_OPEN_CURLY))
+	{
+		parseBlock (token, NULL);
+	}
+}
+
+static bool parseLoop (tokenInfo *const token)
+{
+	/*
+	 * Handles these statements
+	 *	   for (x=0; x<3; x++)
+	 *		   document.write("This text is repeated three times<br>");
+	 *
+	 *	   for (x=0; x<3; x++)
+	 *	   {
+	 *		   document.write("This text is repeated three times<br>");
+	 *	   }
+	 *
+	 *	   while (number<5){
+	 *		   document.write(number+"<br>");
+	 *		   number++;
+	 *	   }
+	 *
+	 *	   do{
+	 *		   document.write(number+"<br>");
+	 *		   number++;
+	 *	   }
+	 *	   while (number<5);
+	 */
+	bool is_terminated = true;
+
+	if (isKeyword (token, KEYWORD_for) || isKeyword (token, KEYWORD_while))
+	{
+		readToken(token);
+
+		if (isType (token, TOKEN_OPEN_PAREN))
+		{
+			skipArgumentList(token, false);
+		}
+
+		if (isType (token, TOKEN_OPEN_CURLY))
+		{
+			parseBlock (token, NULL);
+		}
+		else
+		{
+			is_terminated = parseLine(token);
+		}
+	}
+	else if (isKeyword (token, KEYWORD_do))
+	{
+		readToken(token);
+
+		if (isType (token, TOKEN_OPEN_CURLY))
+		{
+			parseBlock (token, NULL);
+		}
+		else
+		{
+			is_terminated = parseLine(token);
+		}
+
+		if (is_terminated)
+			readToken(token);
+
+		if (isKeyword (token, KEYWORD_while))
+		{
+			readToken(token);
+
+			if (isType (token, TOKEN_OPEN_PAREN))
+			{
+				skipArgumentList(token, true);
+			}
+			if (! isType (token, TOKEN_SEMICOLON))
+			{
+				/* oddly enough, `do {} while (0) var foo = 42` is perfectly
+				 * valid AS, so explicitly handle the remaining of the line
+				 * for the sake of the root scope handling (as parseActionScript()
+				 * always advances a token not to ever get stuck) */
+				is_terminated = parseLine(token);
+			}
+		}
+	}
+
+	return is_terminated;
+}
+
+static bool parseIf (tokenInfo *const token)
+{
+	bool read_next_token = true;
+	/*
+	 * If statements have two forms
+	 *	   if ( ... )
+	 *		   one line;
+	 *
+	 *	   if ( ... )
+	 *		  statement;
+	 *	   else
+	 *		  statement
+	 *
+	 *	   if ( ... ) {
+	 *		  multiple;
+	 *		  statements;
+	 *	   }
+	 *
+	 *
+	 *	   if ( ... ) {
+	 *		  return elem
+	 *	   }
+	 *
+	 *     This example if correctly written, but the
+	 *     else contains only 1 statement without a terminator
+	 *     since the function finishes with the closing brace.
+	 *
+     *     function a(flag){
+     *         if(flag)
+     *             test(1);
+     *         else
+     *             test(2)
+     *     }
+	 *
+	 * TODO:  Deal with statements that can optional end
+	 *		  without a semi-colon.  Currently this messes up
+	 *		  the parsing of blocks.
+	 *		  Need to somehow detect this has happened, and either
+	 *		  backup a token, or skip reading the next token if
+	 *		  that is possible from all code locations.
+	 *
+	 */
+
+	readToken (token);
+
+	if (isKeyword (token, KEYWORD_if))
+	{
+		/*
+		 * Check for an "else if" and consume the "if"
+		 */
+		readToken (token);
+	}
+
+	if (isType (token, TOKEN_OPEN_PAREN))
+	{
+		skipArgumentList(token, false);
+	}
+
+	if (isType (token, TOKEN_OPEN_CURLY))
+	{
+		parseBlock (token, NULL);
+	}
+	else
+	{
+		/* The next token should only be read if this statement had its own
+		 * terminator */
+		read_next_token = findCmdTerm (token, true, false);
+	}
+	return read_next_token;
+}
+
+static bool parseImport (tokenInfo *const token)
+{
+	if (! isKeyword (token, KEYWORD_import))
+		return false;
+
+	readToken (token);
+
+	if (isType (token, TOKEN_IDENTIFIER))
+	{
+		tokenInfo *const name = newToken ();
+
+		copyToken (name, token, true);
+		readToken (token);
+		while (isType (token, TOKEN_PERIOD))
+		{
+			vStringPut (name->string, '.');
+			readToken (token);
+			if (isType (token, TOKEN_IDENTIFIER))
+				vStringCat (name->string, token->string);
+			else if (isType (token, TOKEN_STAR))
+				vStringPut (name->string, '*');
+			if (isType (token, TOKEN_IDENTIFIER) || isType (token, TOKEN_STAR))
+				readToken (token);
+		}
+
+		makeFlexTag (name, FLEXTAG_IMPORT);
+		deleteToken (name);
+	}
+
+	return isType (token, TOKEN_SEMICOLON);
+}
+
+static void parseFunction (tokenInfo *const token)
+{
+	tokenInfo *const name = newToken ();
+	flexKind kind = FLEXTAG_FUNCTION;
+
+	/*
+	 * This deals with these formats
+     *     private static function ioErrorHandler( event:IOErrorEvent ):void {
+     *     public function get prop():String {}
+     *     public function set prop(param:String):void {}
+	 */
+
+	if ( isKeyword(token, KEYWORD_function) )
+	{
+		readToken (token);
+	}
+
+	/* getter and setter */
+	if (isKeyword (token, KEYWORD_get) ||
+		isKeyword (token, KEYWORD_set))
+	{
+		kind = FLEXTAG_PROPERTY;
+		readToken (token);
+	}
+
+	copyToken (name, token, true);
+	/* Add scope in case this is an INNER function
+	addToScope(name, token->scope);
+	*/
+
+	DebugStatement (
+			debugPrintf (DEBUG_PARSE
+				, "\n parseFunction: token isClass:%d  scope:%s  name:%s\n"
+				, token->isClass
+				, vStringValue(token->scope)
+				, vStringValue(token->string)
+				);
+			);
+	DebugStatement (
+			debugPrintf (DEBUG_PARSE
+				, "\n parseFunction: name isClass:%d  scope:%s  name:%s\n"
+				, name->isClass
+				, vStringValue(name->scope)
+				, vStringValue(name->string)
+				);
+			);
+
+	readToken (token);
+
+	if ( isType (token, TOKEN_OPEN_PAREN) )
+		skipArgumentList(token, false);
+
+	if ( isType (token, TOKEN_COLON) )
+	{
+		/*
+		 *   function fname ():ReturnType
+		 */
+		readToken (token);
+		if (isType (token, TOKEN_IDENTIFIER))
+			readToken (token);
+	}
+
+	if ( isType (token, TOKEN_OPEN_CURLY) )
+	{
+		DebugStatement (
+				debugPrintf (DEBUG_PARSE
+					, "\n parseFunction end: name isClass:%d  scope:%s  name:%s\n"
+					, name->isClass
+					, vStringValue(name->scope)
+					, vStringValue(name->string)
+					);
+				);
+		parseBlock (token, name->string);
+		DebugStatement (
+				debugPrintf (DEBUG_PARSE
+					, "\n parseFunction end2: token isClass:%d  scope:%s  name:%s\n"
+					, token->isClass
+					, vStringValue(token->scope)
+					, vStringValue(token->string)
+					);
+				);
+		DebugStatement (
+				debugPrintf (DEBUG_PARSE
+					, "\n parseFunction end2: token isClass:%d  scope:%s  name:%s\n"
+					, token->isClass
+					, vStringValue(token->scope)
+					, vStringValue(token->string)
+					);
+				);
+		DebugStatement (
+				debugPrintf (DEBUG_PARSE
+					, "\n parseFunction end3: name isClass:%d  scope:%s  name:%s\n"
+					, name->isClass
+					, vStringValue(name->scope)
+					, vStringValue(name->string)
+					);
+				);
+		if (kind == FLEXTAG_FUNCTION)
+			makeFunctionTag (name);
+		else
+			makeFlexTag (name, kind);
+	}
+
+	findCmdTerm (token, false, false);
+
+	deleteToken (name);
+}
+ 
+/* Parses a block surrounded by curly braces.
+ * @p parentScope is the scope name for this block, or NULL for unnamed scopes */
+static bool parseBlock (tokenInfo *const token, const vString *const parentScope)
+{
+	bool read_next_token = true;
+	vString * saveScope = vStringNew ();
+
+	vStringCopy (saveScope, token->scope);
+	if (parentScope)
+	{
+		addToScope (token, parentScope);
+		token->nestLevel++;
+	}
+
+	DebugStatement (
+			debugPrintf (DEBUG_PARSE
+				, "\n parseBlock start: token isClass:%d  scope:%s  name:%s\n"
+				, token->isClass
+				, vStringValue(token->scope)
+				, vStringValue(token->string)
+				);
+			);
+	/*
+	 * Make this routine a bit more forgiving.
+	 * If called on an open_curly advance it
+	 */
+	if (isType (token, TOKEN_OPEN_CURLY))
+		readToken(token);
+
+	if (! isType (token, TOKEN_CLOSE_CURLY))
+	{
+		/*
+		 * Read until we find the closing brace,
+		 * any nested braces will be handled within
+		 */
+		do
+		{
+			if (isType (token, TOKEN_OPEN_CURLY))
+			{
+				/* Handle nested blocks */
+				parseBlock (token, NULL);
+			}
+			else
+			{
+				/*
+				 * It is possible for a line to have no terminator
+				 * if the following line is a closing brace.
+				 * parseLine will detect this case and indicate
+				 * whether we should read an additional token.
+				 */
+				read_next_token = parseLine (token);
+			}
+
+			/*
+			 * Always read a new token unless we find a statement without
+			 * a ending terminator
+			 */
+			if( read_next_token )
+				readToken(token);
+
+			/*
+			 * If we find a statement without a terminator consider the
+			 * block finished, otherwise the stack will be off by one.
+			 */
+		} while (! isType (token, TOKEN_EOF) &&
+				 ! isType (token, TOKEN_CLOSE_CURLY) && read_next_token);
+	}
+
+	vStringCopy(token->scope, saveScope);
+	vStringDelete(saveScope);
+	if (parentScope)
+		token->nestLevel--;
+
+	DebugStatement (
+			debugPrintf (DEBUG_PARSE
+				, "\n parseBlock end: token isClass:%d  scope:%s  name:%s\n"
+				, token->isClass
+				, vStringValue(token->scope)
+				, vStringValue(token->string)
+				);
+			);
+	return false;
+}
+
+static void parseMethods (tokenInfo *const token, const tokenInfo *const class)
+{
+	tokenInfo *const name = newToken ();
+	vString *saveScope = vStringNew ();
+
+	vStringCopy (saveScope, token->scope);
+	addToScope (token, class->string);
+
+	/*
+	 * This deals with these formats
+	 *	   validProperty  : 2,
+	 *	   validMethod    : function(a,b) {}
+	 *	   'validMethod2' : function(a,b) {}
+     *     container.dirtyTab = {'url': false, 'title':false, 'snapshot':false, '*': false}
+	 */
+
+	do
+	{
+		readToken (token);
+		if (isType (token, TOKEN_CLOSE_CURLY))
+		{
+			goto cleanUp;
+		}
+
+		if (isType (token, TOKEN_STRING) || isKeyword(token, KEYWORD_NONE))
+		{
+			copyToken (name, token, true);
+
+			readToken (token);
+			if ( isType (token, TOKEN_COLON) )
+			{
+				readToken (token);
+				if ( isKeyword (token, KEYWORD_function) )
+				{
+					readToken (token);
+					if ( isType (token, TOKEN_OPEN_PAREN) )
+					{
+						skipArgumentList(token, false);
+					}
+
+					if (isType (token, TOKEN_OPEN_CURLY))
+					{
+						makeFlexTag (name, FLEXTAG_METHOD);
+						parseBlock (token, name->string);
+
+						/*
+						 * Read to the closing curly, check next
+						 * token, if a comma, we must loop again
+						 */
+						readToken (token);
+					}
+				}
+				else
+				{
+						makeFlexTag (name, FLEXTAG_PROPERTY);
+
+						/*
+						 * Read the next token, if a comma
+						 * we must loop again
+						 */
+						readToken (token);
+				}
+			}
+		}
+	} while ( isType(token, TOKEN_COMMA));
+
+	findCmdTerm (token, false, false);
+
+cleanUp:
+	vStringCopy (token->scope, saveScope);
+	vStringDelete (saveScope);
+	deleteToken (name);
+}
+
+static bool parseVar (tokenInfo *const token, bool is_public)
+{
+	tokenInfo *const name = newToken ();
+	bool is_terminated = true;
+	flexKind kind = is_public ? FLEXTAG_VARIABLE : FLEXTAG_LOCALVAR;
+
+	/*
+	 * Variables are defined as:
+	 *     private static var lastFaultMessage:Date = new Date( 0 );
+	 *     private static var webRequests:ArrayCollection = new ArrayCollection();
+	 */
+
+	if ( isKeyword(token, KEYWORD_var) )
+	{
+		readToken(token);
+	}
+	else if (isKeyword(token, KEYWORD_const))
+	{
+		kind = FLEXTAG_CONST;
+		readToken(token);
+	}
+
+	/* Variable name */
+	copyToken (name, token, true);
+	readToken(token);
+
+	if ( isType (token, TOKEN_COLON) )
+	{
+		/*
+		 *   var vname ():DataType = new Date();
+		 *   var vname ():DataType;
+		 */
+		readToken (token);
+		if (isType (token, TOKEN_IDENTIFIER))
+			readToken (token);
+	}
+
+	is_terminated = findCmdTerm (token, true, false);
+
+	if ( isType (token, TOKEN_SEMICOLON) )
+	{
+		makeFlexTag (name, kind);
+	}
+
+	deleteToken (name);
+
+	return is_terminated;
+}
+
+static void parsePackage (tokenInfo *const token)
+{
+	tokenInfo *name = NULL;
+
+	if (isKeyword (token, KEYWORD_package))
+		readToken(token);
+
+	/* name is optional and can be qualified */
+	if (isType (token, TOKEN_IDENTIFIER))
+	{
+		name = newToken ();
+		copyToken (name, token, true);
+		readToken (token);
+
+		while (isType (token, TOKEN_PERIOD))
+		{
+			vStringPut (name->string, '.');
+			readToken (token);
+			if (isType (token, TOKEN_IDENTIFIER))
+			{
+				vStringCat (name->string, token->string);
+				readToken (token);
+			}
+		}
+	}
+
+	if (isType (token, TOKEN_OPEN_CURLY))
+	{
+		if (name)
+			makeFlexTag (name, FLEXTAG_PACKAGE);
+		parseBlock (token, name ? name->string : NULL);
+	}
+
+	if (name)
+		deleteToken (name);
+}
+
+static bool parseClass (tokenInfo *const token)
+{
+	tokenInfo *const name = newToken ();
+	bool saveIsClass = token->isClass;
+
+	/*
+	 * Variables are defined as:
+	 *     private static var lastFaultMessage:Date = new Date( 0 );
+	 *     private static var webRequests:ArrayCollection = new ArrayCollection();
+	 */
+
+	if ( isKeyword(token, KEYWORD_class) )
+	{
+		readToken(token);
+	}
+
+	token->isClass = true;
+	/* Class name */
+	copyToken (name, token, true);
+	readToken(token);
+
+	DebugStatement (
+			debugPrintf (DEBUG_PARSE
+				, "\n parseClass start: token isClass:%d  scope:%s  name:%s\n"
+				, token->isClass
+				, vStringValue(token->scope)
+				, vStringValue(token->string)
+				);
+			);
+
+	if (isKeyword (token, KEYWORD_extends))
+	{
+		readToken (token);
+		if (isType (token, TOKEN_IDENTIFIER))
+			readToken (token);
+	}
+
+	if (isKeyword (token, KEYWORD_implements))
+	{
+		do
+		{
+			readToken (token);
+			if (isType (token, TOKEN_IDENTIFIER))
+				readToken (token);
+		}
+		while (isType (token, TOKEN_COMMA));
+	}
+
+	if ( isType (token, TOKEN_OPEN_CURLY) )
+	{
+		makeClassTag (name);
+		parseBlock (token, name->string);
+	}
+
+	DebugStatement (
+			debugPrintf (DEBUG_PARSE
+				, "\n parseClass end: token isClass:%d  scope:%s  name:%s\n"
+				, token->isClass
+				, vStringValue(token->scope)
+				, vStringValue(token->string)
+				);
+			);
+	token->isClass = saveIsClass;
+	deleteToken (name);
+
+	return true;
+}
+
+static void parseInterface (tokenInfo *const token)
+{
+	tokenInfo *const name = newToken ();
+	bool saveIsClass = token->isClass;
+
+	if (isKeyword(token, KEYWORD_interface))
+		readToken(token);
+
+	token->isClass = true;
+	/* interface name */
+	copyToken (name, token, true);
+	readToken (token);
+
+	/* interfaces can extend multiple interfaces */
+	if (isKeyword (token, KEYWORD_extends))
+	{
+		do
+		{
+			readToken (token);
+			if (isType (token, TOKEN_IDENTIFIER))
+				readToken (token);
+		}
+		while (isType (token, TOKEN_COMMA));
+	}
+
+	if (isType (token, TOKEN_OPEN_CURLY))
+	{
+		makeFlexTag (name, FLEXTAG_INTERFACE);
+		parseBlock (token, name->string);
+	}
+
+	token->isClass = saveIsClass;
+	deleteToken (name);
+}
+
+static bool parseStatement (tokenInfo *const token)
+{
+	tokenInfo *const name = newToken ();
+	tokenInfo *const secondary_name = newToken ();
+	vString * saveScope = vStringNew ();
+	bool is_public = false;
+	bool is_class = false;
+	bool is_terminated = true;
+	bool is_global = false;
+	/* bool is_prototype = false; */
+	vString *	fulltag;
+
+	vStringCopy (saveScope, token->scope);
+	DebugStatement (
+			debugPrintf (DEBUG_PARSE
+				, "\n parseStatement: token isClass:%d  scope:%s  name:%s\n"
+				, token->isClass
+				, vStringValue(token->scope)
+				, vStringValue(token->string)
+				);
+			);
+	/*
+	 * Functions can be named or unnamed.
+	 * This deals with these formats:
+	 * Function
+	 *	   validFunctionOne = function(a,b) {}
+	 *	   testlib.validFunctionFive = function(a,b) {}
+	 *	   var innerThree = function(a,b) {}
+	 *	   var innerFour = (a,b) {}
+	 *	   var D2 = secondary_fcn_name(a,b) {}
+	 *	   var D3 = new Function("a", "b", "return a+b;");
+	 * Class
+	 *	   testlib.extras.ValidClassOne = function(a,b) {
+	 *		   this.a = a;
+	 *	   }
+	 * Class Methods
+	 *	   testlib.extras.ValidClassOne.prototype = {
+	 *		   'validMethodOne' : function(a,b) {},
+	 *		   'validMethodTwo' : function(a,b) {}
+	 *	   }
+     *     ValidClassTwo = function ()
+     *     {
+     *         this.validMethodThree = function() {}
+     *         // unnamed method
+     *         this.validMethodFour = () {}
+     *     }
+	 *	   Database.prototype.validMethodThree = Database_getTodaysDate;
+	 */
+
+	/* skip attributes */
+	while (isKeyword (token, KEYWORD_public) ||
+	       isKeyword (token, KEYWORD_protected) ||
+	       isKeyword (token, KEYWORD_private) ||
+	       isKeyword (token, KEYWORD_override) ||
+	       isKeyword (token, KEYWORD_static) ||
+	       isKeyword (token, KEYWORD_internal) ||
+	       isKeyword (token, KEYWORD_native) ||
+	       isKeyword (token, KEYWORD_dynamic) ||
+	       isKeyword (token, KEYWORD_final))
+	{
+		if (isKeyword(token, KEYWORD_public))
+			is_public = true;
+
+		readToken (token);
+	}
+
+	if (isType(token, TOKEN_KEYWORD))
+	{
+		switch (token->keyword)
+		{
+			case KEYWORD_for:
+			case KEYWORD_while:
+			case KEYWORD_do:
+				is_terminated = parseLoop (token);
+				break;
+			case KEYWORD_if:
+			case KEYWORD_else:
+			case KEYWORD_try:
+			case KEYWORD_catch:
+			case KEYWORD_finally:
+				/* Common semantics */
+				is_terminated = parseIf (token);
+				break;
+			case KEYWORD_switch:
+				parseSwitch (token);
+				break;
+			case KEYWORD_package:
+				parsePackage (token);
+				goto cleanUp;
+				break;
+			case KEYWORD_class:
+				parseClass (token);
+				goto cleanUp;
+				break;
+			case KEYWORD_interface:
+				parseInterface (token);
+				goto cleanUp;
+				break;
+			case KEYWORD_function:
+				parseFunction (token);
+				goto cleanUp;
+				break;
+			case KEYWORD_var:
+			case KEYWORD_const:
+				is_terminated = parseVar (token, is_public);
+				goto cleanUp;
+				break;
+			default:
+				readToken(token);
+				break;
+		}
+	}
+
+nextVar:
+	copyToken (name, token, true);
+
+	while (! isType (token, TOKEN_CLOSE_CURLY) &&
+	       ! isType (token, TOKEN_SEMICOLON)   &&
+	       ! isType (token, TOKEN_EQUAL_SIGN)  &&
+	       ! isType (token, TOKEN_COMMA)       &&
+	       ! isType (token, TOKEN_EOF))
+	{
+		if (isType (token, TOKEN_OPEN_CURLY))
+			parseBlock (token, NULL);
+
+		/* Potentially the name of the function */
+		if (isType (token, TOKEN_PERIOD))
+		{
+			/*
+			 * Cannot be a global variable is it has dot references in the name
+			 */
+			is_global = false;
+			/* Assume it's an assignment to a global name (e.g. a class) using
+			 * its fully qualified name, so strip the scope.
+			 * FIXME: resolve the scope so we can make more than an assumption. */
+			vStringClear (token->scope);
+			vStringClear (name->scope);
+			do
+			{
+				readToken (token);
+				if (! isType(token, TOKEN_KEYWORD))
+				{
+					if ( is_class )
+					{
+						addToScope(token, name->string);
+					}
+					else
+						addContext (name, token);
+
+					readToken (token);
+				}
+				else if ( isKeyword(token, KEYWORD_prototype) )
+				{
+					/*
+					 * When we reach the "prototype" tag, we infer:
+					 *     "BindAgent" is a class
+					 *     "build"     is a method
+					 *
+					 * function BindAgent( repeatableIdName, newParentIdName ) {
+					 * }
+					 *
+					 * CASE 1
+					 * Specified function name: "build"
+					 *     BindAgent.prototype.build = function( mode ) {
+					 *     	  ignore everything within this function
+					 *     }
+					 *
+					 * CASE 2
+					 * Prototype listing
+					 *     ValidClassOne.prototype = {
+					 *         'validMethodOne' : function(a,b) {},
+					 *         'validMethodTwo' : function(a,b) {}
+					 *     }
+					 *
+					 */
+					makeClassTag (name);
+					is_class = true;
+					/* is_prototype = true; */
+
+					/*
+					 * There should a ".function_name" next.
+					 */
+					readToken (token);
+					if (isType (token, TOKEN_PERIOD))
+					{
+						/*
+						 * Handle CASE 1
+						 */
+						readToken (token);
+						if (! isType(token, TOKEN_KEYWORD))
+						{
+							addToScope(token, name->string);
+
+							makeFlexTag (token, FLEXTAG_METHOD);
+							/*
+							 * We can read until the end of the block / statement.
+							 * We need to correctly parse any nested blocks, but
+							 * we do NOT want to create any tags based on what is
+							 * within the blocks.
+							 */
+							token->ignoreTag = true;
+							/*
+							 * Find to the end of the statement
+							 */
+							findCmdTerm (token, false, false);
+							token->ignoreTag = false;
+							is_terminated = true;
+							goto cleanUp;
+						}
+					}
+					else if (isType (token, TOKEN_EQUAL_SIGN))
+					{
+						readToken (token);
+						if (isType (token, TOKEN_OPEN_CURLY))
+						{
+							/*
+							 * Handle CASE 2
+							 *
+							 * Creates tags for each of these class methods
+							 *     ValidClassOne.prototype = {
+							 *         'validMethodOne' : function(a,b) {},
+							 *         'validMethodTwo' : function(a,b) {}
+							 *     }
+							 */
+							parseMethods(token, name);
+							/*
+							 * Find to the end of the statement
+							 */
+							findCmdTerm (token, false, false);
+							token->ignoreTag = false;
+							is_terminated = true;
+							goto cleanUp;
+						}
+					}
+				}
+				else
+					readToken (token);
+			} while (isType (token, TOKEN_PERIOD));
+		}
+		else
+			readTokenFull (token, true);
+
+		if ( isType (token, TOKEN_OPEN_PAREN) )
+			skipArgumentList(token, false);
+
+		if ( isType (token, TOKEN_COLON) )
+		{
+			/*
+			 * Functions are of this form:
+			 *   function fname ():ReturnType {
+			 */
+			readToken (token);
+			if (isType (token, TOKEN_IDENTIFIER))
+				readToken (token);
+		}
+
+		if ( isType (token, TOKEN_OPEN_SQUARE) )
+			skipArrayList(token, false);
+	}
+
+	if ( isType (token, TOKEN_CLOSE_CURLY) )
+	{
+		/*
+		 * Reaching this section without having
+		 * processed an open curly brace indicates
+		 * the statement is most likely not terminated.
+		 */
+		is_terminated = false;
+		goto cleanUp;
+	}
+
+	if ( isType (token, TOKEN_SEMICOLON) ||
+	     isType (token, TOKEN_EOF) ||
+	     isType (token, TOKEN_COMMA) )
+	{
+		/*
+		 * Only create variables for global scope
+		 */
+		if ( token->nestLevel == 0 && is_global )
+		{
+			/*
+			 * Handles this syntax:
+			 *	   var g_var2;
+			 */
+			makeFlexTag (name, FLEXTAG_VARIABLE);
+		}
+		/*
+		 * Statement has ended.
+		 * This deals with calls to functions, like:
+		 *     alert(..);
+		 */
+		if (isType (token, TOKEN_COMMA))
+		{
+			readToken (token);
+			goto nextVar;
+		}
+		goto cleanUp;
+	}
+
+	if ( isType (token, TOKEN_EQUAL_SIGN) )
+	{
+		readToken (token);
+
+		if ( isKeyword (token, KEYWORD_function) )
+		{
+			readToken (token);
+
+			if (! isType (token, TOKEN_KEYWORD) &&
+				! isType (token, TOKEN_OPEN_PAREN))
+			{
+				/*
+				 * Functions of this format:
+				 *	   var D2A = function theAdd(a, b)
+				 *	   {
+				 *		  return a+b;
+				 *	   }
+				 * Are really two separate defined functions and
+				 * can be referenced in two ways:
+				 *	   alert( D2A(1,2) );			  // produces 3
+				 *	   alert( theAdd(1,2) );		  // also produces 3
+				 * So it must have two tags:
+				 *	   D2A
+				 *	   theAdd
+				 * Save the reference to the name for later use, once
+				 * we have established this is a valid function we will
+				 * create the secondary reference to it.
+				 */
+				copyToken (secondary_name, token, true);
+				readToken (token);
+			}
+
+			if ( isType (token, TOKEN_OPEN_PAREN) )
+				skipArgumentList(token, false);
+
+			if (isType (token, TOKEN_OPEN_CURLY))
+			{
+				/*
+				 * This will be either a function or a class.
+				 * We can only determine this by checking the body
+				 * of the function.  If we find a "this." we know
+				 * it is a class, otherwise it is a function.
+				 */
+				if ( token->isClass )
+				{
+					makeFlexTag (name, FLEXTAG_METHOD);
+					if ( vStringLength(secondary_name->string) > 0 )
+						makeFunctionTag (secondary_name);
+					parseBlock (token, name->string);
+				}
+				else
+				{
+					parseBlock (token, name->string);
+					makeFunctionTag (name);
+
+					if ( vStringLength(secondary_name->string) > 0 )
+						makeFunctionTag (secondary_name);
+				}
+			}
+		}
+		else if (isType (token, TOKEN_OPEN_PAREN))
+		{
+			/*
+			 * Handle nameless functions
+			 *     this.method_name = () {}
+			 */
+			skipArgumentList(token, false);
+
+			if (isType (token, TOKEN_OPEN_CURLY))
+			{
+				/*
+				 * Nameless functions are only setup as methods.
+				 */
+				makeFlexTag (name, FLEXTAG_METHOD);
+				parseBlock (token, name->string);
+			}
+		}
+		else if (isType (token, TOKEN_OPEN_CURLY))
+		{
+			/*
+			 * Creates tags for each of these class methods
+			 *     ValidClassOne.prototype = {
+			 *         'validMethodOne' : function(a,b) {},
+			 *         'validMethodTwo' : function(a,b) {}
+			 *     }
+			 */
+			parseMethods(token, name);
+			/* Here we should be at the end of the block, on the close curly.
+			 * If so, read the next token not to confuse that close curly with
+			 * the end of the current statement. */
+			if (isType (token, TOKEN_CLOSE_CURLY))
+			{
+				readTokenFull(token, true);
+				is_terminated = isType (token, TOKEN_SEMICOLON);
+			}
+		}
+		else if (isKeyword (token, KEYWORD_new))
+		{
+			readToken (token);
+			if ( isKeyword (token, KEYWORD_function) ||
+					isKeyword (token, KEYWORD_capital_function) ||
+					isKeyword (token, KEYWORD_object) ||
+					isKeyword (token, KEYWORD_capital_object) )
+			{
+				if ( isKeyword (token, KEYWORD_object) ||
+						isKeyword (token, KEYWORD_capital_object) )
+					is_class = true;
+
+				readToken (token);
+				if ( isType (token, TOKEN_OPEN_PAREN) )
+					skipArgumentList(token, true);
+
+				if (isType (token, TOKEN_SEMICOLON))
+				{
+					if ( token->nestLevel == 0 )
+					{
+						if ( is_class )
+						{
+							makeClassTag (name);
+						} else {
+							makeFunctionTag (name);
+						}
+					}
+				}
+				else if (isType (token, TOKEN_CLOSE_CURLY))
+					is_terminated = false;
+			}
+		}
+		else if (! isType (token, TOKEN_KEYWORD))
+		{
+			/*
+			 * Only create variables for global scope
+			 */
+			if ( token->nestLevel == 0 && is_global )
+			{
+				/*
+				 * A pointer can be created to the function.
+				 * If we recognize the function/class name ignore the variable.
+				 * This format looks identical to a variable definition.
+				 * A variable defined outside of a block is considered
+				 * a global variable:
+				 *	   var g_var1 = 1;
+				 *	   var g_var2;
+				 * This is not a global variable:
+				 *	   var g_var = function;
+				 * This is a global variable:
+				 *	   var g_var = different_var_name;
+				 */
+				fulltag = vStringNew ();
+				if (vStringLength (token->scope) > 0)
+				{
+					vStringCopy(fulltag, token->scope);
+					vStringPut (fulltag, '.');
+					vStringCat (fulltag, token->string);
+				}
+				else
+				{
+					vStringCopy(fulltag, token->string);
+				}
+				if ( ! stringListHas(FunctionNames, vStringValue (fulltag)) &&
+						! stringListHas(ClassNames, vStringValue (fulltag)) )
+				{
+					makeFlexTag (name, FLEXTAG_VARIABLE);
+				}
+				vStringDelete (fulltag);
+			}
+		}
+	}
+	/* if we aren't already at the cmd end, advance to it and check whether
+	 * the statement was terminated */
+	if (! isType (token, TOKEN_CLOSE_CURLY) &&
+	    ! isType (token, TOKEN_SEMICOLON))
+	{
+		/*
+		 * Statements can be optionally terminated in the case of
+		 * statement prior to a close curly brace as in the
+		 * document.write line below:
+		 *
+		 * function checkForUpdate() {
+		 *	   if( 1==1 ) {
+		 *		   document.write("hello from checkForUpdate<br>")
+		 *	   }
+		 *	   return 1;
+		 * }
+		 */
+		is_terminated = findCmdTerm (token, true, true);
+		/* if we're at a comma, try and read a second var */
+		if (isType (token, TOKEN_COMMA))
+		{
+			readToken (token);
+			goto nextVar;
+		}
+	}
+
+cleanUp:
+	vStringCopy(token->scope, saveScope);
+	deleteToken (name);
+	deleteToken (secondary_name);
+	vStringDelete(saveScope);
+
+	return is_terminated;
+}
+
+static bool parseLine (tokenInfo *const token)
+{
+	bool is_terminated = true;
+	/*
+	 * Detect the common statements, if, while, for, do, ...
+	 * This is necessary since the last statement within a block "{}"
+	 * can be optionally terminated.
+	 *
+	 * If the statement is not terminated, we need to tell
+	 * the calling routine to prevent reading an additional token
+	 * looking for the end of the statement.
+	 */
+
+	if (isType(token, TOKEN_KEYWORD))
+	{
+		switch (token->keyword)
+		{
+			case KEYWORD_for:
+			case KEYWORD_while:
+			case KEYWORD_do:
+				is_terminated = parseLoop (token);
+				break;
+			case KEYWORD_if:
+			case KEYWORD_else:
+			case KEYWORD_try:
+			case KEYWORD_catch:
+			case KEYWORD_finally:
+				/* Common semantics */
+				is_terminated = parseIf (token);
+				break;
+			case KEYWORD_switch:
+				parseSwitch (token);
+				break;
+			case KEYWORD_return:
+				readToken (token);
+				is_terminated = parseLine (token);
+				break;
+			case KEYWORD_function:
+				parseFunction (token);
+				break;
+			case KEYWORD_import:
+				is_terminated = parseImport (token);
+				/* to properly support unterminated imports at top level,
+				 * recurse here because parseActionScript() will *always*
+				 * advance to avoid ever getting stuck. */
+				if (! is_terminated)
+					return parseLine (token);
+				break;
+			default:
+				is_terminated = parseStatement (token);
+				break;
+		}
+	}
+	else
+	{
+		/*
+		 * Special case where single line statements may not be
+		 * SEMICOLON terminated.  parseBlock needs to know this
+		 * so that it does not read the next token.
+		 */
+		is_terminated = parseStatement (token);
+	}
+	return is_terminated;
+}
+
+static bool parseCDATA (tokenInfo *const token)
+{
+	if (isType (token, TOKEN_LESS_THAN))
+	{
+		/*
+		 * Handle these tags
+		 * <![CDATA[
+		 *    ...
+		 * ]]>
+		 */
+		readToken (token);
+		if (isType (token, TOKEN_EXCLAMATION))
+		{
+			readToken (token);
+			if (isType (token, TOKEN_OPEN_SQUARE))
+			{
+				readToken (token);
+				if (isKeyword (token, KEYWORD_cdata))
+				{
+					readToken (token);
+					if (isType (token, TOKEN_OPEN_SQUARE))
+					{
+						parseActionScript (token, true);
+						if (isType (token, TOKEN_CLOSE_SQUARE))
+						{
+							readToken (token);
+							if (isType (token, TOKEN_CLOSE_SQUARE))
+							{
+								readToken (token);
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	else
+	{
+		parseActionScript (token, false);
+	}
+	return true;
+}
+
+static bool parseNamespace (tokenInfo *const token)
+{
+	/*
+	 * If we have found a <, we know it is not a TOKEN_OPEN_MXML
+	 * but it could potentially be a different namespace.
+	 * This means it will also have a closing tag, which will
+	 * mess up the parser if we do not properly recurse
+	 * through these tags.
+	 */
+
+	if (isType (token, TOKEN_LESS_THAN))
+	{
+		readToken (token);
+	}
+
+	/*
+	 * Check if we have reached a other namespace tag
+	 *   <views:Object ... />
+	 * or
+	 *   <views:Object ... >
+	 *   </views:Object>
+	 */
+	if (isType (token, TOKEN_IDENTIFIER))
+	{
+		readToken (token);
+		if (isType (token, TOKEN_COLON))
+		{
+			readToken (token);
+			if ( ! isType (token, TOKEN_IDENTIFIER))
+			{
+				return true;
+			}
+		}
+		else
+		{
+			return true;
+		}
+	}
+	else
+	{
+		return true;
+	}
+
+	/*
+	 * Confirmed we are inside a namespace tag, so
+	 * process it until the close tag.
+	 *
+	 * But also check for new tags, which will either
+	 * be recursive namespaces or MXML tags
+	 */
+	do
+	{
+		if (isType (token, TOKEN_LESS_THAN))
+		{
+			parseNamespace (token);
+			readToken (token);
+		}
+		if (isType (token, TOKEN_OPEN_MXML))
+		{
+			parseMXML (token);
+		}
+		else
+		{
+			readToken (token);
+		}
+	} while (! (isType (token, TOKEN_CLOSE_SGML) ||
+		    isType (token, TOKEN_CLOSE_MXML) ||
+		    isEOF (token)) );
+	return true;
+}
+
+static bool parseMXML (tokenInfo *const token)
+{
+	tokenInfo *const name = newToken ();
+	tokenInfo *const type = newToken ();
+	bool inside_attributes = true;
+	/*
+	 * Detect the common statements, if, while, for, do, ...
+	 * This is necessary since the last statement within a block "{}"
+	 * can be optionally terminated.
+	 *
+	 * If the statement is not terminated, we need to tell
+	 * the calling routine to prevent reading an additional token
+	 * looking for the end of the statement.
+	 */
+
+	readToken (token);
+
+	if (isKeyword (token, KEYWORD_script))
+	{
+		/*
+		 * These tags can be of this form:
+		 * <mx:Script src="filename.as" />
+		 */
+		do
+		{
+			readToken (token);
+		} while (! (isType (token, TOKEN_CLOSE_SGML)   ||
+			    isType (token, TOKEN_CLOSE_MXML)   ||
+			    isType (token, TOKEN_GREATER_THAN) ||
+			    isEOF (token)) );
+
+		if (isType (token, TOKEN_CLOSE_MXML))
+		{
+			/*
+			 * We have found a </mx:type> tag
+			 * Finish reading the "type" and ">"
+			 */
+			readToken (token);
+			readToken (token);
+			goto cleanUp;
+		}
+		if (isType (token, TOKEN_CLOSE_SGML))
+		{
+			/*
+			 * We have found a <mx:Script src="filename.as" />
+			 */
+			goto cleanUp;
+		}
+
+		/*
+		 * This is a beginning of an embedded script.
+		 * These typically are of this format:
+		 *    mx:Script
+		 *        <![CDATA[
+		 *        ... ActionScript ...
+		 *        ]]>
+		 *    </mx:Script>
+		 */
+		readToken (token);
+		parseCDATA (token);
+
+		readToken (token);
+		if (isType (token, TOKEN_CLOSE_MXML))
+		{
+			/*
+			 * We have found a </mx:type> tag
+			 * Finish reading the "type" and ">"
+			 */
+			readToken (token);
+			readToken (token);
+		}
+		goto cleanUp;
+	}
+
+	copyToken (type, token, true);
+
+	readToken (token);
+	do
+	{
+		if (isType (token, TOKEN_GREATER_THAN))
+		{
+			inside_attributes = false;
+		}
+		if (isType (token, TOKEN_LESS_THAN))
+		{
+			parseNamespace (token);
+			readToken (token);
+		}
+		else if (isType (token, TOKEN_OPEN_MXML))
+		{
+			parseMXML (token);
+			readToken (token);
+		}
+		else if (inside_attributes && (isKeyword (token, KEYWORD_id) || isKeyword (token, KEYWORD_name)))
+		{
+			if (vStringLength(name->string) == 0 )
+			{
+				/*
+				 * If we have already created the tag based on either "name"
+				 * or "id" do not do it again.
+				 */
+				readToken (token);
+				readToken (token);
+
+				copyToken (name, token, true);
+				addToScope (name, type->string);
+				makeMXTag (name);
+			}
+			else
+			{
+				readToken (token);
+			}
+		}
+		else
+		{
+			readToken (token);
+		}
+	} while (! (isType (token, TOKEN_CLOSE_SGML) ||
+		    isType (token, TOKEN_CLOSE_MXML) ||
+		    isEOF (token)) );
+
+	if (isType (token, TOKEN_CLOSE_MXML))
+	{
+		/*
+		 * We have found a </mx:type> tag
+		 * Finish reading the "type" and ">"
+		 */
+		readToken (token);
+		readToken (token);
+	}
+
+cleanUp:
+	deleteToken (name);
+	deleteToken (type);
+	return true;
+}
+
+static bool parseActionScript (tokenInfo *const token, bool readNext)
+{
+	LastTokenType = TOKEN_UNDEFINED;
+
+	do
+	{
+		if (! readNext)
+			readNext = true;
+		else
+			readToken (token);
+
+		if (isType (token, TOKEN_LESS_THAN))
+		{
+			/*
+			 * Handle these tags
+			 * <![CDATA[
+			 *    ...
+			 * ]]>
+			 */
+			readToken (token);
+			if (isType (token, TOKEN_EQUAL_SIGN))
+			{
+				if (isType (token, TOKEN_OPEN_SQUARE))
+				{
+					readToken (token);
+					if (isKeyword (token, KEYWORD_cdata))
+					{
+						readToken (token);
+					}
+				}
+			}
+		}
+		if (isType (token, TOKEN_CLOSE_SQUARE))
+		{
+			/*
+			 * Handle these tags
+			 * <![CDATA[
+			 *    ...
+			 * ]]>
+			 */
+			readToken (token);
+			if (isType (token, TOKEN_CLOSE_SQUARE))
+			{
+				readToken (token);
+				if (isType (token, TOKEN_GREATER_THAN))
+				{
+					return true;
+				}
+			}
+		}
+		else if (isType (token, TOKEN_CLOSE_MXML))
+		{
+			/*
+			 * Read the Script> tags
+			 */
+			readToken (token);
+			readToken (token);
+			return true;
+		}
+		else if (isType (token, TOKEN_OPEN_MXML))
+		{
+			parseMXML (token);
+		}
+		else
+		{
+			parseLine (token);
+		}
+	} while (!isEOF (token));
+	return true;
+}
+
+static void parseFlexFile (tokenInfo *const token)
+{
+	do
+	{
+		readToken (token);
+
+		if (isType (token, TOKEN_OPEN_MXML))
+		{
+			parseMXML (token);
+		}
+		else if (isType (token, TOKEN_LESS_THAN))
+		{
+			readToken (token);
+			if (isType (token, TOKEN_QUESTION_MARK))
+			{
+				/*
+				 * <?xml version="1.0" encoding="utf-8"?>
+				 */
+				readToken (token);
+				while (! (isType (token, TOKEN_QUESTION_MARK) || isEOF (token)))
+				{
+					readToken (token);
+				}
+				readToken (token);
+			}
+			else if (isKeyword (token, KEYWORD_NONE))
+			{
+				/*
+				 * This is a simple XML tag, read until the closing statement
+				 * <something .... >
+				 * </something>
+				 */
+				readToken (token);
+				while (! (isType (token, TOKEN_GREATER_THAN) || isEOF (token)))
+				{
+					readToken (token);
+				}
+			}
+		}
+		else
+		{
+			parseActionScript (token, false);
+		}
+	} while (!isEOF (token));
+}
+
+static void initialize (const langType language)
+{
+	Assert (ARRAY_SIZE (FlexKinds) == FLEXTAG_COUNT);
+	Lang_flex = language;
+}
+
+static void findFlexTags (void)
+{
+	tokenInfo *const token = newToken ();
+
+	NextToken = NULL;
+	ClassNames = stringListNew ();
+	FunctionNames = stringListNew ();
+
+	parseFlexFile (token);
+
+	stringListDelete (ClassNames);
+	stringListDelete (FunctionNames);
+	ClassNames = NULL;
+	FunctionNames = NULL;
+	deleteToken (token);
+}
+
+/* Create parser definition structure */
+extern parserDefinition* FlexParser (void)
+{
+	static const char *const extensions [] = { "as", "mxml", NULL };
+	parserDefinition *const def = parserNew ("Flex");
+	def->extensions = extensions;
+	/*
+	 * New definitions for parsing instead of regex
+	 */
+	def->kindTable	= FlexKinds;
+	def->kindCount	= ARRAY_SIZE (FlexKinds);
+	def->parser		= findFlexTags;
+	def->initialize = initialize;
+	def->keywordTable = FlexKeywordTable;
+	def->keywordCount = ARRAY_SIZE (FlexKeywordTable);
+
+	return def;
+}
Modified: src/symbols.c
1 lines changed, 1 insertions(+), 0 deletions(-)
===================================================================
@@ -718,6 +718,7 @@ static void add_top_level_items(GeanyDocument *doc)
    	case GEANY_FILETYPES_AS:
    	{
    		tag_list_add_groups(tag_store,
+				&(tv_iters.tag_externvar), _("Imports"), ICON_NAMESPACE,
    			&(tv_iters.tag_namespace), _("Package"), ICON_NAMESPACE,
    			&(tv_iters.tag_interface), _("Interfaces"), ICON_STRUCT,
    			&(tv_iters.tag_class), _("Classes"), ICON_CLASS,
Modified: src/tagmanager/tm_parser.c
15 lines changed, 9 insertions(+), 6 deletions(-)
===================================================================
@@ -371,14 +371,16 @@ static TMParserMapEntry map_VALA[] = {
 /* not in universal-ctags */
 static TMParserMapEntry map_ACTIONSCRIPT[] = {
    {'f', tm_tag_function_t},
-	{'l', tm_tag_field_t},
-	{'v', tm_tag_variable_t},
-	{'m', tm_tag_macro_t},
    {'c', tm_tag_class_t},
    {'i', tm_tag_interface_t},
-	{'p', tm_tag_package_t},
-	{'o', tm_tag_other_t},
-	{'r', tm_tag_prototype_t},
+	{'P', tm_tag_package_t},
+	{'m', tm_tag_method_t},
+	{'p', tm_tag_member_t},
+	{'v', tm_tag_variable_t},
+	{'l', tm_tag_variable_t},
+	{'C', tm_tag_macro_t},
+	{'I', tm_tag_externvar_t},
+	{'x', tm_tag_other_t},
 };
/* not in universal-ctags */
@@ -765,6 +767,7 @@ gboolean tm_parser_has_full_context(TMParserType lang)
    switch (lang)
    {
    	/* These parsers include full hierarchy in the tag scope, separated by tm_parser_context_separator() */
+		case TM_PARSER_ACTIONSCRIPT:
    	case TM_PARSER_C:
    	case TM_PARSER_CPP:
    	case TM_PARSER_CSHARP:
Modified: tests/ctags/Makefile.am
7 lines changed, 7 insertions(+), 0 deletions(-)
===================================================================
@@ -15,6 +15,13 @@ test_sources = \
    3470609.js						\
    3526726.tex						\
    68hc11.asm						\
+	actionscript/as-first-token.as	\
+	actionscript/classes.as			\
+	actionscript/const2.as			\
+	actionscript/const.as			\
+	actionscript/method-attributes.as	\
+	actionscript/packages.as		\
+	actionscript/sampler.as			\
    angle_bracket.cpp				\
    anonymous_functions.php			\
    arraylist.js					\
Modified: tests/ctags/actionscript/as-first-token.as
1 lines changed, 1 insertions(+), 0 deletions(-)
===================================================================
@@ -0,0 +1 @@
+function f1():void {}
Modified: tests/ctags/actionscript/as-first-token.as.tags
2 lines changed, 2 insertions(+), 0 deletions(-)
===================================================================
@@ -0,0 +1,2 @@
+# format=tagmanager
+f1�16�0
Modified: tests/ctags/actionscript/classes.as
16 lines changed, 16 insertions(+), 0 deletions(-)
===================================================================
@@ -0,0 +1,16 @@
+package {
+  class C1 {
+    public function m1():Boolean { return 0; }
+  }
+  class C2 extends C1 {}
+  class C3 {}
+  interface I1 {}
+  interface I2 {}
+  interface I3 extends I1, I2 {}
+  interface I4 extends I3 {}
+  class C4 implements I1 {}
+  class C5 extends C3 implements I1 {}
+  class C6 extends C3 implements I1, I2 {}
+
+  dynamic class C7{}
+}
Modified: tests/ctags/actionscript/classes.as.tags
13 lines changed, 13 insertions(+), 0 deletions(-)
===================================================================
@@ -0,0 +1,13 @@
+# format=tagmanager
+C1�1�0
+C2�1�0
+C3�1�0
+C4�1�0
+C5�1�0
+C6�1�0
+C7�1�0
+I1�32�0
+I2�32�0
+I3�32�0
+I4�32�0
+m1�128�C1�0
Modified: tests/ctags/actionscript/const.as
8 lines changed, 8 insertions(+), 0 deletions(-)
===================================================================
@@ -0,0 +1,8 @@
+// https://www.oreilly.com/library/view/essential-actionscript-30/0596526946/ch...
+public class AlarmClock {
+  public static const MODE_VISUAL = 1;
+  public static const MODE_AUDIO  = 2;
+  public static const MODE_BOTH   = 3;
+
+  private var mode = AlarmClock.MODE_AUDIO;
+}
Modified: tests/ctags/actionscript/const.as.tags
6 lines changed, 6 insertions(+), 0 deletions(-)
===================================================================
@@ -0,0 +1,6 @@
+# format=tagmanager
+AlarmClock�1�0
+MODE_AUDIO�65536�AlarmClock�0
+MODE_BOTH�65536�AlarmClock�0
+MODE_VISUAL�65536�AlarmClock�0
+mode�16384�AlarmClock�0
Modified: tests/ctags/actionscript/const2.as
7 lines changed, 7 insertions(+), 0 deletions(-)
===================================================================
@@ -0,0 +1,7 @@
+// https://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/statemen...
+const MIN_AGE:int = 21;
+
+const product_array:Array = new Array("Studio", "Dreamweaver", "Flash", "ColdFusion", "Contribute", "Breeze"); 
+product_array.push("Flex"); // array operations are allowed
+product_array = ["Other"];  // assignment is an error
+trace(product_array);
Modified: tests/ctags/actionscript/const2.as.tags
3 lines changed, 3 insertions(+), 0 deletions(-)
===================================================================
@@ -0,0 +1,3 @@
+# format=tagmanager
+MIN_AGE�65536�0
+product_array�65536�0
Modified: tests/ctags/actionscript/method-attributes.as
12 lines changed, 12 insertions(+), 0 deletions(-)
===================================================================
@@ -0,0 +1,12 @@
+/* Not sure it's really valid, but the goal is to check not choking on
+ * attributes, so so long as it's valid attributes it's fine */
+class C {
+  public function f1():void {}
+  private function f2():void {}
+  protected function f3():void {}
+  internal function f4():void {}
+  public function f5():void {}
+  public override function f6():void {}
+  final function f7():void {}
+  native function f8():void {}
+}
Modified: tests/ctags/actionscript/method-attributes.as.tags
10 lines changed, 10 insertions(+), 0 deletions(-)
===================================================================
@@ -0,0 +1,10 @@
+# format=tagmanager
+C�1�0
+f1�128�C�0
+f2�128�C�0
+f3�128�C�0
+f4�128�C�0
+f5�128�C�0
+f6�128�C�0
+f7�128�C�0
+f8�128�C�0
Modified: tests/ctags/actionscript/packages.as
9 lines changed, 9 insertions(+), 0 deletions(-)
===================================================================
@@ -0,0 +1,9 @@
+package P1 {}
+package P2 {
+  function f1() {}
+}
+package P3 {
+  class C1 {}
+}
+package qualified.test . pkg {
+}
Modified: tests/ctags/actionscript/packages.as.tags
7 lines changed, 7 insertions(+), 0 deletions(-)
===================================================================
@@ -0,0 +1,7 @@
+# format=tagmanager
+C1�1�P3�0
+P1�512�0
+P2�512�0
+P3�512�0
+f1�16�P2�0
+qualified.test.pkg�512�0
Modified: tests/ctags/actionscript/sampler.as
66 lines changed, 66 insertions(+), 0 deletions(-)
===================================================================
@@ -0,0 +1,66 @@
+// https://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/sa...
+package 
+{
+    import flash.sampler.*
+    import flash.system.*
+    import flash.utils.*
+    import flash.display.Sprite
+    public class sampleTypes extends Sprite
+    {
+      var b:Boolean = true
+        public function sampleTypes() {
+            flash.sampler.startSampling();
+            for(var i:int=0;i<10000;i++)
+              new Object();
+
+            var cpuSamples:Array=[];
+            var newSamples:Array=[];
+            var delSamples:Array=[];
+            var ids:Array=[]
+
+            var lastTime:Number=0;
+            for each(var s:Sample in getSamples()) {
+              
+              assert(s.time > 0); // positive
+              assert(Math.floor(s.time) == s.time, s.time); // integral
+              assert(s.time >= lastTime, s.time + ":" + lastTime); // ascending
+              assert(s.stack == null || s.stack is Array)
+              if(s.stack) {
+                assert(s.stack[0] is StackFrame);
+                assert(s.stack[0].name is String);
+            }
+              
+              if(s is NewObjectSample) {
+                var nos = NewObjectSample(s);
+                assert(s.id > 0, s.id);
+                assert(s.type is Class, getQualifiedClassName(s.type));
+                newSamples.push(s);
+                ids[s.id] = "got one";
+              } else if(s is DeleteObjectSample) {
+                var dos = DeleteObjectSample(s);
+                delSamples.push(s);
+                assert(ids[dos.id] == "got one");
+              } else if(s is Sample)
+                cpuSamples.push(s);
+              else {
+                assert(false);
+              }
+              lastTime = s.time;
+            }
+
+            trace(b)
+            trace(newSamples.length > 0)
+            trace(cpuSamples.length > 0)
+            trace(delSamples.length > 0)
+
+        }
+
+        private function assert(e:Boolean, mess:String=null):void {
+          b = e && b;
+          if(true && !e) {
+            if(mess) trace(mess);
+            trace(new Error().getStackTrace());
+          }     
+        }         
+    }
+}
Modified: tests/ctags/actionscript/sampler.as.tags
16 lines changed, 16 insertions(+), 0 deletions(-)
===================================================================
@@ -0,0 +1,16 @@
+# format=tagmanager
+assert�128�sampleTypes�0
+b�16384�sampleTypes�0
+cpuSamples�16384�sampleTypes.sampleTypes�0
+delSamples�16384�sampleTypes.sampleTypes�0
+dos�16384�sampleTypes.sampleTypes�0
+flash.display.Sprite�32768�0
+flash.sampler.*�32768�0
+flash.system.*�32768�0
+flash.utils.*�32768�0
+ids�16384�sampleTypes.sampleTypes�0
+lastTime�16384�sampleTypes.sampleTypes�0
+newSamples�16384�sampleTypes.sampleTypes�0
+nos�16384�sampleTypes.sampleTypes�0
+sampleTypes�1�0
+sampleTypes�128�sampleTypes�0
--------------
This E-Mail was brought to you by github_commit_mail.py (Source: https://github.com/geany/infrastructure).

    