diff --git a/plugins/nextmap.sp b/plugins/nextmap.sp
index 0e9e118d..4f11925d 100644
--- a/plugins/nextmap.sp
+++ b/plugins/nextmap.sp
@@ -52,7 +52,7 @@ new g_MapListSerial = -1;
 
 new g_CurrentMapStartTime;
 
-public APLRes:AskPluginLoad2(Handle:myself, bool:late, String:error[], err_max)
+public APLRes:AskPluginLoad2(Handle myself, bool late, char[] error, int err_max)
 {
 	decl String:game[128];
 	GetGameFolderName(game, sizeof(game));
@@ -75,7 +75,6 @@ public APLRes:AskPluginLoad2(Handle:myself, bool:late, String:error[], err_max)
 
 public OnPluginStart()
 {
-
 	LoadTranslations("common.phrases");
 	LoadTranslations("nextmap.phrases");
 	
@@ -110,7 +109,7 @@ public OnConfigsExecuted()
 	}
 }
 
-public Action:Command_List(client, args) 
+public Action:Command_List(int client, int args) 
 {
 	PrintToConsole(client, "Map Cycle:");
 	
@@ -170,7 +169,7 @@ FindAndSetNextMap()
 	SetNextMap(mapName);
 }
 
-public Action:Command_MapHistory(client, args)
+public Action:Command_MapHistory(int client, int args)
 {
 	new mapCount = GetMapHistorySize();
 	
@@ -203,7 +202,7 @@ public Action:Command_MapHistory(client, args)
 	return Plugin_Handled;
 }
 
