wine-devel July 2019

65 participants
284 discussions

Re: widl: Set name return value (passed by reference) in the alias case alias case in get_user_type.
by Alexandre Julliard 23 Nov '20

23 Nov '20

Gerald Pfeifer <gerald(a)pfeifer.com> writes: > So, I admit I don't really know this code, but looking at it (triggered > by a warning issued by GCC development versions), I noticed that this > variable passed by reference is not initialized here. It's initialized when we return a type, and it doesn't need to be initialized on NULL return. The code is correct, but you could probably set the variable to NULL in the caller to silence the warning. -- Alexandre Julliard julliard(a)winehq.org

2 1

Error handling in RpcBindingVectorFree (dlls/rpcrt4/rpc_binding.c)
by Gerald Pfeifer 22 Nov '20

22 Nov '20

Looking at RPC_STATUS WINAPI RpcBindingVectorFree( RPC_BINDING_VECTOR** BindingVector ) { RPC_STATUS status; ULONG c; TRACE("(%p)\n", BindingVector); for (c=0; c<(*BindingVector)->Count; c++) { status = RpcBindingFree(&(*BindingVector)->BindingH[c]); } HeapFree(GetProcessHeap(), 0, *BindingVector); *BindingVector = NULL; return RPC_S_OK; } we currently always ignore the outcome of RpcBindingFree and return RPC_S_OK. However, there is one case where RpcBindingFree returns something different (which is if *Binding is null when RPC_S_INVALID_BINDING is returned). What is the proper way of handling this? Just keeping the code as is and removing the unused status variable? Breaking the loop once RpcBindingFree returns something different from RPC_S_OK? Continuing and returning the first / the last status different from RPC_S_OK? Gerald

1 1

TestBot and graphics tests
by Francois Gouget 24 Aug '20

24 Aug '20

