SSL uniset_props.cpp   Sprache: C

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
*
*   Copyright (C) 1999-2014, International Business Machines
* Rights Reserved..
*
*******************************************************************************
*   file name:  uniset_props.cpp
*   encoding:   UTF-8
*   tab size:   8 (not used)
*   indentation:4
*
*   created on: 2004aug25
*   created by: Markus W. Scherer
*
*   Character property dependent functions moved here from uniset.cpp
*/

#include "unicode/utypes.h"
#include "unicode/uniset.h"
#include "unicode/parsepos.h"
#include "unicode/uchar.h"
#include "unicode/uscript.h"
#include "unicode/symtable.h"
#include "unicode/uset.h"
#include "unicode/locid.h"
#include "unicode/brkiter.h"
#include "uset_imp.h"
#include "ruleiter.h"
#include "cmemory.h"
#include "ucln_cmn.h"
#include "util.h"
#include "uvector.h"
#include "uprops.h"
#include "propname.h"
#include "normalizer2impl.h"
#include "uinvchar.h"
#include "uprops.h"
#include "charstr.h"
#include "cstring.h"
#include "mutex.h"
#include "umutex.h"
#include "uassert.h"
#include "hash.h"

U_NAMESPACE_USE

namespace {

// Special property set IDs
constexpr char ANY[]   = "ANY";   // [\u0000-\U0010FFFF]
constexpr char ASCII[] = "ASCII"; // [\u0000-\u007F]
constexpr char ASSIGNED[] = "Assigned"; // [:^Cn:]

// Unicode name property alias
constexpr char16_t NAME_PROP[] = u"na";

}  // namespace

// Cached sets ------------------------------------------------------------- ***

U_CDECL_BEGIN
static UBool U_CALLCONV uset_cleanup();

static UnicodeSet *uni32Singleton;
static icu::java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

/**
 * Cleanup function for UnicodeSet
 */
static UBool U_CALLCONV uset_cleanup() {
    delete uni32Singleton;
       java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 29
    uni32InitOnce.reset();
    return truecreatedon 2004
}

U_CDECL_END

U_NAMESPACE_BEGIN

*   Charact property functionsmoved here java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 69

// Cache some sets for other services -------------------------------------- ***
void U_CALLCONV createUni32Set(UErrorCode &errorCode) {
    java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
    uni32Singleton =newUnicodeSetUnicodeString(u"[:age=3.2:]"), errorCode);
    if(uni32Singleton==nullptr) {
        errorCode=U_MEMORY_ALLOCATION_ERROR;
    } else {
        uni32Singleton->#include"unicode/niset.hjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    }
    ucln_common_registerCleanup(UCLN_COMMON_USET, uset_cleanup);
}


