CoCalc -- regex.h

GitHub Repository: att/ast
Path: blob/master/src/lib/libast/include/regex.h
¹⁸¹⁰ views
1
/***********************************************************************
2
*                                                                      *
3
*               This software is part of the ast package               *
4
*          Copyright (c) 1985-2012 AT&T Intellectual Property          *
5
*                      and is licensed under the                       *
6
*                 Eclipse Public License, Version 1.0                  *
7
*                    by AT&T Intellectual Property                     *
8
*                                                                      *
9
*                A copy of the License is available at                 *
10
*          http://www.eclipse.org/org/documents/epl-v10.html           *
11
*         (with md5 checksum b35adb5213ca9657e911e9befb180842)         *
12
*                                                                      *
13
*              Information and Software Systems Research               *
14
*                            AT&T Research                             *
15
*                           Florham Park NJ                            *
16
*                                                                      *
17
*                 Glenn Fowler <[email protected]>                  *
18
*                  David Korn <[email protected]>                   *
19
*                   Phong Vo <[email protected]>                    *
20
*                                                                      *
21
***********************************************************************/
22
#pragma prototyped
23

24
/*
25
 * regex library interface
26
 */
27

28
#ifdef	_AST_STD_I
29
#define _REGEX_H	-1
30
#define regex_t		int
31
#define regmatch_t	int
32
#endif
33
#ifndef _REGEX_H
34
#define _REGEX_H	1
35
#undef	regex_t
36
#undef	regmatch_t
37

38
#include <ast_common.h>
39
#include <ast_wchar.h>
40
#include <ast_api.h>
41

42
#define REG_VERSION	20100930L
43

44
/* regcomp flags */
45

46
#define REG_AUGMENTED	0x00000001	/* enable ! & < >		*/
47
#define REG_EXTENDED	0x00000002	/* enable ( | )			*/
48
#define REG_ICASE	0x00000004	/* ignore case in match		*/
49
#define REG_NEWLINE	0x00000008	/* ^/$ match embedded \n	*/
50
#define REG_NOSUB	0x00000010	/* don't report subexp matches	*/
51
#define REG_SHELL	0x00000020	/* shell pattern syntax		*/
52

53
/* nonstandard regcomp flags */
54

55
#define REG_LEFT	0x00000100	/* implicit ^...		*/
56
#define REG_LITERAL	0x00000200	/* no operators			*/
57
#define REG_MINIMAL	0x00000400	/* minimal match		*/
58
#define REG_NULL	0x00000800	/* allow null patterns		*/
59
#define REG_RIGHT	0x00001000	/* implicit ...$		*/
60
#define REG_LENIENT	0x00002000	/* look the other way		*/
61
#define REG_ESCAPE	0x00004000	/* \ escapes delimiter in [...]	*/
62
#define REG_FIRST	0x00008000	/* first match found will do	*/
63
#define REG_MULTIPLE	0x00010000	/* multiple \n sep patterns	*/
64
#define REG_DISCIPLINE	0x00020000	/* regex_t.re_disc is valid	*/
65
#define REG_SPAN	0x00040000	/* . matches \n			*/
66
#define REG_COMMENT	0x00080000	/* ignore pattern space & #...\n*/
67
#define REG_MULTIREF	0x00100000	/* multiple digit backrefs	*/
68
#define REG_MUSTDELIM	0x08000000	/* all delimiters required	*/
69
#define REG_DELIMITED	0x10000000	/* pattern[0] is delimiter	*/
70
#define REG_CLASS_ESCAPE 0x80000000	/* \ escapes in [...]		*/
71

72
#define REG_SHELL_DOT	0x00200000	/* explicit leading . match	*/
73
#define REG_SHELL_ESCAPED 0x00400000	/* \ not special		*/
74
#define REG_SHELL_GROUP	0x20000000	/* (|&) inside [@|&](...) only	*/
75
#define REG_SHELL_PATH	0x00800000	/* explicit / match		*/
76

77
#define REG_REGEXP	0x40000000	/* <regexp.h> compatibility	*/
78

79
/* regexec flags */
80

81
#define REG_NOTBOL	0x00000040	/* ^ is not a special char	*/
82
#define REG_NOTEOL	0x00000080	/* $ is not a special char	*/
83

84
/* nonstandard regexec flags */
85

86
#define REG_INVERT	0x01000000	/* invert regrexec match sense	*/
87
#define REG_STARTEND	0x02000000	/* subject==match[0].rm_{so,eo} */
88
#define REG_ADVANCE	0x04000000	/* advance match[0].rm_{so,eo}	*/
89

