RegexKitLite：Objective-C版Mac OS X轻松使用ICU正则表达式

需积分: 3 20 浏览量更新于2024-07-26 收藏 1.11MB PDF 举报

RegexKitLite 是一款专为 MacOS X 开发的轻量级 Objective-C 库，旨在简化正则表达式在 iOS 和其他平台上的使用。它通过集成 Apple 的 International Components for Unicode (ICU) 动态链接库，提供了一个易于使用的接口，使得开发者能够方便地在 NSString 类中应用正则表达式功能，从而提高代码的灵活性和效率。该库的主要作用是桥接 NSString 类与 ICU 库中的正则引擎，这使得原本在 ICU 中复杂的正则操作可以无缝地融入到标准的 iOS 开发环境中。RegexKitLite 提供了一整套便捷的方法和类，包括但不限于字符串搜索、替换、分割以及验证等功能，这些都是基于正则表达式的强大特性。版本 4.0 的发布日期为 2010 年 4 月 18 日，显示了其持续更新和支持的状态。RegexKitLite 的作者 John Engelhart 拥有版权，并声明所有权利，但同时也强调本文档遵循 Apple 文档风格，但并不意味着苹果对其有任何形式的认可、赞助或关联。在使用 RegexKitLite 时，需要注意的是，尽管它遵循 Apple 的文档规范，但它并非官方支持的一部分，因此在开发过程中可能存在兼容性问题或未来版本更新的不确定性。此外，尽管作者已经尽力确保文档内容的准确性，但不承担任何形式的明示或默示的担保，也不对任何错误、不准确或遗漏负责。对于法律责任，开发者在使用 RegexKitLite 时应自行评估风险，并理解可能涉及的偶然或间接损害责任问题。在利用该库进行开发时，建议查阅官方文档，了解其特性和使用限制，以确保应用的稳定性和合规性。 RegexKitLite 是 iOS 开发者一个强大的工具，它简化了正则表达式的操作，提升了代码的可读性和可维护性，但同时也需要开发者对其潜在的风险有所认识。

C 1

RegexKitLite Overview

See Also

ICU4C C API - Regular Expressions

ICU Regular Expression Syntax (p. 25)

UTF-16 Conversion Cache

RegexKitLite is ideal when the string being matched is a non-ASCII, Unicode string. is is because the

regular expression engine used, ICU, can only operate on UTF-16 encoded strings. Since Cocoa keeps es-

sentially all non-ASCII strings encoded in UTF-16 form internally, this means that RegexKitLite can operate

directly on the strings buﬀer without having to make a temporary copy and transcode the string in to ICU's

required format.

Like all object oriented programming, the internal representation of an objects information is private. How-

ever, the ICU regular expression engine requires that the text to be search be encoded as a UTF-16 string.

For pragmatic purposes, Core Foundation has several public functions that can provide direct access to the

buﬀer used to hold the contents of the string, but such direct access is only available if the private buﬀer is

already encoded in the requested direct access format. As a rough rule of thumb, 8-bit simple strings, such

as ASCII, are kept in their 8-bit format. Non 8-bit simple strings are stored as UTF-16 strings. Of course, this

is an implementation private detail, so this behavior should never be relied upon. It is mentioned because

of the tremendous impact on matching performance and eﬃciency it can have if a string must be converted

to UTF-16.

For strings in which direct access to the UTF-16 string is available, RegexKitLite uses that buﬀer. is is the

ideal case as no extra work needs to be performed, such as converting the string in to a UTF-16 string, and

allocating memory to hold the temporary conversion. Of course, direct access is not always available, and

occasionally the string to be searched will need to be converted in to a UTF-16 string.

RegexKitLite has two conversion cache types. Each conversion cache type contains four buﬀers each, and

buﬀers are re-used on a least recently used basis. If the selected cache type does not contain the con-

tents of the NSString that is currently being searched in any of its buﬀers, the least recently used buﬀer

is cleared and the current NSString takes it place. e rst conversion cache type is xed in size and

set by the C preprocessor dene RKL_FIXED_LENGTH, which defaults to 2048. Any string whose length is

less than RKL_FIXED_LENGTH will use the xed size conversion cache type. e second conversion cache

type, for strings whose length is longer than RKL_FIXED_LENGTH, will use a dynamically sized conversion

buﬀer. e memory allocation for the dynamically sized conversion buﬀer is resized for each conversion

with realloc() to the size needed to hold the entire contents of the UTF-16 converted string.

is strategy was chosen for its relative simplicity. Keeping track of dynamically created resources is re-

quired to prevent memory leaks. As designed, there are only four pointers to dynamically allocated memory:

the four pointers to hold the conversion contents of strings whose length is larger than RKL_FIXED_LENGTH.

However, since realloc() is used to manage those memory allocations, it becomes very diﬃcult to acciden-

tally leak the buﬀers. Having the xed sized buﬀers means that the memory allocation system isn't bothered

with many small requests, most of which are transient in nature to begin with. e current strategy tries to

strike the best balance between performance and simplicity.

Mutable Strings

When converted in to a UTF-16 string, the hash of the NSString is recorded, along with the pointer to the

NSString object and the strings length. In order for the RegexKitLite to use the cached conversion, all of

these parameters must be equal to their values of the NSString to be searched. If there is any diﬀerence,

the cached conversion is discarded and the current NSString, or NSMutableString as the case may be, is

reconverted in to a UTF-16 string.

UTF-16 Conversion Cache

C 1

RegexKitLite Overview

