diff options
Diffstat (limited to 'utils/tfstats/regexp/include/jm/cregex.h')
| -rw-r--r-- | utils/tfstats/regexp/include/jm/cregex.h | 309 |
1 files changed, 309 insertions, 0 deletions
diff --git a/utils/tfstats/regexp/include/jm/cregex.h b/utils/tfstats/regexp/include/jm/cregex.h new file mode 100644 index 0000000..f628522 --- /dev/null +++ b/utils/tfstats/regexp/include/jm/cregex.h @@ -0,0 +1,309 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// +/* + * + * Copyright (c) 1998-9 + * Dr John Maddock + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Dr John Maddock makes no representations + * about the suitability of this software for any purpose. + * It is provided "as is" without express or implied warranty. + * + */ + + /* + * FILE cregex.h + * VERSION 2.12 + */ + +#ifndef CREGEX_H +#define CREGEX_H + +#include <jm/jm_cfg.h> + +/* include these defs only for POSIX compatablity */ + +typedef int regoff_t; + +typedef struct +{ + unsigned int re_magic; + unsigned int re_nsub; /* number of parenthesized subexpressions */ + const char* re_endp; /* end pointer for REG_PEND */ + void* guts; /* none of your business :-) */ + unsigned int eflags; /* none of your business :-) */ +} regex_tA; + +#ifndef JM_NO_WCSTRING +typedef struct +{ + unsigned int re_magic; + unsigned int re_nsub; /* number of parenthesized subexpressions */ + const wchar_t* re_endp; /* end pointer for REG_PEND */ + void* guts; /* none of your business :-) */ + unsigned int eflags; /* none of your business :-) */ +} regex_tW; +#endif + +typedef struct +{ + regoff_t rm_so; /* start of match */ + regoff_t rm_eo; /* end of match */ +} regmatch_t; + +/* regcomp() flags */ +#define REG_BASIC 0000 +#define REG_EXTENDED 0001 +#define REG_ICASE 0002 +#define REG_NOSUB 0004 +#define REG_NEWLINE 0010 +#define REG_NOSPEC 0020 +#define REG_PEND 0040 +#define REG_DUMP 0200 +#define REG_NOCOLLATE 0400 + +#define REG_ASSERT 15 +#define REG_INVARG 16 +#define REG_ATOI 255 /* convert name to number (!) */ +#define REG_ITOA 0400 /* convert number to name (!) */ + +/* regexec() flags */ +#define REG_NOTBOL 00001 +#define REG_NOTEOL 00002 +#define REG_STARTEND 00004 + +#ifdef __cplusplus +extern "C" { +#endif + +JM_IX_DECL int RE_CCALL regcompA(regex_tA*, const char*, int); +JM_IX_DECL unsigned int RE_CCALL regerrorA(int, const regex_tA*, char*, unsigned int); +JM_IX_DECL int RE_CCALL regexecA(const regex_tA*, const char*, unsigned int, regmatch_t*, int); +JM_IX_DECL void RE_CCALL regfreeA(regex_tA*); + +#ifndef JM_NO_WCSTRING +JM_IX_DECL int RE_CCALL regcompW(regex_tW*, const wchar_t*, int); +JM_IX_DECL unsigned int RE_CCALL regerrorW(int, const regex_tW*, wchar_t*, unsigned int); +JM_IX_DECL int RE_CCALL regexecW(const regex_tW*, const wchar_t*, unsigned int, regmatch_t*, int); +JM_IX_DECL void RE_CCALL regfreeW(regex_tW*); +#endif + +#ifdef UNICODE +#define regcomp regcompW +#define regerror regerrorW +#define regexec regexecW +#define regfree regfreeW +#define regex_t regex_tW +#else +#define regcomp regcompA +#define regerror regerrorA +#define regexec regexecA +#define regfree regfreeA +#define regex_t regex_tA +#endif + + +#ifdef __cplusplus +} +#endif + + +#ifdef __cplusplus +JM_NAMESPACE(__JM) +#endif + +/* regerror() flags */ +typedef enum +{ + REG_NOERROR = 0, /* Success. */ + REG_NOMATCH = 1, /* Didn't find a match (for regexec). */ + + /* POSIX regcomp return error codes. (In the order listed in the + standard.) */ + REG_BADPAT = 2, /* Invalid pattern. */ + REG_ECOLLATE = 3, /* Undefined collating element. */ + REG_ECTYPE = 4, /* Invalid character class name. */ + REG_EESCAPE = 5, /* Trailing backslash. */ + REG_ESUBREG = 6, /* Invalid back reference. */ + REG_EBRACK = 7, /* Unmatched left bracket. */ + REG_EPAREN = 8, /* Parenthesis imbalance. */ + REG_EBRACE = 9, /* Unmatched \{. */ + REG_BADBR = 10, /* Invalid contents of \{\}. */ + REG_ERANGE = 11, /* Invalid range end. */ + REG_ESPACE = 12, /* Ran out of memory. */ + REG_BADRPT = 13, /* No preceding re for repetition op. */ + REG_EEND = 14, /* unexpected end of expression */ + REG_ESIZE = 15, /* expression too big */ + REG_ERPAREN = 16, /* unmatched right parenthesis */ + REG_EMPTY = 17, /* empty expression */ + REG_E_MEMORY = 18, /* out of memory */ + REG_E_UNKNOWN = 19 /* unknown error */ +} reg_errcode_t; + +enum match_flags +{ + match_default = 0, + match_not_bol = 1, // first is not start of line + match_not_eol = match_not_bol << 1, // last is not end of line + match_not_bob = match_not_eol << 1, // first is not start of buffer + match_not_eob = match_not_bob << 1, // last is not end of buffer + match_not_bow = match_not_eob << 1, // first is not start of word + match_not_eow = match_not_bow << 1, // last is not end of word + match_not_dot_newline = match_not_eow << 1, // \n is not matched by '.' + match_not_dot_null = match_not_dot_newline << 1, // '\0' is not matched by '.' + match_prev_avail = match_not_dot_null << 1, // *--first is a valid expression + match_init = match_prev_avail << 1, // internal use + match_any = match_init << 1, // don't care what we match + match_not_null = match_any << 1, // string can't be null + match_continuous = match_not_null << 1, // each grep match must continue from + // uninterupted from the previous one + match_stop = match_continuous << 1 // stop after first match (grep) +}; + + + +#ifdef __cplusplus +JM_END_NAMESPACE +#endif + +// +// C++ high level wrapper goes here: +// +#if defined(__cplusplus) && !defined(JM_NO_STRING_H) +#include <string> +#include <vector> +JM_NAMESPACE(__JM) + +class RegExData; +class RegEx; +struct pred1; +struct pred2; +struct pred3; +struct pred4; + +typedef bool (*GrepCallback)(const RegEx& expression); +typedef bool (*GrepFileCallback)(const char* file, const RegEx& expression); +typedef bool (*FindFilesCallback)(const char* file); + +class JM_IX_DECL RegEx +{ +private: + RegExData* pdata; +public: + RegEx(); + RegEx(const RegEx& o); + ~RegEx(); + RegEx(const char* c, bool icase = false); + RegEx(const __JM_STD::string& s, bool icase = false); + RegEx& operator=(const RegEx& o); + RegEx& operator=(const char* p); + RegEx& operator=(const __JM_STD::string& s){ return this->operator=(s.c_str()); } + unsigned int SetExpression(const char* p, bool icase = false); + unsigned int SetExpression(const __JM_STD::string& s, bool icase = false){ return SetExpression(s.c_str(), icase); } + __JM_STD::string Expression()const; + // + // now matching operators: + // + bool Match(const char* p, unsigned int flags = match_default); + bool Match(const __JM_STD::string& s, unsigned int flags = match_default) { return Match(s.c_str(), flags); } + bool Search(const char* p, unsigned int flags = match_default); + bool Search(const __JM_STD::string& s, unsigned int flags = match_default) { return Search(s.c_str(), flags); } + unsigned int Grep(GrepCallback cb, const char* p, unsigned int flags = match_default); + unsigned int Grep(GrepCallback cb, const __JM_STD::string& s, unsigned int flags = match_default) { return Grep(cb, s.c_str(), flags); } + unsigned int Grep(__JM_STD::vector<__JM_STD::string>& v, const char* p, unsigned int flags = match_default); + unsigned int Grep(__JM_STD::vector<__JM_STD::string>& v, const __JM_STD::string& s, unsigned int flags = match_default) { return Grep(v, s.c_str(), flags); } + unsigned int Grep(__JM_STD::vector<unsigned int>& v, const char* p, unsigned int flags = match_default); + unsigned int Grep(__JM_STD::vector<unsigned int>& v, const __JM_STD::string& s, unsigned int flags = match_default) { return Grep(v, s.c_str(), flags); } + unsigned int GrepFiles(GrepFileCallback cb, const char* files, bool recurse = false, unsigned int flags = match_default); + unsigned int GrepFiles(GrepFileCallback cb, const __JM_STD::string& files, bool recurse = false, unsigned int flags = match_default) { return GrepFiles(cb, files.c_str(), recurse, flags); } + unsigned int FindFiles(FindFilesCallback cb, const char* files, bool recurse = false, unsigned int flags = match_default); + unsigned int FindFiles(FindFilesCallback cb, const __JM_STD::string& files, bool recurse = false, unsigned int flags = match_default) { return FindFiles(cb, files.c_str(), recurse, flags); } + // + // now operators for returning what matched in more detail: + // + unsigned int Position(int i = 0)const; + unsigned int Length(int i = 0)const; + unsigned int Line()const; + unsigned int Marks()const; + __JM_STD::string What(int i = 0)const; + __JM_STD::string operator[](int i)const { return What(i); } + + friend struct pred1; + friend struct pred2; + friend struct pred3; + friend struct pred4; +}; + + +JM_END_NAMESPACE + +#if !defined(JM_NO_NAMESPACES) && !defined(JM_NO_USING) && defined(__cplusplus) + +using __JM::RegEx; +using __JM::GrepCallback; +using __JM::GrepFileCallback; +using __JM::FindFilesCallback; + +#endif + +#endif // __cplusplus + +#if !defined(JM_NO_NAMESPACES) && !defined(JM_NO_USING) && defined(__cplusplus) + +using __JM::match_flags; +using __JM::reg_errcode_t; + +using __JM::REG_NOERROR; +using __JM::REG_NOMATCH; +using __JM::REG_BADPAT; +using __JM::REG_ECOLLATE; +using __JM::REG_ECTYPE; +using __JM::REG_EESCAPE; +using __JM::REG_ESUBREG; +using __JM::REG_EBRACK; +using __JM::REG_EPAREN; +using __JM::REG_EBRACE; +using __JM::REG_BADBR; +using __JM::REG_ERANGE; +using __JM::REG_ESPACE; +using __JM::REG_BADRPT; +using __JM::REG_EEND; +using __JM::REG_ESIZE; +using __JM::REG_ERPAREN; +using __JM::REG_EMPTY; +using __JM::REG_E_MEMORY; +using __JM::REG_E_UNKNOWN; +using __JM::match_default; +using __JM::match_not_bol; +using __JM::match_not_eol; +using __JM::match_not_bob; +using __JM::match_not_eob; +using __JM::match_not_bow; +using __JM::match_not_eow; +using __JM::match_not_dot_newline; +using __JM::match_not_dot_null; +using __JM::match_prev_avail; +using __JM::match_init; +using __JM::match_any; +using __JM::match_not_null; +using __JM::match_continuous; +using __JM::match_stop; + +#endif + + +#endif + + + + + |