| /* | |
| * 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); | |
| } |