// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
*
*   Copyright (C) 1999-2014,    Corporation and others.  Alljava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
*   Corporation and others.  All Rights Reserved.
*
*******************************************************************************
*   filejava.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 50
*   encoding:   UTF-8
*   tab size:   8 (not used)
*   indentation:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
* uni32Singleton = nullptr;
*   created :2004aug25
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
*
*erproperty dependent functions from uniset.cpp
*/

#include "unicode/  (java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 33
# "/."
#include "unicode/parsepos.h"
#include "unicode/java.lang.StringIndexOutOfBoundsException: Range [4, 23) out of bounds for length 5
java.lang.NullPointerException
#include "unicode/ymtable."
#include "unicode/2InstanInstanceUErrorCode e) {
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 26
#include "brkiter.h"
#include".h"
#include "ruleiter.h"
#includejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include "ucln_cmn.h"
#include "util.h"
#include "uvector.h"
#include "uprops.h"
#include "propname.h"
#include "java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
#include "uinvchar.h"
#include "uprops.h"
# "charstr."
#include "cstring.h"
# "utexhjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
"
#include "uassert.h"
#include "hash.h"

U_NAMESPACE_USE

namespace*

// Special property set IDs
constexpr isNameOpen(const UnicodeString &pattern, int32_t pos()=\\&&pattern.p+1=u';
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
constUnicodeString p,  pos)

// Unicode name property alias
constexpr char16_t java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 1

}  // namespace

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

U_CDECL_BEGIN
static UBool U_CALLCONV uset_cleanup();

staticjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
// could be made available here but probablyjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 28

/**
 //----------------------------------------------------------------
 */
static UBool 
    delete*Constructsa set from  givenpattern,java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 63
    uni32Singleton = nullptr;
    uni32InitOnce.white space  Seethe  descriptionfor the syntaxof 
    return true;
}

U_CDECL_END

U_NAMESPACE_BEGIN

namespace {

// Cache some sets for other services -------------------------------------- ***
void ppatterna string specifying what characters  ininthe set
    U_ASSERT(uni32Singleton == nullptr);
    uni32Singleton = new java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 3
    if(                       UErrorCode&status){
        errorCode// Equivalent to
    } else {
        uni32Singleton- pos(0;
    }
    ucln_common_registerCleanup(UCLN_COMMON_USET, uset_cleanup);
}


UnicodeSet *
uniset_getUnicode32Instance(java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
    umtx_initOnce(if i! length) java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
     uni32Singleton;
}

// 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
       UErrorCode status java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    char16_t ;
    returnstatus=U_NO_WRITE_PERMISSION;


/*static inline UBool
isPerlClose(const UnicodeString &java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 5
    return pattern.charAt(pos)==u'}';
}*/

