w32tex
About: TeX Live provides a comprehensive TeX system including all the major TeX-related programs, macro packages, and fonts that are free software. Windows sources.
  Fossies Dox: w32tex-src.tar.xz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

unisetspan.cpp
Go to the documentation of this file.
1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /*
4 ******************************************************************************
5 *
6 * Copyright (C) 2007-2012, International Business Machines
7 * Corporation and others. All Rights Reserved.
8 *
9 ******************************************************************************
10 * file name: unisetspan.cpp
11 * encoding: UTF-8
12 * tab size: 8 (not used)
13 * indentation:4
14 *
15 * created on: 2007mar01
16 * created by: Markus W. Scherer
17 */
18 
19 #include "unicode/utypes.h"
20 #include "unicode/uniset.h"
21 #include "unicode/ustring.h"
22 #include "unicode/utf8.h"
23 #include "unicode/utf16.h"
24 #include "cmemory.h"
25 #include "uvector.h"
26 #include "unisetspan.h"
27 
29 
30 /*
31  * List of offsets from the current position from where to try matching
32  * a code point or a string.
33  * Store offsets rather than indexes to simplify the code and use the same list
34  * for both increments (in span()) and decrements (in spanBack()).
35  *
36  * Assumption: The maximum offset is limited, and the offsets that are stored
37  * at any one time are relatively dense, that is, there are normally no gaps of
38  * hundreds or thousands of offset values.
39  *
40  * The implementation uses a circular buffer of byte flags,
41  * each indicating whether the corresponding offset is in the list.
42  * This avoids inserting into a sorted list of offsets (or absolute indexes) and
43  * physically moving part of the list.
44  *
45  * Note: In principle, the caller should setMaxLength() to the maximum of the
46  * max string length and U16_LENGTH/U8_LENGTH to account for
47  * "long" single code points.
48  * However, this implementation uses at least a staticList with more than
49  * U8_LENGTH entries anyway.
50  *
51  * Note: If maxLength were guaranteed to be no more than 32 or 64,
52  * the list could be stored as bit flags in a single integer.
53  * Rather than handling a circular buffer with a start list index,
54  * the integer would simply be shifted when lower offsets are removed.
55  * UnicodeSet does not have a limit on the lengths of strings.
56  */
57 class OffsetList { // Only ever stack-allocated, does not need to inherit UMemory.
58 public:
60 
62  if(list!=staticList) {
63  uprv_free(list);
64  }
65  }
66 
67  // Call exactly once if the list is to be used.
69  if(maxLength<=(int32_t)sizeof(staticList)) {
70  capacity=(int32_t)sizeof(staticList);
71  } else {
73  if(l!=NULL) {
74  list=l;
76  }
77  }
79  }
80 
81  void clear() {
83  start=length=0;
84  }
85 
86  UBool isEmpty() const {
87  return (UBool)(length==0);
88  }
89 
90  // Reduce all stored offsets by delta, used when the current position
91  // moves by delta.
92  // There must not be any offsets lower than delta.
93  // If there is an offset equal to delta, it is removed.
94  // delta=[1..maxLength]
97  if(i>=capacity) {
98  i-=capacity;
99  }
100  if(list[i]) {
101  list[i]=FALSE;
102  --length;
103  }
104  start=i;
105  }
106 
107  // Add an offset. The list must not contain it yet.
108  // offset=[1..maxLength]
111  if(i>=capacity) {
112  i-=capacity;
113  }
114  list[i]=TRUE;
115  ++length;
116  }
117 
118  // offset=[1..maxLength]
121  if(i>=capacity) {
122  i-=capacity;
123  }
124  return list[i];
125  }
126 
127  // Find the lowest stored offset from a non-empty list, remove it,
128  // and reduce all other offsets by this minimum.
129  // Returns [1..maxLength].
131  // Look for the next offset in list[start+1..capacity-1].
133  while(++i<capacity) {
134  if(list[i]) {
135  list[i]=FALSE;
136  --length;
137  result=i-start;
138  start=i;
139  return result;
140  }
141  }
142  // i==capacity
143 
144  // Wrap around and look for the next offset in list[0..start].
145  // Since the list is not empty, there will be one.
147  i=0;
148  while(!list[i]) {
149  ++i;
150  }
151  list[i]=FALSE;
152  --length;
153  start=i;
154  return result+=i;
155  }
156 
157 private:
162 
164 };
165 
166 // Get the number of UTF-8 bytes for a UTF-16 (sub)string.
167 static int32_t
170  int32_t length8=0;
171  u_strToUTF8(NULL, 0, &length8, s, length, &errorCode);
173  return length8;
174  } else {
175  // The string contains an unpaired surrogate.
176  // Ignore this string.
177  return 0;
178  }
179 }
180 
181 // Append the UTF-8 version of the string to t and return the appended UTF-8 length.
182 static int32_t
185  int32_t length8=0;
186  u_strToUTF8((char *)t, capacity, &length8, s, length, &errorCode);
187  if(U_SUCCESS(errorCode)) {
188  return length8;
189  } else {
190  // The string contains an unpaired surrogate.
191  // Ignore this string.
192  return 0;
193  }
194 }
195 
196 static inline uint8_t
198  // 0xfe==UnicodeSetStringSpan::LONG_SPAN
199  return spanLength<0xfe ? (uint8_t)spanLength : (uint8_t)0xfe;
200 }
201 
202 // Construct for all variants of span(), or only for any one variant.
203 // Initialize as little as possible, for single use.
205  const UVector &setStrings,
206  uint32_t which)
207  : spanSet(0, 0x10ffff), pSpanNotSet(NULL), strings(setStrings),
208  utf8Lengths(NULL), spanLengths(NULL), utf8(NULL),
209  utf8Length(0),
210  maxLength16(0), maxLength8(0),
211  all((UBool)(which==ALL)) {
212  spanSet.retainAll(set);
213  if(which&NOT_CONTAINED) {
214  // Default to the same sets.
215  // addToSpanNotSet() will create a separate set if necessary.
217  }
218 
219  // Determine if the strings even need to be taken into account at all for span() etc.
220  // If any string is relevant, then all strings need to be used for
221  // span(longest match) but only the relevant ones for span(while contained).
222  // TODO: Possible optimization: Distinguish CONTAINED vs. LONGEST_MATCH
223  // and do not store UTF-8 strings if !thisRelevant and CONTAINED.
224  // (Only store irrelevant UTF-8 strings for LONGEST_MATCH where they are relevant after all.)
225  // Also count the lengths of the UTF-8 versions of the strings for memory allocation.
226  int32_t stringsLength=strings.size();
227 
228  int32_t i, spanLength;
229  UBool someRelevant=FALSE;
230  for(i=0; i<stringsLength; ++i) {
231  const UnicodeString &string=*(const UnicodeString *)strings.elementAt(i);
232  const UChar *s16=string.getBuffer();
233  int32_t length16=string.length();
234  UBool thisRelevant;
235  spanLength=spanSet.span(s16, length16, USET_SPAN_CONTAINED);
236  if(spanLength<length16) { // Relevant string.
237  someRelevant=thisRelevant=TRUE;
238  } else {
239  thisRelevant=FALSE;
240  }
241  if((which&UTF16) && length16>maxLength16) {
242  maxLength16=length16;
243  }
244  if((which&UTF8) && (thisRelevant || (which&CONTAINED))) {
245  int32_t length8=getUTF8Length(s16, length16);
246  utf8Length+=length8;
247  if(length8>maxLength8) {
248  maxLength8=length8;
249  }
250  }
251  }
252  if(!someRelevant) {
254  return;
255  }
256 
257  // Freeze after checking for the need to use strings at all because freezing
258  // a set takes some time and memory which are wasted if there are no relevant strings.
259  if(all) {
260  spanSet.freeze();
261  }
262 
263  uint8_t *spanBackLengths;
264  uint8_t *spanUTF8Lengths;
265  uint8_t *spanBackUTF8Lengths;
266 
267  // Allocate a block of meta data.
268  int32_t allocSize;
269  if(all) {
270  // UTF-8 lengths, 4 sets of span lengths, UTF-8 strings.
271  allocSize=stringsLength*(4+1+1+1+1)+utf8Length;
272  } else {
273  allocSize=stringsLength; // One set of span lengths.
274  if(which&UTF8) {
275  // UTF-8 lengths and UTF-8 strings.
276  allocSize+=stringsLength*4+utf8Length;
277  }
278  }
279  if(allocSize<=(int32_t)sizeof(staticLengths)) {
281  } else {
282  utf8Lengths=(int32_t *)uprv_malloc(allocSize);
283  if(utf8Lengths==NULL) {
284  maxLength16=maxLength8=0; // Prevent usage by making needsStringSpanUTF16/8() return FALSE.
285  return; // Out of memory.
286  }
287  }
288 
289  if(all) {
290  // Store span lengths for all span() variants.
291  spanLengths=(uint8_t *)(utf8Lengths+stringsLength);
292  spanBackLengths=spanLengths+stringsLength;
293  spanUTF8Lengths=spanBackLengths+stringsLength;
294  spanBackUTF8Lengths=spanUTF8Lengths+stringsLength;
295  utf8=spanBackUTF8Lengths+stringsLength;
296  } else {
297  // Store span lengths for only one span() variant.
298  if(which&UTF8) {
299  spanLengths=(uint8_t *)(utf8Lengths+stringsLength);
300  utf8=spanLengths+stringsLength;
301  } else {
303  }
304  spanBackLengths=spanUTF8Lengths=spanBackUTF8Lengths=spanLengths;
305  }
306 
307  // Set the meta data and pSpanNotSet and write the UTF-8 strings.
308  int32_t utf8Count=0; // Count UTF-8 bytes written so far.
309 
310  for(i=0; i<stringsLength; ++i) {
311  const UnicodeString &string=*(const UnicodeString *)strings.elementAt(i);
312  const UChar *s16=string.getBuffer();
313  int32_t length16=string.length();
314  spanLength=spanSet.span(s16, length16, USET_SPAN_CONTAINED);
315  if(spanLength<length16) { // Relevant string.
316  if(which&UTF16) {
317  if(which&CONTAINED) {
318  if(which&FWD) {
319  spanLengths[i]=makeSpanLengthByte(spanLength);
320  }
321  if(which&BACK) {
322  spanLength=length16-spanSet.spanBack(s16, length16, USET_SPAN_CONTAINED);
323  spanBackLengths[i]=makeSpanLengthByte(spanLength);
324  }
325  } else /* not CONTAINED, not all, but NOT_CONTAINED */ {
326  spanLengths[i]=spanBackLengths[i]=0; // Only store a relevant/irrelevant flag.
327  }
328  }
329  if(which&UTF8) {
330  uint8_t *s8=utf8+utf8Count;
331  int32_t length8=appendUTF8(s16, length16, s8, utf8Length-utf8Count);
332  utf8Count+=utf8Lengths[i]=length8;
333  if(length8==0) { // Irrelevant for UTF-8 because not representable in UTF-8.
334  spanUTF8Lengths[i]=spanBackUTF8Lengths[i]=(uint8_t)ALL_CP_CONTAINED;
335  } else { // Relevant for UTF-8.
336  if(which&CONTAINED) {
337  if(which&FWD) {
338  spanLength=spanSet.spanUTF8((const char *)s8, length8, USET_SPAN_CONTAINED);
339  spanUTF8Lengths[i]=makeSpanLengthByte(spanLength);
340  }
341  if(which&BACK) {
342  spanLength=length8-spanSet.spanBackUTF8((const char *)s8, length8, USET_SPAN_CONTAINED);
343  spanBackUTF8Lengths[i]=makeSpanLengthByte(spanLength);
344  }
345  } else /* not CONTAINED, not all, but NOT_CONTAINED */ {
346  spanUTF8Lengths[i]=spanBackUTF8Lengths[i]=0; // Only store a relevant/irrelevant flag.
347  }
348  }
349  }
350  if(which&NOT_CONTAINED) {
351  // Add string start and end code points to the spanNotSet so that
352  // a span(while not contained) stops before any string.
353  UChar32 c;
354  if(which&FWD) {
355  int32_t len=0;
356  U16_NEXT(s16, len, length16, c);
358  }
359  if(which&BACK) {
360  int32_t len=length16;
361  U16_PREV(s16, 0, len, c);
363  }
364  }
365  } else { // Irrelevant string.
366  if(which&UTF8) {
367  if(which&CONTAINED) { // Only necessary for LONGEST_MATCH.
368  uint8_t *s8=utf8+utf8Count;
369  int32_t length8=appendUTF8(s16, length16, s8, utf8Length-utf8Count);
370  utf8Count+=utf8Lengths[i]=length8;
371  } else {
372  utf8Lengths[i]=0;
373  }
374  }
375  if(all) {
376  spanLengths[i]=spanBackLengths[i]=
377  spanUTF8Lengths[i]=spanBackUTF8Lengths[i]=
379  } else {
380  // All spanXYZLengths pointers contain the same address.
382  }
383  }
384  }
385 
386  // Finish.
387  if(all) {
388  pSpanNotSet->freeze();
389  }
390 }
391 
392 // Copy constructor. Assumes which==ALL for a frozen set.
394  const UVector &newParentSetStrings)
395  : spanSet(otherStringSpan.spanSet), pSpanNotSet(NULL), strings(newParentSetStrings),
396  utf8Lengths(NULL), spanLengths(NULL), utf8(NULL),
397  utf8Length(otherStringSpan.utf8Length),
398  maxLength16(otherStringSpan.maxLength16), maxLength8(otherStringSpan.maxLength8),
399  all(TRUE) {
400  if(otherStringSpan.pSpanNotSet==&otherStringSpan.spanSet) {
402  } else {
403  pSpanNotSet=otherStringSpan.pSpanNotSet->clone();
404  }
405 
406  // Allocate a block of meta data.
407  // UTF-8 lengths, 4 sets of span lengths, UTF-8 strings.
408  int32_t stringsLength=strings.size();
409  int32_t allocSize=stringsLength*(4+1+1+1+1)+utf8Length;
410  if(allocSize<=(int32_t)sizeof(staticLengths)) {
412  } else {
413  utf8Lengths=(int32_t *)uprv_malloc(allocSize);
414  if(utf8Lengths==NULL) {
415  maxLength16=maxLength8=0; // Prevent usage by making needsStringSpanUTF16/8() return FALSE.
416  return; // Out of memory.
417  }
418  }
419 
420  spanLengths=(uint8_t *)(utf8Lengths+stringsLength);
421  utf8=spanLengths+stringsLength*4;
422  uprv_memcpy(utf8Lengths, otherStringSpan.utf8Lengths, allocSize);
423 }
424 
426  if(pSpanNotSet!=NULL && pSpanNotSet!=&spanSet) {
427  delete pSpanNotSet;
428  }
431  }
432 }
433 
435  if(pSpanNotSet==NULL || pSpanNotSet==&spanSet) {
436  if(spanSet.contains(c)) {
437  return; // Nothing to do.
438  }
439  UnicodeSet *newSet=spanSet.cloneAsThawed();
440  if(newSet==NULL) {
441  return; // Out of memory.
442  } else {
443  pSpanNotSet=newSet;
444  }
445  }
446  pSpanNotSet->add(c);
447 }
448 
449 // Compare strings without any argument checks. Requires length>0.
450 static inline UBool
451 matches16(const UChar *s, const UChar *t, int32_t length) {
452  do {
453  if(*s++!=*t++) {
454  return FALSE;
455  }
456  } while(--length>0);
457  return TRUE;
458 }
459 
460 static inline UBool
462  do {
463  if(*s++!=*t++) {
464  return FALSE;
465  }
466  } while(--length>0);
467  return TRUE;
468 }
469 
470 // Compare 16-bit Unicode strings (which may be malformed UTF-16)
471 // at code point boundaries.
472 // That is, each edge of a match must not be in the middle of a surrogate pair.
473 static inline UBool
475  s+=start;
476  limit-=start;
477  return matches16(s, t, length) &&
478  !(0<start && U16_IS_LEAD(s[-1]) && U16_IS_TRAIL(s[0])) &&
480 }
481 
482 // Does the set contain the next code point?
483 // If so, return its length; otherwise return its negative length.
484 static inline int32_t
485 spanOne(const UnicodeSet &set, const UChar *s, int32_t length) {
486  UChar c=*s, c2;
487  if(c>=0xd800 && c<=0xdbff && length>=2 && U16_IS_TRAIL(c2=s[1])) {
488  return set.contains(U16_GET_SUPPLEMENTARY(c, c2)) ? 2 : -2;
489  }
490  return set.contains(c) ? 1 : -1;
491 }
492 
493 static inline int32_t
494 spanOneBack(const UnicodeSet &set, const UChar *s, int32_t length) {
495  UChar c=s[length-1], c2;
496  if(c>=0xdc00 && c<=0xdfff && length>=2 && U16_IS_LEAD(c2=s[length-2])) {
497  return set.contains(U16_GET_SUPPLEMENTARY(c2, c)) ? 2 : -2;
498  }
499  return set.contains(c) ? 1 : -1;
500 }
501 
502 static inline int32_t
503 spanOneUTF8(const UnicodeSet &set, const uint8_t *s, int32_t length) {
504  UChar32 c=*s;
505  if(U8_IS_SINGLE(c)) {
506  return set.contains(c) ? 1 : -1;
507  }
508  // Take advantage of non-ASCII fastpaths in U8_NEXT_OR_FFFD().
509  int32_t i=0;
510  U8_NEXT_OR_FFFD(s, i, length, c);
511  return set.contains(c) ? i : -i;
512 }
513 
514 static inline int32_t
515 spanOneBackUTF8(const UnicodeSet &set, const uint8_t *s, int32_t length) {
516  UChar32 c=s[length-1];
517  if(U8_IS_SINGLE(c)) {
518  return set.contains(c) ? 1 : -1;
519  }
520  int32_t i=length-1;
521  c=utf8_prevCharSafeBody(s, 0, &i, c, -3);
522  length-=i;
523  return set.contains(c) ? length : -length;
524 }
525 
526 /*
527  * Note: In span() when spanLength==0 (after a string match, or at the beginning
528  * after an empty code point span) and in spanNot() and spanNotUTF8(),
529  * string matching could use a binary search
530  * because all string matches are done from the same start index.
531  *
532  * For UTF-8, this would require a comparison function that returns UTF-16 order.
533  *
534  * This optimization should not be necessary for normal UnicodeSets because
535  * most sets have no strings, and most sets with strings have
536  * very few very short strings.
537  * For cases with many strings, it might be better to use a different API
538  * and implementation with a DFA (state machine).
539  */
540 
541 /*
542  * Algorithm for span(USET_SPAN_CONTAINED)
543  *
544  * Theoretical algorithm:
545  * - Iterate through the string, and at each code point boundary:
546  * + If the code point there is in the set, then remember to continue after it.
547  * + If a set string matches at the current position, then remember to continue after it.
548  * + Either recursively span for each code point or string match,
549  * or recursively span for all but the shortest one and
550  * iteratively continue the span with the shortest local match.
551  * + Remember the longest recursive span (the farthest end point).
552  * + If there is no match at the current position, neither for the code point there
553  * nor for any set string, then stop and return the longest recursive span length.
554  *
555  * Optimized implementation:
556  *
557  * (We assume that most sets will have very few very short strings.
558  * A span using a string-less set is extremely fast.)
559  *
560  * Create and cache a spanSet which contains all of the single code points
561  * of the original set but none of its strings.
562  *
563  * - Start with spanLength=spanSet.span(USET_SPAN_CONTAINED).
564  * - Loop:
565  * + Try to match each set string at the end of the spanLength.
566  * ~ Set strings that start with set-contained code points must be matched
567  * with a partial overlap because the recursive algorithm would have tried
568  * to match them at every position.
569  * ~ Set strings that entirely consist of set-contained code points
570  * are irrelevant for span(USET_SPAN_CONTAINED) because the
571  * recursive algorithm would continue after them anyway
572  * and find the longest recursive match from their end.
573  * ~ Rather than recursing, note each end point of a set string match.
574  * + If no set string matched after spanSet.span(), then return
575  * with where the spanSet.span() ended.
576  * + If at least one set string matched after spanSet.span(), then
577  * pop the shortest string match end point and continue
578  * the loop, trying to match all set strings from there.
579  * + If at least one more set string matched after a previous string match,
580  * then test if the code point after the previous string match is also
581  * contained in the set.
582  * Continue the loop with the shortest end point of either this code point
583  * or a matching set string.
584  * + If no more set string matched after a previous string match,
585  * then try another spanLength=spanSet.span(USET_SPAN_CONTAINED).
586  * Stop if spanLength==0, otherwise continue the loop.
587  *
588  * By noting each end point of a set string match,
589  * the function visits each string position at most once and finishes
590  * in linear time.
591  *
592  * The recursive algorithm may visit the same string position many times
593  * if multiple paths lead to it and finishes in exponential time.
594  */
595 
596 /*
597  * Algorithm for span(USET_SPAN_SIMPLE)
598  *
599  * Theoretical algorithm:
600  * - Iterate through the string, and at each code point boundary:
601  * + If the code point there is in the set, then remember to continue after it.
602  * + If a set string matches at the current position, then remember to continue after it.
603  * + Continue from the farthest match position and ignore all others.
604  * + If there is no match at the current position,
605  * then stop and return the current position.
606  *
607  * Optimized implementation:
608  *
609  * (Same assumption and spanSet as above.)
610  *
611  * - Start with spanLength=spanSet.span(USET_SPAN_CONTAINED).
612  * - Loop:
613  * + Try to match each set string at the end of the spanLength.
614  * ~ Set strings that start with set-contained code points must be matched
615  * with a partial overlap because the standard algorithm would have tried
616  * to match them earlier.
617  * ~ Set strings that entirely consist of set-contained code points
618  * must be matched with a full overlap because the longest-match algorithm
619  * would hide set string matches that end earlier.
620  * Such set strings need not be matched earlier inside the code point span
621  * because the standard algorithm would then have continued after
622  * the set string match anyway.
623  * ~ Remember the longest set string match (farthest end point) from the earliest
624  * starting point.
625  * + If no set string matched after spanSet.span(), then return
626  * with where the spanSet.span() ended.
627  * + If at least one set string matched, then continue the loop after the
628  * longest match from the earliest position.
629  * + If no more set string matched after a previous string match,
630  * then try another spanLength=spanSet.span(USET_SPAN_CONTAINED).
631  * Stop if spanLength==0, otherwise continue the loop.
632  */
633 
635  if(spanCondition==USET_SPAN_NOT_CONTAINED) {
636  return spanNot(s, length);
637  }
638  int32_t spanLength=spanSet.span(s, length, USET_SPAN_CONTAINED);
639  if(spanLength==length) {
640  return length;
641  }
642 
643  // Consider strings; they may overlap with the span.
644  OffsetList offsets;
645  if(spanCondition==USET_SPAN_CONTAINED) {
646  // Use offset list to try all possibilities.
647  offsets.setMaxLength(maxLength16);
648  }
649  int32_t pos=spanLength, rest=length-pos;
650  int32_t i, stringsLength=strings.size();
651  for(;;) {
652  if(spanCondition==USET_SPAN_CONTAINED) {
653  for(i=0; i<stringsLength; ++i) {
654  int32_t overlap=spanLengths[i];
655  if(overlap==ALL_CP_CONTAINED) {
656  continue; // Irrelevant string.
657  }
658  const UnicodeString &string=*(const UnicodeString *)strings.elementAt(i);
659  const UChar *s16=string.getBuffer();
660  int32_t length16=string.length();
661 
662  // Try to match this string at pos-overlap..pos.
663  if(overlap>=LONG_SPAN) {
664  overlap=length16;
665  // While contained: No point matching fully inside the code point span.
666  U16_BACK_1(s16, 0, overlap); // Length of the string minus the last code point.
667  }
668  if(overlap>spanLength) {
669  overlap=spanLength;
670  }
671  int32_t inc=length16-overlap; // Keep overlap+inc==length16.
672  for(;;) {
673  if(inc>rest) {
674  break;
675  }
676  // Try to match if the increment is not listed already.
677  if(!offsets.containsOffset(inc) && matches16CPB(s, pos-overlap, length, s16, length16)) {
678  if(inc==rest) {
679  return length; // Reached the end of the string.
680  }
681  offsets.addOffset(inc);
682  }
683  if(overlap==0) {
684  break;
685  }
686  --overlap;
687  ++inc;
688  }
689  }
690  } else /* USET_SPAN_SIMPLE */ {
691  int32_t maxInc=0, maxOverlap=0;
692  for(i=0; i<stringsLength; ++i) {
693  int32_t overlap=spanLengths[i];
694  // For longest match, we do need to try to match even an all-contained string
695  // to find the match from the earliest start.
696 
697  const UnicodeString &string=*(const UnicodeString *)strings.elementAt(i);
698  const UChar *s16=string.getBuffer();
699  int32_t length16=string.length();
700 
701  // Try to match this string at pos-overlap..pos.
702  if(overlap>=LONG_SPAN) {
703  overlap=length16;
704  // Longest match: Need to match fully inside the code point span
705  // to find the match from the earliest start.
706  }
707  if(overlap>spanLength) {
708  overlap=spanLength;
709  }
710  int32_t inc=length16-overlap; // Keep overlap+inc==length16.
711  for(;;) {
712  if(inc>rest || overlap<maxOverlap) {
713  break;
714  }
715  // Try to match if the string is longer or starts earlier.
716  if( (overlap>maxOverlap || /* redundant overlap==maxOverlap && */ inc>maxInc) &&
717  matches16CPB(s, pos-overlap, length, s16, length16)
718  ) {
719  maxInc=inc; // Longest match from earliest start.
720  maxOverlap=overlap;
721  break;
722  }
723  --overlap;
724  ++inc;
725  }
726  }
727 
728  if(maxInc!=0 || maxOverlap!=0) {
729  // Longest-match algorithm, and there was a string match.
730  // Simply continue after it.
731  pos+=maxInc;
732  rest-=maxInc;
733  if(rest==0) {
734  return length; // Reached the end of the string.
735  }
736  spanLength=0; // Match strings from after a string match.
737  continue;
738  }
739  }
740  // Finished trying to match all strings at pos.
741 
742  if(spanLength!=0 || pos==0) {
743  // The position is after an unlimited code point span (spanLength!=0),
744  // not after a string match.
745  // The only position where spanLength==0 after a span is pos==0.
746  // Otherwise, an unlimited code point span is only tried again when no
747  // strings match, and if such a non-initial span fails we stop.
748  if(offsets.isEmpty()) {
749  return pos; // No strings matched after a span.
750  }
751  // Match strings from after the next string match.
752  } else {
753  // The position is after a string match (or a single code point).
754  if(offsets.isEmpty()) {
755  // No more strings matched after a previous string match.
756  // Try another code point span from after the last string match.
757  spanLength=spanSet.span(s+pos, rest, USET_SPAN_CONTAINED);
758  if( spanLength==rest || // Reached the end of the string, or
759  spanLength==0 // neither strings nor span progressed.
760  ) {
761  return pos+spanLength;
762  }
763  pos+=spanLength;
764  rest-=spanLength;
765  continue; // spanLength>0: Match strings from after a span.
766  } else {
767  // Try to match only one code point from after a string match if some
768  // string matched beyond it, so that we try all possible positions
769  // and don't overshoot.
770  spanLength=spanOne(spanSet, s+pos, rest);
771  if(spanLength>0) {
772  if(spanLength==rest) {
773  return length; // Reached the end of the string.
774  }
775  // Match strings after this code point.
776  // There cannot be any increments below it because UnicodeSet strings
777  // contain multiple code points.
778  pos+=spanLength;
779  rest-=spanLength;
780  offsets.shift(spanLength);
781  spanLength=0;
782  continue; // Match strings from after a single code point.
783  }
784  // Match strings from after the next string match.
785  }
786  }
787  int32_t minOffset=offsets.popMinimum();
788  pos+=minOffset;
789  rest-=minOffset;
790  spanLength=0; // Match strings from after a string match.
791  }
792 }
793 
795  if(spanCondition==USET_SPAN_NOT_CONTAINED) {
796  return spanNotBack(s, length);
797  }
799  if(pos==0) {
800  return 0;
801  }
802  int32_t spanLength=length-pos;
803 
804  // Consider strings; they may overlap with the span.
805  OffsetList offsets;
806  if(spanCondition==USET_SPAN_CONTAINED) {
807  // Use offset list to try all possibilities.
808  offsets.setMaxLength(maxLength16);
809  }
810  int32_t i, stringsLength=strings.size();
811  uint8_t *spanBackLengths=spanLengths;
812  if(all) {
813  spanBackLengths+=stringsLength;
814  }
815  for(;;) {
816  if(spanCondition==USET_SPAN_CONTAINED) {
817  for(i=0; i<stringsLength; ++i) {
818  int32_t overlap=spanBackLengths[i];
819  if(overlap==ALL_CP_CONTAINED) {
820  continue; // Irrelevant string.
821  }
822  const UnicodeString &string=*(const UnicodeString *)strings.elementAt(i);
823  const UChar *s16=string.getBuffer();
824  int32_t length16=string.length();
825 
826  // Try to match this string at pos-(length16-overlap)..pos-length16.
827  if(overlap>=LONG_SPAN) {
828  overlap=length16;
829  // While contained: No point matching fully inside the code point span.
830  int32_t len1=0;
831  U16_FWD_1(s16, len1, overlap);
832  overlap-=len1; // Length of the string minus the first code point.
833  }
834  if(overlap>spanLength) {
835  overlap=spanLength;
836  }
837  int32_t dec=length16-overlap; // Keep dec+overlap==length16.
838  for(;;) {
839  if(dec>pos) {
840  break;
841  }
842  // Try to match if the decrement is not listed already.
843  if(!offsets.containsOffset(dec) && matches16CPB(s, pos-dec, length, s16, length16)) {
844  if(dec==pos) {
845  return 0; // Reached the start of the string.
846  }
847  offsets.addOffset(dec);
848  }
849  if(overlap==0) {
850  break;
851  }
852  --overlap;
853  ++dec;
854  }
855  }
856  } else /* USET_SPAN_SIMPLE */ {
857  int32_t maxDec=0, maxOverlap=0;
858  for(i=0; i<stringsLength; ++i) {
859  int32_t overlap=spanBackLengths[i];
860  // For longest match, we do need to try to match even an all-contained string
861  // to find the match from the latest end.
862 
863  const UnicodeString &string=*(const UnicodeString *)strings.elementAt(i);
864  const UChar *s16=string.getBuffer();
865  int32_t length16=string.length();
866 
867  // Try to match this string at pos-(length16-overlap)..pos-length16.
868  if(overlap>=LONG_SPAN) {
869  overlap=length16;
870  // Longest match: Need to match fully inside the code point span
871  // to find the match from the latest end.
872  }
873  if(overlap>spanLength) {
874  overlap=spanLength;
875  }
876  int32_t dec=length16-overlap; // Keep dec+overlap==length16.
877  for(;;) {
878  if(dec>pos || overlap<maxOverlap) {
879  break;
880  }
881  // Try to match if the string is longer or ends later.
882  if( (overlap>maxOverlap || /* redundant overlap==maxOverlap && */ dec>maxDec) &&
883  matches16CPB(s, pos-dec, length, s16, length16)
884  ) {
885  maxDec=dec; // Longest match from latest end.
886  maxOverlap=overlap;
887  break;
888  }
889  --overlap;
890  ++dec;
891  }
892  }
893 
894  if(maxDec!=0 || maxOverlap!=0) {
895  // Longest-match algorithm, and there was a string match.
896  // Simply continue before it.
897  pos-=maxDec;
898  if(pos==0) {
899  return 0; // Reached the start of the string.
900  }
901  spanLength=0; // Match strings from before a string match.
902  continue;
903  }
904  }
905  // Finished trying to match all strings at pos.
906 
907  if(spanLength!=0 || pos==length) {
908  // The position is before an unlimited code point span (spanLength!=0),
909  // not before a string match.
910  // The only position where spanLength==0 before a span is pos==length.
911  // Otherwise, an unlimited code point span is only tried again when no
912  // strings match, and if such a non-initial span fails we stop.
913  if(offsets.isEmpty()) {
914  return pos; // No strings matched before a span.
915  }
916  // Match strings from before the next string match.
917  } else {
918  // The position is before a string match (or a single code point).
919  if(offsets.isEmpty()) {
920  // No more strings matched before a previous string match.
921  // Try another code point span from before the last string match.
922  int32_t oldPos=pos;
923  pos=spanSet.spanBack(s, oldPos, USET_SPAN_CONTAINED);
924  spanLength=oldPos-pos;
925  if( pos==0 || // Reached the start of the string, or
926  spanLength==0 // neither strings nor span progressed.
927  ) {
928  return pos;
929  }
930  continue; // spanLength>0: Match strings from before a span.
931  } else {
932  // Try to match only one code point from before a string match if some
933  // string matched beyond it, so that we try all possible positions
934  // and don't overshoot.
935  spanLength=spanOneBack(spanSet, s, pos);
936  if(spanLength>0) {
937  if(spanLength==pos) {
938  return 0; // Reached the start of the string.
939  }
940  // Match strings before this code point.
941  // There cannot be any decrements below it because UnicodeSet strings
942  // contain multiple code points.
943  pos-=spanLength;
944  offsets.shift(spanLength);
945  spanLength=0;
946  continue; // Match strings from before a single code point.
947  }
948  // Match strings from before the next string match.
949  }
950  }
951  pos-=offsets.popMinimum();
952  spanLength=0; // Match strings from before a string match.
953  }
954 }
955 
957  if(spanCondition==USET_SPAN_NOT_CONTAINED) {
958  return spanNotUTF8(s, length);
959  }
960  int32_t spanLength=spanSet.spanUTF8((const char *)s, length, USET_SPAN_CONTAINED);
961  if(spanLength==length) {
962  return length;
963  }
964 
965  // Consider strings; they may overlap with the span.
966  OffsetList offsets;
967  if(spanCondition==USET_SPAN_CONTAINED) {
968  // Use offset list to try all possibilities.
969  offsets.setMaxLength(maxLength8);
970  }
971  int32_t pos=spanLength, rest=length-pos;
972  int32_t i, stringsLength=strings.size();
973  uint8_t *spanUTF8Lengths=spanLengths;
974  if(all) {
975  spanUTF8Lengths+=2*stringsLength;
976  }
977  for(;;) {
978  const uint8_t *s8=utf8;
979  int32_t length8;
980  if(spanCondition==USET_SPAN_CONTAINED) {
981  for(i=0; i<stringsLength; ++i) {
982  length8=utf8Lengths[i];
983  if(length8==0) {
984  continue; // String not representable in UTF-8.
985  }
986  int32_t overlap=spanUTF8Lengths[i];
987  if(overlap==ALL_CP_CONTAINED) {
988  s8+=length8;
989  continue; // Irrelevant string.
990  }
991 
992  // Try to match this string at pos-overlap..pos.
993  if(overlap>=LONG_SPAN) {
994  overlap=length8;
995  // While contained: No point matching fully inside the code point span.
996  U8_BACK_1(s8, 0, overlap); // Length of the string minus the last code point.
997  }
998  if(overlap>spanLength) {
999  overlap=spanLength;
1000  }
1001  int32_t inc=length8-overlap; // Keep overlap+inc==length8.
1002  for(;;) {
1003  if(inc>rest) {
1004  break;
1005  }
1006  // Try to match if the increment is not listed already.
1007  // Match at code point boundaries. (The UTF-8 strings were converted
1008  // from UTF-16 and are guaranteed to be well-formed.)
1009  if(!U8_IS_TRAIL(s[pos-overlap]) &&
1010  !offsets.containsOffset(inc) &&
1011  matches8(s+pos-overlap, s8, length8)) {
1012  if(inc==rest) {
1013  return length; // Reached the end of the string.
1014  }
1015  offsets.addOffset(inc);
1016  }
1017  if(overlap==0) {
1018  break;
1019  }
1020  --overlap;
1021  ++inc;
1022  }
1023  s8+=length8;
1024  }
1025  } else /* USET_SPAN_SIMPLE */ {
1026  int32_t maxInc=0, maxOverlap=0;
1027  for(i=0; i<stringsLength; ++i) {
1028  length8=utf8Lengths[i];
1029  if(length8==0) {
1030  continue; // String not representable in UTF-8.
1031  }
1032  int32_t overlap=spanUTF8Lengths[i];
1033  // For longest match, we do need to try to match even an all-contained string
1034  // to find the match from the earliest start.
1035 
1036  // Try to match this string at pos-overlap..pos.
1037  if(overlap>=LONG_SPAN) {
1038  overlap=length8;
1039  // Longest match: Need to match fully inside the code point span
1040  // to find the match from the earliest start.
1041  }
1042  if(overlap>spanLength) {
1043  overlap=spanLength;
1044  }
1045  int32_t inc=length8-overlap; // Keep overlap+inc==length8.
1046  for(;;) {
1047  if(inc>rest || overlap<maxOverlap) {
1048  break;
1049  }
1050  // Try to match if the string is longer or starts earlier.
1051  // Match at code point boundaries. (The UTF-8 strings were converted
1052  // from UTF-16 and are guaranteed to be well-formed.)
1053  if(!U8_IS_TRAIL(s[pos-overlap]) &&
1054  (overlap>maxOverlap ||
1055  /* redundant overlap==maxOverlap && */ inc>maxInc) &&
1056  matches8(s+pos-overlap, s8, length8)) {
1057  maxInc=inc; // Longest match from earliest start.
1058  maxOverlap=overlap;
1059  break;
1060  }
1061  --overlap;
1062  ++inc;
1063  }
1064  s8+=length8;
1065  }
1066 
1067  if(maxInc!=0 || maxOverlap!=0) {
1068  // Longest-match algorithm, and there was a string match.
1069  // Simply continue after it.
1070  pos+=maxInc;
1071  rest-=maxInc;
1072  if(rest==0) {
1073  return length; // Reached the end of the string.
1074  }
1075  spanLength=0; // Match strings from after a string match.
1076  continue;
1077  }
1078  }
1079  // Finished trying to match all strings at pos.
1080 
1081  if(spanLength!=0 || pos==0) {
1082  // The position is after an unlimited code point span (spanLength!=0),
1083  // not after a string match.
1084  // The only position where spanLength==0 after a span is pos==0.
1085  // Otherwise, an unlimited code point span is only tried again when no
1086  // strings match, and if such a non-initial span fails we stop.
1087  if(offsets.isEmpty()) {
1088  return pos; // No strings matched after a span.
1089  }
1090  // Match strings from after the next string match.
1091  } else {
1092  // The position is after a string match (or a single code point).
1093  if(offsets.isEmpty()) {
1094  // No more strings matched after a previous string match.
1095  // Try another code point span from after the last string match.
1096  spanLength=spanSet.spanUTF8((const char *)s+pos, rest, USET_SPAN_CONTAINED);
1097  if( spanLength==rest || // Reached the end of the string, or
1098  spanLength==0 // neither strings nor span progressed.
1099  ) {
1100  return pos+spanLength;
1101  }
1102  pos+=spanLength;
1103  rest-=spanLength;
1104  continue; // spanLength>0: Match strings from after a span.
1105  } else {
1106  // Try to match only one code point from after a string match if some
1107  // string matched beyond it, so that we try all possible positions
1108  // and don't overshoot.
1109  spanLength=spanOneUTF8(spanSet, s+pos, rest);
1110  if(spanLength>0) {
1111  if(spanLength==rest) {
1112  return length; // Reached the end of the string.
1113  }
1114  // Match strings after this code point.
1115  // There cannot be any increments below it because UnicodeSet strings
1116  // contain multiple code points.
1117  pos+=spanLength;
1118  rest-=spanLength;
1119  offsets.shift(spanLength);
1120  spanLength=0;
1121  continue; // Match strings from after a single code point.
1122  }
1123  // Match strings from after the next string match.
1124  }
1125  }
1126  int32_t minOffset=offsets.popMinimum();
1127  pos+=minOffset;
1128  rest-=minOffset;
1129  spanLength=0; // Match strings from after a string match.
1130  }
1131 }
1132 
1134  if(spanCondition==USET_SPAN_NOT_CONTAINED) {
1135  return spanNotBackUTF8(s, length);
1136  }
1137  int32_t pos=spanSet.spanBackUTF8((const char *)s, length, USET_SPAN_CONTAINED);
1138  if(pos==0) {
1139  return 0;
1140  }
1141  int32_t spanLength=length-pos;
1142 
1143  // Consider strings; they may overlap with the span.
1144  OffsetList offsets;
1145  if(spanCondition==USET_SPAN_CONTAINED) {
1146  // Use offset list to try all possibilities.
1147  offsets.setMaxLength(maxLength8);
1148  }
1149  int32_t i, stringsLength=strings.size();
1150  uint8_t *spanBackUTF8Lengths=spanLengths;
1151  if(all) {
1152  spanBackUTF8Lengths+=3*stringsLength;
1153  }
1154  for(;;) {
1155  const uint8_t *s8=utf8;
1156  int32_t length8;
1157  if(spanCondition==USET_SPAN_CONTAINED) {
1158  for(i=0; i<stringsLength; ++i) {
1159  length8=utf8Lengths[i];
1160  if(length8==0) {
1161  continue; // String not representable in UTF-8.
1162  }
1163  int32_t overlap=spanBackUTF8Lengths[i];
1164  if(overlap==ALL_CP_CONTAINED) {
1165  s8+=length8;
1166  continue; // Irrelevant string.
1167  }
1168 
1169  // Try to match this string at pos-(length8-overlap)..pos-length8.
1170  if(overlap>=LONG_SPAN) {
1171  overlap=length8;
1172  // While contained: No point matching fully inside the code point span.
1173  int32_t len1=0;
1174  U8_FWD_1(s8, len1, overlap);
1175  overlap-=len1; // Length of the string minus the first code point.
1176  }
1177  if(overlap>spanLength) {
1178  overlap=spanLength;
1179  }
1180  int32_t dec=length8-overlap; // Keep dec+overlap==length8.
1181  for(;;) {
1182  if(dec>pos) {
1183  break;
1184  }
1185  // Try to match if the decrement is not listed already.
1186  // Match at code point boundaries. (The UTF-8 strings were converted
1187  // from UTF-16 and are guaranteed to be well-formed.)
1188  if( !U8_IS_TRAIL(s[pos-dec]) &&
1189  !offsets.containsOffset(dec) &&
1190  matches8(s+pos-dec, s8, length8)
1191  ) {
1192  if(dec==pos) {
1193  return 0; // Reached the start of the string.
1194  }
1195  offsets.addOffset(dec);
1196  }
1197  if(overlap==0) {
1198  break;
1199  }
1200  --overlap;
1201  ++dec;
1202  }
1203  s8+=length8;
1204  }
1205  } else /* USET_SPAN_SIMPLE */ {
1206  int32_t maxDec=0, maxOverlap=0;
1207  for(i=0; i<stringsLength; ++i) {
1208  length8=utf8Lengths[i];
1209  if(length8==0) {
1210  continue; // String not representable in UTF-8.
1211  }
1212  int32_t overlap=spanBackUTF8Lengths[i];
1213  // For longest match, we do need to try to match even an all-contained string
1214  // to find the match from the latest end.
1215 
1216  // Try to match this string at pos-(length8-overlap)..pos-length8.
1217  if(overlap>=LONG_SPAN) {
1218  overlap=length8;
1219  // Longest match: Need to match fully inside the code point span
1220  // to find the match from the latest end.
1221  }
1222  if(overlap>spanLength) {
1223  overlap=spanLength;
1224  }
1225  int32_t dec=length8-overlap; // Keep dec+overlap==length8.
1226  for(;;) {
1227  if(dec>pos || overlap<maxOverlap) {
1228  break;
1229  }
1230  // Try to match if the string is longer or ends later.
1231  // Match at code point boundaries. (The UTF-8 strings were converted
1232  // from UTF-16 and are guaranteed to be well-formed.)
1233  if( !U8_IS_TRAIL(s[pos-dec]) &&
1234  (overlap>maxOverlap || /* redundant overlap==maxOverlap && */ dec>maxDec) &&
1235  matches8(s+pos-dec, s8, length8)
1236  ) {
1237  maxDec=dec; // Longest match from latest end.
1238  maxOverlap=overlap;
1239  break;
1240  }
1241  --overlap;
1242  ++dec;
1243  }
1244  s8+=length8;
1245  }
1246 
1247  if(maxDec!=0 || maxOverlap!=0) {
1248  // Longest-match algorithm, and there was a string match.
1249  // Simply continue before it.
1250  pos-=maxDec;
1251  if(pos==0) {
1252  return 0; // Reached the start of the string.
1253  }
1254  spanLength=0; // Match strings from before a string match.
1255  continue;
1256  }
1257  }
1258  // Finished trying to match all strings at pos.
1259 
1260  if(spanLength!=0 || pos==length) {
1261  // The position is before an unlimited code point span (spanLength!=0),
1262  // not before a string match.
1263  // The only position where spanLength==0 before a span is pos==length.
1264  // Otherwise, an unlimited code point span is only tried again when no
1265  // strings match, and if such a non-initial span fails we stop.
1266  if(offsets.isEmpty()) {
1267  return pos; // No strings matched before a span.
1268  }
1269  // Match strings from before the next string match.
1270  } else {
1271  // The position is before a string match (or a single code point).
1272  if(offsets.isEmpty()) {
1273  // No more strings matched before a previous string match.
1274  // Try another code point span from before the last string match.
1275  int32_t oldPos=pos;
1276  pos=spanSet.spanBackUTF8((const char *)s, oldPos, USET_SPAN_CONTAINED);
1277  spanLength=oldPos-pos;
1278  if( pos==0 || // Reached the start of the string, or
1279  spanLength==0 // neither strings nor span progressed.
1280  ) {
1281  return pos;
1282  }
1283  continue; // spanLength>0: Match strings from before a span.
1284  } else {
1285  // Try to match only one code point from before a string match if some
1286  // string matched beyond it, so that we try all possible positions
1287  // and don't overshoot.
1288  spanLength=spanOneBackUTF8(spanSet, s, pos);
1289  if(spanLength>0) {
1290  if(spanLength==pos) {
1291  return 0; // Reached the start of the string.
1292  }
1293  // Match strings before this code point.
1294  // There cannot be any decrements below it because UnicodeSet strings
1295  // contain multiple code points.
1296  pos-=spanLength;
1297  offsets.shift(spanLength);
1298  spanLength=0;
1299  continue; // Match strings from before a single code point.
1300  }
1301  // Match strings from before the next string match.
1302  }
1303  }
1304  pos-=offsets.popMinimum();
1305  spanLength=0; // Match strings from before a string match.
1306  }
1307 }
1308 
1309 /*
1310  * Algorithm for spanNot()==span(USET_SPAN_NOT_CONTAINED)
1311  *
1312  * Theoretical algorithm:
1313  * - Iterate through the string, and at each code point boundary:
1314  * + If the code point there is in the set, then return with the current position.
1315  * + If a set string matches at the current position, then return with the current position.
1316  *
1317  * Optimized implementation:
1318  *
1319  * (Same assumption as for span() above.)
1320  *
1321  * Create and cache a spanNotSet which contains all of the single code points
1322  * of the original set but none of its strings.
1323  * For each set string add its initial code point to the spanNotSet.
1324  * (Also add its final code point for spanNotBack().)
1325  *
1326  * - Loop:
1327  * + Do spanLength=spanNotSet.span(USET_SPAN_NOT_CONTAINED).
1328  * + If the current code point is in the original set, then
1329  * return the current position.
1330  * + If any set string matches at the current position, then
1331  * return the current position.
1332  * + If there is no match at the current position, neither for the code point there
1333  * nor for any set string, then skip this code point and continue the loop.
1334  * This happens for set-string-initial code points that were added to spanNotSet
1335  * when there is not actually a match for such a set string.
1336  */
1337 
1339  int32_t pos=0, rest=length;
1340  int32_t i, stringsLength=strings.size();
1341  do {
1342  // Span until we find a code point from the set,
1343  // or a code point that starts or ends some string.
1345  if(i==rest) {
1346  return length; // Reached the end of the string.
1347  }
1348  pos+=i;
1349  rest-=i;
1350 
1351  // Check whether the current code point is in the original set,
1352  // without the string starts and ends.
1353  int32_t cpLength=spanOne(spanSet, s+pos, rest);
1354  if(cpLength>0) {
1355  return pos; // There is a set element at pos.
1356  }
1357 
1358  // Try to match the strings at pos.
1359  for(i=0; i<stringsLength; ++i) {
1361  continue; // Irrelevant string.
1362  }
1363  const UnicodeString &string=*(const UnicodeString *)strings.elementAt(i);
1364  const UChar *s16=string.getBuffer();
1365  int32_t length16=string.length();
1366  if(length16<=rest && matches16CPB(s, pos, length, s16, length16)) {
1367  return pos; // There is a set element at pos.
1368  }
1369  }
1370 
1371  // The span(while not contained) ended on a string start/end which is
1372  // not in the original set. Skip this code point and continue.
1373  // cpLength<0
1374  pos-=cpLength;
1375  rest+=cpLength;
1376  } while(rest!=0);
1377  return length; // Reached the end of the string.
1378 }
1379 
1381  int32_t pos=length;
1382  int32_t i, stringsLength=strings.size();
1383  do {
1384  // Span until we find a code point from the set,
1385  // or a code point that starts or ends some string.
1387  if(pos==0) {
1388  return 0; // Reached the start of the string.
1389  }
1390 
1391  // Check whether the current code point is in the original set,
1392  // without the string starts and ends.
1393  int32_t cpLength=spanOneBack(spanSet, s, pos);
1394  if(cpLength>0) {
1395  return pos; // There is a set element at pos.
1396  }
1397 
1398  // Try to match the strings at pos.
1399  for(i=0; i<stringsLength; ++i) {
1400  // Use spanLengths rather than a spanBackLengths pointer because
1401  // it is easier and we only need to know whether the string is irrelevant
1402  // which is the same in either array.
1404  continue; // Irrelevant string.
1405  }
1406  const UnicodeString &string=*(const UnicodeString *)strings.elementAt(i);
1407  const UChar *s16=string.getBuffer();
1408  int32_t length16=string.length();
1409  if(length16<=pos && matches16CPB(s, pos-length16, length, s16, length16)) {
1410  return pos; // There is a set element at pos.
1411  }
1412  }
1413 
1414  // The span(while not contained) ended on a string start/end which is
1415  // not in the original set. Skip this code point and continue.
1416  // cpLength<0
1417  pos+=cpLength;
1418  } while(pos!=0);
1419  return 0; // Reached the start of the string.
1420 }
1421 
1423  int32_t pos=0, rest=length;
1424  int32_t i, stringsLength=strings.size();
1425  uint8_t *spanUTF8Lengths=spanLengths;
1426  if(all) {
1427  spanUTF8Lengths+=2*stringsLength;
1428  }
1429  do {
1430  // Span until we find a code point from the set,
1431  // or a code point that starts or ends some string.
1432  i=pSpanNotSet->spanUTF8((const char *)s+pos, rest, USET_SPAN_NOT_CONTAINED);
1433  if(i==rest) {
1434  return length; // Reached the end of the string.
1435  }
1436  pos+=i;
1437  rest-=i;
1438 
1439  // Check whether the current code point is in the original set,
1440  // without the string starts and ends.
1441  int32_t cpLength=spanOneUTF8(spanSet, s+pos, rest);
1442  if(cpLength>0) {
1443  return pos; // There is a set element at pos.
1444  }
1445 
1446  // Try to match the strings at pos.
1447  const uint8_t *s8=utf8;
1448  int32_t length8;
1449  for(i=0; i<stringsLength; ++i) {
1450  length8=utf8Lengths[i];
1451  // ALL_CP_CONTAINED: Irrelevant string.
1452  if(length8!=0 && spanUTF8Lengths[i]!=ALL_CP_CONTAINED && length8<=rest && matches8(s+pos, s8, length8)) {
1453  return pos; // There is a set element at pos.
1454  }
1455  s8+=length8;
1456  }
1457 
1458  // The span(while not contained) ended on a string start/end which is
1459  // not in the original set. Skip this code point and continue.
1460  // cpLength<0
1461  pos-=cpLength;
1462  rest+=cpLength;
1463  } while(rest!=0);
1464  return length; // Reached the end of the string.
1465 }
1466 
1468  int32_t pos=length;
1469  int32_t i, stringsLength=strings.size();
1470  uint8_t *spanBackUTF8Lengths=spanLengths;
1471  if(all) {
1472  spanBackUTF8Lengths+=3*stringsLength;
1473  }
1474  do {
1475  // Span until we find a code point from the set,
1476  // or a code point that starts or ends some string.
1477  pos=pSpanNotSet->spanBackUTF8((const char *)s, pos, USET_SPAN_NOT_CONTAINED);
1478  if(pos==0) {
1479  return 0; // Reached the start of the string.
1480  }
1481 
1482  // Check whether the current code point is in the original set,
1483  // without the string starts and ends.
1484  int32_t cpLength=spanOneBackUTF8(spanSet, s, pos);
1485  if(cpLength>0) {
1486  return pos; // There is a set element at pos.
1487  }
1488 
1489  // Try to match the strings at pos.
1490  const uint8_t *s8=utf8;
1491  int32_t length8;
1492  for(i=0; i<stringsLength; ++i) {
1493  length8=utf8Lengths[i];
1494  // ALL_CP_CONTAINED: Irrelevant string.
1495  if(length8!=0 && spanBackUTF8Lengths[i]!=ALL_CP_CONTAINED && length8<=pos && matches8(s+pos-length8, s8, length8)) {
1496  return pos; // There is a set element at pos.
1497  }
1498  s8+=length8;
1499  }
1500 
1501  // The span(while not contained) ended on a string start/end which is
1502  // not in the original set. Skip this code point and continue.
1503  // cpLength<0
1504  pos+=cpLength;
1505  } while(pos!=0);
1506  return 0; // Reached the start of the string.
1507 }
1508 
return _Result< 0 ? -1 :_Result;} #line 1069 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _vsnwprintf_s_l(wchar_t *const _Buffer, size_t const _BufferCount, size_t const _MaxCount, wchar_t const *const _Format, _locale_t const _Locale, va_list _ArgList) { int const _Result=__stdio_common_vsnwprintf_s((*__local_stdio_printf_options()), _Buffer, _BufferCount, _MaxCount, _Format, _Locale, _ArgList);return _Result< 0 ? -1 :_Result;} #line 1091 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _vsnwprintf_s(wchar_t *const _Buffer, size_t const _BufferCount, size_t const _MaxCount, wchar_t const *const _Format, va_list _ArgList) { return _vsnwprintf_s_l(_Buffer, _BufferCount, _MaxCount, _Format,((void *) 0), _ArgList);} #line 1108 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __declspec(deprecated("This function or variable may be unsafe. Consider using " "_snwprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline int __cdecl _snwprintf(wchar_t *_Buffer, size_t _BufferCount, wchar_t const *_Format,...);__declspec(deprecated("This function or variable may be unsafe. Consider using " "_vsnwprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline int __cdecl _vsnwprintf(wchar_t *_Buffer, size_t _BufferCount, wchar_t const *_Format, va_list _Args);__declspec(deprecated("This function or variable may be unsafe. Consider using " "_vsnwprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline int __cdecl _vsnwprintf(wchar_t *_Buffer, size_t _BufferCount, wchar_t const *_Format, va_list _ArgList) { return _vsnwprintf_l(_Buffer, _BufferCount, _Format,((void *) 0), _ArgList);} #line 1133 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _vswprintf_c_l(wchar_t *const _Buffer, size_t const _BufferCount, wchar_t const *const _Format, _locale_t const _Locale, va_list _ArgList) { int const _Result=__stdio_common_vswprintf((*__local_stdio_printf_options()), _Buffer, _BufferCount, _Format, _Locale, _ArgList);return _Result< 0 ? -1 :_Result;} #line 1163 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _vswprintf_c(wchar_t *const _Buffer, size_t const _BufferCount, wchar_t const *const _Format, va_list _ArgList) { return _vswprintf_c_l(_Buffer, _BufferCount, _Format,((void *) 0), _ArgList);} #line 1179 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _vswprintf_l(wchar_t *const _Buffer, size_t const _BufferCount, wchar_t const *const _Format, _locale_t const _Locale, va_list _ArgList) { return _vswprintf_c_l(_Buffer, _BufferCount, _Format, _Locale, _ArgList);} #line 1196 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl __vswprintf_l(wchar_t *const _Buffer, wchar_t const *const _Format, _locale_t const _Locale, va_list _ArgList) { return _vswprintf_l(_Buffer,(size_t) -1, _Format, _Locale, _ArgList);} #line 1212 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _vswprintf(wchar_t *const _Buffer, wchar_t const *const _Format, va_list _ArgList) { return _vswprintf_l(_Buffer,(size_t) -1, _Format,((void *) 0), _ArgList);} #line 1227 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl vswprintf(wchar_t *const _Buffer, size_t const _BufferCount, wchar_t const *const _Format, va_list _ArgList) { return _vswprintf_c_l(_Buffer, _BufferCount, _Format,((void *) 0), _ArgList);} #line 1243 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _vswprintf_s_l(wchar_t *const _Buffer, size_t const _BufferCount, wchar_t const *const _Format, _locale_t const _Locale, va_list _ArgList) { int const _Result=__stdio_common_vswprintf_s((*__local_stdio_printf_options()), _Buffer, _BufferCount, _Format, _Locale, _ArgList);return _Result< 0 ? -1 :_Result;} #line 1264 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl vswprintf_s(wchar_t *const _Buffer, size_t const _BufferCount, wchar_t const *const _Format, va_list _ArgList) { return _vswprintf_s_l(_Buffer, _BufferCount, _Format,((void *) 0), _ArgList);} #line 1281 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" #line 1283 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _vswprintf_p_l(wchar_t *const _Buffer, size_t const _BufferCount, wchar_t const *const _Format, _locale_t const _Locale, va_list _ArgList) { int const _Result=__stdio_common_vswprintf_p((*__local_stdio_printf_options()), _Buffer, _BufferCount, _Format, _Locale, _ArgList);return _Result< 0 ? -1 :_Result;} #line 1312 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _vswprintf_p(wchar_t *const _Buffer, size_t const _BufferCount, wchar_t const *const _Format, va_list _ArgList) { return _vswprintf_p_l(_Buffer, _BufferCount, _Format,((void *) 0), _ArgList);} #line 1328 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _vscwprintf_l(wchar_t const *const _Format, _locale_t const _Locale, va_list _ArgList) { int const _Result=__stdio_common_vswprintf((*__local_stdio_printf_options())|(1ULL<< 1),((void *) 0), 0, _Format, _Locale, _ArgList);return _Result< 0 ? -1 :_Result;} #line 1347 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _vscwprintf(wchar_t const *const _Format, va_list _ArgList) { return _vscwprintf_l(_Format,((void *) 0), _ArgList);} #line 1361 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _vscwprintf_p_l(wchar_t const *const _Format, _locale_t const _Locale, va_list _ArgList) { int const _Result=__stdio_common_vswprintf_p((*__local_stdio_printf_options())|(1ULL<< 1),((void *) 0), 0, _Format, _Locale, _ArgList);return _Result< 0 ? -1 :_Result;} #line 1380 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _vscwprintf_p(wchar_t const *const _Format, va_list _ArgList) { return _vscwprintf_p_l(_Format,((void *) 0), _ArgList);} #line 1394 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl __swprintf_l(wchar_t *const _Buffer, wchar_t const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=__vswprintf_l(_Buffer, _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1414 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _swprintf_l(wchar_t *const _Buffer, size_t const _BufferCount, wchar_t const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vswprintf_c_l(_Buffer, _BufferCount, _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1435 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _swprintf(wchar_t *const _Buffer, wchar_t const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=__vswprintf_l(_Buffer, _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1454 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl swprintf(wchar_t *const _Buffer, size_t const _BufferCount, wchar_t const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vswprintf_c_l(_Buffer, _BufferCount, _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1474 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __declspec(deprecated("This function or variable may be unsafe. Consider using " "__swprintf_l_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline int __cdecl __swprintf_l(wchar_t *_Buffer, wchar_t const *_Format, _locale_t _Locale,...);__declspec(deprecated("This function or variable may be unsafe. Consider using " "_vswprintf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline int __cdecl __vswprintf_l(wchar_t *_Buffer, wchar_t const *_Format, _locale_t _Locale, va_list _Args);__declspec(deprecated("This function or variable may be unsafe. Consider using " "swprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline int __cdecl _swprintf(wchar_t *_Buffer, wchar_t const *_Format,...);__declspec(deprecated("This function or variable may be unsafe. Consider using " "vswprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline int __cdecl _vswprintf(wchar_t *_Buffer, wchar_t const *_Format, va_list _Args);__inline int __cdecl _swprintf_s_l(wchar_t *const _Buffer, size_t const _BufferCount, wchar_t const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vswprintf_s_l(_Buffer, _BufferCount, _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1511 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl swprintf_s(wchar_t *const _Buffer, size_t const _BufferCount, wchar_t const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vswprintf_s_l(_Buffer, _BufferCount, _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1532 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" #line 1534 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _swprintf_p_l(wchar_t *const _Buffer, size_t const _BufferCount, wchar_t const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vswprintf_p_l(_Buffer, _BufferCount, _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1562 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _swprintf_p(wchar_t *const _Buffer, size_t const _BufferCount, wchar_t const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vswprintf_p_l(_Buffer, _BufferCount, _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1582 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _swprintf_c_l(wchar_t *const _Buffer, size_t const _BufferCount, wchar_t const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vswprintf_c_l(_Buffer, _BufferCount, _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1603 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _swprintf_c(wchar_t *const _Buffer, size_t const _BufferCount, wchar_t const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vswprintf_c_l(_Buffer, _BufferCount, _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1623 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __declspec(deprecated("This function or variable may be unsafe. Consider using " "_snwprintf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline int __cdecl _snwprintf_l(wchar_t *const _Buffer, size_t const _BufferCount, wchar_t const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vsnwprintf_l(_Buffer, _BufferCount, _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1646 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _snwprintf(wchar_t *_Buffer, size_t _BufferCount, wchar_t const *_Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vsnwprintf_l(_Buffer, _BufferCount, _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1668 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _snwprintf_s_l(wchar_t *const _Buffer, size_t const _BufferCount, size_t const _MaxCount, wchar_t const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vsnwprintf_s_l(_Buffer, _BufferCount, _MaxCount, _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1690 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _snwprintf_s(wchar_t *const _Buffer, size_t const _BufferCount, size_t const _MaxCount, wchar_t const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vsnwprintf_s_l(_Buffer, _BufferCount, _MaxCount, _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1711 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _scwprintf_l(wchar_t const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vscwprintf_l(_Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1737 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _scwprintf(wchar_t const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vscwprintf_l(_Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1755 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _scwprintf_p_l(wchar_t const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vscwprintf_p_l(_Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1774 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _scwprintf_p(wchar_t const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vscwprintf_p_l(_Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1792 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" #pragma warning(push) #pragma warning(disable:4141 6054) #pragma warning(pop) #line 1856 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" int __cdecl __stdio_common_vswscanf(unsigned __int64 _Options, wchar_t const *_Buffer, size_t _BufferCount, wchar_t const *_Format, _locale_t _Locale, va_list _ArgList);__inline int __cdecl _vswscanf_l(wchar_t const *const _Buffer, wchar_t const *const _Format, _locale_t const _Locale, va_list _ArgList) { return __stdio_common_vswscanf((*__local_stdio_scanf_options()), _Buffer,(size_t) -1, _Format, _Locale, _ArgList);} #line 1897 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl vswscanf(wchar_t const *_Buffer, wchar_t const *_Format, va_list _ArgList) { return _vswscanf_l(_Buffer, _Format,((void *) 0), _ArgList);} #line 1912 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _vswscanf_s_l(wchar_t const *const _Buffer, wchar_t const *const _Format, _locale_t const _Locale, va_list _ArgList) { return __stdio_common_vswscanf((*__local_stdio_scanf_options())|(1ULL<< 0), _Buffer,(size_t) -1, _Format, _Locale, _ArgList);} #line 1930 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl vswscanf_s(wchar_t const *const _Buffer, wchar_t const *const _Format, va_list _ArgList) { return _vswscanf_s_l(_Buffer, _Format,((void *) 0), _ArgList);} #line 1947 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" #line 1949 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __declspec(deprecated("This function or variable may be unsafe. Consider using " "_vsnwscanf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline int __cdecl _vsnwscanf_l(wchar_t const *const _Buffer, size_t const _BufferCount, wchar_t const *const _Format, _locale_t const _Locale, va_list _ArgList) { return __stdio_common_vswscanf((*__local_stdio_scanf_options()), _Buffer, _BufferCount, _Format, _Locale, _ArgList);} #line 1976 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _vsnwscanf_s_l(wchar_t const *const _Buffer, size_t const _BufferCount, wchar_t const *const _Format, _locale_t const _Locale, va_list _ArgList) { return __stdio_common_vswscanf((*__local_stdio_scanf_options())|(1ULL<< 0), _Buffer, _BufferCount, _Format, _Locale, _ArgList);} #line 1995 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __declspec(deprecated("This function or variable may be unsafe. Consider using " "_swscanf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline int __cdecl _swscanf_l(wchar_t const *const _Buffer, wchar_t const *const _Format, _locale_t _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vswscanf_l(_Buffer, _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 2015 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __declspec(deprecated("This function or variable may be unsafe. Consider using " "swscanf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline int __cdecl swscanf(wchar_t const *const _Buffer, wchar_t const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vswscanf_l(_Buffer, _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 2034 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _swscanf_s_l(wchar_t const *const _Buffer, wchar_t const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vswscanf_s_l(_Buffer, _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 2054 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl swscanf_s(wchar_t const *const _Buffer, wchar_t const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vswscanf_s_l(_Buffer, _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 2075 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" #line 2077 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __declspec(deprecated("This function or variable may be unsafe. Consider using " "_snwscanf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline int __cdecl _snwscanf_l(wchar_t const *const _Buffer, size_t const _BufferCount, wchar_t const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vsnwscanf_l(_Buffer, _BufferCount, _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 2100 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __declspec(deprecated("This function or variable may be unsafe. Consider using " "_snwscanf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline int __cdecl _snwscanf(wchar_t const *const _Buffer, size_t const _BufferCount, wchar_t const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vsnwscanf_l(_Buffer, _BufferCount, _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 2122 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _snwscanf_s_l(wchar_t const *const _Buffer, size_t const _BufferCount, wchar_t const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vsnwscanf_s_l(_Buffer, _BufferCount, _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 2143 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __inline int __cdecl _snwscanf_s(wchar_t const *const _Buffer, size_t const _BufferCount, wchar_t const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vsnwscanf_s_l(_Buffer, _BufferCount, _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 2163 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstdio.h" __pragma(pack(pop))#pragma warning(pop) #pragma warning(push)#pragma warning(disable:4324 4514 4574 4710 4793 4820 4995 4996 28719 28726 28727) __pragma(pack(push, 8)) typedef __int64 fpos_t;errno_t __cdecl _get_stream_buffer_pointers(FILE *_Stream, char ***_Base, char ***_Pointer, int **_Count);errno_t __cdecl clearerr_s(FILE *_Stream);errno_t __cdecl fopen_s(FILE **_Stream, char const *_FileName, char const *_Mode);size_t __cdecl fread_s(void *_Buffer, size_t _BufferSize, size_t _ElementSize, size_t _ElementCount, FILE *_Stream);errno_t __cdecl freopen_s(FILE **_Stream, char const *_FileName, char const *_Mode, FILE *_OldStream);char *__cdecl gets_s(char *_Buffer, rsize_t _Size);errno_t __cdecl tmpfile_s(FILE **_Stream);errno_t __cdecl tmpnam_s(char *_Buffer, rsize_t _Size);#line 145 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" void __cdecl clearerr(FILE *_Stream);int __cdecl fclose(FILE *_Stream);int __cdecl _fcloseall(void);FILE *__cdecl _fdopen(int _FileHandle, char const *_Mode);int __cdecl feof(FILE *_Stream);int __cdecl ferror(FILE *_Stream);int __cdecl fflush(FILE *_Stream);int __cdecl fgetc(FILE *_Stream);int __cdecl _fgetchar(void);int __cdecl fgetpos(FILE *_Stream, fpos_t *_Position);char *__cdecl fgets(char *_Buffer, int _MaxCount, FILE *_Stream);int __cdecl _fileno(FILE *_Stream);int __cdecl _flushall(void);__declspec(deprecated("This function or variable may be unsafe. Consider using " "fopen_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) FILE *__cdecl fopen(char const *_FileName, char const *_Mode);int __cdecl fputc(int _Character, FILE *_Stream);int __cdecl _fputchar(int _Character);int __cdecl fputs(char const *_Buffer, FILE *_Stream);size_t __cdecl fread(void *_Buffer, size_t _ElementSize, size_t _ElementCount, FILE *_Stream);__declspec(deprecated("This function or variable may be unsafe. Consider using " "freopen_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) FILE *__cdecl freopen(char const *_FileName, char const *_Mode, FILE *_Stream);FILE *__cdecl _fsopen(char const *_FileName, char const *_Mode, int _ShFlag);int __cdecl fsetpos(FILE *_Stream, fpos_t const *_Position);int __cdecl fseek(FILE *_Stream, long _Offset, int _Origin);int __cdecl _fseeki64(FILE *_Stream, __int64 _Offset, int _Origin);long __cdecl ftell(FILE *_Stream);__int64 __cdecl _ftelli64(FILE *_Stream);size_t __cdecl fwrite(void const *_Buffer, size_t _ElementSize, size_t _ElementCount, FILE *_Stream);int __cdecl getc(FILE *_Stream);int __cdecl getchar(void);int __cdecl _getmaxstdio(void);int __cdecl _getw(FILE *_Stream);void __cdecl perror(char const *_ErrorMessage);int __cdecl _pclose(FILE *_Stream);FILE *__cdecl _popen(char const *_Command, char const *_Mode);#line 344 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" int __cdecl putc(int _Character, FILE *_Stream);int __cdecl putchar(int _Character);int __cdecl puts(char const *_Buffer);int __cdecl _putw(int _Word, FILE *_Stream);int __cdecl remove(char const *_FileName);int __cdecl rename(char const *_OldFileName, char const *_NewFileName);int __cdecl _unlink(char const *_FileName);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_unlink" ". See online help for details.")) int __cdecl unlink(char const *_FileName);#line 391 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" void __cdecl rewind(FILE *_Stream);int __cdecl _rmtmp(void);__declspec(deprecated("This function or variable may be unsafe. Consider using " "setvbuf" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) void __cdecl setbuf(FILE *_Stream, char *_Buffer);int __cdecl _setmaxstdio(int _Maximum);int __cdecl setvbuf(FILE *_Stream, char *_Buffer, int _Mode, size_t _Size);__declspec(allocator) char *__cdecl _tempnam(char const *_DirectoryName, char const *_FilePrefix);__declspec(deprecated("This function or variable may be unsafe. Consider using " "tmpfile_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) FILE *__cdecl tmpfile(void);__declspec(deprecated("This function or variable may be unsafe. Consider using " "tmpnam_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) char *__cdecl tmpnam(char *_Buffer);int __cdecl ungetc(int _Character, FILE *_Stream);void __cdecl _lock_file(FILE *_Stream);void __cdecl _unlock_file(FILE *_Stream);int __cdecl _fclose_nolock(FILE *_Stream);int __cdecl _fflush_nolock(FILE *_Stream);int __cdecl _fgetc_nolock(FILE *_Stream);int __cdecl _fputc_nolock(int _Character, FILE *_Stream);size_t __cdecl _fread_nolock(void *_Buffer, size_t _ElementSize, size_t _ElementCount, FILE *_Stream);size_t __cdecl _fread_nolock_s(void *_Buffer, size_t _BufferSize, size_t _ElementSize, size_t _ElementCount, FILE *_Stream);int __cdecl _fseek_nolock(FILE *_Stream, long _Offset, int _Origin);int __cdecl _fseeki64_nolock(FILE *_Stream, __int64 _Offset, int _Origin);long __cdecl _ftell_nolock(FILE *_Stream);__int64 __cdecl _ftelli64_nolock(FILE *_Stream);size_t __cdecl _fwrite_nolock(void const *_Buffer, size_t _ElementSize, size_t _ElementCount, FILE *_Stream);int __cdecl _getc_nolock(FILE *_Stream);int __cdecl _putc_nolock(int _Character, FILE *_Stream);int __cdecl _ungetc_nolock(int _Character, FILE *_Stream);int *__cdecl __p__commode(void);#line 596 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" int __cdecl __stdio_common_vfprintf(unsigned __int64 _Options, FILE *_Stream, char const *_Format, _locale_t _Locale, va_list _ArgList);int __cdecl __stdio_common_vfprintf_s(unsigned __int64 _Options, FILE *_Stream, char const *_Format, _locale_t _Locale, va_list _ArgList);int __cdecl __stdio_common_vfprintf_p(unsigned __int64 _Options, FILE *_Stream, char const *_Format, _locale_t _Locale, va_list _ArgList);__inline int __cdecl _vfprintf_l(FILE *const _Stream, char const *const _Format, _locale_t const _Locale, va_list _ArgList) { return __stdio_common_vfprintf((*__local_stdio_printf_options()), _Stream, _Format, _Locale, _ArgList);} #line 648 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl vfprintf(FILE *const _Stream, char const *const _Format, va_list _ArgList) { return _vfprintf_l(_Stream, _Format,((void *) 0), _ArgList);} #line 662 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _vfprintf_s_l(FILE *const _Stream, char const *const _Format, _locale_t const _Locale, va_list _ArgList) { return __stdio_common_vfprintf_s((*__local_stdio_printf_options()), _Stream, _Format, _Locale, _ArgList);} #line 677 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl vfprintf_s(FILE *const _Stream, char const *const _Format, va_list _ArgList) { return _vfprintf_s_l(_Stream, _Format,((void *) 0), _ArgList);} #line 693 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" #line 695 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _vfprintf_p_l(FILE *const _Stream, char const *const _Format, _locale_t const _Locale, va_list _ArgList) { return __stdio_common_vfprintf_p((*__local_stdio_printf_options()), _Stream, _Format, _Locale, _ArgList);} #line 710 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _vfprintf_p(FILE *const _Stream, char const *const _Format, va_list _ArgList) { return _vfprintf_p_l(_Stream, _Format,((void *) 0), _ArgList);} #line 724 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _vprintf_l(char const *const _Format, _locale_t const _Locale, va_list _ArgList) { return _vfprintf_l((__acrt_iob_func(1)), _Format, _Locale, _ArgList);} #line 738 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl vprintf(char const *const _Format, va_list _ArgList) { return _vfprintf_l((__acrt_iob_func(1)), _Format,((void *) 0), _ArgList);} #line 751 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _vprintf_s_l(char const *const _Format, _locale_t const _Locale, va_list _ArgList) { return _vfprintf_s_l((__acrt_iob_func(1)), _Format, _Locale, _ArgList);} #line 765 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl vprintf_s(char const *const _Format, va_list _ArgList) { return _vfprintf_s_l((__acrt_iob_func(1)), _Format,((void *) 0), _ArgList);} #line 780 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" #line 782 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _vprintf_p_l(char const *const _Format, _locale_t const _Locale, va_list _ArgList) { return _vfprintf_p_l((__acrt_iob_func(1)), _Format, _Locale, _ArgList);} #line 796 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _vprintf_p(char const *const _Format, va_list _ArgList) { return _vfprintf_p_l((__acrt_iob_func(1)), _Format,((void *) 0), _ArgList);} #line 809 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _fprintf_l(FILE *const _Stream, char const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vfprintf_l(_Stream, _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 828 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl fprintf(FILE *const _Stream, char const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vfprintf_l(_Stream, _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 846 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" int __cdecl _set_printf_count_output(int _Value);int __cdecl _get_printf_count_output(void);__inline int __cdecl _fprintf_s_l(FILE *const _Stream, char const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vfprintf_s_l(_Stream, _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 871 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl fprintf_s(FILE *const _Stream, char const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vfprintf_s_l(_Stream, _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 891 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" #line 893 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _fprintf_p_l(FILE *const _Stream, char const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vfprintf_p_l(_Stream, _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 912 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _fprintf_p(FILE *const _Stream, char const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vfprintf_p_l(_Stream, _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 930 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _printf_l(char const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vfprintf_l((__acrt_iob_func(1)), _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 948 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl printf(char const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vfprintf_l((__acrt_iob_func(1)), _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 965 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _printf_s_l(char const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vfprintf_s_l((__acrt_iob_func(1)), _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 983 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl printf_s(char const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vfprintf_s_l((__acrt_iob_func(1)), _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1002 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" #line 1004 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _printf_p_l(char const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vfprintf_p_l((__acrt_iob_func(1)), _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1022 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _printf_p(char const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vfprintf_p_l((__acrt_iob_func(1)), _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1039 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" int __cdecl __stdio_common_vfscanf(unsigned __int64 _Options, FILE *_Stream, char const *_Format, _locale_t _Locale, va_list _Arglist);__inline int __cdecl _vfscanf_l(FILE *const _Stream, char const *const _Format, _locale_t const _Locale, va_list _ArgList) { return __stdio_common_vfscanf((*__local_stdio_scanf_options()), _Stream, _Format, _Locale, _ArgList);} #line 1070 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl vfscanf(FILE *const _Stream, char const *const _Format, va_list _ArgList) { return _vfscanf_l(_Stream, _Format,((void *) 0), _ArgList);} #line 1084 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _vfscanf_s_l(FILE *const _Stream, char const *const _Format, _locale_t const _Locale, va_list _ArgList) { return __stdio_common_vfscanf((*__local_stdio_scanf_options())|(1ULL<< 0), _Stream, _Format, _Locale, _ArgList);} #line 1101 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl vfscanf_s(FILE *const _Stream, char const *const _Format, va_list _ArgList) { return _vfscanf_s_l(_Stream, _Format,((void *) 0), _ArgList);} #line 1118 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" #line 1120 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _vscanf_l(char const *const _Format, _locale_t const _Locale, va_list _ArgList) { return _vfscanf_l((__acrt_iob_func(0)), _Format, _Locale, _ArgList);} #line 1134 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl vscanf(char const *const _Format, va_list _ArgList) { return _vfscanf_l((__acrt_iob_func(0)), _Format,((void *) 0), _ArgList);} #line 1147 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _vscanf_s_l(char const *const _Format, _locale_t const _Locale, va_list _ArgList) { return _vfscanf_s_l((__acrt_iob_func(0)), _Format, _Locale, _ArgList);} #line 1161 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl vscanf_s(char const *const _Format, va_list _ArgList) { return _vfscanf_s_l((__acrt_iob_func(0)), _Format,((void *) 0), _ArgList);} #line 1176 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" #line 1178 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __declspec(deprecated("This function or variable may be unsafe. Consider using " "_fscanf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline int __cdecl _fscanf_l(FILE *const _Stream, char const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vfscanf_l(_Stream, _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1197 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __declspec(deprecated("This function or variable may be unsafe. Consider using " "fscanf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline int __cdecl fscanf(FILE *const _Stream, char const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vfscanf_l(_Stream, _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1215 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _fscanf_s_l(FILE *const _Stream, char const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vfscanf_s_l(_Stream, _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1234 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl fscanf_s(FILE *const _Stream, char const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vfscanf_s_l(_Stream, _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1254 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" #line 1256 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __declspec(deprecated("This function or variable may be unsafe. Consider using " "_scanf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline int __cdecl _scanf_l(char const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vfscanf_l((__acrt_iob_func(0)), _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1274 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __declspec(deprecated("This function or variable may be unsafe. Consider using " "scanf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline int __cdecl scanf(char const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vfscanf_l((__acrt_iob_func(0)), _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1291 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _scanf_s_l(char const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vfscanf_s_l((__acrt_iob_func(0)), _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1309 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl scanf_s(char const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vfscanf_s_l((__acrt_iob_func(0)), _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1328 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" #line 1330 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" int __cdecl __stdio_common_vsprintf(unsigned __int64 _Options, char *_Buffer, size_t _BufferCount, char const *_Format, _locale_t _Locale, va_list _ArgList);int __cdecl __stdio_common_vsprintf_s(unsigned __int64 _Options, char *_Buffer, size_t _BufferCount, char const *_Format, _locale_t _Locale, va_list _ArgList);int __cdecl __stdio_common_vsnprintf_s(unsigned __int64 _Options, char *_Buffer, size_t _BufferCount, size_t _MaxCount, char const *_Format, _locale_t _Locale, va_list _ArgList);int __cdecl __stdio_common_vsprintf_p(unsigned __int64 _Options, char *_Buffer, size_t _BufferCount, char const *_Format, _locale_t _Locale, va_list _ArgList);__declspec(deprecated("This function or variable may be unsafe. Consider using " "_vsnprintf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline int __cdecl _vsnprintf_l(char *const _Buffer, size_t const _BufferCount, char const *const _Format, _locale_t const _Locale, va_list _ArgList) { int const _Result=__stdio_common_vsprintf((*__local_stdio_printf_options())|(1ULL<< 0), _Buffer, _BufferCount, _Format, _Locale, _ArgList);return _Result< 0 ? -1 :_Result;} #line 1399 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _vsnprintf(char *const _Buffer, size_t const _BufferCount, char const *const _Format, va_list _ArgList) { return _vsnprintf_l(_Buffer, _BufferCount, _Format,((void *) 0), _ArgList);} #line 1415 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl vsnprintf(char *const _Buffer, size_t const _BufferCount, char const *const _Format, va_list _ArgList) { int const _Result=__stdio_common_vsprintf((*__local_stdio_printf_options())|(1ULL<< 1), _Buffer, _BufferCount, _Format,((void *) 0), _ArgList);return _Result< 0 ? -1 :_Result;} #line 1446 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __declspec(deprecated("This function or variable may be unsafe. Consider using " "_vsprintf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline int __cdecl _vsprintf_l(char *const _Buffer, char const *const _Format, _locale_t const _Locale, va_list _ArgList) { return _vsnprintf_l(_Buffer,(size_t) -1, _Format, _Locale, _ArgList);} #line 1462 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __declspec(deprecated("This function or variable may be unsafe. Consider using " "vsprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline int __cdecl vsprintf(char *const _Buffer, char const *const _Format, va_list _ArgList) { return _vsnprintf_l(_Buffer,(size_t) -1, _Format,((void *) 0), _ArgList);} #line 1477 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _vsprintf_s_l(char *const _Buffer, size_t const _BufferCount, char const *const _Format, _locale_t const _Locale, va_list _ArgList) { int const _Result=__stdio_common_vsprintf_s((*__local_stdio_printf_options()), _Buffer, _BufferCount, _Format, _Locale, _ArgList);return _Result< 0 ? -1 :_Result;} #line 1498 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl vsprintf_s(char *const _Buffer, size_t const _BufferCount, char const *const _Format, va_list _ArgList) { return _vsprintf_s_l(_Buffer, _BufferCount, _Format,((void *) 0), _ArgList);} #line 1516 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" #line 1526 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _vsprintf_p_l(char *const _Buffer, size_t const _BufferCount, char const *const _Format, _locale_t const _Locale, va_list _ArgList) { int const _Result=__stdio_common_vsprintf_p((*__local_stdio_printf_options()), _Buffer, _BufferCount, _Format, _Locale, _ArgList);return _Result< 0 ? -1 :_Result;} #line 1547 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _vsprintf_p(char *const _Buffer, size_t const _BufferCount, char const *const _Format, va_list _ArgList) { return _vsprintf_p_l(_Buffer, _BufferCount, _Format,((void *) 0), _ArgList);} #line 1563 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _vsnprintf_s_l(char *const _Buffer, size_t const _BufferCount, size_t const _MaxCount, char const *const _Format, _locale_t const _Locale, va_list _ArgList) { int const _Result=__stdio_common_vsnprintf_s((*__local_stdio_printf_options()), _Buffer, _BufferCount, _MaxCount, _Format, _Locale, _ArgList);return _Result< 0 ? -1 :_Result;} #line 1585 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _vsnprintf_s(char *const _Buffer, size_t const _BufferCount, size_t const _MaxCount, char const *const _Format, va_list _ArgList) { return _vsnprintf_s_l(_Buffer, _BufferCount, _MaxCount, _Format,((void *) 0), _ArgList);} #line 1602 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl vsnprintf_s(char *const _Buffer, size_t const _BufferCount, size_t const _MaxCount, char const *const _Format, va_list _ArgList) { return _vsnprintf_s_l(_Buffer, _BufferCount, _MaxCount, _Format,((void *) 0), _ArgList);} #line 1630 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" #line 1641 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _vscprintf_l(char const *const _Format, _locale_t const _Locale, va_list _ArgList) { int const _Result=__stdio_common_vsprintf((*__local_stdio_printf_options())|(1ULL<< 1),((void *) 0), 0, _Format, _Locale, _ArgList);return _Result< 0 ? -1 :_Result;} #line 1659 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _vscprintf(char const *const _Format, va_list _ArgList) { return _vscprintf_l(_Format,((void *) 0), _ArgList);} #line 1672 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _vscprintf_p_l(char const *const _Format, _locale_t const _Locale, va_list _ArgList) { int const _Result=__stdio_common_vsprintf_p((*__local_stdio_printf_options())|(1ULL<< 1),((void *) 0), 0, _Format, _Locale, _ArgList);return _Result< 0 ? -1 :_Result;} #line 1690 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _vscprintf_p(char const *const _Format, va_list _ArgList) { return _vscprintf_p_l(_Format,((void *) 0), _ArgList);} #line 1703 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _vsnprintf_c_l(char *const _Buffer, size_t const _BufferCount, char const *const _Format, _locale_t const _Locale, va_list _ArgList) { int const _Result=__stdio_common_vsprintf((*__local_stdio_printf_options()), _Buffer, _BufferCount, _Format, _Locale, _ArgList);return _Result< 0 ? -1 :_Result;} #line 1723 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _vsnprintf_c(char *const _Buffer, size_t const _BufferCount, char const *const _Format, va_list _ArgList) { return _vsnprintf_c_l(_Buffer, _BufferCount, _Format,((void *) 0), _ArgList);} #line 1739 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __declspec(deprecated("This function or variable may be unsafe. Consider using " "_sprintf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline int __cdecl _sprintf_l(char *const _Buffer, char const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vsprintf_l(_Buffer, _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1761 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl sprintf(char *const _Buffer, char const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vsprintf_l(_Buffer, _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1782 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __declspec(deprecated("This function or variable may be unsafe. Consider using " "sprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) int __cdecl sprintf(char *_Buffer, char const *_Format,...);__declspec(deprecated("This function or variable may be unsafe. Consider using " "vsprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) int __cdecl vsprintf(char *_Buffer, char const *_Format, va_list _Args);__inline int __cdecl _sprintf_s_l(char *const _Buffer, size_t const _BufferCount, char const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vsprintf_s_l(_Buffer, _BufferCount, _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1810 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl sprintf_s(char *const _Buffer, size_t const _BufferCount, char const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vsprintf_s_l(_Buffer, _BufferCount, _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1832 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" #line 1834 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _sprintf_p_l(char *const _Buffer, size_t const _BufferCount, char const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vsprintf_p_l(_Buffer, _BufferCount, _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1862 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _sprintf_p(char *const _Buffer, size_t const _BufferCount, char const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vsprintf_p_l(_Buffer, _BufferCount, _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1882 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __declspec(deprecated("This function or variable may be unsafe. Consider using " "_snprintf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline int __cdecl _snprintf_l(char *const _Buffer, size_t const _BufferCount, char const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vsnprintf_l(_Buffer, _BufferCount, _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1905 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl snprintf(char *const _Buffer, size_t const _BufferCount, char const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=vsnprintf(_Buffer, _BufferCount, _Format, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1936 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _snprintf(char *const _Buffer, size_t const _BufferCount, char const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vsnprintf(_Buffer, _BufferCount, _Format, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1956 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __declspec(deprecated("This function or variable may be unsafe. Consider using " "_snprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) int __cdecl _snprintf(char *_Buffer, size_t _BufferCount, char const *_Format,...);__declspec(deprecated("This function or variable may be unsafe. Consider using " "_vsnprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) int __cdecl _vsnprintf(char *_Buffer, size_t _BufferCount, char const *_Format, va_list _Args);__inline int __cdecl _snprintf_c_l(char *const _Buffer, size_t const _BufferCount, char const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vsnprintf_c_l(_Buffer, _BufferCount, _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 1986 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _snprintf_c(char *const _Buffer, size_t const _BufferCount, char const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vsnprintf_c_l(_Buffer, _BufferCount, _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 2006 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _snprintf_s_l(char *const _Buffer, size_t const _BufferCount, size_t const _MaxCount, char const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vsnprintf_s_l(_Buffer, _BufferCount, _MaxCount, _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 2028 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _snprintf_s(char *const _Buffer, size_t const _BufferCount, size_t const _MaxCount, char const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vsnprintf_s_l(_Buffer, _BufferCount, _MaxCount, _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 2049 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _scprintf_l(char const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vscprintf_l(_Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 2075 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _scprintf(char const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vscprintf_l(_Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 2092 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _scprintf_p_l(char const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vscprintf_p_l(_Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 2110 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _scprintf_p(char const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vscprintf_p(_Format, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 2127 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" int __cdecl __stdio_common_vsscanf(unsigned __int64 _Options, char const *_Buffer, size_t _BufferCount, char const *_Format, _locale_t _Locale, va_list _ArgList);__inline int __cdecl _vsscanf_l(char const *const _Buffer, char const *const _Format, _locale_t const _Locale, va_list _ArgList) { return __stdio_common_vsscanf((*__local_stdio_scanf_options()), _Buffer,(size_t) -1, _Format, _Locale, _ArgList);} #line 2158 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl vsscanf(char const *const _Buffer, char const *const _Format, va_list _ArgList) { return _vsscanf_l(_Buffer, _Format,((void *) 0), _ArgList);} #line 2172 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _vsscanf_s_l(char const *const _Buffer, char const *const _Format, _locale_t const _Locale, va_list _ArgList) { return __stdio_common_vsscanf((*__local_stdio_scanf_options())|(1ULL<< 0), _Buffer,(size_t) -1, _Format, _Locale, _ArgList);} #line 2189 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" #pragma warning(push) #pragma warning(disable:6530) __inline int __cdecl vsscanf_s(char const *const _Buffer, char const *const _Format, va_list _ArgList) { return _vsscanf_s_l(_Buffer, _Format,((void *) 0), _ArgList);} #line 2208 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" #pragma warning(pop) #line 2219 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __declspec(deprecated("This function or variable may be unsafe. Consider using " "_sscanf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline int __cdecl _sscanf_l(char const *const _Buffer, char const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vsscanf_l(_Buffer, _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 2238 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __declspec(deprecated("This function or variable may be unsafe. Consider using " "sscanf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline int __cdecl sscanf(char const *const _Buffer, char const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vsscanf_l(_Buffer, _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 2256 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _sscanf_s_l(char const *const _Buffer, char const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=_vsscanf_s_l(_Buffer, _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 2275 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl sscanf_s(char const *const _Buffer, char const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=vsscanf_s(_Buffer, _Format, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 2297 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" #line 2299 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" #pragma warning(push) #pragma warning(disable:6530) __declspec(deprecated("This function or variable may be unsafe. Consider using " "_snscanf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline int __cdecl _snscanf_l(char const *const _Buffer, size_t const _BufferCount, char const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=__stdio_common_vsscanf((*__local_stdio_scanf_options()), _Buffer, _BufferCount, _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 2326 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __declspec(deprecated("This function or variable may be unsafe. Consider using " "_snscanf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline int __cdecl _snscanf(char const *const _Buffer, size_t const _BufferCount, char const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=__stdio_common_vsscanf((*__local_stdio_scanf_options()), _Buffer, _BufferCount, _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 2349 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _snscanf_s_l(char const *const _Buffer, size_t const _BufferCount, char const *const _Format, _locale_t const _Locale,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Locale))+((sizeof(_Locale)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=__stdio_common_vsscanf((*__local_stdio_scanf_options())|(1ULL<< 0), _Buffer, _BufferCount, _Format, _Locale, _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 2374 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" __inline int __cdecl _snscanf_s(char const *const _Buffer, size_t const _BufferCount, char const *const _Format,...) { int _Result;va_list _ArgList;((void)(_ArgList=(va_list)(&(_Format))+((sizeof(_Format)+sizeof(int) - 1) &~(sizeof(int) - 1)))) ;_Result=__stdio_common_vsscanf((*__local_stdio_scanf_options())|(1ULL<< 0), _Buffer, _BufferCount, _Format,((void *) 0), _ArgList);((void)(_ArgList=(va_list) 0)) ;return _Result;} #line 2397 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h" #pragma warning(pop) __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_tempnam" ". See online help for details.")) char *__cdecl tempnam(char const *_Directory, char const *_FilePrefix);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_fcloseall" ". See online help for details.")) int __cdecl fcloseall(void);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_fdopen" ". See online help for details.")) FILE *__cdecl fdopen(int _FileHandle, char const *_Format);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_fgetchar" ". See online help for details.")) int __cdecl fgetchar(void);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_fileno" ". See online help for details.")) int __cdecl fileno(FILE *_Stream);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_flushall" ". See online help for details.")) int __cdecl flushall(void);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_fputchar" ". See online help for details.")) int __cdecl fputchar(int _Ch);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_getw" ". See online help for details.")) int __cdecl getw(FILE *_Stream);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_putw" ". See online help for details.")) int __cdecl putw(int _Ch, FILE *_Stream);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_rmtmp" ". See online help for details.")) int __cdecl rmtmp(void);#line 2441 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\stdio.h"__pragma(pack(pop))#pragma warning(pop) #pragma once#pragma once#pragma once#pragma once#pragma warning(push)#pragma warning(disable:4324 4514 4574 4710 4793 4820 4995 4996 28719 28726 28727) __pragma(pack(push, 8)) int *__cdecl _errno(void);errno_t __cdecl _set_errno(int _Value);errno_t __cdecl _get_errno(int *_Value);unsigned long *__cdecl __doserrno(void);errno_t __cdecl _set_doserrno(unsigned long _Value);errno_t __cdecl _get_doserrno(unsigned long *_Value);__pragma(pack(pop))#pragma warning(pop) #pragma once#pragma warning(push)#pragma warning(disable:4514 4820) __pragma(pack(push, 8)) void *__cdecl memchr(void const *_Buf, int _Val, size_t _MaxCount);int __cdecl memcmp(void const *_Buf1, void const *_Buf2, size_t _Size);void *__cdecl memcpy(void *_Dst, void const *_Src, size_t _Size);void *__cdecl memmove(void *_Dst, void const *_Src, size_t _Size);void *__cdecl memset(void *_Dst, int _Val, size_t _Size);char *__cdecl strchr(char const *_Str, int _Val);char *__cdecl strrchr(char const *_Str, int _Ch);char *__cdecl strstr(char const *_Str, char const *_SubStr);wchar_t *__cdecl wcschr(wchar_t const *_Str, wchar_t _Ch);wchar_t *__cdecl wcsrchr(wchar_t const *_Str, wchar_t _Ch);wchar_t *__cdecl wcsstr(wchar_t const *_Str, wchar_t const *_SubStr);__pragma(pack(pop))#pragma warning(pop) #pragma warning(push)#pragma warning(disable:4324 4514 4574 4710 4793 4820 4995 4996 28719 28726 28727) __pragma(pack(push, 8)) static __inline errno_t __cdecl memcpy_s(void *const _Destination, rsize_t const _DestinationSize, void const *const _Source, rsize_t const _SourceSize) { if(_SourceSize==0) { return 0;} { int _Expr_val=!!(_Destination !=((void *) 0));if(!(_Expr_val)) {(*_errno())=22;_invalid_parameter_noinfo();return 22;} } ;if(_Source==((void *) 0)||_DestinationSize< _SourceSize) { memset(_Destination, 0, _DestinationSize);{ int _Expr_val=!!(_Source !=((void *) 0));if(!(_Expr_val)) {(*_errno())=22;_invalid_parameter_noinfo();return 22;} } ;{ int _Expr_val=!!(_DestinationSize >=_SourceSize);if(!(_Expr_val)) {(*_errno())=34;_invalid_parameter_noinfo();return 34;} } ;return 22 ;} memcpy(_Destination, _Source, _SourceSize);return 0;} static __inline errno_t __cdecl memmove_s(void *const _Destination, rsize_t const _DestinationSize, void const *const _Source, rsize_t const _SourceSize) { if(_SourceSize==0) { return 0;} { int _Expr_val=!!(_Destination !=((void *) 0));if(!(_Expr_val)) {(*_errno())=22;_invalid_parameter_noinfo();return 22;} } ;{ int _Expr_val=!!(_Source !=((void *) 0));if(!(_Expr_val)) {(*_errno())=22;_invalid_parameter_noinfo();return 22;} } ;{ int _Expr_val=!!(_DestinationSize >=_SourceSize);if(!(_Expr_val)) {(*_errno())=34;_invalid_parameter_noinfo();return 34;} } ;memmove(_Destination, _Source, _SourceSize);return 0;}#pragma warning(pop) __pragma(pack(pop))#pragma warning(push)#pragma warning(disable:4324 4514 4574 4710 4793 4820 4995 4996 28719 28726 28727) __pragma(pack(push, 8)) int __cdecl _memicmp(void const *_Buf1, void const *_Buf2, size_t _Size);int __cdecl _memicmp_l(void const *_Buf1, void const *_Buf2, size_t _Size, _locale_t _Locale);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_memccpy" ". See online help for details.")) void *__cdecl memccpy(void *_Dst, void const *_Src, int _Val, size_t _Size);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_memicmp" ". See online help for details.")) int __cdecl memicmp(void const *_Buf1, void const *_Buf2, size_t _Size);__pragma(pack(pop))#pragma warning(pop) #pragma once#pragma warning(push)#pragma warning(disable:4324 4514 4574 4710 4793 4820 4995 4996 28719 28726 28727) __pragma(pack(push, 8)) errno_t __cdecl wcscat_s(wchar_t *_Destination, rsize_t _SizeInWords, wchar_t const *_Source);errno_t __cdecl wcscpy_s(wchar_t *_Destination, rsize_t _SizeInWords, wchar_t const *_Source);errno_t __cdecl wcsncat_s(wchar_t *_Destination, rsize_t _SizeInWords, wchar_t const *_Source, rsize_t _MaxCount);errno_t __cdecl wcsncpy_s(wchar_t *_Destination, rsize_t _SizeInWords, wchar_t const *_Source, rsize_t _MaxCount);wchar_t *__cdecl wcstok_s(wchar_t *_String, wchar_t const *_Delimiter, wchar_t **_Context);__declspec(allocator) wchar_t *__cdecl _wcsdup(wchar_t const *_String);__declspec(deprecated("This function or variable may be unsafe. Consider using " "wcscat_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) wchar_t *__cdecl wcscat(wchar_t *_Destination, wchar_t const *_Source);int __cdecl wcscmp(wchar_t const *_String1, wchar_t const *_String2);__declspec(deprecated("This function or variable may be unsafe. Consider using " "wcscpy_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) wchar_t *__cdecl wcscpy(wchar_t *_Destination, wchar_t const *_Source);size_t __cdecl wcscspn(wchar_t const *_String, wchar_t const *_Control);size_t __cdecl wcslen(wchar_t const *_String);size_t __cdecl wcsnlen(wchar_t const *_Source, size_t _MaxCount);static __inline size_t __cdecl wcsnlen_s(wchar_t const *_Source, size_t _MaxCount) { return(_Source==0) ? 0 :wcsnlen(_Source, _MaxCount);}__declspec(deprecated("This function or variable may be unsafe. Consider using " "wcsncat_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) wchar_t *__cdecl wcsncat(wchar_t *_Destination, wchar_t const *_Source, size_t _Count);int __cdecl wcsncmp(wchar_t const *_String1, wchar_t const *_String2, size_t _MaxCount);__declspec(deprecated("This function or variable may be unsafe. Consider using " "wcsncpy_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) wchar_t *__cdecl wcsncpy(wchar_t *_Destination, wchar_t const *_Source, size_t _Count);wchar_t *__cdecl wcspbrk(wchar_t const *_String, wchar_t const *_Control);size_t __cdecl wcsspn(wchar_t const *_String, wchar_t const *_Control);__declspec(deprecated("This function or variable may be unsafe. Consider using " "wcstok_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) wchar_t *__cdecl wcstok(wchar_t *_String, wchar_t const *_Delimiter, wchar_t **_Context);#line 237 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\corecrt_wstring.h" __declspec(deprecated("This function or variable may be unsafe. Consider using " "wcstok_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) static __inline wchar_t *__cdecl _wcstok(wchar_t *const _String, wchar_t const *const _Delimiter) { return wcstok(_String, _Delimiter, 0);} __declspec(deprecated("This function or variable may be unsafe. Consider using " "_wcserror_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) wchar_t *__cdecl _wcserror(int _ErrorNumber);errno_t __cdecl _wcserror_s(wchar_t *_Buffer, size_t _SizeInWords, int _ErrorNumber);__declspec(deprecated("This function or variable may be unsafe. Consider using " "__wcserror_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) wchar_t *__cdecl __wcserror(wchar_t const *_String);errno_t __cdecl __wcserror_s(wchar_t *_Buffer, size_t _SizeInWords, wchar_t const *_ErrorMessage);int __cdecl _wcsicmp(wchar_t const *_String1, wchar_t const *_String2);int __cdecl _wcsicmp_l(wchar_t const *_String1, wchar_t const *_String2, _locale_t _Locale);int __cdecl _wcsnicmp(wchar_t const *_String1, wchar_t const *_String2, size_t _MaxCount);int __cdecl _wcsnicmp_l(wchar_t const *_String1, wchar_t const *_String2, size_t _MaxCount, _locale_t _Locale);errno_t __cdecl _wcsnset_s(wchar_t *_Destination, size_t _SizeInWords, wchar_t _Value, size_t _MaxCount);__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wcsnset_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) wchar_t *__cdecl _wcsnset(wchar_t *_String, wchar_t _Value, size_t _MaxCount);wchar_t *__cdecl _wcsrev(wchar_t *_String);errno_t __cdecl _wcsset_s(wchar_t *_Destination, size_t _SizeInWords, wchar_t _Value);__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wcsset_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) wchar_t *__cdecl _wcsset(wchar_t *_String, wchar_t _Value);errno_t __cdecl _wcslwr_s(wchar_t *_String, size_t _SizeInWords);__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wcslwr_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) wchar_t *__cdecl _wcslwr(wchar_t *_String);errno_t __cdecl _wcslwr_s_l(wchar_t *_String, size_t _SizeInWords, _locale_t _Locale);__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wcslwr_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) wchar_t *__cdecl _wcslwr_l(wchar_t *_String, _locale_t _Locale);errno_t __cdecl _wcsupr_s(wchar_t *_String, size_t _Size);__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wcsupr_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) wchar_t *__cdecl _wcsupr(wchar_t *_String);errno_t __cdecl _wcsupr_s_l(wchar_t *_String, size_t _Size, _locale_t _Locale);__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wcsupr_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) wchar_t *__cdecl _wcsupr_l(wchar_t *_String, _locale_t _Locale);size_t __cdecl wcsxfrm(wchar_t *_Destination, wchar_t const *_Source, size_t _MaxCount);size_t __cdecl _wcsxfrm_l(wchar_t *_Destination, wchar_t const *_Source, size_t _MaxCount, _locale_t _Locale);int __cdecl wcscoll(wchar_t const *_String1, wchar_t const *_String2);int __cdecl _wcscoll_l(wchar_t const *_String1, wchar_t const *_String2, _locale_t _Locale);int __cdecl _wcsicoll(wchar_t const *_String1, wchar_t const *_String2);int __cdecl _wcsicoll_l(wchar_t const *_String1, wchar_t const *_String2, _locale_t _Locale);int __cdecl _wcsncoll(wchar_t const *_String1, wchar_t const *_String2, size_t _MaxCount);int __cdecl _wcsncoll_l(wchar_t const *_String1, wchar_t const *_String2, size_t _MaxCount, _locale_t _Locale);int __cdecl _wcsnicoll(wchar_t const *_String1, wchar_t const *_String2, size_t _MaxCount);int __cdecl _wcsnicoll_l(wchar_t const *_String1, wchar_t const *_String2, size_t _MaxCount, _locale_t _Locale);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_wcsdup" ". See online help for details.")) wchar_t *__cdecl wcsdup(wchar_t const *_String);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_wcsicmp" ". See online help for details.")) int __cdecl wcsicmp(wchar_t const *_String1, wchar_t const *_String2);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_wcsnicmp" ". See online help for details.")) int __cdecl wcsnicmp(wchar_t const *_String1, wchar_t const *_String2, size_t _MaxCount);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_wcsnset" ". See online help for details.")) wchar_t *__cdecl wcsnset(wchar_t *_String, wchar_t _Value, size_t _MaxCount);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_wcsrev" ". See online help for details.")) wchar_t *__cdecl wcsrev(wchar_t *_String);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_wcsset" ". See online help for details.")) wchar_t *__cdecl wcsset(wchar_t *_String, wchar_t _Value);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_wcslwr" ". See online help for details.")) wchar_t *__cdecl wcslwr(wchar_t *_String);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_wcsupr" ". See online help for details.")) wchar_t *__cdecl wcsupr(wchar_t *_String);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_wcsicoll" ". See online help for details.")) int __cdecl wcsicoll(wchar_t const *_String1, wchar_t const *_String2);__pragma(pack(pop))#pragma warning(pop) #pragma warning(push)#pragma warning(disable:4324 4514 4574 4710 4793 4820 4995 4996 28719 28726 28727) __pragma(pack(push, 8)) errno_t __cdecl strcpy_s(char *_Destination, rsize_t _SizeInBytes, char const *_Source);errno_t __cdecl strcat_s(char *_Destination, rsize_t _SizeInBytes, char const *_Source);errno_t __cdecl strerror_s(char *_Buffer, size_t _SizeInBytes, int _ErrorNumber);errno_t __cdecl strncat_s(char *_Destination, rsize_t _SizeInBytes, char const *_Source, rsize_t _MaxCount);errno_t __cdecl strncpy_s(char *_Destination, rsize_t _SizeInBytes, char const *_Source, rsize_t _MaxCount);char *__cdecl strtok_s(char *_String, char const *_Delimiter, char **_Context);void *__cdecl _memccpy(void *_Dst, void const *_Src, int _Val, size_t _MaxCount);__declspec(deprecated("This function or variable may be unsafe. Consider using " "strcat_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) char *__cdecl strcat(char *_Destination, char const *_Source);int __cdecl strcmp(char const *_Str1, char const *_Str2);int __cdecl _strcmpi(char const *_String1, char const *_String2);int __cdecl strcoll(char const *_String1, char const *_String2);int __cdecl _strcoll_l(char const *_String1, char const *_String2, _locale_t _Locale);__declspec(deprecated("This function or variable may be unsafe. Consider using " "strcpy_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) char *__cdecl strcpy(char *_Destination, char const *_Source);size_t __cdecl strcspn(char const *_Str, char const *_Control);__declspec(allocator) char *__cdecl _strdup(char const *_Source);__declspec(deprecated("This function or variable may be unsafe. Consider using " "_strerror_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) char *__cdecl _strerror(char const *_ErrorMessage);errno_t __cdecl _strerror_s(char *_Buffer, size_t _SizeInBytes, char const *_ErrorMessage);__declspec(deprecated("This function or variable may be unsafe. Consider using " "strerror_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) char *__cdecl strerror(int _ErrorMessage);int __cdecl _stricmp(char const *_String1, char const *_String2);int __cdecl _stricoll(char const *_String1, char const *_String2);int __cdecl _stricoll_l(char const *_String1, char const *_String2, _locale_t _Locale);int __cdecl _stricmp_l(char const *_String1, char const *_String2, _locale_t _Locale);size_t __cdecl strlen(char const *_Str);errno_t __cdecl _strlwr_s(char *_String, size_t _Size);__declspec(deprecated("This function or variable may be unsafe. Consider using " "_strlwr_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) char *__cdecl _strlwr(char *_String);errno_t __cdecl _strlwr_s_l(char *_String, size_t _Size, _locale_t _Locale);__declspec(deprecated("This function or variable may be unsafe. Consider using " "_strlwr_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) char *__cdecl _strlwr_l(char *_String, _locale_t _Locale);__declspec(deprecated("This function or variable may be unsafe. Consider using " "strncat_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) char *__cdecl strncat(char *_Destination, char const *_Source, size_t _Count);int __cdecl strncmp(char const *_Str1, char const *_Str2, size_t _MaxCount);int __cdecl _strnicmp(char const *_String1, char const *_String2, size_t _MaxCount);int __cdecl _strnicmp_l(char const *_String1, char const *_String2, size_t _MaxCount, _locale_t _Locale);int __cdecl _strnicoll(char const *_String1, char const *_String2, size_t _MaxCount);int __cdecl _strnicoll_l(char const *_String1, char const *_String2, size_t _MaxCount, _locale_t _Locale);int __cdecl _strncoll(char const *_String1, char const *_String2, size_t _MaxCount);int __cdecl _strncoll_l(char const *_String1, char const *_String2, size_t _MaxCount, _locale_t _Locale);size_t __cdecl __strncnt(char const *_String, size_t _Count);__declspec(deprecated("This function or variable may be unsafe. Consider using " "strncpy_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) char *__cdecl strncpy(char *_Destination, char const *_Source, size_t _Count);size_t __cdecl strnlen(char const *_String, size_t _MaxCount);static __inline size_t __cdecl strnlen_s(char const *_String, size_t _MaxCount) { return _String==0 ? 0 :strnlen(_String, _MaxCount);} errno_t __cdecl _strnset_s(char *_String, size_t _SizeInBytes, int _Value, size_t _MaxCount);__declspec(deprecated("This function or variable may be unsafe. Consider using " "_strnset_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) char *__cdecl _strnset(char *_Destination, int _Value, size_t _Count);char *__cdecl strpbrk(char const *_Str, char const *_Control);char *__cdecl _strrev(char *_Str);errno_t __cdecl _strset_s(char *_Destination, size_t _DestinationSize, int _Value);__declspec(deprecated("This function or variable may be unsafe. Consider using " "_strset_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) char *__cdecl _strset(char *_Destination, int _Value);size_t __cdecl strspn(char const *_Str, char const *_Control);__declspec(deprecated("This function or variable may be unsafe. Consider using " "strtok_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) char *__cdecl strtok(char *_String, char const *_Delimiter);errno_t __cdecl _strupr_s(char *_String, size_t _Size);__declspec(deprecated("This function or variable may be unsafe. Consider using " "_strupr_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) char *__cdecl _strupr(char *_String);errno_t __cdecl _strupr_s_l(char *_String, size_t _Size, _locale_t _Locale);__declspec(deprecated("This function or variable may be unsafe. Consider using " "_strupr_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) char *__cdecl _strupr_l(char *_String, _locale_t _Locale);size_t __cdecl strxfrm(char *_Destination, char const *_Source, size_t _MaxCount);size_t __cdecl _strxfrm_l(char *_Destination, char const *_Source, size_t _MaxCount, _locale_t _Locale);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_strdup" ". See online help for details.")) char *__cdecl strdup(char const *_String);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_strcmpi" ". See online help for details.")) int __cdecl strcmpi(char const *_String1, char const *_String2);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_stricmp" ". See online help for details.")) int __cdecl stricmp(char const *_String1, char const *_String2);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_strlwr" ". See online help for details.")) char *__cdecl strlwr(char *_String);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_strnicmp" ". See online help for details.")) int __cdecl strnicmp(char const *_String1, char const *_String2, size_t _MaxCount);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_strnset" ". See online help for details.")) char *__cdecl strnset(char *_String, int _Value, size_t _MaxCount);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_strrev" ". See online help for details.")) char *__cdecl strrev(char *_String);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_strset" ". See online help for details.")) char *__cdecl strset(char *_String, int _Value);__declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_strupr" ". See online help for details.")) char *__cdecl strupr(char *_String);__pragma(pack(pop))#pragma warning(pop) #pragma once#pragma warning(push)#pragma warning(disable:4514 4820) __pragma(pack(push, 8)) __pragma(pack(pop))#pragma warning(pop) #pragma once#pragma warning(push)#pragma warning(disable:4324 4514 4574 4710 4793 4820 4995 4996 28719 28726 28727) typedef unsigned short _ino_t;typedef _ino_t ino_t;#line 24 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\sys/types.h" typedef unsigned int _dev_t;typedef _dev_t dev_t;#line 36 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\sys/types.h" typedef long _off_t;typedef _off_t off_t;#line 48 "C:/Program Files (x86)/Windows Kits/10/include/10.0.19041.0/ucrt\\sys/types.h"#pragma warning(pop) typedef char *sds;#pragma pack(push, 1) struct sdshdr5 { unsigned char flags;char buf[];};struct sdshdr8 { uint8_t len;uint8_t alloc;unsigned char flags;char buf[];};struct sdshdr16 { uint16_t len;uint16_t alloc;unsigned char flags;char buf[];};struct sdshdr32 { uint32_t len;uint32_t alloc;unsigned char flags;char buf[];};struct sdshdr64 { uint64_t len;uint64_t alloc;unsigned char flags;char buf[];};#pragma pack(pop) static inline size_t sdslen(const sds s) { unsigned char flags=s[-1];switch(flags &7) { case 0 :return((flags) >> 3) ;case 1 :return((struct sdshdr8 *)((s) -(sizeof(struct sdshdr8)))) ->len;case 2 :return((struct sdshdr16 *)((s) -(sizeof(struct sdshdr16)))) ->len;case 3 :return((struct sdshdr32 *)((s) -(sizeof(struct sdshdr32)))) ->len;case 4 :return((struct sdshdr64 *)((s) -(sizeof(struct sdshdr64)))) ->len;} return 0;}static inline size_t sdsavail(const sds s) { unsigned char flags=s[-1];switch(flags &7) { case 0 :{ return 0;} case 1 :{ struct sdshdr8 *sh=(void *)((s) -(sizeof(struct sdshdr8)));;return sh->alloc - sh->len;} case 2 :{ struct sdshdr16 *sh=(void *)((s) -(sizeof(struct sdshdr16)));;return sh->alloc - sh->len;} case 3 :{ struct sdshdr32 *sh=(void *)((s) -(sizeof(struct sdshdr32)));;return sh->alloc - sh->len;} case 4 :{ struct sdshdr64 *sh=(void *)((s) -(sizeof(struct sdshdr64)));;return sh->alloc - sh->len;} } return 0;}static inline void sdssetlen(sds s, size_t newlen) { unsigned char flags=s[-1];switch(flags &7) { case 0 :{ unsigned char *fp=((unsigned char *) s) - 1;*fp=0|(newlen<< 3);} break;case 1 :((struct sdshdr8 *)((s) -(sizeof(struct sdshdr8)))) ->len=(uint8_t) newlen;break;case 2 :((struct sdshdr16 *)((s) -(sizeof(struct sdshdr16)))) ->len=(uint16_t) newlen;break;case 3 :((struct sdshdr32 *)((s) -(sizeof(struct sdshdr32)))) -> len
Definition: CPAL.d:15583
static void dec(struct edge *e, int h)
UBool staticList[16]
Definition: unisetspan.cpp:163
int32_t start
Definition: unisetspan.cpp:161
void addOffset(int32_t offset)
Definition: unisetspan.cpp:109
void setMaxLength(int32_t maxLength)
Definition: unisetspan.cpp:68
void shift(int32_t delta)
Definition: unisetspan.cpp:95
int32_t length
Definition: unisetspan.cpp:160
UBool isEmpty() const
Definition: unisetspan.cpp:86
UBool containsOffset(int32_t offset) const
Definition: unisetspan.cpp:119
int32_t popMinimum()
Definition: unisetspan.cpp:130
int32_t capacity
Definition: unisetspan.cpp:159
void clear()
Definition: unisetspan.cpp:81
UBool * list
Definition: unisetspan.cpp:158
int32_t size(void) const
Definition: uvector.h:353
void * elementAt(int32_t index) const
Definition: uvector.cpp:188
UnicodeSetStringSpan(const UnicodeSet &set, const UVector &setStrings, uint32_t which)
Definition: unisetspan.cpp:204
int32_t spanNot(const UChar *s, int32_t length) const
const UVector & strings
Definition: unisetspan.h:111
int32_t spanNotUTF8(const uint8_t *s, int32_t length) const
int32_t spanNotBackUTF8(const uint8_t *s, int32_t length) const
int32_t spanNotBack(const UChar *s, int32_t length) const
int32_t span(const UChar *s, int32_t length, USetSpanCondition spanCondition) const
Definition: unisetspan.cpp:634
uint8_t * spanLengths
Definition: unisetspan.h:120
void addToSpanNotSet(UChar32 c)
Definition: unisetspan.cpp:434
int32_t spanUTF8(const uint8_t *s, int32_t length, USetSpanCondition spanCondition) const
Definition: unisetspan.cpp:956
int32_t * utf8Lengths
Definition: unisetspan.h:116
int32_t spanBack(const UChar *s, int32_t length, USetSpanCondition spanCondition) const
Definition: unisetspan.cpp:794
int32_t staticLengths[32]
Definition: unisetspan.h:140
UnicodeSet * pSpanNotSet
Definition: unisetspan.h:108
UnicodeSet spanSet
Definition: unisetspan.h:104
int32_t spanBackUTF8(const uint8_t *s, int32_t length, USetSpanCondition spanCondition) const
#define uprv_memcpy(dst, src, size)
Definition: cmemory.h:40
#define uprv_memset(buffer, mark, size)
Definition: cmemory.h:51
@ FALSE
Definition: dd.h:101
@ TRUE
Definition: dd.h:102
char * strings
Definition: dvidvi.c:141
#define s
Definition: afcover.h:80
#define c(n)
Definition: gpos-common.c:150
unsigned char UChar
Definition: bzip2.c:163
#define NULL
Definition: ftobjs.h:61
small capitals from c petite p scientific i
Definition: afcover.h:80
unsigned int uint32_t
Definition: stdint.h:80
signed int int32_t
Definition: stdint.h:77
unsigned char uint8_t
Definition: stdint.h:78
int capacity
Definition: pdfcolor.c:1335
#define length(c)
Definition: ctangleboot.c:65
const int * pos
Definition: combiners.h:905
maxLength(int begin, int end)
Definition: miscutil.c:242
utf< uint8 > utf8
Definition: UtfCodec.h:249
std::is_same< integer_sequence< bool, true, Bs... >, integer_sequence< bool, Bs..., true > > all
Definition: variant.hpp:799
static int delta
Definition: pbmtolj.c:36
logical rest[4800]
Definition: pmxab.c:91
static int offset
Definition: ppmtogif.c:642
C API: Unicode string handling functions.
#define int32_t
Definition: stdint.in.h:167
#define uint8_t
Definition: stdint.in.h:154
Definition: dvips.h:235
#define c2
Definition: t1io.c:53
#define s8
Definition: tokst.h:205
int32_t UChar32
Definition: umachine.h:467
int8_t UBool
Definition: umachine.h:269
static UBool matches16(const UChar *s, const UChar *t, int32_t length)
Definition: unisetspan.cpp:451
static int32_t appendUTF8(const UChar *s, int32_t length, uint8_t *t, int32_t capacity)
Definition: unisetspan.cpp:183
static UBool matches16CPB(const UChar *s, int32_t start, int32_t limit, const UChar *t, int32_t length)
Definition: unisetspan.cpp:474
static int32_t spanOneBackUTF8(const UnicodeSet &set, const uint8_t *s, int32_t length)
Definition: unisetspan.cpp:515
static int32_t spanOne(const UnicodeSet &set, const UChar *s, int32_t length)
Definition: unisetspan.cpp:485
static int32_t spanOneBack(const UnicodeSet &set, const UChar *s, int32_t length)
Definition: unisetspan.cpp:494
static UBool matches8(const uint8_t *s, const uint8_t *t, int32_t length)
Definition: unisetspan.cpp:461
static uint8_t makeSpanLengthByte(int32_t spanLength)
Definition: unisetspan.cpp:197
static int32_t spanOneUTF8(const UnicodeSet &set, const uint8_t *s, int32_t length)
Definition: unisetspan.cpp:503
static int32_t getUTF8Length(const UChar *s, int32_t length)
Definition: unisetspan.cpp:168
#define uprv_malloc
Definition: urename.h:1435
#define uprv_free
Definition: urename.h:1414
#define utf8_prevCharSafeBody
Definition: urename.h:1801
#define u_strToUTF8
Definition: urename.h:371
USetSpanCondition
Definition: uset.h:159
@ USET_SPAN_NOT_CONTAINED
Definition: uset.h:172
@ USET_SPAN_CONTAINED
Definition: uset.h:187
C API: 16-bit Unicode handling macros.
#define U16_PREV(s, start, i, c)
Definition: utf16.h:570
#define U16_BACK_1(s, start, i)
Definition: utf16.h:643
#define U16_FWD_1(s, i, length)
Definition: utf16.h:433
#define U16_NEXT(s, i, length, c)
Definition: utf16.h:309
#define U16_GET_SUPPLEMENTARY(lead, trail)
Definition: utf16.h:112
#define U16_IS_LEAD(c)
Definition: utf16.h:59
#define U16_IS_TRAIL(c)
Definition: utf16.h:67
C API: 8-bit Unicode handling macros.
#define U8_FWD_1(s, i, length)
Definition: utf8.h:507
#define U8_NEXT_OR_FFFD(s, i, length, c)
Definition: utf8.h:378
#define U8_IS_SINGLE(c)
Definition: utf8.h:173
#define U8_BACK_1(s, start, i)
Definition: utf8.h:791
#define U8_IS_TRAIL(c)
Definition: utf8.h:190
@ start
Definition: preamble.c:52
Basic definitions for ICU, for both C and C++ APIs.
UErrorCode
Definition: utypes.h:431
@ U_BUFFER_OVERFLOW_ERROR
Definition: utypes.h:481
@ U_ZERO_ERROR
Definition: utypes.h:465
#define U_SUCCESS(x)
Definition: utypes.h:730
#define errorCode
Definition: xmlparse.c:601
#define limit(x)
Definition: yuvsplittoppm.c:26