Regexp Struct Reference

#include <Regexp.h>

Overview

Extended POSIX regular expressions.

Definition at line 43 of file Regexp.h.

Inheritance diagram for Regexp:

Properties
size_t	numberOfSubExpressions
	The number of parenthesized sub-expressions. More...
Object	object
	The superclass. More...
int	options
	A bitwise-or of REG_ICASE, REG_NEWLINE. More...
const char *	pattern
	The pattern. More...
ident	regex
	The backing regular expression. More...
Properties inherited from Object
Class *	clazz
	Every instance of Object begins with a pointer to its Class. More...

Methods
Class *	_Regexp (void)
	The Regexp archetype. More...
Regexp *	initWithPattern (Regexp *self, const char *pattern, int options)
	Initializes this regular expression. More...
_Bool	matchesCharacters (const Regexp *self, const char *chars, int options, Range **matches)
	Matches this regular expression against the given characters. More...
_Bool	matchesString (const Regexp *self, const String *string, int options, Range **matches)
	Matches this regular expression against the given String. More...
Methods inherited from Object
Class *	_Object (void)
	The Object archetype. More...
Object *	copy (const Object *self)
	Creates a shallow copy of this Object. More...
void	dealloc (Object *self)
	Frees all resources held by this Object. More...
String *	description (const Object *self)
int	hash (const Object *self)
Object *	init (Object *self)
	Initializes this Object. More...
_Bool	isEqual (const Object *self, const Object *other)
	Tests equality of the other Object. More...
_Bool	isKindOfClass (const Object *self, const Class *clazz)
	Tests for Class hierarchy membership. More...

Protected Attributes
RegexpInterface *	interface
	The interface. More...
Protected Attributes inherited from Object
ObjectInterface *	interface
	The interface. More...

Related Functions
OBJECTIVELY_EXPORT Regexp *	re (const char *pattern, int options)
	A convenience function for instantiating Regexps. More...

Property Details

interface

RegexpInterface* Regexp::interface

protected

The interface.

Definition at line 54 of file Regexp.h.

numberOfSubExpressions

size_t Regexp::numberOfSubExpressions

The number of parenthesized sub-expressions.

Definition at line 69 of file Regexp.h.

object

Object Regexp::object

The superclass.

Definition at line 48 of file Regexp.h.

options

int Regexp::options

A bitwise-or of REG_ICASE, REG_NEWLINE.

Definition at line 64 of file Regexp.h.

pattern

const char* Regexp::pattern

The pattern.

Definition at line 59 of file Regexp.h.

regex

ident Regexp::regex

The backing regular expression.

Definition at line 74 of file Regexp.h.

Method Details

_Regexp()

Class * _Regexp

(

void

)

The Regexp archetype.

Returns

The Regexp Class.

Definition at line 199 of file Regexp.c.

                     {
    static Class *clazz;
    static Once once;
 
    do_once(&once, {
        clazz = _initialize(&(const ClassDef) {
            .name = "Regexp",
            .superclass = _Object(),
            .instanceSize = sizeof(Regexp),
            .interfaceOffset = offsetof(Regexp, interface),
            .interfaceSize = sizeof(RegexpInterface),
            .initialize = initialize,
        });
    });
 
    return clazz;
}

initWithPattern()

Regexp * initWithPattern	(	Regexp *	self,
		const char *	pattern,
		int	options
	)

Initializes this regular expression.

Parameters

self	The Regexp.
pattern	The POSIX regular expression pattern.
options	A bitwise-or of REG_ICASE, REG_NEWLINE.

Returns

The initialized regular expression, or NULL on error.

Definition at line 112 of file Regexp.c.

                                                                               {
 
    self = (Regexp *) super(Object, self, init);
    if (self) {
        self->regex = calloc(1, sizeof(regex_t));
        assert(self->regex);
 
        const int err = regcomp(self->regex, pattern, REG_EXTENDED | options);
        assert(err == 0);
 
        self->pattern = pattern;
        self->options = options;
        self->numberOfSubExpressions = ((regex_t *) self->regex)->re_nsub;
    }
 
    return self;
}

matchesCharacters()

_Bool matchesCharacters	(	const Regexp *	self,
		const char *	chars,
		int	options,
		Range **	matches
	)

Matches this regular expression against the given characters.

Parameters

self	The Regexp.
chars	The characters to match.
options	A bitwise-or of REG_NOTBOL, REG_NOTEOL.
matches	An optional pointer to return matched sub-expressions.

Returns

true if this Regexp matched chars, false otherwise.

Remarks

If provided, matches will be dynamically allocated and contain numberOfSubExpressions + 1 Ranges. matches[0] will identify the Range of chars that matched the entire pattern. matches[1..n] will identify the Range of each corresponding sub-expression. The caller must free matches when done with it.

See also

regexec(3)

Definition at line 134 of file Regexp.c.

                                                                                                   {
 
    if (ranges) {
        const size_t numberOfMatches = self->numberOfSubExpressions + 1;
        regmatch_t matches[numberOfMatches];
 
        const int err = regexec(self->regex, chars, numberOfMatches, matches, options);
        assert(err == 0 || err == REG_NOMATCH);
 
        *ranges = calloc(numberOfMatches, sizeof(Range));
        assert(*ranges);
 
        Range *range = *ranges;
        const regmatch_t *match = matches;
        for (size_t i = 0; i < numberOfMatches; i++, range++, match++) {
            range->location = match->rm_so;
            if (range->location > -1) {
                range->length = match->rm_eo - match->rm_so;
            } else {
                range->length = 0;
            }
        }
 
        return err == 0;
    }
 
    const int err = regexec(self->regex, chars, 0, NULL, options);
    assert(err == 0 || err == REG_NOMATCH);
 
    return err == 0;
}

matchesString()

_Bool matchesString	(	const Regexp *	self,
		const String *	string,
		int	options,
		Range **	matches
	)

Matches this regular expression against the given String.

Parameters

self	The Regexp.
string	The String to match.
options	A bitwise-or of REG_NOTBOL, REG_NOTEOL.
matches	An optional pointer to return matched sub-expressions.

Returns

true if this expression matches string, false otherwise.

Remarks

If provided, matches will be dynamically allocated and contain numberOfSubExpressions + 1 Ranges. matches[0] will identify the Range of chars that matched the entire pattern. matches[1..n] will identify the Range of each corresponding sub-expression. The caller must free matches when done with it.

Definition at line 170 of file Regexp.c.

                                                                                                  {
 
    assert(string);
 
    return $(self, matchesCharacters, string->chars, options, ranges);
}

Related

re()

OBJECTIVELY_EXPORT Regexp * re ( const char *  pattern, int  options  )

related

A convenience function for instantiating Regexps.

Parameters

pattern	The POSIX regular expression pattern.
options	A bitwise-or of REG_ICASE, REG_NEWLINE.

Returns

A new Regexp, or NULL on error.

Definition at line 219 of file Regexp.c.

                                             {
    return $(alloc(Regexp), initWithPattern, pattern, options);
}

---

The documentation for this struct was generated from the following files:

• Sources/Objectively/Regexp.h
• Sources/Objectively/Regexp.c