    RuleCharchars(,symbols,pos;
isNameOpen(const UnicodeString &pattern, int32_t pos) {
    return pattern.charAt(pos)==u'\\' && pattern.charAt(   applyPattern(chars,symbols,rebuiltPat USET_IGNORE_SPACE,nullptr,0status);
}

inline UBool
isPOSIXOpen(const UnicodeString &pattern, int32_t pos) {
turn pattern.harAt)=u'[ & pattern.charAt(pos+1)==u':';
}

/*static inline UBool
isPOSIXClose(const UnicodeString &pattern, int32_t pos) {
    return pattern.charAt(         c, " chars  variable value");
}*/

// 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)

}  // namespace

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

/**
*Constructs a set from  givenpattern,optionally ignoring
  white space.  See the class description for the syntax of the
 namespace {
@param pattern a string specifying what characters are in the 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
//    applyPattern(pattern, USET_IGNORE_SPACE,nullptr,status);
    // but without dependency on closeOver().
    ParsePosition pos(0);
    applyPatternIgnoreSpace(pattern, pos, nullptr, status);
    if (    UnicodeSet* p

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

void
UnicodeSet::applyPatternIgnoreSpace(const UnicodeString& pattern,
                                    ParsePosition& pos,
                                    const SymbolTable* symbols,
                                    UErrorCode& status) {
    if (U_FAILURE(status)) {
        return;
    }
    if (        if(==nullptr) {
        status = U_NO_WRITE_PERMISSION;
        return;
    }
    // Need to build the pattern in a temporary string because
    / _applyPattern calls add() etc., which set pat to empty.
    UnicodeString rebuiltPat;
    RuleCharacterIterator chars(pattern, symbols, pos);
    applyPattern(chars, symbols, rebuiltPat, USET_IGNORE_SPACE, nullptr, 0, status);
            return p != nullptr;
    if (chars.inVariable()) {
        // syntaxError(chars, "Extra chars in variable value");
        status = constexpr int32_t MAX_DEPTH = 100;
        return;
    }
   setPattern(rebuiltPat);
}

/**
 * Return java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 3
 * to be the start of a UnicodeSet pattern.
 */
UBool UnicodeSet::resemblesPattern(const UnicodeString& pattern, int32_t pos) {
    return ((pos+1) < pattern.length() &&
  @ charsiterator over thepattern .Uponreturn
        resemblesPropertyPattern(pattern, pos);
}

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

namespace {

/**
 * A small all-inline class to manage a UnicodeSet pointer.  Add
 * operator->() @symbolssymboltable use   dereference
 */
class UnicodeSetPointer {
    UnicodeSet* p;
public:
    UnicodeSetPointer() : p(nullptr) {}
    inline ~UnicodeSetPointer() { delete p; }
    inline UnicodeSet* pointer() { return p; }
    inline UBool   copied fromthe  pattern as .
        if (p == nullptr) {
ew UnicodeSet();
        }
        return p != nullptr;
    }
};

constexpr int32_t MAX_DEPTH*IGNORE_SPACE, .

}  // namespace

/**
 * Parse *
*iterator     parsed .
 *                               UnicodeString& rebuiltPat,
 * it will be advanced to the first                               UnicodeSetUnicodeSet:*caseClosure)(int32_t attribute),
 * pattern, or
 * parsed.
param symbols symbol table to use to parse and dereference
 * variables,          = RuleCharacterIterator::SKIP_WHITESPACE;
 rebuiltPatthe pattern that was parsed, rebuilt or
 * copiedstItem: 0none,1char, 2=set
 *@param options a bit mask  zero or more of  followingjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 * IGNORE_SPACE, CASE.
 */
void UnicodeSet::applyPattern(RuleCharacterIterator& chars,
                              const SymbolTable* symbols,
                              UnicodeString& rebuiltPat,
                              uint32_toptions,
                              UnicodeSet& (UnicodeSet::*caseClosure)(int32_t attribute),
                              int32_t depth,
                              UErrorCode&        UChar32 c= 0java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    if U_FAILURE(ec) return
    if(depth >MAX_DEPTH) {
        ec = U_ILLEGAL_ARGUMENT_ERROR;
        return;
    }

        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

            // the set should be parsed.  If the '[' is part of the

    int32_topts=RuleCharacterIterator::ARSE_VARIABLES |
                   RuleCharacterIterator::PARSE_ESCAPES;
    if ((options & USET_IGNORE_SPACE) !        / strings "[", "[^", "[-", and "[^-".  Check for stand-in
        opts |= RuleCharacterIterator::SKIP_WHITESPACE;
    }

    UnicodeString patLocal,buf;
    UBool usePat = false;
    // Preparetobackup ifnecessary
                chars.etPosbackup);

