Sync to wine-0.9.61:
authorEric Kohl <eric.kohl@reactos.org>
Wed, 12 Nov 2008 19:26:25 +0000 (19:26 +0000)
committerEric Kohl <eric.kohl@reactos.org>
Wed, 12 Nov 2008 19:26:25 +0000 (19:26 +0000)
- Rob Shearman <rob@codeweavers.com> Sun, 20 Apr 2008
widl: Stop looping in check_remoting_args when a context_handle or wire_marshal type is found as they are in effect fundamental types.

- Rob Shearman <rob@codeweavers.com> Sun, 20 Apr 2008
widl: Check that fields in structures and unions referenced by non-local functions can be marshalled and that their attributes are consistent.

-Rob Shearman <rob@codeweavers.com> Sun, 20 Apr 2008
widl: The implicit_handle attribute is allowed with a handle explicitly specified in the function parameters. In that case, that handle is used instead of the implicit handle. Fix the check for the explicit_handle attribute being specified without a handle being specified in the function parameters, even though issuing an error is wrong. (Thanks to Marcus Meissner & Coverity for spotting that the check didn't do what it was supposed to do.)

- Rob Shearman <rob@codeweavers.com> Sun, 20 Apr 2008
widl: Automatically add "handle_t IDL_handle" parameter to functions with no explicit handle specified whose containing interface has the explicit_handle attribute.

- Rob Shearman <rob@codeweavers.com> Sun, 20 Apr 2008
widl: Issue an error instead of crashing for dividing by zero in a constant expression.

- Rob Shearman <rob@codeweavers.com> Sun, 20 Apr 2008
widl: Add support for "->" and "." operators in expressions.

- Rob Shearman <rob@codeweavers.com> Sun, 20 Apr 2008
widl: Add support for arrays in expressions.

- Rob Shearman <rob@codeweavers.com> Sun, 20 Apr 2008
widl: Add support for '%' operator in expressions.

- Rob Shearman <rob@codeweavers.com> Tue, 22 Apr 2008
widl: Fix operator precedence in expressions.

- Rob Shearman <rob@codeweavers.com> Tue, 22 Apr 2008
widl: Require a constant expression for case statements.

- Rob Shearman <rob@codeweavers.com> Tue, 22 Apr 2008
widl: Add support for comparison, exclusive or, logical not and positive operators in expressions.

- Rob Shearman <rob@codeweavers.com> Tue, 22 Apr 2008
widl: Remove EXPR_MEMBERPTR and implement it using EXPR_PPTR and EXPR_MEMBER instead.

- Rob Shearman <rob@codeweavers.com> Tue, 22 Apr 2008
widl: Don't free input_name in pop_import as we keep pointers to it in the var_t type now.

- Rob Shearman <rob@codeweavers.com> Tue, 22 Apr 2008
widl: Pass the actual type into check_remoting_fields and check_field_common instead of the type name.

- Rob Shearman <rob@codeweavers.com> Tue, 22 Apr 2008
widl: Check that expressions resolve so that expressions in generated code will compile. Also check that expressions return the correct type for the attribute.

- Rob Shearman <rob@codeweavers.com> Tue, 22 Apr 2008
widl: Move expression functions to a new file, expr.c.

- Rob Shearman <rob@codeweavers.com> Tue, 22 Apr 2008
widl: Use expr_resolve_type to get the type of the identifier in write_conf_or_var_desc. Remove the conversion of pointer types into base types as this was only needed due to lack of proper type resolving.

- Rob Shearman <rob@codeweavers.com> Tue, 22 Apr 2008
widl: Remove duplicated code in the form of the write_struct_expr function by enhancing write_expr to allow toplevel identifiers to be prefixed by a string, if specified.

- Rob Shearman <rob@codeweavers.com> Thu, 24 Apr 2008
widl: Implement lcid property on library declarations.

- Rob Shearman <rob@codeweavers.com> Thu, 24 Apr 2008
widl: Construct the pointer chain while parsing pointers, rather than storing a ptr_level. This method is more flexible and somewhat simpler.

- Rob Shearman <rob@codeweavers.com> Thu, 24 Apr 2008
widl: Allow NULL to be used in expressions.

- Rob Shearman <rob@codeweavers.com> Thu, 24 Apr 2008
widl: Create a list of statements in the whole IDL file, instead of just a list of interfaces.

- Rob Shearman <rob@codeweavers.com> Thu, 24 Apr 2008
widl: Add typedef statements to the statement lists.

- Rob Shearman <rob@codeweavers.com> Fri, 25 Apr 2008
widl: Consolidate most of the inner loop of reg_typedefs into set_type.

- Rob Shearman <rob@codeweavers.com> Fri, 25 Apr 2008
widl: Rename pident to declarator and parse the array declarations as part of declarators. This allows arrays to be used in typedefs and const statements.

- Rob Shearman <rob@codeweavers.com> Fri, 25 Apr 2008
widl: Make the rules for parsing fields in structures, encapsulated unions and non-encapsulated unions more strict. Move the rules in fields that handle empty union cases into separate union rules so that they can't erroneously be accepted for structures or other types of unions.

- Rob Shearman <rob@codeweavers.com> Fri, 25 Apr 2008
widl: Add support for declaring multiple fields of a structure in one statement.

- Rob Shearman <rob@codeweavers.com> Fri, 25 Apr 2008
widl: Add support for string literals and wide-string literals in expressions.

- Rob Shearman <rob@codeweavers.com> Fri, 25 Apr 2008
widl: Create a statement object for import statements. Move the writing of include directives into the generated header into header.c.

- Rob Shearman <rob@codeweavers.com> Fri, 25 Apr 2008
widl: Move the func_declarator rule entirely into direct_declarator.

- Rob Shearman <rob@codeweavers.com> Sat, 26 Apr 2008
widl: Add typedefs to typelibs which have the public or uuid attributes, not any other attribute.

- Rob Shearman <rob@codeweavers.com> Sat, 26 Apr 2008
widl: Support hex digits that use an uppercase 0X prefix.

- Rob Shearman <rob@codeweavers.com> Sun, 27 Apr 2008
widl: Accept integer constant suffixes in the lexer.

- Rob Shearman <rob@codeweavers.com> Tue, 29 Apr 2008
widl: Keep const attributes applied to pointers when writing out the type. Use an attribute to store the const qualifier for the pointer and type. Allow multiple type-qualifiers to be applied to a type by adding a declaration-specifier rule that encompasses type-qualifiers and types.

- Rob Shearman <rob@codeweavers.com> Tue, 29 Apr 2008
widl: Add support for "inline" on function definitions. Fix applying calling convention to function type.

- Rob Shearman <rob@codeweavers.com> Tue, 29 Apr 2008
widl: Make constdef and externdef take a declarator instead of an ident so that functions and arrays can be defined using the statements.

- Rob Shearman <rob@codeweavers.com> Tue, 29 Apr 2008
widl: Allow pointer attributes to be applied to function pointers.

- Rob Shearman <rob@codeweavers.com> Tue, 29 Apr 2008
widl: callback, code, comm_status and in_line are attribute names, not keywords.

- Rob Shearman <rob@codeweavers.com> Wed, 30 Apr 2008
widl: Prepare for supporting storage classes in declaration statements. Return a decl_spec_t structure from decl_spec rules so that the storage
class and type qualifiers can both be returned.

- Rob Shearman <rob@codeweavers.com> Wed, 30 Apr 2008
widl: Add the parsing of storage classes into declaration-specifiers. Support the static and register keywords. This consolidates externdef and constdef rules into one declaration rule.

- Rob Shearman <rob@codeweavers.com> Thu, 1 May 2008
widl: Consolidate writing of COM and dispatch interfaces into one function to remove duplicated code. Split up the writing into start and end to eventually support the style MIDL uses where it writes declared types, etc. between the start and end of the interface. Make internal header functions take the file pointer to print to. Don't write interface IDs for non-object interfaces and always write handle declarations even if the interface has no methods, like MIDL does.

- Gerald Pfeifer <gerald@pfeifer.com> Fri, 2 May 2008
widl: Fix syntax to also work with older versions of bison.

svn path=/trunk/; revision=37313

20 files changed:
reactos/media/doc/README.WINE
reactos/tools/widl/client.c
reactos/tools/widl/header.c
reactos/tools/widl/header.h
reactos/tools/widl/parser.l
reactos/tools/widl/parser.tab.c
reactos/tools/widl/parser.tab.h
reactos/tools/widl/parser.y
reactos/tools/widl/parser.yy.c
reactos/tools/widl/proxy.c
reactos/tools/widl/server.c
reactos/tools/widl/typegen.c
reactos/tools/widl/typegen.h
reactos/tools/widl/typelib.c
reactos/tools/widl/typelib.h
reactos/tools/widl/widl.c
reactos/tools/widl/widl.h
reactos/tools/widl/widl.rbuild
reactos/tools/widl/widltypes.h
reactos/tools/widl/write_msft.c

index 4d9ebfa..bc7f4f9 100644 (file)
@@ -26,7 +26,7 @@ reactos/tools/wpp                 # Synced to Wine-20081105 (~Wine-1.1.7)
 reactos/tools/winebuild           # Synced to Wine-20081105 (~Wine-1.1.7)
 reactos/tools/wmc                 # Synced to Wine-20081105 (~Wine-1.1.7)
 reactos/tools/wrc                 # Synced to Wine-20081105 (~Wine-1.1.7)
-reactos/tools/widl                # Synced to Wine-0_9_60
+reactos/tools/widl                # Synced to Wine-0_9_61
 
 The following libraries are shared with Wine.
 
index 51dfa10..c4d200a 100644 (file)
@@ -36,6 +36,7 @@
 
 #include "widltypes.h"
 #include "typegen.h"
+#include "expr.h"
 
 static FILE* client;
 static int indent = 0;
@@ -70,25 +71,10 @@ static void check_pointers(const func_t *func)
     }
 }
 
-const var_t* get_context_handle_var(const func_t* func)
-{
-    const var_t* var;
-
-    if (!func->args)
-        return NULL;
-
-    LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
-        if (is_attr(var->attrs, ATTR_IN) && is_context_handle(var->type))
-            return var;
-
-    return NULL;
-}
-
 static void write_function_stubs(type_t *iface, unsigned int *proc_offset)
 {
     const func_t *func;
     const char *implicit_handle = get_attrp(iface->attrs, ATTR_IMPLICIT_HANDLE);
-    int explicit_handle = is_attr(iface->attrs, ATTR_EXPLICIT_HANDLE);
     const var_t *var;
     int method_count = 0;
 
@@ -112,22 +98,6 @@ static void write_function_stubs(type_t *iface, unsigned int *proc_offset)
             if (!explicit_generic_handle_var)
                 context_handle_var = get_context_handle_var(func);
         }
-        if (explicit_handle)
-        {
-            if (!explicit_handle_var && !explicit_generic_handle_var && !context_handle_var)
-            {
-                error("%s() does not define an explicit binding handle!\n", def->name);
-                return;
-            }
-        }
-        else if (implicit_handle)
-        {
-            if (explicit_handle_var)
-            {
-                error("%s() must not define a binding handle!\n", def->name);
-                return;
-            }
-        }
 
         write_type_decl_left(client, get_func_return_type(func));
         if (needs_space_after(get_func_return_type(func)))
@@ -196,12 +166,7 @@ static void write_function_stubs(type_t *iface, unsigned int *proc_offset)
             fprintf(client, ");\n\n");
         }
 
-        if (implicit_handle)
-        {
-            print_client("_Handle = %s;\n", implicit_handle);
-            fprintf(client, "\n");
-        }
-        else if (explicit_handle_var)
+        if (explicit_handle_var)
         {
             print_client("_Handle = %s;\n", explicit_handle_var->name);
             fprintf(client, "\n");
@@ -225,6 +190,11 @@ static void write_function_stubs(type_t *iface, unsigned int *proc_offset)
             indent--;
             fprintf(client, "\n");
         }
+        else if (implicit_handle)
+        {
+            print_client("_Handle = %s;\n", implicit_handle);
+            fprintf(client, "\n");
+        }
 
         write_remoting_arguments(client, indent, func, PASS_IN, PHASE_BUFFERSIZE);
 
@@ -460,59 +430,69 @@ static void init_client(void)
     fprintf(client, "\n");
 }
 
+static void write_client_ifaces(const statement_list_t *stmts, int expr_eval_routines, unsigned int *proc_offset)
+{
+    const statement_t *stmt;
+    if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, const statement_t, entry )
+    {
+        if (stmt->type == STMT_TYPE && stmt->u.type->type == RPC_FC_IP)
+        {
+            type_t *iface = stmt->u.type;
+            if (!need_stub(iface))
+                return;
+
+            fprintf(client, "/*****************************************************************************\n");
+            fprintf(client, " * %s interface\n", iface->name);
+            fprintf(client, " */\n");
+            fprintf(client, "\n");
+
+            if (iface->funcs)
+            {
+                write_implicithandledecl(iface);
+
+                write_clientinterfacedecl(iface);
+                write_stubdescdecl(iface);
+                write_function_stubs(iface, proc_offset);
+
+                print_client("#if !defined(__RPC_WIN32__)\n");
+                print_client("#error  Invalid build platform for this stub.\n");
+                print_client("#endif\n");
+
+                fprintf(client, "\n");
+                write_stubdescriptor(iface, expr_eval_routines);
+            }
+        }
+        else if (stmt->type == STMT_LIBRARY)
+            write_client_ifaces(stmt->u.lib->stmts, expr_eval_routines, proc_offset);
+    }
+}
 
-void write_client(ifref_list_t *ifaces)
+void write_client(const statement_list_t *stmts)
 {
     unsigned int proc_offset = 0;
     int expr_eval_routines;
-    ifref_t *iface;
 
     if (!do_client)
         return;
-    if (do_everything && !need_stub_files(ifaces))
+    if (do_everything && !need_stub_files(stmts))
         return;
 
     init_client();
     if (!client)
         return;
 
-    write_formatstringsdecl(client, indent, ifaces, need_stub);
+    write_formatstringsdecl(client, indent, stmts, need_stub);
     expr_eval_routines = write_expr_eval_routines(client, client_token);
     if (expr_eval_routines)
         write_expr_eval_routine_list(client, client_token);
     write_user_quad_list(client);
 
-    if (ifaces) LIST_FOR_EACH_ENTRY( iface, ifaces, ifref_t, entry )
-    {
-        if (!need_stub(iface->iface))
-            continue;
-
-        fprintf(client, "/*****************************************************************************\n");
-        fprintf(client, " * %s interface\n", iface->iface->name);
-        fprintf(client, " */\n");
-        fprintf(client, "\n");
-
-        if (iface->iface->funcs)
-        {
-            write_implicithandledecl(iface->iface);
-    
-            write_clientinterfacedecl(iface->iface);
-            write_stubdescdecl(iface->iface);
-            write_function_stubs(iface->iface, &proc_offset);
-
-            print_client("#if !defined(__RPC_WIN32__)\n");
-            print_client("#error  Invalid build platform for this stub.\n");
-            print_client("#endif\n");
-
-            fprintf(client, "\n");
-            write_stubdescriptor(iface->iface, expr_eval_routines);
-        }
-    }
+    write_client_ifaces(stmts, expr_eval_routines, &proc_offset);
 
     fprintf(client, "\n");
 
-    write_procformatstring(client, ifaces, need_stub);
-    write_typeformatstring(client, ifaces, need_stub);
+    write_procformatstring(client, stmts, need_stub);
+    write_typeformatstring(client, stmts, need_stub);
 
     fclose(client);
 }
index 612572d..3e1b2d0 100644 (file)
@@ -33,6 +33,7 @@
 #include "utils.h"
 #include "parser.h"
 #include "header.h"
+#include "expr.h"
 
 typedef struct _user_type_t generic_handle_t;
 
@@ -194,7 +195,7 @@ static void write_enums(FILE *h, var_list_t *enums)
       write_name(h, v);
       if (v->eval) {
         fprintf(h, " = ");
-        write_expr(h, v->eval, 0);
+        write_expr(h, v->eval, 0, 1, NULL, NULL);
       }
     }
     if (list_next( enums, &v->entry )) fprintf(h, ",\n");
@@ -212,7 +213,9 @@ void write_type_left(FILE *h, type_t *t, int declonly)
 {
   if (!h) return;
 
-  if (t->is_const) fprintf(h, "const ");
+  if (is_attr(t->attrs, ATTR_CONST) &&
+      (t->kind == TKIND_ALIAS || t->declarray || !is_ptr(t)))
+    fprintf(h, "const ");
 
   if (t->kind == TKIND_ALIAS) fprintf(h, "%s", t->name);
   else if (t->declarray) write_type_left(h, t->ref, declonly);
@@ -272,6 +275,7 @@ void write_type_left(FILE *h, type_t *t, int declonly)
       case RPC_FC_BOGUS_ARRAY:
         write_type_left(h, t->ref, declonly);
         fprintf(h, "%s*", needs_space_after(t->ref) ? " " : "");
+        if (is_ptr(t) && is_attr(t->attrs, ATTR_CONST)) fprintf(h, "const ");
         break;
       default:
         fprintf(h, "%s", t->name);
@@ -308,6 +312,7 @@ void write_type_v(FILE *h, type_t *t, int is_field, int declonly,
     int i;
     const char *callconv = get_attrp(pt->attrs, ATTR_CALLCONV);
     if (!callconv) callconv = "";
+    if (is_attr(pt->attrs, ATTR_INLINE)) fprintf(h, "inline ");
     write_type_left(h, pt->ref, declonly);
     fputc(' ', h);
     if (ptr_level) fputc('(', h);
@@ -472,111 +477,56 @@ void write_typedef(type_t *type)
   fprintf(header, ";\n");
 }
 
-void write_expr(FILE *h, const expr_t *e, int brackets)
+int is_const_decl(const var_t *var)
 {
-  switch (e->type) {
-  case EXPR_VOID:
-    break;
-  case EXPR_NUM:
-    fprintf(h, "%lu", e->u.lval);
-    break;
-  case EXPR_HEXNUM:
-    fprintf(h, "0x%lx", e->u.lval);
-    break;
-  case EXPR_DOUBLE:
-    fprintf(h, "%#.15g", e->u.dval);
-    break;
-  case EXPR_TRUEFALSE:
-    if (e->u.lval == 0)
-      fprintf(h, "FALSE");
-    else
-      fprintf(h, "TRUE");
-    break;
-  case EXPR_IDENTIFIER:
-    fprintf(h, "%s", e->u.sval);
-    break;
-  case EXPR_NEG:
-    fprintf(h, "-");
-    write_expr(h, e->ref, 1);
-    break;
-  case EXPR_NOT:
-    fprintf(h, "~");
-    write_expr(h, e->ref, 1);
-    break;
-  case EXPR_PPTR:
-    fprintf(h, "*");
-    write_expr(h, e->ref, 1);
-    break;
-  case EXPR_CAST:
-    fprintf(h, "(");
-    write_type_decl(h, e->u.tref, NULL);
-    fprintf(h, ")");
-    write_expr(h, e->ref, 1);
-    break;
-  case EXPR_SIZEOF:
-    fprintf(h, "sizeof(");
-    write_type_decl(h, e->u.tref, NULL);
-    fprintf(h, ")");
-    break;
-  case EXPR_SHL:
-  case EXPR_SHR:
-  case EXPR_MUL:
-  case EXPR_DIV:
-  case EXPR_ADD:
-  case EXPR_SUB:
-  case EXPR_AND:
-  case EXPR_OR:
-    if (brackets) fprintf(h, "(");
-    write_expr(h, e->ref, 1);
-    switch (e->type) {
-    case EXPR_SHL: fprintf(h, " << "); break;
-    case EXPR_SHR: fprintf(h, " >> "); break;
-    case EXPR_MUL: fprintf(h, " * "); break;
-    case EXPR_DIV: fprintf(h, " / "); break;
-    case EXPR_ADD: fprintf(h, " + "); break;
-    case EXPR_SUB: fprintf(h, " - "); break;
-    case EXPR_AND: fprintf(h, " & "); break;
-    case EXPR_OR:  fprintf(h, " | "); break;
-    default: break;
-    }
-    write_expr(h, e->u.ext, 1);
-    if (brackets) fprintf(h, ")");
-    break;
-  case EXPR_COND:
-    if (brackets) fprintf(h, "(");
-    write_expr(h, e->ref, 1);
-    fprintf(h, " ? ");
-    write_expr(h, e->u.ext, 1);
-    fprintf(h, " : ");
-    write_expr(h, e->ext2, 1);
-    if (brackets) fprintf(h, ")");
-    break;
-  case EXPR_ADDRESSOF:
-    fprintf(h, "&");
-    write_expr(h, e->ref, 1);
-    break;
+  const type_t *t;
+  /* strangely, MIDL accepts a const attribute on any pointer in the
+  * declaration to mean that data isn't being instantiated. this appears
+  * to be a bug, but there is no benefit to being incompatible with MIDL,
+  * so we'll do the same thing */
+  for (t = var->type; ; )
+  {
+    if (is_attr(t->attrs, ATTR_CONST))
+      return TRUE;
+    else if (is_ptr(t))
+      t = t->ref;
+    else break;
   }
+  return FALSE;
 }
 
-void write_constdef(const var_t *v)
-{
-  fprintf(header, "#define %s (", v->name);
-  write_expr(header, v->eval, 0);
-  fprintf(header, ")\n\n");
-}
-
-void write_externdef(const var_t *v)
+void write_declaration(const var_t *v, int is_in_interface)
 {
-  fprintf(header, "extern const ");
-  write_type_def_or_decl(header, v->type, FALSE, "%s", v->name);
-  fprintf(header, ";\n\n");
+  if (is_const_decl(v) && v->eval)
+  {
+    fprintf(header, "#define %s (", v->name);
+    write_expr(header, v->eval, 0, 1, NULL, NULL);
+    fprintf(header, ")\n\n");
+  }
+  else if (v->type->type != RPC_FC_FUNCTION || !is_in_interface)
+  {
+    switch (v->stgclass)
+    {
+      case STG_NONE:
+      case STG_REGISTER: /* ignored */
+        break;
+      case STG_STATIC:
+        fprintf(header, "static ");
+        break;
+      case STG_EXTERN:
+        fprintf(header, "extern ");
+        break;
+    }
+    write_type_def_or_decl(header, v->type, FALSE, "%s", v->name);
+    fprintf(header, ";\n\n");
+  }
 }
 
-void write_library(const char *name, const attr_list_t *attr)
+void write_library(const typelib_t *typelib)
 {
-  const UUID *uuid = get_attrp(attr, ATTR_UUID);
+  const UUID *uuid = get_attrp(typelib->attrs, ATTR_UUID);
   fprintf(header, "\n");
-  write_guid(header, "LIBID", name, uuid);
+  write_guid(header, "LIBID", typelib->name, uuid);
   fprintf(header, "\n");
 }
 
@@ -626,6 +576,20 @@ const var_t* get_explicit_generic_handle_var(const func_t* func)
     return NULL;
 }
 
+const var_t* get_context_handle_var(const func_t* func)
+{
+    const var_t* var;
+
+    if (!func->args)
+        return NULL;
+
+    LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
+        if (is_attr(var->attrs, ATTR_IN) && is_context_handle(var->type))
+            return var;
+
+    return NULL;
+}
+
 int has_out_arg_or_return(const func_t *func)
 {
     const var_t *var;
@@ -664,11 +628,11 @@ const var_t *is_callas(const attr_list_t *a)
   return get_attrp(a, ATTR_CALLAS);
 }
 
-static void write_method_macro(const type_t *iface, const char *name)
+static void write_method_macro(FILE *header, const type_t *iface, const char *name)
 {
   const func_t *cur;
 
-  if (iface->ref) write_method_macro(iface->ref, name);
+  if (iface->ref) write_method_macro(header, iface->ref, name);
 
   if (!iface->funcs) return;
 
@@ -727,7 +691,7 @@ void write_args(FILE *h, const var_list_t *args, const char *name, int method, i
   if (do_indent) indentation--;
 }
 
-static void write_cpp_method_def(const type_t *iface)
+static void write_cpp_method_def(FILE *header, const type_t *iface)
 {
   const func_t *cur;
 
@@ -752,11 +716,11 @@ static void write_cpp_method_def(const type_t *iface)
   }
 }
 
-static void do_write_c_method_def(const type_t *iface, const char *name)
+static void do_write_c_method_def(FILE *header, const type_t *iface, const char *name)
 {
   const func_t *cur;
 
-  if (iface->ref) do_write_c_method_def(iface->ref, name);
+  if (iface->ref) do_write_c_method_def(header, iface->ref, name);
 
   if (!iface->funcs) return;
   indent(header, 0);
@@ -779,17 +743,17 @@ static void do_write_c_method_def(const type_t *iface, const char *name)
   }
 }
 
-static void write_c_method_def(const type_t *iface)
+static void write_c_method_def(FILE *header, const type_t *iface)
 {
-  do_write_c_method_def(iface, iface->name);
+  do_write_c_method_def(header, iface, iface->name);
 }
 
-static void write_c_disp_method_def(const type_t *iface)
+static void write_c_disp_method_def(FILE *header, const type_t *iface)
 {
-  do_write_c_method_def(iface->ref, iface->name);
+  do_write_c_method_def(header, iface->ref, iface->name);
 }
 
-static void write_method_proto(const type_t *iface)
+static void write_method_proto(FILE *header, const type_t *iface)
 {
   const func_t *cur;
 
@@ -884,7 +848,7 @@ void write_locals(FILE *fp, const type_t *iface, int body)
   }
 }
 
-static void write_function_proto(const type_t *iface, const func_t *fun, const char *prefix)
+static void write_function_proto(FILE *header, const type_t *iface, const func_t *fun, const char *prefix)
 {
   var_t *def = fun->def;
   const char *callconv = get_attrp(def->type->attrs, ATTR_CALLCONV);
@@ -902,47 +866,20 @@ static void write_function_proto(const type_t *iface, const func_t *fun, const c
   fprintf(header, ");\n\n");
 }
 
-static void write_function_protos(const type_t *iface)
+static void write_function_protos(FILE *header, const type_t *iface)
 {
-  const char *implicit_handle = get_attrp(iface->attrs, ATTR_IMPLICIT_HANDLE);
-  int explicit_handle = is_attr(iface->attrs, ATTR_EXPLICIT_HANDLE);
-  const var_t* explicit_handle_var;
-  const var_t* explicit_generic_handle_var = NULL;
-  const var_t* context_handle_var = NULL;
   const func_t *cur;
   int prefixes_differ = strcmp(prefix_client, prefix_server);
 
   if (!iface->funcs) return;
   LIST_FOR_EACH_ENTRY( cur, iface->funcs, const func_t, entry )
   {
-    var_t *def = cur->def;
-
-    /* check for a defined binding handle */
-    explicit_handle_var = get_explicit_handle_var(cur);
-    if (!explicit_handle_var)
-    {
-      explicit_generic_handle_var = get_explicit_generic_handle_var(cur);
-      if (!explicit_generic_handle_var)
-        context_handle_var = get_context_handle_var(cur);
-    }
-    if (explicit_handle) {
-      if (!explicit_handle_var && !explicit_generic_handle_var && !context_handle_var) {
-        error("%s() does not define an explicit binding handle!\n", def->name);
-        return;
-      }
-    } else if (implicit_handle) {
-      if (explicit_handle_var) {
-        error("%s() must not define a binding handle!\n", def->name);
-        return;
-      }
-    }
-
     if (prefixes_differ) {
       fprintf(header, "/* client prototype */\n");
-      write_function_proto(iface, cur, prefix_client);
+      write_function_proto(header, iface, cur, prefix_client);
       fprintf(header, "/* server prototype */\n");
     }
-    write_function_proto(iface, cur, prefix_server);
+    write_function_proto(header, iface, cur, prefix_server);
   }
 }
 
@@ -963,68 +900,76 @@ void write_forward(type_t *iface)
   }
 }
 
-static void write_iface_guid(const type_t *iface)
+static void write_iface_guid(FILE *header, const type_t *iface)
 {
   const UUID *uuid = get_attrp(iface->attrs, ATTR_UUID);
   write_guid(header, "IID", iface->name, uuid);
 } 
 
-static void write_dispiface_guid(const type_t *iface)
+static void write_dispiface_guid(FILE *header, const type_t *iface)
 {
   const UUID *uuid = get_attrp(iface->attrs, ATTR_UUID);
   write_guid(header, "DIID", iface->name, uuid);
 }
 
-static void write_coclass_guid(type_t *cocl)
+static void write_coclass_guid(FILE *header, const type_t *cocl)
 {
   const UUID *uuid = get_attrp(cocl->attrs, ATTR_UUID);
   write_guid(header, "CLSID", cocl->name, uuid);
 }
 
-static void write_com_interface(type_t *iface)
+static void write_com_interface_start(FILE *header, const type_t *iface)
 {
-  if (!iface->funcs && !iface->ref) {
-    parser_warning("%s has no methods\n", iface->name);
-    return;
-  }
-
+  int dispinterface = is_attr(iface->attrs, ATTR_DISPINTERFACE);
   fprintf(header, "/*****************************************************************************\n");
-  fprintf(header, " * %s interface\n", iface->name);
+  fprintf(header, " * %s %sinterface\n", iface->name, dispinterface ? "disp" : "");
   fprintf(header, " */\n");
-  fprintf(header,"#ifndef __%s_INTERFACE_DEFINED__\n", iface->name);
-  fprintf(header,"#define __%s_INTERFACE_DEFINED__\n\n", iface->name);
-  write_iface_guid(iface);
-  write_forward(iface);
+  fprintf(header,"#ifndef __%s_%sINTERFACE_DEFINED__\n", iface->name, dispinterface ? "DISP" : "");
+  fprintf(header,"#define __%s_%sINTERFACE_DEFINED__\n\n", iface->name, dispinterface ? "DISP" : "");
+}
+
+static void write_com_interface_end(FILE *header, type_t *iface)
+{
+  int dispinterface = is_attr(iface->attrs, ATTR_DISPINTERFACE);
+  if (dispinterface)
+    write_dispiface_guid(header, iface);
+  else
+    write_iface_guid(header, iface);
   /* C++ interface */
   fprintf(header, "#if defined(__cplusplus) && !defined(CINTERFACE)\n");
   if (iface->ref)
   {
-      fprintf(header, "interface %s : public %s\n", iface->name, iface->ref->name);
-      fprintf(header, "{\n");
-      indentation++;
-      write_cpp_method_def(iface);
-      indentation--;
-      fprintf(header, "};\n");
+    fprintf(header, "interface %s : public %s\n", iface->name, iface->ref->name);
+    fprintf(header, "{\n");
   }
   else
   {
-      fprintf(header, "interface %s\n", iface->name);
-      fprintf(header, "{\n");
-      fprintf(header, "    BEGIN_INTERFACE\n");
-      fprintf(header, "\n");
-      indentation++;
-      write_cpp_method_def(iface);
-      indentation--;
-      fprintf(header, "    END_INTERFACE\n");
-      fprintf(header, "};\n");
+    fprintf(header, "interface %s\n", iface->name);
+    fprintf(header, "{\n");
+    fprintf(header, "    BEGIN_INTERFACE\n");
+    fprintf(header, "\n");
   }
+  /* dispinterfaces don't have real functions, so don't write C++ functions for
+   * them */
+  if (!dispinterface)
+  {
+    indentation++;
+    write_cpp_method_def(header, iface);
+    indentation--;
+  }
+  if (!iface->ref)
+    fprintf(header, "    END_INTERFACE\n");
+  fprintf(header, "};\n");
   fprintf(header, "#else\n");
   /* C interface */
   fprintf(header, "typedef struct %sVtbl {\n", iface->name);
   indentation++;
   fprintf(header, "    BEGIN_INTERFACE\n");
   fprintf(header, "\n");
-  write_c_method_def(iface);
+  if (dispinterface)
+    write_c_disp_method_def(header, iface);
+  else
+    write_c_method_def(header, iface);
   indentation--;
   fprintf(header, "    END_INTERFACE\n");
   fprintf(header, "} %sVtbl;\n", iface->name);
@@ -1033,17 +978,25 @@ static void write_com_interface(type_t *iface)
   fprintf(header, "};\n");
   fprintf(header, "\n");
   fprintf(header, "#ifdef COBJMACROS\n");
-  write_method_macro(iface, iface->name);
+  /* dispinterfaces don't have real functions, so don't write macros for them,
+   * only for the interface this interface inherits from, i.e. IDispatch */
+  write_method_macro(header, dispinterface ? iface->ref : iface, iface->name);
   fprintf(header, "#endif\n");
   fprintf(header, "\n");
   fprintf(header, "#endif\n");
   fprintf(header, "\n");
-  write_method_proto(iface);
-  write_locals(header, iface, FALSE);
-  fprintf(header,"\n#endif  /* __%s_INTERFACE_DEFINED__ */\n\n", iface->name);
+  /* dispinterfaces don't have real functions, so don't write prototypes for
+   * them */
+  if (!dispinterface)
+  {
+    write_method_proto(header, iface);
+    write_locals(header, iface, FALSE);
+    fprintf(header, "\n");
+  }
+  fprintf(header,"#endif  /* __%s_%sINTERFACE_DEFINED__ */\n\n", iface->name, dispinterface ? "DISP" : "");
 }
 
-static void write_rpc_interface(const type_t *iface)
+static void write_rpc_interface_start(FILE *header, const type_t *iface)
 {
   unsigned int ver = get_attrv(iface->attrs, ATTR_VERSION);
   const char *var = get_attrp(iface->attrs, ATTR_IMPLICIT_HANDLE);
@@ -1061,72 +1014,39 @@ static void write_rpc_interface(const type_t *iface)
   fprintf(header, " */\n");
   fprintf(header,"#ifndef __%s_INTERFACE_DEFINED__\n", iface->name);
   fprintf(header,"#define __%s_INTERFACE_DEFINED__\n\n", iface->name);
-  if (iface->funcs)
+  if (var) fprintf(header, "extern handle_t %s;\n", var);
+  if (old_names)
   {
-    write_iface_guid(iface);
-    if (var) fprintf(header, "extern handle_t %s;\n", var);
-    if (old_names)
-    {
-        fprintf(header, "extern RPC_IF_HANDLE %s%s_ClientIfHandle;\n", prefix_client, iface->name);
-        fprintf(header, "extern RPC_IF_HANDLE %s%s_ServerIfHandle;\n", prefix_server, iface->name);
-    }
-    else
-    {
-        fprintf(header, "extern RPC_IF_HANDLE %s%s_v%d_%d_c_ifspec;\n",
-                prefix_client, iface->name, MAJORVERSION(ver), MINORVERSION(ver));
-        fprintf(header, "extern RPC_IF_HANDLE %s%s_v%d_%d_s_ifspec;\n",
-                prefix_server, iface->name, MAJORVERSION(ver), MINORVERSION(ver));
-    }
-    write_function_protos(iface);
+      fprintf(header, "extern RPC_IF_HANDLE %s%s_ClientIfHandle;\n", prefix_client, iface->name);
+      fprintf(header, "extern RPC_IF_HANDLE %s%s_ServerIfHandle;\n", prefix_server, iface->name);
+  }
+  else
+  {
+      fprintf(header, "extern RPC_IF_HANDLE %s%s_v%d_%d_c_ifspec;\n",
+              prefix_client, iface->name, MAJORVERSION(ver), MINORVERSION(ver));
+      fprintf(header, "extern RPC_IF_HANDLE %s%s_v%d_%d_s_ifspec;\n",
+              prefix_server, iface->name, MAJORVERSION(ver), MINORVERSION(ver));
   }
-  fprintf(header,"\n#endif  /* __%s_INTERFACE_DEFINED__ */\n\n", iface->name);
-
-  /* FIXME: server/client code */
 }
 
-void write_interface(type_t *iface)
+static void write_rpc_interface_end(FILE *header, const type_t *iface)
 {
-  if (is_object(iface->attrs))
-    write_com_interface(iface);
-  else
-    write_rpc_interface(iface);
+  fprintf(header,"\n#endif  /* __%s_INTERFACE_DEFINED__ */\n\n", iface->name);
 }
 
-void write_dispinterface(type_t *iface)
+void write_interface(type_t *iface)
 {
-  fprintf(header, "/*****************************************************************************\n");
-  fprintf(header, " * %s dispinterface\n", iface->name);
-  fprintf(header, " */\n");
-  fprintf(header,"#ifndef __%s_DISPINTERFACE_DEFINED__\n", iface->name);
-  fprintf(header,"#define __%s_DISPINTERFACE_DEFINED__\n\n", iface->name);
-  write_dispiface_guid(iface);
-  write_forward(iface);
-  /* C++ interface */
-  fprintf(header, "#if defined(__cplusplus) && !defined(CINTERFACE)\n");
-  fprintf(header, "interface %s : public %s\n", iface->name, iface->ref->name);
-  fprintf(header, "{\n");
-  fprintf(header, "};\n");
-  fprintf(header, "#else\n");
-  /* C interface */
-  fprintf(header, "typedef struct %sVtbl {\n", iface->name);
-  indentation++;
-  fprintf(header, "    BEGIN_INTERFACE\n");
-  fprintf(header, "\n");
-  write_c_disp_method_def(iface);
-  indentation--;
-  fprintf(header, "    END_INTERFACE\n");
-  fprintf(header, "} %sVtbl;\n", iface->name);
-  fprintf(header, "interface %s {\n", iface->name);
-  fprintf(header, "    CONST_VTBL %sVtbl* lpVtbl;\n", iface->name);
-  fprintf(header, "};\n");
-  fprintf(header, "\n");
-  fprintf(header, "#ifdef COBJMACROS\n");
-  write_method_macro(iface->ref, iface->name);
-  fprintf(header, "#endif\n");
-  fprintf(header, "\n");
-  fprintf(header, "#endif\n");
-  fprintf(header, "\n");
-  fprintf(header,"#endif  /* __%s_DISPINTERFACE_DEFINED__ */\n\n", iface->name);
+  if (is_attr(iface->attrs, ATTR_DISPINTERFACE) || is_object(iface->attrs))
+  {
+    write_com_interface_start(header, iface);
+    write_com_interface_end(header, iface);
+  }
+  else
+  {
+    write_rpc_interface_start(header, iface);
+    write_function_protos(header, iface);
+    write_rpc_interface_end(header, iface);
+  }
 }
 
 void write_coclass(type_t *cocl)
@@ -1134,7 +1054,7 @@ void write_coclass(type_t *cocl)
   fprintf(header, "/*****************************************************************************\n");
   fprintf(header, " * %s coclass\n", cocl->name);
   fprintf(header, " */\n\n");
-  write_coclass_guid(cocl);
+  write_coclass_guid(header, cocl);
   fprintf(header, "\n");
 }
 
@@ -1145,3 +1065,15 @@ void write_coclass_forward(type_t *cocl)
   fprintf(header, "typedef struct %s %s;\n", cocl->name, cocl->name);
   fprintf(header, "#endif /* defined __%s_FWD_DEFINED__ */\n\n", cocl->name );
 }
