Index: Makefile.in
===================================================================
RCS file: /home/wine/wine/tools/widl/Makefile.in,v
retrieving revision 1.11
diff -u -b -r1.11 Makefile.in
--- Makefile.in	6 Jan 2005 20:45:21 -0000	1.11
+++ Makefile.in	22 Feb 2005 19:00:40 -0000
@@ -10,9 +10,11 @@
 MODULE   = none
 
 C_SRCS = \
+	client.c \
 	hash.c \
 	header.c \
 	proxy.c \
+	server.c \
 	typelib.c \
 	utils.c \
 	widl.c \
Index: hash.c
===================================================================
RCS file: /home/wine/wine/tools/widl/hash.c,v
retrieving revision 1.1
diff -u -b -r1.1 hash.c
--- hash.c	6 Jan 2005 20:45:21 -0000	1.1
+++ hash.c	22 Feb 2005 19:00:41 -0000
@@ -25,6 +25,7 @@
 #include "winbase.h"
 #include "winnls.h"
 
+#include "widltypes.h"
 #include "hash.h"
 
 static const unsigned char Lookup_16[128 * 3] = {
Index: header.c
===================================================================
RCS file: /home/wine/wine/tools/widl/header.c,v
retrieving revision 1.32
diff -u -b -r1.32 header.c
--- header.c	6 Jan 2005 20:45:21 -0000	1.32
+++ header.c	22 Feb 2005 19:00:42 -0000
@@ -669,7 +669,10 @@
     fprintf(header, " ");
     write_name(header, def);
     fprintf(header, "(\n");
+    if (cur->args)
     write_args(header, cur->args, iface->name, 0, TRUE);
+    else
+      fprintf(header, "    void");
     fprintf(header, ");\n");
 
     cur = PREV_LINK(cur);
@@ -784,6 +787,7 @@
 void write_rpc_interface(type_t *iface)
 {
   unsigned long ver = get_attrv(iface->attrs, ATTR_VERSION);
+  char *var = get_attrp(iface->attrs, ATTR_IMPLICIT_HANDLE);
 
   if (!iface->funcs) return;
 
@@ -791,6 +795,10 @@
   fprintf(header, " * %s interface (v%d.%d)\n", iface->name, LOWORD(ver), HIWORD(ver));
   fprintf(header, " */\n");
   write_iface_guid(iface);
+  if (var)
+  {
+    fprintf(header, "extern handle_t %s;\n", var);
+  }
   fprintf(header, "extern RPC_IF_HANDLE %s_v%d_%d_c_ifspec;\n", iface->name, LOWORD(ver), HIWORD(ver));
   fprintf(header, "extern RPC_IF_HANDLE %s_v%d_%d_s_ifspec;\n", iface->name, LOWORD(ver), HIWORD(ver));
   write_function_proto(iface);
Index: parser.l
===================================================================
RCS file: /home/wine/wine/tools/widl/parser.l,v
retrieving revision 1.26
diff -u -b -r1.26 parser.l
--- parser.l	3 Feb 2005 13:34:28 -0000	1.26
+++ parser.l	22 Feb 2005 19:00:42 -0000
@@ -218,7 +218,7 @@
 	{"entry",			tENTRY},
 	{"enum",			tENUM},
 	{"error_status_t",		tERRORSTATUST},
-/* ... */
+	{"explicit_handle",		tEXPLICITHANDLE},
 	{"extern",			tEXTERN},
 /* ... */
 	{"float",			tFLOAT},
@@ -239,6 +239,7 @@
 /* ... */
 	{"iid_is",			tIIDIS},
 /* ... */
+	{"implicit_handle",		tIMPLICITHANDLE},
 	{"import",			tIMPORT},
 	{"importlib",			tIMPORTLIB},
 	{"in",				tIN},
Index: parser.y
===================================================================
RCS file: /home/wine/wine/tools/widl/parser.y,v
retrieving revision 1.40
diff -u -b -r1.40 parser.y
--- parser.y	3 Feb 2005 13:34:28 -0000	1.40
+++ parser.y	22 Feb 2005 19:00:43 -0000
@@ -40,6 +40,9 @@
 #include "proxy.h"
 #include "typelib.h"
 
+#include "client.h"
+#include "server.h"
+
 #if defined(YYBYACC)
 	/* Berkeley yacc (byacc) doesn't seem to know about these */
 	/* Some *BSD supplied versions do define these though */
@@ -138,7 +141,7 @@
 %token tDLLNAME tDOUBLE tDUAL
 %token tENDPOINT
 %token tENTRY tENUM tERRORSTATUST
-%token tEXTERN
+%token tEXPLICITHANDLE tEXTERN
 %token tFLOAT
 %token tHANDLE
 %token tHANDLET
@@ -147,6 +150,7 @@
 %token tHIDDEN
 %token tHYPER tID tIDEMPOTENT
 %token tIIDIS
+%token tIMPLICITHANDLE
 %token tIMPORT tIMPORTLIB
 %token tIN tINCLUDE tINLINE
 %token tINPUTSYNC
@@ -224,7 +228,7 @@
 
 %%
 
-input:	  gbl_statements			{ write_proxies($1); }
+input:   gbl_statements                        { write_proxies($1); write_client($1); write_server($1); }
 	;
 
 gbl_statements:					{ $$ = NULL; }
@@ -333,6 +337,7 @@
 
 attribute:
 	  tASYNC				{ $$ = make_attr(ATTR_ASYNC); }
+	| tAUTOHANDLE				{ $$ = make_attr(ATTR_AUTO_HANDLE); }
 	| tCALLAS '(' ident ')'			{ $$ = make_attrp(ATTR_CALLAS, $3); }
 	| tCASE '(' expr_list_const ')'		{ $$ = make_attrp(ATTR_CASE, $3); }
 	| tCONTEXTHANDLE			{ $$ = make_attrv(ATTR_CONTEXTHANDLE, 0); }
@@ -347,6 +352,7 @@
 	| tENDPOINT '(' aSTRING ')'		{ $$ = make_attrp(ATTR_ENDPOINT, $3); }
 	| tENTRY '(' aSTRING ')'		{ $$ = make_attrp(ATTR_ENTRY_STRING, $3); }
 	| tENTRY '(' expr_const ')'		{ $$ = make_attrp(ATTR_ENTRY_ORDINAL, $3); }
+	| tEXPLICITHANDLE			{ $$ = make_attr(ATTR_EXPLICIT_HANDLE); }
 	| tHANDLE				{ $$ = make_attr(ATTR_HANDLE); }
 	| tHELPCONTEXT '(' expr_const ')'	{ $$ = make_attrp(ATTR_HELPCONTEXT, $3); }
 	| tHELPFILE '(' aSTRING ')'		{ $$ = make_attrp(ATTR_HELPFILE, $3); }
@@ -357,6 +363,7 @@
 	| tID '(' expr_const ')'		{ $$ = make_attrp(ATTR_ID, $3); }
 	| tIDEMPOTENT				{ $$ = make_attr(ATTR_IDEMPOTENT); }
 	| tIIDIS '(' ident ')'			{ $$ = make_attrp(ATTR_IIDIS, $3); }
+	| tIMPLICITHANDLE '(' tHANDLET aIDENTIFIER ')'	{ $$ = make_attrp(ATTR_IMPLICIT_HANDLE, $4); }
 	| tIN					{ $$ = make_attr(ATTR_IN); }
 	| tINPUTSYNC				{ $$ = make_attr(ATTR_INPUTSYNC); }
 	| tLENGTHIS '(' m_exprs ')'		{ $$ = make_attrp(ATTR_LENGTHIS, $3); }
@@ -490,7 +497,8 @@
 	;
 
 expr_const: expr				{ $$ = $1;
-						  if (!$$->is_const) yyerror("expression is not constant\n");
+						  if (!$$->is_const)
+						      yyerror("expression is not constant\n");
 						}
 	;
 
Index: widl.c
===================================================================
RCS file: /home/wine/wine/tools/widl/widl.c,v
retrieving revision 1.21
diff -u -b -r1.21 widl.c
--- widl.c	26 Jan 2005 19:40:47 -0000	1.21
+++ widl.c	22 Feb 2005 19:00:44 -0000
@@ -42,20 +42,16 @@
 /* future options to reserve characters for: */
 /* a = alignment of structures */
 /* A = ACF input filename */
-/* c = client stub only? */
-/* C = client stub filename */
 /* J = do not search standard include path */
 /* O = generate interpreted stubs */
-/* p = proxy only? */
-/* P = proxy filename */
-/* s = server stub only? */
-/* S = server stub filename */
 /* u = UUID file only? */
 /* U = UUID filename */
 /* w = select win16/win32 output (?) */
 
 static char usage[] =
 "Usage: widl [options...] infile.idl\n"
+"   -c          Generate client stub\n"
+"   -C file     Name of client stub file (default is infile_c.c)\n"
 "   -d n        Set debug level to 'n'\n"
 "   -D id[=val] Define preprocessor identifier id=val\n"
 "   -E          Preprocess only\n"
@@ -63,6 +59,10 @@
 "   -H file     Name of header file (default is infile.h)\n"
 "   -I path     Set include search dir to path (multiple -I allowed)\n"
 "   -N          Do not preprocess input\n"
+"   -p          Generate proxy\n"
+"   -P file     Name of proxy file (default is infile_p.c)\n"
+"   -s          Generate server stub\n"
+"   -S file     Name of server stub file (default is infile_s.c)\n"
 "   -t          Generate typelib\n"
 "   -T file     Name of typelib file (default is infile.tlb)\n"
 "   -V          Print version and exit\n"
@@ -88,6 +88,8 @@
 int do_header = 0;
 int do_typelib = 0;
 int do_proxies = 0;
+int do_client = 0;
+int do_server = 0;
 int no_preprocess = 0;
 
 char *input_name;
@@ -96,6 +98,10 @@
 char *typelib_name;
 char *proxy_name;
 char *proxy_token;
+char *client_name;
+char *client_token;
+char *server_name;
+char *server_token;
 char *temp_name;
 
 int line_number = 1;
@@ -137,8 +143,15 @@
 
   now = time(NULL);
 
-  while((optc = getopt(argc, argv, "d:D:EhH:I:NtT:VW")) != EOF) {
+  while((optc = getopt(argc, argv, "cC:d:D:EhH:I:NpP:sS:tT:VW")) != EOF) {
     switch(optc) {
+    case 'c':
+      do_everything = 0;
+      do_client = 1;
+      break;
+    case 'C':
+      client_name = strdup(optarg);
+      break;
     case 'd':
       debuglevel = strtol(optarg, NULL, 0);
       break;
@@ -162,6 +175,20 @@
     case 'N':
       no_preprocess = 1;
       break;
+    case 'p':
+      do_everything = 0;
+      do_proxies = 1;
+      break;
+    case 'P':
+      proxy_name = strdup(optarg);
+      break;
+    case 's':
+      do_everything = 0;
+      do_server = 1;
+      break;
+    case 'S':
+      server_name = strdup(optarg);
+      break;
     case 't':
       do_everything = 0;
       do_typelib = 1;
@@ -182,7 +209,7 @@
   }
 
   if(do_everything) {
-      do_header = do_typelib = do_proxies = 1;
+      do_header = do_typelib = do_proxies = do_client = do_server = 1;
   }
   if(optind < argc) {
     input_name = xstrdup(argv[optind]);
@@ -221,6 +248,18 @@
     strcat(proxy_name, "_p.c");
   }
 
+  if (!client_name && do_client) {
+    client_name = dup_basename(input_name, ".idl");
+    client_token = xstrdup(client_name);
+    strcat(client_name, "_c.c");
+  }
+
+  if (!server_name && do_server) {
+    server_name = dup_basename(input_name, ".idl");
+    server_token = xstrdup(server_name);
+    strcat(server_name, "_s.c");
+  }
+
   wpp_add_cmdline_define("__WIDL__");
 
   atexit(rm_tempfile);
@@ -284,6 +323,8 @@
     exit(1);
   }
   header_name = NULL;
+  client_name = NULL;
+  server_name = NULL;
   return 0;
 }
 
@@ -293,7 +334,11 @@
   if(temp_name)
     unlink(temp_name);
   if (header_name)
-    unlink( header_name );
+    unlink(header_name);
+  if (client_name)
+    unlink(client_name);
+  if (server_name)
+    unlink(server_name);
 }
 
 static void segvhandler(int sig)
Index: widl.h
===================================================================
RCS file: /home/wine/wine/tools/widl/widl.h,v
retrieving revision 1.8
diff -u -b -r1.8 widl.h
--- widl.h	26 Jan 2005 19:40:47 -0000	1.8
+++ widl.h	22 Feb 2005 19:00:44 -0000
@@ -41,12 +41,18 @@
 extern int do_header;
 extern int do_typelib;
 extern int do_proxies;
+extern int do_client;
+extern int do_server;
 
 extern char *input_name;
 extern char *header_name;
 extern char *typelib_name;
 extern char *proxy_name;
 extern char *proxy_token;
+extern char *client_name;
+extern char *client_token;
+extern char *server_name;
+extern char *server_token;
 extern time_t now;
 
 extern int line_number;
Index: widltypes.h
===================================================================
RCS file: /home/wine/wine/tools/widl/widltypes.h,v
retrieving revision 1.27
diff -u -b -r1.27 widltypes.h
--- widltypes.h	3 Feb 2005 13:34:28 -0000	1.27
+++ widltypes.h	22 Feb 2005 19:00:44 -0000
@@ -57,6 +57,7 @@
 enum attr_type
 {
     ATTR_ASYNC,
+    ATTR_AUTO_HANDLE,
     ATTR_CALLAS,
     ATTR_CASE,
     ATTR_CONTEXTHANDLE,
@@ -69,6 +70,7 @@
     ATTR_ENDPOINT,
     ATTR_ENTRY_STRING,
     ATTR_ENTRY_ORDINAL,
+    ATTR_EXPLICIT_HANDLE,
     ATTR_HANDLE,
     ATTR_HELPCONTEXT,
     ATTR_HELPFILE,
@@ -79,6 +81,7 @@
     ATTR_ID,
     ATTR_IDEMPOTENT,
     ATTR_IIDIS,
+    ATTR_IMPLICIT_HANDLE,
     ATTR_IN,
     ATTR_INPUTSYNC,
     ATTR_LENGTHIS,
--- /dev/null	2005-02-13 17:12:33.000000000 -0500
+++ server.c	2005-02-22 13:24:05.000000000 -0500
@@ -0,0 +1,460 @@
+/*
+ * IDL Compiler
+ *
+ * Copyright 2005 Eric Kohl
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "config.h"
+#include "wine/port.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+#include <string.h>
+#include <assert.h>
+#include <ctype.h>
+#include <signal.h>
+
+#include "widl.h"
+#include "utils.h"
+#include "parser.h"
+#include "header.h"
+#include "windef.h"
+
+#include "widltypes.h"
+#include "typelib.h"
+#include "typelib_struct.h"
+
+#define END_OF_LIST(list)       \
+  do {                          \
+    if (list) {                 \
+      while (NEXT_LINK(list))   \
+        list = NEXT_LINK(list); \
+    }                           \
+  } while(0)
+
+static FILE* server;
+static int indent = 0;
+
+
+static int print_server(const char *format, ...)
+{
+    va_list va;
+    int i, r;
+
+    va_start(va, format);
+    for (i = 0; i < indent; i++)
+        fprintf(server, "    ");
+    r = vfprintf(server, format, va);
+    va_end(va);
+    return r;
+}
+
+
+static void write_procformatstring(type_t *iface)
+{
+    func_t *cur = iface->funcs;
+
+    print_server("static const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString =\n");
+    print_server("{\n");
+    indent++;
+    print_server("0,\n");
+    print_server("{\n");
+    indent++;
+
+    while (NEXT_LINK(cur)) cur = NEXT_LINK(cur);
+    while (cur)
+    {
+        var_t *def = cur->def;
+
+        if (is_void(def->type, NULL))
+        {
+            print_server("0x5b,    /* FC_END */\n");
+            print_server("0x5c,    /* FC_PAD */\n");
+        }
+        else
+        {
+            print_server("0x53,    /* FC_RETURN_PARAM_BASETYPE */\n");
+            print_server("0x%02x,    /* <type> */\n", def->type->type);
+        }
+
+        cur = PREV_LINK(cur);
+    }
+
+    print_server("0x0\n");
+    indent--;
+    print_server("}\n");
+    indent--;
+    print_server("};\n");
+    print_server("\n");
+}
+
+
+static void write_typeformatstring(void)
+{
+    print_server("static const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString =\n");
+    print_server("{\n");
+    indent++;
+    print_server("0,\n");
+    print_server("{\n");
+    indent++;
+    print_server("NdrFcShort(0x0),\n");
+    print_server("0x0\n");
+    indent--;
+    print_server("}\n");
+    indent--;
+    print_server("};\n");
+    print_server("\n");
+}
+
+
+unsigned int get_required_stack_size(type_t *type)
+{
+    switch(type->type)
+    {
+        case RPC_FC_BYTE:
+        case RPC_FC_CHAR:
+        case RPC_FC_WCHAR:
+        case RPC_FC_USHORT:
+        case RPC_FC_SHORT:
+        case RPC_FC_ULONG:
+        case RPC_FC_LONG:
+            return 4;
+
+      case RPC_FC_HYPER:
+            return 8;
+
+        default:
+            error("Unknown/unsupported type: %s\n", type->name);
+    }
+}
+
+
+static void write_function_stubs(type_t *iface)
+{
+    func_t *cur = iface->funcs;
+    while (NEXT_LINK(cur)) cur = NEXT_LINK(cur);
+    while (cur)
+    {
+        var_t *def = cur->def;
+
+        write_type(server, def->type, def, def->tname);
+        fprintf(server, " __RPC_STUB\n");
+        fprintf(server, "%s_", iface->name);
+        write_name(server, def);
+        fprintf(server, "(\n");
+        indent++;
+        print_server("PRPC_MESSAGE _pRpcMessage)\n");
+        indent--;
+
+        /* write the functions body */
+        fprintf(server, "{\n");
+        indent++;
+
+        /* declare return value '_RetVal' */
+        if (!is_void(def->type, NULL))
+        {
+            print_server("");
+            write_type(server, def->type, def, def->tname);
+            fprintf(server, " _RetVal;\n");
+        }
+
+        print_server("MIDL_STUB_MESSAGE _StubMsg;\n");
+        print_server("RPC_STATUS _Status;\n");
+        fprintf(server, "\n");
+        print_server("((void)(_Status));\n");
+        print_server("NdrServerInitializeNew(\n");
+        indent++;
+        print_server("_pRpcMessage,\n");
+        print_server("&_StubMsg,\n");
+        print_server("&%s_StubDesc);\n", iface->name);
+        indent--;
+        fprintf(server, "\n");
+
+        print_server("RpcTryFinally\n");
+        print_server("{\n");
+        indent++;
+        print_server("RpcTryExcept\n");
+        print_server("{\n");
+        indent++;
+        print_server("if (_StubMsg.Buffer > _StubMsg.BufferEnd)\n");
+        print_server("{\n");
+        indent++;
+        print_server("RpcRaiseException(RPC_X_BAD_STUB_DATA);\n");
+        indent--;
+        print_server("}\n");
+        indent--;
+        print_server("}\n");
+        print_server("RpcExcept(RPC_BAD_STUB_DATA_EXCEPTION_FILTER)\n");
+        print_server("{\n");
+        indent++;
+        print_server("RpcRaiseException(RPC_X_BAD_STUB_DATA);\n");
+        indent--;
+        print_server("}\n");
+        print_server("RpcEndExcept\n");
+        fprintf(server, "\n");
+
+
+        /* Call the real server function */
+        if (!is_void(def->type, NULL))
+            print_server("_RetVal = ");
+        else
+            print_server("");
+        write_name(server, def);
+
+        /* FIXME: handle argument list */
+        fprintf(server, "();\n");
+
+        /* FIXME: Marshall the return value */
+        if (!is_void(def->type, NULL))
+        {
+            fprintf(server, "\n");
+            print_server("_StubMsg.BufferLength = %uU;\n", get_required_stack_size(def->type));
+            print_server("_pRpcMessage->BufferLength = _StubMsg.BufferLength;\n");
+            fprintf(server, "\n");
+            print_server("_Status = I_RpcGetBuffer(_pRpcMessage);\n");
+            print_server("if (_Status)\n");
+            indent++;
+            print_server("RpcRaiseException(_Status);\n");
+            indent--;
+            fprintf(server, "\n");
+            print_server("_StubMsg.Buffer = (unsigned char __RPC_FAR *)_pRpcMessage->Buffer;\n");
+            fprintf(server, "\n");
+
+            print_server("*((");
+            write_type(server, def->type, def, def->tname);
+            fprintf(server, " __RPC_FAR *)_StubMsg.Buffer)++ = _RetVal;\n");
+        }
+
+        indent--;
+        print_server("}\n");
+        print_server("RpcFinally\n");
+        print_server("{\n");
+        print_server("}\n");
+        print_server("RpcEndFinally\n");
+
+        /* calculate buffer length */
+        fprintf(server, "\n");
+        print_server("_pRpcMessage->BufferLength =\n");
+        indent++;
+        print_server("(unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);\n");
+        indent--;
+        indent--;
+        fprintf(server, "}\n");
+        fprintf(server, "\n");
+
+        cur = PREV_LINK(cur);
+    }
+}
+
+
+static void write_dispatchtable(type_t *iface)
+{
+    unsigned long ver = get_attrv(iface->attrs, ATTR_VERSION);
+    unsigned long method_count = 0;
+    func_t *cur = iface->funcs;
+
+    print_server("static RPC_DISPATCH_FUNCTION %s_table[] =\n", iface->name);
+    print_server("{\n");
+    indent++;
+    while (NEXT_LINK(cur)) cur = NEXT_LINK(cur);
+    while (cur)
+    {
+        var_t *def = cur->def;
+
+        print_server("%s_", iface->name);
+        write_name(server, def);
+        fprintf(server, ",\n");
+
+        method_count++;
+        cur = PREV_LINK(cur);
+    }
+    print_server("0\n");
+    indent--;
+    print_server("};\n");
+    print_server("RPC_DISPATCH_TABLE %s_v%d_%d_DispatchTable =\n", iface->name, LOWORD(ver), HIWORD(ver));
+    print_server("{\n");
+    indent++;
+    print_server("%u,\n", method_count);
+    print_server("%s_table\n", iface->name);
+    indent--;
+    print_server("};\n");
+    fprintf(server, "\n");
+}
+
+
+static void write_stubdescdecl(type_t *iface)
+{
+    print_server("extern const MIDL_STUB_DESC %s_StubDesc;\n", iface->name);
+    fprintf(server, "\n");
+}
+
+
+static void write_stubdescriptor(type_t *iface)
+{
+    print_server("static const MIDL_STUB_DESC %s_StubDesc =\n", iface->name);
+    print_server("{\n");
+    indent++;
+    print_server("(void __RPC_FAR *)& %s___RpcServerInterface,\n", iface->name);
+    print_server("MIDL_user_allocate,\n");
+    print_server("MIDL_user_free,\n");
+    print_server("0,\n");
+    print_server("0,\n");
+    print_server("0,\n");
+    print_server("0,\n");
+    print_server("0,\n");
+    print_server("__MIDL_TypeFormatString.Format,\n");
+    print_server("1, /* -error bounds_check flag */\n");
+    print_server("0x10001, /* Ndr library version */\n");
+    print_server("0,\n");
+    print_server("0x50100a4, /* MIDL Version 5.1.164 */\n");
+    print_server("0,\n");
+    print_server("0,\n");
+    print_server("0,  /* notify & notify_flag routine table */\n");
+    print_server("1,  /* Flags */\n");
+    print_server("0,  /* Reserved3 */\n");
+    print_server("0,  /* Reserved4 */\n");
+    print_server("0   /* Reserved5 */\n");
+    indent--;
+    print_server("};\n");
+    fprintf(server, "\n");
+}
+
+
+static void write_serverinterfacedecl(type_t *iface)
+{
+    unsigned long ver = get_attrv(iface->attrs, ATTR_VERSION);
+    UUID *uuid = get_attrp(iface->attrs, ATTR_UUID);
+
+    print_server("extern RPC_DISPATCH_TABLE %s_v%d_%d_DispatchTable;\n", iface->name, LOWORD(ver), HIWORD(ver));
+    fprintf(server, "\n");
+    print_server("static const RPC_SERVER_INTERFACE %s___RpcServerInterface =\n", iface->name );
+    print_server("{\n");
+    indent++;
+    print_server("sizeof(RPC_SERVER_INTERFACE),\n");
+    print_server("{{0x%08lx,0x%04x,0x%04x,{0x%02x,0x%02x,0x%02x,0x%02x,0x%02x,0x%02x,0x%02x,0x%02x}},{%d,%d}},\n",
+                 uuid->Data1, uuid->Data2, uuid->Data3, uuid->Data4[0], uuid->Data4[1],
+                 uuid->Data4[2], uuid->Data4[3], uuid->Data4[4], uuid->Data4[5], uuid->Data4[6],
+                 uuid->Data4[7], LOWORD(ver), HIWORD(ver));
+    print_server("{{0x8a885d04,0x1ceb,0x11c9,{0x9f,0xe8,0x08,0x00,0x2b,0x10,0x48,0x60}},{2,0}},\n"); /* FIXME */
+    print_server("&%s_v%d_%d_DispatchTable,\n", iface->name, LOWORD(ver), HIWORD(ver));
+    print_server("0,\n");
+    print_server("0,\n");
+    print_server("0,\n");
+    print_server("0,\n");
+    print_server("0,\n");
+    indent--;
+    print_server("};\n");
+    print_server("RPC_IF_HANDLE %s_v%d_%d_s_ifspec = (RPC_IF_HANDLE)& %s___RpcServerInterface;\n",
+                 iface->name, LOWORD(ver), HIWORD(ver), iface->name);
+    fprintf(server, "\n");
+}
+
+static void write_formatdesc( const char *str )
+{
+    print_server("typedef struct _MIDL_%s_FORMAT_STRING\n", str );
+    print_server("{\n");
+    indent++;
+    print_server("short Pad;\n");
+    print_server("unsigned char Format[%s_FORMAT_STRING_SIZE];\n", str);
+    indent--;
+    print_server("} MIDL_%s_FORMAT_STRING;\n", str);
+    print_server("\n");
+}
+
+
+static void write_formatstringsdecl(type_t *iface)
+{
+    func_t *cur;
+    int byte_count = 1;
+
+    print_server("#define TYPE_FORMAT_STRING_SIZE %d\n", 3); /* FIXME */
+
+    /* determine the proc format string size */
+    cur = iface->funcs;
+    while (NEXT_LINK(cur)) cur = NEXT_LINK(cur);
+    while (cur)
+    {
+        byte_count += 2; /* FIXME: determine real size */
+        cur = PREV_LINK(cur);
+    }
+    print_server("#define PROC_FORMAT_STRING_SIZE %d\n", byte_count);
+
+    fprintf(server, "\n");
+    write_formatdesc("TYPE");
+    write_formatdesc("PROC");
+    fprintf(server, "\n");
+    print_server("extern const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString;\n");
+    print_server("extern const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString;\n");
+    print_server("\n");
+}
+
+
+static void init_server(void)
+{
+    if (server)
+        return;
+    if (!(server = fopen(server_name, "w")))
+        error("Could not open %s for output\n", server_name);
+
+    print_server("/*** Autogenerated by WIDL %s from %s - Do not edit ***/\n", WIDL_FULLVERSION, input_name);
+    print_server("#include<string.h>\n");
+    fprintf(server, "\n");
+    print_server("#include\"%s\"\n", header_name);
+    fprintf(server, "\n");
+}
+
+
+void write_server(ifref_t *ifaces)
+{
+    ifref_t *lcur = ifaces;
+    char *file_id = server_token;
+    int c;
+
+    if (!do_server)
+        return;
+    if (!lcur)
+        return;
+    END_OF_LIST(lcur);
+
+    init_server();
+    if (!server)
+        return;
+
+    write_formatstringsdecl(lcur->iface);
+    write_serverinterfacedecl(lcur->iface);
+    write_stubdescdecl(lcur->iface);
+
+    write_function_stubs(lcur->iface);
+
+    write_stubdescriptor(lcur->iface);
+    write_dispatchtable(lcur->iface);
+
+    print_server("#if !defined(__RPC_WIN32__)\n");
+    print_server("#error  Invalid build platform for this stub.\n");
+    print_server("#endif\n");
+    fprintf(server, "\n");
+
+    write_procformatstring(lcur->iface);
+    write_typeformatstring();
+
+    fprintf(server, "\n");
+
+    fclose(server);
+}
--- /dev/null	2005-02-13 17:12:33.000000000 -0500
+++ server.h	2005-02-22 13:59:14.000000000 -0500
@@ -0,0 +1,26 @@
+/*
+ * IDL Compiler
+ *
+ * Copyright 2005 Eric Kohl
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef __WIDL_SERVER_H
+#define __WIDL_SERVER_H
+
+extern void write_server(ifref_t *ifaces);
+
+#endif
--- /dev/null	2005-02-13 17:12:33.000000000 -0500
+++ client.c	2005-02-22 13:19:54.000000000 -0500
@@ -0,0 +1,451 @@
+/*
+ * IDL Compiler
+ *
+ * Copyright 2005 Eric Kohl
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "config.h"
+#include "wine/port.h"
+ 
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <assert.h>
+#include <ctype.h>
+#include <signal.h>
+
+#include "windef.h"
+
+#include "widl.h"
+#include "utils.h"
+#include "parser.h"
+#include "header.h"
+
+#include "widltypes.h"
+#include "typelib.h"
+#include "typelib_struct.h"
+
+#define END_OF_LIST(list)       \
+  do {                          \
+    if (list) {                 \
+      while (NEXT_LINK(list))   \
+        list = NEXT_LINK(list); \
+    }                           \
+  } while(0)
+
+static FILE* client;
+static int indent = 0;
+
+static int print_client( const char *format, ... )
+{
+    va_list va;
+    int i, r;
+
+    va_start(va, format);
+    for (i = 0; i < indent; i++)
+        fprintf(client, "    ");
+    r = vfprintf(client, format, va);
+    va_end(va);
+    return r;
+}
+
+
+static void write_procformatstring(type_t *iface)
+{
+    func_t *cur = iface->funcs;
+
+    print_client("static const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString =\n");
+    print_client("{\n");
+    indent++;
+    print_client("0,\n");
+    print_client("{\n");
+    indent++;
+
+    while (NEXT_LINK(cur)) cur = NEXT_LINK(cur);
+    while (cur)
+    {
+        var_t *def = cur->def;
+
+        if (is_void(def->type, NULL))
+        {
+            print_client("0x5b,    /* FC_END */\n");
+            print_client("0x5c,    /* FC_PAD */\n");
+        }
+        else
+        {
+            print_client("0x53,    /* FC_RETURN_PARAM_BASETYPE */\n");
+            print_client("0x%02x,    /* <type> */\n", def->type->type);
+        }
+
+        cur = PREV_LINK(cur);
+    }
+
+    print_client("0x0\n");
+    indent--;
+    print_client("}\n");
+    indent--;
+    print_client("};\n");
+    print_client("\n");
+}
+
+
+static void write_typeformatstring(void)
+{
+    print_client("static const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString =\n");
+    print_client("{\n");
+    indent++;
+    print_client("0,\n");
+    print_client("{\n");
+    indent++;
+    print_client("NdrFcShort(0x0),\n");
+    print_client("0x0\n");
+    indent--;
+    print_client("}\n");
+    indent--;
+    print_client("};\n");
+    print_client("\n");
+}
+
+
+static void write_function_stubs(type_t *iface)
+{
+    func_t *cur = iface->funcs;
+    char *handle_name = get_attrp(iface->attrs, ATTR_IMPLICIT_HANDLE);
+    int method_count = 0;
+    unsigned int proc_offset = 0;
+
+    while (NEXT_LINK(cur)) cur = NEXT_LINK(cur);
+    while (cur)
+    {
+        var_t *def = cur->def;
+
+        write_type(client, def->type, def, def->tname);
+        fprintf(client, " ");
+        write_name(client, def);
+        fprintf(client, "(\n");
+        indent++;
+        if (cur->args)
+            write_args(client, cur->args, iface->name, 0, TRUE);
+        else
+            print_client("void");
+        fprintf(client, ")\n");
+        indent--;
+
+        /* write the functions body */
+        fprintf(client, "{\n");
+        indent++;
+
+        /* declare return value '_RetVal' */
+        if (!is_void(def->type, NULL))
+        {
+            print_client("");
+            write_type(client, def->type, def, def->tname);
+            fprintf(client, " _RetVal;\n");
+        }
+
+        if (handle_name)
+            print_client("RPC_BINDING_HANDLE _Handle = 0;\n");
+
+        print_client("RPC_MESSAGE _RpcMessage;\n");
+        print_client("MIDL_STUB_MESSAGE _StubMsg;\n");
+        fprintf(client, "\n");
+        print_client("RpcTryFinally\n");
+        print_client("{\n");
+        indent++;
+
+        print_client("NdrClientInitializeNew(\n");
+        indent++;
+        print_client("(PRPC_MESSAGE)&_RpcMessage,\n");
+        print_client("(PMIDL_STUB_MESSAGE)&_StubMsg,\n");
+        print_client("(PMIDL_STUB_DESC)&%s_StubDesc,\n", iface->name);
+        print_client("%d);\n", method_count);
+        indent--;
+        fprintf(client, "\n");
+
+        if (handle_name)
+            print_client("_Handle = %s;\n", handle_name);
+
+        /* FIXME: marshal arguments */
+        print_client("_StubMsg.BufferLength = 0UL;\n");
+//        print_client("NdrNsGetBuffer(\n");
+        print_client("NdrGetBuffer(\n");
+        indent++;
+        print_client("(PMIDL_STUB_MESSAGE)&_StubMsg,\n");
+        print_client("_StubMsg.BufferLength,\n");
+        if (handle_name)
+            print_client("%_Handle);\n");
+        else
+            print_client("%s__MIDL_AutoBindHandle);\n", iface->name);
+        indent--;
+        fprintf(client, "\n");
+
+
+        /* send/recieve message */
+//        print_client("NdrNsSendReceive(\n");
+        print_client("NdrSendReceive(\n");
+        indent++;
+        print_client("(PMIDL_STUB_MESSAGE)&_StubMsg,\n");
+        print_client("(unsigned char __RPC_FAR *)_StubMsg.Buffer);\n");
+//        print_client("(unsigned char __RPC_FAR *)_StubMsg.Buffer,\n");
+//        print_client("(RPC_BINDING_HANDLE __RPC_FAR *) &%s__MIDL_AutoBindHandle);\n", iface->name);
+        indent--;
+
+        /* unmarshal return value */
+        if (is_void(def->type, NULL))
+        {
+            proc_offset += 2;
+        }
+        else
+        {
+            fprintf(client, "\n");
+
+            print_client("if ((_RpcMessage.DataRepresentation & 0x0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION)\n");
+            indent++;
+            print_client("NdrConvert(\n");
+            indent++;
+            print_client("(PMIDL_STUB_MESSAGE)&_StubMsg,\n");
+            print_client("(PFORMAT_STRING)&__MIDL_ProcFormatString[%u]);\n", proc_offset);
+            indent -= 2;
+            fprintf(client, "\n");
+
+            print_client("_RetVal = *((");
+            write_type(client, def->type, def, def->tname);
+            fprintf(client, " __RPC_FAR *)_StubMsg.Buffer)++;\n");
+
+            /* FIXME: update proc_offset */
+            proc_offset += 2;
+        }
+
+        indent--;
+        print_client("}\n");
+        print_client("RpcFinally\n");
+        print_client("{\n");
+        indent++;
+
+
+        /* FIXME: emit client finally code */
+
+        print_client("NdrFreeBuffer((PMIDL_STUB_MESSAGE)&_StubMsg);\n");
+
+        indent--;
+        print_client("}\n");
+        print_client("RpcEndFinally\n");
+
+
+        /* emit return code */
+        if (!is_void(def->type, NULL))
+        {
+            fprintf(client, "\n");
+            print_client("return _RetVal;\n");
+        }
+
+        indent--;
+        fprintf(client, "}\n");
+        fprintf(client, "\n");
+
+        method_count++;
+        cur = PREV_LINK(cur);
+    }
+}
+
+
+static void write_bindinghandledecl(type_t *iface)
+{
+    print_client("static RPC_BINDING_HANDLE %s__MIDL_AutoBindHandle;\n", iface->name);
+    fprintf(client, "\n");
+}
+
+
+static void write_stubdescdecl(type_t *iface)
+{
+    print_client("extern const MIDL_STUB_DESC %s_StubDesc;\n", iface->name);
+    fprintf(client, "\n");
+}
+
+
+static void write_stubdescriptor(type_t *iface)
+{
+    char *handle_name = get_attrp(iface->attrs, ATTR_IMPLICIT_HANDLE);
+
+    print_client("static const MIDL_STUB_DESC %s_StubDesc =\n", iface->name);
+    print_client("{\n");
+    indent++;
+    print_client("(void __RPC_FAR *)& %s___RpcClientInterface,\n", iface->name);
+    print_client("MIDL_user_allocate,\n");
+    print_client("MIDL_user_free,\n");
+    if (handle_name)
+        print_client("&%s,\n", handle_name);
+    else
+        print_client("&%s__MIDL_AutoBindHandle,\n", iface->name);
+    print_client("0,\n");
+    print_client("0,\n");
+    print_client("0,\n");
+    print_client("0,\n");
+    print_client("__MIDL_TypeFormatString.Format,\n");
+    print_client("1, /* -error bounds_check flag */\n");
+    print_client("0x10001, /* Ndr library version */\n");
+    print_client("0,\n");
+    print_client("0x50100a4, /* MIDL Version 5.1.164 */\n");
+    print_client("0,\n");
+    print_client("0,\n");
+    print_client("0,  /* notify & notify_flag routine table */\n");
+    print_client("1,  /* Flags */\n");
+    print_client("0,  /* Reserved3 */\n");
+    print_client("0,  /* Reserved4 */\n");
+    print_client("0   /* Reserved5 */\n");
+    indent--;
+    print_client("};\n");
+    fprintf(client, "\n");
+}
+
+
+static void write_clientinterfacedecl(type_t *iface)
+{
+    unsigned long ver = get_attrv(iface->attrs, ATTR_VERSION);
+    UUID *uuid = get_attrp(iface->attrs, ATTR_UUID);
+
+    print_client("static const RPC_CLIENT_INTERFACE %s___RpcClientInterface =\n", iface->name );
+    print_client("{\n");
+    indent++;
+    print_client("sizeof(RPC_CLIENT_INTERFACE),\n");
+    print_client("{{0x%08lx,0x%04x,0x%04x,{0x%02x,0x%02x,0x%02x,0x%02x,0x%02x,0x%02x,0x%02x,0x%02x}},{%d,%d}},\n",
+                 uuid->Data1, uuid->Data2, uuid->Data3, uuid->Data4[0], uuid->Data4[1],
+                 uuid->Data4[2], uuid->Data4[3], uuid->Data4[4], uuid->Data4[5], uuid->Data4[6],
+                 uuid->Data4[7], LOWORD(ver), HIWORD(ver));
+    print_client("{{0x8a885d04,0x1ceb,0x11c9,{0x9f,0xe8,0x08,0x00,0x2b,0x10,0x48,0x60}},{2,0}},\n"); /* FIXME */
+    print_client("0,\n");
+    print_client("0,\n");
+    print_client("0,\n");
+    print_client("0,\n");
+    print_client("0,\n");
+    print_client("0,\n");
+    indent--;
+    print_client("};\n");
+    print_client("RPC_IF_HANDLE %s_v%d_%d_c_ifspec = (RPC_IF_HANDLE)& %s___RpcClientInterface;\n",
+                 iface->name, LOWORD(ver), HIWORD(ver), iface->name);
+    fprintf(client, "\n");
+}
+
+
+static void write_formatdesc( const char *str )
+{
+    print_client("typedef struct _MIDL_%s_FORMAT_STRING\n", str );
+    print_client("{\n");
+    indent++;
+    print_client("short Pad;\n");
+    print_client("unsigned char Format[%s_FORMAT_STRING_SIZE];\n", str);
+    indent--;
+    print_client("} MIDL_%s_FORMAT_STRING;\n", str);
+    print_client("\n");
+}
+
+
+static void write_formatstringsdecl(type_t *iface)
+{
+    func_t *cur;
+    int byte_count = 1;
+
+    print_client("#define TYPE_FORMAT_STRING_SIZE %d\n", 3); /* FIXME */
+
+    /* determine the proc format string size */
+    cur = iface->funcs;
+    while (NEXT_LINK(cur)) cur = NEXT_LINK(cur);
+    while (cur)
+    {
+        byte_count += 2; /* FIXME: determine real size */
+        cur = PREV_LINK(cur);
+    }
+    print_client("#define PROC_FORMAT_STRING_SIZE %d\n", byte_count);
+
+    fprintf(client, "\n");
+    write_formatdesc("TYPE");
+    write_formatdesc("PROC");
+    fprintf(client, "\n");
+    print_client("extern const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString;\n");
+    print_client("extern const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString;\n");
+    print_client("\n");
+}
+
+
+static void write_implicithandledecl(type_t *iface)
+{
+    char *var = get_attrp(iface->attrs, ATTR_IMPLICIT_HANDLE);
+
+    if (var)
+    {
+        fprintf(client, "handle_t %s;\n", var);
+        fprintf(client, "\n");
+    }
+}
+
+
+static void init_client(void)
+{
+    if (client) return;
+    if (!(client = fopen(client_name, "w")))
+        error("Could not open %s for output\n", client_name);
+
+    print_client("/*** Autogenerated by WIDL %s from %s - Do not edit ***/\n", WIDL_FULLVERSION, input_name);
+    print_client("#include<string.h>\n");
+    print_client("#ifdef _ALPHA_\n");
+    print_client("#include<stdarg.h>\n");
+    print_client("#endif\n");
+    fprintf(client, "\n");
+    print_client("#include\"%s\"\n", header_name);
+    fprintf(client, "\n");
+}
+
+
+void write_client(ifref_t *ifaces)
+{
+    ifref_t *lcur = ifaces;
+    char *file_id = client_token;
+    int c;
+
+    if (!do_client)
+        return;
+    if (!lcur)
+        return;
+    END_OF_LIST(lcur);
+
+    init_client();
+    if (!client)
+        return;
+
+    write_formatstringsdecl(lcur->iface);
+    write_implicithandledecl(lcur->iface);
+
+    write_clientinterfacedecl(lcur->iface);
+    write_stubdescdecl(lcur->iface);
+    write_bindinghandledecl(lcur->iface);
+
+    write_function_stubs(lcur->iface);
+    write_stubdescriptor(lcur->iface);
+
+    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_procformatstring(lcur->iface);
+    write_typeformatstring();
+
+    fprintf(client, "\n");
+
+    fclose(client);
+}
--- /dev/null	2005-02-13 17:12:33.000000000 -0500
+++ client.h	2005-02-22 13:59:10.000000000 -0500
@@ -0,0 +1,26 @@
+/*
+ * IDL Compiler
+ *
+ * Copyright 2005 Eric Kohl
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef __WIDL_CLIENT_H
+#define __WIDL_CLIENT_H
+
+extern void write_client(ifref_t *ifaces);
+
+#endif