Here are some things I've learned about PCI-passthrough recently, which would be one way (probably the best) to add "real hardware" to the TestBot. I don't want to give anyone false hopes though: this just went from "this is a mysterious thing I need to learn about" to "I think I know how to do it but have not tried it yet". So graphics card PCI-passthrough is now relatively well documented on the Internet and seems to have seen some use-cases that would indicate it may even be reasonably usable. * There are two machines intended to run real GPU tests for Wine: cw1-hd6800 and cw2-gtx560. For now they are only used to run WineTest daily on Windows 8.1, Windows 10 1507, 1709, 1809 and Linux. That's quite a bunch but it would be much better if they were integrated with the TestBot as that would allow developers to submit their own tests. So I had a look at what it would imply to convert them to VM hosts using QEmu + PCI-passthrough. * First one needs a processor with hardware virtualisation support. For Intel that's VT-d. Both machines have an Intel Core 2600 which supports VT-d. Good. * Second the motherboard too needs to support VT-d. Both machines have an ASRock P67 Extreme4 motherboard. Unfortunately UEFI says "unsupported" next to the "VT-d" setting for the motherboard :-( It looks like there was some confusion as to whether the P67 chipset supported VT-d initially. From what I gathered it's only Q67 that does but this caused some manufacturers, among which ASRock, to initially claim support and later retract it. * Then one needs to add the intel_iommu=on option to the kernel command line (resp. amd_iommu). This is should make all the PCI devices appear in /sys/kernel/iommu_groups. But that folder remains empty which confirms that full VT-d support is missing. * Another important aspect is to have a graphics card which is hot-restartable. In some cases when a VM's graphics card is crashed the only way to reset it is to reboot the host. The TestBot is likely to crash the graphics card, particularly if we do a hard-power off on the VMs like we currently do, and it would relaly be annoying to have to reboot the host everytime the graphics card goes belly up. I don't know if the AMD HD6800 and Nvidia GTX560 are suitable but it's quite possible they are not. All I know for now is that we should avoid AMD's R9 line of graphics cards. I still need to find a couple of suitable reasonably lower power graphics cards: one AMD and one Nvidia. * Then one needs to prevent the host from using the graphics card. Usually that's done by having the host use the processor's IGP and dedicating the discrete GPU to the VMs. Unfortunately the 2600's IGP cannot be active when there's a discrete card so that route is denied to us. Fortunately there's quite a bit of documentation on how to shut down not just X but also the Linux virtual consoles to free the GPU and hand it over to the VMs after boot. Doing so means losing KVM access to the host which is a bit annoying in case something goes wrong. So ideally we'd make sure this does not happen in grub's "safe mode" boot option. * Although I have not done any test yet I'm reasonably certain that PCI-passthrough rules out live snapshots: QEmu would have no way to restore the graphics card's internal state. - For Windows VMs that's not an issue: if we provide a power off snapshot the TestBot already knows how to power on the VM and wait for it to boot (as long as the boot is shorter than the connection timeout but it works out usually). - For Linux VM's that's more of an issue: the TestBot will power on the VM as usual. The problem is when it updates Wine: after recompiling everything it deletes the old snapshot and creates a new one from the current state of the VM, which means a live snapshot. So the TestBot will need to be modified so it knows when and how to power off the VM and take a powered off snapshot. * Since the VM has full control of the graphics card QEmu has no access to the content of the screen. That's not an issue for the normal TestBot operation, just for the initial VM setup. Fortunately the graphics card is connected to a KVM so the screen can be accessed through that means. It does mean assigning the mouse and keyboard to the VM too. Should that prove impractical there are a bunch of other options too: VNC, LookingGlass, Synergy, etc. But the less needs to be installed in the VMs the better. * Also the TestBot uses QEmu to take the screenshots. But QEmu does not have access to the content of the screen. The fix is to use a tool to take the screenshots from within the VM and use TestAgent to retrieve them. On Linux there are standard tools we can use. On Windows there's code floating around we can use. So the next steps would be: * Maybe test on my box using the builtin IGP. But that likely won't be very conclusive beyond confirming the snapshot issues, screen access, etc. * Find a suitable AMD or Nvidia graphics card and test that on my box. That would allow me to fully test integration with the TestBot, check for stability issues, etc. * Then see what can be done with the existing cw1 and cw2 boxes. -- Francois Gouget <fgouget(a)codeweavers.com>

4 10

Call for WineConf 2019 presentations
by Aric Stewart 10 Sep '19

10 Sep '19

Hello, Again this year I am helping coordinate the talks and presentations! I hope that people find it helpful and useful! Last work worked out well enough that I am sticking to the same rough format. I think it worked for most other people as well! If you would like to give a presentation! Please e-mail wineconf(a)winehq.org or me directly! I will keep the Wiki updated with presentations and scheduling as we get it worked out. When you propose your talk if you have a preference toward a time slot and Saturday or Sunday please express that. General Guidelines: * Please provide an estimate of how long your talk will be. We are shooting for approximate 40 minute slots with between 15-20 minutes of talk and with likely an equal amount of question and discussion time afterward. Generally shorter talks are not an issue, however longer talks will need to be discussed and will be considered based on the rest of the schedule. * Topics should obviously be of interest to the other attendees, i.e., the broader Wine community, but note that that doesn't imply the talk has to be about Wine itself * If you have a preferred time and date for your talk please indicate that to me when you submit your talk. We will try to make it work as best we can. Here are the rough proposed slots, They will be changed and modified as required by the addenda as it gets fleshed out. Understand that even with this shift toward a scheduled day we will not disrupt productive conversation to fit to the schedule. The schedule will warp and flow as required to facilitate the talk, not force the talks to conform to it. This does mean if you are planing to try to attend a given talk you will likely want to arrive a bit early and understand if when you arrive the schedule is either behind or ahead of plan. Daily Slots: 09:00 - 09:40 slot 1 09:45 - 10:25 slot 2 10:30 - 11:00 break 11:00 - 11:40 slot 3 12:00 - 13:00 lunch break 13:00 - 13:40 slot 4 13:45 - 14:25 slot 5 14:30 - 15:00 break 15:00 - 15:40 slot 6 15:45 - 16:25 slot 7 16:25 - 17:00 Overflow time / small group discussion / short presentations We will track proposed presentations on the WineConf Wiki: https://wiki.winehq.org/WineConf2019 Likely we will have open time at the conference which we will propose presentations and fill at the time. We have never had a problem finding things we all want to talk about. thanks! -aric

3 4

[PATCH v3 0/6] winex11.drv: Fix several cursor and focus issues
by Rémi Bernon 13 Aug '19

13 Aug '19

This is a resend of several patches with some addtional ones. This should address cursor and focus related issues in winex11.drv. Many games are grabbing and warping the cursor to keep it inside their window. There's apparently no way in Xlib to prevent XWarpPointer to succeed even if some other application have active grab on the pointer, so each application should behave. The first two patches should make Wine be nicer in this regard. The focus issue is covered by the four other patches. As keyboard grab notifications are send as focus events, Wine sometimes loses tracks of the current focus state. Fixing this and using these notifications helps deciding whether it is safe or not to ask for a cursor grab / warp. Rémi Bernon (6): winex11.drv: Do not set clipping_cursor when clip window is mapped winex11.drv: Only call XWarpPointer if we can get exclusive grab winex11.drv: Print the FocusIn/FocusOut mode in trace message winex11.drv: Do not react to keyboard grab focus events winex11.drv: Only grab or warp the cursor when keyboard isn't grabbed winex11.drv: Retry last ClipCursor when grab is released dlls/winex11.drv/event.c | 57 ++++++++++++++++++++++++++++++++++++--- dlls/winex11.drv/mouse.c | 46 +++++++++++++++++++++++++++++++ dlls/winex11.drv/x11drv.h | 2 ++ 3 files changed, 102 insertions(+), 3 deletions(-) -- 2.20.1

2 8

Unhandled Page fault on write access - Wine 4.4 - NetBSD i386
by zerous 12 Aug '19

12 Aug '19

Hi, Wine-4.4 throws Unhandled Page fault on write access errors on NetBSD i386 -current. I did some debugging and found that it was due to _lwp_makecontext(3) segfaulting as it tried to access memory that was out-of-bounds. However, the real reason was pthread_attr_setstack(3) setting up a guard of 65536 bytes which Wine didn't account for. I am aware that the manpage of pthread_attr_setstack(3) is dated and it states that no default guard will be allocated. I will indeed send a patch to amend that. In order to work around the issue, I have tried setting the guard to 0 explicitly using pthread_attr_setguardsize(3). As far as I know this change shouldn't affect any other platforms. Additionally, it also solves the initial problem I had, which was wine giving me black windows instead of the UI; an inadvertent side-effect of the same issue. OK? -- zerous

1 1

[PATCH 01/15] widl: change struct _var_t's type member to a struct _decl_spec_t
by Richard Pospesel 08 Aug '19

08 Aug '19

Signed-off-by: Richard Pospesel <richard(a)torproject.org> --- tools/widl/client.c | 32 ++-- tools/widl/expr.c | 8 +- tools/widl/header.c | 116 +++++++------- tools/widl/parser.y | 113 +++++++------- tools/widl/proxy.c | 58 +++---- tools/widl/server.c | 16 +- tools/widl/typegen.c | 334 ++++++++++++++++++++-------------------- tools/widl/typetree.c | 8 +- tools/widl/typetree.h | 4 +- tools/widl/widltypes.h | 25 ++- tools/widl/write_msft.c | 22 +-- 11 files changed, 372 insertions(+), 364 deletions(-) diff --git a/tools/widl/client.c b/tools/widl/client.c index fe88f5993c..b0a5d0cc8c 100644 --- a/tools/widl/client.c +++ b/tools/widl/client.c @@ -52,9 +52,9 @@ static void print_client( const char *format, ... ) static void write_client_func_decl( const type_t *iface, const var_t *func ) { - const char *callconv = get_attrp(func->type->attrs, ATTR_CALLCONV); - const var_list_t *args = type_get_function_args(func->type); - type_t *rettype = type_function_get_rettype(func->type); + const char *callconv = get_attrp(func->declspec.type->attrs, ATTR_CALLCONV); + const var_list_t *args = type_get_function_args(func->declspec.type); + type_t *rettype = type_function_get_rettype(func->declspec.type); if (!callconv) callconv = "__cdecl"; write_type_decl_left(client, rettype); @@ -74,9 +74,9 @@ static void write_function_stub( const type_t *iface, const var_t *func, { unsigned char explicit_fc, implicit_fc; int has_full_pointer = is_full_pointer_function(func); - var_t *retval = type_function_get_retval(func->type); + var_t *retval = type_function_get_retval(func->declspec.type); const var_t *handle_var = get_func_handle_var( iface, func, &explicit_fc, &implicit_fc ); - int has_ret = !is_void(retval->type); + int has_ret = !is_void(retval->declspec.type); if (is_interpreted_func( iface, func )) { @@ -97,7 +97,7 @@ static void write_function_stub( const type_t *iface, const var_t *func, print_client("RPC_BINDING_HANDLE _Handle;\n"); } - if (has_ret && decl_indirect(retval->type)) + if (has_ret && decl_indirect(retval->declspec.type)) { print_client("void *_p_%s;\n", retval->name); } @@ -136,7 +136,7 @@ static void write_function_stub( const type_t *iface, const var_t *func, if (has_ret) { print_client("%s", ""); - write_type_decl(client, retval->type, retval->name); + write_type_decl(client, retval->declspec.type, retval->name); fprintf(client, ";\n"); } print_client("RPC_MESSAGE _RpcMessage;\n"); @@ -147,7 +147,7 @@ static void write_function_stub( const type_t *iface, const var_t *func, if (explicit_fc == FC_BIND_GENERIC) print_client("__frame->%s = %s;\n", handle_var->name, handle_var->name ); } - if (has_ret && decl_indirect(retval->type)) + if (has_ret && decl_indirect(retval->declspec.type)) { print_client("__frame->_p_%s = &%s;\n", retval->name, retval->name); } @@ -194,7 +194,7 @@ static void write_function_stub( const type_t *iface, const var_t *func, /* 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(handle_var->type, ATTR_CONTEXTHANDLE); + int is_ch_ptr = !is_aliaschain_attr(handle_var->declspec.type, ATTR_CONTEXTHANDLE); print_client("if (%s%s != 0)\n", is_ch_ptr ? "*" : "", handle_var->name); indent++; print_client("__frame->_Handle = NDRCContextBinding(%s%s);\n", @@ -257,9 +257,9 @@ static void write_function_stub( const type_t *iface, const var_t *func, /* unmarshal return value */ if (has_ret) { - if (decl_indirect(retval->type)) + if (decl_indirect(retval->declspec.type)) print_client("MIDL_memset(&%s, 0, sizeof(%s));\n", retval->name, retval->name); - else if (is_ptr(retval->type) || is_array(retval->type)) + else if (is_ptr(retval->declspec.type) || is_array(retval->declspec.type)) print_client("%s = 0;\n", retval->name); write_remoting_arguments(client, indent, func, "", PASS_RETURN, PHASE_UNMARSHAL); } @@ -365,8 +365,8 @@ static void write_function_stubs(type_t *iface, unsigned int *proc_offset) case STMT_DECLARATION: { const var_t *func = stmt->u.var; - if (stmt->u.var->stgclass != STG_NONE - || type_get_type_detect_alias(stmt->u.var->type) != TYPE_FUNCTION) + if (stmt->u.var->declspec.stgclass != STG_NONE + || type_get_type_detect_alias(stmt->u.var->declspec.type) != TYPE_FUNCTION) continue; write_function_stub( iface, func, method_count++, *proc_offset ); *proc_offset += get_size_procformatstring_func( iface, func ); @@ -488,7 +488,7 @@ static void write_implicithandledecl(type_t *iface) if (implicit_handle) { - write_type_decl( client, implicit_handle->type, implicit_handle->name ); + write_type_decl( client, implicit_handle->declspec.type, implicit_handle->name ); fprintf(client, ";\n\n"); } } @@ -532,8 +532,8 @@ static void write_client_ifaces(const statement_list_t *stmts, int expr_eval_rou LIST_FOR_EACH_ENTRY(stmt2, type_iface_get_stmts(iface), const statement_t, entry) { - if (stmt2->type == STMT_DECLARATION && stmt2->u.var->stgclass == STG_NONE && - type_get_type_detect_alias(stmt2->u.var->type) == TYPE_FUNCTION) + if (stmt2->type == STMT_DECLARATION && stmt2->u.var->declspec.stgclass == STG_NONE && + type_get_type_detect_alias(stmt2->u.var->declspec.type) == TYPE_FUNCTION) { needs_stub = 1; break; diff --git a/tools/widl/expr.c b/tools/widl/expr.c index 2ed4aff6ad..7ec42db79f 100644 --- a/tools/widl/expr.c +++ b/tools/widl/expr.c @@ -194,10 +194,10 @@ expr_t *make_exprt(enum expr_type type, var_t *var, expr_t *expr) expr_t *e; type_t *tref; - if (var->stgclass != STG_NONE && var->stgclass != STG_REGISTER) + if (var->declspec.stgclass != STG_NONE && var->declspec.stgclass != STG_REGISTER) error_loc("invalid storage class for type expression\n"); - tref = var->type; + tref = var->declspec.type; e = xmalloc(sizeof(expr_t)); e->type = type; @@ -474,7 +474,7 @@ static type_t *find_identifier(const char *identifier, const type_t *cont_type, if (fields) LIST_FOR_EACH_ENTRY( field, fields, const var_t, entry ) if (field->name && !strcmp(identifier, field->name)) { - type = field->type; + type = field->declspec.type; *found_in_cont_type = 1; break; } @@ -482,7 +482,7 @@ static type_t *find_identifier(const char *identifier, const type_t *cont_type, if (!type) { var_t *const_var = find_const(identifier, 0); - if (const_var) type = const_var->type; + if (const_var) type = const_var->declspec.type; } return type; diff --git a/tools/widl/header.c b/tools/widl/header.c index f618e02f3d..3e8cbfae5e 100644 --- a/tools/widl/header.c +++ b/tools/widl/header.c @@ -69,7 +69,7 @@ int is_ptrchain_attr(const var_t *var, enum attr_type t) return 1; else { - type_t *type = var->type; + type_t *type = var->declspec.type; for (;;) { if (is_attr(type->attrs, t)) @@ -204,9 +204,9 @@ static void write_fields(FILE *h, var_list_t *fields) if (!fields) return; LIST_FOR_EACH_ENTRY( v, fields, var_t, entry ) { - if (!v || !v->type) continue; + if (!v || !v->declspec.type) continue; - switch(type_get_type_detect_alias(v->type)) { + switch(type_get_type_detect_alias(v->declspec.type)) { case TYPE_STRUCT: case TYPE_ENCAPSULATED_UNION: nameless_struct_cnt++; @@ -220,12 +220,12 @@ static void write_fields(FILE *h, var_list_t *fields) } LIST_FOR_EACH_ENTRY( v, fields, var_t, entry ) { - if (!v || !v->type) continue; + if (!v || !v->declspec.type) continue; indent(h, 0); name = v->name; - switch(type_get_type_detect_alias(v->type)) { + switch(type_get_type_detect_alias(v->declspec.type)) { case TYPE_STRUCT: case TYPE_ENCAPSULATED_UNION: if(!v->name) { @@ -252,7 +252,7 @@ static void write_fields(FILE *h, var_list_t *fields) default: ; } - write_type_def_or_decl(h, v->type, TRUE, name); + write_type_def_or_decl(h, v->declspec.type, TRUE, name); fprintf(h, ";\n"); } } @@ -697,7 +697,7 @@ void check_for_additional_prototype_types(type_t *type) break; } if (vars) LIST_FOR_EACH_ENTRY( v, vars, const var_t, entry ) - check_for_additional_prototype_types(v->type); + check_for_additional_prototype_types(v->declspec.type); } if (type_is_alias(type)) @@ -800,7 +800,7 @@ int is_const_decl(const var_t *var) * declaration to mean that data isn't being instantiated. this appears * to be a bug, but there is no benefit to being incompatible with MIDL, * so we'll do the same thing */ - for (t = var->type; ; ) + for (t = var->declspec.type; ; ) { if (is_attr(t->attrs, ATTR_CONST)) return TRUE; @@ -821,7 +821,7 @@ static void write_declaration(FILE *header, const var_t *v) } else { - switch (v->stgclass) + switch (v->declspec.stgclass) { case STG_NONE: case STG_REGISTER: /* ignored */ @@ -833,7 +833,7 @@ static void write_declaration(FILE *header, const var_t *v) fprintf(header, "extern "); break; } - write_type_def_or_decl(header, v->type, FALSE, v->name); + write_type_def_or_decl(header, v->declspec.type, FALSE, v->name); fprintf(header, ";\n\n"); } } @@ -850,7 +850,7 @@ static void write_library(FILE *header, const typelib_t *typelib) const type_t* get_explicit_generic_handle_type(const var_t* var) { const type_t *t; - for (t = var->type; + for (t = var->declspec.type; is_ptr(t) || type_is_alias(t); t = type_is_alias(t) ? type_alias_get_aliasee(t) : type_pointer_get_ref(t)) if ((type_get_type_detect_alias(t) != TYPE_BASIC || type_basic_get_type(t) != TYPE_BASIC_HANDLE) && @@ -863,13 +863,13 @@ const var_t *get_func_handle_var( const type_t *iface, const var_t *func, unsigned char *explicit_fc, unsigned char *implicit_fc ) { const var_t *var; - const var_list_t *args = type_get_function_args( func->type ); + const var_list_t *args = type_get_function_args( func->declspec.type ); *explicit_fc = *implicit_fc = 0; if (args) LIST_FOR_EACH_ENTRY( var, args, const var_t, entry ) { if (!is_attr( var->attrs, ATTR_IN ) && is_attr( var->attrs, ATTR_OUT )) continue; - if (type_get_type( var->type ) == TYPE_BASIC && type_basic_get_type( var->type ) == TYPE_BASIC_HANDLE) + if (type_get_type( var->declspec.type ) == TYPE_BASIC && type_basic_get_type( var->declspec.type ) == TYPE_BASIC_HANDLE) { *explicit_fc = FC_BIND_PRIMITIVE; return var; @@ -879,7 +879,7 @@ const var_t *get_func_handle_var( const type_t *iface, const var_t *func, *explicit_fc = FC_BIND_GENERIC; return var; } - if (is_context_handle( var->type )) + if (is_context_handle( var->declspec.type )) { *explicit_fc = FC_BIND_CONTEXT; return var; @@ -888,8 +888,8 @@ const var_t *get_func_handle_var( const type_t *iface, const var_t *func, if ((var = get_attrp( iface->attrs, ATTR_IMPLICIT_HANDLE ))) { - if (type_get_type( var->type ) == TYPE_BASIC && - type_basic_get_type( var->type ) == TYPE_BASIC_HANDLE) + if (type_get_type( var->declspec.type ) == TYPE_BASIC && + type_basic_get_type( var->declspec.type ) == TYPE_BASIC_HANDLE) *implicit_fc = FC_BIND_PRIMITIVE; else *implicit_fc = FC_BIND_GENERIC; @@ -904,13 +904,13 @@ int has_out_arg_or_return(const var_t *func) { const var_t *var; - if (!is_void(type_function_get_rettype(func->type))) + if (!is_void(type_function_get_rettype(func->declspec.type))) return 1; - if (!type_get_function_args(func->type)) + if (!type_get_function_args(func->declspec.type)) return 0; - LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry ) + LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->declspec.type), const var_t, entry ) if (is_attr(var->attrs, ATTR_OUT)) return 1; @@ -990,7 +990,7 @@ static int is_override_method(const type_t *iface, const type_t *child, const va static int is_aggregate_return(const var_t *func) { - enum type_type type = type_get_type(type_function_get_rettype(func->type)); + enum type_type type = type_get_type(type_function_get_rettype(func->declspec.type)); return type == TYPE_STRUCT || type == TYPE_UNION || type == TYPE_COCLASS || type == TYPE_INTERFACE; } @@ -1030,8 +1030,8 @@ static void write_method_macro(FILE *header, const type_t *iface, const type_t * const var_t *arg; fprintf(header, "#define %s_%s(This", name, get_name(func)); - if (type_get_function_args(func->type)) - LIST_FOR_EACH_ENTRY( arg, type_get_function_args(func->type), const var_t, entry ) + if (type_get_function_args(func->declspec.type)) + LIST_FOR_EACH_ENTRY( arg, type_get_function_args(func->declspec.type), const var_t, entry ) fprintf(header, ",%s", arg->name); fprintf(header, ") "); @@ -1042,8 +1042,8 @@ static void write_method_macro(FILE *header, const type_t *iface, const type_t * } fprintf(header, "(This)->lpVtbl->%s(This", get_vtbl_entry_name(iface, func)); - if (type_get_function_args(func->type)) - LIST_FOR_EACH_ENTRY( arg, type_get_function_args(func->type), const var_t, entry ) + if (type_get_function_args(func->declspec.type)) + LIST_FOR_EACH_ENTRY( arg, type_get_function_args(func->declspec.type), const var_t, entry ) fprintf(header, ",%s", arg->name); fprintf(header, ")\n"); } @@ -1073,7 +1073,7 @@ void write_args(FILE *h, const var_list_t *args, const char *name, int method, i } else fprintf(h, ","); } - write_type_decl(h, arg->type, arg->name); + write_type_decl(h, arg->declspec.type, arg->name); if (method == 2) { const expr_t *expr = get_attrp(arg->attrs, ATTR_DEFAULTVALUE); if (expr) { @@ -1085,7 +1085,7 @@ void write_args(FILE *h, const var_list_t *args, const char *name, int method, i expr_t bstr; /* Fixup the expression type for a BSTR like midl does. */ - if (get_type_vt(arg->type) == VT_BSTR && expr->type == EXPR_STRLIT) + if (get_type_vt(arg->declspec.type) == VT_BSTR && expr->type == EXPR_STRLIT) { bstr = *expr; bstr.type = EXPR_WSTRLIT; @@ -1114,8 +1114,8 @@ static void write_cpp_method_def(FILE *header, const type_t *iface) { const var_t *func = stmt->u.var; if (!is_callas(func->attrs)) { - const char *callconv = get_attrp(func->type->attrs, ATTR_CALLCONV); - const var_list_t *args = type_get_function_args(func->type); + const char *callconv = get_attrp(func->declspec.type->attrs, ATTR_CALLCONV); + const var_list_t *args = type_get_function_args(func->declspec.type); const var_t *arg; if (!callconv) callconv = "STDMETHODCALLTYPE"; @@ -1125,11 +1125,11 @@ static void write_cpp_method_def(FILE *header, const type_t *iface) indent(header, 0); fprintf(header, "virtual "); - write_type_decl_left(header, type_function_get_rettype(func->type)); + write_type_decl_left(header, type_function_get_rettype(func->declspec.type)); fprintf(header, "* %s %s(\n", callconv, get_name(func)); ++indentation; indent(header, 0); - write_type_decl_left(header, type_function_get_rettype(func->type)); + write_type_decl_left(header, type_function_get_rettype(func->declspec.type)); fprintf(header, " *__ret"); --indentation; if (args) { @@ -1139,7 +1139,7 @@ static void write_cpp_method_def(FILE *header, const type_t *iface) fprintf(header, ") = 0;\n"); indent(header, 0); - write_type_decl_left(header, type_function_get_rettype(func->type)); + write_type_decl_left(header, type_function_get_rettype(func->declspec.type)); fprintf(header, " %s %s(\n", callconv, get_name(func)); write_args(header, args, iface->name, 2, TRUE); fprintf(header, ")\n"); @@ -1147,7 +1147,7 @@ static void write_cpp_method_def(FILE *header, const type_t *iface) fprintf(header, "{\n"); ++indentation; indent(header, 0); - write_type_decl_left(header, type_function_get_rettype(func->type)); + write_type_decl_left(header, type_function_get_rettype(func->declspec.type)); fprintf(header, " __ret;\n"); indent(header, 0); fprintf(header, "return *%s(&__ret", get_name(func)); @@ -1164,7 +1164,7 @@ static void write_cpp_method_def(FILE *header, const type_t *iface) indent(header, 0); fprintf(header, "virtual "); - write_type_decl_left(header, type_function_get_rettype(func->type)); + write_type_decl_left(header, type_function_get_rettype(func->declspec.type)); fprintf(header, " %s %s(\n", callconv, get_name(func)); write_args(header, args, iface->name, 2, TRUE); fprintf(header, ") = 0;\n"); @@ -1201,25 +1201,25 @@ static void write_inline_wrappers(FILE *header, const type_t *iface, const type_ const var_t *arg; fprintf(header, "static FORCEINLINE "); - write_type_decl_left(header, type_function_get_rettype(func->type)); + write_type_decl_left(header, type_function_get_rettype(func->declspec.type)); fprintf(header, " %s_%s(", name, get_name(func)); - write_args(header, type_get_function_args(func->type), name, 1, FALSE); + write_args(header, type_get_function_args(func->declspec.type), name, 1, FALSE); fprintf(header, ") {\n"); ++indentation; if (!is_aggregate_return(func)) { indent(header, 0); fprintf(header, "%sThis->lpVtbl->%s(This", - is_void(type_function_get_rettype(func->type)) ? "" : "return ", + is_void(type_function_get_rettype(func->declspec.type)) ? "" : "return ", get_vtbl_entry_name(iface, func)); } else { indent(header, 0); - write_type_decl_left(header, type_function_get_rettype(func->type)); + write_type_decl_left(header, type_function_get_rettype(func->declspec.type)); fprintf(header, " __ret;\n"); indent(header, 0); fprintf(header, "return *This->lpVtbl->%s(This,&__ret", get_vtbl_entry_name(iface, func)); } - if (type_get_function_args(func->type)) - LIST_FOR_EACH_ENTRY( arg, type_get_function_args(func->type), const var_t, entry ) + if (type_get_function_args(func->declspec.type)) + LIST_FOR_EACH_ENTRY( arg, type_get_function_args(func->declspec.type), const var_t, entry ) fprintf(header, ",%s", arg->name); fprintf(header, ");\n"); --indentation; @@ -1245,10 +1245,10 @@ static void do_write_c_method_def(FILE *header, const type_t *iface, const char first_iface = 0; } if (!is_callas(func->attrs)) { - const char *callconv = get_attrp(func->type->attrs, ATTR_CALLCONV); + const char *callconv = get_attrp(func->declspec.type->attrs, ATTR_CALLCONV); if (!callconv) callconv = "STDMETHODCALLTYPE"; indent(header, 0); - write_type_decl_left(header, type_function_get_rettype(func->type)); + write_type_decl_left(header, type_function_get_rettype(func->declspec.type)); if (is_aggregate_return(func)) fprintf(header, " *"); if (is_inherited_method(iface, func)) @@ -1261,13 +1261,13 @@ static void do_write_c_method_def(FILE *header, const type_t *iface, const char if (is_aggregate_return(func)) { fprintf(header, ",\n"); indent(header, 0); - write_type_decl_left(header, type_function_get_rettype(func->type)); + write_type_decl_left(header, type_function_get_rettype(func->declspec.type)); fprintf(header, " *__ret"); } --indentation; - if (type_get_function_args(func->type)) { + if (type_get_function_args(func->declspec.type)) { fprintf(header, ",\n"); - write_args(header, type_get_function_args(func->type), name, 0, TRUE); + write_args(header, type_get_function_args(func->declspec.type), name, 0, TRUE); } fprintf(header, ");\n"); fprintf(header, "\n"); @@ -1294,12 +1294,12 @@ static void write_method_proto(FILE *header, const type_t *iface) const var_t *func = stmt->u.var; if (is_callas(func->attrs)) { - const char *callconv = get_attrp(func->type->attrs, ATTR_CALLCONV); + const char *callconv = get_attrp(func->declspec.type->attrs, ATTR_CALLCONV); if (!callconv) callconv = "STDMETHODCALLTYPE"; /* proxy prototype */ - write_type_decl_left(header, type_function_get_rettype(func->type)); + write_type_decl_left(header, type_function_get_rettype(func->declspec.type)); fprintf(header, " %s %s_%s_Proxy(\n", callconv, iface->name, get_name(func)); - write_args(header, type_get_function_args(func->type), iface->name, 1, TRUE); + write_args(header, type_get_function_args(func->declspec.type), iface->name, 1, TRUE); fprintf(header, ");\n"); /* stub prototype */ fprintf(header, "void __RPC_STUB %s_%s_Stub(\n", iface->name, get_name(func)); @@ -1332,12 +1332,12 @@ static void write_locals(FILE *fp, const type_t *iface, int body) if (&stmt2->entry != type_iface_get_stmts(iface)) { const var_t *m = stmt2->u.var; /* proxy prototype - use local prototype */ - write_type_decl_left(fp, type_function_get_rettype(m->type)); + write_type_decl_left(fp, type_function_get_rettype(m->declspec.type)); fprintf(fp, " CALLBACK %s_%s_Proxy(\n", iface->name, get_name(m)); - write_args(fp, type_get_function_args(m->type), iface->name, 1, TRUE); + write_args(fp, type_get_function_args(m->declspec.type), iface->name, 1, TRUE); fprintf(fp, ")"); if (body) { - type_t *rt = type_function_get_rettype(m->type); + type_t *rt = type_function_get_rettype(m->declspec.type); fprintf(fp, "\n{\n"); fprintf(fp, " %s\n", comment); if (rt->name && strcmp(rt->name, "HRESULT") == 0) @@ -1354,9 +1354,9 @@ static 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, type_function_get_rettype(func->type)); + write_type_decl_left(fp, type_function_get_rettype(func->declspec.type)); fprintf(fp, " __RPC_STUB %s_%s_Stub(\n", iface->name, get_name(m)); - write_args(fp, type_get_function_args(func->type), iface->name, 1, TRUE); + write_args(fp, type_get_function_args(func->declspec.type), iface->name, 1, TRUE); fprintf(fp, ")"); if (body) /* Remotable methods must all return HRESULTs. */ @@ -1402,15 +1402,15 @@ void write_local_stubs(const statement_list_t *stmts) static void write_function_proto(FILE *header, const type_t *iface, const var_t *fun, const char *prefix) { - const char *callconv = get_attrp(fun->type->attrs, ATTR_CALLCONV); + const char *callconv = get_attrp(fun->declspec.type->attrs, ATTR_CALLCONV); if (!callconv) callconv = "__cdecl"; /* FIXME: do we need to handle call_as? */ - write_type_decl_left(header, type_function_get_rettype(fun->type)); + write_type_decl_left(header, type_function_get_rettype(fun->declspec.type)); fprintf(header, " %s ", callconv); fprintf(header, "%s%s(\n", prefix, get_name(fun)); - if (type_get_function_args(fun->type)) - write_args(header, type_get_function_args(fun->type), iface->name, 0, TRUE); + if (type_get_function_args(fun->declspec.type)) + write_args(header, type_get_function_args(fun->declspec.type), iface->name, 0, TRUE); else fprintf(header, " void"); fprintf(header, ");\n\n"); @@ -1536,7 +1536,7 @@ static void write_rpc_interface_start(FILE *header, const type_t *iface) if (var) { fprintf(header, "extern "); - write_type_decl( header, var->type, var->name ); + write_type_decl( header, var->declspec.type, var->name ); fprintf(header, ";\n"); } if (old_names) @@ -1745,7 +1745,7 @@ static void write_header_stmts(FILE *header, const statement_list_t *stmts, cons fprintf(header, "%s\n", stmt->u.str); break; case STMT_DECLARATION: - if (iface && type_get_type(stmt->u.var->type) == TYPE_FUNCTION) + if (iface && type_get_type(stmt->u.var->declspec.type) == TYPE_FUNCTION) { if (!ignore_funcs) { diff --git a/tools/widl/parser.y b/tools/widl/parser.y index 1e5c8e181d..50e42291bd 100644 --- a/tools/widl/parser.y +++ b/tools/widl/parser.y @@ -52,13 +52,6 @@ struct _import_t int import_performed; }; -typedef struct _decl_spec_t -{ - type_t *type; - attr_list_t *attrs; - enum storage_class stgclass; -} decl_spec_t; - typelist_t incomplete_types = LIST_INIT(incomplete_types); static void fix_incomplete(void); @@ -651,10 +644,10 @@ enum_list: enum { if (!$1->eval) enum: ident '=' expr_int_const { $$ = reg_const($1); $$->eval = $3; - $$->type = type_new_int(TYPE_BASIC_INT, 0); + $$->declspec.type = type_new_int(TYPE_BASIC_INT, 0); } | ident { $$ = reg_const($1); - $$->type = type_new_int(TYPE_BASIC_INT, 0); + $$->declspec.type = type_new_int(TYPE_BASIC_INT, 0); } ; @@ -740,7 +733,7 @@ field: m_attributes decl_spec struct_declarator_list ';' $$ = set_var_types($1, $2, $3); } | m_attributes uniondef ';' { var_t *v = make_var(NULL); - v->type = $2; v->attrs = $1; + v->declspec.type = $2; v->attrs = $1; $$ = append_var(NULL, v); } ; @@ -764,13 +757,13 @@ s_field: m_attributes decl_spec declarator { $$ = declare_var(check_field_attrs free($3); } | m_attributes structdef { var_t *v = make_var(NULL); - v->type = $2; v->attrs = $1; + v->declspec.type = $2; v->attrs = $1; $$ = v; } ; funcdef: declaration { $$ = $1; - if (type_get_type($$->type) != TYPE_FUNCTION) + if (type_get_type($$->declspec.type) != TYPE_FUNCTION) error_loc("only methods may be declared inside the methods section of a dispinterface\n"); check_function_attrs($$->name, $$->attrs); } @@ -1540,19 +1533,19 @@ static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const decl } /* add type onto the end of the pointers in pident->type */ - v->type = append_chain_type(decl ? decl->type : NULL, type); - v->stgclass = decl_spec->stgclass; + v->declspec.type = append_chain_type(decl ? decl->type : NULL, type); + v->declspec.stgclass = decl_spec->stgclass; v->attrs = attrs; /* check for pointer attribute being applied to non-pointer, non-array * type */ - if (!is_array(v->type)) + if (!is_array(v->declspec.type)) { int ptr_attr = get_attrv(v->attrs, ATTR_POINTERTYPE); const type_t *ptr = NULL; /* pointer attributes on the left side of the type belong to the function * pointer, if one is being declared */ - type_t **pt = func_type ? &func_type : &v->type; + type_t **pt = func_type ? &func_type : &v->declspec.type; for (ptr = *pt; ptr && !ptr_attr; ) { ptr_attr = get_attrv(ptr->attrs, ATTR_POINTERTYPE); @@ -1585,7 +1578,7 @@ static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const decl { type_t *t = type; - if (!is_ptr(v->type) && !is_array(v->type)) + if (!is_ptr(v->declspec.type) && !is_array(v->declspec.type)) error_loc("'%s': [string] attribute applied to non-pointer, non-array type\n", v->name); @@ -1611,15 +1604,15 @@ static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const decl if (is_attr(v->attrs, ATTR_V1ENUM)) { - if (type_get_type_detect_alias(v->type) != TYPE_ENUM) + if (type_get_type_detect_alias(v->declspec.type) != TYPE_ENUM) error_loc("'%s': [v1_enum] attribute applied to non-enum type\n", v->name); } - if (is_attr(v->attrs, ATTR_RANGE) && !is_allowed_range_type(v->type)) + if (is_attr(v->attrs, ATTR_RANGE) && !is_allowed_range_type(v->declspec.type)) error_loc("'%s': [range] attribute applied to non-integer type\n", v->name); - ptype = &v->type; + ptype = &v->declspec.type; if (sizes) LIST_FOR_EACH_ENTRY(dim, sizes, expr_t, entry) { if (dim->type != EXPR_VOID) @@ -1649,7 +1642,7 @@ static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const decl error_loc("%s: too many expressions in size_is attribute\n", v->name); } - ptype = &v->type; + ptype = &v->declspec.type; if (lengs) LIST_FOR_EACH_ENTRY(dim, lengs, expr_t, entry) { if (dim->type != EXPR_VOID) @@ -1681,28 +1674,28 @@ static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const decl if (func_type) { type_t *ft, *t; - type_t *return_type = v->type; - v->type = func_type; - for (ft = v->type; is_ptr(ft); ft = type_pointer_get_ref(ft)) + type_t *return_type = v->declspec.type; + v->declspec.type = func_type; + for (ft = v->declspec.type; is_ptr(ft); ft = type_pointer_get_ref(ft)) ; assert(type_get_type_detect_alias(ft) == TYPE_FUNCTION); ft->details.function->retval = make_var(xstrdup("_RetVal")); - ft->details.function->retval->type = return_type; + ft->details.function->retval->declspec.type = return_type; /* move calling convention attribute, if present, from pointer nodes to * function node */ - for (t = v->type; is_ptr(t); t = type_pointer_get_ref(t)) + for (t = v->declspec.type; is_ptr(t); t = type_pointer_get_ref(t)) ft->attrs = move_attr(ft->attrs, t->attrs, ATTR_CALLCONV); } else { type_t *t; - for (t = v->type; is_ptr(t); t = type_pointer_get_ref(t)) + for (t = v->declspec.type; is_ptr(t); t = type_pointer_get_ref(t)) if (is_attr(t->attrs, ATTR_CALLCONV)) error_loc("calling convention applied to non-function-pointer type\n"); } if (decl->bits) - v->type = type_new_bitfield(v->type, decl->bits); + v->declspec.type = type_new_bitfield(v->declspec.type, decl->bits); return v; } @@ -1770,10 +1763,9 @@ var_t *make_var(char *name) { var_t *v = xmalloc(sizeof(var_t)); v->name = name; - v->type = NULL; + init_declspec(&v->declspec, NULL); v->attrs = NULL; v->eval = NULL; - v->stgclass = STG_NONE; init_loc_info(&v->loc_info); return v; } @@ -1782,10 +1774,9 @@ static var_t *copy_var(var_t *src, char *name, map_attrs_filter_t attr_filter) { var_t *v = xmalloc(sizeof(var_t)); v->name = name; - v->type = src->type; + v->declspec = src->declspec; v->attrs = map_attrs(src->attrs, attr_filter); v->eval = src->eval; - v->stgclass = src->stgclass; v->loc_info = src->loc_info; return v; } @@ -2010,7 +2001,7 @@ static type_t *reg_typedefs(decl_spec_t *decl_spec, declarator_list_t *decls, at cur->loc_info.line_number); name = declare_var(attrs, decl_spec, decl, 0); - cur = type_new_alias(name->type, name->name); + cur = type_new_alias(name->declspec.type, name->name); cur->attrs = attrs; if (is_incomplete(cur)) @@ -2285,10 +2276,10 @@ static attr_list_t *check_iface_attrs(const char *name, attr_list_t *attrs) if (attr->type == ATTR_IMPLICIT_HANDLE) { const var_t *var = attr->u.pval; - if (type_get_type( var->type) == TYPE_BASIC && - type_basic_get_type( var->type ) == TYPE_BASIC_HANDLE) + if (type_get_type( var->declspec.type) == TYPE_BASIC && + type_basic_get_type( var->declspec.type ) == TYPE_BASIC_HANDLE) continue; - if (is_aliaschain_attr( var->type, ATTR_HANDLE )) + if (is_aliaschain_attr( var->declspec.type, ATTR_HANDLE )) continue; error_loc("attribute %s requires a handle type in interface %s\n", allowed_attr[attr->type].display_name, name); @@ -2520,7 +2511,7 @@ static void check_remoting_fields(const var_t *var, type_t *type); static void check_field_common(const type_t *container_type, const char *container_name, const var_t *arg) { - type_t *type = arg->type; + type_t *type = arg->declspec.type; int more_to_do; const char *container_type_name; const char *var_type; @@ -2550,7 +2541,7 @@ static void check_field_common(const type_t *container_type, } if (is_attr(arg->attrs, ATTR_LENGTHIS) && - (is_attr(arg->attrs, ATTR_STRING) || is_aliaschain_attr(arg->type, ATTR_STRING))) + (is_attr(arg->attrs, ATTR_STRING) || is_aliaschain_attr(arg->declspec.type, ATTR_STRING))) error_loc_info(&arg->loc_info, "string and length_is specified for argument %s are mutually exclusive attributes\n", arg->name); @@ -2694,7 +2685,7 @@ static void check_remoting_fields(const var_t *var, type_t *type) fields = type_union_get_cases(type); if (fields) LIST_FOR_EACH_ENTRY( field, fields, const var_t, entry ) - if (field->type) check_field_common(type, type->name, field); + if (field->declspec.type) check_field_common(type, type->name, field); } /* checks that arguments for a function make sense for marshalling and unmarshalling */ @@ -2703,9 +2694,9 @@ static void check_remoting_args(const var_t *func) const char *funcname = func->name; const var_t *arg; - if (func->type->details.function->args) LIST_FOR_EACH_ENTRY( arg, func->type->details.function->args, const var_t, entry ) + if (func->declspec.type->details.function->args) LIST_FOR_EACH_ENTRY( arg, func->declspec.type->details.function->args, const var_t, entry ) { - const type_t *type = arg->type; + const type_t *type = arg->declspec.type; /* check that [out] parameters have enough pointer levels */ if (is_attr(arg->attrs, ATTR_OUT)) @@ -2745,16 +2736,16 @@ static void check_remoting_args(const var_t *func) } } - check_field_common(func->type, funcname, arg); + check_field_common(func->declspec.type, funcname, arg); } - if (type_get_type(type_function_get_rettype(func->type)) != TYPE_VOID) + if (type_get_type(type_function_get_rettype(func->declspec.type)) != TYPE_VOID) { var_t var; var = *func; - var.type = type_function_get_rettype(func->type); + var.declspec.type = type_function_get_rettype(func->declspec.type); var.name = xstrdup("return value"); - check_field_common(func->type, funcname, &var); + check_field_common(func->declspec.type, funcname, &var); free(var.name); } } @@ -2771,8 +2762,8 @@ static void add_explicit_handle_if_necessary(const type_t *iface, var_t *func) * function */ var_t *idl_handle = make_var(xstrdup("IDL_handle")); idl_handle->attrs = append_attr(NULL, make_attr(ATTR_IN)); - idl_handle->type = find_type_or_error("handle_t", 0); - type_function_add_head_arg(func->type, idl_handle); + idl_handle->declspec.type = find_type_or_error("handle_t", 0); + type_function_add_head_arg(func->declspec.type, idl_handle); } } @@ -2853,7 +2844,7 @@ static void check_async_uuid(type_t *iface) var_t *begin_func, *finish_func, *func = stmt->u.var, *arg; var_list_t *begin_args = NULL, *finish_args = NULL, *args; - args = func->type->details.function->args; + args = func->declspec.type->details.function->args; if (args) LIST_FOR_EACH_ENTRY(arg, args, var_t, entry) { if (is_attr(arg->attrs, ATTR_IN) || !is_attr(arg->attrs, ATTR_OUT)) @@ -2863,15 +2854,15 @@ static void check_async_uuid(type_t *iface) } begin_func = copy_var(func, concat_str("Begin_", func->name), NULL); - begin_func->type = type_new_function(begin_args); - begin_func->type->attrs = func->attrs; - begin_func->type->details.function->retval = func->type->details.function->retval; + begin_func->declspec.type = type_new_function(begin_args); + begin_func->declspec.type->attrs = func->attrs; + begin_func->declspec.type->details.function->retval = func->declspec.type->details.function->retval; stmts = append_statement(stmts, make_statement_declaration(begin_func)); finish_func = copy_var(func, concat_str("Finish_", func->name), NULL); - finish_func->type = type_new_function(finish_args); - finish_func->type->attrs = func->attrs; - finish_func->type->details.function->retval = func->type->details.function->retval; + finish_func->declspec.type = type_new_function(finish_args); + finish_func->declspec.type->attrs = func->attrs; + finish_func->declspec.type->details.function->retval = func->declspec.type->details.function->retval; stmts = append_statement(stmts, make_statement_declaration(finish_func)); } @@ -2923,10 +2914,10 @@ static void check_all_user_types(const statement_list_t *stmts) const statement_t *stmt_func; STATEMENTS_FOR_EACH_FUNC(stmt_func, type_iface_get_stmts(stmt->u.type)) { const var_t *func = stmt_func->u.var; - if (func->type->details.function->args) - LIST_FOR_EACH_ENTRY( v, func->type->details.function->args, const var_t, entry ) - check_for_additional_prototype_types(v->type); - check_for_additional_prototype_types(type_function_get_rettype(func->type)); + if (func->declspec.type->details.function->args) + LIST_FOR_EACH_ENTRY( v, func->declspec.type->details.function->args, const var_t, entry ) + check_for_additional_prototype_types(v->declspec.type); + check_for_additional_prototype_types(type_function_get_rettype(func->declspec.type)); } } } @@ -2974,16 +2965,16 @@ static statement_t *make_statement_declaration(var_t *var) { statement_t *stmt = make_statement(STMT_DECLARATION); stmt->u.var = var; - if (var->stgclass == STG_EXTERN && var->eval) + if (var->declspec.stgclass == STG_EXTERN && var->eval) warning("'%s' initialised and declared extern\n", var->name); if (is_const_decl(var)) { if (var->eval) reg_const(var); } - else if (type_get_type(var->type) == TYPE_FUNCTION) + else if (type_get_type(var->declspec.type) == TYPE_FUNCTION) check_function_attrs(var->name, var->attrs); - else if (var->stgclass == STG_NONE || var->stgclass == STG_REGISTER) + else if (var->declspec.stgclass == STG_NONE || var->declspec.stgclass == STG_REGISTER) error_loc("instantiation of data is illegal\n"); return stmt; } diff --git a/tools/widl/proxy.c b/tools/widl/proxy.c index ef52e35a4c..0b37cc9758 100644 --- a/tools/widl/proxy.c +++ b/tools/widl/proxy.c @@ -105,15 +105,15 @@ static void clear_output_vars( const var_list_t *args ) { if (is_attr(arg->attrs, ATTR_IN)) continue; if (!is_attr(arg->attrs, ATTR_OUT)) continue; - if (is_ptr(arg->type)) + if (is_ptr(arg->declspec.type)) { - if (type_get_type(type_pointer_get_ref(arg->type)) == TYPE_BASIC) continue; - if (type_get_type(type_pointer_get_ref(arg->type)) == TYPE_ENUM) continue; + if (type_get_type(type_pointer_get_ref(arg->declspec.type)) == TYPE_BASIC) continue; + if (type_get_type(type_pointer_get_ref(arg->declspec.type)) == TYPE_ENUM) continue; } print_proxy( "if (%s) MIDL_memset( %s, 0, ", arg->name, arg->name ); - if (is_array(arg->type) && type_array_has_conformance(arg->type)) + if (is_array(arg->declspec.type) && type_array_has_conformance(arg->declspec.type)) { - write_expr( proxy, type_array_get_conformance(arg->type), 1, 1, NULL, NULL, "" ); + write_expr( proxy, type_array_get_conformance(arg->declspec.type), 1, 1, NULL, NULL, "" ); fprintf( proxy, " * " ); } fprintf( proxy, "sizeof( *%s ));\n", arg->name ); @@ -147,7 +147,7 @@ static int need_delegation_indirect(const type_t *iface) static void free_variable( const var_t *arg, const char *local_var_prefix ) { unsigned int type_offset = arg->typestring_offset; - type_t *type = arg->type; + type_t *type = arg->declspec.type; write_parameter_conf_or_var_exprs(proxy, indent, local_var_prefix, PHASE_FREE, arg, FALSE); @@ -191,18 +191,18 @@ static void proxy_free_variables( var_list_t *args, const char *local_var_prefix static void gen_proxy(type_t *iface, const var_t *func, int idx, unsigned int proc_offset) { - var_t *retval = type_function_get_retval(func->type); - int has_ret = !is_void(retval->type); + var_t *retval = type_function_get_retval(func->declspec.type); + int has_ret = !is_void(retval->declspec.type); int has_full_pointer = is_full_pointer_function(func); - const char *callconv = get_attrp(func->type->attrs, ATTR_CALLCONV); - const var_list_t *args = type_get_function_args(func->type); + const char *callconv = get_attrp(func->declspec.type->attrs, ATTR_CALLCONV); + const var_list_t *args = type_get_function_args(func->declspec.type); if (!callconv) callconv = "STDMETHODCALLTYPE"; indent = 0; if (is_interpreted_func( iface, func )) { if (get_stub_mode() == MODE_Oif && !is_callas( func->attrs )) return; - write_type_decl_left(proxy, retval->type); + write_type_decl_left(proxy, retval->declspec.type); print_proxy( " %s %s_%s_Proxy(\n", callconv, iface->name, get_name(func)); write_args(proxy, args, iface->name, 1, TRUE); print_proxy( ")\n"); @@ -219,7 +219,7 @@ static void gen_proxy(type_t *iface, const var_t *func, int idx, print_proxy( "}\n"); print_proxy( "\n"); - write_type_decl_left(proxy, retval->type); + write_type_decl_left(proxy, retval->declspec.type); print_proxy( " %s %s_%s_Proxy(\n", callconv, iface->name, get_name(func)); write_args(proxy, args, iface->name, 1, TRUE); print_proxy( ")\n"); @@ -229,12 +229,12 @@ static void gen_proxy(type_t *iface, const var_t *func, int idx, /* local variables */ if (has_ret) { print_proxy( "%s", "" ); - write_type_decl(proxy, retval->type, retval->name); + write_type_decl(proxy, retval->declspec.type, retval->name); fprintf( proxy, ";\n" ); } print_proxy( "RPC_MESSAGE _RpcMessage;\n" ); if (has_ret) { - if (decl_indirect(retval->type)) + if (decl_indirect(retval->declspec.type)) print_proxy("void *_p_%s = &%s;\n", retval->name, retval->name); } print_proxy( "\n"); @@ -246,7 +246,7 @@ static void gen_proxy(type_t *iface, const var_t *func, int idx, write_full_pointer_init(proxy, indent, func, FALSE); /* FIXME: trace */ - clear_output_vars( type_get_function_args(func->type) ); + clear_output_vars( type_get_function_args(func->declspec.type) ); print_proxy( "RpcTryExcept\n" ); print_proxy( "{\n" ); @@ -279,9 +279,9 @@ static void gen_proxy(type_t *iface, const var_t *func, int idx, if (has_ret) { - if (decl_indirect(retval->type)) + if (decl_indirect(retval->declspec.type)) print_proxy("MIDL_memset(&%s, 0, sizeof(%s));\n", retval->name, retval->name); - else if (is_ptr(retval->type) || is_array(retval->type)) + else if (is_ptr(retval->declspec.type) || is_array(retval->declspec.type)) print_proxy("%s = 0;\n", retval->name); write_remoting_arguments(proxy, indent, func, "", PASS_RETURN, PHASE_UNMARSHAL); } @@ -301,7 +301,7 @@ static void gen_proxy(type_t *iface, const var_t *func, int idx, print_proxy( "{\n" ); if (has_ret) { indent++; - proxy_free_variables( type_get_function_args(func->type), "" ); + proxy_free_variables( type_get_function_args(func->declspec.type), "" ); print_proxy( "_RetVal = NdrProxyErrorHandler(RpcExceptionCode());\n" ); indent--; } @@ -320,7 +320,7 @@ static void gen_stub(type_t *iface, const var_t *func, const char *cas, unsigned int proc_offset) { const var_t *arg; - int has_ret = !is_void(type_function_get_rettype(func->type)); + int has_ret = !is_void(type_function_get_rettype(func->declspec.type)); int has_full_pointer = is_full_pointer_function(func); if (is_interpreted_func( iface, func )) return; @@ -389,10 +389,10 @@ static void gen_stub(type_t *iface, const var_t *func, const char *cas, else fprintf(proxy, "__frame->_This->lpVtbl->%s", get_name(func)); fprintf(proxy, "(__frame->_This"); - if (type_get_function_args(func->type)) + if (type_get_function_args(func->declspec.type)) { - LIST_FOR_EACH_ENTRY( arg, type_get_function_args(func->type), const var_t, entry ) - fprintf(proxy, ", %s__frame->%s", is_array(arg->type) && !type_array_is_decl_as_ptr(arg->type) ? "*" :"" , arg->name); + LIST_FOR_EACH_ENTRY( arg, type_get_function_args(func->declspec.type), const var_t, entry ) + fprintf(proxy, ", %s__frame->%s", is_array(arg->declspec.type) && !type_array_is_decl_as_ptr(arg->declspec.type) ? "*" :"" , arg->name); } fprintf(proxy, ");\n"); fprintf(proxy, "\n"); @@ -401,7 +401,7 @@ static void gen_stub(type_t *iface, const var_t *func, const char *cas, write_remoting_arguments(proxy, indent, func, "__frame->", PASS_OUT, PHASE_BUFFERSIZE); - if (!is_void(type_function_get_rettype(func->type))) + if (!is_void(type_function_get_rettype(func->declspec.type))) write_remoting_arguments(proxy, indent, func, "__frame->", PASS_RETURN, PHASE_BUFFERSIZE); print_proxy("NdrStubGetBuffer(This, _pRpcChannelBuffer, &__frame->_StubMsg);\n"); @@ -410,7 +410,7 @@ static void gen_stub(type_t *iface, const var_t *func, const char *cas, fprintf(proxy, "\n"); /* marshall the return value */ - if (!is_void(type_function_get_rettype(func->type))) + if (!is_void(type_function_get_rettype(func->declspec.type))) write_remoting_arguments(proxy, indent, func, "__frame->", PASS_RETURN, PHASE_MARSHAL); indent--; @@ -432,16 +432,16 @@ static void gen_stub(type_t *iface, const var_t *func, const char *cas, static void gen_stub_thunk( type_t *iface, const var_t *func, unsigned int proc_offset ) { - int has_ret = !is_void( type_function_get_rettype( func->type )); + int has_ret = !is_void( type_function_get_rettype( func->declspec.type )); const var_t *arg, *callas = is_callas( func->attrs ); - const var_list_t *args = type_get_function_args( func->type ); + const var_list_t *args = type_get_function_args( func->declspec.type ); indent = 0; print_proxy( "void __RPC_API %s_%s_Thunk( PMIDL_STUB_MESSAGE pStubMsg )\n", iface->name, get_name(func) ); print_proxy( "{\n"); indent++; - write_func_param_struct( proxy, iface, func->type, + write_func_param_struct( proxy, iface, func->declspec.type, "*pParamStruct = (struct _PARAM_STRUCT *)pStubMsg->StackTop", has_ret ); print_proxy( "%s%s_%s_Stub( pParamStruct->This", has_ret ? "pParamStruct->_RetVal = " : "", iface->name, callas->name ); @@ -614,14 +614,14 @@ static void write_proxy(type_t *iface, unsigned int *proc_offset) if (!is_local(func->attrs)) { const var_t *cas = is_callas(func->attrs); const char *cname = cas ? cas->name : NULL; - int idx = func->type->details.function->idx; + int idx = func->declspec.type->details.function->idx; if (cname) { const statement_t *stmt2; STATEMENTS_FOR_EACH_FUNC(stmt2, type_iface_get_stmts(iface)) { const var_t *m = stmt2->u.var; if (!strcmp(m->name, cname)) { - idx = m->type->details.function->idx; + idx = m->declspec.type->details.function->idx; break; } } diff --git a/tools/widl/server.c b/tools/widl/server.c index 59c17d661f..fb14dd87bc 100644 --- a/tools/widl/server.c +++ b/tools/widl/server.c @@ -55,7 +55,7 @@ static void write_function_stub(const type_t *iface, const var_t *func, unsigned unsigned char explicit_fc, implicit_fc; int has_full_pointer = is_full_pointer_function(func); const var_t *handle_var = get_func_handle_var( iface, func, &explicit_fc, &implicit_fc ); - type_t *ret_type = type_function_get_rettype(func->type); + type_t *ret_type = type_function_get_rettype(func->declspec.type); if (is_interpreted_func( iface, func )) return; @@ -121,7 +121,7 @@ static void write_function_stub(const type_t *iface, const var_t *func, unsigned if (has_full_pointer) write_full_pointer_init(server, indent, func, TRUE); - if (type_get_function_args(func->type)) + if (type_get_function_args(func->declspec.type)) { print_server("if ((_pRpcMessage->DataRepresentation & 0x0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION)\n"); indent++; @@ -166,31 +166,31 @@ static void write_function_stub(const type_t *iface, const var_t *func, unsigned print_server("%s", is_void(ret_type) ? "" : "__frame->_RetVal = "); fprintf(server, "%s%s", prefix_server, get_name(func)); - if (type_get_function_args(func->type)) + if (type_get_function_args(func->declspec.type)) { int first_arg = 1; fprintf(server, "(\n"); indent++; - LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry ) + LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->declspec.type), const var_t, entry ) { if (first_arg) first_arg = 0; else fprintf(server, ",\n"); - if (is_context_handle(var->type)) + if (is_context_handle(var->declspec.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 */ - const char *ch_ptr = is_aliaschain_attr(var->type, ATTR_CONTEXTHANDLE) ? "*" : ""; + const char *ch_ptr = is_aliaschain_attr(var->declspec.type, ATTR_CONTEXTHANDLE) ? "*" : ""; print_server("("); - write_type_decl_left(server, var->type); + write_type_decl_left(server, var->declspec.type); fprintf(server, ")%sNDRSContextValue(__frame->%s)", ch_ptr, var->name); } else { - print_server("%s__frame->%s", is_array(var->type) && !type_array_is_decl_as_ptr(var->type) ? "*" : "", var->name); + print_server("%s__frame->%s", is_array(var->declspec.type) && !type_array_is_decl_as_ptr(var->declspec.type) ? "*" : "", var->name); } } fprintf(server, ");\n"); diff --git a/tools/widl/typegen.c b/tools/widl/typegen.c index a121364415..f685f7156a 100644 --- a/tools/widl/typegen.c +++ b/tools/widl/typegen.c @@ -379,13 +379,13 @@ enum typegen_type typegen_detect_type(const type_t *type, const attr_list_t *att static int cant_be_null(const var_t *v) { - switch (typegen_detect_type(v->type, v->attrs, TDT_IGNORE_STRINGS)) + switch (typegen_detect_type(v->declspec.type, v->attrs, TDT_IGNORE_STRINGS)) { case TGT_ARRAY: - if (!type_array_is_decl_as_ptr( v->type )) return 0; + if (!type_array_is_decl_as_ptr( v->declspec.type )) return 0; /* fall through */ case TGT_POINTER: - return (get_pointer_fc(v->type, v->attrs, TRUE) == FC_RP); + return (get_pointer_fc(v->declspec.type, v->attrs, TRUE) == FC_RP); case TGT_CTXT_HANDLE_POINTER: return TRUE; default: @@ -405,7 +405,7 @@ static int get_padding(const var_list_t *fields) LIST_FOR_EACH_ENTRY(f, fields, const var_t, entry) { - type_t *ft = f->type; + type_t *ft = f->declspec.type; unsigned int align = 0; unsigned int size = type_memsize_and_alignment(ft, &align); align = clamp_align(align); @@ -422,7 +422,7 @@ static unsigned int get_stack_size( const var_t *var, int *by_value ) unsigned int stack_size; int by_val; - switch (typegen_detect_type( var->type, var->attrs, TDT_ALL_TYPES )) + switch (typegen_detect_type( var->declspec.type, var->attrs, TDT_ALL_TYPES )) { case TGT_BASIC: case TGT_ENUM: @@ -430,7 +430,7 @@ static unsigned int get_stack_size( const var_t *var, int *by_value ) case TGT_STRUCT: case TGT_UNION: case TGT_USER_TYPE: - stack_size = type_memsize( var->type ); + stack_size = type_memsize( var->declspec.type ); by_val = (pointer_size < 8 || stack_size <= pointer_size); /* FIXME: should be platform-specific */ break; default: @@ -495,14 +495,14 @@ unsigned char get_struct_fc(const type_t *type) if (fields) LIST_FOR_EACH_ENTRY( field, fields, var_t, entry ) { - type_t *t = field->type; + type_t *t = field->declspec.type; enum typegen_type typegen_type; typegen_type = typegen_detect_type(t, field->attrs, TDT_IGNORE_STRINGS); if (typegen_type == TGT_ARRAY && !type_array_is_decl_as_ptr(t)) { - if (is_string_type(field->attrs, field->type)) + if (is_string_type(field->attrs, field->declspec.type)) { if (is_conformant_array(t)) has_conformance = 1; @@ -510,10 +510,10 @@ unsigned char get_struct_fc(const type_t *type) continue; } - if (is_array(type_array_get_element(field->type))) + if (is_array(type_array_get_element(field->declspec.type))) return FC_BOGUS_STRUCT; - if (type_array_has_conformance(field->type)) + if (type_array_has_conformance(field->declspec.type)) { has_conformance = 1; if (list_next(fields, &field->entry)) @@ -721,7 +721,7 @@ static int type_has_pointers(const type_t *type) const var_t *field; if (fields) LIST_FOR_EACH_ENTRY( field, fields, const var_t, entry ) { - if (type_has_pointers(field->type)) + if (type_has_pointers(field->declspec.type)) return TRUE; } break; @@ -733,7 +733,7 @@ static int type_has_pointers(const type_t *type) fields = type_union_get_cases(type); if (fields) LIST_FOR_EACH_ENTRY( field, fields, const var_t, entry ) { - if (field->type && type_has_pointers(field->type)) + if (field->declspec.type && type_has_pointers(field->declspec.type)) return TRUE; } break; @@ -775,7 +775,7 @@ static int type_has_full_pointer(const type_t *type, const attr_list_t *attrs, const var_t *field; if (fields) LIST_FOR_EACH_ENTRY( field, fields, const var_t, entry ) { - if (type_has_full_pointer(field->type, field->attrs, FALSE)) + if (type_has_full_pointer(field->declspec.type, field->attrs, FALSE)) return TRUE; } break; @@ -787,7 +787,7 @@ static int type_has_full_pointer(const type_t *type, const attr_list_t *attrs, fields = type_union_get_cases(type); if (fields) LIST_FOR_EACH_ENTRY( field, fields, const var_t, entry ) { - if (field->type && type_has_full_pointer(field->type, field->attrs, FALSE)) + if (field->declspec.type && type_has_full_pointer(field->declspec.type, field->attrs, FALSE)) return TRUE; } break; @@ -907,16 +907,16 @@ static void write_var_init(FILE *file, int indent, const type_t *t, const char * void write_parameters_init(FILE *file, int indent, const var_t *func, const char *local_var_prefix) { - const var_t *var = type_function_get_retval(func->type); + const var_t *var = type_function_get_retval(func->declspec.type); - if (!is_void(var->type)) - write_var_init(file, indent, var->type, var->name, local_var_prefix); + if (!is_void(var->declspec.type)) + write_var_init(file, indent, var->declspec.type, var->name, local_var_prefix); - if (!type_get_function_args(func->type)) + if (!type_get_function_args(func->declspec.type)) return; - LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry ) - write_var_init(file, indent, var->type, var->name, local_var_prefix); + LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->declspec.type), const var_t, entry ) + write_var_init(file, indent, var->declspec.type, var->name, local_var_prefix); fprintf(file, "\n"); } @@ -980,14 +980,14 @@ static unsigned char get_parameter_fc( const var_t *var, int is_return, unsigned if (is_out) *flags |= IsOut; if (is_return) *flags |= IsReturn; - if (!is_string_type( var->attrs, var->type )) - buffer_size = get_required_buffer_size_type( var->type, NULL, var->attrs, TRUE, &alignment ); + if (!is_string_type( var->attrs, var->declspec.type )) + buffer_size = get_required_buffer_size_type( var->declspec.type, NULL, var->attrs, TRUE, &alignment ); - switch (typegen_detect_type( var->type, var->attrs, TDT_ALL_TYPES )) + switch (typegen_detect_type( var->declspec.type, var->attrs, TDT_ALL_TYPES )) { case TGT_BASIC: *flags |= IsBasetype; - fc = get_basic_fc_signed( var->type ); + fc = get_basic_fc_signed( var->declspec.type ); if (fc == FC_BIND_PRIMITIVE) { buffer_size = 4; /* actually 0 but avoids setting MustSize */ @@ -996,7 +996,7 @@ static unsigned char get_parameter_fc( const var_t *var, int is_return, unsigned break; case TGT_ENUM: *flags |= IsBasetype; - fc = get_enum_fc( var->type ); + fc = get_enum_fc( var->declspec.type ); break; case TGT_RANGE: *flags |= IsByValue; @@ -1011,19 +1011,19 @@ static unsigned char get_parameter_fc( const var_t *var, int is_return, unsigned break; case TGT_ARRAY: *flags |= MustFree; - if (type_array_is_decl_as_ptr(var->type) && var->type->details.array.ptr_tfsoff && - get_pointer_fc( var->type, var->attrs, !is_return ) == FC_RP) + if (type_array_is_decl_as_ptr(var->declspec.type) && var->declspec.type->details.array.ptr_tfsoff && + get_pointer_fc( var->declspec.type, var->attrs, !is_return ) == FC_RP) { - *typestring_offset = var->type->typestring_offset; + *typestring_offset = var->declspec.type->typestring_offset; *flags |= IsSimpleRef; } break; case TGT_STRING: *flags |= MustFree; - if (is_declptr( var->type ) && get_pointer_fc( var->type, var->attrs, !is_return ) == FC_RP) + if (is_declptr( var->declspec.type ) && get_pointer_fc( var->declspec.type, var->attrs, !is_return ) == FC_RP) { /* skip over pointer description straight to string description */ - if (is_conformant_array( var->type )) *typestring_offset += 4; + if (is_conformant_array( var->declspec.type )) *typestring_offset += 4; else *typestring_offset += 2; *flags |= IsSimpleRef; } @@ -1036,9 +1036,9 @@ static unsigned char get_parameter_fc( const var_t *var, int is_return, unsigned buffer_size = 20; break; case TGT_POINTER: - if (get_pointer_fc( var->type, var->attrs, !is_return ) == FC_RP) + if (get_pointer_fc( var->declspec.type, var->attrs, !is_return ) == FC_RP) { - const type_t *ref = type_pointer_get_ref( var->type ); + const type_t *ref = type_pointer_get_ref( var->declspec.type ); if (!is_string_type( var->attrs, ref )) buffer_size = get_required_buffer_size_type( ref, NULL, NULL, TRUE, &alignment ); @@ -1128,8 +1128,8 @@ static unsigned char get_parameter_fc( const var_t *var, int is_return, unsigned static unsigned char get_func_oi2_flags( const var_t *func ) { const var_t *var; - var_list_t *args = type_get_function_args( func->type ); - var_t *retval = type_function_get_retval( func->type ); + var_list_t *args = type_get_function_args( func->declspec.type ); + var_t *retval = type_function_get_retval( func->declspec.type ); unsigned char oi2_flags = 0x40; /* HasExtensions */ unsigned short flags; unsigned int stack_size, typestring_offset; @@ -1144,7 +1144,7 @@ static unsigned char get_func_oi2_flags( const var_t *func ) } } - if (!is_void( retval->type )) + if (!is_void( retval->declspec.type )) { oi2_flags |= 0x04; /* HasRet */ get_parameter_fc( retval, 1, &flags, &stack_size, &typestring_offset ); @@ -1198,8 +1198,8 @@ static unsigned int write_old_procformatstring_type(FILE *file, int indent, cons if (!is_in && !is_out) is_in = TRUE; - if (type_get_type(var->type) == TYPE_BASIC || - type_get_type(var->type) == TYPE_ENUM) + if (type_get_type(var->declspec.type) == TYPE_BASIC || + type_get_type(var->declspec.type) == TYPE_ENUM) { unsigned char fc; @@ -1208,13 +1208,13 @@ static unsigned int write_old_procformatstring_type(FILE *file, int indent, cons else print_file(file, indent, "0x4e, /* FC_IN_PARAM_BASETYPE */\n"); - if (type_get_type(var->type) == TYPE_ENUM) + if (type_get_type(var->declspec.type) == TYPE_ENUM) { - fc = get_enum_fc(var->type); + fc = get_enum_fc(var->declspec.type); } else { - fc = get_basic_fc_signed(var->type); + fc = get_basic_fc_signed(var->declspec.type); if (fc == FC_BIND_PRIMITIVE) fc = FC_IGNORE; @@ -1228,10 +1228,10 @@ static unsigned int write_old_procformatstring_type(FILE *file, int indent, cons { unsigned short offset = var->typestring_offset; - if (!is_interpreted && is_array(var->type) && - type_array_is_decl_as_ptr(var->type) && - var->type->details.array.ptr_tfsoff) - offset = var->type->typestring_offset; + if (!is_interpreted && is_array(var->declspec.type) && + type_array_is_decl_as_ptr(var->declspec.type) && + var->declspec.type->details.array.ptr_tfsoff) + offset = var->declspec.type->typestring_offset; if (is_return) print_file(file, indent, "0x52, /* FC_RETURN_PARAM */\n"); @@ -1254,8 +1254,8 @@ int is_interpreted_func( const type_t *iface, const var_t *func ) { const char *str; const var_t *var; - const var_list_t *args = type_get_function_args( func->type ); - const type_t *ret_type = type_function_get_rettype( func->type ); + const var_list_t *args = type_get_function_args( func->declspec.type ); + const type_t *ret_type = type_function_get_rettype( func->declspec.type ); if (type_get_type( ret_type ) == TYPE_BASIC) { @@ -1277,10 +1277,10 @@ int is_interpreted_func( const type_t *iface, const var_t *func ) if (get_stub_mode() != MODE_Oif && args) { LIST_FOR_EACH_ENTRY( var, args, const var_t, entry ) - switch (type_get_type( var->type )) + switch (type_get_type( var->declspec.type )) { case TYPE_BASIC: - switch (type_basic_get_type( var->type )) + switch (type_basic_get_type( var->declspec.type )) { /* floating point arguments are not supported in Oi mode */ case TYPE_BASIC_FLOAT: return 0; @@ -1305,7 +1305,7 @@ static void write_proc_func_header( FILE *file, int indent, const type_t *iface, unsigned short num_proc ) { var_t *var; - var_list_t *args = type_get_function_args( func->type ); + var_list_t *args = type_get_function_args( func->declspec.type ); unsigned char explicit_fc, implicit_fc; unsigned char handle_flags; const var_t *handle_var = get_func_handle_var( iface, func, &explicit_fc, &implicit_fc ); @@ -1336,7 +1336,7 @@ static void write_proc_func_header( FILE *file, int indent, const type_t *iface, param_num++; nb_args++; } - if (!is_void( type_function_get_rettype( func->type ))) + if (!is_void( type_function_get_rettype( func->declspec.type ))) { stack_size += pointer_size; nb_args++; @@ -1364,22 +1364,22 @@ static void write_proc_func_header( FILE *file, int indent, const type_t *iface, *offset += 4; break; case FC_BIND_GENERIC: - handle_flags = type_memsize( handle_var->type ); + handle_flags = type_memsize( handle_var->declspec.type ); print_file( file, indent, "0x%02x,\t/* %s */\n", explicit_fc, string_of_type(explicit_fc) ); print_file( file, indent, "0x%02x,\n", handle_flags ); print_file( file, indent, "NdrFcShort(0x%hx),\t/* stack offset = %hu */\n", handle_stack_offset, handle_stack_offset ); - print_file( file, indent, "0x%02x,\n", get_generic_handle_offset( handle_var->type ) ); + print_file( file, indent, "0x%02x,\n", get_generic_handle_offset( handle_var->declspec.type ) ); print_file( file, indent, "0x%x,\t/* FC_PAD */\n", FC_PAD); *offset += 6; break; case FC_BIND_CONTEXT: - handle_flags = get_contexthandle_flags( iface, handle_var->attrs, handle_var->type, 0 ); + handle_flags = get_contexthandle_flags( iface, handle_var->attrs, handle_var->declspec.type, 0 ); print_file( file, indent, "0x%02x,\t/* %s */\n", explicit_fc, string_of_type(explicit_fc) ); print_file( file, indent, "0x%02x,\n", handle_flags ); print_file( file, indent, "NdrFcShort(0x%hx),\t/* stack offset = %hu */\n", handle_stack_offset, handle_stack_offset ); - print_file( file, indent, "0x%02x,\n", get_context_handle_offset( handle_var->type ) ); + print_file( file, indent, "0x%02x,\n", get_context_handle_offset( handle_var->declspec.type ) ); print_file( file, indent, "0x%02x,\t/* param %hu */\n", handle_param_num, handle_param_num ); *offset += 6; break; @@ -1415,9 +1415,9 @@ static void write_proc_func_header( FILE *file, int indent, const type_t *iface, if (is_object( iface )) pos += 2; if (args) LIST_FOR_EACH_ENTRY( var, args, var_t, entry ) { - if (type_get_type( var->type ) == TYPE_BASIC) + if (type_get_type( var->declspec.type ) == TYPE_BASIC) { - switch (type_basic_get_type( var->type )) + switch (type_basic_get_type( var->declspec.type )) { case TYPE_BASIC_FLOAT: fpu_mask |= 1 << pos; break; case TYPE_BASIC_DOUBLE: fpu_mask |= 2 << pos; break; @@ -1440,15 +1440,15 @@ static void write_procformatstring_func( FILE *file, int indent, const type_t *i unsigned int stack_offset = is_object( iface ) ? pointer_size : 0; int is_interpreted = is_interpreted_func( iface, func ); int is_new_style = is_interpreted && (get_stub_mode() == MODE_Oif); - var_t *retval = type_function_get_retval( func->type ); + var_t *retval = type_function_get_retval( func->declspec.type ); if (is_interpreted) write_proc_func_header( file, indent, iface, func, offset, num_proc ); /* emit argument data */ - if (type_get_function_args(func->type)) + if (type_get_function_args(func->declspec.type)) { const var_t *var; - LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry ) + LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->declspec.type), const var_t, entry ) { print_file( file, 0, "/* %u (parameter %s) */\n", *offset, var->name ); if (is_new_style) @@ -1459,7 +1459,7 @@ static void write_procformatstring_func( FILE *file, int indent, const type_t *i } /* emit return value data */ - if (is_void(retval->type)) + if (is_void(retval->declspec.type)) { if (!is_new_style) { @@ -1606,7 +1606,7 @@ static unsigned int write_conf_or_var_desc(FILE *file, const type_t *cont_type, { conftype = FC_TOP_LEVEL_CONFORMANCE; conftype_string = "parameter"; - cont_type = current_func->type; + cont_type = current_func->declspec.type; name = current_func->name; iface = current_iface; } @@ -1677,7 +1677,7 @@ static unsigned int write_conf_or_var_desc(FILE *file, const type_t *cont_type, if (var->name && !strcmp(var->name, subexpr->u.sval)) { expr_loc.v = var; - correlation_variable = var->type; + correlation_variable = var->declspec.type; break; } offset += get_stack_size( var, NULL ); @@ -1689,11 +1689,11 @@ static unsigned int write_conf_or_var_desc(FILE *file, const type_t *cont_type, if (fields) LIST_FOR_EACH_ENTRY( var, fields, const var_t, entry ) { - unsigned int size = field_memsize( var->type, &offset ); + unsigned int size = field_memsize( var->declspec.type, &offset ); if (var->name && !strcmp(var->name, subexpr->u.sval)) { expr_loc.v = var; - correlation_variable = var->type; + correlation_variable = var->declspec.type; break; } offset += size; @@ -1832,7 +1832,7 @@ static unsigned int fields_memsize(const var_list_t *fields, unsigned int *align LIST_FOR_EACH_ENTRY( v, fields, const var_t, entry ) { unsigned int falign = 0; - unsigned int fsize = type_memsize_and_alignment(v->type, &falign); + unsigned int fsize = type_memsize_and_alignment(v->declspec.type, &falign); if (*align < falign) *align = falign; falign = clamp_align(falign); size = ROUND_SIZE(size, falign); @@ -1854,9 +1854,9 @@ static unsigned int union_memsize(const var_list_t *fields, unsigned int *pmaxa) if (fields) LIST_FOR_EACH_ENTRY( v, fields, const var_t, entry ) { /* we could have an empty default field with NULL type */ - if (v->type) + if (v->declspec.type) { - size = type_memsize_and_alignment(v->type, &align); + size = type_memsize_and_alignment(v->declspec.type, &align); if (maxs < size) maxs = size; if (*pmaxa < align) *pmaxa = align; } @@ -2029,8 +2029,8 @@ static unsigned int type_buffer_alignment(const type_t *t) if (!(fields = type_struct_get_fields(t))) break; LIST_FOR_EACH_ENTRY( var, fields, const var_t, entry ) { - if (!var->type) continue; - align = type_buffer_alignment( var->type ); + if (!var->declspec.type) continue; + align = type_buffer_alignment( var->declspec.type ); if (max < align) max = align; } break; @@ -2038,8 +2038,8 @@ static unsigned int type_buffer_alignment(const type_t *t) if (!(fields = type_encapsulated_union_get_fields(t))) break; LIST_FOR_EACH_ENTRY( var, fields, const var_t, entry ) { - if (!var->type) continue; - align = type_buffer_alignment( var->type ); + if (!var->declspec.type) continue; + align = type_buffer_alignment( var->declspec.type ); if (max < align) max = align; } break; @@ -2047,8 +2047,8 @@ static unsigned int type_buffer_alignment(const type_t *t) if (!(fields = type_union_get_cases(t))) break; LIST_FOR_EACH_ENTRY( var, fields, const var_t, entry ) { - if (!var->type) continue; - align = type_buffer_alignment( var->type ); + if (!var->declspec.type) continue; + align = type_buffer_alignment( var->declspec.type ); if (max < align) max = align; } break; @@ -2077,12 +2077,12 @@ static unsigned int type_buffer_alignment(const type_t *t) int is_full_pointer_function(const var_t *func) { const var_t *var; - if (type_has_full_pointer(type_function_get_rettype(func->type), func->attrs, TRUE)) + if (type_has_full_pointer(type_function_get_rettype(func->declspec.type), func->attrs, TRUE)) return TRUE; - if (!type_get_function_args(func->type)) + if (!type_get_function_args(func->declspec.type)) return FALSE; - LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry ) - if (type_has_full_pointer( var->type, var->attrs, TRUE )) + LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->declspec.type), const var_t, entry ) + if (type_has_full_pointer( var->declspec.type, var->attrs, TRUE )) return TRUE; return FALSE; } @@ -2424,7 +2424,7 @@ static void write_descriptors(FILE *file, type_t *type, unsigned int *tfsoff) if (fs) LIST_FOR_EACH_ENTRY(f, fs, var_t, entry) { - type_t *ft = f->type; + type_t *ft = f->declspec.type; unsigned int size = field_memsize( ft, &offset ); if (type_get_type(ft) == TYPE_UNION && is_attr(f->attrs, ATTR_SWITCHIS)) { @@ -2519,13 +2519,13 @@ static int write_pointer_description_offsets( { unsigned int padding; unsigned int align = 0; - type_memsize_and_alignment(v->type, &align); + type_memsize_and_alignment(v->declspec.type, &align); padding = ROUNDING(*offset_in_memory, align); *offset_in_memory += padding; *offset_in_buffer += padding; } written += write_pointer_description_offsets( - file, v->attrs, v->type, offset_in_memory, offset_in_buffer, + file, v->attrs, v->declspec.type, offset_in_memory, offset_in_buffer, typestring_offset); } } @@ -2571,13 +2571,13 @@ static int write_no_repeat_pointer_descriptions( { unsigned int padding; unsigned int align = 0; - type_memsize_and_alignment(v->type, &align); + type_memsize_and_alignment(v->declspec.type, &align); padding = ROUNDING(*offset_in_memory, align); *offset_in_memory += padding; *offset_in_buffer += padding; } written += write_no_repeat_pointer_descriptions( - file, v->attrs, v->type, + file, v->attrs, v->declspec.type, offset_in_memory, offset_in_buffer, typestring_offset); } } @@ -2640,13 +2640,13 @@ static int write_fixed_array_pointer_descriptions( { unsigned int padding; unsigned int align = 0; - type_memsize_and_alignment(v->type, &align); + type_memsize_and_alignment(v->declspec.type, &align); padding = ROUNDING(*offset_in_memory, align); *offset_in_memory += padding; *offset_in_buffer += padding; } pointer_count += write_fixed_array_pointer_descriptions( - file, v->attrs, v->type, offset_in_memory, offset_in_buffer, + file, v->attrs, v->declspec.type, offset_in_memory, offset_in_buffer, typestring_offset); } } @@ -2755,20 +2755,20 @@ static int write_varying_array_pointer_descriptions( { unsigned int align = 0, padding; - if (is_array(v->type) && type_array_has_variance(v->type)) + if (is_array(v->declspec.type) && type_array_has_variance(v->declspec.type)) { *offset_in_buffer = ROUND_SIZE(*offset_in_buffer, 4); /* skip over variance and offset in buffer */ *offset_in_buffer += 8; } - type_memsize_and_alignment(v->type, &align); + type_memsize_and_alignment(v->declspec.type, &align); padding = ROUNDING(*offset_in_memory, align); *offset_in_memory += padding; *offset_in_buffer += padding; } pointer_count += write_varying_array_pointer_descriptions( - file, v->attrs, v->type, offset_in_memory, offset_in_buffer, + file, v->attrs, v->declspec.type, offset_in_memory, offset_in_buffer, typestring_offset); } } @@ -2820,7 +2820,7 @@ static void write_pointer_description(FILE *file, const attr_list_t *attrs, type else if (type_get_type(type) == TYPE_STRUCT && get_struct_fc(type) == FC_CPSTRUCT) { - type_t *carray = find_array_or_string_in_struct(type)->type; + type_t *carray = find_array_or_string_in_struct(type)->declspec.type; write_conformant_array_pointer_descriptions( file, NULL, carray, type_memsize(type), typestring_offset); } @@ -3058,7 +3058,7 @@ static const var_t *find_array_or_string_in_struct(const type_t *type) return NULL; last_field = LIST_ENTRY( list_tail(fields), const var_t, entry ); - ft = last_field->type; + ft = last_field->declspec.type; if (is_conformant_array(ft) && !type_array_is_decl_as_ptr(ft)) return last_field; @@ -3081,7 +3081,7 @@ static void write_struct_members(FILE *file, const type_t *type, if (fields) LIST_FOR_EACH_ENTRY( field, fields, const var_t, entry ) { - type_t *ft = field->type; + type_t *ft = field->declspec.type; unsigned int align = 0; unsigned int size = type_memsize_and_alignment(ft, &align); align = clamp_align(align); @@ -3110,7 +3110,7 @@ static void write_struct_members(FILE *file, const type_t *type, offset = ROUND_SIZE(offset, align); *typestring_offset += 1; } - write_member_type(file, type, is_complex, field->attrs, field->type, corroff, + write_member_type(file, type, is_complex, field->attrs, field->declspec.type, corroff, typestring_offset); offset += size; } @@ -3153,15 +3153,15 @@ static unsigned int write_struct_tfs(FILE *file, type_t *type, name, USHRT_MAX, total_size - USHRT_MAX); if (fields) LIST_FOR_EACH_ENTRY(f, fields, var_t, entry) - write_embedded_types(file, f->attrs, f->type, f->name, FALSE, tfsoff); + write_embedded_types(file, f->attrs, f->declspec.type, f->name, FALSE, tfsoff); array = find_array_or_string_in_struct(type); - if (array && !processed(array->type)) + if (array && !processed(array->declspec.type)) { - if(is_string_type(array->attrs, array->type)) - write_string_tfs(file, array->attrs, array->type, TYPE_CONTEXT_CONTAINER, array->name, tfsoff); + if(is_string_type(array->attrs, array->declspec.type)) + write_string_tfs(file, array->attrs, array->declspec.type, TYPE_CONTEXT_CONTAINER, array->name, tfsoff); else - write_array_tfs(file, array->attrs, array->type, array->name, tfsoff); + write_array_tfs(file, array->attrs, array->declspec.type, array->name, tfsoff); } corroff = *tfsoff; @@ -3177,7 +3177,7 @@ static unsigned int write_struct_tfs(FILE *file, type_t *type, if (array) { - unsigned int absoff = array->type->typestring_offset; + unsigned int absoff = array->declspec.type->typestring_offset; short reloff = absoff - *tfsoff; print_file(file, 2, "NdrFcShort(0x%hx),\t/* Offset= %hd (%u) */\n", reloff, reloff, absoff); @@ -3223,7 +3223,7 @@ static unsigned int write_struct_tfs(FILE *file, type_t *type, type->ptrdesc = *tfsoff; if (fields) LIST_FOR_EACH_ENTRY(f, fields, const var_t, entry) { - type_t *ft = f->type; + type_t *ft = f->declspec.type; switch (typegen_detect_type(ft, f->attrs, TDT_IGNORE_STRINGS)) { case TGT_POINTER: @@ -3319,8 +3319,8 @@ static unsigned int write_union_tfs(FILE *file, const attr_list_t *attrs, expr_list_t *cases = get_attrp(f->attrs, ATTR_CASE); if (cases) nbranch += list_count(cases); - if (f->type) - write_embedded_types(file, f->attrs, f->type, f->name, TRUE, tfsoff); + if (f->declspec.type) + write_embedded_types(file, f->attrs, f->declspec.type, f->name, TRUE, tfsoff); } start_offset = *tfsoff; @@ -3329,7 +3329,7 @@ static unsigned int write_union_tfs(FILE *file, const attr_list_t *attrs, if (type_get_type(type) == TYPE_ENCAPSULATED_UNION) { const var_t *sv = type_union_get_switch_value(type); - const type_t *st = sv->type; + const type_t *st = sv->declspec.type; unsigned int align = 0; unsigned char fc; @@ -3361,8 +3361,8 @@ static unsigned int write_union_tfs(FILE *file, const attr_list_t *attrs, type_memsize_and_alignment(st, &align); if (fields) LIST_FOR_EACH_ENTRY(f, fields, var_t, entry) { - if (f->type) - type_memsize_and_alignment(f->type, &align); + if (f->declspec.type) + type_memsize_and_alignment(f->declspec.type, &align); } print_file(file, 2, "0x%x,\t/* FC_ENCAPSULATED_UNION */\n", FC_ENCAPSULATED_UNION); @@ -3417,7 +3417,7 @@ static unsigned int write_union_tfs(FILE *file, const attr_list_t *attrs, if (fields) LIST_FOR_EACH_ENTRY(f, fields, var_t, entry) { - type_t *ft = f->type; + type_t *ft = f->declspec.type; expr_list_t *cases = get_attrp(f->attrs, ATTR_CASE); int deflt = is_attr(f->attrs, ATTR_DEFAULT); expr_t *c; @@ -3699,21 +3699,21 @@ static void process_tfs_iface(type_t *iface, FILE *file, int indent, unsigned in { const var_t *func = stmt->u.var; - if(stmt->u.var->stgclass != STG_NONE - || type_get_type_detect_alias(stmt->u.var->type) != TYPE_FUNCTION) + if(stmt->u.var->declspec.stgclass != STG_NONE + || type_get_type_detect_alias(stmt->u.var->declspec.type) != TYPE_FUNCTION) continue; current_func = func; if (is_local(func->attrs)) continue; - var = type_function_get_retval(func->type); - if (!is_void(var->type)) - var->typestring_offset = write_type_tfs( file, var->attrs, var->type, func->name, + var = type_function_get_retval(func->declspec.type); + if (!is_void(var->declspec.type)) + var->typestring_offset = write_type_tfs( file, var->attrs, var->declspec.type, func->name, TYPE_CONTEXT_RETVAL, offset); - if (type_get_function_args(func->type)) - LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), var_t, entry ) - var->typestring_offset = write_type_tfs( file, var->attrs, var->type, var->name, + if (type_get_function_args(func->declspec.type)) + LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->declspec.type), var_t, entry ) + var->typestring_offset = write_type_tfs( file, var->attrs, var->declspec.type, var->name, TYPE_CONTEXT_TOPLEVELPARAM, offset ); break; @@ -3899,8 +3899,8 @@ static unsigned int get_required_buffer_size(const var_t *var, unsigned int *ali return 20; } - if (!is_string_type(var->attrs, var->type)) - return get_required_buffer_size_type(var->type, var->name, + if (!is_string_type(var->attrs, var->declspec.type)) + return get_required_buffer_size_type(var->declspec.type, var->name, var->attrs, TRUE, alignment); } return 0; @@ -3911,19 +3911,19 @@ static unsigned int get_function_buffer_size( const var_t *func, enum pass pass const var_t *var; unsigned int total_size = 0, alignment; - if (type_get_function_args(func->type)) + if (type_get_function_args(func->declspec.type)) { - LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry ) + LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->declspec.type), const var_t, entry ) { total_size += get_required_buffer_size(var, &alignment, pass); total_size += alignment; } } - if (pass == PASS_OUT && !is_void(type_function_get_rettype(func->type))) + if (pass == PASS_OUT && !is_void(type_function_get_rettype(func->declspec.type))) { var_t v = *func; - v.type = type_function_get_rettype(func->type); + v.declspec.type = type_function_get_rettype(func->declspec.type); total_size += get_required_buffer_size(&v, &alignment, PASS_RETURN); total_size += alignment; } @@ -3959,9 +3959,9 @@ static void print_phase_function(FILE *file, int indent, const char *type, print_file(file, indent, "&__frame->_StubMsg,\n"); print_file(file, indent, "%s%s%s%s%s,\n", (phase == PHASE_UNMARSHAL) ? "(unsigned char **)" : "(unsigned char *)", - (phase == PHASE_UNMARSHAL || decl_indirect(var->type)) ? "&" : "", + (phase == PHASE_UNMARSHAL || decl_indirect(var->declspec.type)) ? "&" : "", local_var_prefix, - (phase == PHASE_UNMARSHAL && decl_indirect(var->type)) ? "_p_" : "", + (phase == PHASE_UNMARSHAL && decl_indirect(var->declspec.type)) ? "_p_" : "", var->name); print_file(file, indent, "(PFORMAT_STRING)&__MIDL_TypeFormatString.Format[%d]%s\n", type_offset, (phase == PHASE_UNMARSHAL) ? "," : ");"); @@ -3974,7 +3974,7 @@ void print_phase_basetype(FILE *file, int indent, const char *local_var_prefix, enum remoting_phase phase, enum pass pass, const var_t *var, const char *varname) { - type_t *type = var->type; + type_t *type = var->declspec.type; unsigned int alignment = 0; /* no work to do for other phases, buffer sizing is done elsewhere */ @@ -4116,7 +4116,7 @@ expr_t *get_size_is_expr(const type_t *t, const char *name) void write_parameter_conf_or_var_exprs(FILE *file, int indent, const char *local_var_prefix, enum remoting_phase phase, const var_t *var, int valid_variance) { - const type_t *type = var->type; + const type_t *type = var->declspec.type; /* get fundamental type for the argument */ for (;;) { @@ -4190,7 +4190,7 @@ static void write_remoting_arg(FILE *file, int indent, const var_t *func, const { int in_attr, out_attr, pointer_type; const char *type_str = NULL; - const type_t *type = var->type; + const type_t *type = var->declspec.type; unsigned int alignment, start_offset = type->typestring_offset; if (is_ptr(type) || is_array(type)) @@ -4243,7 +4243,7 @@ static void write_remoting_arg(FILE *file, int indent, const var_t *func, const print_file(file, indent, "NdrServerContextNewMarshall(\n"); print_file(file, indent + 1, "&__frame->_StubMsg,\n"); print_file(file, indent + 1, "(NDR_SCONTEXT)%s%s,\n", local_var_prefix, var->name); - print_file(file, indent + 1, "(NDR_RUNDOWN)%s_rundown,\n", get_context_handle_type_name(var->type)); + print_file(file, indent + 1, "(NDR_RUNDOWN)%s_rundown,\n", get_context_handle_type_name(var->declspec.type)); print_file(file, indent + 1, "(PFORMAT_STRING)&__MIDL_TypeFormatString.Format[%d]);\n", start_offset); } } @@ -4387,9 +4387,9 @@ static void write_remoting_arg(FILE *file, int indent, const var_t *func, const range_max = LIST_ENTRY(list_next(range_list, list_head(range_list)), const expr_t, entry); print_file(file, indent, "if ((%s%s < (", local_var_prefix, var->name); - write_type_decl(file, var->type, NULL); + write_type_decl(file, var->declspec.type, NULL); fprintf(file, ")0x%x) || (%s%s > (", range_min->cval, local_var_prefix, var->name); - write_type_decl(file, var->type, NULL); + write_type_decl(file, var->declspec.type, NULL); fprintf(file, ")0x%x))\n", range_max->cval); print_file(file, indent, "{\n"); print_file(file, indent+1, "RpcRaiseException(RPC_S_INVALID_BOUND);\n"); @@ -4556,14 +4556,14 @@ void write_remoting_arguments(FILE *file, int indent, const var_t *func, const c if (pass == PASS_RETURN) { write_remoting_arg( file, indent, func, local_var_prefix, pass, phase, - type_function_get_retval(func->type) ); + type_function_get_retval(func->declspec.type) ); } else { const var_t *var; - if (!type_get_function_args(func->type)) + if (!type_get_function_args(func->declspec.type)) return; - LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry ) + LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->declspec.type), const var_t, entry ) write_remoting_arg( file, indent, func, local_var_prefix, pass, phase, var ); } } @@ -4604,62 +4604,62 @@ void declare_stub_args( FILE *file, int indent, const var_t *func ) { int in_attr, out_attr; int i = 0; - const var_t *var = type_function_get_retval(func->type); + const var_t *var = type_function_get_retval(func->declspec.type); /* declare return value */ - if (!is_void(var->type)) + if (!is_void(var->declspec.type)) { - if (is_context_handle(var->type)) + if (is_context_handle(var->declspec.type)) print_file(file, indent, "NDR_SCONTEXT %s;\n", var->name); else { print_file(file, indent, "%s", ""); - write_type_decl(file, var->type, var->name); + write_type_decl(file, var->declspec.type, var->name); fprintf(file, ";\n"); } } - if (!type_get_function_args(func->type)) + if (!type_get_function_args(func->declspec.type)) return; - LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry ) + LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->declspec.type), const var_t, entry ) { in_attr = is_attr(var->attrs, ATTR_IN); out_attr = is_attr(var->attrs, ATTR_OUT); if (!out_attr && !in_attr) in_attr = 1; - if (is_context_handle(var->type)) + if (is_context_handle(var->declspec.type)) print_file(file, indent, "NDR_SCONTEXT %s;\n", var->name); else { - if (!in_attr && !is_conformant_array(var->type)) + if (!in_attr && !is_conformant_array(var->declspec.type)) { type_t *type_to_print; char name[16]; print_file(file, indent, "%s", ""); - if (type_get_type(var->type) == TYPE_ARRAY && - !type_array_is_decl_as_ptr(var->type)) - type_to_print = var->type; + if (type_get_type(var->declspec.type) == TYPE_ARRAY && + !type_array_is_decl_as_ptr(var->declspec.type)) + type_to_print = var->declspec.type; else - type_to_print = type_pointer_get_ref(var->type); + type_to_print = type_pointer_get_ref(var->declspec.type); sprintf(name, "_W%u", i++); write_type_decl(file, type_to_print, name); fprintf(file, ";\n"); } print_file(file, indent, "%s", ""); - write_type_decl_left(file, var->type); + write_type_decl_left(file, var->declspec.type); fprintf(file, " "); - if (type_get_type(var->type) == TYPE_ARRAY && - !type_array_is_decl_as_ptr(var->type)) { + if (type_get_type(var->declspec.type) == TYPE_ARRAY && + !type_array_is_decl_as_ptr(var->declspec.type)) { fprintf(file, "(*%s)", var->name); } else fprintf(file, "%s", var->name); - write_type_right(file, var->type, FALSE); + write_type_right(file, var->declspec.type, FALSE); fprintf(file, ";\n"); - if (decl_indirect(var->type)) + if (decl_indirect(var->declspec.type)) print_file(file, indent, "void *_p_%s;\n", var->name); } } @@ -4673,10 +4673,10 @@ void assign_stub_out_args( FILE *file, int indent, const var_t *func, const char const var_t *var; type_t *ref; - if (!type_get_function_args(func->type)) + if (!type_get_function_args(func->declspec.type)) return; - LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->type), const var_t, entry ) + LIST_FOR_EACH_ENTRY( var, type_get_function_args(func->declspec.type), const var_t, entry ) { in_attr = is_attr(var->attrs, ATTR_IN); out_attr = is_attr(var->attrs, ATTR_OUT); @@ -4687,7 +4687,7 @@ void assign_stub_out_args( FILE *file, int indent, const var_t *func, const char { print_file(file, indent, "%s%s", local_var_prefix, var->name); - switch (typegen_detect_type(var->type, var->attrs, TDT_IGNORE_STRINGS)) + switch (typegen_detect_type(var->declspec.type, var->attrs, TDT_IGNORE_STRINGS)) { case TGT_CTXT_HANDLE_POINTER: fprintf(file, " = NdrContextHandleInitialize(\n"); @@ -4696,13 +4696,13 @@ void assign_stub_out_args( FILE *file, int indent, const var_t *func, const char var->typestring_offset); break; case TGT_ARRAY: - if (type_array_has_conformance(var->type)) + if (type_array_has_conformance(var->declspec.type)) { unsigned int size; type_t *type; fprintf(file, " = NdrAllocate(&__frame->_StubMsg, "); - for (type = var->type; + for (type = var->declspec.type; is_array(type) && type_array_has_conformance(type); type = type_array_get_element(type)) { @@ -4714,7 +4714,7 @@ void assign_stub_out_args( FILE *file, int indent, const var_t *func, const char fprintf(file, "%u);\n", size); print_file(file, indent, "memset(%s%s, 0, ", local_var_prefix, var->name); - for (type = var->type; + for (type = var->declspec.type; is_array(type) && type_array_has_conformance(type); type = type_array_get_element(type)) { @@ -4730,7 +4730,7 @@ void assign_stub_out_args( FILE *file, int indent, const var_t *func, const char break; case TGT_POINTER: fprintf(file, " = &%s_W%u;\n", local_var_prefix, i); - ref = type_pointer_get_ref(var->type); + ref = type_pointer_get_ref(var->declspec.type); switch (typegen_detect_type(ref, var->attrs, TDT_IGNORE_STRINGS)) { case TGT_BASIC: @@ -4790,7 +4790,7 @@ void write_func_param_struct( FILE *file, const type_t *iface, const type_t *fun if (args) LIST_FOR_EACH_ENTRY( arg, args, const var_t, entry ) - if (!is_array( arg->type )) type_memsize_and_alignment( arg->type, &align ); + if (!is_array( arg->declspec.type )) type_memsize_and_alignment( arg->declspec.type, &align ); needs_packing = (align > pointer_size); @@ -4802,26 +4802,26 @@ void write_func_param_struct( FILE *file, const type_t *iface, const type_t *fun if (args) LIST_FOR_EACH_ENTRY( arg, args, const var_t, entry ) { print_file(file, 2, "%s", ""); - write_type_left( file, (type_t *)arg->type, NAME_DEFAULT, TRUE ); - if (needs_space_after( arg->type )) fputc( ' ', file ); - if (is_array( arg->type ) && !type_array_is_decl_as_ptr( arg->type )) fputc( '*', file ); + write_type_left( file, (type_t *)arg->declspec.type, NAME_DEFAULT, TRUE ); + if (needs_space_after( arg->declspec.type )) fputc( ' ', file ); + if (is_array( arg->declspec.type ) && !type_array_is_decl_as_ptr( arg->declspec.type )) fputc( '*', file ); /* FIXME: should check for large args being passed by pointer */ align = 0; - if (is_array( arg->type ) || is_ptr( arg->type )) align = pointer_size; - else type_memsize_and_alignment( arg->type, &align ); + if (is_array( arg->declspec.type ) || is_ptr( arg->declspec.type )) align = pointer_size; + else type_memsize_and_alignment( arg->declspec.type, &align ); if (align >= pointer_size) fprintf( file, "%s;\n", arg->name ); else fprintf( file, "%s DECLSPEC_ALIGN(%u);\n", arg->name, pointer_size ); } - if (add_retval && !is_void( retval->type )) + if (add_retval && !is_void( retval->declspec.type )) { print_file(file, 2, "%s", ""); - write_type_decl( file, retval->type, retval->name ); - if (is_array( retval->type ) || is_ptr( retval->type ) || - type_memsize( retval->type ) == pointer_size) + write_type_decl( file, retval->declspec.type, retval->name ); + if (is_array( retval->declspec.type ) || is_ptr( retval->declspec.type ) || + type_memsize( retval->declspec.type ) == pointer_size) fprintf( file, ";\n" ); else fprintf( file, " DECLSPEC_ALIGN(%u);\n", pointer_size ); @@ -4833,7 +4833,7 @@ void write_func_param_struct( FILE *file, const type_t *iface, const type_t *fun void write_pointer_checks( FILE *file, int indent, const var_t *func ) { - const var_list_t *args = type_get_function_args( func->type ); + const var_list_t *args = type_get_function_args( func->declspec.type ); const var_t *var; if (!args) return; @@ -4963,9 +4963,9 @@ error: void write_client_call_routine( FILE *file, const type_t *iface, const var_t *func, const char *prefix, unsigned int proc_offset ) { - type_t *rettype = type_function_get_rettype( func->type ); + type_t *rettype = type_function_get_rettype( func->declspec.type ); int has_ret = !is_void( rettype ); - const var_list_t *args = type_get_function_args( func->type ); + const var_list_t *args = type_get_function_args( func->declspec.type ); const var_t *arg; int len, needs_params = 0; @@ -4976,7 +4976,7 @@ void write_client_call_routine( FILE *file, const type_t *iface, const var_t *fu if (needs_params) { if (has_ret) print_file( file, 1, "%s", "CLIENT_CALL_RETURN _RetVal;\n" ); - write_func_param_struct( file, iface, func->type, "__params", FALSE ); + write_func_param_struct( file, iface, func->declspec.type, "__params", FALSE ); if (is_object( iface )) print_file( file, 1, "__params.This = This;\n" ); if (args) LIST_FOR_EACH_ENTRY( arg, args, const var_t, entry ) diff --git a/tools/widl/typetree.c b/tools/widl/typetree.c index b93806be98..3b0c944387 100644 --- a/tools/widl/typetree.c +++ b/tools/widl/typetree.c @@ -137,7 +137,7 @@ type_t *type_new_function(var_list_t *args) if (args) { arg = LIST_ENTRY(list_head(args), var_t, entry); - if (list_count(args) == 1 && !arg->name && arg->type && type_get_type(arg->type) == TYPE_VOID) + if (list_count(args) == 1 && !arg->name && arg->declspec.type && type_get_type(arg->declspec.type) == TYPE_VOID) { list_remove(&arg->entry); free(arg); @@ -147,7 +147,7 @@ type_t *type_new_function(var_list_t *args) } if (args) LIST_FOR_EACH_ENTRY(arg, args, var_t, entry) { - if (arg->type && type_get_type(arg->type) == TYPE_VOID) + if (arg->declspec.type && type_get_type(arg->declspec.type) == TYPE_VOID) error_loc("argument '%s' has void type\n", arg->name); if (!arg->name) { @@ -354,7 +354,7 @@ type_t *type_new_encapsulated_union(char *name, var_t *switch_field, var_t *unio { type_t *t = get_type(TYPE_ENCAPSULATED_UNION, name, NULL, tsUNION); if (!union_field) union_field = make_var( xstrdup("tagged_union") ); - union_field->type = type_new_nonencapsulated_union(NULL, TRUE, cases); + union_field->declspec.type = type_new_nonencapsulated_union(NULL, TRUE, cases); t->details.structure = xmalloc(sizeof(*t->details.structure)); t->details.structure->fields = append_var( NULL, switch_field ); t->details.structure->fields = append_var( t->details.structure->fields, union_field ); @@ -430,7 +430,7 @@ static int compute_method_indexes(type_t *iface) { var_t *func = stmt->u.var; if (!is_callas(func->attrs)) - func->type->details.function->idx = idx++; + func->declspec.type->details.function->idx = idx++; } return idx; diff --git a/tools/widl/typetree.h b/tools/widl/typetree.h index fc134cd575..9f0dc5afc6 100644 --- a/tools/widl/typetree.h +++ b/tools/widl/typetree.h @@ -107,7 +107,7 @@ static inline var_t *type_function_get_retval(const type_t *type) static inline type_t *type_function_get_rettype(const type_t *type) { - return type_function_get_retval(type)->type; + return type_function_get_retval(type)->declspec.type; } static inline var_list_t *type_enum_get_values(const type_t *type) @@ -142,7 +142,7 @@ static inline var_list_t *type_union_get_cases(const type_t *type) if (type_type == TYPE_ENCAPSULATED_UNION) { const var_t *uv = LIST_ENTRY(list_tail(type->details.structure->fields), const var_t, entry); - return uv->type->details.structure->fields; + return uv->declspec.type->details.structure->fields; } else return type->details.structure->fields; diff --git a/tools/widl/widltypes.h b/tools/widl/widltypes.h index 1177c1a00a..31a0cc74dd 100644 --- a/tools/widl/widltypes.h +++ b/tools/widl/widltypes.h @@ -40,6 +40,7 @@ typedef struct _attr_t attr_t; typedef struct _expr_t expr_t; typedef struct _type_t type_t; typedef struct _var_t var_t; +typedef struct _decl_spec_t decl_spec_t; typedef struct _declarator_t declarator_t; typedef struct _ifref_t ifref_t; typedef struct _typelib_entry_t typelib_entry_t; @@ -293,6 +294,13 @@ struct str_list_entry_t struct list entry; }; +struct _decl_spec_t +{ + type_t *type; + attr_list_t *attrs; + enum storage_class stgclass; +}; + struct _attr_t { enum attr_type type; union { @@ -449,10 +457,10 @@ struct _type_t { struct _var_t { char *name; - type_t *type; + decl_spec_t declspec; + attr_list_t *attrs; expr_t *eval; - enum storage_class stgclass; unsigned int procstring_offset; unsigned int typestring_offset; @@ -596,8 +604,8 @@ static inline enum type_type type_get_type_detect_alias(const type_t *type) #define STATEMENTS_FOR_EACH_FUNC(stmt, stmts) \ if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, statement_t, entry ) \ - if (stmt->type == STMT_DECLARATION && stmt->u.var->stgclass == STG_NONE && \ - type_get_type_detect_alias(stmt->u.var->type) == TYPE_FUNCTION) + if (stmt->type == STMT_DECLARATION && stmt->u.var->declspec.stgclass == STG_NONE && \ + type_get_type_detect_alias(stmt->u.var->declspec.type) == TYPE_FUNCTION) static inline int statements_has_func(const statement_list_t *stmts) { @@ -616,4 +624,13 @@ static inline int is_global_namespace(const struct namespace *namespace) return !namespace->name; } +static inline decl_spec_t *init_declspec(decl_spec_t *declspec, type_t *type) +{ + declspec->type = type; + declspec->attrs = NULL; + declspec->stgclass = STG_NONE; + + return declspec; +} + #endif diff --git a/tools/widl/write_msft.c b/tools/widl/write_msft.c index 4dcbc03702..7738cae729 100644 --- a/tools/widl/write_msft.c +++ b/tools/widl/write_msft.c @@ -1301,8 +1301,8 @@ static HRESULT add_func_desc(msft_typeinfo_t* typeinfo, var_t *func, int index) return S_FALSE; } - if (type_get_function_args(func->type)) - LIST_FOR_EACH_ENTRY( arg, type_get_function_args(func->type), var_t, entry ) + if (type_get_function_args(func->declspec.type)) + LIST_FOR_EACH_ENTRY( arg, type_get_function_args(func->declspec.type), var_t, entry ) { num_params++; if (arg->attrs) LIST_FOR_EACH_ENTRY( attr, arg->attrs, const attr_t, entry ) { @@ -1444,7 +1444,7 @@ static HRESULT add_func_desc(msft_typeinfo_t* typeinfo, var_t *func, int index) /* fill out the basic type information */ typedata[0] = typedata_size | (index << 16); - encode_var(typeinfo->typelib, type_function_get_rettype(func->type), func, + encode_var(typeinfo->typelib, type_function_get_rettype(func->declspec.type), func, &typedata[1], &decoded_size); typedata[2] = funcflags; typedata[3] = ((52 /*sizeof(FUNCDESC)*/ + decoded_size) << 16) | typeinfo->typeinfo->cbSizeVft; @@ -1471,10 +1471,10 @@ static HRESULT add_func_desc(msft_typeinfo_t* typeinfo, var_t *func, int index) warning("unknown number of optional attrs\n"); } - if (type_get_function_args(func->type)) + if (type_get_function_args(func->declspec.type)) { i = 0; - LIST_FOR_EACH_ENTRY( arg, type_get_function_args(func->type), var_t, entry ) + LIST_FOR_EACH_ENTRY( arg, type_get_function_args(func->declspec.type), var_t, entry ) { int paramflags = 0; int *paramdata = typedata + 6 + extra_attr + (num_defaults ? num_params : 0) + i * 3; @@ -1482,13 +1482,13 @@ static HRESULT add_func_desc(msft_typeinfo_t* typeinfo, var_t *func, int index) if(defaultdata) *defaultdata = -1; - encode_var(typeinfo->typelib, arg->type, arg, paramdata, &decoded_size); + encode_var(typeinfo->typelib, arg->declspec.type, arg, paramdata, &decoded_size); if (arg->attrs) LIST_FOR_EACH_ENTRY( attr, arg->attrs, const attr_t, entry ) { switch(attr->type) { case ATTR_DEFAULTVALUE: { paramflags |= 0x30; /* PARAMFLAG_FHASDEFAULT | PARAMFLAG_FOPT */ - write_default_value(typeinfo->typelib, arg->type, (expr_t *)attr->u.pval, defaultdata); + write_default_value(typeinfo->typelib, arg->declspec.type, (expr_t *)attr->u.pval, defaultdata); break; } case ATTR_IN: @@ -1572,10 +1572,10 @@ static HRESULT add_func_desc(msft_typeinfo_t* typeinfo, var_t *func, int index) if(typeinfo->typekind == TKIND_MODULE) namedata[9] |= 0x20; - if (type_get_function_args(func->type)) + if (type_get_function_args(func->declspec.type)) { i = 0; - LIST_FOR_EACH_ENTRY( arg, type_get_function_args(func->type), var_t, entry ) + LIST_FOR_EACH_ENTRY( arg, type_get_function_args(func->declspec.type), var_t, entry ) { /* don't give the last arg of a [propput*] func a name */ if(i != num_params - 1 || (invokekind != 0x4 /* INVOKE_PROPERTYPUT */ && invokekind != 0x8 /* INVOKE_PROPERTYPUTREF */)) @@ -1697,8 +1697,8 @@ static HRESULT add_var_desc(msft_typeinfo_t *typeinfo, UINT index, var_t* var) typeinfo->var_offsets[var_num] = offset; /* figure out type widths and whatnot */ - var_datawidth = type_memsize_and_alignment(var->type, &var_alignment); - encode_var(typeinfo->typelib, var->type, var, &typedata[1], &var_type_size); + var_datawidth = type_memsize_and_alignment(var->declspec.type, &var_alignment); + encode_var(typeinfo->typelib, var->declspec.type, var, &typedata[1], &var_type_size); /* pad out starting position to data width */ typeinfo->datawidth += var_alignment - 1; -- 2.17.1

2 18

[PATCH 2/2] winegcc: Always use -nostartfiles when building DLLs.
by Jacek Caban 05 Aug '19

05 Aug '19

So that simplified DllMainCRTStartup version from winecrt0 is used instead of mingw crt. Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- tools/winegcc/winegcc.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)

2 4

[PATCH 1/5] strmbase: Remove unused wine/unicode.h import.
by Zebediah Figura 05 Aug '19

05 Aug '19

Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- dlls/strmbase/strmbase_private.h | 1 - 1 file changed, 1 deletion(-) diff --git a/dlls/strmbase/strmbase_private.h b/dlls/strmbase/strmbase_private.h index 439ab9aefaf..06fbe62a425 100644 --- a/dlls/strmbase/strmbase_private.h +++ b/dlls/strmbase/strmbase_private.h @@ -31,7 +31,6 @@ #include "wine/heap.h" #include "wine/list.h" #include "wine/strmbase.h" -#include "wine/unicode.h" /* Quality Control */ typedef struct QualityControlImpl { -- 2.20.1

2 6

[PATCH] wined3d: Add some graphics cards.
by Kristján Gerhardsson 02 Aug '19

02 Aug '19

Signed-off-by: Kristjan Gerhardsson <kristjang at ccpgames.com> --- dlls/wined3d/directx.c | 7 +++++-- dlls/wined3d/wined3d_private.h | 7 +++++-- 2 files changed, 10 insertions(+), 4 deletions(-) diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index 5975766f16..461ea222ba 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -396,7 +396,8 @@ static const struct wined3d_gpu_description gpu_description_table[] = {HW_VENDOR_AMD, CARD_AMD_RADEON_R9_M395X, "AMD Radeon R9 M395X", DRIVER_AMD_RX, 4096}, {HW_VENDOR_AMD, CARD_AMD_RADEON_RX_460, "Radeon(TM) RX 460 Graphics", DRIVER_AMD_RX, 4096}, {HW_VENDOR_AMD, CARD_AMD_RADEON_RX_480, "Radeon (TM) RX 480 Graphics", DRIVER_AMD_RX, 4096}, - {HW_VENDOR_AMD, CARD_AMD_RADEON_RX_VEGA, "Radeon RX Vega", DRIVER_AMD_RX, 8192}, + {HW_VENDOR_AMD, CARD_AMD_RADEON_RX_VEGA_10, "Radeon RX Vega", DRIVER_AMD_RX, 8192}, + {HW_VENDOR_AMD, CARD_AMD_RADEON_RX_VEGA_20, "Radeon RX Vega 20", DRIVER_AMD_RX, 4096}, /* Red Hat */ {HW_VENDOR_REDHAT, CARD_REDHAT_VIRGL, "Red Hat VirtIO GPU", DRIVER_REDHAT_VIRGL, 1024}, @@ -477,8 +478,10 @@ static const struct wined3d_gpu_description gpu_description_table[] = {HW_VENDOR_INTEL, CARD_INTEL_IP580_2, "Intel(R) Iris(TM) Pro Graphics 580", DRIVER_INTEL_HD4000, 2048}, {HW_VENDOR_INTEL, CARD_INTEL_IPP580_1, "Intel(R) Iris(TM) Pro Graphics P580", DRIVER_INTEL_HD4000, 2048}, {HW_VENDOR_INTEL, CARD_INTEL_IPP580_2, "Intel(R) Iris(TM) Pro Graphics P580", DRIVER_INTEL_HD4000, 2048}, + {HW_VENDOR_INTEL, CARD_INTEL_UHD617, "Intel(R) UHD Graphics 617", DRIVER_INTEL_HD4000, 2048}, {HW_VENDOR_INTEL, CARD_INTEL_HD620, "Intel(R) HD Graphics 620", DRIVER_INTEL_HD4000, 3072}, - {HW_VENDOR_INTEL, CARD_INTEL_HD630, "Intel(R) HD Graphics 630", DRIVER_INTEL_HD4000, 3072}, + {HW_VENDOR_INTEL, CARD_INTEL_HD630_1, "Intel(R) HD Graphics 630", DRIVER_INTEL_HD4000, 3072}, + {HW_VENDOR_INTEL, CARD_INTEL_HD630_2, "Intel(R) HD Graphics 630", DRIVER_INTEL_HD4000, 3072}, }; static const struct driver_version_information *get_driver_version_info(enum wined3d_display_driver driver, diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index a2c81617b6..037434431d 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2378,7 +2378,8 @@ enum wined3d_pci_device CARD_AMD_RADEON_R9_M395X = 0x6920, CARD_AMD_RADEON_RX_460 = 0x67ef, CARD_AMD_RADEON_RX_480 = 0x67df, - CARD_AMD_RADEON_RX_VEGA = 0x687f, + CARD_AMD_RADEON_RX_VEGA_10 = 0x687f, + CARD_AMD_RADEON_RX_VEGA_20 = 0x66af, CARD_NVIDIA_RIVA_128 = 0x0018, CARD_NVIDIA_RIVA_TNT = 0x0020, @@ -2593,8 +2594,10 @@ enum wined3d_pci_device CARD_INTEL_IP580_2 = 0x193b, CARD_INTEL_IPP580_1 = 0x193a, CARD_INTEL_IPP580_2 = 0x193d, + CARD_INTEL_UHD617 = 0x87c0, CARD_INTEL_HD620 = 0x5916, - CARD_INTEL_HD630 = 0x5912, + CARD_INTEL_HD630_1 = 0x5912, + CARD_INTEL_HD630_2 = 0x591b, }; struct wined3d_fbo_ops -- 2.17.0

3 2

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

wine-devel July 2019