summaryrefslogtreecommitdiff
path: root/Source/kwsys/RegularExpression.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'Source/kwsys/RegularExpression.cxx')
-rw-r--r--Source/kwsys/RegularExpression.cxx114
1 files changed, 57 insertions, 57 deletions
diff --git a/Source/kwsys/RegularExpression.cxx b/Source/kwsys/RegularExpression.cxx
index f6eeeba..c829787 100644
--- a/Source/kwsys/RegularExpression.cxx
+++ b/Source/kwsys/RegularExpression.cxx
@@ -312,8 +312,8 @@ static char* regbranch (int*);
static char* regpiece (int*);
static char* regatom (int*);
static char* regnode (char);
-static const char* regnext (register const char*);
-static char* regnext (register char*);
+static const char* regnext (const char*);
+static char* regnext (char*);
static void regc (char);
static void reginsert (char, char*);
static void regtail (char*, const char*);
@@ -344,10 +344,10 @@ static int strcspn ();
// for later pattern matching.
bool RegularExpression::compile (const char* exp) {
- register const char* scan;
- register const char* longest;
- register size_t len;
- int flags;
+ const char* scan;
+ const char* longest;
+ size_t len;
+ int flags;
if (exp == 0) {
//RAISE Error, SYM(RegularExpression), SYM(No_Expr),
@@ -444,11 +444,11 @@ bool RegularExpression::compile (const char* exp) {
* follows makes it hard to avoid.
*/
static char* reg (int paren, int *flagp) {
- register char* ret;
- register char* br;
- register char* ender;
- register int parno =0;
- int flags;
+ char* ret;
+ char* br;
+ char* ender;
+ int parno =0;
+ int flags;
*flagp = HASWIDTH; // Tentatively.
@@ -525,10 +525,10 @@ static char* reg (int paren, int *flagp) {
* Implements the concatenation operator.
*/
static char* regbranch (int *flagp) {
- register char* ret;
- register char* chain;
- register char* latest;
- int flags;
+ char* ret;
+ char* chain;
+ char* latest;
+ int flags;
*flagp = WORST; // Tentatively.
@@ -562,10 +562,10 @@ static char* regbranch (int *flagp) {
* endmarker role is not redundant.
*/
static char* regpiece (int *flagp) {
- register char* ret;
- register char op;
- register char* next;
- int flags;
+ char* ret;
+ char op;
+ char* next;
+ int flags;
ret = regatom(&flags);
if (ret == 0)
@@ -631,8 +631,8 @@ static char* regpiece (int *flagp) {
* separate node; the code is simpler that way and it's not worth fixing.
*/
static char* regatom (int *flagp) {
- register char* ret;
- int flags;
+ char* ret;
+ int flags;
*flagp = WORST; // Tentatively.
@@ -648,8 +648,8 @@ static char* regatom (int *flagp) {
*flagp |= HASWIDTH | SIMPLE;
break;
case '[':{
- register int rxpclass;
- register int rxpclassend;
+ int rxpclass;
+ int rxpclassend;
if (*regparse == '^') { // Complement of range.
ret = regnode(ANYBUT);
@@ -720,8 +720,8 @@ static char* regatom (int *flagp) {
*flagp |= HASWIDTH | SIMPLE;
break;
default:{
- register int len;
- register char ender;
+ int len;
+ char ender;
regparse--;
len = int(strcspn(regparse, META));
@@ -754,8 +754,8 @@ static char* regatom (int *flagp) {
Location.
*/
static char* regnode (char op) {
- register char* ret;
- register char* ptr;
+ char* ret;
+ char* ptr;
ret = regcode;
if (ret == &regdummy) {
@@ -790,9 +790,9 @@ static void regc (char b) {
* Means relocating the operand.
*/
static void reginsert (char op, char* opnd) {
- register char* src;
- register char* dst;
- register char* place;
+ char* src;
+ char* dst;
+ char* place;
if (regcode == &regdummy) {
regsize += 3;
@@ -816,9 +816,9 @@ static void reginsert (char op, char* opnd) {
- regtail - set the next-pointer at the end of a node chain
*/
static void regtail (char* p, const char* val) {
- register char* scan;
- register char* temp;
- register int offset;
+ char* scan;
+ char* temp;
+ int offset;
if (p == &regdummy)
return;
@@ -893,7 +893,7 @@ bool RegularExpression::find (kwsys_stl::string const& s)
// Returns true if found, and sets start and end indexes accordingly.
bool RegularExpression::find (const char* string) {
- register const char* s;
+ const char* s;
this->searchstring = string;
@@ -956,9 +956,9 @@ bool RegularExpression::find (const char* string) {
*/
static int regtry (const char* string, const char* *start,
const char* *end, const char* prog) {
- register int i;
- register const char* *sp1;
- register const char* *ep;
+ int i;
+ const char* *sp1;
+ const char* *ep;
reginput = string;
regstartp = start;
@@ -992,8 +992,8 @@ static int regtry (const char* string, const char* *start,
* 0 failure, 1 success
*/
static int regmatch (const char* prog) {
- register const char* scan; // Current node.
- const char* next; // Next node.
+ const char* scan; // Current node.
+ const char* next; // Next node.
scan = prog;
@@ -1016,8 +1016,8 @@ static int regmatch (const char* prog) {
reginput++;
break;
case EXACTLY:{
- register size_t len;
- register const char* opnd;
+ size_t len;
+ const char* opnd;
opnd = OPERAND(scan);
// Inline the first character, for speed.
@@ -1052,8 +1052,8 @@ static int regmatch (const char* prog) {
case OPEN + 7:
case OPEN + 8:
case OPEN + 9:{
- register int no;
- register const char* save;
+ int no;
+ const char* save;
no = OP(scan) - OPEN;
save = reginput;
@@ -1081,8 +1081,8 @@ static int regmatch (const char* prog) {
case CLOSE + 7:
case CLOSE + 8:
case CLOSE + 9:{
- register int no;
- register const char* save;
+ int no;
+ const char* save;
no = OP(scan) - CLOSE;
save = reginput;
@@ -1103,7 +1103,7 @@ static int regmatch (const char* prog) {
// break;
case BRANCH:{
- register const char* save;
+ const char* save;
if (OP(next) != BRANCH) // No choice.
next = OPERAND(scan); // Avoid recursion.
@@ -1122,10 +1122,10 @@ static int regmatch (const char* prog) {
break;
case STAR:
case PLUS:{
- register char nextch;
- register int no;
- register const char* save;
- register int min_no;
+ char nextch;
+ int no;
+ const char* save;
+ int min_no;
//
// Lookahead to avoid useless match attempts when we know
@@ -1174,9 +1174,9 @@ static int regmatch (const char* prog) {
- regrepeat - repeatedly match something simple, report how many
*/
static int regrepeat (const char* p) {
- register int count = 0;
- register const char* scan;
- register const char* opnd;
+ int count = 0;
+ const char* scan;
+ const char* opnd;
scan = reginput;
opnd = OPERAND(p);
@@ -1216,8 +1216,8 @@ static int regrepeat (const char* p) {
/*
- regnext - dig the "next" pointer out of a node
*/
-static const char* regnext (register const char* p) {
- register int offset;
+static const char* regnext (const char* p) {
+ int offset;
if (p == &regdummy)
return (0);
@@ -1232,8 +1232,8 @@ static const char* regnext (register const char* p) {
return (p + offset);
}
-static char* regnext (register char* p) {
- register int offset;
+static char* regnext (char* p) {
+ int offset;
if (p == &regdummy)
return (0);