tools/widl/register.c

   1 /*
   2  * Generation of dll registration scripts
   3  *
   4  * Copyright 2010 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #ifdef HAVE_UNISTD_H
  27 # include <unistd.h>
  28 #endif
  29 #include <string.h>
  30 #include <ctype.h>
  31
  32 #include "widl.h"
  33 #include "utils.h"
  34 #include "parser.h"
  35 #include "header.h"
  36 #include "typegen.h"
  37 #include "typelib.h"
  38
  39 static int indent;
  40
  41 static const char *format_uuid( const UUID *uuid )
  42 {
  43     static char buffer[40];
  44     sprintf( buffer, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
  45              uuid->Data1, uuid->Data2, uuid->Data3,
  46              uuid->Data4[0], uuid->Data4[1], uuid->Data4[2], uuid->Data4[3],
  47              uuid->Data4[4], uuid->Data4[5], uuid->Data4[6], uuid->Data4[7] );
  48     return buffer;
  49 }
  50
  51 static const char *get_coclass_threading( const type_t *class )
  52 {
  53     static const char * const models[] =
  54     {
  55         NULL,
  56         "Apartment", /* THREADING_APARTMENT */
  57         "Neutral",   /* THREADING_NEUTRAL */
  58         "Single",    /* THREADING_SINGLE */
  59         "Free",      /* THREADING_FREE */
  60         "Both",      /* THREADING_BOTH */
  61     };
  62     return models[get_attrv( class->attrs, ATTR_THREADING )];
  63 }
  64
  65 static const type_t *find_ps_factory( const statement_list_t *stmts )
  66 {
  67     const statement_t *stmt;
  68
  69     if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, const statement_t, entry )
  70     {
  71         if (stmt->type == STMT_TYPE)
  72         {
  73             const type_t *type = stmt->u.type;
  74             if (type_get_type(type) == TYPE_COCLASS && !strcmp( type->name, "PSFactoryBuffer" ))
  75                 return type;
  76         }
  77     }
  78     return NULL;
  79 }
  80
  81 static void write_interface( const type_t *iface, const type_t *ps_factory )
  82 {
  83     const UUID *uuid = get_attrp( iface->attrs, ATTR_UUID );
  84     const UUID *ps_uuid = get_attrp( ps_factory->attrs, ATTR_UUID );
  85
  86     if (!uuid) return;
  87     if (!is_object( iface )) return;
  88     if (!type_iface_get_inherit(iface)) /* special case for IUnknown */
  89     {
  90         put_str( indent, "'%s' = s '%s'\n", format_uuid( uuid ), iface->name );
  91         return;
  92     }
  93     if (is_local( iface->attrs )) return;
  94     put_str( indent, "'%s' = s '%s'\n", format_uuid( uuid ), iface->name );
  95     put_str( indent, "{\n" );
  96     indent++;
  97     put_str( indent, "NumMethods = s %u\n", count_methods( iface ));
  98     put_str( indent, "ProxyStubClsid32 = s '%s'\n", format_uuid( ps_uuid ));
  99     indent--;
 100     put_str( indent, "}\n" );
 101 }
 102
 103 static void write_interfaces( const statement_list_t *stmts, const type_t *ps_factory )
 104 {
 105     const statement_t *stmt;
 106
 107     if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, const statement_t, entry )
 108     {
 109         if (stmt->type == STMT_TYPE && type_get_type( stmt->u.type ) == TYPE_INTERFACE)
 110             write_interface( stmt->u.type, ps_factory );
 111     }
 112 }
 113
 114 static void write_typelib_interface( const type_t *iface, const typelib_t *typelib )
 115 {
 116     const UUID *typelib_uuid = get_attrp( typelib->attrs, ATTR_UUID );
 117     const UUID *uuid = get_attrp( iface->attrs, ATTR_UUID );
 118     unsigned int version = get_attrv( typelib->attrs, ATTR_VERSION );
 119
 120     if (!uuid) return;
 121     if (!is_object( iface )) return;
 122     put_str( indent, "'%s' = s '%s'\n", format_uuid( uuid ), iface->name );
 123     put_str( indent, "{\n" );
 124     indent++;
 125     put_str( indent, "ProxyStubClsid = s '{00020424-0000-0000-C000-000000000046}'\n" );
 126     put_str( indent, "ProxyStubClsid32 = s '{00020424-0000-0000-C000-000000000046}'\n" );
 127     if (version)
 128         put_str( indent, "TypeLib = s '%s' { val Version = s '%u.%u' }\n",
 129                  format_uuid( typelib_uuid ), MAJORVERSION(version), MINORVERSION(version) );
 130     else
 131         put_str( indent, "TypeLib = s '%s'", format_uuid( typelib_uuid ));
 132     indent--;
 133     put_str( indent, "}\n" );
 134 }
 135
 136 static void write_typelib_interfaces( const typelib_t *typelib )
 137 {
 138     unsigned int i;
 139
 140     for (i = 0; i < typelib->reg_iface_count; ++i)
 141         write_typelib_interface( typelib->reg_ifaces[i], typelib );
 142 }
 143
 144 static int write_coclass( const type_t *class, const typelib_t *typelib )
 145 {
 146     const UUID *uuid = get_attrp( class->attrs, ATTR_UUID );
 147     const char *descr = get_attrp( class->attrs, ATTR_HELPSTRING );
 148     const char *progid = get_attrp( class->attrs, ATTR_PROGID );
 149     const char *vi_progid = get_attrp( class->attrs, ATTR_VIPROGID );
 150     const char *threading = get_coclass_threading( class );
 151     unsigned int version = get_attrv( class->attrs, ATTR_VERSION );
 152
 153     if (!uuid) return 0;
 154     if (typelib && !threading && !progid) return 0;
 155     if (!descr) descr = class->name;
 156
 157     put_str( indent, "'%s' = s '%s'\n", format_uuid( uuid ), descr );
 158     put_str( indent++, "{\n" );
 159     if (threading) put_str( indent, "InprocServer32 = s '%%MODULE%%' { val ThreadingModel = s '%s' }\n",
 160                             threading );
 161     if (progid) put_str( indent, "ProgId = s '%s'\n", progid );
 162     if (typelib)
 163     {
 164         const UUID *typelib_uuid = get_attrp( typelib->attrs, ATTR_UUID );
 165         put_str( indent, "TypeLib = s '%s'\n", format_uuid( typelib_uuid ));
 166         if (!version) version = get_attrv( typelib->attrs, ATTR_VERSION );
 167     }
 168     if (version) put_str( indent, "Version = s '%u.%u'\n", MAJORVERSION(version), MINORVERSION(version) );
 169     if (vi_progid) put_str( indent, "VersionIndependentProgId = s '%s'\n", vi_progid );
 170     put_str( --indent, "}\n" );
 171     return 1;
 172 }
 173
 174 static void write_coclasses( const statement_list_t *stmts, const typelib_t *typelib )
 175 {
 176     const statement_t *stmt;
 177
 178     if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, const statement_t, entry )
 179     {
 180         if (stmt->type == STMT_TYPE)
 181         {
 182             const type_t *type = stmt->u.type;
 183             if (type_get_type(type) == TYPE_COCLASS) write_coclass( type, typelib );
 184         }
 185     }
 186 }
 187
 188 static void write_runtimeclasses_registry( const statement_list_t *stmts )
 189 {
 190     const statement_t *stmt;
 191     const type_t *type;
 192
 193     if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, const statement_t, entry )
 194     {
 195         if (stmt->type != STMT_TYPE) continue;
 196         if (type_get_type((type = stmt->u.type)) != TYPE_RUNTIMECLASS) continue;
 197         put_str( indent, "ForceRemove %s\n", format_namespace( type->namespace, "", ".", type->name, NULL ) );
 198         put_str( indent++, "{\n" );
 199         put_str( indent, "val 'DllPath' = s '%%MODULE%%'\n" );
 200         put_str( --indent, "}\n" );
 201     }
 202 }
 203
 204 static int write_progid( const type_t *class )
 205 {
 206     const UUID *uuid = get_attrp( class->attrs, ATTR_UUID );
 207     const char *descr = get_attrp( class->attrs, ATTR_HELPSTRING );
 208     const char *progid = get_attrp( class->attrs, ATTR_PROGID );
 209     const char *vi_progid = get_attrp( class->attrs, ATTR_VIPROGID );
 210
 211     if (!uuid) return 0;
 212     if (!descr) descr = class->name;
 213
 214     if (progid)
 215     {
 216         put_str( indent, "'%s' = s '%s'\n", progid, descr );
 217         put_str( indent++, "{\n" );
 218         put_str( indent, "CLSID = s '%s'\n", format_uuid( uuid ) );
 219         put_str( --indent, "}\n" );
 220     }
 221     if (vi_progid)
 222     {
 223         put_str( indent, "'%s' = s '%s'\n", vi_progid, descr );
 224         put_str( indent++, "{\n" );
 225         put_str( indent, "CLSID = s '%s'\n", format_uuid( uuid ) );
 226         if (progid && strcmp( progid, vi_progid )) put_str( indent, "CurVer = s '%s'\n", progid );
 227         put_str( --indent, "}\n" );
 228     }
 229     return 1;
 230 }
 231
 232 static void write_progids( const statement_list_t *stmts )
 233 {
 234     const statement_t *stmt;
 235
 236     if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, const statement_t, entry )
 237     {
 238         if (stmt->type == STMT_TYPE)
 239         {
 240             const type_t *type = stmt->u.type;
 241             if (type_get_type(type) == TYPE_COCLASS) write_progid( type );
 242         }
 243     }
 244 }
 245
 246 void write_regscript( const statement_list_t *stmts )
 247 {
 248     const type_t *ps_factory;
 249
 250     if (!do_regscript) return;
 251     if (do_everything && !need_proxy_file( stmts )) return;
 252
 253     init_output_buffer();
 254
 255     if (winrt_mode)
 256     {
 257         put_str( indent, "HKLM\n" );
 258         put_str( indent++, "{\n" );
 259         put_str( indent, "NoRemove Software\n" );
 260         put_str( indent++, "{\n" );
 261         put_str( indent, "NoRemove Microsoft\n" );
 262         put_str( indent++, "{\n" );
 263         put_str( indent, "NoRemove WindowsRuntime\n" );
 264         put_str( indent++, "{\n" );
 265         put_str( indent, "NoRemove ActivatableClassId\n" );
 266         put_str( indent++, "{\n" );
 267         write_runtimeclasses_registry( stmts );
 268         put_str( --indent, "}\n" );
 269         put_str( --indent, "}\n" );
 270         put_str( --indent, "}\n" );
 271         put_str( --indent, "}\n" );
 272         put_str( --indent, "}\n" );
 273     }
 274     else
 275     {
 276         put_str( indent, "HKCR\n" );
 277         put_str( indent++, "{\n" );
 278
 279         put_str( indent, "NoRemove Interface\n" );
 280         put_str( indent++, "{\n" );
 281         ps_factory = find_ps_factory( stmts );
 282         if (ps_factory) write_interfaces( stmts, ps_factory );
 283         put_str( --indent, "}\n" );
 284
 285         put_str( indent, "NoRemove CLSID\n" );
 286         put_str( indent++, "{\n" );
 287         write_coclasses( stmts, NULL );
 288         put_str( --indent, "}\n" );
 289
 290         write_progids( stmts );
 291         put_str( --indent, "}\n" );
 292     }
 293
 294     if (strendswith( regscript_name, ".res" ))  /* create a binary resource file */
 295     {
 296         add_output_to_resources( "WINE_REGISTRY", regscript_token );
 297         flush_output_resources( regscript_name );
 298     }
 299     else
 300     {
 301         FILE *f = fopen( regscript_name, "w" );
 302         if (!f) error( "Could not open %s for output\n", regscript_name );
 303         if (fwrite( output_buffer, 1, output_buffer_pos, f ) != output_buffer_pos)
 304             error( "Failed to write to %s\n", regscript_name );
 305         if (fclose( f ))
 306             error( "Failed to write to %s\n", regscript_name );
 307     }
 308 }
 309
 310 void write_typelib_regscript( const statement_list_t *stmts )
 311 {
 312     const statement_t *stmt;
 313     unsigned int count = 0;
 314
 315     if (!do_typelib) return;
 316     if (stmts) LIST_FOR_EACH_ENTRY( stmt, stmts, const statement_t, entry )
 317     {
 318         if (stmt->type != STMT_LIBRARY) continue;
 319         if (count && !strendswith( typelib_name, ".res" ))
 320             error( "Cannot store multiple typelibs into %s\n", typelib_name );
 321         else
 322             create_msft_typelib( stmt->u.lib );
 323         count++;
 324     }
 325     if (count && strendswith( typelib_name, ".res" )) flush_output_resources( typelib_name );
 326 }
 327
 328 void output_typelib_regscript( const typelib_t *typelib )
 329 {
 330     const UUID *typelib_uuid = get_attrp( typelib->attrs, ATTR_UUID );
 331     const char *descr = get_attrp( typelib->attrs, ATTR_HELPSTRING );
 332     const expr_t *lcid_expr = get_attrp( typelib->attrs, ATTR_LIBLCID );
 333     unsigned int version = get_attrv( typelib->attrs, ATTR_VERSION );
 334     unsigned int flags = 0;
 335     char id_part[12] = "";
 336     char *resname = typelib_name;
 337     expr_t *expr;
 338
 339     if (is_attr( typelib->attrs, ATTR_RESTRICTED )) flags |= 1; /* LIBFLAG_FRESTRICTED */
 340     if (is_attr( typelib->attrs, ATTR_CONTROL )) flags |= 2; /* LIBFLAG_FCONTROL */
 341     if (is_attr( typelib->attrs, ATTR_HIDDEN )) flags |= 4; /* LIBFLAG_FHIDDEN */
 342
 343     put_str( indent, "HKCR\n" );
 344     put_str( indent++, "{\n" );
 345
 346     put_str( indent, "NoRemove Typelib\n" );
 347     put_str( indent++, "{\n" );
 348     put_str( indent, "NoRemove '%s'\n", format_uuid( typelib_uuid ));
 349     put_str( indent++, "{\n" );
 350     put_str( indent, "'%u.%u' = s '%s'\n",
 351              MAJORVERSION(version), MINORVERSION(version), descr ? descr : typelib->name );
 352     put_str( indent++, "{\n" );
 353     expr = get_attrp( typelib->attrs, ATTR_ID );
 354     if (expr)
 355     {
 356         sprintf(id_part, "\\%d", expr->cval);
 357         resname = strmake("%s\\%d", typelib_name, expr->cval);
 358     }
 359     put_str( indent, "'%x' { %s = s '%%MODULE%%%s' }\n",
 360              lcid_expr ? lcid_expr->cval : 0, pointer_size == 8 ? "win64" : "win32", id_part );
 361     put_str( indent, "FLAGS = s '%u'\n", flags );
 362     put_str( --indent, "}\n" );
 363     put_str( --indent, "}\n" );
 364     put_str( --indent, "}\n" );
 365
 366     put_str( indent, "NoRemove Interface\n" );
 367     put_str( indent++, "{\n" );
 368     write_typelib_interfaces( typelib );
 369     put_str( --indent, "}\n" );
 370
 371     put_str( indent, "NoRemove CLSID\n" );
 372     put_str( indent++, "{\n" );
 373     write_coclasses( typelib->stmts, typelib );
 374     put_str( --indent, "}\n" );
 375
 376     write_progids( typelib->stmts );
 377     put_str( --indent, "}\n" );
 378
 379     add_output_to_resources( "WINE_REGISTRY", resname );
 380 }