-FormatTimeDuration(String:buffer[], maxlen, time)
+FormatTimeDuration(char[] buffer, int maxlen, int time)
 {
 	new	days = time / 86400;
 	new	hours = (time / 3600) % 24;
diff --git a/sourcepawn/compiler/sc.h b/sourcepawn/compiler/sc.h
index 3d052794..2fb0a391 100644
--- a/sourcepawn/compiler/sc.h
+++ b/sourcepawn/compiler/sc.h
@@ -1,3 +1,4 @@
+// vim: set sts=2 ts=8 sw=2 tw=99 et:
 /*  Pawn compiler
  *
  *  Drafted after the Small-C compiler Version 2.01, originally created
@@ -50,6 +51,7 @@
 #define CTRL_CHAR   '\\'    /* default control character */
 #define sCHARBITS   8       /* size of a packed character */
 
+#define MAXTAGS 16
 #define sDIMEN_MAX     4    /* maximum number of array dimensions */
 #define sLINEMAX     4095   /* input line length (in characters) */
 #define sCOMP_STACK   32    /* maximum nesting of #if .. #endif sections */
@@ -256,14 +258,34 @@ typedef struct svalue_s {
   int lvalue;
 } svalue;
 
-#define DECLFLAG_ONLY_NEW_TYPES  0x1
+#define TYPEFLAG_ONLY_NEW        0x01 // Only new-style types are allowed.
+#define TYPEFLAG_ARGUMENT        0x02 // The declaration is for an argument.
+#define TYPEFLAG_VARIABLE        0x04 // The declaration is for a variable.
+#define TYPEFLAG_ENUMROOT        0x08 // Multi-dimensional arrays should have an enumroot.
+#define TYPEFLAG_NO_POSTDIMS     0x10 // Do not parse post-fix dimensions.
+#define TYPEFLAG_RETURN          0x20 // Return type.
+#define TYPEMASK_NAMED_DECL      (TYPEFLAG_ARGUMENT | TYPEFLAG_VARIABLE)
+
+typedef struct {
+  // Array information.
+  int numdim;
+  int dim[sDIMEN_MAX];
+  int idxtag[sDIMEN_MAX];
+  cell array_size;
+  constvalue *enumroot;
+
+  // Type information.
+  int tag;           // Same as tags[0].
+  int tags[MAXTAGS]; // List of tags if multi-tagged.
+  int numtags;       // Number of tags found.
+  int ident;         // Either iREFERENCE, iARRAY, or iVARIABLE.
+  char usage;        // Usage flags.
+} typeinfo_t;
 
 /* For parsing declarations. */
 typedef struct {
-  char type[sNAMEMAX + 1];
-  constvalue *enumroot;
-  int tag;
-  char usage;
+  char name[sNAMEMAX + 1];
+  typeinfo_t type;
 } declinfo_t;
 
 /*  "while" statement queue (also used for "for" and "do - while" loops) */
@@ -492,8 +514,11 @@ typedef enum s_optmark {
 #define FIXEDTAG     0x40000000Lu
 #define FUNCTAG      0x20000000Lu
 #define OBJECTTAG    0x10000000Lu
+#define ENUMTAG      0x08000000Lu
+#define METHODMAPTAG 0x04000000Lu
 #define TAGMASK       (~PUBLICTAG)
-#define TAGFLAGMASK   (FIXEDTAG | FUNCTAG | OBJECTTAG)
+#define TAGTYPEMASK   (FUNCTAG | OBJECTTAG | ENUMTAG | METHODMAPTAG)
+#define TAGFLAGMASK   (FIXEDTAG | TAGTYPEMASK)
 #define CELL_MAX      (((ucell)1 << (sizeof(cell)*8-1)) - 1)
 
 
@@ -513,7 +538,8 @@ int pc_findtag(const char *name);
 constvalue *pc_tagptr(const char *name);
 int pc_enablewarning(int number,int enable);
 const char *pc_tagname(int tag);
-int parse_decl(declinfo_t *decl, const token_t *first, int flags);
+int parse_decl(declinfo_t *decl, int flags);
+const char *type_to_name(int tag);
 
 /*
  * Functions called from the compiler (to be implemented by you)
@@ -599,11 +625,13 @@ SC_FUNC void preprocess(void);
 SC_FUNC void lexinit(void);
 SC_FUNC int lex(cell *lexvalue,char **lexsym);
 SC_FUNC int lextok(token_t *tok);
+SC_FUNC int lexpeek(int id);
 SC_FUNC void lexpush(void);
 SC_FUNC void lexclr(int clreol);
 SC_FUNC int matchtoken(int token);
 SC_FUNC int tokeninfo(cell *val,char **str);
 SC_FUNC int needtoken(int token);
+SC_FUNC int matchtoken2(int id, token_t *tok);
 SC_FUNC int expecttoken(int id, token_t *tok);
 SC_FUNC int matchsymbol(token_ident_t *ident);
 SC_FUNC int needsymbol(token_ident_t *ident);
@@ -888,8 +916,10 @@ SC_VDECL int pc_functag;      /* global function tag */
 SC_VDECL int pc_tag_string;   /* global String tag */
 SC_VDECL int pc_tag_void;     /* global void tag */
 SC_VDECL int pc_tag_object;   /* root object tag */
+SC_VDECL int pc_tag_bool;     /* global bool tag */
 SC_VDECL int pc_anytag;       /* global any tag */
 SC_VDECL int glbstringread;	  /* last global string read */
+SC_VDECL int sc_require_newdecls; /* only newdecls are allowed */
 
 SC_VDECL constvalue sc_automaton_tab; /* automaton table */
 SC_VDECL constvalue sc_state_tab;     /* state table */
diff --git a/sourcepawn/compiler/sc1.c b/sourcepawn/compiler/sc1.c
index 7f63f9ac..8dabb4e5 100644
--- a/sourcepawn/compiler/sc1.c
+++ b/sourcepawn/compiler/sc1.c
@@ -78,6 +78,7 @@ int pc_functag = 0;
 int pc_tag_string = 0;
 int pc_tag_void = 0;
 int pc_tag_object = 0;
+int pc_tag_bool = 0;
 
 typedef struct funcstub_setup_s {
   const char *name;
@@ -121,8 +122,7 @@ static void attachstatelist(symbol *sym, int state_id);
 static symbol *funcstub(int fnative, const funcstub_setup_t *setup);
 static int newfunc(const funcstub_setup_t *setup,int fpublic,int fstatic,int stock,symbol **symp);
 static int declargs(symbol *sym, int chkshadow, const int *thistag);
-static void doarg(char *name,int ident,int offset,int tags[],int numtags,
-                  int fpublic,int fconst,int chkshadow,arginfo *arg);
+static void doarg(declinfo_t *decl, int offset, int fpublic, int chkshadow, arginfo *arg);
 static void make_report(symbol *root,FILE *log,char *sourcefile);
 static void reduce_referrers(symbol *root);
 static long max_stacksize(symbol *root,int *recursion);
@@ -705,8 +705,10 @@ int pc_addtag_flags(char *name, int flags)
   ptr=tagname_tab.next;
   while (ptr!=NULL) {
     tag=(int)(ptr->value & TAGMASK);
-    if (strcmp(name,ptr->name)==0)
+    if (strcmp(name,ptr->name)==0) {
+      ptr->value |= flags;
       return tag;       /* tagname is known, return its sequence number */
+    }
     tag &= ~TAGFLAGMASK;
     if (tag>last)
       last=tag;
@@ -1261,7 +1263,7 @@ static void setconfig(char *root)
 static void setcaption(void)
 {
   pc_printf("SourcePawn Compiler %s\n", SOURCEMOD_VERSION);
-  pc_printf("Copyright (c) 1997-2006, ITB CompuPhase, (C)2004-2008 AlliedModders, LLC\n\n");
+  pc_printf("Copyright (c) 1997-2006, ITB CompuPhase, (C)2004-2014 AlliedModders, LLC\n\n");
 }
 
 static void about(void)
@@ -1345,6 +1347,7 @@ static void setconstants(void)
   sc_rationaltag = pc_addtag("Float");
   pc_tag_void = pc_addtag_flags("void", FIXEDTAG);
   pc_tag_object = pc_addtag_flags("object", FIXEDTAG|OBJECTTAG);
+  pc_tag_bool = pc_addtag("bool");
 
   add_constant("true",1,sGLOBAL,1);     /* boolean flags */
   add_constant("false",0,sGLOBAL,1);
@@ -3242,70 +3245,6 @@ static void declstruct(void)
 	matchtoken(';');	/* eat up optional semicolon */
 }
 
-int parse_typeexpr(declinfo_t *decl, const token_t *first, int flags)
-{
-  token_t tok;
-
-  if (first) {
-    tok = *first;
-  } else {
-    lextok(&tok);
-  }
-
-  if (tok.id == tCONST) {
-    decl->usage |= uCONST;
-    lextok(&tok);
-  }
-
-  if (tok.id == tLABEL && (flags & DECLFLAG_ONLY_NEW_TYPES)) {
-    error(120);
-    return FALSE;
-  }
-
-  if (tok.id == '[') {
-    error(121);
-    return FALSE;
-  }
-
-  switch (tok.id) {
-    case tINT:
-      strcpy(decl->type, "int");
-      decl->tag = 0;
-      break;
-    case tCHAR:
-      strcpy(decl->type, "char");
-      decl->tag = pc_tag_string;
-      break;
-    case tVOID:
-      strcpy(decl->type, "void");
-      decl->tag = pc_tag_void;
-      break;
-    case tOBJECT:
-      strcpy(decl->type, "object");
-      decl->tag = pc_tag_object;
-      break;
-    case tSYMBOL:
-      strcpy(decl->type, tok.str);
-      if (strcmp(decl->type, "float") == 0) {
-        decl->tag = sc_rationaltag;
-      } else {
-        decl->tag = pc_findtag(decl->type);
-        if (decl->tag == sc_rationaltag)
-          error(98, "Float", "float");
-        else if (decl->tag == pc_tag_string)
-          error(98, "String", "char");
-        else if (decl->tag == 0)
-          error(98, "_", "int");
-      }
-      break;
-    default:
-      error(122);
-      return FALSE;
-  }
-
-  return TRUE;
-}
-
 // Consumes a line, returns FALSE if EOF hit.
 static int consume_line()
 {
@@ -3326,18 +3265,310 @@ static int consume_line()
   return TRUE;
 }
 
-// Parse a new-style declaration. If the name was already fetched (because we
-// didn't have enough lookahead), it can be given ahead of time.
-int parse_decl(declinfo_t *decl, const token_t *first, int flags)
+static int parse_new_typeexpr(typeinfo_t *type, const token_t *first, int flags)
 {
-  memset(decl, 0, sizeof(*decl));
+  token_t tok;
 
-  if (!parse_typeexpr(decl, first, flags))
-    return FALSE;
+  if (first)
+    tok = *first;
+  else
+    lextok(&tok);
+
+  if (tok.id == tCONST) {
+    if (type->usage & uCONST)
+      error(138);
+    type->usage |= uCONST;
+    lextok(&tok);
+  }
+
+  switch (tok.id) {
+    case tINT:
+      type->tag = 0;
+      break;
+    case tCHAR:
+      type->tag = pc_tag_string;
+      break;
+    case tVOID:
+      type->tag = pc_tag_void;
+      break;
+    case tOBJECT:
+      type->tag = pc_tag_object;
+      break;
+    case tLABEL:
+      type->tag = pc_addtag(tok.str);
+      error(120);
+      break;
+    case tSYMBOL:
+      if (strcmp(tok.str, "float") == 0) {
+        type->tag = sc_rationaltag;
+      } else if (strcmp(tok.str, "bool") == 0) {
+        type->tag = pc_tag_bool;
+      } else if (strcmp(tok.str, "char") == 0) {
+        type->tag = pc_tag_string;
+      } else {
+        type->tag = pc_findtag(tok.str);
+        if (type->tag == sc_rationaltag) {
+          error(98, "Float", "float");
+        } else if (type->tag == pc_tag_string) {
+          error(98, "String", "char");
+        } else if (type->tag == 0) {
+          error(98, "_", "int");
+        } else if (type->tag == -1) {
+          error(139, tok.str);
+          type->tag = 0;
+        } else {
+          // Perform some basic filters so we can start narrowing down what can
+          // be used as a type.
+          if (!(type->tag & TAGTYPEMASK))
+            error(139, tok.str);
+        }
+      }
+      break;
+    default:
+      error(122);
+      goto err_out;
+  }
+
+  // Note: we could have already filled in the prefix array bits, so we check
+  // that ident != iARRAY before looking for an open bracket.
+  if (type->ident != iARRAY && matchtoken('[')) {
+    // Not yet supported for return vals. This is allowed with old decls, but
+    // it's a huge hack. For now we forbid it in new code until it works right.
+    if (flags & TYPEFLAG_RETURN)
+      error(136);
+
+    do {
+      if (type->numdim == sDIMEN_MAX) {
+        error(53);
+        break;
+      }
+      type->dim[type->numdim++] = 0;
+      if (!matchtoken(']')) {
+        error(140);
+        goto err_out;
+      }
+    } while (matchtoken('['));
+    type->ident = iARRAY;
+  }
+
+
+  if (flags & TYPEFLAG_ARGUMENT) {
+    if (matchtoken('&')) {
+      if (type->ident == iARRAY) {
+        error(137);
+        goto err_out;
+      }
+      type->ident = iREFERENCE;
+    }
+  }
+
+  type->tags[0] = type->tag;
+  type->numtags = 1;
+  return TRUE;
+
+err_out:
+  type->tags[0] = type->tag;
+  type->numtags = 1;
+  return FALSE;
+}
+
+static void parse_old_array_dims(declinfo_t *decl, int flags)
+{
+  typeinfo_t *type = &decl->type;
+  constvalue **enumrootp;
+
+  // Illegal declaration (we'll have a name since ref requires decl).
+  if (type->ident == iREFERENCE)
+    error(67, decl->name);
+
+  if (flags & TYPEFLAG_ENUMROOT)
+    enumrootp = &type->enumroot;
+  else
+    enumrootp = NULL;
+
+  do {
+    cell size;
+
+    if (type->numdim == sDIMEN_MAX) {
+      error(53);
+      return;
+    }
+
+    type->array_size = needsub(&type->idxtag[type->numdim], enumrootp);
+    if (type->array_size > INT_MAX)
+      error(165);
+
+    type->dim[type->numdim++] = type->array_size;
+  } while (matchtoken('['));
+
+  type->ident = iARRAY;
+}
+
+static int parse_old_decl(declinfo_t *decl, int flags)
+{
+  token_t tok;
+  typeinfo_t *type = &decl->type;
+
+  if (matchtoken(tCONST)) {
+    if (type->usage & uCONST)
+      error(138);
+    type->usage |= uCONST;
+  }
+
+  if (flags & TYPEFLAG_ARGUMENT) {
+    if (matchtoken('&'))
+      type->ident = iREFERENCE;
+
+    // grammar for multitags is:
+    //   multi-tag ::= '{' (symbol (',' symbol)*)? '}' ':'
+    if (matchtoken('{')) {
+      while (type->numtags < MAXTAGS) {
+        int tag = 0;
+
+        if (!matchtoken('_')) {
+          // If we don't get the magic tag '_', then we should have a symbol.
+          if (expecttoken(tSYMBOL, &tok))
+            tag = pc_addtag(tok.str);
+        }
+        type->tags[type->numtags++] = tag;
+
+        if (matchtoken('}'))
+          break;
+        needtoken(',');
+      }
+      needtoken(':');
+    }
+  }
+  
+  if (type->numtags == 0) {
+    if (matchtoken2(tLABEL, &tok))
+      type->tags[type->numtags++] = pc_addtag(tok.str);
+    else
+      type->tags[type->numtags++] = 0;
+  }
+
+  // All finished with tag stuff.
+  type->tag = type->tags[0];
+
+  // Look for varargs and end early.
+  if (matchtoken(tELLIPS)) {
+    type->ident = iVARARGS;
+    return TRUE;
+  }
+
+  if (flags & TYPEMASK_NAMED_DECL) {
+    if (expecttoken(tSYMBOL, &tok))
+      strcpy(decl->name, tok.str);
+    else
+      strcpy(decl->name, "<unknown>");
+  }
+
+  if ((flags & TYPEMASK_NAMED_DECL) && !(flags & TYPEFLAG_NO_POSTDIMS)) {
+    if (matchtoken('['))
+      parse_old_array_dims(decl, flags);
+  }
 
   return TRUE;
 }
 
+static int parse_new_decl(declinfo_t *decl, const token_t *first, int flags)
+{
+  token_t tok;
+
+  if (!parse_new_typeexpr(&decl->type, first, flags))
+    return FALSE;
+  if (!expecttoken(tSYMBOL, &tok))
+    return FALSE;
+  strcpy(decl->name, tok.str);
+
+  if ((flags & TYPEMASK_NAMED_DECL) && !(flags & TYPEFLAG_NO_POSTDIMS)) {
+    if (matchtoken('[')) {
+      if (decl->type.numdim == 0)
+        parse_old_array_dims(decl, flags);
+      else
+        error(121);
+    }
+  }
+
+  return TRUE;
+}
+
+// Parse a declaration.
+//
+// Grammar for named declarations is:
+//    "const"? symbol ('[' ']')* '&'? symbol
+//  | "const"? label? '&'? symbol '[' ']'
+//
+int parse_decl(declinfo_t *decl, int flags)
+{
+  token_t tok;
+  token_ident_t ident;
+
+  memset(decl, 0, sizeof(*decl));
+
+  decl->type.ident = iVARIABLE;
+
+  // Must attempt to match const first, since it's a common prefix.
+  if (matchtoken(tCONST))
+    decl->type.usage |= uCONST;
+
+  // If parsing an argument, there are two simple checks for whether this is a
+  // new or old-style declaration.
+  if ((flags & TYPEFLAG_ARGUMENT) && (lexpeek('&') || lexpeek('{')))
+    return parse_old_decl(decl, flags);
+
+  // Another dead giveaway is there being a label.
+  if (lexpeek(tLABEL))
+    return parse_old_decl(decl, flags);
+
+  // Otherwise, we have to eat a symbol to tell.
+  if (matchsymbol(&ident)) {
+    if (lexpeek(tSYMBOL)) {
+      // A new-style declaration only allows array dims or a symbol name, so
+      // this is a new-style declaration. Make sure to push back the first
+      // symbol.
+      return parse_new_decl(decl, &ident.tok, flags);
+    }
+
+    if ((flags & TYPEMASK_NAMED_DECL) && matchtoken('[')) {
+      // If we're not allowing postdims here, then it must be a newdecl.
+      if (flags & TYPEFLAG_NO_POSTDIMS) {
+        // Give the '[' and symbol back, since we're going to parse from the start.
+        lexpush();
+        lexpush();
+        return parse_new_decl(decl, NULL, flags);
+      }
+
+      // Oh no - we have to parse array dims before we can tell what kind of
+      // declarator this is. It could be either:
+      //    "x[] y" (new-style), or
+      //    "y[],"  (old-style)
+      parse_old_array_dims(decl, flags);
+
+      if (matchtoken(tSYMBOL) || matchtoken('&')) {
+        // This must be a newdecl, "x[] y" or "x[] &y", the latter of which
+        // is illegal, but we flow it through the right path anyway.
+        lexpush();
+        return parse_new_decl(decl, &ident.tok, flags);
+      }
+
+      // The most basic - "x[]" and that's it. Well, we know it has no tag and
+      // we know its name. We might as well just complete the entire decl.
+      strcpy(decl->name, ident.name);
+      decl->type.tags[decl->type.numtags++] = 0;
+      decl->type.tag = decl->type.tags[0];
+      return TRUE;
+    }
+
+    // Give the symbol back to the lexer. This is an old decl.
+    lexpush();
+    return parse_old_decl(decl, flags);
+  }
+
+  // All else has failed. Probably got a type keyword. New-style.
+  return parse_new_decl(decl, NULL, flags);
+}
+
 void define_constructor(methodmap_t *map, methodmap_method_t *method)
 {
   symbol *sym = findglb(map->name, sGLOBAL);
@@ -3410,7 +3641,7 @@ void check_name_length(char *original)
   }
 }
 
-symbol *parse_inline_function(methodmap_t *map, const declinfo_t *decl, const char *name, int is_native, int is_ctor, int is_dtor)
+symbol *parse_inline_function(methodmap_t *map, const typeinfo_t *type, const char *name, int is_native, int is_ctor, int is_dtor)
 {
   funcstub_setup_t setup;
   if (is_dtor)
@@ -3418,7 +3649,7 @@ symbol *parse_inline_function(methodmap_t *map, const declinfo_t *decl, const ch
   else if (is_ctor)
     setup.return_tag = map->tag;
   else
-    setup.return_tag = decl->tag;
+    setup.return_tag = type->tag;
 
   if (is_ctor)
     setup.this_tag = -1;
@@ -3474,7 +3705,7 @@ int check_this_tag(methodmap_t *map, symbol *target)
   return ok;
 }
 
-int parse_property_accessor(const declinfo_t *decl, methodmap_t *map, methodmap_method_t *method)
+int parse_property_accessor(const typeinfo_t *type, methodmap_t *map, methodmap_method_t *method)
 {
   token_ident_t ident;
   int is_native = FALSE;
@@ -3517,7 +3748,7 @@ int parse_property_accessor(const declinfo_t *decl, methodmap_t *map, methodmap_
     char tmpname[METHOD_NAMEMAX + 1];
     strcpy(tmpname, method->name);
     strcat(tmpname, ".get");
-    target = parse_inline_function(map, decl, tmpname, is_native, FALSE, FALSE);
+    target = parse_inline_function(map, type, tmpname, is_native, FALSE, FALSE);
   }
 
   if (!target)
@@ -3537,9 +3768,9 @@ int parse_property_accessor(const declinfo_t *decl, methodmap_t *map, methodmap_
   }
 
   // Must return the same tag as the property.
-  if (decl->tag != target->tag) {
+  if (type->tag != target->tag) {
     const char *kind = getter ? "getter" : "setter";
-    error(128, "getter", map->name, decl->type);
+    error(128, "getter", map->name, type_to_name(type->tag));
   }
 
   if (!check_this_tag(map, target)) {
@@ -3553,11 +3784,12 @@ int parse_property_accessor(const declinfo_t *decl, methodmap_t *map, methodmap_
 
 methodmap_method_t *parse_property(methodmap_t *map)
 {
-  declinfo_t decl;
+  typeinfo_t type;
   token_ident_t ident;
   methodmap_method_t *method;
 
-  if (!parse_decl(&decl, NULL, DECLFLAG_ONLY_NEW_TYPES))
+  memset(&type, 0, sizeof(type));
+  if (!parse_new_typeexpr(&type, NULL, TYPEFLAG_RETURN))
     return NULL;
   if (!needsymbol(&ident))
     return NULL;
@@ -3573,7 +3805,7 @@ methodmap_method_t *parse_property(methodmap_t *map)
       return method;
 
     while (!matchtoken('}')) {
-      if (!parse_property_accessor(&decl, map,method)) {
+      if (!parse_property_accessor(&type, map,method)) {
         if (!consume_line())
           return NULL;
       }
@@ -3601,8 +3833,10 @@ methodmap_method_t *parse_method(methodmap_t *map)
   token_ident_t bindsource;
   strcpy(bindsource.name, "<unknown>");
 
+  typeinfo_t type;
+  memset(&type, 0, sizeof(type));
+
   token_t tok;
-  declinfo_t decl;
   if (matchtoken('~')) {
     // We got something like "public ~Blah = X"
     is_bind = TRUE;
@@ -3657,7 +3891,7 @@ methodmap_method_t *parse_method(methodmap_t *map)
 
         // Parse for type expression, priming it with the token we predicted
         // would be an identifier.
-        if (!parse_decl(&decl, first, DECLFLAG_ONLY_NEW_TYPES))
+        if (!parse_new_typeexpr(&type, first, TYPEFLAG_RETURN))
           return NULL;
 
         // Now, we should get an identifier.
@@ -3697,7 +3931,7 @@ methodmap_method_t *parse_method(methodmap_t *map)
     else if (target->ident != iFUNCTN) 
       error(10);
   } else {
-    target = parse_inline_function(map, &decl, ident.name, is_native, is_ctor, is_dtor);
+    target = parse_inline_function(map, &type, ident.name, is_native, is_ctor, is_dtor);
   }
 
   if (!target)
@@ -3796,7 +4030,7 @@ static void domethodmap(LayoutSpec spec)
   map->spec = spec;
   strcpy(map->name, mapname);
   if (spec == Layout_MethodMap) {
-    map->tag = pc_addtag(mapname);
+    map->tag = pc_addtag_flags(mapname, FIXEDTAG | METHODMAPTAG);
   } else {
     constvalue *tagptr = pc_tagptr(mapname);
     if (!tagptr) {
@@ -4166,7 +4400,10 @@ static void decl_enum(int vclass)
    * pc_addtag() here
    */
   if (lex(&val,&str)==tLABEL) {
-    tag = pc_addtag(str);
+    int flags = ENUMTAG;
+    if (isupper(*str))
+      flags |= FIXEDTAG;
+    tag = pc_addtag_flags(str, flags);
     spec = deduce_layout_spec_by_tag(tag);
     if (!can_redef_layout_spec(spec, Layout_Enum))
       error(110, str, layout_spec_name(spec));
@@ -4181,7 +4418,10 @@ static void decl_enum(int vclass)
   if (lex(&val,&str)==tSYMBOL) {        /* read in (new) token */
     strcpy(enumname,str);               /* save enum name (last constant) */
     if (!explicittag) {
-      tag=pc_addtag(enumname);
+      int flags = ENUMTAG;
+      if (isupper(*str))
+        flags |= FIXEDTAG;
+      tag=pc_addtag_flags(enumname, flags);
       spec = deduce_layout_spec_by_tag(tag);
       if (!can_redef_layout_spec(spec, Layout_Enum))
         error(110, enumname, layout_spec_name(spec));
@@ -4398,6 +4638,15 @@ static void attachstatelist(symbol *sym, int state_id)
   } /* if */
 }
 
+// This simpler version of matchtag() only checks whether two tags represent
+// the same type. Because methodmaps are attached to types and are not actually
+// types themselves, we strip out the methodmap bit in case a methodmap was
+// seen later than another instance of a tag.
+static int compare_tag(int tag1, int tag2)
+{
+  return (tag1 & (~METHODMAPTAG)) == (tag2 & (~METHODMAPTAG));
+}
+
 /*
  *  Finds a function in the global symbol table or creates a new entry.
  *  It does some basic processing and error checking.
@@ -4414,7 +4663,7 @@ SC_FUNC symbol *fetchfunc(char *name,int tag)
       error(21,name);                     /* yes, and it is a native */
     } /* if */
     assert(sym->vclass==sGLOBAL);
-    if ((sym->usage & uPROTOTYPED)!=0 && sym->tag!=tag)
+    if ((sym->usage & uPROTOTYPED)!=0 && !compare_tag(sym->tag, tag))
       error(25);                          /* mismatch from earlier prototype */
     if ((sym->usage & uDEFINE)==0) {
       /* as long as the function stays undefined, update the address and the tag */
@@ -4616,7 +4865,7 @@ static int check_operatortag(int opertok,int resulttag,char *opername)
   case tlNE:
   case tlLE:
   case tlGE:
-    if (resulttag!=pc_addtag("bool")) {
+    if (resulttag!=pc_tag_bool) {
       error(63,opername,"bool:"); /* operator X requires a "bool:" result tag */
       return FALSE;
     } /* if */
@@ -5103,11 +5352,7 @@ static int argcompare(arginfo *a1,arginfo *a2)
 {
   int result,level,i;
 
-#if 0	/* SourceMod uses case insensitive args for forwards */
-  result= strcmp(a1->name,a2->name)==0;     /* name */
-#else
   result=1;
-#endif
   if (result)
     result= a1->ident==a2->ident;           /* type/class */
   if (result)
@@ -5115,13 +5360,13 @@ static int argcompare(arginfo *a1,arginfo *a2)
   if (result)
     result= a1->numtags==a2->numtags;       /* tags (number and names) */
   for (i=0; result && i<a1->numtags; i++)
-    result= a1->tags[i]==a2->tags[i];
+    result= compare_tag(a1->tags[i], a2->tags[i]);
   if (result)
     result= a1->numdim==a2->numdim;         /* array dimensions & index tags */
   for (level=0; result && level<a1->numdim; level++)
     result= a1->dim[level]==a2->dim[level];
   for (level=0; result && level<a1->numdim; level++)
-    result= a1->idxtag[level]==a2->idxtag[level];
+    result= compare_tag(a1->idxtag[level], a2->idxtag[level]);
   if (result)
     result= a1->hasdefault==a2->hasdefault; /* availability of default value */
   if (a1->hasdefault) {
@@ -5144,7 +5389,7 @@ static int argcompare(arginfo *a1,arginfo *a2)
       } /* if */
     } /* if */
     if (result)
-      result= a1->defvalue_tag==a2->defvalue_tag;
+      result= compare_tag(a1->defvalue_tag, a2->defvalue_tag);
   } /* if */
   return result;
 }
@@ -5156,13 +5401,12 @@ static int argcompare(arginfo *a1,arginfo *a2)
  */
 static int declargs(symbol *sym, int chkshadow, const int *thistag)
 {
-  #define MAXTAGS 16
   char *ptr;
-  int argcnt,oldargcnt,tok,tags[MAXTAGS],numtags;
+  int argcnt,oldargcnt,tok;
   cell val;
   arginfo arg, *arglist;
   char name[sNAMEMAX+1];
-  int ident,fpublic,fconst;
+  int ident,fpublic;
   int idx;
 
   /* if the function is already defined earlier, get the number of arguments
@@ -5173,9 +5417,6 @@ static int declargs(symbol *sym, int chkshadow, const int *thistag)
     while (sym->dim.arglist[oldargcnt].ident!=0)
       oldargcnt++;
   argcnt=0;                             /* zero aruments up to now */
-  ident=iVARIABLE;
-  numtags=0;
-  fconst=FALSE;
   fpublic = (sym->usage & (uPUBLIC|uSTOCK))!=0;
 
   if (thistag && *thistag != -1) {
@@ -5210,52 +5451,43 @@ static int declargs(symbol *sym, int chkshadow, const int *thistag)
   /* the '(' parantheses has already been parsed */
   if (!matchtoken(')')){
     do {                                /* there are arguments; process them */
-      /* any legal name increases argument count (and stack offset) */
-      tok=lex(&val,&ptr);
-      switch (tok) {
-      case 0:
-        /* nothing */
-        break;
-      case '&':
-        if (ident!=iVARIABLE || numtags>0)
-          error(1,"-identifier-","&");
-        ident=iREFERENCE;
-        break;
-      case tCONST:
-        if (ident!=iVARIABLE || numtags>0)
-          error(1,"-identifier-","const");
-        fconst=TRUE;
-        break;
-      case tLABEL:
-        if (numtags>0)
-          error(1,"-identifier-","-tagname-");
-        tags[0]=pc_addtag(ptr);
-        numtags=1;
-        break;
-      case '{':
-        if (numtags>0)
-          error(1,"-identifier-","-tagname-");
-        numtags=0;
-        while (numtags<MAXTAGS) {
-          if (!matchtoken('_') && !needtoken(tSYMBOL))
-            break;
-          tokeninfo(&val,&ptr);
-          tags[numtags++]=pc_addtag(ptr);
-          if (matchtoken('}'))
-            break;
-          needtoken(',');
-        } /* for */
-        needtoken(':');
-        tok=tLABEL;     /* for outer loop: flag that we have seen a tagname */
-        break;
-      case tSYMBOL:
-        if (argcnt>=sMAXARGS)
-          error(45);                    /* too many function arguments */
-        strcpy(name,ptr);               /* save symbol name */
-        if (name[0]==PUBLIC_CHAR)
-          error(56,name);               /* function arguments cannot be public */
-        if (numtags==0)
-          tags[numtags++]=0;            /* default tag */
+      declinfo_t decl;
+      parse_decl(&decl, TYPEFLAG_ARGUMENT|TYPEFLAG_ENUMROOT);
+      assert(decl.type.numtags > 0);
+
+      if (decl.type.ident == iVARARGS) {
+        assert(decl.type.numtags > 0);
+        if ((sym->usage & uPROTOTYPED)==0) {
+          /* redimension the argument list, add the entry iVARARGS */
+          sym->dim.arglist=(arginfo*)realloc(sym->dim.arglist,(argcnt+2)*sizeof(arginfo));
+          if (sym->dim.arglist==0)
+            error(163);                 /* insufficient memory */
+          memset(&sym->dim.arglist[argcnt+1],0,sizeof(arginfo));  /* keep the list terminated */
+          sym->dim.arglist[argcnt].ident=iVARARGS;
+          sym->dim.arglist[argcnt].hasdefault=FALSE;
+          sym->dim.arglist[argcnt].defvalue.val=0;
+          sym->dim.arglist[argcnt].defvalue_tag=0;
+          sym->dim.arglist[argcnt].numtags=decl.type.numtags;
+          sym->dim.arglist[argcnt].tags=(int*)malloc(decl.type.numtags*sizeof decl.type.tags[0]);
+          if (sym->dim.arglist[argcnt].tags==NULL)
+            error(163);                 /* insufficient memory */
+          memcpy(sym->dim.arglist[argcnt].tags,decl.type.tags,decl.type.numtags*sizeof decl.type.tags[0]);
+        } else {
+          if (argcnt>oldargcnt || sym->dim.arglist[argcnt].ident!=iVARARGS)
+            error(25);          /* function definition does not match prototype */
+        } /* if */
+        argcnt++;
+        continue;
+      }
+
+      if (argcnt>=sMAXARGS)
+        error(45);
+      if (decl.name[0] == PUBLIC_CHAR)
+        error(56,name);                 /* function arguments cannot be public */
+
+      if (1) {
+        if (decl.type.ident == iARRAY)
+          decl.type.ident = iREFARRAY;
         /* Stack layout:
          *   base + 0*sizeof(cell)  == previous "base"
          *   base + 1*sizeof(cell)  == function return address
@@ -5263,10 +5495,11 @@ static int declargs(symbol *sym, int chkshadow, const int *thistag)
          *   base + 3*sizeof(cell)  == first argument of the function
          * So the offset of each argument is "(argcnt+3) * sizeof(cell)".
          */
-        doarg(name,ident,(argcnt+3)*sizeof(cell),tags,numtags,fpublic,fconst,chkshadow,&arg);
-        /* :TODO: fix this so stocks that are func pointers can't have default arguments? */
+        doarg(&decl,(argcnt+3)*sizeof(cell),fpublic,chkshadow,&arg);
+
         if ((sym->usage & uPUBLIC) && arg.hasdefault)
           error(59,name);       /* arguments of a public function may not have a default value */
+
         if ((sym->usage & uPROTOTYPED)==0) {
           /* redimension the argument list, add the entry */
           sym->dim.arglist=(arginfo*)realloc(sym->dim.arglist,(argcnt+2)*sizeof(arginfo));
@@ -5287,41 +5520,8 @@ static int declargs(symbol *sym, int chkshadow, const int *thistag)
           free(arg.tags);
         } /* if */
         argcnt++;
-        ident=iVARIABLE;
-        numtags=0;
-        fconst=FALSE;
-        break;
-      case tELLIPS:
-        if (ident!=iVARIABLE)
-          error(10);                    /* illegal function or declaration */
-        if (numtags==0)
-          tags[numtags++]=0;            /* default tag */
-        if ((sym->usage & uPROTOTYPED)==0) {
-          /* redimension the argument list, add the entry iVARARGS */
-          sym->dim.arglist=(arginfo*)realloc(sym->dim.arglist,(argcnt+2)*sizeof(arginfo));
-          if (sym->dim.arglist==0)
-            error(163);                 /* insufficient memory */
-          memset(&sym->dim.arglist[argcnt+1],0,sizeof(arginfo));  /* keep the list terminated */
-          sym->dim.arglist[argcnt].ident=iVARARGS;
-          sym->dim.arglist[argcnt].hasdefault=FALSE;
-          sym->dim.arglist[argcnt].defvalue.val=0;
-          sym->dim.arglist[argcnt].defvalue_tag=0;
-          sym->dim.arglist[argcnt].numtags=numtags;
-          sym->dim.arglist[argcnt].tags=(int*)malloc(numtags*sizeof tags[0]);
-          if (sym->dim.arglist[argcnt].tags==NULL)
-            error(163);                 /* insufficient memory */
-          memcpy(sym->dim.arglist[argcnt].tags,tags,numtags*sizeof tags[0]);
-        } else {
-          if (argcnt>oldargcnt || sym->dim.arglist[argcnt].ident!=iVARARGS)
-            error(25);          /* function definition does not match prototype */
-        } /* if */
-        argcnt++;
-        break;
-      default:
-        error(10);                      /* illegal function or declaration */
-      } /* switch */
-    } while (tok=='&' || tok==tLABEL || tok==tCONST
-             || (tok!=tELLIPS && matchtoken(','))); /* more? */
+      }
+    } while (matchtoken(','));
     /* if the next token is not ",", it should be ")" */
     needtoken(')');
   } /* if */
@@ -5380,50 +5580,29 @@ static int declargs(symbol *sym, int chkshadow, const int *thistag)
  *  "fpublic" indicates whether the function for this argument list is public.
  *  The arguments themselves are never public.
  */
-static void doarg(char *name,int ident,int offset,int tags[],int numtags,
-                  int fpublic,int fconst,int chkshadow,arginfo *arg)
+static void doarg(declinfo_t *decl, int offset, int fpublic, int chkshadow, arginfo *arg)
 {
   symbol *argsym;
   constvalue *enumroot;
-  cell size;
   int slength=0;
+  typeinfo_t *type = &decl->type;
 
-  strcpy(arg->name,name);
+  strcpy(arg->name, decl->name);
   arg->hasdefault=FALSE;        /* preset (most common case) */
   arg->defvalue.val=0;          /* clear */
   arg->defvalue_tag=0;
   arg->numdim=0;
-  if (matchtoken('[')) {
-    if (ident==iREFERENCE)
-      error(67,name);           /* illegal declaration ("&name[]" is unsupported) */
-    do {
-      if (arg->numdim == sDIMEN_MAX) {
-        error(53);              /* exceeding maximum number of dimensions */
-        return;
-      } /* if */
-      size=needsub(&arg->idxtag[arg->numdim],&enumroot);/* may be zero here, it is a pointer anyway */
-      #if INT_MAX < LONG_MAX
-        if (size > INT_MAX)
-          error(165);           /* overflow, exceeding capacity */
-      #endif
-      arg->dim[arg->numdim]=(int)size;
-      arg->numdim+=1;
-    } while (matchtoken('['));
-    ident=iREFARRAY;            /* "reference to array" (is a pointer) */
-#if 0 /* For SM, multiple tags including string don't make sense,
-		 so just check the first tag. Done manually so the string
-		 tag isn't matched with the any tag. */
-    if (checktag(tags, numtags, pc_tag_string)) {
-#endif
-	assert(tags!=0);
-	assert(numtags>0);
-	if (tags[0] == pc_tag_string) {
+  if (type->ident == iREFARRAY) {
+    arg->numdim = type->numdim;
+    memcpy(arg->dim, type->dim, sizeof(int) * type->numdim);
+    memcpy(arg->idxtag, type->idxtag, sizeof(int) * type->numdim);
+    assert(type->numtags > 0);
+    if (type->tags[0] == pc_tag_string) {
       slength = arg->dim[arg->numdim - 1];
-      arg->dim[arg->numdim - 1] = (size + sizeof(cell) - 1) / sizeof(cell);
+      arg->dim[arg->numdim - 1] = (type->array_size + sizeof(cell) - 1) / sizeof(cell);
     }
     if (matchtoken('=')) {
       assert(litidx==0);        /* at the start of a function, this is reset */
-      assert(numtags>0);
       /* Check if there is a symbol */
       if (matchtoken(tSYMBOL)) {
         symbol *sym;
@@ -5443,8 +5622,8 @@ static void doarg(char *name,int ident,int offset,int tags[],int numtags,
           }
         }
       } else {
-        initials2(ident,tags[0],&size,arg->dim,arg->numdim,enumroot, 1, 0);
-        assert(size>=litidx);
+        initials2(type->ident, type->tags[0], &type->array_size, arg->dim, arg->numdim, type->enumroot, 1, 0);
+        assert(type->array_size >= litidx);
         /* allocate memory to hold the initial values */
         arg->defvalue.array.data=(cell *)malloc(litidx*sizeof(cell));
         if (arg->defvalue.array.data!=NULL) {
@@ -5466,7 +5645,7 @@ static void doarg(char *name,int ident,int offset,int tags[],int numtags,
   } else {
     if (matchtoken('=')) {
       unsigned char size_tag_token;
-      assert(ident==iVARIABLE || ident==iREFERENCE);
+      assert(type->ident==iVARIABLE || type->ident==iREFERENCE);
       arg->hasdefault=TRUE;     /* argument has a default value */
       size_tag_token=(unsigned char)(matchtoken(tSIZEOF) ? uSIZEOF : 0);
       if (size_tag_token==0)
@@ -5475,8 +5654,8 @@ static void doarg(char *name,int ident,int offset,int tags[],int numtags,
         size_tag_token=(unsigned char)(matchtoken(tCELLSOF) ? uCOUNTOF : 0);
       if (size_tag_token!=0) {
         int paranthese;
-        if (ident==iREFERENCE)
-          error(66,name);       /* argument may not be a reference */
+        if (type->ident==iREFERENCE)
+          error(66, decl->name); /* argument may not be a reference */
         paranthese=0;
         while (matchtoken('('))
           paranthese++;
@@ -5494,41 +5673,41 @@ static void doarg(char *name,int ident,int offset,int tags[],int numtags,
               needtoken(']');
             } /* while */
           } /* if */
-          if (ident==iVARIABLE) /* make sure we set this only if not a reference */
+          if (type->ident==iVARIABLE) /* make sure we set this only if not a reference */
             arg->hasdefault |= size_tag_token;  /* uSIZEOF or uTAGOF */
         } /* if */
         while (paranthese--)
           needtoken(')');
       } else {
         constexpr(&arg->defvalue.val,&arg->defvalue_tag,NULL);
-        assert(numtags>0);
-        matchtag(tags[0],arg->defvalue_tag,TRUE);
+        assert(type->numtags > 0);
+        matchtag(type->tags[0], arg->defvalue_tag, TRUE);
       } /* if */
     } /* if */
   } /* if */
-  arg->ident=(char)ident;
-  arg->usage=(char)(fconst ? uCONST : 0);
-  arg->numtags=numtags;
-  arg->tags=(int*)malloc(numtags*sizeof tags[0]);
+  arg->ident=(char)type->ident;
+  arg->usage=type->usage;
+  arg->numtags=type->numtags;
+  arg->tags=(int*)malloc(type->numtags * sizeof(type->tags[0]));
   if (arg->tags==NULL)
     error(163);                 /* insufficient memory */
-  memcpy(arg->tags,tags,numtags*sizeof tags[0]);
-  argsym=findloc(name);
+  memcpy(arg->tags, type->tags, type->numtags * sizeof(type->tags[0]));
+  argsym=findloc(decl->name);
   if (argsym!=NULL) {
-    error(21,name);             /* symbol already defined */
+    error(21, decl->name);      /* symbol already defined */
   } else {
-    if (chkshadow && (argsym=findglb(name,sSTATEVAR))!=NULL && argsym->ident!=iFUNCTN)
-      error(219,name);          /* variable shadows another symbol */
+    if (chkshadow && (argsym=findglb(decl->name,sSTATEVAR))!=NULL && argsym->ident!=iFUNCTN)
+      error(219, decl->name);   /* variable shadows another symbol */
     /* add details of type and address */
-    assert(numtags>0);
-    argsym=addvariable2(name,offset,ident,sLOCAL,tags[0],
+    assert(type->numtags > 0);
+    argsym=addvariable2(decl->name,offset,type->ident,sLOCAL,type->tags[0],
                        arg->dim,arg->numdim,arg->idxtag,slength);
     argsym->compound=0;
-    if (ident==iREFERENCE)
+    if (type->ident==iREFERENCE)
       argsym->usage|=uREAD;     /* because references are passed back */
     if (fpublic)
       argsym->usage|=uREAD;     /* arguments of public functions are always "used" */
-    if (fconst)
+    if (type->usage & uCONST)
       argsym->usage|=uCONST;
   } /* if */
 }
@@ -6375,7 +6554,7 @@ SC_FUNC symbol *add_constant(char *name,cell val,int vclass,int tag)
        */
       if (!redef)
         goto redef_enumfield;
-    } else if (sym->tag!=tag) {
+    } else if (!compare_tag(sym->tag, tag)) {
       redef=1;                  /* redefinition of a constant (non-enum) to a different tag is not allowed */
     } /* if */
     if (redef) {
@@ -6753,9 +6932,10 @@ static int test(int label,int parens,int invert)
     } /* if */
     return testtype;
   } /* if */
-  if (tag!=0 && tag!=pc_addtag("bool"))
+  if (tag!=0 && tag!=pc_tag_bool) {
     if (check_userop(lneg,tag,0,1,NULL,&tag))
       invert= !invert;          /* user-defined ! operator inverted result */
+  }
   if (invert)
     jmp_ne0(label);             /* jump to label if true (different from 0) */
   else
diff --git a/sourcepawn/compiler/sc2.c b/sourcepawn/compiler/sc2.c
index e06af8cb..25d17e7d 100644
--- a/sourcepawn/compiler/sc2.c
+++ b/sourcepawn/compiler/sc2.c
@@ -1151,6 +1151,10 @@ static int command(void)
           cell val;
           preproc_expr(&val,NULL);
           sc_needsemicolon=(int)val;
+        } else if (strcmp(str, "require_newdecls")==0) {
+          cell val;
+          preproc_expr(&val,NULL);
+          sc_require_newdecls = (int)val;
         } else if (strcmp(str,"tabsize")==0) {
           cell val;
           preproc_expr(&val,NULL);
@@ -2264,6 +2268,16 @@ SC_FUNC void lexclr(int clreol)
   } /* if */
 }
 
+// Return true if the symbol is ahead, false otherwise.
+SC_FUNC int lexpeek(int id)
+{
+  if (matchtoken(id)) {
+    lexpush();
+    return TRUE;
+  }
+  return FALSE;
+}
+
 /*  matchtoken
  *
  *  This routine is useful if only a simple check is needed. If the token
@@ -3119,6 +3133,15 @@ SC_FUNC int expecttoken(int id, token_t *tok)
   return FALSE;
 }
 
+SC_FUNC int matchtoken2(int id, token_t *tok)
+{
+  if (matchtoken(id)) {
+    tok->id = tokeninfo(&tok->val, &tok->str);
+    return TRUE;
+  }
+  return FALSE;
+}
+
 SC_FUNC int matchsymbol(token_ident_t *ident)
 {
   if (lextok(&ident->tok) != tSYMBOL) {
diff --git a/sourcepawn/compiler/sc3.c b/sourcepawn/compiler/sc3.c
index 39907863..152ef3ef 100644
--- a/sourcepawn/compiler/sc3.c
+++ b/sourcepawn/compiler/sc3.c
@@ -314,6 +314,24 @@ SC_FUNC int checktag_string(value *sym1, value *sym2)
   return FALSE;
 }
 
+SC_FUNC const char *type_to_name(int tag)
+{
+  if (tag == 0)
+    return "int";
+  if (tag == sc_rationaltag)
+    return "float";
+  if (tag == pc_tag_string)
+    return "char";
+
+  const char *name = pc_tagname(tag);
+  if (name)
+    return NULL;
+
+  if (tag & FUNCTAG)
+    return "function";
+  return "unknown";
+}
+
 SC_FUNC int matchtag_string(int ident, int tag)
 {
   if (ident == iARRAY || ident == iREFARRAY)
diff --git a/sourcepawn/compiler/sc5.scp b/sourcepawn/compiler/sc5.scp
index 08769f9e..ab2cf3ae 100644
--- a/sourcepawn/compiler/sc5.scp
+++ b/sourcepawn/compiler/sc5.scp
@@ -31,14 +31,14 @@ SC_FUNC int strexpand(char *dest, unsigned char *source, int maxlen, unsigned ch
 #define SCPACK_TABLE errstr_table
 /*-*SCPACK start of pair table, do not change or remove this line */
 unsigned char errstr_table
[][2] = {
-  {101,32}, {116,32}, {111,110}, {115,32}, {105,110}, {100,32}, {97,114}, {116,105}, {37,115}, {101,114}, {110,111}, {101,110}, {97,108}, {97,110}, {135,130}, {34,136},
-  {143,34}, {111,114}, {114,101}, {117,110}, {121,32}, {138,129}, {97,116}, {115,116}, {115,105}, {100,101}, {101,133}, {32,144}, {117,109}, {41,10}, {116,104}, {117,115},
-  {145,32}, {147,99}, {98,108}, {142,32}, {102,161}, {97,32}, {98,111}, {101,120}, {118,140}, {114,97}, {115,121}, {109,166}, {170,171}, {172,108}, {103,32}, {156,139},
-  {99,141}, {137,32}, {103,175}, {134,178}, {116,111}, {105,131}, {115,10}, {176,149}, {115,152}, {134,169}, {99,104}, {105,133}, {102,132}, {97,162}, {116,121}, {101,131},
-  {159,129}, {164,163}, {168,187}, {109,192}, {104,97}, {101,100}, {111,102}, {99,116}, {132,194}, {109,97}, {109,101}, {190,112}, {37,131}, {173,155}, {44,32}, {116,97},
-  {99,111}, {167,112}, {98,128}, {99,130}, {118,134}, {198,32}, {105,189}, {212,214}, {117,108}, {109,139}, {185,148}, {153,188}, {134,97}, {118,128}, {179,129}, {101,10},
-  {130,32}, {102,105}, {111,112}, {97,115}, {136,10}, {155,10}, {151,150}, {109,150}, {110,32}, {226,137}, {128,144}, {205,157}, {34,32}, {100,105}, {119,105}, {40,235},
-  {99,108}, {211,151}, {140,32}, {141,32}, {196,221}, {101,108}, {152,122}, {108,128}, {164,142}, {132,32}, {132,174}, {207,174}, {231,186}, {158,128}, {97,131}
+  {101,32}, {116,32}, {111,110}, {115,32}, {100,32}, {105,110}, {97,114}, {116,105}, {37,115}, {101,114}, {110,111}, {97,110}, {101,110}, {97,108}, {135,130}, {34,136},
+  {143,34}, {114,101}, {111,114}, {117,110}, {121,32}, {138,129}, {97,116}, {115,105}, {115,116}, {101,132}, {100,101}, {109,140}, {32,144}, {41,10}, {109,98}, {116,104},
+  {114,97}, {117,115}, {146,32}, {147,99}, {142,32}, {98,108}, {102,163}, {111,108}, {101,120}, {118,141}, {97,32}, {115,121}, {171,158}, {172,167}, {99,139}, {103,32},
+  {134,160}, {116,121}, {115,10}, {174,149}, {112,101}, {103,117}, {181,155}, {137,32}, {134,182}, {116,111}, {102,133}, {115,151}, {99,104}, {105,132}, {97,165}, {105,131},
+  {161,129}, {166,164}, {169,189}, {109,192}, {104,97}, {109,101}, {111,102}, {99,116}, {133,194}, {109,97}, {101,100}, {99,130}, {37,131}, {176,148}, {173,156}, {44,32},
+  {117,108}, {99,111}, {98,128}, {118,134}, {112,145}, {198,32}, {105,190}, {211,214}, {116,97}, {101,131}, {130,32}, {154,186}, {134,97}, {102,105}, {118,128}, {184,129},
+  {110,32}, {111,112}, {97,115}, {136,10}, {156,10}, {128,144}, {152,150}, {109,150}, {100,105}, {119,105}, {225,137}, {101,10}, {206,157}, {34,32}, {40,236}, {99,108},
+  {97,131}, {203,152}, {139,32}, {141,32}, {196,222}, {101,108}, {177,112}, {151,122}, {108,128}, {166,142}, {133,32}, {159,32}, {216,175}, {133,175}, {231,188}
 };
 /*-*SCPACK end of pair table, do not change or remove this line */
 
@@ -164,7 +164,7 @@ static char *errmsg[] = {
 /*118*/  "destructors must be native functions\n",
 /*119*/  "destructors cannot have extra arguments\n",
 /*120*/  "methodmap and class signatures must use new-style type declarations\n",
-/*121*/  "this syntax is not yet supported\n",
+/*121*/  "cannot specify array dimensions on both type and name\n",
 /*122*/  "expected type expression\n",
 /*123*/  "fully-qualified name \"%s\" is too long, would be truncated to \"%s\"\n",
 /*124*/  "unexpected token, expected method or property\n",
@@ -179,142 +179,151 @@ static char *errmsg[] = {
 /*133*/  "cannot coerce unrelated object types %s and %s\n",
 /*134*/  "type mismatch (%s and %s)\n",
 /*135*/  "cannot use an object in a multi-tag selector\n",
+/*136*/  "arrays are not supported as return types\n",
+/*137*/  "cannot mix reference and array types\n",
+/*138*/  "const was specified twice\n",
+/*139*/  "could not find type \"%s\"\n",
+/*140*/  "new-style array types cannot specify dimension sizes as part of their type\n",
 #else
-  "\321e\307\232\264k\213:\233\316bu\201fo\223\205\220\012",
-  "\202l\224\245s\204g\367\346e\331\201(\240\321\222\270\202) \260 follow ea\272 \042c\343e\042\012",
-  "\231\360\334\243\325\245loc\362\327\200\303appe\206 \371\245\320mpo\223\205\242ock\012",
-  "\370\233 \265\225imple\331t\305\012",
-  "\301\311\224\225\364\263t\266",
-  "\303\322a\270gn\232\264 \363\271y\012",
-  "\351\226\240\267\322\222\333\305\012",
-  "\303\322\245\361\215\201\321\222\270\202; \343s\234\232z\211o\012",
-  "\310\332\366\200(nega\207ve\316z\211o \240ou\201\325\246\223ds\235",
-  "\310\301\240\231\360\334\216\012",
-  "\310out\230d\200\370\266",
-  "\310\301c\214l\316\225\245\302add\222s\266",
-  "\212 \213tr\224po\204\201(\212 pu\242ic \370s\235",
-  "\310\346e\331t; \225\371s\356t\272\012",
-  "\042\231fa\330t\354c\343\200\303\322\375l\343\201c\343\200\371s\356t\272 \346e\331t\012",
-  "m\330\207p\367\231fa\330t\203\371\042s\356t\272\042\012",
-  "\223\333\232\315\012",
-  "\204i\207\214iza\243d\226\245\247ce\305\203\231\360\206\232\366\337",
-  "\225\245lab\365:\345",
-  "\310\255 nam\352\012",
-  "\255 \214\222ad\224\333\305:\345",
-  "\303\322l\250u\200(n\202-\361\215t\235",
-  "\332a\270gn\331\201\303\322\230mp\367a\270gn\331t\012",
-  "\042b\222ak\354\240\042\323t\204ue\354\265ou\201\325\323t\247t\012",
-  "\301head\372\355ff\211\203from pro\264\313\337",
-  "\212 \374\372\042#if...\042\012",
-  "\310\272\334\307\261\361\215t\012",
-  "\310subscrip\201(\225\363\332\240\264o m\215\224subscripts):\345",
-  "\310\321\222\270\202\316\343s\234\232z\211o\012",
-  "\320mpo\223\205\346e\331\201\225\360os\232a\201\375\213\205\325\341\367(\227\206t\232a\201l\204\200%d\235",
-  "\223k\212w\350\355\222c\207v\337",
-  "\332\204\231x ou\201\325\246\223d\203(\327\352\235",
-  "\332\303\322\204\231x\232(\327\352\235",
-  "\336do\277\225\364\245\231fa\330\201\250u\200(\336%d\235",
-  "\336\313\200mis\374 (\336%d\235",
-  "empt\224\346e\331t\012",
-  "\310\227r\372(po\270\242\224n\202-t\211m\204\226\232\227r\204g\235",
-  "\247tr\245\272\334\307\211\203\340l\204\337",
-  "\361\215\201\255 \304\203\212 \366\337",
-  "duplic\226\200\042c\343e\354lab\365 (\250u\200%d\235",
-  "\310\365lip\230s\316\332\366\200\265\225k\212wn\012",
-  "\310\320mb\204a\243\325\360\343\203speci\341\211\266",
-  "\272\334\307\261\361\215\201\247ce\305\203r\215g\200f\240pack\232\227r\204g\012",
-  "po\230\216\362p\334\312t\211\203\303p\222c\305\200\214l nam\232p\334\312t\211\266",
-  "\264o m\215\224\301\263t\266",
-  "\223k\212w\350\332\366\200(\327\352\235",
-  "\332\366\277do \225\374\316\240\231\227\204a\243\332\265\264o sm\214l\012",
-  "\332(\203do \225\374\012",
-  "\310l\204\200\323t\204ua\216\012",
-  "\310r\215g\337",
-  "\310subscript\316\237\200\042[ ]\354\351\226\221\203\340\311j\240\355\331\230\202\266",
-  "m\330\207-\355\331\230\202\362\271y\203\303\322f\330l\224\204i\207\214iz\305\012",
-  "\247ce\305\372\311xim\234 n\234b\261\325\355\331\230\202\266",
-  "\223\374\232\360os\372b\251c\200(\042}\042\235",
-  "\227\206\201\325\301\246d\224\356\236ou\201\301head\211\012",
-  "\271ys\316loc\362\327\277\215\205\301\263t\203\267\322pu\242ic (\327\352\235",
-  "\223\274ish\232\321\222\270\340bef\221\200\320mpil\261\355\222c\207v\337",
-  "duplic\226\200\263t; sam\200\336\265p\343s\232t\356c\337",
-  "\301\336\311\224\225\364\245\231fa\330\201\250u\200(\327\352\235",
-  "m\330\207p\367\042#\365se\354\355\222c\207v\277betwe\213 \042#if ... #\213\355f\042\012",
-  "\042#\365seif\354\355\222c\207\335follow\203\363\042#\365se\354\355\222c\207v\337",
-  "n\234b\261\325\351\215d\203do\277\225\341\201\375\351\226\221\012",
-  "\301\222s\330\201\373\325\351\226\221\233 \303\322\220\012",
-  "\267\272\215g\200p\222\333\232\351\226\221\266",
-  "\301\336\311\224\202l\224\364\245s\204g\367\373(\336%d\235",
-  "\301\336\311\224\225\322\245\222f\211\213c\200\336\240\363\332(\336\220\235",
-  "\327\200\267\322\246\236 \245\222f\211\213c\200\215\205\363\332(\327\352\235",
-  "\310\251\216\362n\234b\261p\222ci\230\340\371#p\251g\311\012",
-  "\251\216\362n\234b\261f\221\311\201\214\222ad\224\333\305\012",
-  "\251\216\362n\234b\261supp\221\201w\376\225\213\275\305\012",
-  "\237\211-\333\232\351\226\240\303\322\231\360\206\232bef\221\200\237\200(\370\233\235",
-  "\042\366e\306\354\351\226\240\265\310\340\042\370\354\255\266",
-  "\301\336\303\322\363\332(\336\220\235",
-  "#\333\200p\226t\211\350\303\227\206\201\356\236 \363\214p\304be\207c \272\334\307\211\012",
-  "\204pu\201l\204\200\264o l\202\256(aft\261subs\207tu\216s\235",
-  "\252n\317x \211r\240\371\375\321\222\270\202\316\240\310\301c\214l\012",
-  "m\214f\221m\232UTF-8 \213\320d\204g\316\240c\221rupt\232\341le: \344",
-  "\301\237\277\246\236 \042\222turn\354\215\205\042\222tur\350<\250ue>\042\012",
-  "\204\323\230\227\213\201\222tur\350\313\277(\332& n\202-\271y\235",
-  "\223k\212w\350\255\316\240\225\245\361\215\201\255 \357",
-  "\267\317k\200\245\373\376\245\231fa\330\201\250u\200f\240\363\204\231x\232\332p\334\312t\261\357",
-  "\237\211-\333\232\351\226\221\203\215\205na\207\335\370\203\311\224\225\364\346e\266",
-  "\245\301\240\327\200\311\224\202l\224b\365\202\256\264 \245s\204g\367au\264\347\340\357",
-  "\346\200\323fli\307: \202\200\325\375\346\277\265\214\222ad\224a\270gn\232\264 a\212\236\261imple\331\317\243\357",
-  "\212 \346\277\206\200\333\232f\240\315\012",
-  "\223k\212w\350au\264\347\202\345",
-  "\223k\212w\350\346\352 f\240au\264\347\202\345",
-  "pu\242ic \327\277\215\205loc\362\327\277\311\224\225\364\346\277\357",
-  "\346\200\327\277\311\224\225\322\204i\207\214iz\232\357",
-  "pu\242ic \370\203\311\224\225\222tur\350\271y\203\357",
-  "ambiguou\203\361\215t; \373ov\211rid\200\265\222qui\222\205\357",
-  "n\234b\261\325\263t\203do\277\225\374 \333i\216\012",
-  "\321e\307\232\373nam\200id\213\207\341\211\012",
-  "\301\213\234\211a\243\222qui\222\203\223iqu\200\317g\012",
-  "\267\364\222qui\222\205p\334\312t\211\203aft\261\342\216\362p\334\312t\211\266",
-  "\320\330\205\225\274\205\312mb\211\233 \371\227ruc\201\220\012",
-  "\315 do\277\225\364\245\374\372\313\337",
-  "\313\352 sho\330\205\322\220 \371new-\227y\367\231\360\334\216\266",
-  "\314sho\330\205\225\364\363\321lici\201\222tur\350\313\337",
-  "\301pro\264\313\277do \225\374\012",
-  "specif\224ei\236\261\214l \355\331\230\202\203\240\202l\224\375l\343\201\355\331\230\202\012",
-  "\267\274\205\314\344",
-  "\314w\376\214\222ad\224\333\232\340\236\265\344",
-  "\267\274\205\215\224\312\236od\203f\240\344",
-  "\267\274\205\312\236o\205\240pr\351t\224\210.\344",
-  "\267c\214l \312\236od\203\340\363\271y\012",
-  "\267c\214l \312\236od\203\340\245\370\012",
-  "\312\236o\205\303\364\245\341rs\201\336\320mpa\207\242\200\356\236 \375\314\313\200(\210\235",
-  "\314nam\200\303\227\206\201\356\236 \363upp\211c\343\200lett\211\012",
-  "\314\304\203\214\222ad\224be\213 \333\232(p\222vio\237l\224se\213 \376\210\235",
-  "\321e\307\232id\213\207\341\261- d\273you f\221ge\201\245\313e?\012",
-  "\361ru\307\240\301\303\222tur\350\373\344",
-  "\267\333\200\361ru\307\240f\221\233; \214\222ad\224\247i\227\203\376\245\344",
-  "miss\372\313e\316\240\314\303\364\375sam\200nam\200\376\314\220\012",
-  "\267\237\200\231lete\316\314\314\304\203\212 \231\227ru\307\221\012",
-  "\212 \312\236od\311p \240\360\343\203w\376fo\223\205f\240\344",
-  "\212 \231\227ru\307\240w\376fo\223\205f\240\314\344",
-  "\231\227ru\307\221\203\303\322na\207\335\370\266",
-  "\231\227ru\307\221\203\267\364\247tr\245\263t\266",
-  "\312\236od\311p \215\205\360\343\203\230gn\226u\222\203\303\237\200new-\227y\367\313\200\231\360\334\216\266",
-  "\236\265\252n\317x \265\225ye\201supp\221t\305\012",
-  "\321e\307\232\313\200\321\222\270\202\012",
-  "f\330ly-qu\214i\341\232nam\352 \265\264o l\202g\316wo\330\205\322tr\241\226\232\264\345",
-  "\223\321e\307\232\264k\213\316\321e\307\232\312\236o\205\240pr\351\276\012",
-  "\321e\307\232\042na\207ve\354\240\042get\042\012",
-  "\314f\240\314\214\222ad\224\247i\227\266",
-  "pr\351t\224gett\211\203\267accep\201\247tr\245\263t\266",
-  "\314\303\364\375sam\200\222tur\350\313\200\376pr\351t\224\314(\210\235",
-  "\267mix \312\236od\311p\203\215\205\360\343s\277\356\236 \204h\211it\215c\337",
-  "\267\320\211c\200\370\203\264 \250ue\266",
-  "\267\320\211c\200objec\201\313\200\314\264 n\202-objec\201\313\200\344",
-  "\267\320\211c\200n\202-objec\201\313\200\314\264 objec\201\313\200\344",
-  "\267\320\211c\200\223\222l\226\232objec\201\313\277\314\215\205\344",
-  "\313\200mis\374 (\314\215\205\210\235",
-  "\267\237\200\363objec\201\371\245m\330\207-\373s\365e\307\221\012"
+  "\250\264\307\231\271k\214:\234\317bu\201fo\223\204\220\012",
+  "\202l\224\252s\205g\370\346e\233\201(\242\250\324\273\202) \256 f\247low ea\274 \042c\342e\042\012",
+  "\232\357\334\244\325\252loc\363\327\200\303ap\264\206 \372\252\321mpo\223\204\245ock\012",
+  "\371\234 \277\225imple\233t\312\012",
+  "\301\311\224\225\364\270t\262",
+  "\303\322a\273gn\231\271 \362\260y\012",
+  "\352\226\242\263\322\221\333\312\012",
+  "\303\322\252\361\213\201\250\324\273\202; \342sum\231z\211o\012",
+  "\310\315\367\200(nega\207ve\317z\211o \242ou\201\325bo\223ds\235",
+  "\310\301\242\232\357\334\216\012",
+  "\310out\227d\200\371\262",
+  "\310\301c\215l\317\225\252\302add\221s\262",
+  "\212 \214tr\224po\205\201(\212 pu\245ic \371s\235",
+  "\310\346e\233t; \225\372s\351t\274\012",
+  "\042\232fa\320t\355c\342\200\303\322\237\200l\342\201c\342\200\372s\351t\274 \346e\233t\012",
+  "m\320\207p\370\232fa\320t\203\372\042s\351t\274\042\012",
+  "\223\333\231\316\012",
+  "\205i\207\215iza\244d\226\252\250ce\312\203\232\357\206\231\367\353",
+  "\225\252lab\365:\344",
+  "\310\255 nam\345\012",
+  "\255 \215\221ad\224\333\312:\344",
+  "\303\322l\251u\200(n\202-\361\213t\235",
+  "\315a\273gn\233\201\303\322\227mp\370a\273gn\233t\012",
+  "\042b\221ak\355\242\042\313t\205ue\355\277ou\201\325\313t\250t\012",
+  "\301head\375\350ff\211\203from pro\271\261\264\012",
+  "\212 \376\375\042#if...\042\012",
+  "\310\274\334\307\267\361\213t\012",
+  "\310subscrip\201(\225\362\315\242\271o m\213\224subscripts):\344",
+  "\310\250\324\273\202\317\342sum\231z\211o\012",
+  "\321mpo\223\204\346e\233\201\225\357os\231a\201\237\200\214\204\325\335\370(\230\206t\231a\201l\205\200%d\235",
+  "\223k\212w\340\350\221c\207v\353",
+  "\315\205\232x ou\201\325bo\223d\203(\327\345\235",
+  "\315\303\322\205\232x\231(\327\345\235",
+  "\337do\331\225\364\252\232fa\320\201\251u\200(\337%d\235",
+  "\337\366\200mis\376 (\337%d\235",
+  "empt\224\346e\233t\012",
+  "\310\230r\375(po\273\245\224n\202-t\211m\205\226\231\230r\205g\235",
+  "\250t\240 \274\334\307\211\203\332l\205\353",
+  "\361\213\201\255 \304\203\212 \367\353",
+  "duplic\226\200\042c\342e\355lab\365 (\251u\200%d\235",
+  "\310\365lip\227s\317\315\367\200\277\225k\212wn\012",
+  "\310\321\236\205a\244\325\357\342\203s\264ci\335\211\262",
+  "\274\334\307\267\361\213\201\250ce\312\203r\213g\200f\242pack\231\230r\205g\012",
+  "po\227\216\363p\334\305t\211\203\303\324c\312\200\215l nam\231p\334\305t\211\262",
+  "\271o m\213\224\301\270t\262",
+  "\223k\212w\340\315\367\200(\327\345\235",
+  "\315\367\331do \225\376\317\242\232\230\205a\244\315\277\271o sm\215l\012",
+  "\315(\203do \225\376\012",
+  "\310l\205\200\313t\205ua\216\012",
+  "\310r\213g\353",
+  "\310subscript\317\241\200\042[ ]\355\352\226\222\203\332\311j\242\350\233\227\202\262",
+  "m\320\207-\350\233\227\202\363\260y\203\303\322f\320l\224\205i\207\215iz\312\012",
+  "\250ce\312\375\311ximum nu\236\267\325\350\233\227\202\262",
+  "\223\376\231\357os\375b\240c\200(\042}\042\235",
+  "\230\206\201\325\301bod\224\351\237ou\201\301head\211\012",
+  "\260ys\317loc\363\327\331\213\204\301\270t\203\263\322pu\245ic (\327\345\235",
+  "\223\272ish\231\250\324\273\332bef\222\200\321mpil\267\350\221c\207v\353",
+  "duplic\226\200\270t; sam\200\337\277p\342s\231t\351c\353",
+  "\301\337\311\224\225\364\252\232fa\320\201\251u\200(\327\345\235",
+  "m\320\207p\370\042#\365se\355\350\221c\207v\331betwe\214 \042#if ... #\214\350f\042\012",
+  "\042#\365seif\355\350\221c\207\336f\247low\203\362\042#\365se\355\350\221c\207v\353",
+  "nu\236\267\325\352\213d\203do\331\225\335\201\237\200\352\226\222\012",
+  "\301\221s\320\201\374\325\352\226\222\234 \303\322\220\012",
+  "\263\274\213g\200\324\333\231\352\226\222\262",
+  "\301\337\311\224\202l\224\364\252s\205g\370\374(\337%d\235",
+  "\301\337\311\224\225\322\252\221f\211\214c\200\337\242\362\315(\337\220\235",
+  "\327\200\263\322bo\373\252\221f\211\214c\200\213\204\362\315(\327\345\235",
+  "\310\240\216\363nu\236\267\324ci\227\332\372#p\240g\311\012",
+  "\240\216\363nu\236\267f\222\311\201\215\221ad\224\333\312\012",
+  "\240\216\363nu\236\267supp\222\201w\360\225\214\276\312\012",
+  "\241\211-\333\231\352\226\242\303\322\232\357\206\231bef\222\200\241\200(\371\234\235",
+  "\042\367e\306\355\352\226\242\277\310\332\042\371\355\255\262",
+  "\301\337\303\322\362\315(\337\220\235",
+  "#\333\200p\226t\211\340\303\230\206\201\351\373\362\215p\304be\207c \274\334\307\211\012",
+  "\205pu\201l\205\200\271o l\202\257(aft\267subs\207tu\216s\235",
+  "\253n\330x \211r\242\372\237\200\250\324\273\202\317\242\310\301c\215l\012",
+  "m\215f\222m\231UTF-8 \214\321d\205g\317\242c\222rupt\231\335le: \343",
+  "\301\241\331bo\373\042\221turn\355\213\204\042\221tur\340<\251ue>\042\012",
+  "\205\313\227\230\214\201\221tur\340\261\264\203(\315& n\202-\260y\235",
+  "\223k\212w\340\255\317\242\225\252\361\213\201\255 \356",
+  "\263\330k\200\252\374\360\252\232fa\320\201\251u\200f\242\362\205\232x\231\315p\334\305t\267\356",
+  "\241\211-\333\231\352\226\222\203\213\204na\207\336\371\203\311\224\225\364\346e\262",
+  "\252\301\242\327\200\311\224\202l\224b\365\202\257\271 \252s\205g\370au\271\347\332\356",
+  "\346\200\313fli\307: \202\200\325\237\200\346\331\277\215\221ad\224a\273gn\231\271 a\212\237\267imple\233\330\244\356",
+  "\212 \346\331\206\200\333\231f\242\316\012",
+  "\223k\212w\340au\271\347\202\344",
+  "\223k\212w\340\346\345 f\242au\271\347\202\344",
+  "pu\245ic \327\331\213\204loc\363\327\331\311\224\225\364\346\331\356",
+  "\346\200\327\331\311\224\225\322\205i\207\215iz\231\356",
+  "pu\245ic \371\203\311\224\225\221tur\340\260y\203\356",
+  "a\236i\265ou\203\361\213t; \374ov\211rid\200\277\221qui\221\204\356",
+  "nu\236\267\325\270t\203do\331\225\376 \333i\216\012",
+  "\250\264\307\231\374nam\200id\214\207\335\211\012",
+  "\301\214um\211a\244\221qui\221\203\223iqu\200\330g\012",
+  "\263\364\221qui\221\204p\334\305t\211\203aft\267\341\216\363p\334\305t\211\262",
+  "\321\320\204\225\272\204\305\236\211\234 \372\230ruc\201\220\012",
+  "\316 do\331\225\364\252\376\375\261\264\012",
+  "\366\345 sho\320\204\322\220 \372new-\230y\370\232\357\334\216\262",
+  "\314sho\320\204\225\364\362\250plici\201\221tur\340\261\264\012",
+  "\301pro\271\261\264\203do \225\376\012",
+  "s\264cif\224ei\237\267\215l \350\233\227\202\203\242\202l\224\237\200l\342\201\350\233\227\202\012",
+  "\263\272\204\314\343",
+  "\314w\360\215\221ad\224\333\231\332\237\277\343",
+  "\263\272\204\213\224\305\237od\203f\242\343",
+  "\263\272\204\305\237o\204\242pr\352t\224\210.\343",
+  "\263c\215l \305\237od\203\332\362\260y\012",
+  "\263c\215l \305\237od\203\332\252\371\012",
+  "\305\237o\204\303\364\252\335rs\201\337\321mpa\207\245\200\351\373\237\200\314\366\200(\210\235",
+  "\314nam\200\303\230\206\201\351\373\362upp\211c\342\200lett\211\012",
+  "\314\304\203\215\221ad\224be\214 \333\231(\324vio\241l\224se\214 \360\210\235",
+  "\250\264\307\231id\214\207\335\267- d\275you f\222ge\201\252\261\264?\012",
+  "\361ru\307\242\301\303\221tur\340\374\343",
+  "\263\333\200\361ru\307\242f\222\234; \215\221ad\224\250i\230\203\360\252\343",
+  "miss\375\261\264\317\242\314\303\364\237\200sam\200nam\200\360\314\220\012",
+  "\263\241\200\232lete\317\314\314\304\203\212 \232\230ru\307\222\012",
+  "\212 \305\237od\311p \242\357\342\203w\360fo\223\204f\242\343",
+  "\212 \232\230ru\307\242w\360fo\223\204f\242\314\343",
+  "\232\230ru\307\222\203\303\322na\207\336\371\262",
+  "\232\230ru\307\222\203\263\364\250t\240 \270t\262",
+  "\305\237od\311p \213\204\357\342\203\227gn\226u\221\203\303\241\200new-\230y\370\366\200\232\357\334\216\262",
+  "\263s\264cif\224\315\350\233\227\202\203\332bo\373\366\200\213\204na\305\012",
+  "\250\264\307\231\366\200\250\324\273\202\012",
+  "f\320ly-qu\215i\335\231nam\345 \277\271o l\202g\317wo\320\204\322tr\243\226\231\271\344",
+  "\223\250\264\307\231\271k\214\317\250\264\307\231\305\237o\204\242pr\352\261\012",
+  "\250\264\307\231\042na\207ve\355\242\042get\042\012",
+  "\314f\242\314\215\221ad\224\250i\230\262",
+  "pr\352t\224gett\211\203\263accep\201\250t\240 \270t\262",
+  "\314\303\364\237\200sam\200\221tur\340\366\200\360pr\352t\224\314(\210\235",
+  "\263mix \305\237od\311p\203\213\204\357\342s\331\351\373\205h\211it\213c\353",
+  "\263\321\211c\200\371\203\271 \251ue\262",
+  "\263\321\211c\200objec\201\366\200\314\271 n\202-objec\201\366\200\343",
+  "\263\321\211c\200n\202-objec\201\366\200\314\271 objec\201\366\200\343",
+  "\263\321\211c\200\223\221l\226\231objec\201\261\264\203\314\213\204\343",
+  "\366\200mis\376 (\314\213\204\210\235",
+  "\263\241\200\362objec\201\372\252m\320\207-\374s\365e\307\222\012",
+  "\260y\203\206\200\225supp\222t\231\360\221tur\340\261\264\262",
+  "\263mix \221f\211\214c\200\213\204\315\261\264\262",
+  "\313s\201w\360s\264ci\335\231t\351c\353",
+  "\321\320\204\225\272\204\366\345\012"
 #endif
        };
 
@@ -339,18 +348,18 @@ static char *fatalmsg[] = {
 /*170*/  "assertion failed: %s\n",
 /*171*/  "user error: %s\n",
 #else
-  "\267\222a\205from \341le:\345",
-  "\267writ\200\264 \341le:\345",
-  "t\275\200ov\211flow:\345",
-  "\204suf\341ci\213\201\312m\221y\012",
-  "\310\343sem\242\261\204\227ruc\216\345",
-  "n\234\211ic ov\211flow\316\247ce\305\372capaci\276\012",
-  "\320mpil\232scrip\201\247ce\305\203\375\311xim\234 \312m\221\224\366\200(%l\205bytes\235",
-  "\264o m\215\224\211r\240\312ssag\277\340\202\200l\204\337",
-  "\320\231pag\200\311pp\372\341\367\225fo\223d\012",
-  "\310p\226h:\345",
-  "\343s\211\243fail\305: \344",
-  "\237\261\211r\221: \344"
+  "\263\221a\204from \335le:\344",
+  "\263writ\200\271 \335le:\344",
+  "t\276\200ov\211flow:\344",
+  "\205suf\335ci\214\201\305m\222y\012",
+  "\310\342se\236l\267\205\230ruc\216\344",
+  "num\211ic ov\211flow\317\250ce\312\375capaci\261\012",
+  "\321mpil\231scrip\201\250ce\312\203\237\200\311ximum \305m\222\224\367\200(%l\204bytes\235",
+  "\271o m\213\224\211r\242\305ssag\331\332\202\200l\205\353",
+  "\321\232pag\200\311pp\375\335\370\225fo\223d\012",
+  "\310p\226h:\344",
+  "\342s\211\244fail\312: \343",
+  "\241\267\211r\222: \343"
 #endif
        };
 
@@ -394,43 +403,43 @@ static char *warnmsg[] = {
 /*235*/  "public function lacks forward declaration (symbol \"%s\")\n",
 /*236*/  "unknown parameter in substitution (incorrect #define pattern)\n"
 #else
-  "\315 \265tr\241\226\232\264 %\205\272\334\307\211\266",
-  "\222\333i\243\325\361\215t/\311cro \357",
-  "n\234b\261\325\263t\203do\277\225\374 \333i\216\012",
-  "\255 \265nev\261\237\305:\345",
-  "\255 \265a\270gn\232\245\250u\200\236a\201\265nev\261\237\305:\345",
-  "\222d\223d\215\201\320\231: \361\215\201\321\222\270\340\265z\211o\012",
-  "\222d\223d\215\201te\227: \361\215\201\321\222\270\340\265n\202-z\211o\012",
-  "\223k\212w\350#p\251g\311\012",
-  "\301\356\236 \373\222s\330\201\237\232bef\221\200\333i\216\316f\221c\372\222p\206s\337",
-  "\370\233 sho\330\205\222tur\350\245\250u\337",
-  "po\270\242\200\237\200\325\255 bef\221\200\204i\207\214iza\216:\345",
-  "po\270\242\224\223\204t\213\231\205a\270gn\331t\012",
-  "po\270\242\224\223\204t\213\231\205bit\356s\200\351a\216\012",
-  "\373mis\374\012",
-  "po\270\242\224\245\042\361\354\332\336w\376\204t\213\231d:\345",
-  "\321\222\270\340\304\203\212 effe\307\012",
-  "ne\227\232\320m\331t\012",
-  "loos\200\204d\213\317\216\012",
-  "ol\205\227y\367pro\264\313\277\237\232\356\236 \342\216\362semi\320l\234n\266",
-  "loc\362\327\352 s\304dow\203\245\327\200a\201\245p\222c\305\372lev\365\012",
-  "\321\222\270\340\356\236 \373ov\211rid\200\303appe\206 betwe\213 p\206\213\236ese\266",
-  "lab\365 nam\352 s\304dow\203\373na\312\012",
-  "n\234b\261\325\355git\203\247ce\305\203\251\216\362n\234b\261p\222ci\230\202\012",
-  "\222d\223d\215\201\042\366e\306\042: \336\366\200\265\214way\2031 \357",
-  "\204\231t\211m\204\226\200\332\366\200\371\042\366e\306\354\321\222\270\340\357",
-  "\223\222a\272\275\200\320\231\012",
-  "\245\327\200\265a\270gn\232\264 its\365f \357",
-  "m\221\200\204i\207\214iz\211\203\236\363\213\234 \341\365d\266",
-  "l\213g\236 \325\204i\207\214iz\261\247ce\305\203\366\200\325\375\213\234 \341\365d\012",
-  "\204\231x \373mis\374 \357",
-  "\212 imple\331\317\243f\240\346\352 \371\370\233\316\212 f\214l-back\012",
-  "\346\200speci\341ca\243\340f\221w\206\205\231\360\334\243\265ig\212\222d\012",
-  "outpu\201\341\367\265writt\213\316bu\201\356\236 \320mpac\201\213\320d\372\355s\275\305\012",
-  "\346\200\327\352 s\304dow\203\245glob\362\327\337",
-  "\315 \265m\206k\232\376\231p\222c\226\305: \344",
-  "pu\242ic \301lack\203f\221w\206\205\231\360\334\243\357",
-  "\223k\212w\350p\334\312t\261\371subs\207tu\243(\204c\221\222c\201#\333\200p\226t\211n\235"
+  "\316 \277tr\243\226\231\271 %\204\274\334\307\211\262",
+  "\221\333i\244\325\361\213t/\311cro \356",
+  "nu\236\267\325\270t\203do\331\225\376 \333i\216\012",
+  "\255 \277nev\267\241\312:\344",
+  "\255 \277a\273gn\231\252\251u\200\237a\201\277nev\267\241\312:\344",
+  "\221d\223d\213\201\321\232: \361\213\201\250\324\273\332\277z\211o\012",
+  "\221d\223d\213\201te\230: \361\213\201\250\324\273\332\277n\202-z\211o\012",
+  "\223k\212w\340#p\240g\311\012",
+  "\301\351\373\374\221s\320\201\241\231bef\222\200\333i\216\317f\222c\375\221p\206s\353",
+  "\371\234 sho\320\204\221tur\340\252\251u\353",
+  "po\273\245\200\241\200\325\255 bef\222\200\205i\207\215iza\216:\344",
+  "po\273\245\224\223\205t\214d\231a\273gn\233t\012",
+  "po\273\245\224\223\205t\214d\231bit\351s\200\352a\216\012",
+  "\374mis\376\012",
+  "po\273\245\224\252\042\361\355\315\337w\360\205t\214\232d:\344",
+  "\250\324\273\332\304\203\212 effe\307\012",
+  "ne\230\231\321m\233t\012",
+  "loos\200\205d\214\330\216\012",
+  "\247\204\230y\370pro\271\261\264\203\241\231\351\373\341\216\363semic\247umn\262",
+  "loc\363\327\345 s\304dow\203\252\327\200a\201\252\324c\312\375lev\365\012",
+  "\250\324\273\332\351\373\374ov\211rid\200\303ap\264\206 betwe\214 p\206\214\237ese\262",
+  "lab\365 nam\345 s\304dow\203\374na\305\012",
+  "nu\236\267\325\350git\203\250ce\312\203\240\216\363nu\236\267\324ci\227\202\012",
+  "\221d\223d\213\201\042\367e\306\042: \337\367\200\277\215way\2031 \356",
+  "\205\232t\211m\205\226\200\315\367\200\372\042\367e\306\355\250\324\273\332\356",
+  "\223\221a\274\276\200\321\232\012",
+  "\252\327\200\277a\273gn\231\271 its\365f \356",
+  "m\222\200\205i\207\215iz\211\203\237\362\214um \335\365d\262",
+  "l\214g\373\325\205i\207\215iz\267\250ce\312\203\367\200\325\237\200\214um \335\365d\012",
+  "\205\232x \374mis\376 \356",
+  "\212 imple\233\330\244f\242\346\345 \372\371\234\317\212 f\215l-back\012",
+  "\346\200s\264ci\335ca\244\332f\222w\206\204\232\357\334\244\277ig\212\221d\012",
+  "outpu\201\335\370\277writt\214\317bu\201\351\373\321mpac\201\214\321d\375\350s\276\312\012",
+  "\346\200\327\345 s\304dow\203\252glob\363\327\353",
+  "\316 \277m\206k\231\360\232\324c\226\312: \343",
+  "pu\245ic \301lack\203f\222w\206\204\232\357\334\244\356",
+  "\223k\212w\340p\334\305t\267\372subs\207tu\244(\205c\222\221c\201#\333\200p\226t\211n\235"
 #endif
        };
 
diff --git a/sourcepawn/compiler/scvars.c b/sourcepawn/compiler/scvars.c
index 7eed33e1..c9a440be 100644
--- a/sourcepawn/compiler/scvars.c
+++ b/sourcepawn/compiler/scvars.c
@@ -92,6 +92,7 @@ SC_VDEFINE int sc_curstates=0;     /* ID of the current state list */
 SC_VDEFINE int pc_optimize=sOPTIMIZE_NOMACRO; /* (peephole) optimization level */
 SC_VDEFINE int pc_memflags=0;      /* special flags for the stack/heap usage */
 SC_VDEFINE int sc_showincludes=0;  /* show include files */
+SC_VDEFINE int sc_require_newdecls=0; /* Require new-style declarations */
 
 SC_VDEFINE constvalue sc_automaton_tab = { NULL, "", 0, 0}; /* automaton table */
 SC_VDEFINE constvalue sc_state_tab = { NULL, "", 0, 0};   /* state table */
diff --git a/sourcepawn/compiler/tests/fail-bad-arg-decls.sp b/sourcepawn/compiler/tests/fail-bad-arg-decls.sp
new file mode 100644
index 00000000..cda0ec89
--- /dev/null
+++ b/sourcepawn/compiler/tests/fail-bad-arg-decls.sp
@@ -0,0 +1,15 @@
+stock A(int)
+{
+}
+
+stock B(int[5] N)
+{
+}
+
+stock C(int:N)
+{
+}
+
+public main()
+{
+}
diff --git a/sourcepawn/compiler/tests/fail-bad-arg-decls.txt b/sourcepawn/compiler/tests/fail-bad-arg-decls.txt
new file mode 100644
index 00000000..d92248fe
--- /dev/null
+++ b/sourcepawn/compiler/tests/fail-bad-arg-decls.txt
@@ -0,0 +1,3 @@
+(1) : error 001: expected token: "-identifier-", but found ")"
+(5) : error 140: new-style array types cannot specify dimension sizes as part of their type
+(9) : error 001: expected token: "-identifier-", but found ":"
diff --git a/sourcepawn/compiler/tests/ok-new-decl-args.sp b/sourcepawn/compiler/tests/ok-new-decl-args.sp
new file mode 100644
index 00000000..75fe92f7
--- /dev/null
+++ b/sourcepawn/compiler/tests/ok-new-decl-args.sp
@@ -0,0 +1,44 @@
+stock A(int n)
+{
+}
+
+stock B(int n[])
+{
+}
+
+stock C(int[] n)
+{
+}
+
+enum E1: {
+}
+enum E2 {
+}
+
+stock D(E1 t)
+{
+}
+
+stock E(E2 t)
+{
+}
+
+stock F(const int n[10]) {
+}
+
+stock G(int& n)
+{
+}
+
+public main()
+{
+  new x[10]
+  new t
+  A(1)
+  B(x)
+  C(x)
+  D(E1:5)
+  E(E2:5)
+  F(x)
+  G(t)
+}
diff --git a/sourcepawn/compiler/tests/runtests.py b/sourcepawn/compiler/tests/runtests.py
index 0c03b064..ac4c7c30 100644
--- a/sourcepawn/compiler/tests/runtests.py
+++ b/sourcepawn/compiler/tests/runtests.py
@@ -22,7 +22,7 @@ def run_tests(args):
             kind = 'pass'
 
         try:
-            argv = [args.spcomp, os.path.join(testdir, test + '.sp')]
+            argv = [os.path.abspath(args.spcomp), os.path.join(testdir, test + '.sp')]
             p = subprocess.Popen(argv, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
             stdout, stderr = p.communicate()
             stdout = stdout.decode('utf-8')