wine/dlls/rpcrt4/tests/server.idl

/*
 * A simple interface to test the RPC server.
 *
 * Copyright (C) Google 2007 (Dan Hipschman)
 *
 * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

#pragma makedep client
#pragma makedep server

import "objidl.idl";

#include "server_defines.h"

#ifndef IFACE_NAME
#define IFACE_NAME IMixedServer
#endif

#ifndef IFACE_HANDLE
#define IFACE_HANDLE IMixedServer_IfHandle
#endif

#ifndef ISERVER_UUID
#define ISERVER_UUID 00000000-4114-0704-2301-000000000000
#endif

cpp_quote("#ifndef SKIP_TYPE_DECLS")
typedef struct tag_vector
{
  int x;
  int y;
  int z;
} vector_t;

typedef int fnprintf(const char *format, ...);
cpp_quote("#endif")

[
  uuid(ISERVER_UUID),
  implicit_handle(handle_t IFACE_HANDLE)
]
interface IFACE_NAME
{
cpp_quote("#if 0")
  typedef wchar_t WCHAR;
cpp_quote("#endif")

cpp_quote("#ifndef SKIP_TYPE_DECLS")
  typedef [string] char *str_t;
  typedef [string] WCHAR *wstr_t;

  typedef struct
  {
    int *pi;
    int **ppi;
    int ***pppi;
  } pints_t;

  typedef struct
  {
    char *pc;
    short *ps;
    long *pl;
    float *pf;
    double *pd;
  } ptypes_t;

  typedef struct
  {
    vector_t *pu;
    vector_t **pv;
  } pvectors_t;

  typedef struct
  {
    [switch_is(s)] union
    {
      [case(SUN_I)] int i;
      [case(SUN_F1, SUN_F2)] float f;
      [case(SUN_PI)] int *pi;
    } u;

    int s;
  } sun_t;

  typedef struct
  {
    signed char a, b, c, d, e;
  } chars_t;

  typedef struct
  {
    int i;
    hyper j;
  } ints_t;

  typedef struct
  {
    int i;
    float f;
  } flts_t;

  typedef struct
  {
    int i;
    double d;
  } dbls_t;
cpp_quote("#endif")

  int int_return(void);
  int square(int x);
  int sum(int x, int y);
  signed char sum_char(signed char x, signed char y);
  short sum_short(short x, short y);
  int sum_float(float x, float y);
  int sum_double_int(int x, double y);
  hyper sum_hyper(hyper x, hyper y);
  int sum_hyper_int(hyper x, hyper y);
  int sum_char_hyper(signed char x, hyper y);
  int sum_ints(int a, ints_t x, ints_t y);
  int sum_chars(int a, chars_t x, chars_t y);
  int sum_flts(int a, flts_t x, flts_t y);
  int sum_dbls(int a, dbls_t x, dbls_t y);
  int sum_iiff(int x0, int y0, float x1, float y1);
  int sum_ifif(int x0, float y0, int x1, float y1);
  int sum_iidd(int x0, int y0, double x1, double y1);
  int sum_idid(int x0, double y0, int x1, double y1);
  int sum_ififififififif(int x0, float y0, int x1, float y1, int x2, float y2, int x3, float y3, int x4, float y4, int x5, float y5, int x6, float y6);
  int sum_ididididididid(int x0, double y0, int x1, double y1, int x2, double y2, int x3, double y3, int x4, double y4, int x5, double y5, int x6, double y6);
  int sum_idfdifdfifdfidifdidf(int x0, double y0, float z0, double y1, int x1, float z1, double y2, float z2, int x2, float z3, double y3, float z4, int x3, double y4, int x4, float z5, double y5, int x5, double y6, float z6);
  int sum_ididididididididididid(int x0, double y0, int x1, double y1, int x2, double y2, int x3, double y3, int x4, double y4, int x5, double y5, int x6, double y6, int x7, double y7, int x8, double y8);
  int sum_iidiidiidiidiidiidiidiidiidiidiid(int x0, int x1, double y0, int x2, int x3, double y1, int x4, int x5, double y2, int x6, int x7, double y3, int x8, int x9, double y4, int x10, int x11, double y5, int x12, int x13, double y6, int x14, int x15, double y7, int x16, int x17, double y8);
  int sum_iyiy(int x0, hyper y0, int x1, hyper y1);
  void square_out(int x, [out] int *y);
  void square_ref([in, out] int *x);
  int str_length([string] const char *s);
  int str_t_length(str_t s);
  int cstr_length([string, size_is(n)] const char *s, int n);
  int dot_self(vector_t *v);
  double square_half(double x, [out] double *y);
  float square_half_float(float x, [out] float *y);
  long square_half_long(long x, [out] long *y);
  int sum_fixed_array(int a[5]);
  int pints_sum(pints_t *pints);
  double ptypes_sum(ptypes_t *ptypes);
  int dot_pvectors(pvectors_t *pvectors);

cpp_quote("#ifndef SKIP_TYPE_DECLS")
  /* don't use this anywhere except in sp_t */
  typedef struct
  {
    int x;
  } sp_inner_t;

  typedef struct
  {
    int x;
    sp_inner_t *s;
  } sp_t;