Caution:

Care must be taken when mutable strings are searched and there exists the possibility that

the string has mutated between searches. See NSString RegexKitLite Additions Reference

- Cached Information and Mutable Strings (p. 50) for more information.

Multithreading Safety

RegexKitLite is also multithreading safe. Access to the compiled regular expression cache and the conver-

sion cache is protected by a single OSSpinLock to ensure that only one thread has access at a time. e

lock remains held while the regular expression match is performed since the compiled regular expression

returned by the ICU library is not safe to use from multiple threads. Once the match has completed, the

lock is released, and another thread is free to lock the cache and perform a match.

Important:

While it is safe to use the same regular expression from any thread at any time, the usual

multithreading caveats apply. For example, it is not safe to mutate a NSMutableString

in one thread while performing a match on the mutating string in another.

If Blocks functionality is enabled, and a RegexKitLite method that takes a Block as one of its parameters is

used, RegexKitLite takes a slightly diﬀerent approach in order to support the asynchronous, and possibly

re-entrant, nature of Blocks.

First, an autoreleased Block helper proxy object is created and is used to keep track of any Block local re-

sources needed to perform a Block-based enumeration.

en the regular expression cache is checked exactly as before. Once a compiled regular expression is ob-

tained, the ICU function uregex_clone is used to create a Block local copy of the regular expression. After

the Block local copy has been made, the global compiled regular expression cache lock is unlocked.

If the string to be searched requires conversion to UTF-16, then a one time use Block local UTF-16 conversion

of the string is created.

ese changes mean that RegexKitLite Block-based enumeration methods are just as multithreading safe

and easy to use as non-Block-based enumeration methods, such as the ability to continue to use RegexKitLite

methods without any restrictions from within the Block used for enumeration.

64-bit Support

RegexKitLite is 64-bit clean. Internally, RegexKitLite uses Cocoas standard NSInteger and NSUInteger

types for representing integer values. e size of these types change between 32-bit and 64-bit automatically,

depending on the target architecture. ICU, on the other hand, uses a signed 32-bit int type for many of its

arguments, such as string oﬀset values. Because of this, the maximum length of a string that RegexKitLite

will accept is the maximum value that can be represented by a signed 32-bit integer, which is approximately

2 gigabytes. Strings that are longer this limit will raise NSRangeException. is limitation may be signicant

to those who are switching to 64-bit because the size of the data they need to process exceeds what can be

represented with 32-bits.

Note:

Several numeric constants throughout this document will have either L or UL appended to

them– for example 0UL, or 2L. is is to ensure that they are treated as 64-bit long or

unsigned long values, respectively, when targeting a 64-bit architecture.

Multithreading Safety

C 2

Using RegexKitLite

e goal of RegexKitLite is not to be a comprehensive Objective-C regular expression framework, but to

provide a set of easy to use primitives from which additional functionality can be created. To this end,

RegexKitLite provides the following two core primitives from which everything else is built:

◼ - (NSInteger)captureCountWithOptions:(RKLRegexOptions)options

error:(NSError **)error;

◼ - (NSRange)rangeOfRegex:(NSString *)regex options:(RKLRegexOptions)options

inRange:(NSRange)range capture:(NSInteger)capture error:(NSError **)error;

ere is often a need to create a new string of the characters that were matched by a regular expression.

RegexKitLite provides the following method which conveniently combines sending the receiver

substringWithRange: with the range returned by rangeOfRegex:.

◼ - (NSString *)stringByMatching:(NSString *)regex options:(RKLRegexOptions)options

inRange:(NSRange)range capture:(NSInteger)capture error:(NSError **)error;

RegexKitLite 2.0 adds the ability to split strings by dividing them with a regular expression, and

the ability to perform search and replace operations using common $n substitution syntax.

replaceOccurrencesOfRegex:withString: (p. 87) is used to modify the contents of NSMutableString

objects directly and stringByReplacingOccurrencesOfRegex:withString: (p. 93) will create a new, im-

mutable NSString from the receiver.

◼ - (NSArray *)componentsSeparatedByRegex:(NSString *)regex

options:(RKLRegexOptions)options range:(NSRange)range error:(NSError **)error;

◼ - (NSUInteger)replaceOccurrencesOfRegex:(NSString *)regex

options:(RKLRegexOptions)options withString:(NSString *)replacement

range:(NSRange)range error:(NSError **)error;

◼ - (NSString *)stringByReplacingOccurrencesOfRegex:(NSString *)regex

options:(RKLRegexOptions)options withString:(NSString *)replacement

range:(NSRange)range error:(NSError **)error;

RegexKitLite 3.0 adds several new methods that return a NSArray containing the aggregated results of a

number of individual regex operations.

◼ - (NSArray *)arrayOfCaptureComponentsMatchedByRegex:(NSString *)regex

options:(RKLRegexOptions)options range:(NSRange)range error:(NSError **)error;

◼ - (NSArray *)captureComponentsMatchedByRegex:(NSString *)regex

options:(RKLRegexOptions)options range:(NSRange)range error:(NSError **)error;

◼ - (NSArray *)componentsMatchedByRegex:(NSString *)regex range:(NSRange)range;

Using RegexKitLite

C 2

Using RegexKitLite

RegexKitLite 4.0 adds several new methods that take advantage of the new blocks language extension.

◼ - (BOOL)enumerateStringsMatchedByRegex:(NSString *)regex usingBlock:(void (^)(

NSInteger captureCount, NSString * const capturedStrings[captureCount],