+
+void write_import(const char *fname)
+{
+  char *hname, *p;
+
+  hname = dup_basename(fname, ".idl");
+  p = hname + strlen(hname) - 2;
+  if (p <= hname || strcmp( p, ".h" )) strcat(hname, ".h");
+
+  fprintf(header, "#include <%s>\n", hname);
+  free(hname);
+}
index e74a95f..3344c80 100644 (file)
@@ -44,22 +44,20 @@ extern int is_object(const attr_list_t *list);
 extern int is_local(const attr_list_t *list);
 extern int need_stub(const type_t *iface);
 extern int need_proxy(const type_t *iface);
-extern int need_stub_files(const ifref_list_t *ifaces);
-extern int need_proxy_file(const ifref_list_t *ifaces);
+extern int need_stub_files(const statement_list_t *stmts);
+extern int need_proxy_file(const statement_list_t *stmts);
 extern const var_t *is_callas(const attr_list_t *list);
 extern void write_args(FILE *h, const var_list_t *arg, const char *name, int obj, int do_indent);
 extern void write_array(FILE *h, array_dims_t *v, int field);
+extern void write_import(const char *fname);
 extern void write_forward(type_t *iface);
 extern void write_interface(type_t *iface);
-extern void write_dispinterface(type_t *iface);
 extern void write_locals(FILE *fp, const type_t *iface, int body);
 extern void write_coclass(type_t *cocl);
 extern void write_coclass_forward(type_t *cocl);
 extern void write_typedef(type_t *type);
-extern void write_expr(FILE *h, const expr_t *e, int brackets);
-extern void write_constdef(const var_t *v);
-extern void write_externdef(const var_t *v);
-extern void write_library(const char *name, const attr_list_t *attr);
+extern void write_declaration(const var_t *v, int is_in_interface);
+extern void write_library(const typelib_t *typelib);
 extern void write_user_types(void);
 extern void write_context_handle_rundowns(void);
 extern void write_generic_handle_routines(void);
@@ -70,6 +68,7 @@ extern const var_t* get_context_handle_var(const func_t* func);
 extern int has_out_arg_or_return(const func_t *func);
 extern void write_guid(FILE *f, const char *guid_prefix, const char *name,
                        const UUID *uuid);
+extern int is_const_decl(const var_t *var);
 
 static inline int last_ptr(const type_t *type)
 {
index 5b24b26..c085d4f 100644 (file)
 nl     \r?\n
 ws     [ \f\t\r]
 cident [a-zA-Z_][0-9a-zA-Z_]*
-int    [0-9]+
+u_suffix       (u|U)
+l_suffix       (l|L)
+int    [0-9]+({l_suffix}?{u_suffix}?|{u_suffix}?{l_suffix}?)?
 hexd   [0-9a-fA-F]
-hex    0x{hexd}+
+hex    0(x|X){hexd}+({l_suffix}?{u_suffix}?|{u_suffix}?{l_suffix}?)?
 uuid   {hexd}{8}-{hexd}{4}-{hexd}{4}-{hexd}{4}-{hexd}{12}
 double [0-9]+\.[0-9]+([eE][+-]?[0-9]+)*
 
 %x QUOTE
+%x WSTRQUOTE
 %x ATTR
 %x PP_LINE
 
@@ -133,10 +136,16 @@ UUID *parse_uuid(const char *u)
                                parser_lval.str = get_buffered_cstring();
                                return aSTRING;
                        }
-<QUOTE>\\\\            |
-<QUOTE>\\\"            addcchar(yytext[1]);
-<QUOTE>\\.             addcchar('\\'); addcchar(yytext[1]);
-<QUOTE>.               addcchar(yytext[0]);
+<INITIAL,ATTR>L\"      yy_push_state(WSTRQUOTE);
+<WSTRQUOTE>\"          {
+                               yy_pop_state();
+                               parser_lval.str = get_buffered_cstring();
+                               return aWSTRING;
+                       }
+<QUOTE,WSTRQUOTE>\\\\  |
+<QUOTE,WSTRQUOTE>\\\"  addcchar(yytext[1]);
+<QUOTE,WSTRQUOTE>\\.   addcchar('\\'); addcchar(yytext[1]);
+<QUOTE,WSTRQUOTE>.     addcchar(yytext[0]);
 <INITIAL,ATTR>\[       yy_push_state(ATTR); return '[';
 <ATTR>\]               yy_pop_state(); return ']';
 <ATTR>{cident}         return attr_token(yytext);