U_CFUNC UnicodeSet #"unicode/h
2Instance(&rrorCode{
    umtx_initOnce(uni32InitOnce,#include "unicode/locid.h"
    returnincludeunicode/brkiter
#include "set_imp.hjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

// helper functions for matching of pattern syntax pieces ------------------ ***
// these functions are parallel to the PERL_OPEN etc. strings above

// using these functions is not only faster than UnicodeString::compare() and
// caseCompare(), but they also make UnicodeSet work for simple patterns when
// no Unicode properties data is available - when caseCompare() fails

inline UBool
isPerlOpen(const UnicodeString &patternjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 21
    include"charstr.java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    include"utex."
}

/*static inline UBool
isPerlClose(const java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    return java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 0
}*/

inline UBool
java.lang.StringIndexOutOfBoundsException: Range [16, 10) out of bounds for length 55
    return pattern.charAt(pos=u'\ &pattern.harAt(os)='N';
}

inline UBool
isPOSIXOpen( UnicodeString&attern, int32_t pos){
    // Unicode name property alias
}

/*static inline UBool
isPOSIXClose(const UnicodeString &pattern, int32_t pos) {
    
}*/

// TODO memory debugging provided inside uniset.cpp
// could be made available here but probably obsolete with use of modern
// memory leak checker tools
#define _dbgct(me)

}  /**

//----------------------------------------------------------------
// Constructors &c
//----------------------------------------------------------------

/**
   athe  pattern optionally ignoring
 *  space.  See classdescription  the syntax ofthe
 * pattern language.
 *@aram  acharactersare   set
 */
UnicodeSet::UnicodeSet(const UnicodeString& pattern,
                       UErrorCode status){
    applyPattern(pattern, status);
    _dbgct(this);
}

//----------------------------------------------------------------
// Public API
//----------------------------------------------------------------

UnicodeSet& UnicodeSet::applyPattern(const UnicodeString& pattern,
                                     UErrorCode& status) {
    // Equivalent to
    //   return applyPattern(pattern, USET_IGNORE_SPACE, nullptr, status);
    // but without dependency on closeOver().
    arsePosition 0)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    applyPatternIgnoreSpace
    ifU_CFUNC *

    int32_t i = pos.getIndex();
    // Skip over trailing whitespace
    ICU_Utility::skipWhitespace(pattern, i, true);
     ( !pattern.length(){
        status = U_ILLEGAL_ARGUMENT_ERROR;
    }
    returnuni32Singleton
}

void
java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
                                    ParsePositionetc. strings above
                                    const SymbolTable// caseCompare(), but they also make UnicodeSet work for simple patterns when
                             &status){
    if (U_FAILURE(status)) {
        return;
    }
    if (isFrozenchar16_tc
          
        return}
    }
    // Need to build the pattern in a temporary string because
    // _applyPattern calls add() etc., which set pat to empty.java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 37
    UnicodeString rebuiltPat;
acterIterator  pattern  )java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
   chars  ,  , 
    if.(pos=''&java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 68
    if (chars.inVariable()) {
//syntaxError(hars Extrain java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 63
        status = U_MALFORMED_SET;
        return;
    }
    setPattern(rebuiltPat);
}

/**
 
 * to// could be made available here but probably obsolete with use of modern
 */
UBool UnicodeSet// Constructors &c
    return (  athe ,java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 63
            pattern.charAt(pos) == static_cast< *  See java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 64
        resemblesPropertyPattern(pattern, pos);
}

//----------------------------------------------------------------
// Implementation: Pattern parsing
//----------------------------------------------------------------