cpp_quote("#endif")

  int sum_sp(sp_t *sp);
  double square_sun(sun_t *su);

cpp_quote("#ifndef SKIP_TYPE_DECLS")
  typedef struct test_list
  {
    int t;
    [switch_is(t)] union
    {
      [case(TL_NULL)] char x;  /* end of list */
      [case(TL_LIST)] struct test_list *tail;
    } u;
  } test_list_t;

  typedef [ref] int *refpint_t;
cpp_quote("#endif")

  int test_list_length(test_list_t *ls);
  int sum_fixed_int_3d(int m[2][3][4]);
  int sum_conf_array([size_is(n)] int x[], int n);
  int sum_conf_ptr_by_conf_ptr(int n1, [size_is(n1)] int *n2_then_x1, [size_is(*n2_then_x1)] int *x2);
  int sum_unique_conf_array([size_is(n), unique] int x[], int n);
  int sum_unique_conf_ptr([size_is(n), unique] int *x, int n);
  int sum_var_array([length_is(n)] int x[20], int n);
  int dot_two_vectors(vector_t vs[2]);
  void get_number_array([out, length_is(*n)] int x[20], [out] int *n);

cpp_quote("#ifndef SKIP_TYPE_DECLS")
  typedef struct
  {
    int n;
    [size_is(n)] int ca[];
  } cs_t;

  typedef struct
  {
    int n;
    [size_is(n)] int *ca;
  } cs_blob_t;

  typedef struct
  {
/* FIXME: widl generates incorrect correlation descriptor and the tests crash */
#if 0
    int dummy[1]; /* to make offset to conformant array unique */
#endif
    cs_blob_t blob;
  } cs_data_t;

  typedef struct
  {
/* FIXME: widl generates incorrect correlation descriptor and the tests crash */
#if 0
    int dummy[2]; /* to make offset to conformant array unique */
#endif
    cs_data_t data;
  } cs_container_t;

  typedef struct
  {
    int *pn;
    [size_is(*pn)] int *ca1;
    [size_is(n * 2)] int *ca2;
    int n;
  } cps_t;

  typedef struct
  {
    [size_is(c ? a : b)] int *ca;
    int a;
    int b;
    int c;
  } cpsc_t;
cpp_quote("#endif")

  int sum_cs(cs_t *cs);
  int sum_cps(cps_t *cps);
  int sum_cpsc(cpsc_t *cpsc);
  int get_cpsc(int n, [out] cpsc_t *cpsc );
  int sum_complex_array(int n, [size_is(n)] refpint_t pi[]);
  int sum_blob([in] cs_blob_t *blob);
  int sum_data([in] cs_data_t *data);
  int sum_container([in] cs_container_t *container);