@@ -162,6 +171,13 @@ SAFEARRAY{ws}*/\(  return tSAFEARRAY;
 <INITIAL,ATTR>{ws}
 <INITIAL,ATTR>\<\<     return SHL;
 <INITIAL,ATTR>\>\>     return SHR;
+<INITIAL,ATTR>\-\>     return MEMBERPTR;
+<INITIAL,ATTR>==       return EQUALITY;
+<INITIAL,ATTR>!=       return INEQUALITY;
+<INITIAL,ATTR>\>=      return GREATEREQUAL;
+<INITIAL,ATTR>\<=      return LESSEQUAL;
+<INITIAL,ATTR>\|\|     return LOGICALOR;
+<INITIAL,ATTR>&&       return LOGICALAND;
 <INITIAL,ATTR>.                return yytext[0];
 <<EOF>>                        {
                                if (import_stack_ptr)
@@ -184,6 +200,7 @@ struct keyword {
 
 static const struct keyword keywords[] = {
        {"FALSE",                       tFALSE},
+       {"NULL",                        tNULL},
        {"TRUE",                        tTRUE},
        {"__cdecl",                     tCDECL},
        {"__fastcall",                  tFASTCALL},
@@ -196,13 +213,10 @@ static const struct keyword keywords[] = {
        {"_stdcall",                    tSTDCALL},
        {"boolean",                     tBOOLEAN},
        {"byte",                        tBYTE},
-       {"callback",                    tCALLBACK},
        {"case",                        tCASE},
        {"cdecl",                       tCDECL},
        {"char",                        tCHAR},
        {"coclass",                     tCOCLASS},
-       {"code",                        tCODE},
-       {"comm_status",                 tCOMMSTATUS},
        {"const",                       tCONST},
        {"cpp_quote",                   tCPPQUOTE},
        {"default",                     tDEFAULT},
@@ -216,7 +230,7 @@ static const struct keyword keywords[] = {
        {"hyper",                       tHYPER},
        {"import",                      tIMPORT},
        {"importlib",                   tIMPORTLIB},
-       {"in_line",                     tINLINE},
+       {"inline",                      tINLINE},
        {"int",                         tINT},
        {"interface",                   tINTERFACE},
        {"library",                     tLIBRARY},
@@ -225,10 +239,12 @@ static const struct keyword keywords[] = {
        {"module",                      tMODULE},
        {"pascal",                      tPASCAL},
        {"properties",                  tPROPERTIES},
+       {"register",                    tREGISTER},
        {"short",                       tSHORT},
        {"signed",                      tSIGNED},
        {"sizeof",                      tSIZEOF},
-        {"small",                      tSMALL},
+       {"small",                       tSMALL},
+       {"static",                      tSTATIC},
        {"stdcall",                     tSTDCALL},
        {"struct",                      tSTRUCT},
        {"switch",                      tSWITCH},
@@ -253,6 +269,9 @@ static const struct keyword attr_keywords[] =
         {"broadcast",                   tBROADCAST},
         {"byte_count",                  tBYTECOUNT},
         {"call_as",                     tCALLAS},
+        {"callback",                    tCALLBACK},
+        {"code",                        tCODE},
+        {"comm_status",                 tCOMMSTATUS},
         {"context_handle",              tCONTEXTHANDLE},
         {"context_handle_noserialize",  tCONTEXTHANDLENOSERIALIZE},
         {"context_handle_serialize",    tCONTEXTHANDLENOSERIALIZE},
@@ -279,6 +298,7 @@ static const struct keyword attr_keywords[] =
         {"immediatebind",               tIMMEDIATEBIND},
         {"implicit_handle",             tIMPLICITHANDLE},
         {"in",                          tIN},
+        {"in_line",                     tIN_LINE},
         {"input_sync",                  tINPUTSYNC},
         {"lcid",                        tLCID},
         {"length_is",                   tLENGTHIS},
@@ -383,7 +403,6 @@ void pop_import(void)
                free(temp_name);
        }
        temp_name = import_stack[ptr].temp_name;
-       free( input_name );
        input_name = import_stack[ptr].input_name;
        line_number = import_stack[ptr].line_number;
        import_stack_ptr--;
@@ -397,20 +416,11 @@ struct imports {
 int do_import(char *fname)
 {
        FILE *f;
-       char *hname, *path, *p;
+       char *path;
        struct imports *import;
        int ptr = import_stack_ptr;
        int ret;
 
-       if (!parse_only && do_header) {
-               hname = dup_basename(fname, ".idl");
-                p = hname + strlen(hname) - 2;
-                if (p <= hname || strcmp( p, ".h" )) strcat(hname, ".h");
-
-               fprintf(header, "#include <%s>\n", hname);
-               free(hname);
-       }
-
        import = first_import;
        while (import && strcmp(import->name, fname))
                import = import->next;
index 20b4648..3cc926d 100644 (file)
      aHEXNUM = 261,
      aDOUBLE = 262,
      aSTRING = 263,
-     aUUID = 264,
-     aEOF = 265,
-     SHL = 266,
-     SHR = 267,
-     tAGGREGATABLE = 268,
-     tALLOCATE = 269,
-     tAPPOBJECT = 270,
-     tASYNC = 271,
-     tASYNCUUID = 272,
-     tAUTOHANDLE = 273,
-     tBINDABLE = 274,
-     tBOOLEAN = 275,
-     tBROADCAST = 276,
-     tBYTE = 277,
-     tBYTECOUNT = 278,
-     tCALLAS = 279,
-     tCALLBACK = 280,
-     tCASE = 281,
-     tCDECL = 282,
-     tCHAR = 283,
-     tCOCLASS = 284,
-     tCODE = 285,
-     tCOMMSTATUS = 286,
-     tCONST = 287,
-     tCONTEXTHANDLE = 288,
-     tCONTEXTHANDLENOSERIALIZE = 289,
-     tCONTEXTHANDLESERIALIZE = 290,
-     tCONTROL = 291,
-     tCPPQUOTE = 292,
-     tDEFAULT = 293,
-     tDEFAULTCOLLELEM = 294,
-     tDEFAULTVALUE = 295,
-     tDEFAULTVTABLE = 296,
-     tDISPLAYBIND = 297,
-     tDISPINTERFACE = 298,
-     tDLLNAME = 299,
-     tDOUBLE = 300,
-     tDUAL = 301,
-     tENDPOINT = 302,
-     tENTRY = 303,
-     tENUM = 304,
-     tERRORSTATUST = 305,
-     tEXPLICITHANDLE = 306,
-     tEXTERN = 307,
-     tFALSE = 308,
-     tFASTCALL = 309,
-     tFLOAT = 310,
-     tHANDLE = 311,
-     tHANDLET = 312,
-     tHELPCONTEXT = 313,
-     tHELPFILE = 314,
-     tHELPSTRING = 315,
-     tHELPSTRINGCONTEXT = 316,
-     tHELPSTRINGDLL = 317,
-     tHIDDEN = 318,
-     tHYPER = 319,
-     tID = 320,
-     tIDEMPOTENT = 321,
-     tIIDIS = 322,
-     tIMMEDIATEBIND = 323,
-     tIMPLICITHANDLE = 324,
-     tIMPORT = 325,
-     tIMPORTLIB = 326,
-     tIN = 327,
-     tINLINE = 328,
-     tINPUTSYNC = 329,
-     tINT = 330,
-     tINT64 = 331,
-     tINTERFACE = 332,
-     tLCID = 333,
-     tLENGTHIS = 334,
-     tLIBRARY = 335,
-     tLOCAL = 336,
-     tLONG = 337,
-     tMETHODS = 338,
-     tMODULE = 339,
-     tNONBROWSABLE = 340,
-     tNONCREATABLE = 341,
-     tNONEXTENSIBLE = 342,
-     tOBJECT = 343,
-     tODL = 344,
-     tOLEAUTOMATION = 345,
-     tOPTIONAL = 346,
-     tOUT = 347,
-     tPASCAL = 348,
-     tPOINTERDEFAULT = 349,
-     tPROPERTIES = 350,
-     tPROPGET = 351,
-     tPROPPUT = 352,
-     tPROPPUTREF = 353,
-     tPTR = 354,
-     tPUBLIC = 355,
-     tRANGE = 356,
-     tREADONLY = 357,
-     tREF = 358,
-     tREQUESTEDIT = 359,
-     tRESTRICTED = 360,
-     tRETVAL = 361,
-     tSAFEARRAY = 362,
-     tSHORT = 363,
-     tSIGNED = 364,
-     tSINGLE = 365,
-     tSIZEIS = 366,
-     tSIZEOF = 367,
-     tSMALL = 368,
-     tSOURCE = 369,
-     tSTDCALL = 370,
-     tSTRICTCONTEXTHANDLE = 371,
-     tSTRING = 372,
-     tSTRUCT = 373,
-     tSWITCH = 374,
-     tSWITCHIS = 375,
-     tSWITCHTYPE = 376,
-     tTRANSMITAS = 377,
-     tTRUE = 378,
-     tTYPEDEF = 379,
-     tUNION = 380,
-     tUNIQUE = 381,
-     tUNSIGNED = 382,
-     tUUID = 383,
-     tV1ENUM = 384,
-     tVARARG = 385,
-     tVERSION = 386,
-     tVOID = 387,
-     tWCHAR = 388,
-     tWIREMARSHAL = 389,
-     CAST = 390,
-     PPTR = 391,
-     NEG = 392,
-     ADDRESSOF = 393
+     aWSTRING = 264,
+     aUUID = 265,
+     aEOF = 266,
+     SHL = 267,
+     SHR = 268,
+     MEMBERPTR = 269,
+     EQUALITY = 270,
+     INEQUALITY = 271,
+     GREATEREQUAL = 272,
+     LESSEQUAL = 273,
+     LOGICALOR = 274,
+     LOGICALAND = 275,
+     tAGGREGATABLE = 276,
+     tALLOCATE = 277,
+     tAPPOBJECT = 278,
+     tASYNC = 279,
+     tASYNCUUID = 280,
+     tAUTOHANDLE = 281,
+     tBINDABLE = 282,
+     tBOOLEAN = 283,
+     tBROADCAST = 284,
+     tBYTE = 285,
+     tBYTECOUNT = 286,
+     tCALLAS = 287,
+     tCALLBACK = 288,
+     tCASE = 289,
+     tCDECL = 290,
+     tCHAR = 291,
+     tCOCLASS = 292,
+     tCODE = 293,
+     tCOMMSTATUS = 294,
+     tCONST = 295,
+     tCONTEXTHANDLE = 296,
+     tCONTEXTHANDLENOSERIALIZE = 297,
+     tCONTEXTHANDLESERIALIZE = 298,
+     tCONTROL = 299,
+     tCPPQUOTE = 300,
+     tDEFAULT = 301,
+     tDEFAULTCOLLELEM = 302,
+     tDEFAULTVALUE = 303,
+     tDEFAULTVTABLE = 304,
+     tDISPLAYBIND = 305,
+     tDISPINTERFACE = 306,
+     tDLLNAME = 307,
+     tDOUBLE = 308,
+     tDUAL = 309,
+     tENDPOINT = 310,
+     tENTRY = 311,
+     tENUM = 312,
+     tERRORSTATUST = 313,
+     tEXPLICITHANDLE = 314,
+     tEXTERN = 315,
+     tFALSE = 316,
+     tFASTCALL = 317,
+     tFLOAT = 318,
+     tHANDLE = 319,
+     tHANDLET = 320,
+     tHELPCONTEXT = 321,
+     tHELPFILE = 322,
+     tHELPSTRING = 323,
+     tHELPSTRINGCONTEXT = 324,
+     tHELPSTRINGDLL = 325,
+     tHIDDEN = 326,
+     tHYPER = 327,
+     tID = 328,
+     tIDEMPOTENT = 329,
+     tIIDIS = 330,
+     tIMMEDIATEBIND = 331,
+     tIMPLICITHANDLE = 332,
+     tIMPORT = 333,
+     tIMPORTLIB = 334,
+     tIN = 335,
+     tIN_LINE = 336,
+     tINLINE = 337,
+     tINPUTSYNC = 338,
+     tINT = 339,
+     tINT64 = 340,
+     tINTERFACE = 341,
+     tLCID = 342,
+     tLENGTHIS = 343,
+     tLIBRARY = 344,
+     tLOCAL = 345,
+     tLONG = 346,
+     tMETHODS = 347,
+     tMODULE = 348,
+     tNONBROWSABLE = 349,
+     tNONCREATABLE = 350,
+     tNONEXTENSIBLE = 351,
+     tNULL = 352,
+     tOBJECT = 353,
+     tODL = 354,
+     tOLEAUTOMATION = 355,
+     tOPTIONAL = 356,
+     tOUT = 357,
+     tPASCAL = 358,
+     tPOINTERDEFAULT = 359,
+     tPROPERTIES = 360,
+     tPROPGET = 361,
+     tPROPPUT = 362,
+     tPROPPUTREF = 363,
+     tPTR = 364,
+     tPUBLIC = 365,
+     tRANGE = 366,
+     tREADONLY = 367,
+     tREF = 368,
+     tREGISTER = 369,
+     tREQUESTEDIT = 370,
+     tRESTRICTED = 371,
+     tRETVAL = 372,
+     tSAFEARRAY = 373,
+     tSHORT = 374,
+     tSIGNED = 375,
+     tSINGLE = 376,
+     tSIZEIS = 377,
+     tSIZEOF = 378,
+     tSMALL = 379,
+     tSOURCE = 380,
+     tSTATIC = 381,
+     tSTDCALL = 382,
+     tSTRICTCONTEXTHANDLE = 383,
+     tSTRING = 384,
+     tSTRUCT = 385,
+     tSWITCH = 386,
+     tSWITCHIS = 387,
+     tSWITCHTYPE = 388,
+     tTRANSMITAS = 389,
+     tTRUE = 390,
+     tTYPEDEF = 391,
+     tUNION = 392,
+     tUNIQUE = 393,
+     tUNSIGNED = 394,
+     tUUID = 395,
+     tV1ENUM = 396,
+     tVARARG = 397,
+     tVERSION = 398,
+     tVOID = 399,
+     tWCHAR = 400,
+     tWIREMARSHAL = 401,
+     ADDRESSOF = 402,
+     NEG = 403,
+     POS = 404,
+     PPTR = 405,
+     CAST = 406
    };
 #endif
 /* Tokens.  */
 #define aHEXNUM 261
 #define aDOUBLE 262
 #define aSTRING 263
-#define aUUID 264
-#define aEOF 265
-#define SHL 266
-#define SHR 267
-#define tAGGREGATABLE 268
-#define tALLOCATE 269
-#define tAPPOBJECT 270
-#define tASYNC 271
-#define tASYNCUUID 272
-#define tAUTOHANDLE 273
-#define tBINDABLE 274
-#define tBOOLEAN 275
-#define tBROADCAST 276
-#define tBYTE 277
-#define tBYTECOUNT 278
-#define tCALLAS 279
-#define tCALLBACK 280
-#define tCASE 281
-#define tCDECL 282
-#define tCHAR 283
-#define tCOCLASS 284
-#define tCODE 285
-#define tCOMMSTATUS 286
-#define tCONST 287
-#define tCONTEXTHANDLE 288
-#define tCONTEXTHANDLENOSERIALIZE 289
-#define tCONTEXTHANDLESERIALIZE 290
-#define tCONTROL 291
-#define tCPPQUOTE 292
-#define tDEFAULT 293
-#define tDEFAULTCOLLELEM 294
-#define tDEFAULTVALUE 295
-#define tDEFAULTVTABLE 296
-#define tDISPLAYBIND 297
-#define tDISPINTERFACE 298
-#define tDLLNAME 299
-#define tDOUBLE 300
-#define tDUAL 301
-#define tENDPOINT 302
-#define tENTRY 303
-#define tENUM 304
-#define tERRORSTATUST 305
-#define tEXPLICITHANDLE 306
-#define tEXTERN 307
-#define tFALSE 308
-#define tFASTCALL 309
-#define tFLOAT 310
-#define tHANDLE 311
-#define tHANDLET 312
-#define tHELPCONTEXT 313
-#define tHELPFILE 314
-#define tHELPSTRING 315
-#define tHELPSTRINGCONTEXT 316
-#define tHELPSTRINGDLL 317
-#define tHIDDEN 318
-#define tHYPER 319
-#define tID 320
-#define tIDEMPOTENT 321
-#define tIIDIS 322
-#define tIMMEDIATEBIND 323
-#define tIMPLICITHANDLE 324
-#define tIMPORT 325
-#define tIMPORTLIB 326
-#define tIN 327
-#define tINLINE 328
-#define tINPUTSYNC 329
-#define tINT 330
-#define tINT64 331
-#define tINTERFACE 332
-#define tLCID 333
-#define tLENGTHIS 334
-#define tLIBRARY 335
-#define tLOCAL 336
-#define tLONG 337
-#define tMETHODS 338
-#define tMODULE 339
-#define tNONBROWSABLE 340
-#define tNONCREATABLE 341
-#define tNONEXTENSIBLE 342
-#define tOBJECT 343
-#define tODL 344
-#define tOLEAUTOMATION 345
-#define tOPTIONAL 346
-#define tOUT 347
-#define tPASCAL 348
-#define tPOINTERDEFAULT 349
-#define tPROPERTIES 350
-#define tPROPGET 351
-#define tPROPPUT 352
-#define tPROPPUTREF 353
-#define tPTR 354
-#define tPUBLIC 355
-#define tRANGE 356
-#define tREADONLY 357
-#define tREF 358
-#define tREQUESTEDIT 359
-#define tRESTRICTED 360
-#define tRETVAL 361
-#define tSAFEARRAY 362
-#define tSHORT 363
-#define tSIGNED 364
-#define tSINGLE 365
-#define tSIZEIS 366
-#define tSIZEOF 367
-#define tSMALL 368
-#define tSOURCE 369
-#define tSTDCALL 370
-#define tSTRICTCONTEXTHANDLE 371
-#define tSTRING 372
-#define tSTRUCT 373
-#define tSWITCH 374
-#define tSWITCHIS 375
-#define tSWITCHTYPE 376
-#define tTRANSMITAS 377
-#define tTRUE 378
-#define tTYPEDEF 379
-#define tUNION 380
-#define tUNIQUE 381
-#define tUNSIGNED 382
-#define tUUID 383
-#define tV1ENUM 384
-#define tVARARG 385
-#define tVERSION 386
-#define tVOID 387
-#define tWCHAR 388
-#define tWIREMARSHAL 389
-#define CAST 390
-#define PPTR 391
-#define NEG 392
-#define ADDRESSOF 393
+#define aWSTRING 264
+#define aUUID 265
+#define aEOF 266
+#define SHL 267
+#define SHR 268
+#define MEMBERPTR 269
+#define EQUALITY 270
+#define INEQUALITY 271
+#define GREATEREQUAL 272
+#define LESSEQUAL 273
+#define LOGICALOR 274
+#define LOGICALAND 275
+#define tAGGREGATABLE 276
+#define tALLOCATE 277
+#define tAPPOBJECT 278
+#define tASYNC 279
+#define tASYNCUUID 280
+#define tAUTOHANDLE 281
+#define tBINDABLE 282
+#define tBOOLEAN 283
+#define tBROADCAST 284
+#define tBYTE 285
+#define tBYTECOUNT 286
+#define tCALLAS 287
+#define tCALLBACK 288
+#define tCASE 289
+#define tCDECL 290
+#define tCHAR 291
+#define tCOCLASS 292
+#define tCODE 293
+#define tCOMMSTATUS 294
+#define tCONST 295
+#define tCONTEXTHANDLE 296
+#define tCONTEXTHANDLENOSERIALIZE 297
+#define tCONTEXTHANDLESERIALIZE 298
+#define tCONTROL 299
+#define tCPPQUOTE 300
+#define tDEFAULT 301
+#define tDEFAULTCOLLELEM 302
+#define tDEFAULTVALUE 303
+#define tDEFAULTVTABLE 304
+#define tDISPLAYBIND 305
+#define tDISPINTERFACE 306
+#define tDLLNAME 307
+#define tDOUBLE 308
+#define tDUAL 309
+#define tENDPOINT 310
+#define tENTRY 311
+#define tENUM 312
+#define tERRORSTATUST 313
+#define tEXPLICITHANDLE 314
+#define tEXTERN 315
+#define tFALSE 316
+#define tFASTCALL 317
+#define tFLOAT 318
+#define tHANDLE 319
+#define tHANDLET 320
+#define tHELPCONTEXT 321
+#define tHELPFILE 322
+#define tHELPSTRING 323
+#define tHELPSTRINGCONTEXT 324
+#define tHELPSTRINGDLL 325
+#define tHIDDEN 326
+#define tHYPER 327
+#define tID 328
+#define tIDEMPOTENT 329
+#define tIIDIS 330
+#define tIMMEDIATEBIND 331
+#define tIMPLICITHANDLE 332
+#define tIMPORT 333
+#define tIMPORTLIB 334
+#define tIN 335
+#define tIN_LINE 336
+#define tINLINE 337
+#define tINPUTSYNC 338
+#define tINT 339
+#define tINT64 340
+#define tINTERFACE 341
+#define tLCID 342
+#define tLENGTHIS 343
+#define tLIBRARY 344
+#define tLOCAL 345
+#define tLONG 346
+#define tMETHODS 347
+#define tMODULE 348
+#define tNONBROWSABLE 349
+#define tNONCREATABLE 350
+#define tNONEXTENSIBLE 351
+#define tNULL 352
+#define tOBJECT 353
+#define tODL 354
+#define tOLEAUTOMATION 355
+#define tOPTIONAL 356
+#define tOUT 357
+#define tPASCAL 358
+#define tPOINTERDEFAULT 359
+#define tPROPERTIES 360
+#define tPROPGET 361
+#define tPROPPUT 362
+#define tPROPPUTREF 363
+#define tPTR 364
+#define tPUBLIC 365
+#define tRANGE 366
+#define tREADONLY 367
+#define tREF 368
+#define tREGISTER 369
+#define tREQUESTEDIT 370
+#define tRESTRICTED 371
+#define tRETVAL 372
+#define tSAFEARRAY 373
+#define tSHORT 374
+#define tSIGNED 375
+#define tSINGLE 376
+#define tSIZEIS 377
+#define tSIZEOF 378
+#define tSMALL 379
+#define tSOURCE 380
+#define tSTATIC 381
+#define tSTDCALL 382
+#define tSTRICTCONTEXTHANDLE 383
+#define tSTRING 384
+#define tSTRUCT 385
+#define tSWITCH 386
+#define tSWITCHIS 387
+#define tSWITCHTYPE 388
+#define tTRANSMITAS 389
+#define tTRUE 390
+#define tTYPEDEF 391
+#define tUNION 392
+#define tUNIQUE 393
+#define tUNSIGNED 394
+#define tUUID 395
+#define tV1ENUM 396
+#define tVARARG 397
+#define tVERSION 398
+#define tVOID 399
+#define tWCHAR 400
+#define tWIREMARSHAL 401
+#define ADDRESSOF 402
+#define NEG 403
+#define POS 404
+#define PPTR 405
+#define CAST 406
 
 
 
  * IDL Compiler
  *
  * Copyright 2002 Ove Kaaven
+ * Copyright 2006-2008 Robert Shearman
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
 #include "header.h"
 #include "typelib.h"
 #include "typegen.h"
+#include "expr.h"
 
 #if defined(YYBYACC)
        /* Berkeley yacc (byacc) doesn't seem to know about these */
 #define YYERROR_VERBOSE
 
 unsigned char pointer_default = RPC_FC_UP;
+static int is_in_interface = FALSE;
 static int is_object_interface = FALSE;
 /* are we inside a library block? */
 static int is_inside_library = FALSE;
@@ -423,6 +452,19 @@ struct typenode {
   struct list entry;
 };
 
+struct _import_t
+{
+  char *name;
+  int import_performed;
+};
+
+typedef struct _decl_spec_t
+{
+  type_t *type;
+  attr_list_t *attrs;
+  enum storage_class stgclass;
+} decl_spec_t;
+
 typelist_t incomplete_types = LIST_INIT(incomplete_types);
 
 static void add_incomplete(type_t *t);
@@ -430,65 +472,75 @@ static void fix_incomplete(void);
 
 static str_list_t *append_str(str_list_t *list, char *str);
 static attr_list_t *append_attr(attr_list_t *list, attr_t *attr);
+static attr_list_t *append_attr_list(attr_list_t *new_list, attr_list_t *old_list);
+static decl_spec_t *make_decl_spec(type_t *type, decl_spec_t *left, decl_spec_t *right, attr_t *attr, enum storage_class stgclass);
 static attr_t *make_attr(enum attr_type type);
 static attr_t *make_attrv(enum attr_type type, unsigned long val);
 static attr_t *make_attrp(enum attr_type type, void *val);
-static expr_t *make_expr(enum expr_type type);
-static expr_t *make_exprl(enum expr_type type, long val);
-static expr_t *make_exprd(enum expr_type type, double val);
-static expr_t *make_exprs(enum expr_type type, char *val);
-static expr_t *make_exprt(enum expr_type type, type_t *tref, expr_t *expr);
-static expr_t *make_expr1(enum expr_type type, expr_t *expr);
-static expr_t *make_expr2(enum expr_type type, expr_t *exp1, expr_t *exp2);
-static expr_t *make_expr3(enum expr_type type, expr_t *expr1, expr_t *expr2, expr_t *expr3);
-static type_t *make_type(unsigned char type, type_t *ref);
 static expr_list_t *append_expr(expr_list_t *list, expr_t *expr);
 static array_dims_t *append_array(array_dims_t *list, expr_t *expr);
-static void set_type(var_t *v, type_t *type, const pident_t *pident, array_dims_t *arr, int top);
+static void set_type(var_t *v, decl_spec_t *decl_spec, const declarator_t *decl, int top);
+static var_list_t *set_var_types(attr_list_t *attrs, decl_spec_t *decl_spec, declarator_list_t *decls);
 static ifref_list_t *append_ifref(ifref_list_t *list, ifref_t *iface);
 static ifref_t *make_ifref(type_t *iface);
 static var_list_t *append_var(var_list_t *list, var_t *var);
+static var_list_t *append_var_list(var_list_t *list, var_list_t *vars);
 static var_t *make_var(char *name);
-static pident_list_t *append_pident(pident_list_t *list, pident_t *p);
-static pident_t *make_pident(var_t *var);
+static declarator_list_t *append_declarator(declarator_list_t *list, declarator_t *p);
+static declarator_t *make_declarator(var_t *var);
 static func_list_t *append_func(func_list_t *list, func_t *func);
-static func_t *make_func(var_t *def, var_list_t *args);
+static func_t *make_func(var_t *def);
 static type_t *make_class(char *name);
 static type_t *make_safearray(type_t *type);
 static type_t *make_builtin(char *name);
 static type_t *make_int(int sign);
+static typelib_t *make_library(const char *name, const attr_list_t *attrs);
+static type_t *make_func_type(var_list_t *args);
+static type_t *make_pointer_type(type_t *ref, attr_list_t *attrs);
+static type_t *append_ptrchain_type(type_t *ptrchain, type_t *type);
 
 static type_t *reg_type(type_t *type, const char *name, int t);
-static type_t *reg_typedefs(type_t *type, var_list_t *names, attr_list_t *attrs);
-static type_t *find_type(const char *name, int t);
+static type_t *reg_typedefs(decl_spec_t *decl_spec, var_list_t *names, attr_list_t *attrs);
 static type_t *find_type2(char *name, int t);
 static type_t *get_type(unsigned char type, char *name, int t);
 static type_t *get_typev(unsigned char type, var_t *name, int t);
 static int get_struct_type(var_list_t *fields);
 
 static var_t *reg_const(var_t *var);
-static var_t *find_const(char *name, int f);
 
-static void write_libid(const char *name, const attr_list_t *attr);
+static void write_libid(const typelib_t *typelib);
 static void write_clsid(type_t *cls);
 static void write_diid(type_t *iface);
 static void write_iid(type_t *iface);
 
 static int compute_method_indexes(type_t *iface);
 static char *gen_name(void);
-static void process_typedefs(var_list_t *names);
+static statement_t *process_typedefs(var_list_t *names);
 static void check_arg(var_t *arg);
 static void check_functions(const type_t *iface);
-static void check_all_user_types(ifref_list_t *ifaces);
-static const attr_list_t *check_iface_attrs(const char *name, const attr_list_t *attrs);
+static void check_all_user_types(const statement_list_t *stmts);
+static attr_list_t *check_iface_attrs(const char *name, attr_list_t *attrs);
 static attr_list_t *check_function_attrs(const char *name, attr_list_t *attrs);
 static attr_list_t *check_typedef_attrs(attr_list_t *attrs);
 static attr_list_t *check_field_attrs(const char *name, attr_list_t *attrs);
-static const attr_list_t *check_library_attrs(const char *name, const attr_list_t *attrs);
+static attr_list_t *check_library_attrs(const char *name, attr_list_t *attrs);
 static attr_list_t *check_dispiface_attrs(const char *name, attr_list_t *attrs);
-static const attr_list_t *check_module_attrs(const char *name, const attr_list_t *attrs);
-static const attr_list_t *check_coclass_attrs(const char *name, const attr_list_t *attrs);
+static attr_list_t *check_module_attrs(const char *name, attr_list_t *attrs);
+static attr_list_t *check_coclass_attrs(const char *name, attr_list_t *attrs);
 const char *get_attr_display_name(enum attr_type type);
+static void add_explicit_handle_if_necessary(func_t *func);
+
+static statement_t *make_statement(enum statement_type type);
+static statement_t *make_statement_type_decl(type_t *type);
+static statement_t *make_statement_reference(type_t *type);
+static statement_t *make_statement_declaration(var_t *var);
+static statement_t *make_statement_library(typelib_t *typelib);
+static statement_t *make_statement_cppquote(const char *str);
+static statement_t *make_statement_importlib(const char *str);
+static statement_t *make_statement_module(type_t *type);
+static statement_t *make_statement_import(const char *str);
+static statement_list_t *append_statement(statement_list_t *list, statement_t *stmt);
+static func_list_t *append_func_from_statement(func_list_t *list, statement_t *stmt);
 
 #define tsENUM   1
 #define tsSTRUCT 2
@@ -515,7 +567,7 @@ const char *get_attr_display_name(enum attr_type type);
 #endif
 
 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
-#line 151 "parser.y"
+#line 177 "parser.y"
 typedef union YYSTYPE {
        attr_t *attr;
        attr_list_t *attr_list;
@@ -526,10 +578,12 @@ typedef union YYSTYPE {
        type_t *type;
        var_t *var;
        var_list_t *var_list;
-       pident_t *pident;
-       pident_list_t *pident_list;
+       declarator_t *declarator;
+       declarator_list_t *declarator_list;
        func_t *func;
        func_list_t *func_list;
+       statement_t *statement;
+       statement_list_t *stmt_list;
        ifref_t *ifref;
        ifref_list_t *ifref_list;
        char *str;
@@ -537,9 +591,13 @@ typedef union YYSTYPE {
        unsigned int num;
        double dbl;
        interface_info_t ifinfo;
+       typelib_t *typelib;
+       struct _import_t *import;
+       struct _decl_spec_t *declspec;
+       enum storage_class stgclass;
 } YYSTYPE;
 /* Line 196 of yacc.c.  */
-#line 543 "parser.tab.c"
+#line 601 "parser.tab.c"
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 # define YYSTYPE_IS_DECLARED 1
 # define YYSTYPE_IS_TRIVIAL 1
@@ -551,7 +609,7 @@ typedef union YYSTYPE {
 
 
 /* Line 219 of yacc.c.  */
-#line 555 "parser.tab.c"
+#line 613 "parser.tab.c"
 
 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
 # define YYSIZE_T __SIZE_TYPE__
@@ -702,20 +760,20 @@ union yyalloc
 /* YYFINAL -- State number of the termination state. */
 #define YYFINAL  3
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   1042
+#define YYLAST   2015
 
 /* YYNTOKENS -- Number of terminals. */
-#define YYNTOKENS  158
+#define YYNTOKENS  176
 /* YYNNTS -- Number of nonterminals. */
-#define YYNNTS  78
+#define YYNNTS  87
 /* YYNRULES -- Number of rules. */
-#define YYNRULES  278
+#define YYNRULES  308
 /* YYNRULES -- Number of states. */
-#define YYNSTATES  507
+#define YYNSTATES  546
 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 #define YYUNDEFTOK  2
-#define YYMAXUTOK   393
+#define YYMAXUTOK   406
 
 #define YYTRANSLATE(YYX)                                               \
   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
@@ -726,16 +784,16 @@ static const unsigned char yytranslate[] =
        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,   139,     2,
-     150,   151,   142,   141,   135,   140,   157,   143,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,   137,   149,
-       2,   156,     2,   136,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,   160,     2,     2,     2,   159,   152,     2,
+     171,   172,   157,   156,   147,   155,   167,   158,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,   149,   170,
+     153,   175,   154,   148,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,   154,     2,   155,     2,     2,     2,     2,     2,     2,
+       2,   168,     2,   169,   151,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,   152,   138,   153,   144,     2,     2,     2,
+       2,     2,     2,   173,   150,   174,   161,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
@@ -762,7 +820,8 @@ static const unsigned char yytranslate[] =
      105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
      115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
      125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
-     145,   146,   147,   148
+     135,   136,   137,   138,   139,   140,   141,   142,   143,   144,
+     145,   146,   162,   163,   164,   165,   166
 };
 
 #if YYDEBUG
@@ -772,156 +831,170 @@ static const unsigned short int yyprhs[] =
 {
        0,     0,     3,     5,     6,     9,    12,    16,    19,    22,
       25,    28,    29,    32,    35,    39,    42,    45,    48,    51,
-      54,    55,    59,    62,    63,    65,    68,    70,    73,    76,
-      78,    81,    84,    87,    92,    96,   100,   106,   109,   113,
-     118,   119,   121,   123,   125,   129,   131,   136,   140,   141,
-     145,   149,   151,   155,   160,   161,   163,   167,   169,   173,
-     178,   180,   184,   185,   187,   189,   191,   193,   195,   197,
-     202,   207,   209,   211,   213,   215,   217,   219,   224,   229,
-     231,   233,   238,   240,   245,   250,   255,   257,   259,   264,
-     269,   274,   279,   284,   286,   291,   293,   298,   300,   306,
-     308,   310,   315,   317,   319,   321,   323,   325,   327,   329,
-     331,   333,   338,   340,   342,   344,   346,   353,   355,   357,
-     359,   361,   366,   368,   370,   372,   377,   382,   387,   392,
-     394,   396,   401,   406,   408,   410,   412,   414,   416,   418,
-     420,   421,   424,   429,   433,   439,   440,   443,   445,   447,
-     451,   455,   457,   463,   465,   469,   470,   472,   474,   476,
-     478,   480,   482,   484,   490,   494,   498,   502,   506,   510,
-     514,   518,   522,   525,   528,   531,   534,   539,   544,   548,
-     550,   554,   556,   561,   562,   565,   568,   572,   575,   577,
-     582,   586,   587,   589,   590,   592,   594,   596,   598,   600,
-     602,   604,   607,   610,   612,   614,   616,   618,   620,   622,
-     624,   625,   627,   629,   632,   634,   637,   640,   642,   644,
-     647,   650,   653,   659,   660,   663,   666,   669,   672,   675,
-     678,   682,   685,   689,   695,   701,   702,   705,   708,   711,
-     714,   721,   730,   733,   736,   739,   742,   745,   748,   754,
-     757,   760,   763,   765,   770,   772,   776,   778,   780,   784,
-     786,   788,   790,   796,   798,   800,   802,   805,   807,   810,
-     812,   815,   817,   820,   825,   830,   836,   847,   849
+      54,    55,    58,    59,    61,    63,    66,    69,    71,    74,
+      77,    80,    85,    89,    93,    99,   102,   106,   111,   112,
+     114,   116,   118,   122,   124,   128,   131,   135,   139,   140,
+     142,   146,   148,   152,   157,   159,   163,   164,   166,   168,
+     170,   172,   174,   176,   181,   186,   188,   190,   192,   194,
+     196,   198,   203,   205,   207,   212,   214,   219,   224,   226,
+     228,   233,   238,   243,   248,   253,   255,   260,   262,   267,
+     269,   275,   277,   279,   284,   289,   291,   293,   295,   297,
+     299,   301,   303,   305,   307,   312,   314,   316,   318,   320,
+     327,   329,   331,   333,   335,   340,   342,   344,   346,   351,
+     356,   361,   366,   368,   370,   375,   380,   382,   384,   386,
+     388,   390,   392,   394,   395,   398,   403,   407,   408,   411,
+     413,   415,   419,   423,   425,   431,   433,   437,   438,   440,
+     442,   444,   446,   448,   450,   452,   454,   456,   458,   464,
+     468,   472,   476,   480,   484,   488,   492,   496,   500,   504,
+     508,   512,   516,   520,   524,   528,   532,   536,   539,   542,
+     545,   548,   551,   554,   558,   562,   567,   572,   577,   581,
+     583,   587,   589,   591,   592,   595,   600,   604,   607,   610,
+     611,   614,   617,   619,   623,   627,   631,   634,   635,   637,
+     638,   640,   642,   644,   646,   648,   650,   652,   655,   658,
+     660,   662,   664,   666,   668,   670,   672,   673,   675,   677,
+     680,   682,   685,   688,   690,   692,   695,   698,   701,   707,
+     708,   711,   714,   717,   720,   723,   726,   730,   733,   737,
+     743,   749,   750,   753,   756,   759,   762,   769,   778,   781,
+     784,   787,   790,   793,   796,   802,   804,   806,   808,   810,
+     812,   813,   816,   819,   823,   824,   826,   829,   832,   835,
+     839,   842,   844,   846,   850,   853,   858,   860,   864,   866,
+     870,   872,   874,   876,   882,   884,   886,   888,   890,   893,
+     895,   898,   900,   903,   908,   913,   919,   930,   932
 };
 
 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
 static const short int yyrhs[] =
 {
-     159,     0,    -1,   160,    -1,    -1,   160,   222,    -1,   160,
-     221,    -1,   160,   208,   149,    -1,   160,   210,    -1,   160,
-     225,    -1,   160,   171,    -1,   160,   164,    -1,    -1,   161,
-     222,    -1,   161,   221,    -1,   161,   208,   149,    -1,   161,
-     210,    -1,   161,   225,    -1,   161,   164,    -1,   161,   168,
-      -1,   161,   171,    -1,    -1,   162,   201,   149,    -1,   162,
-     164,    -1,    -1,   149,    -1,   187,   149,    -1,   165,    -1,
-     191,   149,    -1,   197,   149,    -1,   167,    -1,   231,   149,
-      -1,   233,   149,    -1,   234,   149,    -1,    37,   150,     8,
-     151,    -1,    70,     8,   149,    -1,   166,   161,    10,    -1,
-      71,   150,     8,   151,   163,    -1,    80,     3,    -1,   179,
-     169,   152,    -1,   170,   161,   153,   163,    -1,    -1,   174,
-      -1,   132,    -1,   175,    -1,   174,   135,   175,    -1,   173,
-      -1,   179,   232,   226,   176,    -1,   232,   226,   176,    -1,
-      -1,   154,   177,   155,    -1,   154,   142,   155,    -1,   193,
-      -1,   177,   135,   194,    -1,   177,   155,   154,   194,    -1,
-      -1,   179,    -1,   154,   180,   155,    -1,   182,    -1,   180,
-     135,   182,    -1,   180,   155,   154,   182,    -1,     8,    -1,
-     181,   135,     8,    -1,    -1,    13,    -1,    15,    -1,    16,
-      -1,    18,    -1,    19,    -1,    21,    -1,    24,   150,   204,
-     151,    -1,    26,   150,   195,   151,    -1,    33,    -1,    34,
-      -1,    35,    -1,    36,    -1,    38,    -1,    39,    -1,    40,
-     150,   196,   151,    -1,    40,   150,     8,   151,    -1,    41,
-      -1,    42,    -1,    44,   150,     8,   151,    -1,    46,    -1,
-      47,   150,   181,   151,    -1,    48,   150,     8,   151,    -1,
-      48,   150,   196,   151,    -1,    51,    -1,    56,    -1,    58,
-     150,   196,   151,    -1,    59,   150,     8,   151,    -1,    60,
-     150,     8,   151,    -1,    61,   150,   196,   151,    -1,    62,
-     150,     8,   151,    -1,    63,    -1,    65,   150,   196,   151,
-      -1,    66,    -1,    67,   150,   194,   151,    -1,    68,    -1,
-      69,   150,    57,     3,   151,    -1,    72,    -1,    74,    -1,
-      79,   150,   192,   151,    -1,    81,    -1,    85,    -1,    86,
-      -1,    87,    -1,    88,    -1,    89,    -1,    90,    -1,    91,
-      -1,    92,    -1,    94,   150,   230,   151,    -1,    96,    -1,
-      97,    -1,    98,    -1,   100,    -1,   101,   150,   196,   135,
-     196,   151,    -1,   102,    -1,   104,    -1,   105,    -1,   106,
-      -1,   111,   150,   192,   151,    -1,   114,    -1,   116,    -1,
-     117,    -1,   120,   150,   194,   151,    -1,   121,   150,   232,
-     151,    -1,   122,   150,   232,   151,    -1,   128,   150,   183,
-     151,    -1,   129,    -1,   130,    -1,   131,   150,   235,   151,
-      -1,   134,   150,   232,   151,    -1,   230,    -1,     9,    -1,
-       8,    -1,    27,    -1,    54,    -1,    93,    -1,   115,    -1,
-      -1,   185,   186,    -1,    26,   194,   137,   199,    -1,    38,
-     137,   199,    -1,    32,   232,   204,   156,   196,    -1,    -1,
-     189,   135,    -1,   189,    -1,   190,    -1,   189,   135,   190,
-      -1,   204,   156,   196,    -1,   204,    -1,    49,   203,   152,
-     188,   153,    -1,   193,    -1,   192,   135,   193,    -1,    -1,
-     194,    -1,     5,    -1,     6,    -1,     7,    -1,    53,    -1,
-     123,    -1,     3,    -1,   194,   136,   194,   137,   194,    -1,
-     194,   138,   194,    -1,   194,   139,   194,    -1,   194,   141,
-     194,    -1,   194,   140,   194,    -1,   194,   142,   194,    -1,
-     194,   143,   194,    -1,   194,    11,   194,    -1,   194,    12,
-     194,    -1,   144,   194,    -1,   140,   194,    -1,   139,   194,
-      -1,   142,   194,    -1,   150,   232,   151,   194,    -1,   112,
-     150,   232,   151,    -1,   150,   194,   151,    -1,   196,    -1,
-     195,   135,   196,    -1,   194,    -1,    52,    32,   232,   204,
-      -1,    -1,   198,   199,    -1,   200,   149,    -1,   178,   234,
-     149,    -1,   179,   149,    -1,   149,    -1,   178,   232,   226,
-     176,    -1,   178,   232,   226,    -1,    -1,   204,    -1,    -1,
-       3,    -1,     4,    -1,     3,    -1,     4,    -1,    22,    -1,
-     133,    -1,   207,    -1,   109,   207,    -1,   127,   207,    -1,
-     127,    -1,    55,    -1,   110,    -1,    45,    -1,    20,    -1,
-      50,    -1,    57,    -1,    -1,    75,    -1,    75,    -1,   108,
-     206,    -1,   113,    -1,    82,   206,    -1,    64,   206,    -1,
-      76,    -1,    28,    -1,    29,     3,    -1,    29,     4,    -1,
-     179,   208,    -1,   209,   152,   211,   153,   163,    -1,    -1,
-     211,   212,    -1,   178,   222,    -1,    43,     3,    -1,    43,
-       4,    -1,   179,   213,    -1,    95,   137,    -1,   215,   200,
-     149,    -1,    83,   137,    -1,   216,   201,   149,    -1,   214,
-     152,   215,   216,   153,    -1,   214,   152,   219,   149,   153,
-      -1,    -1,   137,     4,    -1,    77,     3,    -1,    77,     4,
-      -1,   179,   219,    -1,   220,   218,   152,   162,   153,   163,
-      -1,   220,   137,     3,   152,   167,   162,   153,   163,    -1,
-     217,   163,    -1,   219,   149,    -1,   213,   149,    -1,    84,
-       3,    -1,    84,     4,    -1,   179,   223,    -1,   224,   152,
-     162,   153,   163,    -1,   142,   226,    -1,    32,   226,    -1,
-     184,   226,    -1,   228,    -1,   228,   150,   172,   151,    -1,
-     204,    -1,   150,   226,   151,    -1,   227,    -1,   226,    -1,
-     229,   135,   226,    -1,   103,    -1,   126,    -1,    99,    -1,
-     118,   203,   152,   198,   153,    -1,   132,    -1,     4,    -1,
-     205,    -1,    32,   232,    -1,   191,    -1,    49,     3,    -1,
-     231,    -1,   118,     3,    -1,   234,    -1,   125,     3,    -1,
-     107,   150,   232,   151,    -1,   124,   178,   232,   229,    -1,
-     125,   203,   152,   198,   153,    -1,   125,   203,   119,   150,
-     200,   151,   202,   152,   185,   153,    -1,     5,    -1,     5,
-     157,     5,    -1
+     177,     0,    -1,   178,    -1,    -1,   178,   242,    -1,   178,
+     241,    -1,   178,   228,   170,    -1,   178,   230,    -1,   178,
+     245,    -1,   178,   189,    -1,   178,   182,    -1,    -1,   179,
+     242,    -1,   179,   241,    -1,   179,   228,   170,    -1,   179,
+     230,    -1,   179,   245,    -1,   179,   182,    -1,   179,   186,
+      -1,   179,   189,    -1,    -1,   180,   182,    -1,    -1,   170,
+      -1,   183,    -1,   207,   170,    -1,   221,   170,    -1,   185,
+      -1,   258,   170,    -1,   260,   170,    -1,   261,   170,    -1,
+      45,   171,     8,   172,    -1,    78,     8,   170,    -1,   184,
+     179,    11,    -1,    79,   171,     8,   172,   181,    -1,    89,
+       3,    -1,   196,   187,   173,    -1,   188,   179,   174,   181,
+      -1,    -1,   192,    -1,   144,    -1,   193,    -1,   192,   147,
+     193,    -1,   191,    -1,   196,   250,   253,    -1,   250,   253,
+      -1,   168,   209,   169,    -1,   168,   157,   169,    -1,    -1,
+     196,    -1,   168,   197,   169,    -1,   199,    -1,   197,   147,
+     199,    -1,   197,   169,   168,   199,    -1,     8,    -1,   198,
+     147,     8,    -1,    -1,    21,    -1,    23,    -1,    24,    -1,
+      26,    -1,    27,    -1,    29,    -1,    32,   171,   224,   172,
+      -1,    34,   171,   211,   172,    -1,    41,    -1,    42,    -1,
+      43,    -1,    44,    -1,    46,    -1,    47,    -1,    48,   171,
+     213,   172,    -1,    49,    -1,    50,    -1,    52,   171,     8,
+     172,    -1,    54,    -1,    55,   171,   198,   172,    -1,    56,
+     171,   213,   172,    -1,    59,    -1,    64,    -1,    66,   171,
+     212,   172,    -1,    67,   171,     8,   172,    -1,    68,   171,
+       8,   172,    -1,    69,   171,   212,   172,    -1,    70,   171,
+       8,   172,    -1,    71,    -1,    73,   171,   212,   172,    -1,
+      74,    -1,    75,   171,   210,   172,    -1,    76,    -1,    77,
+     171,    65,     3,   172,    -1,    80,    -1,    83,    -1,    88,
+     171,   208,   172,    -1,    87,   171,   212,   172,    -1,    90,
+      -1,    94,    -1,    95,    -1,    96,    -1,    98,    -1,    99,
+      -1,   100,    -1,   101,    -1,   102,    -1,   104,   171,   257,
+     172,    -1,   106,    -1,   107,    -1,   108,    -1,   110,    -1,
+     111,   171,   212,   147,   212,   172,    -1,   112,    -1,   115,
+      -1,   116,    -1,   117,    -1,   122,   171,   208,   172,    -1,
+     125,    -1,   128,    -1,   129,    -1,   132,   171,   210,   172,
+      -1,   133,   171,   259,   172,    -1,   134,   171,   259,   172,
+      -1,   140,   171,   200,   172,    -1,   141,    -1,   142,    -1,
+     143,   171,   262,   172,    -1,   146,   171,   259,   172,    -1,
+     257,    -1,    10,    -1,     8,    -1,    35,    -1,    62,    -1,
+     103,    -1,   127,    -1,    -1,   202,   203,    -1,    34,   212,
+     149,   218,    -1,    46,   149,   218,    -1,    -1,   205,   147,
+      -1,   205,    -1,   206,    -1,   205,   147,   206,    -1,   224,
+     175,   212,    -1,   224,    -1,    57,   223,   173,   204,   174,
+      -1,   209,    -1,   208,   147,   209,    -1,    -1,   210,    -1,
+       5,    -1,     6,    -1,     7,    -1,    61,    -1,    97,    -1,
+     135,    -1,     8,    -1,     9,    -1,     3,    -1,   210,   148,
+     210,   149,   210,    -1,   210,    19,   210,    -1,   210,    20,
+     210,    -1,   210,   150,   210,    -1,   210,   151,   210,    -1,
+     210,   152,   210,    -1,   210,    15,   210,    -1,   210,    16,
+     210,    -1,   210,   154,   210,    -1,   210,   153,   210,    -1,
+     210,    17,   210,    -1,   210,    18,   210,    -1,   210,    12,
+     210,    -1,   210,    13,   210,    -1,   210,   156,   210,    -1,
+     210,   155,   210,    -1,   210,   159,   210,    -1,   210,   157,
+     210,    -1,   210,   158,   210,    -1,   160,   210,    -1,   161,
+     210,    -1,   156,   210,    -1,   155,   210,    -1,   152,   210,
+      -1,   157,   210,    -1,   210,    14,     3,    -1,   210,   167,
+       3,    -1,   171,   259,   172,   210,    -1,   123,   171,   259,
+     172,    -1,   210,   168,   210,   169,    -1,   171,   210,   172,
+      -1,   212,    -1,   211,   147,   212,    -1,   210,    -1,   210,
+      -1,    -1,   214,   215,    -1,   195,   250,   255,   170,    -1,
+     195,   261,   170,    -1,   219,   170,    -1,   196,   170,    -1,
+      -1,   217,   216,    -1,   219,   170,    -1,   170,    -1,   195,
+     250,   253,    -1,   195,   250,   253,    -1,   196,   250,   256,
+      -1,   250,   256,    -1,    -1,   224,    -1,    -1,     3,    -1,
+       4,    -1,     3,    -1,     4,    -1,    30,    -1,   145,    -1,
+     227,    -1,   120,   227,    -1,   139,   227,    -1,   139,    -1,
+      63,    -1,   121,    -1,    53,    -1,    28,    -1,    58,    -1,
+      65,    -1,    -1,    84,    -1,    84,    -1,   119,   226,    -1,
+     124,    -1,    91,   226,    -1,    72,   226,    -1,    85,    -1,
+      36,    -1,    37,     3,    -1,    37,     4,    -1,   196,   228,
+      -1,   229,   173,   231,   174,   181,    -1,    -1,   231,   232,
+      -1,   195,   242,    -1,    51,     3,    -1,    51,     4,    -1,
+     196,   233,    -1,   105,   149,    -1,   235,   219,   170,    -1,
+      92,   149,    -1,   236,   220,   170,    -1,   234,   173,   235,
+     236,   174,    -1,   234,   173,   239,   170,   174,    -1,    -1,
+     149,     4,    -1,    86,     3,    -1,    86,     4,    -1,   196,
+     239,    -1,   240,   238,   173,   180,   174,   181,    -1,   240,
+     149,     3,   173,   185,   180,   174,   181,    -1,   237,   181,
+      -1,   239,   170,    -1,   233,   170,    -1,    93,     3,    -1,
+      93,     4,    -1,   196,   243,    -1,   244,   173,   180,   174,
+     181,    -1,    60,    -1,   126,    -1,   114,    -1,    82,    -1,
+      40,    -1,    -1,   249,   248,    -1,   259,   251,    -1,   252,
+     259,   251,    -1,    -1,   252,    -1,   248,   251,    -1,   247,
+     251,    -1,   246,   251,    -1,   157,   249,   253,    -1,   201,
+     253,    -1,   254,    -1,   224,    -1,   171,   253,   172,    -1,
+     254,   194,    -1,   254,   171,   190,   172,    -1,   253,    -1,
+     255,   147,   253,    -1,   253,    -1,   253,   175,   213,    -1,
+     113,    -1,   138,    -1,   109,    -1,   130,   223,   173,   214,
+     174,    -1,   144,    -1,     4,    -1,   225,    -1,   207,    -1,
+      57,     3,    -1,   258,    -1,   130,     3,    -1,   261,    -1,
+     137,     3,    -1,   118,   171,   259,   172,    -1,   136,   195,
+     250,   255,    -1,   137,   223,   173,   217,   174,    -1,   137,
+     223,   131,   171,   219,   172,   222,   173,   202,   174,    -1,
+       5,    -1,     5,   167,     5,    -1
 };
 
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 static const unsigned short int yyrline[] =
 {
-       0,   304,   304,   313,   314,   315,   316,   320,   325,   326,
-     327,   330,   331,   332,   333,   334,   338,   339,   340,   341,
-     344,   345,   346,   349,   350,   353,   354,   355,   360,   361,
-     362,   367,   368,   375,   377,   383,   387,   391,   393,   400,
-     404,   405,   408,   411,   412,   413,   417,   422,   428,   429,
-     430,   433,   434,   435,   438,   439,   443,   449,   450,   451,
-     454,   455,   458,   459,   460,   461,   462,   463,   464,   465,
-     466,   467,   468,   469,   470,   471,   472,   473,   474,   475,
-     476,   477,   478,   479,   480,   481,   482,   483,   484,   485,
-     486,   487,   488,   489,   490,   491,   492,   493,   494,   495,
-     496,   497,   498,   499,   500,   501,   502,   503,   504,   505,
-     506,   507,   508,   509,   510,   511,   512,   515,   516,   517,
-     518,   519,   520,   521,   522,   523,   524,   525,   526,   527,
-     528,   529,   530,   531,   535,   536,   541,   542,   543,   544,
-     547,   548,   551,   555,   561,   567,   568,   569,   572,   576,
-     585,   589,   594,   603,   604,   617,   618,   621,   622,   623,
-     624,   625,   626,   627,   628,   629,   630,   631,   632,   633,
-     634,   635,   636,   637,   638,   639,   640,   641,   642,   645,
-     646,   649,   655,   660,   661,   664,   665,   666,   667,   670,
-     678,   687,   688,   691,   692,   693,   696,   698,   701,   702,
-     703,   704,   705,   721,   722,   723,   724,   725,   726,   727,
-     730,   731,   734,   735,   736,   737,   738,   739,   740,   743,
-     744,   750,   759,   766,   767,   771,   774,   775,   778,   791,
-     792,   795,   796,   799,   808,   817,   818,   821,   822,   825,
-     837,   850,   862,   866,   867,   870,   871,   874,   879,   886,
-     887,   888,   892,   895,   902,   903,   904,   911,   912,   916,
-     917,   918,   921,   932,   933,   934,   935,   936,   937,   938,
-     939,   940,   941,   942,   945,   950,   955,   972,   973
+       0,   349,   349,   358,   359,   360,   361,   365,   370,   373,
+     374,   377,   378,   379,   380,   381,   386,   387,   388,   389,
+     392,   393,   396,   397,   401,   402,   408,   411,   412,   418,
+     419,   427,   429,   437,   444,   448,   450,   457,   465,   466,
+     469,   472,   473,   474,   478,   485,   493,   494,   497,   498,
+     502,   508,   509,   510,   513,   514,   517,   518,   519,   520,
+     521,   522,   523,   524,   525,   526,   527,   528,   529,   530,
+     531,   532,   533,   534,   535,   536,   537,   538,   539,   540,
+     541,   542,   543,   544,   545,   546,   547,   548,   549,   550,
+     551,   552,   553,   554,   555,   556,   557,   558,   559,   560,
+     561,   562,   563,   564,   565,   566,   567,   568,   569,   570,
+     574,   575,   576,   577,   578,   579,   580,   581,   582,   583,
+     584,   585,   586,   587,   588,   589,   590,   594,   595,   600,
+     601,   602,   603,   606,   607,   610,   614,   620,   621,   622,
+     625,   629,   638,   642,   647,   656,   657,   670,   671,   674,
+     675,   676,   677,   678,   679,   680,   681,   682,   683,   684,
+     685,   686,   687,   688,   689,   690,   691,   692,   693,   694,
+     695,   696,   697,   698,   699,   700,   701,   702,   703,   704,
+     705,   706,   707,   708,   709,   710,   711,   712,   713,   716,
+     717,   720,   726,   732,   733,   736,   741,   748,   749,   752,
+     753,   757,   758,   761,   769,   778,   784,   790,   791,   794,
+     795,   796,   799,   801,   804,   805,   806,   807,   808,   824,
+     825,   826,   827,   828,   829,   830,   833,   834,   837,   838,
+     839,   840,   841,   842,   843,   846,   847,   853,   862,   869,
+     870,   874,   877,   878,   881,   895,   896,   899,   900,   903,
+     913,   923,   924,   927,   928,   931,   944,   958,   971,   975,
+     976,   979,   980,   983,   988,   996,   997,   998,  1002,  1006,
+    1009,  1010,  1013,  1014,  1018,  1019,  1023,  1024,  1025,  1029,
+    1031,  1032,  1036,  1037,  1038,  1039,  1046,  1047,  1051,  1052,
+    1056,  1057,  1058,  1061,  1072,  1073,  1074,  1075,  1076,  1077,
+    1078,  1079,  1080,  1081,  1084,  1090,  1096,  1113,  1114
 };
 #endif
 
@@ -931,48 +1004,54 @@ static const unsigned short int yyrline[] =
 static const char *const yytname[] =
 {
   "$end", "error", "$undefined", "aIDENTIFIER", "aKNOWNTYPE", "aNUM",
-  "aHEXNUM", "aDOUBLE", "aSTRING", "aUUID", "aEOF", "SHL", "SHR",
-  "tAGGREGATABLE", "tALLOCATE", "tAPPOBJECT", "tASYNC", "tASYNCUUID",
-  "tAUTOHANDLE", "tBINDABLE", "tBOOLEAN", "tBROADCAST", "tBYTE",
-  "tBYTECOUNT", "tCALLAS", "tCALLBACK", "tCASE", "tCDECL", "tCHAR",
-  "tCOCLASS", "tCODE", "tCOMMSTATUS", "tCONST", "tCONTEXTHANDLE",
-  "tCONTEXTHANDLENOSERIALIZE", "tCONTEXTHANDLESERIALIZE", "tCONTROL",
-  "tCPPQUOTE", "tDEFAULT", "tDEFAULTCOLLELEM", "tDEFAULTVALUE",
+  "aHEXNUM", "aDOUBLE", "aSTRING", "aWSTRING", "aUUID", "aEOF", "SHL",
+  "SHR", "MEMBERPTR", "EQUALITY", "INEQUALITY", "GREATEREQUAL",
+  "LESSEQUAL", "LOGICALOR", "LOGICALAND", "tAGGREGATABLE", "tALLOCATE",
+  "tAPPOBJECT", "tASYNC", "tASYNCUUID", "tAUTOHANDLE", "tBINDABLE",
+  "tBOOLEAN", "tBROADCAST", "tBYTE", "tBYTECOUNT", "tCALLAS", "tCALLBACK",
+  "tCASE", "tCDECL", "tCHAR", "tCOCLASS", "tCODE", "tCOMMSTATUS", "tCONST",
+  "tCONTEXTHANDLE", "tCONTEXTHANDLENOSERIALIZE", "tCONTEXTHANDLESERIALIZE",
+  "tCONTROL", "tCPPQUOTE", "tDEFAULT", "tDEFAULTCOLLELEM", "tDEFAULTVALUE",
   "tDEFAULTVTABLE", "tDISPLAYBIND", "tDISPINTERFACE", "tDLLNAME",
   "tDOUBLE", "tDUAL", "tENDPOINT", "tENTRY", "tENUM", "tERRORSTATUST",
   "tEXPLICITHANDLE", "tEXTERN", "tFALSE", "tFASTCALL", "tFLOAT", "tHANDLE",
   "tHANDLET", "tHELPCONTEXT", "tHELPFILE", "tHELPSTRING",
   "tHELPSTRINGCONTEXT", "tHELPSTRINGDLL", "tHIDDEN", "tHYPER", "tID",
   "tIDEMPOTENT", "tIIDIS", "tIMMEDIATEBIND", "tIMPLICITHANDLE", "tIMPORT",
-  "tIMPORTLIB", "tIN", "tINLINE", "tINPUTSYNC", "tINT", "tINT64",
-  "tINTERFACE", "tLCID", "tLENGTHIS", "tLIBRARY", "tLOCAL", "tLONG",
-  "tMETHODS", "tMODULE", "tNONBROWSABLE", "tNONCREATABLE",
-  "tNONEXTENSIBLE", "tOBJECT", "tODL", "tOLEAUTOMATION", "tOPTIONAL",
-  "tOUT", "tPASCAL", "tPOINTERDEFAULT", "tPROPERTIES", "tPROPGET",
-  "tPROPPUT", "tPROPPUTREF", "tPTR", "tPUBLIC", "tRANGE", "tREADONLY",
-  "tREF", "tREQUESTEDIT", "tRESTRICTED", "tRETVAL", "tSAFEARRAY", "tSHORT",
-  "tSIGNED", "tSINGLE", "tSIZEIS", "tSIZEOF", "tSMALL", "tSOURCE",
-  "tSTDCALL", "tSTRICTCONTEXTHANDLE", "tSTRING", "tSTRUCT", "tSWITCH",
-  "tSWITCHIS", "tSWITCHTYPE", "tTRANSMITAS", "tTRUE", "tTYPEDEF", "tUNION",
-  "tUNIQUE", "tUNSIGNED", "tUUID", "tV1ENUM", "tVARARG", "tVERSION",
-  "tVOID", "tWCHAR", "tWIREMARSHAL", "','", "'?'", "':'", "'|'", "'&'",
-  "'-'", "'+'", "'*'", "'/'", "'~'", "CAST", "PPTR", "NEG", "ADDRESSOF",
-  "';'", "'('", "')'", "'{'", "'}'", "'['", "']'", "'='", "'.'", "$accept",
-  "input", "gbl_statements", "imp_statements", "int_statements",
-  "semicolon_opt", "statement", "cppquote", "import_start", "import",
-  "importlib", "libraryhdr", "library_start", "librarydef", "m_args",
-  "no_args", "args", "arg", "array", "array_list", "m_attributes",
-  "attributes", "attrib_list", "str_list", "attribute", "uuid_string",
-  "callconv", "cases", "case", "constdef", "enums", "enum_list", "enum",
-  "enumdef", "m_exprs", "m_expr", "expr", "expr_list_const", "expr_const",
-  "externdef", "fields", "field", "s_field", "funcdef", "m_ident",
-  "t_ident", "ident", "base_type", "m_int", "int_std", "coclass",
-  "coclasshdr", "coclassdef", "coclass_ints", "coclass_int",
-  "dispinterface", "dispinterfacehdr", "dispint_props", "dispint_meths",
-  "dispinterfacedef", "inherit", "interface", "interfacehdr",
-  "interfacedef", "interfacedec", "module", "modulehdr", "moduledef",
-  "pident", "func_ident", "direct_ident", "pident_list", "pointer_type",
-  "structdef", "type", "typedef", "uniondef", "version", 0
+  "tIMPORTLIB", "tIN", "tIN_LINE", "tINLINE", "tINPUTSYNC", "tINT",
+  "tINT64", "tINTERFACE", "tLCID", "tLENGTHIS", "tLIBRARY", "tLOCAL",
+  "tLONG", "tMETHODS", "tMODULE", "tNONBROWSABLE", "tNONCREATABLE",
+  "tNONEXTENSIBLE", "tNULL", "tOBJECT", "tODL", "tOLEAUTOMATION",
+  "tOPTIONAL", "tOUT", "tPASCAL", "tPOINTERDEFAULT", "tPROPERTIES",
+  "tPROPGET", "tPROPPUT", "tPROPPUTREF", "tPTR", "tPUBLIC", "tRANGE",
+  "tREADONLY", "tREF", "tREGISTER", "tREQUESTEDIT", "tRESTRICTED",
+  "tRETVAL", "tSAFEARRAY", "tSHORT", "tSIGNED", "tSINGLE", "tSIZEIS",
+  "tSIZEOF", "tSMALL", "tSOURCE", "tSTATIC", "tSTDCALL",
+  "tSTRICTCONTEXTHANDLE", "tSTRING", "tSTRUCT", "tSWITCH", "tSWITCHIS",
+  "tSWITCHTYPE", "tTRANSMITAS", "tTRUE", "tTYPEDEF", "tUNION", "tUNIQUE",
+  "tUNSIGNED", "tUUID", "tV1ENUM", "tVARARG", "tVERSION", "tVOID",
+  "tWCHAR", "tWIREMARSHAL", "','", "'?'", "':'", "'|'", "'^'", "'&'",
+  "'<'", "'>'", "'-'", "'+'", "'*'", "'/'", "'%'", "'!'", "'~'",
+  "ADDRESSOF", "NEG", "POS", "PPTR", "CAST", "'.'", "'['", "']'", "';'",
+  "'('", "')'", "'{'", "'}'", "'='", "$accept", "input", "gbl_statements",
+  "imp_statements", "int_statements", "semicolon_opt", "statement",
+  "cppquote", "import_start", "import", "importlib", "libraryhdr",
+  "library_start", "librarydef", "m_args", "no_args", "args", "arg",
+  "array", "m_attributes", "attributes", "attrib_list", "str_list",
+  "attribute", "uuid_string", "callconv", "cases", "case", "enums",
+  "enum_list", "enum", "enumdef", "m_exprs", "m_expr", "expr",
+  "expr_list_int_const", "expr_int_const", "expr_const", "fields", "field",
+  "ne_union_field", "ne_union_fields", "union_field", "s_field", "funcdef",
+  "declaration", "m_ident", "t_ident", "ident", "base_type", "m_int",
+  "int_std", "coclass", "coclasshdr", "coclassdef", "coclass_ints",
+  "coclass_int", "dispinterface", "dispinterfacehdr", "dispint_props",
+  "dispint_meths", "dispinterfacedef", "inherit", "interface",
+  "interfacehdr", "interfacedef", "interfacedec", "module", "modulehdr",
+  "moduledef", "storage_cls_spec", "function_specifier", "type_qualifier",
+  "m_type_qual_list", "decl_spec", "m_decl_spec_no_type",
+  "decl_spec_no_type", "declarator", "direct_declarator",
+  "declarator_list", "init_declarator", "pointer_type", "structdef",
+  "type", "typedef", "uniondef", "version", 0
 };
 #endif
 
@@ -994,43 +1073,48 @@ static const unsigned short int yytoknum[] =
      355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
      365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
      375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
-     385,   386,   387,   388,   389,    44,    63,    58,   124,    38,
-      45,    43,    42,    47,   126,   390,   391,   392,   393,    59,
-      40,    41,   123,   125,    91,    93,    61,    46
+     385,   386,   387,   388,   389,   390,   391,   392,   393,   394,
+     395,   396,   397,   398,   399,   400,   401,    44,    63,    58,
+     124,    94,    38,    60,    62,    45,    43,    42,    47,    37,
+      33,   126,   402,   403,   404,   405,   406,    46,    91,    93,
+      59,    40,    41,   123,   125,    61
 };
 # endif
 
 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
-static const unsigned char yyr1[] =
+static const unsigned short int yyr1[] =
 {
-       0,   158,   159,   160,   160,   160,   160,   160,   160,   160,
-     160,   161,   161,   161,   161,   161,   161,   161,   161,   161,
-     162,   162,   162,   163,   163,   164,   164,   164,   164,   164,
-     164,   164,   164,   165,   166,   167,   168,   169,   170,   171,
-     172,   172,   173,   174,   174,   174,   175,   175,   176,   176,
-     176,   177,   177,   177,   178,   178,   179,   180,   180,   180,
-     181,   181,   182,   182,   182,   182,   182,   182,   182,   182,
-     182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
-     182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
-     182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
-     182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
-     182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
-     182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
-     182,   182,   182,   182,   183,   183,   184,   184,   184,   184,
-     185,   185,   186,   186,   187,   188,   188,   188,   189,   189,
-     190,   190,   191,   192,   192,   193,   193,   194,   194,   194,
-     194,   194,   194,   194,   194,   194,   194,   194,   194,   194,
-     194,   194,   194,   194,   194,   194,   194,   194,   194,   195,
-     195,   196,   197,   198,   198,   199,   199,   199,   199,   200,
-     201,   202,   202,   203,   203,   203,   204,   204,   205,   205,
-     205,   205,   205,   205,   205,   205,   205,   205,   205,   205,
-     206,   206,   207,   207,   207,   207,   207,   207,   207,   208,
-     208,   209,   210,   211,   211,   212,   213,   213,   214,   215,
-     215,   216,   216,   217,   217,   218,   218,   219,   219,   220,
-     221,   221,   221,   222,   222,   223,   223,   224,   225,   226,
-     226,   226,   226,   227,   228,   228,   228,   229,   229,   230,
-     230,   230,   231,   232,   232,   232,   232,   232,   232,   232,
-     232,   232,   232,   232,   233,   234,   234,   235,   235
+       0,   176,   177,   178,   178,   178,   178,   178,   178,   178,
+     178,   179,   179,   179,   179,   179,   179,   179,   179,   179,
+     180,   180,   181,   181,   182,   182,   182,   182,   182,   182,
+     182,   183,   184,   185,   186,   187,   188,   189,   190,   190,
+     191,   192,   192,   192,   193,   193,   194,   194,   195,   195,
+     196,   197,   197,   197,   198,   198,   199,   199,   199,   199,
+     199,   199,   199,   199,   199,   199,   199,   199,   199,   199,
+     199,   199,   199,   199,   199,   199,   199,   199,   199,   199,
+     199,   199,   199,   199,   199,   199,   199,   199,   199,   199,
+     199,   199,   199,   199,   199,   199,   199,   199,   199,   199,
+     199,   199,   199,   199,   199,   199,   199,   199,   199,   199,
+     199,   199,   199,   199,   199,   199,   199,   199,   199,   199,
+     199,   199,   199,   199,   199,   199,   199,   200,   200,   201,
+     201,   201,   201,   202,   202,   203,   203,   204,   204,   204,
+     205,   205,   206,   206,   207,   208,   208,   209,   209,   210,
+     210,   210,   210,   210,   210,   210,   210,   210,   210,   210,
+     210,   210,   210,   210,   210,   210,   210,   210,   210,   210,
+     210,   210,   210,   210,   210,   210,   210,   210,   210,   210,
+     210,   210,   210,   210,   210,   210,   210,   210,   210,   211,
+     211,   212,   213,   214,   214,   215,   215,   216,   216,   217,
+     217,   218,   218,   219,   220,   221,   221,   222,   222,   223,
+     223,   223,   224,   224,   225,   225,   225,   225,   225,   225,
+     225,   225,   225,   225,   225,   225,   226,   226,   227,   227,
+     227,   227,   227,   227,   227,   228,   228,   229,   230,   231,
+     231,   232,   233,   233,   234,   235,   235,   236,   236,   237,
+     237,   238,   238,   239,   239,   240,   241,   241,   241,   242,
+     242,   243,   243,   244,   245,   246,   246,   246,   247,   248,
+     249,   249,   250,   250,   251,   251,   252,   252,   252,   253,
+     253,   253,   254,   254,   254,   254,   255,   255,   256,   256,
+     257,   257,   257,   258,   259,   259,   259,   259,   259,   259,
+     259,   259,   259,   259,   260,   261,   261,   262,   262
 };
 
 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
@@ -1038,31 +1122,34 @@ static const unsigned char yyr2[] =
 {
        0,     2,     1,     0,     2,     2,     3,     2,     2,     2,
        2,     0,     2,     2,     3,     2,     2,     2,     2,     2,
-       0,     3,     2,     0,     1,     2,     1,     2,     2,     1,
-       2,     2,     2,     4,     3,     3,     5,     2,     3,     4,
-       0,     1,     1,     1,     3,     1,     4,     3,     0,     3,
-       3,     1,     3,     4,     0,     1,     3,     1,     3,     4,
-       1,     3,     0,     1,     1,     1,     1,     1,     1,     4,
-       4,     1,     1,     1,     1,     1,     1,     4,     4,     1,
-       1,     4,     1,     4,     4,     4,     1,     1,     4,     4,
-       4,     4,     4,     1,     4,     1,     4,     1,     5,     1,
-       1,     4,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     4,     1,     1,     1,     1,     6,     1,     1,     1,
-       1,     4,     1,     1,     1,     4,     4,     4,     4,     1,
-       1,     4,     4,     1,     1,     1,     1,     1,     1,     1,
-       0,     2,     4,     3,     5,     0,     2,     1,     1,     3,
-       3,     1,     5,     1,     3,     0,     1,     1,     1,     1,
-       1,     1,     1,     5,     3,     3,     3,     3,     3,     3,
-       3,     3,     2,     2,     2,     2,     4,     4,     3,     1,
-       3,     1,     4,     0,     2,     2,     3,     2,     1,     4,
-       3,     0,     1,     0,     1,     1,     1,     1,     1,     1,
-       1,     2,     2,     1,     1,     1,     1,     1,     1,     1,
-       0,     1,     1,     2,     1,     2,     2,     1,     1,     2,
-       2,     2,     5,     0,     2,     2,     2,     2,     2,     2,
-       3,     2,     3,     5,     5,     0,     2,     2,     2,     2,
-       6,     8,     2,     2,     2,     2,     2,     2,     5,     2,
-       2,     2,     1,     4,     1,     3,     1,     1,     3,     1,
-       1,     1,     5,     1,     1,     1,     2,     1,     2,     1,
+       0,     2,     0,     1,     1,     2,     2,     1,     2,     2,
+       2,     4,     3,     3,     5,     2,     3,     4,     0,     1,
+       1,     1,     3,     1,     3,     2,     3,     3,     0,     1,
+       3,     1,     3,     4,     1,     3,     0,     1,     1,     1,
+       1,     1,     1,     4,     4,     1,     1,     1,     1,     1,
+       1,     4,     1,     1,     4,     1,     4,     4,     1,     1,
+       4,     4,     4,     4,     4,     1,     4,     1,     4,     1,
+       5,     1,     1,     4,     4,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     4,     1,     1,     1,     1,     6,
+       1,     1,     1,     1,     4,     1,     1,     1,     4,     4,
+       4,     4,     1,     1,     4,     4,     1,     1,     1,     1,
+       1,     1,     1,     0,     2,     4,     3,     0,     2,     1,
+       1,     3,     3,     1,     5,     1,     3,     0,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     5,     3,
+       3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
+       3,     3,     3,     3,     3,     3,     3,     2,     2,     2,
+       2,     2,     2,     3,     3,     4,     4,     4,     3,     1,
+       3,     1,     1,     0,     2,     4,     3,     2,     2,     0,
+       2,     2,     1,     3,     3,     3,     2,     0,     1,     0,
+       1,     1,     1,     1,     1,     1,     1,     2,     2,     1,
+       1,     1,     1,     1,     1,     1,     0,     1,     1,     2,
+       1,     2,     2,     1,     1,     2,     2,     2,     5,     0,
+       2,     2,     2,     2,     2,     2,     3,     2,     3,     5,
+       5,     0,     2,     2,     2,     2,     6,     8,     2,     2,
+       2,     2,     2,     2,     5,     1,     1,     1,     1,     1,
+       0,     2,     2,     3,     0,     1,     2,     2,     2,     3,
+       2,     1,     1,     3,     2,     4,     1,     3,     1,     3,
+       1,     1,     1,     5,     1,     1,     1,     1,     2,     1,
        2,     1,     2,     4,     4,     5,    10,     1,     3
 };
 
@@ -1071,421 +1158,629 @@ static const unsigned char yyr2[] =
    means the default is an error.  */
 static const unsigned short int yydefact[] =
 {
-       3,     0,     2,     1,     0,     0,     0,     0,   193,     0,
-       0,     0,   193,    54,   193,    62,    10,    26,    11,    29,
-      11,     9,     0,     0,     0,     0,     0,     0,     7,     0,
-       0,    23,     0,   235,     5,     4,     0,     8,     0,     0,
-       0,   219,   220,   264,   207,   198,   218,     0,   206,   193,
-     208,   204,   209,   210,   212,   217,   210,     0,   210,     0,
-     205,   214,   193,   193,   203,   263,   199,   267,   265,   200,
-     269,     0,   271,     0,   226,   227,   194,   195,     0,     0,
-       0,   237,   238,     0,     0,    55,     0,    63,    64,    65,
-      66,    67,    68,     0,     0,    71,    72,    73,    74,    75,
-      76,     0,    79,    80,     0,    82,     0,     0,    86,    87,
-       0,     0,     0,     0,     0,    93,     0,    95,     0,    97,
-       0,    99,   100,     0,   102,   103,   104,   105,   106,   107,
-     108,   109,   110,     0,   112,   113,   114,   261,   115,     0,
-     117,   259,   118,   119,   120,     0,   122,   123,   124,     0,
-       0,     0,   260,     0,   129,   130,     0,     0,     0,    57,
-     133,     0,     0,     0,     0,     0,   221,   228,   239,   247,
-      25,    27,    28,     6,   223,   244,     0,    24,   242,   243,
-       0,     0,    20,    30,    31,    32,   266,   268,   211,   216,
-     215,     0,   213,   201,   270,   272,   202,   196,   197,     0,
-       0,   145,     0,    34,   183,     0,     0,   183,     0,     0,
+       3,     0,     2,     1,   295,   223,   214,   234,     0,   269,
+       0,     0,   222,   209,   224,   265,   220,   225,   226,     0,
+     268,   228,   233,     0,   226,   267,     0,   226,     0,   221,
+     230,   266,   209,    48,   209,   219,   294,   215,    56,    10,
+      24,    11,    27,    11,     9,     0,   297,     0,   296,   216,
+       0,     0,     7,     0,     0,    22,     0,   251,     5,     4,
+       0,     8,   274,   274,   274,     0,     0,   299,   274,     0,
+     301,   235,   236,     0,   242,   243,   298,   211,     0,   227,
+     232,     0,   253,   254,   231,     0,   229,   217,   300,     0,
+       0,    49,   302,     0,   218,    57,    58,    59,    60,    61,
+      62,     0,     0,    65,    66,    67,    68,    69,    70,     0,
+      72,    73,     0,    75,     0,     0,    78,    79,     0,     0,
+       0,     0,     0,    85,     0,    87,     0,    89,     0,    91,
+      92,     0,     0,    95,    96,    97,    98,    99,   100,   101,
+     102,   103,     0,   105,   106,   107,   292,   108,     0,   110,
+     290,   111,   112,   113,     0,   115,   116,   117,     0,     0,
+       0,   291,     0,   122,   123,     0,     0,     0,    51,   126,
+       0,     0,     0,     0,     0,   297,   237,   244,   255,   263,
+       0,   299,   301,    25,    26,     6,   239,   260,     0,    23,
+     258,   259,     0,     0,    20,   278,   275,   277,   276,   212,
+     213,   129,   130,   131,   132,   270,     0,     0,   282,   288,
+     281,   206,   274,    28,   272,    29,    30,     0,   137,    32,
+       0,   193,     0,     0,   199,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     147,     0,     0,   147,     0,     0,     0,     0,     0,     0,
+      56,    50,    33,     0,    17,    18,    19,     0,    15,    13,
+      12,    16,    22,    35,   261,   262,    36,   205,    48,     0,
+      48,     0,     0,   252,    20,     0,     0,     0,   280,     0,
+     147,    38,   284,   273,    31,     0,   139,   140,   143,   303,
+      48,   286,   304,    48,    48,     0,   157,   149,   150,   151,
+     155,   156,   152,   153,     0,   154,     0,     0,     0,     0,
+       0,     0,     0,   191,     0,   189,   192,     0,     0,    54,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   155,     0,     0,   155,     0,     0,     0,     0,
-       0,     0,    62,    56,    35,     0,    17,    18,    19,     0,
-      15,    13,    12,    16,    23,    37,   245,   246,    38,    54,
-       0,    54,     0,     0,   236,    20,    54,     0,     0,    33,
-       0,   147,   148,   151,   182,    54,   136,     0,   137,   138,
-     139,     0,     0,     0,   254,   257,   256,   252,   274,    54,
-      54,     0,   162,   157,   158,   159,   160,     0,   161,     0,
-       0,     0,     0,     0,   181,     0,   179,     0,     0,     0,
-      60,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   153,   156,     0,     0,     0,     0,     0,
-       0,   135,   134,     0,   277,     0,     0,    58,    62,     0,
-      14,    39,    23,     0,   224,   229,     0,     0,     0,    54,
-       0,     0,    54,    23,    22,     0,     0,   273,   144,   152,
-     146,     0,   188,   262,     0,    55,   184,     0,   250,   249,
-       0,   251,    40,     0,     0,   275,    69,     0,   174,   173,
-     175,   172,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    70,    78,    77,    81,     0,    83,
-      84,    85,    88,    89,    90,    91,    92,    94,    96,     0,
-     155,   101,   111,     0,   121,   125,   126,   127,   128,     0,
-     131,   132,    59,     0,   222,   225,   231,     0,   230,   233,
-       0,   234,    20,    23,   248,     0,    21,   149,   150,   271,
-     187,   185,   255,   263,     0,    45,    41,    43,     0,     0,
-     258,   191,     0,   178,     0,   170,   171,     0,   164,   165,
-     167,   166,   168,   169,   180,    61,    98,   154,     0,   278,
-      23,    48,   232,    54,   240,   190,   186,   253,     0,     0,
-      48,     0,   192,   177,   176,     0,   116,    36,   155,   189,
-      23,    44,    48,    47,   140,   163,     0,     0,    51,   241,
-      46,     0,    50,     0,    49,     0,     0,   276,   141,    52,
-       0,     0,    54,    53,    54,   143,   142
+       0,     0,   145,   148,     0,     0,     0,     0,     0,     0,
+     128,   127,     0,   307,     0,     0,    52,    56,     0,    14,
+      37,    22,     0,   240,   245,     0,     0,     0,    48,     0,
+       0,     0,    22,    21,     0,   271,   279,   283,   289,     0,
+       0,   294,     0,    43,    39,    41,     0,     0,   144,   138,
+       0,   293,     0,   194,     0,     0,   305,    49,   200,     0,
+      63,     0,   181,   180,   179,   182,   177,   178,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    64,    71,    74,     0,    76,    77,    80,
+      81,    82,    83,    84,    86,    88,     0,    94,   147,    93,
+     104,     0,   114,   118,   119,   120,   121,     0,   124,   125,
+      53,     0,   238,   241,   247,     0,   246,   249,     0,     0,
+     250,    20,    22,   264,    47,    46,   285,     0,     0,    45,
+     141,   142,     0,   301,   287,   207,   198,   197,     0,   188,
+       0,   170,   171,   183,   164,   165,   168,   169,   159,   160,
+       0,   161,   162,   163,   167,   166,   173,   172,   175,   176,
+     174,   184,     0,   190,    55,    90,   146,     0,   308,    22,
+     203,     0,   248,     0,   256,    42,    44,     0,   196,     0,
+     208,   186,   185,     0,   187,   109,    34,   204,    22,   195,
+     133,   158,   257,     0,     0,     0,   306,   134,     0,    48,
+      48,   202,   136,     0,   135,   201
 };
 
 /* YYDEFGOTO[NTERM-NUM]. */
 static const short int yydefgoto[] =
 {
-      -1,     1,     2,   161,   256,   178,   344,    17,    18,    19,
-     237,   165,    20,   238,   434,   435,   436,   437,   479,   487,
-     345,    85,   158,   301,   159,   323,   273,   491,   498,    23,
-     260,   261,   262,    67,   312,   313,   294,   295,   296,    25,
-     265,   356,   357,   346,   471,    78,   274,    68,   189,    69,
-     239,    27,   240,   249,   334,    29,    30,   251,   339,    31,
-     181,    32,    33,   241,   242,   169,    36,   243,   275,   276,
-     277,   278,   160,    70,   417,    39,    72,   325
+      -1,     1,     2,   170,   275,   190,   363,    40,    41,    42,
+     255,   174,    43,   256,   372,   373,   374,   375,   282,   356,
+      91,   167,   320,   168,   342,   207,   533,   537,   285,   286,
+     287,   175,   331,   332,   313,   314,   315,   317,   290,   383,
+     388,   294,   542,   543,   459,    47,   519,    78,   208,    48,
+      80,    49,   257,    51,   258,   268,   353,    53,    54,   270,
+     358,    55,   193,    56,    57,   259,   260,   179,    60,   261,
+      62,    63,    64,   276,    65,   195,    66,   209,   210,   292,
+     211,   169,   181,    68,    69,   182,   344
 };
 
 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */
-#define YYPACT_NINF -455
+#define YYPACT_NINF -267
 static const short int yypact[] =
 {
-    -455,    47,   733,  -455,   135,   699,   -87,   145,   151,    35,
-     101,   153,   151,   -53,   151,   908,  -455,  -455,  -455,  -455,
-    -455,  -455,    16,   -42,   -31,   -27,   -16,   -25,  -455,     9,
-      12,    20,    41,    13,  -455,  -455,    43,  -455,    50,    53,
-      57,  -455,  -455,  -455,  -455,  -455,  -455,   699,  -455,   190,
-    -455,  -455,  -455,    71,  -455,  -455,    71,     2,    71,    15,
-    -455,  -455,   194,   201,    15,  -455,  -455,  -455,  -455,  -455,
-    -455,   226,  -455,   203,  -455,  -455,  -455,  -455,    61,   699,
-      60,  -455,  -455,    63,   699,  -455,  -110,  -455,  -455,  -455,
-    -455,  -455,  -455,    11,    70,  -455,  -455,  -455,  -455,  -455,
-    -455,    72,  -455,  -455,    76,  -455,    88,    92,  -455,  -455,
-     102,   106,   108,   109,   125,  -455,   126,  -455,   127,  -455,
-     130,  -455,  -455,   131,  -455,  -455,  -455,  -455,  -455,  -455,
-    -455,  -455,  -455,   134,  -455,  -455,  -455,  -455,  -455,   136,
-    -455,  -455,  -455,  -455,  -455,   137,  -455,  -455,  -455,   138,
-     142,   143,  -455,   144,  -455,  -455,   148,   149,   -98,  -455,
-    -455,   362,   709,   258,   247,   114,  -455,  -455,  -455,  -455,
-    -455,  -455,  -455,  -455,  -455,  -455,   -39,  -455,  -455,  -455,
-     251,   133,  -455,  -455,  -455,  -455,  -455,   150,  -455,  -455,
-    -455,   699,  -455,  -455,   150,   -88,  -455,  -455,  -455,   156,
-     154,   226,   226,  -455,  -455,    99,   163,  -455,   226,    68,
-     303,   292,   293,   452,    68,   296,   306,    68,   307,    68,
-      68,   259,    68,   -48,    68,    68,    68,   699,   699,    31,
-     312,   699,   908,   164,  -455,   169,  -455,  -455,  -455,   172,
-    -455,  -455,  -455,  -455,    20,  -455,  -455,  -455,  -455,   111,
-     185,   -55,   174,   175,  -455,  -455,   735,   177,    68,  -455,
-     173,   196,  -455,   178,  -455,   -17,  -455,    99,  -455,  -455,
-    -455,    99,    99,    99,  -455,  -455,  -455,   179,   198,   -53,
-      -9,   184,  -455,  -455,  -455,  -455,  -455,   187,  -455,    68,
-      68,    68,    68,   491,   594,   -86,  -455,   189,   193,   202,
-    -455,   -83,   207,   210,   211,   212,   214,   215,   216,   217,
-     531,   335,   -82,  -455,   594,   218,   206,   -37,   545,   219,
-     220,  -455,  -455,   222,   188,   224,   225,  -455,   908,   339,
-    -455,  -455,    20,    -7,  -455,  -455,   240,   699,   200,   116,
-     199,   284,   746,    20,  -455,   699,   229,  -455,  -455,  -455,
-     226,    68,  -455,  -455,   699,   230,  -455,   231,  -455,  -455,
-     235,  -455,   275,    99,   236,  -455,  -455,   699,  -455,  -455,
-    -455,  -455,   559,   238,    68,    68,    68,    68,    68,    68,
-      68,    68,    68,    68,  -455,  -455,  -455,  -455,   373,  -455,
-    -455,  -455,  -455,  -455,  -455,  -455,  -455,  -455,  -455,   239,
-      68,  -455,  -455,    68,  -455,  -455,  -455,  -455,  -455,   387,
-    -455,  -455,  -455,   244,  -455,  -455,  -455,    99,  -455,  -455,
-     248,  -455,  -455,    20,  -455,    99,  -455,  -455,  -455,   249,
-    -455,  -455,  -455,   -22,   245,  -455,   266,  -455,   699,    99,
-    -455,   226,   253,  -455,    68,  -455,  -455,   440,   105,    93,
-       0,     0,   261,   261,  -455,  -455,  -455,  -455,   255,  -455,
-      20,   256,  -455,   786,  -455,  -455,  -455,  -455,   399,    99,
-     256,   257,  -455,  -455,  -455,    68,  -455,  -455,   515,  -455,
-      20,  -455,   256,  -455,  -455,   594,    77,   -94,  -455,  -455,
-    -455,    -6,  -455,    68,   262,    68,   276,  -455,  -455,   594,
-      68,   575,   -77,   594,   -77,  -455,  -455
+    -267,    42,  1020,  -267,  -267,  -267,  -267,  -267,    47,  -267,
+     -94,    86,  -267,   144,  -267,  -267,  -267,  -267,    40,   137,
+    -267,  -267,  -267,   150,    40,  -267,   -20,    40,   199,  -267,
+    -267,  -267,   161,    -7,   194,   199,  -267,  -267,  1869,  -267,
+    -267,  -267,  -267,  -267,  -267,  1631,   -14,     4,  -267,  -267,
+      10,    -6,  -267,    12,    21,    38,    43,    73,  -267,  -267,
+      59,  -267,    -3,    -3,    -3,    52,  1744,    55,    -3,    56,
+      63,  -267,  -267,   226,  -267,  -267,    65,  -267,    66,  -267,
+    -267,    70,  -267,  -267,  -267,  1744,  -267,  -267,    65,    69,
+    1674,  -267,  -110,  -108,  -267,  -267,  -267,  -267,  -267,  -267,
+    -267,    77,    78,  -267,  -267,  -267,  -267,  -267,  -267,    79,
+    -267,  -267,    81,  -267,    82,    83,  -267,  -267,    87,    89,
+      91,    93,    98,  -267,    99,  -267,   101,  -267,   110,  -267,
+    -267,   115,   116,  -267,  -267,  -267,  -267,  -267,  -267,  -267,
+    -267,  -267,   117,  -267,  -267,  -267,  -267,  -267,   118,  -267,
+    -267,  -267,  -267,  -267,   120,  -267,  -267,  -267,   129,   130,
+     131,  -267,   138,  -267,  -267,   139,   140,  -107,  -267,  -267,
+     925,   403,   233,   203,    95,  -267,  -267,  -267,  -267,  -267,
+      52,  -267,  -267,  -267,  -267,  -267,  -267,  -267,   -12,  -267,
+    -267,  -267,   208,   135,  -267,  -267,  -267,  -267,  -267,  -267,
+    -267,  -267,  -267,  -267,  -267,  -267,    52,    52,  -267,    84,
+     -42,  -267,    -3,  -267,  -267,  -267,  -267,   113,   212,  -267,
+     141,  -267,    52,   151,  -267,   212,   749,   749,   311,   313,
+     749,   749,   316,   317,   749,   318,   749,   749,   262,   749,
+     749,   -79,   749,   749,   749,  1744,  1744,    97,   323,  1744,
+    1869,   165,  -267,   158,  -267,  -267,  -267,   164,  -267,  -267,
+    -267,  -267,    38,  -267,  -267,  -267,  -267,  -267,  -114,   186,
+     -65,   166,   174,  -267,  -267,    13,    32,   167,  -267,   749,
+     789,  1095,  -267,  -267,  -267,   163,   201,  -267,   175,  -267,
+     -82,  -267,   202,    -7,   -46,   179,  -267,  -267,  -267,  -267,
+    -267,  -267,  -267,  -267,   181,  -267,   749,   749,   749,   749,
+     749,   749,   688,  1390,  -103,  -267,  1390,   185,   188,  -267,
+     -66,   190,   192,   193,   195,   196,   197,   198,  1229,   355,
+     200,   -64,  -267,  1390,   204,   224,   -63,  1272,   205,   206,
+    -267,  -267,   207,   213,   209,   211,  -267,  1869,   365,  -267,
+    -267,    38,   -22,  -267,  -267,   225,  1674,   214,   -38,   215,
+     297,   498,    38,  -267,  1674,  -267,  -267,  -267,  -267,   444,
+     216,   -59,   237,  -267,   239,  -267,  1674,    52,  -267,   212,
+     749,  -267,  1674,  -267,    52,   238,  -267,   241,  -267,   242,
+    -267,  1744,    25,    25,    25,    25,    25,    25,  1295,   243,
+     749,   749,   410,   749,   749,   749,   749,   749,   749,   749,
+     749,   749,   749,   749,   749,   749,   749,   749,   749,   749,
+     413,   749,   749,  -267,  -267,  -267,   409,  -267,  -267,  -267,
+    -267,  -267,  -267,  -267,  -267,  -267,   246,  -267,   749,  -267,
+    -267,   749,  -267,  -267,  -267,  -267,  -267,   414,  -267,  -267,
+    -267,   248,  -267,  -267,  -267,    52,  -267,  -267,  1674,   251,
+    -267,  -267,    38,  -267,  -267,  -267,  -267,  1138,    52,  -267,
+    -267,  -267,    52,   252,  -267,   212,  -267,  -267,   254,  -267,
+     749,   148,   148,  -267,   187,   187,    88,    88,  1497,  1420,
+    1340,  1443,  1466,   864,    88,    88,    61,    61,    25,    25,
+      25,  -267,  1318,  -267,  -267,  -267,  -267,   255,  -267,    38,
+    -267,    52,  -267,   593,  -267,  -267,  -267,  -102,  -267,   256,
+    -267,  -267,    25,   749,  -267,  -267,  -267,  -267,    38,  -267,
+    -267,  1390,  -267,    -8,   749,   275,  -267,  -267,   279,   -28,
+     -28,  -267,  -267,   260,  -267,  -267
 };
 
 /* YYPGOTO[NTERM-NUM].  */
 static const short int yypgoto[] =
 {
-    -455,  -455,  -455,   392,  -240,  -237,    23,  -455,  -455,    79,
-    -455,  -455,  -455,   415,  -455,  -455,  -455,   -50,  -358,  -455,
-     -12,    -2,  -455,  -455,  -209,  -455,  -455,  -455,  -455,  -455,
-    -455,  -455,    73,     4,   197,  -370,  -204,  -455,  -200,  -455,
-     221,  -454,  -225,    85,  -455,    48,   -67,  -455,    36,    56,
-      44,  -455,   423,  -455,  -455,   408,  -455,  -455,  -455,  -455,
-    -455,     5,  -455,   432,     3,  -455,  -455,   434,  -238,  -455,
-    -455,  -455,   223,     6,    -3,  -455,     1,  -455
+    -267,  -267,  -267,   389,  -266,  -252,     7,  -267,  -267,    74,
+    -267,  -267,  -267,   433,  -267,  -267,  -267,   -31,  -267,   -27,
+      -2,  -267,  -267,  -235,  -267,  -267,  -267,  -267,  -267,  -267,
+      58,     2,   219,  -247,   -13,  -267,  -220,  -199,  -267,  -267,
+    -267,  -267,   -99,  -174,  -267,  -267,  -267,   112,  -193,  -267,
+     114,    90,    16,  -267,   436,  -267,  -267,   397,  -267,  -267,
+    -267,  -267,  -267,   -25,  -267,   442,     1,  -267,  -267,   443,
+    -267,  -267,   170,  -267,   -44,   -16,    53,  -194,  -267,   -17,
+     277,   217,     5,   -61,  -267,     0,  -267
 };
 
 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
    positive, shift that token.  If negative, reduce the rule which
    number is the opposite.  If zero, do what YYDEFACT says.
    If YYTABLE_NINF, syntax error.  */
-#define YYTABLE_NINF -195
+#define YYTABLE_NINF -211
 static const short int yytable[] =
 {
-      22,    84,    71,    40,   199,    35,    24,   331,    38,   206,
-     298,   374,   375,   303,   304,   342,   310,   307,   314,   309,
-     495,   314,   318,   327,   316,    16,   338,   168,   336,   358,
-     457,  -194,   496,   359,   360,   361,     7,   232,    11,   321,
-     322,   493,   207,    46,   186,     4,    26,     3,   505,   383,
-     506,   137,   388,   400,   364,   141,   250,   233,   348,     7,
-      83,   494,    86,    73,  -194,   384,   166,    79,   389,   401,
-      11,   282,   352,   283,   284,   285,   202,    15,   152,    53,
-     282,   205,   283,   284,   285,   368,   369,   370,   371,   372,
-      54,    55,   190,    11,   192,   414,   163,    56,   400,    15,
-     164,    15,   197,   198,   374,   375,   424,   170,   488,    80,
-      83,    86,   483,   -42,   404,   193,   374,   375,   171,   412,
-     196,   286,   172,    58,   490,   440,   266,   174,    61,   -42,
-     286,   267,   352,   173,   263,   264,   353,    15,    41,    42,
-     352,   281,   381,   382,   365,    15,   188,   497,    74,    75,
-     180,   428,   191,   268,    76,    77,    81,    82,   175,    22,
-      22,   208,    40,    40,   176,    24,    24,    38,    38,   177,
-     445,   446,   447,   448,   449,   450,   451,   452,   453,   461,
-     287,   252,   463,   454,   236,   236,   464,   465,   257,   287,
-     179,   288,   269,   187,    77,   182,   314,   194,    77,   183,
-     288,   470,   184,   458,   195,    77,   185,   289,   290,   203,
-     291,   200,   292,   201,   270,   204,   289,   290,   293,   291,
-     209,   292,   210,   477,   319,   320,   211,   293,   326,   197,
-     198,   482,   492,   379,   380,   381,   382,   333,   212,   337,
-     474,   271,   213,   489,   378,   379,   380,   381,   382,   272,
-     246,   247,   214,   354,   253,   254,   215,    40,   216,   217,
-      24,   245,    38,   355,   332,    15,   248,   337,   354,   419,
-      15,   485,   374,   375,   314,   218,   219,   220,   355,    43,
-     221,   222,   370,   263,   223,   255,   224,   225,   226,   499,
-     373,   501,   227,   228,   229,    44,   503,    45,   230,   231,
-     299,   300,  -194,    46,   305,   259,   282,    47,   283,   284,
-     285,   297,   258,   279,   306,   308,   311,   324,   328,   329,
-      48,   330,   335,   340,    49,    50,   349,   341,   347,   362,
-      51,   350,    52,   363,   351,   366,   415,   367,   399,    53,
-     385,   403,   425,    40,   386,   409,    24,   413,    38,   418,
-      54,    55,   421,   387,    10,   429,   286,    56,   390,   439,
-     438,   391,   392,   393,   442,   394,   395,   396,   397,   402,
-     406,   407,   234,   408,   472,   410,   411,   416,   426,   430,
-     431,   455,    57,    58,    59,    60,   432,   441,    61,   444,
-     456,     4,   459,    62,     5,   460,   467,   462,   466,     6,
-      63,   468,    64,    43,   473,     7,   476,   433,    66,   484,
-     478,     8,   162,   502,     9,   287,   500,    21,   481,    44,
-     422,    45,   317,   427,   420,    28,   288,    46,   280,    15,
-     167,    47,    10,   235,    34,   469,    37,     0,     0,    11,
-       0,     0,   289,   290,    48,   291,   315,   292,    49,    50,
-       0,   374,   375,   293,    51,   282,    52,   283,   284,   285,
-     302,     0,     0,    53,    40,   439,   438,    24,     0,    38,
-       0,     0,     0,     0,    54,    55,     0,     0,     0,     0,
-      12,    56,     0,     0,     0,     0,    13,    14,     0,     0,
-     354,     0,   354,     0,   282,    43,   283,   284,   285,     0,
-     355,     0,   355,     0,     0,   286,    57,    58,    59,    60,
-       0,    44,    61,    45,     0,     0,    15,    62,   282,    46,
-     283,   284,   285,    47,    63,     0,    64,     0,     0,     0,
-       0,    65,    66,     0,     0,     0,    48,     0,     0,     0,
-      49,    50,   374,   375,   286,     0,    51,     0,    52,     0,
-       0,     0,     0,    15,     0,    53,   374,   375,     0,     0,
-       0,     0,     0,     0,   287,     0,    54,    55,   286,     0,
-     374,   375,     0,    56,     0,   288,   376,   475,   377,   378,
-     379,   380,   381,   382,     0,     0,   374,   375,     0,     0,
-       0,   289,   290,     0,   291,     0,   292,     0,    57,    58,
-      59,    60,   293,   287,    61,   374,   375,     0,     0,    62,
-       0,     0,     0,     0,   288,     0,    63,     0,    64,     0,
-       0,     0,     0,    65,    66,     0,     0,   287,     0,     0,
-     289,   290,     0,   291,     0,   292,     0,     0,   288,     0,
-       0,   293,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   289,   290,     0,   486,     0,   292,
-       0,     0,     0,     0,     0,   293,     0,   376,     0,   377,
-     378,   379,   380,   381,   382,     0,     0,     0,     0,     0,
-       0,   376,   398,   377,   378,   379,   380,   381,   382,     0,
-       0,     0,     0,     0,     0,   376,   405,   377,   378,   379,
-     380,   381,   382,    43,     0,     0,     0,     0,     0,     0,
-     443,   376,   504,   377,   378,   379,   380,   381,   382,    44,
-       0,    45,     0,     0,     0,     0,     0,    46,     0,     0,
-     376,    47,   377,   378,   379,   380,   381,   382,     4,     0,
-       0,     5,     0,     0,    48,     0,     6,     0,    49,    50,
-       0,     0,     7,     0,    51,     0,    52,     0,     8,     0,
-       0,     9,     4,    53,     0,     5,     0,     5,     0,     0,
-       6,     0,     6,     0,    54,    55,     7,     0,     5,    10,
-     235,    56,     8,     6,     8,     9,    11,     9,     0,     0,
-       0,     0,     0,     0,     0,     8,     0,     0,     9,     0,
-       0,     0,     0,    10,     0,    10,    57,    58,    59,    60,
-      11,     0,    61,     0,     0,     0,    10,    62,     5,     0,
-       0,     0,     0,     6,    63,     0,    64,    12,     0,     0,
-       0,    65,    66,    13,    14,     8,     0,     0,     9,     0,
+      45,   180,    70,    59,    46,   212,    90,    67,   361,    39,
+     350,   322,   277,   278,   325,   346,   327,     4,    50,   330,
+     178,  -210,   335,   223,   220,   288,   534,   355,   291,    11,
+     146,   321,   295,   370,   150,   199,   200,     9,   535,   402,
+     250,     5,     3,     6,   422,   384,   222,   197,   198,     7,
+      71,    72,   214,     9,    38,   199,   200,    15,    10,   161,
+     351,   176,   251,  -210,    23,   224,    12,   201,   529,   423,
+      13,    14,     9,    15,    23,   402,    16,    73,    17,    20,
+     368,   426,   366,   438,   438,    18,    38,   201,   -40,    74,
+      75,    19,   381,   269,   202,    20,   357,    21,    22,   452,
+     400,   401,   402,    38,    24,   340,   427,   341,   439,   442,
+     463,    25,   450,   -40,   202,   196,   196,   196,    87,   385,
+     389,   196,    38,    31,    79,    94,   280,    25,   386,   281,
+      38,    26,    27,    28,    29,   203,   457,    30,    84,    31,
+      38,    86,   541,    32,    89,    81,    93,    76,    77,    33,
+      34,    85,    35,    82,    83,   203,   183,    36,    37,   204,
+     471,    38,   402,   271,    88,    77,   536,   186,    45,    45,
+      70,    70,    46,    46,   184,    67,    67,   254,   254,   204,
+     185,    38,   187,   469,   338,   339,   288,   362,   345,   205,
+     474,   506,   420,   421,   188,   513,   283,    92,    77,   400,
+     401,   402,   503,   206,   405,   406,   264,   265,   189,   205,
+     514,   272,   273,   191,   316,   199,   200,   316,   417,   418,
+     419,   507,   192,   206,   328,   213,   215,   333,   420,   421,
+     333,   337,   194,   216,   217,     7,   263,   377,  -210,   218,
+     219,   352,   221,   415,   416,   417,   418,   419,   225,   226,
+     227,   399,   228,   229,   230,   420,   421,   526,   231,   279,
+     232,   510,   233,   382,   234,   196,   316,   333,   266,   235,
+     236,    18,   237,   364,   516,    70,   532,    46,   291,   376,
+      67,   238,   520,    21,    22,   284,   239,   240,   241,   242,
+      24,   243,   387,   392,   393,   394,   395,   396,   397,   398,
+     244,   245,   246,   415,   416,   417,   418,   419,   274,   247,
+     248,   249,   455,   289,   538,   420,   421,   527,    27,   318,
+     180,   319,   293,    30,   323,   324,   326,   329,   343,   348,
+     478,   458,   468,   347,   349,   354,   359,   378,   472,   367,
+     413,   414,   415,   416,   417,   418,   419,   360,   379,   384,
+     380,   390,   391,   453,   420,   421,   395,   424,   436,   364,
+     425,    70,   428,    46,   429,   430,    67,   431,   432,   433,
+     434,   441,   437,   451,   454,    19,   440,   444,   445,   446,
+     447,   448,   473,   449,   456,   465,   467,   481,   482,   460,
+     484,   485,   486,   487,   488,   489,   490,   491,   492,   493,
+     494,   495,   496,   497,   498,   499,   500,     4,   502,   466,
+     475,   476,   477,   483,   511,   480,   501,   504,   505,   508,
+     509,   512,   518,   377,   539,   333,   521,   525,   540,   530,
+     545,     5,   171,     6,   461,    44,   515,   470,    52,     7,
+       8,   544,   177,     9,    58,    61,   365,   296,    10,   297,
+     298,   299,   300,   301,    11,   517,    12,   267,   334,     0,
+      13,    14,   336,    15,     0,   376,    16,   522,    17,     0,
+       0,     0,     0,     0,     0,    18,     0,     0,     0,     0,
+       0,    19,   253,     0,     0,    20,     0,    21,    22,    23,
+       0,     0,     0,     0,    24,     0,     0,     0,     0,     0,
+       0,     0,     4,     0,     0,   302,     0,     0,     0,     0,
+     531,   364,     0,    70,     0,    46,     0,    25,    67,     0,
+       0,    26,    27,    28,    29,     0,     5,    30,     6,    31,
+       0,     0,     0,    32,     7,     0,     0,     0,     9,    33,
+      34,   303,    35,    10,     0,     0,     0,    36,    37,     0,
+       0,    12,     0,     0,     0,    13,    14,     0,    15,     0,
+       0,    16,     0,    17,     0,     0,     0,   304,     0,     0,
+      18,    38,     0,     0,     0,     0,    19,   262,     0,   305,
+      20,     0,    21,    22,     0,     0,     0,     0,     0,    24,
+       0,     0,     0,     0,     0,     0,   306,     4,     0,   307,
+     308,   309,     0,     0,   310,   311,     0,     0,     0,     0,
+       0,     0,    25,   464,     0,   312,    26,    27,    28,    29,
+       0,     5,    30,     6,    31,     0,     0,     0,    32,     7,
+       0,     0,     0,     9,    33,    34,     0,    35,    10,     0,
+       0,     0,    36,    37,     0,     0,    12,     0,     0,     0,
+      13,    14,     0,    15,     0,     0,    16,     0,    17,     0,
+       0,     0,     0,     0,     0,    18,    38,     0,     0,     0,
+       0,    19,   462,     0,     0,    20,     0,    21,    22,     0,
+       0,     0,     0,     0,    24,     0,     0,     0,     0,     0,
+       0,   296,     4,   297,   298,   299,   300,   301,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,    25,     0,     0,
+       0,    26,    27,    28,    29,     0,     5,    30,     6,    31,
+       0,     0,     0,    32,     7,     0,     0,     0,     0,    33,
+      34,     0,    35,     0,     0,     0,     0,    36,    37,     0,
+       0,    12,     0,     0,     0,    13,    14,     0,     0,   302,
+       0,    16,   296,    17,   297,   298,   299,   300,   301,     0,
+      18,    38,     0,     0,     0,     0,     0,   528,     0,     0,
+       0,     0,    21,    22,     0,     0,     0,     0,     0,    24,
+       0,     0,     0,     0,     0,   303,     0,     0,     0,     0,
+       0,     0,   296,     0,   297,   298,   299,   300,   301,     0,
+       0,     0,     0,     0,     0,     0,    26,    27,    28,    29,
+     302,   304,    30,     0,     0,     0,     0,     0,    32,     0,
+       0,     0,     0,   305,     0,    34,     0,    35,     0,     0,
+       0,     0,    36,    37,     0,     0,     0,     0,     0,     0,
+     306,     0,     0,   307,   308,   309,   303,     0,   310,   311,
+     302,     0,     0,     0,     0,     0,     0,     0,     0,   312,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   304,     0,     0,     0,   400,   401,   402,   403,
+     404,   405,   406,     0,   305,     0,   303,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   306,     0,     0,   307,   308,   309,     0,     0,   310,
+     311,     0,   304,     0,     0,     0,     0,     0,     0,     0,
+     312,     0,     0,     0,   305,     0,     0,     0,     0,     4,
+       0,     0,     0,     0,     0,     0,   252,     0,     0,     0,
+       0,   306,     0,     0,   307,   308,   369,     0,     0,   310,
+     311,     0,     0,     5,     0,     6,     0,     0,     0,     0,
+     312,     7,     8,     0,     0,     9,     0,     0,     0,     0,
+      10,     0,     0,     0,     0,     0,    11,     0,    12,     0,
+       0,     0,    13,    14,     0,    15,     0,     0,    16,     0,
+      17,     0,     0,     0,     0,     0,     0,    18,     0,     0,
+       0,     0,     0,    19,   253,     0,     0,    20,     0,    21,
+      22,    23,     0,     0,     0,     0,    24,   413,   414,   415,
+     416,   417,   418,   419,     4,     0,     0,     0,     0,     0,
+       0,   420,   421,     0,     0,     0,     0,     0,     0,    25,
+       0,     0,     0,    26,    27,    28,    29,     0,     5,    30,
+       6,    31,     0,     0,     0,    32,     7,     8,     0,     0,
+       9,    33,    34,     0,    35,    10,     0,     0,     0,    36,
+      37,    11,     0,    12,     0,     0,     0,    13,    14,     0,
+      15,     0,     0,    16,     0,    17,     0,     0,     0,     0,
+       0,     0,    18,    38,     0,     0,     0,     0,    19,     4,
+       0,     0,    20,     0,    21,    22,    23,     0,     0,     0,
+       0,    24,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     5,     0,     6,     0,     0,     0,     0,
+       0,     7,     0,     0,    25,     9,     0,     0,    26,    27,
+      28,    29,     4,     0,    30,     0,    31,     0,    12,     0,
+      32,     0,    13,    14,     0,    15,    33,    34,    16,    35,
+      17,     0,     0,     0,    36,    37,     5,    18,     6,     0,
+       0,     0,     0,     0,     7,     0,     0,    20,     9,    21,
+      22,     0,     0,     0,     0,     0,    24,     0,    38,     0,
+       0,    12,     0,     0,     0,    13,    14,     0,    15,     0,
+       0,    16,     0,    17,     0,     0,     0,     0,     0,    25,
+      18,     0,     0,    26,    27,    28,    29,     0,     0,    30,
+      20,    31,    21,    22,     0,    32,     0,     0,     0,    24,
+       0,     0,    34,     0,    35,     0,     0,     0,     0,   371,
+      37,   400,   401,   402,   403,   404,   405,   406,   407,   408,
+       0,     0,    25,     0,     0,     0,    26,    27,    28,    29,
+       0,     0,    30,    38,    31,     0,     0,     0,    32,     0,
+       0,     0,     0,     0,     0,    34,     0,    35,     0,     0,
+       0,     0,    36,    37,   400,   401,   402,   403,   404,   405,
+     406,   407,   408,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,    38,   400,   401,   402,
+     403,   404,   405,   406,   407,   408,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     400,   401,   402,   403,   404,   405,   406,   407,   408,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   400,   401,   402,   403,   404,   405,   406,   407,
+     408,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   409,     0,   410,
+     411,   412,   413,   414,   415,   416,   417,   418,   419,     0,
+       0,     0,     0,     0,     0,     0,   420,   421,     0,     0,
+       0,   435,   400,   401,   402,   403,   404,   405,   406,   407,
+     408,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     409,     0,   410,   411,   412,   413,   414,   415,   416,   417,
+     418,   419,   400,   401,   402,   403,   404,   405,   406,   420,
+     421,     0,     0,   409,   443,   410,   411,   412,   413,   414,
+     415,   416,   417,   418,   419,   400,   401,   402,   403,   404,
+     405,   406,   420,   421,     0,     0,   409,   479,   410,   411,
+     412,   413,   414,   415,   416,   417,   418,   419,   400,   401,
+     402,   403,   404,   405,   406,   420,   421,   524,   409,   523,
+     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
+       0,     0,     0,     0,     0,     0,     0,   420,   421,   400,
+     401,   402,   403,   404,   405,   406,     0,   408,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   409,     0,
+     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
+       0,     0,     0,     0,     0,     0,     0,   420,   421,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     410,   411,   412,   413,   414,   415,   416,   417,   418,   419,
+       0,     0,     0,     0,     0,     0,     0,   420,   421,     0,
+       0,     0,     0,     0,   411,   412,   413,   414,   415,   416,
+     417,   418,   419,     0,     0,     0,     0,     0,     0,     0,
+     420,   421,     0,     0,     0,     0,     0,     0,   412,   413,
+     414,   415,   416,   417,   418,   419,     0,     0,     0,     0,
+       0,     0,     0,   420,   421,     4,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   410,   411,   412,
+     413,   414,   415,   416,   417,   418,   419,     0,     0,     5,
+       0,     6,     0,     0,   420,   421,     0,     7,     8,     0,
+       0,     9,     0,     0,     0,     0,     0,     0,     4,     0,
+       0,     0,    11,     0,    12,     0,     0,     0,    13,    14,
+       0,    15,     0,     0,    16,     0,    17,     0,     0,     0,
+       0,     0,     5,    18,     6,     0,     0,     0,     0,     0,
+       7,     0,     0,    20,     9,    21,    22,    23,     0,     0,
+     172,     0,    24,     0,   173,     0,     0,    12,     0,     0,
+       0,    13,    14,     0,    15,     0,     0,    16,     0,    17,
+       0,     0,     0,     0,     0,    25,    18,     0,     4,    26,
+      27,    28,    29,     0,     0,    30,    20,    31,    21,    22,
+       0,    32,     0,     0,     0,    24,     0,     0,    34,     0,
+      35,     0,     5,     0,     6,    36,    37,     0,     0,     0,
+       7,     0,     0,     0,     0,     0,     0,     0,    25,     0,
+       0,     0,    26,    27,    28,    29,     0,    12,    30,     0,
+      31,    13,    14,     0,    32,     0,     0,    16,     0,    17,
+       0,    34,     0,    35,     0,     0,    18,     0,    36,    37,
+       0,     0,     0,     0,     0,     0,     0,     0,    21,    22,
+       0,     0,     0,     0,     0,    24,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    12,     0,    12,     0,     0,    10,    13,    14,    13,
-      14,     0,   244,    15,    12,     0,     0,     0,     0,     0,
-      13,    14,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    15,   343,    15,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   423,
-      15,     0,     0,     0,    12,     0,     0,     0,     0,     0,
-      13,    14,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    87,     0,    88,    89,     0,    90,    91,     0,    92,
-       0,     0,    93,     0,    94,     0,     0,     0,     0,   480,
-      15,    95,    96,    97,    98,     0,    99,   100,   101,   102,
-     103,     0,   104,     0,   105,   106,   107,     0,     0,   108,
-       0,     0,     0,     0,   109,     0,   110,   111,   112,   113,
-     114,   115,     0,   116,   117,   118,   119,   120,     0,     0,
-     121,     0,   122,     0,     0,     0,     0,   123,     0,   124,
-       0,     0,     0,   125,   126,   127,   128,   129,   130,   131,
-     132,     0,   133,     0,   134,   135,   136,   137,   138,   139,
-     140,   141,   142,   143,   144,     0,     0,     0,     0,   145,
-       0,     0,   146,     0,   147,   148,     0,     0,   149,   150,
-     151,     0,     0,     0,   152,     0,   153,   154,   155,   156,
-       0,     0,   157
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,    26,    27,    28,    29,     0,     0,    30,     0,
+       0,     0,     0,     0,    32,     0,     0,     0,     0,     0,
+       0,    34,     0,    35,     0,     0,     0,     0,    36,    37,
+      95,     0,    96,    97,     0,    98,    99,     0,   100,     0,
+       0,   101,     0,   102,     0,     0,     0,     0,     0,     0,
+     103,   104,   105,   106,     0,   107,   108,   109,   110,   111,
+       0,   112,     0,   113,   114,   115,     0,     0,   116,     0,
+       0,     0,     0,   117,     0,   118,   119,   120,   121,   122,
+     123,     0,   124,   125,   126,   127,   128,     0,     0,   129,
+       0,     0,   130,     0,     0,     0,   131,   132,     0,   133,
+       0,     0,     0,   134,   135,   136,     0,   137,   138,   139,
+     140,   141,     0,   142,     0,   143,   144,   145,   146,   147,
+     148,   149,   150,     0,   151,   152,   153,     0,     0,     0,
+       0,   154,     0,     0,   155,     0,     0,   156,   157,     0,
+       0,   158,   159,   160,     0,     0,     0,   161,     0,   162,
+     163,   164,   165,     0,     0,   166
 };
 
 static const short int yycheck[] =
 {
-       2,    13,     5,     2,    71,     2,     2,   244,     2,   119,
-     210,    11,    12,   213,   214,   255,   220,   217,   222,   219,
-      26,   225,   226,   232,   224,     2,   251,    22,    83,   267,
-     400,   119,    38,   271,   272,   273,    43,   135,    77,     8,
-       9,   135,   152,    28,    47,    29,     2,     0,   502,   135,
-     504,    99,   135,   135,   279,   103,    95,   155,   258,    43,
-      12,   155,    14,   150,   152,   151,    22,    32,   151,   151,
-      77,     3,   149,     5,     6,     7,    79,   154,   126,    64,
-       3,    84,     5,     6,     7,   289,   290,   291,   292,   293,
-      75,    76,    56,    77,    58,   332,    80,    82,   135,   154,
-      84,   154,     3,     4,    11,    12,   343,   149,   478,     8,
-      62,    63,   470,   135,   151,    59,    11,    12,   149,   328,
-      64,    53,   149,   108,   482,   363,    27,   152,   113,   151,
-      53,    32,   149,   149,   201,   202,   153,   154,     3,     4,
-     149,   208,   142,   143,   153,   154,    75,   153,     3,     4,
-     137,   351,   150,    54,     3,     4,     3,     4,   149,   161,
-     162,   150,   161,   162,   152,   161,   162,   161,   162,   149,
-     374,   375,   376,   377,   378,   379,   380,   381,   382,   417,
-     112,   176,   422,   383,   161,   162,   423,   425,   191,   112,
-     149,   123,    93,     3,     4,   152,   400,     3,     4,   149,
-     123,   439,   149,   403,     3,     4,   149,   139,   140,   149,
-     142,     8,   144,   152,   115,   152,   139,   140,   150,   142,
-     150,   144,   150,   460,   227,   228,   150,   150,   231,     3,
-       4,   469,   155,   140,   141,   142,   143,   249,   150,   251,
-     444,   142,   150,   480,   139,   140,   141,   142,   143,   150,
-       3,     4,   150,   265,     3,     4,   150,   256,   150,   150,
-     256,     3,   256,   265,   153,   154,   152,   279,   280,   153,
-     154,   475,    11,    12,   478,   150,   150,   150,   280,     4,
-     150,   150,   486,   350,   150,   152,   150,   150,   150,   493,
-     293,   495,   150,   150,   150,    20,   500,    22,   150,   150,
-       8,     8,   152,    28,     8,   151,     3,    32,     5,     6,
-       7,     8,   156,   150,     8,     8,    57,     5,   154,   150,
-      45,   149,   137,   149,    49,    50,   153,   152,   151,   150,
-      55,   135,    57,   135,   156,   151,   333,   150,     3,    64,
-     151,   135,   345,   342,   151,   157,   342,     8,   342,   149,
-      75,    76,   153,   151,    70,   354,    53,    82,   151,   362,
-     362,   151,   151,   151,   367,   151,   151,   151,   151,   151,
-     151,   151,    10,   151,   441,   151,   151,   137,   149,   149,
-     149,     8,   107,   108,   109,   110,   151,   151,   113,   151,
-     151,    29,     5,   118,    32,   151,   151,   149,   149,    37,
-     125,   135,   127,     4,   151,    43,   151,   132,   133,   152,
-     154,    49,    20,   137,    52,   112,   154,     2,   468,    20,
-     341,    22,   225,   350,   339,     2,   123,    28,   207,   154,
-      22,    32,    70,    71,     2,   438,     2,    -1,    -1,    77,
-      -1,    -1,   139,   140,    45,   142,   223,   144,    49,    50,
-      -1,    11,    12,   150,    55,     3,    57,     5,     6,     7,
-       8,    -1,    -1,    64,   463,   468,   468,   463,    -1,   463,
-      -1,    -1,    -1,    -1,    75,    76,    -1,    -1,    -1,    -1,
-     118,    82,    -1,    -1,    -1,    -1,   124,   125,    -1,    -1,
-     502,    -1,   504,    -1,     3,     4,     5,     6,     7,    -1,
-     502,    -1,   504,    -1,    -1,    53,   107,   108,   109,   110,
-      -1,    20,   113,    22,    -1,    -1,   154,   118,     3,    28,
-       5,     6,     7,    32,   125,    -1,   127,    -1,    -1,    -1,
-      -1,   132,   133,    -1,    -1,    -1,    45,    -1,    -1,    -1,
-      49,    50,    11,    12,    53,    -1,    55,    -1,    57,    -1,
-      -1,    -1,    -1,   154,    -1,    64,    11,    12,    -1,    -1,
-      -1,    -1,    -1,    -1,   112,    -1,    75,    76,    53,    -1,
-      11,    12,    -1,    82,    -1,   123,   136,   137,   138,   139,
-     140,   141,   142,   143,    -1,    -1,    11,    12,    -1,    -1,
-      -1,   139,   140,    -1,   142,    -1,   144,    -1,   107,   108,
-     109,   110,   150,   112,   113,    11,    12,    -1,    -1,   118,
-      -1,    -1,    -1,    -1,   123,    -1,   125,    -1,   127,    -1,
-      -1,    -1,    -1,   132,   133,    -1,    -1,   112,    -1,    -1,
-     139,   140,    -1,   142,    -1,   144,    -1,    -1,   123,    -1,
-      -1,   150,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   139,   140,    -1,   142,    -1,   144,
-      -1,    -1,    -1,    -1,    -1,   150,    -1,   136,    -1,   138,
-     139,   140,   141,   142,   143,    -1,    -1,    -1,    -1,    -1,
-      -1,   136,   151,   138,   139,   140,   141,   142,   143,    -1,
-      -1,    -1,    -1,    -1,    -1,   136,   151,   138,   139,   140,
-     141,   142,   143,     4,    -1,    -1,    -1,    -1,    -1,    -1,
-     151,   136,   137,   138,   139,   140,   141,   142,   143,    20,
-      -1,    22,    -1,    -1,    -1,    -1,    -1,    28,    -1,    -1,
-     136,    32,   138,   139,   140,   141,   142,   143,    29,    -1,
-      -1,    32,    -1,    -1,    45,    -1,    37,    -1,    49,    50,
-      -1,    -1,    43,    -1,    55,    -1,    57,    -1,    49,    -1,
-      -1,    52,    29,    64,    -1,    32,    -1,    32,    -1,    -1,
-      37,    -1,    37,    -1,    75,    76,    43,    -1,    32,    70,
-      71,    82,    49,    37,    49,    52,    77,    52,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    49,    -1,    -1,    52,    -1,
-      -1,    -1,    -1,    70,    -1,    70,   107,   108,   109,   110,
-      77,    -1,   113,    -1,    -1,    -1,    70,   118,    32,    -1,
-      -1,    -1,    -1,    37,   125,    -1,   127,   118,    -1,    -1,
-      -1,   132,   133,   124,   125,    49,    -1,    -1,    52,    -1,
+       2,    45,     2,     2,     2,    66,    33,     2,   274,     2,
+     262,   231,   206,   207,   234,   250,   236,     4,     2,   239,
+      45,   131,   242,   131,    85,   218,    34,    92,   222,    51,
+     109,   230,   225,   280,   113,     3,     4,    40,    46,    14,
+     147,    28,     0,    30,   147,   147,    90,    63,    64,    36,
+       3,     4,    68,    40,   168,     3,     4,    60,    45,   138,
+     174,    45,   169,   173,    86,   173,    53,    35,   170,   172,
+      57,    58,    40,    60,    86,    14,    63,   171,    65,    82,
+     279,   147,   276,   147,   147,    72,   168,    35,   147,     3,
+       4,    78,   174,   105,    62,    82,   270,    84,    85,   351,
+      12,    13,    14,   168,    91,     8,   172,    10,   172,   172,
+     362,   114,   347,   172,    62,    62,    63,    64,    28,   293,
+     294,    68,   168,   126,    84,    35,   168,   114,   174,   171,
+     168,   118,   119,   120,   121,   103,   174,   124,    24,   126,
+     168,    27,   170,   130,    32,     8,    34,     3,     4,   136,
+     137,   171,   139,     3,     4,   103,   170,   144,   145,   127,
+     380,   168,    14,   188,     3,     4,   174,   173,   170,   171,
+     170,   171,   170,   171,   170,   170,   171,   170,   171,   127,
+     170,   168,   170,   377,   245,   246,   379,   174,   249,   157,
+     384,   438,   167,   168,   173,   461,   212,     3,     4,    12,
+      13,    14,   422,   171,    17,    18,     3,     4,   170,   157,
+     462,     3,     4,   170,   227,     3,     4,   230,   157,   158,
+     159,   441,   149,   171,   237,   170,   170,   240,   167,   168,
+     243,   244,   173,   170,     8,    36,     3,   281,   173,   173,
+     170,   268,   173,   155,   156,   157,   158,   159,   171,   171,
+     171,   312,   171,   171,   171,   167,   168,   509,   171,   175,
+     171,   455,   171,   290,   171,   212,   279,   280,   173,   171,
+     171,    72,   171,   275,   468,   275,   528,   275,   472,   281,
+     275,   171,   475,    84,    85,   172,   171,   171,   171,   171,
+      91,   171,   294,   306,   307,   308,   309,   310,   311,   312,
+     171,   171,   171,   155,   156,   157,   158,   159,   173,   171,
+     171,   171,   356,   172,   534,   167,   168,   511,   119,     8,
+     364,     8,   171,   124,     8,     8,     8,    65,     5,   171,
+     391,   358,   376,   168,   170,   149,   170,   174,   382,   172,
+     153,   154,   155,   156,   157,   158,   159,   173,   147,   147,
+     175,   172,   171,   352,   167,   168,   369,   172,     3,   361,
+     172,   361,   172,   361,   172,   172,   361,   172,   172,   172,
+     172,   147,   172,     8,   149,    78,   172,   172,   172,   172,
+     167,   172,   382,   172,   170,   169,   147,   400,   401,   174,
+     403,   404,   405,   406,   407,   408,   409,   410,   411,   412,
+     413,   414,   415,   416,   417,   418,   419,     4,   421,   172,
+     172,   170,   170,     3,   458,   172,     3,     8,   172,     5,
+     172,   170,   170,   467,   149,   438,   172,   172,   149,   173,
+     170,    28,    43,    30,   360,     2,   467,   379,     2,    36,
+      37,   540,    45,    40,     2,     2,   276,     3,    45,     5,
+       6,     7,     8,     9,    51,   472,    53,   180,   241,    -1,
+      57,    58,   243,    60,    -1,   467,    63,   480,    65,    -1,
+      -1,    -1,    -1,    -1,    -1,    72,    -1,    -1,    -1,    -1,
+      -1,    78,    79,    -1,    -1,    82,    -1,    84,    85,    86,
+      -1,    -1,    -1,    -1,    91,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,     4,    -1,    -1,    61,    -1,    -1,    -1,    -1,
+     523,   513,    -1,   513,    -1,   513,    -1,   114,   513,    -1,
+      -1,   118,   119,   120,   121,    -1,    28,   124,    30,   126,
+      -1,    -1,    -1,   130,    36,    -1,    -1,    -1,    40,   136,
+     137,    97,   139,    45,    -1,    -1,    -1,   144,   145,    -1,
+      -1,    53,    -1,    -1,    -1,    57,    58,    -1,    60,    -1,
+      -1,    63,    -1,    65,    -1,    -1,    -1,   123,    -1,    -1,
+      72,   168,    -1,    -1,    -1,    -1,    78,   174,    -1,   135,
+      82,    -1,    84,    85,    -1,    -1,    -1,    -1,    -1,    91,
+      -1,    -1,    -1,    -1,    -1,    -1,   152,     4,    -1,   155,
+     156,   157,    -1,    -1,   160,   161,    -1,    -1,    -1,    -1,
+      -1,    -1,   114,   169,    -1,   171,   118,   119,   120,   121,
+      -1,    28,   124,    30,   126,    -1,    -1,    -1,   130,    36,
+      -1,    -1,    -1,    40,   136,   137,    -1,   139,    45,    -1,
+      -1,    -1,   144,   145,    -1,    -1,    53,    -1,    -1,    -1,
+      57,    58,    -1,    60,    -1,    -1,    63,    -1,    65,    -1,
+      -1,    -1,    -1,    -1,    -1,    72,   168,    -1,    -1,    -1,
+      -1,    78,   174,    -1,    -1,    82,    -1,    84,    85,    -1,
+      -1,    -1,    -1,    -1,    91,    -1,    -1,    -1,    -1,    -1,
+      -1,     3,     4,     5,     6,     7,     8,     9,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   114,    -1,    -1,
+      -1,   118,   119,   120,   121,    -1,    28,   124,    30,   126,
+      -1,    -1,    -1,   130,    36,    -1,    -1,    -1,    -1,   136,
+     137,    -1,   139,    -1,    -1,    -1,    -1,   144,   145,    -1,
+      -1,    53,    -1,    -1,    -1,    57,    58,    -1,    -1,    61,
+      -1,    63,     3,    65,     5,     6,     7,     8,     9,    -1,
+      72,   168,    -1,    -1,    -1,    -1,    -1,   174,    -1,    -1,
+      -1,    -1,    84,    85,    -1,    -1,    -1,    -1,    -1,    91,
+      -1,    -1,    -1,    -1,    -1,    97,    -1,    -1,    -1,    -1,
+      -1,    -1,     3,    -1,     5,     6,     7,     8,     9,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   118,   119,   120,   121,
+      61,   123,   124,    -1,    -1,    -1,    -1,    -1,   130,    -1,
+      -1,    -1,    -1,   135,    -1,   137,    -1,   139,    -1,    -1,
+      -1,    -1,   144,   145,    -1,    -1,    -1,    -1,    -1,    -1,
+     152,    -1,    -1,   155,   156,   157,    97,    -1,   160,   161,
+      61,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   171,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   123,    -1,    -1,    -1,    12,    13,    14,    15,
+      16,    17,    18,    -1,   135,    -1,    97,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   152,    -1,    -1,   155,   156,   157,    -1,    -1,   160,
+     161,    -1,   123,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     171,    -1,    -1,    -1,   135,    -1,    -1,    -1,    -1,     4,
+      -1,    -1,    -1,    -1,    -1,    -1,    11,    -1,    -1,    -1,
+      -1,   152,    -1,    -1,   155,   156,   157,    -1,    -1,   160,
+     161,    -1,    -1,    28,    -1,    30,    -1,    -1,    -1,    -1,
+     171,    36,    37,    -1,    -1,    40,    -1,    -1,    -1,    -1,
+      45,    -1,    -1,    -1,    -1,    -1,    51,    -1,    53,    -1,
+      -1,    -1,    57,    58,    -1,    60,    -1,    -1,    63,    -1,
+      65,    -1,    -1,    -1,    -1,    -1,    -1,    72,    -1,    -1,
+      -1,    -1,    -1,    78,    79,    -1,    -1,    82,    -1,    84,
+      85,    86,    -1,    -1,    -1,    -1,    91,   153,   154,   155,
+     156,   157,   158,   159,     4,    -1,    -1,    -1,    -1,    -1,
+      -1,   167,   168,    -1,    -1,    -1,    -1,    -1,    -1,   114,
+      -1,    -1,    -1,   118,   119,   120,   121,    -1,    28,   124,
+      30,   126,    -1,    -1,    -1,   130,    36,    37,    -1,    -1,
+      40,   136,   137,    -1,   139,    45,    -1,    -1,    -1,   144,
+     145,    51,    -1,    53,    -1,    -1,    -1,    57,    58,    -1,
+      60,    -1,    -1,    63,    -1,    65,    -1,    -1,    -1,    -1,
+      -1,    -1,    72,   168,    -1,    -1,    -1,    -1,    78,     4,
+      -1,    -1,    82,    -1,    84,    85,    86,    -1,    -1,    -1,
+      -1,    91,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    28,    -1,    30,    -1,    -1,    -1,    -1,
+      -1,    36,    -1,    -1,   114,    40,    -1,    -1,   118,   119,
+     120,   121,     4,    -1,   124,    -1,   126,    -1,    53,    -1,
+     130,    -1,    57,    58,    -1,    60,   136,   137,    63,   139,
+      65,    -1,    -1,    -1,   144,   145,    28,    72,    30,    -1,
+      -1,    -1,    -1,    -1,    36,    -1,    -1,    82,    40,    84,
+      85,    -1,    -1,    -1,    -1,    -1,    91,    -1,   168,    -1,
+      -1,    53,    -1,    -1,    -1,    57,    58,    -1,    60,    -1,
+      -1,    63,    -1,    65,    -1,    -1,    -1,    -1,    -1,   114,
+      72,    -1,    -1,   118,   119,   120,   121,    -1,    -1,   124,
+      82,   126,    84,    85,    -1,   130,    -1,    -1,    -1,    91,
+      -1,    -1,   137,    -1,   139,    -1,    -1,    -1,    -1,   144,
+     145,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+      -1,    -1,   114,    -1,    -1,    -1,   118,   119,   120,   121,
+      -1,    -1,   124,   168,   126,    -1,    -1,    -1,   130,    -1,
+      -1,    -1,    -1,    -1,    -1,   137,    -1,   139,    -1,    -1,
+      -1,    -1,   144,   145,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   168,    12,    13,    14,
+      15,    16,    17,    18,    19,    20,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   148,    -1,   150,
+     151,   152,   153,   154,   155,   156,   157,   158,   159,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   167,   168,    -1,    -1,
+      -1,   172,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     148,    -1,   150,   151,   152,   153,   154,   155,   156,   157,
+     158,   159,    12,    13,    14,    15,    16,    17,    18,   167,
+     168,    -1,    -1,   148,   172,   150,   151,   152,   153,   154,
+     155,   156,   157,   158,   159,    12,    13,    14,    15,    16,
+      17,    18,   167,   168,    -1,    -1,   148,   172,   150,   151,
+     152,   153,   154,   155,   156,   157,   158,   159,    12,    13,
+      14,    15,    16,    17,    18,   167,   168,   169,   148,   149,
+     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   167,   168,    12,
+      13,    14,    15,    16,    17,    18,    -1,    20,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   148,    -1,
+     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   167,   168,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   167,   168,    -1,
+      -1,    -1,    -1,    -1,   151,   152,   153,   154,   155,   156,
+     157,   158,   159,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     167,   168,    -1,    -1,    -1,    -1,    -1,    -1,   152,   153,
+     154,   155,   156,   157,   158,   159,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   167,   168,     4,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   150,   151,   152,
+     153,   154,   155,   156,   157,   158,   159,    -1,    -1,    28,
+      -1,    30,    -1,    -1,   167,   168,    -1,    36,    37,    -1,
+      -1,    40,    -1,    -1,    -1,    -1,    -1,    -1,     4,    -1,
+      -1,    -1,    51,    -1,    53,    -1,    -1,    -1,    57,    58,
+      -1,    60,    -1,    -1,    63,    -1,    65,    -1,    -1,    -1,
+      -1,    -1,    28,    72,    30,    -1,    -1,    -1,    -1,    -1,
+      36,    -1,    -1,    82,    40,    84,    85,    86,    -1,    -1,
+      89,    -1,    91,    -1,    93,    -1,    -1,    53,    -1,    -1,
+      -1,    57,    58,    -1,    60,    -1,    -1,    63,    -1,    65,
+      -1,    -1,    -1,    -1,    -1,   114,    72,    -1,     4,   118,
+     119,   120,   121,    -1,    -1,   124,    82,   126,    84,    85,
+      -1,   130,    -1,    -1,    -1,    91,    -1,    -1,   137,    -1,
+     139,    -1,    28,    -1,    30,   144,   145,    -1,    -1,    -1,
+      36,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   114,    -1,
+      -1,    -1,   118,   119,   120,   121,    -1,    53,   124,    -1,
+     126,    57,    58,    -1,   130,    -1,    -1,    63,    -1,    65,
+      -1,   137,    -1,   139,    -1,    -1,    72,    -1,   144,   145,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    84,    85,
+      -1,    -1,    -1,    -1,    -1,    91,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   118,    -1,   118,    -1,    -1,    70,   124,   125,   124,
-     125,    -1,   153,   154,   118,    -1,    -1,    -1,    -1,    -1,
-     124,   125,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   154,   153,   154,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   153,
-     154,    -1,    -1,    -1,   118,    -1,    -1,    -1,    -1,    -1,
-     124,   125,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    13,    -1,    15,    16,    -1,    18,    19,    -1,    21,
-      -1,    -1,    24,    -1,    26,    -1,    -1,    -1,    -1,   153,
-     154,    33,    34,    35,    36,    -1,    38,    39,    40,    41,
-      42,    -1,    44,    -1,    46,    47,    48,    -1,    -1,    51,
-      -1,    -1,    -1,    -1,    56,    -1,    58,    59,    60,    61,
-      62,    63,    -1,    65,    66,    67,    68,    69,    -1,    -1,
-      72,    -1,    74,    -1,    -1,    -1,    -1,    79,    -1,    81,
-      -1,    -1,    -1,    85,    86,    87,    88,    89,    90,    91,
-      92,    -1,    94,    -1,    96,    97,    98,    99,   100,   101,
-     102,   103,   104,   105,   106,    -1,    -1,    -1,    -1,   111,
-      -1,    -1,   114,    -1,   116,   117,    -1,    -1,   120,   121,
-     122,    -1,    -1,    -1,   126,    -1,   128,   129,   130,   131,
-      -1,    -1,   134
+      -1,    -1,   118,   119,   120,   121,    -1,    -1,   124,    -1,
+      -1,    -1,    -1,    -1,   130,    -1,    -1,    -1,    -1,    -1,
+      -1,   137,    -1,   139,    -1,    -1,    -1,    -1,   144,   145,
+      21,    -1,    23,    24,    -1,    26,    27,    -1,    29,    -1,
+      -1,    32,    -1,    34,    -1,    -1,    -1,    -1,    -1,    -1,
+      41,    42,    43,    44,    -1,    46,    47,    48,    49,    50,
+      -1,    52,    -1,    54,    55,    56,    -1,    -1,    59,    -1,
+      -1,    -1,    -1,    64,    -1,    66,    67,    68,    69,    70,
+      71,    -1,    73,    74,    75,    76,    77,    -1,    -1,    80,
+      -1,    -1,    83,    -1,    -1,    -1,    87,    88,    -1,    90,
+      -1,    -1,    -1,    94,    95,    96,    -1,    98,    99,   100,
+     101,   102,    -1,   104,    -1,   106,   107,   108,   109,   110,
+     111,   112,   113,    -1,   115,   116,   117,    -1,    -1,    -1,
+      -1,   122,    -1,    -1,   125,    -1,    -1,   128,   129,    -1,
+      -1,   132,   133,   134,    -1,    -1,    -1,   138,    -1,   140,
+     141,   142,   143,    -1,    -1,   146
 };
 
 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
    symbol of state STATE-NUM.  */
-static const unsigned char yystos[] =
+static const unsigned short int yystos[] =
 {
-       0,   159,   160,     0,    29,    32,    37,    43,    49,    52,
-      70,    77,   118,   124,   125,   154,   164,   165,   166,   167,
-     170,   171,   179,   187,   191,   197,   208,   209,   210,   213,
-     214,   217,   219,   220,   221,   222,   224,   225,   231,   233,
-     234,     3,     4,     4,    20,    22,    28,    32,    45,    49,
-      50,    55,    57,    64,    75,    76,    82,   107,   108,   109,
-     110,   113,   118,   125,   127,   132,   133,   191,   205,   207,
-     231,   232,   234,   150,     3,     4,     3,     4,   203,    32,
-       8,     3,     4,   203,   178,   179,   203,    13,    15,    16,
-      18,    19,    21,    24,    26,    33,    34,    35,    36,    38,
-      39,    40,    41,    42,    44,    46,    47,    48,    51,    56,
-      58,    59,    60,    61,    62,    63,    65,    66,    67,    68,
-      69,    72,    74,    79,    81,    85,    86,    87,    88,    89,
-      90,    91,    92,    94,    96,    97,    98,    99,   100,   101,
-     102,   103,   104,   105,   106,   111,   114,   116,   117,   120,
-     121,   122,   126,   128,   129,   130,   131,   134,   180,   182,
-     230,   161,   161,    80,    84,   169,   208,   213,   219,   223,
-     149,   149,   149,   149,   152,   149,   152,   149,   163,   149,
-     137,   218,   152,   149,   149,   149,   232,     3,    75,   206,
-     206,   150,   206,   207,     3,     3,   207,     3,     4,   204,
-       8,   152,   232,   149,   152,   232,   119,   152,   150,   150,
-     150,   150,   150,   150,   150,   150,   150,   150,   150,   150,
-     150,   150,   150,   150,   150,   150,   150,   150,   150,   150,
-     150,   150,   135,   155,    10,    71,   164,   168,   171,   208,
-     210,   221,   222,   225,   153,     3,     3,     4,   152,   211,
-      95,   215,   219,     3,     4,   152,   162,   232,   156,   151,
-     188,   189,   190,   204,   204,   198,    27,    32,    54,    93,
-     115,   142,   150,   184,   204,   226,   227,   228,   229,   150,
-     198,   204,     3,     5,     6,     7,    53,   112,   123,   139,
-     140,   142,   144,   150,   194,   195,   196,     8,   196,     8,
-       8,   181,     8,   196,   196,     8,     8,   196,     8,   196,
-     194,    57,   192,   193,   194,   230,   196,   192,   194,   232,
-     232,     8,     9,   183,     5,   235,   232,   182,   154,   150,
-     149,   163,   153,   178,   212,   137,    83,   178,   200,   216,
-     149,   152,   162,   153,   164,   178,   201,   151,   196,   153,
-     135,   156,   149,   153,   178,   179,   199,   200,   226,   226,
-     226,   226,   150,   135,   200,   153,   151,   150,   194,   194,
-     194,   194,   194,   232,    11,    12,   136,   138,   139,   140,
-     141,   142,   143,   135,   151,   151,   151,   151,   135,   151,
-     151,   151,   151,   151,   151,   151,   151,   151,   151,     3,
-     135,   151,   151,   135,   151,   151,   151,   151,   151,   157,
-     151,   151,   182,     8,   163,   222,   137,   232,   149,   153,
-     201,   153,   167,   153,   163,   232,   149,   190,   196,   234,
-     149,   149,   151,   132,   172,   173,   174,   175,   179,   232,
-     226,   151,   232,   151,   151,   194,   194,   194,   194,   194,
-     194,   194,   194,   194,   196,     8,   151,   193,   196,     5,
-     151,   226,   149,   162,   163,   226,   149,   151,   135,   232,
-     226,   202,   204,   151,   194,   137,   151,   163,   154,   176,
-     153,   175,   226,   176,   152,   194,   142,   177,   193,   163,
-     176,   185,   155,   135,   155,    26,    38,   153,   186,   194,
-     154,   194,   137,   194,   137,   199,   199
+       0,   177,   178,     0,     4,    28,    30,    36,    37,    40,
+      45,    51,    53,    57,    58,    60,    63,    65,    72,    78,
+      82,    84,    85,    86,    91,   114,   118,   119,   120,   121,
+     124,   126,   130,   136,   137,   139,   144,   145,   168,   182,
+     183,   184,   185,   188,   189,   196,   207,   221,   225,   227,
+     228,   229,   230,   233,   234,   237,   239,   240,   241,   242,
+     244,   245,   246,   247,   248,   250,   252,   258,   259,   260,
+     261,     3,     4,   171,     3,     4,     3,     4,   223,    84,
+     226,     8,     3,     4,   226,   171,   226,   227,     3,   223,
+     195,   196,     3,   223,   227,    21,    23,    24,    26,    27,
+      29,    32,    34,    41,    42,    43,    44,    46,    47,    48,
+      49,    50,    52,    54,    55,    56,    59,    64,    66,    67,
+      68,    69,    70,    71,    73,    74,    75,    76,    77,    80,
+      83,    87,    88,    90,    94,    95,    96,    98,    99,   100,
+     101,   102,   104,   106,   107,   108,   109,   110,   111,   112,
+     113,   115,   116,   117,   122,   125,   128,   129,   132,   133,
+     134,   138,   140,   141,   142,   143,   146,   197,   199,   257,
+     179,   179,    89,    93,   187,   207,   228,   233,   239,   243,
+     250,   258,   261,   170,   170,   170,   173,   170,   173,   170,
+     181,   170,   149,   238,   173,   251,   252,   251,   251,     3,
+       4,    35,    62,   103,   127,   157,   171,   201,   224,   253,
+     254,   256,   259,   170,   251,   170,   170,     8,   173,   170,
+     259,   173,   250,   131,   173,   171,   171,   171,   171,   171,
+     171,   171,   171,   171,   171,   171,   171,   171,   171,   171,
+     171,   171,   171,   171,   171,   171,   171,   171,   171,   171,
+     147,   169,    11,    79,   182,   186,   189,   228,   230,   241,
+     242,   245,   174,     3,     3,     4,   173,   256,   231,   105,
+     235,   239,     3,     4,   173,   180,   249,   253,   253,   175,
+     168,   171,   194,   251,   172,   204,   205,   206,   224,   172,
+     214,   253,   255,   171,   217,   224,     3,     5,     6,     7,
+       8,     9,    61,    97,   123,   135,   152,   155,   156,   157,
+     160,   161,   171,   210,   211,   212,   210,   213,     8,     8,
+     198,   213,   212,     8,     8,   212,     8,   212,   210,    65,
+     212,   208,   209,   210,   257,   212,   208,   210,   259,   259,
+       8,    10,   200,     5,   262,   259,   199,   168,   171,   170,
+     181,   174,   195,   232,   149,    92,   195,   219,   236,   170,
+     173,   180,   174,   182,   196,   248,   253,   172,   213,   157,
+     209,   144,   190,   191,   192,   193,   196,   250,   174,   147,
+     175,   174,   195,   215,   147,   219,   174,   196,   216,   219,
+     172,   171,   210,   210,   210,   210,   210,   210,   210,   259,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,   148,
+     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
+     167,   168,   147,   172,   172,   172,   147,   172,   172,   172,
+     172,   172,   172,   172,   172,   172,     3,   172,   147,   172,
+     172,   147,   172,   172,   172,   172,   172,   167,   172,   172,
+     199,     8,   181,   242,   149,   250,   170,   174,   195,   220,
+     174,   185,   174,   181,   169,   169,   172,   147,   250,   253,
+     206,   212,   250,   261,   253,   172,   170,   170,   259,   172,
+     172,   210,   210,     3,   210,   210,   210,   210,   210,   210,
+     210,   210,   210,   210,   210,   210,   210,   210,   210,   210,
+     210,     3,   210,   212,     8,   172,   209,   212,     5,   172,
+     253,   250,   170,   180,   181,   193,   253,   255,   170,   222,
+     224,   172,   210,   149,   169,   172,   181,   253,   174,   170,
+     173,   210,   181,   202,    34,    46,   174,   203,   212,   149,
+     149,   170,   218,   219,   218,   170
 };
 
 #define yyerrok                (yyerrstatus = 0)
@@ -2155,42 +2450,42 @@ yyreduce:
   switch (yyn)
     {
         case 2:
-#line 304 "parser.y"
+#line 349 "parser.y"
     { fix_incomplete();
-                                                 check_all_user_types((yyvsp[0].ifref_list));
-                                                 write_proxies((yyvsp[0].ifref_list));
-                                                 write_client((yyvsp[0].ifref_list));
-                                                 write_server((yyvsp[0].ifref_list));
-                                                 write_dlldata((yyvsp[0].ifref_list));
+                                                 check_all_user_types((yyvsp[0].stmt_list));
+                                                 write_proxies((yyvsp[0].stmt_list));
+                                                 write_client((yyvsp[0].stmt_list));
+                                                 write_server((yyvsp[0].stmt_list));
+                                                 write_dlldata((yyvsp[0].stmt_list));
                                                ;}
     break;
 
   case 3:
-#line 313 "parser.y"
-    { (yyval.ifref_list) = NULL; ;}
+#line 358 "parser.y"
+    { (yyval.stmt_list) = NULL; ;}
     break;
 
   case 4:
-#line 314 "parser.y"
-    { (yyval.ifref_list) = (yyvsp[-1].ifref_list); ;}
+#line 359 "parser.y"
+    { (yyval.stmt_list) = (yyvsp[-1].stmt_list); ;}
     break;
 
   case 5:
-#line 315 "parser.y"
-    { (yyval.ifref_list) = append_ifref( (yyvsp[-1].ifref_list), make_ifref((yyvsp[0].type)) ); ;}
+#line 360 "parser.y"
+    { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_type_decl((yyvsp[0].type))); ;}
     break;
 
   case 6:
-#line 316 "parser.y"
-    { (yyval.ifref_list) = (yyvsp[-2].ifref_list);
+#line 361 "parser.y"
+    { (yyval.stmt_list) = (yyvsp[-2].stmt_list);
                                                  reg_type((yyvsp[-1].type), (yyvsp[-1].type)->name, 0);
                                                  if (!parse_only && do_header) write_coclass_forward((yyvsp[-1].type));
                                                ;}
     break;
 
   case 7:
-#line 320 "parser.y"
-    { (yyval.ifref_list) = (yyvsp[-1].ifref_list);
+#line 365 "parser.y"
+    { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_type_decl((yyvsp[0].type)));
                                                  add_typelib_entry((yyvsp[0].type));
                                                  reg_type((yyvsp[0].type), (yyvsp[0].type)->name, 0);
                                                  if (!parse_only && do_header) write_coclass_forward((yyvsp[0].type));
@@ -2198,115 +2493,127 @@ yyreduce:
     break;
 
   case 8:
-#line 325 "parser.y"
-    { (yyval.ifref_list) = (yyvsp[-1].ifref_list); add_typelib_entry((yyvsp[0].type)); ;}
+#line 370 "parser.y"
+    { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_module((yyvsp[0].type)));
+                                                 add_typelib_entry((yyvsp[0].type));
+                                               ;}
     break;
 
   case 9:
-#line 326 "parser.y"
-    { (yyval.ifref_list) = (yyvsp[-1].ifref_list); ;}
+#line 373 "parser.y"
+    { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_library((yyvsp[0].typelib))); ;}
     break;
 
   case 10:
-#line 327 "parser.y"
-    { (yyval.ifref_list) = (yyvsp[-1].ifref_list); ;}
+#line 374 "parser.y"
+    { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), (yyvsp[0].statement)); ;}
     break;
 
   case 11:
-#line 330 "parser.y"
-    {;}
+#line 377 "parser.y"
+    { (yyval.stmt_list) = NULL; ;}
     break;
 
   case 12:
-#line 331 "parser.y"
-    { if (!parse_only) add_typelib_entry((yyvsp[0].type)); ;}
+#line 378 "parser.y"
+    { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_reference((yyvsp[0].type))); if (!parse_only) add_typelib_entry((yyvsp[0].type)); ;}
     break;
 
   case 13:
-#line 332 "parser.y"
-    { if (!parse_only) add_typelib_entry((yyvsp[0].type)); ;}
+#line 379 "parser.y"
+    { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_type_decl((yyvsp[0].type))); if (!parse_only) add_typelib_entry((yyvsp[0].type)); ;}
     break;
 
   case 14:
-#line 333 "parser.y"
-    { reg_type((yyvsp[-1].type), (yyvsp[-1].type)->name, 0); if (!parse_only && do_header) write_coclass_forward((yyvsp[-1].type)); ;}
+#line 380 "parser.y"
+    { (yyval.stmt_list) = (yyvsp[-2].stmt_list); reg_type((yyvsp[-1].type), (yyvsp[-1].type)->name, 0); if (!parse_only && do_header) write_coclass_forward((yyvsp[-1].type)); ;}
     break;
 
   case 15:
-#line 334 "parser.y"
-    { if (!parse_only) add_typelib_entry((yyvsp[0].type));
+#line 381 "parser.y"
+    { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_type_decl((yyvsp[0].type)));
+                                                 if (!parse_only) add_typelib_entry((yyvsp[0].type));
                                                  reg_type((yyvsp[0].type), (yyvsp[0].type)->name, 0);
                                                  if (!parse_only && do_header) write_coclass_forward((yyvsp[0].type));
                                                ;}
     break;
 
   case 16:
-#line 338 "parser.y"
-    { if (!parse_only) add_typelib_entry((yyvsp[0].type)); ;}
+#line 386 "parser.y"
+    { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_module((yyvsp[0].type))); if (!parse_only) add_typelib_entry((yyvsp[0].type)); ;}
     break;
 
   case 17:
-#line 339 "parser.y"
-    {;}
+#line 387 "parser.y"
+    { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), (yyvsp[0].statement)); ;}
     break;
 
   case 18:
-#line 340 "parser.y"
-    {;}
+#line 388 "parser.y"
+    { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_importlib((yyvsp[0].str))); ;}
     break;
 
   case 19:
-#line 341 "parser.y"
-    {;}
+#line 389 "parser.y"
+    { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_library((yyvsp[0].typelib))); ;}
     break;
 
   case 20:
-#line 344 "parser.y"
+#line 392 "parser.y"
     { (yyval.func_list) = NULL; ;}
     break;
 
   case 21:
-#line 345 "parser.y"
-    { (yyval.func_list) = append_func( (yyvsp[-2].func_list), (yyvsp[-1].func) ); ;}
+#line 393 "parser.y"
+    { (yyval.func_list) = append_func_from_statement( (yyvsp[-1].func_list), (yyvsp[0].statement) ); ;}
     break;
 
-  case 22:
-#line 346 "parser.y"
-    { (yyval.func_list) = (yyvsp[-1].func_list); ;}
+  case 24:
+#line 401 "parser.y"
+    { (yyval.statement) = make_statement_cppquote((yyvsp[0].str)); ;}
     break;
 
   case 25:
-#line 353 "parser.y"
-    { if (!parse_only && do_header) { write_constdef((yyvsp[-1].var)); } ;}
+#line 402 "parser.y"
+    { (yyval.statement) = make_statement_type_decl((yyvsp[-1].type));
+                                                 if (!parse_only && do_header) {
+                                                   write_type_def_or_decl(header, (yyvsp[-1].type), FALSE, NULL);
+                                                   fprintf(header, ";\n\n");
+                                                 }
+                                               ;}
     break;
 
   case 26:
