#define SUPPRESS_COMPILER_INLINES
#include "std.h"
#include "lpc_incl.h"
#include "scratchpad.h"
#include "compiler.h"
/*
* This is a first attempt at beating malloc() for allocation of strings
* during compilation. It's pretty general, and could probably be done
* better.
*
* Here's what we can assume:
* Things are going to conform to LIFO order, more or less.
* Strings will be of the long variety and the short variety.
* A realloc on strings might be nice, for "a" "b" "c" ... etc
*
* Although in rare cases (errors) certain items won't come off until the
* table is destroyed.
*/
/* Here is what is currently being used:
*
* <0> <0> string1 <len1> string2 <len2>
* ^ ^
* last tail
*
* len1 is the length of string1 including the zero at the end
*
* Note: "" looks a heck of a lot like a interior freed string. Currently,
* we ignore the problem. In some cases, it could be left dangling, but
* I don't think that can happen with the present grammar/use of the
* scratchpad.
*/
/*
* Todo: This algorithm might be faster if we aligned to 2 byte
* boundaries and used shorts for lengths. We wouldn't have to
* worry about the 256 byte limit then
*/
/*
* Within this file, a capitalized identifier is that var cast to an
* unsigned type. It makes things easier to read than having casts
* all over the place since we go back and forth a lot. strict ANSI
* requires casts from (unsigned char *) to (char *) and back, but
* we want to deal with strings as unsigned since we keep the length
* in them.
*/
#define Str ((unsigned char *)str)
#define Ptr ((unsigned char *)ptr)
#define Res ((unsigned char *)res)
#define S1 ((unsigned char *)s1)
#define S2 ((unsigned char *)s2)
#define Scratch_large_alloc(x) ((unsigned char *)scratch_large_alloc(x))
#define Strlen(x) (strlen((char *)x))
#define Strcpy(x, y) (strcpy((char *)x, (char *)y))
#define Strncpy(x, y, z) (strncpy((char *)x, (char *)y, z))
/* not strictly ANSI, but should always work ... */
#define HDR_SIZE ((char *)&scratch_head.block[2] - (char *)&scratch_head)
#define FIND_HDR(x) ((sp_block_t *)(x - HDR_SIZE))
#define SIZE_WITH_HDR(x) (x + HDR_SIZE)
static unsigned char scratchblock[SCRATCHPAD_SIZE];
static sp_block_t scratch_head = { 0, 0 };
unsigned char *scr_last = &scratchblock[2], *scr_tail = &scratchblock[2];
unsigned char *scratch_end = scratchblock + SCRATCHPAD_SIZE;
#if 0
static void scratch_summary (void);
static void scratch_summary() {
unsigned char *p = scratchblock;
int i;
while (p<=scr_tail) {
if (*p == 0) printf("0");
else if (*p < 32 || *p > 127) printf("*");
else printf("%c", *p);
p++;
}
printf("\n");
i = scr_last - scratchblock;
while (i--) printf(" ");
printf("l\n");
i = scr_tail - scratchblock;
while (i--) printf(" ");
printf("t\n");
}
#endif
void scratch_destroy() {
sp_block_t *next, *this = scratch_head.next;
SDEBUG(printf("scratch_destroy\n"));
while (this) {
next = this->next;
FREE(this);
this = next;
}
scratch_head.next = 0;
scr_last = &scratchblock[2];
scr_tail = &scratchblock[2];
}
char *scratch_copy (const char * str) {
unsigned char *from, *to, *end;
SDEBUG2(printf("scratch_copy(%s):", str));
/* first, take a wild guess that there is room and save a strlen() :) */
from = Str;
to = scr_tail+1;
end = scratch_end - 2; /* room for zero and len */
if (end > to + 255) end = to + 255;
while (*from && to < end)
*to++ = *from++;
if (!(*from)) {
SDEBUG2(printf(" on scratchpad\n"));
scr_last = scr_tail + 1;
*to++ = 0;
scr_tail = to;
*to = to - scr_last;
return (char *)scr_last;
}
SDEBUG(printf(" mallocing ... "));
/* ACK! no room. strlen(str) == (from - str) + strlen(from) */
to = Scratch_large_alloc((from - Str) + Strlen(from) + 1);
Strcpy(to, str);
return (char *)to;
}
void scratch_free (char * ptr) {
/* how do we know what this is? first we check if it's the last string
we made. Otherwise, take advantage of the fact that things on the
scratchpad have a zero two before them. Things not on it wont
(we make sure of this) */
SDEBUG2(printf("scratch_free(%s): ", ptr));
if (Ptr == scr_last) {
SDEBUG2(printf("last freed\n"));
scratch_free_last();
} else if (*(Ptr - 2)) {
sp_block_t *sbt;
DEBUG_CHECK(*(Ptr - 2) != SCRATCH_MAGIC, "scratch_free called on non-scratchpad string.\n");
SDEBUG(printf("block freed\n"));
sbt = FIND_HDR(ptr);
if (sbt->prev)
sbt->prev->next = sbt->next;
if (sbt->next)
sbt->next->prev = sbt->prev;
FREE(sbt);
} else {
SDEBUG(printf("interior free\n"));
*ptr = 0; /* mark it as freed */
}
}
char *scratch_large_alloc (int size) {
sp_block_t *spt;
SDEBUG(printf("scratch_large_alloc(%i)\n", size));
spt = (sp_block_t *)DMALLOC(SIZE_WITH_HDR(size), TAG_COMPILER, "scratch_alloc");
if ((spt->next = scratch_head.next))
spt->next->prev = spt;
spt->prev = (sp_block_t *)&scratch_head;
spt->block[0] = SCRATCH_MAGIC;
scratch_head.next = spt;
return (char *)&spt->block[2];
}
/* warning: unlike REALLOC(), this one only allows increases */
char *scratch_realloc (char * ptr, int size) {
SDEBUG(printf("scratch_realloc(%s): ", ptr));
if (Ptr == scr_last) {
if (size < 256 && (scr_last + size) < scratch_end) {
SDEBUG(printf("on scratchpad\n"));
scr_tail = scr_last + size;
*scr_tail = size;
return ptr;
} else {
char *res;
SDEBUG(printf("copy off ... "));
res = scratch_large_alloc(size);
strcpy(res, ptr);
scratch_free_last();
return res;
}
} else if (*(Ptr - 2)) {
sp_block_t *sbt, *newsbt;
DEBUG_CHECK(*(Ptr - 2) != SCRATCH_MAGIC, "scratch_realloc on non-scratchpad string.\n");
SDEBUG(printf("block\n"));
sbt = FIND_HDR(ptr);
newsbt = (sp_block_t *)DREALLOC(sbt, SIZE_WITH_HDR(size),
TAG_COMPILER, "scratch_realloc");
newsbt->prev->next = newsbt;
if (newsbt->next)
newsbt->next->prev = newsbt;
return (char *)&newsbt->block[2];
} else {
char *res;
SDEBUG(printf("interior ... "));
/* ACK!! it's in the middle. */
if (size < 256 && (scr_tail + size + 1) < scratch_end) {
SDEBUG(printf("move to end\n"));
scr_last = scr_tail + 1;
Strcpy(scr_last, ptr);
scr_tail = scr_last + size;
*scr_tail = size;
res = (char *)scr_last;
} else {
SDEBUG(printf("copy off ... "));
res = scratch_large_alloc(size);
strcpy(res, ptr);
}
*ptr = 0; /* free the old version */
return res;
}
}
/* the routines above are better than this */
char *scratch_alloc (int size) {
SDEBUG(printf("scratch_alloc(%i)\n", size));
if (size < 256 && (scr_tail + size + 1) < scratch_end) {
scr_last = scr_tail + 1;
scr_tail = scr_last + size;
*scr_tail = size;
return (char *)scr_last;
} else
return scratch_large_alloc(size);
}
char *scratch_join (char * s1, char * s2) {
char *res;
int tmp;
SDEBUG(printf("scratch_join\n"));
if (*(s1-2) || *(s2-2)) {
int l = strlen(s1);
DEBUG_CHECK(*(S1 - 2) && *(S1 - 2) != SCRATCH_MAGIC, "argument 1 to scratch_join was not a scratchpad string.\n");
DEBUG_CHECK(*(S2 - 2) && *(S2 - 2) != SCRATCH_MAGIC, "argument 2 to scratch_join was not a scratchpad string.\n");
res = scratch_realloc(s1, l + strlen(s2) + 1);
strcpy(res + l, s2);
scratch_free(s2);
return res;
} else {
/* This assumes that S1 and S2 were the last two things allocated.
Make sure this is true */
DEBUG_CHECK(S2 != scr_last, "Argument 2 to scratch_join was not the last allocated string.\n");
DEBUG_CHECK(S1 != (scr_last - 1 - (*(scr_last - 1))), "Argument 1 to scratch_join was not the second to last allocated string.\n");
if ((tmp = ((scr_tail - S1) - 2)) < 256) {
scr_tail = scr_last - 2;
do {
*scr_tail = *(scr_tail + 2);
} while (*scr_tail++);
*scr_tail = tmp;
scr_last = S1;
return s1;
} else {
char *ret = scratch_large_alloc(tmp);
strcpy(ret, s1);
strcpy(ret + (scr_last - S1) - 2, s2);
scratch_free(s1);
scratch_free(s2);
return ret;
}
}
}
char *scratch_copy_string (char *s) {
int l;
register unsigned char *to = scr_tail + 1;
char *res;
SDEBUG2(printf("scratch_copy_string\n"));
l = scratch_end - to;
if (l > 255) l = 255;
s++;
while (l--) {
if (*s == '\\') {
switch (*++s) {
case 'n': *to++ = '\n'; break;
case 't': *to++ = '\t'; break;
case 'r': *to++ = '\r'; break;
case 'b': *to++ = '\b'; break;
case '"':
case '\\': *to++ = *s; break;
default:
*to++ = *s;
yywarn("Unknown \\x char.");
}
s++;
} else if (*s == '"') {
*to++ = 0;
if (!l && (to == scratch_end)) {
res = scratch_large_alloc(to - scr_tail - 1);
Strcpy(res, scr_tail + 1);
return res;
}
scr_last = scr_tail + 1;
scr_tail = to;
*to = to - scr_last;
return (char *)scr_last;
} else
*to++ = *s++;
}
/* estimate the length we need */
/* Note that the last char is we read is ", not \0 - Sym */
res = scratch_large_alloc(to - scr_tail + strlen(s) - 1);
Strncpy(res, (scr_tail + 1), (to - scr_tail) - 1);
to = Res + (to - scr_tail) - 1;
for (;;) {
if (*s == '\\') {
switch (*++s) {
case 'n': *to++ = '\n'; break;
case 't': *to++ = '\t'; break;
case 'r': *to++ = '\r'; break;
case 'b': *to++ = '\b'; break;
case '"':
case '\\': *to++ = *s; break;
default:
*to++ = *s;
yywarn("Unknown \\x char.");
}
s++;
} else if (*s == '"') {
*to++ = 0;
return res;
} else
*to++ = *s++;
}
}