90
/* regalloc flags */
91

92
#define REG_NOFREE	0x00000001	/* don't free			*/
93

94
/* regsub flags */
95

96
#define REG_SUB_ALL	0x00000001	/* substitute all occurrences	*/
97
#define REG_SUB_LOWER	0x00000002	/* substitute to lower case	*/
98
#define REG_SUB_UPPER	0x00000004	/* substitute to upper case	*/
99
#define REG_SUB_PRINT	0x00000010	/* internal no-op		*/
100
#define REG_SUB_NUMBER	0x00000020	/* internal no-op		*/
101
#define REG_SUB_STOP	0x00000040	/* internal no-op		*/
102
#define REG_SUB_WRITE	0x00000080	/* internal no-op		*/
103
#define REG_SUB_LAST	0x00000100	/* last substitution option	*/
104
#define REG_SUB_FULL	0x00000200	/* fully delimited		*/
105
#define REG_SUB_USER	0x00001000	/* first user flag bit		*/
106

107
/* regex error codes */
108

109
#define REG_ENOSYS	(-1)		/* not supported		*/
110
#define REG_NOMATCH	1		/* regexec didn't match		*/
111
#define REG_BADPAT	2		/* invalid regular expression	*/
112
#define REG_ECOLLATE	3		/* invalid collation element	*/
113
#define REG_ECTYPE	4		/* invalid character class	*/
114
#define REG_EESCAPE	5		/* trailing \ in pattern	*/
115
#define REG_ESUBREG	6		/* invalid \digit backreference	*/
116
#define REG_EBRACK	7		/* [...] imbalance		*/
117
#define REG_EPAREN	8		/* \(...\) or (...) imbalance	*/
118
#define REG_EBRACE	9		/* \{...\} or {...} imbalance	*/
119
#define REG_BADBR	10		/* invalid {...} digits		*/
120
#define REG_ERANGE	11		/* invalid [...] range endpoint	*/
121
#define REG_ESPACE	12		/* out of space			*/
122
#define REG_BADRPT	13		/* unary op not preceded by re	*/
123
#define REG_ENULL	14		/* empty subexpr in pattern	*/
124
#define REG_ECOUNT	15		/* re component count overflow	*/
125
#define REG_BADESC	16		/* invalid \char escape		*/
126
#define REG_VERSIONID	17		/* version id (pseudo error)	*/
127
#define REG_EFLAGS	18		/* flags conflict		*/
128
#define REG_EDELIM	19		/* invalid or omitted delimiter	*/
129
#define REG_PANIC	20		/* unrecoverable internal error	*/
130

131
struct regex_s; typedef struct regex_s regex_t;
132
struct regdisc_s; typedef struct regdisc_s regdisc_t;
133

134
typedef int (*regclass_t)(int);
135
typedef uint32_t regflags_t;
136
typedef int (*regerror_t)(const regex_t*, regdisc_t*, int, ...);
137
typedef void* (*regcomp_t)(const regex_t*, const char*, size_t, regdisc_t*);
138
typedef int (*regexec_t)(const regex_t*, void*, const char*, size_t, const char*, size_t, char**, regdisc_t*);
139
typedef void* (*regresize_t)(void*, void*, size_t);
140
typedef int (*regrecord_t)(void*, const char*, size_t);
141

142
#if ASTAPI(20120528)
143
typedef ssize_t regoff_t;
144
#else
145
typedef int regoff_t;
146
#endif
147

148
typedef struct regmatch_s
149
{
150
	regoff_t	rm_so;		/* offset of start		*/
151
	regoff_t	rm_eo;		/* offset of end		*/
152
} regmatch_t;
153

154
typedef struct regsub_s
155
{
156
	regflags_t	re_flags;	/* regsubcomp() flags		*/
157
	char*		re_buf;		/* regsubexec() output buffer	*/
158
	size_t		re_len;		/* re_buf length		*/
159
	int		re_min;		/* regsubcomp() min matches	*/
160
#ifdef _REG_SUB_PRIVATE_
161
	_REG_SUB_PRIVATE_
162
#endif
163
} regsub_t;
164

