mirror of
https://github.com/reactos/reactos.git
synced 2025-05-24 19:56:38 +00:00
Sync to wine-0.9.60:
- Rob Shearman <rob@codeweavers.com> Wed, 26 Mar 2008 widl: Support using context handles as the binding handle in client functions. - Rob Shearman <rob@codeweavers.com> Thu, 27 Mar 2008 widl: Use is_string_type for detecting strings in write_typeformatstring_var to make it consistent with write_remoting_arg. - Rob Shearman <rob@codeweavers.com> Thu, 27 Mar 2008 widl: Add support for generic binding handles. - Rob Shearman <rob@codeweavers.com> Thu, 27 Mar 2008 widl: Fix detection of non-pointer context handles. - Rob Shearman <rob@codeweavers.com> Thu, 27 Mar 2008 widl: Make sure that string types are always written out by write_string_tfs and not write_simple_pointer. - Rob Shearman <rob@codeweavers.com> Mon, 31 Mar 2008 widl: Parse typedefs of function pointers. - Rob Shearman <rob@codeweavers.com> Tue, 1 Apr 2008 widl: Be more strict about where semicolons can appear in IDL files. - Rob Shearman <rob@codeweavers.com> Wed, 2 Apr 2008 widl: Add a function to get the return type of a parsed function. - Rob Shearman <rob@codeweavers.com> Wed, 2 Apr 2008 widl: Store function and function pointer types completely within type_t type. - Rob Shearman <rob@codeweavers.com> Wed, 2 Apr 2008 widl: Support parsing calling conventions for function identifiers. - Rob Shearman <rob@codeweavers.com> Wed, 2 Apr 2008 widl: Support __fastcall and __pascal calling conventions. - Rob Shearman <rob@codeweavers.com> Wed, 2 Apr 2008 widl: Add a newline between function prototypes for non-object interfaces. - Rob Shearman <rob@codeweavers.com> Wed, 2 Apr 2008 widl: Fix the writing out of function pointers with more than one level of indirection. - Rob Shearman <rob@codeweavers.com> Wed, 2 Apr 2008 widl: Turn on verbose errors, which gives a little more information in the case of a syntax error. - Dan Hipschman <dsh@linux.ucla.edu> Thu, 3 Apr 2008 widl: Fix a mistake in an ordered list (keywords). svn path=/trunk/; revision=36829
This commit is contained in:
Eric Kohl
parent
c2a9e1f979
commit
0690324f95
18 changed files with 2458 additions and 1913 deletions
|
|
@ -26,7 +26,7 @@ reactos/tools/wpp # Synced to Wine-0_9_5
|
|||
reactos/tools/winebuild # Synced to Wine-20071217
|
||||
reactos/tools/wmc # Synced to Wine-20071201
|
||||
reactos/tools/wrc # Synced to Wine-0_9_53
|
||||
reactos/tools/widl # Synced to Wine-0_9_58
|
||||
reactos/tools/widl # Synced to Wine-0_9_59
|
||||
|
||||
The following libraries are shared with Wine.
|
||||
|
||||
|
|
|
|||
|
|
@ -70,6 +70,20 @@ 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;
|
||||
|
|
@ -85,13 +99,21 @@ static void write_function_stubs(type_t *iface, unsigned int *proc_offset)
|
|||
{
|
||||
const var_t *def = func->def;
|
||||
const var_t* explicit_handle_var;
|
||||
const var_t* explicit_generic_handle_var = NULL;
|
||||
const var_t* context_handle_var = NULL;
|
||||
int has_full_pointer = is_full_pointer_function(func);
|
||||
|
||||
/* check for a defined binding handle */
|
||||
explicit_handle_var = get_explicit_handle_var(func);
|
||||
if (!explicit_handle_var)
|
||||
{
|
||||
explicit_generic_handle_var = get_explicit_generic_handle_var(func);
|
||||
if (!explicit_generic_handle_var)
|
||||
context_handle_var = get_context_handle_var(func);
|
||||
}
|
||||
if (explicit_handle)
|
||||
{
|
||||
if (!explicit_handle_var)
|
||||
if (!explicit_handle_var && !explicit_generic_handle_var && !context_handle_var)
|
||||
{
|
||||
error("%s() does not define an explicit binding handle!\n", def->name);
|
||||
return;
|
||||
|
|
@ -106,8 +128,8 @@ static void write_function_stubs(type_t *iface, unsigned int *proc_offset)
|
|||
}
|
||||
}
|
||||
|
||||
write_type_decl_left(client, def->type);
|
||||
if (needs_space_after(def->type))
|
||||
write_type_decl_left(client, get_func_return_type(func));
|
||||
if (needs_space_after(get_func_return_type(func)))
|
||||
fprintf(client, " ");
|
||||
write_prefix_name(client, prefix_client, def);
|
||||
fprintf(client, "(\n");
|
||||
|
|
@ -124,19 +146,19 @@ static void write_function_stubs(type_t *iface, unsigned int *proc_offset)
|
|||
indent++;
|
||||
|
||||
/* declare return value '_RetVal' */
|
||||
if (!is_void(def->type))
|
||||
if (!is_void(get_func_return_type(func)))
|
||||
{
|
||||
print_client("");
|
||||
write_type_decl_left(client, def->type);
|
||||
write_type_decl_left(client, get_func_return_type(func));
|
||||
fprintf(client, " _RetVal;\n");
|
||||
}
|
||||
|
||||
if (implicit_handle || explicit_handle_var)
|
||||
if (implicit_handle || explicit_handle_var || explicit_generic_handle_var || context_handle_var)
|
||||
print_client("RPC_BINDING_HANDLE _Handle = 0;\n");
|
||||
|
||||
print_client("RPC_MESSAGE _RpcMessage;\n");
|
||||
print_client("MIDL_STUB_MESSAGE _StubMsg;\n");
|
||||
if (!is_void(def->type) && decl_indirect(def->type))
|
||||
if (!is_void(get_func_return_type(func)) && decl_indirect(get_func_return_type(func)))
|
||||
{
|
||||
print_client("void *_p_%s = &%s;\n",
|
||||
"_RetVal", "_RetVal");
|
||||
|
|
@ -172,6 +194,25 @@ static void write_function_stubs(type_t *iface, unsigned int *proc_offset)
|
|||
print_client("_Handle = %s;\n", explicit_handle_var->name);
|
||||
fprintf(client, "\n");
|
||||
}
|
||||
else if (explicit_generic_handle_var)
|
||||
{
|
||||
print_client("_Handle = %s_bind(%s);\n",
|
||||
get_explicit_generic_handle_type(explicit_generic_handle_var)->name,
|
||||
explicit_generic_handle_var->name);
|
||||
fprintf(client, "\n");
|
||||
}
|
||||
else if (context_handle_var)
|
||||
{
|
||||
/* if the context_handle attribute appears in the chain of types
|
||||
* without pointers being followed, then the context handle must
|
||||
* be direct, otherwise it is a pointer */
|
||||
int is_ch_ptr = is_aliaschain_attr(context_handle_var->type, ATTR_CONTEXTHANDLE) ? FALSE : TRUE;
|
||||
print_client("if (%s%s != 0)\n", is_ch_ptr ? "*" : "", context_handle_var->name);
|
||||
indent++;
|
||||
print_client("_Handle = NDRCContextBinding(%s%s);\n", is_ch_ptr ? "*" : "", context_handle_var->name);
|
||||
indent--;
|
||||
fprintf(client, "\n");
|
||||
}
|
||||
|
||||
write_remoting_arguments(client, indent, func, PASS_IN, PHASE_BUFFERSIZE);
|
||||
|
||||
|
|
@ -179,7 +220,7 @@ static void write_function_stubs(type_t *iface, unsigned int *proc_offset)
|
|||
indent++;
|
||||
print_client("(PMIDL_STUB_MESSAGE)&_StubMsg,\n");
|
||||
print_client("_StubMsg.BufferLength,\n");
|
||||
if (implicit_handle || explicit_handle_var)
|
||||
if (implicit_handle || explicit_handle_var || explicit_generic_handle_var || context_handle_var)
|
||||
print_client("_Handle);\n");
|
||||
else
|
||||
print_client("%s__MIDL_AutoBindHandle);\n", iface->name);
|
||||
|
|
@ -220,11 +261,11 @@ static void write_function_stubs(type_t *iface, unsigned int *proc_offset)
|
|||
write_remoting_arguments(client, indent, func, PASS_OUT, PHASE_UNMARSHAL);
|
||||
|
||||
/* unmarshal return value */
|
||||
if (!is_void(def->type))
|
||||
if (!is_void(get_func_return_type(func)))
|
||||
{
|
||||
if (decl_indirect(def->type))
|
||||
if (decl_indirect(get_func_return_type(func)))
|
||||
print_client("MIDL_memset(&%s, 0, sizeof(%s));\n", "_RetVal", "_RetVal");
|
||||
else if (is_ptr(def->type) || is_array(def->type))
|
||||
else if (is_ptr(get_func_return_type(func)) || is_array(get_func_return_type(func)))
|
||||
print_client("%s = 0;\n", "_RetVal");
|
||||
write_remoting_arguments(client, indent, func, PASS_RETURN, PHASE_UNMARSHAL);
|
||||
}
|
||||
|
|
@ -233,10 +274,10 @@ static void write_function_stubs(type_t *iface, unsigned int *proc_offset)
|
|||
if (func->args)
|
||||
{
|
||||
LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
|
||||
*proc_offset += get_size_procformatstring_var(var);
|
||||
*proc_offset += get_size_procformatstring_type(var->name, var->type, var->attrs);
|
||||
}
|
||||
if (!is_void(def->type))
|
||||
*proc_offset += get_size_procformatstring_var(def);
|
||||
if (!is_void(get_func_return_type(func)))
|
||||
*proc_offset += get_size_procformatstring_type("return value", get_func_return_type(func), NULL);
|
||||
else
|
||||
*proc_offset += 2; /* FC_END and FC_PAD */
|
||||
|
||||
|
|
@ -254,13 +295,24 @@ static void write_function_stubs(type_t *iface, unsigned int *proc_offset)
|
|||
|
||||
print_client("NdrFreeBuffer((PMIDL_STUB_MESSAGE)&_StubMsg);\n");
|
||||
|
||||
if (!implicit_handle && explicit_generic_handle_var)
|
||||
{
|
||||
fprintf(client, "\n");
|
||||
print_client("if (_Handle)\n");
|
||||
indent++;
|
||||
print_client("%s_unbind(%s, _Handle);\n",
|
||||
get_explicit_generic_handle_type(explicit_generic_handle_var)->name,
|
||||
explicit_generic_handle_var->name);
|
||||
indent--;
|
||||
}
|
||||
|
||||
indent--;
|
||||
print_client("}\n");
|
||||
print_client("RpcEndFinally\n");
|
||||
|
||||
|
||||
/* emit return code */
|
||||
if (!is_void(def->type))
|
||||
if (!is_void(get_func_return_type(func)))
|
||||
{
|
||||
fprintf(client, "\n");
|
||||
print_client("return _RetVal;\n");
|
||||
|
|
|
|||
|
|
@ -34,9 +34,12 @@
|
|||
#include "parser.h"
|
||||
#include "header.h"
|
||||
|
||||
typedef struct _user_type_t generic_handle_t;
|
||||
|
||||
static int indentation = 0;
|
||||
user_type_list_t user_type_list = LIST_INIT(user_type_list);
|
||||
static context_handle_list_t context_handle_list = LIST_INIT(context_handle_list);
|
||||
static struct list generic_handle_list = LIST_INIT(generic_handle_list);
|
||||
|
||||
static void indent(FILE *h, int delta)
|
||||
{
|
||||
|
|
@ -66,6 +69,19 @@ int is_ptrchain_attr(const var_t *var, enum attr_type t)
|
|||
}
|
||||
}
|
||||
|
||||
int is_aliaschain_attr(const type_t *type, enum attr_type attr)
|
||||
{
|
||||
const type_t *t = type;
|
||||
for (;;)
|
||||
{
|
||||
if (is_attr(t->attrs, attr))
|
||||
return 1;
|
||||
else if (t->kind == TKIND_ALIAS)
|
||||
t = t->orig;
|
||||
else return 0;
|
||||
}
|
||||
}
|
||||
|
||||
int is_attr(const attr_list_t *list, enum attr_type t)
|
||||
{
|
||||
const attr_t *attr;
|
||||
|
|
@ -211,7 +227,7 @@ void write_type_left(FILE *h, type_t *t, int declonly)
|
|||
else fprintf(h, "enum {\n");
|
||||
t->written = TRUE;
|
||||
indentation++;
|
||||
write_enums(h, t->fields);
|
||||
write_enums(h, t->fields_or_args);
|
||||
indent(h, -1);
|
||||
fprintf(h, "}");
|
||||
}
|
||||
|
|
@ -229,7 +245,7 @@ void write_type_left(FILE *h, type_t *t, int declonly)
|
|||
else fprintf(h, "struct {\n");
|
||||
t->written = TRUE;
|
||||
indentation++;
|
||||
write_fields(h, t->fields);
|
||||
write_fields(h, t->fields_or_args);
|
||||
indent(h, -1);
|
||||
fprintf(h, "}");
|
||||
}
|
||||
|
|
@ -241,7 +257,7 @@ void write_type_left(FILE *h, type_t *t, int declonly)
|
|||
else fprintf(h, "union {\n");
|
||||
t->written = TRUE;
|
||||
indentation++;
|
||||
write_fields(h, t->fields);
|
||||
write_fields(h, t->fields_or_args);
|
||||
indent(h, -1);
|
||||
fprintf(h, "}");
|
||||
}
|
||||
|
|
@ -280,15 +296,38 @@ void write_type_right(FILE *h, type_t *t, int is_field)
|
|||
void write_type_v(FILE *h, type_t *t, int is_field, int declonly,
|
||||
const char *fmt, va_list args)
|
||||
{
|
||||
type_t *pt;
|
||||
int ptr_level = 0;
|
||||
|
||||
if (!h) return;
|
||||
|
||||
write_type_left(h, t, declonly);
|
||||
for (pt = t; is_ptr(pt); pt = pt->ref, ptr_level++)
|
||||
;
|
||||
|
||||
if (pt->type == RPC_FC_FUNCTION) {
|
||||
int i;
|
||||
const char *callconv = get_attrp(pt->attrs, ATTR_CALLCONV);
|
||||
if (!callconv) callconv = "";
|
||||
write_type_left(h, pt->ref, declonly);
|
||||
fputc(' ', h);
|
||||
if (ptr_level) fputc('(', h);
|
||||
fprintf(h, "%s ", callconv);
|
||||
for (i = 0; i < ptr_level; i++)
|
||||
fputc('*', h);
|
||||
} else
|
||||
write_type_left(h, t, declonly);
|
||||
if (fmt) {
|
||||
if (needs_space_after(t))
|
||||
fprintf(h, " ");
|
||||
fputc(' ', h);
|
||||
vfprintf(h, fmt, args);
|
||||
}
|
||||
write_type_right(h, t, is_field);
|
||||
if (pt->type == RPC_FC_FUNCTION) {
|
||||
if (ptr_level) fputc(')', h);
|
||||
fputc('(', h);
|
||||
write_args(h, pt->fields_or_args, NULL, 0, FALSE);
|
||||
fputc(')', h);
|
||||
} else
|
||||
write_type_right(h, t, is_field);
|
||||
}
|
||||
|
||||
void write_type_def_or_decl(FILE *f, type_t *t, int field, const char *fmt, ...)
|
||||
|
|
@ -330,7 +369,18 @@ static int context_handle_registered(const char *name)
|
|||
return 0;
|
||||
}
|
||||
|
||||
void check_for_user_types_and_context_handles(const var_list_t *list)
|
||||
static int generic_handle_registered(const char *name)
|
||||
{
|
||||
generic_handle_t *gh;
|
||||
LIST_FOR_EACH_ENTRY(gh, &generic_handle_list, generic_handle_t, entry)
|
||||
if (!strcmp(name, gh->name))
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* check for types which require additional prototypes to be generated in the
|
||||
* header */
|
||||
void check_for_additional_prototype_types(const var_list_t *list)
|
||||
{
|
||||
const var_t *v;
|
||||
|
||||
|
|
@ -352,6 +402,16 @@ void check_for_user_types_and_context_handles(const var_list_t *list)
|
|||
/* don't carry on parsing fields within this type */
|
||||
break;
|
||||
}
|
||||
if (type->type != RPC_FC_BIND_PRIMITIVE && is_attr(type->attrs, ATTR_HANDLE)) {
|
||||
if (!generic_handle_registered(name))
|
||||
{
|
||||
generic_handle_t *gh = xmalloc(sizeof(*gh));
|
||||
gh->name = xstrdup(name);
|
||||
list_add_tail(&generic_handle_list, &gh->entry);
|
||||
}
|
||||
/* don't carry on parsing fields within this type */
|
||||
break;
|
||||
}
|
||||
if (is_attr(type->attrs, ATTR_WIREMARSHAL)) {
|
||||
if (!user_type_registered(name))
|
||||
{
|
||||
|
|
@ -365,7 +425,7 @@ void check_for_user_types_and_context_handles(const var_list_t *list)
|
|||
}
|
||||
else
|
||||
{
|
||||
check_for_user_types_and_context_handles(type->fields);
|
||||
check_for_additional_prototype_types(type->fields_or_args);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -394,6 +454,17 @@ void write_context_handle_rundowns(void)
|
|||
}
|
||||
}
|
||||
|
||||
void write_generic_handle_routines(void)
|
||||
{
|
||||
generic_handle_t *gh;
|
||||
LIST_FOR_EACH_ENTRY(gh, &generic_handle_list, generic_handle_t, entry)
|
||||
{
|
||||
const char *name = gh->name;
|
||||
fprintf(header, "handle_t __RPC_USER %s_bind(%s);\n", name, name);
|
||||
fprintf(header, "void __RPC_USER %s_unbind(%s, handle_t);\n", name, name);
|
||||
}
|
||||
}
|
||||
|
||||
void write_typedef(type_t *type)
|
||||
{
|
||||
fprintf(header, "typedef ");
|
||||
|
|
@ -524,11 +595,34 @@ const var_t* get_explicit_handle_var(const func_t* func)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
const type_t* get_explicit_generic_handle_type(const var_t* var)
|
||||
{
|
||||
const type_t *t;
|
||||
for (t = var->type; is_ptr(t); t = t->ref)
|
||||
if (t->type != RPC_FC_BIND_PRIMITIVE && is_attr(t->attrs, ATTR_HANDLE))
|
||||
return t;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const var_t* get_explicit_generic_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 (get_explicit_generic_handle_type(var))
|
||||
return var;
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int has_out_arg_or_return(const func_t *func)
|
||||
{
|
||||
const var_t *var;
|
||||
|
||||
if (!is_void(func->def->type))
|
||||
if (!is_void(get_func_return_type(func)))
|
||||
return 1;
|
||||
|
||||
if (!func->args)
|
||||
|
|
@ -619,17 +713,7 @@ void write_args(FILE *h, const var_list_t *args, const char *name, int method, i
|
|||
}
|
||||
else fprintf(h, ",");
|
||||
}
|
||||
if (arg->args)
|
||||
{
|
||||
write_type_decl_left(h, arg->type);
|
||||
fprintf(h, " (STDMETHODCALLTYPE *");
|
||||
write_name(h,arg);
|
||||
fprintf(h, ")(");
|
||||
write_args(h, arg->args, NULL, 0, FALSE);
|
||||
fprintf(h, ")");
|
||||
}
|
||||
else
|
||||
write_type_decl(h, arg->type, "%s", arg->name);
|
||||
write_type_decl(h, arg->type, "%s", arg->name);
|
||||
count++;
|
||||
}
|
||||
if (do_indent) indentation--;
|
||||
|
|
@ -647,7 +731,7 @@ static void write_cpp_method_def(const type_t *iface)
|
|||
if (!is_callas(def->attrs)) {
|
||||
indent(header, 0);
|
||||
fprintf(header, "virtual ");
|
||||
write_type_decl_left(header, def->type);
|
||||
write_type_decl_left(header, get_func_return_type(cur));
|
||||
fprintf(header, " STDMETHODCALLTYPE ");
|
||||
write_name(header, def);
|
||||
fprintf(header, "(\n");
|
||||
|
|
@ -672,7 +756,7 @@ static void do_write_c_method_def(const type_t *iface, const char *name)
|
|||
const var_t *def = cur->def;
|
||||
if (!is_callas(def->attrs)) {
|
||||
indent(header, 0);
|
||||
write_type_decl_left(header, def->type);
|
||||
write_type_decl_left(header, get_func_return_type(cur));
|
||||
fprintf(header, " (STDMETHODCALLTYPE *");
|
||||
write_name(header, def);
|
||||
fprintf(header, ")(\n");
|
||||
|
|
@ -704,7 +788,7 @@ static void write_method_proto(const type_t *iface)
|
|||
|
||||
if (!is_local(def->attrs)) {
|
||||
/* proxy prototype */
|
||||
write_type_decl_left(header, def->type);
|
||||
write_type_decl_left(header, get_func_return_type(cur));
|
||||
fprintf(header, " CALLBACK %s_", iface->name);
|
||||
write_name(header, def);
|
||||
fprintf(header, "_Proxy(\n");
|
||||
|
|
@ -744,14 +828,14 @@ void write_locals(FILE *fp, const type_t *iface, int body)
|
|||
if (&m->entry != iface->funcs) {
|
||||
const var_t *mdef = m->def;
|
||||
/* proxy prototype - use local prototype */
|
||||
write_type_decl_left(fp, mdef->type);
|
||||
write_type_decl_left(fp, get_func_return_type(m));
|
||||
fprintf(fp, " CALLBACK %s_", iface->name);
|
||||
write_name(fp, mdef);
|
||||
fprintf(fp, "_Proxy(\n");
|
||||
write_args(fp, m->args, iface->name, 1, TRUE);
|
||||
fprintf(fp, ")");
|
||||
if (body) {
|
||||
type_t *rt = mdef->type;
|
||||
type_t *rt = get_func_return_type(m);
|
||||
fprintf(fp, "\n{\n");
|
||||
fprintf(fp, " %s\n", comment);
|
||||
if (rt->name && strcmp(rt->name, "HRESULT") == 0)
|
||||
|
|
@ -768,7 +852,7 @@ void write_locals(FILE *fp, const type_t *iface, int body)
|
|||
else
|
||||
fprintf(fp, ";\n");
|
||||
/* stub prototype - use remotable prototype */
|
||||
write_type_decl_left(fp, def->type);
|
||||
write_type_decl_left(fp, get_func_return_type(cur));
|
||||
fprintf(fp, " __RPC_STUB %s_", iface->name);
|
||||
write_name(fp, mdef);
|
||||
fprintf(fp, "_Stub(\n");
|
||||
|
|
@ -791,7 +875,7 @@ static void write_function_proto(const type_t *iface, const func_t *fun, const c
|
|||
var_t *def = fun->def;
|
||||
|
||||
/* FIXME: do we need to handle call_as? */
|
||||
write_type_decl_left(header, def->type);
|
||||
write_type_decl_left(header, get_func_return_type(fun));
|
||||
fprintf(header, " ");
|
||||
write_prefix_name(header, prefix, def);
|
||||
fprintf(header, "(\n");
|
||||
|
|
@ -799,7 +883,7 @@ static void write_function_proto(const type_t *iface, const func_t *fun, const c
|
|||
write_args(header, fun->args, iface->name, 0, TRUE);
|
||||
else
|
||||
fprintf(header, " void");
|
||||
fprintf(header, ");\n");
|
||||
fprintf(header, ");\n\n");
|
||||
}
|
||||
|
||||
static void write_function_protos(const type_t *iface)
|
||||
|
|
@ -807,6 +891,8 @@ static void write_function_protos(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);
|
||||
|
||||
|
|
@ -817,8 +903,14 @@ static void write_function_protos(const type_t *iface)
|
|||
|
||||
/* 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) {
|
||||
if (!explicit_handle_var && !explicit_generic_handle_var && !context_handle_var) {
|
||||
error("%s() does not define an explicit binding handle!\n", def->name);
|
||||
return;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -24,6 +24,7 @@
|
|||
#include "widltypes.h"
|
||||
|
||||
extern int is_ptrchain_attr(const var_t *var, enum attr_type t);
|
||||
extern int is_aliaschain_attr(const type_t *var, enum attr_type t);
|
||||
extern int is_attr(const attr_list_t *list, enum attr_type t);
|
||||
extern void *get_attrp(const attr_list_t *list, enum attr_type t);
|
||||
extern unsigned long get_attrv(const attr_list_t *list, enum attr_type t);
|
||||
|
|
@ -61,7 +62,11 @@ extern void write_externdef(const var_t *v);
|
|||
extern void write_library(const char *name, const attr_list_t *attr);
|
||||
extern void write_user_types(void);
|
||||
extern void write_context_handle_rundowns(void);
|
||||
extern void write_generic_handle_routines(void);
|
||||
extern const var_t* get_explicit_handle_var(const func_t* func);
|
||||
extern const type_t* get_explicit_generic_handle_type(const var_t* var);
|
||||
extern const var_t* get_explicit_generic_handle_var(const func_t* func);
|
||||
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);
|
||||
|
|
@ -78,17 +83,25 @@ static inline int last_array(const type_t *type)
|
|||
|
||||
static inline int is_string_type(const attr_list_t *attrs, const type_t *type)
|
||||
{
|
||||
return ((is_attr(attrs, ATTR_STRING) || is_attr(type->attrs, ATTR_STRING))
|
||||
return ((is_attr(attrs, ATTR_STRING) || is_aliaschain_attr(type, ATTR_STRING))
|
||||
&& (last_ptr(type) || last_array(type)));
|
||||
}
|
||||
|
||||
static inline int is_context_handle(const type_t *type)
|
||||
{
|
||||
const type_t *t;
|
||||
for (t = type; is_ptr(t); t = t->ref)
|
||||
if (is_attr(t->attrs, ATTR_CONTEXTHANDLE))
|
||||
if (is_attr(type->attrs, ATTR_CONTEXTHANDLE))
|
||||
return 1;
|
||||
|
||||
for (;;)
|
||||
{
|
||||
if (is_attr(type->attrs, ATTR_CONTEXTHANDLE))
|
||||
return 1;
|
||||
return 0;
|
||||
else if (type->kind == TKIND_ALIAS)
|
||||
type = type->orig;
|
||||
else if (is_ptr(type))
|
||||
type = type->ref;
|
||||
else return 0;
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -39,6 +39,7 @@ int parser_lex(void);
|
|||
extern int import_stack_ptr;
|
||||
int do_import(char *fname);
|
||||
void abort_import(void);
|
||||
void pop_import(void);
|
||||
|
||||
#define parse_only import_stack_ptr
|
||||
|
||||
|
|
|
|||
|
|
@ -79,8 +79,6 @@ struct {
|
|||
} import_stack[MAX_IMPORT_DEPTH];
|
||||
int import_stack_ptr = 0;
|
||||
|
||||
static void pop_import(void);
|
||||
|
||||
UUID *parse_uuid(const char *u)
|
||||
{
|
||||
UUID* uuid = xmalloc(sizeof(UUID));
|
||||
|
|
@ -166,10 +164,8 @@ SAFEARRAY{ws}*/\( return tSAFEARRAY;
|
|||
<INITIAL,ATTR>\>\> return SHR;
|
||||
<INITIAL,ATTR>. return yytext[0];
|
||||
<<EOF>> {
|
||||
if (import_stack_ptr) {
|
||||
pop_import();
|
||||
if (import_stack_ptr)
|
||||
return aEOF;
|
||||
}
|
||||
else yyterminate();
|
||||
}
|
||||
%%
|
||||
|
|
@ -190,13 +186,19 @@ static const struct keyword keywords[] = {
|
|||
{"FALSE", tFALSE},
|
||||
{"TRUE", tTRUE},
|
||||
{"__cdecl", tCDECL},
|
||||
{"__fastcall", tFASTCALL},
|
||||
{"__int64", tINT64},
|
||||
{"__pascal", tPASCAL},
|
||||
{"__stdcall", tSTDCALL},
|
||||
{"_cdecl", tCDECL},
|
||||
{"_fastcall", tFASTCALL},
|
||||
{"_pascal", tPASCAL},
|
||||
{"_stdcall", tSTDCALL},
|
||||
{"boolean", tBOOLEAN},
|
||||
{"byte", tBYTE},
|
||||
{"callback", tCALLBACK},
|
||||
{"case", tCASE},
|
||||
{"cdecl", tCDECL},
|
||||
{"char", tCHAR},
|
||||
{"coclass", tCOCLASS},
|
||||
{"code", tCODE},
|
||||
|
|
@ -221,11 +223,13 @@ static const struct keyword keywords[] = {
|
|||
{"long", tLONG},
|
||||
{"methods", tMETHODS},
|
||||
{"module", tMODULE},
|
||||
{"pascal", tPASCAL},
|
||||
{"properties", tPROPERTIES},
|
||||
{"short", tSHORT},
|
||||
{"signed", tSIGNED},
|
||||
{"sizeof", tSIZEOF},
|
||||
{"small", tSMALL},
|
||||
{"stdcall", tSTDCALL},
|
||||
{"struct", tSTRUCT},
|
||||
{"switch", tSWITCH},
|
||||
{"typedef", tTYPEDEF},
|
||||
|
|
@ -367,7 +371,7 @@ static char *get_buffered_cstring(void)
|
|||
return xstrdup(cbuffer);
|
||||
}
|
||||
|
||||
static void pop_import(void)
|
||||
void pop_import(void)
|
||||
{
|
||||
int ptr = import_stack_ptr-1;
|
||||
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -80,89 +80,91 @@
|
|||
tEXPLICITHANDLE = 306,
|
||||
tEXTERN = 307,
|
||||
tFALSE = 308,
|
||||
tFLOAT = 309,
|
||||
tHANDLE = 310,
|
||||
tHANDLET = 311,
|
||||
tHELPCONTEXT = 312,
|
||||
tHELPFILE = 313,
|
||||
tHELPSTRING = 314,
|
||||
tHELPSTRINGCONTEXT = 315,
|
||||
tHELPSTRINGDLL = 316,
|
||||
tHIDDEN = 317,
|
||||
tHYPER = 318,
|
||||
tID = 319,
|
||||
tIDEMPOTENT = 320,
|
||||
tIIDIS = 321,
|
||||
tIMMEDIATEBIND = 322,
|
||||
tIMPLICITHANDLE = 323,
|
||||
tIMPORT = 324,
|
||||
tIMPORTLIB = 325,
|
||||
tIN = 326,
|
||||
tINLINE = 327,
|
||||
tINPUTSYNC = 328,
|
||||
tINT = 329,
|
||||
tINT64 = 330,
|
||||
tINTERFACE = 331,
|
||||
tLCID = 332,
|
||||
tLENGTHIS = 333,
|
||||
tLIBRARY = 334,
|
||||
tLOCAL = 335,
|
||||
tLONG = 336,
|
||||
tMETHODS = 337,
|
||||
tMODULE = 338,
|
||||
tNONBROWSABLE = 339,
|
||||
tNONCREATABLE = 340,
|
||||
tNONEXTENSIBLE = 341,
|
||||
tOBJECT = 342,
|
||||
tODL = 343,
|
||||
tOLEAUTOMATION = 344,
|
||||
tOPTIONAL = 345,
|
||||
tOUT = 346,
|
||||
tPOINTERDEFAULT = 347,
|
||||
tPROPERTIES = 348,
|
||||
tPROPGET = 349,
|
||||
tPROPPUT = 350,
|
||||
tPROPPUTREF = 351,
|
||||
tPTR = 352,
|
||||
tPUBLIC = 353,
|
||||
tRANGE = 354,
|
||||
tREADONLY = 355,
|
||||
tREF = 356,
|
||||
tREQUESTEDIT = 357,
|
||||
tRESTRICTED = 358,
|
||||
tRETVAL = 359,
|
||||
tSAFEARRAY = 360,
|
||||
tSHORT = 361,
|
||||
tSIGNED = 362,
|
||||
tSINGLE = 363,
|
||||
tSIZEIS = 364,
|
||||
tSIZEOF = 365,
|
||||
tSMALL = 366,
|
||||
tSOURCE = 367,
|
||||
tSTDCALL = 368,
|
||||
tSTRICTCONTEXTHANDLE = 369,
|
||||
tSTRING = 370,
|
||||
tSTRUCT = 371,
|
||||
tSWITCH = 372,
|
||||
tSWITCHIS = 373,
|
||||
tSWITCHTYPE = 374,
|
||||
tTRANSMITAS = 375,
|
||||
tTRUE = 376,
|
||||
tTYPEDEF = 377,
|
||||
tUNION = 378,
|
||||
tUNIQUE = 379,
|
||||
tUNSIGNED = 380,
|
||||
tUUID = 381,
|
||||
tV1ENUM = 382,
|
||||
tVARARG = 383,
|
||||
tVERSION = 384,
|
||||
tVOID = 385,
|
||||
tWCHAR = 386,
|
||||
tWIREMARSHAL = 387,
|
||||
CAST = 388,
|
||||
PPTR = 389,
|
||||
NEG = 390,
|
||||
ADDRESSOF = 391
|
||||
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
|
||||
};
|
||||
#endif
|
||||
/* Tokens. */
|
||||
|
|
@ -217,95 +219,97 @@
|
|||
#define tEXPLICITHANDLE 306
|
||||
#define tEXTERN 307
|
||||
#define tFALSE 308
|
||||
#define tFLOAT 309
|
||||
#define tHANDLE 310
|
||||
#define tHANDLET 311
|
||||
#define tHELPCONTEXT 312
|
||||
#define tHELPFILE 313
|
||||
#define tHELPSTRING 314
|
||||
#define tHELPSTRINGCONTEXT 315
|
||||
#define tHELPSTRINGDLL 316
|
||||
#define tHIDDEN 317
|
||||
#define tHYPER 318
|
||||
#define tID 319
|
||||
#define tIDEMPOTENT 320
|
||||
#define tIIDIS 321
|
||||
#define tIMMEDIATEBIND 322
|
||||
#define tIMPLICITHANDLE 323
|
||||
#define tIMPORT 324
|
||||
#define tIMPORTLIB 325
|
||||
#define tIN 326
|
||||
#define tINLINE 327
|
||||
#define tINPUTSYNC 328
|
||||
#define tINT 329
|
||||
#define tINT64 330
|
||||
#define tINTERFACE 331
|
||||
#define tLCID 332
|
||||
#define tLENGTHIS 333
|
||||
#define tLIBRARY 334
|
||||
#define tLOCAL 335
|
||||
#define tLONG 336
|
||||
#define tMETHODS 337
|
||||
#define tMODULE 338
|
||||
#define tNONBROWSABLE 339
|
||||
#define tNONCREATABLE 340
|
||||
#define tNONEXTENSIBLE 341
|
||||
#define tOBJECT 342
|
||||
#define tODL 343
|
||||
#define tOLEAUTOMATION 344
|
||||
#define tOPTIONAL 345
|
||||
#define tOUT 346
|
||||
#define tPOINTERDEFAULT 347
|
||||
#define tPROPERTIES 348
|
||||
#define tPROPGET 349
|
||||
#define tPROPPUT 350
|
||||
#define tPROPPUTREF 351
|
||||
#define tPTR 352
|
||||
#define tPUBLIC 353
|
||||
#define tRANGE 354
|
||||
#define tREADONLY 355
|
||||
#define tREF 356
|
||||
#define tREQUESTEDIT 357
|
||||
#define tRESTRICTED 358
|
||||
#define tRETVAL 359
|
||||
#define tSAFEARRAY 360
|
||||
#define tSHORT 361
|
||||
#define tSIGNED 362
|
||||
#define tSINGLE 363
|
||||
#define tSIZEIS 364
|
||||
#define tSIZEOF 365
|
||||
#define tSMALL 366
|
||||
#define tSOURCE 367
|
||||
#define tSTDCALL 368
|
||||
#define tSTRICTCONTEXTHANDLE 369
|
||||
#define tSTRING 370
|
||||
#define tSTRUCT 371
|
||||
#define tSWITCH 372
|
||||
#define tSWITCHIS 373
|
||||
#define tSWITCHTYPE 374
|
||||
#define tTRANSMITAS 375
|
||||
#define tTRUE 376
|
||||
#define tTYPEDEF 377
|
||||
#define tUNION 378
|
||||
#define tUNIQUE 379
|
||||
#define tUNSIGNED 380
|
||||
#define tUUID 381
|
||||
#define tV1ENUM 382
|
||||
#define tVARARG 383
|
||||
#define tVERSION 384
|
||||
#define tVOID 385
|
||||
#define tWCHAR 386
|
||||
#define tWIREMARSHAL 387
|
||||
#define CAST 388
|
||||
#define PPTR 389
|
||||
#define NEG 390
|
||||
#define ADDRESSOF 391
|
||||
#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
|
||||
|
||||
|
||||
|
||||
|
||||
#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
|
||||
#line 136 "parser.y"
|
||||
#line 139 "parser.y"
|
||||
typedef union YYSTYPE {
|
||||
attr_t *attr;
|
||||
attr_list_t *attr_list;
|
||||
|
|
@ -329,7 +333,7 @@ typedef union YYSTYPE {
|
|||
interface_info_t ifinfo;
|
||||
} YYSTYPE;
|
||||
/* Line 1447 of yacc.c. */
|
||||
#line 333 "parser.tab.h"
|
||||
#line 337 "parser.tab.h"
|
||||
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
|
||||
# define YYSTYPE_IS_DECLARED 1
|
||||
# define YYSTYPE_IS_TRIVIAL 1
|
||||
|
|
|
|||
|
|
@ -63,7 +63,10 @@
|
|||
# endif
|
||||
#endif
|
||||
|
||||
#define YYERROR_VERBOSE
|
||||
|
||||
unsigned char pointer_default = RPC_FC_UP;
|
||||
static int is_object_interface = FALSE;
|
||||
|
||||
typedef struct list typelist_t;
|
||||
struct typenode {
|
||||
|
|
@ -92,7 +95,7 @@ static expr_t *make_expr3(enum expr_type type, expr_t *expr1, expr_t *expr2, exp
|
|||
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, int ptr_level, array_dims_t *arr, int top);
|
||||
static void set_type(var_t *v, type_t *type, const pident_t *pident, array_dims_t *arr, int top);
|
||||
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);
|
||||
|
|
@ -180,6 +183,7 @@ static void check_all_user_types(ifref_list_t *ifaces);
|
|||
%token tENTRY tENUM tERRORSTATUST
|
||||
%token tEXPLICITHANDLE tEXTERN
|
||||
%token tFALSE
|
||||
%token tFASTCALL
|
||||
%token tFLOAT
|
||||
%token tHANDLE
|
||||
%token tHANDLET
|
||||
|
|
@ -207,6 +211,7 @@ static void check_all_user_types(ifref_list_t *ifaces);
|
|||
%token tOBJECT tODL tOLEAUTOMATION
|
||||
%token tOPTIONAL
|
||||
%token tOUT
|
||||
%token tPASCAL
|
||||
%token tPOINTERDEFAULT
|
||||
%token tPROPERTIES
|
||||
%token tPROPGET tPROPPUT tPROPPUTREF
|
||||
|
|
@ -259,14 +264,15 @@ static void check_all_user_types(ifref_list_t *ifaces);
|
|||
%type <var> arg field s_field case enum constdef externdef
|
||||
%type <var_list> m_args no_args args fields cases enums enum_list dispint_props
|
||||
%type <var> m_ident t_ident ident
|
||||
%type <pident> p_ident pident
|
||||
%type <pident> pident func_ident direct_ident
|
||||
%type <pident_list> pident_list
|
||||
%type <func> funcdef
|
||||
%type <func_list> int_statements dispint_meths
|
||||
%type <type> coclass coclasshdr coclassdef
|
||||
%type <num> pointer_type version
|
||||
%type <str> libraryhdr
|
||||
%type <str> libraryhdr callconv
|
||||
%type <uuid> uuid_string
|
||||
%type <num> import_start
|
||||
|
||||
%left ','
|
||||
%right '?' ':'
|
||||
|
|
@ -328,8 +334,11 @@ int_statements: { $$ = NULL; }
|
|||
| int_statements statement { $$ = $1; }
|
||||
;
|
||||
|
||||
statement: ';' {}
|
||||
| constdef ';' { if (!parse_only && do_header) { write_constdef($1); } }
|
||||
semicolon_opt:
|
||||
| ';'
|
||||
;
|
||||
|
||||
statement: constdef ';' { if (!parse_only && do_header) { write_constdef($1); } }
|
||||
| cppquote {}
|
||||
| enumdef ';' { if (!parse_only && do_header) {
|
||||
write_type_def_or_decl(header, $1, FALSE, NULL);
|
||||
|
|
@ -354,12 +363,17 @@ statement: ';' {}
|
|||
cppquote: tCPPQUOTE '(' aSTRING ')' { if (!parse_only && do_header) fprintf(header, "%s\n", $3); }
|
||||
;
|
||||
import_start: tIMPORT aSTRING ';' { assert(yychar == YYEMPTY);
|
||||
if (!do_import($2)) yychar = aEOF; }
|
||||
;
|
||||
import: import_start imp_statements aEOF {}
|
||||
$$ = do_import($2);
|
||||
if (!$$) yychar = aEOF;
|
||||
}
|
||||
;
|
||||
|
||||
importlib: tIMPORTLIB '(' aSTRING ')' { if(!parse_only) add_importlib($3); }
|
||||
import: import_start imp_statements aEOF
|
||||
{ if ($1) pop_import(); }
|
||||
;
|
||||
|
||||
importlib: tIMPORTLIB '(' aSTRING ')'
|
||||
semicolon_opt { if(!parse_only) add_importlib($3); }
|
||||
;
|
||||
|
||||
libraryhdr: tLIBRARY aIDENTIFIER { $$ = $2; }
|
||||
|
|
@ -369,7 +383,8 @@ library_start: attributes libraryhdr '{' { if (!parse_only) start_typelib($2, $1
|
|||
if (!parse_only && do_idfile) write_libid($2, $1);
|
||||
}
|
||||
;
|
||||
librarydef: library_start imp_statements '}' { if (!parse_only) end_typelib(); }
|
||||
librarydef: library_start imp_statements '}'
|
||||
semicolon_opt { if (!parse_only) end_typelib(); }
|
||||
;
|
||||
|
||||
m_args: { $$ = NULL; }
|
||||
|
|
@ -387,24 +402,13 @@ args: arg { check_arg($1); $$ = append_var( NULL, $1 ); }
|
|||
/* split into two rules to get bison to resolve a tVOID conflict */
|
||||
arg: attributes type pident array { $$ = $3->var;
|
||||
$$->attrs = $1;
|
||||
set_type($$, $2, $3->ptr_level, $4, TRUE);
|
||||
set_type($$, $2, $3, $4, TRUE);
|
||||
free($3);
|
||||
}
|
||||
| type pident array { $$ = $2->var;
|
||||
set_type($$, $1, $2->ptr_level, $3, TRUE);
|
||||
set_type($$, $1, $2, $3, TRUE);
|
||||
free($2);
|
||||
}
|
||||
| attributes type pident '(' m_args ')' { $$ = $3->var;
|
||||
$$->attrs = $1;
|
||||
set_type($$, $2, $3->ptr_level - 1, NULL, TRUE);
|
||||
free($3);
|
||||
$$->args = $5;
|
||||
}
|
||||
| type pident '(' m_args ')' { $$ = $2->var;
|
||||
set_type($$, $1, $2->ptr_level - 1, NULL, TRUE);
|
||||
free($2);
|
||||
$$->args = $4;
|
||||
}
|
||||
;
|
||||
|
||||
array: { $$ = NULL; }
|
||||
|
|
@ -519,8 +523,10 @@ uuid_string:
|
|||
$$ = parse_uuid($1); }
|
||||
;
|
||||
|
||||
callconv:
|
||||
| tSTDCALL
|
||||
callconv: tCDECL { $$ = $<str>1; }
|
||||
| tFASTCALL { $$ = $<str>1; }
|
||||
| tPASCAL { $$ = $<str>1; }
|
||||
| tSTDCALL { $$ = $<str>1; }
|
||||
;
|
||||
|
||||
cases: { $$ = NULL; }
|
||||
|
|
@ -538,7 +544,7 @@ case: tCASE expr ':' field { attr_t *a = make_attrp(ATTR_CASE, append_expr(
|
|||
;
|
||||
|
||||
constdef: tCONST type ident '=' expr_const { $$ = reg_const($3);
|
||||
set_type($$, $2, 0, NULL, FALSE);
|
||||
set_type($$, $2, NULL, NULL, FALSE);
|
||||
$$->eval = $5;
|
||||
}
|
||||
;
|
||||
|
|
@ -572,7 +578,7 @@ enum: ident '=' expr_const { $$ = reg_const($1);
|
|||
|
||||
enumdef: tENUM t_ident '{' enums '}' { $$ = get_typev(RPC_FC_ENUM16, $2, tsENUM);
|
||||
$$->kind = TKIND_ENUM;
|
||||
$$->fields = $4;
|
||||
$$->fields_or_args = $4;
|
||||
$$->defined = TRUE;
|
||||
if(in_typelib)
|
||||
add_typelib_entry($$);
|
||||
|
|
@ -632,7 +638,7 @@ expr_const: expr { $$ = $1;
|
|||
;
|
||||
|
||||
externdef: tEXTERN tCONST type ident { $$ = $4;
|
||||
set_type($$, $3, 0, NULL, FALSE);
|
||||
set_type($$, $3, NULL, NULL, FALSE);
|
||||
}
|
||||
;
|
||||
|
||||
|
|
@ -648,18 +654,18 @@ field: s_field ';' { $$ = $1; }
|
|||
|
||||
s_field: m_attributes type pident array { $$ = $3->var;
|
||||
$$->attrs = $1;
|
||||
set_type($$, $2, $3->ptr_level, $4, FALSE);
|
||||
set_type($$, $2, $3, $4, FALSE);
|
||||
free($3);
|
||||
}
|
||||
;
|
||||
|
||||
funcdef:
|
||||
m_attributes type callconv pident
|
||||
'(' m_args ')' { var_t *v = $4->var;
|
||||
m_attributes type pident { var_t *v = $3->var;
|
||||
var_list_t *args = $3->args;
|
||||
v->attrs = $1;
|
||||
set_type(v, $2, $4->ptr_level, NULL, FALSE);
|
||||
free($4);
|
||||
$$ = make_func(v, $6);
|
||||
set_type(v, $2, $3, NULL, FALSE);
|
||||
free($3);
|
||||
$$ = make_func(v, args);
|
||||
if (is_attr(v->attrs, ATTR_IN)) {
|
||||
error_loc("inapplicable attribute [in] for function '%s'\n",$$->def->name);
|
||||
}
|
||||
|
|
@ -738,7 +744,8 @@ coclasshdr: attributes coclass { $$ = $2;
|
|||
}
|
||||
;
|
||||
|
||||
coclassdef: coclasshdr '{' coclass_ints '}' { $$ = $1;
|
||||
coclassdef: coclasshdr '{' coclass_ints '}' semicolon_opt
|
||||
{ $$ = $1;
|
||||
$$->ifaces = $3;
|
||||
$$->defined = TRUE;
|
||||
}
|
||||
|
|
@ -757,6 +764,7 @@ dispinterface: tDISPINTERFACE aIDENTIFIER { $$ = get_type(0, $2, 0); $$->kind =
|
|||
;
|
||||
|
||||
dispinterfacehdr: attributes dispinterface { attr_t *attrs;
|
||||
is_object_interface = TRUE;
|
||||
$$ = $2;
|
||||
if ($$->defined) error_loc("multiple definition error\n");
|
||||
attrs = make_attr(ATTR_DISPINTERFACE);
|
||||
|
|
@ -780,14 +788,14 @@ dispinterfacedef: dispinterfacehdr '{'
|
|||
dispint_props
|
||||
dispint_meths
|
||||
'}' { $$ = $1;
|
||||
$$->fields = $3;
|
||||
$$->fields_or_args = $3;
|
||||
$$->funcs = $4;
|
||||
if (!parse_only && do_header) write_dispinterface($$);
|
||||
if (!parse_only && do_idfile) write_diid($$);
|
||||
}
|
||||
| dispinterfacehdr
|
||||
'{' interface ';' '}' { $$ = $1;
|
||||
$$->fields = $3->fields;
|
||||
'{' interface ';' '}' { $$ = $1;
|
||||
$$->fields_or_args = $3->fields_or_args;
|
||||
$$->funcs = $3->funcs;
|
||||
if (!parse_only && do_header) write_dispinterface($$);
|
||||
if (!parse_only && do_idfile) write_diid($$);
|
||||
|
|
@ -806,6 +814,7 @@ interfacehdr: attributes interface { $$.interface = $2;
|
|||
$$.old_pointer_default = pointer_default;
|
||||
if (is_attr($1, ATTR_POINTERDEFAULT))
|
||||
pointer_default = get_attrv($1, ATTR_POINTERDEFAULT);
|
||||
is_object_interface = is_object($1);
|
||||
if ($2->defined) error_loc("multiple definition error\n");
|
||||
$2->attrs = $1;
|
||||
$2->defined = TRUE;
|
||||
|
|
@ -814,7 +823,7 @@ interfacehdr: attributes interface { $$.interface = $2;
|
|||
;
|
||||
|
||||
interfacedef: interfacehdr inherit
|
||||
'{' int_statements '}' { $$ = $1.interface;
|
||||
'{' int_statements '}' semicolon_opt { $$ = $1.interface;
|
||||
$$->ref = $2;
|
||||
$$->funcs = $4;
|
||||
compute_method_indexes($$);
|
||||
|
|
@ -826,7 +835,8 @@ interfacedef: interfacehdr inherit
|
|||
/* MIDL is able to import the definition of a base class from inside the
|
||||
* definition of a derived class, I'll try to support it with this rule */
|
||||
| interfacehdr ':' aIDENTIFIER
|
||||
'{' import int_statements '}' { $$ = $1.interface;
|
||||
'{' import int_statements '}'
|
||||
semicolon_opt { $$ = $1.interface;
|
||||
$$->ref = find_type2($3, 0);
|
||||
if (!$$->ref) error_loc("base class '%s' not found in import\n", $3);
|
||||
$$->funcs = $6;
|
||||
|
|
@ -836,7 +846,7 @@ interfacedef: interfacehdr inherit
|
|||
if (!parse_only && do_idfile) write_iid($$);
|
||||
pointer_default = $1.old_pointer_default;
|
||||
}
|
||||
| dispinterfacedef { $$ = $1; }
|
||||
| dispinterfacedef semicolon_opt { $$ = $1; }
|
||||
;
|
||||
|
||||
interfacedec:
|
||||
|
|
@ -853,19 +863,35 @@ modulehdr: attributes module { $$ = $2;
|
|||
}
|
||||
;
|
||||
|
||||
moduledef: modulehdr '{' int_statements '}' { $$ = $1;
|
||||
moduledef: modulehdr '{' int_statements '}'
|
||||
semicolon_opt { $$ = $1;
|
||||
$$->funcs = $3;
|
||||
/* FIXME: if (!parse_only && do_header) write_module($$); */
|
||||
}
|
||||
;
|
||||
|
||||
p_ident: '*' pident %prec PPTR { $$ = $2; $$->ptr_level++; }
|
||||
| tCONST p_ident { $$ = $2; /* FIXME */ }
|
||||
pident: '*' pident %prec PPTR { $$ = $2; $$->ptr_level++; }
|
||||
| tCONST pident { $$ = $2; /* FIXME */ }
|
||||
| callconv pident { $$ = $2;
|
||||
if ($$->callconv) parser_warning("multiple calling conventions %s, %s for function %s\n", $$->callconv, $1, $$->var->name);
|
||||
$$->callconv = $1;
|
||||
}
|
||||
| direct_ident
|
||||
;
|
||||
|
||||
pident: ident { $$ = make_pident($1); }
|
||||
| p_ident
|
||||
func_ident: direct_ident '(' m_args ')'
|
||||
{ $$ = $1;
|
||||
$1->args = $3;
|
||||
$1->is_func = TRUE;
|
||||
}
|
||||
;
|
||||
|
||||
direct_ident: ident { $$ = make_pident($1); }
|
||||
| '(' pident ')' { $$ = $2; }
|
||||
| func_ident { $$ = $1;
|
||||
$$->func_ptr_level = $$->ptr_level;
|
||||
$$->ptr_level = 0;
|
||||
}
|
||||
;
|
||||
|
||||
pident_list:
|
||||
|
|
@ -883,7 +909,7 @@ structdef: tSTRUCT t_ident '{' fields '}' { $$ = get_typev(RPC_FC_STRUCT, $2, ts
|
|||
/* overwrite RPC_FC_STRUCT with a more exact type */
|
||||
$$->type = get_struct_type( $4 );
|
||||
$$->kind = TKIND_RECORD;
|
||||
$$->fields = $4;
|
||||
$$->fields_or_args = $4;
|
||||
$$->defined = TRUE;
|
||||
if(in_typelib)
|
||||
add_typelib_entry($$);
|
||||
|
|
@ -910,7 +936,7 @@ typedef: tTYPEDEF m_attributes type pident_list { reg_typedefs($3, $4, $2);
|
|||
|
||||
uniondef: tUNION t_ident '{' fields '}' { $$ = get_typev(RPC_FC_NON_ENCAPSULATED_UNION, $2, tsUNION);
|
||||
$$->kind = TKIND_UNION;
|
||||
$$->fields = $4;
|
||||
$$->fields_or_args = $4;
|
||||
$$->defined = TRUE;
|
||||
}
|
||||
| tUNION t_ident
|
||||
|
|
@ -921,10 +947,10 @@ uniondef: tUNION t_ident '{' fields '}' { $$ = get_typev(RPC_FC_NON_ENCAPSULATE
|
|||
if (!u) u = make_var( xstrdup("tagged_union") );
|
||||
u->type = make_type(RPC_FC_NON_ENCAPSULATED_UNION, NULL);
|
||||
u->type->kind = TKIND_UNION;
|
||||
u->type->fields = $9;
|
||||
u->type->fields_or_args = $9;
|
||||
u->type->defined = TRUE;
|
||||
$$->fields = append_var( $$->fields, $5 );
|
||||
$$->fields = append_var( $$->fields, u );
|
||||
$$->fields_or_args = append_var( $$->fields_or_args, $5 );
|
||||
$$->fields_or_args = append_var( $$->fields_or_args, u );
|
||||
$$->defined = TRUE;
|
||||
}
|
||||
;
|
||||
|
|
@ -1289,7 +1315,7 @@ static type_t *make_type(unsigned char type, type_t *ref)
|
|||
t->attrs = NULL;
|
||||
t->orig = NULL;
|
||||
t->funcs = NULL;
|
||||
t->fields = NULL;
|
||||
t->fields_or_args = NULL;
|
||||
t->ifaces = NULL;
|
||||
t->dim = 0;
|
||||
t->size_is = NULL;
|
||||
|
|
@ -1308,7 +1334,7 @@ static type_t *make_type(unsigned char type, type_t *ref)
|
|||
return t;
|
||||
}
|
||||
|
||||
static void set_type(var_t *v, type_t *type, int ptr_level, array_dims_t *arr,
|
||||
static void set_type(var_t *v, type_t *type, const pident_t *pident, array_dims_t *arr,
|
||||
int top)
|
||||
{
|
||||
expr_list_t *sizes = get_attrp(v->attrs, ATTR_SIZEIS);
|
||||
|
|
@ -1318,6 +1344,7 @@ static void set_type(var_t *v, type_t *type, int ptr_level, array_dims_t *arr,
|
|||
int sizeless, has_varconf;
|
||||
expr_t *dim;
|
||||
type_t *atype, **ptype;
|
||||
int ptr_level = (pident ? pident->ptr_level : 0);
|
||||
|
||||
v->type = type;
|
||||
|
||||
|
|
@ -1348,6 +1375,21 @@ static void set_type(var_t *v, type_t *type, int ptr_level, array_dims_t *arr,
|
|||
error("%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));
|
||||
}
|
||||
for (; func_ptr_level > 0; func_ptr_level--)
|
||||
v->type = make_type(ptr_type, v->type);
|
||||
}
|
||||
|
||||
sizeless = FALSE;
|
||||
if (arr) LIST_FOR_EACH_ENTRY_REV(dim, arr, expr_t, entry)
|
||||
{
|
||||
|
|
@ -1499,7 +1541,6 @@ static var_t *make_var(char *name)
|
|||
var_t *v = xmalloc(sizeof(var_t));
|
||||
v->name = name;
|
||||
v->type = NULL;
|
||||
v->args = NULL;
|
||||
v->attrs = NULL;
|
||||
v->eval = NULL;
|
||||
return v;
|
||||
|
|
@ -1520,7 +1561,11 @@ static pident_t *make_pident(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;
|
||||
}
|
||||
|
||||
|
|
@ -1621,7 +1666,7 @@ static void fix_type(type_t *t)
|
|||
if (t->kind == TKIND_ALIAS && is_incomplete(t)) {
|
||||
type_t *ot = t->orig;
|
||||
fix_type(ot);
|
||||
t->fields = ot->fields;
|
||||
t->fields_or_args = ot->fields_or_args;
|
||||
t->defined = ot->defined;
|
||||
}
|
||||
}
|
||||
|
|
@ -1691,6 +1736,20 @@ static type_t *reg_typedefs(type_t *type, pident_list_t *pidents, attr_list_t *a
|
|||
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);
|
||||
cur->attrs = attrs;
|
||||
if (ptr_type)
|
||||
|
|
@ -2072,7 +2131,7 @@ static void check_all_user_types(ifref_list_t *ifrefs)
|
|||
{
|
||||
const func_list_t *fs = ifref->iface->funcs;
|
||||
if (fs) LIST_FOR_EACH_ENTRY(f, fs, const func_t, entry)
|
||||
check_for_user_types_and_context_handles(f->args);
|
||||
check_for_additional_prototype_types(f->args);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -559,8 +559,6 @@ struct {
|
|||
} import_stack[MAX_IMPORT_DEPTH];
|
||||
int import_stack_ptr = 0;
|
||||
|
||||
static void pop_import(void);
|
||||
|
||||
UUID *parse_uuid(const char *u)
|
||||
{
|
||||
UUID* uuid = xmalloc(sizeof(UUID));
|
||||
|
|
@ -586,7 +584,7 @@ UUID *parse_uuid(const char *u)
|
|||
* The flexer starts here
|
||||
**************************************************************************
|
||||
*/
|
||||
#line 590 "parser.yy.c"
|
||||
#line 588 "parser.yy.c"
|
||||
|
||||
/* Macros after this point can all be overridden by user definitions in
|
||||
* section 1.
|
||||
|
|
@ -740,9 +738,9 @@ YY_DECL
|
|||
register char *yy_cp, *yy_bp;
|
||||
register int yy_act;
|
||||
|
||||
#line 111 "parser.l"
|
||||
#line 109 "parser.l"
|
||||
|
||||
#line 746 "parser.yy.c"
|
||||
#line 744 "parser.yy.c"
|
||||
|
||||
if ( yy_init )
|
||||
{
|
||||
|
|
@ -828,12 +826,12 @@ do_action: /* This label is used only to access EOF actions. */
|
|||
|
||||
case 1:
|
||||
YY_RULE_SETUP
|
||||
#line 112 "parser.l"
|
||||
#line 110 "parser.l"
|
||||
yy_push_state(PP_LINE);
|
||||
YY_BREAK
|
||||
case 2:
|
||||
YY_RULE_SETUP
|
||||
#line 113 "parser.l"
|
||||
#line 111 "parser.l"
|
||||
{
|
||||
int lineno;
|
||||
char *cptr, *fname;
|
||||
|
|
@ -856,12 +854,12 @@ YY_RULE_SETUP
|
|||
YY_BREAK
|
||||
case 3:
|
||||
YY_RULE_SETUP
|
||||
#line 132 "parser.l"
|
||||
#line 130 "parser.l"
|
||||
yy_push_state(QUOTE); cbufidx = 0;
|
||||
YY_BREAK
|
||||
case 4:
|
||||
YY_RULE_SETUP
|
||||
#line 133 "parser.l"
|
||||
#line 131 "parser.l"
|
||||
{
|
||||
yy_pop_state();
|
||||
parser_lval.str = get_buffered_cstring();
|
||||
|
|
@ -869,40 +867,40 @@ YY_RULE_SETUP
|
|||
}
|
||||
YY_BREAK
|
||||
case 5:
|
||||
#line 139 "parser.l"
|
||||
#line 137 "parser.l"
|
||||
case 6:
|
||||
YY_RULE_SETUP
|
||||
#line 139 "parser.l"
|
||||
#line 137 "parser.l"
|
||||
addcchar(yytext[1]);
|
||||
YY_BREAK
|
||||
case 7:
|
||||
YY_RULE_SETUP
|
||||
#line 140 "parser.l"
|
||||
#line 138 "parser.l"
|
||||
addcchar('\\'); addcchar(yytext[1]);
|
||||
YY_BREAK
|
||||
case 8:
|
||||
YY_RULE_SETUP
|
||||
#line 141 "parser.l"
|
||||
#line 139 "parser.l"
|
||||
addcchar(yytext[0]);
|
||||
YY_BREAK
|
||||
case 9:
|
||||
YY_RULE_SETUP
|
||||
#line 142 "parser.l"
|
||||
#line 140 "parser.l"
|
||||
yy_push_state(ATTR); return '[';
|
||||
YY_BREAK
|
||||
case 10:
|
||||
YY_RULE_SETUP
|
||||
#line 143 "parser.l"
|
||||
#line 141 "parser.l"
|
||||
yy_pop_state(); return ']';
|
||||
YY_BREAK
|
||||
case 11:
|
||||
YY_RULE_SETUP
|
||||
#line 144 "parser.l"
|
||||
#line 142 "parser.l"
|
||||
return attr_token(yytext);
|
||||
YY_BREAK
|
||||
case 12:
|
||||
YY_RULE_SETUP
|
||||
#line 145 "parser.l"
|
||||
#line 143 "parser.l"
|
||||
{
|
||||
parser_lval.uuid = parse_uuid(yytext);
|
||||
return aUUID;
|
||||
|
|
@ -910,7 +908,7 @@ YY_RULE_SETUP
|
|||
YY_BREAK
|
||||
case 13:
|
||||
YY_RULE_SETUP
|
||||
#line 149 "parser.l"
|
||||
#line 147 "parser.l"
|
||||
{
|
||||
parser_lval.num = strtoul(yytext, NULL, 0);
|
||||
return aHEXNUM;
|
||||
|
|
@ -918,7 +916,7 @@ YY_RULE_SETUP
|
|||
YY_BREAK
|
||||
case 14:
|
||||
YY_RULE_SETUP
|
||||
#line 153 "parser.l"
|
||||
#line 151 "parser.l"
|
||||
{
|
||||
parser_lval.num = strtoul(yytext, NULL, 0);
|
||||
return aNUM;
|
||||
|
|
@ -926,7 +924,7 @@ YY_RULE_SETUP
|
|||
YY_BREAK
|
||||
case 15:
|
||||
YY_RULE_SETUP
|
||||
#line 157 "parser.l"
|
||||
#line 155 "parser.l"
|
||||
{
|
||||
parser_lval.dbl = strtod(yytext, NULL);
|
||||
return aDOUBLE;
|
||||
|
|
@ -937,58 +935,56 @@ case 16:
|
|||
yy_c_buf_p = yy_cp -= 1;
|
||||
YY_DO_BEFORE_ACTION; /* set up yytext again */
|
||||
YY_RULE_SETUP
|
||||
#line 161 "parser.l"
|
||||
#line 159 "parser.l"
|
||||
return tSAFEARRAY;
|
||||
YY_BREAK
|
||||
case 17:
|
||||
YY_RULE_SETUP
|
||||
#line 162 "parser.l"
|
||||
#line 160 "parser.l"
|
||||
return kw_token(yytext);
|
||||
YY_BREAK
|
||||
case 18:
|
||||
YY_RULE_SETUP
|
||||
#line 163 "parser.l"
|
||||
#line 161 "parser.l"
|
||||
line_number++;
|
||||
YY_BREAK
|
||||
case 19:
|
||||
YY_RULE_SETUP
|
||||
#line 164 "parser.l"
|
||||
#line 162 "parser.l"
|
||||
|
||||
YY_BREAK
|
||||
case 20:
|
||||
YY_RULE_SETUP
|
||||
#line 165 "parser.l"
|
||||
#line 163 "parser.l"
|
||||
return SHL;
|
||||
YY_BREAK
|
||||
case 21:
|
||||
YY_RULE_SETUP
|
||||
#line 166 "parser.l"
|
||||
#line 164 "parser.l"
|
||||
return SHR;
|
||||
YY_BREAK
|
||||
case 22:
|
||||
YY_RULE_SETUP
|
||||
#line 167 "parser.l"
|
||||
#line 165 "parser.l"
|
||||
return yytext[0];
|
||||
YY_BREAK
|
||||
case YY_STATE_EOF(INITIAL):
|
||||
case YY_STATE_EOF(QUOTE):
|
||||
case YY_STATE_EOF(ATTR):
|
||||
case YY_STATE_EOF(PP_LINE):
|
||||
#line 168 "parser.l"
|
||||
#line 166 "parser.l"
|
||||
{
|
||||
if (import_stack_ptr) {
|
||||
pop_import();
|
||||
if (import_stack_ptr)
|
||||
return aEOF;
|
||||
}
|
||||
else yyterminate();
|
||||
}
|
||||
YY_BREAK
|
||||
case 23:
|
||||
YY_RULE_SETUP
|
||||
#line 175 "parser.l"
|
||||
#line 171 "parser.l"
|
||||
ECHO;
|
||||
YY_BREAK
|
||||
#line 992 "parser.yy.c"
|
||||
#line 988 "parser.yy.c"
|
||||
|
||||
case YY_END_OF_BUFFER:
|
||||
{
|
||||
|
|
@ -1874,7 +1870,7 @@ int main()
|
|||
return 0;
|
||||
}
|
||||
#endif
|
||||
#line 175 "parser.l"
|
||||
#line 171 "parser.l"
|
||||
|
||||
|
||||
#ifndef parser_wrap
|
||||
|
|
@ -1893,13 +1889,19 @@ static const struct keyword keywords[] = {
|
|||
{"FALSE", tFALSE},
|
||||
{"TRUE", tTRUE},
|
||||
{"__cdecl", tCDECL},
|
||||
{"__fastcall", tFASTCALL},
|
||||
{"__int64", tINT64},
|
||||
{"__pascal", tPASCAL},
|
||||
{"__stdcall", tSTDCALL},
|
||||
{"_cdecl", tCDECL},
|
||||
{"_fastcall", tFASTCALL},
|
||||
{"_pascal", tPASCAL},
|
||||
{"_stdcall", tSTDCALL},
|
||||
{"boolean", tBOOLEAN},
|
||||
{"byte", tBYTE},
|
||||
{"callback", tCALLBACK},
|
||||
{"case", tCASE},
|
||||
{"cdecl", tCDECL},
|
||||
{"char", tCHAR},
|
||||
{"coclass", tCOCLASS},
|
||||
{"code", tCODE},
|
||||
|
|
@ -1924,11 +1926,13 @@ static const struct keyword keywords[] = {
|
|||
{"long", tLONG},
|
||||
{"methods", tMETHODS},
|
||||
{"module", tMODULE},
|
||||
{"pascal", tPASCAL},
|
||||
{"properties", tPROPERTIES},
|
||||
{"short", tSHORT},
|
||||
{"signed", tSIGNED},
|
||||
{"sizeof", tSIZEOF},
|
||||
{"small", tSMALL},
|
||||
{"stdcall", tSTDCALL},
|
||||
{"struct", tSTRUCT},
|
||||
{"switch", tSWITCH},
|
||||
{"typedef", tTYPEDEF},
|
||||
|
|
@ -2070,7 +2074,7 @@ static char *get_buffered_cstring(void)
|
|||
return xstrdup(cbuffer);
|
||||
}
|
||||
|
||||
static void pop_import(void)
|
||||
void pop_import(void)
|
||||
{
|
||||
int ptr = import_stack_ptr-1;
|
||||
|
||||
|
|
|
|||
|
|
@ -251,11 +251,11 @@ static void gen_proxy(type_t *iface, const func_t *cur, int idx,
|
|||
unsigned int proc_offset)
|
||||
{
|
||||
var_t *def = cur->def;
|
||||
int has_ret = !is_void(def->type);
|
||||
int has_ret = !is_void(get_func_return_type(cur));
|
||||
int has_full_pointer = is_full_pointer_function(cur);
|
||||
|
||||
indent = 0;
|
||||
write_type_decl_left(proxy, def->type);
|
||||
write_type_decl_left(proxy, get_func_return_type(cur));
|
||||
print_proxy( " STDMETHODCALLTYPE %s_", iface->name);
|
||||
write_name(proxy, def);
|
||||
print_proxy( "_Proxy(\n");
|
||||
|
|
@ -266,13 +266,13 @@ static void gen_proxy(type_t *iface, const func_t *cur, int idx,
|
|||
/* local variables */
|
||||
if (has_ret) {
|
||||
print_proxy( "" );
|
||||
write_type_decl_left(proxy, def->type);
|
||||
write_type_decl_left(proxy, get_func_return_type(cur));
|
||||
print_proxy( " _RetVal;\n");
|
||||
}
|
||||
print_proxy( "RPC_MESSAGE _RpcMessage;\n" );
|
||||
print_proxy( "MIDL_STUB_MESSAGE _StubMsg;\n" );
|
||||
if (has_ret) {
|
||||
if (decl_indirect(def->type))
|
||||
if (decl_indirect(get_func_return_type(cur)))
|
||||
print_proxy("void *_p_%s = &%s;\n",
|
||||
"_RetVal", "_RetVal");
|
||||
}
|
||||
|
|
@ -315,9 +315,9 @@ static void gen_proxy(type_t *iface, const func_t *cur, int idx,
|
|||
|
||||
if (has_ret)
|
||||
{
|
||||
if (decl_indirect(def->type))
|
||||
if (decl_indirect(get_func_return_type(cur)))
|
||||
print_proxy("MIDL_memset(&%s, 0, sizeof(%s));\n", "_RetVal", "_RetVal");
|
||||
else if (is_ptr(def->type) || is_array(def->type))
|
||||
else if (is_ptr(get_func_return_type(cur)) || is_array(get_func_return_type(cur)))
|
||||
print_proxy("%s = 0;\n", "_RetVal");
|
||||
write_remoting_arguments(proxy, indent, cur, PASS_RETURN, PHASE_UNMARSHAL);
|
||||
}
|
||||
|
|
@ -359,7 +359,7 @@ static void gen_stub(type_t *iface, const func_t *cur, const char *cas,
|
|||
{
|
||||
var_t *def = cur->def;
|
||||
const var_t *arg;
|
||||
int has_ret = !is_void(def->type);
|
||||
int has_ret = !is_void(get_func_return_type(cur));
|
||||
int has_full_pointer = is_full_pointer_function(cur);
|
||||
|
||||
indent = 0;
|
||||
|
|
@ -431,13 +431,17 @@ static void gen_stub(type_t *iface, const func_t *cur, const char *cas,
|
|||
|
||||
write_remoting_arguments(proxy, indent, cur, PASS_OUT, PHASE_BUFFERSIZE);
|
||||
|
||||
if (!is_void(get_func_return_type(cur)))
|
||||
write_remoting_arguments(proxy, indent, cur, PASS_RETURN, PHASE_BUFFERSIZE);
|
||||
|
||||
print_proxy("NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);\n");
|
||||
|
||||
write_remoting_arguments(proxy, indent, cur, PASS_OUT, PHASE_MARSHAL);
|
||||
fprintf(proxy, "\n");
|
||||
|
||||
if (has_ret)
|
||||
print_phase_basetype(proxy, indent, PHASE_MARSHAL, PASS_RETURN, def, "_RetVal");
|
||||
/* marshall the return value */
|
||||
if (!is_void(get_func_return_type(cur)))
|
||||
write_remoting_arguments(proxy, indent, cur, PASS_RETURN, PHASE_MARSHAL);
|
||||
|
||||
indent--;
|
||||
print_proxy("}\n");
|
||||
|
|
|
|||
|
|
@ -60,13 +60,21 @@ static void write_function_stubs(type_t *iface, unsigned int *proc_offset)
|
|||
LIST_FOR_EACH_ENTRY( func, iface->funcs, const func_t, entry )
|
||||
{
|
||||
const var_t *def = func->def;
|
||||
const var_t* context_handle_var = NULL;
|
||||
const var_t* explicit_generic_handle_var = NULL;
|
||||
int has_full_pointer = is_full_pointer_function(func);
|
||||
|
||||
/* check for a defined binding handle */
|
||||
explicit_handle_var = get_explicit_handle_var(func);
|
||||
if (!explicit_handle_var)
|
||||
{
|
||||
explicit_generic_handle_var = get_explicit_generic_handle_var(func);
|
||||
if (!explicit_generic_handle_var)
|
||||
context_handle_var = get_context_handle_var(func);
|
||||
}
|
||||
if (explicit_handle)
|
||||
{
|
||||
if (!explicit_handle_var)
|
||||
if (!explicit_handle_var && !explicit_generic_handle_var && !context_handle_var)
|
||||
{
|
||||
error("%s() does not define an explicit binding handle!\n", def->name);
|
||||
return;
|
||||
|
|
@ -164,7 +172,7 @@ static void write_function_stubs(type_t *iface, unsigned int *proc_offset)
|
|||
assign_stub_out_args(server, indent, func);
|
||||
|
||||
/* Call the real server function */
|
||||
if (!is_void(def->type))
|
||||
if (!is_void(get_func_return_type(func)))
|
||||
print_server("_RetVal = ");
|
||||
else
|
||||
print_server("");
|
||||
|
|
@ -184,9 +192,13 @@ static void write_function_stubs(type_t *iface, unsigned int *proc_offset)
|
|||
fprintf(server, ",\n");
|
||||
if (is_context_handle(var->type))
|
||||
{
|
||||
/* if the context_handle attribute appears in the chain of types
|
||||
* without pointers being followed, then the context handle must
|
||||
* be direct, otherwise it is a pointer */
|
||||
int is_ch_ptr = is_aliaschain_attr(var->type, ATTR_CONTEXTHANDLE) ? FALSE : TRUE;
|
||||
print_server("(");
|
||||
write_type_decl_left(server, var->type);
|
||||
fprintf(server, ")%sNDRSContextValue(%s)", is_ptr(var->type) ? "" : "*", var->name);
|
||||
fprintf(server, ")%sNDRSContextValue(%s)", is_ch_ptr ? "" : "*", var->name);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -208,7 +220,7 @@ static void write_function_stubs(type_t *iface, unsigned int *proc_offset)
|
|||
{
|
||||
write_remoting_arguments(server, indent, func, PASS_OUT, PHASE_BUFFERSIZE);
|
||||
|
||||
if (!is_void(def->type))
|
||||
if (!is_void(get_func_return_type(func)))
|
||||
write_remoting_arguments(server, indent, func, PASS_RETURN, PHASE_BUFFERSIZE);
|
||||
|
||||
print_server("_pRpcMessage->BufferLength = _StubMsg.BufferLength;\n");
|
||||
|
|
@ -227,7 +239,7 @@ static void write_function_stubs(type_t *iface, unsigned int *proc_offset)
|
|||
write_remoting_arguments(server, indent, func, PASS_OUT, PHASE_MARSHAL);
|
||||
|
||||
/* marshall the return value */
|
||||
if (!is_void(def->type))
|
||||
if (!is_void(get_func_return_type(func)))
|
||||
write_remoting_arguments(server, indent, func, PASS_RETURN, PHASE_MARSHAL);
|
||||
|
||||
indent--;
|
||||
|
|
|
|||
|
|
@ -58,6 +58,9 @@ static size_t write_struct_tfs(FILE *file, type_t *type, const char *name, unsig
|
|||
static int write_embedded_types(FILE *file, const attr_list_t *attrs, type_t *type,
|
||||
const char *name, int write_ptr, unsigned int *tfsoff);
|
||||
static const var_t *find_array_or_string_in_struct(const type_t *type);
|
||||
static size_t write_string_tfs(FILE *file, const attr_list_t *attrs,
|
||||
type_t *type,
|
||||
const char *name, unsigned int *typestring_offset);
|
||||
|
||||
const char *string_of_type(unsigned char type)
|
||||
{
|
||||
|
|
@ -165,7 +168,7 @@ static int type_has_pointers(const type_t *type)
|
|||
else if (is_struct(type->type))
|
||||
{
|
||||
const var_t *field;
|
||||
if (type->fields) LIST_FOR_EACH_ENTRY( field, type->fields, const var_t, entry )
|
||||
if (type->fields_or_args) LIST_FOR_EACH_ENTRY( field, type->fields_or_args, const var_t, entry )
|
||||
{
|
||||
if (type_has_pointers(field->type))
|
||||
return TRUE;
|
||||
|
|
@ -177,11 +180,11 @@ static int type_has_pointers(const type_t *type)
|
|||
const var_t *field;
|
||||
if (type->type == RPC_FC_ENCAPSULATED_UNION)
|
||||
{
|
||||
const var_t *uv = LIST_ENTRY(list_tail(type->fields), const var_t, entry);
|
||||
fields = uv->type->fields;
|
||||
const var_t *uv = LIST_ENTRY(list_tail(type->fields_or_args), const var_t, entry);
|
||||
fields = uv->type->fields_or_args;
|
||||
}
|
||||
else
|
||||
fields = type->fields;
|
||||
fields = type->fields_or_args;
|
||||
if (fields) LIST_FOR_EACH_ENTRY( field, fields, const var_t, entry )
|
||||
{
|
||||
if (field->type && type_has_pointers(field->type))
|
||||
|
|
@ -205,7 +208,7 @@ static int type_has_full_pointer(const type_t *type)
|
|||
else if (is_struct(type->type))
|
||||
{
|
||||
const var_t *field;
|
||||
if (type->fields) LIST_FOR_EACH_ENTRY( field, type->fields, const var_t, entry )
|
||||
if (type->fields_or_args) LIST_FOR_EACH_ENTRY( field, type->fields_or_args, const var_t, entry )
|
||||
{
|
||||
if (type_has_full_pointer(field->type))
|
||||
return TRUE;
|
||||
|
|
@ -217,11 +220,11 @@ static int type_has_full_pointer(const type_t *type)
|
|||
const var_t *field;
|
||||
if (type->type == RPC_FC_ENCAPSULATED_UNION)
|
||||
{
|
||||
const var_t *uv = LIST_ENTRY(list_tail(type->fields), const var_t, entry);
|
||||
fields = uv->type->fields;
|
||||
const var_t *uv = LIST_ENTRY(list_tail(type->fields_or_args), const var_t, entry);
|
||||
fields = uv->type->fields_or_args;
|
||||
}
|
||||
else
|
||||
fields = type->fields;
|
||||
fields = type->fields_or_args;
|
||||
if (fields) LIST_FOR_EACH_ENTRY( field, fields, const var_t, entry )
|
||||
{
|
||||
if (field->type && type_has_full_pointer(field->type))
|
||||
|
|
@ -415,8 +418,8 @@ void write_parameters_init(FILE *file, int indent, const func_t *func)
|
|||
{
|
||||
const var_t *var;
|
||||
|
||||
if (!is_void(func->def->type))
|
||||
write_var_init(file, indent, func->def->type, "_RetVal");
|
||||
if (!is_void(get_func_return_type(func)))
|
||||
write_var_init(file, indent, get_func_return_type(func), "_RetVal");
|
||||
|
||||
if (!func->args)
|
||||
return;
|
||||
|
|
@ -490,14 +493,16 @@ int decl_indirect(const type_t *t)
|
|||
&& !is_array(t));
|
||||
}
|
||||
|
||||
static size_t write_procformatstring_var(FILE *file, int indent,
|
||||
const var_t *var, int is_return)
|
||||
static size_t write_procformatstring_type(FILE *file, int indent,
|
||||
const char *name,
|
||||
const type_t *type,
|
||||
const attr_list_t *attrs,
|
||||
int is_return)
|
||||
{
|
||||
size_t size;
|
||||
const type_t *type = var->type;
|
||||
|
||||
int is_in = is_attr(var->attrs, ATTR_IN);
|
||||
int is_out = is_attr(var->attrs, ATTR_OUT);
|
||||
int is_in = is_attr(attrs, ATTR_IN);
|
||||
int is_out = is_attr(attrs, ATTR_OUT);
|
||||
|
||||
if (!is_in && !is_out) is_in = TRUE;
|
||||
|
||||
|
|
@ -520,7 +525,7 @@ static size_t write_procformatstring_var(FILE *file, int indent,
|
|||
}
|
||||
else
|
||||
{
|
||||
error("Unknown/unsupported type: %s (0x%02x)\n", var->name, type->type);
|
||||
error("Unknown/unsupported type: %s (0x%02x)\n", name, type->type);
|
||||
size = 0;
|
||||
}
|
||||
}
|
||||
|
|
@ -570,18 +575,17 @@ void write_procformatstring(FILE *file, const ifref_list_t *ifaces, type_pred_t
|
|||
if (func->args)
|
||||
{
|
||||
LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
|
||||
write_procformatstring_var(file, indent, var, FALSE);
|
||||
write_procformatstring_type(file, indent, var->name, var->type, var->attrs, FALSE);
|
||||
}
|
||||
|
||||
/* emit return value data */
|
||||
var = func->def;
|
||||
if (is_void(var->type))
|
||||
if (is_void(get_func_return_type(func)))
|
||||
{
|
||||
print_file(file, indent, "0x5b, /* FC_END */\n");
|
||||
print_file(file, indent, "0x5c, /* FC_PAD */\n");
|
||||
}
|
||||
else
|
||||
write_procformatstring_var(file, indent, var, TRUE);
|
||||
write_procformatstring_type(file, indent, "return value", get_func_return_type(func), NULL, TRUE);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -706,7 +710,7 @@ static size_t write_conf_or_var_desc(FILE *file, const type_t *structure,
|
|||
size_t offset = 0;
|
||||
const var_t *var;
|
||||
|
||||
if (structure->fields) LIST_FOR_EACH_ENTRY( var, structure->fields, const var_t, entry )
|
||||
if (structure->fields_or_args) LIST_FOR_EACH_ENTRY( var, structure->fields_or_args, const var_t, entry )
|
||||
{
|
||||
unsigned int align = 0;
|
||||
/* FIXME: take alignment into account */
|
||||
|
|
@ -921,11 +925,11 @@ size_t type_memsize(const type_t *t, unsigned int *align)
|
|||
case RPC_FC_CSTRUCT:
|
||||
case RPC_FC_PSTRUCT:
|
||||
case RPC_FC_BOGUS_STRUCT:
|
||||
size = fields_memsize(t->fields, align);
|
||||
size = fields_memsize(t->fields_or_args, align);
|
||||
break;
|
||||
case RPC_FC_ENCAPSULATED_UNION:
|
||||
case RPC_FC_NON_ENCAPSULATED_UNION:
|
||||
size = union_memsize(t->fields, align);
|
||||
size = union_memsize(t->fields_or_args, align);
|
||||
break;
|
||||
case RPC_FC_SMFARRAY:
|
||||
case RPC_FC_LGFARRAY:
|
||||
|
|
@ -945,7 +949,7 @@ size_t type_memsize(const type_t *t, unsigned int *align)
|
|||
int is_full_pointer_function(const func_t *func)
|
||||
{
|
||||
const var_t *var;
|
||||
if (type_has_full_pointer(func->def->type))
|
||||
if (type_has_full_pointer(get_func_return_type(func)))
|
||||
return TRUE;
|
||||
if (!func->args)
|
||||
return FALSE;
|
||||
|
|
@ -981,27 +985,13 @@ static unsigned int write_nonsimple_pointer(FILE *file, const type_t *type, size
|
|||
return 4;
|
||||
}
|
||||
|
||||
static unsigned char conf_string_type_of_char_type(unsigned char t)
|
||||
{
|
||||
switch (t)
|
||||
{
|
||||
case RPC_FC_BYTE:
|
||||
case RPC_FC_CHAR:
|
||||
return RPC_FC_C_CSTRING;
|
||||
case RPC_FC_WCHAR:
|
||||
return RPC_FC_C_WSTRING;
|
||||
}
|
||||
|
||||
error("string_type_of_char_type: unrecognized type %d\n", t);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static unsigned int write_simple_pointer(FILE *file, const type_t *type)
|
||||
{
|
||||
unsigned char fc
|
||||
= is_string_type(type->attrs, type)
|
||||
? conf_string_type_of_char_type(type->ref->type)
|
||||
: type->ref->type;
|
||||
unsigned char fc = type->ref->type;
|
||||
/* for historical reasons, write_simple_pointer also handled string types,
|
||||
* but no longer does. catch bad uses of the function with this check */
|
||||
if (is_string_type(type->attrs, type))
|
||||
error("write_simple_pointer: can't handle type %s which is a string type\n", type->name);
|
||||
print_file(file, 2, "0x%02x, 0x8,\t/* %s [simple_pointer] */\n",
|
||||
type->type, string_of_type(type->type));
|
||||
print_file(file, 2, "0x%02x,\t/* %s */\n", fc, string_of_type(fc));
|
||||
|
|
@ -1157,7 +1147,7 @@ static void write_end(FILE *file, unsigned int *tfsoff)
|
|||
static void write_descriptors(FILE *file, type_t *type, unsigned int *tfsoff)
|
||||
{
|
||||
unsigned int offset = 0;
|
||||
var_list_t *fs = type->fields;
|
||||
var_list_t *fs = type->fields_or_args;
|
||||
var_t *f;
|
||||
|
||||
if (fs) LIST_FOR_EACH_ENTRY(f, fs, var_t, entry)
|
||||
|
|
@ -1202,7 +1192,12 @@ static int write_no_repeat_pointer_descriptions(
|
|||
*typestring_offset += 6;
|
||||
|
||||
if (is_ptr(type))
|
||||
write_pointer_tfs(file, type, typestring_offset);
|
||||
{
|
||||
if (is_string_type(type->attrs, type))
|
||||
write_string_tfs(file, NULL, type, NULL, typestring_offset);
|
||||
else
|
||||
write_pointer_tfs(file, type, typestring_offset);
|
||||
}
|
||||
else
|
||||
{
|
||||
unsigned absoff = type->typestring_offset;
|
||||
|
|
@ -1226,7 +1221,7 @@ static int write_no_repeat_pointer_descriptions(
|
|||
if (is_non_complex_struct(type))
|
||||
{
|
||||
const var_t *v;
|
||||
LIST_FOR_EACH_ENTRY( v, type->fields, const var_t, entry )
|
||||
LIST_FOR_EACH_ENTRY( v, type->fields_or_args, const var_t, entry )
|
||||
written += write_no_repeat_pointer_descriptions(
|
||||
file, v->type,
|
||||
offset_in_memory, offset_in_buffer, typestring_offset);
|
||||
|
|
@ -1268,7 +1263,9 @@ static int write_pointer_description_offsets(
|
|||
}
|
||||
*typestring_offset += 4;
|
||||
|
||||
if (processed(type->ref) || is_base_type(type->ref->type))
|
||||
if (is_string_type(attrs, type))
|
||||
write_string_tfs(file, NULL, type, NULL, typestring_offset);
|
||||
else if (processed(type->ref) || is_base_type(type->ref->type))
|
||||
write_pointer_tfs(file, type, typestring_offset);
|
||||
else
|
||||
error("write_pointer_description_offsets: type format string unknown\n");
|
||||
|
|
@ -1286,7 +1283,7 @@ static int write_pointer_description_offsets(
|
|||
{
|
||||
/* otherwise search for interesting fields to parse */
|
||||
const var_t *v;
|
||||
LIST_FOR_EACH_ENTRY( v, type->fields, const var_t, entry )
|
||||
LIST_FOR_EACH_ENTRY( v, type->fields_or_args, const var_t, entry )
|
||||
{
|
||||
written += write_pointer_description_offsets(
|
||||
file, v->attrs, v->type, offset_in_memory, offset_in_buffer,
|
||||
|
|
@ -1349,7 +1346,7 @@ static int write_fixed_array_pointer_descriptions(
|
|||
else if (is_struct(type->type))
|
||||
{
|
||||
const var_t *v;
|
||||
LIST_FOR_EACH_ENTRY( v, type->fields, const var_t, entry )
|
||||
LIST_FOR_EACH_ENTRY( v, type->fields_or_args, const var_t, entry )
|
||||
{
|
||||
pointer_count += write_fixed_array_pointer_descriptions(
|
||||
file, v->attrs, v->type, offset_in_memory, offset_in_buffer,
|
||||
|
|
@ -1460,7 +1457,7 @@ static int write_varying_array_pointer_descriptions(
|
|||
else if (is_struct(type->type))
|
||||
{
|
||||
const var_t *v;
|
||||
LIST_FOR_EACH_ENTRY( v, type->fields, const var_t, entry )
|
||||
LIST_FOR_EACH_ENTRY( v, type->fields_or_args, const var_t, entry )
|
||||
{
|
||||
pointer_count += write_varying_array_pointer_descriptions(
|
||||
file, v->attrs, v->type, offset_in_memory, offset_in_buffer,
|
||||
|
|
@ -1535,18 +1532,18 @@ int is_declptr(const type_t *t)
|
|||
|
||||
static size_t write_string_tfs(FILE *file, const attr_list_t *attrs,
|
||||
type_t *type,
|
||||
const char *name, unsigned int *typestring_offset,
|
||||
int toplevel)
|
||||
const char *name, unsigned int *typestring_offset)
|
||||
{
|
||||
size_t start_offset;
|
||||
unsigned char rtype;
|
||||
|
||||
if (toplevel && is_declptr(type))
|
||||
if (is_declptr(type))
|
||||
{
|
||||
unsigned char flag = is_conformant_array(type) ? 0 : RPC_FC_P_SIMPLEPOINTER;
|
||||
int pointer_type = is_ptr(type) ? type->type : get_attrv(attrs, ATTR_POINTERTYPE);
|
||||
if (!pointer_type)
|
||||
pointer_type = RPC_FC_RP;
|
||||
print_start_tfs_comment(file, type, *typestring_offset);
|
||||
print_file(file, 2,"0x%x, 0x%x,\t/* %s%s */\n",
|
||||
pointer_type, flag, string_of_type(pointer_type),
|
||||
flag ? " [simple_pointer]" : "");
|
||||
|
|
@ -1733,7 +1730,7 @@ static size_t write_array_tfs(FILE *file, const attr_list_t *attrs, type_t *type
|
|||
|
||||
static const var_t *find_array_or_string_in_struct(const type_t *type)
|
||||
{
|
||||
const var_t *last_field = LIST_ENTRY( list_tail(type->fields), const var_t, entry );
|
||||
const var_t *last_field = LIST_ENTRY( list_tail(type->fields_or_args), const var_t, entry );
|
||||
const type_t *ft = last_field->type;
|
||||
|
||||
if (ft->declarray && is_conformant_array(ft))
|
||||
|
|
@ -1753,7 +1750,7 @@ static void write_struct_members(FILE *file, const type_t *type,
|
|||
int salign = -1;
|
||||
int padding;
|
||||
|
||||
if (type->fields) LIST_FOR_EACH_ENTRY( field, type->fields, const var_t, entry )
|
||||
if (type->fields_or_args) LIST_FOR_EACH_ENTRY( field, type->fields_or_args, const var_t, entry )
|
||||
{
|
||||
type_t *ft = field->type;
|
||||
if (!ft->declarray || !is_conformant_array(ft))
|
||||
|
|
@ -1819,7 +1816,7 @@ static size_t write_struct_tfs(FILE *file, type_t *type,
|
|||
error("structure size for %s exceeds %d bytes by %d bytes\n",
|
||||
name, USHRT_MAX, total_size - USHRT_MAX);
|
||||
|
||||
if (type->fields) LIST_FOR_EACH_ENTRY(f, type->fields, var_t, entry)
|
||||
if (type->fields_or_args) LIST_FOR_EACH_ENTRY(f, type->fields_or_args, var_t, entry)
|
||||
has_pointers |= write_embedded_types(file, f->attrs, f->type, f->name,
|
||||
FALSE, tfsoff);
|
||||
if (!has_pointers) has_pointers = type_has_pointers(type);
|
||||
|
|
@ -1828,7 +1825,7 @@ static size_t write_struct_tfs(FILE *file, type_t *type,
|
|||
if (array && !processed(array->type))
|
||||
array_offset
|
||||
= is_attr(array->attrs, ATTR_STRING)
|
||||
? write_string_tfs(file, array->attrs, array->type, array->name, tfsoff, FALSE)
|
||||
? write_string_tfs(file, array->attrs, array->type, array->name, tfsoff)
|
||||
: write_array_tfs(file, array->attrs, array->type, array->name, tfsoff);
|
||||
|
||||
corroff = *tfsoff;
|
||||
|
|
@ -1883,7 +1880,7 @@ static size_t write_struct_tfs(FILE *file, type_t *type,
|
|||
|
||||
if (type->type == RPC_FC_BOGUS_STRUCT)
|
||||
{
|
||||
const var_list_t *fs = type->fields;
|
||||
const var_list_t *fs = type->fields_or_args;
|
||||
const var_t *f;
|
||||
|
||||
type->ptrdesc = *tfsoff;
|
||||
|
|
@ -1891,7 +1888,12 @@ static size_t write_struct_tfs(FILE *file, type_t *type,
|
|||
{
|
||||
type_t *ft = f->type;
|
||||
if (is_ptr(ft))
|
||||
write_pointer_tfs(file, ft, tfsoff);
|
||||
{
|
||||
if (is_string_type(f->attrs, ft))
|
||||
write_string_tfs(file, f->attrs, ft, f->name, tfsoff);
|
||||
else
|
||||
write_pointer_tfs(file, ft, tfsoff);
|
||||
}
|
||||
else if (!ft->declarray && is_conformant_array(ft))
|
||||
{
|
||||
unsigned int absoff = ft->typestring_offset;
|
||||
|
|
@ -1988,11 +1990,11 @@ static size_t write_union_tfs(FILE *file, type_t *type, unsigned int *tfsoff)
|
|||
|
||||
if (type->type == RPC_FC_ENCAPSULATED_UNION)
|
||||
{
|
||||
const var_t *uv = LIST_ENTRY(list_tail(type->fields), const var_t, entry);
|
||||
fields = uv->type->fields;
|
||||
const var_t *uv = LIST_ENTRY(list_tail(type->fields_or_args), const var_t, entry);
|
||||
fields = uv->type->fields_or_args;
|
||||
}
|
||||
else
|
||||
fields = type->fields;
|
||||
fields = type->fields_or_args;
|
||||
|
||||
if (fields) LIST_FOR_EACH_ENTRY(f, fields, var_t, entry)
|
||||
{
|
||||
|
|
@ -2008,7 +2010,7 @@ static size_t write_union_tfs(FILE *file, type_t *type, unsigned int *tfsoff)
|
|||
print_start_tfs_comment(file, type, start_offset);
|
||||
if (type->type == RPC_FC_ENCAPSULATED_UNION)
|
||||
{
|
||||
const var_t *sv = LIST_ENTRY(list_head(type->fields), const var_t, entry);
|
||||
const var_t *sv = LIST_ENTRY(list_head(type->fields_or_args), const var_t, entry);
|
||||
const type_t *st = sv->type;
|
||||
|
||||
switch (st->type)
|
||||
|
|
@ -2181,8 +2183,8 @@ static size_t write_typeformatstring_var(FILE *file, int indent, const func_t *f
|
|||
return type->typestring_offset;
|
||||
}
|
||||
|
||||
if ((last_ptr(type) || last_array(type)) && is_ptrchain_attr(var, ATTR_STRING))
|
||||
return write_string_tfs(file, var->attrs, type, var->name, typeformat_offset, TRUE);
|
||||
if (is_string_type(var->attrs, type))
|
||||
return write_string_tfs(file, var->attrs, type, var->name, typeformat_offset);
|
||||
|
||||
if (is_array(type))
|
||||
{
|
||||
|
|
@ -2286,6 +2288,10 @@ static int write_embedded_types(FILE *file, const attr_list_t *attrs, type_t *ty
|
|||
{
|
||||
write_user_tfs(file, type, tfsoff);
|
||||
}
|
||||
else if (is_string_type(attrs, type))
|
||||
{
|
||||
write_string_tfs(file, attrs, type, name, tfsoff);
|
||||
}
|
||||
else if (is_ptr(type))
|
||||
{
|
||||
type_t *ref = type->ref;
|
||||
|
|
@ -2307,10 +2313,6 @@ static int write_embedded_types(FILE *file, const attr_list_t *attrs, type_t *ty
|
|||
retmask |= 1;
|
||||
}
|
||||
}
|
||||
else if (last_array(type) && is_attr(attrs, ATTR_STRING))
|
||||
{
|
||||
write_string_tfs(file, attrs, type, name, tfsoff, FALSE);
|
||||
}
|
||||
else if (type->declarray && is_conformant_array(type))
|
||||
; /* conformant arrays and strings are handled specially */
|
||||
else if (is_array(type))
|
||||
|
|
@ -2355,12 +2357,16 @@ static size_t process_tfs(FILE *file, const ifref_list_t *ifaces, type_pred_t pr
|
|||
{
|
||||
if (is_local(func->def->attrs)) continue;
|
||||
|
||||
if (!is_void(func->def->type))
|
||||
update_tfsoff(func->def->type,
|
||||
if (!is_void(get_func_return_type(func)))
|
||||
{
|
||||
var_t v = *func->def;
|
||||
v.type = get_func_return_type(func);
|
||||
update_tfsoff(get_func_return_type(func),
|
||||
write_typeformatstring_var(
|
||||
file, 2, NULL, func->def->type,
|
||||
func->def, &typeformat_offset),
|
||||
file, 2, NULL, get_func_return_type(func),
|
||||
&v, &typeformat_offset),
|
||||
file);
|
||||
}
|
||||
|
||||
current_func = func;
|
||||
if (func->args)
|
||||
|
|
@ -2452,8 +2458,8 @@ static unsigned int get_required_buffer_size_type(
|
|||
{
|
||||
size_t size = 0;
|
||||
const var_t *field;
|
||||
if (!type->fields) return 0;
|
||||
LIST_FOR_EACH_ENTRY( field, type->fields, const var_t, entry )
|
||||
if (!type->fields_or_args) return 0;
|
||||
LIST_FOR_EACH_ENTRY( field, type->fields_or_args, const var_t, entry )
|
||||
{
|
||||
unsigned int alignment;
|
||||
size += get_required_buffer_size_type(field->type, field->name,
|
||||
|
|
@ -2507,8 +2513,8 @@ static unsigned int get_required_buffer_size(const var_t *var, unsigned int *ali
|
|||
const var_t *field;
|
||||
unsigned int size = 36;
|
||||
|
||||
if (!type->fields) return size;
|
||||
LIST_FOR_EACH_ENTRY( field, type->fields, const var_t, entry )
|
||||
if (!type->fields_or_args) return size;
|
||||
LIST_FOR_EACH_ENTRY( field, type->fields_or_args, const var_t, entry )
|
||||
{
|
||||
unsigned int align;
|
||||
size += get_required_buffer_size_type(
|
||||
|
|
@ -2537,8 +2543,8 @@ static unsigned int get_required_buffer_size(const var_t *var, unsigned int *ali
|
|||
unsigned int size = 36;
|
||||
const var_t *field;
|
||||
|
||||
if (!type->fields) return size;
|
||||
LIST_FOR_EACH_ENTRY( field, type->fields, const var_t, entry )
|
||||
if (!type->fields_or_args) return size;
|
||||
LIST_FOR_EACH_ENTRY( field, type->fields_or_args, const var_t, entry )
|
||||
{
|
||||
unsigned int align;
|
||||
size += get_required_buffer_size_type(
|
||||
|
|
@ -2567,9 +2573,11 @@ static unsigned int get_function_buffer_size( const func_t *func, enum pass pass
|
|||
}
|
||||
}
|
||||
|
||||
if (pass == PASS_OUT && !is_void(func->def->type))
|
||||
if (pass == PASS_OUT && !is_void(get_func_return_type(func)))
|
||||
{
|
||||
total_size += get_required_buffer_size(func->def, &alignment, PASS_RETURN);
|
||||
var_t v = *func->def;
|
||||
v.type = get_func_return_type(func);
|
||||
total_size += get_required_buffer_size(&v, &alignment, PASS_RETURN);
|
||||
total_size += alignment;
|
||||
}
|
||||
return total_size;
|
||||
|
|
@ -2778,9 +2786,13 @@ static void write_remoting_arg(FILE *file, int indent, const func_t *func,
|
|||
{
|
||||
if (pass == PASS_IN)
|
||||
{
|
||||
/* if the context_handle attribute appears in the chain of types
|
||||
* without pointers being followed, then the context handle must
|
||||
* be direct, otherwise it is a pointer */
|
||||
int is_ch_ptr = is_aliaschain_attr(type, ATTR_CONTEXTHANDLE) ? FALSE : TRUE;
|
||||
print_file(file, indent, "NdrClientContextMarshall(\n");
|
||||
print_file(file, indent + 1, "&_StubMsg,\n");
|
||||
print_file(file, indent + 1, "(NDR_CCONTEXT)%s%s,\n", is_ptr(type) ? "*" : "", var->name);
|
||||
print_file(file, indent + 1, "(NDR_CCONTEXT)%s%s,\n", is_ch_ptr ? "*" : "", var->name);
|
||||
print_file(file, indent + 1, "%s);\n", in_attr && out_attr ? "1" : "0");
|
||||
}
|
||||
else
|
||||
|
|
@ -3008,6 +3020,7 @@ void write_remoting_arguments(FILE *file, int indent, const func_t *func,
|
|||
{
|
||||
var_t var;
|
||||
var = *func->def;
|
||||
var.type = get_func_return_type(func);
|
||||
var.name = xstrdup( "_RetVal" );
|
||||
write_remoting_arg( file, indent, func, pass, phase, &var );
|
||||
free( var.name );
|
||||
|
|
@ -3023,9 +3036,9 @@ void write_remoting_arguments(FILE *file, int indent, const func_t *func,
|
|||
}
|
||||
|
||||
|
||||
size_t get_size_procformatstring_var(const var_t *var)
|
||||
size_t get_size_procformatstring_type(const char *name, const type_t *type, const attr_list_t *attrs)
|
||||
{
|
||||
return write_procformatstring_var(NULL, 0, var, FALSE);
|
||||
return write_procformatstring_type(NULL, 0, name, type, attrs, FALSE);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -3037,13 +3050,13 @@ size_t get_size_procformatstring_func(const func_t *func)
|
|||
/* argument list size */
|
||||
if (func->args)
|
||||
LIST_FOR_EACH_ENTRY( var, func->args, const var_t, entry )
|
||||
size += get_size_procformatstring_var(var);
|
||||
size += get_size_procformatstring_type(var->name, var->type, var->attrs);
|
||||
|
||||
/* return value size */
|
||||
if (is_void(func->def->type))
|
||||
if (is_void(get_func_return_type(func)))
|
||||
size += 2; /* FC_END and FC_PAD */
|
||||
else
|
||||
size += get_size_procformatstring_var(func->def);
|
||||
size += get_size_procformatstring_type("return value", get_func_return_type(func), NULL);
|
||||
|
||||
return size;
|
||||
}
|
||||
|
|
@ -3175,14 +3188,13 @@ void declare_stub_args( FILE *file, int indent, const func_t *func )
|
|||
{
|
||||
int in_attr, out_attr;
|
||||
int i = 0;
|
||||
const var_t *def = func->def;
|
||||
const var_t *var;
|
||||
|
||||
/* declare return value '_RetVal' */
|
||||
if (!is_void(def->type))
|
||||
if (!is_void(get_func_return_type(func)))
|
||||
{
|
||||
print_file(file, indent, "");
|
||||
write_type_decl_left(file, def->type);
|
||||
write_type_decl_left(file, get_func_return_type(func));
|
||||
fprintf(file, " _RetVal;\n");
|
||||
}
|
||||
|
||||
|
|
@ -3299,7 +3311,7 @@ int write_expr_eval_routines(FILE *file, const char *iface)
|
|||
LIST_FOR_EACH_ENTRY(eval, &expr_eval_routines, struct expr_eval_routine, entry)
|
||||
{
|
||||
const char *name = eval->structure->name;
|
||||
const var_list_t *fields = eval->structure->fields;
|
||||
const var_list_t *fields = eval->structure->fields_or_args;
|
||||
result = 1;
|
||||
|
||||
print_file(file, 0, "static void __RPC_USER %s_%sExprEval_%04u(PMIDL_STUB_MESSAGE pStubMsg)\n",
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@ void write_procformatstring(FILE *file, const ifref_list_t *ifaces, type_pred_t
|
|||
void write_typeformatstring(FILE *file, const ifref_list_t *ifaces, type_pred_t pred);
|
||||
void print_phase_basetype(FILE *file, int indent, enum remoting_phase phase, enum pass pass, const var_t *var, const char *varname);
|
||||
void write_remoting_arguments(FILE *file, int indent, const func_t *func, enum pass pass, enum remoting_phase phase);
|
||||
size_t get_size_procformatstring_var(const var_t *var);
|
||||
size_t get_size_procformatstring_type(const char *name, const type_t *type, const attr_list_t *attrs);
|
||||
size_t get_size_procformatstring_func(const func_t *func);
|
||||
size_t get_size_procformatstring(const ifref_list_t *ifaces, type_pred_t pred);
|
||||
size_t get_size_typeformatstring(const ifref_list_t *ifaces, type_pred_t pred);
|
||||
|
|
|
|||
|
|
@ -601,6 +601,7 @@ int main(int argc,char *argv[])
|
|||
fprintf(header, "/* Begin additional prototypes for all interfaces */\n");
|
||||
fprintf(header, "\n");
|
||||
write_user_types();
|
||||
write_generic_handle_routines();
|
||||
write_context_handle_rundowns();
|
||||
fprintf(header, "\n");
|
||||
fprintf(header, "/* End additional prototypes */\n");
|
||||
|
|
|
|||
|
|
@ -1,7 +1,16 @@
|
|||
Index: hash.c
|
||||
===================================================================
|
||||
--- hash.c (revision 32187)
|
||||
+++ hash.c (working copy)
|
||||
--- client.c 2008-09-27 21:56:02.000000000 +0200
|
||||
+++ client.c 2008-09-27 20:49:05.000000000 +0200
|
||||
@@ -113,7 +113,7 @@
|
||||
}
|
||||
if (explicit_handle)
|
||||
{
|
||||
- if (!explicit_handle_var || !explicit_generic_handle_var || !context_handle_var)
|
||||
+ if (!explicit_handle_var && !explicit_generic_handle_var && !context_handle_var)
|
||||
{
|
||||
error("%s() does not define an explicit binding handle!\n", def->name);
|
||||
return;
|
||||
--- hash.c 2008-09-27 21:56:02.000000000 +0200
|
||||
+++ hash.c 2008-09-22 00:14:35.703125000 +0200
|
||||
@@ -21,9 +21,7 @@
|
||||
#include <stdio.h>
|
||||
#include <stdarg.h>
|
||||
|
|
@ -34,11 +43,170 @@ Index: hash.c
|
|||
nOffset = 16;
|
||||
pnLookup = Lookup_16;
|
||||
break;
|
||||
Index: server.c
|
||||
===================================================================
|
||||
--- server.c (revision 32187)
|
||||
+++ server.c (working copy)
|
||||
@@ -390,6 +390,7 @@
|
||||
--- header.c 2008-09-27 21:56:02.000000000 +0200
|
||||
+++ header.c 2008-09-27 20:49:05.000000000 +0200
|
||||
@@ -891,6 +891,8 @@
|
||||
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);
|
||||
|
||||
@@ -901,8 +903,14 @@
|
||||
|
||||
/* 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) {
|
||||
+ if (!explicit_handle_var && !explicit_generic_handle_var && !context_handle_var) {
|
||||
error("%s() does not define an explicit binding handle!\n", def->name);
|
||||
return;
|
||||
}
|
||||
--- header.h 2008-09-27 21:56:02.000000000 +0200
|
||||
+++ header.h 2008-09-23 21:14:50.781250000 +0200
|
||||
@@ -66,6 +66,7 @@
|
||||
extern const var_t* get_explicit_handle_var(const func_t* func);
|
||||
extern const type_t* get_explicit_generic_handle_type(const var_t* var);
|
||||
extern const var_t* get_explicit_generic_handle_var(const func_t* func);
|
||||
+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);
|
||||
@@ -88,11 +89,19 @@
|
||||
|
||||
static inline int is_context_handle(const type_t *type)
|
||||
{
|
||||
- const type_t *t;
|
||||
- for (t = type; is_ptr(t); t = t->ref)
|
||||
- if (is_attr(t->attrs, ATTR_CONTEXTHANDLE))
|
||||
+ if (is_attr(type->attrs, ATTR_CONTEXTHANDLE))
|
||||
+ return 1;
|
||||
+
|
||||
+ for (;;)
|
||||
+ {
|
||||
+ if (is_attr(type->attrs, ATTR_CONTEXTHANDLE))
|
||||
return 1;
|
||||
- return 0;
|
||||
+ else if (type->kind == TKIND_ALIAS)
|
||||
+ type = type->orig;
|
||||
+ else if (is_ptr(type))
|
||||
+ type = type->ref;
|
||||
+ else return 0;
|
||||
+ }
|
||||
}
|
||||
|
||||
#endif
|
||||
--- proxy.c 2008-09-27 21:56:02.000000000 +0200
|
||||
+++ proxy.c 2008-09-27 20:49:05.000000000 +0200
|
||||
@@ -463,41 +463,45 @@
|
||||
print_proxy("\n");
|
||||
}
|
||||
|
||||
-static int write_proxy_methods(type_t *iface)
|
||||
+static int write_proxy_methods(type_t *iface, int skip)
|
||||
{
|
||||
const func_t *cur;
|
||||
int i = 0;
|
||||
|
||||
- if (iface->ref) i = write_proxy_methods(iface->ref);
|
||||
+ if (iface->ref) i = write_proxy_methods(iface->ref, iface->ref->ref != NULL);
|
||||
if (iface->funcs) LIST_FOR_EACH_ENTRY( cur, iface->funcs, const func_t, entry ) {
|
||||
var_t *def = cur->def;
|
||||
if (!is_callas(def->attrs)) {
|
||||
if (i) fprintf(proxy, ",\n");
|
||||
- print_proxy( "%s_", iface->name);
|
||||
+ print_proxy( "%s%s_", skip ? "0\t/* " : "", iface->name);
|
||||
write_name(proxy, def);
|
||||
- fprintf(proxy, "_Proxy");
|
||||
+ fprintf(proxy, "_Proxy%s", skip ? " */" : "");
|
||||
i++;
|
||||
}
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
||||
-static int write_stub_methods(type_t *iface)
|
||||
+static int write_stub_methods(type_t *iface, int skip)
|
||||
{
|
||||
const func_t *cur;
|
||||
int i = 0;
|
||||
|
||||
- if (iface->ref) i = write_stub_methods(iface->ref);
|
||||
+ if (iface->ref) i = write_stub_methods(iface->ref, TRUE);
|
||||
else return i; /* skip IUnknown */
|
||||
|
||||
if (iface->funcs) LIST_FOR_EACH_ENTRY( cur, iface->funcs, const func_t, entry ) {
|
||||
var_t *def = cur->def;
|
||||
if (!is_local(def->attrs)) {
|
||||
- if (i) fprintf(proxy,",\n");
|
||||
- print_proxy( "%s_", iface->name);
|
||||
- write_name(proxy, def);
|
||||
- fprintf(proxy, "_Stub");
|
||||
- i++;
|
||||
+ if (skip)
|
||||
+ print_proxy("STUB_FORWARDING_FUNCTION,\n");
|
||||
+ else {
|
||||
+ if (i) fprintf(proxy,",\n");
|
||||
+ print_proxy( "%s_", iface->name);
|
||||
+ write_name(proxy, def);
|
||||
+ fprintf(proxy, "_Stub");
|
||||
+ i++;
|
||||
+ }
|
||||
}
|
||||
}
|
||||
return i;
|
||||
@@ -551,7 +555,7 @@
|
||||
print_proxy( "},\n");
|
||||
print_proxy( "{\n");
|
||||
indent++;
|
||||
- write_proxy_methods(iface);
|
||||
+ write_proxy_methods(iface, FALSE);
|
||||
fprintf(proxy, "\n");
|
||||
indent--;
|
||||
print_proxy( "}\n");
|
||||
@@ -563,7 +567,7 @@
|
||||
print_proxy( "static const PRPC_STUB_FUNCTION %s_table[] =\n", iface->name);
|
||||
print_proxy( "{\n");
|
||||
indent++;
|
||||
- stubs = write_stub_methods(iface);
|
||||
+ stubs = write_stub_methods(iface, FALSE);
|
||||
fprintf(proxy, "\n");
|
||||
indent--;
|
||||
fprintf(proxy, "};\n");
|
||||
--- server.c 2008-09-27 21:56:02.000000000 +0200
|
||||
+++ server.c 2008-09-27 20:49:05.000000000 +0200
|
||||
@@ -60,13 +60,21 @@
|
||||
LIST_FOR_EACH_ENTRY( func, iface->funcs, const func_t, entry )
|
||||
{
|
||||
const var_t *def = func->def;
|
||||
+ const var_t* context_handle_var = NULL;
|
||||
+ const var_t* explicit_generic_handle_var = NULL;
|
||||
int has_full_pointer = is_full_pointer_function(func);
|
||||
|
||||
/* check for a defined binding handle */
|
||||
explicit_handle_var = get_explicit_handle_var(func);
|
||||
+ if (!explicit_handle_var)
|
||||
+ {
|
||||
+ explicit_generic_handle_var = get_explicit_generic_handle_var(func);
|
||||
+ if (!explicit_generic_handle_var)
|
||||
+ context_handle_var = get_context_handle_var(func);
|
||||
+ }
|
||||
if (explicit_handle)
|
||||
{
|
||||
- if (!explicit_handle_var)
|
||||
+ if (!explicit_handle_var && !explicit_generic_handle_var && !context_handle_var)
|
||||
{
|
||||
error("%s() does not define an explicit binding handle!\n", def->name);
|
||||
return;
|
||||
@@ -399,6 +407,7 @@
|
||||
print_server("/*** Autogenerated by WIDL %s from %s - Do not edit ***/\n", PACKAGE_VERSION, input_name);
|
||||
print_server("#include <string.h>\n");
|
||||
fprintf(server, "\n");
|
||||
|
|
@ -46,10 +214,8 @@ Index: server.c
|
|||
print_server("#include \"%s\"\n", header_name);
|
||||
fprintf(server, "\n");
|
||||
}
|
||||
Index: typelib.c
|
||||
===================================================================
|
||||
--- typelib.c (revision 32187)
|
||||
+++ typelib.c (working copy)
|
||||
--- typelib.c 2008-09-27 21:56:02.000000000 +0200
|
||||
+++ typelib.c 2008-09-27 20:49:05.000000000 +0200
|
||||
@@ -35,8 +35,7 @@
|
||||
#define NONAMELESSUNION
|
||||
#define NONAMELESSSTRUCT
|
||||
|
|
@ -60,10 +226,41 @@ Index: typelib.c
|
|||
|
||||
#include "widl.h"
|
||||
#include "utils.h"
|
||||
Index: widl.c
|
||||
===================================================================
|
||||
--- widl.c (revision 32187)
|
||||
+++ widl.c (working copy)
|
||||
@@ -360,10 +359,10 @@
|
||||
|
||||
file_name = wpp_find_include(importlib->name, NULL);
|
||||
if(file_name) {
|
||||
- fd = open(file_name, O_RDONLY);
|
||||
+ fd = open(file_name, O_RDONLY | O_BINARY);
|
||||
free(file_name);
|
||||
}else {
|
||||
- fd = open(importlib->name, O_RDONLY);
|
||||
+ fd = open(importlib->name, O_RDONLY | O_BINARY);
|
||||
}
|
||||
|
||||
if(fd < 0)
|
||||
--- typelib_struct.h 2008-09-27 21:56:02.000000000 +0200
|
||||
+++ typelib_struct.h 2008-09-22 00:14:35.703125000 +0200
|
||||
@@ -302,7 +302,7 @@
|
||||
*
|
||||
*/
|
||||
|
||||
-#include "pshpack1.h"
|
||||
+#include <host/pshpack1.h>
|
||||
|
||||
typedef struct {
|
||||
/*00*/ DWORD SLTG_magic; /* 0x47544c53 == "SLTG" */
|
||||
@@ -599,7 +599,7 @@
|
||||
WORD typeofarray
|
||||
*/
|
||||
|
||||
-#include "poppack.h"
|
||||
+#include <host/poppack.h>
|
||||
|
||||
/*---------------------------END--------------------------------------------*/
|
||||
#endif
|
||||
--- widl.c 2008-09-27 21:56:02.000000000 +0200
|
||||
+++ widl.c 2008-09-27 20:49:05.000000000 +0200
|
||||
@@ -174,7 +174,7 @@
|
||||
token = xstrdup(name);
|
||||
for (i=0; token[i]; i++) {
|
||||
|
|
@ -83,8 +280,8 @@ Index: widl.c
|
|||
+ fprintf(header, "#define __%s__\n", header_token);
|
||||
start_cplusplus_guard(header);
|
||||
}
|
||||
|
||||
@@ -606,7 +606,7 @@
|
||||
|
||||
@@ -607,7 +607,7 @@
|
||||
fprintf(header, "/* End additional prototypes */\n");
|
||||
fprintf(header, "\n");
|
||||
end_cplusplus_guard(header);
|
||||
|
|
@ -92,10 +289,9 @@ Index: widl.c
|
|||
+ fprintf(header, "#endif /* __%s__ */\n", header_token);
|
||||
fclose(header);
|
||||
}
|
||||
Index: widltypes.h
|
||||
===================================================================
|
||||
--- widltypes.h (revision 32187)
|
||||
+++ widltypes.h (working copy)
|
||||
|
||||
--- widltypes.h 2008-09-27 21:56:02.000000000 +0200
|
||||
+++ widltypes.h 2008-09-26 19:42:52.859375000 +0200
|
||||
@@ -21,6 +21,13 @@
|
||||
#ifndef __WIDL_WIDLTYPES_H
|
||||
#define __WIDL_WIDLTYPES_H
|
||||
|
|
@ -110,7 +306,7 @@ Index: widltypes.h
|
|||
#include <stdarg.h>
|
||||
#include "guiddef.h"
|
||||
#include "wine/rpcfc.h"
|
||||
@@ -38,7 +38,9 @@
|
||||
@@ -31,7 +38,9 @@
|
||||
typedef GUID UUID;
|
||||
#endif
|
||||
|
||||
|
|
@ -119,11 +315,9 @@ Index: widltypes.h
|
|||
+#endif
|
||||
#define FALSE 0
|
||||
|
||||
typedef struct _attr_t attr_t;
|
||||
Index: write_msft.c
|
||||
===================================================================
|
||||
--- write_msft.c (revision 32187)
|
||||
+++ write_msft.c (working copy)
|
||||
#define RPC_FC_FUNCTION 0xfe
|
||||
--- write_msft.c 2008-09-27 21:56:02.000000000 +0200
|
||||
+++ write_msft.c 2008-09-27 20:49:05.000000000 +0200
|
||||
@@ -40,10 +40,8 @@
|
||||
#define NONAMELESSUNION
|
||||
#define NONAMELESSSTRUCT
|
||||
|
|
|
|||
|
|
@ -43,6 +43,8 @@ typedef GUID UUID;
|
|||
#endif
|
||||
#define FALSE 0
|
||||
|
||||
#define RPC_FC_FUNCTION 0xfe
|
||||
|
||||
typedef struct _attr_t attr_t;
|
||||
typedef struct _expr_t expr_t;
|
||||
typedef struct _type_t type_t;
|
||||
|
|
@ -77,6 +79,7 @@ enum attr_type
|
|||
ATTR_AUTO_HANDLE,
|
||||
ATTR_BINDABLE,
|
||||
ATTR_CALLAS,
|
||||
ATTR_CALLCONV, /* calling convention pseudo-attribute */
|
||||
ATTR_CASE,
|
||||
ATTR_CONTEXTHANDLE,
|
||||
ATTR_CONTROL,
|
||||
|
|
@ -221,7 +224,7 @@ struct _type_t {
|
|||
struct _type_t *ref;
|
||||
const attr_list_t *attrs;
|
||||
func_list_t *funcs; /* interfaces and modules */
|
||||
var_list_t *fields; /* interfaces, structures and enumerations */
|
||||
var_list_t *fields_or_args; /* interfaces, structures, enumerations and functions (for args) */
|
||||
ifref_list_t *ifaces; /* coclasses */
|
||||
unsigned long dim; /* array dimension */
|
||||
expr_t *size_is, *length_is;
|
||||
|
|
@ -242,7 +245,6 @@ struct _type_t {
|
|||
struct _var_t {
|
||||
char *name;
|
||||
type_t *type;
|
||||
var_list_t *args; /* for function pointers */
|
||||
attr_list_t *attrs;
|
||||
expr_t *eval;
|
||||
|
||||
|
|
@ -254,6 +256,12 @@ struct _pident_t {
|
|||
var_t *var;
|
||||
int ptr_level;
|
||||
|
||||
int is_func;
|
||||
/* levels of indirection for function pointers */
|
||||
int func_ptr_level;
|
||||
var_list_t *args;
|
||||
char *callconv;
|
||||
|
||||
/* parser-internal */
|
||||
struct list entry;
|
||||
};
|
||||
|
|
@ -321,7 +329,7 @@ struct _user_type_t {
|
|||
extern unsigned char pointer_default;
|
||||
|
||||
extern user_type_list_t user_type_list;
|
||||
void check_for_user_types_and_context_handles(const var_list_t *list);
|
||||
void check_for_additional_prototype_types(const var_list_t *list);
|
||||
|
||||
void init_types(void);
|
||||
type_t *alloc_type(void);
|
||||
|
|
@ -337,4 +345,9 @@ int cant_be_null(const var_t *v);
|
|||
int is_struct(unsigned char tc);
|
||||
int is_union(unsigned char tc);
|
||||
|
||||
static inline type_t *get_func_return_type(const func_t *func)
|
||||
{
|
||||
return func->def->type->ref;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1419,7 +1419,7 @@ static HRESULT add_func_desc(msft_typeinfo_t* typeinfo, const func_t *func, int
|
|||
|
||||
/* fill out the basic type information */
|
||||
typedata[0] = typedata_size | (index << 16);
|
||||
encode_var(typeinfo->typelib, func->def->type, func->def, &typedata[1], NULL, NULL, &decoded_size);
|
||||
encode_var(typeinfo->typelib, get_func_return_type(func), func->def, &typedata[1], NULL, NULL, &decoded_size);
|
||||
typedata[2] = funcflags;
|
||||
typedata[3] = ((52 /*sizeof(FUNCDESC)*/ + decoded_size) << 16) | typeinfo->typeinfo->cbSizeVft;
|
||||
typedata[4] = (next_idx << 16) | (callconv << 8) | (invokekind << 3) | funckind;
|
||||
|
|
@ -1946,8 +1946,8 @@ static void add_dispinterface_typeinfo(msft_typelib_t *typelib, type_t *dispinte
|
|||
if (dispinterface->funcs)
|
||||
LIST_FOR_EACH_ENTRY( func, dispinterface->funcs, const func_t, entry ) idx++;
|
||||
|
||||
if (dispinterface->fields)
|
||||
LIST_FOR_EACH_ENTRY( var, dispinterface->fields, var_t, entry )
|
||||
if (dispinterface->fields_or_args)
|
||||
LIST_FOR_EACH_ENTRY( var, dispinterface->fields_or_args, var_t, entry )
|
||||
add_var_desc(msft_typeinfo, idx++, var);
|
||||
|
||||
if (dispinterface->funcs)
|
||||
|
|
@ -2030,8 +2030,8 @@ static void add_structure_typeinfo(msft_typelib_t *typelib, type_t *structure)
|
|||
msft_typeinfo = create_msft_typeinfo(typelib, TKIND_RECORD, structure->name, structure->attrs);
|
||||
msft_typeinfo->typeinfo->size = 0;
|
||||
|
||||
if (structure->fields)
|
||||
LIST_FOR_EACH_ENTRY( cur, structure->fields, var_t, entry )
|
||||
if (structure->fields_or_args)
|
||||
LIST_FOR_EACH_ENTRY( cur, structure->fields_or_args, var_t, entry )
|
||||
add_var_desc(msft_typeinfo, idx++, cur);
|
||||
}
|
||||
|
||||
|
|
@ -2045,8 +2045,8 @@ static void add_enum_typeinfo(msft_typelib_t *typelib, type_t *enumeration)
|
|||
msft_typeinfo = create_msft_typeinfo(typelib, TKIND_ENUM, enumeration->name, enumeration->attrs);
|
||||
msft_typeinfo->typeinfo->size = 0;
|
||||
|
||||
if (enumeration->fields)
|
||||
LIST_FOR_EACH_ENTRY( cur, enumeration->fields, var_t, entry )
|
||||
if (enumeration->fields_or_args)
|
||||
LIST_FOR_EACH_ENTRY( cur, enumeration->fields_or_args, var_t, entry )
|
||||
add_var_desc(msft_typeinfo, idx++, cur);
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue