// This file is part of SmallBASIC
//
// strings
//
// This program is distributed under the terms of the GPL v2.0 or later
// Download the GNU Public License (GPL) from www.gnu.org
//
// Copyright(C) 2000 Nicholas Christopoulos
#include "common/sys.h"
#include "common/str.h"
#include "common/panic.h"
#include "common/fmt.h"
/**
* removes spaces and returns a new string
*/
char *trimdup(const char *str) {
char *buf;
char *p;
buf = tmp_alloc(strlen(str) + 1);
strcpy(buf, str);
if (*str == '\0') {
return buf;
}
p = (char *) str;
while (is_wspace(*p)) {
p++;
}
strcpy(buf, p);
if (*p != '\0') {
p = buf;
while (*p) {
p++;
}
p--;
while (p > buf && is_wspace(*p)) {
p--;
}
p++;
*p = '\0';
}
return buf;
}
/**
* removes spaces
*/
void str_alltrim(char *str) {
char *buf;
buf = trimdup(str);
strcpy(str, buf);
tmp_free(buf);
}
/**
* caseless string compare
*/
int strcaseless(const char *s1, const char *s2) {
const char *p1 = s1;
const char *p2 = s2;
int ch1, ch2;
while (*p1) {
if (*p1 == '\0' && *p2 != '\0') {
return -1;
}
if (*p2 == '\0' && *p1 != '\0') {
return 1;
}
ch1 = to_upper(*p1);
ch2 = to_upper(*p2);
if (ch1 < ch2) {
return -1;
}
if (ch1 > ch2) {
return 1;
}
p1++;
p2++;
}
return 0;
}
/**
* caseless string compare
*/
int strcaselessn(const char *s1, const char *s2, int len) {
const char *p1 = s1;
const char *p2 = s2;
int ch1, ch2, count;
count = 0;
while (*p1) {
if (count == len) {
return 0;
}
if (*p1 == '\0' && *p2 != '\0') {
return -1;
}
if (*p2 == '\0' && *p1 != '\0') {
return 1;
}
ch1 = to_upper(*p1);
ch2 = to_upper(*p2);
if (ch1 < ch2) {
return -1;
}
if (ch1 > ch2) {
return 1;
}
p1++;
p2++;
count++;
}
return 0;
}
/**
* strstr with ignore case
*/
char *stristr(const char *s1, const char *s2) {
char *p;
int l2;
p = (char *) s1;
l2 = strlen(s2);
while (*p) {
if (strcaselessn(p, s2, l2) == 0)
return p;
p++;
}
return NULL;
}
/**
*
*/
char *transdup(const char *src, const char *what, const char *with) {
char *p = (char *) src;
char *dest, *d;
int lwhat, lwith, size, len;
lwhat = strlen(what);
lwith = strlen(with);
size = 256;
dest = tmp_alloc(size);
d = dest;
*d = '\0';
while (*p) {
if (strncmp(p, what, lwhat) == 0) {
if ((d - dest) + lwith >= size - 1) {
len = d - dest;
size += 256;
dest = tmp_realloc(dest, size);
d = dest + len;
}
memcpy(d, with, lwith);
d += lwith;
p += (lwhat - 1);
} else {
if ((d - dest) + 1 >= size - 1) {
len = d - dest;
size += 256;
dest = tmp_realloc(dest, size);
d = dest + len;
}
*d = *p;
d++;
}
p++;
}
*d = '\0';
return dest;
}
/*
* strstr with support for quotes
*/
char *q_strstr(const char *s1, const char *s2, const char *pairs) {
char *p, *z;
int l2;
int wait_q, open_q, level_q;
p = (char *) s1;
l2 = strlen(s2);
wait_q = open_q = level_q = 0;
while (*p) {
if (*p == wait_q) { // i am waiting that. level down
level_q--;
if (level_q <= 0) { // level = 0
level_q = 0;
wait_q = 0;
}
} else if ((z = strchr(pairs, *p)) != NULL) { // character is a
// delimiter;
// level up
open_q = ((z - pairs) + 1) % 2; // true, if its a 'begin'
// delimiter
if (wait_q && open_q) {
if (*(z + 1) == wait_q) // open_q of our pair?
level_q++; // increase level
} else if (wait_q)
; // do nothing, I am waitting something
// else
else { // its a new section
if (open_q) {
level_q++; // level = 1
wait_q = *(z + 1); // what to wait for
}
}
} else if (wait_q == 0) { // it is a regular character
if (strncmp(p, s2, l2) == 0)
return p;
}
// next
p++;
}
return NULL;
}
/**
*
*/
int is_alpha(int ch) {
if (ch == 0)
return 0;
if ((ch > 64 && ch < 91) || (ch > 96 && ch < 123))
return -1;
// return
// (strchr("_���������������������������������������������������������", ch)
// != NULL); // Greek
return (ch & 0x80); // +foreign
}
/**
* returns true if the ch is alphanumeric
*/
int is_alnum(int ch) {
if (ch == 0) {
return 0;
}
return (is_alpha(ch) || is_digit(ch));
}
/**
* returns true if the ch is an 'empty' character
*/
int is_space(int ch) {
return (ch == ' ' || ch == '\t' || ch == '\f' || ch == '\n' || ch == '\r' || ch == '\v') ? -1 : 0;
}
/**
* returns true if 'text' contains digits only
*/
int is_all_digits(const char *text) {
const char *p = text;
if (p == NULL) {
return 0;
}
if (*p == '\0') {
return 0;
}
while (*p) {
if (!is_digit(*p)) {
return 0;
}
p++;
}
return 1;
}
/**
* returns true if the text is keyword
*/
int is_keyword(const char *name) {
char *p = (char *) name;
if (p == NULL) {
return 0;
}
if (is_alpha(name[0])) {
while (is_alnum(*p) || (*p == '_')) {
p++;
}
return (*p == '\0');
}
return 0;
}
/**
* converts the 'str' string to uppercase
*/
char *strupper(char *str) {
char *p = str;
if (p == NULL) {
return 0;
}
while (*p) {
*p = to_upper(*p);
p++;
}
return str;
}
/**
* converts the 'str' string to lowercase
*/
char *strlower(char *str) {
char *p = str;
if (p == NULL) {
return 0;
}
while (*p) {
*p = to_lower(*p);
p++;
}
return str;
}
/**
*
*/
char *get_keyword(char *text, char *dest) {
char *p = (char *) text;
char *d = dest;
if (p == NULL) {
*dest = '\0';
return 0;
}
while (is_space(*p)) {
p++;
}
while (is_alnum(*p) || (*p == '_')) {
*d = to_upper(*p);
d++;
p++;
}
// Code to kill the $
// if ( *p == '$' )
// p ++;
if (*p == '$') {
*d++ = *p++;
}
*d = '\0';
while (is_space(*p)) {
p++;
}
// special case, something wrong, jump to next char
if (p == text) {
*dest = *p;
*(dest + 1) = '\0';
p++;
}
return p;
}
/**
* Returns the number of a string (constant numeric expression)
*
* type <=0 = error
* 1 = int32
* 2 = double
*
* Warning: octals are different from C (QB compatibility: 009 = 9)
*/
char *get_numexpr(char *text, char *dest, int *type, var_int_t *lv, var_num_t *dv) {
char *p = (char *) text;
char *d = dest;
char *epos = NULL, *epos_on_text = NULL;
byte base = 10;
byte dpc = 0, stupid_e_fmt = 0, eop = '+';
int sign = 1;
var_num_t power = 1.0;
var_num_t num;
*type = 0;
*lv = 0;
*dv = 0.0;
if (p == NULL) {
*dest = '\0';
return NULL;
}
// spaces
while (is_space(*p)) {
p++;
}
// sign
if ((*p == '-' || *p == '+') && strchr("0123456789.", *(p + 1)) &&
*(p + 1) != '\0'){if (*p == '-') {
sign = -1;
}
p++; // don't copy it
}
//
// resolve the base (hex, octal and binary)
//
if ((*p == '&') || (*p == '0' && (*(p + 1) != '\0' && strchr("HXBO", to_upper(*(p + 1))) != NULL))) {
p++;
switch (*p) {
case 'H':
case 'h':
case 'X':
case 'x':
base = 16;
break;
case 'O':
case 'o':
base = 8;
break;
case 'B':
case 'b':
base = 2;
break;
default:
*type = -1;
return p; // Unknown base
}
p++;
}
//
// copy parts of number
//
if (base == 16) {
// copy hex
while (is_hexdigit(*p)) {
*d = to_upper(*p);
d++;
p++;
}
} else if (base != 10) {
// copy octal | bin
while (is_digit(*p))
*d++ = *p++;
} else if (is_digit(*p) || *p == '.') {
// copy number (first part)
while (is_digit(*p) || *p == '.') {
if (*p == '.') {
dpc++;
if (dpc > 1) {
*type = -2; // DP ERROR
break;
}
}
*d++ = *p++;
}
// check second part
if ((*p == 'E' || *p == 'e') && (*type == 0)) {
epos = d;
epos_on_text = p;
*d++ = *p++; // E
if (*p == '+' || *p == '-' || is_digit(*p) || *p == '.') {
dpc = 0;
// copy second part (power)
if (*p == '+' || *p == '-') {
*d++ = *p++;
if (strchr("+-*/\\^", *p) != 0) { // stupid E format
// (1E--9 ||
// 1E++9)
stupid_e_fmt = 1;
eop = *p;
*d++ = *p++;
if (*p == '+' || *p == '-')
*d++ = *p++;
}
}
// power
while (is_digit(*p) || *p == '.') {
if (*p == '.') {
dpc++;
if (dpc > 1) {
*type = -4; // DP ERROR (second part)
break;
}
}
*d++ = *p++;
} // after E
} //
else {
*type = -3; // E+- ERROR
}
}
} else
*type = -9; // NOT A NUMBER
*d = '\0';
//
// finaly, calculate the number
//
if (*type == 0) {
switch (base) {
case 10:
if (dpc || (epos != NULL) || (strlen(dest) > 8)) {
*type = 2; // double
if (epos) {
if (stupid_e_fmt) {
int r_type = 1;
*epos = '\0';
num = sb_strtof(dest) * ((double) sign);
*epos = 'E'; // restore E
/*
* if ( *p == 'E' || *p == 'e' ) { long r_lv; double r_dv;
*
* p = get_numexpr(epos_on_text+3, dest, &r_type, &r_lv, &r_dv);
*
* switch ( r_type ) { case 1: power = r_lv; break; case 2: power =
* r_dv; break; default: // error *type = r_type; } } else
*/
power = sb_strtof(epos + 3);
if (r_type > 0) {
switch (eop) {
case '+':
*dv = num + power;
break;
case '-':
*dv = num - power;
break;
case '*':
*dv = num * power;
break;
case '/':
if (ABS(power) != 0.0)
*dv = num / power;
else
*dv = 0;
// else if(comp) sc_raise() else rt_raise
break;
case '\\':
if ((long) power != 0) {
*type = 1;
*lv = num / (long) power;
} else {
*type = 1;
*lv = 0;
}
// else if(comp) sc_raise() else rt_raise
break;
case '^':
*dv = pow(num, power);
break;
}
}
} else {
*epos = '\0';
power = pow(10, sb_strtof(epos + 1));
*dv = sb_strtof(dest) * ((double) sign) * power;
*epos = 'E';
}
} else {
*dv = sb_strtof(dest) * ((double) sign);
}
} else {
// dpc = 0 && epos = 0
*type = 1; // int32
*lv = xstrtol(dest) * sign;
}
break;
case 16:
*type = 1; // int32
*lv = hextol(dest);
break;
case 8:
*type = 1; // int32
*lv = octtol(dest);
break;
case 2:
*type = 1; // int32
*lv = bintol(dest);
break;
}
}
//
if (is_alpha(*p))
*type = -9; // ITS NOT A NUMBER
while (is_space(*p))
p++;
return p;
}
/**
*
*/
var_num_t numexpr_sb_strtof(char *source) {
char buf[256], *np;
int type;
var_int_t lv;
var_num_t dv;
np = get_numexpr(source, buf, &type, &lv, &dv);
if (type == 1 && *np == '\0') {
return (var_num_t) lv;
} else if (type == 2 && *np == '\0') {
return dv;
}
return 0.0;
}
/**
*
*/
var_int_t numexpr_strtol(char *source) {
char buf[256], *np;
int type;
var_int_t lv;
var_num_t dv;
np = get_numexpr(source, buf, &type, &lv, &dv);
if (type == 1 && *np == '\0') {
return lv;
} else if (type == 2 && *np == '\0') {
return (var_int_t) dv;
}
return 0;
}
/**
* convertion: binary to decimal
*/
long bintol(const char *str) {
long r = 0;
char *p = (char *) str;
if (p == NULL) {
return 0;
}
while (*p) {
if (*p == 48 || *p == 49) // 01
r = (r << 1) + ((*p) - 48);
p++;
}
return r;
}
/**
* convertion: octal to decimal
*/
long octtol(const char *str) {
long r = 0;
char *p = (char *) str;
if (p == NULL) {
return 0;
}
while (*p) {
if (*p >= 48 && *p <= 55) // 01234567
r = (r << 3) + ((*p) - 48);
p++;
}
return r;
}
/**
* convertion: hexadecimal to decimal
*/
long hextol(const char *str) {
long r = 0;
char *p = (char *) str;
if (p == NULL) {
return 0;
}
while (*p) {
if (is_digit(*p)) // 0123456789
r = (r << 4) + ((*p) - 48);
else if (*p >= 65 && *p <= 70) // ABCDEF
r = (r << 4) + ((*p) - 55);
else if (*p >= 97 && *p <= 102) // abcdef
r = (r << 4) + ((*p) - 87);
p++;
}
return r;
}
/**
* string to double
*/
var_num_t sb_strtof(const char *str) {
char *p = (char *) str;
var_num_t r = 0.0;
var_num_t d = 10.0;
var_num_t sign = 1;
int decp = 0;
if (p == NULL) {
return 0;
}
if (*p == '-') {
sign = -1;
p++;
} else if (*p == '+')
p++;
while (*p) {
if (is_digit(*p)) {
if (!decp)
r = (r * 10) + ((*p) - 48);
else {
r += (((*p) - 48) * 1 / d);
d *= 10;
}
} else if (*p == '.')
decp = 1;
else if (*p == ' ')
break;
else {
r = 0;
break;
}
p++;
}
return r * sign;
}
/**
*
*/
long xstrtol(const char *str) {
if (str == NULL) {
return 0;
}
return atoi(str);
}
/**
*
*/
int is_number(const char *str) {
char *p = (char *) str;
int dpc = 0, cnt = 0;
if (str == NULL) {
return 0;
}
if (*p == '+' || *p == '-')
p++;
while (*p) {
if (strchr("0123456789.", *p) == NULL
)
return 0;
else
cnt++;
if (*p == '.') {
dpc++;
if (dpc > 1)
return 0;
}
p++;
}
if (cnt)
return 1;
return 0;
}
/**
* double to string
*/
char *ftostr(var_num_t num, char *dest) {
bestfta(num, dest);
return dest;
}
/**
*
*/
char *ltostr(var_int_t num, char *dest) {
if (dest == NULL) {
panic("l2s(..,null)");
}
sprintf(dest, VAR_INT_FMT, num);
return dest;
}
/**
* newdir must ends with dirsep
* new_ext must starts with .
*/
char *chgfilename(char *dest, char *source, char *newdir, char *prefix, char *new_ext, char *suffix) {
char *plast_dir;
char *plast_point;
dest[0] = '\0';
plast_dir = strrchr(source, OS_DIRSEP);
if (!plast_dir) {
plast_dir = source;
} else {
plast_dir++;
}
plast_point = strrchr(source, '.');
if (newdir) {
strcat(dest, newdir);
}
if (prefix) {
strcat(dest, prefix);
}
if (new_ext) {
*plast_point = '\0';
}
strcat(dest, plast_dir);
if (suffix) {
strcat(dest, suffix);
}
if (new_ext) {
strcat(dest, new_ext);
*plast_point = '.';
}
return dest;
}
/**
*
*/
char *xbasename(char *dest, const char *source) {
char *p;
p = strrchr(source, OS_DIRSEP);
if (!p)
p = (char *) source;
else
p++;
strcpy(dest, p);
return dest;
}
/**
*
*/
int is_wspace(int c) {
return (c != 0 && strchr(" \t\n\r\v\f", c));
}
/**
* squeeze (& strdup)
*/
char *sqzdup(const char *source) {
char *rp, *p, *d;
int lc = 0;
rp = tmp_alloc(strlen(source) + 1);
p = (char *) source;
d = rp;
while (*p != '\0' && is_wspace(*p))
p++;
while (*p) {
if (is_wspace(*p)) {
if (!lc) {
lc = 1;
if (p > source) {
if (is_alpha(*(p - 1)) || is_digit(*(p - 1)))
*d++ = ' ';
else {
char *nc;
nc = p;
while (*nc != '\0' && is_wspace(*nc))
nc++;
if (is_alpha(*nc) || is_digit(*nc)
)
*d++ = ' ';
}
}
}
} else
(lc = 0, *d++ = *p);
p++;
}
*d = '\0';
if (d > rp) {
if (is_wspace(*(d - 1)))
*(d - 1) = '\0';
}
return rp;
}
/**
* enclose, returns a newly created string
*/
char *encldup(const char *source, const char *pairs) {
char *rp;
int l;
l = strlen(source);
rp = tmp_alloc(l + 3);
memcpy(rp + 1, source, l);
*(rp) = pairs[0];
if (pairs[1])
*(rp + l + 1) = pairs[1];
else
*(rp + l + 1) = pairs[0];
*(rp + l + 2) = '\0';
return rp;
}
/**
* disclose, returns a newly created string
*/
char *discldup(const char *source, const char *pairs, const char *ignpairs) {
char *rp, *np, *r, *p, *z;
int wait_p = 0, open_p = 0, level_p = 0;
int wait_q = 0, open_q = 0, level_q = 0;
int record = 0;
rp = tmp_strdup(source);
r = rp;
p = (char *) source;
while (*p) {
// ignore pairs
if (*p == wait_q) { // ignore pair - level down
level_q--;
if (level_q <= 0) {
level_q = 0;
wait_q = 0;
}
} else if ((z = strchr(ignpairs, *p)) != NULL) {
open_q = ((z - ignpairs) + 1) % 2;
if (wait_q && open_q) {
if (*(z + 1) == wait_q) // open_q of our pair?
level_q++;
} else if (wait_q)
; // do nothing, I am waitting something
// else
else { // new pair
if (open_q) {
level_q++;
wait_q = *(z + 1);
}
}
}
// primary pairs
else if (*p == wait_p && wait_q == 0) { // primary pair - level
// down
level_p--;
if (level_p <= 0) {
// store and exit
record = 0;
break;
}
} else if ((z = strchr(pairs, *p)) != NULL && wait_q == 0) {
open_p = ((z - pairs) + 1) % 2;
if (wait_p && open_p) {
if (*(z + 1) == wait_p) // open_q of our pair?
level_p++;
} else if (wait_p)
; // do nothing, I am waitting something
// else
else { // new pair
if (open_p) {
level_p++;
wait_p = *(z + 1);
record = 1;
}
}
}
// next
if (record == 1) // ignore the first
record++;
else if (record == 2)
*r++ = *p;
p++;
}
*r = '\0';
np = tmp_strdup(rp); // actually, resize down
tmp_free(rp);
return np;
}
/**
* C-Style control codes
*/
char *cstrdup(const char *source) {
char *buf, *p, *d;
buf = tmp_alloc(strlen(source) + 1);
p = (char *) source;
d = buf;
while (*p) {
if (*p == '\\') {
p++;
switch (*p) {
case 'e':
*d++ = '\033';
break;
case 'v':
*d++ = '\v';
break;
case 't':
*d++ = '\t';
break;
case 'r':
*d++ = '\r';
break;
case 'n':
*d++ = '\n';
break;
case 'b':
*d++ = '\b';
break;
case '\'':
*d++ = '\'';
break;
case '\"':
*d++ = '\"';
break;
case 'a':
*d++ = '\a';
break;
case 'f':
*d++ = '\f';
break;
case '\\':
*d++ = '\\';
break;
case 'x': // hex
if (is_hexdigit(*(p + 1)) && is_hexdigit(*(p + 2))) {
int c = 0;
p++;
if (is_digit(*p))
c |= ((*p - '0') << 4);
else
c |= (((to_upper(*p) - 'A') + 10) << 4);
p++;
if (is_digit(*p))
c |= *p - '0';
else
c |= (to_upper(*p) - 'A') + 10;
*d++ = c;
} else
*d++ = '\0';
break;
case '0': // oct
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
if (is_octdigit(*(p + 1)) && is_octdigit(*(p + 2))) {
int c = 0;
c |= ((*p - '0') << 6);
p++;
c |= ((*p - '0') << 3);
p++;
c |= (*p - '0');
*d++ = c;
} else
*d++ = '\0';
break;
default:
*d++ = *p;
}
p++;
} else
*d++ = *p++;
}
*d = '\0';
return buf;
}
/**
* basic-string to c-string convertion
*/
char *bstrdup(const char *source) {
char *buf, *p, *d;
buf = tmp_alloc(strlen(source) * 4 + 1);
p = (char *) source;
d = buf;
while (*p) {
if (*p < 32 && *p >= 0) {
switch (*p) {
case '\033':
*d++ = '\\';
*d++ = 'e';
break;
case '\v':
*d++ = '\\';
*d++ = 'v';
break;
case '\t':
*d++ = '\\';
*d++ = 't';
break;
case '\r':
*d++ = '\\';
*d++ = 'r';
break;
case '\n':
*d++ = '\\';
*d++ = 'n';
break;
case '\b':
*d++ = '\\';
*d++ = 'b';
break;
case '\'':
*d++ = '\\';
*d++ = '\'';
break;
case '\"':
*d++ = '\\';
*d++ = '\"';
break;
case '\a':
*d++ = '\\';
*d++ = 'a';
break;
case '\f':
*d++ = '\\';
*d++ = 'f';
break;
case '\\':
*d++ = '\\';
*d++ = '\\';
break;
default:
*d++ = '\\';
*d++ = 'x';
*d++ = to_hexdigit((*p & 0xF0) >> 4);
*d++ = to_hexdigit(*p & 0xF);
}
p++;
} else
*d++ = *p++;
}
*d = '\0';
return buf;
}
/**
*
*/
const char *baseof(const char *source, int delim) {
const char *p;
p = strrchr(source, delim);
if (p) {
return p + 1;
}
return source;
}
/**
*
*/
char char_table_replace(const char *what_table, int ch, const char *replace_table) {
const char *p;
p = strchr(what_table, ch);
if (!p) {
return ch;
}
return *(replace_table + (p - what_table));
}