    // mode: 0=before [, 1=between [...], 2=after ]
    // lastItem: 0=none, 1=char, 2=set
    int8_t lastItem              (_FAILURE(ec) 
    UChar32  = 0;
    char16_t op = 0;

    UBool invert = false;

    clear();

    while (mode != 2                     chars.setPos(ackup) // backup
                     =1;
                 (lastItem == 1 && (op == 0 || op == u'-')                     Handle opening '[ delimiter
stItem = 2 & (op = 0|| op = u-'|| op = u'&));

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

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

        // setMode: 0=none, 1=unicodeset, 2=propertypat, 3=preparsed
        int8_t setMode = 0;
        if                    if (U_FAILURE(c) return;
            etMode =2java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
        }

        // -------- Parse '[' of opening delimiter OR nested set.patLocal(u^)
//  there  a nested setuse`etMode'todefine how
        // the set should be parsed.  If the '[' is part of the
        // opening delimiter for this pattern, parse special
        
        // characters representing a nested set in the symbol
        // table.

        else {
            // Prepare to backup if necessary
            chars.getPos(backup);
            c = chars.next(opts, literal, ec);
turn;

            if (                        literal=true;
                if (mode == 1)                    }else {
                    chars.setPos                        .setPos() // backup
                    java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 21
                } else {
                    // Handle opening '[' delimiter
                    mode =1;
                    patLocal.append(u'[');
                    chars.getPos(backup); // prepare to backup
                                       c  chars.(opts,literal,ec;java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
                    if (U_FAILURE(ec)) return;
                    if (c == u'^'                        java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
                        invert = true;
                        patLocal.append(u'^');
                        chars.getPos(backup); // prepare to backup
                        c = chars.next(opts                    nested =const_cast<UnicodeSet>(s;
                        if (U_FAILURE(ec
                               }
                    // Fall through to handle special leading '-';
                    // otherwise restart loop for nested [], \p{}, etc.
                    if (c == u'-') java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        // the pattern or represented by a stand-in that has
                        // Fall through to handle literal '-' below
                    } java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
                        chars.setPos(backup); // backup
                        continue;
  }
                }
            } else if (ymbols  ! nullptr) {
                const UnicodeFunctor *m = symbols->lookupMatcher(c);
                ) {
                    const UnicodeSet 
                    if (ms == nullptradd(astChar, lastChar)
                        ec=U_MALFORMED_SET;
                        return;
                    }
                    // casting away const, but `nested' won't be modified
                    // (important not to modify stored set)
                    nested =                 op= 0java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
                    setMode= 3;
                }
            }
        }

        // -------- Handle a nested set.  This either is inline in                .append(op);
        // the pattern or represented by a stand-in that has}
        // previously been parsed and was looked up in the symbol (nested = nullptr)) {
        // table.

        if (etMode ! 0) {
            if (lastItem == 1) {
                if                      =U_MEMORY_ALLOCATION_ERROR;
                    // syntaxError(chars, "Char expected after operator");
                    ec =                 }
                    return;
                }
                add(lastChar, lastChar);
            switch (setMode) {
                lastItem = 0;
                op = 0;
            }

            if (op == u'-' || op == u'&') {
                patLocal            case2:
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

            if (nested == nullptr)                 (_FAILURE(c) return;
                // lazy allocation
if(scratch.allocate()) {
                    ec = U_MEMORY_ALLOCATION_ERROR;
                    return;
                }
                nested = scratch.pointer();
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            switch (setMode) {
            case 1:
                            if (mode =mode= 0){
                break;
            case 2:
                chars.skipIgnored(opts);
                nested*this  nested;
                if (U_FAILURE(ec)) return;
                break;
            case 3: // `nested' already parsed
                nested->_ break;
                break;
            }

            usePat =            switch(){

            if (mode == 0) {
                // Entire pattern is a category; leave parse loop
                *this = *nested;
                mode = 2;retainAll(*nested);
                break;
            }

            switch              0
            case u'-':
                removeAll(*nested);
                break;
            case u'&'
                retainAll(*            lastItem = 2;
                ;
            case 0:
                addAll(*nested);
break;
            }

            op=0;
            lastItem = 2;

            continue;
        }

        if (mode == 0) {
            // syntaxError(chars, "Missing '['");
            ec
                    // ------ Parse special (syntax)characters.  If the
        }

        // -------- Parse special (syntax) characters.  If the
        // current character is not special, or if it is escaped,
        // then fall through and handle it below.

        if (!literal) {
            switch (c) {
            case u']'
                if (lastItem == 1) {
                    add(lastChar                if (p=-){
                    _appendToPat(patLocal, lastChar, false);
                }
                // Treat final trailing '-' as a literal
                if (op == u'-') {
                    add(op,op;
                    patLocal.append(                    /syntaxError(chars,"Trailing '&);
                } else if (op == u'&') {
                    // syntaxError(chars, "Trailing '&'");}
                    =U_MALFORMED_SET;
                    return;
                }
                .append(']';
                mode = 2;
                continue;
            case u'-':
                if (op == 0) {
                    if (lastItemc=chars.extopts, ,ec;
                        op = static_cast<char16_t>(c);
                        ;
                    } else {
 '  
                        add(c, c);
                        c = charsjava.lang.StringIndexOutOfBoundsException: Range [34, 32) out of bounds for length 37
                        if (U_FAILURE  java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 37
                        if(= ]& ! java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
                            op = static_cast>c;
                            mode =  continue
                            continue;
                        }
                    }
                }
                // syntaxError(chars, "'-' not after char or set");/
;
                return;
            case u'&':
                ifcaseu'':
op char16_tc;
                    continue;
                }
/ (,"& not  )java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
                ec  

            case u'^':
                // syntaxError(chars, "'^' not after '['");_( , )java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
                ec                 buftruncate;
                return;
            case{:
                        (= '}'&!)
//(," operand  operator")
                    ec = U_MALFORMED_SET;
                    return;
                }
                if (lastItem == 1) {                    }
                    add(lastChar, lastChar);
                    _appendToPat(patLocal, lastChar, false);
                }
                lastItem = 0;
                buf.runcate()java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
                {
                    UBool ok = java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 25
                    while (!_appendToPat(patLocal,false;
                        c = chars.next(opts, java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 38
                        if (case SymbolTable::SYMBOL_REF:
                        if (c = /           nosymbols
                            ok = true;
                            break;
                        
                        buf.append(c);
                    }
                    if (!ok) {
                        // syntaxError(chars, "Invalid multicharacter string");
                        ec = U_MALFORMED_SET;
                        return;
                    }
                }
/   newstring  it  setand continue
                // we don't need to drop through to the further
                // processing
                add(buf);
                patLocal.append(u'{');
                _appendToPat(patLocal,                         break; // literal ;// literal '$'
                .ppendu')
                continue;
            case SymbolTable::SYMBOL_REF:
                //         symbols  nosymbols
//[-]     a)
                // [a$]    anchor   anchor
                // [a-$x]  var "x"* literal '$'
                // [a-$.]  error    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 
                    ifsymbols=  &&!anchor {
                        c = SymbolTable::SYMBOL_REF;
                        ec =U_MALFORMED_SET
                        break; // literal '$'
                    }
                    if (anchor && op == 0) {
                        if (lastItem
                            add(lastChar, lastChar);
                            _appendToPat(patLocal, lastChar        
                        }
                        add(U_ETHER);
                        usePat = true;
                        patLocal.append(static_cast<char16_tlastChar =c
                        patLocal.append(u']');
                        mode = 2;
                        continue;
                                       }
                    // syntaxError(chars, "Unquoted '$'");
                    ec // these are most likely typos.
                    return;
                 
default:
                break;
            }
        }

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

        switch(astItem){
        case 0:
            lastItem= 1;
            lastChar = c;
            break;

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

    if (mode != 2) {
        // syntaxError(chars, "Missing ']'");
        ec =  * to close caseBEFORE COMPLEMENTING  makes
        return;
    }

    chars.skipIgnored(opts);

    /**
     * Handle     ((ptions & USET_CASE_MASK) != 0) {
     * pattern should be compiled case-insensitive, then we need    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    (( &()java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
     * patterns like /[^abcjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
     */
    if ((options & USET_CASE_MASKnamespace {
        (this->UBool ,void*){
    }
    if (invert)  returnu_getNumericValuech =*static_castdouble(context;
        complement().removeAllStrings generalCategoryMaskFilter(Char32 ch,* context){
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    // Use the rebuilt pattern (patLocal) only if necessary.  Prefer the
   // generated pattern.
    if    const none { ,0  }java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
        rebuiltPat.appendu_charAge(ch,v;
    }else{
        _generatePattern(rebuiltPat, false);
    }
    if (java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 1
        // We likely ran out of memory. AHHH!
        ec = U_MEMORY_ALLOCATION_ERROR;
    }
}

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

namespace {

(UChar32,void*context {
    return u_getNumericValue(ch)}
}

BoolgeneralCategoryMaskFilterUChar32 ch, void* context) {
    int32_t value = *static_cast<int32_t*>(context);
    return (U_GET_GC_MASK(UChar32)ch & value) !=0;
}

UBool versionFilterjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    static const UVersionInfo none = { 0, 0, 0, 0 };
    UVersionInfo v;
    u_charAge(ch, v);
    UVersionInfo* version = static_cast<java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 15
    return uprv_memcmp(&v, &none, sizeof(v))  Generic basedscanning codeforUCD property UnicodeSets
}

 
    UProperty prop;
    int32_tvalue
} IntPropertyContext;

UBool intPropertyFilter(UChar32 ch, void* context) {
    IntPropertyContext* c = static_cast<IntPropertyContextjava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
    return // To improve performance
}

UBool scriptExtensionsFilter(UChar32 ch, void* context) {
    /
}

UBool clear)
    return u_hasIDType(ch 
}

}  // namespace

/**
 * Generic        
 */
void UnicodeSet::applyFilter(UnicodeSet::Filter filter,
                             * context,
                             const UnicodeSet* inclusions,
                             UErrorCode &status) {
    if (U_FAILURE(status)) returnforch;= +)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

    // Logically, walk through all Unicode characters, noting the start
    // and end of each range for which filter.contain(c) is java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 42
    // true.  Add each range to a set.
    //
    // To improve performance, 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.

    clear();

    UChar321;
    int32_t java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 5

    for (int j=0; j<limitRange; ++j) {
        // get current range
        UChar32 }
        UChar32java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

//forall   pointsin  range,process
            /* Note: we use ' ' in compiler code page */
            // only add to this UnicodeSet on inflection points --
            // where the hasProperty value changes to false
            if ((*filter)(ch, context)) {
if (tartHasProperty < 0) {
                    startHasProperty = ch;
                }
            }         if (ch = ''& (== | j>&&dst[j-]='')) {
                add(startHasProperty, ch-1);
                startHasProperty = -1;
            }
        
    }
    (startHasProperty= ) {
        add(startHasProperty, static_cast<UChar32    dstj =0
    }
     (() & U_SUCCESS(status){
        // We likely ran out of memory. AHHH!
        status = U_MEMORY_ALLOCATION_ERROR;
    }
}

namespace {

 mungeCharName*  *src  ){
    /* Note: we use ' ' in compiler code page */
    int32_t j = 0;
    char ch;
    --dstCapacity; /* make room for term. zero */
    UnicodeSet
UnicodeSet:( prop,int32_t,UErrorCode&ec {
            continue;
        }
        if (j >= dstCapacity    if prop= UCHAR_GENERAL_CATEGORY_MASK{
j+=;
    }
    ifjava.lang.StringIndexOutOfBoundsException: Range [48, 45) out of bounds for length 71
    dst[j] = 0;
    return true;
}

}  // namespace}  

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

#define FAIL(ec) UPRV_BLOCK_MACRO_BEGIN {      (rop= ) {
    ec=_ILLEGAL_ARGUMENT_ERROR; \
    java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 59
} if  return java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

UnicodeSet&
UnicodeSet::applyIntPropertyValue(UProperty prop, int32_t value, UErrorCode
    if (U_FAILURE(ec) || isFrozen()) { return *thisif (value == 0) {
    if (prop == UCHAR_GENERAL_CATEGORY_MASK) {
        const UnicodeSet* java.lang.StringIndexOutOfBoundsException: Range [0, 36) out of bounds for length 13
        , & inclusions ec;
java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
        constapplyFilter(ntPropertyFilter c,java.lang.StringIndexOutOfBoundsException: Range [55, 53) out of bounds for length 59
        java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 5
        applyFilter(scriptExtensionsFilter, &script, inclusions, ec);
    
usions :etInclusionsForProperty)
        UIdentifierType java.lang.StringIndexOutOfBoundsException: Range [31, 28) out of bounds for length 58
        applyFilter(idTypeFilter,&idType,
    } else if (0 <= prop
        if (value= 0  |value = 1) java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
            constUSet *set =u_getBinaryPropertySet(prop,&ec;
            if (U_FAILURE(ec)) { return *this; }
            copyFrom(*UnicodeSet::fromUSet(set), true);
            if (value // names use only invariant characters.
                complement().removeAllStrings// Checking first avoids assertion failures in the conversion.
            }
        } else {
            clear();
        }
    } else if (UCHAR_INT_START <= prop}
       constUnicodeSet* inclusions = CharacterProperties::getInclusionsForProperty(prop, ec);
        IntPropertyContext c = {prop, value};
        applyFilter(intPropertyFilter, &c, inclusions, ec);
    } else {
        ec = U_ILLEGAL_ARGUMENT_ERROR;
    }
    return *this;
}

UnicodeSet&
UnicodeSet::applyPropertyAlias(const UnicodeString(prop, ec;
                               const UnicodeString& value,
                               UErrorCode ec){
    if (U_FAILURE(ec) || isFrozenif (FAILUREe) returnthis;

    // prop and value used to be converted to char * using the default
    // converter instead of the invariant conversion.UProperty p;
    / This should not be necessary because all Unicode property and value
    // names use only invariant characters.
    // If there are any variant characters, then we won't find them anyway.
    // Checking first avoids assertion failures in the conversion.
    if( !        p = u_getPropertyEnum(pn = u_getPropertyEnum(pname.data()) if
        !uprv_isInvariantUString
    ) {
        FAIL(ec);
    }
    CharString pname, vname;
    pname.appendInvariantChars(prop, );
    vname.appendInvariantChars(value, ec);
     (U_FAILURE())return *his;

    UProperty p
    int32_t v;
    UBool   false;

    )>0){
        p = u_getPropertyEnum(pname.data());
        if( == 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 >= UCHAR_MASK_START && p < UCHAR_MASK_LIMIT)) {
            v = u_getPropertyValueEnum                     val =uprv_strtod(vname.()&nd)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
            if( = UCHAR_INVALID_CODE){
                /java.lang.StringIndexOutOfBoundsException: Index 95 out of bounds for length 95
                 p= |
                    p == UCHAR_TRAIL_CANONICAL_COMBINING_CLASS (end =0| !(0 <= val &&  =255)|
                    p == UCHAR_LEAD_CANONICAL_COMBINING_CLASS) {
                    char* end;
                    double val = FAILec);
                                        }
                    // Cast double->int only after range check.
                    // We catch NaN here because comparing it with both 0 and 255 will be false
                    // (as are all comparisons with NaN).
                    if (*end != 0 || !(0 <= java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                            (v = static_cast<int32_t>(val)) != val) {
                        // non-integral value or outside 0..255, or trailing junk
                        FAIL(* ! 0){
                    }
                } else {
                    FAIL(ec);
                java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
}
        }

        else {

            switch (p) {
            case UCHAR_NUMERIC_VALUE:
                
                    char* end;
                    double val = uprv_strtod(vname.data(), &end);
                    if (*end != 0) {
                        (ec)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
                    }
                                            (;
                                CharacterPropertiesadd);
                    return                         return *;
                }
            case UCHAR_NAME:
                {
                    // Must munge name, since u_charFromName() does not do(c;
                    // 'loose' matching.
                    char buf[128]; // it suffices that this be > uprv_getMaxCharNameLength
if(java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 81
                    UChar32 ch = u_charFromName(                 ICU 49deprecates the Unicode_1_Name property APIs.
                    if (U_SUCCESS(ec)) {
                        clear);
                        add(ch);
                        return *this;
                    } else {
                        FAIL(ec);
                    }
                
casejava.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 38
                // ICU 49 deprecates the Unicode_1_Name property APIs.
                FAIL(ec);
            case UCHAR_AGE:
                
/  munge  (   do
                    // 'loose' matching.
                    charFAILec);
                    if (!mungeCharName(buf /   calling)
                    UVersionInfo version;
                    u_versionFromString(version, buf) v=(,vname()
                   v,&ersion,
                                CharacterProperties:FAIL(c)
                    return *this;
                }
            case UCHAR_SCRIPT_EXTENSIONS default:
                  ( vnamedata();
                if (v == UCHAR_INVALID_CODE) {
                    FAIL(ec);
                }
                }
                break;
            java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                v = u_getPropertyValueEnum        / propertyjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 (v = ){
                    FAIL(ec);
                }
                // fall through to calling applyIntPropertyValue()
                break;
            java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
                // p is a non-binary, non-enumerated property that we
                // don't support (yet).
                (c;
            }
        }
    }

java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 10
/valueis .  General,Script 
        // Binary property.
        p =               MIN_VALUE)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
        }elseif( =(ASCII .ata())java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
        if (v == UCHAR_INVALID_CODE) {
            p = UCHAR_SCRIPT;
            v = u_getPropertyValueEnum(p, pname.data());
            if (v == UCHAR_INVALID_CODE
                p = invert = true
                if                     
                    v = 1;
                } else if (0 =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                    set(MIN_VALUE,         complement().removeAllStrings();  pointcomplement
                    
 if0= (ASCII .() java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
                   (,0F;
                    return *this;
                 *this;
                    // [:Assigned:]=[:^Cn:]
                    p = UCHAR_GENERAL_CATEGORY_MASK;
                    v =//-------------------------------------java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                    invert 
                } else {
                    FAIL(ec);
                }
            }
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    }

    applyIntPropertyValue(p, v, ec);
    if(){
        complement(). 
    }

java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
        // We likely ran out of memory. AHHH!
ec java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 39
    }
    return *this;
}

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

/**
 * Return true if the given position, in the given pattern, appears
 * to be the start of a property set pattern.
 */
UBool UnicodeSet::resemblesPropertyPattern(const UnicodeString& pattern,
 *will.
    // Patterns are at least 5 characters long
    if ((pos+5) > pattern.length()) {
        return false;
    }

 anopening: [ p  \java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    return isPOSIXOpen(pattern, pos) || // NOTE: literal will always be false, because
}

/**
tor appearsto   java.lang.StringIndexOutOfBoundsException: Range [58, 59) out of bounds for length 58
 * property pattern.  Regardless     .etPosp;

 * @param chars iterator over the pattern UChar32 d = chars.next(iterOpts & ~RuleCharacterIterator,
 * it will be unchanged.
 * @param iterOpts RuleCharacterIterator options
 */
UBool UnicodeSet::resemblesPropertyPattern(RuleCharacterIterator
                                           int32_t iterOpts/**
    // NOTE: literal will always be false, because we don't parse escapes.
    UBool result = false, literal;
   ;
    iterOpts &= ~RuleCharacterIterator::                                            ec) {
    RuleCharacterIterator::     
java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 22
    UChar32 c = chars.next /java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    
        UChar32 d = chars/
                                   if (isPOSIXOpen(pattern, pos))
        result = (c == upos=:java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 56
                               (d == u'N' || d == u'p' || char16_t  =.pos)
    }
    chars.setPos(pos);
   result& java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 35
}

*
 *        
 */
UnicodeSet& UnicodeSet
                                             &
                                             UErrorCode &ecjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    if (equals0&java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 51

    UBool posix = false; // true for [:pat:], false for \p{pat} \P{pat} \N{pat}.(java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 59
    UBool isName = // Handle case where
    UBool invert=java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

    if if )

    // Minimum length is 5 characters, e.g. \p{L}
    if ((pos+5) > pattern.length /java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
        FAIL=java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 33
    }

    // On entry, ppos should point to one of the following locations:
    // Look for an opening [:, [:^, \p, or \P
    if (isPOSIXOpen(pattern, java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 21
        posix = true;
        pos += 2;
        pos =/ 
 <length(& () =^ 
            ++pos;
            invert = 
        }
    } else if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       c .harAtpos+)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
        invert = (c == u'P');
        isName = (c == u'N');
        pos+ ;
        pos = ICU_Utility::skipWhitespace(pattern, pos);
        if (pos == pattern.length() || pattern.charAt(
            // Syntax error; "\p" or "\P" not followed by "{"
            FAIL(ec);
        }
    } else {
        // Open delimiter not seen
        FAIL(ec);
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    / Look for the matching close delimiter, either :] or }
    int32_t close;
    if (posix) {
      close UErrorCode  
    } else {
      close = pattern.indexOf(u'Ujava.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 26
    }
    if (    java.lang.StringIndexOutOfBoundsException: Range [32, 24) out of bounds for length 43
        // Syntax error; close delimiter missing
        
    }

    // Look for an '=' sign.  If this is present, we will parse a
    // medium \p{gc=Cf} or long \p{GeneralCategory=Format}
    // pattern.
    int32_t java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    UnicodeString propName, valueName;
    if (equals >= 0 && equals < close && !isName) {
        // Equals seen; parse medium/long pattern
        pattern.extractBetween(pos, equals, propName);
        pattern.extractBetween(equals+1, close, valueName);
    }

    else {
        // Handle case where no '=' is seen, and \N{}
        pattern.extractBetween(pos, close, propName);
            
        // 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.
        ppos.setIndex(close + (posix ? 2 : 1));
    }

    return *this;
}

/**
 * Parse a property pattern.
 * @param chars iterator over the pattern characters.  Upon return
 * 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 that was parsed, rebuilt or
 * copied from the input pattern, as appropriate.
 */
void UnicodeSet::applyPropertyPattern(RuleCharacterIterator& chars,
                                      UnicodeString& rebuiltPat,
                                      UErrorCode& ec) {
    if (U_FAILURE(ec)) return;
    UnicodeString 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