jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Include ctype.h as dependency.

Browse source 
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk/SWIG@432 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Thien-Thi Nguyen 2000-05-11 06:17:02 +00:00
commit f55be8b52f
1 changed files with 104 additions and 103 deletions
Download patch file Download diff file Expand all files Collapse all files

207
Source/Swig/super.c
View file

@ -1,32 +1,33 @@
/* ------------------------------------------------------------------------- /* -------------------------------------------------------------------------
* super.c * super.c
* *
* SuperStrings are just like strings, except that they maintain * SuperStrings are just like strings, except that they maintain
* information as to the origininal file/line of each character they * information as to the origininal file/line of each character they
* contain. * contain.
* *
* Author(s) : Dustin Mitchell (djmitche@cs.uchicago.edu) * Author(s) : Dustin Mitchell (djmitche@cs.uchicago.edu)
* *
* Copyright (C) 1999-2000. The University of Chicago * Copyright (C) 1999-2000. The University of Chicago
* See the file LICENSE for information on usage and redistribution. * See the file LICENSE for information on usage and redistribution.
* ------------------------------------------------------------------------- */ * ------------------------------------------------------------------------- */
#include <ctype.h>
#include "doh.h" #include "doh.h"
#include "swig.h" #include "swig.h"
static char cvstag[] = "$Header$"; static char cvstag[] = "$Header$";
typedef struct SSTag typedef struct SSTag
{ {
int length; /* distance to the next tag */ int length; /* distance to the next tag */
int line; /* of this character */ int line; /* of this character */
DOH *filename; /* of this character */ DOH *filename; /* of this character */
} SSTag; } SSTag;
typedef struct Super typedef struct Super
{ {
DOHCOMMON; DOHCOMMON;
/* -- from the regular string implementation */ /* -- from the regular string implementation */
int maxsize; /* Max size allocated */ int maxsize; /* Max size allocated */
int len; /* Current length */ int len; /* Current length */
@ -70,7 +71,7 @@ static long Super_tell(DOH *s);
static int Super_putc(DOH *s, int ch); static int Super_putc(DOH *s, int ch);
static int Super_getc(DOH *s); static int Super_getc(DOH *s);
static int Super_ungetc(DOH *s, int ch); static int Super_ungetc(DOH *s, int ch);
static int Super_replace(DOH *str, DOH *token, DOH *rep, int flags); static int Super_replace(DOH *str, DOH *token, DOH *rep, int flags);
static void Super_setfile(DOH *s, DOH *f); static void Super_setfile(DOH *s, DOH *f);
static void Super_setline(DOH *s, int); static void Super_setline(DOH *s, int);
static DOH * Super_getfile(DOH *s); static DOH * Super_getfile(DOH *s);
@ -82,7 +83,7 @@ static void Super_chop(DOH *str);
static void Super_move(Super *s, int delta); static void Super_move(Super *s, int delta);
static int Super_get_tag(Super *s, int pos, int *offset); static int Super_get_tag(Super *s, int pos, int *offset);
static void Super_add_space(Super *s, int more_bytes); static void Super_add_space(Super *s, int more_bytes);
static void Super_insert_tag(Super *s, int index, int length, static void Super_insert_tag(Super *s, int index, int length,
int line, DOH *filename); int line, DOH *filename);
static void Super_Delete_tag(Super *s, int index); static void Super_Delete_tag(Super *s, int index);
static int Super_count_newlines(char *s, int len); static int Super_count_newlines(char *s, int len);
@ -94,12 +95,12 @@ static void Super_super_insert(Super *s, int pos, Super *str);
typedef void (*callback)(Super *, int, char *, int, DOH *, int); typedef void (*callback)(Super *, int, char *, int, DOH *, int);
static int Super_raw_replace(Super *str, char *token, int flags, static int Super_raw_replace(Super *str, char *token, int flags,
callback insert, DOH *rep, int rep_len, callback insert, DOH *rep, int rep_len,
DOH *rep_fn, int rep_line); DOH *rep_fn, int rep_line);
/* method tables */ /* method tables */
static DohSequenceMethods SuperSeqMethods = static DohSequenceMethods SuperSeqMethods =
{ {
0, /* doh_getitem */ 0, /* doh_getitem */
0, /* doh_setitem */ 0, /* doh_setitem */
@ -109,7 +110,7 @@ static DohSequenceMethods SuperSeqMethods =
0, /* doh_next */ 0, /* doh_next */
}; };
static DohPositionalMethods SuperPositionalMethods = static DohPositionalMethods SuperPositionalMethods =
{ {
Super_setfile, Super_setfile,
Super_getfile, Super_getfile,
@ -117,7 +118,7 @@ static DohPositionalMethods SuperPositionalMethods =
Super_getline Super_getline
}; };
static DohFileMethods SuperFileMethods = static DohFileMethods SuperFileMethods =
{ {
Super_read, Super_read,
Super_write, Super_write,
@ -129,13 +130,13 @@ static DohFileMethods SuperFileMethods =
0, 0,
}; };
static DohStringMethods SuperStringMethods = static DohStringMethods SuperStringMethods =
{ {
Super_replace, Super_replace,
Super_chop Super_chop
}; };
static DohObjInfo SuperType = static DohObjInfo SuperType =
{ {
"SuperString", /* objname */ "SuperString", /* objname */
sizeof(Super), /* objsize */ sizeof(Super), /* objsize */
@ -153,8 +154,8 @@ static DohObjInfo SuperType =
0, /* doh_mapping */ 0, /* doh_mapping */
&SuperSeqMethods, /* doh_sequence */ &SuperSeqMethods, /* doh_sequence */
&SuperFileMethods, /* doh_file */ &SuperFileMethods, /* doh_file */
&SuperStringMethods, /* doh_string */ &SuperStringMethods, /* doh_string */
0, /* doh_callable */ 0, /* doh_callable */
&SuperPositionalMethods, /* doh_position */ &SuperPositionalMethods, /* doh_position */
}; };
@ -202,7 +203,7 @@ NewSuperString(char *s, DOH *filename, int firstline)
assert(str->tags); assert(str->tags);
str->tags[0].length = strlen(str->str); str->tags[0].length = strlen(str->str);
str->tags[0].line = firstline; str->tags[0].line = firstline;
if (!DohCheck(filename) || if (!DohCheck(filename) ||
(!String_check(filename) && !SuperString_check(filename))) (!String_check(filename) && !SuperString_check(filename)))
filename = NewString(filename); filename = NewString(filename);
else else
@ -220,7 +221,7 @@ NewSuperString(char *s, DOH *filename, int firstline)
* int SuperString_check(DOH *s) - Check if s is a Super * int SuperString_check(DOH *s) - Check if s is a Super
* ------------------------------------------------------------------------- */ * ------------------------------------------------------------------------- */
int int
SuperString_check(DOH *s) SuperString_check(DOH *s)
{ {
return (s && DohCheck(s) && ((Super *) s)->objinfo == &SuperType); return (s && DohCheck(s) && ((Super *) s)->objinfo == &SuperType);
} }
@ -251,7 +252,7 @@ CopySuper(DOH *so)
str->str[str->len] = 0; str->str[str->len] = 0;
str->line = s->line; str->line = s->line;
str->file = s->file; str->file = s->file;
max = s->maxtags; max = s->maxtags;
str->numtags = s->numtags; str->numtags = s->numtags;
@ -267,18 +268,18 @@ CopySuper(DOH *so)
return (DOH *) str; return (DOH *) str;
} }
/* ------------------------------------------------------------------------- /* -------------------------------------------------------------------------
* DelSuper(DOH *s) - Delete a Super * DelSuper(DOH *s) - Delete a Super
* ------------------------------------------------------------------------- */ * ------------------------------------------------------------------------- */
static void static void
DelSuper(DOH *so) DelSuper(DOH *so)
{ {
Super *s; Super *s;
s = (Super *) so; s = (Super *) so;
assert(s->refcount <= 0); assert(s->refcount <= 0);
if (s->str) if (s->str)
DohFree(s->str); DohFree(s->str);
s->str = 0; s->str = 0;
@ -290,7 +291,7 @@ DelSuper(DOH *so)
DohFree(s->tags); DohFree(s->tags);
} }
s->tags = 0; s->tags = 0;
DohObjFree(s); DohObjFree(s);
} }
@ -299,7 +300,7 @@ DelSuper(DOH *so)
* void *Super_data(DOH *so) - Return as a 'void *' * void *Super_data(DOH *so) - Return as a 'void *'
* ------------------------------------------------------------------------- */ * ------------------------------------------------------------------------- */
static void * static void *
Super_data(DOH *so) Super_data(DOH *so)
{ {
Super *s = (Super *) so; Super *s = (Super *) so;
s->str[s->len] = 0; s->str[s->len] = 0;
@ -307,21 +308,21 @@ Super_data(DOH *so)
} }
/* ------------------------------------------------------------------------- /* -------------------------------------------------------------------------
* int Super_dump(DOH *so, DOH *out) * int Super_dump(DOH *so, DOH *out)
* *
* Serialize a Super onto out * Serialize a Super onto out
* ------------------------------------------------------------------------- */ * ------------------------------------------------------------------------- */
static int static int
Super_dump(DOH *so, DOH *out) Super_dump(DOH *so, DOH *out)
{ {
int nsent; int nsent;
int ret; int ret;
Super *s; Super *s;
s = (Super *) so; s = (Super *) so;
nsent = 0; nsent = 0;
while (nsent < s->len) while (nsent < s->len)
{ {
ret = Write(out,s->str+nsent,(s->len-nsent)); ret = Write(out,s->str+nsent,(s->len-nsent));
if (ret < 0) return ret; if (ret < 0) return ret;
@ -334,8 +335,8 @@ Super_dump(DOH *so, DOH *out)
* int Super_len(DOH *s) - Length of a Super * int Super_len(DOH *s) - Length of a Super
* ------------------------------------------------------------------------- */ * ------------------------------------------------------------------------- */
static int static int
Super_len(DOH *so) Super_len(DOH *so)
{ {
Super *s = (Super *)so; Super *s = (Super *)so;
return s->len; return s->len;
@ -359,9 +360,9 @@ Super_cmp(DOH *so1, DOH *so2)
maxlen = s2->len; maxlen = s2->len;
c1 = s1->str; c1 = s1->str;
c2 = s2->str; c2 = s2->str;
for (i = 0; i < maxlen; i++,c1++,c2++) for (i = 0; i < maxlen; i++,c1++,c2++)
if (*c1 != *c2) break; if (*c1 != *c2) break;
if (i < maxlen) if (i < maxlen)
{ {
if (*c1 < *c2) return -1; if (*c1 < *c2) return -1;
else return 1; else return 1;
@ -385,14 +386,14 @@ Super_hash(DOH *so)
if (s->hashkey >= 0) return s->hashkey; if (s->hashkey >= 0) return s->hashkey;
c = s->str; c = s->str;
len = s->len > 50 ? 50 : s->len; len = s->len > 50 ? 50 : s->len;
for (i = 0; i < len; i++) for (i = 0; i < len; i++)
{ {
h = (((h << 5) + *(c++))); h = (((h << 5) + *(c++)));
} }
h = h & 0x7fffffff; h = h & 0x7fffffff;
s->hashkey = h; s->hashkey = h;
return h; return h;
} }
/* ------------------------------------------------------------------------- /* -------------------------------------------------------------------------
* void Super_clear(DOH *s) - Clear a Super * void Super_clear(DOH *s) - Clear a Super
@ -435,7 +436,7 @@ Super_clear(DOH *so)
s->curtag = 0; s->curtag = 0;
s->curtag_offset = 0; s->curtag_offset = 0;
} }
/* ------------------------------------------------------------------------- /* -------------------------------------------------------------------------
* void Super_insert(DOH *so, int pos, SO *str) - Insert a Super * void Super_insert(DOH *so, int pos, SO *str) - Insert a Super
* ------------------------------------------------------------------------- */ * ------------------------------------------------------------------------- */
@ -448,18 +449,18 @@ Super_insert(DOH *so, int pos, DOH *str)
if (SuperString_check(str)) if (SuperString_check(str))
Super_super_insert(s, pos, (Super *)str); Super_super_insert(s, pos, (Super *)str);
else if (DohCheck(str)) else if (DohCheck(str))
Super_string_insert(s, pos, Char(str), Len(str), Super_string_insert(s, pos, Char(str), Len(str),
Getfile(str), Getline(str)); Getfile(str), Getline(str));
else else
/* hmph. Nothin. */ /* hmph. Nothin. */
Super_string_insert(s, pos, str, 0, 0, 0); Super_string_insert(s, pos, str, 0, 0, 0);
return 0; return 0;
} }
/* ------------------------------------------------------------------------- /* -------------------------------------------------------------------------
* int Super_delitem(DOH *so, int pos) * int Super_delitem(DOH *so, int pos)
* *
* Delete an individual item * Delete an individual item
* ------------------------------------------------------------------------- */ * ------------------------------------------------------------------------- */
@ -478,7 +479,7 @@ static int Super_delitem(DOH *so, int pos)
/* special handling for deleting the current character */ /* special handling for deleting the current character */
if (s->sp == pos) if (s->sp == pos)
Super_move(s, 1); /* move ahead off of the character */ Super_move(s, 1); /* move ahead off of the character */
/* move the current point */ /* move the current point */
else if (s->sp > pos) else if (s->sp > pos)
{ {
@ -498,7 +499,7 @@ static int Super_delitem(DOH *so, int pos)
return 0; return 0;
} }
/* ------------------------------------------------------------------------- /* -------------------------------------------------------------------------
* DOH *Super_str(DOH *so) - Returns a Super (used by printing commands) * DOH *Super_str(DOH *so) - Returns a Super (used by printing commands)
* ------------------------------------------------------------------------- */ * ------------------------------------------------------------------------- */
@ -514,7 +515,7 @@ Super_str(DOH *so)
/* ------------------------------------------------------------------------- /* -------------------------------------------------------------------------
* int Super_read(DOH *so, void *buffer, int len) * int Super_read(DOH *so, void *buffer, int len)
* *
* Read data from the Super * Read data from the Super
* ------------------------------------------------------------------------- */ * ------------------------------------------------------------------------- */
@ -547,16 +548,16 @@ Super_read(DOH *so, void *buffer, int len)
/* ------------------------------------------------------------------------- /* -------------------------------------------------------------------------
* int Super_write(DOH *so, void *buffer, int len) * int Super_write(DOH *so, void *buffer, int len)
* *
* Write data to the Super * Write data to the Super
* ------------------------------------------------------------------------- */ * ------------------------------------------------------------------------- */
static int static int
Super_write(DOH *so, void *buffer, int len) Super_write(DOH *so, void *buffer, int len)
{ {
int newsize; int newsize;
Super *s = (Super *) so; Super *s = (Super *) so;
/* zero the hash and pushback */ /* zero the hash and pushback */
s->hashkey = -1; s->hashkey = -1;
s->pbi = 0; s->pbi = 0;
@ -571,7 +572,7 @@ Super_write(DOH *so, void *buffer, int len)
} }
/* update length */ /* update length */
if ((s->sp + len) > s->len) if ((s->sp + len) > s->len)
{ {
int newlen = s->sp + len; int newlen = s->sp + len;
s->tags[s->numtags-1].length += newlen - s->len; s->tags[s->numtags-1].length += newlen - s->len;
@ -593,12 +594,12 @@ Super_write(DOH *so, void *buffer, int len)
/* ------------------------------------------------------------------------- /* -------------------------------------------------------------------------
* int Super_seek(DOH *so, long offset, int whence) * int Super_seek(DOH *so, long offset, int whence)
* *
* Seek to a new position * Seek to a new position
* ------------------------------------------------------------------------- */ * ------------------------------------------------------------------------- */
static int static int
Super_seek(DOH *so, long offset, int whence) Super_seek(DOH *so, long offset, int whence)
{ {
Super *s = (Super *) so; Super *s = (Super *) so;
s->pbi = 0; s->pbi = 0;
@ -618,7 +619,7 @@ Super_seek(DOH *so, long offset, int whence)
/* ------------------------------------------------------------------------- /* -------------------------------------------------------------------------
* long Super_tell(DOH *so) * long Super_tell(DOH *so)
* *
* Return current position * Return current position
* ------------------------------------------------------------------------- */ * ------------------------------------------------------------------------- */
static long static long
@ -691,7 +692,7 @@ Super_getc(DOH *so)
* Put a character back on to the input stream. Updates the line count. * Put a character back on to the input stream. Updates the line count.
* ------------------------------------------------------------------------- */ * ------------------------------------------------------------------------- */
static int static int
Super_ungetc(DOH *so, int ch) Super_ungetc(DOH *so, int ch)
{ {
Super *s = (Super *) so; Super *s = (Super *) so;
@ -714,11 +715,11 @@ Super_ungetc(DOH *so, int ch)
* int Super_replace(DOH *str, DOH *token, DOH *rep, int flags) * int Super_replace(DOH *str, DOH *token, DOH *rep, int flags)
* ------------------------------------------------------------------------- */ * ------------------------------------------------------------------------- */
static int static int
Super_replace(DOH *stro, DOH *token, DOH *rep, int flags) Super_replace(DOH *stro, DOH *token, DOH *rep, int flags)
{ {
if (SuperString_check(rep)) if (SuperString_check(rep))
Super_raw_replace((Super *)stro, Char(token), flags, Super_raw_replace((Super *)stro, Char(token), flags,
Super_super_insert2, (DOH *)rep, 0, 0, 0); Super_super_insert2, (DOH *)rep, 0, 0, 0);
else if (String_check(rep)) else if (String_check(rep))
{ {
@ -782,13 +783,13 @@ Super_chop(DOH *so) {
char *c; char *c;
int len, tag, offset; int len, tag, offset;
Super *s = (Super *) so; Super *s = (Super *) so;
s->hashkey = -1; s->hashkey = -1;
s->pbi = 0; s->pbi = 0;
/* find trailing whitespace */ /* find trailing whitespace */
c = s->str + s->len - 1; c = s->str + s->len - 1;
while ((s->len >= 0) && (isspace(*c))) while ((s->len >= 0) && (isspace(*c)))
c--; c--;
len = c - s->str + 1; len = c - s->str + 1;
@ -807,12 +808,12 @@ Super_chop(DOH *so) {
} }
/* ---- internal functions ---- */ /* ---- internal functions ---- */
/* ------------------------------------------------------------------------- /* -------------------------------------------------------------------------
* static Super_move(Super *s, int delta) * static Super_move(Super *s, int delta)
* ------------------------------------------------------------------------- */ * ------------------------------------------------------------------------- */
static void static void
Super_move(Super *s, int delta) Super_move(Super *s, int delta)
{ {
int curtag_offset = s->curtag_offset; int curtag_offset = s->curtag_offset;
@ -828,7 +829,7 @@ Super_move(Super *s, int delta)
while (1) while (1)
{ {
int remaining = s->tags[s->curtag].length - curtag_offset; int remaining = s->tags[s->curtag].length - curtag_offset;
if (delta >= remaining) if (delta >= remaining)
{ {
s->curtag++; s->curtag++;
@ -841,7 +842,7 @@ Super_move(Super *s, int delta)
{ {
--s->curtag; --s->curtag;
curtag_offset = s->tags[s->curtag].length; curtag_offset = s->tags[s->curtag].length;
line = s->tags[s->curtag].line + line = s->tags[s->curtag].line +
Super_count_newlines(s->str + s->sp, remaining); Super_count_newlines(s->str + s->sp, remaining);
s->sp += remaining; s->sp += remaining;
@ -853,7 +854,7 @@ Super_move(Super *s, int delta)
line = s->tags[s->curtag].line; line = s->tags[s->curtag].line;
curtag_offset = 0; curtag_offset = 0;
} }
else else
{ {
line += Super_count_newlines(s->str + s->sp, delta); line += Super_count_newlines(s->str + s->sp, delta);
curtag_offset += delta; curtag_offset += delta;
@ -878,7 +879,7 @@ Super_move(Super *s, int delta)
while (1) while (1)
{ {
int remaining = curtag_offset; int remaining = curtag_offset;
if (delta > remaining) if (delta > remaining)
{ {
delta -= remaining; delta -= remaining;
@ -899,7 +900,7 @@ Super_move(Super *s, int delta)
curtag_offset -= delta; curtag_offset -= delta;
s->sp -= delta; s->sp -= delta;
line = s->tags[s->curtag].line + line = s->tags[s->curtag].line +
Super_count_newlines(s->str + s->sp - curtag_offset, Super_count_newlines(s->str + s->sp - curtag_offset,
curtag_offset); curtag_offset);
break; break;
@ -940,12 +941,12 @@ Super_get_tag(Super *s, int pos, int *offset)
} }
/* ------------------------------------------------------------------------- /* -------------------------------------------------------------------------
* static int Super_insert_tag(Super *s, int index, int length, * static int Super_insert_tag(Super *s, int index, int length,
* int line, DOH *filename) * int line, DOH *filename)
* ------------------------------------------------------------------------- */ * ------------------------------------------------------------------------- */
static void static void
Super_insert_tag(Super *s, int index, int length, Super_insert_tag(Super *s, int index, int length,
int line, DOH *filename) int line, DOH *filename)
{ {
if (s->numtags + 1 >= s->maxtags) if (s->numtags + 1 >= s->maxtags)
@ -955,8 +956,8 @@ Super_insert_tag(Super *s, int index, int length,
s->maxtags * sizeof(SSTag)); s->maxtags * sizeof(SSTag));
assert(s->tags); assert(s->tags);
} }
memmove(s->tags + index + 1, s->tags + index, memmove(s->tags + index + 1, s->tags + index,
(s->numtags - index) * sizeof(SSTag)); (s->numtags - index) * sizeof(SSTag));
s->tags[index].length = length; s->tags[index].length = length;
s->tags[index].line = line; s->tags[index].line = line;
@ -974,7 +975,7 @@ Super_Delete_tag(Super *s, int index)
if (!index) return; /* don't Delete first tag */ if (!index) return; /* don't Delete first tag */
Delete(s->tags[index].filename); Delete(s->tags[index].filename);
memmove(s->tags + index, s->tags + index + 1, memmove(s->tags + index, s->tags + index + 1,
(s->numtags - index - 1) * sizeof(SSTag)); (s->numtags - index - 1) * sizeof(SSTag));
s->numtags--; s->numtags--;
} }
@ -1019,7 +1020,7 @@ Super_string_insert(Super *s, int pos, char *str, int len,
{ {
int offset, tag; int offset, tag;
s->hashkey = -1; s->hashkey = -1;
/* normalize the inputs */ /* normalize the inputs */
if (len == 0) len = strlen(str); if (len == 0) len = strlen(str);
if (len == 0) return; if (len == 0) return;
@ -1034,7 +1035,7 @@ Super_string_insert(Super *s, int pos, char *str, int len,
if (pos < s->len) if (pos < s->len)
memmove(s->str+pos+len, s->str+pos, (s->len - pos)); memmove(s->str+pos+len, s->str+pos, (s->len - pos));
memmove(s->str+pos,str,len); memmove(s->str+pos,str,len);
s->len += len; s->len += len;
s->str[s->len] = 0; s->str[s->len] = 0;
/* insert new tags for this string if necessary */ /* insert new tags for this string if necessary */
@ -1049,7 +1050,7 @@ Super_string_insert(Super *s, int pos, char *str, int len,
if (right_len) if (right_len)
{ {
/* only calculate this if it will be used. */ /* only calculate this if it will be used. */
right_line = s->tags[tag].line + right_line = s->tags[tag].line +
Super_count_newlines(s->str + pos - offset, offset); Super_count_newlines(s->str + pos - offset, offset);
/* if a new tag uses filename, Incref it */ /* if a new tag uses filename, Incref it */
@ -1091,14 +1092,14 @@ Super_string_insert(Super *s, int pos, char *str, int len,
s->file = s->tags[s->curtag].filename; s->file = s->tags[s->curtag].filename;
s->line = Super_count_newlines(s->str + s->sp - offset, offset); s->line = Super_count_newlines(s->str + s->sp - offset, offset);
} }
} }
/* ------------------------------------------------------------------------- /* -------------------------------------------------------------------------
* static Super_super_insert(Super *s, int pos, Super *str) * static Super_super_insert(Super *s, int pos, Super *str)
* ------------------------------------------------------------------------- */ * ------------------------------------------------------------------------- */
static void static void
Super_super_insert2(Super *s, int pos, char *str, Super_super_insert2(Super *s, int pos, char *str,
int ignore1, DOH *ignore2, int ignore3) int ignore1, DOH *ignore2, int ignore3)
{ /* this function's prototype matches Super_string_insert, so it can { /* this function's prototype matches Super_string_insert, so it can
be used as a callback */ be used as a callback */
@ -1114,11 +1115,11 @@ Super_super_insert(Super *s, int pos, Super *str)
DOH *right_filename; DOH *right_filename;
s->hashkey = -1; s->hashkey = -1;
/* normalize the inputs */ /* normalize the inputs */
if (pos == DOH_END || pos > s->len) pos = s->len; if (pos == DOH_END || pos > s->len) pos = s->len;
else if (pos < 0) pos = 0; else if (pos < 0) pos = 0;
len = str->len; len = str->len;
if (len == 0) return; if (len == 0) return;
@ -1129,7 +1130,7 @@ Super_super_insert(Super *s, int pos, Super *str)
if (pos < s->len) if (pos < s->len)
memmove(s->str+pos+len, s->str+pos, (s->len - pos)); memmove(s->str+pos+len, s->str+pos, (s->len - pos));
memmove(s->str+pos,str->str,len); memmove(s->str+pos,str->str,len);
s->len += len; s->len += len;
s->str[s->len] = 0; s->str[s->len] = 0;
/* collect some factoids about the new layout of the tags */ /* collect some factoids about the new layout of the tags */
@ -1141,7 +1142,7 @@ Super_super_insert(Super *s, int pos, Super *str)
right_filename = s->tags[tag].filename; right_filename = s->tags[tag].filename;
/* only calculate this if it will be used */ /* only calculate this if it will be used */
right_line = s->tags[tag].line + right_line = s->tags[tag].line +
Super_count_newlines(s->str + pos - offset, offset); Super_count_newlines(s->str + pos - offset, offset);
/* if we will have another tag using filename, Incref it */ /* if we will have another tag using filename, Incref it */
@ -1167,9 +1168,9 @@ Super_super_insert(Super *s, int pos, Super *str)
} }
/* and move the existing tags forward. */ /* and move the existing tags forward. */
memmove(s->tags + tag + new_tags, s->tags + tag, memmove(s->tags + tag + new_tags, s->tags + tag,
(s->numtags - tag) * sizeof(SSTag)); (s->numtags - tag) * sizeof(SSTag));
/* and start writing in the data */ /* and start writing in the data */
if (left_len) if (left_len)
s->tags[tag++].length = left_len; s->tags[tag++].length = left_len;
@ -1199,12 +1200,12 @@ Super_super_insert(Super *s, int pos, Super *str)
s->file = s->tags[s->curtag].filename; s->file = s->tags[s->curtag].filename;
s->line = Super_count_newlines(s->str + s->sp - offset, offset); s->line = Super_count_newlines(s->str + s->sp - offset, offset);
} }
} }
/* ------------------------------------------------------------------------- /* -------------------------------------------------------------------------
* static int * static int
* Super_raw_replace(Super *str, char *token, int flags, * Super_raw_replace(Super *str, char *token, int flags,
* callback insert, DOH *rep, int rep_len, * callback insert, DOH *rep, int rep_len,
* DOH *rep_fn, int rep_line); * DOH *rep_fn, int rep_line);
* *
* Replaces token with rep. flags is as follows: * Replaces token with rep. flags is as follows:
@ -1213,7 +1214,7 @@ Super_super_insert(Super *s, int pos, Super *str)
* DOH_REPLACE_NOQUOTE - Don't replace in quotes * DOH_REPLACE_NOQUOTE - Don't replace in quotes
* DOH_REPLACE_ID - Only replace valid identifiers * DOH_REPLACE_ID - Only replace valid identifiers
* DOH_REPLACE_FIRST - Only replace first occurrence * DOH_REPLACE_FIRST - Only replace first occurrence
* *
* ------------------------------------------------------------------------- */ * ------------------------------------------------------------------------- */
/* static variables for use in Super_raw_replace */ /* static variables for use in Super_raw_replace */
@ -1277,7 +1278,7 @@ Super_rr_append_chunk(int start, int len)
rr_original->tags += initial_tag; rr_original->tags += initial_tag;
rr_original->len = len; rr_original->len = len;
rr_original->str += start; rr_original->str += start;
Super_super_insert(rr_dest, DOH_END, rr_original); /* easy!? */ Super_super_insert(rr_dest, DOH_END, rr_original); /* easy!? */
/* and swap things back in the opposite order. */ /* and swap things back in the opposite order. */
@ -1290,17 +1291,17 @@ Super_rr_append_chunk(int start, int len)
} }
static int static int
Super_raw_replace(Super *str, char *token, int flags, Super_raw_replace(Super *str, char *token, int flags,
callback insert, DOH *rep, int rep_len, callback insert, DOH *rep, int rep_len,
DOH *rep_fn, int rep_line) DOH *rep_fn, int rep_line)
{ {
char *match, *lastmatch_end; char *match, *lastmatch_end;
int tokenlen, state, i; int tokenlen, state, i;
int repcount = 0; int repcount = 0;
str->hashkey = -1; str->hashkey = -1;
tokenlen = strlen(token); tokenlen = strlen(token);
/* first see if there is a match, using the speedy library /* first see if there is a match, using the speedy library
function */ function */
match = strstr(str->str, token); match = strstr(str->str, token);
@ -1325,7 +1326,7 @@ Super_raw_replace(Super *str, char *token, int flags,
match - lastmatch_end); match - lastmatch_end);
/* and now insert the replacement */ /* and now insert the replacement */
(*insert)(rr_dest, DOH_END, (char *)rep, (*insert)(rr_dest, DOH_END, (char *)rep,
rep_len, rep_fn, rep_line); rep_len, rep_fn, rep_line);
/* now move our pointer up.. */ /* now move our pointer up.. */
@ -1353,21 +1354,21 @@ Super_raw_replace(Super *str, char *token, int flags,
state = 0; state = 0;
match = lastmatch_end = rr_original->str; match = lastmatch_end = rr_original->str;
while (*match && state != RR_DONE) while (*match && state != RR_DONE)
{ {
switch(state) switch(state)
{ {
case RR_BEGIN_MATCH: case RR_BEGIN_MATCH:
if (*match == *token && if (*match == *token &&
strncmp(match,token,tokenlen) == 0) strncmp(match,token,tokenlen) == 0)
{ {
/* skip if not the whole identifier */ /* skip if not the whole identifier */
if (flags & DOH_REPLACE_ID) if (flags & DOH_REPLACE_ID)
{ {
char after= *(match + tokenlen); char after= *(match + tokenlen);
if (after == '_' || after == '$' || isalnum(after)) if (after == '_' || after == '$' || isalnum(after))
{ {
match += tokenlen; match += tokenlen;
state = RR_INSIDE_IDENTIFIER; state = RR_INSIDE_IDENTIFIER;
continue; continue;
} }
@ -1376,11 +1377,11 @@ Super_raw_replace(Super *str, char *token, int flags,
/* copy the unchanged stuff from the original */ /* copy the unchanged stuff from the original */
Super_rr_append_chunk(lastmatch_end - rr_original->str, Super_rr_append_chunk(lastmatch_end - rr_original->str,
match - lastmatch_end); match - lastmatch_end);
/* and now insert the replacement */ /* and now insert the replacement */
(*insert)(rr_dest, DOH_END, (char *)rep, (*insert)(rr_dest, DOH_END, (char *)rep,
rep_len, rep_fn, rep_line); rep_len, rep_fn, rep_line);
/* now move our pointer up.. */ /* now move our pointer up.. */
match = lastmatch_end = match + tokenlen; match = lastmatch_end = match + tokenlen;
repcount++; repcount++;
@ -1391,23 +1392,23 @@ Super_raw_replace(Super *str, char *token, int flags,
/* we're now not ready to replace another identifier, /* we're now not ready to replace another identifier,
if anybody cares */ if anybody cares */
else if (flags & DOH_REPLACE_ID) else if (flags & DOH_REPLACE_ID)
state = RR_INSIDE_IDENTIFIER; state = RR_INSIDE_IDENTIFIER;
continue; continue;
} }
if (flags & DOH_REPLACE_ID) if (flags & DOH_REPLACE_ID)
{ {
if (*match == '_' || *match == '*' || isalpha(*match)) if (*match == '_' || *match == '*' || isalpha(*match))
state = RR_INSIDE_IDENTIFIER; state = RR_INSIDE_IDENTIFIER;
} }
if (flags & DOH_REPLACE_NOQUOTE) if (flags & DOH_REPLACE_NOQUOTE)
{ {
if (*match == '\"') state = RR_INSIDE_DOUBLE_QUOTE; if (*match == '\"') state = RR_INSIDE_DOUBLE_QUOTE;
else if (*match == '\'') state = RR_INSIDE_SINGLE_QUOTE; else if (*match == '\'') state = RR_INSIDE_SINGLE_QUOTE;
else if (*match == '\\' && else if (*match == '\\' &&
(*(match+1) == '\'' || *(match+1) == '\"')) (*(match+1) == '\'' || *(match+1) == '\"'))
match++; match++;
} }
@ -1437,10 +1438,10 @@ Super_raw_replace(Super *str, char *token, int flags,
Super_rr_append_chunk(lastmatch_end - rr_original->str, Super_rr_append_chunk(lastmatch_end - rr_original->str,
rr_original->str + rr_original->len - rr_original->str + rr_original->len -
lastmatch_end); lastmatch_end);
/* and reset the pointer */ /* and reset the pointer */
rr_dest->sp = rr_dest->curtag = rr_dest->sp = rr_dest->curtag =
rr_dest->curtag_offset = rr_dest->pbi = 0; rr_dest->curtag_offset = rr_dest->pbi = 0;
rr_dest->line = rr_dest->tags[0].line; rr_dest->line = rr_dest->tags[0].line;
rr_dest->file = rr_dest->tags[0].filename; rr_dest->file = rr_dest->tags[0].filename;
@ -1460,7 +1461,7 @@ static void dump_tags(DOH *so)
while (tag < s->numtags) while (tag < s->numtags)
{ {
Printf(stdout, "TAG %d: %d to %d (%d bytes), starting at '%s':%d\n", Printf(stdout, "TAG %d: %d to %d (%d bytes), starting at '%s':%d\n",
tag, pos, pos + s->tags[tag].length - 1, s->tags[tag].length, tag, pos, pos + s->tags[tag].length - 1, s->tags[tag].length,
s->tags[tag].filename, s->tags[tag].line); s->tags[tag].filename, s->tags[tag].line);
pos += s->tags[tag].length; pos += s->tags[tag].length;
tag++; tag++;
@ -1513,7 +1514,7 @@ int main(int argc, char **argv)
Insert(a, 6, b); Insert(a, 6, b);
Insert(a, 5, c); Insert(a, 5, c);
Insert(a, 3, d); Insert(a, 3, d);
Insert(r, 2, r2); Insert(r, 2, r2);
Replace(a, "ac", r, 0); Replace(a, "ac", r, 0);