cpp_quote("#ifndef SKIP_TYPE_DECLS")
  typedef [wire_marshal(int)] void *puint_t;
cpp_quote("#endif")
  int square_puint(puint_t p);

cpp_quote("#ifndef SKIP_TYPE_DECLS")
  typedef struct
  {
    [size_is(n)] puint_t *ps;
    int n;
  } puints_t;

  /* Same thing as puints_t, but make it complex (needs padding).  */
  typedef struct
  {
    [size_is(n)] puint_t *ps;
    char n;
  } cpuints_t;
cpp_quote("#endif")

  int sum_puints(puints_t *p);
  int sum_cpuints(cpuints_t *p);
  int dot_copy_vectors(vector_t u, vector_t v);

cpp_quote("#ifndef SKIP_TYPE_DECLS")
  typedef struct wire_us *wire_us_t;
  typedef [wire_marshal(wire_us_t)] struct us us_t;
  struct us
  {
    void *x;
  };
  struct wire_us
  {
    int x;
  };
  typedef struct
  {
    us_t us;
  } test_us_t;
cpp_quote("#endif")

  int square_test_us(test_us_t *tus);

cpp_quote("#ifndef SKIP_TYPE_DECLS")
  typedef union encu switch (int t)
  {
  case ENCU_I: int i;
  case ENCU_F: float f;
  } encu_t;

  typedef [switch_type(int)] union unencu
  {
    [case (ENCU_I)] int i;
    [case (ENCU_F)] float f;
  } unencu_t;

  typedef enum
  {
    E1 = 23,
    E2 = 4,
    E3 = 0,
    E4 = 64
  } e_t;

  typedef union encue switch (e_t t)
  {
  case E1: int i1;
  case E2: float f2;
  } encue_t;

  typedef struct
  {
    e_t f;
  } se_t;
cpp_quote("#endif")

  double square_encu(encu_t *eu);
  double square_unencu(int t, [switch_is(t)] unencu_t *eu);
  int sum_parr(int *a[3]);
  int sum_pcarr([size_is(n)] int *a[], int n);
  int enum_ord(e_t e);
  double square_encue(encue_t *eue);
  void check_se2(se_t *s);

  int sum_toplev_conf_2n([size_is(n * 2)] int *x, int n);
  int sum_toplev_conf_cond([size_is(c ? a : b)] int *x, int a, int b, int c);

cpp_quote("#ifndef SKIP_TYPE_DECLS")
  typedef struct
  {
    char c;
    int i;
    short s;
    double d;
  } aligns_t;
cpp_quote("#endif")

  double sum_aligns(aligns_t *a);

cpp_quote("#ifndef SKIP_TYPE_DECLS")
  typedef struct
  {
    int i;
    char c;
  } padded_t;
cpp_quote("#endif")

  int sum_padded(padded_t *p);
  int sum_padded2(padded_t ps[2]);
  int sum_padded_conf([size_is(n)] padded_t *ps, int n);

cpp_quote("#ifndef SKIP_TYPE_DECLS")
  typedef struct
  {
    int *p1;
  } bogus_helper_t;

  typedef struct
  {
    bogus_helper_t h;
    int *p2;
    int *p3;
    char c;
  } bogus_t;
cpp_quote("#endif")

  int sum_bogus(bogus_t *b);
  void check_null([unique] int *null);

cpp_quote("#ifndef SKIP_TYPE_DECLS")
  typedef struct
  {
    str_t s;
  } str_struct_t;

  typedef struct
  {
    wstr_t s;
  } wstr_struct_t;
cpp_quote("#endif")

  int str_struct_len(str_struct_t *s);
  int wstr_struct_len(wstr_struct_t *s);

cpp_quote("#ifndef SKIP_TYPE_DECLS")
  typedef struct
  {
    unsigned int n;
    [size_is(n)] byte a[];
  } doub_carr_1_t;

  typedef struct
  {
    int n;
    [size_is(n)] doub_carr_1_t *a[];
  } doub_carr_t;
