wine-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;
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);
  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);
}