blob: 05b1bfe8257039b0dac95628fe97045d2d3e582d (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
namespace rondpoint {
Dictionnaire copie_dictionnaire(Dictionnaire d);
Enumeration copie_enumeration(Enumeration e);
sequence<Enumeration> copie_enumerations(sequence<Enumeration> e);
record<DOMString, EnumerationAvecDonnees> copie_carte(record<DOMString, EnumerationAvecDonnees> c);
boolean switcheroo(boolean b);
};
dictionary minusculeMAJUSCULEDict {
boolean minusculeMAJUSCULEField;
};
enum minusculeMAJUSCULEEnum {
"minusculeMAJUSCULEVariant",
};
enum Enumeration {
"Un",
"Deux",
"Trois",
};
[Enum]
interface EnumerationAvecDonnees {
Zero();
Un(u32 premier);
Deux(u32 premier, string second);
};
dictionary Dictionnaire {
Enumeration un;
boolean deux;
u8 petit_nombre;
u64 gros_nombre;
};
dictionary DictionnaireNombres {
u8 petit_nombre;
u16 court_nombre;
u32 nombre_simple;
u64 gros_nombre;
};
dictionary DictionnaireNombresSignes {
i8 petit_nombre;
i16 court_nombre;
i32 nombre_simple;
i64 gros_nombre;
};
interface Retourneur {
constructor();
i8 identique_i8(i8 value);
u8 identique_u8(u8 value);
i16 identique_i16(i16 value);
u16 identique_u16(u16 value);
i32 identique_i32(i32 value);
u32 identique_u32(u32 value);
i64 identique_i64(i64 value);
u64 identique_u64(u64 value);
float identique_float(float value);
double identique_double(double value);
boolean identique_boolean(boolean value);
string identique_string(string value);
DictionnaireNombresSignes identique_nombres_signes(DictionnaireNombresSignes value);
DictionnaireNombres identique_nombres(DictionnaireNombres value);
OptionneurDictionnaire identique_optionneur_dictionnaire(OptionneurDictionnaire value);
};
interface Stringifier {
constructor();
string well_known_string(string value);
string to_string_i8(i8 value);
string to_string_u8(u8 value);
string to_string_i16(i16 value);
string to_string_u16(u16 value);
string to_string_i32(i32 value);
string to_string_u32(u32 value);
string to_string_i64(i64 value);
string to_string_u64(u64 value);
string to_string_float(float value);
string to_string_double(double value);
string to_string_boolean(boolean value);
};
interface Optionneur {
constructor();
boolean sinon_boolean(optional boolean value = false);
string sinon_string(optional string value = "default");
sequence<string> sinon_sequence(optional sequence<string> value = []);
// Either sides of nullable.
string? sinon_null(optional string? value = null);
i32? sinon_zero(optional i32? value = 0);
// Decimal integers, all 42.
u8 sinon_u8_dec(optional u8 value = 42);
i8 sinon_i8_dec(optional i8 value = -42);
u16 sinon_u16_dec(optional u16 value = 42);
i16 sinon_i16_dec(optional i16 value = 42);
u32 sinon_u32_dec(optional u32 value = 42);
i32 sinon_i32_dec(optional i32 value = 42);
u64 sinon_u64_dec(optional u64 value = 42);
i64 sinon_i64_dec(optional i64 value = 42);
// Hexadecimal, including negatgives.
u8 sinon_u8_hex(optional u8 value = 0xff);
i8 sinon_i8_hex(optional i8 value = -0x7f);
u16 sinon_u16_hex(optional u16 value = 0xffff);
i16 sinon_i16_hex(optional i16 value = 0x7f);
u32 sinon_u32_hex(optional u32 value = 0xffffffff);
i32 sinon_i32_hex(optional i32 value = 0x7fffffff);
u64 sinon_u64_hex(optional u64 value = 0xffffffffffffffff);
i64 sinon_i64_hex(optional i64 value = 0x7fffffffffffffff);
// Octal, FWIW.
u32 sinon_u32_oct(optional u32 value = 0755);
// Floats
f32 sinon_f32(optional f32 value = 42.0);
f64 sinon_f64(optional f64 value = 42.1);
// Enums, which we have to treat as strings in the UDL frontend.
Enumeration sinon_enum(optional Enumeration value = "Trois");
};
dictionary OptionneurDictionnaire {
i8 i8_var = -8;
u8 u8_var = 8;
i16 i16_var = -0x10;
u16 u16_var = 0x10;
i32 i32_var = -32;
u32 u32_var = 32;
i64 i64_var = -64;
u64 u64_var = 64;
float float_var = 4.0;
double double_var = 8.0;
boolean boolean_var = true;
string string_var = "default";
sequence<string> list_var = [];
Enumeration enumeration_var = "DEUX";
minusculeMAJUSCULEEnum? dictionnaire_var = null;
};
|