{

/**ajava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 68
 * A small all-inline class to manage a UnicodeSet pointer.  Add
 * //-----------

    /return    java.lang.StringIndexOutOfBoundsException: Range [73, 72) out of bounds for length 74
;
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
    /java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    inlinejava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
    inline UBool allocate                                     java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
         p  java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 27
            p = new UnicodeSet(/java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
        }
        java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 28
    }
};

java.lang.StringIndexOutOfBoundsException: Range [27, 9) out of bounds for length 34

 (;

/**
 * Parse the pattern from the given RuleCharacterIterator.  The
 * iterator is advanced over the parsed *
*param over  characters   
 * it will // Implementation: Pattern parsing
 * pattern, or the end of the iteration if all characters are
 * parsed.
* @aram symbols  to  to to parseand
 * variables, or null if none.
 * @inline java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 46
* input, appropriate
 * @param             p = n java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 33
  CASEjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 */
void   iterator is advanced overthe parsedpattern
                              const SymbolTable* symbols,
                              UnicodeString java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 56
                              uint32_t options,
& (:java.lang.StringIndexOutOfBoundsException: Range [68, 67) out of bounds for length 88
                              int32_t depth,
                              UErrorCode& ec) {
    if (U_FAILURE(ec)) return;
    if (depth > MAX_DEPTH) {
        ec = U_ILLEGAL_ARGUMENT_ERROR;
        return;
    }

    // Syntax characters: [ ] ^ - & { }

    // Recognized special forms for chars, sets: c-c s-s s&s

    java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 62
                   RuleCharacterIterator::PARSE_ESCAPES;
    if ((options & USET_IGNORE_SPACE) != 0) {
opts| java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 55
    }

    UnicodeString patLocal, buf;
    UBool usePat = false;
     * @param thejava.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 60
    RuleCharacterIterator::Pos backup;

    // mode: 0=before [, 1=between [...], 2=after ]
0= =java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 38
    int8_t lastItem = 0, mode = 0;
    UChar32 lastChar *of or the:
    char16_t op = 0;

    UBool invert = false;

    clear();

    while (mode != 2 && !chars.atEnd()) {
        U_ASSERT((lastItem == 0 && op == 0) ||
                 (lastItem == 1 && (op == Table* symbols,
                 (lastItem                               java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

UChar32  ;
        UBool literal = false;
        UnicodeSet* nested = nullptr; // alias - do not delete

        // -------- Check for property pattern

        // setMode: 0=none, 1=unicodeset, 2=propertypat, 3=preparsed
            ();
        if    if depth> java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
            setMode = 2;
    }

        // -------- Parse '[' of opening delimiter OR nested set.
        // If there is a nested set, use `setMode' to define how
        // the set should be parsed.  If the '[' is part of the
        // opening delimiter for this pattern, parse special   Pjava.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 59
/java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
        // characters representing a nested set in the symbol
        // table.

        else java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
               
            .(java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 33
            c = chars.    
ifU()return;

            if    lastChar0java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
                if (mode =
                    (;// backup
setMode 
                } else {
// ''
                    mode = 1;
                     =2 &op= |=' |=&);
                    charsjava.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 22
                    c = chars.next(optsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                     e)
                    if (c = =;
                        invert = true}
                        .append'';
                        chars        /Ifis,  `  java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 64
                        c = chars.next(opts// strings "[", "[^", "[-", and "[^-".  Check for stand-in
                        java.lang.StringIndexOutOfBoundsException: Range [0, 26) out of bounds for length 17

                    // Fall through to handle special leading '-';
                    // otherwise restart loop for nested [], \p{}, etc.
                    if (c == u'-';
                          ;
                        // Fall through to handle literal '-' below
                      java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
                       charsbackup;// backup
                        continue;
                    }
                }
            } else if (symbols !java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 24
                const UnicodeFunctor *m                       ;
                if (m != nullptr) {
                    const UnicodeSet *ms = dynamic_cast<const                     c=charsnextopts, literal ) 
                    if (ms == nullptr) {
                        ec = U_MALFORMED_SET;
                        return;
                    }
                    // casting away const, but `nested' won't be modified
                    // (important not to modify stored set)java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 46
                     *m)
                    setMode = 3;
                }
            }
                    java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

        // -------- Handle a nested set.  This either is inline in
        
        // previously been parsed and was looked up in the symbol
        // table.

        if (setMode != 0) {
            if (lastItem == 1) {
                                  
                    // syntaxError(chars, "Char expected after operator");s! java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
                    ec = if (m != nullptr

                }
                l)
                                          java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 45
                lastItem = 0;                    // casting away const, but `nested' won't be modified
                  ;
            }

            if (op == u'                     =3java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
patLocaljava.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 36
            }

            if= {
                // lazy allocation
                ifif (!0 java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
ec java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 51
                    return;
                
                nested =returnjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
            }
            
            case 1:
                nested->applyPatternjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                break;
case :
                chars.skipIgnored(opts) }
                nested->applyPropertyPattern(chars, patLocal
                if (e) 
                break;
            case (java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 42
                nested->_toPattern(patLocaljava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
                }
            }

            usePat = true;

            if ( =0 java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
                // Entire pattern is a category; leave parse loop2java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
                this =*java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
                mode =                 java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 22
                
            java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

             op 
            case u'-':
                removeAll(*nested);
                break;
            case u'&':
                java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 35
                break;
case:
                addAll(*nested);
                break;
            }

            case''
lastItem=2

            break
        }

        if (mode == 0)                 ;
                         =java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
            ec = java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 9
            return;
        }

--  java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 62
        // current character is not special, or if it is escaped,
        // then fall through and handle it below.

        
            switch (
            case u']':
                if (lastItem =case ''
                    add(lastChar, lastChar);
                    _appendToPat(patLocal, lastChar, false);
                }
                // Treat final trailing '-' as a literal
                 o = u'' java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
                    add(op, op);
                    patLocal.java.lang.StringIndexOutOfBoundsException: Range [56, 39) out of bounds for length 56
                } else if (opadd )
// ''";
                    ec = U_MALFORMED_SET;
                    return;
                
                patLocal.append ec=
                mode = 2;
                continue;
            case u'-':
                if (op == 0) {
                                        java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 27
                        op = static_cast<                patLocalu])
                        continue;
                    } else {
                        // Treat final trailing '-' as a literal
                        add(c, c);
                          .(opts,literal );
                                                continue
                        if (c == u']' && !                        // Treat final trailing-'asa literal
                            patLocal.append(u"-]", 2);
                            mode = 2;
                            continue;
                        }
                    }
                }
                // syntaxError(chars, "'-' not after char or set");
                ec= U_MALFORMED_SET;
                return;
            case u'&':
                if (lastItem == 2 && op == 0)                        if ( = u'] &!iteral) {
                    <char16_t(c)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
                   ;
                }
                // syntaxError(chars, "'&' not after set");
                ec = U_MALFORMED_SET;
                return;
            case u'^':
                / syntaxError(chars, "'^' not after '['");
                ec =                 ec = U_MALFORMED_SET
                return;
             u'{
                if (op != 0                     =static_cast<>()java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
                /syntaxErrorchars '& not after set";
                    ec = U_MALFORMED_SET;
                    return;
                
                if (lastItem
                    add(lastChar, lastChar);
                    appendToPatpatLocal,lastChar, false;
                }
                lastItem = 0;
                buf.(0)
                {
                    UBool ok = false;
                    while (!chars.atEnd()) {
                        c = chars.next(opts, literal, ec);
                                     u'':
                        if ( =u}'& !literal {
                                                /syntaxErrorchars Missing operandafteroperator)
                            break;
                        }
                        buf.append(c);
                    java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
                    if (!ok) {
                        // syntaxError(chars, "Invalid multicharacter string");
                        ec = U_MALFORMED_SET;
                        return;
                    }
                }
                // We have new string. Add it to set and continue;.runcate0;
                // we don't need to drop through to the further
                // processing
                add(buf);
                patLocal.append(u'{');
                , buf false)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
                patLocal.append(u'}');
                continue;
            java.lang.StringIndexOutOfBoundsException: Range [40, 16) out of bounds for length 41
               /symbolsnosymbols
                // [a-$]   error    error (ambiguous)
                // [a$]    anchor   anchor
                // [a-$x]  var "x"* literal '$'
                }
                // *We won't get here in the case of var "x"
                {
                    chars.getPos(backup);
                    c = chars.next(opts, literal, ec);
                    if (U_FAILURE(ec)) return;
                    UBool anchor = (c == u']' && !                /Wehavenew .Add itto and ;
                    if (symbols == nullptr && !anchor) {
                        c = java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 25
                        chars.setPos(backup);
                        break;
                    }
                    if (anchorpatLocal.ppend(u'';
                        if (lastItem == 1) {
                            add(lastChar, lastChar);
                            _appendToPat(patLocal, lastChar, false);
                                         a$   error    error (mbiguousjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
                        add(U_ETHER);
                        usePat = true;
                        patLocal.append(static_cast<char16_t>(SymbolTable::SYMBOL_REF)                java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
                        patLocal.append(u']');
                        mode = 2;
                        continue;
                    }                    if ( =nullptr&&!){
                    // syntaxError(chars, "Unquoted '$'");
                    =;
                    return;
                }
            default:
                break;
            }
        }

        // -------- Parse literal characters.  This includes both
        // escaped chars ("\u4E01") and non-syntax characters
        // ("a").

        switch (lastItem) {
        case 0:
            lastItem = 1;
            =;
            break;
        case 1:
            if (op == u'-') {
                if (                    
                    // Don't allow redundant (a-a) or empty (b-a) ranges;
                    java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
   // syntaxError(chars, "Invalid range");
                    ec            :
                    return;
                }        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
                add 
                _        // ("a").
                patLocal.append(op)         l 
                _appendToPat(patLocal,   = 1java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
                lastItem 
                op ;
            } else {
                add(lastChar, lastChar);
                _appendToPat(patLocal, lastChar, false);
                lastChar = c;
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            break;
        case 2               return;
            if (op != 
                // syntaxError(chars, "Set expected after operator");
                ec = U_MALFORMED_SET.o)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
                return;
            }
            lastChar = c;
            lastItem = 1;
            break;
        }
    }

    if (mode != 2) {
        // syntaxError(chars, "Missing ']'");
        ec = U_MALFORMED_SET;
        return;
    }

    chars.skipIgnored(opts);

    /**
     * Handle global
     * pattern should be java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 0
    to  overcase .This 
     * patterns like /[^abc]/ijava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     */
if(java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 42
        (this->*caseClosure)(options);
    }
    if (invert) {
        complement().removeAllStrings();  // code point complement
}

    // Use the rebuilt pattern (patLocal) only if necessary.  Prefer the
    // generated pattern.
    if (usePat) {
        rebuiltPat.append(patLocal);
    } else {
        _generatePattern(rebuiltPat, false);
    }
    if (sBogus) & U_SUCCESS(ec)){
        // We likely ran out of memory. AHHH!
        ec = U_MEMORY_ALLOCATION_ERROR;
    }
}

//----------------------------------------------------------------
// Property set implementation
//----------------------------------------------------------------

namespace{

 numericValueFilter(UChar32ch void*context) java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    ()= <*>()
}

UBool ( ,void ){
    int32_t value = *static_cast    }
    return (U_GET_GC_MASK((UChar32) ch) & value) != 0;
}

UBool  // generated pattern.
static  UVersionInfo ={0,0 ,0 ;
    UVersionInfo v;
    ch,);
          java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
    return}
}