165
struct regdisc_s
166
{
167
	unsigned long	re_version;	/* discipline version		*/
168
	regflags_t	re_flags;	/* discipline flags		*/
169
	regerror_t	re_errorf;	/* error function		*/
170
	int		re_errorlevel;	/* errorf level			*/
171
	regresize_t	re_resizef;	/* alloc/free function		*/
172
	void*		re_resizehandle;/* resizef handle		*/
173
	regcomp_t	re_compf;	/* (?{...}) compile function	*/
174
	regexec_t	re_execf;	/* (?{...}) execute function	*/
175
	unsigned char*	re_map;		/* external to native ccode map	*/
176
};
177

178
typedef struct regstat_s
179
{
180
	regflags_t	re_flags;	/* REG_*			*/
181
	ssize_t		re_min;		/* min anchored match length	*/
182
	ssize_t		re_max;		/* max anchored match length	*/
183
	ssize_t		re_record;	/* regrexec() match length	*/
184
	regflags_t	re_info;	/* REG_* info			*/
185
} regstat_t;
186

187
struct regex_s
188
{
189
	size_t		re_nsub;	/* number of subexpressions	*/
190
	struct reglib_s*re_info;	/* library private info		*/
191
	size_t		re_npat;	/* number of pattern chars used	*/
192
	regdisc_t*	re_disc;	/* REG_DISCIPLINE discipline	*/
193
	regsub_t*	re_sub;		/* regsubcomp() data		*/
194
};
195

196
#define reginit(disc)	(memset(disc,0,sizeof(*(disc))),(disc)->re_version=REG_VERSION)
197

198
#if _BLD_ast && defined(__EXPORT__)
199
#define extern		__EXPORT__
200
#endif
201

202
extern int	regcomp(regex_t*, const char*, regflags_t);
203
extern size_t	regerror(int, const regex_t*, char*, size_t);
204
extern int	regexec(const regex_t*, const char*, size_t, regmatch_t*, regflags_t);
205
extern void	regfree(regex_t*);
206

207
/* nonstandard hooks */
208

209
#define _REG_cache	1	/* have regcache()			*/
210
#define _REG_class	1	/* have regclass()			*/
211
#define _REG_collate	1	/* have regcollate(), regclass()	*/
212
#define _REG_comb	1	/* have regcomb()			*/
213
#define _REG_decomp	1	/* have regdecomp()			*/
214
#define _REG_dup	1	/* have regdup()			*/
215
#define _REG_fatal	1	/* have regfatal(), regfatalpat()	*/
216
#define _REG_ncomp	1	/* have regncomp()			*/
217
#define _REG_nexec	1	/* have regnexec()			*/
218
#define _REG_rexec	1	/* have regrexec(), regrecord()		*/
219
#define _REG_stat	1	/* have regstat()			*/
220
#define _REG_subcomp	1	/* have regsubcomp(), regsubexec()	*/
221

222
extern regclass_t regclass(const char*, char**);
223
extern int	regaddclass(const char*, regclass_t);
224
extern int	regcollate(const char*, char**, char*, size_t, wchar_t*);
225
extern int	regcomb(regex_t*, regex_t*);
226
extern size_t	regdecomp(regex_t*, regflags_t, char*, size_t);
227
extern int	regdup(regex_t*, regex_t*);
228
extern int	regncomp(regex_t*, const char*, size_t, regflags_t);
229
extern int	regnexec(const regex_t*, const char*, size_t, size_t, regmatch_t*, regflags_t);
230
extern void	regfatal(regex_t*, int, int);
231
extern void	regfatalpat(regex_t*, int, int, const char*);
232
extern int	regrecord(const regex_t*);
233
extern int	regrexec(const regex_t*, const char*, size_t, size_t, regmatch_t*, regflags_t, int, void*, regrecord_t);
234
extern regstat_t* regstat(const regex_t*);
235

236
extern regex_t*	regcache(const char*, regflags_t, int*);
237

238
extern int	regsubcomp(regex_t*, const char*, const regflags_t*, int, regflags_t);
239
extern int	regsubexec(const regex_t*, const char*, size_t, regmatch_t*);
240
extern int	regsubflags(regex_t*, const char*, char**, int, const regflags_t*, int*, regflags_t*);
241
extern void	regsubfree(regex_t*);
242

243
/* obsolete hooks */
244

245
#ifndef _SFIO_H
246
struct _sfio_s;
247
#endif
248

249
extern void	regalloc(void*, regresize_t, regflags_t);
250
extern int	regsub(const regex_t*, struct _sfio_s*, const char*, const char*, size_t, regmatch_t*, regflags_t);
251

252
#undef	extern
253

254
#endif
255

256
Product

Resources

Company