-#line 354 "parser.y"
-    {;}
+#line 408 "parser.y"
+    { (yyval.statement) = make_statement_declaration((yyvsp[-1].var));
+                                                 if (!parse_only && do_header) write_declaration((yyvsp[-1].var), is_in_interface);
+                                               ;}
     break;
 
   case 27:
-#line 355 "parser.y"
-    { if (!parse_only && do_header) {
+#line 411 "parser.y"
+    { (yyval.statement) = make_statement_import((yyvsp[0].str)); ;}
+    break;
+
+  case 28:
+#line 412 "parser.y"
+    { (yyval.statement) = make_statement_type_decl((yyvsp[-1].type));
+                                                 if (!parse_only && do_header) {
                                                    write_type_def_or_decl(header, (yyvsp[-1].type), FALSE, NULL);
                                                    fprintf(header, ";\n\n");
                                                  }
                                                ;}
     break;
 
-  case 28:
-#line 360 "parser.y"
-    { if (!parse_only && do_header) { write_externdef((yyvsp[-1].var)); } ;}
-    break;
-
   case 29:
-#line 361 "parser.y"
-    {;}
+#line 418 "parser.y"
+    { (yyval.statement) = (yyvsp[-1].statement); ;}
     break;
 
   case 30:
-#line 362 "parser.y"
-    { if (!parse_only && do_header) {
+#line 419 "parser.y"
+    { (yyval.statement) = make_statement_type_decl((yyvsp[-1].type));
+                                                 if (!parse_only && do_header) {
                                                    write_type_def_or_decl(header, (yyvsp[-1].type), FALSE, NULL);
                                                    fprintf(header, ";\n\n");
                                                  }
@@ -2314,610 +2621,577 @@ yyreduce:
     break;
 
   case 31:
-#line 367 "parser.y"
-    {;}
+#line 427 "parser.y"
+    { (yyval.str) = (yyvsp[-1].str); if (!parse_only && do_header) fprintf(header, "%s\n", (yyvsp[-1].str)); ;}
     break;
 
   case 32:
-#line 368 "parser.y"
-    { if (!parse_only && do_header) {
-                                                   write_type_def_or_decl(header, (yyvsp[-1].type), FALSE, NULL);
-                                                   fprintf(header, ";\n\n");
-                                                 }
+#line 429 "parser.y"
+    { assert(yychar == YYEMPTY);
+                                                 (yyval.import) = xmalloc(sizeof(struct _import_t));
+                                                 (yyval.import)->name = (yyvsp[-1].str);
+                                                 (yyval.import)->import_performed = do_import((yyvsp[-1].str));
+                                                 if (!(yyval.import)->import_performed) yychar = aEOF;
                                                ;}
     break;
 
   case 33:
-#line 375 "parser.y"
-    { if (!parse_only && do_header) fprintf(header, "%s\n", (yyvsp[-1].str)); ;}
+#line 437 "parser.y"
+    { (yyval.str) = (yyvsp[-2].import)->name;
+                                                 if ((yyvsp[-2].import)->import_performed) pop_import();
+                                                 free((yyvsp[-2].import));
+                                                 if (!parse_only && do_header) write_import((yyval.str));
+                                               ;}
     break;
 
   case 34:
-#line 377 "parser.y"
-    { assert(yychar == YYEMPTY);
-                                                 (yyval.num) = do_import((yyvsp[-1].str));
-                                                 if (!(yyval.num)) yychar = aEOF;
-                                               ;}
+#line 445 "parser.y"
+    { (yyval.str) = (yyvsp[-2].str); if(!parse_only) add_importlib((yyvsp[-2].str)); ;}
     break;
 
   case 35:
-#line 384 "parser.y"
-    { if ((yyvsp[-2].num)) pop_import(); ;}
-    break;
-
-  case 36:
-#line 388 "parser.y"
-    { if(!parse_only) add_importlib((yyvsp[-2].str)); ;}
-    break;
-
-  case 37:
-#line 391 "parser.y"
+#line 448 "parser.y"
     { (yyval.str) = (yyvsp[0].str); ;}
     break;
 
-  case 38:
-#line 393 "parser.y"
-    { check_library_attrs((yyvsp[-1].str), (yyvsp[-2].attr_list));
-                                                 if (!parse_only) start_typelib((yyvsp[-1].str), (yyvsp[-2].attr_list));
-                                                 if (!parse_only && do_header) write_library((yyvsp[-1].str), (yyvsp[-2].attr_list));
-                                                 if (!parse_only && do_idfile) write_libid((yyvsp[-1].str), (yyvsp[-2].attr_list));
+  case 36:
+#line 450 "parser.y"
+    { (yyval.typelib) = make_library((yyvsp[-1].str), check_library_attrs((yyvsp[-1].str), (yyvsp[-2].attr_list)));
+                                                 if (!parse_only) start_typelib((yyval.typelib));
+                                                 if (!parse_only && do_header) write_library((yyval.typelib));
+                                                 if (!parse_only && do_idfile) write_libid((yyval.typelib));
                                                  is_inside_library = TRUE;
                                                ;}
     break;
 
-  case 39:
-#line 401 "parser.y"
-    { if (!parse_only) end_typelib(); is_inside_library = FALSE; ;}
+  case 37:
+#line 458 "parser.y"
+    { (yyval.typelib) = (yyvsp[-3].typelib);
+                                                 (yyval.typelib)->stmts = (yyvsp[-2].stmt_list);
+                                                 if (!parse_only) end_typelib();
+                                                 is_inside_library = FALSE;
+                                               ;}
     break;
 
-  case 40:
-#line 404 "parser.y"
+  case 38:
+#line 465 "parser.y"
     { (yyval.var_list) = NULL; ;}
     break;
 
-  case 42:
-#line 408 "parser.y"
+  case 40:
+#line 469 "parser.y"
     { (yyval.var_list) = NULL; ;}
     break;
 
-  case 43:
-#line 411 "parser.y"
+  case 41:
+#line 472 "parser.y"
     { check_arg((yyvsp[0].var)); (yyval.var_list) = append_var( NULL, (yyvsp[0].var) ); ;}
     break;
 
-  case 44:
-#line 412 "parser.y"
+  case 42:
+#line 473 "parser.y"
     { check_arg((yyvsp[0].var)); (yyval.var_list) = append_var( (yyvsp[-2].var_list), (yyvsp[0].var)); ;}
     break;
 
-  case 46:
-#line 417 "parser.y"
-    { (yyval.var) = (yyvsp[-1].pident)->var;
-                                                 (yyval.var)->attrs = (yyvsp[-3].attr_list);
-                                                 set_type((yyval.var), (yyvsp[-2].type), (yyvsp[-1].pident), (yyvsp[0].array_dims), TRUE);
-                                                 free((yyvsp[-1].pident));
+  case 44:
+#line 478 "parser.y"
+    { (yyval.var) = (yyvsp[0].declarator)->var;
+                                                 (yyval.var)->attrs = (yyvsp[-2].attr_list);
+                                                 if ((yyvsp[-1].declspec)->stgclass != STG_NONE && (yyvsp[-1].declspec)->stgclass != STG_REGISTER)
+                                                   error_loc("invalid storage class for function parameter\n");
+                                                 set_type((yyval.var), (yyvsp[-1].declspec), (yyvsp[0].declarator), TRUE);
+                                                 free((yyvsp[0].declarator));
                                                ;}
     break;
 
-  case 47:
-#line 422 "parser.y"
-    { (yyval.var) = (yyvsp[-1].pident)->var;
-                                                 set_type((yyval.var), (yyvsp[-2].type), (yyvsp[-1].pident), (yyvsp[0].array_dims), TRUE);
-                                                 free((yyvsp[-1].pident));
+  case 45:
+#line 485 "parser.y"
+    { (yyval.var) = (yyvsp[0].declarator)->var;
+                                                 if ((yyvsp[-1].declspec)->stgclass != STG_NONE && (yyvsp[-1].declspec)->stgclass != STG_REGISTER)
+                                                   error_loc("invalid storage class for function parameter\n");
+                                                 set_type((yyval.var), (yyvsp[-1].declspec), (yyvsp[0].declarator), TRUE);
+                                                 free((yyvsp[0].declarator));
                                                ;}
     break;
 
-  case 48:
-#line 428 "parser.y"
-    { (yyval.array_dims) = NULL; ;}
+  case 46:
+#line 493 "parser.y"
+    { (yyval.expr) = (yyvsp[-1].expr); ;}
     break;
 
-  case 49:
-#line 429 "parser.y"
-    { (yyval.array_dims) = (yyvsp[-1].array_dims); ;}
+  case 47:
+#line 494 "parser.y"
+    { (yyval.expr) = make_expr(EXPR_VOID); ;}
+    break;
+
+  case 48:
+#line 497 "parser.y"
+    { (yyval.attr_list) = NULL; ;}
     break;
 
   case 50:
-#line 430 "parser.y"
-    { (yyval.array_dims) = append_array( NULL, make_expr(EXPR_VOID) ); ;}
+#line 502 "parser.y"
+    { (yyval.attr_list) = (yyvsp[-1].attr_list);
+                                                 if (!(yyval.attr_list))
+                                                   error_loc("empty attribute lists unsupported\n");
+                                               ;}
     break;
 
   case 51:
-#line 433 "parser.y"
-    { (yyval.array_dims) = append_array( NULL, (yyvsp[0].expr) ); ;}
+#line 508 "parser.y"
+    { (yyval.attr_list) = append_attr( NULL, (yyvsp[0].attr) ); ;}
     break;
 
   case 52:
-#line 434 "parser.y"
-    { (yyval.array_dims) = append_array( (yyvsp[-2].array_dims), (yyvsp[0].expr) ); ;}
+#line 509 "parser.y"
+    { (yyval.attr_list) = append_attr( (yyvsp[-2].attr_list), (yyvsp[0].attr) ); ;}
     break;
 
   case 53:
-#line 435 "parser.y"
-    { (yyval.array_dims) = append_array( (yyvsp[-3].array_dims), (yyvsp[0].expr) ); ;}
+#line 510 "parser.y"
+    { (yyval.attr_list) = append_attr( (yyvsp[-3].attr_list), (yyvsp[0].attr) ); ;}
     break;
 
   case 54:
-#line 438 "parser.y"
-    { (yyval.attr_list) = NULL; ;}
+#line 513 "parser.y"
+    { (yyval.str_list) = append_str( NULL, (yyvsp[0].str) ); ;}
+    break;
+
+  case 55:
+#line 514 "parser.y"
+    { (yyval.str_list) = append_str( (yyvsp[-2].str_list), (yyvsp[0].str) ); ;}
     break;
 
   case 56:
-#line 443 "parser.y"
-    { (yyval.attr_list) = (yyvsp[-1].attr_list);
-                                                 if (!(yyval.attr_list))
-                                                   error_loc("empty attribute lists unsupported\n");
-                                               ;}
+#line 517 "parser.y"
+    { (yyval.attr) = NULL; ;}
     break;
 
   case 57:
-#line 449 "parser.y"
-    { (yyval.attr_list) = append_attr( NULL, (yyvsp[0].attr) ); ;}
+#line 518 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_AGGREGATABLE); ;}
     break;
 
   case 58:
-#line 450 "parser.y"
-    { (yyval.attr_list) = append_attr( (yyvsp[-2].attr_list), (yyvsp[0].attr) ); ;}
+#line 519 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_APPOBJECT); ;}
     break;
 
   case 59:
-#line 451 "parser.y"
-    { (yyval.attr_list) = append_attr( (yyvsp[-3].attr_list), (yyvsp[0].attr) ); ;}
+#line 520 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_ASYNC); ;}
     break;
 
   case 60:
-#line 454 "parser.y"
-    { (yyval.str_list) = append_str( NULL, (yyvsp[0].str) ); ;}
+#line 521 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_AUTO_HANDLE); ;}
     break;
 
   case 61:
-#line 455 "parser.y"
-    { (yyval.str_list) = append_str( (yyvsp[-2].str_list), (yyvsp[0].str) ); ;}
+#line 522 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_BINDABLE); ;}
     break;
 
   case 62:
-#line 458 "parser.y"
-    { (yyval.attr) = NULL; ;}
+#line 523 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_BROADCAST); ;}
     break;
 
   case 63:
-#line 459 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_AGGREGATABLE); ;}
+#line 524 "parser.y"
+    { (yyval.attr) = make_attrp(ATTR_CALLAS, (yyvsp[-1].var)); ;}
     break;
 
   case 64:
-#line 460 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_APPOBJECT); ;}
+#line 525 "parser.y"
+    { (yyval.attr) = make_attrp(ATTR_CASE, (yyvsp[-1].expr_list)); ;}
     break;
 
   case 65:
-#line 461 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_ASYNC); ;}
+#line 526 "parser.y"
+    { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); ;}
     break;
 
   case 66:
-#line 462 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_AUTO_HANDLE); ;}
+#line 527 "parser.y"
+    { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_DONT_SERIALIZE */ ;}
     break;
 
   case 67:
-#line 463 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_BINDABLE); ;}
+#line 528 "parser.y"
+    { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_SERIALIZE */ ;}
     break;
 
   case 68:
-#line 464 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_BROADCAST); ;}
+#line 529 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_CONTROL); ;}
     break;
 
   case 69:
-#line 465 "parser.y"
-    { (yyval.attr) = make_attrp(ATTR_CALLAS, (yyvsp[-1].var)); ;}
+#line 530 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_DEFAULT); ;}
     break;
 
   case 70:
-#line 466 "parser.y"
-    { (yyval.attr) = make_attrp(ATTR_CASE, (yyvsp[-1].expr_list)); ;}
+#line 531 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_DEFAULTCOLLELEM); ;}
     break;
 
   case 71:
-#line 467 "parser.y"
-    { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); ;}
+#line 532 "parser.y"
+    { (yyval.attr) = make_attrp(ATTR_DEFAULTVALUE, (yyvsp[-1].expr)); ;}
     break;
 
   case 72:
-#line 468 "parser.y"
-    { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_DONT_SERIALIZE */ ;}
+#line 533 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_DEFAULTVTABLE); ;}
     break;
 
   case 73:
-#line 469 "parser.y"
-    { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_SERIALIZE */ ;}
+#line 534 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_DISPLAYBIND); ;}
     break;
 
   case 74:
-#line 470 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_CONTROL); ;}
+#line 535 "parser.y"
+    { (yyval.attr) = make_attrp(ATTR_DLLNAME, (yyvsp[-1].str)); ;}
     break;
 
   case 75:
-#line 471 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_DEFAULT); ;}
+#line 536 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_DUAL); ;}
     break;
 
   case 76:
-#line 472 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_DEFAULTCOLLELEM); ;}
+#line 537 "parser.y"
+    { (yyval.attr) = make_attrp(ATTR_ENDPOINT, (yyvsp[-1].str_list)); ;}
     break;
 
   case 77:
-#line 473 "parser.y"
-    { (yyval.attr) = make_attrp(ATTR_DEFAULTVALUE_EXPR, (yyvsp[-1].expr)); ;}
+#line 538 "parser.y"
+    { (yyval.attr) = make_attrp(ATTR_ENTRY, (yyvsp[-1].expr)); ;}
     break;
 
   case 78:
-#line 474 "parser.y"
-    { (yyval.attr) = make_attrp(ATTR_DEFAULTVALUE_STRING, (yyvsp[-1].str)); ;}
+#line 539 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_EXPLICIT_HANDLE); ;}
     break;
 
   case 79:
-#line 475 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_DEFAULTVTABLE); ;}
+#line 540 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_HANDLE); ;}
     break;
 
   case 80:
-#line 476 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_DISPLAYBIND); ;}
+#line 541 "parser.y"
+    { (yyval.attr) = make_attrp(ATTR_HELPCONTEXT, (yyvsp[-1].expr)); ;}
     break;
 
   case 81:
-#line 477 "parser.y"
-    { (yyval.attr) = make_attrp(ATTR_DLLNAME, (yyvsp[-1].str)); ;}
+#line 542 "parser.y"
+    { (yyval.attr) = make_attrp(ATTR_HELPFILE, (yyvsp[-1].str)); ;}
     break;
 
   case 82:
-#line 478 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_DUAL); ;}
+#line 543 "parser.y"
+    { (yyval.attr) = make_attrp(ATTR_HELPSTRING, (yyvsp[-1].str)); ;}
     break;
 
   case 83:
-#line 479 "parser.y"
-    { (yyval.attr) = make_attrp(ATTR_ENDPOINT, (yyvsp[-1].str_list)); ;}
+#line 544 "parser.y"
+    { (yyval.attr) = make_attrp(ATTR_HELPSTRINGCONTEXT, (yyvsp[-1].expr)); ;}
     break;
 
   case 84:
-#line 480 "parser.y"
-    { (yyval.attr) = make_attrp(ATTR_ENTRY_STRING, (yyvsp[-1].str)); ;}
+#line 545 "parser.y"
+    { (yyval.attr) = make_attrp(ATTR_HELPSTRINGDLL, (yyvsp[-1].str)); ;}
     break;
 
   case 85:
-#line 481 "parser.y"
-    { (yyval.attr) = make_attrp(ATTR_ENTRY_ORDINAL, (yyvsp[-1].expr)); ;}
+#line 546 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_HIDDEN); ;}
     break;
 
   case 86:
-#line 482 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_EXPLICIT_HANDLE); ;}
+#line 547 "parser.y"
+    { (yyval.attr) = make_attrp(ATTR_ID, (yyvsp[-1].expr)); ;}
     break;
 
   case 87:
-#line 483 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_HANDLE); ;}
+#line 548 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_IDEMPOTENT); ;}
     break;
 
   case 88:
-#line 484 "parser.y"
-    { (yyval.attr) = make_attrp(ATTR_HELPCONTEXT, (yyvsp[-1].expr)); ;}
+#line 549 "parser.y"
+    { (yyval.attr) = make_attrp(ATTR_IIDIS, (yyvsp[-1].expr)); ;}
     break;
 
   case 89:
-#line 485 "parser.y"
-    { (yyval.attr) = make_attrp(ATTR_HELPFILE, (yyvsp[-1].str)); ;}
+#line 550 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_IMMEDIATEBIND); ;}
     break;
 
   case 90:
-#line 486 "parser.y"
-    { (yyval.attr) = make_attrp(ATTR_HELPSTRING, (yyvsp[-1].str)); ;}
+#line 551 "parser.y"
+    { (yyval.attr) = make_attrp(ATTR_IMPLICIT_HANDLE, (yyvsp[-1].str)); ;}
     break;
 
   case 91:
-#line 487 "parser.y"
-    { (yyval.attr) = make_attrp(ATTR_HELPSTRINGCONTEXT, (yyvsp[-1].expr)); ;}
+#line 552 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_IN); ;}
     break;
 
   case 92:
-#line 488 "parser.y"
-    { (yyval.attr) = make_attrp(ATTR_HELPSTRINGDLL, (yyvsp[-1].str)); ;}
+#line 553 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_INPUTSYNC); ;}
     break;
 
   case 93:
-#line 489 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_HIDDEN); ;}
+#line 554 "parser.y"
+    { (yyval.attr) = make_attrp(ATTR_LENGTHIS, (yyvsp[-1].expr_list)); ;}
     break;
 
   case 94:
-#line 490 "parser.y"
-    { (yyval.attr) = make_attrp(ATTR_ID, (yyvsp[-1].expr)); ;}
+#line 555 "parser.y"
+    { (yyval.attr) = make_attrp(ATTR_LIBLCID, (yyvsp[-1].expr)); ;}
     break;
 
   case 95:
-#line 491 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_IDEMPOTENT); ;}
+#line 556 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_LOCAL); ;}
     break;
 
   case 96:
-#line 492 "parser.y"
-    { (yyval.attr) = make_attrp(ATTR_IIDIS, (yyvsp[-1].expr)); ;}
+#line 557 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_NONBROWSABLE); ;}
     break;
 
   case 97:
-#line 493 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_IMMEDIATEBIND); ;}
+#line 558 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_NONCREATABLE); ;}
     break;
 
   case 98:
-#line 494 "parser.y"
-    { (yyval.attr) = make_attrp(ATTR_IMPLICIT_HANDLE, (yyvsp[-1].str)); ;}
+#line 559 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_NONEXTENSIBLE); ;}
     break;
 
   case 99:
-#line 495 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_IN); ;}
+#line 560 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_OBJECT); ;}
     break;
 
   case 100:
-#line 496 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_INPUTSYNC); ;}
+#line 561 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_ODL); ;}
     break;
 
   case 101:
-#line 497 "parser.y"
-    { (yyval.attr) = make_attrp(ATTR_LENGTHIS, (yyvsp[-1].expr_list)); ;}
+#line 562 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_OLEAUTOMATION); ;}
     break;
 
   case 102:
-#line 498 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_LOCAL); ;}
+#line 563 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_OPTIONAL); ;}
     break;
 
   case 103:
-#line 499 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_NONBROWSABLE); ;}
+#line 564 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_OUT); ;}
     break;
 
   case 104:
-#line 500 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_NONCREATABLE); ;}
+#line 565 "parser.y"
+    { (yyval.attr) = make_attrv(ATTR_POINTERDEFAULT, (yyvsp[-1].num)); ;}
     break;
 
   case 105:
-#line 501 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_NONEXTENSIBLE); ;}
+#line 566 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_PROPGET); ;}
     break;
 
   case 106:
-#line 502 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_OBJECT); ;}
-    break;
-
-  case 107:
-#line 503 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_ODL); ;}
-    break;
-
-  case 108:
-#line 504 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_OLEAUTOMATION); ;}
-    break;
-
-  case 109:
-#line 505 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_OPTIONAL); ;}
-    break;
-
-  case 110:
-#line 506 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_OUT); ;}
-    break;
-
-  case 111:
-#line 507 "parser.y"
-    { (yyval.attr) = make_attrv(ATTR_POINTERDEFAULT, (yyvsp[-1].num)); ;}
-    break;
-
-  case 112:
-#line 508 "parser.y"
-    { (yyval.attr) = make_attr(ATTR_PROPGET); ;}
-    break;
-
-  case 113:
-#line 509 "parser.y"
+#line 567 "parser.y"
     { (yyval.attr) = make_attr(ATTR_PROPPUT); ;}
     break;
 
-  case 114:
-#line 510 "parser.y"
+  case 107:
+#line 568 "parser.y"
     { (yyval.attr) = make_attr(ATTR_PROPPUTREF); ;}
     break;
 
-  case 115:
-#line 511 "parser.y"
+  case 108:
+#line 569 "parser.y"
     { (yyval.attr) = make_attr(ATTR_PUBLIC); ;}
     break;
 
-  case 116:
-#line 512 "parser.y"
+  case 109:
+#line 571 "parser.y"
     { expr_list_t *list = append_expr( NULL, (yyvsp[-3].expr) );
-                                                     list = append_expr( list, (yyvsp[-1].expr) );
-                                                     (yyval.attr) = make_attrp(ATTR_RANGE, list); ;}
+                                                 list = append_expr( list, (yyvsp[-1].expr) );
+                                                 (yyval.attr) = make_attrp(ATTR_RANGE, list); ;}
     break;
 
-  case 117:
-#line 515 "parser.y"
+  case 110:
+#line 574 "parser.y"
     { (yyval.attr) = make_attr(ATTR_READONLY); ;}
     break;
 
-  case 118:
-#line 516 "parser.y"
+  case 111:
+#line 575 "parser.y"
     { (yyval.attr) = make_attr(ATTR_REQUESTEDIT); ;}
     break;
 
-  case 119:
-#line 517 "parser.y"
+  case 112:
+#line 576 "parser.y"
     { (yyval.attr) = make_attr(ATTR_RESTRICTED); ;}
     break;
 
-  case 120:
-#line 518 "parser.y"
+  case 113:
+#line 577 "parser.y"
     { (yyval.attr) = make_attr(ATTR_RETVAL); ;}
     break;
 
-  case 121:
-#line 519 "parser.y"
+  case 114:
+#line 578 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_SIZEIS, (yyvsp[-1].expr_list)); ;}
     break;
 
-  case 122:
-#line 520 "parser.y"
+  case 115:
+#line 579 "parser.y"
     { (yyval.attr) = make_attr(ATTR_SOURCE); ;}
     break;
 
-  case 123:
-#line 521 "parser.y"
+  case 116:
+#line 580 "parser.y"
     { (yyval.attr) = make_attr(ATTR_STRICTCONTEXTHANDLE); ;}
     break;
 
-  case 124:
-#line 522 "parser.y"
+  case 117:
+#line 581 "parser.y"
     { (yyval.attr) = make_attr(ATTR_STRING); ;}
     break;
 
-  case 125:
-#line 523 "parser.y"
+  case 118:
+#line 582 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_SWITCHIS, (yyvsp[-1].expr)); ;}
     break;
 
-  case 126:
-#line 524 "parser.y"
+  case 119:
+#line 583 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_SWITCHTYPE, (yyvsp[-1].type)); ;}
     break;
 
-  case 127:
-#line 525 "parser.y"
+  case 120:
+#line 584 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_TRANSMITAS, (yyvsp[-1].type)); ;}
     break;
 
-  case 128:
-#line 526 "parser.y"
+  case 121:
+#line 585 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_UUID, (yyvsp[-1].uuid)); ;}
     break;
 
-  case 129:
-#line 527 "parser.y"
+  case 122:
+#line 586 "parser.y"
     { (yyval.attr) = make_attr(ATTR_V1ENUM); ;}
     break;
 
-  case 130:
-#line 528 "parser.y"
+  case 123:
+#line 587 "parser.y"
     { (yyval.attr) = make_attr(ATTR_VARARG); ;}
     break;
 
-  case 131:
-#line 529 "parser.y"
+  case 124:
+#line 588 "parser.y"
     { (yyval.attr) = make_attrv(ATTR_VERSION, (yyvsp[-1].num)); ;}
     break;
 
-  case 132:
-#line 530 "parser.y"
+  case 125:
+#line 589 "parser.y"
     { (yyval.attr) = make_attrp(ATTR_WIREMARSHAL, (yyvsp[-1].type)); ;}
     break;
 
-  case 133:
-#line 531 "parser.y"
+  case 126:
+#line 590 "parser.y"
     { (yyval.attr) = make_attrv(ATTR_POINTERTYPE, (yyvsp[0].num)); ;}
     break;
 
-  case 135:
-#line 536 "parser.y"
+  case 128:
+#line 595 "parser.y"
     { if (!is_valid_uuid((yyvsp[0].str)))
                                                    error_loc("invalid UUID: %s\n", (yyvsp[0].str));
                                                  (yyval.uuid) = parse_uuid((yyvsp[0].str)); ;}
     break;
 
-  case 136:
-#line 541 "parser.y"
+  case 129:
+#line 600 "parser.y"
     { (yyval.str) = (yyvsp[0].str); ;}
     break;
 
-  case 137:
-#line 542 "parser.y"
+  case 130:
+#line 601 "parser.y"
     { (yyval.str) = (yyvsp[0].str); ;}
     break;
 
-  case 138:
-#line 543 "parser.y"
+  case 131:
+#line 602 "parser.y"
     { (yyval.str) = (yyvsp[0].str); ;}
     break;
 
-  case 139:
-#line 544 "parser.y"
+  case 132:
+#line 603 "parser.y"
     { (yyval.str) = (yyvsp[0].str); ;}
     break;
 
-  case 140:
-#line 547 "parser.y"
+  case 133:
+#line 606 "parser.y"
     { (yyval.var_list) = NULL; ;}
     break;
 
-  case 141:
-#line 548 "parser.y"
+  case 134:
+#line 607 "parser.y"
     { (yyval.var_list) = append_var( (yyvsp[-1].var_list), (yyvsp[0].var) ); ;}
     break;
 
-  case 142:
-#line 551 "parser.y"
+  case 135:
+#line 610 "parser.y"
     { attr_t *a = make_attrp(ATTR_CASE, append_expr( NULL, (yyvsp[-2].expr) ));
                                                  (yyval.var) = (yyvsp[0].var); if (!(yyval.var)) (yyval.var) = make_var(NULL);
                                                  (yyval.var)->attrs = append_attr( (yyval.var)->attrs, a );
                                                ;}
     break;
 
-  case 143:
-#line 555 "parser.y"
+  case 136:
+#line 614 "parser.y"
     { attr_t *a = make_attr(ATTR_DEFAULT);
                                                  (yyval.var) = (yyvsp[0].var); if (!(yyval.var)) (yyval.var) = make_var(NULL);
                                                  (yyval.var)->attrs = append_attr( (yyval.var)->attrs, a );
                                                ;}
     break;
 
-  case 144:
-#line 561 "parser.y"
-    { (yyval.var) = reg_const((yyvsp[-2].var));
-                                                 set_type((yyval.var), (yyvsp[-3].type), NULL, NULL, FALSE);
-                                                 (yyval.var)->eval = (yyvsp[0].expr);
-                                               ;}
-    break;
-
-  case 145:
-#line 567 "parser.y"
+  case 137:
+#line 620 "parser.y"
     { (yyval.var_list) = NULL; ;}
     break;
 
-  case 146:
-#line 568 "parser.y"
+  case 138:
+#line 621 "parser.y"
     { (yyval.var_list) = (yyvsp[-1].var_list); ;}
     break;
 
-  case 148:
-#line 572 "parser.y"
+  case 140:
+#line 625 "parser.y"
     { if (!(yyvsp[0].var)->eval)
                                                    (yyvsp[0].var)->eval = make_exprl(EXPR_NUM, 0 /* default for first enum entry */);
                                                   (yyval.var_list) = append_var( NULL, (yyvsp[0].var) );
                                                ;}
     break;
 
-  case 149:
-#line 576 "parser.y"
+  case 141:
+#line 629 "parser.y"
     { if (!(yyvsp[0].var)->eval)
                                                   {
                                                     var_t *last = LIST_ENTRY( list_tail((yyval.var_list)), var_t, entry );
@@ -2927,23 +3201,23 @@ yyreduce:
                                                ;}
     break;
 
-  case 150:
-#line 585 "parser.y"
+  case 142:
+#line 638 "parser.y"
     { (yyval.var) = reg_const((yyvsp[-2].var));
                                                  (yyval.var)->eval = (yyvsp[0].expr);
                                                   (yyval.var)->type = make_int(0);
                                                ;}
     break;
 
-  case 151:
-#line 589 "parser.y"
+  case 143:
+#line 642 "parser.y"
     { (yyval.var) = reg_const((yyvsp[0].var));
                                                   (yyval.var)->type = make_int(0);
                                                ;}
     break;
 
-  case 152:
-#line 594 "parser.y"
+  case 144:
+#line 647 "parser.y"
     { (yyval.type) = get_typev(RPC_FC_ENUM16, (yyvsp[-3].var), tsENUM);
                                                  (yyval.type)->kind = TKIND_ENUM;
                                                  (yyval.type)->fields_or_args = (yyvsp[-1].var_list);
@@ -2953,253 +3227,386 @@ yyreduce:
                                                ;}
     break;
 
-  case 153:
-#line 603 "parser.y"
+  case 145:
+#line 656 "parser.y"
     { (yyval.expr_list) = append_expr( NULL, (yyvsp[0].expr) ); ;}
     break;
 
-  case 154:
-#line 604 "parser.y"
+  case 146:
+#line 657 "parser.y"
     { (yyval.expr_list) = append_expr( (yyvsp[-2].expr_list), (yyvsp[0].expr) ); ;}
     break;
 
-  case 155:
-#line 617 "parser.y"
+  case 147:
+#line 670 "parser.y"
     { (yyval.expr) = make_expr(EXPR_VOID); ;}
     break;
 
-  case 157:
-#line 621 "parser.y"
+  case 149:
+#line 674 "parser.y"
     { (yyval.expr) = make_exprl(EXPR_NUM, (yyvsp[0].num)); ;}
     break;
 
-  case 158:
-#line 622 "parser.y"
+  case 150:
+#line 675 "parser.y"
     { (yyval.expr) = make_exprl(EXPR_HEXNUM, (yyvsp[0].num)); ;}
     break;
 
-  case 159:
-#line 623 "parser.y"
+  case 151:
+#line 676 "parser.y"
     { (yyval.expr) = make_exprd(EXPR_DOUBLE, (yyvsp[0].dbl)); ;}
     break;
 
-  case 160:
-#line 624 "parser.y"
+  case 152:
+#line 677 "parser.y"
     { (yyval.expr) = make_exprl(EXPR_TRUEFALSE, 0); ;}
     break;
 
-  case 161:
-#line 625 "parser.y"
+  case 153:
+#line 678 "parser.y"
+    { (yyval.expr) = make_exprl(EXPR_NUM, 0); ;}
+    break;
+
+  case 154:
+#line 679 "parser.y"
     { (yyval.expr) = make_exprl(EXPR_TRUEFALSE, 1); ;}
     break;
 
-  case 162:
-#line 626 "parser.y"
+  case 155:
+#line 680 "parser.y"
+    { (yyval.expr) = make_exprs(EXPR_STRLIT, (yyvsp[0].str)); ;}
+    break;
+
+  case 156:
+#line 681 "parser.y"
+    { (yyval.expr) = make_exprs(EXPR_WSTRLIT, (yyvsp[0].str)); ;}
+    break;
+
+  case 157:
+#line 682 "parser.y"
     { (yyval.expr) = make_exprs(EXPR_IDENTIFIER, (yyvsp[0].str)); ;}
     break;
 
-  case 163:
-#line 627 "parser.y"
+  case 158:
+#line 683 "parser.y"
     { (yyval.expr) = make_expr3(EXPR_COND, (yyvsp[-4].expr), (yyvsp[-2].expr), (yyvsp[0].expr)); ;}
     break;
 
-  case 164:
-#line 628 "parser.y"
+  case 159:
+#line 684 "parser.y"
+    { (yyval.expr) = make_expr2(EXPR_LOGOR, (yyvsp[-2].expr), (yyvsp[0].expr)); ;}
+    break;
+
+  case 160:
+#line 685 "parser.y"
+    { (yyval.expr) = make_expr2(EXPR_LOGAND, (yyvsp[-2].expr), (yyvsp[0].expr)); ;}
+    break;
+
+  case 161:
+#line 686 "parser.y"
     { (yyval.expr) = make_expr2(EXPR_OR , (yyvsp[-2].expr), (yyvsp[0].expr)); ;}
     break;
 
-  case 165:
-#line 629 "parser.y"
+  case 162:
+#line 687 "parser.y"
+    { (yyval.expr) = make_expr2(EXPR_XOR, (yyvsp[-2].expr), (yyvsp[0].expr)); ;}
+    break;
+
+  case 163:
+#line 688 "parser.y"
     { (yyval.expr) = make_expr2(EXPR_AND, (yyvsp[-2].expr), (yyvsp[0].expr)); ;}
     break;
 
+  case 164:
+#line 689 "parser.y"
+    { (yyval.expr) = make_expr2(EXPR_EQUALITY, (yyvsp[-2].expr), (yyvsp[0].expr)); ;}
+    break;
+
+  case 165:
+#line 690 "parser.y"
+    { (yyval.expr) = make_expr2(EXPR_INEQUALITY, (yyvsp[-2].expr), (yyvsp[0].expr)); ;}
+    break;
+
   case 166:
-#line 630 "parser.y"
-    { (yyval.expr) = make_expr2(EXPR_ADD, (yyvsp[-2].expr), (yyvsp[0].expr)); ;}
+#line 691 "parser.y"
+    { (yyval.expr) = make_expr2(EXPR_GTR, (yyvsp[-2].expr), (yyvsp[0].expr)); ;}
     break;
 
   case 167:
-#line 631 "parser.y"
-    { (yyval.expr) = make_expr2(EXPR_SUB, (yyvsp[-2].expr), (yyvsp[0].expr)); ;}
+#line 692 "parser.y"
+    { (yyval.expr) = make_expr2(EXPR_LESS, (yyvsp[-2].expr), (yyvsp[0].expr)); ;}
     break;
 
   case 168:
-#line 632 "parser.y"
-    { (yyval.expr) = make_expr2(EXPR_MUL, (yyvsp[-2].expr), (yyvsp[0].expr)); ;}
+#line 693 "parser.y"
+    { (yyval.expr) = make_expr2(EXPR_GTREQL, (yyvsp[-2].expr), (yyvsp[0].expr)); ;}
     break;
 
   case 169:
-#line 633 "parser.y"
-    { (yyval.expr) = make_expr2(EXPR_DIV, (yyvsp[-2].expr), (yyvsp[0].expr)); ;}
+#line 694 "parser.y"
+    { (yyval.expr) = make_expr2(EXPR_LESSEQL, (yyvsp[-2].expr), (yyvsp[0].expr)); ;}
     break;
 
   case 170:
-#line 634 "parser.y"
+#line 695 "parser.y"
     { (yyval.expr) = make_expr2(EXPR_SHL, (yyvsp[-2].expr), (yyvsp[0].expr)); ;}
     break;
 
   case 171:
-#line 635 "parser.y"
+#line 696 "parser.y"
     { (yyval.expr) = make_expr2(EXPR_SHR, (yyvsp[-2].expr), (yyvsp[0].expr)); ;}
     break;
 
   case 172:
-#line 636 "parser.y"
-    { (yyval.expr) = make_expr1(EXPR_NOT, (yyvsp[0].expr)); ;}
+#line 697 "parser.y"
+    { (yyval.expr) = make_expr2(EXPR_ADD, (yyvsp[-2].expr), (yyvsp[0].expr)); ;}
     break;
 
   case 173:
-#line 637 "parser.y"
-    { (yyval.expr) = make_expr1(EXPR_NEG, (yyvsp[0].expr)); ;}
+#line 698 "parser.y"
+    { (yyval.expr) = make_expr2(EXPR_SUB, (yyvsp[-2].expr), (yyvsp[0].expr)); ;}
     break;
 
   case 174:
-#line 638 "parser.y"
-    { (yyval.expr) = make_expr1(EXPR_ADDRESSOF, (yyvsp[0].expr)); ;}
+#line 699 "parser.y"
+    { (yyval.expr) = make_expr2(EXPR_MOD, (yyvsp[-2].expr), (yyvsp[0].expr)); ;}
     break;
 
   case 175:
-#line 639 "parser.y"
-    { (yyval.expr) = make_expr1(EXPR_PPTR, (yyvsp[0].expr)); ;}
+#line 700 "parser.y"
+    { (yyval.expr) = make_expr2(EXPR_MUL, (yyvsp[-2].expr), (yyvsp[0].expr)); ;}
     break;
 
   case 176:
-#line 640 "parser.y"
-    { (yyval.expr) = make_exprt(EXPR_CAST, (yyvsp[-2].type), (yyvsp[0].expr)); ;}
+#line 701 "parser.y"
+    { (yyval.expr) = make_expr2(EXPR_DIV, (yyvsp[-2].expr), (yyvsp[0].expr)); ;}
     break;
 
   case 177:
-#line 641 "parser.y"
-    { (yyval.expr) = make_exprt(EXPR_SIZEOF, (yyvsp[-1].type), NULL); ;}
+#line 702 "parser.y"
+    { (yyval.expr) = make_expr1(EXPR_LOGNOT, (yyvsp[0].expr)); ;}
     break;
 
   case 178:
-#line 642 "parser.y"
-    { (yyval.expr) = (yyvsp[-1].expr); ;}
+#line 703 "parser.y"
+    { (yyval.expr) = make_expr1(EXPR_NOT, (yyvsp[0].expr)); ;}
     break;
 
   case 179:
-#line 645 "parser.y"
-    { (yyval.expr_list) = append_expr( NULL, (yyvsp[0].expr) ); ;}
+#line 704 "parser.y"
+    { (yyval.expr) = make_expr1(EXPR_POS, (yyvsp[0].expr)); ;}
     break;
 
   case 180:
-#line 646 "parser.y"
-    { (yyval.expr_list) = append_expr( (yyvsp[-2].expr_list), (yyvsp[0].expr) ); ;}
+#line 705 "parser.y"
+    { (yyval.expr) = make_expr1(EXPR_NEG, (yyvsp[0].expr)); ;}
     break;
 
   case 181:
-#line 649 "parser.y"
-    { (yyval.expr) = (yyvsp[0].expr);
-                                                 if (!(yyval.expr)->is_const)
-                                                     error_loc("expression is not constant\n");
-                                               ;}
+#line 706 "parser.y"
+    { (yyval.expr) = make_expr1(EXPR_ADDRESSOF, (yyvsp[0].expr)); ;}
     break;
 
   case 182:
-#line 655 "parser.y"
-    { (yyval.var) = (yyvsp[0].var);
-                                                 set_type((yyval.var), (yyvsp[-1].type), NULL, NULL, FALSE);
-                                               ;}
+#line 707 "parser.y"
+    { (yyval.expr) = make_expr1(EXPR_PPTR, (yyvsp[0].expr)); ;}
     break;
 
   case 183:
-#line 660 "parser.y"
-    { (yyval.var_list) = NULL; ;}
+#line 708 "parser.y"
+    { (yyval.expr) = make_expr2(EXPR_MEMBER, make_expr1(EXPR_PPTR, (yyvsp[-2].expr)), make_exprs(EXPR_IDENTIFIER, (yyvsp[0].str))); ;}
     break;
 
   case 184:
-#line 661 "parser.y"
-    { (yyval.var_list) = append_var( (yyvsp[-1].var_list), (yyvsp[0].var) ); ;}
+#line 709 "parser.y"
+    { (yyval.expr) = make_expr2(EXPR_MEMBER, (yyvsp[-2].expr), make_exprs(EXPR_IDENTIFIER, (yyvsp[0].str))); ;}
     break;
 
   case 185:
-#line 664 "parser.y"
-    { (yyval.var) = (yyvsp[-1].var); ;}
+#line 710 "parser.y"
+    { (yyval.expr) = make_exprt(EXPR_CAST, (yyvsp[-2].type), (yyvsp[0].expr)); ;}
     break;
 
   case 186:
-#line 665 "parser.y"
-    { (yyval.var) = make_var(NULL); (yyval.var)->type = (yyvsp[-1].type); (yyval.var)->attrs = (yyvsp[-2].attr_list); ;}
+#line 711 "parser.y"
+    { (yyval.expr) = make_exprt(EXPR_SIZEOF, (yyvsp[-1].type), NULL); ;}
     break;
 
   case 187:
-#line 666 "parser.y"
-    { (yyval.var) = make_var(NULL); (yyval.var)->attrs = (yyvsp[-1].attr_list); ;}
+#line 712 "parser.y"
+    { (yyval.expr) = make_expr2(EXPR_ARRAY, (yyvsp[-3].expr), (yyvsp[-1].expr)); ;}
     break;
 
   case 188:
-#line 667 "parser.y"
-    { (yyval.var) = NULL; ;}
+#line 713 "parser.y"
+    { (yyval.expr) = (yyvsp[-1].expr); ;}
     break;
 
   case 189:
-#line 670 "parser.y"
-    { (yyval.var) = (yyvsp[-1].pident)->var;
-                                                 (yyval.var)->attrs = check_field_attrs((yyval.var)->name, (yyvsp[-3].attr_list));
-                                                 set_type((yyval.var), (yyvsp[-2].type), (yyvsp[-1].pident), (yyvsp[0].array_dims), FALSE);
-                                                 free((yyvsp[-1].pident));
+#line 716 "parser.y"
+    { (yyval.expr_list) = append_expr( NULL, (yyvsp[0].expr) ); ;}
+    break;
+
+  case 190:
+#line 717 "parser.y"
+    { (yyval.expr_list) = append_expr( (yyvsp[-2].expr_list), (yyvsp[0].expr) ); ;}
+    break;
+
+  case 191:
+#line 720 "parser.y"
+    { (yyval.expr) = (yyvsp[0].expr);
+                                                 if (!(yyval.expr)->is_const)
+                                                     error_loc("expression is not an integer constant\n");
+                                               ;}
+    break;
+
+  case 192:
+#line 726 "parser.y"
+    { (yyval.expr) = (yyvsp[0].expr);
+                                                 if (!(yyval.expr)->is_const && (yyval.expr)->type != EXPR_STRLIT && (yyval.expr)->type != EXPR_WSTRLIT)
+                                                     error_loc("expression is not constant\n");
+                                               ;}
+    break;
+
+  case 193:
+#line 732 "parser.y"
+    { (yyval.var_list) = NULL; ;}
+    break;
+
+  case 194:
+#line 733 "parser.y"
+    { (yyval.var_list) = append_var_list((yyvsp[-1].var_list), (yyvsp[0].var_list)); ;}
+    break;
+
+  case 195:
+#line 737 "parser.y"
+    { const char *first = LIST_ENTRY(list_head((yyvsp[-1].declarator_list)), declarator_t, entry)->var->name;
+                                                 check_field_attrs(first, (yyvsp[-3].attr_list));
+                                                 (yyval.var_list) = set_var_types((yyvsp[-3].attr_list), (yyvsp[-2].declspec), (yyvsp[-1].declarator_list));
+                                               ;}
+    break;
+
+  case 196:
+#line 741 "parser.y"
+    { var_t *v = make_var(NULL);
+                                                 v->type = (yyvsp[-1].type); v->attrs = (yyvsp[-2].attr_list);
+                                                 (yyval.var_list) = append_var(NULL, v);
+                                               ;}
+    break;
+
+  case 197:
+#line 748 "parser.y"
+    { (yyval.var) = (yyvsp[-1].var); ;}
+    break;
+
+  case 198:
+#line 749 "parser.y"
+    { (yyval.var) = make_var(NULL); (yyval.var)->attrs = (yyvsp[-1].attr_list); ;}
+    break;
+
+  case 199:
+#line 752 "parser.y"
+    { (yyval.var_list) = NULL; ;}
+    break;
+
+  case 200:
+#line 753 "parser.y"
+    { (yyval.var_list) = append_var( (yyvsp[-1].var_list), (yyvsp[0].var) ); ;}
+    break;
+
+  case 201:
+#line 757 "parser.y"
+    { (yyval.var) = (yyvsp[-1].var); ;}
+    break;
+
+  case 202:
+#line 758 "parser.y"
+    { (yyval.var) = NULL; ;}
+    break;
+
+  case 203:
+#line 761 "parser.y"
+    { (yyval.var) = (yyvsp[0].declarator)->var;
+                                                 (yyval.var)->attrs = check_field_attrs((yyval.var)->name, (yyvsp[-2].attr_list));
+                                                 set_type((yyval.var), (yyvsp[-1].declspec), (yyvsp[0].declarator), FALSE);
+                                                 free((yyvsp[0].declarator));
+                                               ;}
+    break;
+
+  case 204:
+#line 769 "parser.y"
+    { var_t *v = (yyvsp[0].declarator)->var;
+                                                 v->attrs = check_function_attrs(v->name, (yyvsp[-2].attr_list));
+                                                 set_type(v, (yyvsp[-1].declspec), (yyvsp[0].declarator), FALSE);
+                                                 free((yyvsp[0].declarator));
+                                                 (yyval.func) = make_func(v);
+                                               ;}
+    break;
+
+  case 205:
+#line 779 "parser.y"
+    { (yyval.var) = (yyvsp[0].declarator)->var;
+                                                 (yyval.var)->attrs = (yyvsp[-2].attr_list);
+                                                 set_type((yyval.var), (yyvsp[-1].declspec), (yyvsp[0].declarator), FALSE);
+                                                 free((yyvsp[0].declarator));
                                                ;}
     break;
 
-  case 190:
-#line 678 "parser.y"
-    { var_t *v = (yyvsp[0].pident)->var;
-                                                 var_list_t *args = (yyvsp[0].pident)->args;
-                                                 v->attrs = check_function_attrs(v->name, (yyvsp[-2].attr_list));
-                                                 set_type(v, (yyvsp[-1].type), (yyvsp[0].pident), NULL, FALSE);
-                                                 free((yyvsp[0].pident));
-                                                 (yyval.func) = make_func(v, args);
+  case 206:
+#line 784 "parser.y"
+    { (yyval.var) = (yyvsp[0].declarator)->var;
+                                                 set_type((yyval.var), (yyvsp[-1].declspec), (yyvsp[0].declarator), FALSE);
+                                                 free((yyvsp[0].declarator));
                                                ;}
     break;
 
-  case 191:
-#line 687 "parser.y"
+  case 207:
+#line 790 "parser.y"
     { (yyval.var) = NULL; ;}
     break;
 
-  case 193:
-#line 691 "parser.y"
+  case 209:
+#line 794 "parser.y"
     { (yyval.var) = NULL; ;}
     break;
 
-  case 194:
-#line 692 "parser.y"
+  case 210:
+#line 795 "parser.y"
     { (yyval.var) = make_var((yyvsp[0].str)); ;}
     break;
 
-  case 195:
-#line 693 "parser.y"
+  case 211:
+#line 796 "parser.y"
     { (yyval.var) = make_var((yyvsp[0].str)); ;}
     break;
 
-  case 196:
-#line 696 "parser.y"
+  case 212:
+#line 799 "parser.y"
     { (yyval.var) = make_var((yyvsp[0].str)); ;}
     break;
 
-  case 197:
-#line 698 "parser.y"
+  case 213:
+#line 801 "parser.y"
     { (yyval.var) = make_var((yyvsp[0].str)); ;}
     break;
 
-  case 198:
-#line 701 "parser.y"
+  case 214:
+#line 804 "parser.y"
     { (yyval.type) = make_builtin((yyvsp[0].str)); ;}
     break;
 
-  case 199:
-#line 702 "parser.y"
+  case 215:
+#line 805 "parser.y"
     { (yyval.type) = make_builtin((yyvsp[0].str)); ;}
     break;
 
-  case 201:
-#line 704 "parser.y"
+  case 217:
+#line 807 "parser.y"
     { (yyval.type) = (yyvsp[0].type); (yyval.type)->sign = 1; ;}
     break;
 
-  case 202:
-#line 705 "parser.y"
+  case 218:
+#line 808 "parser.y"
     { (yyval.type) = (yyvsp[0].type); (yyval.type)->sign = -1;
                                                  switch ((yyval.type)->type) {
                                                  case RPC_FC_CHAR:  break;
@@ -3218,91 +3625,91 @@ yyreduce:
                                                ;}
     break;
 
-  case 203:
-#line 721 "parser.y"
+  case 219:
+#line 824 "parser.y"
     { (yyval.type) = make_int(-1); ;}
     break;
 
-  case 204:
-#line 722 "parser.y"
+  case 220:
+#line 825 "parser.y"
     { (yyval.type) = make_builtin((yyvsp[0].str)); ;}
     break;
 
-  case 205:
-#line 723 "parser.y"
+  case 221:
+#line 826 "parser.y"
     { (yyval.type) = duptype(find_type("float", 0), 1); ;}
     break;
 
-  case 206:
-#line 724 "parser.y"
+  case 222:
+#line 827 "parser.y"
     { (yyval.type) = make_builtin((yyvsp[0].str)); ;}
     break;
 
-  case 207:
-#line 725 "parser.y"
+  case 223:
+#line 828 "parser.y"
     { (yyval.type) = make_builtin((yyvsp[0].str)); ;}
     break;
 
-  case 208:
-#line 726 "parser.y"
+  case 224:
+#line 829 "parser.y"
     { (yyval.type) = make_builtin((yyvsp[0].str)); ;}
     break;
 
-  case 209:
-#line 727 "parser.y"
+  case 225:
+#line 830 "parser.y"
     { (yyval.type) = make_builtin((yyvsp[0].str)); ;}
     break;
 
-  case 212:
-#line 734 "parser.y"
+  case 228:
+#line 837 "parser.y"
     { (yyval.type) = make_builtin((yyvsp[0].str)); ;}
     break;
 
-  case 213:
-#line 735 "parser.y"
+  case 229:
+#line 838 "parser.y"
     { (yyval.type) = make_builtin((yyvsp[-1].str)); ;}
     break;
 
-  case 214:
-#line 736 "parser.y"
+  case 230:
+#line 839 "parser.y"
     { (yyval.type) = make_builtin((yyvsp[0].str)); ;}
     break;
 
-  case 215:
-#line 737 "parser.y"
+  case 231:
+#line 840 "parser.y"
     { (yyval.type) = make_builtin((yyvsp[-1].str)); ;}
     break;
 
-  case 216:
-#line 738 "parser.y"
+  case 232:
+#line 841 "parser.y"
     { (yyval.type) = make_builtin((yyvsp[-1].str)); ;}
     break;
 
-  case 217:
-#line 739 "parser.y"
+  case 233:
+#line 842 "parser.y"
     { (yyval.type) = make_builtin((yyvsp[0].str)); ;}
     break;
 
-  case 218:
-#line 740 "parser.y"
+  case 234:
+#line 843 "parser.y"
     { (yyval.type) = make_builtin((yyvsp[0].str)); ;}
     break;
 
-  case 219:
-#line 743 "parser.y"
+  case 235:
+#line 846 "parser.y"
     { (yyval.type) = make_class((yyvsp[0].str)); ;}
     break;
 
-  case 220:
-#line 744 "parser.y"
+  case 236:
+#line 847 "parser.y"
     { (yyval.type) = find_type((yyvsp[0].str), 0);
                                                  if ((yyval.type)->defined) error_loc("multiple definition error\n");
                                                  if ((yyval.type)->kind != TKIND_COCLASS) error_loc("%s was not declared a coclass\n", (yyvsp[0].str));
                                                ;}
     break;
 
-  case 221:
-#line 750 "parser.y"
+  case 237:
+#line 853 "parser.y"
     { (yyval.type) = (yyvsp[0].type);
                                                  (yyval.type)->attrs = check_coclass_attrs((yyvsp[0].type)->name, (yyvsp[-1].attr_list));
                                                  if (!parse_only && do_header)
@@ -3312,42 +3719,43 @@ yyreduce:
                                                ;}
     break;
 
-  case 222:
-#line 760 "parser.y"
+  case 238:
+#line 863 "parser.y"
     { (yyval.type) = (yyvsp[-4].type);
                                                  (yyval.type)->ifaces = (yyvsp[-2].ifref_list);
                                                  (yyval.type)->defined = TRUE;
                                                ;}
     break;
 
-  case 223:
-#line 766 "parser.y"
+  case 239:
+#line 869 "parser.y"
     { (yyval.ifref_list) = NULL; ;}
     break;
 
-  case 224:
-#line 767 "parser.y"
+  case 240:
+#line 870 "parser.y"
     { (yyval.ifref_list) = append_ifref( (yyvsp[-1].ifref_list), (yyvsp[0].ifref) ); ;}
     break;
 
-  case 225:
-#line 771 "parser.y"
+  case 241:
+#line 874 "parser.y"
     { (yyval.ifref) = make_ifref((yyvsp[0].type)); (yyval.ifref)->attrs = (yyvsp[-1].attr_list); ;}
     break;
 
-  case 226:
-#line 774 "parser.y"
+  case 242:
+#line 877 "parser.y"
     { (yyval.type) = get_type(0, (yyvsp[0].str), 0); (yyval.type)->kind = TKIND_DISPATCH; ;}
     break;
 
-  case 227:
-#line 775 "parser.y"
+  case 243:
+#line 878 "parser.y"
     { (yyval.type) = get_type(0, (yyvsp[0].str), 0); (yyval.type)->kind = TKIND_DISPATCH; ;}
     break;
 
-  case 228:
-#line 778 "parser.y"
+  case 244:
+#line 881 "parser.y"
     { attr_t *attrs;
+                                                 is_in_interface = TRUE;
                                                  is_object_interface = TRUE;
                                                  (yyval.type) = (yyvsp[0].type);
                                                  if ((yyval.type)->defined) error_loc("multiple definition error\n");
@@ -3360,73 +3768,76 @@ yyreduce:
                                                ;}
     break;
 
-  case 229:
-#line 791 "parser.y"
+  case 245:
+#line 895 "parser.y"
     { (yyval.var_list) = NULL; ;}
     break;
 
-  case 230:
-#line 792 "parser.y"
+  case 246:
+#line 896 "parser.y"
     { (yyval.var_list) = append_var( (yyvsp[-2].var_list), (yyvsp[-1].var) ); ;}
     break;
 
-  case 231:
-#line 795 "parser.y"
+  case 247:
+#line 899 "parser.y"
     { (yyval.func_list) = NULL; ;}
     break;
 
-  case 232:
-#line 796 "parser.y"
+  case 248:
+#line 900 "parser.y"
     { (yyval.func_list) = append_func( (yyvsp[-2].func_list), (yyvsp[-1].func) ); ;}
     break;
 
-  case 233:
-#line 802 "parser.y"
+  case 249:
+#line 906 "parser.y"
     { (yyval.type) = (yyvsp[-4].type);
                                                  (yyval.type)->fields_or_args = (yyvsp[-2].var_list);
                                                  (yyval.type)->funcs = (yyvsp[-1].func_list);
-                                                 if (!parse_only && do_header) write_dispinterface((yyval.type));
+                                                 if (!parse_only && do_header) write_interface((yyval.type));
                                                  if (!parse_only && do_idfile) write_diid((yyval.type));
+                                                 is_in_interface = FALSE;
                                                ;}
     break;
 
-  case 234:
-#line 809 "parser.y"
+  case 250:
+#line 914 "parser.y"
     { (yyval.type) = (yyvsp[-4].type);
                                                  (yyval.type)->fields_or_args = (yyvsp[-2].type)->fields_or_args;
                                                  (yyval.type)->funcs = (yyvsp[-2].type)->funcs;
-                                                 if (!parse_only && do_header) write_dispinterface((yyval.type));
+                                                 if (!parse_only && do_header) write_interface((yyval.type));
                                                  if (!parse_only && do_idfile) write_diid((yyval.type));
+                                                 is_in_interface = FALSE;
                                                ;}
     break;
 
-  case 235:
-#line 817 "parser.y"
+  case 251:
+#line 923 "parser.y"
     { (yyval.type) = NULL; ;}
     break;
 
-  case 236:
-#line 818 "parser.y"
+  case 252:
+#line 924 "parser.y"
     { (yyval.type) = find_type2((yyvsp[0].str), 0); ;}
     break;
 
-  case 237:
-#line 821 "parser.y"
+  case 253:
+#line 927 "parser.y"
     { (yyval.type) = get_type(RPC_FC_IP, (yyvsp[0].str), 0); (yyval.type)->kind = TKIND_INTERFACE; ;}
     break;
 
-  case 238:
-#line 822 "parser.y"
+  case 254:
+#line 928 "parser.y"
     { (yyval.type) = get_type(RPC_FC_IP, (yyvsp[0].str), 0); (yyval.type)->kind = TKIND_INTERFACE; ;}
     break;
 
-  case 239:
-#line 825 "parser.y"
+  case 255:
+#line 931 "parser.y"
     { (yyval.ifinfo).interface = (yyvsp[0].type);
                                                  (yyval.ifinfo).old_pointer_default = pointer_default;
                                                  if (is_attr((yyvsp[-1].attr_list), ATTR_POINTERDEFAULT))
                                                    pointer_default = get_attrv((yyvsp[-1].attr_list), ATTR_POINTERDEFAULT);
                                                  is_object_interface = is_object((yyvsp[-1].attr_list));
+                                                 is_in_interface = TRUE;
                                                  if ((yyvsp[0].type)->defined) error_loc("multiple definition error\n");
                                                  (yyvsp[0].type)->attrs = check_iface_attrs((yyvsp[0].type)->name, (yyvsp[-1].attr_list));
                                                  (yyvsp[0].type)->defined = TRUE;
@@ -3434,8 +3845,8 @@ yyreduce:
                                                ;}
     break;
 
-  case 240:
-#line 838 "parser.y"
+  case 256:
+#line 945 "parser.y"
     { (yyval.type) = (yyvsp[-5].ifinfo).interface;
                                                  (yyval.type)->ref = (yyvsp[-4].type);
                                                  (yyval.type)->funcs = (yyvsp[-2].func_list);
@@ -3445,11 +3856,12 @@ yyreduce:
                                                  if (!parse_only && local_stubs) write_locals(local_stubs, (yyval.type), TRUE);
                                                  if (!parse_only && do_idfile) write_iid((yyval.type));
                                                  pointer_default = (yyvsp[-5].ifinfo).old_pointer_default;
+                                                 is_in_interface = FALSE;
                                                ;}
     break;
 
-  case 241:
-#line 852 "parser.y"
+  case 257:
+#line 960 "parser.y"
     { (yyval.type) = (yyvsp[-7].ifinfo).interface;
                                                  (yyval.type)->ref = find_type2((yyvsp[-5].str), 0);
                                                  if (!(yyval.type)->ref) error_loc("base class '%s' not found in import\n", (yyvsp[-5].str));
@@ -3459,120 +3871,185 @@ yyreduce:
                                                  if (!parse_only && local_stubs) write_locals(local_stubs, (yyval.type), TRUE);
                                                  if (!parse_only && do_idfile) write_iid((yyval.type));
                                                  pointer_default = (yyvsp[-7].ifinfo).old_pointer_default;
+                                                 is_in_interface = FALSE;
                                                ;}
     break;
 
-  case 242:
-#line 862 "parser.y"
+  case 258:
+#line 971 "parser.y"
     { (yyval.type) = (yyvsp[-1].type); ;}
     break;
 
-  case 243:
-#line 866 "parser.y"
+  case 259:
+#line 975 "parser.y"
     { (yyval.type) = (yyvsp[-1].type); if (!parse_only && do_header) write_forward((yyval.type)); ;}
     break;
 
-  case 244:
-#line 867 "parser.y"
+  case 260:
+#line 976 "parser.y"
     { (yyval.type) = (yyvsp[-1].type); if (!parse_only && do_header) write_forward((yyval.type)); ;}
     break;
 
-  case 245:
-#line 870 "parser.y"
+  case 261:
+#line 979 "parser.y"
     { (yyval.type) = make_type(0, NULL); (yyval.type)->name = (yyvsp[0].str); (yyval.type)->kind = TKIND_MODULE; ;}
     break;
 
-  case 246:
-#line 871 "parser.y"
+  case 262:
+#line 980 "parser.y"
     { (yyval.type) = make_type(0, NULL); (yyval.type)->name = (yyvsp[0].str); (yyval.type)->kind = TKIND_MODULE; ;}
     break;
 
-  case 247:
-#line 874 "parser.y"
+  case 263:
+#line 983 "parser.y"
     { (yyval.type) = (yyvsp[0].type);
                                                  (yyval.type)->attrs = check_module_attrs((yyvsp[0].type)->name, (yyvsp[-1].attr_list));
                                                ;}
     break;
 
-  case 248:
-#line 880 "parser.y"
+  case 264:
+#line 989 "parser.y"
     { (yyval.type) = (yyvsp[-4].type);
                                                  (yyval.type)->funcs = (yyvsp[-2].func_list);
                                                  /* FIXME: if (!parse_only && do_header) write_module($$); */
                                                ;}
     break;
 
-  case 249:
-#line 886 "parser.y"
-    { (yyval.pident) = (yyvsp[0].pident); (yyval.pident)->ptr_level++; ;}
+  case 265:
+#line 996 "parser.y"
+    { (yyval.stgclass) = STG_EXTERN; ;}
     break;
 
-  case 250:
-#line 887 "parser.y"
-    { (yyval.pident) = (yyvsp[0].pident); /* FIXME */ ;}
+  case 266:
+#line 997 "parser.y"
+    { (yyval.stgclass) = STG_STATIC; ;}
     break;
 
-  case 251:
-#line 888 "parser.y"
-    { (yyval.pident) = (yyvsp[0].pident);
-                                                 if ((yyval.pident)->callconv) parser_warning("multiple calling conventions %s, %s for function %s\n", (yyval.pident)->callconv, (yyvsp[-1].str), (yyval.pident)->var->name);
-                                                 (yyval.pident)->callconv = (yyvsp[-1].str);
-                                               ;}
+  case 267:
+#line 998 "parser.y"
+    { (yyval.stgclass) = STG_REGISTER; ;}
     break;
 
-  case 253:
-#line 896 "parser.y"
-    { (yyval.pident) = (yyvsp[-3].pident);
-                                                 (yyvsp[-3].pident)->args = (yyvsp[-1].var_list);
-                                                 (yyvsp[-3].pident)->is_func = TRUE;
-                                               ;}
+  case 268:
+#line 1002 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_INLINE); ;}
     break;
 
-  case 254:
-#line 902 "parser.y"
-    { (yyval.pident) = make_pident((yyvsp[0].var)); ;}
+  case 269:
+#line 1006 "parser.y"
+    { (yyval.attr) = make_attr(ATTR_CONST); ;}
     break;
 
-  case 255:
-#line 903 "parser.y"
-    { (yyval.pident) = (yyvsp[-1].pident); ;}
+  case 270:
+#line 1009 "parser.y"
+    { (yyval.attr_list) = NULL; ;}
     break;
 
-  case 256:
-#line 904 "parser.y"
-    { (yyval.pident) = (yyvsp[0].pident);
-                                                 (yyval.pident)->func_ptr_level = (yyval.pident)->ptr_level;
-                                                 (yyval.pident)->ptr_level = 0;
+  case 271:
+#line 1010 "parser.y"
+    { (yyval.attr_list) = append_attr((yyvsp[-1].attr_list), (yyvsp[0].attr)); ;}
+    break;
+
+  case 272:
+#line 1013 "parser.y"
+    { (yyval.declspec) = make_decl_spec((yyvsp[-1].type), (yyvsp[0].declspec), NULL, NULL, STG_NONE); ;}
+    break;
+
+  case 273:
+#line 1015 "parser.y"
+    { (yyval.declspec) = make_decl_spec((yyvsp[-1].type), (yyvsp[-2].declspec), (yyvsp[0].declspec), NULL, STG_NONE); ;}
+    break;
+
+  case 274:
+#line 1018 "parser.y"
+    { (yyval.declspec) = NULL; ;}
+    break;
+
+  case 276:
+#line 1023 "parser.y"
+    { (yyval.declspec) = make_decl_spec(NULL, (yyvsp[0].declspec), NULL, (yyvsp[-1].attr), STG_NONE); ;}
+    break;
+
+  case 277:
+#line 1024 "parser.y"
+    { (yyval.declspec) = make_decl_spec(NULL, (yyvsp[0].declspec), NULL, (yyvsp[-1].attr), STG_NONE); ;}
+    break;
+
+  case 278:
+#line 1025 "parser.y"
+    { (yyval.declspec) = make_decl_spec(NULL, (yyvsp[0].declspec), NULL, NULL, (yyvsp[-1].stgclass)); ;}
+    break;
+
+  case 279:
+#line 1030 "parser.y"
+    { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type = append_ptrchain_type((yyval.declarator)->type, make_pointer_type(NULL, (yyvsp[-1].attr_list))); ;}
+    break;
+
+  case 280:
+#line 1031 "parser.y"
+    { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[-1].str))); ;}
+    break;
+
+  case 282:
+#line 1036 "parser.y"
+    { (yyval.declarator) = make_declarator((yyvsp[0].var)); ;}
+    break;
+
+  case 283:
+#line 1037 "parser.y"
+    { (yyval.declarator) = (yyvsp[-1].declarator); ;}
+    break;
+
+  case 284:
+#line 1038 "parser.y"
+    { (yyval.declarator) = (yyvsp[-1].declarator); (yyval.declarator)->array = append_array((yyval.declarator)->array, (yyvsp[0].expr)); ;}
+    break;
+
+  case 285:
+#line 1039 "parser.y"
+    { (yyval.declarator) = (yyvsp[-3].declarator);
+                                                 (yyval.declarator)->func_type = append_ptrchain_type((yyval.declarator)->type, make_func_type((yyvsp[-1].var_list)));
+                                                 (yyval.declarator)->type = NULL;
                                                ;}
     break;
 
-  case 257:
-#line 911 "parser.y"
-    { (yyval.pident_list) = append_pident( NULL, (yyvsp[0].pident) ); ;}
+  case 286:
+#line 1046 "parser.y"
+    { (yyval.declarator_list) = append_declarator( NULL, (yyvsp[0].declarator) ); ;}
     break;
 
-  case 258:
-#line 912 "parser.y"
-    { (yyval.pident_list) = append_pident( (yyvsp[-2].pident_list), (yyvsp[0].pident) ); ;}
+  case 287:
+#line 1047 "parser.y"
+    { (yyval.declarator_list) = append_declarator( (yyvsp[-2].declarator_list), (yyvsp[0].declarator) ); ;}
     break;
 
-  case 259:
-#line 916 "parser.y"
+  case 288:
+#line 1051 "parser.y"
+    { (yyval.declarator) = (yyvsp[0].declarator); ;}
+    break;
+
+  case 289:
+#line 1052 "parser.y"
+    { (yyval.declarator) = (yyvsp[-2].declarator); (yyvsp[-2].declarator)->var->eval = (yyvsp[0].expr); ;}
+    break;
+
+  case 290:
+#line 1056 "parser.y"
     { (yyval.num) = RPC_FC_RP; ;}
     break;
 
-  case 260:
-#line 917 "parser.y"
+  case 291:
+#line 1057 "parser.y"
     { (yyval.num) = RPC_FC_UP; ;}
     break;
 
-  case 261:
-#line 918 "parser.y"
+  case 292:
+#line 1058 "parser.y"
     { (yyval.num) = RPC_FC_FP; ;}
     break;
 
-  case 262:
-#line 921 "parser.y"
+  case 293:
+#line 1061 "parser.y"
     { (yyval.type) = get_typev(RPC_FC_STRUCT, (yyvsp[-3].var), tsSTRUCT);
                                                   /* overwrite RPC_FC_STRUCT with a more exact type */
                                                  (yyval.type)->type = get_struct_type( (yyvsp[-1].var_list) );
@@ -3584,70 +4061,65 @@ yyreduce:
                                                 ;}
     break;
 
-  case 263:
-#line 932 "parser.y"
+  case 294:
+#line 1072 "parser.y"
     { (yyval.type) = duptype(find_type("void", 0), 1); ;}
     break;
 
-  case 264:
-#line 933 "parser.y"
+  case 295:
+#line 1073 "parser.y"
     { (yyval.type) = find_type((yyvsp[0].str), 0); ;}
     break;
 
-  case 265:
-#line 934 "parser.y"
+  case 296:
+#line 1074 "parser.y"
     { (yyval.type) = (yyvsp[0].type); ;}
     break;
 
-  case 266:
-#line 935 "parser.y"
-    { (yyval.type) = duptype((yyvsp[0].type), 1); (yyval.type)->is_const = TRUE; ;}
-    break;
-
-  case 267:
-#line 936 "parser.y"
+  case 297:
+#line 1075 "parser.y"
     { (yyval.type) = (yyvsp[0].type); ;}
     break;
 
-  case 268:
-#line 937 "parser.y"
+  case 298:
+#line 1076 "parser.y"
     { (yyval.type) = find_type2((yyvsp[0].str), tsENUM); ;}
     break;
 
-  case 269:
-#line 938 "parser.y"
+  case 299:
+#line 1077 "parser.y"
     { (yyval.type) = (yyvsp[0].type); ;}
     break;
 
-  case 270:
-#line 939 "parser.y"
+  case 300:
+#line 1078 "parser.y"
     { (yyval.type) = get_type(RPC_FC_STRUCT, (yyvsp[0].str), tsSTRUCT); ;}
     break;
 
-  case 271:
-#line 940 "parser.y"
+  case 301:
+#line 1079 "parser.y"
     { (yyval.type) = (yyvsp[0].type); ;}
     break;
 
-  case 272:
-#line 941 "parser.y"
+  case 302:
+#line 1080 "parser.y"
     { (yyval.type) = find_type2((yyvsp[0].str), tsUNION); ;}
     break;
 
-  case 273:
-#line 942 "parser.y"
+  case 303:
+#line 1081 "parser.y"
     { (yyval.type) = make_safearray((yyvsp[-1].type)); ;}
     break;
 
-  case 274:
-#line 945 "parser.y"
-    { reg_typedefs((yyvsp[-1].type), (yyvsp[0].pident_list), check_typedef_attrs((yyvsp[-2].attr_list)));
-                                                 process_typedefs((yyvsp[0].pident_list));
+  case 304:
+#line 1085 "parser.y"
+    { reg_typedefs((yyvsp[-1].declspec), (yyvsp[0].declarator_list), check_typedef_attrs((yyvsp[-2].attr_list)));
+                                                 (yyval.statement) = process_typedefs((yyvsp[0].declarator_list));
                                                ;}
     break;
 
-  case 275:
-#line 950 "parser.y"
+  case 305:
+#line 1091 "parser.y"
     { (yyval.type) = get_typev(RPC_FC_NON_ENCAPSULATED_UNION, (yyvsp[-3].var), tsUNION);
                                                  (yyval.type)->kind = TKIND_UNION;
                                                  (yyval.type)->fields_or_args = (yyvsp[-1].var_list);
@@ -3655,8 +4127,8 @@ yyreduce:
                                                ;}
     break;
 
-  case 276:
-#line 957 "parser.y"
+  case 306:
+#line 1098 "parser.y"
     { var_t *u = (yyvsp[-3].var);
                                                  (yyval.type) = get_typev(RPC_FC_ENCAPSULATED_UNION, (yyvsp[-8].var), tsUNION);
                                                  (yyval.type)->kind = TKIND_UNION;
@@ -3671,13 +4143,13 @@ yyreduce:
                                                ;}
     break;
 
-  case 277:
-#line 972 "parser.y"
+  case 307:
+#line 1113 "parser.y"
     { (yyval.num) = MAKEVERSION((yyvsp[0].num), 0); ;}
     break;
 
-  case 278:
-#line 973 "parser.y"
+  case 308:
+#line 1114 "parser.y"
     { (yyval.num) = MAKEVERSION((yyvsp[-2].num), (yyvsp[0].num)); ;}
     break;
 
@@ -3686,7 +4158,7 @@ yyreduce:
     }
 
 /* Line 1126 of yacc.c.  */
-#line 3690 "parser.tab.c"
+#line 4162 "parser.tab.c"
 \f
   yyvsp -= yylen;
   yyssp -= yylen;
@@ -3954,7 +4426,7 @@ yyreturn:
 }
 
 
-#line 976 "parser.y"
+#line 1117 "parser.y"
 
 
 static void decl_builtin(const char *name, unsigned char type)
@@ -4039,229 +4511,125 @@ static attr_list_t *append_attr(attr_list_t *list, attr_t *attr)
     return list;
 }
 
-static attr_t *make_attr(enum attr_type type)
-{
-  attr_t *a = xmalloc(sizeof(attr_t));
-  a->type = type;
-  a->u.ival = 0;
-  return a;
-}
-
-static attr_t *make_attrv(enum attr_type type, unsigned long val)
+static attr_list_t *move_attr(attr_list_t *dst, attr_list_t *src, enum attr_type type)
 {
-  attr_t *a = xmalloc(sizeof(attr_t));
-  a->type = type;
-  a->u.ival = val;
-  return a;
+  attr_t *attr;
+  if (!src) return dst;
+  LIST_FOR_EACH_ENTRY(attr, src, attr_t, entry)
+    if (attr->type == type)
+    {
+      list_remove(&attr->entry);
+      return append_attr(dst, attr);
+    }
+  return dst;
 }
 
-static attr_t *make_attrp(enum attr_type type, void *val)
+static attr_list_t *append_attr_list(attr_list_t *new_list, attr_list_t *old_list)
 {
-  attr_t *a = xmalloc(sizeof(attr_t));
-  a->type = type;
-  a->u.pval = val;
-  return a;
-}
+  struct list *entry;
 
-static expr_t *make_expr(enum expr_type type)
-{
-  expr_t *e = xmalloc(sizeof(expr_t));
-  e->type = type;
-  e->ref = NULL;
-  e->u.lval = 0;
-  e->is_const = FALSE;
-  e->cval = 0;
-  return e;
-}
+  if (!old_list) return new_list;
 
-static expr_t *make_exprl(enum expr_type type, long val)
-{
-  expr_t *e = xmalloc(sizeof(expr_t));
-  e->type = type;
-  e->ref = NULL;
-  e->u.lval = val;
-  e->is_const = FALSE;
-  /* check for numeric constant */
-  if (type == EXPR_NUM || type == EXPR_HEXNUM || type == EXPR_TRUEFALSE) {
-    /* make sure true/false value is valid */
-    assert(type != EXPR_TRUEFALSE || val == 0 || val == 1);
-    e->is_const = TRUE;
-    e->cval = val;
+  while ((entry = list_head(old_list)))
+  {
+    attr_t *attr = LIST_ENTRY(entry, attr_t, entry);
+    list_remove(entry);
+    new_list = append_attr(new_list, attr);
   }
-  return e;
+  return new_list;
 }
 
-static expr_t *make_exprd(enum expr_type type, double val)
+static attr_list_t *dupattrs(const attr_list_t *list)
 {
-  expr_t *e = xmalloc(sizeof(expr_t));
-  e->type = type;
-  e->ref = NULL;
-  e->u.dval = val;
-  e->is_const = TRUE;
-  e->cval = val;
-  return e;
-}
+  attr_list_t *new_list;
+  const attr_t *attr;
 
-static expr_t *make_exprs(enum expr_type type, char *val)
-{
-  expr_t *e;
-  e = xmalloc(sizeof(expr_t));
-  e->type = type;
-  e->ref = NULL;
-  e->u.sval = val;
-  e->is_const = FALSE;
-  /* check for predefined constants */
-  if (type == EXPR_IDENTIFIER) {
-    var_t *c = find_const(val, 0);
-    if (c) {
-      e->u.sval = c->name;
-      free(val);
-      e->is_const = TRUE;
-      e->cval = c->eval->cval;
-    }
+  if (!list) return NULL;
+
+  new_list = xmalloc( sizeof(*list) );
+  list_init( new_list );
+  LIST_FOR_EACH_ENTRY(attr, list, const attr_t, entry)
+  {
+    attr_t *new_attr = xmalloc(sizeof(*new_attr));
+    *new_attr = *attr;
+    list_add_tail(new_list, &new_attr->entry);
   }
-  return e;
+  return new_list;
 }
 
-static expr_t *make_exprt(enum expr_type type, type_t *tref, expr_t *expr)
+static decl_spec_t *make_decl_spec(type_t *type, decl_spec_t *left, decl_spec_t *right, attr_t *attr, enum storage_class stgclass)
 {
-  expr_t *e;
-  e = xmalloc(sizeof(expr_t));
-  e->type = type;
-  e->ref = expr;
-  e->u.tref = tref;
-  e->is_const = FALSE;
-  /* check for cast of constant expression */
-  if (type == EXPR_SIZEOF) {
-    switch (tref->type) {
-      case RPC_FC_BYTE:
-      case RPC_FC_CHAR:
-      case RPC_FC_SMALL:
-      case RPC_FC_USMALL:
-        e->is_const = TRUE;
-        e->cval = 1;
-        break;
-      case RPC_FC_WCHAR:
-      case RPC_FC_USHORT:
-      case RPC_FC_SHORT:
-        e->is_const = TRUE;
-        e->cval = 2;
-        break;
-      case RPC_FC_LONG:
-      case RPC_FC_ULONG:
-      case RPC_FC_FLOAT:
-      case RPC_FC_ERROR_STATUS_T:
-        e->is_const = TRUE;
-        e->cval = 4;
-        break;
-      case RPC_FC_HYPER:
-      case RPC_FC_DOUBLE:
-        e->is_const = TRUE;
-        e->cval = 8;
-        break;
-    }
+  decl_spec_t *declspec = left ? left : right;
+  if (!declspec)
+  {
+    declspec = xmalloc(sizeof(*declspec));
+    declspec->type = NULL;
+    declspec->attrs = NULL;
+    declspec->stgclass = STG_NONE;
+  }
+  declspec->type = type;
+  if (left && declspec != left)
+  {
+    declspec->attrs = append_attr_list(declspec->attrs, left->attrs);
+    if (declspec->stgclass == STG_NONE)
+      declspec->stgclass = left->stgclass;
+    else if (left->stgclass != STG_NONE)
+      error_loc("only one storage class can be specified\n");
+    assert(!left->type);
+    free(left);
+  }
+  if (right && declspec != right)
+  {
+    declspec->attrs = append_attr_list(declspec->attrs, right->attrs);
+    if (declspec->stgclass == STG_NONE)
+      declspec->stgclass = right->stgclass;
+    else if (right->stgclass != STG_NONE)
+      error_loc("only one storage class can be specified\n");
+    assert(!right->type);
+    free(right);
   }
-  if (type == EXPR_CAST && expr->is_const) {
-    e->is_const = TRUE;
-    e->cval = expr->cval;
+
+  declspec->attrs = append_attr(declspec->attrs, attr);
+  if (declspec->stgclass == STG_NONE)
+    declspec->stgclass = stgclass;
+  else if (stgclass != STG_NONE)
+    error_loc("only one storage class can be specified\n");
+
+  /* apply attributes to type */
+  if (type && declspec->attrs)
+  {
+    attr_list_t *attrs;
+    declspec->type = duptype(type, 1);
+    attrs = dupattrs(type->attrs);
+    declspec->type->attrs = append_attr_list(attrs, declspec->attrs);
+    declspec->attrs = NULL;
   }
-  return e;
+
+  return declspec;
 }
 
-static expr_t *make_expr1(enum expr_type type, expr_t *expr)
+static attr_t *make_attr(enum attr_type type)
 {
-  expr_t *e;
-  if (type == EXPR_ADDRESSOF && expr->type != EXPR_IDENTIFIER)
-    error_loc("address-of operator applied to invalid expression\n");
-  e = xmalloc(sizeof(expr_t));
-  e->type = type;
-  e->ref = expr;
-  e->u.lval = 0;
-  e->is_const = FALSE;
-  /* check for compile-time optimization */
-  if (expr->is_const) {
-    e->is_const = TRUE;
-    switch (type) {
-    case EXPR_NEG:
-      e->cval = -expr->cval;
-      break;
-    case EXPR_NOT:
-      e->cval = ~expr->cval;
-      break;
-    default:
-      e->is_const = FALSE;
-      break;
-    }
-  }
-  return e;
+  attr_t *a = xmalloc(sizeof(attr_t));
+  a->type = type;
+  a->u.ival = 0;
+  return a;
 }
 
-static expr_t *make_expr2(enum expr_type type, expr_t *expr1, expr_t *expr2)
+static attr_t *make_attrv(enum attr_type type, unsigned long val)
 {
-  expr_t *e;
-  e = xmalloc(sizeof(expr_t));
-  e->type = type;
-  e->ref = expr1;
-  e->u.ext = expr2;
-  e->is_const = FALSE;
-  /* check for compile-time optimization */
-  if (expr1->is_const && expr2->is_const) {
-    e->is_const = TRUE;
-    switch (type) {
-    case EXPR_ADD:
-      e->cval = expr1->cval + expr2->cval;
-      break;
-    case EXPR_SUB:
-      e->cval = expr1->cval - expr2->cval;
-      break;
-    case EXPR_MUL:
-      e->cval = expr1->cval * expr2->cval;
-      break;
-    case EXPR_DIV:
-      e->cval = expr1->cval / expr2->cval;
-      break;
-    case EXPR_OR:
-      e->cval = expr1->cval | expr2->cval;
-      break;
-    case EXPR_AND:
-      e->cval = expr1->cval & expr2->cval;
-      break;
-    case EXPR_SHL:
-      e->cval = expr1->cval << expr2->cval;
-      break;
-    case EXPR_SHR:
-      e->cval = expr1->cval >> expr2->cval;
-      break;
-    default:
-      e->is_const = FALSE;
-      break;
-    }
-  }
-  return e;
+  attr_t *a = xmalloc(sizeof(attr_t));
+  a->type = type;
+  a->u.ival = val;
+  return a;
 }
 
-static expr_t *make_expr3(enum expr_type type, expr_t *expr1, expr_t *expr2, expr_t *expr3)
+static attr_t *make_attrp(enum attr_type type, void *val)
 {
-  expr_t *e;
-  e = xmalloc(sizeof(expr_t));
-  e->type = type;
-  e->ref = expr1;
-  e->u.ext = expr2;
-  e->ext2 = expr3;
-  e->is_const = FALSE;
-  /* check for compile-time optimization */
-  if (expr1->is_const && expr2->is_const && expr3->is_const) {
-    e->is_const = TRUE;
-    switch (type) {
-    case EXPR_COND:
-      e->cval = expr1->cval ? expr2->cval : expr3->cval;
-      break;
-    default:
-      e->is_const = FALSE;
-      break;
-    }
-  }
-  return e;
+  attr_t *a = xmalloc(sizeof(attr_t));
+  a->type = type;
+  a->u.pval = val;
+  return a;
 }
 
 static expr_list_t *append_expr(expr_list_t *list, expr_t *expr)
@@ -4309,7 +4677,7 @@ void set_all_tfswrite(int val)
     node->data.tfswrite = val;
 }
 
-static type_t *make_type(unsigned char type, type_t *ref)
+type_t *make_type(unsigned char type, type_t *ref)
 {
   type_t *t = alloc_type();
   t->name = NULL;
@@ -4328,72 +4696,102 @@ static type_t *make_type(unsigned char type, type_t *ref)
   t->ptrdesc = 0;
   t->declarray = FALSE;
   t->ignore = (parse_only != 0);
-  t->is_const = FALSE;
   t->sign = 0;
   t->defined = FALSE;
   t->written = FALSE;
   t->user_types_registered = FALSE;
   t->tfswrite = FALSE;
+  t->checked = FALSE;
   t->typelib_idx = -1;
   return t;
 }
 
-static void set_type(var_t *v, type_t *type, const pident_t *pident, array_dims_t *arr,
+static type_t *make_func_type(var_list_t *args)
+{
+  type_t *t = make_type(RPC_FC_FUNCTION, NULL);
+  t->fields_or_args = args;
+  return t;
+}
+
+static type_t *make_pointer_type(type_t *ref, attr_list_t *attrs)
+{
+    type_t *t = make_type(pointer_default, ref);
+    t->attrs = attrs;
+    return t;
+}
+
+static type_t *append_ptrchain_type(type_t *ptrchain, type_t *type)
+{
+  type_t *ptrchain_type;
+  if (!ptrchain)
+    return type;
+  for (ptrchain_type = ptrchain; ptrchain_type->ref; ptrchain_type = ptrchain_type->ref)
+    ;
+  ptrchain_type->ref = type;
+  return ptrchain;
+}
+
+static void set_type(var_t *v, decl_spec_t *decl_spec, const declarator_t *decl,
                      int top)
 {
   expr_list_t *sizes = get_attrp(v->attrs, ATTR_SIZEIS);
   expr_list_t *lengs = get_attrp(v->attrs, ATTR_LENGTHIS);
   int ptr_attr = get_attrv(v->attrs, ATTR_POINTERTYPE);
-  int ptr_type = ptr_attr;
   int sizeless, has_varconf;
   expr_t *dim;
   type_t *atype, **ptype;
-  int ptr_level = (pident ? pident->ptr_level : 0);
-
-  v->type = type;
+  array_dims_t *arr = decl ? decl->array : NULL;
+  type_t *func_type = decl ? decl->func_type : NULL;
+  type_t *type = decl_spec->type;
 
-  if (!ptr_type && top)
-    ptr_type = RPC_FC_RP;
-
-  for ( ; 0 < ptr_level; --ptr_level)
+  if (is_attr(type->attrs, ATTR_INLINE))
   {
-    v->type = make_type(pointer_default, v->type);
-    if (ptr_level == 1 && ptr_type && !arr)
+    if (!func_type)
+      error_loc("inline attribute applied to non-function type\n");
+    else
     {
-      v->type->type = ptr_type;
-      ptr_type = 0;
+      type_t *t;
+      /* move inline attribute from return type node to function node */
+      for (t = func_type; is_ptr(t); t = t->ref)
+        ;
+      t->attrs = move_attr(t->attrs, type->attrs, ATTR_INLINE);
     }
   }
 
-  if (ptr_type && !arr)
+  /* add type onto the end of the pointers in pident->type */
+  v->type = append_ptrchain_type(decl ? decl->type : NULL, type);
+  v->stgclass = decl_spec->stgclass;
+
+  /* the highest level of pointer specified should default to the var's ptr attr
+   * or (RPC_FC_RP if not specified and it's a top level ptr), not
+   * pointer_default so we need to fix that up here */
+  if (!arr)
   {
-    if (is_ptr(v->type))
+    const type_t *ptr = NULL;
+    /* pointer attributes on the left side of the type belong to the function
+     * pointer, if one is being declared */
+    type_t **pt = func_type ? &func_type : &v->type;
+    for (ptr = *pt; ptr; )
     {
-      if (v->type->type != ptr_type)
-      {
-        v->type = duptype(v->type, 1);
-        v->type->type = ptr_type;
-      }
+      if (ptr->kind == TKIND_ALIAS)
+        ptr = ptr->orig;
+      else
+        break;
     }
-    else if (!arr && ptr_attr)
-      error_loc("%s: pointer attribute applied to non-pointer type\n", v->name);
-  }
-
-  if (pident && pident->is_func) {
-    int func_ptr_level = pident->func_ptr_level;
-    v->type = make_type(RPC_FC_FUNCTION, v->type);
-    v->type->fields_or_args = pident->args;
-    if (pident->callconv)
-      v->type->attrs = append_attr(NULL, make_attrp(ATTR_CALLCONV, pident->callconv));
-    else if (is_object_interface) {
-      static char *stdmethodcalltype;
-      if (!stdmethodcalltype) stdmethodcalltype = strdup("STDMETHODCALLTYPE");
-      v->type->attrs = append_attr(NULL, make_attrp(ATTR_CALLCONV, stdmethodcalltype));
+    if (ptr && is_ptr(ptr) && (ptr_attr || top))
+    {
+      /* duplicate type to avoid changing original type */
+      *pt = duptype(*pt, 1);
+      (*pt)->type = ptr_attr ? ptr_attr : RPC_FC_RP;
     }
-    for (; func_ptr_level > 0; func_ptr_level--)
-      v->type = make_type(ptr_type, v->type);
+    else if (ptr_attr)
+       error_loc("%s: pointer attribute applied to non-pointer type\n", v->name);
   }
 
+  if (is_attr(v->attrs, ATTR_STRING) && !is_ptr(v->type) && !arr)
+    error_loc("'%s': [string] attribute applied to non-pointer, non-array type\n",
+              v->name);
+
   sizeless = FALSE;
   if (arr) LIST_FOR_EACH_ENTRY_REV(dim, arr, expr_t, entry)
   {
@@ -4506,6 +4904,54 @@ static void set_type(var_t *v, type_t *type, const pident_t *pident, array_dims_
           break;
         }
   }
+
+  /* v->type is currently pointing the the type on the left-side of the
+   * declaration, so we need to fix this up so that it is the return type of the
+   * function and make v->type point to the function side of the declaration */
+  if (func_type)
+  {
+    type_t *ft, *t;
+    type_t *return_type = v->type;
+    v->type = func_type;
+    for (ft = v->type; is_ptr(ft); ft = ft->ref)
+      ;
+    assert(ft->type == RPC_FC_FUNCTION);
+    ft->ref = return_type;
+    /* move calling convention attribute, if present, from pointer nodes to
+     * function node */
+    for (t = v->type; is_ptr(t); t = t->ref)
+      ft->attrs = move_attr(ft->attrs, t->attrs, ATTR_CALLCONV);
+    if (is_object_interface && !is_attr(ft->attrs, ATTR_CALLCONV))
+    {
+      static char *stdmethodcalltype;
+      if (!stdmethodcalltype) stdmethodcalltype = strdup("STDMETHODCALLTYPE");
+      ft->attrs = append_attr(NULL, make_attrp(ATTR_CALLCONV, stdmethodcalltype));
+    }
+  }
+  else
+  {
+    type_t *t;
+    for (t = v->type; is_ptr(t); t = t->ref)
+      if (is_attr(t->attrs, ATTR_CALLCONV))
+        error_loc("calling convention applied to non-function-pointer type\n");
+  }
+}
+
+static var_list_t *set_var_types(attr_list_t *attrs, decl_spec_t *decl_spec, declarator_list_t *decls)
+{
+  declarator_t *decl, *next;
+  var_list_t *var_list = NULL;
+
+  LIST_FOR_EACH_ENTRY_SAFE( decl, next, decls, declarator_t, entry )
+  {
+    var_t *var = decl->var;
+
+    var->attrs = attrs;
+    set_type(var, decl_spec, decl, 0);
+    var_list = append_var(var_list, var);
+    free(decl);
+  }
+  return var_list;
 }
 
 static ifref_list_t *append_ifref(ifref_list_t *list, ifref_t *iface)
@@ -4540,6 +4986,18 @@ static var_list_t *append_var(var_list_t *list, var_t *var)
     return list;
 }
 
+static var_list_t *append_var_list(var_list_t *list, var_list_t *vars)
+{
+    if (!vars) return list;
+    if (!list)
+    {
+        list = xmalloc( sizeof(*list) );
+        list_init( list );
+    }
+    list_move_tail( list, vars );
+    return list;
+}
+
 static var_t *make_var(char *name)
 {
   var_t *v = xmalloc(sizeof(var_t));
@@ -4547,33 +5005,32 @@ static var_t *make_var(char *name)
   v->type = NULL;
   v->attrs = NULL;
   v->eval = NULL;
+  v->stgclass = STG_NONE;
   v->loc_info.input_name = input_name ? input_name : "stdin";
   v->loc_info.line_number = line_number;
   v->loc_info.near_text = parser_text;
   return v;
 }
 
-static pident_list_t *append_pident(pident_list_t *list, pident_t *p)
+static declarator_list_t *append_declarator(declarator_list_t *list, declarator_t *d)
 {
-  if (!p) return list;
+  if (!d) return list;
   if (!list) {
     list = xmalloc(sizeof(*list));
     list_init(list);
   }
-  list_add_tail(list, &p->entry);
+  list_add_tail(list, &d->entry);
   return list;
 }
 
-static pident_t *make_pident(var_t *var)
+static declarator_t *make_declarator(var_t *var)
 {
-  pident_t *p = xmalloc(sizeof(*p));
-  p->var = var;
-  p->is_func = FALSE;
-  p->ptr_level = 0;
-  p->func_ptr_level = 0;
-  p->args = NULL;
-  p->callconv = NULL;
-  return p;
+  declarator_t *d = xmalloc(sizeof(*d));
+  d->var = var;
+  d->type = NULL;
+  d->func_type = NULL;
+  d->array = NULL;
+  return d;
 }
 
 static func_list_t *append_func(func_list_t *list, func_t *func)
@@ -4588,11 +5045,11 @@ static func_list_t *append_func(func_list_t *list, func_t *func)
     return list;
 }
 
-static func_t *make_func(var_t *def, var_list_t *args)
+static func_t *make_func(var_t *def)
 {
   func_t *f = xmalloc(sizeof(func_t));
   f->def = def;
-  f->args = args;
+  f->args = def->type->fields_or_args;
   f->ignore = parse_only;
   f->idx = -1;
   return f;
@@ -4600,7 +5057,7 @@ static func_t *make_func(var_t *def, var_list_t *args)
 
 static type_t *make_class(char *name)
 {
-  type_t *c = make_type(0, NULL);
+  type_t *c = make_type(RPC_FC_COCLASS, NULL);
   c->name = name;
   c->kind = TKIND_COCLASS;
   return c;
@@ -4613,6 +5070,17 @@ static type_t *make_safearray(type_t *type)
   return make_type(pointer_default, sa);
 }
 
+static typelib_t *make_library(const char *name, const attr_list_t *attrs)
+{
+    typelib_t *typelib = xmalloc(sizeof(*typelib));
+    typelib->name = xstrdup(name);
+    typelib->filename = NULL;
+    typelib->attrs = attrs;
+    list_init( &typelib->entries );
+    list_init( &typelib->importlibs );
+    return typelib;
+}
+
 #define HASHMAX 64
 
 static int hash_ident(const char *name)
@@ -4688,17 +5156,15 @@ static void fix_incomplete(void)
   }
 }
 
-static type_t *reg_typedefs(type_t *type, pident_list_t *pidents, attr_list_t *attrs)
+static type_t *reg_typedefs(decl_spec_t *decl_spec, declarator_list_t *decls, attr_list_t *attrs)
 {
-  type_t *ptr = type;
-  const pident_t *pident;
-  int ptrc = 0;
+  const declarator_t *decl;
   int is_str = is_attr(attrs, ATTR_STRING);
-  unsigned char ptr_type = get_attrv(attrs, ATTR_POINTERTYPE);
+  type_t *type = decl_spec->type;
 
   if (is_str)
   {
-    type_t *t = type;
+    type_t *t = decl_spec->type;
     unsigned char c;
 
     while (is_ptr(t))
@@ -4707,16 +5173,15 @@ static type_t *reg_typedefs(type_t *type, pident_list_t *pidents, attr_list_t *a
     c = t->type;
     if (c != RPC_FC_CHAR && c != RPC_FC_BYTE && c != RPC_FC_WCHAR)
     {
-      pident = LIST_ENTRY( list_head( pidents ), const pident_t, entry );
+      decl = LIST_ENTRY( list_head( decls ), const declarator_t, entry );
       error_loc("'%s': [string] attribute is only valid on 'char', 'byte', or 'wchar_t' pointers and arrays\n",
-              pident->var->name);
+              decl->var->name);
     }
   }
 
   /* We must generate names for tagless enum, struct or union.
      Typedef-ing a tagless enum, struct or union means we want the typedef
-     to be included in a library whether it has other attributes or not,
-     hence the public attribute.  */
+     to be included in a library hence the public attribute.  */
   if ((type->kind == TKIND_ENUM || type->kind == TKIND_RECORD
        || type->kind == TKIND_UNION) && ! type->name && ! parse_only)
   {
@@ -4724,52 +5189,21 @@ static type_t *reg_typedefs(type_t *type, pident_list_t *pidents, attr_list_t *a
       attrs = append_attr( attrs, make_attr(ATTR_PUBLIC) );
     type->name = gen_name();
   }
+  else if (is_attr(attrs, ATTR_UUID) && !is_attr(attrs, ATTR_PUBLIC))
+    attrs = append_attr( attrs, make_attr(ATTR_PUBLIC) );
 
-  LIST_FOR_EACH_ENTRY( pident, pidents, const pident_t, entry )
+  LIST_FOR_EACH_ENTRY( decl, decls, const declarator_t, entry )
   {
-    var_t *name = pident->var;
+    var_t *name = decl->var;
 
     if (name->name) {
-      type_t *cur = ptr;
-      int cptr = pident->ptr_level;
-      if (cptr > ptrc) {
-        while (cptr > ptrc) {
-          cur = ptr = make_type(pointer_default, cur);
-          ptrc++;
-        }
-      } else {
-        while (cptr < ptrc) {
-          cur = cur->ref;
-          cptr++;
-        }
-      }
-      if (pident->is_func) {
-        int func_ptr_level = pident->func_ptr_level;
-        cur = make_type(RPC_FC_FUNCTION, cur);
-        cur->fields_or_args = pident->args;
-        if (pident->callconv)
-          cur->attrs = append_attr(NULL, make_attrp(ATTR_CALLCONV, pident->callconv));
-        else if (is_object_interface) {
-          static char *stdmethodcalltype;
-          if (!stdmethodcalltype) stdmethodcalltype = strdup("STDMETHODCALLTYPE");
-          cur->attrs = append_attr(NULL, make_attrp(ATTR_CALLCONV, stdmethodcalltype));
-        }
-        for (; func_ptr_level > 0; func_ptr_level--)
-          cur = make_type(pointer_default, cur);
-      }
-      cur = alias(cur, name->name);
+      type_t *cur;
+
+      /* set the attributes to allow set_type to do some checks on them */
+      name->attrs = attrs;
+      set_type(name, decl_spec, decl, 0);
+      cur = alias(name->type, name->name);
       cur->attrs = attrs;
-      if (ptr_type)
-      {
-        if (is_ptr(cur))
-          cur->type = ptr_type;
-        else
-          error_loc("'%s': pointer attribute applied to non-pointer type\n",
-                  cur->name);
-      }
-      else if (is_str && ! is_ptr(cur))
-        error_loc("'%s': [string] attribute applied to non-pointer type\n",
-                cur->name);
 
       if (is_incomplete(cur))
         add_incomplete(cur);
@@ -4779,7 +5213,7 @@ static type_t *reg_typedefs(type_t *type, pident_list_t *pidents, attr_list_t *a
   return type;
 }
 
-static type_t *find_type(const char *name, int t)
+type_t *find_type(const char *name, int t)
 {
   struct rtype *cur = type_hash[hash_ident(name)];
   while (cur && (cur->t != t || strcmp(cur->name, name)))
@@ -5020,7 +5454,7 @@ static var_t *reg_const(var_t *var)
   return var;
 }
 
-static var_t *find_const(char *name, int f)
+var_t *find_const(const char *name, int f)
 {
   struct rconst *cur = const_hash[hash_ident(name)];
   while (cur && strcmp(cur->name, name))
@@ -5032,10 +5466,10 @@ static var_t *find_const(char *name, int f)
   return cur->var;
 }
 
-static void write_libid(const char *name, const attr_list_t *attr)
+static void write_libid(const typelib_t *typelib)
 {
-  const UUID *uuid = get_attrp(attr, ATTR_UUID);
-  write_guid(idfile, "LIBID", name, uuid);
+  const UUID *uuid = get_attrp(typelib->attrs, ATTR_UUID);
+  write_guid(idfile, "LIBID", typelib->name, uuid);
 }
 
 static void write_clsid(type_t *cls)
@@ -5101,26 +5535,6 @@ static char *gen_name(void)
   return name;
 }
 
-static void process_typedefs(pident_list_t *pidents)
-{
-  pident_t *pident, *next;
-
-  if (!pidents) return;
-  LIST_FOR_EACH_ENTRY_SAFE( pident, next, pidents, pident_t, entry )
-  {
-    var_t *var = pident->var;
-    type_t *type = find_type(var->name, 0);
-
-    if (! parse_only && do_header)
-      write_typedef(type);
-    if (in_typelib && type->attrs)
-      add_typelib_entry(type);
-
-    free(pident);
-    free(var);
-  }
-}
-
 struct allowed_attr
 {
     unsigned int dce_compatible : 1;
@@ -5147,22 +5561,21 @@ struct allowed_attr allowed_attr[] =
     /* ATTR_BINDABLE */         { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, "bindable" },
     /* ATTR_BROADCAST */        { 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, "broadcast" },
     /* ATTR_CALLAS */           { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, "call_as" },
-    /* ATTR_CALLCONV */         { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL },
+    /* ATTR_CALLCONV */         { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, NULL },
     /* ATTR_CASE */             { 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, "case" },
+    /* ATTR_CONST */            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "const" },
     /* ATTR_CONTEXTHANDLE */    { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, "context_handle" },
     /* ATTR_CONTROL */          { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, "control" },
     /* ATTR_DEFAULT */          { 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, "default" },
     /* ATTR_DEFAULTCOLLELEM */  { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, "defaultcollelem" },
-    /* ATTR_DEFAULTVALUE_EXPR */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, "defaultvalue" },
-    /* ATTR_DEFAULTVALUE_STRING */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, "defaultvalue" },
+    /* ATTR_DEFAULTVALUE */     { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, "defaultvalue" },
     /* ATTR_DEFAULTVTABLE */    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "defaultvtable" },
     /* ATTR_DISPINTERFACE */    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL },
     /* ATTR_DISPLAYBIND */      { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, "displaybind" },
     /* ATTR_DLLNAME */          { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, "dllname" },
     /* ATTR_DUAL */             { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, "dual" },
     /* ATTR_ENDPOINT */         { 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, "endpoint" },
-    /* ATTR_ENTRY_ORDINAL */    { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, "entry" },
-    /* ATTR_ENTRY_STRING */     { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, "entry" },
+    /* ATTR_ENTRY */            { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, "entry" },
     /* ATTR_EXPLICIT_HANDLE */  { 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, "explicit_handle" },
     /* ATTR_HANDLE */           { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, "handle" },
     /* ATTR_HELPCONTEXT */      { 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, "helpcontext" },
@@ -5177,8 +5590,10 @@ struct allowed_attr allowed_attr[] =
     /* ATTR_IMMEDIATEBIND */    { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, "immediatebind" },
     /* ATTR_IMPLICIT_HANDLE */  { 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, "implicit_handle" },
     /* ATTR_IN */               { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, "in" },
+    /* ATTR_INLINE */           { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "inline" },
     /* ATTR_INPUTSYNC */        { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "inputsync" },
     /* ATTR_LENGTHIS */         { 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, "length_is" },
+    /* ATTR_LIBLCID */          { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, "lcid" },
     /* ATTR_LOCAL */            { 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, "local" },
     /* ATTR_NONBROWSABLE */     { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, "nonbrowsable" },
     /* ATTR_NONCREATABLE */     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "noncreatable" },
@@ -5218,7 +5633,7 @@ const char *get_attr_display_name(enum attr_type type)
     return allowed_attr[type].display_name;
 }
 
-static const attr_list_t *check_iface_attrs(const char *name, const attr_list_t *attrs)
+static attr_list_t *check_iface_attrs(const char *name, attr_list_t *attrs)
 {
   const attr_t *attr;
   if (!attrs) return attrs;
@@ -5289,7 +5704,7 @@ static attr_list_t *check_field_attrs(const char *name, attr_list_t *attrs)
   return attrs;
 }
 
-static const attr_list_t *check_library_attrs(const char *name, const attr_list_t *attrs)
+static attr_list_t *check_library_attrs(const char *name, attr_list_t *attrs)
 {
   const attr_t *attr;
   if (!attrs) return attrs;
@@ -5315,7 +5730,7 @@ static attr_list_t *check_dispiface_attrs(const char *name, attr_list_t *attrs)
   return attrs;
 }
 
-static const attr_list_t *check_module_attrs(const char *name, const attr_list_t *attrs)
+static attr_list_t *check_module_attrs(const char *name, attr_list_t *attrs)
 {
   const attr_t *attr;
   if (!attrs) return attrs;
@@ -5328,7 +5743,7 @@ static const attr_list_t *check_module_attrs(const char *name, const attr_list_t
   return attrs;
 }
 
-static const attr_list_t *check_coclass_attrs(const char *name, const attr_list_t *attrs)
+static attr_list_t *check_coclass_attrs(const char *name, attr_list_t *attrs)
 {
   const attr_t *attr;
   if (!attrs) return attrs;
@@ -5341,6 +5756,183 @@ static const attr_list_t *check_coclass_attrs(const char *name, const attr_list_
   return attrs;
 }
 
+static int is_allowed_conf_type(const type_t *type)
+{
+    switch (type->type)
+    {
+    case RPC_FC_CHAR:
+    case RPC_FC_SMALL:
+    case RPC_FC_BYTE:
+    case RPC_FC_USMALL:
+    case RPC_FC_WCHAR:
+    case RPC_FC_SHORT:
+    case RPC_FC_ENUM16:
+    case RPC_FC_USHORT:
+    case RPC_FC_LONG:
+    case RPC_FC_ENUM32:
+    case RPC_FC_ULONG:
+        return TRUE;
+    default:
+        return FALSE;
+    }
+}
+
+static int is_ptr_guid_type(const type_t *type)
+{
+    unsigned int align = 0;
+    for (;;)
+    {
+        if (type->kind == TKIND_ALIAS)
+            type = type->orig;
+        else if (is_ptr(type))
+        {
+            type = type->ref;
+            break;
+        }
+        else
+            return FALSE;
+    }
+    return (type_memsize(type, &align) == 16);
+}
+
+static void check_conformance_expr_list(const char *attr_name, const var_t *arg, const type_t *container_type, expr_list_t *expr_list)
+{
+    expr_t *dim;
+    struct expr_loc expr_loc;
+    expr_loc.v = arg;
+    expr_loc.attr = attr_name;
+    if (expr_list) LIST_FOR_EACH_ENTRY(dim, expr_list, expr_t, entry)
+    {
+        if (dim->type != EXPR_VOID)
+        {
+            const type_t *expr_type = expr_resolve_type(&expr_loc, container_type, dim);
+            if (!is_allowed_conf_type(expr_type))
+                error_loc_info(&arg->loc_info, "expression must resolve to integral type <= 32bits for attribute %s\n",
+                               attr_name);
+        }
+    }
+}
+
+static void check_remoting_fields(const var_t *var, type_t *type);
+
+/* checks that properties common to fields and arguments are consistent */
+static void check_field_common(const type_t *container_type,
+                               const char *container_name, const var_t *arg)
+{
+    type_t *type = arg->type;
+    int is_wire_marshal = 0;
+    int is_context_handle = 0;
+    const char *container_type_name = NULL;
+
+    if (is_struct(container_type->type))
+        container_type_name = "struct";
+    else if (is_union(container_type->type))
+        container_type_name = "union";
+    else if (container_type->type == RPC_FC_FUNCTION)
+        container_type_name = "function";
+
+    if (is_attr(arg->attrs, ATTR_LENGTHIS) &&
+        (is_attr(arg->attrs, ATTR_STRING) || is_aliaschain_attr(arg->type, ATTR_STRING)))
+        error_loc_info(&arg->loc_info,
+                       "string and length_is specified for argument %s are mutually exclusive attributes\n",
+                       arg->name);
+
+    if (is_attr(arg->attrs, ATTR_SIZEIS))
+    {
+        expr_list_t *size_is_exprs = get_attrp(arg->attrs, ATTR_SIZEIS);
+        check_conformance_expr_list("size_is", arg, container_type, size_is_exprs);
+    }
+    if (is_attr(arg->attrs, ATTR_LENGTHIS))
+    {
+        expr_list_t *length_is_exprs = get_attrp(arg->attrs, ATTR_LENGTHIS);
+        check_conformance_expr_list("length_is", arg, container_type, length_is_exprs);
+    }
+    if (is_attr(arg->attrs, ATTR_IIDIS))
+    {
+        struct expr_loc expr_loc;
+        expr_t *expr = get_attrp(arg->attrs, ATTR_IIDIS);
+        if (expr->type != EXPR_VOID)
+        {
+            const type_t *expr_type;
+            expr_loc.v = arg;
+            expr_loc.attr = "iid_is";
+            expr_type = expr_resolve_type(&expr_loc, container_type, expr);
+            if (!expr_type || !is_ptr_guid_type(expr_type))
+                error_loc_info(&arg->loc_info, "expression must resolve to pointer to GUID type for attribute iid_is\n");
+        }
+    }
+    if (is_attr(arg->attrs, ATTR_SWITCHIS))
+    {
+        struct expr_loc expr_loc;
+        expr_t *expr = get_attrp(arg->attrs, ATTR_SWITCHIS);
+        if (expr->type != EXPR_VOID)
+        {
+            const type_t *expr_type;
+            expr_loc.v = arg;
+            expr_loc.attr = "switch_is";
+            expr_type = expr_resolve_type(&expr_loc, container_type, expr);
+            if (!expr_type || !is_allowed_conf_type(expr_type))
+                error_loc_info(&arg->loc_info, "expression must resolve to integral type <= 32bits for attribute %s\n",
+                               expr_loc.attr);
+        }
+    }
+
+    /* get fundamental type for the argument */
+    for (;;)
+    {
+        if (is_attr(type->attrs, ATTR_WIREMARSHAL))
+        {
+            is_wire_marshal = 1;
+            break;
+        }
+        if (is_attr(type->attrs, ATTR_CONTEXTHANDLE))
+        {
+            is_context_handle = 1;
+            break;
+        }
+        if (type->kind == TKIND_ALIAS)
+            type = type->orig;
+        else if (is_ptr(type) || is_array(type))
+            type = type->ref;
+        else
+            break;
+    }
+
+    if (type->type == 0 && !is_attr(arg->attrs, ATTR_IIDIS) && !is_wire_marshal && !is_context_handle)
+        error_loc_info(&arg->loc_info, "parameter \'%s\' of %s \'%s\' cannot derive from void *\n", arg->name, container_type_name, container_name);
+    else if (type->type == RPC_FC_FUNCTION)
+        error_loc_info(&arg->loc_info, "parameter \'%s\' of %s \'%s\' cannot be a function pointer\n", arg->name, container_type_name, container_name);
+    else if (!is_wire_marshal &&