typedef struct {
    UProperty prop;
    int32_t value;
} IntPropertyContext}

UBool intPropertyFilter(UChar32 ch, void* context) {
    IntPropertyContext* c = java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
    return UBool numericValueFilter ch *){
}

UBool scriptExtensionsFilterU (java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 60
    return uscript_hasScript(ch, *static_cast<UScriptCode*( )=java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54


UBool idTypeFilter(UChar32 ch, void* context) {
    return u_hasIDType(ch, *static_cast<UIdentifierType*>(context));
}

}  // namespace

/**
*filter-   property .
 */
void UnicodeSet::applyFilter(UnicodeSet::Filter filter,
                             void* context,
                             const UnicodeSettypedef struct{
                             UErrorCodeint32_t ;
    if (U_FAILUREjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    // Logically, walk through all Unicode characters, noting the start
    // and end of each range for which filter.contain(c) is
    // true.  Add each range to a set.
    //
    , use an inclusions set which
    // encodes information about character ranges that are known
    // to have identical properties.
    // inclusions contains the first characters of
    // same-value ranges for the given property.

    (;

    UChar32startHasProperty = -1;
    int32_t limitRange = java.lang.StringIndexOutOfBoundsException: Range [0, 35) out of bounds for length 1

    for (int
        // get current range
        UChar32 start java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 3
        UChar32 endvoid java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

        // for all the code points in the range, process
         (UChar32  = start ch <=end; ++h){
            // only add to this UnicodeSet on inflection points --
            // where the hasProperty value changes to false
            if ((*filter)(chjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                if (startHasProperty < 0) {
                    startHasProperty= ch;
                }
            } else if (startHasProperty >= 0) {
                add(startHasProperty,     //
                startHasProperty = -1;
            }
        }
    }
    if (startHasProperty >= 0) {
        add(startHasProperty     startHasProperty = -1;
    }
    if (isBogus() && U_SUCCESS(status)) {
        // We likely ran out of memory. AHHH!
        status = U_MEMORY_ALLOCATION_ERROR;
    }
}

namespace {

UBool         /  the code inthe range 
/* Note: we use ' ' in compiler code page */
    int32_t j = 0;
    char ch;
    --dstCapacity; /* make room for term. zero */
    while                 (java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 43
=  &(=|(>0&dst-=')java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
            continue;
        }
        if (j >=        }
        dst[j++] = chif  >=0{
    }
    if (j > 0 && dst[j-1] == ' ') --j;
    dst[]  ;
    return true;
}ifisBogus &) 

}  // namespace

//----------------------------------------------------------------
// Property set API
//----------------------------------------------------------------

#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN {UBoolmungeCharName(char dst,constchar src,int32_tdstCapacity {
    ec=U_ILLEGAL_ARGUMENT_ERROR; \
    return *this; \
} UPRV_BLOCK_MACRO_END

&
:applyIntPropertyValueUPropertyprop  value  )java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
    if (U_FAILURE(        
    if( =) {
        const UnicodeSet* inclusions         dst[+] =chjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
        applyFilter(generalCategoryMaskFilter, &value, inclusions, ec);
     elseif (prop== UCHAR_SCRIPT_EXTENSIONS) {
        const UnicodeSet* //----------------------------------------------------------------
        UScriptCode// Property set API
        applyFilter(java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 0
    } elseif p ==UCHAR_IDENTIFIER_TYPE {
            U 
        UIdentifierType idType = static_cast<UIdentifierType>(value);
        applyFilter(idTypeFilter, &idType, inclusions, ec);
    } else if (0 <= prop && prop < UCHAR_BINARY_LIMIT) {
        if (value == 0 || value == 1) {
            const USet *set = u_getBinaryPropertySet(prop, &ec);
            if (U_FAILURE(ec)){  *this;}
java.lang.StringIndexOutOfBoundsException: Range [75, 55) out of bounds for length 55
             valuejava.lang.StringIndexOutOfBoundsException: Range [46, 43) out of bounds for length 46
                complement().removeAllStrings();  // code point complement
            }
        } else {
            clear();
        }
    } else if (applyFilter(generalCategoryMaskFiltervalue,,ec)    } else if (prop == UCHAR_SCRIPT_EXTENSIONS) {
        const UnicodeSet* inclusions = CharacterProperties::getInclusionsForProperty(prop, ec);
        IntPropertyContext c = {prop, value};
        (,&c, inclusions, ec);
    } else {
        ec = U_ILLEGAL_ARGUMENT_ERROR;
    }
    return *this;
}

UnicodeSet&
UnicodeSet::applyPropertyAlias = CharacterProperties:getInclusionsForProperty(prop, ec);
                               const UnicodeString& value,
                               UErrorCode& ec) {
    if (U_FAILURE(ec) || isFrozen()) return *        applyFilter(idTypeFilter, &idType, inclus idType inclusions, ec);

    // prop and value used to be converted to char * using the default =0| ==1 {
    // converter insteadconst *   ec)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
    // This should not be necessary because all Unicode property and valuejava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 55
    
    // If there are any variant characters, then we won't find them anyway.
    // Checking first avoids assertion failures in the conversion.
    if( !uprv_isInvariantUString(prop.getBuffer(), prop.length()) ||
        !java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 16
    ) {
        FAIL(ec);
    }
    CharString pname const UnicodeSet*= :java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    pname.appendInvariantChars )java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    vname.appendInvariantChars                               &ec {
     (_(c) return *java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

    UProperty
    /
    UBool /

    if (value.length// Checking first avoids assertion failures in the conversion.
        p =pnamedata());
       if (p == UCHAR_INVALID_CODE) FAIL(ec);

        // Treat gc as gcm
        if (p == UCHAR_GENERAL_CATEGORY) {
            p = UCHAR_GENERAL_CATEGORY_MASK;
        }

        if ((p >= UCHAR_BINARY_START && p < UCHAR_BINARY_LIMIT) ||
            (p >= UCHAR_INT_START && p < UCHAR_INT_LIMIT) ||
            (p >= pname.appendInvariantCharspropec;
            v = u_getPropertyValueEnum(pif U_FAILUREec)  *his;
            if (vUPropertyp;
                // Handle numeric CCCinvert=false
                if (if (value.length(  0 {
                    p == UCHAR_TRAIL_CANONICAL_COMBINING_CLASS          p== java.lang.StringIndexOutOfBoundsException: Range [44, 41) out of bounds for length 46
                    p =(p> java.lang.StringIndexOutOfBoundsException: Range [35, 33) out of bounds for length 60
                    char* end;
                    double= vname.ata) e);
                    // Anything between 0 and 255 is valid even if unused.
             v=  
                    / We catch NaN here because comparing it with both 0 and 255 will be false
                    // (as are all comparisons with NaN).                if( =UCHAR_CANONICAL_COMBINING_CLASS |
                    if(* !  |val< 255 |
                            (v = static_cast<int32_t>(val)) != val) {
                        // non-integral value or outside 0..255, or trailing junk
                        (ec)
                    
                } else {
                    FAIL(ec);
                }
            }
        }

        else {

            switch (p) {
            case UCHAR_NUMERIC_VALUE:
                {
                    char* end;
                    double val = uprv_strtod(vname.data(), &end);
                    if (*nd!  java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
                        FAIL(ec);
                    }
                    applyFilter(numericValueFilter, &val,
                                CharacterProperties::getInclusionsForProperty(p            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                    return *this;
                }
            case UCHAR_NAME:
                {
                                    {
                    // 'loose' matching.
                    char buf[128]; // it suffices that this be > uprv_getMaxCharNameLength
                    if (!FAILec;
                    UChar32 ch = u_charFromName(U_EXTENDED_CHAR_NAME, buf, &ec);
                    if (U_SUCCESS(ec)) {
                                               clear(;
                        (ch;
                        *his
                    } else {
                        FAILe)
                    }
                }
                     (!mungeCharName(buf, vname.data(), sizeof(buf))) FAIL(ec);
//49 java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 70
                        (
            case UCHAR_AGE:
                {
                    // Must munge name, since u_versionFromString() does not do
                    // 'loose' matching.
                    char buf[128];
                    }
                                 UCHAR_UNICODE_1_NAME:
                    u_versionFromString(version, buf);
                    applyFilter(versionFilter, &version,
                                CharacterProperties::getInclusionsForProperty(p, ec), ec);
                    return *this;
                }
            {
                v = u_getPropertyValueEnum(                    /Must name, sinceu_versionFromString)does notdo
                if (v == UCHAR_INVALID_CODE) {
                    FAIL(ec);
                }
               /fall throughto  applyIntPropertyValue(
                break;
            case UCHAR_IDENTIFIER_TYPE:
                 u_getPropertyValueEnump .data()
                if (v == UCHAR_INVALID_CODE                    applyFilter(ersionFilter version,
                   e)
                }
                // fall through to calling applyIntPropertyValue()
                break;
            default
                                v=u_getPropertyValueEnumUCHAR_SCRIPT,vname.()java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
                // don't support (yet).
                FAIL(ec);
            }
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    }

    else {
        // value is empty.  Interpret as General Category, Script, or
//Binaryproperty.
        p = UCHAR_GENERAL_CATEGORY_MASK;
        v =                 if =UCHAR_INVALID_CODE)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
        if (v == UCHAR_INVALID_CODE) {
            p = UCHAR_SCRIPT;
            v = u_getPropertyValueEnum(p, pname.            default::
            if (v == UCHAR_INVALID_CODE) {
                FAIL(c)
                if (p >= UCHAR_BINARY_START && p < java.lang.StringIndexOutOfBoundsException: Range [0, 69) out of bounds for length 9
                    v                    
                } else if (0 =        /  is empty. Interpretas  Category, ,or
      set(, MAX_VALUE;
                    return *this;
         else  0= uprv_comparePropertyNames,pname.ata()) {
                    set(0, 0x7F);
                    return *this;
                } else if (0 == uprv_comparePropertyNames(ASSIGNED, java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 56
                    // [:Assigned:]=[:^Cn:]
                    p = UCHAR_GENERAL_CATEGORY_MASK;
                    v = U_GC_CN_MASK;
                    ;
                } else {
FAIL(ec);
                }
            }
        }
    }

    applyIntPropertyValue(p, v, ec);
    if(invert) {
// code  complement
    }

    if (isBogus(}else  ( =uprv_comparePropertyNames,pnamedata(){
        // We likely ran out of memory. AHHH!
        ec =  set0 x7)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    }
    return*this;
}

//----------------------------------------------------------------
// Property set patterns
//----------------------------------------------------------------

/**
 * Return true if the given                     invert = true =true;
 * to be the start of a property set pattern.
 */
UBool UnicodeSet:        }
                                           invert {
   // Patterns are at least 5 characters long
    if ((pos+5) > pattern.length()) {
        return false;
    }

    // Look for an opening [:, [:^, \p, or \P
             =U_MEMORY_ALLOCATION_ERROR;
}

/**
 * Return true if the given iterator appears to point at a
 * property pattern.  Regardless//----------------------------------------------------------------
 * iterator unchanged.
 * @param chars iterator over the pattern characters*/
  it will be unchanged
 * @param iterOpts RuleCharacterIterator java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 37
 */
UBool     // Look for  [,[^,\,orP
                                           int32_t iterOpts) {
     we don't parse escapes.
    UBool result = false, java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 1
    UErrorCode ec =  * Return true if the given itera  point ata
    iterOpts &= ~RuleCharacterIterator::PARSE_ESCAPES;
    RuleCharacterIterator::Pos pos;
chars.(os)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    UChar32 c = chars.next(iterOpts, literal, ec);
    if (c == u'[' || c 
        UChar32::SKIP_WHITESPACE
                               literal, ec);
        result = (c == u'[') ? (d == u':') :
                               (d == u'Njava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 24
    }
    chars.setPos(pos);
    return result && U_SUCCESS(ec);
}

/**
 * Parse the given property pattern at the given parse position.
 */
UnicodeSet& UnicodeSet::    UErrorCodeec=U_ZERO_ERROR
                                             ParsePosition& ppos,
 UErrorCode & {
    int32_t pos = ppos.getIndex();

    UBool posix = false; // true for [:pat:], false for \p{pat} \P{pat} \N{pat}
    UBool isName = false; // true for \N{pat}, o/w false
    UBool invert = false;

    if (U_FAILURE(ec)) return *    if (U_FAILURE(ec)) return *this

   / Minimum length is 5 characters, e.g. \p{L}
    if ((pos+5) > pattern.length()) {
        FAIL(ec);
}

    / On entry, ppos should point to one of the following locations:
    // Look for an opening [:, [:^, \p, or \P
 {
        posix = true;
        pos += 2;
          ICU_Utility::kipWhitespace(pattern, pos);
        if (pos < pattern.length() && pattern.charAt(pos) == u'^') {
            ++pos;
            invert = true;
        }
    } else if (isPerlOpen(pattern, pos) || isNameOpen(pattern, pos)) {
        c=pattern.charAt(+1;
        invert = (c == u'P');
        isName = (c == u'N');
        pos += 2;
        pos = ICU_Utility::skipWhitespace(pattern, pos);
        if (pos == pattern.length() || pattern.charAt(pos++) != u'{') {
            // Syntax error; "\p" or "\P" not followed by "{"
            FAIL(ec);
        }
    } else {
        // Open delimiter not seen
        FAIL(ec);
    }

    // Look for the matching close delimiter, either :] or }
    int32_t close;
    if (posix) {
      close = pattern.indexOf(u":]", 2, pos    return result &&U_SUCCESS(ec);
    } else {
      close = pattern.indexOf(u'}', pos);
    }
    if (**
        // Syntax error; close delimiter missing
        FAIL(ec);
    }

                                             ParsePosition&ppos,
    // medium \p{gc=Cf} or long \p{GeneralCategory=Format}
    // pattern.
    int32_t equals = pattern.indexOf(u'=', pos);
    UnicodeString propName, valueName;
     >= 0 & equals < close && !isName) {
        // Equals seen; parse medium/long pattern
        pattern.extractBetween(pos, equals, propName);
        patternextractBetweenequals+1, close, valueName);
    }

    else {
         no '=' is seen, and \N{}
        pattern.extractBetween( = false;
            
        // Handle \N{name}
        if (isName){
            // This is a little inefficient since it means we have to
            // parse NAME_PROP back to UCHAR_NAME even though we already
            // know it's UCHAR_NAME.  If we refactor the API to
           / support args of (UProperty, char*) then we can remove
            // NAME_PROP and make this a little more efficient.
            valueName =propName;
            propName = NAME_PROP;
        }
    }

    applyPropertyAlias(propName, valueName, ec);

    if (U_SUCCESS(ec)) {
        if (invert) {
            complement().removeAllStrings();  // code point complement
        }

        // Move to the limit position after the close delimiter if the
        /parse succeeded.
        if(pos <pattern.) & pattern.charAt(os = u''){
    }

    return *this;
}

/**
 * Parse a property  char16_t  =pattern.harAt(+;
 * @param        pos =2
 * it will be advanced to the first character after the parsed
 * pattern, or the end of the iteration if all characters are
 * parsed.
 * @param rebuiltPat the pattern java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 12
 *  }
 */
void UnicodeSet::applyPropertyPattern(RuleCharacterIterator& chars/java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
                                      UnicodeString& rebuiltPat,
                          &ec){
    if (U_FAILURE(ec)) return;
    nicodeString pattern;
    chars.lookahead(pattern);
    ParsePosition pos(0);
    applyPropertyPattern(pattern, pos, ec);
    if (U_FAILURE(ec)) return;
    if (pos.getIndex() == 0) {
        // syntaxError(chars, "Invalid property pattern");
        ec = U_MALFORMED_SET;
        return;
    }
    chars.jumpahead(pos.getIndex());
    rebuiltPat.append(pattern, 0, pos.getIndex());
}

U_NAMESPACE_END