1pub type wchar_t = ::std::os::raw::c_int;
4pub type UBool = i8;
5pub type UChar = u16;
6pub type UChar32 = i32;
7pub type UVersionInfo = [u8; 4usize];
8extern "C" {
9 pub fn u_versionFromString_74(
10 versionArray: *mut u8,
11 versionString: *const ::std::os::raw::c_char,
12 );
13}
14extern "C" {
15 pub fn u_versionFromUString_74(versionArray: *mut u8, versionString: *const UChar);
16}
17extern "C" {
18 pub fn u_versionToString_74(versionArray: *mut u8, versionString: *mut ::std::os::raw::c_char);
19}
20extern "C" {
21 pub fn u_getVersion_74(versionArray: *mut u8);
22}
23pub type UDate = f64;
24impl UErrorCode {
25 pub const U_ERROR_WARNING_START: UErrorCode = UErrorCode::U_USING_FALLBACK_WARNING;
26}
27impl UErrorCode {
28 pub const U_PARSE_ERROR_START: UErrorCode = UErrorCode::U_BAD_VARIABLE_DEFINITION;
29}
30impl UErrorCode {
31 pub const U_FMT_PARSE_ERROR_START: UErrorCode = UErrorCode::U_UNEXPECTED_TOKEN;
32}
33impl UErrorCode {
34 pub const U_MULTIPLE_DECIMAL_SEPERATORS: UErrorCode = UErrorCode::U_MULTIPLE_DECIMAL_SEPARATORS;
35}
36impl UErrorCode {
37 pub const U_BRK_ERROR_START: UErrorCode = UErrorCode::U_BRK_INTERNAL_ERROR;
38}
39impl UErrorCode {
40 pub const U_REGEX_ERROR_START: UErrorCode = UErrorCode::U_REGEX_INTERNAL_ERROR;
41}
42impl UErrorCode {
43 pub const U_IDNA_ERROR_START: UErrorCode = UErrorCode::U_IDNA_PROHIBITED_ERROR;
44}
45impl UErrorCode {
46 pub const U_STRINGPREP_PROHIBITED_ERROR: UErrorCode = UErrorCode::U_IDNA_PROHIBITED_ERROR;
47}
48impl UErrorCode {
49 pub const U_STRINGPREP_UNASSIGNED_ERROR: UErrorCode = UErrorCode::U_IDNA_UNASSIGNED_ERROR;
50}
51impl UErrorCode {
52 pub const U_STRINGPREP_CHECK_BIDI_ERROR: UErrorCode = UErrorCode::U_IDNA_CHECK_BIDI_ERROR;
53}
54impl UErrorCode {
55 pub const U_PLUGIN_TOO_HIGH: UErrorCode = UErrorCode::U_PLUGIN_ERROR_START;
56}
57impl UErrorCode {
58 pub const U_ERROR_LIMIT: UErrorCode = UErrorCode::U_PLUGIN_ERROR_LIMIT;
59}
60#[repr(i32)]
61#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
62pub enum UErrorCode {
63 U_USING_FALLBACK_WARNING = -128,
64 U_USING_DEFAULT_WARNING = -127,
65 U_SAFECLONE_ALLOCATED_WARNING = -126,
66 U_STATE_OLD_WARNING = -125,
67 U_STRING_NOT_TERMINATED_WARNING = -124,
68 U_SORT_KEY_TOO_SHORT_WARNING = -123,
69 U_AMBIGUOUS_ALIAS_WARNING = -122,
70 U_DIFFERENT_UCA_VERSION = -121,
71 U_PLUGIN_CHANGED_LEVEL_WARNING = -120,
72 U_ERROR_WARNING_LIMIT = -119,
73 U_ZERO_ERROR = 0,
74 U_ILLEGAL_ARGUMENT_ERROR = 1,
75 U_MISSING_RESOURCE_ERROR = 2,
76 U_INVALID_FORMAT_ERROR = 3,
77 U_FILE_ACCESS_ERROR = 4,
78 U_INTERNAL_PROGRAM_ERROR = 5,
79 U_MESSAGE_PARSE_ERROR = 6,
80 U_MEMORY_ALLOCATION_ERROR = 7,
81 U_INDEX_OUTOFBOUNDS_ERROR = 8,
82 U_PARSE_ERROR = 9,
83 U_INVALID_CHAR_FOUND = 10,
84 U_TRUNCATED_CHAR_FOUND = 11,
85 U_ILLEGAL_CHAR_FOUND = 12,
86 U_INVALID_TABLE_FORMAT = 13,
87 U_INVALID_TABLE_FILE = 14,
88 U_BUFFER_OVERFLOW_ERROR = 15,
89 U_UNSUPPORTED_ERROR = 16,
90 U_RESOURCE_TYPE_MISMATCH = 17,
91 U_ILLEGAL_ESCAPE_SEQUENCE = 18,
92 U_UNSUPPORTED_ESCAPE_SEQUENCE = 19,
93 U_NO_SPACE_AVAILABLE = 20,
94 U_CE_NOT_FOUND_ERROR = 21,
95 U_PRIMARY_TOO_LONG_ERROR = 22,
96 U_STATE_TOO_OLD_ERROR = 23,
97 U_TOO_MANY_ALIASES_ERROR = 24,
98 U_ENUM_OUT_OF_SYNC_ERROR = 25,
99 U_INVARIANT_CONVERSION_ERROR = 26,
100 U_INVALID_STATE_ERROR = 27,
101 U_COLLATOR_VERSION_MISMATCH = 28,
102 U_USELESS_COLLATOR_ERROR = 29,
103 U_NO_WRITE_PERMISSION = 30,
104 U_INPUT_TOO_LONG_ERROR = 31,
105 U_STANDARD_ERROR_LIMIT = 32,
106 U_BAD_VARIABLE_DEFINITION = 65536,
107 U_MALFORMED_RULE = 65537,
108 U_MALFORMED_SET = 65538,
109 U_MALFORMED_SYMBOL_REFERENCE = 65539,
110 U_MALFORMED_UNICODE_ESCAPE = 65540,
111 U_MALFORMED_VARIABLE_DEFINITION = 65541,
112 U_MALFORMED_VARIABLE_REFERENCE = 65542,
113 U_MISMATCHED_SEGMENT_DELIMITERS = 65543,
114 U_MISPLACED_ANCHOR_START = 65544,
115 U_MISPLACED_CURSOR_OFFSET = 65545,
116 U_MISPLACED_QUANTIFIER = 65546,
117 U_MISSING_OPERATOR = 65547,
118 U_MISSING_SEGMENT_CLOSE = 65548,
119 U_MULTIPLE_ANTE_CONTEXTS = 65549,
120 U_MULTIPLE_CURSORS = 65550,
121 U_MULTIPLE_POST_CONTEXTS = 65551,
122 U_TRAILING_BACKSLASH = 65552,
123 U_UNDEFINED_SEGMENT_REFERENCE = 65553,
124 U_UNDEFINED_VARIABLE = 65554,
125 U_UNQUOTED_SPECIAL = 65555,
126 U_UNTERMINATED_QUOTE = 65556,
127 U_RULE_MASK_ERROR = 65557,
128 U_MISPLACED_COMPOUND_FILTER = 65558,
129 U_MULTIPLE_COMPOUND_FILTERS = 65559,
130 U_INVALID_RBT_SYNTAX = 65560,
131 U_INVALID_PROPERTY_PATTERN = 65561,
132 U_MALFORMED_PRAGMA = 65562,
133 U_UNCLOSED_SEGMENT = 65563,
134 U_ILLEGAL_CHAR_IN_SEGMENT = 65564,
135 U_VARIABLE_RANGE_EXHAUSTED = 65565,
136 U_VARIABLE_RANGE_OVERLAP = 65566,
137 U_ILLEGAL_CHARACTER = 65567,
138 U_INTERNAL_TRANSLITERATOR_ERROR = 65568,
139 U_INVALID_ID = 65569,
140 U_INVALID_FUNCTION = 65570,
141 U_PARSE_ERROR_LIMIT = 65571,
142 U_UNEXPECTED_TOKEN = 65792,
143 U_MULTIPLE_DECIMAL_SEPARATORS = 65793,
144 U_MULTIPLE_EXPONENTIAL_SYMBOLS = 65794,
145 U_MALFORMED_EXPONENTIAL_PATTERN = 65795,
146 U_MULTIPLE_PERCENT_SYMBOLS = 65796,
147 U_MULTIPLE_PERMILL_SYMBOLS = 65797,
148 U_MULTIPLE_PAD_SPECIFIERS = 65798,
149 U_PATTERN_SYNTAX_ERROR = 65799,
150 U_ILLEGAL_PAD_POSITION = 65800,
151 U_UNMATCHED_BRACES = 65801,
152 U_UNSUPPORTED_PROPERTY = 65802,
153 U_UNSUPPORTED_ATTRIBUTE = 65803,
154 U_ARGUMENT_TYPE_MISMATCH = 65804,
155 U_DUPLICATE_KEYWORD = 65805,
156 U_UNDEFINED_KEYWORD = 65806,
157 U_DEFAULT_KEYWORD_MISSING = 65807,
158 U_DECIMAL_NUMBER_SYNTAX_ERROR = 65808,
159 U_FORMAT_INEXACT_ERROR = 65809,
160 U_NUMBER_ARG_OUTOFBOUNDS_ERROR = 65810,
161 U_NUMBER_SKELETON_SYNTAX_ERROR = 65811,
162 U_FMT_PARSE_ERROR_LIMIT = 65812,
163 U_BRK_INTERNAL_ERROR = 66048,
164 U_BRK_HEX_DIGITS_EXPECTED = 66049,
165 U_BRK_SEMICOLON_EXPECTED = 66050,
166 U_BRK_RULE_SYNTAX = 66051,
167 U_BRK_UNCLOSED_SET = 66052,
168 U_BRK_ASSIGN_ERROR = 66053,
169 U_BRK_VARIABLE_REDFINITION = 66054,
170 U_BRK_MISMATCHED_PAREN = 66055,
171 U_BRK_NEW_LINE_IN_QUOTED_STRING = 66056,
172 U_BRK_UNDEFINED_VARIABLE = 66057,
173 U_BRK_INIT_ERROR = 66058,
174 U_BRK_RULE_EMPTY_SET = 66059,
175 U_BRK_UNRECOGNIZED_OPTION = 66060,
176 U_BRK_MALFORMED_RULE_TAG = 66061,
177 U_BRK_ERROR_LIMIT = 66062,
178 U_REGEX_INTERNAL_ERROR = 66304,
179 U_REGEX_RULE_SYNTAX = 66305,
180 U_REGEX_INVALID_STATE = 66306,
181 U_REGEX_BAD_ESCAPE_SEQUENCE = 66307,
182 U_REGEX_PROPERTY_SYNTAX = 66308,
183 U_REGEX_UNIMPLEMENTED = 66309,
184 U_REGEX_MISMATCHED_PAREN = 66310,
185 U_REGEX_NUMBER_TOO_BIG = 66311,
186 U_REGEX_BAD_INTERVAL = 66312,
187 U_REGEX_MAX_LT_MIN = 66313,
188 U_REGEX_INVALID_BACK_REF = 66314,
189 U_REGEX_INVALID_FLAG = 66315,
190 U_REGEX_LOOK_BEHIND_LIMIT = 66316,
191 U_REGEX_SET_CONTAINS_STRING = 66317,
192 U_REGEX_OCTAL_TOO_BIG = 66318,
193 U_REGEX_MISSING_CLOSE_BRACKET = 66319,
194 U_REGEX_INVALID_RANGE = 66320,
195 U_REGEX_STACK_OVERFLOW = 66321,
196 U_REGEX_TIME_OUT = 66322,
197 U_REGEX_STOPPED_BY_CALLER = 66323,
198 U_REGEX_PATTERN_TOO_BIG = 66324,
199 U_REGEX_INVALID_CAPTURE_GROUP_NAME = 66325,
200 U_REGEX_ERROR_LIMIT = 66326,
201 U_IDNA_PROHIBITED_ERROR = 66560,
202 U_IDNA_UNASSIGNED_ERROR = 66561,
203 U_IDNA_CHECK_BIDI_ERROR = 66562,
204 U_IDNA_STD3_ASCII_RULES_ERROR = 66563,
205 U_IDNA_ACE_PREFIX_ERROR = 66564,
206 U_IDNA_VERIFICATION_ERROR = 66565,
207 U_IDNA_LABEL_TOO_LONG_ERROR = 66566,
208 U_IDNA_ZERO_LENGTH_LABEL_ERROR = 66567,
209 U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR = 66568,
210 U_IDNA_ERROR_LIMIT = 66569,
211 U_PLUGIN_ERROR_START = 66816,
212 U_PLUGIN_DIDNT_SET_LEVEL = 66817,
213 U_PLUGIN_ERROR_LIMIT = 66818,
214}
215extern "C" {
216 pub fn u_errorName_74(code: UErrorCode) -> *const ::std::os::raw::c_char;
217}
218#[repr(C)]
219#[derive(Debug, Copy, Clone)]
220pub struct UEnumeration {
221 _unused: [u8; 0],
222}
223extern "C" {
224 pub fn uenum_close_74(en: *mut UEnumeration);
225}
226extern "C" {
227 pub fn uenum_count_74(en: *mut UEnumeration, status: *mut UErrorCode) -> i32;
228}
229extern "C" {
230 pub fn uenum_unext_74(
231 en: *mut UEnumeration,
232 resultLength: *mut i32,
233 status: *mut UErrorCode,
234 ) -> *const UChar;
235}
236extern "C" {
237 pub fn uenum_next_74(
238 en: *mut UEnumeration,
239 resultLength: *mut i32,
240 status: *mut UErrorCode,
241 ) -> *const ::std::os::raw::c_char;
242}
243extern "C" {
244 pub fn uenum_reset_74(en: *mut UEnumeration, status: *mut UErrorCode);
245}
246extern "C" {
247 pub fn uenum_openUCharStringsEnumeration_74(
248 strings: *const *const UChar,
249 count: i32,
250 ec: *mut UErrorCode,
251 ) -> *mut UEnumeration;
252}
253extern "C" {
254 pub fn uenum_openCharStringsEnumeration_74(
255 strings: *const *const ::std::os::raw::c_char,
256 count: i32,
257 ec: *mut UErrorCode,
258 ) -> *mut UEnumeration;
259}
260#[repr(u32)]
261#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
262pub enum ULocDataLocaleType {
263 ULOC_ACTUAL_LOCALE = 0,
264 ULOC_VALID_LOCALE = 1,
265 ULOC_REQUESTED_LOCALE = 2,
266 ULOC_DATA_LOCALE_TYPE_LIMIT = 3,
267}
268extern "C" {
269 pub fn uloc_getDefault_74() -> *const ::std::os::raw::c_char;
270}
271extern "C" {
272 pub fn uloc_setDefault_74(localeID: *const ::std::os::raw::c_char, status: *mut UErrorCode);
273}
274extern "C" {
275 pub fn uloc_getLanguage_74(
276 localeID: *const ::std::os::raw::c_char,
277 language: *mut ::std::os::raw::c_char,
278 languageCapacity: i32,
279 err: *mut UErrorCode,
280 ) -> i32;
281}
282extern "C" {
283 pub fn uloc_getScript_74(
284 localeID: *const ::std::os::raw::c_char,
285 script: *mut ::std::os::raw::c_char,
286 scriptCapacity: i32,
287 err: *mut UErrorCode,
288 ) -> i32;
289}
290extern "C" {
291 pub fn uloc_getCountry_74(
292 localeID: *const ::std::os::raw::c_char,
293 country: *mut ::std::os::raw::c_char,
294 countryCapacity: i32,
295 err: *mut UErrorCode,
296 ) -> i32;
297}
298extern "C" {
299 pub fn uloc_getVariant_74(
300 localeID: *const ::std::os::raw::c_char,
301 variant: *mut ::std::os::raw::c_char,
302 variantCapacity: i32,
303 err: *mut UErrorCode,
304 ) -> i32;
305}
306extern "C" {
307 pub fn uloc_getName_74(
308 localeID: *const ::std::os::raw::c_char,
309 name: *mut ::std::os::raw::c_char,
310 nameCapacity: i32,
311 err: *mut UErrorCode,
312 ) -> i32;
313}
314extern "C" {
315 pub fn uloc_canonicalize_74(
316 localeID: *const ::std::os::raw::c_char,
317 name: *mut ::std::os::raw::c_char,
318 nameCapacity: i32,
319 err: *mut UErrorCode,
320 ) -> i32;
321}
322extern "C" {
323 pub fn uloc_getISO3Language_74(
324 localeID: *const ::std::os::raw::c_char,
325 ) -> *const ::std::os::raw::c_char;
326}
327extern "C" {
328 pub fn uloc_getISO3Country_74(
329 localeID: *const ::std::os::raw::c_char,
330 ) -> *const ::std::os::raw::c_char;
331}
332extern "C" {
333 pub fn uloc_getLCID_74(localeID: *const ::std::os::raw::c_char) -> u32;
334}
335extern "C" {
336 pub fn uloc_getDisplayLanguage_74(
337 locale: *const ::std::os::raw::c_char,
338 displayLocale: *const ::std::os::raw::c_char,
339 language: *mut UChar,
340 languageCapacity: i32,
341 status: *mut UErrorCode,
342 ) -> i32;
343}
344extern "C" {
345 pub fn uloc_getDisplayScript_74(
346 locale: *const ::std::os::raw::c_char,
347 displayLocale: *const ::std::os::raw::c_char,
348 script: *mut UChar,
349 scriptCapacity: i32,
350 status: *mut UErrorCode,
351 ) -> i32;
352}
353extern "C" {
354 pub fn uloc_getDisplayCountry_74(
355 locale: *const ::std::os::raw::c_char,
356 displayLocale: *const ::std::os::raw::c_char,
357 country: *mut UChar,
358 countryCapacity: i32,
359 status: *mut UErrorCode,
360 ) -> i32;
361}
362extern "C" {
363 pub fn uloc_getDisplayVariant_74(
364 locale: *const ::std::os::raw::c_char,
365 displayLocale: *const ::std::os::raw::c_char,
366 variant: *mut UChar,
367 variantCapacity: i32,
368 status: *mut UErrorCode,
369 ) -> i32;
370}
371extern "C" {
372 pub fn uloc_getDisplayKeyword_74(
373 keyword: *const ::std::os::raw::c_char,
374 displayLocale: *const ::std::os::raw::c_char,
375 dest: *mut UChar,
376 destCapacity: i32,
377 status: *mut UErrorCode,
378 ) -> i32;
379}
380extern "C" {
381 pub fn uloc_getDisplayKeywordValue_74(
382 locale: *const ::std::os::raw::c_char,
383 keyword: *const ::std::os::raw::c_char,
384 displayLocale: *const ::std::os::raw::c_char,
385 dest: *mut UChar,
386 destCapacity: i32,
387 status: *mut UErrorCode,
388 ) -> i32;
389}
390extern "C" {
391 pub fn uloc_getDisplayName_74(
392 localeID: *const ::std::os::raw::c_char,
393 inLocaleID: *const ::std::os::raw::c_char,
394 result: *mut UChar,
395 maxResultSize: i32,
396 err: *mut UErrorCode,
397 ) -> i32;
398}
399extern "C" {
400 pub fn uloc_getAvailable_74(n: i32) -> *const ::std::os::raw::c_char;
401}
402extern "C" {
403 pub fn uloc_countAvailable_74() -> i32;
404}
405#[repr(u32)]
406#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
407pub enum ULocAvailableType {
408 ULOC_AVAILABLE_DEFAULT = 0,
409 ULOC_AVAILABLE_ONLY_LEGACY_ALIASES = 1,
410 ULOC_AVAILABLE_WITH_LEGACY_ALIASES = 2,
411 ULOC_AVAILABLE_COUNT = 3,
412}
413extern "C" {
414 pub fn uloc_openAvailableByType_74(
415 type_: ULocAvailableType,
416 status: *mut UErrorCode,
417 ) -> *mut UEnumeration;
418}
419extern "C" {
420 pub fn uloc_getISOLanguages_74() -> *const *const ::std::os::raw::c_char;
421}
422extern "C" {
423 pub fn uloc_getISOCountries_74() -> *const *const ::std::os::raw::c_char;
424}
425extern "C" {
426 pub fn uloc_getParent_74(
427 localeID: *const ::std::os::raw::c_char,
428 parent: *mut ::std::os::raw::c_char,
429 parentCapacity: i32,
430 err: *mut UErrorCode,
431 ) -> i32;
432}
433extern "C" {
434 pub fn uloc_getBaseName_74(
435 localeID: *const ::std::os::raw::c_char,
436 name: *mut ::std::os::raw::c_char,
437 nameCapacity: i32,
438 err: *mut UErrorCode,
439 ) -> i32;
440}
441extern "C" {
442 pub fn uloc_openKeywords_74(
443 localeID: *const ::std::os::raw::c_char,
444 status: *mut UErrorCode,
445 ) -> *mut UEnumeration;
446}
447extern "C" {
448 pub fn uloc_getKeywordValue_74(
449 localeID: *const ::std::os::raw::c_char,
450 keywordName: *const ::std::os::raw::c_char,
451 buffer: *mut ::std::os::raw::c_char,
452 bufferCapacity: i32,
453 status: *mut UErrorCode,
454 ) -> i32;
455}
456extern "C" {
457 pub fn uloc_setKeywordValue_74(
458 keywordName: *const ::std::os::raw::c_char,
459 keywordValue: *const ::std::os::raw::c_char,
460 buffer: *mut ::std::os::raw::c_char,
461 bufferCapacity: i32,
462 status: *mut UErrorCode,
463 ) -> i32;
464}
465extern "C" {
466 pub fn uloc_isRightToLeft_74(locale: *const ::std::os::raw::c_char) -> UBool;
467}
468#[repr(u32)]
469#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
470pub enum ULayoutType {
471 ULOC_LAYOUT_LTR = 0,
472 ULOC_LAYOUT_RTL = 1,
473 ULOC_LAYOUT_TTB = 2,
474 ULOC_LAYOUT_BTT = 3,
475 ULOC_LAYOUT_UNKNOWN = 4,
476}
477extern "C" {
478 pub fn uloc_getCharacterOrientation_74(
479 localeId: *const ::std::os::raw::c_char,
480 status: *mut UErrorCode,
481 ) -> ULayoutType;
482}
483extern "C" {
484 pub fn uloc_getLineOrientation_74(
485 localeId: *const ::std::os::raw::c_char,
486 status: *mut UErrorCode,
487 ) -> ULayoutType;
488}
489#[repr(u32)]
490#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
491pub enum UAcceptResult {
492 ULOC_ACCEPT_FAILED = 0,
493 ULOC_ACCEPT_VALID = 1,
494 ULOC_ACCEPT_FALLBACK = 2,
495}
496extern "C" {
497 pub fn uloc_acceptLanguageFromHTTP_74(
498 result: *mut ::std::os::raw::c_char,
499 resultAvailable: i32,
500 outResult: *mut UAcceptResult,
501 httpAcceptLanguage: *const ::std::os::raw::c_char,
502 availableLocales: *mut UEnumeration,
503 status: *mut UErrorCode,
504 ) -> i32;
505}
506extern "C" {
507 pub fn uloc_acceptLanguage_74(
508 result: *mut ::std::os::raw::c_char,
509 resultAvailable: i32,
510 outResult: *mut UAcceptResult,
511 acceptList: *mut *const ::std::os::raw::c_char,
512 acceptListCount: i32,
513 availableLocales: *mut UEnumeration,
514 status: *mut UErrorCode,
515 ) -> i32;
516}
517extern "C" {
518 pub fn uloc_getLocaleForLCID_74(
519 hostID: u32,
520 locale: *mut ::std::os::raw::c_char,
521 localeCapacity: i32,
522 status: *mut UErrorCode,
523 ) -> i32;
524}
525extern "C" {
526 pub fn uloc_addLikelySubtags_74(
527 localeID: *const ::std::os::raw::c_char,
528 maximizedLocaleID: *mut ::std::os::raw::c_char,
529 maximizedLocaleIDCapacity: i32,
530 err: *mut UErrorCode,
531 ) -> i32;
532}
533extern "C" {
534 pub fn uloc_minimizeSubtags_74(
535 localeID: *const ::std::os::raw::c_char,
536 minimizedLocaleID: *mut ::std::os::raw::c_char,
537 minimizedLocaleIDCapacity: i32,
538 err: *mut UErrorCode,
539 ) -> i32;
540}
541extern "C" {
542 pub fn uloc_forLanguageTag_74(
543 langtag: *const ::std::os::raw::c_char,
544 localeID: *mut ::std::os::raw::c_char,
545 localeIDCapacity: i32,
546 parsedLength: *mut i32,
547 err: *mut UErrorCode,
548 ) -> i32;
549}
550extern "C" {
551 pub fn uloc_toLanguageTag_74(
552 localeID: *const ::std::os::raw::c_char,
553 langtag: *mut ::std::os::raw::c_char,
554 langtagCapacity: i32,
555 strict: UBool,
556 err: *mut UErrorCode,
557 ) -> i32;
558}
559extern "C" {
560 pub fn uloc_toUnicodeLocaleKey_74(
561 keyword: *const ::std::os::raw::c_char,
562 ) -> *const ::std::os::raw::c_char;
563}
564extern "C" {
565 pub fn uloc_toUnicodeLocaleType_74(
566 keyword: *const ::std::os::raw::c_char,
567 value: *const ::std::os::raw::c_char,
568 ) -> *const ::std::os::raw::c_char;
569}
570extern "C" {
571 pub fn uloc_toLegacyKey_74(
572 keyword: *const ::std::os::raw::c_char,
573 ) -> *const ::std::os::raw::c_char;
574}
575extern "C" {
576 pub fn uloc_toLegacyType_74(
577 keyword: *const ::std::os::raw::c_char,
578 value: *const ::std::os::raw::c_char,
579 ) -> *const ::std::os::raw::c_char;
580}
581#[repr(C)]
582#[derive(Debug, Copy, Clone)]
583pub struct UCPMap {
584 _unused: [u8; 0],
585}
586#[repr(u32)]
587#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
588pub enum UCPMapRangeOption {
589 UCPMAP_RANGE_NORMAL = 0,
590 UCPMAP_RANGE_FIXED_LEAD_SURROGATES = 1,
591 UCPMAP_RANGE_FIXED_ALL_SURROGATES = 2,
592}
593extern "C" {
594 pub fn ucpmap_get_74(map: *const UCPMap, c: UChar32) -> u32;
595}
596pub type UCPMapValueFilter = ::std::option::Option<
597 unsafe extern "C" fn(context: *const ::std::os::raw::c_void, value: u32) -> u32,
598>;
599extern "C" {
600 pub fn ucpmap_getRange_74(
601 map: *const UCPMap,
602 start: UChar32,
603 option: UCPMapRangeOption,
604 surrogateValue: u32,
605 filter: UCPMapValueFilter,
606 context: *const ::std::os::raw::c_void,
607 pValue: *mut u32,
608 ) -> UChar32;
609}
610#[repr(C)]
611#[derive(Debug, Copy, Clone)]
612pub struct USet {
613 _unused: [u8; 0],
614}
615impl UProperty {
616 pub const UCHAR_BINARY_START: UProperty = UProperty::UCHAR_ALPHABETIC;
617}
618impl UProperty {
619 pub const UCHAR_INT_START: UProperty = UProperty::UCHAR_BIDI_CLASS;
620}
621impl UProperty {
622 pub const UCHAR_MASK_START: UProperty = UProperty::UCHAR_GENERAL_CATEGORY_MASK;
623}
624impl UProperty {
625 pub const UCHAR_DOUBLE_START: UProperty = UProperty::UCHAR_NUMERIC_VALUE;
626}
627impl UProperty {
628 pub const UCHAR_STRING_START: UProperty = UProperty::UCHAR_AGE;
629}
630impl UProperty {
631 pub const UCHAR_OTHER_PROPERTY_START: UProperty = UProperty::UCHAR_SCRIPT_EXTENSIONS;
632}
633#[repr(i32)]
634#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
635pub enum UProperty {
636 UCHAR_ALPHABETIC = 0,
637 UCHAR_ASCII_HEX_DIGIT = 1,
638 UCHAR_BIDI_CONTROL = 2,
639 UCHAR_BIDI_MIRRORED = 3,
640 UCHAR_DASH = 4,
641 UCHAR_DEFAULT_IGNORABLE_CODE_POINT = 5,
642 UCHAR_DEPRECATED = 6,
643 UCHAR_DIACRITIC = 7,
644 UCHAR_EXTENDER = 8,
645 UCHAR_FULL_COMPOSITION_EXCLUSION = 9,
646 UCHAR_GRAPHEME_BASE = 10,
647 UCHAR_GRAPHEME_EXTEND = 11,
648 UCHAR_GRAPHEME_LINK = 12,
649 UCHAR_HEX_DIGIT = 13,
650 UCHAR_HYPHEN = 14,
651 UCHAR_ID_CONTINUE = 15,
652 UCHAR_ID_START = 16,
653 UCHAR_IDEOGRAPHIC = 17,
654 UCHAR_IDS_BINARY_OPERATOR = 18,
655 UCHAR_IDS_TRINARY_OPERATOR = 19,
656 UCHAR_JOIN_CONTROL = 20,
657 UCHAR_LOGICAL_ORDER_EXCEPTION = 21,
658 UCHAR_LOWERCASE = 22,
659 UCHAR_MATH = 23,
660 UCHAR_NONCHARACTER_CODE_POINT = 24,
661 UCHAR_QUOTATION_MARK = 25,
662 UCHAR_RADICAL = 26,
663 UCHAR_SOFT_DOTTED = 27,
664 UCHAR_TERMINAL_PUNCTUATION = 28,
665 UCHAR_UNIFIED_IDEOGRAPH = 29,
666 UCHAR_UPPERCASE = 30,
667 UCHAR_WHITE_SPACE = 31,
668 UCHAR_XID_CONTINUE = 32,
669 UCHAR_XID_START = 33,
670 UCHAR_CASE_SENSITIVE = 34,
671 UCHAR_S_TERM = 35,
672 UCHAR_VARIATION_SELECTOR = 36,
673 UCHAR_NFD_INERT = 37,
674 UCHAR_NFKD_INERT = 38,
675 UCHAR_NFC_INERT = 39,
676 UCHAR_NFKC_INERT = 40,
677 UCHAR_SEGMENT_STARTER = 41,
678 UCHAR_PATTERN_SYNTAX = 42,
679 UCHAR_PATTERN_WHITE_SPACE = 43,
680 UCHAR_POSIX_ALNUM = 44,
681 UCHAR_POSIX_BLANK = 45,
682 UCHAR_POSIX_GRAPH = 46,
683 UCHAR_POSIX_PRINT = 47,
684 UCHAR_POSIX_XDIGIT = 48,
685 UCHAR_CASED = 49,
686 UCHAR_CASE_IGNORABLE = 50,
687 UCHAR_CHANGES_WHEN_LOWERCASED = 51,
688 UCHAR_CHANGES_WHEN_UPPERCASED = 52,
689 UCHAR_CHANGES_WHEN_TITLECASED = 53,
690 UCHAR_CHANGES_WHEN_CASEFOLDED = 54,
691 UCHAR_CHANGES_WHEN_CASEMAPPED = 55,
692 UCHAR_CHANGES_WHEN_NFKC_CASEFOLDED = 56,
693 UCHAR_EMOJI = 57,
694 UCHAR_EMOJI_PRESENTATION = 58,
695 UCHAR_EMOJI_MODIFIER = 59,
696 UCHAR_EMOJI_MODIFIER_BASE = 60,
697 UCHAR_EMOJI_COMPONENT = 61,
698 UCHAR_REGIONAL_INDICATOR = 62,
699 UCHAR_PREPENDED_CONCATENATION_MARK = 63,
700 UCHAR_EXTENDED_PICTOGRAPHIC = 64,
701 UCHAR_BASIC_EMOJI = 65,
702 UCHAR_EMOJI_KEYCAP_SEQUENCE = 66,
703 UCHAR_RGI_EMOJI_MODIFIER_SEQUENCE = 67,
704 UCHAR_RGI_EMOJI_FLAG_SEQUENCE = 68,
705 UCHAR_RGI_EMOJI_TAG_SEQUENCE = 69,
706 UCHAR_RGI_EMOJI_ZWJ_SEQUENCE = 70,
707 UCHAR_RGI_EMOJI = 71,
708 UCHAR_IDS_UNARY_OPERATOR = 72,
709 UCHAR_ID_COMPAT_MATH_START = 73,
710 UCHAR_ID_COMPAT_MATH_CONTINUE = 74,
711 UCHAR_BINARY_LIMIT = 75,
712 UCHAR_BIDI_CLASS = 4096,
713 UCHAR_BLOCK = 4097,
714 UCHAR_CANONICAL_COMBINING_CLASS = 4098,
715 UCHAR_DECOMPOSITION_TYPE = 4099,
716 UCHAR_EAST_ASIAN_WIDTH = 4100,
717 UCHAR_GENERAL_CATEGORY = 4101,
718 UCHAR_JOINING_GROUP = 4102,
719 UCHAR_JOINING_TYPE = 4103,
720 UCHAR_LINE_BREAK = 4104,
721 UCHAR_NUMERIC_TYPE = 4105,
722 UCHAR_SCRIPT = 4106,
723 UCHAR_HANGUL_SYLLABLE_TYPE = 4107,
724 UCHAR_NFD_QUICK_CHECK = 4108,
725 UCHAR_NFKD_QUICK_CHECK = 4109,
726 UCHAR_NFC_QUICK_CHECK = 4110,
727 UCHAR_NFKC_QUICK_CHECK = 4111,
728 UCHAR_LEAD_CANONICAL_COMBINING_CLASS = 4112,
729 UCHAR_TRAIL_CANONICAL_COMBINING_CLASS = 4113,
730 UCHAR_GRAPHEME_CLUSTER_BREAK = 4114,
731 UCHAR_SENTENCE_BREAK = 4115,
732 UCHAR_WORD_BREAK = 4116,
733 UCHAR_BIDI_PAIRED_BRACKET_TYPE = 4117,
734 UCHAR_INDIC_POSITIONAL_CATEGORY = 4118,
735 UCHAR_INDIC_SYLLABIC_CATEGORY = 4119,
736 UCHAR_VERTICAL_ORIENTATION = 4120,
737 UCHAR_INT_LIMIT = 4121,
738 UCHAR_GENERAL_CATEGORY_MASK = 8192,
739 UCHAR_MASK_LIMIT = 8193,
740 UCHAR_NUMERIC_VALUE = 12288,
741 UCHAR_DOUBLE_LIMIT = 12289,
742 UCHAR_AGE = 16384,
743 UCHAR_BIDI_MIRRORING_GLYPH = 16385,
744 UCHAR_CASE_FOLDING = 16386,
745 UCHAR_ISO_COMMENT = 16387,
746 UCHAR_LOWERCASE_MAPPING = 16388,
747 UCHAR_NAME = 16389,
748 UCHAR_SIMPLE_CASE_FOLDING = 16390,
749 UCHAR_SIMPLE_LOWERCASE_MAPPING = 16391,
750 UCHAR_SIMPLE_TITLECASE_MAPPING = 16392,
751 UCHAR_SIMPLE_UPPERCASE_MAPPING = 16393,
752 UCHAR_TITLECASE_MAPPING = 16394,
753 UCHAR_UNICODE_1_NAME = 16395,
754 UCHAR_UPPERCASE_MAPPING = 16396,
755 UCHAR_BIDI_PAIRED_BRACKET = 16397,
756 UCHAR_STRING_LIMIT = 16398,
757 UCHAR_SCRIPT_EXTENSIONS = 28672,
758 UCHAR_OTHER_PROPERTY_LIMIT = 28673,
759 UCHAR_INVALID_CODE = -1,
760}
761impl UCharCategory {
762 pub const U_GENERAL_OTHER_TYPES: UCharCategory = UCharCategory::U_UNASSIGNED;
763}
764#[repr(u32)]
765#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
766pub enum UCharCategory {
767 U_UNASSIGNED = 0,
768 U_UPPERCASE_LETTER = 1,
769 U_LOWERCASE_LETTER = 2,
770 U_TITLECASE_LETTER = 3,
771 U_MODIFIER_LETTER = 4,
772 U_OTHER_LETTER = 5,
773 U_NON_SPACING_MARK = 6,
774 U_ENCLOSING_MARK = 7,
775 U_COMBINING_SPACING_MARK = 8,
776 U_DECIMAL_DIGIT_NUMBER = 9,
777 U_LETTER_NUMBER = 10,
778 U_OTHER_NUMBER = 11,
779 U_SPACE_SEPARATOR = 12,
780 U_LINE_SEPARATOR = 13,
781 U_PARAGRAPH_SEPARATOR = 14,
782 U_CONTROL_CHAR = 15,
783 U_FORMAT_CHAR = 16,
784 U_PRIVATE_USE_CHAR = 17,
785 U_SURROGATE = 18,
786 U_DASH_PUNCTUATION = 19,
787 U_START_PUNCTUATION = 20,
788 U_END_PUNCTUATION = 21,
789 U_CONNECTOR_PUNCTUATION = 22,
790 U_OTHER_PUNCTUATION = 23,
791 U_MATH_SYMBOL = 24,
792 U_CURRENCY_SYMBOL = 25,
793 U_MODIFIER_SYMBOL = 26,
794 U_OTHER_SYMBOL = 27,
795 U_INITIAL_PUNCTUATION = 28,
796 U_FINAL_PUNCTUATION = 29,
797 U_CHAR_CATEGORY_COUNT = 30,
798}
799#[repr(u32)]
800#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
801pub enum UCharDirection {
802 U_LEFT_TO_RIGHT = 0,
803 U_RIGHT_TO_LEFT = 1,
804 U_EUROPEAN_NUMBER = 2,
805 U_EUROPEAN_NUMBER_SEPARATOR = 3,
806 U_EUROPEAN_NUMBER_TERMINATOR = 4,
807 U_ARABIC_NUMBER = 5,
808 U_COMMON_NUMBER_SEPARATOR = 6,
809 U_BLOCK_SEPARATOR = 7,
810 U_SEGMENT_SEPARATOR = 8,
811 U_WHITE_SPACE_NEUTRAL = 9,
812 U_OTHER_NEUTRAL = 10,
813 U_LEFT_TO_RIGHT_EMBEDDING = 11,
814 U_LEFT_TO_RIGHT_OVERRIDE = 12,
815 U_RIGHT_TO_LEFT_ARABIC = 13,
816 U_RIGHT_TO_LEFT_EMBEDDING = 14,
817 U_RIGHT_TO_LEFT_OVERRIDE = 15,
818 U_POP_DIRECTIONAL_FORMAT = 16,
819 U_DIR_NON_SPACING_MARK = 17,
820 U_BOUNDARY_NEUTRAL = 18,
821 U_FIRST_STRONG_ISOLATE = 19,
822 U_LEFT_TO_RIGHT_ISOLATE = 20,
823 U_RIGHT_TO_LEFT_ISOLATE = 21,
824 U_POP_DIRECTIONAL_ISOLATE = 22,
825 U_CHAR_DIRECTION_COUNT = 23,
826}
827#[repr(u32)]
828#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
829pub enum UCharNameChoice {
830 U_UNICODE_CHAR_NAME = 0,
831 U_UNICODE_10_CHAR_NAME = 1,
832 U_EXTENDED_CHAR_NAME = 2,
833 U_CHAR_NAME_ALIAS = 3,
834 U_CHAR_NAME_CHOICE_COUNT = 4,
835}
836#[repr(u32)]
837#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
838pub enum UPropertyNameChoice {
839 U_SHORT_PROPERTY_NAME = 0,
840 U_LONG_PROPERTY_NAME = 1,
841 U_PROPERTY_NAME_CHOICE_COUNT = 2,
842}
843extern "C" {
844 pub fn u_hasBinaryProperty_74(c: UChar32, which: UProperty) -> UBool;
845}
846extern "C" {
847 pub fn u_stringHasBinaryProperty_74(s: *const UChar, length: i32, which: UProperty) -> UBool;
848}
849extern "C" {
850 pub fn u_getBinaryPropertySet_74(
851 property: UProperty,
852 pErrorCode: *mut UErrorCode,
853 ) -> *const USet;
854}
855extern "C" {
856 pub fn u_isUAlphabetic_74(c: UChar32) -> UBool;
857}
858extern "C" {
859 pub fn u_isULowercase_74(c: UChar32) -> UBool;
860}
861extern "C" {
862 pub fn u_isUUppercase_74(c: UChar32) -> UBool;
863}
864extern "C" {
865 pub fn u_isUWhiteSpace_74(c: UChar32) -> UBool;
866}
867extern "C" {
868 pub fn u_getIntPropertyValue_74(c: UChar32, which: UProperty) -> i32;
869}
870extern "C" {
871 pub fn u_getIntPropertyMinValue_74(which: UProperty) -> i32;
872}
873extern "C" {
874 pub fn u_getIntPropertyMaxValue_74(which: UProperty) -> i32;
875}
876extern "C" {
877 pub fn u_getIntPropertyMap_74(
878 property: UProperty,
879 pErrorCode: *mut UErrorCode,
880 ) -> *const UCPMap;
881}
882extern "C" {
883 pub fn u_getNumericValue_74(c: UChar32) -> f64;
884}
885extern "C" {
886 pub fn u_islower_74(c: UChar32) -> UBool;
887}
888extern "C" {
889 pub fn u_isupper_74(c: UChar32) -> UBool;
890}
891extern "C" {
892 pub fn u_istitle_74(c: UChar32) -> UBool;
893}
894extern "C" {
895 pub fn u_isdigit_74(c: UChar32) -> UBool;
896}
897extern "C" {
898 pub fn u_isalpha_74(c: UChar32) -> UBool;
899}
900extern "C" {
901 pub fn u_isalnum_74(c: UChar32) -> UBool;
902}
903extern "C" {
904 pub fn u_isxdigit_74(c: UChar32) -> UBool;
905}
906extern "C" {
907 pub fn u_ispunct_74(c: UChar32) -> UBool;
908}
909extern "C" {
910 pub fn u_isgraph_74(c: UChar32) -> UBool;
911}
912extern "C" {
913 pub fn u_isblank_74(c: UChar32) -> UBool;
914}
915extern "C" {
916 pub fn u_isdefined_74(c: UChar32) -> UBool;
917}
918extern "C" {
919 pub fn u_isspace_74(c: UChar32) -> UBool;
920}
921extern "C" {
922 pub fn u_isJavaSpaceChar_74(c: UChar32) -> UBool;
923}
924extern "C" {
925 pub fn u_isWhitespace_74(c: UChar32) -> UBool;
926}
927extern "C" {
928 pub fn u_iscntrl_74(c: UChar32) -> UBool;
929}
930extern "C" {
931 pub fn u_isISOControl_74(c: UChar32) -> UBool;
932}
933extern "C" {
934 pub fn u_isprint_74(c: UChar32) -> UBool;
935}
936extern "C" {
937 pub fn u_isbase_74(c: UChar32) -> UBool;
938}
939extern "C" {
940 pub fn u_charDirection_74(c: UChar32) -> UCharDirection;
941}
942extern "C" {
943 pub fn u_isMirrored_74(c: UChar32) -> UBool;
944}
945extern "C" {
946 pub fn u_charMirror_74(c: UChar32) -> UChar32;
947}
948extern "C" {
949 pub fn u_getBidiPairedBracket_74(c: UChar32) -> UChar32;
950}
951extern "C" {
952 pub fn u_charType_74(c: UChar32) -> i8;
953}
954pub type UCharEnumTypeRange = ::std::option::Option<
955 unsafe extern "C" fn(
956 context: *const ::std::os::raw::c_void,
957 start: UChar32,
958 limit: UChar32,
959 type_: UCharCategory,
960 ) -> UBool,
961>;
962extern "C" {
963 pub fn u_enumCharTypes_74(
964 enumRange: UCharEnumTypeRange,
965 context: *const ::std::os::raw::c_void,
966 );
967}
968extern "C" {
969 pub fn u_getCombiningClass_74(c: UChar32) -> u8;
970}
971extern "C" {
972 pub fn u_charDigitValue_74(c: UChar32) -> i32;
973}
974extern "C" {
975 pub fn u_charName_74(
976 code: UChar32,
977 nameChoice: UCharNameChoice,
978 buffer: *mut ::std::os::raw::c_char,
979 bufferLength: i32,
980 pErrorCode: *mut UErrorCode,
981 ) -> i32;
982}
983extern "C" {
984 pub fn u_getISOComment_74(
985 c: UChar32,
986 dest: *mut ::std::os::raw::c_char,
987 destCapacity: i32,
988 pErrorCode: *mut UErrorCode,
989 ) -> i32;
990}
991extern "C" {
992 pub fn u_charFromName_74(
993 nameChoice: UCharNameChoice,
994 name: *const ::std::os::raw::c_char,
995 pErrorCode: *mut UErrorCode,
996 ) -> UChar32;
997}
998pub type UEnumCharNamesFn = ::std::option::Option<
999 unsafe extern "C" fn(
1000 context: *mut ::std::os::raw::c_void,
1001 code: UChar32,
1002 nameChoice: UCharNameChoice,
1003 name: *const ::std::os::raw::c_char,
1004 length: i32,
1005 ) -> UBool,
1006>;
1007extern "C" {
1008 pub fn u_enumCharNames_74(
1009 start: UChar32,
1010 limit: UChar32,
1011 fn_: UEnumCharNamesFn,
1012 context: *mut ::std::os::raw::c_void,
1013 nameChoice: UCharNameChoice,
1014 pErrorCode: *mut UErrorCode,
1015 );
1016}
1017extern "C" {
1018 pub fn u_getPropertyName_74(
1019 property: UProperty,
1020 nameChoice: UPropertyNameChoice,
1021 ) -> *const ::std::os::raw::c_char;
1022}
1023extern "C" {
1024 pub fn u_getPropertyEnum_74(alias: *const ::std::os::raw::c_char) -> UProperty;
1025}
1026extern "C" {
1027 pub fn u_getPropertyValueName_74(
1028 property: UProperty,
1029 value: i32,
1030 nameChoice: UPropertyNameChoice,
1031 ) -> *const ::std::os::raw::c_char;
1032}
1033extern "C" {
1034 pub fn u_getPropertyValueEnum_74(
1035 property: UProperty,
1036 alias: *const ::std::os::raw::c_char,
1037 ) -> i32;
1038}
1039extern "C" {
1040 pub fn u_isIDStart_74(c: UChar32) -> UBool;
1041}
1042extern "C" {
1043 pub fn u_isIDPart_74(c: UChar32) -> UBool;
1044}
1045extern "C" {
1046 pub fn u_isIDIgnorable_74(c: UChar32) -> UBool;
1047}
1048extern "C" {
1049 pub fn u_isJavaIDStart_74(c: UChar32) -> UBool;
1050}
1051extern "C" {
1052 pub fn u_isJavaIDPart_74(c: UChar32) -> UBool;
1053}
1054extern "C" {
1055 pub fn u_tolower_74(c: UChar32) -> UChar32;
1056}
1057extern "C" {
1058 pub fn u_toupper_74(c: UChar32) -> UChar32;
1059}
1060extern "C" {
1061 pub fn u_totitle_74(c: UChar32) -> UChar32;
1062}
1063extern "C" {
1064 pub fn u_foldCase_74(c: UChar32, options: u32) -> UChar32;
1065}
1066extern "C" {
1067 pub fn u_digit_74(ch: UChar32, radix: i8) -> i32;
1068}
1069extern "C" {
1070 pub fn u_forDigit_74(digit: i32, radix: i8) -> UChar32;
1071}
1072extern "C" {
1073 pub fn u_charAge_74(c: UChar32, versionArray: *mut u8);
1074}
1075extern "C" {
1076 pub fn u_getUnicodeVersion_74(versionArray: *mut u8);
1077}
1078extern "C" {
1079 pub fn u_getFC_NFKC_Closure_74(
1080 c: UChar32,
1081 dest: *mut UChar,
1082 destCapacity: i32,
1083 pErrorCode: *mut UErrorCode,
1084 ) -> i32;
1085}
1086extern "C" {
1087 pub fn utext_close_74(ut: *mut UText) -> *mut UText;
1088}
1089extern "C" {
1090 pub fn utext_openUTF8_74(
1091 ut: *mut UText,
1092 s: *const ::std::os::raw::c_char,
1093 length: i64,
1094 status: *mut UErrorCode,
1095 ) -> *mut UText;
1096}
1097extern "C" {
1098 pub fn utext_openUChars_74(
1099 ut: *mut UText,
1100 s: *const UChar,
1101 length: i64,
1102 status: *mut UErrorCode,
1103 ) -> *mut UText;
1104}
1105extern "C" {
1106 pub fn utext_clone_74(
1107 dest: *mut UText,
1108 src: *const UText,
1109 deep: UBool,
1110 readOnly: UBool,
1111 status: *mut UErrorCode,
1112 ) -> *mut UText;
1113}
1114extern "C" {
1115 pub fn utext_equals_74(a: *const UText, b: *const UText) -> UBool;
1116}
1117extern "C" {
1118 pub fn utext_nativeLength_74(ut: *mut UText) -> i64;
1119}
1120extern "C" {
1121 pub fn utext_isLengthExpensive_74(ut: *const UText) -> UBool;
1122}
1123extern "C" {
1124 pub fn utext_char32At_74(ut: *mut UText, nativeIndex: i64) -> UChar32;
1125}
1126extern "C" {
1127 pub fn utext_current32_74(ut: *mut UText) -> UChar32;
1128}
1129extern "C" {
1130 pub fn utext_next32_74(ut: *mut UText) -> UChar32;
1131}
1132extern "C" {
1133 pub fn utext_previous32_74(ut: *mut UText) -> UChar32;
1134}
1135extern "C" {
1136 pub fn utext_next32From_74(ut: *mut UText, nativeIndex: i64) -> UChar32;
1137}
1138extern "C" {
1139 pub fn utext_previous32From_74(ut: *mut UText, nativeIndex: i64) -> UChar32;
1140}
1141extern "C" {
1142 pub fn utext_getNativeIndex_74(ut: *const UText) -> i64;
1143}
1144extern "C" {
1145 pub fn utext_setNativeIndex_74(ut: *mut UText, nativeIndex: i64);
1146}
1147extern "C" {
1148 pub fn utext_moveIndex32_74(ut: *mut UText, delta: i32) -> UBool;
1149}
1150extern "C" {
1151 pub fn utext_getPreviousNativeIndex_74(ut: *mut UText) -> i64;
1152}
1153extern "C" {
1154 pub fn utext_extract_74(
1155 ut: *mut UText,
1156 nativeStart: i64,
1157 nativeLimit: i64,
1158 dest: *mut UChar,
1159 destCapacity: i32,
1160 status: *mut UErrorCode,
1161 ) -> i32;
1162}
1163extern "C" {
1164 pub fn utext_isWritable_74(ut: *const UText) -> UBool;
1165}
1166extern "C" {
1167 pub fn utext_hasMetaData_74(ut: *const UText) -> UBool;
1168}
1169extern "C" {
1170 pub fn utext_replace_74(
1171 ut: *mut UText,
1172 nativeStart: i64,
1173 nativeLimit: i64,
1174 replacementText: *const UChar,
1175 replacementLength: i32,
1176 status: *mut UErrorCode,
1177 ) -> i32;
1178}
1179extern "C" {
1180 pub fn utext_copy_74(
1181 ut: *mut UText,
1182 nativeStart: i64,
1183 nativeLimit: i64,
1184 destIndex: i64,
1185 move_: UBool,
1186 status: *mut UErrorCode,
1187 );
1188}
1189extern "C" {
1190 pub fn utext_freeze_74(ut: *mut UText);
1191}
1192pub type UTextClone = ::std::option::Option<
1193 unsafe extern "C" fn(
1194 dest: *mut UText,
1195 src: *const UText,
1196 deep: UBool,
1197 status: *mut UErrorCode,
1198 ) -> *mut UText,
1199>;
1200pub type UTextNativeLength = ::std::option::Option<unsafe extern "C" fn(ut: *mut UText) -> i64>;
1201pub type UTextAccess = ::std::option::Option<
1202 unsafe extern "C" fn(ut: *mut UText, nativeIndex: i64, forward: UBool) -> UBool,
1203>;
1204pub type UTextExtract = ::std::option::Option<
1205 unsafe extern "C" fn(
1206 ut: *mut UText,
1207 nativeStart: i64,
1208 nativeLimit: i64,
1209 dest: *mut UChar,
1210 destCapacity: i32,
1211 status: *mut UErrorCode,
1212 ) -> i32,
1213>;
1214pub type UTextReplace = ::std::option::Option<
1215 unsafe extern "C" fn(
1216 ut: *mut UText,
1217 nativeStart: i64,
1218 nativeLimit: i64,
1219 replacementText: *const UChar,
1220 replacmentLength: i32,
1221 status: *mut UErrorCode,
1222 ) -> i32,
1223>;
1224pub type UTextCopy = ::std::option::Option<
1225 unsafe extern "C" fn(
1226 ut: *mut UText,
1227 nativeStart: i64,
1228 nativeLimit: i64,
1229 nativeDest: i64,
1230 move_: UBool,
1231 status: *mut UErrorCode,
1232 ),
1233>;
1234pub type UTextMapOffsetToNative =
1235 ::std::option::Option<unsafe extern "C" fn(ut: *const UText) -> i64>;
1236pub type UTextMapNativeIndexToUTF16 =
1237 ::std::option::Option<unsafe extern "C" fn(ut: *const UText, nativeIndex: i64) -> i32>;
1238pub type UTextClose = ::std::option::Option<unsafe extern "C" fn(ut: *mut UText)>;
1239#[repr(C)]
1240#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, PartialEq)]
1241pub struct UTextFuncs {
1242 pub tableSize: i32,
1243 pub reserved1: i32,
1244 pub reserved2: i32,
1245 pub reserved3: i32,
1246 pub clone: UTextClone,
1247 pub nativeLength: UTextNativeLength,
1248 pub access: UTextAccess,
1249 pub extract: UTextExtract,
1250 pub replace: UTextReplace,
1251 pub copy: UTextCopy,
1252 pub mapOffsetToNative: UTextMapOffsetToNative,
1253 pub mapNativeIndexToUTF16: UTextMapNativeIndexToUTF16,
1254 pub close: UTextClose,
1255 pub spare1: UTextClose,
1256 pub spare2: UTextClose,
1257 pub spare3: UTextClose,
1258}
1259#[test]
1260fn bindgen_test_layout_UTextFuncs() {
1261 const UNINIT: ::std::mem::MaybeUninit<UTextFuncs> = ::std::mem::MaybeUninit::uninit();
1262 let ptr = UNINIT.as_ptr();
1263 assert_eq!(
1264 ::std::mem::size_of::<UTextFuncs>(),
1265 112usize,
1266 concat!("Size of: ", stringify!(UTextFuncs))
1267 );
1268 assert_eq!(
1269 ::std::mem::align_of::<UTextFuncs>(),
1270 8usize,
1271 concat!("Alignment of ", stringify!(UTextFuncs))
1272 );
1273 assert_eq!(
1274 unsafe { ::std::ptr::addr_of!((*ptr).tableSize) as usize - ptr as usize },
1275 0usize,
1276 concat!(
1277 "Offset of field: ",
1278 stringify!(UTextFuncs),
1279 "::",
1280 stringify!(tableSize)
1281 )
1282 );
1283 assert_eq!(
1284 unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
1285 4usize,
1286 concat!(
1287 "Offset of field: ",
1288 stringify!(UTextFuncs),
1289 "::",
1290 stringify!(reserved1)
1291 )
1292 );
1293 assert_eq!(
1294 unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
1295 8usize,
1296 concat!(
1297 "Offset of field: ",
1298 stringify!(UTextFuncs),
1299 "::",
1300 stringify!(reserved2)
1301 )
1302 );
1303 assert_eq!(
1304 unsafe { ::std::ptr::addr_of!((*ptr).reserved3) as usize - ptr as usize },
1305 12usize,
1306 concat!(
1307 "Offset of field: ",
1308 stringify!(UTextFuncs),
1309 "::",
1310 stringify!(reserved3)
1311 )
1312 );
1313 assert_eq!(
1314 unsafe { ::std::ptr::addr_of!((*ptr).clone) as usize - ptr as usize },
1315 16usize,
1316 concat!(
1317 "Offset of field: ",
1318 stringify!(UTextFuncs),
1319 "::",
1320 stringify!(clone)
1321 )
1322 );
1323 assert_eq!(
1324 unsafe { ::std::ptr::addr_of!((*ptr).nativeLength) as usize - ptr as usize },
1325 24usize,
1326 concat!(
1327 "Offset of field: ",
1328 stringify!(UTextFuncs),
1329 "::",
1330 stringify!(nativeLength)
1331 )
1332 );
1333 assert_eq!(
1334 unsafe { ::std::ptr::addr_of!((*ptr).access) as usize - ptr as usize },
1335 32usize,
1336 concat!(
1337 "Offset of field: ",
1338 stringify!(UTextFuncs),
1339 "::",
1340 stringify!(access)
1341 )
1342 );
1343 assert_eq!(
1344 unsafe { ::std::ptr::addr_of!((*ptr).extract) as usize - ptr as usize },
1345 40usize,
1346 concat!(
1347 "Offset of field: ",
1348 stringify!(UTextFuncs),
1349 "::",
1350 stringify!(extract)
1351 )
1352 );
1353 assert_eq!(
1354 unsafe { ::std::ptr::addr_of!((*ptr).replace) as usize - ptr as usize },
1355 48usize,
1356 concat!(
1357 "Offset of field: ",
1358 stringify!(UTextFuncs),
1359 "::",
1360 stringify!(replace)
1361 )
1362 );
1363 assert_eq!(
1364 unsafe { ::std::ptr::addr_of!((*ptr).copy) as usize - ptr as usize },
1365 56usize,
1366 concat!(
1367 "Offset of field: ",
1368 stringify!(UTextFuncs),
1369 "::",
1370 stringify!(copy)
1371 )
1372 );
1373 assert_eq!(
1374 unsafe { ::std::ptr::addr_of!((*ptr).mapOffsetToNative) as usize - ptr as usize },
1375 64usize,
1376 concat!(
1377 "Offset of field: ",
1378 stringify!(UTextFuncs),
1379 "::",
1380 stringify!(mapOffsetToNative)
1381 )
1382 );
1383 assert_eq!(
1384 unsafe { ::std::ptr::addr_of!((*ptr).mapNativeIndexToUTF16) as usize - ptr as usize },
1385 72usize,
1386 concat!(
1387 "Offset of field: ",
1388 stringify!(UTextFuncs),
1389 "::",
1390 stringify!(mapNativeIndexToUTF16)
1391 )
1392 );
1393 assert_eq!(
1394 unsafe { ::std::ptr::addr_of!((*ptr).close) as usize - ptr as usize },
1395 80usize,
1396 concat!(
1397 "Offset of field: ",
1398 stringify!(UTextFuncs),
1399 "::",
1400 stringify!(close)
1401 )
1402 );
1403 assert_eq!(
1404 unsafe { ::std::ptr::addr_of!((*ptr).spare1) as usize - ptr as usize },
1405 88usize,
1406 concat!(
1407 "Offset of field: ",
1408 stringify!(UTextFuncs),
1409 "::",
1410 stringify!(spare1)
1411 )
1412 );
1413 assert_eq!(
1414 unsafe { ::std::ptr::addr_of!((*ptr).spare2) as usize - ptr as usize },
1415 96usize,
1416 concat!(
1417 "Offset of field: ",
1418 stringify!(UTextFuncs),
1419 "::",
1420 stringify!(spare2)
1421 )
1422 );
1423 assert_eq!(
1424 unsafe { ::std::ptr::addr_of!((*ptr).spare3) as usize - ptr as usize },
1425 104usize,
1426 concat!(
1427 "Offset of field: ",
1428 stringify!(UTextFuncs),
1429 "::",
1430 stringify!(spare3)
1431 )
1432 );
1433}
1434#[repr(C)]
1435#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq)]
1436pub struct UText {
1437 pub magic: u32,
1438 pub flags: i32,
1439 pub providerProperties: i32,
1440 pub sizeOfStruct: i32,
1441 pub chunkNativeLimit: i64,
1442 pub extraSize: i32,
1443 pub nativeIndexingLimit: i32,
1444 pub chunkNativeStart: i64,
1445 pub chunkOffset: i32,
1446 pub chunkLength: i32,
1447 pub chunkContents: *const UChar,
1448 pub pFuncs: *const UTextFuncs,
1449 pub pExtra: *mut ::std::os::raw::c_void,
1450 pub context: *const ::std::os::raw::c_void,
1451 pub p: *const ::std::os::raw::c_void,
1452 pub q: *const ::std::os::raw::c_void,
1453 pub r: *const ::std::os::raw::c_void,
1454 pub privP: *mut ::std::os::raw::c_void,
1455 pub a: i64,
1456 pub b: i32,
1457 pub c: i32,
1458 pub privA: i64,
1459 pub privB: i32,
1460 pub privC: i32,
1461}
1462#[test]
1463fn bindgen_test_layout_UText() {
1464 const UNINIT: ::std::mem::MaybeUninit<UText> = ::std::mem::MaybeUninit::uninit();
1465 let ptr = UNINIT.as_ptr();
1466 assert_eq!(
1467 ::std::mem::size_of::<UText>(),
1468 144usize,
1469 concat!("Size of: ", stringify!(UText))
1470 );
1471 assert_eq!(
1472 ::std::mem::align_of::<UText>(),
1473 8usize,
1474 concat!("Alignment of ", stringify!(UText))
1475 );
1476 assert_eq!(
1477 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
1478 0usize,
1479 concat!(
1480 "Offset of field: ",
1481 stringify!(UText),
1482 "::",
1483 stringify!(magic)
1484 )
1485 );
1486 assert_eq!(
1487 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
1488 4usize,
1489 concat!(
1490 "Offset of field: ",
1491 stringify!(UText),
1492 "::",
1493 stringify!(flags)
1494 )
1495 );
1496 assert_eq!(
1497 unsafe { ::std::ptr::addr_of!((*ptr).providerProperties) as usize - ptr as usize },
1498 8usize,
1499 concat!(
1500 "Offset of field: ",
1501 stringify!(UText),
1502 "::",
1503 stringify!(providerProperties)
1504 )
1505 );
1506 assert_eq!(
1507 unsafe { ::std::ptr::addr_of!((*ptr).sizeOfStruct) as usize - ptr as usize },
1508 12usize,
1509 concat!(
1510 "Offset of field: ",
1511 stringify!(UText),
1512 "::",
1513 stringify!(sizeOfStruct)
1514 )
1515 );
1516 assert_eq!(
1517 unsafe { ::std::ptr::addr_of!((*ptr).chunkNativeLimit) as usize - ptr as usize },
1518 16usize,
1519 concat!(
1520 "Offset of field: ",
1521 stringify!(UText),
1522 "::",
1523 stringify!(chunkNativeLimit)
1524 )
1525 );
1526 assert_eq!(
1527 unsafe { ::std::ptr::addr_of!((*ptr).extraSize) as usize - ptr as usize },
1528 24usize,
1529 concat!(
1530 "Offset of field: ",
1531 stringify!(UText),
1532 "::",
1533 stringify!(extraSize)
1534 )
1535 );
1536 assert_eq!(
1537 unsafe { ::std::ptr::addr_of!((*ptr).nativeIndexingLimit) as usize - ptr as usize },
1538 28usize,
1539 concat!(
1540 "Offset of field: ",
1541 stringify!(UText),
1542 "::",
1543 stringify!(nativeIndexingLimit)
1544 )
1545 );
1546 assert_eq!(
1547 unsafe { ::std::ptr::addr_of!((*ptr).chunkNativeStart) as usize - ptr as usize },
1548 32usize,
1549 concat!(
1550 "Offset of field: ",
1551 stringify!(UText),
1552 "::",
1553 stringify!(chunkNativeStart)
1554 )
1555 );
1556 assert_eq!(
1557 unsafe { ::std::ptr::addr_of!((*ptr).chunkOffset) as usize - ptr as usize },
1558 40usize,
1559 concat!(
1560 "Offset of field: ",
1561 stringify!(UText),
1562 "::",
1563 stringify!(chunkOffset)
1564 )
1565 );
1566 assert_eq!(
1567 unsafe { ::std::ptr::addr_of!((*ptr).chunkLength) as usize - ptr as usize },
1568 44usize,
1569 concat!(
1570 "Offset of field: ",
1571 stringify!(UText),
1572 "::",
1573 stringify!(chunkLength)
1574 )
1575 );
1576 assert_eq!(
1577 unsafe { ::std::ptr::addr_of!((*ptr).chunkContents) as usize - ptr as usize },
1578 48usize,
1579 concat!(
1580 "Offset of field: ",
1581 stringify!(UText),
1582 "::",
1583 stringify!(chunkContents)
1584 )
1585 );
1586 assert_eq!(
1587 unsafe { ::std::ptr::addr_of!((*ptr).pFuncs) as usize - ptr as usize },
1588 56usize,
1589 concat!(
1590 "Offset of field: ",
1591 stringify!(UText),
1592 "::",
1593 stringify!(pFuncs)
1594 )
1595 );
1596 assert_eq!(
1597 unsafe { ::std::ptr::addr_of!((*ptr).pExtra) as usize - ptr as usize },
1598 64usize,
1599 concat!(
1600 "Offset of field: ",
1601 stringify!(UText),
1602 "::",
1603 stringify!(pExtra)
1604 )
1605 );
1606 assert_eq!(
1607 unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
1608 72usize,
1609 concat!(
1610 "Offset of field: ",
1611 stringify!(UText),
1612 "::",
1613 stringify!(context)
1614 )
1615 );
1616 assert_eq!(
1617 unsafe { ::std::ptr::addr_of!((*ptr).p) as usize - ptr as usize },
1618 80usize,
1619 concat!("Offset of field: ", stringify!(UText), "::", stringify!(p))
1620 );
1621 assert_eq!(
1622 unsafe { ::std::ptr::addr_of!((*ptr).q) as usize - ptr as usize },
1623 88usize,
1624 concat!("Offset of field: ", stringify!(UText), "::", stringify!(q))
1625 );
1626 assert_eq!(
1627 unsafe { ::std::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
1628 96usize,
1629 concat!("Offset of field: ", stringify!(UText), "::", stringify!(r))
1630 );
1631 assert_eq!(
1632 unsafe { ::std::ptr::addr_of!((*ptr).privP) as usize - ptr as usize },
1633 104usize,
1634 concat!(
1635 "Offset of field: ",
1636 stringify!(UText),
1637 "::",
1638 stringify!(privP)
1639 )
1640 );
1641 assert_eq!(
1642 unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
1643 112usize,
1644 concat!("Offset of field: ", stringify!(UText), "::", stringify!(a))
1645 );
1646 assert_eq!(
1647 unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
1648 120usize,
1649 concat!("Offset of field: ", stringify!(UText), "::", stringify!(b))
1650 );
1651 assert_eq!(
1652 unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
1653 124usize,
1654 concat!("Offset of field: ", stringify!(UText), "::", stringify!(c))
1655 );
1656 assert_eq!(
1657 unsafe { ::std::ptr::addr_of!((*ptr).privA) as usize - ptr as usize },
1658 128usize,
1659 concat!(
1660 "Offset of field: ",
1661 stringify!(UText),
1662 "::",
1663 stringify!(privA)
1664 )
1665 );
1666 assert_eq!(
1667 unsafe { ::std::ptr::addr_of!((*ptr).privB) as usize - ptr as usize },
1668 136usize,
1669 concat!(
1670 "Offset of field: ",
1671 stringify!(UText),
1672 "::",
1673 stringify!(privB)
1674 )
1675 );
1676 assert_eq!(
1677 unsafe { ::std::ptr::addr_of!((*ptr).privC) as usize - ptr as usize },
1678 140usize,
1679 concat!(
1680 "Offset of field: ",
1681 stringify!(UText),
1682 "::",
1683 stringify!(privC)
1684 )
1685 );
1686}
1687impl Default for UText {
1688 fn default() -> Self {
1689 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1690 unsafe {
1691 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1692 s.assume_init()
1693 }
1694 }
1695}
1696extern "C" {
1697 pub fn utext_setup_74(ut: *mut UText, extraSpace: i32, status: *mut UErrorCode) -> *mut UText;
1698}
1699#[repr(C)]
1700#[derive(Debug, Copy, Clone)]
1701pub struct UBreakIterator {
1702 _unused: [u8; 0],
1703}
1704#[repr(C)]
1705#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, PartialEq)]
1706pub struct UParseError {
1707 pub line: i32,
1708 pub offset: i32,
1709 pub preContext: [UChar; 16usize],
1710 pub postContext: [UChar; 16usize],
1711}
1712#[test]
1713fn bindgen_test_layout_UParseError() {
1714 const UNINIT: ::std::mem::MaybeUninit<UParseError> = ::std::mem::MaybeUninit::uninit();
1715 let ptr = UNINIT.as_ptr();
1716 assert_eq!(
1717 ::std::mem::size_of::<UParseError>(),
1718 72usize,
1719 concat!("Size of: ", stringify!(UParseError))
1720 );
1721 assert_eq!(
1722 ::std::mem::align_of::<UParseError>(),
1723 4usize,
1724 concat!("Alignment of ", stringify!(UParseError))
1725 );
1726 assert_eq!(
1727 unsafe { ::std::ptr::addr_of!((*ptr).line) as usize - ptr as usize },
1728 0usize,
1729 concat!(
1730 "Offset of field: ",
1731 stringify!(UParseError),
1732 "::",
1733 stringify!(line)
1734 )
1735 );
1736 assert_eq!(
1737 unsafe { ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
1738 4usize,
1739 concat!(
1740 "Offset of field: ",
1741 stringify!(UParseError),
1742 "::",
1743 stringify!(offset)
1744 )
1745 );
1746 assert_eq!(
1747 unsafe { ::std::ptr::addr_of!((*ptr).preContext) as usize - ptr as usize },
1748 8usize,
1749 concat!(
1750 "Offset of field: ",
1751 stringify!(UParseError),
1752 "::",
1753 stringify!(preContext)
1754 )
1755 );
1756 assert_eq!(
1757 unsafe { ::std::ptr::addr_of!((*ptr).postContext) as usize - ptr as usize },
1758 40usize,
1759 concat!(
1760 "Offset of field: ",
1761 stringify!(UParseError),
1762 "::",
1763 stringify!(postContext)
1764 )
1765 );
1766}
1767#[repr(u32)]
1768#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
1769pub enum UBreakIteratorType {
1770 UBRK_CHARACTER = 0,
1771 UBRK_WORD = 1,
1772 UBRK_LINE = 2,
1773 UBRK_SENTENCE = 3,
1774 UBRK_TITLE = 4,
1775 UBRK_COUNT = 5,
1776}
1777impl UWordBreak {
1778 pub const UBRK_WORD_NUMBER: UWordBreak = UWordBreak::UBRK_WORD_NONE_LIMIT;
1779}
1780impl UWordBreak {
1781 pub const UBRK_WORD_LETTER: UWordBreak = UWordBreak::UBRK_WORD_NUMBER_LIMIT;
1782}
1783impl UWordBreak {
1784 pub const UBRK_WORD_KANA: UWordBreak = UWordBreak::UBRK_WORD_LETTER_LIMIT;
1785}
1786impl UWordBreak {
1787 pub const UBRK_WORD_IDEO: UWordBreak = UWordBreak::UBRK_WORD_KANA_LIMIT;
1788}
1789#[repr(u32)]
1790#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
1791pub enum UWordBreak {
1792 UBRK_WORD_NONE = 0,
1793 UBRK_WORD_NONE_LIMIT = 100,
1794 UBRK_WORD_NUMBER_LIMIT = 200,
1795 UBRK_WORD_LETTER_LIMIT = 300,
1796 UBRK_WORD_KANA_LIMIT = 400,
1797 UBRK_WORD_IDEO_LIMIT = 500,
1798}
1799impl ULineBreakTag {
1800 pub const UBRK_LINE_HARD: ULineBreakTag = ULineBreakTag::UBRK_LINE_SOFT_LIMIT;
1801}
1802#[repr(u32)]
1803#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
1804pub enum ULineBreakTag {
1805 UBRK_LINE_SOFT = 0,
1806 UBRK_LINE_SOFT_LIMIT = 100,
1807 UBRK_LINE_HARD_LIMIT = 200,
1808}
1809impl USentenceBreakTag {
1810 pub const UBRK_SENTENCE_SEP: USentenceBreakTag = USentenceBreakTag::UBRK_SENTENCE_TERM_LIMIT;
1811}
1812#[repr(u32)]
1813#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
1814pub enum USentenceBreakTag {
1815 UBRK_SENTENCE_TERM = 0,
1816 UBRK_SENTENCE_TERM_LIMIT = 100,
1817 UBRK_SENTENCE_SEP_LIMIT = 200,
1818}
1819extern "C" {
1820 pub fn ubrk_open_74(
1821 type_: UBreakIteratorType,
1822 locale: *const ::std::os::raw::c_char,
1823 text: *const UChar,
1824 textLength: i32,
1825 status: *mut UErrorCode,
1826 ) -> *mut UBreakIterator;
1827}
1828extern "C" {
1829 pub fn ubrk_openRules_74(
1830 rules: *const UChar,
1831 rulesLength: i32,
1832 text: *const UChar,
1833 textLength: i32,
1834 parseErr: *mut UParseError,
1835 status: *mut UErrorCode,
1836 ) -> *mut UBreakIterator;
1837}
1838extern "C" {
1839 pub fn ubrk_openBinaryRules_74(
1840 binaryRules: *const u8,
1841 rulesLength: i32,
1842 text: *const UChar,
1843 textLength: i32,
1844 status: *mut UErrorCode,
1845 ) -> *mut UBreakIterator;
1846}
1847extern "C" {
1848 pub fn ubrk_safeClone_74(
1849 bi: *const UBreakIterator,
1850 stackBuffer: *mut ::std::os::raw::c_void,
1851 pBufferSize: *mut i32,
1852 status: *mut UErrorCode,
1853 ) -> *mut UBreakIterator;
1854}
1855extern "C" {
1856 pub fn ubrk_clone_74(bi: *const UBreakIterator, status: *mut UErrorCode)
1857 -> *mut UBreakIterator;
1858}
1859extern "C" {
1860 pub fn ubrk_close_74(bi: *mut UBreakIterator);
1861}
1862extern "C" {
1863 pub fn ubrk_setText_74(
1864 bi: *mut UBreakIterator,
1865 text: *const UChar,
1866 textLength: i32,
1867 status: *mut UErrorCode,
1868 );
1869}
1870extern "C" {
1871 pub fn ubrk_setUText_74(bi: *mut UBreakIterator, text: *mut UText, status: *mut UErrorCode);
1872}
1873extern "C" {
1874 pub fn ubrk_current_74(bi: *const UBreakIterator) -> i32;
1875}
1876extern "C" {
1877 pub fn ubrk_next_74(bi: *mut UBreakIterator) -> i32;
1878}
1879extern "C" {
1880 pub fn ubrk_previous_74(bi: *mut UBreakIterator) -> i32;
1881}
1882extern "C" {
1883 pub fn ubrk_first_74(bi: *mut UBreakIterator) -> i32;
1884}
1885extern "C" {
1886 pub fn ubrk_last_74(bi: *mut UBreakIterator) -> i32;
1887}
1888extern "C" {
1889 pub fn ubrk_preceding_74(bi: *mut UBreakIterator, offset: i32) -> i32;
1890}
1891extern "C" {
1892 pub fn ubrk_following_74(bi: *mut UBreakIterator, offset: i32) -> i32;
1893}
1894extern "C" {
1895 pub fn ubrk_getAvailable_74(index: i32) -> *const ::std::os::raw::c_char;
1896}
1897extern "C" {
1898 pub fn ubrk_countAvailable_74() -> i32;
1899}
1900extern "C" {
1901 pub fn ubrk_isBoundary_74(bi: *mut UBreakIterator, offset: i32) -> UBool;
1902}
1903extern "C" {
1904 pub fn ubrk_getRuleStatus_74(bi: *mut UBreakIterator) -> i32;
1905}
1906extern "C" {
1907 pub fn ubrk_getRuleStatusVec_74(
1908 bi: *mut UBreakIterator,
1909 fillInVec: *mut i32,
1910 capacity: i32,
1911 status: *mut UErrorCode,
1912 ) -> i32;
1913}
1914extern "C" {
1915 pub fn ubrk_getLocaleByType_74(
1916 bi: *const UBreakIterator,
1917 type_: ULocDataLocaleType,
1918 status: *mut UErrorCode,
1919 ) -> *const ::std::os::raw::c_char;
1920}
1921extern "C" {
1922 pub fn ubrk_refreshUText_74(bi: *mut UBreakIterator, text: *mut UText, status: *mut UErrorCode);
1923}
1924extern "C" {
1925 pub fn ubrk_getBinaryRules_74(
1926 bi: *mut UBreakIterator,
1927 binaryRules: *mut u8,
1928 rulesCapacity: i32,
1929 status: *mut UErrorCode,
1930 ) -> i32;
1931}
1932pub type UCalendar = *mut ::std::os::raw::c_void;
1933impl UCalendarType {
1934 pub const UCAL_DEFAULT: UCalendarType = UCalendarType::UCAL_TRADITIONAL;
1935}
1936#[repr(u32)]
1937#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
1938pub enum UCalendarType {
1939 UCAL_TRADITIONAL = 0,
1940 UCAL_GREGORIAN = 1,
1941}
1942impl UCalendarDateFields {
1943 pub const UCAL_DAY_OF_MONTH: UCalendarDateFields = UCalendarDateFields::UCAL_DATE;
1944}
1945#[repr(u32)]
1946#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
1947pub enum UCalendarDateFields {
1948 UCAL_ERA = 0,
1949 UCAL_YEAR = 1,
1950 UCAL_MONTH = 2,
1951 UCAL_WEEK_OF_YEAR = 3,
1952 UCAL_WEEK_OF_MONTH = 4,
1953 UCAL_DATE = 5,
1954 UCAL_DAY_OF_YEAR = 6,
1955 UCAL_DAY_OF_WEEK = 7,
1956 UCAL_DAY_OF_WEEK_IN_MONTH = 8,
1957 UCAL_AM_PM = 9,
1958 UCAL_HOUR = 10,
1959 UCAL_HOUR_OF_DAY = 11,
1960 UCAL_MINUTE = 12,
1961 UCAL_SECOND = 13,
1962 UCAL_MILLISECOND = 14,
1963 UCAL_ZONE_OFFSET = 15,
1964 UCAL_DST_OFFSET = 16,
1965 UCAL_YEAR_WOY = 17,
1966 UCAL_DOW_LOCAL = 18,
1967 UCAL_EXTENDED_YEAR = 19,
1968 UCAL_JULIAN_DAY = 20,
1969 UCAL_MILLISECONDS_IN_DAY = 21,
1970 UCAL_IS_LEAP_MONTH = 22,
1971 UCAL_ORDINAL_MONTH = 23,
1972 UCAL_FIELD_COUNT = 24,
1973}
1974#[repr(u32)]
1975#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
1976pub enum UCalendarDaysOfWeek {
1977 UCAL_SUNDAY = 1,
1978 UCAL_MONDAY = 2,
1979 UCAL_TUESDAY = 3,
1980 UCAL_WEDNESDAY = 4,
1981 UCAL_THURSDAY = 5,
1982 UCAL_FRIDAY = 6,
1983 UCAL_SATURDAY = 7,
1984}
1985#[repr(u32)]
1986#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
1987pub enum UCalendarMonths {
1988 UCAL_JANUARY = 0,
1989 UCAL_FEBRUARY = 1,
1990 UCAL_MARCH = 2,
1991 UCAL_APRIL = 3,
1992 UCAL_MAY = 4,
1993 UCAL_JUNE = 5,
1994 UCAL_JULY = 6,
1995 UCAL_AUGUST = 7,
1996 UCAL_SEPTEMBER = 8,
1997 UCAL_OCTOBER = 9,
1998 UCAL_NOVEMBER = 10,
1999 UCAL_DECEMBER = 11,
2000 UCAL_UNDECIMBER = 12,
2001}
2002#[repr(u32)]
2003#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
2004pub enum UCalendarAMPMs {
2005 UCAL_AM = 0,
2006 UCAL_PM = 1,
2007}
2008#[repr(u32)]
2009#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
2010pub enum USystemTimeZoneType {
2011 UCAL_ZONE_TYPE_ANY = 0,
2012 UCAL_ZONE_TYPE_CANONICAL = 1,
2013 UCAL_ZONE_TYPE_CANONICAL_LOCATION = 2,
2014}
2015extern "C" {
2016 pub fn ucal_openTimeZoneIDEnumeration_74(
2017 zoneType: USystemTimeZoneType,
2018 region: *const ::std::os::raw::c_char,
2019 rawOffset: *const i32,
2020 ec: *mut UErrorCode,
2021 ) -> *mut UEnumeration;
2022}
2023extern "C" {
2024 pub fn ucal_openTimeZones_74(ec: *mut UErrorCode) -> *mut UEnumeration;
2025}
2026extern "C" {
2027 pub fn ucal_openCountryTimeZones_74(
2028 country: *const ::std::os::raw::c_char,
2029 ec: *mut UErrorCode,
2030 ) -> *mut UEnumeration;
2031}
2032extern "C" {
2033 pub fn ucal_getDefaultTimeZone_74(
2034 result: *mut UChar,
2035 resultCapacity: i32,
2036 ec: *mut UErrorCode,
2037 ) -> i32;
2038}
2039extern "C" {
2040 pub fn ucal_setDefaultTimeZone_74(zoneID: *const UChar, ec: *mut UErrorCode);
2041}
2042extern "C" {
2043 pub fn ucal_getHostTimeZone_74(
2044 result: *mut UChar,
2045 resultCapacity: i32,
2046 ec: *mut UErrorCode,
2047 ) -> i32;
2048}
2049extern "C" {
2050 pub fn ucal_getDSTSavings_74(zoneID: *const UChar, ec: *mut UErrorCode) -> i32;
2051}
2052extern "C" {
2053 pub fn ucal_getNow_74() -> UDate;
2054}
2055extern "C" {
2056 pub fn ucal_open_74(
2057 zoneID: *const UChar,
2058 len: i32,
2059 locale: *const ::std::os::raw::c_char,
2060 type_: UCalendarType,
2061 status: *mut UErrorCode,
2062 ) -> *mut UCalendar;
2063}
2064extern "C" {
2065 pub fn ucal_close_74(cal: *mut UCalendar);
2066}
2067extern "C" {
2068 pub fn ucal_clone_74(cal: *const UCalendar, status: *mut UErrorCode) -> *mut UCalendar;
2069}
2070extern "C" {
2071 pub fn ucal_setTimeZone_74(
2072 cal: *mut UCalendar,
2073 zoneID: *const UChar,
2074 len: i32,
2075 status: *mut UErrorCode,
2076 );
2077}
2078extern "C" {
2079 pub fn ucal_getTimeZoneID_74(
2080 cal: *const UCalendar,
2081 result: *mut UChar,
2082 resultLength: i32,
2083 status: *mut UErrorCode,
2084 ) -> i32;
2085}
2086#[repr(u32)]
2087#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
2088pub enum UCalendarDisplayNameType {
2089 UCAL_STANDARD = 0,
2090 UCAL_SHORT_STANDARD = 1,
2091 UCAL_DST = 2,
2092 UCAL_SHORT_DST = 3,
2093}
2094extern "C" {
2095 pub fn ucal_getTimeZoneDisplayName_74(
2096 cal: *const UCalendar,
2097 type_: UCalendarDisplayNameType,
2098 locale: *const ::std::os::raw::c_char,
2099 result: *mut UChar,
2100 resultLength: i32,
2101 status: *mut UErrorCode,
2102 ) -> i32;
2103}
2104extern "C" {
2105 pub fn ucal_inDaylightTime_74(cal: *const UCalendar, status: *mut UErrorCode) -> UBool;
2106}
2107extern "C" {
2108 pub fn ucal_setGregorianChange_74(
2109 cal: *mut UCalendar,
2110 date: UDate,
2111 pErrorCode: *mut UErrorCode,
2112 );
2113}
2114extern "C" {
2115 pub fn ucal_getGregorianChange_74(cal: *const UCalendar, pErrorCode: *mut UErrorCode) -> UDate;
2116}
2117#[repr(u32)]
2118#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
2119pub enum UCalendarAttribute {
2120 UCAL_LENIENT = 0,
2121 UCAL_FIRST_DAY_OF_WEEK = 1,
2122 UCAL_MINIMAL_DAYS_IN_FIRST_WEEK = 2,
2123 UCAL_REPEATED_WALL_TIME = 3,
2124 UCAL_SKIPPED_WALL_TIME = 4,
2125}
2126#[repr(u32)]
2127#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
2128pub enum UCalendarWallTimeOption {
2129 UCAL_WALLTIME_LAST = 0,
2130 UCAL_WALLTIME_FIRST = 1,
2131 UCAL_WALLTIME_NEXT_VALID = 2,
2132}
2133extern "C" {
2134 pub fn ucal_getAttribute_74(cal: *const UCalendar, attr: UCalendarAttribute) -> i32;
2135}
2136extern "C" {
2137 pub fn ucal_setAttribute_74(cal: *mut UCalendar, attr: UCalendarAttribute, newValue: i32);
2138}
2139extern "C" {
2140 pub fn ucal_getAvailable_74(localeIndex: i32) -> *const ::std::os::raw::c_char;
2141}
2142extern "C" {
2143 pub fn ucal_countAvailable_74() -> i32;
2144}
2145extern "C" {
2146 pub fn ucal_getMillis_74(cal: *const UCalendar, status: *mut UErrorCode) -> UDate;
2147}
2148extern "C" {
2149 pub fn ucal_setMillis_74(cal: *mut UCalendar, dateTime: UDate, status: *mut UErrorCode);
2150}
2151extern "C" {
2152 pub fn ucal_setDate_74(
2153 cal: *mut UCalendar,
2154 year: i32,
2155 month: i32,
2156 date: i32,
2157 status: *mut UErrorCode,
2158 );
2159}
2160extern "C" {
2161 pub fn ucal_setDateTime_74(
2162 cal: *mut UCalendar,
2163 year: i32,
2164 month: i32,
2165 date: i32,
2166 hour: i32,
2167 minute: i32,
2168 second: i32,
2169 status: *mut UErrorCode,
2170 );
2171}
2172extern "C" {
2173 pub fn ucal_equivalentTo_74(cal1: *const UCalendar, cal2: *const UCalendar) -> UBool;
2174}
2175extern "C" {
2176 pub fn ucal_add_74(
2177 cal: *mut UCalendar,
2178 field: UCalendarDateFields,
2179 amount: i32,
2180 status: *mut UErrorCode,
2181 );
2182}
2183extern "C" {
2184 pub fn ucal_roll_74(
2185 cal: *mut UCalendar,
2186 field: UCalendarDateFields,
2187 amount: i32,
2188 status: *mut UErrorCode,
2189 );
2190}
2191extern "C" {
2192 pub fn ucal_get_74(
2193 cal: *const UCalendar,
2194 field: UCalendarDateFields,
2195 status: *mut UErrorCode,
2196 ) -> i32;
2197}
2198extern "C" {
2199 pub fn ucal_set_74(cal: *mut UCalendar, field: UCalendarDateFields, value: i32);
2200}
2201extern "C" {
2202 pub fn ucal_isSet_74(cal: *const UCalendar, field: UCalendarDateFields) -> UBool;
2203}
2204extern "C" {
2205 pub fn ucal_clearField_74(cal: *mut UCalendar, field: UCalendarDateFields);
2206}
2207extern "C" {
2208 pub fn ucal_clear_74(calendar: *mut UCalendar);
2209}
2210#[repr(u32)]
2211#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
2212pub enum UCalendarLimitType {
2213 UCAL_MINIMUM = 0,
2214 UCAL_MAXIMUM = 1,
2215 UCAL_GREATEST_MINIMUM = 2,
2216 UCAL_LEAST_MAXIMUM = 3,
2217 UCAL_ACTUAL_MINIMUM = 4,
2218 UCAL_ACTUAL_MAXIMUM = 5,
2219}
2220extern "C" {
2221 pub fn ucal_getLimit_74(
2222 cal: *const UCalendar,
2223 field: UCalendarDateFields,
2224 type_: UCalendarLimitType,
2225 status: *mut UErrorCode,
2226 ) -> i32;
2227}
2228extern "C" {
2229 pub fn ucal_getLocaleByType_74(
2230 cal: *const UCalendar,
2231 type_: ULocDataLocaleType,
2232 status: *mut UErrorCode,
2233 ) -> *const ::std::os::raw::c_char;
2234}
2235extern "C" {
2236 pub fn ucal_getTZDataVersion_74(status: *mut UErrorCode) -> *const ::std::os::raw::c_char;
2237}
2238extern "C" {
2239 pub fn ucal_getCanonicalTimeZoneID_74(
2240 id: *const UChar,
2241 len: i32,
2242 result: *mut UChar,
2243 resultCapacity: i32,
2244 isSystemID: *mut UBool,
2245 status: *mut UErrorCode,
2246 ) -> i32;
2247}
2248extern "C" {
2249 pub fn ucal_getIanaTimeZoneID_74(
2250 id: *const UChar,
2251 len: i32,
2252 result: *mut UChar,
2253 resultCapacity: i32,
2254 status: *mut UErrorCode,
2255 ) -> i32;
2256}
2257extern "C" {
2258 pub fn ucal_getType_74(
2259 cal: *const UCalendar,
2260 status: *mut UErrorCode,
2261 ) -> *const ::std::os::raw::c_char;
2262}
2263extern "C" {
2264 pub fn ucal_getKeywordValuesForLocale_74(
2265 key: *const ::std::os::raw::c_char,
2266 locale: *const ::std::os::raw::c_char,
2267 commonlyUsed: UBool,
2268 status: *mut UErrorCode,
2269 ) -> *mut UEnumeration;
2270}
2271#[repr(u32)]
2272#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
2273pub enum UCalendarWeekdayType {
2274 UCAL_WEEKDAY = 0,
2275 UCAL_WEEKEND = 1,
2276 UCAL_WEEKEND_ONSET = 2,
2277 UCAL_WEEKEND_CEASE = 3,
2278}
2279extern "C" {
2280 pub fn ucal_getDayOfWeekType_74(
2281 cal: *const UCalendar,
2282 dayOfWeek: UCalendarDaysOfWeek,
2283 status: *mut UErrorCode,
2284 ) -> UCalendarWeekdayType;
2285}
2286extern "C" {
2287 pub fn ucal_getWeekendTransition_74(
2288 cal: *const UCalendar,
2289 dayOfWeek: UCalendarDaysOfWeek,
2290 status: *mut UErrorCode,
2291 ) -> i32;
2292}
2293extern "C" {
2294 pub fn ucal_isWeekend_74(cal: *const UCalendar, date: UDate, status: *mut UErrorCode) -> UBool;
2295}
2296extern "C" {
2297 pub fn ucal_getFieldDifference_74(
2298 cal: *mut UCalendar,
2299 target: UDate,
2300 field: UCalendarDateFields,
2301 status: *mut UErrorCode,
2302 ) -> i32;
2303}
2304#[repr(u32)]
2305#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
2306pub enum UTimeZoneTransitionType {
2307 UCAL_TZ_TRANSITION_NEXT = 0,
2308 UCAL_TZ_TRANSITION_NEXT_INCLUSIVE = 1,
2309 UCAL_TZ_TRANSITION_PREVIOUS = 2,
2310 UCAL_TZ_TRANSITION_PREVIOUS_INCLUSIVE = 3,
2311}
2312extern "C" {
2313 pub fn ucal_getTimeZoneTransitionDate_74(
2314 cal: *const UCalendar,
2315 type_: UTimeZoneTransitionType,
2316 transition: *mut UDate,
2317 status: *mut UErrorCode,
2318 ) -> UBool;
2319}
2320extern "C" {
2321 pub fn ucal_getWindowsTimeZoneID_74(
2322 id: *const UChar,
2323 len: i32,
2324 winid: *mut UChar,
2325 winidCapacity: i32,
2326 status: *mut UErrorCode,
2327 ) -> i32;
2328}
2329extern "C" {
2330 pub fn ucal_getTimeZoneIDForWindowsID_74(
2331 winid: *const UChar,
2332 len: i32,
2333 region: *const ::std::os::raw::c_char,
2334 id: *mut UChar,
2335 idCapacity: i32,
2336 status: *mut UErrorCode,
2337 ) -> i32;
2338}
2339#[repr(u32)]
2340#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
2341pub enum UTimeZoneLocalOption {
2342 UCAL_TZ_LOCAL_FORMER = 4,
2343 UCAL_TZ_LOCAL_LATTER = 12,
2344 UCAL_TZ_LOCAL_STANDARD_FORMER = 5,
2345 UCAL_TZ_LOCAL_STANDARD_LATTER = 13,
2346 UCAL_TZ_LOCAL_DAYLIGHT_FORMER = 7,
2347 UCAL_TZ_LOCAL_DAYLIGHT_LATTER = 15,
2348}
2349extern "C" {
2350 pub fn ucal_getTimeZoneOffsetFromLocal_74(
2351 cal: *const UCalendar,
2352 nonExistingTimeOpt: UTimeZoneLocalOption,
2353 duplicatedTimeOpt: UTimeZoneLocalOption,
2354 rawOffset: *mut i32,
2355 dstOffset: *mut i32,
2356 status: *mut UErrorCode,
2357 );
2358}
2359extern "C" {
2360 pub fn u_init_74(status: *mut UErrorCode);
2361}
2362extern "C" {
2363 pub fn u_cleanup_74();
2364}
2365pub type UMemAllocFn = ::std::option::Option<
2366 unsafe extern "C" fn(
2367 context: *const ::std::os::raw::c_void,
2368 size: usize,
2369 ) -> *mut ::std::os::raw::c_void,
2370>;
2371pub type UMemReallocFn = ::std::option::Option<
2372 unsafe extern "C" fn(
2373 context: *const ::std::os::raw::c_void,
2374 mem: *mut ::std::os::raw::c_void,
2375 size: usize,
2376 ) -> *mut ::std::os::raw::c_void,
2377>;
2378pub type UMemFreeFn = ::std::option::Option<
2379 unsafe extern "C" fn(context: *const ::std::os::raw::c_void, mem: *mut ::std::os::raw::c_void),
2380>;
2381extern "C" {
2382 pub fn u_setMemoryFunctions_74(
2383 context: *const ::std::os::raw::c_void,
2384 a: UMemAllocFn,
2385 r: UMemReallocFn,
2386 f: UMemFreeFn,
2387 status: *mut UErrorCode,
2388 );
2389}
2390pub type UMTX = *mut ::std::os::raw::c_void;
2391pub type UMtxInitFn = ::std::option::Option<
2392 unsafe extern "C" fn(
2393 context: *const ::std::os::raw::c_void,
2394 mutex: *mut UMTX,
2395 status: *mut UErrorCode,
2396 ),
2397>;
2398pub type UMtxFn = ::std::option::Option<
2399 unsafe extern "C" fn(context: *const ::std::os::raw::c_void, mutex: *mut UMTX),
2400>;
2401extern "C" {
2402 pub fn u_setMutexFunctions_74(
2403 context: *const ::std::os::raw::c_void,
2404 init: UMtxInitFn,
2405 destroy: UMtxFn,
2406 lock: UMtxFn,
2407 unlock: UMtxFn,
2408 status: *mut UErrorCode,
2409 );
2410}
2411pub type UMtxAtomicFn = ::std::option::Option<
2412 unsafe extern "C" fn(context: *const ::std::os::raw::c_void, p: *mut i32) -> i32,
2413>;
2414extern "C" {
2415 pub fn u_setAtomicIncDecFunctions_74(
2416 context: *const ::std::os::raw::c_void,
2417 inc: UMtxAtomicFn,
2418 dec: UMtxAtomicFn,
2419 status: *mut UErrorCode,
2420 );
2421}
2422#[repr(C)]
2423#[derive(Debug, Copy, Clone)]
2424pub struct UConverter {
2425 _unused: [u8; 0],
2426}
2427#[repr(u32)]
2428#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
2429pub enum UConverterCallbackReason {
2430 UCNV_UNASSIGNED = 0,
2431 UCNV_ILLEGAL = 1,
2432 UCNV_IRREGULAR = 2,
2433 UCNV_RESET = 3,
2434 UCNV_CLOSE = 4,
2435 UCNV_CLONE = 5,
2436}
2437#[repr(C)]
2438#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq)]
2439pub struct UConverterFromUnicodeArgs {
2440 pub size: u16,
2441 pub flush: UBool,
2442 pub converter: *mut UConverter,
2443 pub source: *const UChar,
2444 pub sourceLimit: *const UChar,
2445 pub target: *mut ::std::os::raw::c_char,
2446 pub targetLimit: *const ::std::os::raw::c_char,
2447 pub offsets: *mut i32,
2448}
2449#[test]
2450fn bindgen_test_layout_UConverterFromUnicodeArgs() {
2451 const UNINIT: ::std::mem::MaybeUninit<UConverterFromUnicodeArgs> =
2452 ::std::mem::MaybeUninit::uninit();
2453 let ptr = UNINIT.as_ptr();
2454 assert_eq!(
2455 ::std::mem::size_of::<UConverterFromUnicodeArgs>(),
2456 56usize,
2457 concat!("Size of: ", stringify!(UConverterFromUnicodeArgs))
2458 );
2459 assert_eq!(
2460 ::std::mem::align_of::<UConverterFromUnicodeArgs>(),
2461 8usize,
2462 concat!("Alignment of ", stringify!(UConverterFromUnicodeArgs))
2463 );
2464 assert_eq!(
2465 unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
2466 0usize,
2467 concat!(
2468 "Offset of field: ",
2469 stringify!(UConverterFromUnicodeArgs),
2470 "::",
2471 stringify!(size)
2472 )
2473 );
2474 assert_eq!(
2475 unsafe { ::std::ptr::addr_of!((*ptr).flush) as usize - ptr as usize },
2476 2usize,
2477 concat!(
2478 "Offset of field: ",
2479 stringify!(UConverterFromUnicodeArgs),
2480 "::",
2481 stringify!(flush)
2482 )
2483 );
2484 assert_eq!(
2485 unsafe { ::std::ptr::addr_of!((*ptr).converter) as usize - ptr as usize },
2486 8usize,
2487 concat!(
2488 "Offset of field: ",
2489 stringify!(UConverterFromUnicodeArgs),
2490 "::",
2491 stringify!(converter)
2492 )
2493 );
2494 assert_eq!(
2495 unsafe { ::std::ptr::addr_of!((*ptr).source) as usize - ptr as usize },
2496 16usize,
2497 concat!(
2498 "Offset of field: ",
2499 stringify!(UConverterFromUnicodeArgs),
2500 "::",
2501 stringify!(source)
2502 )
2503 );
2504 assert_eq!(
2505 unsafe { ::std::ptr::addr_of!((*ptr).sourceLimit) as usize - ptr as usize },
2506 24usize,
2507 concat!(
2508 "Offset of field: ",
2509 stringify!(UConverterFromUnicodeArgs),
2510 "::",
2511 stringify!(sourceLimit)
2512 )
2513 );
2514 assert_eq!(
2515 unsafe { ::std::ptr::addr_of!((*ptr).target) as usize - ptr as usize },
2516 32usize,
2517 concat!(
2518 "Offset of field: ",
2519 stringify!(UConverterFromUnicodeArgs),
2520 "::",
2521 stringify!(target)
2522 )
2523 );
2524 assert_eq!(
2525 unsafe { ::std::ptr::addr_of!((*ptr).targetLimit) as usize - ptr as usize },
2526 40usize,
2527 concat!(
2528 "Offset of field: ",
2529 stringify!(UConverterFromUnicodeArgs),
2530 "::",
2531 stringify!(targetLimit)
2532 )
2533 );
2534 assert_eq!(
2535 unsafe { ::std::ptr::addr_of!((*ptr).offsets) as usize - ptr as usize },
2536 48usize,
2537 concat!(
2538 "Offset of field: ",
2539 stringify!(UConverterFromUnicodeArgs),
2540 "::",
2541 stringify!(offsets)
2542 )
2543 );
2544}
2545impl Default for UConverterFromUnicodeArgs {
2546 fn default() -> Self {
2547 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2548 unsafe {
2549 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2550 s.assume_init()
2551 }
2552 }
2553}
2554#[repr(C)]
2555#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq)]
2556pub struct UConverterToUnicodeArgs {
2557 pub size: u16,
2558 pub flush: UBool,
2559 pub converter: *mut UConverter,
2560 pub source: *const ::std::os::raw::c_char,
2561 pub sourceLimit: *const ::std::os::raw::c_char,
2562 pub target: *mut UChar,
2563 pub targetLimit: *const UChar,
2564 pub offsets: *mut i32,
2565}
2566#[test]
2567fn bindgen_test_layout_UConverterToUnicodeArgs() {
2568 const UNINIT: ::std::mem::MaybeUninit<UConverterToUnicodeArgs> =
2569 ::std::mem::MaybeUninit::uninit();
2570 let ptr = UNINIT.as_ptr();
2571 assert_eq!(
2572 ::std::mem::size_of::<UConverterToUnicodeArgs>(),
2573 56usize,
2574 concat!("Size of: ", stringify!(UConverterToUnicodeArgs))
2575 );
2576 assert_eq!(
2577 ::std::mem::align_of::<UConverterToUnicodeArgs>(),
2578 8usize,
2579 concat!("Alignment of ", stringify!(UConverterToUnicodeArgs))
2580 );
2581 assert_eq!(
2582 unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
2583 0usize,
2584 concat!(
2585 "Offset of field: ",
2586 stringify!(UConverterToUnicodeArgs),
2587 "::",
2588 stringify!(size)
2589 )
2590 );
2591 assert_eq!(
2592 unsafe { ::std::ptr::addr_of!((*ptr).flush) as usize - ptr as usize },
2593 2usize,
2594 concat!(
2595 "Offset of field: ",
2596 stringify!(UConverterToUnicodeArgs),
2597 "::",
2598 stringify!(flush)
2599 )
2600 );
2601 assert_eq!(
2602 unsafe { ::std::ptr::addr_of!((*ptr).converter) as usize - ptr as usize },
2603 8usize,
2604 concat!(
2605 "Offset of field: ",
2606 stringify!(UConverterToUnicodeArgs),
2607 "::",
2608 stringify!(converter)
2609 )
2610 );
2611 assert_eq!(
2612 unsafe { ::std::ptr::addr_of!((*ptr).source) as usize - ptr as usize },
2613 16usize,
2614 concat!(
2615 "Offset of field: ",
2616 stringify!(UConverterToUnicodeArgs),
2617 "::",
2618 stringify!(source)
2619 )
2620 );
2621 assert_eq!(
2622 unsafe { ::std::ptr::addr_of!((*ptr).sourceLimit) as usize - ptr as usize },
2623 24usize,
2624 concat!(
2625 "Offset of field: ",
2626 stringify!(UConverterToUnicodeArgs),
2627 "::",
2628 stringify!(sourceLimit)
2629 )
2630 );
2631 assert_eq!(
2632 unsafe { ::std::ptr::addr_of!((*ptr).target) as usize - ptr as usize },
2633 32usize,
2634 concat!(
2635 "Offset of field: ",
2636 stringify!(UConverterToUnicodeArgs),
2637 "::",
2638 stringify!(target)
2639 )
2640 );
2641 assert_eq!(
2642 unsafe { ::std::ptr::addr_of!((*ptr).targetLimit) as usize - ptr as usize },
2643 40usize,
2644 concat!(
2645 "Offset of field: ",
2646 stringify!(UConverterToUnicodeArgs),
2647 "::",
2648 stringify!(targetLimit)
2649 )
2650 );
2651 assert_eq!(
2652 unsafe { ::std::ptr::addr_of!((*ptr).offsets) as usize - ptr as usize },
2653 48usize,
2654 concat!(
2655 "Offset of field: ",
2656 stringify!(UConverterToUnicodeArgs),
2657 "::",
2658 stringify!(offsets)
2659 )
2660 );
2661}
2662impl Default for UConverterToUnicodeArgs {
2663 fn default() -> Self {
2664 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2665 unsafe {
2666 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2667 s.assume_init()
2668 }
2669 }
2670}
2671impl UConverterType {
2672 pub const UCNV_LMBCS_LAST: UConverterType = UConverterType::UCNV_LMBCS_19;
2673}
2674#[repr(i32)]
2675#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
2676pub enum UConverterType {
2677 UCNV_UNSUPPORTED_CONVERTER = -1,
2678 UCNV_SBCS = 0,
2679 UCNV_DBCS = 1,
2680 UCNV_MBCS = 2,
2681 UCNV_LATIN_1 = 3,
2682 UCNV_UTF8 = 4,
2683 UCNV_UTF16_BigEndian = 5,
2684 UCNV_UTF16_LittleEndian = 6,
2685 UCNV_UTF32_BigEndian = 7,
2686 UCNV_UTF32_LittleEndian = 8,
2687 UCNV_EBCDIC_STATEFUL = 9,
2688 UCNV_ISO_2022 = 10,
2689 UCNV_LMBCS_1 = 11,
2690 UCNV_LMBCS_2 = 12,
2691 UCNV_LMBCS_3 = 13,
2692 UCNV_LMBCS_4 = 14,
2693 UCNV_LMBCS_5 = 15,
2694 UCNV_LMBCS_6 = 16,
2695 UCNV_LMBCS_8 = 17,
2696 UCNV_LMBCS_11 = 18,
2697 UCNV_LMBCS_16 = 19,
2698 UCNV_LMBCS_17 = 20,
2699 UCNV_LMBCS_18 = 21,
2700 UCNV_LMBCS_19 = 22,
2701 UCNV_HZ = 23,
2702 UCNV_SCSU = 24,
2703 UCNV_ISCII = 25,
2704 UCNV_US_ASCII = 26,
2705 UCNV_UTF7 = 27,
2706 UCNV_BOCU1 = 28,
2707 UCNV_UTF16 = 29,
2708 UCNV_UTF32 = 30,
2709 UCNV_CESU8 = 31,
2710 UCNV_IMAP_MAILBOX = 32,
2711 UCNV_COMPOUND_TEXT = 33,
2712 UCNV_NUMBER_OF_SUPPORTED_CONVERTER_TYPES = 34,
2713}
2714#[repr(i32)]
2715#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
2716pub enum UConverterPlatform {
2717 UCNV_UNKNOWN = -1,
2718 UCNV_IBM = 0,
2719}
2720pub type UConverterToUCallback = ::std::option::Option<
2721 unsafe extern "C" fn(
2722 context: *const ::std::os::raw::c_void,
2723 args: *mut UConverterToUnicodeArgs,
2724 codeUnits: *const ::std::os::raw::c_char,
2725 length: i32,
2726 reason: UConverterCallbackReason,
2727 pErrorCode: *mut UErrorCode,
2728 ),
2729>;
2730pub type UConverterFromUCallback = ::std::option::Option<
2731 unsafe extern "C" fn(
2732 context: *const ::std::os::raw::c_void,
2733 args: *mut UConverterFromUnicodeArgs,
2734 codeUnits: *const UChar,
2735 length: i32,
2736 codePoint: UChar32,
2737 reason: UConverterCallbackReason,
2738 pErrorCode: *mut UErrorCode,
2739 ),
2740>;
2741extern "C" {
2742 pub fn ucnv_compareNames_74(
2743 name1: *const ::std::os::raw::c_char,
2744 name2: *const ::std::os::raw::c_char,
2745 ) -> ::std::os::raw::c_int;
2746}
2747extern "C" {
2748 pub fn ucnv_open_74(
2749 converterName: *const ::std::os::raw::c_char,
2750 err: *mut UErrorCode,
2751 ) -> *mut UConverter;
2752}
2753extern "C" {
2754 pub fn ucnv_openU_74(name: *const UChar, err: *mut UErrorCode) -> *mut UConverter;
2755}
2756extern "C" {
2757 pub fn ucnv_openCCSID_74(
2758 codepage: i32,
2759 platform: UConverterPlatform,
2760 err: *mut UErrorCode,
2761 ) -> *mut UConverter;
2762}
2763extern "C" {
2764 pub fn ucnv_openPackage_74(
2765 packageName: *const ::std::os::raw::c_char,
2766 converterName: *const ::std::os::raw::c_char,
2767 err: *mut UErrorCode,
2768 ) -> *mut UConverter;
2769}
2770extern "C" {
2771 pub fn ucnv_clone_74(cnv: *const UConverter, status: *mut UErrorCode) -> *mut UConverter;
2772}
2773extern "C" {
2774 pub fn ucnv_safeClone_74(
2775 cnv: *const UConverter,
2776 stackBuffer: *mut ::std::os::raw::c_void,
2777 pBufferSize: *mut i32,
2778 status: *mut UErrorCode,
2779 ) -> *mut UConverter;
2780}
2781extern "C" {
2782 pub fn ucnv_close_74(converter: *mut UConverter);
2783}
2784extern "C" {
2785 pub fn ucnv_getSubstChars_74(
2786 converter: *const UConverter,
2787 subChars: *mut ::std::os::raw::c_char,
2788 len: *mut i8,
2789 err: *mut UErrorCode,
2790 );
2791}
2792extern "C" {
2793 pub fn ucnv_setSubstChars_74(
2794 converter: *mut UConverter,
2795 subChars: *const ::std::os::raw::c_char,
2796 len: i8,
2797 err: *mut UErrorCode,
2798 );
2799}
2800extern "C" {
2801 pub fn ucnv_setSubstString_74(
2802 cnv: *mut UConverter,
2803 s: *const UChar,
2804 length: i32,
2805 err: *mut UErrorCode,
2806 );
2807}
2808extern "C" {
2809 pub fn ucnv_getInvalidChars_74(
2810 converter: *const UConverter,
2811 errBytes: *mut ::std::os::raw::c_char,
2812 len: *mut i8,
2813 err: *mut UErrorCode,
2814 );
2815}
2816extern "C" {
2817 pub fn ucnv_getInvalidUChars_74(
2818 converter: *const UConverter,
2819 errUChars: *mut UChar,
2820 len: *mut i8,
2821 err: *mut UErrorCode,
2822 );
2823}
2824extern "C" {
2825 pub fn ucnv_reset_74(converter: *mut UConverter);
2826}
2827extern "C" {
2828 pub fn ucnv_resetToUnicode_74(converter: *mut UConverter);
2829}
2830extern "C" {
2831 pub fn ucnv_resetFromUnicode_74(converter: *mut UConverter);
2832}
2833extern "C" {
2834 pub fn ucnv_getMaxCharSize_74(converter: *const UConverter) -> i8;
2835}
2836extern "C" {
2837 pub fn ucnv_getMinCharSize_74(converter: *const UConverter) -> i8;
2838}
2839extern "C" {
2840 pub fn ucnv_getDisplayName_74(
2841 converter: *const UConverter,
2842 displayLocale: *const ::std::os::raw::c_char,
2843 displayName: *mut UChar,
2844 displayNameCapacity: i32,
2845 err: *mut UErrorCode,
2846 ) -> i32;
2847}
2848extern "C" {
2849 pub fn ucnv_getName_74(
2850 converter: *const UConverter,
2851 err: *mut UErrorCode,
2852 ) -> *const ::std::os::raw::c_char;
2853}
2854extern "C" {
2855 pub fn ucnv_getCCSID_74(converter: *const UConverter, err: *mut UErrorCode) -> i32;
2856}
2857extern "C" {
2858 pub fn ucnv_getPlatform_74(
2859 converter: *const UConverter,
2860 err: *mut UErrorCode,
2861 ) -> UConverterPlatform;
2862}
2863extern "C" {
2864 pub fn ucnv_getType_74(converter: *const UConverter) -> UConverterType;
2865}
2866extern "C" {
2867 pub fn ucnv_getStarters_74(
2868 converter: *const UConverter,
2869 starters: *mut UBool,
2870 err: *mut UErrorCode,
2871 );
2872}
2873#[repr(u32)]
2874#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
2875pub enum UConverterUnicodeSet {
2876 UCNV_ROUNDTRIP_SET = 0,
2877 UCNV_ROUNDTRIP_AND_FALLBACK_SET = 1,
2878 UCNV_SET_COUNT = 2,
2879}
2880extern "C" {
2881 pub fn ucnv_getUnicodeSet_74(
2882 cnv: *const UConverter,
2883 setFillIn: *mut USet,
2884 whichSet: UConverterUnicodeSet,
2885 pErrorCode: *mut UErrorCode,
2886 );
2887}
2888extern "C" {
2889 pub fn ucnv_getToUCallBack_74(
2890 converter: *const UConverter,
2891 action: *mut UConverterToUCallback,
2892 context: *mut *const ::std::os::raw::c_void,
2893 );
2894}
2895extern "C" {
2896 pub fn ucnv_getFromUCallBack_74(
2897 converter: *const UConverter,
2898 action: *mut UConverterFromUCallback,
2899 context: *mut *const ::std::os::raw::c_void,
2900 );
2901}
2902extern "C" {
2903 pub fn ucnv_setToUCallBack_74(
2904 converter: *mut UConverter,
2905 newAction: UConverterToUCallback,
2906 newContext: *const ::std::os::raw::c_void,
2907 oldAction: *mut UConverterToUCallback,
2908 oldContext: *mut *const ::std::os::raw::c_void,
2909 err: *mut UErrorCode,
2910 );
2911}
2912extern "C" {
2913 pub fn ucnv_setFromUCallBack_74(
2914 converter: *mut UConverter,
2915 newAction: UConverterFromUCallback,
2916 newContext: *const ::std::os::raw::c_void,
2917 oldAction: *mut UConverterFromUCallback,
2918 oldContext: *mut *const ::std::os::raw::c_void,
2919 err: *mut UErrorCode,
2920 );
2921}
2922extern "C" {
2923 pub fn ucnv_fromUnicode_74(
2924 converter: *mut UConverter,
2925 target: *mut *mut ::std::os::raw::c_char,
2926 targetLimit: *const ::std::os::raw::c_char,
2927 source: *mut *const UChar,
2928 sourceLimit: *const UChar,
2929 offsets: *mut i32,
2930 flush: UBool,
2931 err: *mut UErrorCode,
2932 );
2933}
2934extern "C" {
2935 pub fn ucnv_toUnicode_74(
2936 converter: *mut UConverter,
2937 target: *mut *mut UChar,
2938 targetLimit: *const UChar,
2939 source: *mut *const ::std::os::raw::c_char,
2940 sourceLimit: *const ::std::os::raw::c_char,
2941 offsets: *mut i32,
2942 flush: UBool,
2943 err: *mut UErrorCode,
2944 );
2945}
2946extern "C" {
2947 pub fn ucnv_fromUChars_74(
2948 cnv: *mut UConverter,
2949 dest: *mut ::std::os::raw::c_char,
2950 destCapacity: i32,
2951 src: *const UChar,
2952 srcLength: i32,
2953 pErrorCode: *mut UErrorCode,
2954 ) -> i32;
2955}
2956extern "C" {
2957 pub fn ucnv_toUChars_74(
2958 cnv: *mut UConverter,
2959 dest: *mut UChar,
2960 destCapacity: i32,
2961 src: *const ::std::os::raw::c_char,
2962 srcLength: i32,
2963 pErrorCode: *mut UErrorCode,
2964 ) -> i32;
2965}
2966extern "C" {
2967 pub fn ucnv_getNextUChar_74(
2968 converter: *mut UConverter,
2969 source: *mut *const ::std::os::raw::c_char,
2970 sourceLimit: *const ::std::os::raw::c_char,
2971 err: *mut UErrorCode,
2972 ) -> UChar32;
2973}
2974extern "C" {
2975 pub fn ucnv_convertEx_74(
2976 targetCnv: *mut UConverter,
2977 sourceCnv: *mut UConverter,
2978 target: *mut *mut ::std::os::raw::c_char,
2979 targetLimit: *const ::std::os::raw::c_char,
2980 source: *mut *const ::std::os::raw::c_char,
2981 sourceLimit: *const ::std::os::raw::c_char,
2982 pivotStart: *mut UChar,
2983 pivotSource: *mut *mut UChar,
2984 pivotTarget: *mut *mut UChar,
2985 pivotLimit: *const UChar,
2986 reset: UBool,
2987 flush: UBool,
2988 pErrorCode: *mut UErrorCode,
2989 );
2990}
2991extern "C" {
2992 pub fn ucnv_convert_74(
2993 toConverterName: *const ::std::os::raw::c_char,
2994 fromConverterName: *const ::std::os::raw::c_char,
2995 target: *mut ::std::os::raw::c_char,
2996 targetCapacity: i32,
2997 source: *const ::std::os::raw::c_char,
2998 sourceLength: i32,
2999 pErrorCode: *mut UErrorCode,
3000 ) -> i32;
3001}
3002extern "C" {
3003 pub fn ucnv_toAlgorithmic_74(
3004 algorithmicType: UConverterType,
3005 cnv: *mut UConverter,
3006 target: *mut ::std::os::raw::c_char,
3007 targetCapacity: i32,
3008 source: *const ::std::os::raw::c_char,
3009 sourceLength: i32,
3010 pErrorCode: *mut UErrorCode,
3011 ) -> i32;
3012}
3013extern "C" {
3014 pub fn ucnv_fromAlgorithmic_74(
3015 cnv: *mut UConverter,
3016 algorithmicType: UConverterType,
3017 target: *mut ::std::os::raw::c_char,
3018 targetCapacity: i32,
3019 source: *const ::std::os::raw::c_char,
3020 sourceLength: i32,
3021 pErrorCode: *mut UErrorCode,
3022 ) -> i32;
3023}
3024extern "C" {
3025 pub fn ucnv_flushCache_74() -> i32;
3026}
3027extern "C" {
3028 pub fn ucnv_countAvailable_74() -> i32;
3029}
3030extern "C" {
3031 pub fn ucnv_getAvailableName_74(n: i32) -> *const ::std::os::raw::c_char;
3032}
3033extern "C" {
3034 pub fn ucnv_openAllNames_74(pErrorCode: *mut UErrorCode) -> *mut UEnumeration;
3035}
3036extern "C" {
3037 pub fn ucnv_countAliases_74(
3038 alias: *const ::std::os::raw::c_char,
3039 pErrorCode: *mut UErrorCode,
3040 ) -> u16;
3041}
3042extern "C" {
3043 pub fn ucnv_getAlias_74(
3044 alias: *const ::std::os::raw::c_char,
3045 n: u16,
3046 pErrorCode: *mut UErrorCode,
3047 ) -> *const ::std::os::raw::c_char;
3048}
3049extern "C" {
3050 pub fn ucnv_getAliases_74(
3051 alias: *const ::std::os::raw::c_char,
3052 aliases: *mut *const ::std::os::raw::c_char,
3053 pErrorCode: *mut UErrorCode,
3054 );
3055}
3056extern "C" {
3057 pub fn ucnv_openStandardNames_74(
3058 convName: *const ::std::os::raw::c_char,
3059 standard: *const ::std::os::raw::c_char,
3060 pErrorCode: *mut UErrorCode,
3061 ) -> *mut UEnumeration;
3062}
3063extern "C" {
3064 pub fn ucnv_countStandards_74() -> u16;
3065}
3066extern "C" {
3067 pub fn ucnv_getStandard_74(
3068 n: u16,
3069 pErrorCode: *mut UErrorCode,
3070 ) -> *const ::std::os::raw::c_char;
3071}
3072extern "C" {
3073 pub fn ucnv_getStandardName_74(
3074 name: *const ::std::os::raw::c_char,
3075 standard: *const ::std::os::raw::c_char,
3076 pErrorCode: *mut UErrorCode,
3077 ) -> *const ::std::os::raw::c_char;
3078}
3079extern "C" {
3080 pub fn ucnv_getCanonicalName_74(
3081 alias: *const ::std::os::raw::c_char,
3082 standard: *const ::std::os::raw::c_char,
3083 pErrorCode: *mut UErrorCode,
3084 ) -> *const ::std::os::raw::c_char;
3085}
3086extern "C" {
3087 pub fn ucnv_getDefaultName_74() -> *const ::std::os::raw::c_char;
3088}
3089extern "C" {
3090 pub fn ucnv_setDefaultName_74(name: *const ::std::os::raw::c_char);
3091}
3092extern "C" {
3093 pub fn ucnv_fixFileSeparator_74(cnv: *const UConverter, source: *mut UChar, sourceLen: i32);
3094}
3095extern "C" {
3096 pub fn ucnv_isAmbiguous_74(cnv: *const UConverter) -> UBool;
3097}
3098extern "C" {
3099 pub fn ucnv_setFallback_74(cnv: *mut UConverter, usesFallback: UBool);
3100}
3101extern "C" {
3102 pub fn ucnv_usesFallback_74(cnv: *const UConverter) -> UBool;
3103}
3104extern "C" {
3105 pub fn ucnv_detectUnicodeSignature_74(
3106 source: *const ::std::os::raw::c_char,
3107 sourceLength: i32,
3108 signatureLength: *mut i32,
3109 pErrorCode: *mut UErrorCode,
3110 ) -> *const ::std::os::raw::c_char;
3111}
3112extern "C" {
3113 pub fn ucnv_fromUCountPending_74(cnv: *const UConverter, status: *mut UErrorCode) -> i32;
3114}
3115extern "C" {
3116 pub fn ucnv_toUCountPending_74(cnv: *const UConverter, status: *mut UErrorCode) -> i32;
3117}
3118extern "C" {
3119 pub fn ucnv_isFixedWidth_74(cnv: *mut UConverter, status: *mut UErrorCode) -> UBool;
3120}
3121#[repr(u32)]
3122#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
3123pub enum UCharIteratorOrigin {
3124 UITER_START = 0,
3125 UITER_CURRENT = 1,
3126 UITER_LIMIT = 2,
3127 UITER_ZERO = 3,
3128 UITER_LENGTH = 4,
3129}
3130pub type UCharIteratorGetIndex = ::std::option::Option<
3131 unsafe extern "C" fn(iter: *mut UCharIterator, origin: UCharIteratorOrigin) -> i32,
3132>;
3133pub type UCharIteratorMove = ::std::option::Option<
3134 unsafe extern "C" fn(iter: *mut UCharIterator, delta: i32, origin: UCharIteratorOrigin) -> i32,
3135>;
3136pub type UCharIteratorHasNext =
3137 ::std::option::Option<unsafe extern "C" fn(iter: *mut UCharIterator) -> UBool>;
3138pub type UCharIteratorHasPrevious =
3139 ::std::option::Option<unsafe extern "C" fn(iter: *mut UCharIterator) -> UBool>;
3140pub type UCharIteratorCurrent =
3141 ::std::option::Option<unsafe extern "C" fn(iter: *mut UCharIterator) -> UChar32>;
3142pub type UCharIteratorNext =
3143 ::std::option::Option<unsafe extern "C" fn(iter: *mut UCharIterator) -> UChar32>;
3144pub type UCharIteratorPrevious =
3145 ::std::option::Option<unsafe extern "C" fn(iter: *mut UCharIterator) -> UChar32>;
3146pub type UCharIteratorReserved =
3147 ::std::option::Option<unsafe extern "C" fn(iter: *mut UCharIterator, something: i32) -> i32>;
3148pub type UCharIteratorGetState =
3149 ::std::option::Option<unsafe extern "C" fn(iter: *const UCharIterator) -> u32>;
3150pub type UCharIteratorSetState = ::std::option::Option<
3151 unsafe extern "C" fn(iter: *mut UCharIterator, state: u32, pErrorCode: *mut UErrorCode),
3152>;
3153#[repr(C)]
3154#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq)]
3155pub struct UCharIterator {
3156 pub context: *const ::std::os::raw::c_void,
3157 pub length: i32,
3158 pub start: i32,
3159 pub index: i32,
3160 pub limit: i32,
3161 pub reservedField: i32,
3162 pub getIndex: UCharIteratorGetIndex,
3163 pub move_: UCharIteratorMove,
3164 pub hasNext: UCharIteratorHasNext,
3165 pub hasPrevious: UCharIteratorHasPrevious,
3166 pub current: UCharIteratorCurrent,
3167 pub next: UCharIteratorNext,
3168 pub previous: UCharIteratorPrevious,
3169 pub reservedFn: UCharIteratorReserved,
3170 pub getState: UCharIteratorGetState,
3171 pub setState: UCharIteratorSetState,
3172}
3173#[test]
3174fn bindgen_test_layout_UCharIterator() {
3175 const UNINIT: ::std::mem::MaybeUninit<UCharIterator> = ::std::mem::MaybeUninit::uninit();
3176 let ptr = UNINIT.as_ptr();
3177 assert_eq!(
3178 ::std::mem::size_of::<UCharIterator>(),
3179 112usize,
3180 concat!("Size of: ", stringify!(UCharIterator))
3181 );
3182 assert_eq!(
3183 ::std::mem::align_of::<UCharIterator>(),
3184 8usize,
3185 concat!("Alignment of ", stringify!(UCharIterator))
3186 );
3187 assert_eq!(
3188 unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
3189 0usize,
3190 concat!(
3191 "Offset of field: ",
3192 stringify!(UCharIterator),
3193 "::",
3194 stringify!(context)
3195 )
3196 );
3197 assert_eq!(
3198 unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
3199 8usize,
3200 concat!(
3201 "Offset of field: ",
3202 stringify!(UCharIterator),
3203 "::",
3204 stringify!(length)
3205 )
3206 );
3207 assert_eq!(
3208 unsafe { ::std::ptr::addr_of!((*ptr).start) as usize - ptr as usize },
3209 12usize,
3210 concat!(
3211 "Offset of field: ",
3212 stringify!(UCharIterator),
3213 "::",
3214 stringify!(start)
3215 )
3216 );
3217 assert_eq!(
3218 unsafe { ::std::ptr::addr_of!((*ptr).index) as usize - ptr as usize },
3219 16usize,
3220 concat!(
3221 "Offset of field: ",
3222 stringify!(UCharIterator),
3223 "::",
3224 stringify!(index)
3225 )
3226 );
3227 assert_eq!(
3228 unsafe { ::std::ptr::addr_of!((*ptr).limit) as usize - ptr as usize },
3229 20usize,
3230 concat!(
3231 "Offset of field: ",
3232 stringify!(UCharIterator),
3233 "::",
3234 stringify!(limit)
3235 )
3236 );
3237 assert_eq!(
3238 unsafe { ::std::ptr::addr_of!((*ptr).reservedField) as usize - ptr as usize },
3239 24usize,
3240 concat!(
3241 "Offset of field: ",
3242 stringify!(UCharIterator),
3243 "::",
3244 stringify!(reservedField)
3245 )
3246 );
3247 assert_eq!(
3248 unsafe { ::std::ptr::addr_of!((*ptr).getIndex) as usize - ptr as usize },
3249 32usize,
3250 concat!(
3251 "Offset of field: ",
3252 stringify!(UCharIterator),
3253 "::",
3254 stringify!(getIndex)
3255 )
3256 );
3257 assert_eq!(
3258 unsafe { ::std::ptr::addr_of!((*ptr).move_) as usize - ptr as usize },
3259 40usize,
3260 concat!(
3261 "Offset of field: ",
3262 stringify!(UCharIterator),
3263 "::",
3264 stringify!(move_)
3265 )
3266 );
3267 assert_eq!(
3268 unsafe { ::std::ptr::addr_of!((*ptr).hasNext) as usize - ptr as usize },
3269 48usize,
3270 concat!(
3271 "Offset of field: ",
3272 stringify!(UCharIterator),
3273 "::",
3274 stringify!(hasNext)
3275 )
3276 );
3277 assert_eq!(
3278 unsafe { ::std::ptr::addr_of!((*ptr).hasPrevious) as usize - ptr as usize },
3279 56usize,
3280 concat!(
3281 "Offset of field: ",
3282 stringify!(UCharIterator),
3283 "::",
3284 stringify!(hasPrevious)
3285 )
3286 );
3287 assert_eq!(
3288 unsafe { ::std::ptr::addr_of!((*ptr).current) as usize - ptr as usize },
3289 64usize,
3290 concat!(
3291 "Offset of field: ",
3292 stringify!(UCharIterator),
3293 "::",
3294 stringify!(current)
3295 )
3296 );
3297 assert_eq!(
3298 unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
3299 72usize,
3300 concat!(
3301 "Offset of field: ",
3302 stringify!(UCharIterator),
3303 "::",
3304 stringify!(next)
3305 )
3306 );
3307 assert_eq!(
3308 unsafe { ::std::ptr::addr_of!((*ptr).previous) as usize - ptr as usize },
3309 80usize,
3310 concat!(
3311 "Offset of field: ",
3312 stringify!(UCharIterator),
3313 "::",
3314 stringify!(previous)
3315 )
3316 );
3317 assert_eq!(
3318 unsafe { ::std::ptr::addr_of!((*ptr).reservedFn) as usize - ptr as usize },
3319 88usize,
3320 concat!(
3321 "Offset of field: ",
3322 stringify!(UCharIterator),
3323 "::",
3324 stringify!(reservedFn)
3325 )
3326 );
3327 assert_eq!(
3328 unsafe { ::std::ptr::addr_of!((*ptr).getState) as usize - ptr as usize },
3329 96usize,
3330 concat!(
3331 "Offset of field: ",
3332 stringify!(UCharIterator),
3333 "::",
3334 stringify!(getState)
3335 )
3336 );
3337 assert_eq!(
3338 unsafe { ::std::ptr::addr_of!((*ptr).setState) as usize - ptr as usize },
3339 104usize,
3340 concat!(
3341 "Offset of field: ",
3342 stringify!(UCharIterator),
3343 "::",
3344 stringify!(setState)
3345 )
3346 );
3347}
3348impl Default for UCharIterator {
3349 fn default() -> Self {
3350 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3351 unsafe {
3352 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3353 s.assume_init()
3354 }
3355 }
3356}
3357#[repr(u32)]
3358#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
3359pub enum UNormalization2Mode {
3360 UNORM2_COMPOSE = 0,
3361 UNORM2_DECOMPOSE = 1,
3362 UNORM2_FCD = 2,
3363 UNORM2_COMPOSE_CONTIGUOUS = 3,
3364}
3365#[repr(u32)]
3366#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
3367pub enum UNormalizationCheckResult {
3368 UNORM_NO = 0,
3369 UNORM_YES = 1,
3370 UNORM_MAYBE = 2,
3371}
3372#[repr(C)]
3373#[derive(Debug, Copy, Clone)]
3374pub struct UNormalizer2 {
3375 _unused: [u8; 0],
3376}
3377extern "C" {
3378 pub fn unorm2_getNFCInstance_74(pErrorCode: *mut UErrorCode) -> *const UNormalizer2;
3379}
3380extern "C" {
3381 pub fn unorm2_getNFDInstance_74(pErrorCode: *mut UErrorCode) -> *const UNormalizer2;
3382}
3383extern "C" {
3384 pub fn unorm2_getNFKCInstance_74(pErrorCode: *mut UErrorCode) -> *const UNormalizer2;
3385}
3386extern "C" {
3387 pub fn unorm2_getNFKDInstance_74(pErrorCode: *mut UErrorCode) -> *const UNormalizer2;
3388}
3389extern "C" {
3390 pub fn unorm2_getNFKCCasefoldInstance_74(pErrorCode: *mut UErrorCode) -> *const UNormalizer2;
3391}
3392extern "C" {
3393 pub fn unorm2_getNFKCSimpleCasefoldInstance_74(
3394 pErrorCode: *mut UErrorCode,
3395 ) -> *const UNormalizer2;
3396}
3397extern "C" {
3398 pub fn unorm2_getInstance_74(
3399 packageName: *const ::std::os::raw::c_char,
3400 name: *const ::std::os::raw::c_char,
3401 mode: UNormalization2Mode,
3402 pErrorCode: *mut UErrorCode,
3403 ) -> *const UNormalizer2;
3404}
3405extern "C" {
3406 pub fn unorm2_openFiltered_74(
3407 norm2: *const UNormalizer2,
3408 filterSet: *const USet,
3409 pErrorCode: *mut UErrorCode,
3410 ) -> *mut UNormalizer2;
3411}
3412extern "C" {
3413 pub fn unorm2_close_74(norm2: *mut UNormalizer2);
3414}
3415extern "C" {
3416 pub fn unorm2_normalize_74(
3417 norm2: *const UNormalizer2,
3418 src: *const UChar,
3419 length: i32,
3420 dest: *mut UChar,
3421 capacity: i32,
3422 pErrorCode: *mut UErrorCode,
3423 ) -> i32;
3424}
3425extern "C" {
3426 pub fn unorm2_normalizeSecondAndAppend_74(
3427 norm2: *const UNormalizer2,
3428 first: *mut UChar,
3429 firstLength: i32,
3430 firstCapacity: i32,
3431 second: *const UChar,
3432 secondLength: i32,
3433 pErrorCode: *mut UErrorCode,
3434 ) -> i32;
3435}
3436extern "C" {
3437 pub fn unorm2_append_74(
3438 norm2: *const UNormalizer2,
3439 first: *mut UChar,
3440 firstLength: i32,
3441 firstCapacity: i32,
3442 second: *const UChar,
3443 secondLength: i32,
3444 pErrorCode: *mut UErrorCode,
3445 ) -> i32;
3446}
3447extern "C" {
3448 pub fn unorm2_getDecomposition_74(
3449 norm2: *const UNormalizer2,
3450 c: UChar32,
3451 decomposition: *mut UChar,
3452 capacity: i32,
3453 pErrorCode: *mut UErrorCode,
3454 ) -> i32;
3455}
3456extern "C" {
3457 pub fn unorm2_getRawDecomposition_74(
3458 norm2: *const UNormalizer2,
3459 c: UChar32,
3460 decomposition: *mut UChar,
3461 capacity: i32,
3462 pErrorCode: *mut UErrorCode,
3463 ) -> i32;
3464}
3465extern "C" {
3466 pub fn unorm2_composePair_74(norm2: *const UNormalizer2, a: UChar32, b: UChar32) -> UChar32;
3467}
3468extern "C" {
3469 pub fn unorm2_getCombiningClass_74(norm2: *const UNormalizer2, c: UChar32) -> u8;
3470}
3471extern "C" {
3472 pub fn unorm2_isNormalized_74(
3473 norm2: *const UNormalizer2,
3474 s: *const UChar,
3475 length: i32,
3476 pErrorCode: *mut UErrorCode,
3477 ) -> UBool;
3478}
3479extern "C" {
3480 pub fn unorm2_quickCheck_74(
3481 norm2: *const UNormalizer2,
3482 s: *const UChar,
3483 length: i32,
3484 pErrorCode: *mut UErrorCode,
3485 ) -> UNormalizationCheckResult;
3486}
3487extern "C" {
3488 pub fn unorm2_spanQuickCheckYes_74(
3489 norm2: *const UNormalizer2,
3490 s: *const UChar,
3491 length: i32,
3492 pErrorCode: *mut UErrorCode,
3493 ) -> i32;
3494}
3495extern "C" {
3496 pub fn unorm2_hasBoundaryBefore_74(norm2: *const UNormalizer2, c: UChar32) -> UBool;
3497}
3498extern "C" {
3499 pub fn unorm2_hasBoundaryAfter_74(norm2: *const UNormalizer2, c: UChar32) -> UBool;
3500}
3501extern "C" {
3502 pub fn unorm2_isInert_74(norm2: *const UNormalizer2, c: UChar32) -> UBool;
3503}
3504impl UNormalizationMode {
3505 pub const UNORM_DEFAULT: UNormalizationMode = UNormalizationMode::UNORM_NFC;
3506}
3507#[repr(u32)]
3508#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
3509pub enum UNormalizationMode {
3510 UNORM_NONE = 1,
3511 UNORM_NFD = 2,
3512 UNORM_NFKD = 3,
3513 UNORM_NFC = 4,
3514 UNORM_NFKC = 5,
3515 UNORM_FCD = 6,
3516 UNORM_MODE_COUNT = 7,
3517}
3518#[repr(C)]
3519#[derive(Debug, Copy, Clone)]
3520pub struct UCollator {
3521 _unused: [u8; 0],
3522}
3523#[repr(i32)]
3524#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
3525pub enum UCollationResult {
3526 UCOL_EQUAL = 0,
3527 UCOL_GREATER = 1,
3528 UCOL_LESS = -1,
3529}
3530impl UColAttributeValue {
3531 pub const UCOL_DEFAULT_STRENGTH: UColAttributeValue = UColAttributeValue::UCOL_TERTIARY;
3532}
3533impl UColAttributeValue {
3534 pub const UCOL_QUATERNARY: UColAttributeValue = UColAttributeValue::UCOL_CE_STRENGTH_LIMIT;
3535}
3536impl UColAttributeValue {
3537 pub const UCOL_OFF: UColAttributeValue = UColAttributeValue::UCOL_STRENGTH_LIMIT;
3538}
3539#[repr(i32)]
3540#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
3541pub enum UColAttributeValue {
3542 UCOL_DEFAULT = -1,
3543 UCOL_PRIMARY = 0,
3544 UCOL_SECONDARY = 1,
3545 UCOL_TERTIARY = 2,
3546 UCOL_CE_STRENGTH_LIMIT = 3,
3547 UCOL_IDENTICAL = 15,
3548 UCOL_STRENGTH_LIMIT = 16,
3549 UCOL_ON = 17,
3550 UCOL_SHIFTED = 20,
3551 UCOL_NON_IGNORABLE = 21,
3552 UCOL_LOWER_FIRST = 24,
3553 UCOL_UPPER_FIRST = 25,
3554 UCOL_ATTRIBUTE_VALUE_COUNT = 26,
3555}
3556impl UColReorderCode {
3557 pub const UCOL_REORDER_CODE_OTHERS: UColReorderCode = UColReorderCode::UCOL_REORDER_CODE_NONE;
3558}
3559impl UColReorderCode {
3560 pub const UCOL_REORDER_CODE_FIRST: UColReorderCode = UColReorderCode::UCOL_REORDER_CODE_SPACE;
3561}
3562#[repr(i32)]
3563#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
3564pub enum UColReorderCode {
3565 UCOL_REORDER_CODE_DEFAULT = -1,
3566 UCOL_REORDER_CODE_NONE = 103,
3567 UCOL_REORDER_CODE_SPACE = 4096,
3568 UCOL_REORDER_CODE_PUNCTUATION = 4097,
3569 UCOL_REORDER_CODE_SYMBOL = 4098,
3570 UCOL_REORDER_CODE_CURRENCY = 4099,
3571 UCOL_REORDER_CODE_DIGIT = 4100,
3572 UCOL_REORDER_CODE_LIMIT = 4101,
3573}
3574pub use self::UColAttributeValue as UCollationStrength;
3575impl UColAttribute {
3576 pub const UCOL_DECOMPOSITION_MODE: UColAttribute = UColAttribute::UCOL_NORMALIZATION_MODE;
3577}
3578#[repr(u32)]
3579#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
3580pub enum UColAttribute {
3581 UCOL_FRENCH_COLLATION = 0,
3582 UCOL_ALTERNATE_HANDLING = 1,
3583 UCOL_CASE_FIRST = 2,
3584 UCOL_CASE_LEVEL = 3,
3585 UCOL_NORMALIZATION_MODE = 4,
3586 UCOL_STRENGTH = 5,
3587 UCOL_HIRAGANA_QUATERNARY_MODE = 6,
3588 UCOL_NUMERIC_COLLATION = 7,
3589 UCOL_ATTRIBUTE_COUNT = 8,
3590}
3591#[repr(u32)]
3592#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
3593pub enum UColRuleOption {
3594 UCOL_TAILORING_ONLY = 0,
3595 UCOL_FULL_RULES = 1,
3596}
3597extern "C" {
3598 pub fn ucol_open_74(
3599 loc: *const ::std::os::raw::c_char,
3600 status: *mut UErrorCode,
3601 ) -> *mut UCollator;
3602}
3603extern "C" {
3604 pub fn ucol_openRules_74(
3605 rules: *const UChar,
3606 rulesLength: i32,
3607 normalizationMode: UColAttributeValue,
3608 strength: UCollationStrength,
3609 parseError: *mut UParseError,
3610 status: *mut UErrorCode,
3611 ) -> *mut UCollator;
3612}
3613extern "C" {
3614 pub fn ucol_openFromShortString_74(
3615 definition: *const ::std::os::raw::c_char,
3616 forceDefaults: UBool,
3617 parseError: *mut UParseError,
3618 status: *mut UErrorCode,
3619 ) -> *mut UCollator;
3620}
3621extern "C" {
3622 pub fn ucol_getContractions_74(
3623 coll: *const UCollator,
3624 conts: *mut USet,
3625 status: *mut UErrorCode,
3626 ) -> i32;
3627}
3628extern "C" {
3629 pub fn ucol_getContractionsAndExpansions_74(
3630 coll: *const UCollator,
3631 contractions: *mut USet,
3632 expansions: *mut USet,
3633 addPrefixes: UBool,
3634 status: *mut UErrorCode,
3635 );
3636}
3637extern "C" {
3638 pub fn ucol_close_74(coll: *mut UCollator);
3639}
3640extern "C" {
3641 pub fn ucol_strcoll_74(
3642 coll: *const UCollator,
3643 source: *const UChar,
3644 sourceLength: i32,
3645 target: *const UChar,
3646 targetLength: i32,
3647 ) -> UCollationResult;
3648}
3649extern "C" {
3650 pub fn ucol_strcollUTF8_74(
3651 coll: *const UCollator,
3652 source: *const ::std::os::raw::c_char,
3653 sourceLength: i32,
3654 target: *const ::std::os::raw::c_char,
3655 targetLength: i32,
3656 status: *mut UErrorCode,
3657 ) -> UCollationResult;
3658}
3659extern "C" {
3660 pub fn ucol_greater_74(
3661 coll: *const UCollator,
3662 source: *const UChar,
3663 sourceLength: i32,
3664 target: *const UChar,
3665 targetLength: i32,
3666 ) -> UBool;
3667}
3668extern "C" {
3669 pub fn ucol_greaterOrEqual_74(
3670 coll: *const UCollator,
3671 source: *const UChar,
3672 sourceLength: i32,
3673 target: *const UChar,
3674 targetLength: i32,
3675 ) -> UBool;
3676}
3677extern "C" {
3678 pub fn ucol_equal_74(
3679 coll: *const UCollator,
3680 source: *const UChar,
3681 sourceLength: i32,
3682 target: *const UChar,
3683 targetLength: i32,
3684 ) -> UBool;
3685}
3686extern "C" {
3687 pub fn ucol_strcollIter_74(
3688 coll: *const UCollator,
3689 sIter: *mut UCharIterator,
3690 tIter: *mut UCharIterator,
3691 status: *mut UErrorCode,
3692 ) -> UCollationResult;
3693}
3694extern "C" {
3695 pub fn ucol_getStrength_74(coll: *const UCollator) -> UCollationStrength;
3696}
3697extern "C" {
3698 pub fn ucol_setStrength_74(coll: *mut UCollator, strength: UCollationStrength);
3699}
3700extern "C" {
3701 pub fn ucol_getReorderCodes_74(
3702 coll: *const UCollator,
3703 dest: *mut i32,
3704 destCapacity: i32,
3705 pErrorCode: *mut UErrorCode,
3706 ) -> i32;
3707}
3708extern "C" {
3709 pub fn ucol_setReorderCodes_74(
3710 coll: *mut UCollator,
3711 reorderCodes: *const i32,
3712 reorderCodesLength: i32,
3713 pErrorCode: *mut UErrorCode,
3714 );
3715}
3716extern "C" {
3717 pub fn ucol_getEquivalentReorderCodes_74(
3718 reorderCode: i32,
3719 dest: *mut i32,
3720 destCapacity: i32,
3721 pErrorCode: *mut UErrorCode,
3722 ) -> i32;
3723}
3724extern "C" {
3725 pub fn ucol_getDisplayName_74(
3726 objLoc: *const ::std::os::raw::c_char,
3727 dispLoc: *const ::std::os::raw::c_char,
3728 result: *mut UChar,
3729 resultLength: i32,
3730 status: *mut UErrorCode,
3731 ) -> i32;
3732}
3733extern "C" {
3734 pub fn ucol_getAvailable_74(localeIndex: i32) -> *const ::std::os::raw::c_char;
3735}
3736extern "C" {
3737 pub fn ucol_countAvailable_74() -> i32;
3738}
3739extern "C" {
3740 pub fn ucol_openAvailableLocales_74(status: *mut UErrorCode) -> *mut UEnumeration;
3741}
3742extern "C" {
3743 pub fn ucol_getKeywords_74(status: *mut UErrorCode) -> *mut UEnumeration;
3744}
3745extern "C" {
3746 pub fn ucol_getKeywordValues_74(
3747 keyword: *const ::std::os::raw::c_char,
3748 status: *mut UErrorCode,
3749 ) -> *mut UEnumeration;
3750}
3751extern "C" {
3752 pub fn ucol_getKeywordValuesForLocale_74(
3753 key: *const ::std::os::raw::c_char,
3754 locale: *const ::std::os::raw::c_char,
3755 commonlyUsed: UBool,
3756 status: *mut UErrorCode,
3757 ) -> *mut UEnumeration;
3758}
3759extern "C" {
3760 pub fn ucol_getFunctionalEquivalent_74(
3761 result: *mut ::std::os::raw::c_char,
3762 resultCapacity: i32,
3763 keyword: *const ::std::os::raw::c_char,
3764 locale: *const ::std::os::raw::c_char,
3765 isAvailable: *mut UBool,
3766 status: *mut UErrorCode,
3767 ) -> i32;
3768}
3769extern "C" {
3770 pub fn ucol_getRules_74(coll: *const UCollator, length: *mut i32) -> *const UChar;
3771}
3772extern "C" {
3773 pub fn ucol_getShortDefinitionString_74(
3774 coll: *const UCollator,
3775 locale: *const ::std::os::raw::c_char,
3776 buffer: *mut ::std::os::raw::c_char,
3777 capacity: i32,
3778 status: *mut UErrorCode,
3779 ) -> i32;
3780}
3781extern "C" {
3782 pub fn ucol_normalizeShortDefinitionString_74(
3783 source: *const ::std::os::raw::c_char,
3784 destination: *mut ::std::os::raw::c_char,
3785 capacity: i32,
3786 parseError: *mut UParseError,
3787 status: *mut UErrorCode,
3788 ) -> i32;
3789}
3790extern "C" {
3791 pub fn ucol_getSortKey_74(
3792 coll: *const UCollator,
3793 source: *const UChar,
3794 sourceLength: i32,
3795 result: *mut u8,
3796 resultLength: i32,
3797 ) -> i32;
3798}
3799extern "C" {
3800 pub fn ucol_nextSortKeyPart_74(
3801 coll: *const UCollator,
3802 iter: *mut UCharIterator,
3803 state: *mut u32,
3804 dest: *mut u8,
3805 count: i32,
3806 status: *mut UErrorCode,
3807 ) -> i32;
3808}
3809#[repr(u32)]
3810#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
3811pub enum UColBoundMode {
3812 UCOL_BOUND_LOWER = 0,
3813 UCOL_BOUND_UPPER = 1,
3814 UCOL_BOUND_UPPER_LONG = 2,
3815 UCOL_BOUND_VALUE_COUNT = 3,
3816}
3817extern "C" {
3818 pub fn ucol_getBound_74(
3819 source: *const u8,
3820 sourceLength: i32,
3821 boundType: UColBoundMode,
3822 noOfLevels: u32,
3823 result: *mut u8,
3824 resultLength: i32,
3825 status: *mut UErrorCode,
3826 ) -> i32;
3827}
3828extern "C" {
3829 pub fn ucol_getVersion_74(coll: *const UCollator, info: *mut u8);
3830}
3831extern "C" {
3832 pub fn ucol_getUCAVersion_74(coll: *const UCollator, info: *mut u8);
3833}
3834extern "C" {
3835 pub fn ucol_mergeSortkeys_74(
3836 src1: *const u8,
3837 src1Length: i32,
3838 src2: *const u8,
3839 src2Length: i32,
3840 dest: *mut u8,
3841 destCapacity: i32,
3842 ) -> i32;
3843}
3844extern "C" {
3845 pub fn ucol_setAttribute_74(
3846 coll: *mut UCollator,
3847 attr: UColAttribute,
3848 value: UColAttributeValue,
3849 status: *mut UErrorCode,
3850 );
3851}
3852extern "C" {
3853 pub fn ucol_getAttribute_74(
3854 coll: *const UCollator,
3855 attr: UColAttribute,
3856 status: *mut UErrorCode,
3857 ) -> UColAttributeValue;
3858}
3859extern "C" {
3860 pub fn ucol_setMaxVariable_74(
3861 coll: *mut UCollator,
3862 group: UColReorderCode,
3863 pErrorCode: *mut UErrorCode,
3864 );
3865}
3866extern "C" {
3867 pub fn ucol_getMaxVariable_74(coll: *const UCollator) -> UColReorderCode;
3868}
3869extern "C" {
3870 pub fn ucol_setVariableTop_74(
3871 coll: *mut UCollator,
3872 varTop: *const UChar,
3873 len: i32,
3874 status: *mut UErrorCode,
3875 ) -> u32;
3876}
3877extern "C" {
3878 pub fn ucol_getVariableTop_74(coll: *const UCollator, status: *mut UErrorCode) -> u32;
3879}
3880extern "C" {
3881 pub fn ucol_restoreVariableTop_74(coll: *mut UCollator, varTop: u32, status: *mut UErrorCode);
3882}
3883extern "C" {
3884 pub fn ucol_clone_74(coll: *const UCollator, status: *mut UErrorCode) -> *mut UCollator;
3885}
3886extern "C" {
3887 pub fn ucol_safeClone_74(
3888 coll: *const UCollator,
3889 stackBuffer: *mut ::std::os::raw::c_void,
3890 pBufferSize: *mut i32,
3891 status: *mut UErrorCode,
3892 ) -> *mut UCollator;
3893}
3894extern "C" {
3895 pub fn ucol_getRulesEx_74(
3896 coll: *const UCollator,
3897 delta: UColRuleOption,
3898 buffer: *mut UChar,
3899 bufferLen: i32,
3900 ) -> i32;
3901}
3902extern "C" {
3903 pub fn ucol_getLocale_74(
3904 coll: *const UCollator,
3905 type_: ULocDataLocaleType,
3906 status: *mut UErrorCode,
3907 ) -> *const ::std::os::raw::c_char;
3908}
3909extern "C" {
3910 pub fn ucol_getLocaleByType_74(
3911 coll: *const UCollator,
3912 type_: ULocDataLocaleType,
3913 status: *mut UErrorCode,
3914 ) -> *const ::std::os::raw::c_char;
3915}
3916extern "C" {
3917 pub fn ucol_getTailoredSet_74(coll: *const UCollator, status: *mut UErrorCode) -> *mut USet;
3918}
3919extern "C" {
3920 pub fn ucol_getUnsafeSet_74(
3921 coll: *const UCollator,
3922 unsafe_: *mut USet,
3923 status: *mut UErrorCode,
3924 ) -> i32;
3925}
3926extern "C" {
3927 pub fn ucol_prepareShortStringOpen_74(
3928 definition: *const ::std::os::raw::c_char,
3929 forceDefaults: UBool,
3930 parseError: *mut UParseError,
3931 status: *mut UErrorCode,
3932 );
3933}
3934extern "C" {
3935 pub fn ucol_cloneBinary_74(
3936 coll: *const UCollator,
3937 buffer: *mut u8,
3938 capacity: i32,
3939 status: *mut UErrorCode,
3940 ) -> i32;
3941}
3942extern "C" {
3943 pub fn ucol_openBinary_74(
3944 bin: *const u8,
3945 length: i32,
3946 base: *const UCollator,
3947 status: *mut UErrorCode,
3948 ) -> *mut UCollator;
3949}
3950#[repr(C)]
3951#[derive(Debug, Copy, Clone)]
3952pub struct UCharsetDetector {
3953 _unused: [u8; 0],
3954}
3955#[repr(C)]
3956#[derive(Debug, Copy, Clone)]
3957pub struct UCharsetMatch {
3958 _unused: [u8; 0],
3959}
3960extern "C" {
3961 pub fn ucsdet_open_74(status: *mut UErrorCode) -> *mut UCharsetDetector;
3962}
3963extern "C" {
3964 pub fn ucsdet_close_74(ucsd: *mut UCharsetDetector);
3965}
3966extern "C" {
3967 pub fn ucsdet_setText_74(
3968 ucsd: *mut UCharsetDetector,
3969 textIn: *const ::std::os::raw::c_char,
3970 len: i32,
3971 status: *mut UErrorCode,
3972 );
3973}
3974extern "C" {
3975 pub fn ucsdet_setDeclaredEncoding_74(
3976 ucsd: *mut UCharsetDetector,
3977 encoding: *const ::std::os::raw::c_char,
3978 length: i32,
3979 status: *mut UErrorCode,
3980 );
3981}
3982extern "C" {
3983 pub fn ucsdet_detect_74(
3984 ucsd: *mut UCharsetDetector,
3985 status: *mut UErrorCode,
3986 ) -> *const UCharsetMatch;
3987}
3988extern "C" {
3989 pub fn ucsdet_detectAll_74(
3990 ucsd: *mut UCharsetDetector,
3991 matchesFound: *mut i32,
3992 status: *mut UErrorCode,
3993 ) -> *mut *const UCharsetMatch;
3994}
3995extern "C" {
3996 pub fn ucsdet_getName_74(
3997 ucsm: *const UCharsetMatch,
3998 status: *mut UErrorCode,
3999 ) -> *const ::std::os::raw::c_char;
4000}
4001extern "C" {
4002 pub fn ucsdet_getConfidence_74(ucsm: *const UCharsetMatch, status: *mut UErrorCode) -> i32;
4003}
4004extern "C" {
4005 pub fn ucsdet_getLanguage_74(
4006 ucsm: *const UCharsetMatch,
4007 status: *mut UErrorCode,
4008 ) -> *const ::std::os::raw::c_char;
4009}
4010extern "C" {
4011 pub fn ucsdet_getUChars_74(
4012 ucsm: *const UCharsetMatch,
4013 buf: *mut UChar,
4014 cap: i32,
4015 status: *mut UErrorCode,
4016 ) -> i32;
4017}
4018extern "C" {
4019 pub fn ucsdet_getAllDetectableCharsets_74(
4020 ucsd: *const UCharsetDetector,
4021 status: *mut UErrorCode,
4022 ) -> *mut UEnumeration;
4023}
4024extern "C" {
4025 pub fn ucsdet_isInputFilterEnabled_74(ucsd: *const UCharsetDetector) -> UBool;
4026}
4027extern "C" {
4028 pub fn ucsdet_enableInputFilter_74(ucsd: *mut UCharsetDetector, filter: UBool) -> UBool;
4029}
4030extern "C" {
4031 pub fn ucsdet_getDetectableCharsets_74(
4032 ucsd: *const UCharsetDetector,
4033 status: *mut UErrorCode,
4034 ) -> *mut UEnumeration;
4035}
4036extern "C" {
4037 pub fn ucsdet_setDetectableCharset_74(
4038 ucsd: *mut UCharsetDetector,
4039 encoding: *const ::std::os::raw::c_char,
4040 enabled: UBool,
4041 status: *mut UErrorCode,
4042 );
4043}
4044#[repr(C)]
4045#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, PartialEq)]
4046pub struct UFieldPosition {
4047 pub field: i32,
4048 pub beginIndex: i32,
4049 pub endIndex: i32,
4050}
4051#[test]
4052fn bindgen_test_layout_UFieldPosition() {
4053 const UNINIT: ::std::mem::MaybeUninit<UFieldPosition> = ::std::mem::MaybeUninit::uninit();
4054 let ptr = UNINIT.as_ptr();
4055 assert_eq!(
4056 ::std::mem::size_of::<UFieldPosition>(),
4057 12usize,
4058 concat!("Size of: ", stringify!(UFieldPosition))
4059 );
4060 assert_eq!(
4061 ::std::mem::align_of::<UFieldPosition>(),
4062 4usize,
4063 concat!("Alignment of ", stringify!(UFieldPosition))
4064 );
4065 assert_eq!(
4066 unsafe { ::std::ptr::addr_of!((*ptr).field) as usize - ptr as usize },
4067 0usize,
4068 concat!(
4069 "Offset of field: ",
4070 stringify!(UFieldPosition),
4071 "::",
4072 stringify!(field)
4073 )
4074 );
4075 assert_eq!(
4076 unsafe { ::std::ptr::addr_of!((*ptr).beginIndex) as usize - ptr as usize },
4077 4usize,
4078 concat!(
4079 "Offset of field: ",
4080 stringify!(UFieldPosition),
4081 "::",
4082 stringify!(beginIndex)
4083 )
4084 );
4085 assert_eq!(
4086 unsafe { ::std::ptr::addr_of!((*ptr).endIndex) as usize - ptr as usize },
4087 8usize,
4088 concat!(
4089 "Offset of field: ",
4090 stringify!(UFieldPosition),
4091 "::",
4092 stringify!(endIndex)
4093 )
4094 );
4095}
4096#[repr(u32)]
4097#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
4098pub enum UFormattableType {
4099 UFMT_DATE = 0,
4100 UFMT_DOUBLE = 1,
4101 UFMT_LONG = 2,
4102 UFMT_STRING = 3,
4103 UFMT_ARRAY = 4,
4104 UFMT_INT64 = 5,
4105 UFMT_OBJECT = 6,
4106 UFMT_COUNT = 7,
4107}
4108pub type UFormattable = *mut ::std::os::raw::c_void;
4109extern "C" {
4110 pub fn ufmt_open_74(status: *mut UErrorCode) -> *mut UFormattable;
4111}
4112extern "C" {
4113 pub fn ufmt_close_74(fmt: *mut UFormattable);
4114}
4115extern "C" {
4116 pub fn ufmt_getType_74(fmt: *const UFormattable, status: *mut UErrorCode) -> UFormattableType;
4117}
4118extern "C" {
4119 pub fn ufmt_isNumeric_74(fmt: *const UFormattable) -> UBool;
4120}
4121extern "C" {
4122 pub fn ufmt_getDate_74(fmt: *const UFormattable, status: *mut UErrorCode) -> UDate;
4123}
4124extern "C" {
4125 pub fn ufmt_getDouble_74(fmt: *mut UFormattable, status: *mut UErrorCode) -> f64;
4126}
4127extern "C" {
4128 pub fn ufmt_getLong_74(fmt: *mut UFormattable, status: *mut UErrorCode) -> i32;
4129}
4130extern "C" {
4131 pub fn ufmt_getInt64_74(fmt: *mut UFormattable, status: *mut UErrorCode) -> i64;
4132}
4133extern "C" {
4134 pub fn ufmt_getObject_74(
4135 fmt: *const UFormattable,
4136 status: *mut UErrorCode,
4137 ) -> *const ::std::os::raw::c_void;
4138}
4139extern "C" {
4140 pub fn ufmt_getUChars_74(
4141 fmt: *mut UFormattable,
4142 len: *mut i32,
4143 status: *mut UErrorCode,
4144 ) -> *const UChar;
4145}
4146extern "C" {
4147 pub fn ufmt_getArrayLength_74(fmt: *const UFormattable, status: *mut UErrorCode) -> i32;
4148}
4149extern "C" {
4150 pub fn ufmt_getArrayItemByIndex_74(
4151 fmt: *mut UFormattable,
4152 n: i32,
4153 status: *mut UErrorCode,
4154 ) -> *mut UFormattable;
4155}
4156extern "C" {
4157 pub fn ufmt_getDecNumChars_74(
4158 fmt: *mut UFormattable,
4159 len: *mut i32,
4160 status: *mut UErrorCode,
4161 ) -> *const ::std::os::raw::c_char;
4162}
4163#[repr(u32)]
4164#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
4165pub enum UDisplayContextType {
4166 UDISPCTX_TYPE_DIALECT_HANDLING = 0,
4167 UDISPCTX_TYPE_CAPITALIZATION = 1,
4168 UDISPCTX_TYPE_DISPLAY_LENGTH = 2,
4169 UDISPCTX_TYPE_SUBSTITUTE_HANDLING = 3,
4170}
4171#[repr(u32)]
4172#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
4173pub enum UDisplayContext {
4174 UDISPCTX_STANDARD_NAMES = 0,
4175 UDISPCTX_DIALECT_NAMES = 1,
4176 UDISPCTX_CAPITALIZATION_NONE = 256,
4177 UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE = 257,
4178 UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE = 258,
4179 UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU = 259,
4180 UDISPCTX_CAPITALIZATION_FOR_STANDALONE = 260,
4181 UDISPCTX_LENGTH_FULL = 512,
4182 UDISPCTX_LENGTH_SHORT = 513,
4183 UDISPCTX_SUBSTITUTE = 768,
4184 UDISPCTX_NO_SUBSTITUTE = 769,
4185}
4186#[repr(C)]
4187#[derive(Debug, Copy, Clone)]
4188pub struct UFieldPositionIterator {
4189 _unused: [u8; 0],
4190}
4191extern "C" {
4192 pub fn ufieldpositer_open_74(status: *mut UErrorCode) -> *mut UFieldPositionIterator;
4193}
4194extern "C" {
4195 pub fn ufieldpositer_close_74(fpositer: *mut UFieldPositionIterator);
4196}
4197extern "C" {
4198 pub fn ufieldpositer_next_74(
4199 fpositer: *mut UFieldPositionIterator,
4200 beginIndex: *mut i32,
4201 endIndex: *mut i32,
4202 ) -> i32;
4203}
4204pub type UNumberFormat = *mut ::std::os::raw::c_void;
4205impl UNumberFormatStyle {
4206 pub const UNUM_DEFAULT: UNumberFormatStyle = UNumberFormatStyle::UNUM_DECIMAL;
4207}
4208impl UNumberFormatStyle {
4209 pub const UNUM_IGNORE: UNumberFormatStyle = UNumberFormatStyle::UNUM_PATTERN_DECIMAL;
4210}
4211#[repr(u32)]
4212#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
4213pub enum UNumberFormatStyle {
4214 UNUM_PATTERN_DECIMAL = 0,
4215 UNUM_DECIMAL = 1,
4216 UNUM_CURRENCY = 2,
4217 UNUM_PERCENT = 3,
4218 UNUM_SCIENTIFIC = 4,
4219 UNUM_SPELLOUT = 5,
4220 UNUM_ORDINAL = 6,
4221 UNUM_DURATION = 7,
4222 UNUM_NUMBERING_SYSTEM = 8,
4223 UNUM_PATTERN_RULEBASED = 9,
4224 UNUM_CURRENCY_ISO = 10,
4225 UNUM_CURRENCY_PLURAL = 11,
4226 UNUM_CURRENCY_ACCOUNTING = 12,
4227 UNUM_CASH_CURRENCY = 13,
4228 UNUM_DECIMAL_COMPACT_SHORT = 14,
4229 UNUM_DECIMAL_COMPACT_LONG = 15,
4230 UNUM_CURRENCY_STANDARD = 16,
4231 UNUM_FORMAT_STYLE_COUNT = 17,
4232}
4233extern "C" {
4234 pub fn unum_open_74(
4235 style: UNumberFormatStyle,
4236 pattern: *const UChar,
4237 patternLength: i32,
4238 locale: *const ::std::os::raw::c_char,
4239 parseErr: *mut UParseError,
4240 status: *mut UErrorCode,
4241 ) -> *mut UNumberFormat;
4242}
4243extern "C" {
4244 pub fn unum_close_74(fmt: *mut UNumberFormat);
4245}
4246extern "C" {
4247 pub fn unum_clone_74(fmt: *const UNumberFormat, status: *mut UErrorCode) -> *mut UNumberFormat;
4248}
4249extern "C" {
4250 pub fn unum_format_74(
4251 fmt: *const UNumberFormat,
4252 number: i32,
4253 result: *mut UChar,
4254 resultLength: i32,
4255 pos: *mut UFieldPosition,
4256 status: *mut UErrorCode,
4257 ) -> i32;
4258}
4259extern "C" {
4260 pub fn unum_formatInt64_74(
4261 fmt: *const UNumberFormat,
4262 number: i64,
4263 result: *mut UChar,
4264 resultLength: i32,
4265 pos: *mut UFieldPosition,
4266 status: *mut UErrorCode,
4267 ) -> i32;
4268}
4269extern "C" {
4270 pub fn unum_formatDouble_74(
4271 fmt: *const UNumberFormat,
4272 number: f64,
4273 result: *mut UChar,
4274 resultLength: i32,
4275 pos: *mut UFieldPosition,
4276 status: *mut UErrorCode,
4277 ) -> i32;
4278}
4279extern "C" {
4280 pub fn unum_formatDoubleForFields_74(
4281 format: *const UNumberFormat,
4282 number: f64,
4283 result: *mut UChar,
4284 resultLength: i32,
4285 fpositer: *mut UFieldPositionIterator,
4286 status: *mut UErrorCode,
4287 ) -> i32;
4288}
4289extern "C" {
4290 pub fn unum_formatDecimal_74(
4291 fmt: *const UNumberFormat,
4292 number: *const ::std::os::raw::c_char,
4293 length: i32,
4294 result: *mut UChar,
4295 resultLength: i32,
4296 pos: *mut UFieldPosition,
4297 status: *mut UErrorCode,
4298 ) -> i32;
4299}
4300extern "C" {
4301 pub fn unum_formatDoubleCurrency_74(
4302 fmt: *const UNumberFormat,
4303 number: f64,
4304 currency: *mut UChar,
4305 result: *mut UChar,
4306 resultLength: i32,
4307 pos: *mut UFieldPosition,
4308 status: *mut UErrorCode,
4309 ) -> i32;
4310}
4311extern "C" {
4312 pub fn unum_formatUFormattable_74(
4313 fmt: *const UNumberFormat,
4314 number: *const UFormattable,
4315 result: *mut UChar,
4316 resultLength: i32,
4317 pos: *mut UFieldPosition,
4318 status: *mut UErrorCode,
4319 ) -> i32;
4320}
4321extern "C" {
4322 pub fn unum_parse_74(
4323 fmt: *const UNumberFormat,
4324 text: *const UChar,
4325 textLength: i32,
4326 parsePos: *mut i32,
4327 status: *mut UErrorCode,
4328 ) -> i32;
4329}
4330extern "C" {
4331 pub fn unum_parseInt64_74(
4332 fmt: *const UNumberFormat,
4333 text: *const UChar,
4334 textLength: i32,
4335 parsePos: *mut i32,
4336 status: *mut UErrorCode,
4337 ) -> i64;
4338}
4339extern "C" {
4340 pub fn unum_parseDouble_74(
4341 fmt: *const UNumberFormat,
4342 text: *const UChar,
4343 textLength: i32,
4344 parsePos: *mut i32,
4345 status: *mut UErrorCode,
4346 ) -> f64;
4347}
4348extern "C" {
4349 pub fn unum_parseDecimal_74(
4350 fmt: *const UNumberFormat,
4351 text: *const UChar,
4352 textLength: i32,
4353 parsePos: *mut i32,
4354 outBuf: *mut ::std::os::raw::c_char,
4355 outBufLength: i32,
4356 status: *mut UErrorCode,
4357 ) -> i32;
4358}
4359extern "C" {
4360 pub fn unum_parseDoubleCurrency_74(
4361 fmt: *const UNumberFormat,
4362 text: *const UChar,
4363 textLength: i32,
4364 parsePos: *mut i32,
4365 currency: *mut UChar,
4366 status: *mut UErrorCode,
4367 ) -> f64;
4368}
4369extern "C" {
4370 pub fn unum_parseToUFormattable_74(
4371 fmt: *const UNumberFormat,
4372 result: *mut UFormattable,
4373 text: *const UChar,
4374 textLength: i32,
4375 parsePos: *mut i32,
4376 status: *mut UErrorCode,
4377 ) -> *mut UFormattable;
4378}
4379extern "C" {
4380 pub fn unum_applyPattern_74(
4381 format: *mut UNumberFormat,
4382 localized: UBool,
4383 pattern: *const UChar,
4384 patternLength: i32,
4385 parseError: *mut UParseError,
4386 status: *mut UErrorCode,
4387 );
4388}
4389extern "C" {
4390 pub fn unum_getAvailable_74(localeIndex: i32) -> *const ::std::os::raw::c_char;
4391}
4392extern "C" {
4393 pub fn unum_countAvailable_74() -> i32;
4394}
4395#[repr(u32)]
4396#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
4397pub enum UNumberFormatAttribute {
4398 UNUM_PARSE_INT_ONLY = 0,
4399 UNUM_GROUPING_USED = 1,
4400 UNUM_DECIMAL_ALWAYS_SHOWN = 2,
4401 UNUM_MAX_INTEGER_DIGITS = 3,
4402 UNUM_MIN_INTEGER_DIGITS = 4,
4403 UNUM_INTEGER_DIGITS = 5,
4404 UNUM_MAX_FRACTION_DIGITS = 6,
4405 UNUM_MIN_FRACTION_DIGITS = 7,
4406 UNUM_FRACTION_DIGITS = 8,
4407 UNUM_MULTIPLIER = 9,
4408 UNUM_GROUPING_SIZE = 10,
4409 UNUM_ROUNDING_MODE = 11,
4410 UNUM_ROUNDING_INCREMENT = 12,
4411 UNUM_FORMAT_WIDTH = 13,
4412 UNUM_PADDING_POSITION = 14,
4413 UNUM_SECONDARY_GROUPING_SIZE = 15,
4414 UNUM_SIGNIFICANT_DIGITS_USED = 16,
4415 UNUM_MIN_SIGNIFICANT_DIGITS = 17,
4416 UNUM_MAX_SIGNIFICANT_DIGITS = 18,
4417 UNUM_LENIENT_PARSE = 19,
4418 UNUM_PARSE_ALL_INPUT = 20,
4419 UNUM_SCALE = 21,
4420 UNUM_MINIMUM_GROUPING_DIGITS = 22,
4421 UNUM_CURRENCY_USAGE = 23,
4422 UNUM_MAX_NONBOOLEAN_ATTRIBUTE = 4095,
4423 UNUM_FORMAT_FAIL_IF_MORE_THAN_MAX_DIGITS = 4096,
4424 UNUM_PARSE_NO_EXPONENT = 4097,
4425 UNUM_PARSE_DECIMAL_MARK_REQUIRED = 4098,
4426 UNUM_PARSE_CASE_SENSITIVE = 4099,
4427 UNUM_SIGN_ALWAYS_SHOWN = 4100,
4428 UNUM_LIMIT_BOOLEAN_ATTRIBUTE = 4101,
4429}
4430extern "C" {
4431 pub fn unum_hasAttribute_74(fmt: *const UNumberFormat, attr: UNumberFormatAttribute) -> bool;
4432}
4433extern "C" {
4434 pub fn unum_getAttribute_74(fmt: *const UNumberFormat, attr: UNumberFormatAttribute) -> i32;
4435}
4436extern "C" {
4437 pub fn unum_setAttribute_74(
4438 fmt: *mut UNumberFormat,
4439 attr: UNumberFormatAttribute,
4440 newValue: i32,
4441 );
4442}
4443extern "C" {
4444 pub fn unum_getDoubleAttribute_74(
4445 fmt: *const UNumberFormat,
4446 attr: UNumberFormatAttribute,
4447 ) -> f64;
4448}
4449extern "C" {
4450 pub fn unum_setDoubleAttribute_74(
4451 fmt: *mut UNumberFormat,
4452 attr: UNumberFormatAttribute,
4453 newValue: f64,
4454 );
4455}
4456#[repr(u32)]
4457#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
4458pub enum UNumberFormatTextAttribute {
4459 UNUM_POSITIVE_PREFIX = 0,
4460 UNUM_POSITIVE_SUFFIX = 1,
4461 UNUM_NEGATIVE_PREFIX = 2,
4462 UNUM_NEGATIVE_SUFFIX = 3,
4463 UNUM_PADDING_CHARACTER = 4,
4464 UNUM_CURRENCY_CODE = 5,
4465 UNUM_DEFAULT_RULESET = 6,
4466 UNUM_PUBLIC_RULESETS = 7,
4467}
4468extern "C" {
4469 pub fn unum_getTextAttribute_74(
4470 fmt: *const UNumberFormat,
4471 tag: UNumberFormatTextAttribute,
4472 result: *mut UChar,
4473 resultLength: i32,
4474 status: *mut UErrorCode,
4475 ) -> i32;
4476}
4477extern "C" {
4478 pub fn unum_setTextAttribute_74(
4479 fmt: *mut UNumberFormat,
4480 tag: UNumberFormatTextAttribute,
4481 newValue: *const UChar,
4482 newValueLength: i32,
4483 status: *mut UErrorCode,
4484 );
4485}
4486extern "C" {
4487 pub fn unum_toPattern_74(
4488 fmt: *const UNumberFormat,
4489 isPatternLocalized: UBool,
4490 result: *mut UChar,
4491 resultLength: i32,
4492 status: *mut UErrorCode,
4493 ) -> i32;
4494}
4495#[repr(u32)]
4496#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
4497pub enum UNumberFormatSymbol {
4498 UNUM_DECIMAL_SEPARATOR_SYMBOL = 0,
4499 UNUM_GROUPING_SEPARATOR_SYMBOL = 1,
4500 UNUM_PATTERN_SEPARATOR_SYMBOL = 2,
4501 UNUM_PERCENT_SYMBOL = 3,
4502 UNUM_ZERO_DIGIT_SYMBOL = 4,
4503 UNUM_DIGIT_SYMBOL = 5,
4504 UNUM_MINUS_SIGN_SYMBOL = 6,
4505 UNUM_PLUS_SIGN_SYMBOL = 7,
4506 UNUM_CURRENCY_SYMBOL = 8,
4507 UNUM_INTL_CURRENCY_SYMBOL = 9,
4508 UNUM_MONETARY_SEPARATOR_SYMBOL = 10,
4509 UNUM_EXPONENTIAL_SYMBOL = 11,
4510 UNUM_PERMILL_SYMBOL = 12,
4511 UNUM_PAD_ESCAPE_SYMBOL = 13,
4512 UNUM_INFINITY_SYMBOL = 14,
4513 UNUM_NAN_SYMBOL = 15,
4514 UNUM_SIGNIFICANT_DIGIT_SYMBOL = 16,
4515 UNUM_MONETARY_GROUPING_SEPARATOR_SYMBOL = 17,
4516 UNUM_ONE_DIGIT_SYMBOL = 18,
4517 UNUM_TWO_DIGIT_SYMBOL = 19,
4518 UNUM_THREE_DIGIT_SYMBOL = 20,
4519 UNUM_FOUR_DIGIT_SYMBOL = 21,
4520 UNUM_FIVE_DIGIT_SYMBOL = 22,
4521 UNUM_SIX_DIGIT_SYMBOL = 23,
4522 UNUM_SEVEN_DIGIT_SYMBOL = 24,
4523 UNUM_EIGHT_DIGIT_SYMBOL = 25,
4524 UNUM_NINE_DIGIT_SYMBOL = 26,
4525 UNUM_EXPONENT_MULTIPLICATION_SYMBOL = 27,
4526 UNUM_APPROXIMATELY_SIGN_SYMBOL = 28,
4527 UNUM_FORMAT_SYMBOL_COUNT = 29,
4528}
4529extern "C" {
4530 pub fn unum_getSymbol_74(
4531 fmt: *const UNumberFormat,
4532 symbol: UNumberFormatSymbol,
4533 buffer: *mut UChar,
4534 size: i32,
4535 status: *mut UErrorCode,
4536 ) -> i32;
4537}
4538extern "C" {
4539 pub fn unum_setSymbol_74(
4540 fmt: *mut UNumberFormat,
4541 symbol: UNumberFormatSymbol,
4542 value: *const UChar,
4543 length: i32,
4544 status: *mut UErrorCode,
4545 );
4546}
4547extern "C" {
4548 pub fn unum_getLocaleByType_74(
4549 fmt: *const UNumberFormat,
4550 type_: ULocDataLocaleType,
4551 status: *mut UErrorCode,
4552 ) -> *const ::std::os::raw::c_char;
4553}
4554extern "C" {
4555 pub fn unum_setContext_74(
4556 fmt: *mut UNumberFormat,
4557 value: UDisplayContext,
4558 status: *mut UErrorCode,
4559 );
4560}
4561extern "C" {
4562 pub fn unum_getContext_74(
4563 fmt: *const UNumberFormat,
4564 type_: UDisplayContextType,
4565 status: *mut UErrorCode,
4566 ) -> UDisplayContext;
4567}
4568pub type UDateFormat = *mut ::std::os::raw::c_void;
4569impl UDateFormatStyle {
4570 pub const UDAT_DEFAULT: UDateFormatStyle = UDateFormatStyle::UDAT_MEDIUM;
4571}
4572impl UDateFormatStyle {
4573 pub const UDAT_FULL_RELATIVE: UDateFormatStyle = UDateFormatStyle::UDAT_RELATIVE;
4574}
4575impl UDateFormatStyle {
4576 pub const UDAT_IGNORE: UDateFormatStyle = UDateFormatStyle::UDAT_PATTERN;
4577}
4578#[repr(i32)]
4579#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
4580pub enum UDateFormatStyle {
4581 UDAT_FULL = 0,
4582 UDAT_LONG = 1,
4583 UDAT_MEDIUM = 2,
4584 UDAT_SHORT = 3,
4585 UDAT_RELATIVE = 128,
4586 UDAT_LONG_RELATIVE = 129,
4587 UDAT_MEDIUM_RELATIVE = 130,
4588 UDAT_SHORT_RELATIVE = 131,
4589 UDAT_NONE = -1,
4590 UDAT_PATTERN = -2,
4591}
4592#[repr(u32)]
4593#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
4594pub enum UDateFormatField {
4595 UDAT_ERA_FIELD = 0,
4596 UDAT_YEAR_FIELD = 1,
4597 UDAT_MONTH_FIELD = 2,
4598 UDAT_DATE_FIELD = 3,
4599 UDAT_HOUR_OF_DAY1_FIELD = 4,
4600 UDAT_HOUR_OF_DAY0_FIELD = 5,
4601 UDAT_MINUTE_FIELD = 6,
4602 UDAT_SECOND_FIELD = 7,
4603 UDAT_FRACTIONAL_SECOND_FIELD = 8,
4604 UDAT_DAY_OF_WEEK_FIELD = 9,
4605 UDAT_DAY_OF_YEAR_FIELD = 10,
4606 UDAT_DAY_OF_WEEK_IN_MONTH_FIELD = 11,
4607 UDAT_WEEK_OF_YEAR_FIELD = 12,
4608 UDAT_WEEK_OF_MONTH_FIELD = 13,
4609 UDAT_AM_PM_FIELD = 14,
4610 UDAT_HOUR1_FIELD = 15,
4611 UDAT_HOUR0_FIELD = 16,
4612 UDAT_TIMEZONE_FIELD = 17,
4613 UDAT_YEAR_WOY_FIELD = 18,
4614 UDAT_DOW_LOCAL_FIELD = 19,
4615 UDAT_EXTENDED_YEAR_FIELD = 20,
4616 UDAT_JULIAN_DAY_FIELD = 21,
4617 UDAT_MILLISECONDS_IN_DAY_FIELD = 22,
4618 UDAT_TIMEZONE_RFC_FIELD = 23,
4619 UDAT_TIMEZONE_GENERIC_FIELD = 24,
4620 UDAT_STANDALONE_DAY_FIELD = 25,
4621 UDAT_STANDALONE_MONTH_FIELD = 26,
4622 UDAT_QUARTER_FIELD = 27,
4623 UDAT_STANDALONE_QUARTER_FIELD = 28,
4624 UDAT_TIMEZONE_SPECIAL_FIELD = 29,
4625 UDAT_YEAR_NAME_FIELD = 30,
4626 UDAT_TIMEZONE_LOCALIZED_GMT_OFFSET_FIELD = 31,
4627 UDAT_TIMEZONE_ISO_FIELD = 32,
4628 UDAT_TIMEZONE_ISO_LOCAL_FIELD = 33,
4629 UDAT_RELATED_YEAR_FIELD = 34,
4630 UDAT_AM_PM_MIDNIGHT_NOON_FIELD = 35,
4631 UDAT_FLEXIBLE_DAY_PERIOD_FIELD = 36,
4632 UDAT_TIME_SEPARATOR_FIELD = 37,
4633 UDAT_FIELD_COUNT = 38,
4634}
4635extern "C" {
4636 pub fn udat_toCalendarDateField_74(field: UDateFormatField) -> UCalendarDateFields;
4637}
4638extern "C" {
4639 pub fn udat_open_74(
4640 timeStyle: UDateFormatStyle,
4641 dateStyle: UDateFormatStyle,
4642 locale: *const ::std::os::raw::c_char,
4643 tzID: *const UChar,
4644 tzIDLength: i32,
4645 pattern: *const UChar,
4646 patternLength: i32,
4647 status: *mut UErrorCode,
4648 ) -> *mut UDateFormat;
4649}
4650extern "C" {
4651 pub fn udat_close_74(format: *mut UDateFormat);
4652}
4653#[repr(u32)]
4654#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
4655pub enum UDateFormatBooleanAttribute {
4656 UDAT_PARSE_ALLOW_WHITESPACE = 0,
4657 UDAT_PARSE_ALLOW_NUMERIC = 1,
4658 UDAT_PARSE_PARTIAL_LITERAL_MATCH = 2,
4659 UDAT_PARSE_MULTIPLE_PATTERNS_FOR_MATCH = 3,
4660 UDAT_BOOLEAN_ATTRIBUTE_COUNT = 4,
4661}
4662extern "C" {
4663 pub fn udat_getBooleanAttribute_74(
4664 fmt: *const UDateFormat,
4665 attr: UDateFormatBooleanAttribute,
4666 status: *mut UErrorCode,
4667 ) -> UBool;
4668}
4669extern "C" {
4670 pub fn udat_setBooleanAttribute_74(
4671 fmt: *mut UDateFormat,
4672 attr: UDateFormatBooleanAttribute,
4673 newValue: UBool,
4674 status: *mut UErrorCode,
4675 );
4676}
4677#[repr(u32)]
4678#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
4679pub enum UDateFormatHourCycle {
4680 UDAT_HOUR_CYCLE_11 = 0,
4681 UDAT_HOUR_CYCLE_12 = 1,
4682 UDAT_HOUR_CYCLE_23 = 2,
4683 UDAT_HOUR_CYCLE_24 = 3,
4684}
4685extern "C" {
4686 pub fn udat_clone_74(fmt: *const UDateFormat, status: *mut UErrorCode) -> *mut UDateFormat;
4687}
4688extern "C" {
4689 pub fn udat_format_74(
4690 format: *const UDateFormat,
4691 dateToFormat: UDate,
4692 result: *mut UChar,
4693 resultLength: i32,
4694 position: *mut UFieldPosition,
4695 status: *mut UErrorCode,
4696 ) -> i32;
4697}
4698extern "C" {
4699 pub fn udat_formatCalendar_74(
4700 format: *const UDateFormat,
4701 calendar: *mut UCalendar,
4702 result: *mut UChar,
4703 capacity: i32,
4704 position: *mut UFieldPosition,
4705 status: *mut UErrorCode,
4706 ) -> i32;
4707}
4708extern "C" {
4709 pub fn udat_formatForFields_74(
4710 format: *const UDateFormat,
4711 dateToFormat: UDate,
4712 result: *mut UChar,
4713 resultLength: i32,
4714 fpositer: *mut UFieldPositionIterator,
4715 status: *mut UErrorCode,
4716 ) -> i32;
4717}
4718extern "C" {
4719 pub fn udat_formatCalendarForFields_74(
4720 format: *const UDateFormat,
4721 calendar: *mut UCalendar,
4722 result: *mut UChar,
4723 capacity: i32,
4724 fpositer: *mut UFieldPositionIterator,
4725 status: *mut UErrorCode,
4726 ) -> i32;
4727}
4728extern "C" {
4729 pub fn udat_parse_74(
4730 format: *const UDateFormat,
4731 text: *const UChar,
4732 textLength: i32,
4733 parsePos: *mut i32,
4734 status: *mut UErrorCode,
4735 ) -> UDate;
4736}
4737extern "C" {
4738 pub fn udat_parseCalendar_74(
4739 format: *const UDateFormat,
4740 calendar: *mut UCalendar,
4741 text: *const UChar,
4742 textLength: i32,
4743 parsePos: *mut i32,
4744 status: *mut UErrorCode,
4745 );
4746}
4747extern "C" {
4748 pub fn udat_isLenient_74(fmt: *const UDateFormat) -> UBool;
4749}
4750extern "C" {
4751 pub fn udat_setLenient_74(fmt: *mut UDateFormat, isLenient: UBool);
4752}
4753extern "C" {
4754 pub fn udat_getCalendar_74(fmt: *const UDateFormat) -> *const UCalendar;
4755}
4756extern "C" {
4757 pub fn udat_setCalendar_74(fmt: *mut UDateFormat, calendarToSet: *const UCalendar);
4758}
4759extern "C" {
4760 pub fn udat_getNumberFormat_74(fmt: *const UDateFormat) -> *const UNumberFormat;
4761}
4762extern "C" {
4763 pub fn udat_getNumberFormatForField_74(
4764 fmt: *const UDateFormat,
4765 field: UChar,
4766 ) -> *const UNumberFormat;
4767}
4768extern "C" {
4769 pub fn udat_adoptNumberFormatForFields_74(
4770 fmt: *mut UDateFormat,
4771 fields: *const UChar,
4772 numberFormatToSet: *mut UNumberFormat,
4773 status: *mut UErrorCode,
4774 );
4775}
4776extern "C" {
4777 pub fn udat_setNumberFormat_74(fmt: *mut UDateFormat, numberFormatToSet: *const UNumberFormat);
4778}
4779extern "C" {
4780 pub fn udat_adoptNumberFormat_74(
4781 fmt: *mut UDateFormat,
4782 numberFormatToAdopt: *mut UNumberFormat,
4783 );
4784}
4785extern "C" {
4786 pub fn udat_getAvailable_74(localeIndex: i32) -> *const ::std::os::raw::c_char;
4787}
4788extern "C" {
4789 pub fn udat_countAvailable_74() -> i32;
4790}
4791extern "C" {
4792 pub fn udat_get2DigitYearStart_74(fmt: *const UDateFormat, status: *mut UErrorCode) -> UDate;
4793}
4794extern "C" {
4795 pub fn udat_set2DigitYearStart_74(fmt: *mut UDateFormat, d: UDate, status: *mut UErrorCode);
4796}
4797extern "C" {
4798 pub fn udat_toPattern_74(
4799 fmt: *const UDateFormat,
4800 localized: UBool,
4801 result: *mut UChar,
4802 resultLength: i32,
4803 status: *mut UErrorCode,
4804 ) -> i32;
4805}
4806extern "C" {
4807 pub fn udat_applyPattern_74(
4808 format: *mut UDateFormat,
4809 localized: UBool,
4810 pattern: *const UChar,
4811 patternLength: i32,
4812 );
4813}
4814#[repr(u32)]
4815#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
4816pub enum UDateFormatSymbolType {
4817 UDAT_ERAS = 0,
4818 UDAT_MONTHS = 1,
4819 UDAT_SHORT_MONTHS = 2,
4820 UDAT_WEEKDAYS = 3,
4821 UDAT_SHORT_WEEKDAYS = 4,
4822 UDAT_AM_PMS = 5,
4823 UDAT_LOCALIZED_CHARS = 6,
4824 UDAT_ERA_NAMES = 7,
4825 UDAT_NARROW_MONTHS = 8,
4826 UDAT_NARROW_WEEKDAYS = 9,
4827 UDAT_STANDALONE_MONTHS = 10,
4828 UDAT_STANDALONE_SHORT_MONTHS = 11,
4829 UDAT_STANDALONE_NARROW_MONTHS = 12,
4830 UDAT_STANDALONE_WEEKDAYS = 13,
4831 UDAT_STANDALONE_SHORT_WEEKDAYS = 14,
4832 UDAT_STANDALONE_NARROW_WEEKDAYS = 15,
4833 UDAT_QUARTERS = 16,
4834 UDAT_SHORT_QUARTERS = 17,
4835 UDAT_STANDALONE_QUARTERS = 18,
4836 UDAT_STANDALONE_SHORT_QUARTERS = 19,
4837 UDAT_SHORTER_WEEKDAYS = 20,
4838 UDAT_STANDALONE_SHORTER_WEEKDAYS = 21,
4839 UDAT_CYCLIC_YEARS_WIDE = 22,
4840 UDAT_CYCLIC_YEARS_ABBREVIATED = 23,
4841 UDAT_CYCLIC_YEARS_NARROW = 24,
4842 UDAT_ZODIAC_NAMES_WIDE = 25,
4843 UDAT_ZODIAC_NAMES_ABBREVIATED = 26,
4844 UDAT_ZODIAC_NAMES_NARROW = 27,
4845 UDAT_NARROW_QUARTERS = 28,
4846 UDAT_STANDALONE_NARROW_QUARTERS = 29,
4847}
4848#[repr(C)]
4849#[derive(Debug, Copy, Clone)]
4850pub struct UDateFormatSymbols {
4851 _unused: [u8; 0],
4852}
4853extern "C" {
4854 pub fn udat_getSymbols_74(
4855 fmt: *const UDateFormat,
4856 type_: UDateFormatSymbolType,
4857 symbolIndex: i32,
4858 result: *mut UChar,
4859 resultLength: i32,
4860 status: *mut UErrorCode,
4861 ) -> i32;
4862}
4863extern "C" {
4864 pub fn udat_countSymbols_74(fmt: *const UDateFormat, type_: UDateFormatSymbolType) -> i32;
4865}
4866extern "C" {
4867 pub fn udat_setSymbols_74(
4868 format: *mut UDateFormat,
4869 type_: UDateFormatSymbolType,
4870 symbolIndex: i32,
4871 value: *mut UChar,
4872 valueLength: i32,
4873 status: *mut UErrorCode,
4874 );
4875}
4876extern "C" {
4877 pub fn udat_getLocaleByType_74(
4878 fmt: *const UDateFormat,
4879 type_: ULocDataLocaleType,
4880 status: *mut UErrorCode,
4881 ) -> *const ::std::os::raw::c_char;
4882}
4883extern "C" {
4884 pub fn udat_setContext_74(
4885 fmt: *mut UDateFormat,
4886 value: UDisplayContext,
4887 status: *mut UErrorCode,
4888 );
4889}
4890extern "C" {
4891 pub fn udat_getContext_74(
4892 fmt: *const UDateFormat,
4893 type_: UDisplayContextType,
4894 status: *mut UErrorCode,
4895 ) -> UDisplayContext;
4896}
4897extern "C" {
4898 pub fn udat_toPatternRelativeDate_74(
4899 fmt: *const UDateFormat,
4900 result: *mut UChar,
4901 resultLength: i32,
4902 status: *mut UErrorCode,
4903 ) -> i32;
4904}
4905extern "C" {
4906 pub fn udat_toPatternRelativeTime_74(
4907 fmt: *const UDateFormat,
4908 result: *mut UChar,
4909 resultLength: i32,
4910 status: *mut UErrorCode,
4911 ) -> i32;
4912}
4913extern "C" {
4914 pub fn udat_applyPatternRelative_74(
4915 format: *mut UDateFormat,
4916 datePattern: *const UChar,
4917 datePatternLength: i32,
4918 timePattern: *const UChar,
4919 timePatternLength: i32,
4920 status: *mut UErrorCode,
4921 );
4922}
4923pub type UDateFormatOpener = ::std::option::Option<
4924 unsafe extern "C" fn(
4925 timeStyle: UDateFormatStyle,
4926 dateStyle: UDateFormatStyle,
4927 locale: *const ::std::os::raw::c_char,
4928 tzID: *const UChar,
4929 tzIDLength: i32,
4930 pattern: *const UChar,
4931 patternLength: i32,
4932 status: *mut UErrorCode,
4933 ) -> *mut UDateFormat,
4934>;
4935extern "C" {
4936 pub fn udat_registerOpener_74(opener: UDateFormatOpener, status: *mut UErrorCode);
4937}
4938extern "C" {
4939 pub fn udat_unregisterOpener_74(
4940 opener: UDateFormatOpener,
4941 status: *mut UErrorCode,
4942 ) -> UDateFormatOpener;
4943}
4944pub type UDateTimePatternGenerator = *mut ::std::os::raw::c_void;
4945#[repr(u32)]
4946#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
4947pub enum UDateTimePatternField {
4948 UDATPG_ERA_FIELD = 0,
4949 UDATPG_YEAR_FIELD = 1,
4950 UDATPG_QUARTER_FIELD = 2,
4951 UDATPG_MONTH_FIELD = 3,
4952 UDATPG_WEEK_OF_YEAR_FIELD = 4,
4953 UDATPG_WEEK_OF_MONTH_FIELD = 5,
4954 UDATPG_WEEKDAY_FIELD = 6,
4955 UDATPG_DAY_OF_YEAR_FIELD = 7,
4956 UDATPG_DAY_OF_WEEK_IN_MONTH_FIELD = 8,
4957 UDATPG_DAY_FIELD = 9,
4958 UDATPG_DAYPERIOD_FIELD = 10,
4959 UDATPG_HOUR_FIELD = 11,
4960 UDATPG_MINUTE_FIELD = 12,
4961 UDATPG_SECOND_FIELD = 13,
4962 UDATPG_FRACTIONAL_SECOND_FIELD = 14,
4963 UDATPG_ZONE_FIELD = 15,
4964 UDATPG_FIELD_COUNT = 16,
4965}
4966#[repr(u32)]
4967#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
4968pub enum UDateTimePGDisplayWidth {
4969 UDATPG_WIDE = 0,
4970 UDATPG_ABBREVIATED = 1,
4971 UDATPG_NARROW = 2,
4972}
4973#[repr(u32)]
4974#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
4975pub enum UDateTimePatternMatchOptions {
4976 UDATPG_MATCH_NO_OPTIONS = 0,
4977 UDATPG_MATCH_HOUR_FIELD_LENGTH = 2048,
4978 UDATPG_MATCH_MINUTE_FIELD_LENGTH = 4096,
4979 UDATPG_MATCH_SECOND_FIELD_LENGTH = 8192,
4980 UDATPG_MATCH_ALL_FIELDS_LENGTH = 65535,
4981}
4982#[repr(u32)]
4983#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
4984pub enum UDateTimePatternConflict {
4985 UDATPG_NO_CONFLICT = 0,
4986 UDATPG_BASE_CONFLICT = 1,
4987 UDATPG_CONFLICT = 2,
4988 UDATPG_CONFLICT_COUNT = 3,
4989}
4990extern "C" {
4991 pub fn udatpg_open_74(
4992 locale: *const ::std::os::raw::c_char,
4993 pErrorCode: *mut UErrorCode,
4994 ) -> *mut UDateTimePatternGenerator;
4995}
4996extern "C" {
4997 pub fn udatpg_openEmpty_74(pErrorCode: *mut UErrorCode) -> *mut UDateTimePatternGenerator;
4998}
4999extern "C" {
5000 pub fn udatpg_close_74(dtpg: *mut UDateTimePatternGenerator);
5001}
5002extern "C" {
5003 pub fn udatpg_clone_74(
5004 dtpg: *const UDateTimePatternGenerator,
5005 pErrorCode: *mut UErrorCode,
5006 ) -> *mut UDateTimePatternGenerator;
5007}
5008extern "C" {
5009 pub fn udatpg_getBestPattern_74(
5010 dtpg: *mut UDateTimePatternGenerator,
5011 skeleton: *const UChar,
5012 length: i32,
5013 bestPattern: *mut UChar,
5014 capacity: i32,
5015 pErrorCode: *mut UErrorCode,
5016 ) -> i32;
5017}
5018extern "C" {
5019 pub fn udatpg_getBestPatternWithOptions_74(
5020 dtpg: *mut UDateTimePatternGenerator,
5021 skeleton: *const UChar,
5022 length: i32,
5023 options: UDateTimePatternMatchOptions,
5024 bestPattern: *mut UChar,
5025 capacity: i32,
5026 pErrorCode: *mut UErrorCode,
5027 ) -> i32;
5028}
5029extern "C" {
5030 pub fn udatpg_getSkeleton_74(
5031 unusedDtpg: *mut UDateTimePatternGenerator,
5032 pattern: *const UChar,
5033 length: i32,
5034 skeleton: *mut UChar,
5035 capacity: i32,
5036 pErrorCode: *mut UErrorCode,
5037 ) -> i32;
5038}
5039extern "C" {
5040 pub fn udatpg_getBaseSkeleton_74(
5041 unusedDtpg: *mut UDateTimePatternGenerator,
5042 pattern: *const UChar,
5043 length: i32,
5044 baseSkeleton: *mut UChar,
5045 capacity: i32,
5046 pErrorCode: *mut UErrorCode,
5047 ) -> i32;
5048}
5049extern "C" {
5050 pub fn udatpg_addPattern_74(
5051 dtpg: *mut UDateTimePatternGenerator,
5052 pattern: *const UChar,
5053 patternLength: i32,
5054 override_: UBool,
5055 conflictingPattern: *mut UChar,
5056 capacity: i32,
5057 pLength: *mut i32,
5058 pErrorCode: *mut UErrorCode,
5059 ) -> UDateTimePatternConflict;
5060}
5061extern "C" {
5062 pub fn udatpg_setAppendItemFormat_74(
5063 dtpg: *mut UDateTimePatternGenerator,
5064 field: UDateTimePatternField,
5065 value: *const UChar,
5066 length: i32,
5067 );
5068}
5069extern "C" {
5070 pub fn udatpg_getAppendItemFormat_74(
5071 dtpg: *const UDateTimePatternGenerator,
5072 field: UDateTimePatternField,
5073 pLength: *mut i32,
5074 ) -> *const UChar;
5075}
5076extern "C" {
5077 pub fn udatpg_setAppendItemName_74(
5078 dtpg: *mut UDateTimePatternGenerator,
5079 field: UDateTimePatternField,
5080 value: *const UChar,
5081 length: i32,
5082 );
5083}
5084extern "C" {
5085 pub fn udatpg_getAppendItemName_74(
5086 dtpg: *const UDateTimePatternGenerator,
5087 field: UDateTimePatternField,
5088 pLength: *mut i32,
5089 ) -> *const UChar;
5090}
5091extern "C" {
5092 pub fn udatpg_getFieldDisplayName_74(
5093 dtpg: *const UDateTimePatternGenerator,
5094 field: UDateTimePatternField,
5095 width: UDateTimePGDisplayWidth,
5096 fieldName: *mut UChar,
5097 capacity: i32,
5098 pErrorCode: *mut UErrorCode,
5099 ) -> i32;
5100}
5101extern "C" {
5102 pub fn udatpg_setDateTimeFormat_74(
5103 dtpg: *const UDateTimePatternGenerator,
5104 dtFormat: *const UChar,
5105 length: i32,
5106 );
5107}
5108extern "C" {
5109 pub fn udatpg_getDateTimeFormat_74(
5110 dtpg: *const UDateTimePatternGenerator,
5111 pLength: *mut i32,
5112 ) -> *const UChar;
5113}
5114extern "C" {
5115 pub fn udatpg_setDateTimeFormatForStyle_74(
5116 udtpg: *mut UDateTimePatternGenerator,
5117 style: UDateFormatStyle,
5118 dateTimeFormat: *const UChar,
5119 length: i32,
5120 pErrorCode: *mut UErrorCode,
5121 );
5122}
5123extern "C" {
5124 pub fn udatpg_getDateTimeFormatForStyle_74(
5125 udtpg: *const UDateTimePatternGenerator,
5126 style: UDateFormatStyle,
5127 pLength: *mut i32,
5128 pErrorCode: *mut UErrorCode,
5129 ) -> *const UChar;
5130}
5131extern "C" {
5132 pub fn udatpg_setDecimal_74(
5133 dtpg: *mut UDateTimePatternGenerator,
5134 decimal: *const UChar,
5135 length: i32,
5136 );
5137}
5138extern "C" {
5139 pub fn udatpg_getDecimal_74(
5140 dtpg: *const UDateTimePatternGenerator,
5141 pLength: *mut i32,
5142 ) -> *const UChar;
5143}
5144extern "C" {
5145 pub fn udatpg_replaceFieldTypes_74(
5146 dtpg: *mut UDateTimePatternGenerator,
5147 pattern: *const UChar,
5148 patternLength: i32,
5149 skeleton: *const UChar,
5150 skeletonLength: i32,
5151 dest: *mut UChar,
5152 destCapacity: i32,
5153 pErrorCode: *mut UErrorCode,
5154 ) -> i32;
5155}
5156extern "C" {
5157 pub fn udatpg_replaceFieldTypesWithOptions_74(
5158 dtpg: *mut UDateTimePatternGenerator,
5159 pattern: *const UChar,
5160 patternLength: i32,
5161 skeleton: *const UChar,
5162 skeletonLength: i32,
5163 options: UDateTimePatternMatchOptions,
5164 dest: *mut UChar,
5165 destCapacity: i32,
5166 pErrorCode: *mut UErrorCode,
5167 ) -> i32;
5168}
5169extern "C" {
5170 pub fn udatpg_openSkeletons_74(
5171 dtpg: *const UDateTimePatternGenerator,
5172 pErrorCode: *mut UErrorCode,
5173 ) -> *mut UEnumeration;
5174}
5175extern "C" {
5176 pub fn udatpg_openBaseSkeletons_74(
5177 dtpg: *const UDateTimePatternGenerator,
5178 pErrorCode: *mut UErrorCode,
5179 ) -> *mut UEnumeration;
5180}
5181extern "C" {
5182 pub fn udatpg_getPatternForSkeleton_74(
5183 dtpg: *const UDateTimePatternGenerator,
5184 skeleton: *const UChar,
5185 skeletonLength: i32,
5186 pLength: *mut i32,
5187 ) -> *const UChar;
5188}
5189extern "C" {
5190 pub fn udatpg_getDefaultHourCycle_74(
5191 dtpg: *const UDateTimePatternGenerator,
5192 pErrorCode: *mut UErrorCode,
5193 ) -> UDateFormatHourCycle;
5194}
5195#[repr(C)]
5196#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, PartialEq)]
5197pub struct UDataInfo {
5198 pub size: u16,
5199 pub reservedWord: u16,
5200 pub isBigEndian: u8,
5201 pub charsetFamily: u8,
5202 pub sizeofUChar: u8,
5203 pub reservedByte: u8,
5204 pub dataFormat: [u8; 4usize],
5205 pub formatVersion: [u8; 4usize],
5206 pub dataVersion: [u8; 4usize],
5207}
5208#[test]
5209fn bindgen_test_layout_UDataInfo() {
5210 const UNINIT: ::std::mem::MaybeUninit<UDataInfo> = ::std::mem::MaybeUninit::uninit();
5211 let ptr = UNINIT.as_ptr();
5212 assert_eq!(
5213 ::std::mem::size_of::<UDataInfo>(),
5214 20usize,
5215 concat!("Size of: ", stringify!(UDataInfo))
5216 );
5217 assert_eq!(
5218 ::std::mem::align_of::<UDataInfo>(),
5219 2usize,
5220 concat!("Alignment of ", stringify!(UDataInfo))
5221 );
5222 assert_eq!(
5223 unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
5224 0usize,
5225 concat!(
5226 "Offset of field: ",
5227 stringify!(UDataInfo),
5228 "::",
5229 stringify!(size)
5230 )
5231 );
5232 assert_eq!(
5233 unsafe { ::std::ptr::addr_of!((*ptr).reservedWord) as usize - ptr as usize },
5234 2usize,
5235 concat!(
5236 "Offset of field: ",
5237 stringify!(UDataInfo),
5238 "::",
5239 stringify!(reservedWord)
5240 )
5241 );
5242 assert_eq!(
5243 unsafe { ::std::ptr::addr_of!((*ptr).isBigEndian) as usize - ptr as usize },
5244 4usize,
5245 concat!(
5246 "Offset of field: ",
5247 stringify!(UDataInfo),
5248 "::",
5249 stringify!(isBigEndian)
5250 )
5251 );
5252 assert_eq!(
5253 unsafe { ::std::ptr::addr_of!((*ptr).charsetFamily) as usize - ptr as usize },
5254 5usize,
5255 concat!(
5256 "Offset of field: ",
5257 stringify!(UDataInfo),
5258 "::",
5259 stringify!(charsetFamily)
5260 )
5261 );
5262 assert_eq!(
5263 unsafe { ::std::ptr::addr_of!((*ptr).sizeofUChar) as usize - ptr as usize },
5264 6usize,
5265 concat!(
5266 "Offset of field: ",
5267 stringify!(UDataInfo),
5268 "::",
5269 stringify!(sizeofUChar)
5270 )
5271 );
5272 assert_eq!(
5273 unsafe { ::std::ptr::addr_of!((*ptr).reservedByte) as usize - ptr as usize },
5274 7usize,
5275 concat!(
5276 "Offset of field: ",
5277 stringify!(UDataInfo),
5278 "::",
5279 stringify!(reservedByte)
5280 )
5281 );
5282 assert_eq!(
5283 unsafe { ::std::ptr::addr_of!((*ptr).dataFormat) as usize - ptr as usize },
5284 8usize,
5285 concat!(
5286 "Offset of field: ",
5287 stringify!(UDataInfo),
5288 "::",
5289 stringify!(dataFormat)
5290 )
5291 );
5292 assert_eq!(
5293 unsafe { ::std::ptr::addr_of!((*ptr).formatVersion) as usize - ptr as usize },
5294 12usize,
5295 concat!(
5296 "Offset of field: ",
5297 stringify!(UDataInfo),
5298 "::",
5299 stringify!(formatVersion)
5300 )
5301 );
5302 assert_eq!(
5303 unsafe { ::std::ptr::addr_of!((*ptr).dataVersion) as usize - ptr as usize },
5304 16usize,
5305 concat!(
5306 "Offset of field: ",
5307 stringify!(UDataInfo),
5308 "::",
5309 stringify!(dataVersion)
5310 )
5311 );
5312}
5313#[repr(C)]
5314#[derive(Debug, Copy, Clone)]
5315pub struct UDataMemory {
5316 _unused: [u8; 0],
5317}
5318pub type UDataMemoryIsAcceptable = ::std::option::Option<
5319 unsafe extern "C" fn(
5320 context: *mut ::std::os::raw::c_void,
5321 type_: *const ::std::os::raw::c_char,
5322 name: *const ::std::os::raw::c_char,
5323 pInfo: *const UDataInfo,
5324 ) -> UBool,
5325>;
5326extern "C" {
5327 pub fn udata_open_74(
5328 path: *const ::std::os::raw::c_char,
5329 type_: *const ::std::os::raw::c_char,
5330 name: *const ::std::os::raw::c_char,
5331 pErrorCode: *mut UErrorCode,
5332 ) -> *mut UDataMemory;
5333}
5334extern "C" {
5335 pub fn udata_openChoice_74(
5336 path: *const ::std::os::raw::c_char,
5337 type_: *const ::std::os::raw::c_char,
5338 name: *const ::std::os::raw::c_char,
5339 isAcceptable: UDataMemoryIsAcceptable,
5340 context: *mut ::std::os::raw::c_void,
5341 pErrorCode: *mut UErrorCode,
5342 ) -> *mut UDataMemory;
5343}
5344extern "C" {
5345 pub fn udata_close_74(pData: *mut UDataMemory);
5346}
5347extern "C" {
5348 pub fn udata_getMemory_74(pData: *mut UDataMemory) -> *const ::std::os::raw::c_void;
5349}
5350extern "C" {
5351 pub fn udata_getInfo_74(pData: *mut UDataMemory, pInfo: *mut UDataInfo);
5352}
5353extern "C" {
5354 pub fn udata_setCommonData_74(data: *const ::std::os::raw::c_void, err: *mut UErrorCode);
5355}
5356extern "C" {
5357 pub fn udata_setAppData_74(
5358 packageName: *const ::std::os::raw::c_char,
5359 data: *const ::std::os::raw::c_void,
5360 err: *mut UErrorCode,
5361 );
5362}
5363impl UDataFileAccess {
5364 pub const UDATA_DEFAULT_ACCESS: UDataFileAccess = UDataFileAccess::UDATA_FILES_FIRST;
5365}
5366#[repr(u32)]
5367#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
5368pub enum UDataFileAccess {
5369 UDATA_FILES_FIRST = 0,
5370 UDATA_ONLY_PACKAGES = 1,
5371 UDATA_PACKAGES_FIRST = 2,
5372 UDATA_NO_FILES = 3,
5373 UDATA_FILE_ACCESS_COUNT = 4,
5374}
5375extern "C" {
5376 pub fn udata_setFileAccess_74(access: UDataFileAccess, status: *mut UErrorCode);
5377}
5378#[repr(u32)]
5379#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
5380pub enum UFieldCategory {
5381 UFIELD_CATEGORY_UNDEFINED = 0,
5382 UFIELD_CATEGORY_DATE = 1,
5383 UFIELD_CATEGORY_NUMBER = 2,
5384 UFIELD_CATEGORY_LIST = 3,
5385 UFIELD_CATEGORY_RELATIVE_DATETIME = 4,
5386 UFIELD_CATEGORY_DATE_INTERVAL = 5,
5387 UFIELD_CATEGORY_COUNT = 6,
5388 UFIELD_CATEGORY_LIST_SPAN = 4099,
5389 UFIELD_CATEGORY_DATE_INTERVAL_SPAN = 4101,
5390 UFIELD_CATEGORY_NUMBER_RANGE_SPAN = 4098,
5391}
5392#[repr(C)]
5393#[derive(Debug, Copy, Clone)]
5394pub struct UFormattedValue {
5395 _unused: [u8; 0],
5396}
5397#[repr(C)]
5398#[derive(Debug, Copy, Clone)]
5399pub struct UListFormatter {
5400 _unused: [u8; 0],
5401}
5402#[repr(C)]
5403#[derive(Debug, Copy, Clone)]
5404pub struct UFormattedList {
5405 _unused: [u8; 0],
5406}
5407#[repr(u32)]
5408#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
5409pub enum UListFormatterField {
5410 ULISTFMT_LITERAL_FIELD = 0,
5411 ULISTFMT_ELEMENT_FIELD = 1,
5412}
5413#[repr(u32)]
5414#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
5415pub enum UListFormatterType {
5416 ULISTFMT_TYPE_AND = 0,
5417 ULISTFMT_TYPE_OR = 1,
5418 ULISTFMT_TYPE_UNITS = 2,
5419}
5420#[repr(u32)]
5421#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
5422pub enum UListFormatterWidth {
5423 ULISTFMT_WIDTH_WIDE = 0,
5424 ULISTFMT_WIDTH_SHORT = 1,
5425 ULISTFMT_WIDTH_NARROW = 2,
5426}
5427extern "C" {
5428 pub fn ulistfmt_open_74(
5429 locale: *const ::std::os::raw::c_char,
5430 status: *mut UErrorCode,
5431 ) -> *mut UListFormatter;
5432}
5433extern "C" {
5434 pub fn ulistfmt_openForType_74(
5435 locale: *const ::std::os::raw::c_char,
5436 type_: UListFormatterType,
5437 width: UListFormatterWidth,
5438 status: *mut UErrorCode,
5439 ) -> *mut UListFormatter;
5440}
5441extern "C" {
5442 pub fn ulistfmt_close_74(listfmt: *mut UListFormatter);
5443}
5444extern "C" {
5445 pub fn ulistfmt_openResult_74(ec: *mut UErrorCode) -> *mut UFormattedList;
5446}
5447extern "C" {
5448 pub fn ulistfmt_resultAsValue_74(
5449 uresult: *const UFormattedList,
5450 ec: *mut UErrorCode,
5451 ) -> *const UFormattedValue;
5452}
5453extern "C" {
5454 pub fn ulistfmt_closeResult_74(uresult: *mut UFormattedList);
5455}
5456extern "C" {
5457 pub fn ulistfmt_format_74(
5458 listfmt: *const UListFormatter,
5459 strings: *const *const UChar,
5460 stringLengths: *const i32,
5461 stringCount: i32,
5462 result: *mut UChar,
5463 resultCapacity: i32,
5464 status: *mut UErrorCode,
5465 ) -> i32;
5466}
5467extern "C" {
5468 pub fn ulistfmt_formatStringsToResult_74(
5469 listfmt: *const UListFormatter,
5470 strings: *const *const UChar,
5471 stringLengths: *const i32,
5472 stringCount: i32,
5473 uresult: *mut UFormattedList,
5474 status: *mut UErrorCode,
5475 );
5476}
5477pub type va_list = __builtin_va_list;
5478extern "C" {
5479 pub fn u_formatMessage_74(
5480 locale: *const ::std::os::raw::c_char,
5481 pattern: *const UChar,
5482 patternLength: i32,
5483 result: *mut UChar,
5484 resultLength: i32,
5485 status: *mut UErrorCode,
5486 ...
5487 ) -> i32;
5488}
5489extern "C" {
5490 pub fn u_vformatMessage_74(
5491 locale: *const ::std::os::raw::c_char,
5492 pattern: *const UChar,
5493 patternLength: i32,
5494 result: *mut UChar,
5495 resultLength: i32,
5496 ap: *mut __va_list_tag,
5497 status: *mut UErrorCode,
5498 ) -> i32;
5499}
5500extern "C" {
5501 pub fn u_parseMessage_74(
5502 locale: *const ::std::os::raw::c_char,
5503 pattern: *const UChar,
5504 patternLength: i32,
5505 source: *const UChar,
5506 sourceLength: i32,
5507 status: *mut UErrorCode,
5508 ...
5509 );
5510}
5511extern "C" {
5512 pub fn u_vparseMessage_74(
5513 locale: *const ::std::os::raw::c_char,
5514 pattern: *const UChar,
5515 patternLength: i32,
5516 source: *const UChar,
5517 sourceLength: i32,
5518 ap: *mut __va_list_tag,
5519 status: *mut UErrorCode,
5520 );
5521}
5522extern "C" {
5523 pub fn u_formatMessageWithError_74(
5524 locale: *const ::std::os::raw::c_char,
5525 pattern: *const UChar,
5526 patternLength: i32,
5527 result: *mut UChar,
5528 resultLength: i32,
5529 parseError: *mut UParseError,
5530 status: *mut UErrorCode,
5531 ...
5532 ) -> i32;
5533}
5534extern "C" {
5535 pub fn u_vformatMessageWithError_74(
5536 locale: *const ::std::os::raw::c_char,
5537 pattern: *const UChar,
5538 patternLength: i32,
5539 result: *mut UChar,
5540 resultLength: i32,
5541 parseError: *mut UParseError,
5542 ap: *mut __va_list_tag,
5543 status: *mut UErrorCode,
5544 ) -> i32;
5545}
5546extern "C" {
5547 pub fn u_parseMessageWithError_74(
5548 locale: *const ::std::os::raw::c_char,
5549 pattern: *const UChar,
5550 patternLength: i32,
5551 source: *const UChar,
5552 sourceLength: i32,
5553 parseError: *mut UParseError,
5554 status: *mut UErrorCode,
5555 ...
5556 );
5557}
5558extern "C" {
5559 pub fn u_vparseMessageWithError_74(
5560 locale: *const ::std::os::raw::c_char,
5561 pattern: *const UChar,
5562 patternLength: i32,
5563 source: *const UChar,
5564 sourceLength: i32,
5565 ap: *mut __va_list_tag,
5566 parseError: *mut UParseError,
5567 status: *mut UErrorCode,
5568 );
5569}
5570pub type UMessageFormat = *mut ::std::os::raw::c_void;
5571extern "C" {
5572 pub fn umsg_open_74(
5573 pattern: *const UChar,
5574 patternLength: i32,
5575 locale: *const ::std::os::raw::c_char,
5576 parseError: *mut UParseError,
5577 status: *mut UErrorCode,
5578 ) -> *mut UMessageFormat;
5579}
5580extern "C" {
5581 pub fn umsg_close_74(format: *mut UMessageFormat);
5582}
5583extern "C" {
5584 pub fn umsg_clone_74(fmt: *const UMessageFormat, status: *mut UErrorCode) -> UMessageFormat;
5585}
5586extern "C" {
5587 pub fn umsg_setLocale_74(fmt: *mut UMessageFormat, locale: *const ::std::os::raw::c_char);
5588}
5589extern "C" {
5590 pub fn umsg_getLocale_74(fmt: *const UMessageFormat) -> *const ::std::os::raw::c_char;
5591}
5592extern "C" {
5593 pub fn umsg_applyPattern_74(
5594 fmt: *mut UMessageFormat,
5595 pattern: *const UChar,
5596 patternLength: i32,
5597 parseError: *mut UParseError,
5598 status: *mut UErrorCode,
5599 );
5600}
5601extern "C" {
5602 pub fn umsg_toPattern_74(
5603 fmt: *const UMessageFormat,
5604 result: *mut UChar,
5605 resultLength: i32,
5606 status: *mut UErrorCode,
5607 ) -> i32;
5608}
5609extern "C" {
5610 pub fn umsg_format_74(
5611 fmt: *const UMessageFormat,
5612 result: *mut UChar,
5613 resultLength: i32,
5614 status: *mut UErrorCode,
5615 ...
5616 ) -> i32;
5617}
5618extern "C" {
5619 pub fn umsg_vformat_74(
5620 fmt: *const UMessageFormat,
5621 result: *mut UChar,
5622 resultLength: i32,
5623 ap: *mut __va_list_tag,
5624 status: *mut UErrorCode,
5625 ) -> i32;
5626}
5627extern "C" {
5628 pub fn umsg_parse_74(
5629 fmt: *const UMessageFormat,
5630 source: *const UChar,
5631 sourceLength: i32,
5632 count: *mut i32,
5633 status: *mut UErrorCode,
5634 ...
5635 );
5636}
5637extern "C" {
5638 pub fn umsg_vparse_74(
5639 fmt: *const UMessageFormat,
5640 source: *const UChar,
5641 sourceLength: i32,
5642 count: *mut i32,
5643 ap: *mut __va_list_tag,
5644 status: *mut UErrorCode,
5645 );
5646}
5647extern "C" {
5648 pub fn umsg_autoQuoteApostrophe_74(
5649 pattern: *const UChar,
5650 patternLength: i32,
5651 dest: *mut UChar,
5652 destCapacity: i32,
5653 ec: *mut UErrorCode,
5654 ) -> i32;
5655}
5656#[repr(C)]
5657#[derive(Debug, Copy, Clone)]
5658pub struct UFormattedNumber {
5659 _unused: [u8; 0],
5660}
5661extern "C" {
5662 pub fn unumf_openResult_74(ec: *mut UErrorCode) -> *mut UFormattedNumber;
5663}
5664extern "C" {
5665 pub fn unumf_resultAsValue_74(
5666 uresult: *const UFormattedNumber,
5667 ec: *mut UErrorCode,
5668 ) -> *const UFormattedValue;
5669}
5670extern "C" {
5671 pub fn unumf_resultToString_74(
5672 uresult: *const UFormattedNumber,
5673 buffer: *mut UChar,
5674 bufferCapacity: i32,
5675 ec: *mut UErrorCode,
5676 ) -> i32;
5677}
5678extern "C" {
5679 pub fn unumf_resultNextFieldPosition_74(
5680 uresult: *const UFormattedNumber,
5681 ufpos: *mut UFieldPosition,
5682 ec: *mut UErrorCode,
5683 ) -> UBool;
5684}
5685extern "C" {
5686 pub fn unumf_resultGetAllFieldPositions_74(
5687 uresult: *const UFormattedNumber,
5688 ufpositer: *mut UFieldPositionIterator,
5689 ec: *mut UErrorCode,
5690 );
5691}
5692extern "C" {
5693 pub fn unumf_resultToDecimalNumber_74(
5694 uresult: *const UFormattedNumber,
5695 dest: *mut ::std::os::raw::c_char,
5696 destCapacity: i32,
5697 ec: *mut UErrorCode,
5698 ) -> i32;
5699}
5700extern "C" {
5701 pub fn unumf_closeResult_74(uresult: *mut UFormattedNumber);
5702}
5703#[repr(C)]
5704#[derive(Debug, Copy, Clone)]
5705pub struct UNumberFormatter {
5706 _unused: [u8; 0],
5707}
5708extern "C" {
5709 pub fn unumf_openForSkeletonAndLocale_74(
5710 skeleton: *const UChar,
5711 skeletonLen: i32,
5712 locale: *const ::std::os::raw::c_char,
5713 ec: *mut UErrorCode,
5714 ) -> *mut UNumberFormatter;
5715}
5716extern "C" {
5717 pub fn unumf_openForSkeletonAndLocaleWithError_74(
5718 skeleton: *const UChar,
5719 skeletonLen: i32,
5720 locale: *const ::std::os::raw::c_char,
5721 perror: *mut UParseError,
5722 ec: *mut UErrorCode,
5723 ) -> *mut UNumberFormatter;
5724}
5725extern "C" {
5726 pub fn unumf_formatInt_74(
5727 uformatter: *const UNumberFormatter,
5728 value: i64,
5729 uresult: *mut UFormattedNumber,
5730 ec: *mut UErrorCode,
5731 );
5732}
5733extern "C" {
5734 pub fn unumf_formatDouble_74(
5735 uformatter: *const UNumberFormatter,
5736 value: f64,
5737 uresult: *mut UFormattedNumber,
5738 ec: *mut UErrorCode,
5739 );
5740}
5741extern "C" {
5742 pub fn unumf_formatDecimal_74(
5743 uformatter: *const UNumberFormatter,
5744 value: *const ::std::os::raw::c_char,
5745 valueLen: i32,
5746 uresult: *mut UFormattedNumber,
5747 ec: *mut UErrorCode,
5748 );
5749}
5750extern "C" {
5751 pub fn unumf_close_74(uformatter: *mut UNumberFormatter);
5752}
5753#[repr(C)]
5754#[derive(Debug, Copy, Clone)]
5755pub struct UFormattedNumberRange {
5756 _unused: [u8; 0],
5757}
5758#[repr(u32)]
5759#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
5760pub enum UPluralType {
5761 UPLURAL_TYPE_CARDINAL = 0,
5762 UPLURAL_TYPE_ORDINAL = 1,
5763 UPLURAL_TYPE_COUNT = 2,
5764}
5765#[repr(C)]
5766#[derive(Debug, Copy, Clone)]
5767pub struct UPluralRules {
5768 _unused: [u8; 0],
5769}
5770extern "C" {
5771 pub fn uplrules_open_74(
5772 locale: *const ::std::os::raw::c_char,
5773 status: *mut UErrorCode,
5774 ) -> *mut UPluralRules;
5775}
5776extern "C" {
5777 pub fn uplrules_openForType_74(
5778 locale: *const ::std::os::raw::c_char,
5779 type_: UPluralType,
5780 status: *mut UErrorCode,
5781 ) -> *mut UPluralRules;
5782}
5783extern "C" {
5784 pub fn uplrules_close_74(uplrules: *mut UPluralRules);
5785}
5786extern "C" {
5787 pub fn uplrules_select_74(
5788 uplrules: *const UPluralRules,
5789 number: f64,
5790 keyword: *mut UChar,
5791 capacity: i32,
5792 status: *mut UErrorCode,
5793 ) -> i32;
5794}
5795extern "C" {
5796 pub fn uplrules_selectFormatted_74(
5797 uplrules: *const UPluralRules,
5798 number: *const UFormattedNumber,
5799 keyword: *mut UChar,
5800 capacity: i32,
5801 status: *mut UErrorCode,
5802 ) -> i32;
5803}
5804extern "C" {
5805 pub fn uplrules_selectForRange_74(
5806 uplrules: *const UPluralRules,
5807 urange: *const UFormattedNumberRange,
5808 keyword: *mut UChar,
5809 capacity: i32,
5810 status: *mut UErrorCode,
5811 ) -> i32;
5812}
5813extern "C" {
5814 pub fn uplrules_selectWithFormat_74(
5815 uplrules: *const UPluralRules,
5816 number: f64,
5817 fmt: *const UNumberFormat,
5818 keyword: *mut UChar,
5819 capacity: i32,
5820 status: *mut UErrorCode,
5821 ) -> i32;
5822}
5823extern "C" {
5824 pub fn uplrules_getKeywords_74(
5825 uplrules: *const UPluralRules,
5826 status: *mut UErrorCode,
5827 ) -> *mut UEnumeration;
5828}
5829extern "C" {
5830 pub fn u_getDataDirectory_74() -> *const ::std::os::raw::c_char;
5831}
5832extern "C" {
5833 pub fn u_setDataDirectory_74(directory: *const ::std::os::raw::c_char);
5834}
5835extern "C" {
5836 pub fn u_getTimeZoneFilesDirectory_74(status: *mut UErrorCode)
5837 -> *const ::std::os::raw::c_char;
5838}
5839extern "C" {
5840 pub fn u_setTimeZoneFilesDirectory_74(
5841 path: *const ::std::os::raw::c_char,
5842 status: *mut UErrorCode,
5843 );
5844}
5845extern "C" {
5846 pub fn u_charsToUChars_74(cs: *const ::std::os::raw::c_char, us: *mut UChar, length: i32);
5847}
5848extern "C" {
5849 pub fn u_UCharsToChars_74(us: *const UChar, cs: *mut ::std::os::raw::c_char, length: i32);
5850}
5851extern "C" {
5852 pub fn u_strlen_74(s: *const UChar) -> i32;
5853}
5854extern "C" {
5855 pub fn u_countChar32_74(s: *const UChar, length: i32) -> i32;
5856}
5857extern "C" {
5858 pub fn u_strHasMoreChar32Than_74(s: *const UChar, length: i32, number: i32) -> UBool;
5859}
5860extern "C" {
5861 pub fn u_strcat_74(dst: *mut UChar, src: *const UChar) -> *mut UChar;
5862}
5863extern "C" {
5864 pub fn u_strncat_74(dst: *mut UChar, src: *const UChar, n: i32) -> *mut UChar;
5865}
5866extern "C" {
5867 pub fn u_strstr_74(s: *const UChar, substring: *const UChar) -> *mut UChar;
5868}
5869extern "C" {
5870 pub fn u_strFindFirst_74(
5871 s: *const UChar,
5872 length: i32,
5873 substring: *const UChar,
5874 subLength: i32,
5875 ) -> *mut UChar;
5876}
5877extern "C" {
5878 pub fn u_strchr_74(s: *const UChar, c: UChar) -> *mut UChar;
5879}
5880extern "C" {
5881 pub fn u_strchr32_74(s: *const UChar, c: UChar32) -> *mut UChar;
5882}
5883extern "C" {
5884 pub fn u_strrstr_74(s: *const UChar, substring: *const UChar) -> *mut UChar;
5885}
5886extern "C" {
5887 pub fn u_strFindLast_74(
5888 s: *const UChar,
5889 length: i32,
5890 substring: *const UChar,
5891 subLength: i32,
5892 ) -> *mut UChar;
5893}
5894extern "C" {
5895 pub fn u_strrchr_74(s: *const UChar, c: UChar) -> *mut UChar;
5896}
5897extern "C" {
5898 pub fn u_strrchr32_74(s: *const UChar, c: UChar32) -> *mut UChar;
5899}
5900extern "C" {
5901 pub fn u_strpbrk_74(string: *const UChar, matchSet: *const UChar) -> *mut UChar;
5902}
5903extern "C" {
5904 pub fn u_strcspn_74(string: *const UChar, matchSet: *const UChar) -> i32;
5905}
5906extern "C" {
5907 pub fn u_strspn_74(string: *const UChar, matchSet: *const UChar) -> i32;
5908}
5909extern "C" {
5910 pub fn u_strtok_r_74(
5911 src: *mut UChar,
5912 delim: *const UChar,
5913 saveState: *mut *mut UChar,
5914 ) -> *mut UChar;
5915}
5916extern "C" {
5917 pub fn u_strcmp_74(s1: *const UChar, s2: *const UChar) -> i32;
5918}
5919extern "C" {
5920 pub fn u_strcmpCodePointOrder_74(s1: *const UChar, s2: *const UChar) -> i32;
5921}
5922extern "C" {
5923 pub fn u_strCompare_74(
5924 s1: *const UChar,
5925 length1: i32,
5926 s2: *const UChar,
5927 length2: i32,
5928 codePointOrder: UBool,
5929 ) -> i32;
5930}
5931extern "C" {
5932 pub fn u_strCompareIter_74(
5933 iter1: *mut UCharIterator,
5934 iter2: *mut UCharIterator,
5935 codePointOrder: UBool,
5936 ) -> i32;
5937}
5938extern "C" {
5939 pub fn u_strCaseCompare_74(
5940 s1: *const UChar,
5941 length1: i32,
5942 s2: *const UChar,
5943 length2: i32,
5944 options: u32,
5945 pErrorCode: *mut UErrorCode,
5946 ) -> i32;
5947}
5948extern "C" {
5949 pub fn u_strncmp_74(ucs1: *const UChar, ucs2: *const UChar, n: i32) -> i32;
5950}
5951extern "C" {
5952 pub fn u_strncmpCodePointOrder_74(s1: *const UChar, s2: *const UChar, n: i32) -> i32;
5953}
5954extern "C" {
5955 pub fn u_strcasecmp_74(s1: *const UChar, s2: *const UChar, options: u32) -> i32;
5956}
5957extern "C" {
5958 pub fn u_strncasecmp_74(s1: *const UChar, s2: *const UChar, n: i32, options: u32) -> i32;
5959}
5960extern "C" {
5961 pub fn u_memcasecmp_74(s1: *const UChar, s2: *const UChar, length: i32, options: u32) -> i32;
5962}
5963extern "C" {
5964 pub fn u_strcpy_74(dst: *mut UChar, src: *const UChar) -> *mut UChar;
5965}
5966extern "C" {
5967 pub fn u_strncpy_74(dst: *mut UChar, src: *const UChar, n: i32) -> *mut UChar;
5968}
5969extern "C" {
5970 pub fn u_uastrcpy_74(dst: *mut UChar, src: *const ::std::os::raw::c_char) -> *mut UChar;
5971}
5972extern "C" {
5973 pub fn u_uastrncpy_74(
5974 dst: *mut UChar,
5975 src: *const ::std::os::raw::c_char,
5976 n: i32,
5977 ) -> *mut UChar;
5978}
5979extern "C" {
5980 pub fn u_austrcpy_74(
5981 dst: *mut ::std::os::raw::c_char,
5982 src: *const UChar,
5983 ) -> *mut ::std::os::raw::c_char;
5984}
5985extern "C" {
5986 pub fn u_austrncpy_74(
5987 dst: *mut ::std::os::raw::c_char,
5988 src: *const UChar,
5989 n: i32,
5990 ) -> *mut ::std::os::raw::c_char;
5991}
5992extern "C" {
5993 pub fn u_memcpy_74(dest: *mut UChar, src: *const UChar, count: i32) -> *mut UChar;
5994}
5995extern "C" {
5996 pub fn u_memmove_74(dest: *mut UChar, src: *const UChar, count: i32) -> *mut UChar;
5997}
5998extern "C" {
5999 pub fn u_memset_74(dest: *mut UChar, c: UChar, count: i32) -> *mut UChar;
6000}
6001extern "C" {
6002 pub fn u_memcmp_74(buf1: *const UChar, buf2: *const UChar, count: i32) -> i32;
6003}
6004extern "C" {
6005 pub fn u_memcmpCodePointOrder_74(s1: *const UChar, s2: *const UChar, count: i32) -> i32;
6006}
6007extern "C" {
6008 pub fn u_memchr_74(s: *const UChar, c: UChar, count: i32) -> *mut UChar;
6009}
6010extern "C" {
6011 pub fn u_memchr32_74(s: *const UChar, c: UChar32, count: i32) -> *mut UChar;
6012}
6013extern "C" {
6014 pub fn u_memrchr_74(s: *const UChar, c: UChar, count: i32) -> *mut UChar;
6015}
6016extern "C" {
6017 pub fn u_memrchr32_74(s: *const UChar, c: UChar32, count: i32) -> *mut UChar;
6018}
6019extern "C" {
6020 pub fn u_unescape_74(
6021 src: *const ::std::os::raw::c_char,
6022 dest: *mut UChar,
6023 destCapacity: i32,
6024 ) -> i32;
6025}
6026pub type UNESCAPE_CHAR_AT = ::std::option::Option<
6027 unsafe extern "C" fn(offset: i32, context: *mut ::std::os::raw::c_void) -> UChar,
6028>;
6029extern "C" {
6030 pub fn u_unescapeAt_74(
6031 charAt: UNESCAPE_CHAR_AT,
6032 offset: *mut i32,
6033 length: i32,
6034 context: *mut ::std::os::raw::c_void,
6035 ) -> UChar32;
6036}
6037extern "C" {
6038 pub fn u_strToUpper_74(
6039 dest: *mut UChar,
6040 destCapacity: i32,
6041 src: *const UChar,
6042 srcLength: i32,
6043 locale: *const ::std::os::raw::c_char,
6044 pErrorCode: *mut UErrorCode,
6045 ) -> i32;
6046}
6047extern "C" {
6048 pub fn u_strToLower_74(
6049 dest: *mut UChar,
6050 destCapacity: i32,
6051 src: *const UChar,
6052 srcLength: i32,
6053 locale: *const ::std::os::raw::c_char,
6054 pErrorCode: *mut UErrorCode,
6055 ) -> i32;
6056}
6057extern "C" {
6058 pub fn u_strToTitle_74(
6059 dest: *mut UChar,
6060 destCapacity: i32,
6061 src: *const UChar,
6062 srcLength: i32,
6063 titleIter: *mut UBreakIterator,
6064 locale: *const ::std::os::raw::c_char,
6065 pErrorCode: *mut UErrorCode,
6066 ) -> i32;
6067}
6068extern "C" {
6069 pub fn u_strFoldCase_74(
6070 dest: *mut UChar,
6071 destCapacity: i32,
6072 src: *const UChar,
6073 srcLength: i32,
6074 options: u32,
6075 pErrorCode: *mut UErrorCode,
6076 ) -> i32;
6077}
6078extern "C" {
6079 pub fn u_strToWCS_74(
6080 dest: *mut wchar_t,
6081 destCapacity: i32,
6082 pDestLength: *mut i32,
6083 src: *const UChar,
6084 srcLength: i32,
6085 pErrorCode: *mut UErrorCode,
6086 ) -> *mut wchar_t;
6087}
6088extern "C" {
6089 pub fn u_strFromWCS_74(
6090 dest: *mut UChar,
6091 destCapacity: i32,
6092 pDestLength: *mut i32,
6093 src: *const wchar_t,
6094 srcLength: i32,
6095 pErrorCode: *mut UErrorCode,
6096 ) -> *mut UChar;
6097}
6098extern "C" {
6099 pub fn u_strToUTF8_74(
6100 dest: *mut ::std::os::raw::c_char,
6101 destCapacity: i32,
6102 pDestLength: *mut i32,
6103 src: *const UChar,
6104 srcLength: i32,
6105 pErrorCode: *mut UErrorCode,
6106 ) -> *mut ::std::os::raw::c_char;
6107}
6108extern "C" {
6109 pub fn u_strFromUTF8_74(
6110 dest: *mut UChar,
6111 destCapacity: i32,
6112 pDestLength: *mut i32,
6113 src: *const ::std::os::raw::c_char,
6114 srcLength: i32,
6115 pErrorCode: *mut UErrorCode,
6116 ) -> *mut UChar;
6117}
6118extern "C" {
6119 pub fn u_strToUTF8WithSub_74(
6120 dest: *mut ::std::os::raw::c_char,
6121 destCapacity: i32,
6122 pDestLength: *mut i32,
6123 src: *const UChar,
6124 srcLength: i32,
6125 subchar: UChar32,
6126 pNumSubstitutions: *mut i32,
6127 pErrorCode: *mut UErrorCode,
6128 ) -> *mut ::std::os::raw::c_char;
6129}
6130extern "C" {
6131 pub fn u_strFromUTF8WithSub_74(
6132 dest: *mut UChar,
6133 destCapacity: i32,
6134 pDestLength: *mut i32,
6135 src: *const ::std::os::raw::c_char,
6136 srcLength: i32,
6137 subchar: UChar32,
6138 pNumSubstitutions: *mut i32,
6139 pErrorCode: *mut UErrorCode,
6140 ) -> *mut UChar;
6141}
6142extern "C" {
6143 pub fn u_strFromUTF8Lenient_74(
6144 dest: *mut UChar,
6145 destCapacity: i32,
6146 pDestLength: *mut i32,
6147 src: *const ::std::os::raw::c_char,
6148 srcLength: i32,
6149 pErrorCode: *mut UErrorCode,
6150 ) -> *mut UChar;
6151}
6152extern "C" {
6153 pub fn u_strToUTF32_74(
6154 dest: *mut UChar32,
6155 destCapacity: i32,
6156 pDestLength: *mut i32,
6157 src: *const UChar,
6158 srcLength: i32,
6159 pErrorCode: *mut UErrorCode,
6160 ) -> *mut UChar32;
6161}
6162extern "C" {
6163 pub fn u_strFromUTF32_74(
6164 dest: *mut UChar,
6165 destCapacity: i32,
6166 pDestLength: *mut i32,
6167 src: *const UChar32,
6168 srcLength: i32,
6169 pErrorCode: *mut UErrorCode,
6170 ) -> *mut UChar;
6171}
6172extern "C" {
6173 pub fn u_strToUTF32WithSub_74(
6174 dest: *mut UChar32,
6175 destCapacity: i32,
6176 pDestLength: *mut i32,
6177 src: *const UChar,
6178 srcLength: i32,
6179 subchar: UChar32,
6180 pNumSubstitutions: *mut i32,
6181 pErrorCode: *mut UErrorCode,
6182 ) -> *mut UChar32;
6183}
6184extern "C" {
6185 pub fn u_strFromUTF32WithSub_74(
6186 dest: *mut UChar,
6187 destCapacity: i32,
6188 pDestLength: *mut i32,
6189 src: *const UChar32,
6190 srcLength: i32,
6191 subchar: UChar32,
6192 pNumSubstitutions: *mut i32,
6193 pErrorCode: *mut UErrorCode,
6194 ) -> *mut UChar;
6195}
6196extern "C" {
6197 pub fn u_strToJavaModifiedUTF8_74(
6198 dest: *mut ::std::os::raw::c_char,
6199 destCapacity: i32,
6200 pDestLength: *mut i32,
6201 src: *const UChar,
6202 srcLength: i32,
6203 pErrorCode: *mut UErrorCode,
6204 ) -> *mut ::std::os::raw::c_char;
6205}
6206extern "C" {
6207 pub fn u_strFromJavaModifiedUTF8WithSub_74(
6208 dest: *mut UChar,
6209 destCapacity: i32,
6210 pDestLength: *mut i32,
6211 src: *const ::std::os::raw::c_char,
6212 srcLength: i32,
6213 subchar: UChar32,
6214 pNumSubstitutions: *mut i32,
6215 pErrorCode: *mut UErrorCode,
6216 ) -> *mut UChar;
6217}
6218pub type UReplaceable = *mut ::std::os::raw::c_void;
6219#[repr(C)]
6220#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, PartialEq)]
6221pub struct UReplaceableCallbacks {
6222 pub length: ::std::option::Option<unsafe extern "C" fn(rep: *const UReplaceable) -> i32>,
6223 pub charAt:
6224 ::std::option::Option<unsafe extern "C" fn(rep: *const UReplaceable, offset: i32) -> UChar>,
6225 pub char32At: ::std::option::Option<
6226 unsafe extern "C" fn(rep: *const UReplaceable, offset: i32) -> UChar32,
6227 >,
6228 pub replace: ::std::option::Option<
6229 unsafe extern "C" fn(
6230 rep: *mut UReplaceable,
6231 start: i32,
6232 limit: i32,
6233 text: *const UChar,
6234 textLength: i32,
6235 ),
6236 >,
6237 pub extract: ::std::option::Option<
6238 unsafe extern "C" fn(rep: *mut UReplaceable, start: i32, limit: i32, dst: *mut UChar),
6239 >,
6240 pub copy: ::std::option::Option<
6241 unsafe extern "C" fn(rep: *mut UReplaceable, start: i32, limit: i32, dest: i32),
6242 >,
6243}
6244#[test]
6245fn bindgen_test_layout_UReplaceableCallbacks() {
6246 const UNINIT: ::std::mem::MaybeUninit<UReplaceableCallbacks> =
6247 ::std::mem::MaybeUninit::uninit();
6248 let ptr = UNINIT.as_ptr();
6249 assert_eq!(
6250 ::std::mem::size_of::<UReplaceableCallbacks>(),
6251 48usize,
6252 concat!("Size of: ", stringify!(UReplaceableCallbacks))
6253 );
6254 assert_eq!(
6255 ::std::mem::align_of::<UReplaceableCallbacks>(),
6256 8usize,
6257 concat!("Alignment of ", stringify!(UReplaceableCallbacks))
6258 );
6259 assert_eq!(
6260 unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
6261 0usize,
6262 concat!(
6263 "Offset of field: ",
6264 stringify!(UReplaceableCallbacks),
6265 "::",
6266 stringify!(length)
6267 )
6268 );
6269 assert_eq!(
6270 unsafe { ::std::ptr::addr_of!((*ptr).charAt) as usize - ptr as usize },
6271 8usize,
6272 concat!(
6273 "Offset of field: ",
6274 stringify!(UReplaceableCallbacks),
6275 "::",
6276 stringify!(charAt)
6277 )
6278 );
6279 assert_eq!(
6280 unsafe { ::std::ptr::addr_of!((*ptr).char32At) as usize - ptr as usize },
6281 16usize,
6282 concat!(
6283 "Offset of field: ",
6284 stringify!(UReplaceableCallbacks),
6285 "::",
6286 stringify!(char32At)
6287 )
6288 );
6289 assert_eq!(
6290 unsafe { ::std::ptr::addr_of!((*ptr).replace) as usize - ptr as usize },
6291 24usize,
6292 concat!(
6293 "Offset of field: ",
6294 stringify!(UReplaceableCallbacks),
6295 "::",
6296 stringify!(replace)
6297 )
6298 );
6299 assert_eq!(
6300 unsafe { ::std::ptr::addr_of!((*ptr).extract) as usize - ptr as usize },
6301 32usize,
6302 concat!(
6303 "Offset of field: ",
6304 stringify!(UReplaceableCallbacks),
6305 "::",
6306 stringify!(extract)
6307 )
6308 );
6309 assert_eq!(
6310 unsafe { ::std::ptr::addr_of!((*ptr).copy) as usize - ptr as usize },
6311 40usize,
6312 concat!(
6313 "Offset of field: ",
6314 stringify!(UReplaceableCallbacks),
6315 "::",
6316 stringify!(copy)
6317 )
6318 );
6319}
6320pub type UTransliterator = *mut ::std::os::raw::c_void;
6321#[repr(u32)]
6322#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
6323pub enum UTransDirection {
6324 UTRANS_FORWARD = 0,
6325 UTRANS_REVERSE = 1,
6326}
6327#[repr(C)]
6328#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, PartialEq)]
6329pub struct UTransPosition {
6330 pub contextStart: i32,
6331 pub contextLimit: i32,
6332 pub start: i32,
6333 pub limit: i32,
6334}
6335#[test]
6336fn bindgen_test_layout_UTransPosition() {
6337 const UNINIT: ::std::mem::MaybeUninit<UTransPosition> = ::std::mem::MaybeUninit::uninit();
6338 let ptr = UNINIT.as_ptr();
6339 assert_eq!(
6340 ::std::mem::size_of::<UTransPosition>(),
6341 16usize,
6342 concat!("Size of: ", stringify!(UTransPosition))
6343 );
6344 assert_eq!(
6345 ::std::mem::align_of::<UTransPosition>(),
6346 4usize,
6347 concat!("Alignment of ", stringify!(UTransPosition))
6348 );
6349 assert_eq!(
6350 unsafe { ::std::ptr::addr_of!((*ptr).contextStart) as usize - ptr as usize },
6351 0usize,
6352 concat!(
6353 "Offset of field: ",
6354 stringify!(UTransPosition),
6355 "::",
6356 stringify!(contextStart)
6357 )
6358 );
6359 assert_eq!(
6360 unsafe { ::std::ptr::addr_of!((*ptr).contextLimit) as usize - ptr as usize },
6361 4usize,
6362 concat!(
6363 "Offset of field: ",
6364 stringify!(UTransPosition),
6365 "::",
6366 stringify!(contextLimit)
6367 )
6368 );
6369 assert_eq!(
6370 unsafe { ::std::ptr::addr_of!((*ptr).start) as usize - ptr as usize },
6371 8usize,
6372 concat!(
6373 "Offset of field: ",
6374 stringify!(UTransPosition),
6375 "::",
6376 stringify!(start)
6377 )
6378 );
6379 assert_eq!(
6380 unsafe { ::std::ptr::addr_of!((*ptr).limit) as usize - ptr as usize },
6381 12usize,
6382 concat!(
6383 "Offset of field: ",
6384 stringify!(UTransPosition),
6385 "::",
6386 stringify!(limit)
6387 )
6388 );
6389}
6390extern "C" {
6391 pub fn utrans_openU_74(
6392 id: *const UChar,
6393 idLength: i32,
6394 dir: UTransDirection,
6395 rules: *const UChar,
6396 rulesLength: i32,
6397 parseError: *mut UParseError,
6398 pErrorCode: *mut UErrorCode,
6399 ) -> *mut UTransliterator;
6400}
6401extern "C" {
6402 pub fn utrans_openInverse_74(
6403 trans: *const UTransliterator,
6404 status: *mut UErrorCode,
6405 ) -> *mut UTransliterator;
6406}
6407extern "C" {
6408 pub fn utrans_clone_74(
6409 trans: *const UTransliterator,
6410 status: *mut UErrorCode,
6411 ) -> *mut UTransliterator;
6412}
6413extern "C" {
6414 pub fn utrans_close_74(trans: *mut UTransliterator);
6415}
6416extern "C" {
6417 pub fn utrans_getUnicodeID_74(
6418 trans: *const UTransliterator,
6419 resultLength: *mut i32,
6420 ) -> *const UChar;
6421}
6422extern "C" {
6423 pub fn utrans_register_74(adoptedTrans: *mut UTransliterator, status: *mut UErrorCode);
6424}
6425extern "C" {
6426 pub fn utrans_unregisterID_74(id: *const UChar, idLength: i32);
6427}
6428extern "C" {
6429 pub fn utrans_setFilter_74(
6430 trans: *mut UTransliterator,
6431 filterPattern: *const UChar,
6432 filterPatternLen: i32,
6433 status: *mut UErrorCode,
6434 );
6435}
6436extern "C" {
6437 pub fn utrans_countAvailableIDs_74() -> i32;
6438}
6439extern "C" {
6440 pub fn utrans_openIDs_74(pErrorCode: *mut UErrorCode) -> *mut UEnumeration;
6441}
6442extern "C" {
6443 pub fn utrans_trans_74(
6444 trans: *const UTransliterator,
6445 rep: *mut UReplaceable,
6446 repFunc: *const UReplaceableCallbacks,
6447 start: i32,
6448 limit: *mut i32,
6449 status: *mut UErrorCode,
6450 );
6451}
6452extern "C" {
6453 pub fn utrans_transIncremental_74(
6454 trans: *const UTransliterator,
6455 rep: *mut UReplaceable,
6456 repFunc: *const UReplaceableCallbacks,
6457 pos: *mut UTransPosition,
6458 status: *mut UErrorCode,
6459 );
6460}
6461extern "C" {
6462 pub fn utrans_transUChars_74(
6463 trans: *const UTransliterator,
6464 text: *mut UChar,
6465 textLength: *mut i32,
6466 textCapacity: i32,
6467 start: i32,
6468 limit: *mut i32,
6469 status: *mut UErrorCode,
6470 );
6471}
6472extern "C" {
6473 pub fn utrans_transIncrementalUChars_74(
6474 trans: *const UTransliterator,
6475 text: *mut UChar,
6476 textLength: *mut i32,
6477 textCapacity: i32,
6478 pos: *mut UTransPosition,
6479 status: *mut UErrorCode,
6480 );
6481}
6482extern "C" {
6483 pub fn utrans_toRules_74(
6484 trans: *const UTransliterator,
6485 escapeUnprintable: UBool,
6486 result: *mut UChar,
6487 resultLength: i32,
6488 status: *mut UErrorCode,
6489 ) -> i32;
6490}
6491extern "C" {
6492 pub fn utrans_getSourceSet_74(
6493 trans: *const UTransliterator,
6494 ignoreFilter: UBool,
6495 fillIn: *mut USet,
6496 status: *mut UErrorCode,
6497 ) -> *mut USet;
6498}
6499extern "C" {
6500 pub fn utrans_open_74(
6501 id: *const ::std::os::raw::c_char,
6502 dir: UTransDirection,
6503 rules: *const UChar,
6504 rulesLength: i32,
6505 parseError: *mut UParseError,
6506 status: *mut UErrorCode,
6507 ) -> *mut UTransliterator;
6508}
6509extern "C" {
6510 pub fn utrans_getID_74(
6511 trans: *const UTransliterator,
6512 buf: *mut ::std::os::raw::c_char,
6513 bufCapacity: i32,
6514 ) -> i32;
6515}
6516extern "C" {
6517 pub fn utrans_unregister_74(id: *const ::std::os::raw::c_char);
6518}
6519extern "C" {
6520 pub fn utrans_getAvailableID_74(
6521 index: i32,
6522 buf: *mut ::std::os::raw::c_char,
6523 bufCapacity: i32,
6524 ) -> i32;
6525}
6526#[repr(C)]
6527#[derive(Copy, Clone)]
6528pub union UCPTrieData {
6529 pub ptr0: *const ::std::os::raw::c_void,
6530 pub ptr16: *const u16,
6531 pub ptr32: *const u32,
6532 pub ptr8: *const u8,
6533}
6534#[test]
6535fn bindgen_test_layout_UCPTrieData() {
6536 const UNINIT: ::std::mem::MaybeUninit<UCPTrieData> = ::std::mem::MaybeUninit::uninit();
6537 let ptr = UNINIT.as_ptr();
6538 assert_eq!(
6539 ::std::mem::size_of::<UCPTrieData>(),
6540 8usize,
6541 concat!("Size of: ", stringify!(UCPTrieData))
6542 );
6543 assert_eq!(
6544 ::std::mem::align_of::<UCPTrieData>(),
6545 8usize,
6546 concat!("Alignment of ", stringify!(UCPTrieData))
6547 );
6548 assert_eq!(
6549 unsafe { ::std::ptr::addr_of!((*ptr).ptr0) as usize - ptr as usize },
6550 0usize,
6551 concat!(
6552 "Offset of field: ",
6553 stringify!(UCPTrieData),
6554 "::",
6555 stringify!(ptr0)
6556 )
6557 );
6558 assert_eq!(
6559 unsafe { ::std::ptr::addr_of!((*ptr).ptr16) as usize - ptr as usize },
6560 0usize,
6561 concat!(
6562 "Offset of field: ",
6563 stringify!(UCPTrieData),
6564 "::",
6565 stringify!(ptr16)
6566 )
6567 );
6568 assert_eq!(
6569 unsafe { ::std::ptr::addr_of!((*ptr).ptr32) as usize - ptr as usize },
6570 0usize,
6571 concat!(
6572 "Offset of field: ",
6573 stringify!(UCPTrieData),
6574 "::",
6575 stringify!(ptr32)
6576 )
6577 );
6578 assert_eq!(
6579 unsafe { ::std::ptr::addr_of!((*ptr).ptr8) as usize - ptr as usize },
6580 0usize,
6581 concat!(
6582 "Offset of field: ",
6583 stringify!(UCPTrieData),
6584 "::",
6585 stringify!(ptr8)
6586 )
6587 );
6588}
6589impl Default for UCPTrieData {
6590 fn default() -> Self {
6591 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6592 unsafe {
6593 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6594 s.assume_init()
6595 }
6596 }
6597}
6598#[repr(C)]
6599#[derive(Copy, Clone)]
6600pub struct UCPTrie {
6601 pub index: *const u16,
6602 pub data: UCPTrieData,
6603 pub indexLength: i32,
6604 pub dataLength: i32,
6605 pub highStart: UChar32,
6606 pub shifted12HighStart: u16,
6607 pub type_: i8,
6608 pub valueWidth: i8,
6609 pub reserved32: u32,
6610 pub reserved16: u16,
6611 pub index3NullOffset: u16,
6612 pub dataNullOffset: i32,
6613 pub nullValue: u32,
6614}
6615#[test]
6616fn bindgen_test_layout_UCPTrie() {
6617 const UNINIT: ::std::mem::MaybeUninit<UCPTrie> = ::std::mem::MaybeUninit::uninit();
6618 let ptr = UNINIT.as_ptr();
6619 assert_eq!(
6620 ::std::mem::size_of::<UCPTrie>(),
6621 48usize,
6622 concat!("Size of: ", stringify!(UCPTrie))
6623 );
6624 assert_eq!(
6625 ::std::mem::align_of::<UCPTrie>(),
6626 8usize,
6627 concat!("Alignment of ", stringify!(UCPTrie))
6628 );
6629 assert_eq!(
6630 unsafe { ::std::ptr::addr_of!((*ptr).index) as usize - ptr as usize },
6631 0usize,
6632 concat!(
6633 "Offset of field: ",
6634 stringify!(UCPTrie),
6635 "::",
6636 stringify!(index)
6637 )
6638 );
6639 assert_eq!(
6640 unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
6641 8usize,
6642 concat!(
6643 "Offset of field: ",
6644 stringify!(UCPTrie),
6645 "::",
6646 stringify!(data)
6647 )
6648 );
6649 assert_eq!(
6650 unsafe { ::std::ptr::addr_of!((*ptr).indexLength) as usize - ptr as usize },
6651 16usize,
6652 concat!(
6653 "Offset of field: ",
6654 stringify!(UCPTrie),
6655 "::",
6656 stringify!(indexLength)
6657 )
6658 );
6659 assert_eq!(
6660 unsafe { ::std::ptr::addr_of!((*ptr).dataLength) as usize - ptr as usize },
6661 20usize,
6662 concat!(
6663 "Offset of field: ",
6664 stringify!(UCPTrie),
6665 "::",
6666 stringify!(dataLength)
6667 )
6668 );
6669 assert_eq!(
6670 unsafe { ::std::ptr::addr_of!((*ptr).highStart) as usize - ptr as usize },
6671 24usize,
6672 concat!(
6673 "Offset of field: ",
6674 stringify!(UCPTrie),
6675 "::",
6676 stringify!(highStart)
6677 )
6678 );
6679 assert_eq!(
6680 unsafe { ::std::ptr::addr_of!((*ptr).shifted12HighStart) as usize - ptr as usize },
6681 28usize,
6682 concat!(
6683 "Offset of field: ",
6684 stringify!(UCPTrie),
6685 "::",
6686 stringify!(shifted12HighStart)
6687 )
6688 );
6689 assert_eq!(
6690 unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
6691 30usize,
6692 concat!(
6693 "Offset of field: ",
6694 stringify!(UCPTrie),
6695 "::",
6696 stringify!(type_)
6697 )
6698 );
6699 assert_eq!(
6700 unsafe { ::std::ptr::addr_of!((*ptr).valueWidth) as usize - ptr as usize },
6701 31usize,
6702 concat!(
6703 "Offset of field: ",
6704 stringify!(UCPTrie),
6705 "::",
6706 stringify!(valueWidth)
6707 )
6708 );
6709 assert_eq!(
6710 unsafe { ::std::ptr::addr_of!((*ptr).reserved32) as usize - ptr as usize },
6711 32usize,
6712 concat!(
6713 "Offset of field: ",
6714 stringify!(UCPTrie),
6715 "::",
6716 stringify!(reserved32)
6717 )
6718 );
6719 assert_eq!(
6720 unsafe { ::std::ptr::addr_of!((*ptr).reserved16) as usize - ptr as usize },
6721 36usize,
6722 concat!(
6723 "Offset of field: ",
6724 stringify!(UCPTrie),
6725 "::",
6726 stringify!(reserved16)
6727 )
6728 );
6729 assert_eq!(
6730 unsafe { ::std::ptr::addr_of!((*ptr).index3NullOffset) as usize - ptr as usize },
6731 38usize,
6732 concat!(
6733 "Offset of field: ",
6734 stringify!(UCPTrie),
6735 "::",
6736 stringify!(index3NullOffset)
6737 )
6738 );
6739 assert_eq!(
6740 unsafe { ::std::ptr::addr_of!((*ptr).dataNullOffset) as usize - ptr as usize },
6741 40usize,
6742 concat!(
6743 "Offset of field: ",
6744 stringify!(UCPTrie),
6745 "::",
6746 stringify!(dataNullOffset)
6747 )
6748 );
6749 assert_eq!(
6750 unsafe { ::std::ptr::addr_of!((*ptr).nullValue) as usize - ptr as usize },
6751 44usize,
6752 concat!(
6753 "Offset of field: ",
6754 stringify!(UCPTrie),
6755 "::",
6756 stringify!(nullValue)
6757 )
6758 );
6759}
6760impl Default for UCPTrie {
6761 fn default() -> Self {
6762 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6763 unsafe {
6764 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6765 s.assume_init()
6766 }
6767 }
6768}
6769#[repr(i32)]
6770#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
6771pub enum UCPTrieType {
6772 UCPTRIE_TYPE_ANY = -1,
6773 UCPTRIE_TYPE_FAST = 0,
6774 UCPTRIE_TYPE_SMALL = 1,
6775}
6776#[repr(i32)]
6777#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq)]
6778pub enum UCPTrieValueWidth {
6779 UCPTRIE_VALUE_BITS_ANY = -1,
6780 UCPTRIE_VALUE_BITS_16 = 0,
6781 UCPTRIE_VALUE_BITS_32 = 1,
6782 UCPTRIE_VALUE_BITS_8 = 2,
6783}
6784extern "C" {
6785 pub fn ucptrie_openFromBinary_74(
6786 type_: UCPTrieType,
6787 valueWidth: UCPTrieValueWidth,
6788 data: *const ::std::os::raw::c_void,
6789 length: i32,
6790 pActualLength: *mut i32,
6791 pErrorCode: *mut UErrorCode,
6792 ) -> *mut UCPTrie;
6793}
6794extern "C" {
6795 pub fn ucptrie_close_74(trie: *mut UCPTrie);
6796}
6797extern "C" {
6798 pub fn ucptrie_getType_74(trie: *const UCPTrie) -> UCPTrieType;
6799}
6800extern "C" {
6801 pub fn ucptrie_getValueWidth_74(trie: *const UCPTrie) -> UCPTrieValueWidth;
6802}
6803extern "C" {
6804 pub fn ucptrie_get_74(trie: *const UCPTrie, c: UChar32) -> u32;
6805}
6806extern "C" {
6807 pub fn ucptrie_getRange_74(
6808 trie: *const UCPTrie,
6809 start: UChar32,
6810 option: UCPMapRangeOption,
6811 surrogateValue: u32,
6812 filter: UCPMapValueFilter,
6813 context: *const ::std::os::raw::c_void,
6814 pValue: *mut u32,
6815 ) -> UChar32;
6816}
6817extern "C" {
6818 pub fn ucptrie_toBinary_74(
6819 trie: *const UCPTrie,
6820 data: *mut ::std::os::raw::c_void,
6821 capacity: i32,
6822 pErrorCode: *mut UErrorCode,
6823 ) -> i32;
6824}
6825extern "C" {
6826 pub fn ucptrie_internalSmallIndex_74(trie: *const UCPTrie, c: UChar32) -> i32;
6827}
6828extern "C" {
6829 pub fn ucptrie_internalSmallU8Index_74(trie: *const UCPTrie, lt1: i32, t2: u8, t3: u8) -> i32;
6830}
6831extern "C" {
6832 pub fn ucptrie_internalU8PrevIndex_74(
6833 trie: *const UCPTrie,
6834 c: UChar32,
6835 start: *const u8,
6836 src: *const u8,
6837 ) -> i32;
6838}
6839#[repr(C)]
6840#[derive(Debug, Copy, Clone)]
6841pub struct UMutableCPTrie {
6842 _unused: [u8; 0],
6843}
6844extern "C" {
6845 pub fn umutablecptrie_open_74(
6846 initialValue: u32,
6847 errorValue: u32,
6848 pErrorCode: *mut UErrorCode,
6849 ) -> *mut UMutableCPTrie;
6850}
6851extern "C" {
6852 pub fn umutablecptrie_clone_74(
6853 other: *const UMutableCPTrie,
6854 pErrorCode: *mut UErrorCode,
6855 ) -> *mut UMutableCPTrie;
6856}
6857extern "C" {
6858 pub fn umutablecptrie_close_74(trie: *mut UMutableCPTrie);
6859}
6860extern "C" {
6861 pub fn umutablecptrie_fromUCPMap_74(
6862 map: *const UCPMap,
6863 pErrorCode: *mut UErrorCode,
6864 ) -> *mut UMutableCPTrie;
6865}
6866extern "C" {
6867 pub fn umutablecptrie_fromUCPTrie_74(
6868 trie: *const UCPTrie,
6869 pErrorCode: *mut UErrorCode,
6870 ) -> *mut UMutableCPTrie;
6871}
6872extern "C" {
6873 pub fn umutablecptrie_get_74(trie: *const UMutableCPTrie, c: UChar32) -> u32;
6874}
6875extern "C" {
6876 pub fn umutablecptrie_getRange_74(
6877 trie: *const UMutableCPTrie,
6878 start: UChar32,
6879 option: UCPMapRangeOption,
6880 surrogateValue: u32,
6881 filter: UCPMapValueFilter,
6882 context: *const ::std::os::raw::c_void,
6883 pValue: *mut u32,
6884 ) -> UChar32;
6885}
6886extern "C" {
6887 pub fn umutablecptrie_set_74(
6888 trie: *mut UMutableCPTrie,
6889 c: UChar32,
6890 value: u32,
6891 pErrorCode: *mut UErrorCode,
6892 );
6893}
6894extern "C" {
6895 pub fn umutablecptrie_setRange_74(
6896 trie: *mut UMutableCPTrie,
6897 start: UChar32,
6898 end: UChar32,
6899 value: u32,
6900 pErrorCode: *mut UErrorCode,
6901 );
6902}
6903extern "C" {
6904 pub fn umutablecptrie_buildImmutable_74(
6905 trie: *mut UMutableCPTrie,
6906 type_: UCPTrieType,
6907 valueWidth: UCPTrieValueWidth,
6908 pErrorCode: *mut UErrorCode,
6909 ) -> *mut UCPTrie;
6910}
6911pub type __builtin_va_list = [__va_list_tag; 1usize];
6912#[repr(C)]
6913#[derive(Debug, Copy, Clone, Hash, PartialOrd, PartialEq)]
6914pub struct __va_list_tag {
6915 pub gp_offset: ::std::os::raw::c_uint,
6916 pub fp_offset: ::std::os::raw::c_uint,
6917 pub overflow_arg_area: *mut ::std::os::raw::c_void,
6918 pub reg_save_area: *mut ::std::os::raw::c_void,
6919}
6920#[test]
6921fn bindgen_test_layout___va_list_tag() {
6922 const UNINIT: ::std::mem::MaybeUninit<__va_list_tag> = ::std::mem::MaybeUninit::uninit();
6923 let ptr = UNINIT.as_ptr();
6924 assert_eq!(
6925 ::std::mem::size_of::<__va_list_tag>(),
6926 24usize,
6927 concat!("Size of: ", stringify!(__va_list_tag))
6928 );
6929 assert_eq!(
6930 ::std::mem::align_of::<__va_list_tag>(),
6931 8usize,
6932 concat!("Alignment of ", stringify!(__va_list_tag))
6933 );
6934 assert_eq!(
6935 unsafe { ::std::ptr::addr_of!((*ptr).gp_offset) as usize - ptr as usize },
6936 0usize,
6937 concat!(
6938 "Offset of field: ",
6939 stringify!(__va_list_tag),
6940 "::",
6941 stringify!(gp_offset)
6942 )
6943 );
6944 assert_eq!(
6945 unsafe { ::std::ptr::addr_of!((*ptr).fp_offset) as usize - ptr as usize },
6946 4usize,
6947 concat!(
6948 "Offset of field: ",
6949 stringify!(__va_list_tag),
6950 "::",
6951 stringify!(fp_offset)
6952 )
6953 );
6954 assert_eq!(
6955 unsafe { ::std::ptr::addr_of!((*ptr).overflow_arg_area) as usize - ptr as usize },
6956 8usize,
6957 concat!(
6958 "Offset of field: ",
6959 stringify!(__va_list_tag),
6960 "::",
6961 stringify!(overflow_arg_area)
6962 )
6963 );
6964 assert_eq!(
6965 unsafe { ::std::ptr::addr_of!((*ptr).reg_save_area) as usize - ptr as usize },
6966 16usize,
6967 concat!(
6968 "Offset of field: ",
6969 stringify!(__va_list_tag),
6970 "::",
6971 stringify!(reg_save_area)
6972 )
6973 );
6974}
6975impl Default for __va_list_tag {
6976 fn default() -> Self {
6977 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6978 unsafe {
6979 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6980 s.assume_init()
6981 }
6982 }
6983}