cpp_quote("#endif")

  int sum_doub_carr(doub_carr_t *dc);
  void make_pyramid_doub_carr(unsigned char n, [out] doub_carr_t **dc);

cpp_quote("#ifndef SKIP_TYPE_DECLS")
  typedef struct
  {
    short n;
    [size_is(n)] short data[];
  } user_bstr_t;

  typedef [unique] user_bstr_t *wire_bstr_t;
  typedef [wire_marshal(wire_bstr_t)] short *bstr_t;
cpp_quote("#endif")
  unsigned hash_bstr(bstr_t s);
  void get_a_bstr([out]bstr_t *s);
cpp_quote("#ifndef SKIP_TYPE_DECLS")
  typedef struct
  {
    [string, size_is(size)] char *name;
    unsigned int size;
  } name_t;
cpp_quote("#endif")
  void get_name([in,out] name_t *name);

cpp_quote("#ifndef SKIP_TYPE_DECLS")
  typedef char **str_array_t;
  typedef WCHAR **wstr_array_t;
cpp_quote("#endif")
  void get_names([out] int *n, [out, string, size_is(,*n)] str_array_t *names);
  void get_namesw([out] int *n, [out, string, size_is(,*n)] wstr_array_t *names);

  int sum_pcarr2(int n, [size_is(, n)] int **pa);
  int sum_L1_norms(int n, [size_is(n)] vector_t *vs);

cpp_quote("#ifndef SKIP_TYPE_DECLS")
  /* Don't use this except in the get_s123 test.  */
  typedef struct
  {
    int f1;
    int f2;
    int f3;
  } s123_t;
cpp_quote("#endif")

  /* Make sure WIDL generates a type format string for a previously unseen
     type as a return value.  */
  s123_t *get_s123(void);

cpp_quote("#ifndef SKIP_TYPE_DECLS")
  typedef struct
  {
    unsigned int length;
    unsigned int size;
    [size_is(size), length_is(length)] pints_t numbers[];
  } numbers_struct_t;
cpp_quote("#endif")

  void get_numbers([in] int length, [in] int size, [out, length_is(length), size_is(size)] pints_t pn[]);
  void get_numbers_struct([out] numbers_struct_t **ns);

  str_t get_filename(void);

cpp_quote("#ifndef SKIP_TYPE_DECLS")
  enum renum
  {
    RE0,
    RE1,
    RE2,
    RE3,
  };
  const int RE_MIN = RE0;
  const int RE_MAX = RE3;
  typedef [range(RE_MIN, RE_MAX)] enum renum renum_t;
  typedef [range(0, 100)] int rint_t;
cpp_quote("#endif")
  rint_t echo_ranged_int([range(0, 10)] int i, [range(0, 20)] int j, [range(0, 100)] int k);
  rint_t echo_ranged_int2([range(0, 40)] int i);
  void get_ranged_enum([out] renum_t *re);

  void context_handle_test(void);

  void full_pointer_test([in, ptr] int *a, [in, ptr] int *b);
  void full_pointer_null_test([in, ptr] int *a, [in, ptr] int *b);

  void authinfo_test(unsigned int protseq, int secure);

  void stop(void);
  void stop_autolisten(void);

cpp_quote("#ifndef SKIP_TYPE_DECLS")
  typedef union ipu switch(int t)
  {
    default: IStream *stream;
  } ipu_t;
cpp_quote("#endif")

  void ip_test([in] ipu_t *a);

  int sum_ptr_array([in] int *a[2]);
  int sum_array_ptr([in] int (*a)[2]);

cpp_quote("#ifndef SKIP_TYPE_DECLS")
  typedef [context_handle] void *ctx_handle_t;
cpp_quote("#endif")

  ctx_handle_t get_handle();
  void get_handle_by_ptr([out] ctx_handle_t *r);
  void test_handle(ctx_handle_t ctx_handle);

  void test_I_RpcBindingInqLocalClientPID([in] unsigned int protseq, [in] handle_t binding);
}