mirror of
https://github.com/reactos/reactos.git
synced 2024-08-20 10:23:22 +00:00
387 lines
8.3 KiB
Plaintext
387 lines
8.3 KiB
Plaintext
/*
|
|
* 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
|
|
|
|
#include "server_defines.h"
|
|
|
|
typedef struct tag_vector
|
|
{
|
|
int x;
|
|
int y;
|
|
int z;
|
|
} vector_t;
|
|
|
|
typedef int fnprintf(const char *format, ...);
|
|
|
|
[
|
|
uuid(00000000-4114-0704-2301-000000000000),
|
|
implicit_handle(handle_t IServer_IfHandle)
|
|
]
|
|
interface IServer
|
|
{
|
|
cpp_quote("#if 0")
|
|
typedef wchar_t WCHAR;
|
|
cpp_quote("#endif")
|
|
|
|
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;
|
|
|
|
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);
|
|
|
|
/* 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;
|
|
|
|
int sum_sp(sp_t *sp);
|
|
double square_sun(sun_t *su);
|
|
|
|
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;
|
|
|
|
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);
|
|
|
|
typedef struct
|
|
{
|
|
int n;
|
|
[size_is(n)] int ca[];
|
|
} cs_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;
|
|
|
|
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[]);
|
|
|
|
typedef [wire_marshal(int)] void *puint_t;
|
|
int square_puint(puint_t p);
|
|
|
|
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;
|
|
|
|
int sum_puints(puints_t *p);
|
|
int sum_cpuints(cpuints_t *p);
|
|
int dot_copy_vectors(vector_t u, vector_t v);
|
|
|
|
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;
|
|
|
|
int square_test_us(test_us_t *tus);
|
|
|
|
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;
|
|
|
|
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);
|
|
|
|
typedef struct
|
|
{
|
|
char c;
|
|
int i;
|
|
short s;
|
|
double d;
|
|
} aligns_t;
|
|
|
|
double sum_aligns(aligns_t *a);
|
|
|
|
typedef struct
|
|
{
|
|
int i;
|
|
char c;
|
|
} padded_t;
|
|
|
|
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);
|
|
|
|
typedef struct
|
|
{
|
|
int *p1;
|
|
} bogus_helper_t;
|
|
|
|
typedef struct
|
|
{
|
|
bogus_helper_t h;
|
|
int *p2;
|
|
int *p3;
|
|
char c;
|
|
} bogus_t;
|
|
|
|
int sum_bogus(bogus_t *b);
|
|
void check_null([unique] int *null);
|
|
|
|
typedef struct
|
|
{
|
|
str_t s;
|
|
} str_struct_t;
|
|
|
|
typedef struct
|
|
{
|
|
wstr_t s;
|
|
} wstr_struct_t;
|
|
|
|
int str_struct_len(str_struct_t *s);
|
|
int wstr_struct_len(wstr_struct_t *s);
|
|
|
|
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;
|
|
|
|
int sum_doub_carr(doub_carr_t *dc);
|
|
void make_pyramid_doub_carr(unsigned char n, [out] doub_carr_t **dc);
|
|
|
|
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;
|
|
unsigned hash_bstr(bstr_t s);
|
|
void get_a_bstr([out]bstr_t *s);
|
|
typedef struct
|
|
{
|
|
[string, size_is(size)] char *name;
|
|
unsigned int size;
|
|
} name_t;
|
|
void get_name([in,out] name_t *name);
|
|
|
|
typedef char **str_array_t;
|
|
void get_names([out] int *n, [out, string, size_is(,*n)] str_array_t *names);
|
|
typedef WCHAR **wstr_array_t;
|
|
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);
|
|
|
|
/* Don't use this except in the get_s123 test. */
|
|
typedef struct
|
|
{
|
|
int f1;
|
|
int f2;
|
|
int f3;
|
|
} s123_t;
|
|
|
|
/* Make sure WIDL generates a type format string for a previously unseen
|
|
type as a return value. */
|
|
s123_t *get_s123(void);
|
|
|
|
typedef struct
|
|
{
|
|
unsigned int length;
|
|
unsigned int size;
|
|
[size_is(size), length_is(length)] pints_t numbers[];
|
|
} numbers_struct_t;
|
|
|
|
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);
|
|
|
|
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;
|
|
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);
|
|
}
|