Code: Select all
#include <stdio.h>
#include <string.h>
/* Issues:
If a program accidentally inserts at an insane offset (e.g. 2000000000), it will resize
the buffer that large and fault all the memory up to there. This could allow for very annoying
bugs and even be a security problem. Other padding places (e.g. property len) have the same
problem.
*/
//NOTE: glibc has this exact same function as a GNU extension, but it is only stable and
// correct in glibc 2.1 or newer (I wrote my own implementation rather than copying this)
//If _GNU_SOURCE is defined, that memmem will conflict with this one.
void *memmem(const void *haystack, uint haystacklen, const void *needle, uint needlelen) {
const byte *s=(const byte*)haystack, *p, *e;
const byte *n;
uint d;
byte fbn;
if (!needlelen--)
return (void*)haystack;
if (haystacklen <= needlelen)
return null;
e = (byte*)haystack+haystacklen-needlelen;
fbn = *(byte*)needle++;
do {
if (*s++ != fbn)
continue;
p = s;
n = needle;
d = needlelen;
while (d--) {
if (*p++ == *n++)
continue;
goto keepgoing;
}
return (void*)(s-1);
keepgoing:
;
} while (s<e);
return null;
}
//CharFlags is a collection of characters that are to be returned (or not returned) by the find* functions
struct CharFlags {
property char *charsSet {
set {
const byte *n = (const byte*)value;
byte val = 0;
while (*n)
flags[(uint)*n++] = ++val;
}
}
property char * {
set { charsSet = value; }
}
byte flags[256]; //flags[c] indicates whether character c is selected
void Clear(void) {
memset(flags, 0, sizeof(flags));
}
void Set(const char *needles, byte val) {
const byte *n = (const byte*)needles;
while (*n)
flags[(uint)*n++] = val;
}
};
char *findfirst(const char *haystack, uint haystacklen, CharFlags cf) {
const byte *h = (const byte*)haystack;
while (haystacklen--) {
if (cf.flags[(uint)*h++])
return h-1;
}
return null;
}
char *findfirstnon(const char *haystack, uint haystacklen, CharFlags cf) {
const byte *h = (const byte*)haystack;
while (haystacklen--) {
if (!cf.flags[(uint)*h++])
return h-1;
}
return null;
}
char *findlast(const char *haystack, uint haystacklen, CharFlags cf) {
const byte *h = (const byte*)haystack + haystacklen;
while (haystacklen--) {
if (cf.flags[(uint)*--h])
return h;
}
return null;
}
char *findlastnon(const char *haystack, uint haystacklen, CharFlags cf) {
const byte *h = (const byte*)haystack + haystacklen;
while (haystacklen--) {
if (!cf.flags[(uint)*--h])
return h;
}
return null;
}
struct StringLiteral {
property char* str {
set {
len = strlen(value);
data = value;
}
get { return data; }
}
property JString {
set {
len = value.len;
data = value.data;
}
get { return JString {literal = this}; }
}
property char* {
set {
len = strlen(value);
data = value;
}
get { return data; }
}
uint len;
char *data;
};
class JString : struct {
private:
struct {
uint len;
char *data;
uint size;
} n;
public:
//I would like property StringLiteral literal to come first so all JStrings created with
//instantiation syntax will know the size immediately rather than have to calculate it with
//strlen. Saying JString str {"Hello"} didn't work because of the problem using
//property char* set with that makes JString str = "Hello"; not work either.
property char* data {
get { return n.data; }
set {
literal = StringLiteral {len=strlen(value), data=value};
}
}
property StringLiteral literal {
get {
value = StringLiteral {len=n.len, data=n.data};
}
set {
n.len = value.len;
if (n.len > n.size) {
n.size = n.len;
n.data = renew n.data char[n.size+1];
}
memcpy(n.data, value.data, n.len);
n.data[n.len] = 0;
}
}
JString() {
n.data = new char[1];
n.data[0] = 0;
}
~JString() {
delete data;
}
property uint size {
get { return n.size; }
set {
if (n.len > value) {
n.len = value;
n.data[value] = 0;
}
n.size = value;
n.data = renew n.data char[n.size+1];
}
}
property uint len {
get { return n.len; }
set { //changes len with padding
uint oldlen = n.len;
Resize(value);
if (value > oldlen)
memset(n.data+oldlen, ' ', value-oldlen);
}
}
property char* {
set { n.data = value; } //this invokes the data property's set function
get { return n.data; }
}
property StringLiteral {
set { literal = value; } //this invokes the literal property's set function
get { value = StringLiteral {len = n.len, data = n.data}; }
}
//changes len without padding
void Resize(uint newlen) {
if (newlen > n.size) {
n.size = newlen;
n.data = renew n.data char[newlen+1];
}
n.data[newlen] = 0;
n.len = newlen;
}
char *PrependGap(uint alen) {
uint oldlen = n.len;
Resize(n.len + alen);
memmove(n.data+alen, n.data, oldlen+1);
return n.data;
}
char *InsertGap(uint offset, uint alen) {
uint oldlen = n.len;
if (offset >= oldlen) {
Resize(offset+alen);
memset(n.data+oldlen, ' ', offset-oldlen);
} else {
Resize(oldlen+alen);
memmove(n.data+offset+alen, n.data+offset, oldlen-offset);
}
return n.data+offset;
}
void Append(StringLiteral a) {
uint oldlen = n.len;
Resize(n.len + a.len);
memcpy(n.data+oldlen, a.data, a.len);
}
void Prepend(StringLiteral a) {
memcpy(PrependGap(a.len), a.data, a.len);
}
void Insert(StringLiteral a, uint offset) {
memcpy(InsertGap(offset, a.len), a.data, a.len);
}
void Delete(uint offset, uint dlen) {
if (offset >= n.len)
return;
if (dlen > n.len-offset)
dlen = n.len-offset;
memmove(n.data+offset, n.data+offset+dlen, n.len-offset-dlen);
Resize(n.len - dlen);
}
char *FindStr(uint start, StringLiteral needle) {
if (start > n.len)
return null;
return (char*)memmem(n.data+start, n.len-start, needle.data, needle.len);
}
//the n.len+1 in the following character-finding functions allows the zero terminator to be found also
char *FindChar(uint start, char c) {
if (start > n.len+1)
return null;
return (char*)memchr(n.data+start, c, n.len+1-start);
}
char *FindFirst(uint start, CharFlags cf) {
if (start > n.len+1)
return null;
return findfirst(n.data+start, n.len+1-start, cf);
}
char *FindFirstNon(uint start, CharFlags cf) {
if (start > n.len+1)
return null;
return findfirstnon(n.data+start, n.len+1-start, cf);
}
char *FindLast(uint end, CharFlags cf) {
if (end > n.len+1)
end = n.len+1;
return findlast(n.data, end, cf);
}
char *FindLastNon(uint end, CharFlags cf) {
if (end > n.len+1)
end = n.len+1;
return findlastnon(n.data, end, cf);
}
};
class Main : Application {
void Main() {
//JString str = "Hello deleteme";
//JString awesome = "awesome ";
//the char* set property isn't working correctly here, so I had to do what is below instead
JString str {"Hello deleteme"};
JString awesome {"awesome "};
//Moreover, I had to type this in an external editor because the IDE
// crashes if you type these lines or if you try to save after carefully
// typing around the problem.
//puts(str);
//this generates puts(__ecereProp_JString_Get_char__PTR_(&str)); instead of puts(__ecereProp_JString_Get_char__PTR_(str));
puts(str.data);
//str.Append(" world!");
//str.Insert(" friggin", 5);
str.Append({" world!"});
str.Insert({" friggin"}, 5);
str.Delete(14, 9);
//str.Insert(awesome, 14);
printf("\"%s\"\n", str.data);
{
//const char *loc = str.FindStr(0, "frig");
// This tries to convert "frig" to JString before converting it to StringLiteral. Moreover, it runs into the char* set property problem.
const char *loc = str.FindStr(0, {"frig"});
if (loc)
printf("\"frig\" found at %u\n", (uint)(loc-str));
}
{
//const char *v = str.FindFirst(0, "AEIOUaeiou");
// This does no conversion at all. It should invoke the property char* set function of struct CharFlags instead of passing the pointer directly
const char *v = str.FindFirst(0, {"AEIOUaeiou"});
if (v)
printf("First vowel: %c at %u\n", *v, (uint)(v-str));
//v = str.FindLast(str.len+1, "AEIOUaeiou");
v = str.FindLast(str.len+1, {"AEIOUaeiou"});
if (v)
printf("Last vowel: %c at %u\n", *v, (uint)(v-str));
}
}
}
) is you're kind of forced to learn how to use C style strings. Hopefully the future will bring some very developer-friendly 
