| /* |
| * IDL Compiler |
| * |
| * Copyright 2004 Ove Kaaven |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| */ |
| |
| #include "config.h" |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <unistd.h> |
| #include <string.h> |
| #include <assert.h> |
| #include <ctype.h> |
| #include <signal.h> |
| |
| #include "widl.h" |
| #include "utils.h" |
| #include "parser.h" |
| #include "header.h" |
| #include "typelib.h" |
| |
| int in_typelib = 0; |
| |
| static typelib_t *typelib; |
| |
| /* List of oleauto types that should be recognized by name. |
| * (most of) these seem to be intrinsic types in mktyplib. */ |
| |
| static struct oatype { |
| const char *kw; |
| unsigned short vt; |
| } oatypes[] = { |
| {"BSTR", VT_BSTR}, |
| {"CURRENCY", VT_CY}, |
| {"DATE", VT_DATE}, |
| {"DECIMAL", VT_DECIMAL}, |
| {"HRESULT", VT_HRESULT}, |
| {"LPSTR", VT_LPSTR}, |
| {"LPWSTR", VT_LPWSTR}, |
| {"SCODE", VT_ERROR}, |
| {"VARIANT", VT_VARIANT}, |
| {"VARIANT_BOOL", VT_BOOL} |
| }; |
| #define NTYPES (sizeof(oatypes)/sizeof(oatypes[0])) |
| #define KWP(p) ((const struct oatype *)(p)) |
| |
| static int kw_cmp_func(const void *s1, const void *s2) |
| { |
| return strcmp(KWP(s1)->kw, KWP(s2)->kw); |
| } |
| |
| static unsigned short builtin_vt(const char *kw) |
| { |
| struct oatype key, *kwp; |
| key.kw = kw; |
| #ifdef KW_BSEARCH |
| kwp = bsearch(&key, oatypes, NTYPES, sizeof(oatypes[0]), kw_cmp_func); |
| #else |
| { |
| unsigned int i; |
| for (kwp=NULL, i=0; i < NTYPES; i++) |
| if (!kw_cmp_func(&key, &oatypes[i])) { |
| kwp = &oatypes[i]; |
| break; |
| } |
| } |
| #endif |
| if (kwp) { |
| return kwp->vt; |
| } |
| return 0; |
| } |
| |
| static int match(const char*n, const char*m) |
| { |
| if (!n) return 0; |
| return !strcmp(n, m); |
| } |
| |
| unsigned short get_type_vt(type_t *t) |
| { |
| unsigned short vt; |
| |
| chat("get_type_vt: %p type->name %s\n", t, t->name); |
| if (t->name) { |
| vt = builtin_vt(t->name); |
| if (vt) return vt; |
| } |
| |
| switch (t->type) { |
| case RPC_FC_BYTE: |
| case RPC_FC_USMALL: |
| return VT_UI1; |
| case RPC_FC_CHAR: |
| case RPC_FC_SMALL: |
| return VT_I1; |
| case RPC_FC_WCHAR: |
| return VT_I2; /* mktyplib seems to parse wchar_t as short */ |
| case RPC_FC_SHORT: |
| return VT_I2; |
| case RPC_FC_USHORT: |
| return VT_UI2; |
| case RPC_FC_LONG: |
| if (t->ref && match(t->ref->name, "int")) return VT_INT; |
| return VT_I4; |
| case RPC_FC_ULONG: |
| if (t->ref && match(t->ref->name, "int")) return VT_UINT; |
| return VT_UI4; |
| case RPC_FC_HYPER: |
| if (t->sign < 0) return VT_UI8; |
| if (t->ref && match(t->ref->name, "MIDL_uhyper")) return VT_UI8; |
| return VT_I8; |
| case RPC_FC_FLOAT: |
| return VT_R4; |
| case RPC_FC_DOUBLE: |
| return VT_R8; |
| case RPC_FC_RP: |
| case RPC_FC_UP: |
| case RPC_FC_OP: |
| case RPC_FC_FP: |
| if(t->ref) |
| return VT_PTR; |
| |
| error("get_type_vt: unknown-deref-type: %d\n", t->ref->type); |
| break; |
| case RPC_FC_IP: |
| if(match(t->name, "IUnknown")) |
| return VT_UNKNOWN; |
| if(match(t->name, "IDispatch")) |
| return VT_DISPATCH; |
| return VT_USERDEFINED; |
| |
| case RPC_FC_ENUM16: |
| case RPC_FC_STRUCT: |
| case RPC_FC_PSTRUCT: |
| case RPC_FC_CSTRUCT: |
| case RPC_FC_CPSTRUCT: |
| case RPC_FC_CVSTRUCT: |
| case RPC_FC_BOGUS_STRUCT: |
| return VT_USERDEFINED; |
| case 0: |
| if(t->attrs) |
| return VT_USERDEFINED; |
| return 0; |
| default: |
| error("get_type_vt: unknown type: 0x%02x\n", t->type); |
| } |
| return 0; |
| } |
| |
| unsigned short get_var_vt(var_t *v) |
| { |
| unsigned short vt; |
| |
| chat("get_var_vt: %p tname %s\n", v, v->tname); |
| if (v->tname) { |
| vt = builtin_vt(v->tname); |
| if (vt) return vt; |
| } |
| |
| return get_type_vt(v->type); |
| } |
| |
| void start_typelib(char *name, attr_t *attrs) |
| { |
| in_typelib++; |
| if (!do_typelib) return; |
| |
| typelib = xmalloc(sizeof(*typelib)); |
| typelib->name = xstrdup(name); |
| typelib->filename = xstrdup(typelib_name); |
| typelib->attrs = attrs; |
| } |
| |
| void end_typelib(void) |
| { |
| in_typelib--; |
| if (!typelib) return; |
| |
| create_msft_typelib(typelib); |
| return; |
| } |
| |
| void add_interface(type_t *iface) |
| { |
| typelib_entry_t *entry; |
| if (!typelib) return; |
| |
| chat("add interface: %s\n", iface->name); |
| entry = xmalloc(sizeof(*entry)); |
| entry->kind = TKIND_INTERFACE; |
| entry->u.interface = iface; |
| LINK(entry, typelib->entry); |
| typelib->entry = entry; |
| } |
| |
| void add_coclass(class_t *cls) |
| { |
| typelib_entry_t *entry; |
| |
| if (!typelib) return; |
| |
| chat("add coclass: %s\n", cls->name); |
| |
| entry = xmalloc(sizeof(*entry)); |
| entry->kind = TKIND_COCLASS; |
| entry->u.class = cls; |
| LINK(entry, typelib->entry); |
| typelib->entry = entry; |
| } |
| |
| void add_module(type_t *module) |
| { |
| typelib_entry_t *entry; |
| if (!typelib) return; |
| |
| chat("add module: %s\n", module->name); |
| entry = xmalloc(sizeof(*entry)); |
| entry->kind = TKIND_MODULE; |
| entry->u.module = module; |
| LINK(entry, typelib->entry); |
| typelib->entry = entry; |
| } |
| |
| void add_struct(type_t *structure) |
| { |
| typelib_entry_t *entry; |
| if (!typelib) return; |
| |
| chat("add struct: %s\n", structure->name); |
| entry = xmalloc(sizeof(*entry)); |
| entry->kind = TKIND_RECORD; |
| entry->u.structure = structure; |
| LINK(entry, typelib->entry); |
| typelib->entry = entry; |
| } |
| |
| void add_enum(type_t *enumeration) |
| { |
| typelib_entry_t *entry; |
| if (!typelib) return; |
| |
| chat("add enum: %s\n", enumeration->name); |
| entry = xmalloc(sizeof(*entry)); |
| entry->kind = TKIND_ENUM; |
| entry->u.enumeration = enumeration; |
| LINK(entry, typelib->entry); |
| typelib->entry = entry; |
| } |
| |
| void add_typedef(type_t *tdef, var_t *name) |
| { |
| typelib_entry_t *entry; |
| if (!typelib) return; |
| |
| entry = xmalloc(sizeof(*entry)); |
| entry->kind = TKIND_ALIAS; |
| entry->u.tdef = xmalloc(sizeof(*entry->u.tdef)); |
| memcpy(entry->u.tdef, name, sizeof(*name)); |
| entry->u.tdef->type = tdef; |
| entry->u.tdef->name = xstrdup(name->name); |
| LINK(entry, typelib->entry); |
| typelib->entry = entry; |
| } |