mirror of https://github.com/ksherlock/x65.git
5259 lines
152 KiB
C++
5259 lines
152 KiB
C++
/*
|
|
String User Classes
|
|
|
|
The MIT License (MIT)
|
|
|
|
Copyright (c) 2015 Carl-Henrik Skårstedt
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy of this software
|
|
and associated documentation files (the "Software"), to deal in the Software without restriction,
|
|
including without limitation the rights to use, copy, modify, merge, publish, distribute,
|
|
sublicense, and/or sell copies of the Software, and to permit persons to whom the Software
|
|
is furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in all copies or
|
|
substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
|
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
|
|
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
|
|
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
https://github.com/sakrac/struse
|
|
|
|
Add this #define to *one* C++ file before #include "struse.h" to create the implementation:
|
|
|
|
#define STRUSE_IMPLEMENTATION
|
|
|
|
// in other words, this sequence should be at the top of one file:
|
|
#include ...
|
|
#define STRUSE_IMPLEMENTATION
|
|
#include "struse.h"
|
|
*/
|
|
|
|
#ifndef __STRUSE_H__
|
|
#define __STRUSE_H__
|
|
|
|
#include <inttypes.h> // uint32_t etc.
|
|
#include <string.h> // memcpy, memmove
|
|
#include <stdio.h> // printf, vsnprintf
|
|
#include <stdarg.h> // va_list
|
|
|
|
//
|
|
// Naming Rules:
|
|
//
|
|
// find* returns a position of a string where a match if found or -1 if not
|
|
// skip*/clip* trims beginning or end of string based on condition
|
|
// get_* returns a property, single character or substring
|
|
// before*/after* returns a substring matching the condition
|
|
// is_* returns a bool for a character or whole string test
|
|
// len_* return the number of characters matching the condition from the start of the string
|
|
// *_last indicates that search is done from the end of the string
|
|
// *_rh indicates a rolling hash search is used
|
|
// *_esc indicates that the search string allows for escape codes (\x => x)
|
|
// same_str* is a full string compare and returns true or false based on condtions
|
|
// *_range indicates that the result is filtered by a given set of valid characters
|
|
//
|
|
|
|
typedef unsigned int strl_t;
|
|
|
|
// helper defines for sprintf/printf with strop
|
|
// example: printf("string is " STROP_FMT "\n", STROP_ARG(strref))
|
|
#define STRREF_FMT "%.*s"
|
|
#define STRREF_ARG(s) (int)(s).get_len(), (s).get()
|
|
|
|
// internal helper functions for strref
|
|
int _find_rh(const char *text, strl_t len, const char *comp, strl_t comp_len);
|
|
int _find_rh_case(const char *text, strl_t len, const char *comp, strl_t comp_len);
|
|
|
|
// strref holds a reference to a constant substring (const char*)
|
|
class strref {
|
|
protected:
|
|
const char *string;
|
|
strl_t length;
|
|
|
|
public:
|
|
strref() { clear(); }
|
|
strref(const char *str) { set(str); }
|
|
strref(char *str) { set((const char*)str); }
|
|
strref(const char *str, strl_t len) : string(str), length(len) {}
|
|
strref(const char *str, int len) : string(str), length(strl_t(len)) {}
|
|
strref(char *str, int len) : string((const char*)str), length(strl_t(len)) {}
|
|
strref(char *str, strl_t len) : string((const char*)str), length(len) {}
|
|
|
|
bool valid() const { return string && length; }
|
|
void clear() { string = nullptr; length = 0; }
|
|
void set(const char *str);
|
|
const char* get() const { return string; }
|
|
const uint8_t* get_u() const { return (const uint8_t*)string; }
|
|
strl_t get_len() const { return length; }
|
|
char get_first() const { return (string && length) ? *string : 0; }
|
|
char get_last() const { return (string && length) ? string[length-1] : 0; }
|
|
char pop_first() { if (length && string) { char c = *string++; --length; return c; } return 0; }
|
|
|
|
strl_t limit_pos(strl_t pos) { return pos<length ? pos : length; }
|
|
|
|
bool is_substr(const char *sub) const { return sub>=string && sub<=(string+length); }
|
|
strl_t substr_offs(strref substr) const {
|
|
if (is_substr(substr.get())) return strl_t(substr.get()-get()); return 0; }
|
|
strl_t substr_end_offs(strref substr) const {
|
|
if (is_substr(substr.get())) return strl_t(substr.get()-get()) + substr.get_len(); return 0; }
|
|
bool is_empty() const { return length==0; }
|
|
|
|
// get fnv1a hash for string
|
|
unsigned int fnv1a(unsigned int seed = 2166136261) const;
|
|
unsigned int fnv1a_lower(unsigned int seed = 2166136261) const;
|
|
unsigned int fnv1a_append(unsigned int base_fnv1a_hash) const { return fnv1a(base_fnv1a_hash); }
|
|
unsigned short fnv1a_16( unsigned int seed = 2166136261 ) const;
|
|
uint64_t fnv1a_64(uint64_t seed = 14695981039346656037ULL) const;
|
|
|
|
// whitespace ignore fnv1a (any sequence whitespace is replaced by one space)
|
|
unsigned int fnv1a_ws(unsigned int seed = 2166136261) const;
|
|
|
|
// convert string to basic integer
|
|
int64_t atoi() const;
|
|
uint64_t atoui() const;
|
|
|
|
// convert string to floating point
|
|
float atof() const;
|
|
double atod() const;
|
|
|
|
// number of characters of basic integer in string
|
|
int atoi_skip();
|
|
|
|
// convert hexadecimal string to signed integer
|
|
int ahextoi() const;
|
|
|
|
// convert hexadecimal string to unsigned integer
|
|
size_t ahextoui() const;
|
|
uint64_t ahextou64() const;
|
|
size_t ahextoui_skip();
|
|
size_t abinarytoui_skip();
|
|
|
|
// output string with newline (printf)
|
|
void writeln();
|
|
|
|
// single digit number
|
|
static char num_to_char(uint8_t num) { return num<10 ? (num+'0'):(num+'a'-10); }
|
|
|
|
// is character empty such as space, tab, linefeed etc.?
|
|
static bool is_ws(uint8_t c) { return c <= ' '; }
|
|
static bool is_ws(char c) { return (uint8_t)c <= ' '; }
|
|
|
|
// is character a number?
|
|
static bool is_number(uint8_t c) { return c>='0' && c<='9'; }
|
|
static bool is_number(char c) { return (uint8_t)c>='0' && (uint8_t)c<='9'; }
|
|
|
|
// is character a hexadecimal number?
|
|
static bool is_hex(uint8_t c) { return is_number(c) || (c>='A' && c<='F') || (c>='a' && c<='f'); }
|
|
static bool is_hex(char c) { return is_hex(uint8_t(c)); }
|
|
|
|
// is character alphabetic (A-Z or a-z)?
|
|
static bool is_alphabetic(uint8_t c) { return (c>='a' && c<='z') || (c>='A' && c<='Z'); }
|
|
|
|
// is character alphabetic or numeric?
|
|
static bool is_alphanumeric(uint8_t c) { return is_number(c) || is_alphabetic(c); }
|
|
|
|
// is character valid as part of a label? (num, _, A-Z, a-z)
|
|
static bool is_valid_label(uint8_t c) { return c=='_' || is_alphanumeric(c); }
|
|
|
|
// word separators are non-alphanumeric characters except apostrophe.
|
|
static bool is_sep_ws(uint8_t c) { return c!='\'' && !is_alphanumeric(c); }
|
|
static bool is_sep_ws(char c) { return is_sep_ws(uint8_t(c)); }
|
|
|
|
// is control character? (!-/, ?-@, [-^, {-~)
|
|
static bool is_control(uint8_t c) { return !is_ws(c) && !is_alphanumeric(c) && c!='_'; }
|
|
|
|
// choice of upper/lowercase conversions
|
|
static char tolower(char c);
|
|
static char toupper(char c);
|
|
static char tolower_win(char c);
|
|
static char toupper_win(char c);
|
|
static char tolower_amiga(char c);
|
|
static char toupper_amiga(char c);
|
|
static char tolower_macos(char c);
|
|
static char toupper_macos(char c);
|
|
static size_t tolower_unicode(int c);
|
|
static size_t toupper_unicode(int c);
|
|
|
|
// operators
|
|
// strref += int: move string forward (skip)
|
|
void operator+=(const strl_t skip) { if (skip<length) { string += skip; length -= skip; } else clear(); }
|
|
void operator+=(const int skip) { if (strl_t(skip)<length) { string += skip; length -= strl_t(skip); } else clear(); }
|
|
|
|
// strref + int: return a string that is moved forward (skip)
|
|
strref operator+(const strl_t skip) { if (skip<length) return strref(string+skip, length-skip); return strref(); }
|
|
strref operator+(const int skip) { if (skip>=0 && strl_t(skip)<length) return strref(string+skip, length-skip); return strref(); }
|
|
|
|
// (bool): check if string is valid (0 length strings are invalid)
|
|
operator bool() const { return string && length; }
|
|
|
|
// strref++: skip string forward by one character
|
|
strref& operator++() { if (valid()) { string++; length--; } return *this; }
|
|
|
|
// strref > strref / strref < strref: greater than and lesser than operators
|
|
bool operator>(const strref o) const;
|
|
bool operator<(const strref o) const;
|
|
|
|
// strref[int]: get character at position
|
|
char operator[](strl_t pos) const { return pos<length ? string[pos] : 0; }
|
|
char operator[](int pos) const { return (strl_t)pos<length ? string[pos] : 0; }
|
|
|
|
// remove from start or end
|
|
void skip(strl_t count) { if (count<length) { string += count; length -= count; } else clear(); }
|
|
void clip(strl_t count) { if (count<length) { length -= count; } else clear(); }
|
|
|
|
// check if there are any potential non-text characters in the string
|
|
bool valid_ascii7() const;
|
|
|
|
// fetch a utf-8 character from the beginning of this string
|
|
size_t get_utf8() const;
|
|
|
|
// fetch a utf-8 character from the beginnning of this string and move cursor forward to the next utf-8 character
|
|
size_t pop_utf8();
|
|
|
|
// return character at position
|
|
char get_at(strl_t pos) const { return string && pos<length ? string[pos] : 0; }
|
|
char get_at(int pos) const { return string && (strl_t)pos<length ? string[pos] : 0; }
|
|
|
|
// return uint8_tacter at position
|
|
uint8_t get_u_at(strl_t pos) const { return (uint8_t)get_at(pos); }
|
|
|
|
// is there a whitespace at position offs in the string?
|
|
bool whitespace_at(strl_t pos) const { return is_ws(get_u_at(pos)); }
|
|
|
|
// count occurrences of char c
|
|
int count_char(char c) const;
|
|
|
|
// count characters to end of line
|
|
strl_t len_eol() const;
|
|
|
|
// characters start of next line (may be end of string)
|
|
strl_t len_next_line() const;
|
|
|
|
// count characters that can be converted to a floating point number
|
|
strl_t len_float_number() const;
|
|
|
|
// count characters that can be converted to a hexadecimal number
|
|
strl_t len_hex() const;
|
|
|
|
// check if string is a valid floating point number
|
|
bool is_float_number() const { return valid() && len_float_number() == length; }
|
|
|
|
// check if matching first char and skip if match
|
|
bool grab_char( char c ) { if(length && string[0]==c) { length--; string++; return true; } return false; }
|
|
|
|
// wildcard search
|
|
strref find_wildcard(const strref wild, strl_t pos = 0, bool case_sensitive = true) const;
|
|
strref next_wildcard(const strref wild, strref prev, bool case_sensitive = true) const {
|
|
return find_wildcard(wild, is_substr(prev.get()) ? (strl_t(prev.get()-get())+1) : 0, case_sensitive); }
|
|
strref wildcard_after(const strref wild, strref prev, bool case_sensitive = true) const {
|
|
return find_wildcard(wild, is_substr(prev.get()) ? strl_t(prev.get()+prev.get_len()-get()) : 0, case_sensitive); }
|
|
|
|
// character filter by string, as in a wildcard [] operator
|
|
bool char_matches_ranges(uint8_t c) const;
|
|
bool char_matches_ranges(char c) const { return char_matches_ranges((uint8_t)c); }
|
|
|
|
// whole string compare (_case indicates case sensitive)
|
|
bool same_str(const strref str) const;
|
|
bool same_str_case(const strref str) const;
|
|
bool same_str(const char *str) const;
|
|
bool same_str_case(const char *str);
|
|
|
|
// whole string compare, treat character same1 and same2 as equal
|
|
bool same_str(const strref str, char same1, char same2) const;
|
|
bool same_str_case(const strref str, char same1, char same2) const;
|
|
|
|
// mid string compare
|
|
bool same_substr(const strref str, strl_t pos) const;
|
|
bool same_substr_esc(const strref str, strl_t pos) const;
|
|
bool same_substr_case(const strref str, strl_t pos) const;
|
|
bool same_substr_case_esc(const strref str, strl_t pos) const;
|
|
bool same_substr_case_esc(const strref str, int pos) const { return same_substr_case_esc(str, (strl_t)pos); }
|
|
bool same_substr_case_esc_range(const strref str, const strref range, strl_t pos) const;
|
|
|
|
// prefix compare
|
|
strl_t prefix_len(const strref str) const;
|
|
strl_t prefix_len_case(const strref str) const;
|
|
strl_t prefix_len(const char *str) const;
|
|
strl_t prefix_len_case(const char *str) const;
|
|
strl_t prefix_len(const strref str, char same1, char same2) const;
|
|
bool has_prefix(const strref str) const { return prefix_len(str) == str.get_len(); }
|
|
bool has_prefix(const char* str) const { return str[prefix_len(str)]==0; }
|
|
bool is_prefix_of(const strref str) const { return prefix_len(str)==get_len(); }
|
|
bool is_prefix_of(const strref str, char same1, char same2) const {
|
|
return prefix_len(str, same1, same2)==get_len(); }
|
|
bool is_prefix_word(const strref str) const { return prefix_len(str)==get_len() &&
|
|
(str.get_len()==length || !is_alphanumeric((uint8_t)str[length])); }
|
|
bool is_prefix_case_of(const strref str) const { return prefix_len_case(str)==get_len(); }
|
|
bool is_prefix_float_number() const { return len_float_number() > 0; }
|
|
bool grab_prefix( const char* str ) { strl_t p = prefix_len( str ); if( !str[ p ] ) { skip( p ); return true; } return false; }
|
|
|
|
// suffix compare
|
|
strl_t suffix_len(const strref str) const;
|
|
strl_t suffix_len_case(const strref str) const;
|
|
bool is_suffix_of(const strref str) const { return suffix_len(str)==get_len(); }
|
|
bool is_suffix_case_of(const strref str) { return suffix_len_case(str)==get_len(); }
|
|
bool has_suffix(const char *str) const { return strref(str).is_suffix_of(*this); }
|
|
|
|
// whole word compare (prefix match + next char is whitespace or end of string)
|
|
bool is_word(const strref str) const { return prefix_len(str)==str.get_len() && whitespace_at(str.get_len()); }
|
|
bool is_word_case(const strref str) const { return prefix_len_case(str)==str.get_len() && whitespace_at(str.get_len()); }
|
|
|
|
// string search
|
|
|
|
// find first index of char c
|
|
int find(char c) const;
|
|
|
|
// find first index of char c after pos
|
|
int find_at(char c, strl_t pos) const;
|
|
|
|
// find first index of char c after index pos (find_at(c, pos+1))
|
|
int find_after(char c, strl_t pos) const;
|
|
|
|
// find first index of char c after index pos or return length for full string
|
|
strl_t find_or_full(char c, strl_t pos) const;
|
|
strl_t find_or_full_esc(char c, strl_t pos) const;
|
|
|
|
// find last position of char c
|
|
int find_last(char c) const;
|
|
|
|
// find first position of either char c or char d
|
|
int find(char c, char d) const;
|
|
|
|
// find last position of either char c or char d
|
|
int find_last(char c, char d) const;
|
|
|
|
// find first <b> after last <a> in string
|
|
int find_after_last(char a, char b) const { return find_after(b, (strl_t)(find_last(a)+1)); }
|
|
int find_after_last(char a1, char a2, char b) const {
|
|
int w = find_last(a1, a2)+1; int l = strref(string+w, length-w).find(b); return l>=0?l+w:-1; }
|
|
|
|
// return position in this string of the first occurrence of the argument or negative if not found, not case sensitive
|
|
int find(const strref str) const;
|
|
int find(const strref str, strl_t pos) const; // find first instance after pos
|
|
int find_bookend(const strref str, const strref bookend) const;
|
|
|
|
// return position in this string of the first occurrence of the argument or negative if not found, not case sensitive
|
|
int find(const char *str, strl_t pos = 0) const;
|
|
strl_t find_or_full(const char *str) const { int f = find(str); return f < 0 ? length : strl_t(f); }
|
|
|
|
// return position in this string of the first occurrence of the argument or negative if not found, case sensitive
|
|
int find_case(const strref str, strl_t pos = 0) const;
|
|
|
|
// return position in this string of the first occurrence of the argument or negative if not found, case sensitive
|
|
int find_case(const char *str) const;
|
|
int find_case_esc(const strref str, strl_t pos) const;
|
|
int find_case_esc_range(const strref str, const strref range, strl_t pos) const;
|
|
int find_esc_range(const strref str, const strref range, strl_t pos) const;
|
|
|
|
// return position in this string of the last occurrence of the argument or negative if not found, not case sensitive
|
|
int find_last(const strref str) const;
|
|
int find_last_bookend(const strref str, const strref bookend) const;
|
|
|
|
// return position in this string of the last occurrence of the argument or negative if not found, not case sensitive
|
|
int find_last(const char *str) const;
|
|
|
|
// return position in this string of the last occurrence of the argument or negative if not found, case sensitive
|
|
int find_last_case(const strref str) const;
|
|
|
|
// find first instance after pos allowing escape codes in search string
|
|
int find_esc(const strref str, strl_t pos) const;
|
|
|
|
// find any char from str in this string at position
|
|
int find_any_char_of(const strref range, strl_t pos = 0) const;
|
|
|
|
// find any char from str or char range or char - with backslash prefix
|
|
int find_any_char_or_range(const strref range, strl_t pos = 0) const;
|
|
int find_any_not_in_range(const strref range, strl_t pos = 0) const;
|
|
|
|
// find any char from str or char range or char - with backslash prefix
|
|
int find_range_char_within_range(const strref range_find, const strref range_within, strl_t pos = 0) const;
|
|
|
|
// find but not within parenthesis
|
|
int find_skip_parens(char token) const;
|
|
|
|
// counts
|
|
int substr_count(const strref str) const; // count the occurrences of the argument in this string
|
|
int substr_count_bookend(const strref str, const strref bookend) const;
|
|
int substr_case_count(const strref str) const; // count the occurrences of the argument in this string
|
|
int substr_label_case_count(const strref str) const;
|
|
int count_repeat(char c, strl_t pos) const;
|
|
int count_repeat_reverse(char c, strl_t pos) const;
|
|
int count_lines() const;
|
|
int count_lines(strl_t pos) const { return strref(string, pos<length ? pos : length).count_lines(); }
|
|
int count_lines(strref substring) const { return is_substr(substring.get()) ?
|
|
count_lines(strl_t(substring.get()-get())) : -1; }
|
|
|
|
strl_t prev_line_pos( strl_t pos );
|
|
strl_t start_line_pos( strl_t pos );
|
|
strl_t end_line_pos( strl_t pos );
|
|
|
|
// rolling hash find
|
|
int find_rh(strref str) const { return _find_rh(get(), get_len(), str.get(), str.get_len()); }
|
|
int find_rh_case(strref str) const {
|
|
return _find_rh_case(get(), get_len(), str.get(), str.get_len()); }
|
|
|
|
int find_rh(strref str, strl_t pos) const {
|
|
strref sub = *this; sub += pos; return sub.find_rh(str); }
|
|
|
|
int find_rh_case(strref str, strl_t pos) const {
|
|
strref sub = *this; sub += pos; return sub.find_rh_case(str); }
|
|
|
|
int find_rh_after(strref str, strref prev) const {
|
|
strref sub = *this; if (is_substr(prev.get())) sub.skip(strl_t(prev.get()-get()));
|
|
return sub.find_rh(str); }
|
|
|
|
int find_rh_case_after(strref str, strref prev) const {
|
|
strref sub = *this; if (is_substr(prev.get())) sub.skip(strl_t(prev.get()-get()));
|
|
return sub.find_rh_case(str); }
|
|
|
|
// whitespace management
|
|
|
|
// number of white space characters from start of string
|
|
strl_t len_whitespace() const { if (!valid()) return 0;
|
|
strl_t o = 0; while (o<length && is_ws((uint8_t)string[o])) o++; return o; }
|
|
|
|
// number of white space characters from pos
|
|
strl_t len_whitespace(strl_t pos) const {
|
|
strl_t o = pos; while (o<length && is_ws((uint8_t)string[o])) o++; return o-pos; }
|
|
|
|
// number of separator or white space characters from pos
|
|
strl_t len_sep_ws(strl_t pos) const {
|
|
strl_t o = pos; while (o<length && is_sep_ws((uint8_t)string[o])) o++; return o-pos; }
|
|
|
|
strl_t len_sep_ws(int pos) const { return len_sep_ws((strl_t)pos); }
|
|
|
|
// number of non white space characters from start of string
|
|
strl_t len_grayspace() const { if (!valid()) return 0;
|
|
strl_t o = 0; while (o<length && !is_ws((uint8_t)string[o])) o++; return o; }
|
|
|
|
// number of non white space characters from pos
|
|
strl_t len_grayspace(strl_t pos) const {
|
|
strl_t o = pos; while (o<length && !is_ws((uint8_t)string[o])) o++; return o-pos; }
|
|
|
|
// number of non separating non white space characters from pos
|
|
strl_t len_non_sep_ws(strl_t pos) const {
|
|
strl_t o = pos; while (o<length && !is_sep_ws((uint8_t)string[o])) o++; return o-pos; }
|
|
|
|
strl_t len_non_sep_ws(int pos) const { return len_non_sep_ws((strl_t)pos); }
|
|
|
|
// move string forward to the first non-whitespace character
|
|
void skip_whitespace() { skip(len_whitespace()); }
|
|
|
|
// move string forward to the first whitespace character
|
|
void skip_to_whitespace() { skip(len_grayspace()); }
|
|
|
|
// if bom detected skip it
|
|
strref skip_bom();
|
|
|
|
// cut white space characters at end of string
|
|
void clip_trailing_whitespace() { if (valid()) {
|
|
const char *e = string+length; while (*--e<=0x20 && length) { length--; } } }
|
|
|
|
// remove white space from start and end
|
|
void trim_whitespace() { clip_trailing_whitespace(); skip_whitespace(); }
|
|
|
|
strref get_trimmed_ws() const { strref ret = *this;
|
|
ret.clip_trailing_whitespace(); ret.skip_whitespace(); return ret; }
|
|
|
|
// find next whitespace or entire string
|
|
strl_t find_whitespace_or_full() const {
|
|
strl_t ws = (strl_t)len_grayspace(); return (ws==length) ? 0 : ws; }
|
|
|
|
// find next whitespace or -1
|
|
int find_whitespace() const {
|
|
strl_t ws = len_grayspace(); return (ws==length) ? -1 : (int)ws; }
|
|
|
|
// string content
|
|
// count number of alphanumeric characters from p
|
|
strl_t len_alphanumeric(strl_t p = 0) const { if (valid()) {
|
|
const char *s = string+p; strl_t r = length-p; while (is_alphanumeric((uint8_t)*s) && r) { s++; r--; }
|
|
return length-r; } return 0; }
|
|
|
|
// length of word consisting of alphanumeric characters
|
|
strl_t len_word() const { return len_alphanumeric(0); }
|
|
|
|
// length of string with escape characters
|
|
strl_t len_esc() const;
|
|
|
|
// return number of characters that can be a label
|
|
strl_t len_label() const { if (valid()) { const uint8_t *s = get_u(); strl_t r = length;
|
|
while (is_valid_label(*s) && r) { s++; r--; } return length-r; } return 0; }
|
|
|
|
// return whether or not this string is a number
|
|
bool is_number() const { if (strl_t r = length) { if (const uint8_t *s = get_u()) {
|
|
while (r) { if (!is_number(*s)) return false; s++; r--; } return true; } } return false; }
|
|
|
|
// go to the next word
|
|
void next_word_ws() { skip_whitespace(); skip_to_whitespace(); skip_whitespace(); }
|
|
|
|
// go to the end of this word
|
|
void end_word() { strl_t a = len_word(); string += a; length -= a; }
|
|
|
|
// get a portion of a string
|
|
strref get_substr(strl_t pos, strl_t len) const { return pos<length ?
|
|
(strref(string+pos, (pos+len)<length?len : (length-pos))) : strref(); }
|
|
|
|
strref get_substr(int pos, int len) const { return get_substr((strl_t)pos, (strl_t)len); }
|
|
strref get_substr(int pos, strl_t len) const { return get_substr((strl_t)pos, len); }
|
|
|
|
strref get_skipped(strl_t len) const { if (len<length)
|
|
return strref(string+len, length-len); return strref(); }
|
|
|
|
// get this strref without leading whitespace
|
|
strref get_skip_ws() const { return get_skipped(len_whitespace()); }
|
|
|
|
strref get_clipped(strl_t len) const { return strref(len>0?string:nullptr,
|
|
len>0?(strl_t(len)<length?len:length):0); }
|
|
|
|
strref get_word() const { return get_clipped(len_word()); }
|
|
|
|
// get a range of characters matching the range
|
|
strref get_range_word(const strref range, strl_t pos = 0) const;
|
|
|
|
// get the next block of characters separated by whitespace
|
|
strref get_word_ws() const {
|
|
strl_t w = len_whitespace(), g = len_grayspace(w); return get_substr(w, g - w); }
|
|
|
|
strref get_valid_json_string() const {
|
|
const uint8_t *s = get_u(); strl_t l = length; while (l) {
|
|
uint8_t c = *s++; if (!(c=='+' || c=='.' || c=='-' || is_number(c) || c>='A'))
|
|
break; l--; } return strref(string, length-l); }
|
|
|
|
strref before(char c) const {
|
|
int o = find(c); if (o>=0) return strref(string, o); return strref(); }
|
|
|
|
strref before(char c, char d) const {
|
|
int o = find(c, d); if (o>=0) return strref(string, o); return strref(); }
|
|
|
|
strref before_or_full(char c) const {
|
|
int o = find(c); if (o>=0) return strref(string, o); return *this; }
|
|
|
|
strref before_or_full_track_parens(char c) const {
|
|
int o = find_skip_parens(c); if (o >= 0) return strref(string, o); return *this;
|
|
}
|
|
|
|
strref before_last(char c) const {
|
|
int o = find_last(c); if (o>=0) return strref(string, o); return strref(); }
|
|
|
|
strref before_last(char c, char d) const {
|
|
int o = find_last(c, d); if (o>=0) return strref(string, o); return strref(); }
|
|
|
|
strref before_or_full(const strref str) const {
|
|
int o = find(str); if (o<0) return *this; return strref(string, o); }
|
|
|
|
strref after_or_full(const strref str) const {
|
|
int o = find(str); if (o<0) return *this; return strref(string+o, length-o); }
|
|
|
|
strref after_or_full(char c) const { int o = find(c);
|
|
if (o>=0) return strref(string+o+1, length-o-1); return *this; }
|
|
|
|
strref after_or_full(char c, char d) const { int o = find(c, d);
|
|
if (o>=0) return strref(string+o+1, length-o-1); return *this; }
|
|
|
|
strref after(char c) const { int o = find(c);
|
|
if (o>=0) return strref(string+o+1, length-o-1); return strref(); }
|
|
|
|
strref after_last_or_full(char c) const { int o = find_last(c);
|
|
if (o>=0) return strref(string+o+1, length-o-1); return *this; }
|
|
|
|
strref after_last_or_full(char c, char d) const {
|
|
int o = find_last(c, d); if (o>=0) return strref(string+o+1, length-o-1); return *this; }
|
|
|
|
strref after_last(char c) const { int o = find_last(c); if (o>=0)
|
|
return strref(string+o+1, length-o-1); return strref(); }
|
|
|
|
strref after_last(char c, char d) const { int o = find_last(c, d); if (o>=0)
|
|
return strref(string+o+1, length-o-1); return strref(); }
|
|
|
|
strref get_alphanumeric() const { strref r(*this); r.skip_whitespace();
|
|
if (strl_t l = r.len_alphanumeric()) return strref(string, l); return strref(); }
|
|
|
|
strref get_label() const { return strref(string, len_label()); }
|
|
|
|
strref before_or_full_case(const strref str) const { int o = find_case(str);
|
|
if (o<0) return *this; return strref(string, o); }
|
|
|
|
strref after_or_full_case(const strref str) const { int o = find_case(str);
|
|
if (o<0) return *this; return strref(string+o, length-o); }
|
|
|
|
strref between(char c, char d) { int s = find(c); if (s>=0) { int e = find_after(d, (strl_t)s);
|
|
if (e>=0) return get_substr(strl_t(s+1), strl_t(e-s-1)); } return strref(); }
|
|
|
|
// tokenization
|
|
strref split(strl_t pos);
|
|
strref split(int pos);
|
|
strref split_token(char c);
|
|
strref split_token_any(const strref chars);
|
|
strref split_token_trim(char c);
|
|
strref split_token_any_trim(const strref chars);
|
|
strref split_token_track_parens(char c);
|
|
strref split_token_track_parens_quote(char c);
|
|
strref split_token_trim_track_parens(char c);
|
|
strref split_range(const strref range, strl_t pos=0);
|
|
strref split_range_trim(const strref range, strl_t pos=0);
|
|
strref split_label();
|
|
strref split_lang();
|
|
strref split_num();
|
|
|
|
// get a snippet, previous and full current line around a position
|
|
strref get_snippet( strl_t pos );
|
|
|
|
// grab a block of text starting with (, [ or { and end with the corresponding number of ), ] or }
|
|
strref scoped_block_skip( bool quotes = false );
|
|
|
|
// scoped_block_skip with C style comments
|
|
strl_t scoped_block_comment_len();
|
|
strl_t scoped_block_utf8_comment_len();
|
|
strref scoped_block_comment_skip(bool include = false) { strref ret = split(scoped_block_comment_len()); if (!include) { ++ret; ret.clip(1); } return ret; }
|
|
strref scoped_block_utf8_comment_skip( bool include = false ) {
|
|
strref ret = split( scoped_block_utf8_comment_len() );
|
|
if( !include ) { ++ret; ret.clip( 1 ); }
|
|
return ret;
|
|
}
|
|
|
|
// check matching characters that are terminated by any character in term or ends
|
|
strl_t match_chars_str(const strref match, const strref term = strref());
|
|
|
|
strref get_line() const; // return the current line even if empty,t don't change this line
|
|
strref get_line(strl_t line) const; // return line by index
|
|
strref next_line(); // return the current line even if empty and skip this to line after
|
|
strref line() { strref ret; while (valid() && !ret.valid()) ret = next_line(); return ret; } // return the current or next valid line skip this to line after
|
|
strref next_token(char c) { int o = find(c); if (o<0) o = (int)get_len(); return split(o); }
|
|
strref token_chunk(char c) const { int o = find(c); if (o<0) return *this; return strref(string, o); }
|
|
void token_skip(const strref chunk) { skip(chunk.length+1); }
|
|
strref find_token(const char *substr, char token) const;
|
|
strref find_token_case(const char *substr, char token) const;
|
|
strref find_token(strref substr, char token) const;
|
|
strref find_token_case(strref substr, char token) const;
|
|
strref within_last(char a, char b) const { int f = find_last(a)+1;
|
|
int l = strref(string+f, length-f).find(b); if (l<0) l = 0; return strref(string+f, l); }
|
|
strref within_last(char a1, char a2, char b) const { int f = find_last(a1, a2)+1;
|
|
int l = strref(string+f, length-f).find(b); if (l<0) l = 0; return strref(string+f, l); }
|
|
|
|
strref get_quote_xml() const;
|
|
strref skip_quote_xml();
|
|
int find_quoted_xml(char d) const; // returns length up to the delimiter d with xml quotation rules, or -1 if delimiter not found
|
|
int find_quoted(char d) const; // returns length up to the delimiter d with c/c++ quotation rules, or -1 if delimiter not found
|
|
|
|
strref next_chunk_xml(char open, char close) const { int s = find_quoted_xml(open);
|
|
if (s<0) return strref(); strref left = get_skipped(strl_t(s+1)); return left.get_clipped(strl_t(left.find_quoted_xml(close))); }
|
|
strref next_chunk_quoted(char open, char close) const { int s = find_quoted(open);
|
|
if (s<0) return strref(); strref left = get_skipped(strl_t(s+1)); return left.get_clipped(strl_t(left.find_quoted(close))); }
|
|
void skip_chunk(const strref chunk) { strl_t add = strl_t(chunk.string-string)+chunk.length+1UL;
|
|
if (add<length) { string += add; length -= add; } else { clear(); } }
|
|
};
|
|
|
|
// internal helper functions for strmod
|
|
strl_t _strmod_copy(char *string, strl_t cap, const char *str);
|
|
strl_t _strmod_copy(char *string, strl_t cap, strref str);
|
|
strl_t _strmod_append(char *string, strl_t length, strl_t cap, const char *str);
|
|
strl_t _strmod_append(char *string, strl_t length, strl_t cap, strref str);
|
|
strl_t _strmod_insert(char *string, strl_t length, strl_t cap, const strref sub, strl_t pos);
|
|
strl_t _strmod_utf8_tolower(char *string, strl_t length, strl_t cap);
|
|
strl_t _strmod_write_utf8( char *string, strl_t cap, size_t code, strl_t pos );
|
|
void _strmod_substrcopy(char *string, strl_t length, strl_t cap, strl_t src, strl_t dst, strl_t chars);
|
|
void _strmod_tolower(char *string, strl_t length);
|
|
void _strmod_toupper(char *string, strl_t length);
|
|
strl_t _strmod_format_insert(char *string, strl_t length, strl_t cap, strl_t pos, strref format, const strref *args);
|
|
strl_t _strmod_append_num(char* str, strl_t left, uint32_t num, strl_t size, uint32_t radix);
|
|
strl_t _strmod_remove(char *string, strl_t length, char a);
|
|
strl_t _strmod_remove(char *string, strl_t length, strl_t start, strl_t len);
|
|
strl_t _strmod_exchange(char *string, strl_t length, strl_t cap, strl_t start, strl_t size, const strref insert);
|
|
strl_t _strmod_cleanup_path(char *file, strl_t len);
|
|
strl_t _strmod_relative_path(char *out, strl_t cap, strref orig, strref target);
|
|
|
|
// intermediate template class to support writeable string classes. use strown or strovl which inherits from this.
|
|
template <class B> class strmod : public B {
|
|
// mirror base class unsafe size operations (doesn't check capacity)
|
|
void add_len_int(strl_t l) { B::add_len_int(l); }
|
|
void sub_len_int(strl_t l) { B::sub_len_int(l); }
|
|
void set_len_int(strl_t l) { B::set_len_int(l); }
|
|
void dec_len_int() { B::dec_len_int(); }
|
|
void inc_len_int() { B::inc_len_int(); }
|
|
public:
|
|
strmod() { clear(); }
|
|
operator strref() { return strref(charstr(), len()); }
|
|
|
|
// mirror base template class
|
|
strl_t cap() const { return B::cap(); }
|
|
char* charstr() { return B::charstr(); }
|
|
const char* charstr() const { return B::charstr(); }
|
|
strl_t len() const { return B::len(); }
|
|
|
|
// get a strref version of this string
|
|
strref get_strref() { return strref(charstr(), len()); }
|
|
strref get_strref() const { return strref(charstr(), len()); }
|
|
strl_t get_len() const { return B::len(); }
|
|
|
|
// basic tests and operations
|
|
void clear() { set_len_int(0); }
|
|
bool valid() const { return charstr() && len(); }
|
|
operator bool() const { return valid(); }
|
|
bool empty() const { return !len(); }
|
|
bool full() const { return len() == cap(); }
|
|
const char* get() const { return charstr(); }
|
|
char get_first() const { return (charstr() && len()) ? *charstr() : 0; }
|
|
char get_last() const { return (charstr() && len()) ? charstr()[len()-1] : 0; }
|
|
void copy(strref o) { set_len_int(_strmod_copy(charstr(), cap(), o)); }
|
|
bool is_substr(const char *sub) const { return sub>=charstr() && sub<=(charstr()+len()); }
|
|
|
|
// public size operators (checks for capacity)
|
|
strl_t fit_add(strl_t desired) { return (desired+len()) < cap() ? desired : (cap()-len()); }
|
|
bool set_len(strl_t l) { if (l<=cap()) { set_len_int(l); return true; } set_len_int(cap()); return false; }
|
|
void add_len(strl_t l) { add_len_int(fit_add(l)); }
|
|
|
|
// offset operators will always return a strref
|
|
strref operator+(const strl_t skip) { if (skip<len())
|
|
return strref(charstr()+skip, len()-skip); return strref(); }
|
|
strref operator+(const int skip) { if (skip>=0 && strl_t(skip)<len())
|
|
return strref(charstr()+skip, len()-skip); return strref(); }
|
|
|
|
// get character at position
|
|
char operator[](size_t pos) { return pos<len() ? charstr()[pos] : 0; }
|
|
|
|
// mirror strref functionality
|
|
int count_char(char c) const { return get_strref().count_char(c); }
|
|
int len_eol() const { return get_strref().len_eol(); }
|
|
int len_next_line() const { return get_strref().len_next_line(); }
|
|
strl_t len_float_number() const { return get_strref().len_float_number(); }
|
|
bool is_float_number() const { return get_strref().is_float_number(); }
|
|
|
|
// get fnv1a hash for string
|
|
unsigned int fnv1a(unsigned int seed = 2166136261) const { return get_strref().fnv1a(seed); }
|
|
unsigned int fnv1a_append(unsigned int base_fnv1a_hash) const { return get_strref().fnv1a(base_fnv1a_hash); }
|
|
|
|
// whole string compare
|
|
bool same_str(const strref str) const { return get_strref().same_str_case(str); }
|
|
bool same_str_case(const strref str) const { return get_strref().same_str_case(str); }
|
|
bool same_str(const strref str, char same1, char same2) const {
|
|
return get_strref().same_str_case(str, same1, same2); }
|
|
bool same_str_case(const strref str, char same1, char same2) const {
|
|
return get_strref().same_str_case(str, same1, same2); }
|
|
bool same_str(const char *str) const { return get_strref().same_str(str); }
|
|
bool same_str_case(const char *str) const { return get_strref().same_str_case(str); }
|
|
|
|
// prefix compare
|
|
strl_t prefix_len(const strref str) const { return get_strref().prefix_len(str); }
|
|
strl_t prefix_len(const strref str, char same1, char same2) const {
|
|
return get_strref().prefix_len_case(str, same1, same2); }
|
|
strl_t prefix_len(const char *str) const { return get_strref().prefix_len(str); }
|
|
strl_t prefix_len_case(const strref str) const { return get_strref().prefix_len_case(str); }
|
|
strl_t prefix_len_case(const char *str) const { return get_strref().prefix_len_case(str); }
|
|
bool is_prefix_of(const strref str) const { return get_strref().is_prefix_of(str); }
|
|
bool is_prefix_of(const strref str, char same1, char same2) const {
|
|
return get_strref().is_prefix_of(str, same1, same2); }
|
|
bool is_prefix_word(const strref str) const { return get_strref().is_prefix_word(str); }
|
|
bool is_prefix_case_of(const strref str) const { return get_strref().is_prefix_case_of(str); }
|
|
bool is_prefix_float_number() const { return get_strref().is_prefix_float_number(); }
|
|
bool grab_prefix( const char* str ) { return get_strref().grab_prefix( str ); }
|
|
|
|
// whole word compare (prefix match + next char is whitespace or end of string)
|
|
bool is_word(const strref str) const { return get_strref().is_word(str); }
|
|
bool is_word_case(const strref str) const { return get_strref().is_word_case(str); }
|
|
|
|
// suffix compare
|
|
strl_t suffix_len(const strref str) const { return get_strref().suffix_len(str); }
|
|
strl_t suffix_len_case(const strref str) const { return get_strref().suffix_len_case(str); }
|
|
bool is_suffix_of(const strref str) const { return get_strref().is_suffix_of(str); }
|
|
bool is_suffix_case_of(const strref str) const { return get_strref().is_suffix_case_of(str); }
|
|
bool has_suffix(const char *str) const { return get_strref().has_suffix(str); }
|
|
|
|
// string search
|
|
int find(char c) const { return get_strref().find(c); }
|
|
int find_after(char c, strl_t pos) const { return get_strref().find_after(c, pos); }
|
|
int find_or_full(char c, strl_t pos) const { return get_strref().find_or_full(c, pos); }
|
|
int find_last(char c) const { return get_strref().find_last(c); }
|
|
int find(char c, char d) const { return get_strref().find(c, d); }
|
|
int find_last(char c, char d) const { return get_strref().find_last(c, d); }
|
|
int find_after_last(char a, char b) const { return get_strref().find_after_last(a, b); }
|
|
int find_after_last(char a1, char a2, char b) const { return get_strref().find_after_last(a1, a2, b); }
|
|
int find(const strref str) const { return get_strref().find(str); }
|
|
int find(const strref str, strl_t pos) const { return get_strref().find(str, pos); }
|
|
int find(const char *str, strl_t pos = 0) const { return get_strref().find(str, pos); }
|
|
int find_case(const strref str) const { return get_strref().find_case(str); }
|
|
int find_case(const char *str) const { return get_strref().find_case(str); }
|
|
int find_last(const strref str) const { return get_strref().find_last(str); }
|
|
int find_last(const char *str) const { return get_strref().find_last(str); }
|
|
int find_last_case(const strref str) const { return get_strref().find_last_case(str); }
|
|
int substr_count(const strref p) const { return get_strref().substr_count(p); }
|
|
|
|
// rolling hash string search
|
|
int find_rh(strref str) const { return get_strref().find_rh(str); }
|
|
int find_rh_case(strref str) const { return get_strref().find_rh_case(str); }
|
|
int find_rh(strref str, strl_t pos) const { return get_strref().find_rh(str, pos); }
|
|
int find_rh_case(strref str, strl_t pos) const { return get_strref().find_rh_case(str, pos); }
|
|
int find_rh_after(strref str, strref prev) const { return get_strref().find_rh_after(str, prev); }
|
|
int find_rh_case_after(strref str, strref prev) const { return get_strref().find_rh_case_after(str, prev); }
|
|
|
|
// whitespace management
|
|
int len_whitespace() const { return get_strref().len_whitespace(); }
|
|
int len_grayspace() const { return get_strref().len_grayspace(); }
|
|
strl_t find_whitespace_or_full() const { return get_strref().find_whitespace_or_full(); }
|
|
int find_whitespace() const { return get_strref().find_whitespace(); }
|
|
|
|
// string content
|
|
strl_t len_alphanumeric(strl_t p = 0) const { return get_strref().len_alphanumeric(p); }
|
|
strl_t len_word() const { return get_strref().len_word(); }
|
|
int len_label() const { return get_strref().len_label(); }
|
|
bool is_number() const { return get_strref().is_number(); }
|
|
|
|
// get a portion of a string
|
|
strref get_substr(strl_t pos, strl_t length) const { return get_strref().get_substr(pos, length); }
|
|
strref get_skipped(int skip_len) const { return get_strref().get_skipped(skip_len); }
|
|
strref get_clipped(int clip_len) const { return get_strref().get_clipped(clip_len); }
|
|
strref get_word() const { return get_strref().get_word(); }
|
|
strref get_json() const { return get_strref().get_json(); }
|
|
|
|
strref before(char c) const { return get_strref().before(c); }
|
|
strref before(char c, char d) const { return get_strref().before(c, d); }
|
|
strref before_last(char c) const { return get_strref().before_last(c); }
|
|
strref before_last(char c, char d) const { return get_strref().before_last(c, d); }
|
|
strref before_or_full(char c) const { return get_strref().before_or_full(c); }
|
|
strref before_or_full(const strref str) const { return get_strref().before_or_full(str); }
|
|
strref after_or_full(const strref str) const { return get_strref().after_or_full(str); }
|
|
strref after_or_full(char c) const { return get_strref().after_or_full(c); }
|
|
strref after(char c) const { return get_strref().after(c); }
|
|
strref after_last_or_full(char c) const { return get_strref().after_last_or_full(c); }
|
|
strref after_last(char c) const { return get_strref().after_last(c); }
|
|
strref get_alphanumeric() const { return get_strref().get_alphanumeric(); }
|
|
strref before_or_full_case(const strref str) const { return get_strref().before_or_full_case(str); }
|
|
strref after_or_full_case(const strref str) const { return get_strref().after_or_full_case(str); }
|
|
strref between(char c, char d) const { return get_strref().between(c, d); }
|
|
|
|
// tokenization
|
|
strref line(); // return the current line and skip this to next line
|
|
strref token_chunk(char c) const { return get_strref().token_chunk(c); }
|
|
strref find_token(const char *substr, char token) const { return get_strref().find_token(substr, token); }
|
|
strref find_token_case(const char *substr, char token) const { return get_strref().find_token_case(substr, token); }
|
|
strref find_token(strref substr, char token) const { return get_strref().find_token(substr, token); }
|
|
strref find_token_case(strref substr, char token) const { return get_strref().find_token_case(substr, token); }
|
|
strref within_last(char a, char b) const { return get_strref().within_last(a, b); }
|
|
strref within_last(char a1, char a2, char b) const { return get_strref().within_last(a1, a2, b); }
|
|
|
|
strref get_quote_xml() const { return get_strref().get_quote_xml(); }
|
|
int find_quoted_xml(char d) const { return get_strref().find_quoted_xml(d); }
|
|
int find_quoted(char d) const { return get_strref().find_quoted(d); }
|
|
|
|
// wildcard search
|
|
strref find_wildcard(const strref wild, strl_t pos = 0, bool case_sensitive = true) const {
|
|
return get_strref().find_wildcard(wild, pos, case_sensitive); }
|
|
|
|
// find a wildcard right after the start of the previous find
|
|
strref next_wildcard(const strref wild, strref prev, bool case_sensitive = true) const {
|
|
return get_strref().next_wildcard(wild, prev, case_sensitive); }
|
|
|
|
// find a wildcard right after the end of the previous find
|
|
strref wildcard_after(const strref wild, strref prev, bool case_sensitive = true) const {
|
|
return get_strref().next_wildcard(wild, prev, case_sensitive); }
|
|
|
|
// write a single utf-8 character to pos and return how many bytes was required
|
|
strl_t write_utf8(int code, strl_t pos) { return _strmod_write_utf8(charstr(), cap(), code, pos); }
|
|
|
|
// push a single utf-8 character to the end of this string
|
|
void push_utf8(int code) { add_len_int(write_utf8(code, len())); }
|
|
|
|
// get a single utf-8 character
|
|
int get_utf8(strl_t pos) { strl_t skip; return _strmod_read_utf8(charstr(), len(), pos, skip); }
|
|
|
|
// get a single utf-8 characer and the number of bytes that was used to store it
|
|
int get_utf8(strl_t pos, strl_t &skip) { return _strmod_read_utf8(charstr(), len(), pos, skip); }
|
|
|
|
// choice of uppercasing / lowercasing entire string
|
|
void tolower() { _strmod_tolower(charstr(), len()); }
|
|
void toupper() { _strmod_toupper(charstr(), len()); }
|
|
void tolower_win() { _strmod_tolower_win_ascii(charstr(), len()); }
|
|
void toupper_win() { _strmod_toupper_win_ascii(charstr(), len()); }
|
|
void tolower_amiga() { _strmod_tolower_amiga_ascii(charstr(), len()); }
|
|
void toupper_amiga() { _strmod_toupper_amiga_ascii(charstr(), len()); }
|
|
void tolower_macos() { _strmod_tolower_macos_ascii(charstr(), len()); }
|
|
void toupper_macos() { _strmod_toupper_macos_ascii(charstr(), len()); }
|
|
void tolower_utf8() { set_len_int(_strmod_utf8_tolower(charstr(), len(), cap())); }
|
|
void toupper_utf8() { set_len_int(_strmod_utf8_toupper(charstr(), len(), cap())); }
|
|
|
|
// get the end of the current string
|
|
char *end() { return charstr()+len(); }
|
|
|
|
// number of characters left until at capacity
|
|
strl_t left() const { return cap()-len(); }
|
|
|
|
// remove trailing whitespace
|
|
void clip_trailing_whitespace() { if (valid()) {
|
|
const char *e = end(); while (*--e<=0x20 && len()) { dec_len_int(); } } }
|
|
|
|
// copy a substring internally while checking for overlap
|
|
void substrcopy(strl_t pos, strl_t target, strl_t _length) {
|
|
_strmod_substrcopy(charstr(), len(), cap(), pos, target, _length); }
|
|
|
|
// insert a substring and expand the string to fit it
|
|
bool insert(const strref sub, strl_t pos) {
|
|
return set_len(_strmod_insert(charstr(), len(), cap(), sub, pos)); }
|
|
|
|
// append a substring at the end of this string
|
|
strmod& append(const strref o) { if (o) { strl_t a = fit_add(o.get_len());
|
|
if (a) { memcpy(end(), o.get(), a); add_len_int(a); } } return *this; }
|
|
|
|
// append a character at the end of this string
|
|
strmod& append(char c) { if (!full()) { charstr()[len()] = c; inc_len_int(); } return *this; }
|
|
|
|
// C#-ish string concatenation
|
|
strmod& operator+(char c) { return append(c); }
|
|
strmod& operator+(const char* str) { return append(str); }
|
|
strmod& operator+(strref str) { return append(str); }
|
|
|
|
// C++COut-ish string concatenation
|
|
strmod& operator<<(char c) { return append(c); }
|
|
strmod& operator<<(const char* str) { return append(str); }
|
|
strmod& operator<<(strref str) { return append(str); }
|
|
|
|
// append a character repeatedly
|
|
strmod& pad_to(char c, strl_t pos) { if (len() >= pos) set_len_int(pos); else {
|
|
strl_t ol = len(); set_len(pos); for (strl_t p = ol; p < len(); ++p) charstr()[p] = c; } return *this; }
|
|
|
|
// prepend this string with a substring
|
|
void prepend(const strref o) { insert(o, 0); }
|
|
|
|
// prepend this string with a c string
|
|
void prepend(const char *s) { insert(strref(s), 0); }
|
|
|
|
// format this string using {n} notation to index into the args list
|
|
void format(const strref format, const strref *args) {
|
|
set_len_int(_strmod_format_insert(charstr(), 0, cap(), 0, format, args)); }
|
|
|
|
// append a formatted string, return the appended part as a strref
|
|
strref format_append(const strref format, const strref *args) { strl_t l = len();
|
|
set_len_int(_strmod_format_insert(charstr(), len(), cap(), len(), format, args));
|
|
return strref(charstr()+l, len()-l); }
|
|
|
|
// prepend a formatted string, return the prepend part as a strref
|
|
strref format_prepend(const strref format, const strref *args) { strl_t l = len();
|
|
set_len_int(_strmod_format_insert(charstr(), len(), cap(), 0, format, args));
|
|
return strref(charstr(), len()-l); }
|
|
|
|
// insert a formatted string
|
|
void format_insert(const strref format, const strref *args, strl_t pos) {
|
|
set_len_int(_strmod_format_insert(charstr(), len(), cap(), pos, format, args)); }
|
|
|
|
strmod& append_num(uint32_t num, strl_t size, strl_t radix) {
|
|
add_len_int( _strmod_append_num( charstr() + len(), cap() - len(), num, size, radix ) );
|
|
return *this;
|
|
}
|
|
|
|
// c style sprintf (work around windows _s preference)
|
|
#ifdef _WIN32
|
|
int sprintf(const char *format, ...) { va_list args; va_start(args, format);
|
|
set_len_int((strl_t)vsnprintf_s(charstr(), cap(), _TRUNCATE, format, args)); va_end(args); return (int)len(); }
|
|
int sprintf_at(strl_t pos, const char *format, ...) { va_list args; va_start(args, format);
|
|
int l = vsnprintf_s(charstr()+pos, cap()-pos, _TRUNCATE, format, args);
|
|
if (l+pos>len()) set_len(l+pos); va_end(args); return l; }
|
|
int sprintf_append(const char *format, ...) { va_list args; va_start(args, format); strl_t l = 0;
|
|
if (len()<cap()) { l = (strl_t)vsnprintf_s(end(), cap()-len(), _TRUNCATE, format, args); va_end(args);
|
|
add_len_int(l); } return (int)l; }
|
|
#else
|
|
int sprintf(const char *format, ...) { va_list args; va_start(args, format);
|
|
set_len_int(vsnprintf(charstr(), cap(), format, args)); va_end(args); return len(); }
|
|
int sprintf_at(strl_t pos, const char *format, ...) { va_list args; va_start(args, format);
|
|
int l = vsnprintf(charstr()+pos, cap()-pos, format, args);
|
|
if (l+pos>len()) set_len(l+pos); va_end(args); return l; }
|
|
int sprintf_append(const char *format, ...) { va_list args; va_start(args, format);
|
|
int l = vsnprintf(end(), cap()-len(), format, args); va_end(args); add_len_int(l); return l; }
|
|
#endif
|
|
// replace instances of character c with character d
|
|
strref replace(char c, char d) { if (char *b = charstr()) {
|
|
for (strl_t i = len(); i; i--) { if (*b==c) *b = d; b++; } } return get_strref(); }
|
|
|
|
// replace instances of substring a with substring b
|
|
strref replace(const strref a, const strref b) {
|
|
set_len(_strmod_inplace_replace_int(charstr(), len(), cap(), a, b)); return get_strref(); }
|
|
|
|
// replace strings bookended by a specific string
|
|
strref replace_bookend(const strref a, const strref b, const strref bookend) { if (len() && get() && a && bookend)
|
|
set_len(_strmod_inplace_replace_bookend_int(charstr(), len(), cap(), a, b, bookend)); return get_strref(); }
|
|
|
|
// replace a string found within this string with another string
|
|
void exchange(strl_t pos, strl_t size, const strref insert) {
|
|
set_len_int(_strmod_exchange(charstr(), len(), cap(), pos, size, insert)); }
|
|
|
|
void exchange(const strref original, const strref insert) {
|
|
if (is_substr(original.get())) { exchange(strl_t(original.get()-get()), original.get_len(), insert); } }
|
|
|
|
// remove a part of this string
|
|
strref remove(strl_t start, strl_t _length) {
|
|
set_len_int(_strmod_remove(charstr(), len(), start, _length)); return get_strref(); }
|
|
|
|
// remove all instances of a character from this string
|
|
strref remove(char a) { set_len_int(_strmod_remove(charstr(), len(), a)); return get_strref(); }
|
|
|
|
// zero terminate this string and return it
|
|
const char *c_str() { charstr()[len()<cap()?len():(cap()-1)] = 0; return charstr(); }
|
|
|
|
// get the end of this string
|
|
char* charend() { return charstr()+len(); }
|
|
|
|
// remove a portion of this string
|
|
void erase(strl_t pos, strl_t length) { if (pos<len()) { if ((pos+length)>len())
|
|
length = len()-pos; if (length) { for (strl_t i = 0; i<length; i++)
|
|
charstr()[pos+i] = charstr()[pos+i+length]; } sub_len_int(length); } }
|
|
|
|
strmod& cleanup_path() {
|
|
set_len(_strmod_cleanup_path(charstr(), get_len()));
|
|
return *this;
|
|
}
|
|
|
|
// find a relative path between an original folder and a target file path (returns this as a strref)
|
|
strmod& relative_path(strref orig_folder, strref target_path) {
|
|
set_len(_strmod_relative_path(charstr(), cap(), orig_folder, target_path));
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
template <strl_t S> class strown_base {
|
|
char string[S];
|
|
strl_t length;
|
|
protected:
|
|
void add_len_int(strl_t l) { length += l; } // unsafe add len (size already checked)
|
|
void sub_len_int(strl_t l) { length -= l; } // unsafe sub len (size already checked)
|
|
void set_len_int(strl_t l) { length = l; }
|
|
void dec_len_int() { length--; }
|
|
void inc_len_int() { length++; }
|
|
public:
|
|
strl_t cap() const { return S; }
|
|
char* charstr() { return string; }
|
|
const char* charstr() const { return string; }
|
|
strl_t len() const { return length; }
|
|
};
|
|
|
|
class strovl_base {
|
|
protected:
|
|
char *string_ptr;
|
|
strl_t string_length;
|
|
strl_t string_space;
|
|
void add_len_int(strl_t l) { string_length += l; } // unsafe add len (size already checked)
|
|
void sub_len_int(strl_t l) { string_length -= l; } // unsafe sub len (size already checked)
|
|
void set_len_int(strl_t l) { string_length = l; }
|
|
void dec_len_int() { string_length--; }
|
|
void inc_len_int() { string_length++; }
|
|
public:
|
|
strl_t cap() const { return string_space; }
|
|
strl_t len() const { return string_length; }
|
|
char *charstr() { return string_ptr; }
|
|
const char* charstr() const { return string_ptr; }
|
|
void invalidate() { string_ptr = nullptr; string_space = 0; }
|
|
void set_overlay(char *ptr, strl_t space) { string_ptr = ptr; string_space = space; }
|
|
void set_overlay(char *ptr, strl_t space, strl_t len) {
|
|
string_ptr = ptr; string_space = space; string_length = len; }
|
|
};
|
|
|
|
// owned string class, instance with 'strown<capacity> name'
|
|
template <strl_t S> class strown : public strmod<strown_base<S> > {
|
|
public:
|
|
strown(const char *s) { strmod<strown_base<S> >::copy(s); }
|
|
explicit strown(strref s) { strmod<strown_base<S> >::copy(s); }
|
|
strown() {}
|
|
};
|
|
|
|
// overlay string class, instance with 'strovl name(char *, size)'
|
|
class strovl : public strmod<strovl_base> {
|
|
public:
|
|
strovl() { invalidate(); string_length = 0; }
|
|
strovl(char *ptr, strl_t space) { set_overlay(ptr, space); string_length = 0; }
|
|
strovl(char *ptr, strl_t space, strl_t length) { set_overlay(ptr, space); string_length = length; }
|
|
};
|
|
|
|
|
|
// helper for relative strings. purpose is for string collections that may need to grow
|
|
// by allocating a new buffer and copying. requires calling get(base strref) tp use string.
|
|
class strref_rel {
|
|
protected:
|
|
strl_t offset;
|
|
strl_t length;
|
|
public:
|
|
strref_rel() { clear(); }
|
|
strref_rel(const strref_rel &rel) : offset(rel.offset), length(rel.length) {}
|
|
strref_rel(strref orig, strref base) {
|
|
if (base.is_substr(orig.get())) {
|
|
offset = strl_t(orig.get()-base.get()); length = orig.get_len();
|
|
} else
|
|
length = 0;
|
|
}
|
|
strref_rel(const char *str, strl_t len, strref base) {
|
|
if (base.is_substr(str)) {
|
|
offset = strl_t(str-base.get()); length = len;
|
|
} else
|
|
length = 0;
|
|
}
|
|
|
|
strref get(strref base) { return strref(base.get() + offset, length); }
|
|
strref get(strovl base) { return strref(base.get() + offset, length); }
|
|
strl_t get_len() { return length; }
|
|
|
|
bool valid() const { return length>0; }
|
|
operator bool() const { return valid(); }
|
|
|
|
void clear() { length = 0; }
|
|
};
|
|
|
|
|
|
|
|
// dynamic collection of strings in a single fixed char array
|
|
template <strl_t S> class strcol {
|
|
char _buffer[S];
|
|
strl_t end_buf;
|
|
char* push_back_len(char *w, char *e, strl_t len) { while (w<e && len) { *w++ = (len&0x7f) | (len&(~strl_t(0x7f)) ? 0x80 : 0); len >>= 7; } return w; }
|
|
char* push_back_int(const char *s, strl_t l, strl_t o) { char *e = _buffer+S, *w = push_back_len(_buffer+o, e, l); if (strl_t(e-w)<l) return nullptr; memcpy(w, s, l); return w+l; }
|
|
strl_t lim(strl_t pos) const { return pos<end_buf ? pos : end_buf; }
|
|
strl_t lim_len(strl_t pos, strl_t len) const { return (pos+len)<end_buf ? len : (end_buf-pos); }
|
|
public:
|
|
strcol() : end_buf(0) { }
|
|
bool empty() const { return end_buf == 0; }
|
|
void clear() const { end_buf = 0; }
|
|
bool end(strl_t curr) const { return curr>=end_buf; }
|
|
bool last(strl_t curr) const { return end(next(curr)); }
|
|
strl_t get_len(strl_t curr) { strl_t o = 0, s = 0; char c; do { c = _buffer[curr++]; o += strl_t(c&0x7f)<<s; s += 7; } while (c<0); return lim_len(c, o); }
|
|
strl_t next(strl_t curr) const { if (curr >= end_buf) return end_buf; strl_t o = 0, s = 0; char c; do { c = _buffer[curr++]; o += strl_t(c&0x7f)<<s; s += 7; } while (c<0); return lim(o+curr); }
|
|
strref get(strl_t curr) const { if (end(curr)) return strref(); strl_t o = 0, s = 0, c; do { c = _buffer[curr++]; o += (c&0x7f)<<s; s += 7; } while (c&0x80); return strref(_buffer+curr, lim_len(curr, o)); }
|
|
strl_t get_index(int i) const { strl_t curr = 0; while (i-- && !end(curr)) { curr = next(curr); } return curr; }
|
|
strref operator[](int i) const { return get(get_index(i)); }
|
|
bool push_back(const strref s) { if (char *w = push_back_int(s.get(), s.get_len(), end_buf)) { end_buf = (strl_t)(w-_buffer); return true; } return false; }
|
|
void erase(strl_t curr) { strl_t n = next(curr); memmove(_buffer+curr, _buffer+n, end_buf-n); end_buf -= n-curr; }
|
|
|
|
class iterator {
|
|
strcol *coll;
|
|
strl_t curr;
|
|
public:
|
|
iterator() : coll(nullptr), curr(0) {}
|
|
iterator(strcol &collection, strl_t pos = 0) : coll(&collection), curr(pos) {}
|
|
void operator++() { if (coll) curr = coll->next(curr); else curr = 0; }
|
|
bool operator==(const iterator &i) const { return curr==i.curr && coll==i.coll; }
|
|
bool operator!=(const iterator &i) const { return curr!=i.curr || coll!=i.coll; }
|
|
void erase() { coll->erase(curr); }
|
|
strref operator*() { return coll->get(curr); }
|
|
};
|
|
iterator end() { return iterator(*this, end_buf); }
|
|
iterator begin() { return iterator(*this); }
|
|
};
|
|
|
|
#ifdef STRUSE_IMPLEMENTATION
|
|
//#include <math.h>
|
|
#include <stdlib.h> // atof
|
|
|
|
// Windows extended ascii: https://msdn.microsoft.com/en-us/library/9hxt0028(v=vs.80).aspx
|
|
// Unicode: http://unicode-table.com/en/#basic-latin
|
|
// Mac OS Roman ascii: https://en.wikipedia.org/wiki/Mac_OS_Roman
|
|
// Amiga ascii: http://www.amigacoding.com/index.php/AMOSi:ASCII_Table
|
|
|
|
static const uint8_t _aMacOSRomanHigh_ToLower[0x80] = {
|
|
0x8a, 0x8c, 0x8d, 0x8e, 0x96, 0x9a, 0x9f, 0x87,
|
|
0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
|
|
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
|
|
0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
|
|
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
|
|
0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xbe, 0xbf,
|
|
0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
|
|
0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
|
|
0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
|
|
0xc8, 0xc9, 0xca, 0x88, 0x8a, 0x9b, 0xcf, 0xcf,
|
|
0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
|
|
0xd8, 0xd8, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
|
|
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0x89, 0x90, 0x87,
|
|
0x91, 0x8f, 0x92, 0x94, 0x95, 0x93, 0x97, 0x99,
|
|
0xf0, 0x98, 0x9c, 0x9e, 0x9d, 0xfd, 0xfe, 0xff };
|
|
|
|
static const uint8_t _aMacOSRomanHigh_ToUpper[0x80] = {
|
|
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0xe7,
|
|
0xcb, 0xe5, 0x80, 0xcc, 0x81, 0x82, 0x83, 0xe9,
|
|
0xe6, 0xe8, 0xea, 0xed, 0xeb, 0xec, 0x84, 0xee,
|
|
0xf1, 0xef, 0x85, 0xcd, 0xf2, 0xf4, 0xf3, 0x86,
|
|
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
|
|
0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
|
|
0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
|
|
0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xae, 0xaf,
|
|
0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
|
|
0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xce,
|
|
0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
|
|
0xd9, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
|
|
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
|
|
0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
|
|
0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
|
|
0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff };
|
|
|
|
|
|
uint8_t int_tolower_macos_roman_ascii(uint8_t c) {
|
|
if (c>='A' && c<='Z')
|
|
return (uint8_t)(c+'a'-'A');
|
|
if (c>=0x80)
|
|
return _aMacOSRomanHigh_ToLower[c&0x7f];
|
|
return c;
|
|
}
|
|
|
|
uint8_t int_toupper_macos_roman_ascii(uint8_t c) {
|
|
if (c>='a' && c<='z')
|
|
return (uint8_t)(c+'A'-'a');
|
|
if (c>=0x80)
|
|
return _aMacOSRomanHigh_ToUpper[c&0x7f];
|
|
return c;
|
|
}
|
|
|
|
uint8_t int_tolower_amiga_ascii(uint8_t c) {
|
|
if (c>='A' && c<='Z')
|
|
return (uint8_t)(c+'a'-'A');
|
|
if (c>=0xc0 && c<0xe0)
|
|
return (uint8_t)(c+0x20);
|
|
return c;
|
|
}
|
|
|
|
uint8_t int_toupper_amiga_ascii(uint8_t c) {
|
|
if (c>='a' && c<='z')
|
|
return (uint8_t)(c+'A'-'a');
|
|
if (c>=0xe0)
|
|
return (uint8_t)(c-0x20);
|
|
return c;
|
|
}
|
|
|
|
uint8_t int_toupper_win_ascii(uint8_t c) {
|
|
if (c<'a')
|
|
return c;
|
|
if (c<='z')
|
|
return (uint8_t)(c+'A'-'a');
|
|
switch (c) {
|
|
case 0x84:
|
|
return 0x83;
|
|
case 0x86:
|
|
return 0x8f;
|
|
case 0x82:
|
|
return 0x90;
|
|
case 0x91:
|
|
return 0x92;
|
|
case 0x94:
|
|
return 0x99;
|
|
case 0x81:
|
|
return 0x9a;
|
|
}
|
|
return c;
|
|
}
|
|
|
|
uint8_t int_tolower_win_ascii(uint8_t c) {
|
|
if (c<'A')
|
|
return c;
|
|
if (c<='Z')
|
|
return (uint8_t)(c+'a'-'A');
|
|
switch (c) {
|
|
case 0x8e:
|
|
return 0x84;
|
|
case 0x8f:
|
|
return 0x86;
|
|
case 0x90:
|
|
return 0x82;
|
|
case 0x92:
|
|
return 0x91;
|
|
case 0x99:
|
|
return 0x94;
|
|
case 0x9a:
|
|
return 0x81;
|
|
}
|
|
return c;
|
|
}
|
|
|
|
// General lowercase of unicode range
|
|
size_t int_tolower_unicode(size_t c)
|
|
{
|
|
if (c<'A' || c==0xd7 || c==0x138 || c==0x149)
|
|
return c;
|
|
if (c<='Z')
|
|
return c+'a'-'A';
|
|
if (c<0xc0)
|
|
return c;
|
|
if (c<0xe0 || (c>=0x391 && c<0x3ab) || (c>=0x3d8 && c<0x3f0) || (c>=0x410 && c<0x430))
|
|
return c+0x20;
|
|
if (c<0x100)
|
|
return c;
|
|
if (c<0x178) {
|
|
if (c>0x138 && c<0x149)
|
|
return ((c-1)|1)+1;
|
|
return c | 1;
|
|
}
|
|
if ((c>=0x460 && c<0x482) || (c>=0x48a && c<0x4c0) || (c>=0x4d0 && c<0x530))
|
|
return c | 1;
|
|
if (c>=0x4c1 && c<0x4cf)
|
|
return ((c-1)|1)+1;
|
|
if (c>=0x400 && c<0x410)
|
|
return c+0x50;
|
|
|
|
if (c>=0x531 && c<0x556)
|
|
return c+0x30;
|
|
|
|
if (c==0x178)
|
|
return 0xff;
|
|
if (c==0x4c0)
|
|
return 0x4cf;
|
|
|
|
return c;
|
|
}
|
|
|
|
// General uppercase of unicode range
|
|
size_t int_toupper_unicode(size_t c)
|
|
{
|
|
if (c<'a' || c==0xd7 || c==0x138 || c==0x149)
|
|
return c;
|
|
if (c<='z')
|
|
return c+'A'-'c';
|
|
if (c<0xe0)
|
|
return c;
|
|
if (c==0xff)
|
|
return 0x178;
|
|
if (c<0x100 || (c>=0x3b1 && c<0x3cb) || (c>=0x3f8 && c<0x410) || (c>=0x430 && c<0x450))
|
|
return c-0x20;
|
|
if (c<0x178) {
|
|
if (c>0x138 && c<0x149)
|
|
return ((c-1)&1UL)+1;
|
|
return c & ~1UL;
|
|
}
|
|
if ((c>=0x460 && c<0x482) || (c>=0x48a && c<0x4c0) || (c>=0x4d0 && c<0x530))
|
|
return c & ~1UL;
|
|
if (c>=0x4c1 && c<0x4cf)
|
|
return ((c-1)&1UL)+1;
|
|
if (c>=0x450 && c<0x460)
|
|
return c-0x50;
|
|
|
|
if (c>=0x561 && c<0x586)
|
|
return c-0x30;
|
|
|
|
if (c==0x4cf)
|
|
return 0x4c0;
|
|
|
|
return c;
|
|
}
|
|
|
|
// english latin lowercase
|
|
uint8_t int_tolower_ascii7(uint8_t c)
|
|
{
|
|
if (c<='Z' && c>='A')
|
|
return (uint8_t)(c+'a'-'A');
|
|
return c;
|
|
}
|
|
|
|
// english latin uppercase
|
|
uint8_t int_toupper_ascii7(uint8_t c)
|
|
{
|
|
if (c>='a' && c<='z')
|
|
return (uint8_t)(c+'A'-'a');
|
|
return c;
|
|
}
|
|
|
|
// convert escape codes to characters
|
|
// supports: \a, \b, \f, \n, \r, \t, \v, \000, \x00
|
|
// any other character is returned as same
|
|
static strl_t int_get_esc_code(const uint8_t *buf, strl_t left, uint8_t &code)
|
|
{
|
|
strl_t step = 0;
|
|
if (!left)
|
|
return step;
|
|
uint8_t c = *buf++;
|
|
left--;
|
|
step++;
|
|
if (c=='x' && left && strref::is_hex(*buf)) {
|
|
// parse hex char code
|
|
c = 0;
|
|
for (int r = 0; r<2 && left; r++) {
|
|
uint8_t n = *buf++;
|
|
if (!strref::is_hex(n))
|
|
break;
|
|
c = (uint8_t)((c<<4) + n - (n<='9' ? '0' : (n<='F'?('A'-0xA) : ('a'-0xa))));
|
|
step++;
|
|
left--;
|
|
}
|
|
} else if (c>='0' && c<='7') {
|
|
// parse octal char code
|
|
c -= '0';
|
|
for (int r = 0; r<2 && left; r++) {
|
|
uint8_t n = *buf++;
|
|
if (n<'0' || n>'7')
|
|
break;
|
|
c = (uint8_t)(c*8 + n-'0');
|
|
step++;
|
|
left--;
|
|
}
|
|
} else {
|
|
// check for custom escape code symbol
|
|
switch (c) {
|
|
case 'a':
|
|
c = 7;
|
|
break;
|
|
case 'b':
|
|
c = 8;
|
|
break;
|
|
case 'f':
|
|
c = 12;
|
|
break;
|
|
case 'n':
|
|
c = 10;
|
|
break;
|
|
case 'r':
|
|
c = 13;
|
|
break;
|
|
case 't':
|
|
c = 9;
|
|
break;
|
|
case 'v':
|
|
c = 11;
|
|
break;
|
|
}
|
|
}
|
|
code = c;
|
|
return step;
|
|
}
|
|
|
|
// tolower/toupper implementation
|
|
char strref::tolower(char c) { return (char)int_tolower_ascii7((uint8_t)c); }
|
|
char strref::toupper(char c) { return (char)int_toupper_ascii7((uint8_t)c); }
|
|
char strref::tolower_win(char c) { return (char)int_tolower_win_ascii((uint8_t)c); }
|
|
char strref::toupper_win(char c) { return (char)int_toupper_win_ascii((uint8_t)c); }
|
|
char strref::tolower_amiga(char c) { return (char)int_tolower_amiga_ascii((uint8_t)c); }
|
|
char strref::toupper_amiga(char c) { return (char)int_toupper_amiga_ascii((uint8_t)c); }
|
|
char strref::tolower_macos(char c) { return (char)int_tolower_macos_roman_ascii((uint8_t)c); }
|
|
char strref::toupper_macos(char c) { return (char)int_toupper_macos_roman_ascii((uint8_t)c); }
|
|
size_t strref::tolower_unicode(int c) { return int_tolower_unicode((size_t)c); }
|
|
size_t strref::toupper_unicode(int c) { return int_toupper_unicode((size_t)c); }
|
|
|
|
// use printf to print current string on a single line
|
|
void strref::writeln()
|
|
{
|
|
if (valid()) {
|
|
printf(STRREF_FMT "\n", STRREF_ARG(*this));
|
|
} else
|
|
printf("\n");
|
|
}
|
|
|
|
// construct a strref from const char*
|
|
void strref::set(const char *str)
|
|
{
|
|
if (!str || !*str) {
|
|
string = nullptr;
|
|
length = 0;
|
|
} else {
|
|
string = str;
|
|
strl_t l = 0;
|
|
while (*str++)
|
|
l++;
|
|
length = l;
|
|
}
|
|
}
|
|
|
|
// get fnv1a hash of a string
|
|
unsigned int strref::fnv1a(unsigned int seed) const
|
|
{
|
|
unsigned int hash = seed;
|
|
if (string) {
|
|
unsigned const char *scan = (unsigned const char*)string;
|
|
strl_t left = length;
|
|
while (left--)
|
|
hash = (*scan++ ^ hash) * 16777619;
|
|
}
|
|
return hash;
|
|
}
|
|
|
|
// get 16 bit fnv1a hash of a string, this is officially done by xor folding
|
|
unsigned short strref::fnv1a_16(unsigned int seed) const
|
|
{
|
|
unsigned int hash = fnv1a(seed);
|
|
return (unsigned short)(hash ^ (hash>>16));
|
|
}
|
|
|
|
|
|
uint64_t strref::fnv1a_64(uint64_t seed) const
|
|
{
|
|
uint64_t hash = seed;
|
|
if (string) {
|
|
unsigned const char *scan = (unsigned const char*)string;
|
|
strl_t left = length;
|
|
while (left--)
|
|
hash = (*scan++ ^ hash) * 1099511628211;
|
|
}
|
|
return hash;
|
|
}
|
|
|
|
// get lowercase fnv1a hash of a string
|
|
unsigned int strref::fnv1a_lower(unsigned int seed) const
|
|
{
|
|
unsigned const char *scan = (unsigned const char*)string;
|
|
unsigned int hash = seed;
|
|
strl_t left = length;
|
|
while (left--)
|
|
hash = (int_toupper_ascii7(*scan++) ^ hash) * 16777619;
|
|
return hash;
|
|
}
|
|
|
|
// get fnv1a hash of a string and treat any number whitespace as a single space
|
|
unsigned int strref::fnv1a_ws(unsigned int seed) const
|
|
{
|
|
unsigned const char *scan = (unsigned const char*)string;
|
|
unsigned int hash = seed;
|
|
strl_t left = length;
|
|
while (left--) {
|
|
uint8_t c = *scan++;
|
|
if (c<' ')
|
|
c = ' ';
|
|
hash = (c ^ hash) * 16777619;
|
|
if (c==' ') {
|
|
while (left && *scan<=0x20) {
|
|
left--;
|
|
scan++;
|
|
}
|
|
}
|
|
}
|
|
return hash;
|
|
}
|
|
|
|
// convert numeric string to integer
|
|
int64_t strref::atoi() const
|
|
{
|
|
if (string) {
|
|
const unsigned char *s = get_u();
|
|
const unsigned char *e = s + length;
|
|
while (s!=e && *s<=0x20) s++;
|
|
if (s<e) {
|
|
int64_t v = 0;
|
|
bool neg = *s=='-';
|
|
if (neg) s++;
|
|
while (s!=e) {
|
|
unsigned char c = *s++;
|
|
if (c<'0' || c>'9') break;
|
|
v = c-'0' + v*10;
|
|
}
|
|
return neg ? -v : v;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
uint64_t strref::atoui() const
|
|
{
|
|
if (string) {
|
|
const unsigned char *s = get_u();
|
|
strl_t left = length;
|
|
|
|
while (left && *s<=0x20) { s++; left--; }
|
|
if (left>=2 && *s=='0' && s[1]=='x' ) { return ahextou64(); }
|
|
|
|
uint64_t v = 0;
|
|
while (left) {
|
|
unsigned char c = *s++;
|
|
if (c<'0' || c>'9') break;
|
|
v = c-'0' + v*10;
|
|
--left;
|
|
}
|
|
return v;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// convert numeric string into floating point value
|
|
float strref::atof() const {
|
|
if (string[length]==0)
|
|
return (float)::atof(string);
|
|
strown<64> num(*this);
|
|
return (float)::atof(num.c_str());
|
|
}
|
|
|
|
// convert numeric string into double precision floating point value
|
|
double strref::atod() const {
|
|
if (string[length]==0)
|
|
return ::atof(string);
|
|
strown<64> num(*this);
|
|
return ::atof(num.c_str());
|
|
}
|
|
|
|
// convert numeric string to integer and move string forward
|
|
int strref::atoi_skip()
|
|
{
|
|
const char *scan = string;
|
|
strl_t left = length;
|
|
while (*scan<=0x20 && left) {
|
|
scan++;
|
|
left--;
|
|
}
|
|
if (!left)
|
|
return 0;
|
|
bool neg = false;
|
|
if (*scan=='-') {
|
|
neg = true;
|
|
left--;
|
|
}
|
|
int value = 0;
|
|
while (left) {
|
|
char c = *scan;
|
|
if (c<'0' || c>'9')
|
|
break;
|
|
left--;
|
|
scan++;
|
|
value = c-'0' + value*10;
|
|
}
|
|
string += length-left;
|
|
length = left;
|
|
return neg ? -value : value;
|
|
}
|
|
|
|
// convert a hexadecimal string to an unsigned integer
|
|
size_t strref::ahextoui() const
|
|
{
|
|
const char *scan = string;
|
|
strl_t left = length;
|
|
while (left && *scan<=0x20) {
|
|
scan++;
|
|
left--;
|
|
}
|
|
if (!left)
|
|
return 0;
|
|
if (left>2 && *scan=='0' && (scan[1]=='x' || scan[1]=='X')) {
|
|
scan += 2;
|
|
left -= 2;
|
|
}
|
|
strl_t hex = 0;
|
|
while (left) {
|
|
char c = *scan++;
|
|
left--;
|
|
if (c>='0' && c<='9')
|
|
hex = (hex<<4) | (c-'0');
|
|
else if (c>='a' && c<='f')
|
|
hex = (hex<<4) | (c-'a'+10);
|
|
else if (c>='A' && c<='F')
|
|
hex = (hex<<4) | (c-'A'+10);
|
|
else
|
|
break;
|
|
}
|
|
return hex;
|
|
}
|
|
|
|
// convert a hexadecimal string to an unsigned integer
|
|
uint64_t strref::ahextou64() const
|
|
{
|
|
const char *scan = string;
|
|
strl_t left = length;
|
|
while (*scan<=0x20 && left) {
|
|
scan++;
|
|
left--;
|
|
}
|
|
if (!left)
|
|
return 0;
|
|
if (left>2 && *scan=='0' && (scan[1]=='x' || scan[1]=='X')) {
|
|
scan += 2;
|
|
left -= 2;
|
|
}
|
|
uint64_t hex = 0;
|
|
while (left) {
|
|
char c = *scan++;
|
|
left--;
|
|
if (c>='0' && c<='9')
|
|
hex = (hex<<4) | (c-'0');
|
|
else if (c>='a' && c<='f')
|
|
hex = (hex<<4) | (c-'a'+10);
|
|
else if (c>='A' && c<='F')
|
|
hex = (hex<<4) | (c-'A'+10);
|
|
else
|
|
break;
|
|
}
|
|
return hex;
|
|
}
|
|
// convert a hexadecimal string to an unsigned integer
|
|
size_t strref::ahextoui_skip()
|
|
{
|
|
const char *scan = string;
|
|
strl_t left = length;
|
|
while (left && *scan<=0x20) {
|
|
scan++;
|
|
left--;
|
|
}
|
|
if (!left)
|
|
return 0;
|
|
if (left>2 && *scan=='0' && (scan[1]=='x' || scan[1]=='X')) {
|
|
scan += 2;
|
|
left -= 2;
|
|
}
|
|
if (left > 16) { left = 16; }
|
|
size_t hex = 0;
|
|
while (left) {
|
|
char c = *scan;
|
|
if (c>='0' && c<='9')
|
|
hex = (hex<<4) | (c-'0');
|
|
else if (c>='a' && c<='f')
|
|
hex = (hex<<4) | (c-'a'+10);
|
|
else if (c>='A' && c<='F')
|
|
hex = (hex<<4) | (c-'A'+10);
|
|
else
|
|
break;
|
|
scan++;
|
|
left--;
|
|
}
|
|
length -= strl_t(scan-string);
|
|
string = scan;
|
|
return hex;
|
|
}
|
|
|
|
// convert a binary string to an unsigned integer
|
|
size_t strref::abinarytoui_skip()
|
|
{
|
|
skip_whitespace();
|
|
const char *scan = string;
|
|
strl_t left = length;
|
|
if (!left)
|
|
return 0;
|
|
strl_t bin = 0;
|
|
while (left) {
|
|
uint8_t c = (uint8_t)*scan;
|
|
if (c<'0' || c>'1')
|
|
break;
|
|
scan++;
|
|
left--;
|
|
bin = (bin<<1) | (c-'0');
|
|
}
|
|
length -= strl_t(scan-string);
|
|
string = scan;
|
|
return bin;
|
|
}
|
|
// convert a hexadecimal string to a signed integer
|
|
int strref::ahextoi() const
|
|
{
|
|
const char *scan = string;
|
|
strl_t left = length;
|
|
while (*scan<=0x20 && left) {
|
|
scan++;
|
|
left--;
|
|
}
|
|
if (!left)
|
|
return 0;
|
|
bool neg = *scan=='-';
|
|
if (neg) {
|
|
scan++;
|
|
left--;
|
|
}
|
|
if (left>2 && *scan=='0' && (scan[1]=='x' || scan[1]=='X')) {
|
|
scan += 2;
|
|
left -= 2;
|
|
}
|
|
strl_t hex = 0;
|
|
while (left) {
|
|
char c = *scan++;
|
|
left--;
|
|
if (c>='0' && c<='9')
|
|
hex = (hex<<4) | (c-'0');
|
|
else if (c>='a' && c<='f')
|
|
hex = (hex<<4) | (c-'a'+10);
|
|
else if (c>='A' && c<='F')
|
|
hex = (hex<<4) | (c-'A'+10);
|
|
else
|
|
break;
|
|
}
|
|
return neg ? -(int)hex : (int)hex;
|
|
}
|
|
|
|
// count instances of a character in a string
|
|
int strref::count_char(char c) const
|
|
{
|
|
strl_t left = length;
|
|
const char *scan = string;
|
|
int count = 0;
|
|
while (left) {
|
|
if (*scan++ == c)
|
|
count++;
|
|
left--;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
// skip bom header of a utf-8 file if detected
|
|
strref strref::skip_bom()
|
|
{
|
|
const uint8_t* buf = get_u();
|
|
if (length >= 3 && buf && buf[0] == 0xef && buf[1] == 0xbb && buf[2] == 0xbf) {
|
|
return strref(string + 3, length - 3);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
// find a character in a string
|
|
static int int_find_char(char c, const char *scan, strl_t length)
|
|
{
|
|
strl_t left = length;
|
|
while (left) {
|
|
if (*scan++ == c)
|
|
return int(length - left);
|
|
left--;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// find a character in a string after pos
|
|
int strref::find(char c) const
|
|
{
|
|
if (!valid())
|
|
return -1;
|
|
return int_find_char(c, string, length);
|
|
}
|
|
|
|
// find an instance of a char after pos
|
|
int strref::find_after(char c, strl_t pos) const
|
|
{
|
|
if (length>pos) {
|
|
int o = int_find_char(c, string + pos + 1, length - pos - 1);
|
|
if (o >= 0)
|
|
return int(o + pos + 1);
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// find an instance of a char at pos or after
|
|
int strref::find_at(char c, strl_t pos) const
|
|
{
|
|
if (length>pos) {
|
|
int o = int_find_char(c, string + pos, length - pos);
|
|
if (o >= 0)
|
|
return int(o + pos);
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// find an instance of a char at pos or after or return full string
|
|
strl_t strref::find_or_full(char c, strl_t pos) const
|
|
{
|
|
if (!string)
|
|
return 0;
|
|
if (pos>=length)
|
|
return length;
|
|
int o = int_find_char(c, string + pos, length - pos);
|
|
if (o >= 0)
|
|
return o + pos;
|
|
return length;
|
|
}
|
|
|
|
// ignore matches that are in escape codes
|
|
strl_t strref::find_or_full_esc(char c, strl_t pos) const
|
|
{
|
|
if (!string)
|
|
return 0;
|
|
if (pos>=length)
|
|
return length;
|
|
|
|
strl_t left = length-pos;
|
|
const char *scan = string+pos;
|
|
while (left) {
|
|
char m = *scan++;
|
|
if (m=='\\' && left) {
|
|
scan++;
|
|
left--;
|
|
} else if (m==c)
|
|
return length-left;
|
|
left--;
|
|
}
|
|
return length;
|
|
}
|
|
|
|
// find last position of character c
|
|
int strref::find_last(char c) const
|
|
{
|
|
if (length && string) {
|
|
strl_t left = length;
|
|
const char *scan = string + left;
|
|
while (left) {
|
|
if (*--scan == c)
|
|
return int(left - 1);
|
|
left--;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// find first position of either c or d
|
|
int strref::find(char c, char d) const
|
|
{
|
|
strl_t left = length;
|
|
if (const char *scan = string) {
|
|
while (left) {
|
|
char n = *scan++;
|
|
if (n == c || n == d)
|
|
return int(length - left);
|
|
left--;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// find last instance of either character c or d
|
|
int strref::find_last(char c, char d) const
|
|
{
|
|
if (length && string) {
|
|
strl_t left = length - 1;
|
|
const char *scan = string + left;
|
|
while (left) {
|
|
char n = *--scan;
|
|
if (n == c || n == d)
|
|
return int(left - 1);
|
|
left--;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
int strref::find_skip_parens(char token) const
|
|
{
|
|
int parens = 0;
|
|
const char* scan = string;
|
|
strl_t left = length;
|
|
while (left && (parens || *scan != token)) {
|
|
if (*scan == '(') { ++parens; } else if (*scan == ')' && parens) { --parens; }
|
|
--left;
|
|
++scan;
|
|
}
|
|
if (left) { return length - left; }
|
|
return -1;
|
|
}
|
|
|
|
// compare a string with a substring case sensitive
|
|
static bool int_compare_substr_case(const char *scan, strl_t length, const char *check, strl_t chk_len)
|
|
{
|
|
if (length < chk_len)
|
|
return false;
|
|
if (scan==nullptr || check==nullptr)
|
|
return scan==check;
|
|
for (strl_t cl = 0; cl<chk_len; cl++) {
|
|
if (*scan++ != *check++)
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// compare a string with a substring case sensitive
|
|
static bool int_compare_substr(const uint8_t *scan, strl_t length, const uint8_t *check, strl_t chk_len)
|
|
{
|
|
if (length < chk_len)
|
|
return false;
|
|
for (strl_t cl = 0; cl<chk_len; cl++) {
|
|
if (int_tolower_ascii7(*scan++) != int_tolower_ascii7(*check++))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// case sensitive rolling hash find substring
|
|
int _find_rh_case(const char *text, strl_t length, const char *comp, strl_t comp_length)
|
|
{
|
|
if (length < comp_length)
|
|
return -1;
|
|
size_t roll_hash = 0;
|
|
size_t hash = 0;
|
|
size_t hash_remove = 1;
|
|
const char *rem = text;
|
|
|
|
// generate compare hash
|
|
for (strl_t cl = 0; cl<comp_length; cl++) {
|
|
hash = hash * 101 + (size_t)comp[cl];
|
|
hash_remove *= 101;
|
|
}
|
|
|
|
// initial buffer
|
|
for (strl_t cl = 0; cl<comp_length; cl++)
|
|
roll_hash = roll_hash*101 + (size_t)*text++;
|
|
|
|
// roll
|
|
strl_t left = length - comp_length;
|
|
for (;;) {
|
|
if (roll_hash == hash) {
|
|
// compare!
|
|
if (int_compare_substr_case(text - comp_length, left + comp_length, comp, comp_length))
|
|
return int(length - comp_length - left);
|
|
}
|
|
if (!left)
|
|
break;
|
|
left--;
|
|
roll_hash = roll_hash * 101 + (size_t)*text++ -
|
|
hash_remove * (size_t)*rem++;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// case ignore rolling hash find substring
|
|
int _find_rh(const uint8_t *text, strl_t length, const uint8_t *comp, strl_t comp_length)
|
|
{
|
|
if (length < comp_length)
|
|
return -1;
|
|
|
|
size_t roll_hash = 0;
|
|
size_t hash = 0;
|
|
size_t hash_remove = 1;
|
|
const uint8_t *rem = text;
|
|
|
|
// generate compare hash
|
|
for (strl_t cl = 0; cl<comp_length; cl++) {
|
|
hash = hash*101 + int_tolower_ascii7(comp[cl]);
|
|
hash_remove *= 101;
|
|
}
|
|
|
|
// initial buffer
|
|
for (strl_t cl = 0; cl<comp_length; cl++)
|
|
roll_hash = roll_hash*101 + int_tolower_ascii7(*text++);
|
|
|
|
// roll
|
|
strl_t left = length - comp_length;
|
|
for (;;) {
|
|
if (roll_hash == hash) {
|
|
// compare!
|
|
if (int_compare_substr(text - comp_length, left + comp_length, comp, comp_length))
|
|
return int(left - length + comp_length);
|
|
}
|
|
if (!left)
|
|
break;
|
|
left--;
|
|
roll_hash = roll_hash*101 + int_tolower_ascii7(*text++) -
|
|
hash_remove * int_tolower_ascii7(*rem++);
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// calculate number of characters in this line
|
|
strl_t strref::len_eol() const
|
|
{
|
|
strl_t left = length;
|
|
const char *str = string;
|
|
if (!left || !str)
|
|
return 0;
|
|
while (left && *str!=0x0d && *str!=0x0a) {
|
|
str++;
|
|
left--;
|
|
}
|
|
|
|
return length-left;
|
|
}
|
|
|
|
// length of string with escape characters counting as one
|
|
strl_t strref::len_esc() const
|
|
{
|
|
strl_t len = 0;
|
|
if (const char *str = string) {
|
|
strl_t left = length;
|
|
while (left) {
|
|
left--;
|
|
if (*str=='\\' && left) {
|
|
left--;
|
|
str++;
|
|
}
|
|
str++;
|
|
len++;
|
|
}
|
|
}
|
|
return len;
|
|
}
|
|
|
|
|
|
// calculate number of characters to next line
|
|
strl_t strref::len_next_line() const
|
|
{
|
|
strl_t line = len_eol();
|
|
if (line < length) {
|
|
if (string[line]==0x0d) {
|
|
line++;
|
|
if (line < length && string[line]==0x0a)
|
|
line++;
|
|
} else if (string[line]==0x0a) {
|
|
line++;
|
|
if (string[line]==0x0d)
|
|
line++;
|
|
}
|
|
}
|
|
return line;
|
|
}
|
|
|
|
// compare two strings case ignored
|
|
bool strref::same_str(const strref str) const
|
|
{
|
|
if (length!=str.length)
|
|
return false;
|
|
|
|
const uint8_t *scan = get_u();
|
|
const uint8_t *compare = str.get_u();
|
|
if (scan==nullptr || compare==nullptr)
|
|
return scan==compare;
|
|
strl_t compare_left = length;
|
|
while (compare_left) {
|
|
if (int_tolower_ascii7(*scan++)!=int_tolower_ascii7(*compare++))
|
|
return false;
|
|
compare_left--;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// mid string compare
|
|
bool strref::same_substr(const strref str, strl_t pos) const {
|
|
if ((str.length+pos) > length)
|
|
return false;
|
|
|
|
return int_compare_substr(get_u() + pos, length - pos, str.get_u(), str.length);
|
|
}
|
|
|
|
// allow escape codes in search string
|
|
bool strref::same_substr_esc(const strref str, strl_t pos) const {
|
|
if (pos >= length)
|
|
return false;
|
|
|
|
const uint8_t *scan = get_u() + pos;
|
|
const uint8_t *compare = str.get_u();
|
|
strl_t compare_left = str.length;
|
|
while (compare_left) {
|
|
uint8_t c = (uint8_t)*compare++;
|
|
compare_left--;
|
|
if (c=='\\' && compare_left) {
|
|
strl_t skip = int_get_esc_code(compare, compare_left, c);
|
|
compare += skip;
|
|
compare_left -= skip;
|
|
}
|
|
if (int_tolower_ascii7(*scan++) != int_tolower_ascii7(c))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// case sensitive substring compare
|
|
bool strref::same_substr_case(const strref str, strl_t pos) const {
|
|
if ((str.length+pos) > length)
|
|
return false;
|
|
|
|
return int_compare_substr_case(string + pos, length - pos, str.string, str.length);
|
|
}
|
|
|
|
// allow escape codes in search string
|
|
bool strref::same_substr_case_esc(const strref str, strl_t pos) const {
|
|
if (pos >= length)
|
|
return false;
|
|
|
|
const uint8_t *scan = get_u() + pos;
|
|
const uint8_t *compare = str.get_u();
|
|
strl_t compare_left = str.length;
|
|
while (compare_left) {
|
|
uint8_t c = (uint8_t)*compare++;
|
|
compare_left--;
|
|
if (c=='\\' && compare_left) {
|
|
strl_t skip = int_get_esc_code(compare, compare_left, c);
|
|
compare += skip;
|
|
compare_left -= skip;
|
|
}
|
|
if (*scan++ != c)
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// iterate over tokens to find a string that matches substr case ignored
|
|
strref strref::find_token(const char *substr, char token) const
|
|
{
|
|
strref parse = *this;
|
|
while (strref chunk = parse.token_chunk(token)) {
|
|
if (chunk.same_str(substr))
|
|
return chunk;
|
|
parse.token_skip(chunk);
|
|
}
|
|
return strref();
|
|
}
|
|
|
|
// iterate over tokens to find a string matching substr case ignored
|
|
strref strref::find_token(strref substr, char token) const
|
|
{
|
|
strref parse = *this;
|
|
while (strref chunk = parse.token_chunk(token)) {
|
|
if (chunk.same_str(substr))
|
|
return chunk;
|
|
parse.token_skip(chunk);
|
|
}
|
|
return strref();
|
|
}
|
|
|
|
// iterate over tokens to find a string matching substr case sensitive
|
|
strref strref::find_token_case(const char *substr, char token) const
|
|
{
|
|
strref parse = *this;
|
|
while (strref chunk = parse.token_chunk(token)) {
|
|
if (chunk.same_str_case(substr))
|
|
return chunk;
|
|
parse.token_skip(chunk);
|
|
}
|
|
return strref();
|
|
}
|
|
|
|
// iterate over tokens to find a string matching substr case sensitive
|
|
strref strref::find_token_case(strref substr, char token) const
|
|
{
|
|
strref parse = *this;
|
|
while (strref chunk = parse.token_chunk(token)) {
|
|
if (chunk.same_str_case(substr))
|
|
return chunk;
|
|
parse.token_skip(chunk);
|
|
}
|
|
return strref();
|
|
}
|
|
|
|
// determine if string is greater than other string
|
|
bool strref::operator>(const strref o) const
|
|
{
|
|
const char *scan = string;
|
|
const char *compare = o.string;
|
|
strl_t left = length>o.length ? o.length : length;
|
|
while (left) {
|
|
char c1 = *scan++;
|
|
char c2 = *compare++;
|
|
if (c1>c2)
|
|
return true;
|
|
else if (c1<c2)
|
|
return false;
|
|
left--;
|
|
}
|
|
return length>o.length;
|
|
}
|
|
|
|
// determine if string is lesser than other string
|
|
bool strref::operator<(const strref o) const
|
|
{
|
|
const char *scan = string;
|
|
const char *compare = o.string;
|
|
strl_t left = length>o.length ? o.length : length;
|
|
while (left) {
|
|
char c1 = *scan++;
|
|
char c2 = *compare++;
|
|
if (c1<c2)
|
|
return true;
|
|
else if (c1>c2)
|
|
return false;
|
|
left--;
|
|
}
|
|
return length<o.length;
|
|
}
|
|
|
|
// compare two strings case ignored where character same1 is considered equal to same2
|
|
bool strref::same_str(const strref str, char same1, char same2) const
|
|
{
|
|
if (length!=str.length)
|
|
return false;
|
|
|
|
const uint8_t *scan = get_u();
|
|
const uint8_t *compare = str.get_u();
|
|
strl_t left = length;
|
|
while (left) {
|
|
uint8_t c1 = int_tolower_ascii7(*scan++);
|
|
uint8_t c2 = int_tolower_ascii7(*compare++);
|
|
if (c1!=c2 && !(c1==same1 && c2==same2) && !(c1==same2 && c2==same1))
|
|
return false;
|
|
left--;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// compare two strings case ignored
|
|
bool strref::same_str(const char *compare) const
|
|
{
|
|
if (!*compare || !valid())
|
|
return false;
|
|
|
|
const uint8_t *scan = get_u();
|
|
const uint8_t *cmp = (const uint8_t*)compare;
|
|
strl_t left = length;
|
|
uint8_t c;
|
|
for (;;) {
|
|
c = *cmp++;
|
|
if (c == 0 || !left)
|
|
break;
|
|
if (int_tolower_ascii7(*scan++)!=int_tolower_ascii7(c))
|
|
return false;
|
|
left--;
|
|
}
|
|
return !c && !left;
|
|
}
|
|
|
|
// compare two strings case sensitive
|
|
bool strref::same_str_case(const strref str) const
|
|
{
|
|
if (length!=str.length)
|
|
return false;
|
|
|
|
return int_compare_substr_case(string, length, str.string, str.length);
|
|
}
|
|
|
|
// compare two strings case sensitive where character same1 is considered equal to same2
|
|
bool strref::same_str_case(const strref str, char same1, char same2) const
|
|
{
|
|
if (length!=str.length)
|
|
return false;
|
|
|
|
const char *scan = string;
|
|
const char *compare = str.string;
|
|
strl_t left = length;
|
|
while (left) {
|
|
char c1 = *scan++;
|
|
char c2 = *compare++;
|
|
if (c1!=c2 && !(c1==same1 && c2==same2) && !(c1==same2 && c2==same1))
|
|
return false;
|
|
left--;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// compare two strings case sensitive
|
|
bool strref::same_str_case(const char *str)
|
|
{
|
|
if (!*str || !valid())
|
|
return false;
|
|
|
|
const char *scan = string;
|
|
strl_t left = length;
|
|
char c;
|
|
for (;;) {
|
|
c = *str++;
|
|
if (c == 0 || !left)
|
|
break;
|
|
if (*scan++!=c)
|
|
return false;
|
|
left--;
|
|
}
|
|
return !c && !left;
|
|
}
|
|
|
|
// count how many characters match from start between two strings
|
|
strl_t strref::prefix_len(const strref str) const
|
|
{
|
|
const uint8_t *scan = get_u();
|
|
const uint8_t *compare = str.get_u();
|
|
|
|
if (!scan || !compare)
|
|
return 0;
|
|
|
|
strl_t left = length<str.length ? length : str.length;
|
|
strl_t count = 0;
|
|
while (left) {
|
|
if (int_tolower_ascii7(*scan++)!=int_tolower_ascii7(*compare++))
|
|
break;
|
|
count++;
|
|
left--;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
// count how many characters match from start between two strings where
|
|
// character same1 is considered equal to same2
|
|
strl_t strref::prefix_len(const strref str, char same1, char same2) const
|
|
{
|
|
const uint8_t *scan = get_u();
|
|
const uint8_t *compare = str.get_u();
|
|
|
|
strl_t left = length<str.length ? length : str.length;
|
|
strl_t count = 0;
|
|
while (left) {
|
|
uint8_t c1 = int_tolower_ascii7(*scan++);
|
|
uint8_t c2 = int_tolower_ascii7(*compare++);
|
|
if (c1!=c2 && !(c1==same1 && c2==same2) && !(c1==same2 && c2==same1))
|
|
break;
|
|
count++;
|
|
left--;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
// count how many characters match from start between two strings case ignored
|
|
strl_t strref::prefix_len(const char *str) const
|
|
{
|
|
if (!str)
|
|
return 0;
|
|
|
|
const uint8_t *scan = get_u();
|
|
const uint8_t *stru = (const uint8_t*)str;
|
|
strl_t left = length;
|
|
uint8_t c;
|
|
while ((c = *stru++) && left) {
|
|
if (int_tolower_ascii7(*scan++)!=int_tolower_ascii7(c))
|
|
break;
|
|
left--;
|
|
}
|
|
return length-left;
|
|
}
|
|
|
|
// count how many characters match from start between two strings case sensitive
|
|
strl_t strref::prefix_len_case(const strref str) const
|
|
{
|
|
const uint8_t *scan = get_u();
|
|
const uint8_t *compare = str.get_u();
|
|
|
|
strl_t left = length<str.length ? length : str.length;
|
|
strl_t count = 0;
|
|
while (left) {
|
|
if (*scan++!=*compare++)
|
|
break;
|
|
count++;
|
|
left--;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
// count how many characters match from start between two strings case sensitive
|
|
strl_t strref::prefix_len_case(const char *str) const
|
|
{
|
|
if (!str)
|
|
return 0;
|
|
const char *scan = string;
|
|
strl_t left = length;
|
|
char c;
|
|
while ((c = *str++) && left) {
|
|
if (*scan++!=c)
|
|
break;
|
|
left--;
|
|
}
|
|
return length-left;
|
|
}
|
|
|
|
// count how many characters match from the end between two strings case ignored
|
|
strl_t strref::suffix_len(const strref str) const
|
|
{
|
|
const uint8_t *scan = get_u()+length;
|
|
const uint8_t *compare = str.get_u()+str.length;
|
|
|
|
strl_t left = length<str.length ? length : str.length;
|
|
strl_t count = 0;
|
|
while (left) {
|
|
if (int_tolower_ascii7(*(--scan))!=int_tolower_ascii7(*(--compare)))
|
|
break;
|
|
count++;
|
|
left--;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
// count how many characters match from the end between two strings case sensitive
|
|
strl_t strref::suffix_len_case(const strref str) const
|
|
{
|
|
const uint8_t *scan = get_u()+length;
|
|
const uint8_t *compare = str.get_u()+str.length;
|
|
|
|
strl_t left = length<str.length ? length : str.length;
|
|
strl_t count = 0;
|
|
while (left) {
|
|
if (*(--scan)!=*(--compare))
|
|
break;
|
|
count++;
|
|
left--;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
// find a substring within a string case ignored
|
|
int strref::find(const strref str) const
|
|
{
|
|
if (!str.valid() || !valid() || length<str.length)
|
|
return -1;
|
|
|
|
const uint8_t *scan = get_u();
|
|
strl_t left = length;
|
|
|
|
const uint8_t *compare = str.get_u();
|
|
strl_t find_len = str.length;
|
|
|
|
uint8_t c = int_tolower_ascii7(*compare++);
|
|
|
|
while (left>=find_len) {
|
|
if (int_tolower_ascii7(*scan++)==c) {
|
|
if (int_compare_substr(scan, left - 1, compare, find_len - 1))
|
|
return int(length-left);
|
|
}
|
|
left--;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// find a substring within a string case ignored
|
|
int strref::find_bookend(const strref str, const strref bookend) const
|
|
{
|
|
if (!str.valid() || !valid() || length<str.length)
|
|
return -1;
|
|
|
|
const uint8_t *scan = get_u();
|
|
strl_t left = length;
|
|
|
|
const uint8_t *compare = str.get_u();
|
|
strl_t find_len = str.length;
|
|
|
|
uint8_t p = 0;
|
|
uint8_t c = int_tolower_ascii7(*compare++);
|
|
|
|
while (left >= find_len) {
|
|
uint8_t d = int_tolower_ascii7(*scan++);
|
|
if (d == c && (left == length || bookend.char_matches_ranges(p)) &&
|
|
(left == find_len || bookend.char_matches_ranges(int_tolower_ascii7(scan[find_len-1])))) {
|
|
if (int_compare_substr(scan, left - 1, compare, find_len - 1))
|
|
return int(length - left);
|
|
}
|
|
p = d;
|
|
left--;
|
|
}
|
|
return -1;
|
|
}
|
|
// find a substring within a string case ignored starting at pos
|
|
int strref::find(const strref str, strl_t pos) const
|
|
{
|
|
if (!str.valid() || !valid() || length<str.length)
|
|
return -1;
|
|
|
|
const uint8_t *scan = get_u() + pos;
|
|
strl_t left = length - pos;
|
|
|
|
const uint8_t *compare = str.get_u();
|
|
strl_t find_len = str.length;
|
|
|
|
uint8_t c = int_tolower_ascii7(*compare++);
|
|
while (left >= find_len) {
|
|
if (int_tolower_ascii7(*scan++) == c) {
|
|
if (int_compare_substr(scan, left - 1, compare, find_len - 1))
|
|
return int(length - left);
|
|
}
|
|
left--;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
// find case sensitive allow escape codes (\x => x) in search string
|
|
int strref::find_esc(const strref str, strl_t pos) const
|
|
{
|
|
if (!str.valid() || !valid() || pos>=length)
|
|
return -1;
|
|
|
|
// start scan buffer pointers
|
|
const uint8_t *scan = get_u() + pos;
|
|
const uint8_t *compare = str.get_u();
|
|
|
|
// number of characters left in each buffer
|
|
strl_t scan_left = length - pos;
|
|
strl_t compare_left = str.length;
|
|
|
|
// get first character
|
|
uint8_t c = (uint8_t)*compare++;
|
|
compare_left--;
|
|
if (c=='\\' && compare_left) {
|
|
strl_t skip = int_get_esc_code(compare, compare_left, c);
|
|
compare += skip;
|
|
compare_left -= skip;
|
|
}
|
|
|
|
// sweep the scan buffer for the matching string
|
|
while (scan_left) {
|
|
if (*scan++ == c) {
|
|
const uint8_t *chk_scan = scan;
|
|
const uint8_t *chk_compare = compare;
|
|
strl_t chk_scan_left = scan_left;
|
|
strl_t chk_compare_left = compare_left;
|
|
while (chk_compare_left) {
|
|
uint8_t d = *chk_compare++;
|
|
chk_compare_left--;
|
|
if (d=='\\' && compare_left) {
|
|
strl_t skip = int_get_esc_code(compare, compare_left, d);
|
|
compare += skip;
|
|
compare_left -= skip;
|
|
}
|
|
if (!chk_scan_left || int_tolower_ascii7(*chk_scan++)!=int_tolower_ascii7(d)) {
|
|
chk_compare_left = 1;
|
|
break;
|
|
}
|
|
chk_scan_left--;
|
|
}
|
|
if (!chk_compare_left)
|
|
return int(length - scan_left);
|
|
}
|
|
scan_left--;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// find a substring within a string case ignored
|
|
int strref::find(const char *str, strl_t pos) const
|
|
{
|
|
if (!str || !valid() || pos>=length)
|
|
return -1;
|
|
|
|
const uint8_t *stru = (const uint8_t*)str;
|
|
uint8_t c = int_tolower_ascii7(*stru++);
|
|
if (!c)
|
|
return 0;
|
|
|
|
const uint8_t *scan = get_u() + pos;
|
|
const uint8_t *compare = stru;
|
|
|
|
strl_t l = length - pos;
|
|
while (l) {
|
|
if (int_tolower_ascii7(*scan++)==c) {
|
|
bool equal = true;
|
|
const uint8_t *scan_chk = scan;
|
|
while (uint8_t c2 = *compare++) {
|
|
if (int_tolower_ascii7(*scan_chk++)!=int_tolower_ascii7(c2)) {
|
|
compare = stru;
|
|
equal = false;
|
|
break;
|
|
}
|
|
}
|
|
if (equal)
|
|
return int(length-l);
|
|
}
|
|
l--;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// find a substring within a string case sensitive
|
|
int strref::find_case(const strref str, strl_t pos) const
|
|
{
|
|
if (!str.valid() || !valid() || length<str.length || pos>=length)
|
|
return -1;
|
|
|
|
const char *scan = string + pos;
|
|
const char *compare = str.string, *compare_chk = compare;
|
|
strl_t left2 = str.length - pos;
|
|
|
|
strl_t left = length;
|
|
while (left>=left2) {
|
|
if (*scan++==*compare_chk) {
|
|
const char *scan_chk = scan;
|
|
compare_chk++;
|
|
while (--left2) {
|
|
if (*scan_chk++!=*compare_chk++) {
|
|
compare_chk = compare;
|
|
left2 = str.length;
|
|
break;
|
|
}
|
|
}
|
|
if (!left2)
|
|
return int(length-left);
|
|
}
|
|
left--;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// find case sensitive allow escape codes (\x => x) in search string
|
|
int strref::find_case_esc(const strref str, strl_t pos) const
|
|
{
|
|
if (!str.valid() || !valid() || pos>=length)
|
|
return -1;
|
|
|
|
// start scan buffer pointers
|
|
const uint8_t *scan = get_u() + pos;
|
|
const uint8_t *compare = str.get_u();
|
|
|
|
// number of characters left in each buffer
|
|
strl_t scan_left = length - pos;
|
|
strl_t compare_left = str.length;
|
|
|
|
// get first character
|
|
uint8_t c = *compare++;
|
|
compare_left--;
|
|
if (c=='\\' && compare_left) {
|
|
strl_t skip = int_get_esc_code(compare, compare_left, c);
|
|
compare += skip;
|
|
compare_left -= skip;
|
|
}
|
|
|
|
// sweep the scan buffer for the matching string
|
|
while (scan_left) {
|
|
if (*scan++ == c) {
|
|
const uint8_t *chk_scan = scan;
|
|
const uint8_t *chk_compare = compare;
|
|
strl_t chk_scan_left = scan_left;
|
|
strl_t chk_compare_left = compare_left;
|
|
while (chk_compare_left) {
|
|
uint8_t d = *chk_compare++;
|
|
chk_compare_left--;
|
|
if (d=='\\' && chk_compare_left) {
|
|
strl_t skip = int_get_esc_code(chk_compare, chk_compare_left, d);
|
|
chk_compare += skip;
|
|
chk_compare_left -= skip;
|
|
}
|
|
if (!chk_scan_left || *chk_scan++!=d) {
|
|
chk_compare_left = 1;
|
|
break;
|
|
}
|
|
chk_scan_left--;
|
|
}
|
|
if (!chk_compare_left)
|
|
return int(length - scan_left);
|
|
}
|
|
scan_left--;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// checks if a range is an exclusion
|
|
static strref int_check_exclude(strref range, bool &include)
|
|
{
|
|
const char *rng = range.get();
|
|
strl_t rng_left = range.get_len();
|
|
if (rng_left && *rng == '!') {
|
|
include = false;
|
|
return range + 1;
|
|
}
|
|
include = true;
|
|
return range;
|
|
}
|
|
|
|
// checks if character c matches range
|
|
static bool int_char_match_range_case(uint8_t c, const uint8_t *rng_chk, strl_t rng_lft)
|
|
{
|
|
// no match yet, check skipped character against allowed range
|
|
bool match = false;
|
|
while (rng_lft) {
|
|
uint8_t m = *rng_chk++;
|
|
rng_lft--;
|
|
// escape code?
|
|
if (m == '\\' && rng_lft) {
|
|
strl_t skip = int_get_esc_code(rng_chk, rng_lft, m);
|
|
rng_chk += skip;
|
|
rng_lft -= skip;
|
|
}
|
|
// range?
|
|
if (rng_lft>1 && *rng_chk == '-') {
|
|
rng_chk++;
|
|
rng_lft--;
|
|
uint8_t n = (uint8_t)*rng_chk++;
|
|
rng_lft--;
|
|
// escape code for range end?
|
|
if (n == '\\' && rng_lft) {
|
|
strl_t skip = int_get_esc_code(rng_chk, rng_lft, n);
|
|
rng_chk += skip;
|
|
rng_lft -= skip;
|
|
}
|
|
if (c >= m && c <= n) {
|
|
match = true;
|
|
break;
|
|
}
|
|
}
|
|
else if (c == m) {
|
|
match = true;
|
|
break;
|
|
}
|
|
}
|
|
return match;
|
|
}
|
|
|
|
// checks if character c matches range
|
|
static bool int_char_match_range(uint8_t c, const uint8_t *rng_chk, strl_t rng_lft)
|
|
{
|
|
// no match yet, check skipped character against allowed range
|
|
bool match = false;
|
|
while (rng_lft) {
|
|
uint8_t m = (uint8_t)*rng_chk++;
|
|
rng_lft--;
|
|
// escape code?
|
|
if (m == '\\' && rng_lft) {
|
|
strl_t skip = int_get_esc_code(rng_chk, rng_lft, m);
|
|
rng_chk += skip;
|
|
rng_lft -= skip;
|
|
}
|
|
// range?
|
|
if (rng_lft>1 && *rng_chk == '-') {
|
|
rng_chk++;
|
|
rng_lft--;
|
|
uint8_t n = (uint8_t)*rng_chk++;
|
|
rng_lft--;
|
|
// escape code for range end?
|
|
if (n == '\\' && rng_lft) {
|
|
strl_t skip = int_get_esc_code(rng_chk, rng_lft, n);
|
|
rng_chk += skip;
|
|
rng_lft -= skip;
|
|
}
|
|
if (c >= int_tolower_ascii7(m) && c <= int_tolower_ascii7(n)) {
|
|
match = true;
|
|
break;
|
|
}
|
|
}
|
|
else if (c == int_tolower_ascii7(m)) {
|
|
match = true;
|
|
break;
|
|
}
|
|
}
|
|
return match;
|
|
}
|
|
|
|
// find case sensitive allow escape codes (\x => x) in search string
|
|
int strref::find_case_esc_range(const strref str, const strref range, strl_t pos) const
|
|
{
|
|
if (!str.valid() || !valid() || pos>=get_len() || !range.get_len())
|
|
return -1;
|
|
|
|
// start scan buffer pointers
|
|
const uint8_t *scan = get_u() + pos;
|
|
const uint8_t *compare = str.get_u();
|
|
|
|
// number of characters left in each buffer
|
|
strl_t scan_left = length - pos;
|
|
strl_t compare_left = str.length;
|
|
|
|
// get first character
|
|
uint8_t c = *compare++;
|
|
compare_left--;
|
|
if (c=='\\' && compare_left) {
|
|
strl_t skip = int_get_esc_code(compare, compare_left, c);
|
|
compare += skip;
|
|
compare_left -= skip;
|
|
}
|
|
|
|
// check if range is inclusive or exclusive
|
|
bool include;
|
|
strref rng = int_check_exclude(range, include);
|
|
|
|
// sweep the scan buffer for the matching string
|
|
while (scan_left) {
|
|
uint8_t b = (uint8_t)*scan++;
|
|
// check for string match
|
|
if (b == c) {
|
|
const uint8_t *chk_scan = scan;
|
|
const uint8_t *chk_compare = compare;
|
|
strl_t chk_scan_left = scan_left;
|
|
strl_t chk_compare_left = compare_left;
|
|
while (chk_compare_left) {
|
|
uint8_t d = *chk_compare++;
|
|
chk_compare_left--;
|
|
uint8_t e = *chk_scan++;
|
|
chk_scan_left--;
|
|
if (d=='\\' && compare_left) {
|
|
strl_t skip = int_get_esc_code(compare, compare_left, d);
|
|
compare += skip;
|
|
compare_left -= skip;
|
|
}
|
|
if (e!=d) {
|
|
chk_compare_left = 1;
|
|
break;
|
|
}
|
|
}
|
|
if (!chk_compare_left)
|
|
return int(length - scan_left);
|
|
}
|
|
|
|
// no match yet, check character against range
|
|
// check if character is allowed
|
|
bool match = int_char_match_range_case(b, rng.get_u(), rng.get_len());
|
|
if ((match && !include) || (!match && include))
|
|
return -1;
|
|
|
|
scan_left--;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// find substring, allow escape codes (\x => x) in search string
|
|
int strref::find_esc_range(const strref str, const strref range, strl_t pos) const
|
|
{
|
|
if (!str.valid() || !valid() || pos>=get_len() || !range.get_len())
|
|
return -1;
|
|
|
|
// start scan buffer pointers
|
|
const uint8_t *scan = get_u() + pos;
|
|
const uint8_t *compare = str.get_u();
|
|
|
|
// number of characters left in each buffer
|
|
strl_t scan_left = length - pos;
|
|
strl_t compare_left = str.length;
|
|
|
|
// get first character
|
|
uint8_t c = *compare++;
|
|
compare_left--;
|
|
if (c=='\\' && compare_left) {
|
|
strl_t skip = int_get_esc_code(compare, compare_left, c);
|
|
compare += skip;
|
|
compare_left -= skip;
|
|
}
|
|
|
|
// check if range is inclusive or exclusive
|
|
bool include;
|
|
strref rng = int_check_exclude(range, include);
|
|
|
|
// sweep the scan buffer for the matching string
|
|
while (scan_left) {
|
|
uint8_t b = int_tolower_ascii7(*scan++);
|
|
// check for string match
|
|
if (b == c) {
|
|
const uint8_t *chk_scan = scan;
|
|
const uint8_t *chk_compare = compare;
|
|
strl_t chk_scan_left = scan_left;
|
|
strl_t chk_compare_left = compare_left;
|
|
while (chk_compare_left) {
|
|
uint8_t d = int_tolower_ascii7(*chk_compare++);
|
|
chk_compare_left--;
|
|
uint8_t e = int_tolower_ascii7(*chk_scan++);
|
|
chk_scan_left--;
|
|
if (d=='\\' && compare_left) {
|
|
strl_t skip = int_get_esc_code(compare, compare_left, d);
|
|
compare += skip;
|
|
compare_left -= skip;
|
|
}
|
|
if (e!=d) {
|
|
chk_compare_left = 1;
|
|
break;
|
|
}
|
|
}
|
|
if (!chk_compare_left)
|
|
return int(length - scan_left);
|
|
}
|
|
|
|
// no match yet, check character against range
|
|
bool match = int_char_match_range(b, rng.get_u(), rng.get_len());
|
|
|
|
// check if character is allowed
|
|
if ((match && !include) || (!match && include))
|
|
return -1;
|
|
|
|
scan_left--;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// find a substring within a string case sensitive
|
|
int strref::find_case(const char *str) const
|
|
{
|
|
if (!str || !valid())
|
|
return -1;
|
|
|
|
char c = *str++;
|
|
if (!c)
|
|
return 0;
|
|
|
|
const char *scan = string;
|
|
const char *compare = str;
|
|
|
|
strl_t left = length;
|
|
while (left) {
|
|
if (*scan++==c) {
|
|
bool equal = true;
|
|
const char *pb = scan;
|
|
while (char c2 = *compare++) {
|
|
if (*pb++!=c2) {
|
|
compare = str;
|
|
equal = false;
|
|
break;
|
|
}
|
|
}
|
|
if (equal)
|
|
return int(length-left);
|
|
}
|
|
left--;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// find last matching substring within a string case ignored
|
|
int strref::find_last(const strref str) const
|
|
{
|
|
if (!str.valid() || !valid() || length<str.length)
|
|
return -1;
|
|
|
|
const uint8_t *scan = get_u() + length;
|
|
const uint8_t *compare = str.get_u() + str.length;
|
|
|
|
uint8_t c = int_tolower_ascii7(*--compare);
|
|
|
|
int left = (int)length;
|
|
while (left>0) {
|
|
left--;
|
|
if (int_tolower_ascii7(*--scan)==c) {
|
|
const uint8_t *scan_chk = scan;
|
|
const uint8_t *cmp_chk = compare;
|
|
strl_t left_check = str.length;
|
|
while (--left_check) {
|
|
if (int_tolower_ascii7(*--scan_chk)!=int_tolower_ascii7(*--cmp_chk)) {
|
|
left_check = 1;
|
|
break;
|
|
}
|
|
}
|
|
if (!left_check)
|
|
return left-(int)str.length+1;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// find last matching substring within a string case ignored
|
|
int strref::find_last_bookend(const strref str, const strref bookend) const
|
|
{
|
|
if (!str.valid() || !valid() || length<str.length)
|
|
return -1;
|
|
|
|
const uint8_t *scan = get_u() + length;
|
|
const uint8_t *compare = str.get_u() + str.length;
|
|
|
|
uint8_t c = int_tolower_ascii7(*--compare);
|
|
uint8_t p = 0;
|
|
strl_t left = length;
|
|
while (left>0) {
|
|
left--;
|
|
uint8_t d = int_tolower_ascii7(*--scan);
|
|
if (d == c && (left==length || bookend.char_matches_ranges(p))) {
|
|
const uint8_t *scan_chk = scan;
|
|
const uint8_t *cmp_chk = compare;
|
|
strl_t left_check = str.length;
|
|
while (--left_check) {
|
|
if (int_tolower_ascii7(*--scan_chk) != int_tolower_ascii7(*--cmp_chk)) {
|
|
left_check = 1;
|
|
break;
|
|
}
|
|
}
|
|
if (!left_check) {
|
|
if (get_u() == scan_chk || bookend.char_matches_ranges(int_tolower_ascii7(*--scan_chk)))
|
|
return int(left - str.length + 1);
|
|
}
|
|
}
|
|
p = d;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// find last matching substring within a string case ignored
|
|
int strref::find_last(const char *str) const
|
|
{
|
|
if (!str || !*str || !valid())
|
|
return -1;
|
|
|
|
const uint8_t *scan = get_u()+length;
|
|
const uint8_t *compare = (const uint8_t*)str + strlen(str);
|
|
uint8_t c = int_tolower_ascii7(*--compare);
|
|
int l = (int)length;
|
|
while (l>=0) {
|
|
l--;
|
|
if (int_tolower_ascii7(*--scan)==c) {
|
|
const uint8_t *scan_chk = scan;
|
|
const uint8_t *cmp_chk = compare;
|
|
while (cmp_chk>(const uint8_t*)str) {
|
|
if (int_tolower_ascii7(*--scan_chk)!=int_tolower_ascii7(*--cmp_chk)) {
|
|
cmp_chk = compare;
|
|
break;
|
|
}
|
|
}
|
|
if (cmp_chk==(const uint8_t*)str)
|
|
return int(scan_chk-(const uint8_t*)string);
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// find last matching substring within a string case sensitive
|
|
int strref::find_last_case(const strref str) const
|
|
{
|
|
if (!str.valid() || !valid() || length<str.length)
|
|
return -1;
|
|
|
|
const char *scan = string+length-str.length;
|
|
const char *compare = str.string+str.length-1,
|
|
*compare_chk = compare;
|
|
strl_t left_chk = str.length;
|
|
|
|
int left = int(length-left_chk);
|
|
while (left>=0) {
|
|
if (*--scan==*compare_chk) {
|
|
const char *scan_chk = scan;
|
|
while (--left_chk) {
|
|
if (*--scan_chk!=*--compare_chk) {
|
|
compare_chk = compare;
|
|
left_chk = str.length;
|
|
break;
|
|
}
|
|
}
|
|
if (!left_chk)
|
|
return int(length-left);
|
|
}
|
|
left--;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// count number of matching substrings in string
|
|
int strref::substr_count(const strref str) const
|
|
{
|
|
if (!str.valid() || !valid() || length<str.length)
|
|
return 0;
|
|
|
|
int count = 0;
|
|
const uint8_t *scan = get_u();
|
|
strl_t left = length;
|
|
strl_t substrlen = str.length;
|
|
uint8_t c = int_tolower_ascii7((uint8_t)str.get_first());
|
|
|
|
while (left>=substrlen) {
|
|
while (left && int_tolower_ascii7(*scan++)!=c)
|
|
left--;
|
|
if (left && left>=substrlen) {
|
|
// first character matches and enough characters remain for a potential match
|
|
const uint8_t *compare = str.get_u()+1;
|
|
strl_t sr = substrlen-1;
|
|
const uint8_t *scan_chk = scan;
|
|
while (sr && int_tolower_ascii7(*compare++)==int_tolower_ascii7(*scan_chk++))
|
|
sr--;
|
|
if (sr==0) {
|
|
scan = scan_chk;
|
|
left -= substrlen-1;
|
|
count++;
|
|
}
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
|
|
// count number of matching substrings in string
|
|
int strref::substr_count_bookend(const strref str, const strref bookend) const
|
|
{
|
|
if (!str.valid() || !valid() || length<str.length)
|
|
return 0;
|
|
|
|
int count = 0;
|
|
const uint8_t *scan = get_u();
|
|
strl_t left = length;
|
|
strl_t substrlen = str.length;
|
|
uint8_t c = int_tolower_ascii7((uint8_t)str.get_first());
|
|
uint8_t p = 0;
|
|
|
|
while (left >= substrlen) {
|
|
|
|
while (left) {
|
|
uint8_t d = int_tolower_ascii7(*scan++);
|
|
if (d == c && bookend.char_matches_ranges(p))
|
|
break;
|
|
p = d;
|
|
left--;
|
|
}
|
|
if (left && left >= substrlen) {
|
|
// first character matches and enough characters remain for a potential match
|
|
const uint8_t *compare = str.get_u() + 1;
|
|
strl_t sr = substrlen - 1;
|
|
const uint8_t *scan_chk = scan;
|
|
while (sr && int_tolower_ascii7(*compare++) == int_tolower_ascii7(*scan_chk++))
|
|
sr--;
|
|
if (sr == 0 && (scan_chk == (get_u() + length) || bookend.char_matches_ranges(int_tolower_ascii7(*scan_chk++)))) {
|
|
scan = scan_chk;
|
|
left -= substrlen - 1;
|
|
count++;
|
|
}
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
|
|
// count number of matching substrings in string
|
|
int strref::substr_case_count(const strref str) const
|
|
{
|
|
if (!str.valid() || !valid() || length<str.length)
|
|
return 0;
|
|
|
|
int count = 0;
|
|
const char *scan = string;
|
|
strl_t left = length;
|
|
strl_t substrlen = str.length;
|
|
char c = str.get_first();
|
|
|
|
while (left>=substrlen) {
|
|
while (left && *scan++!=c)
|
|
left--;
|
|
if (left && left>=substrlen) {
|
|
// first character matches and enough characters remain for a potential match
|
|
const char *compare = str.string+1;
|
|
strl_t sr = substrlen-1;
|
|
const char *scan_chk = scan;
|
|
while (sr && *compare++==*scan_chk++)
|
|
sr--;
|
|
if (sr==0) {
|
|
scan = scan_chk;
|
|
left -= substrlen-1;
|
|
count++;
|
|
}
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
|
|
// count number of matching substrings that are bounded by separators and case sensitive in string
|
|
int strref::substr_label_case_count(const strref str) const
|
|
{
|
|
if (!str.valid() || !valid() || length<str.length)
|
|
return 0;
|
|
|
|
int count = 0;
|
|
const uint8_t *scan = get_u();
|
|
strl_t left = length;
|
|
strl_t substrlen = str.length;
|
|
uint8_t c = (uint8_t)str.get_first(), p=0;
|
|
|
|
while (left>=substrlen) {
|
|
while (left) {
|
|
uint8_t d = *scan++;
|
|
if (d==c)
|
|
break;
|
|
left--;
|
|
p = d;
|
|
}
|
|
if (!is_valid_label(p) && left && left>=substrlen) {
|
|
// first character matches and enough characters remain for a potential match
|
|
const char *compare = str.string+1;
|
|
strl_t sr = substrlen-1;
|
|
const uint8_t *scan_chk = scan;
|
|
while (sr && *compare++==*scan_chk++)
|
|
sr--;
|
|
if (sr==0) {
|
|
if (!left || !is_valid_label(*scan_chk)) {
|
|
scan = scan_chk;
|
|
left -= substrlen-1;
|
|
count++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
|
|
// count how many times character c repeats at pos
|
|
int strref::count_repeat(char c, strl_t pos) const {
|
|
if (pos>=length)
|
|
return 0;
|
|
const char *scan = string + pos;
|
|
strl_t left = length - pos;
|
|
int count = 0;
|
|
while (left) {
|
|
if (*scan++ != c)
|
|
return count;
|
|
left--;
|
|
count++;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
// count how many time a character repeats backwards at pos
|
|
int strref::count_repeat_reverse(char c, strl_t pos) const {
|
|
if (pos>=length)
|
|
return 0;
|
|
const char *scan = string + pos;
|
|
strl_t left = pos;
|
|
int count = 0;
|
|
while (left) {
|
|
if (*scan-- != c)
|
|
return count;
|
|
left--;
|
|
count++;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
// count number of lines with any line ending standard
|
|
int strref::count_lines() const {
|
|
const char *scan = string;
|
|
strl_t left = length;
|
|
int count = 0;
|
|
while (left) {
|
|
char c = *scan++;
|
|
left--;
|
|
if (c==0x0a || c==0x0d) {
|
|
count++;
|
|
if (left && ((c==0x0a && *scan==0x0d) || (c==0x0d && *scan==0x0a))) {
|
|
scan++;
|
|
left--;
|
|
}
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
|
|
strl_t strref::prev_line_pos( strl_t pos )
|
|
{
|
|
if( !pos || !length ) { return pos; }
|
|
|
|
const char *start = string;
|
|
pos = pos < length ? pos : length;
|
|
--pos;
|
|
char c = start[pos];
|
|
if( c==0x0a || c==0x0d ) --pos;
|
|
if(pos && ((c==0x0a && start[pos]==0x0d) || (c==0x0d && start[pos]==0x0a))) --pos;
|
|
while( pos && start[pos-1]!=0x0a && start[pos-1]!=0x0d ) --pos;
|
|
return pos;
|
|
}
|
|
|
|
strl_t strref::start_line_pos( strl_t pos )
|
|
{
|
|
if( !pos || !length ) { return pos; }
|
|
|
|
const char *start = string;
|
|
pos = pos < length ? pos : length;
|
|
--pos;
|
|
while( pos && start[pos-1]!=0x0a && start[pos-1]!=0x0d ) --pos;
|
|
return pos;
|
|
}
|
|
|
|
strl_t strref::end_line_pos( strl_t pos )
|
|
{
|
|
const char *start = string;
|
|
if( pos > length ) { return length; }
|
|
while( pos < length ) {
|
|
if (start[pos]==0x0a || start[pos] == 0x0d) { return pos; }
|
|
++pos;
|
|
}
|
|
return pos;
|
|
}
|
|
|
|
|
|
// find any char from str in this string at position
|
|
// (does not check for escape codes or ranges)
|
|
int strref::find_any_char_of(const strref range, strl_t pos) const {
|
|
if (pos>=length)
|
|
return -1;
|
|
|
|
const char *scan = get() + pos;
|
|
strl_t left = length-pos;
|
|
|
|
const char *rng = range.get();
|
|
strl_t count = range.get_len();
|
|
|
|
while (left) {
|
|
char c = *scan++;
|
|
const char *rng_chk = rng;
|
|
for (strl_t n = count; n; --n) {
|
|
if (c == *rng_chk++)
|
|
return int(length-left);
|
|
}
|
|
left--;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static int int_find_range(const char *scan, strl_t left, strl_t length, strref rng, bool include)
|
|
{
|
|
while (left) {
|
|
uint8_t c = (uint8_t)*scan++;
|
|
bool match = int_char_match_range_case(c, rng.get_u(), rng.get_len());
|
|
if ((match && include) || (!match && !include))
|
|
return int(length - left);
|
|
left--;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// find a character matching a range, allow a range of characters using '-'
|
|
// such as a-fq0-5 == abcdefq012345 and prefix ! to exclude
|
|
int strref::find_any_char_or_range(const strref range, strl_t pos) const {
|
|
if (pos>=length)
|
|
return -1;
|
|
|
|
bool include;
|
|
strref rng = int_check_exclude(range, include);
|
|
|
|
return int_find_range(string+pos, length-pos, length, rng, include);
|
|
}
|
|
|
|
// find a word made out of characters in the given range
|
|
strref strref::get_range_word(const strref range, strl_t pos) const
|
|
{
|
|
if (pos >= length)
|
|
return strref();
|
|
|
|
bool include;
|
|
strref rng = int_check_exclude(range, include);
|
|
|
|
return get_substr(0, (strl_t)int_find_range(string + pos, length - pos, length, rng, !include));
|
|
}
|
|
|
|
int strref::find_any_not_in_range(const strref range, strl_t pos) const {
|
|
if (pos>=length)
|
|
return -1;
|
|
|
|
if (pos>=length)
|
|
return -1;
|
|
|
|
bool include;
|
|
strref rng = int_check_exclude(range, include);
|
|
|
|
return int_find_range(string+pos, length-pos, length, rng, !include);
|
|
}
|
|
|
|
// search of a character in a given range while also checking that
|
|
// skipped characters are in another given range.
|
|
int strref::find_range_char_within_range(const strref range_find, const strref range_within, strl_t pos) const {
|
|
if (pos>=length)
|
|
return -1;
|
|
|
|
const char *scan = get() + pos;
|
|
strl_t l = length-pos;
|
|
|
|
// check if range is inclusive or exclusive
|
|
bool include_find;
|
|
strref rng_f = int_check_exclude(range_find, include_find);
|
|
|
|
bool include_within;
|
|
strref rng_w = int_check_exclude(range_within, include_within);
|
|
|
|
while (l) {
|
|
uint8_t c = (uint8_t)*scan++;
|
|
bool match_find = int_char_match_range_case(c, rng_f.get_u(), rng_f.get_len());
|
|
if ((match_find && include_find) || (!match_find && !include_find))
|
|
return int(length - l);
|
|
|
|
// no match yet, check skipped character against allowed range
|
|
bool match = int_char_match_range_case(c, rng_w.get_u(), rng_w.get_len());
|
|
|
|
// check if character is allowed
|
|
if ((match && !include_within) || (!match && include_within))
|
|
return -1;
|
|
l--;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// check if character matches a given range (this)
|
|
bool strref::char_matches_ranges(uint8_t c) const {
|
|
// check if range is inclusive or exclusive
|
|
bool include;
|
|
strref rng = int_check_exclude(*this, include);
|
|
bool match = int_char_match_range_case(c, rng.get_u(), rng.get_len());
|
|
return (match && include) || (!match && !include);
|
|
}
|
|
|
|
// count number of characters matching the range match as long
|
|
// as it is terminated by a given character or empty
|
|
strl_t strref::match_chars_str(const strref match, const strref term)
|
|
{
|
|
bool include_match, include_term;
|
|
strref rng = int_check_exclude(match, include_match);
|
|
strref trm = int_check_exclude(term, include_term);
|
|
strl_t ret = 0;
|
|
const uint8_t *str = get_u();
|
|
strl_t left = length;
|
|
while (left) {
|
|
uint8_t c = *str++;
|
|
if (include_match == int_char_match_range_case(c, rng.get_u(), rng.get_len())) {
|
|
ret++;
|
|
} else if (!term || include_term == int_char_match_range_case(c, trm.get_u(), trm.get_len())) {
|
|
return ret;
|
|
} else
|
|
return 0;
|
|
left--;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
// wildcard search
|
|
|
|
#define MAX_WILDCARD_SEGMENTS 64
|
|
#define MAX_WILDCARD_STEPS 48
|
|
#define MAX_WILDCARD_SEARCH_STACK 32
|
|
enum WILDCARD_SEGMENT_TYPE {
|
|
WCST_END,
|
|
WCST_FIND_SUBSTR,
|
|
WCST_FIND_SUBSTR_RANGE,
|
|
WCST_SUBSTR_MATCH_RANGE,
|
|
WCST_FIND_RANGE_CHAR,
|
|
WCST_FIND_RANGE_CHAR_RANGED,
|
|
WCST_FIND_WORD_START,
|
|
WCST_FIND_WORD_START_RANGED,
|
|
WCST_FIND_WORD_END,
|
|
WCST_FIND_WORD_END_RANGED,
|
|
WCST_FIND_LINE_START,
|
|
WCST_FIND_LINE_START_RANGED,
|
|
WCST_FIND_LINE_END,
|
|
WCST_FIND_LINE_END_RANGED,
|
|
WCST_NEXT_SUBSTR,
|
|
WCST_NEXT_ANY_CHAR,
|
|
WCST_NEXT_RANGE_CHAR,
|
|
WCST_NEXT_WORD_START,
|
|
WCST_NEXT_WORD_END,
|
|
WCST_NEXT_LINE_START,
|
|
WCST_NEXT_LINE_END,
|
|
};
|
|
|
|
// ? => any single
|
|
// # => any single number
|
|
// [] => any single between the brackets
|
|
// [-] => any single in the range from character before - to character after
|
|
// [!] => any single not between the brackets
|
|
// < => start of word
|
|
// > => end of word
|
|
// @ => start of line
|
|
// ^ => end of line
|
|
// * => any substring
|
|
// *% => any substring excluding whitespace
|
|
// *@ => any substring on same line
|
|
// *$ => any substring containing alphanumeric ascii characters
|
|
// *{} => any substring only containing characters between parenthesis
|
|
// *{!} => any substring not containing characters between parenthesis
|
|
// \?, \[, \*, etc. => search for character after backslash
|
|
// \n, \t, etc. => search for linefeed, tab etc.
|
|
//
|
|
// words are groups of letters not containing whitespace or separators
|
|
// which are alphanumeric characters plus apostrophe (')
|
|
|
|
// predefined ranges for wildcard filters
|
|
static const strref _no_whitespace_range("!\01- ");
|
|
static const strref _no_enter_range("!\n\r");
|
|
static const strref _enter_range("\n\r");
|
|
static const strref _alphanumeric_range("0-9A-Za-z");
|
|
static const strref _numeric_range("0-9");
|
|
static const strref _wildcard_control("*?#[<>@^");
|
|
|
|
// convert wildcard to a set of search steps
|
|
static int _build_wildcard_steps(const strref wild, strref *segs, char *type, int &segments) {
|
|
int numSeg = 0;
|
|
int numType = 0;
|
|
|
|
// segment separators are: *, ?, [, <
|
|
int pos = 0, last = 0; // current position, last evaluated position
|
|
bool search = true; // in search mode
|
|
strref range;
|
|
for (;;) {
|
|
// check for number of search segments / number of search steps overflow
|
|
if (numSeg > (MAX_WILDCARD_SEGMENTS-4) || numType > (MAX_WILDCARD_STEPS-2))
|
|
return strref();
|
|
int next_pos = wild.find_any_char_of(_wildcard_control, (strl_t)pos);
|
|
if (next_pos<0) { // completed? (found no wildcard token)
|
|
// add last segment if there was one
|
|
if (wild.get_len() > (strl_t)last) {
|
|
segs[numSeg++] = wild.get_substr((strl_t)last, wild.get_len()-(strl_t)last);
|
|
if (search && range)
|
|
segs[numSeg++] = range;
|
|
type[numType++] = (char)(search ? (range ? WCST_FIND_SUBSTR_RANGE : WCST_FIND_SUBSTR) : WCST_NEXT_SUBSTR);
|
|
} else if (range) {
|
|
segs[numSeg++] = range;
|
|
type[numType++] = WCST_SUBSTR_MATCH_RANGE;
|
|
}
|
|
range.clear();
|
|
break;
|
|
}
|
|
switch (wild.get_at((strl_t)next_pos)) {
|
|
case '*': // * => any substring with optional filter
|
|
if (next_pos > last) {
|
|
segs[numSeg++] = wild.get_substr((strl_t)last, (strl_t)(next_pos-last));
|
|
if (search && range)
|
|
segs[numSeg++] = range;
|
|
type[numType++] = (char)(search ? (range ? WCST_FIND_SUBSTR_RANGE : WCST_FIND_SUBSTR) : WCST_NEXT_SUBSTR);
|
|
}
|
|
last = pos = next_pos+1;
|
|
range.clear();
|
|
// check for substring character filter
|
|
if (strl_t(pos) < wild.get_len()) {
|
|
switch (wild[pos]) {
|
|
case '{': { // user defined character filter
|
|
int range_end = wild.find_after('}', (strl_t)pos);
|
|
if (range_end > 0) {
|
|
range = wild.get_substr(strl_t(pos+1), strl_t(range_end-pos-1));
|
|
last = pos = range_end + 1;
|
|
} else
|
|
pos++;
|
|
break;
|
|
}
|
|
case '%': // % => no whitespaces
|
|
range = _no_whitespace_range;
|
|
last = ++pos;
|
|
break;
|
|
case '@': // @ => no line break
|
|
range = _no_enter_range;
|
|
last = ++pos;
|
|
break;
|
|
case '$': // $ => only alphanumeric characters
|
|
range = _alphanumeric_range;
|
|
last = ++pos;
|
|
break;
|
|
}
|
|
}
|
|
search = true;
|
|
break;
|
|
|
|
case '<': // < = first character of word
|
|
if (next_pos > last) {
|
|
segs[numSeg++] = wild.get_substr((strl_t)last, strl_t(next_pos-last));
|
|
if (search && range)
|
|
segs[numSeg++] = range;
|
|
type[numType++] = (char)(search ? (range ? WCST_FIND_SUBSTR_RANGE : WCST_FIND_SUBSTR) : WCST_NEXT_SUBSTR);
|
|
search = false;
|
|
range.clear();
|
|
}
|
|
if (search && range)
|
|
segs[numSeg++] = range;
|
|
type[numType++] = (char)(search ? (range ? WCST_FIND_WORD_START_RANGED : WCST_FIND_WORD_START) : WCST_NEXT_WORD_START);
|
|
search = false;
|
|
range.clear();
|
|
pos = last = next_pos+1;
|
|
break;
|
|
|
|
case '>': // > = first character after word
|
|
if (next_pos > last) {
|
|
segs[numSeg++] = wild.get_substr(strl_t(last), strl_t(next_pos-last));
|
|
if (search && range)
|
|
segs[numSeg++] = range;
|
|
type[numType++] = (char)(search ? (range ? WCST_FIND_SUBSTR_RANGE : WCST_FIND_SUBSTR) : WCST_NEXT_SUBSTR);
|
|
search = false;
|
|
range.clear();
|
|
}
|
|
if (search && range)
|
|
segs[numSeg++] = range;
|
|
type[numType++] = (char)(search ? (range ? WCST_FIND_WORD_END_RANGED : WCST_FIND_WORD_END) : WCST_NEXT_WORD_END);
|
|
search = false;
|
|
range.clear();
|
|
pos = last = next_pos+1;
|
|
break;
|
|
|
|
case '@': // < = first character of line
|
|
if (next_pos > last) {
|
|
segs[numSeg++] = wild.get_substr(last, next_pos-last);
|
|
if (search && range)
|
|
segs[numSeg++] = range;
|
|
type[numType++] = (char)(search ? (range ? WCST_FIND_SUBSTR_RANGE : WCST_FIND_SUBSTR) : WCST_NEXT_SUBSTR);
|
|
search = false;
|
|
range.clear();
|
|
}
|
|
type[numType++] = (char)(search ? (range ? WCST_FIND_LINE_START_RANGED : WCST_FIND_LINE_START) : WCST_NEXT_LINE_START);
|
|
search = false;
|
|
range.clear();
|
|
pos = last = next_pos+1;
|
|
break;
|
|
|
|
case '^': // > = first character after line
|
|
if (next_pos > last) {
|
|
segs[numSeg++] = wild.get_substr(last, next_pos-last);
|
|
if (search && range)
|
|
segs[numSeg++] = range;
|
|
type[numType++] = (char)(search ? (range ? WCST_FIND_SUBSTR_RANGE : WCST_FIND_SUBSTR) : WCST_NEXT_SUBSTR);
|
|
search = false;
|
|
range.clear();
|
|
}
|
|
if (search && range)
|
|
segs[numSeg++] = range;
|
|
type[numType++] = (char)(search ? (range ? WCST_FIND_LINE_END_RANGED : WCST_FIND_LINE_END) : WCST_NEXT_LINE_END);
|
|
search = false;
|
|
range.clear();
|
|
pos = last = next_pos+1;
|
|
break;
|
|
|
|
case '?': // ? = any character
|
|
// any character is redundant if currently searching
|
|
if (!search) {
|
|
if (next_pos > last) {
|
|
segs[numSeg++] = wild.get_substr(last, next_pos-last);
|
|
if (search && range)
|
|
segs[numSeg++] = range;
|
|
type[numType++] = (char)(search ? (range ? WCST_FIND_SUBSTR_RANGE : WCST_FIND_SUBSTR) : WCST_NEXT_SUBSTR);
|
|
}
|
|
range.clear();
|
|
type[numType++] = (char)WCST_NEXT_ANY_CHAR;
|
|
search = false;
|
|
range.clear();
|
|
pos = last = next_pos+1;
|
|
} else
|
|
last = ++pos;
|
|
break;
|
|
|
|
case '#': // # = any number (hard coded range)
|
|
if (next_pos > last) {
|
|
segs[numSeg++] = wild.get_substr(last, next_pos-last);
|
|
type[numType++] = (char)(search ? WCST_FIND_SUBSTR : WCST_NEXT_SUBSTR);
|
|
search = false;
|
|
}
|
|
segs[numSeg++] = _numeric_range;
|
|
type[numType++] = (char)(search ? WCST_FIND_RANGE_CHAR : WCST_NEXT_RANGE_CHAR);
|
|
search = false;
|
|
pos = last = next_pos+1;
|
|
break;
|
|
|
|
case '[': { // [..] = limited range character
|
|
int close_pos = wild.find_after(']', strl_t(next_pos+1));
|
|
if (close_pos>=1) {
|
|
if (next_pos > last) {
|
|
segs[numSeg++] = wild.get_substr(last, next_pos-last);
|
|
if (search && range)
|
|
segs[numSeg++] = range;
|
|
type[numType++] = (char)(search ? (range ? WCST_FIND_SUBSTR_RANGE : WCST_FIND_SUBSTR) : WCST_NEXT_SUBSTR);
|
|
search = false;
|
|
range.clear();
|
|
}
|
|
segs[numSeg++] = wild.get_substr(next_pos+1, close_pos-next_pos-1);
|
|
if (search && range)
|
|
segs[numSeg++] = range;
|
|
type[numType++] = (char)(search ? (range ? WCST_FIND_RANGE_CHAR_RANGED : WCST_FIND_RANGE_CHAR) : WCST_NEXT_RANGE_CHAR);
|
|
search = false;
|
|
range.clear();
|
|
pos = last = close_pos+1;
|
|
} else
|
|
pos = next_pos+1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
type[numType++] = WCST_END;
|
|
segments = numSeg;
|
|
return numType;
|
|
}
|
|
|
|
// search for a substring with wildcard rules
|
|
strref strref::find_wildcard(const strref wild, strl_t start, bool case_sensitive) const
|
|
{
|
|
// collection of sub segments from wildcard
|
|
strref segs[MAX_WILDCARD_SEGMENTS];
|
|
char type[MAX_WILDCARD_STEPS];
|
|
int numSeg = 0;
|
|
|
|
// Convert the wildcard to a set of sequential searches and matches
|
|
int numType = _build_wildcard_steps(wild, segs, type, numSeg);
|
|
|
|
// start going through the steps to find a match
|
|
int pos = (int)start;
|
|
char last_valid_search_step[MAX_WILDCARD_SEARCH_STACK];
|
|
char last_valid_search_seg[MAX_WILDCARD_SEARCH_STACK];
|
|
strl_t last_valid_search_pos[MAX_WILDCARD_SEARCH_STACK];
|
|
while ((strl_t)pos < length) {
|
|
int first_pos = pos;
|
|
int seg = 0;
|
|
bool valid = true;
|
|
int last_valid_stack = 0;
|
|
int step = 0;
|
|
while (step<numType) {
|
|
bool find = false;
|
|
strl_t found_pos = (strl_t)first_pos;
|
|
int seg_step = seg;
|
|
switch (type[step]) {
|
|
case WCST_END: // success!
|
|
return strref(string+first_pos, pos-first_pos);
|
|
|
|
case WCST_FIND_SUBSTR:
|
|
find = true;
|
|
pos = case_sensitive ? find_case_esc(segs[seg], (strl_t)pos) : find_esc(segs[seg], (strl_t)pos);
|
|
if (pos<0) {
|
|
valid = false;
|
|
break;
|
|
}
|
|
found_pos = (strl_t)pos;
|
|
pos += (int)segs[seg++].len_esc();
|
|
break;
|
|
|
|
case WCST_FIND_SUBSTR_RANGE:
|
|
find = true;
|
|
pos = case_sensitive ? find_case_esc_range(segs[seg], segs[seg + 1], (strl_t)pos) : find_esc_range(segs[seg], segs[seg + 1], (strl_t)pos);
|
|
if (pos<0) {
|
|
valid = false;
|
|
break;
|
|
}
|
|
found_pos = (strl_t)pos;
|
|
pos += (int)segs[seg].length;
|
|
seg += 2;
|
|
break;
|
|
|
|
case WCST_SUBSTR_MATCH_RANGE:
|
|
valid = false;
|
|
while ((strl_t)pos < length && segs[seg].char_matches_ranges((uint8_t)get_at(pos))) {
|
|
pos++;
|
|
valid = true;
|
|
}
|
|
seg++;
|
|
break;
|
|
|
|
case WCST_FIND_RANGE_CHAR:
|
|
find = true;
|
|
pos = find_any_char_or_range(segs[seg++], (strl_t)pos);
|
|
if (pos<0) {
|
|
valid = false;
|
|
break;
|
|
}
|
|
found_pos = (strl_t)pos;
|
|
pos++;
|
|
break;
|
|
|
|
case WCST_FIND_RANGE_CHAR_RANGED:
|
|
find = true;
|
|
pos = find_range_char_within_range(segs[seg], segs[seg + 1], (strl_t)pos);
|
|
if (pos<0) {
|
|
valid = false;
|
|
break;
|
|
}
|
|
found_pos = (strl_t)pos;
|
|
pos++;
|
|
seg += 2;
|
|
break;
|
|
|
|
case WCST_NEXT_ANY_CHAR:
|
|
valid = pos != (int)length;
|
|
if (!valid)
|
|
break;
|
|
pos++;
|
|
break;
|
|
|
|
case WCST_NEXT_RANGE_CHAR:
|
|
valid = !(pos == (int)length || !segs[seg++].char_matches_ranges(get_at(pos)));
|
|
if (!valid)
|
|
break;
|
|
pos++;
|
|
break;
|
|
|
|
case WCST_NEXT_SUBSTR:
|
|
valid = same_substr_case_esc(segs[seg], pos);
|
|
if (!valid)
|
|
break;
|
|
pos += (int)segs[seg++].length;
|
|
break;
|
|
|
|
case WCST_NEXT_WORD_START:
|
|
valid = !(is_ws(string[pos]) || (pos && !is_ws(string[pos - 1])));
|
|
if (!valid)
|
|
break;
|
|
pos++;
|
|
break;
|
|
|
|
case WCST_NEXT_WORD_END:
|
|
valid = (pos==(int)length || is_ws(string[pos])) && pos && !is_ws(string[pos-1]);
|
|
break;
|
|
|
|
case WCST_FIND_WORD_START:
|
|
find = true;
|
|
// current position may be ok if first pos or prev=whitespace/separator
|
|
// skip if: current = separator or previous is not separator
|
|
if ((strl_t(pos)<length && is_sep_ws(string[pos])) || (pos && !is_sep_ws(string[pos-1]))) {
|
|
if (strl_t(pos)<length && !is_sep_ws(string[pos]))
|
|
pos += (int)len_non_sep_ws(pos);
|
|
if (strl_t(pos)<length && is_sep_ws(string[pos]))
|
|
pos += (int)len_sep_ws(pos);
|
|
}
|
|
valid = strl_t(pos) < length;
|
|
found_pos = (strl_t)pos;
|
|
break;
|
|
|
|
case WCST_FIND_WORD_START_RANGED:
|
|
find = true;
|
|
// current position may be ok if first pos or prev=whitespace/separator
|
|
// skip if: current = separator or previous is not separator
|
|
if (is_sep_ws(string[pos]) || (pos && !is_sep_ws(string[pos-1]))) {
|
|
while (strl_t(pos)<length && !is_sep_ws(string[pos])) {
|
|
valid = segs[seg].char_matches_ranges(string[pos]);
|
|
if (!valid)
|
|
break;
|
|
pos++;
|
|
}
|
|
while (strl_t(pos)<length && is_sep_ws(string[pos])) {
|
|
valid = segs[seg].char_matches_ranges(string[pos]);
|
|
if (!valid)
|
|
break;
|
|
pos++;
|
|
}
|
|
}
|
|
valid = valid && strl_t(pos) < length;
|
|
found_pos = (strl_t)pos;
|
|
seg++;
|
|
break;
|
|
|
|
case WCST_FIND_WORD_END:
|
|
find = true;
|
|
// current position may be ok if first pos or prev=whitespace/separator
|
|
// skip if: current = separator or previous is not separator
|
|
if (!is_sep_ws(string[pos]) || (pos && is_sep_ws(string[pos-1]))) {
|
|
valid = pos != (int)length;
|
|
if (!valid)
|
|
break;
|
|
else {
|
|
if (is_sep_ws(string[pos]))
|
|
pos += (int)len_sep_ws(pos);
|
|
if (!is_sep_ws(string[pos]))
|
|
pos += (int)len_non_sep_ws(pos);
|
|
}
|
|
}
|
|
found_pos = (strl_t)pos;
|
|
break;
|
|
|
|
case WCST_FIND_WORD_END_RANGED:
|
|
find = true;
|
|
// current position may be ok if first pos or prev=whitespace/separator
|
|
// skip if: current = separator or previous is not separator
|
|
if (!is_sep_ws(string[pos]) || (pos && is_sep_ws(string[pos-1]))) {
|
|
valid = pos != (int)length;
|
|
if (!valid)
|
|
break;
|
|
else {
|
|
while (strl_t(pos)<length && is_sep_ws(string[pos])) {
|
|
valid = segs[seg].char_matches_ranges(string[pos]);
|
|
if (!valid)
|
|
break;
|
|
pos++;
|
|
}
|
|
while (strl_t(pos)<length && !is_sep_ws(string[pos])) {
|
|
valid = segs[seg].char_matches_ranges(string[pos]);
|
|
if (!valid)
|
|
break;
|
|
pos++;
|
|
}
|
|
}
|
|
}
|
|
found_pos = (strl_t)pos;
|
|
seg++;
|
|
break;
|
|
|
|
case WCST_NEXT_LINE_START:
|
|
valid = !(pos && string[pos - 1] != 0xa && string[pos - 1] != 0x0d);
|
|
if (!valid)
|
|
break;
|
|
break;
|
|
|
|
case WCST_FIND_LINE_START:
|
|
find = true;
|
|
// current position may be ok if first pos or prev=line sep
|
|
// skip if: current = separator or previous is not separator
|
|
if (pos && string[pos-1]!=0xa && string[pos-1]!=0x0d) {
|
|
while (strl_t(pos)<length && string[pos]!=0x0a && string[pos]!=0x0d)
|
|
pos++;
|
|
if (strl_t(pos)<length) {
|
|
char p = string[pos];
|
|
pos++;
|
|
if (strl_t(pos)<length && ((p==0x0a && string[pos]==0x0d) || (p==0x0d && string[pos]==0x0a)))
|
|
pos++;
|
|
}
|
|
if (strl_t(pos)>=length) {
|
|
valid = false;
|
|
break;
|
|
}
|
|
}
|
|
found_pos = (strl_t)pos;
|
|
break;
|
|
|
|
case WCST_FIND_LINE_START_RANGED:
|
|
find = true;
|
|
// current position may be ok if first pos or prev=line sep
|
|
// skip if: current = separator or previous is not separator
|
|
if (pos && string[pos-1]!=0xa && string[pos-1]!=0x0d) {
|
|
while (strl_t(pos)<length && string[pos]!=0x0a && string[pos]!=0x0d) {
|
|
if (!segs[seg].char_matches_ranges(string[pos])) {
|
|
valid = false;
|
|
break;
|
|
}
|
|
pos++;
|
|
}
|
|
if (strl_t(pos)<length) {
|
|
char p = string[pos];
|
|
pos++;
|
|
if (strl_t(pos)<length && ((p==0x0a && string[pos]==0x0d) || (p==0x0d && string[pos]==0x0a)))
|
|
pos++;
|
|
}
|
|
if (strl_t(pos)>=length) {
|
|
valid = false;
|
|
break;
|
|
}
|
|
}
|
|
found_pos = (strl_t)pos;
|
|
seg++;
|
|
break;
|
|
|
|
case WCST_NEXT_LINE_END:
|
|
if (strl_t(pos)<length && string[pos]!=0x0a && string[pos]!=0x0d) {
|
|
valid = false;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case WCST_FIND_LINE_END:
|
|
find = true;
|
|
// current position may be ok if first pos or prev=whitespace/separator
|
|
// skip if: current = separator or previous is not separator
|
|
while (strl_t(pos)<length && string[pos]!=0x0a && string[pos]!=0x0d)
|
|
pos++;
|
|
found_pos = true;
|
|
break;
|
|
case WCST_FIND_LINE_END_RANGED:
|
|
find = true;
|
|
// current position may be ok if first pos or prev=whitespace/separator
|
|
// skip if: current = separator or previous is not separator
|
|
// note: end of string is also a valid end of line so make a custom step
|
|
while (strl_t(pos)<length && string[pos]!=0x0a && string[pos]!=0x0d) {
|
|
if (!segs[seg].char_matches_ranges(string[pos])) {
|
|
valid = false;
|
|
break;
|
|
}
|
|
pos++;
|
|
}
|
|
found_pos = (strl_t)pos;
|
|
seg++;
|
|
break;
|
|
}
|
|
|
|
// if current step is not valid go to the next character and try again
|
|
if (!valid) {
|
|
if (last_valid_stack) {
|
|
last_valid_stack--; // step back one level and try again
|
|
step = last_valid_search_step[last_valid_stack];
|
|
seg = last_valid_search_seg[last_valid_stack];
|
|
pos = (int)last_valid_search_pos[last_valid_stack] + 1;
|
|
valid = true;
|
|
}
|
|
else {
|
|
pos = first_pos + 1;
|
|
break;
|
|
}
|
|
} else {
|
|
if (find) {
|
|
if (!step)
|
|
first_pos = (int)found_pos;
|
|
if (last_valid_stack < MAX_WILDCARD_SEARCH_STACK) {
|
|
last_valid_search_pos[last_valid_stack] = found_pos;
|
|
last_valid_search_seg[last_valid_stack] = (char)seg_step;
|
|
last_valid_search_step[last_valid_stack] = (char)step;
|
|
last_valid_stack++;
|
|
}
|
|
}
|
|
step++;
|
|
}
|
|
}
|
|
}
|
|
return strref();
|
|
}
|
|
|
|
// read one utf8 from the start of a string
|
|
size_t strref::get_utf8() const
|
|
{
|
|
if (!valid())
|
|
return 0;
|
|
const uint8_t *scan = get_u();
|
|
strl_t left = length-1;
|
|
if (left>5)
|
|
left = 5;
|
|
uint8_t f = *scan++;
|
|
size_t c = f, mask = 0x80;
|
|
while ((mask&c) && left) {
|
|
uint8_t n = *scan++;
|
|
c = (c<<6)|(n&0x3f);
|
|
mask <<= 5;
|
|
left--;
|
|
}
|
|
return c;
|
|
}
|
|
|
|
// read one utf8 from the start of a string and move string
|
|
// move string forward by the size of the code.
|
|
size_t strref::pop_utf8()
|
|
{
|
|
if (!valid())
|
|
return 0;
|
|
const uint8_t *scan = get_u();
|
|
strl_t left = length-1;
|
|
if (left>5)
|
|
left = 5;
|
|
uint8_t f = *scan++;
|
|
size_t c = f, m = 0x80;
|
|
while ((m&c) && left) {
|
|
uint8_t n = *scan++;
|
|
c = (c<<6)|(n&0x3f);
|
|
m <<= 5;
|
|
left--;
|
|
}
|
|
length -= strl_t((const char*)scan - string);
|
|
string = (const char*)scan;
|
|
return c;
|
|
}
|
|
|
|
bool strref::valid_ascii7() const
|
|
{
|
|
const char *scan = get();
|
|
size_t left = get_len();
|
|
while (left) {
|
|
char c = *scan++;
|
|
if ((c<' ' || c>=127) && c!=0x0a && c!=0x0d && c!=0x09)
|
|
return false;
|
|
left--;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// find the character d outside of quoted xml text
|
|
int strref::find_quoted_xml(char d) const
|
|
{
|
|
const char *scan = string;
|
|
strl_t left = length;
|
|
char q = 0; // quote type is either " or '
|
|
while (left) {
|
|
char c = *scan++;
|
|
if (q) {
|
|
if (c==q)
|
|
q = 0;
|
|
} else if ((c=='"' || c=='\''))
|
|
q = c;
|
|
else if (c==d)
|
|
return int(length-left);
|
|
--left;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// if this string begins as an xml quote return that.
|
|
strref strref::get_quote_xml() const
|
|
{
|
|
char quote_char = get_first();
|
|
if (quote_char!='"' && quote_char!='\'')
|
|
return strref();
|
|
|
|
const char *scan = string+1;
|
|
strl_t left = length-1;
|
|
while (left) {
|
|
char c = *scan++;
|
|
if (c==quote_char)
|
|
return strref(string+1, length-left-1);
|
|
--left;
|
|
}
|
|
return strref();
|
|
}
|
|
|
|
// if this string begins as an xml quote return that.
|
|
strref strref::skip_quote_xml()
|
|
{
|
|
char quote_char = get_first();
|
|
if( quote_char != '"' && quote_char != '\'' )
|
|
return strref();
|
|
|
|
const char *scan = string + 1;
|
|
strl_t left = length - 1;
|
|
while( left ) {
|
|
char c = *scan++;
|
|
if( c == quote_char ) {
|
|
strref ret( string + 1, length - left - 1 );
|
|
string = scan+1;
|
|
length = left-2;
|
|
return ret;
|
|
}
|
|
--left;
|
|
}
|
|
return strref();
|
|
}
|
|
|
|
// find the character d outside of a quote
|
|
int strref::find_quoted(char d) const
|
|
{
|
|
strl_t left = length;
|
|
const char *scan = string;
|
|
char quote_char = 0;
|
|
char previous_char = 0;
|
|
while (left) {
|
|
char c = *scan++;
|
|
if (quote_char) {
|
|
if (c==quote_char && previous_char!='\\')
|
|
quote_char = 0;
|
|
} else if (c=='"' || c=='\'')
|
|
quote_char = c;
|
|
else if (c==d)
|
|
return int(length-left);
|
|
--left;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
strref strref::split( strl_t pos ) {
|
|
pos = limit_pos( pos );
|
|
strref ret = strref( string, pos );
|
|
*this += pos;
|
|
return ret;
|
|
}
|
|
|
|
strref strref::split( int pos ) {
|
|
return split( strl_t( pos ) );
|
|
}
|
|
|
|
strref strref::split_token( char c ) {
|
|
int t = find( c );
|
|
if ( t < 0 ) t = ( int )length;
|
|
strref r = strref( string, strl_t( t ) );
|
|
*this += t + 1;
|
|
return r;
|
|
}
|
|
|
|
strref strref::split_token_track_parens(char c)
|
|
{
|
|
int t = find_skip_parens(c);
|
|
if (t < 0) t = (int)length;
|
|
strref r = strref(string, strl_t(t));
|
|
*this += t + 1;
|
|
return r;
|
|
}
|
|
|
|
strref strref::split_token_track_parens_quote(char c)
|
|
{
|
|
if (length>=2 && string[0] == '"') {
|
|
strl_t o = 1;
|
|
while (o < length && string[o] != '"') { ++o; }
|
|
if (o < length) {
|
|
strref r = strref(string, o + 1);
|
|
*this += o + 1;
|
|
return r;
|
|
}
|
|
}
|
|
int t = find_skip_parens(c);
|
|
if (t < 0) t = (int)length;
|
|
strref r = strref(string, strl_t(t));
|
|
*this += t + 1;
|
|
return r;
|
|
}
|
|
|
|
strref strref::split_token_any( const strref chars )
|
|
{
|
|
strref r; int t = find_any_char_of( chars );
|
|
if ( t >= 0 ) {
|
|
r = strref( string, t );
|
|
*this += t;
|
|
}
|
|
return r;
|
|
}
|
|
|
|
strref strref::split_token_trim_track_parens(char c)
|
|
{
|
|
strref r = split_token_track_parens(c);
|
|
skip_whitespace();
|
|
r.trim_whitespace();
|
|
return r;
|
|
}
|
|
strref strref::split_token_trim( char c ) {
|
|
strref r = split_token( c );
|
|
skip_whitespace();
|
|
r.trim_whitespace();
|
|
return r;
|
|
}
|
|
|
|
strref strref::split_token_any_trim( const strref chars )
|
|
{
|
|
int t = find_any_char_of( chars );
|
|
if ( t < 0 ) t = ( int )length;
|
|
strref r = strref( string, t );
|
|
*this += t + 1;
|
|
r.trim_whitespace();
|
|
return r;
|
|
}
|
|
|
|
strref strref::split_range( const strref range, strl_t pos )
|
|
{
|
|
int t = find_any_char_or_range( range, pos );
|
|
if ( t < 0 ) t = ( int )length;
|
|
strref r = strref( string, t );
|
|
*this += t;
|
|
return r;
|
|
}
|
|
strref strref::split_range_trim( const strref range, strl_t pos )
|
|
{
|
|
int t = find_any_char_or_range( range, pos );
|
|
if ( t < 0 ) t = ( int )length;
|
|
strref r = strref( string, t );
|
|
*this += t;
|
|
r.trim_whitespace();
|
|
trim_whitespace();
|
|
return r;
|
|
}
|
|
|
|
strref strref::split_label() {
|
|
skip_whitespace();
|
|
strref r( string, len_label() );
|
|
*this += r.length;
|
|
skip_whitespace();
|
|
return r;
|
|
}
|
|
|
|
strref strref::split_num() {
|
|
skip_whitespace();
|
|
strref r( string, 0 );
|
|
while( length && *string >= '0' && *string <= '9' ) {
|
|
r.length++;
|
|
string++;
|
|
length--;
|
|
}
|
|
skip_whitespace();
|
|
return r;
|
|
}
|
|
|
|
|
|
// split string based on common programming tokens (words, quotes, scopes, numbers)
|
|
strref strref::split_lang()
|
|
{
|
|
skip_whitespace();
|
|
char c = get_first();
|
|
strl_t l = 1;
|
|
if (c == '"')
|
|
{
|
|
int f = find_after('"', 1);
|
|
l = f >= 0 ? (strl_t)(f+1) : get_len();
|
|
}
|
|
else if (c == '{' || c=='(')
|
|
{
|
|
strref f2(*this);
|
|
l = f2.scoped_block_comment_skip(true).get_len();
|
|
}
|
|
else if (strref::is_number(c) || c == '-')
|
|
{
|
|
if ((c == '0' && string[1] == 'x') || string[1] == 'X')
|
|
l = 2 + (*this + 2).len_hex();
|
|
else
|
|
l = len_float_number();
|
|
}
|
|
else
|
|
l = len_grayspace();
|
|
strref r = split(l); // control character
|
|
return r;
|
|
}
|
|
|
|
strref strref::get_snippet( strl_t pos )
|
|
{
|
|
strref snippet(string, end_line_pos(pos));
|
|
snippet.skip(snippet.prev_line_pos(snippet.start_line_pos(pos)));
|
|
return snippet;
|
|
}
|
|
|
|
// grab a block of text starting with (, [ or { and end with the corresponding number of ), ] or }
|
|
strref strref::scoped_block_skip(bool quotes)
|
|
{
|
|
char scope = get_first();
|
|
if (length && (scope == '(' || scope == '[' || scope == '{')) {
|
|
char close = scope=='(' ? ')' : (scope=='[' ? ']' : '}');
|
|
const char *scan = string;
|
|
bool inQuote = false;
|
|
strl_t depth = 0;
|
|
strl_t left = length;
|
|
do {
|
|
char c = *scan++;
|
|
left--;
|
|
if( inQuote ) {
|
|
if( c == '"' ) { inQuote = false; }
|
|
} else if( quotes && c=='"' ) { inQuote = true; }
|
|
else if( c == scope )
|
|
depth++;
|
|
else if (c==close)
|
|
depth--;
|
|
} while (depth && left);
|
|
if (!depth) {
|
|
strl_t block_len = strl_t(scan - string);
|
|
strref block = strref(string, block_len);
|
|
block.string++;
|
|
block.length -= 2;
|
|
string += block_len;
|
|
length -= block_len;
|
|
return block;
|
|
}
|
|
}
|
|
return strref();
|
|
}
|
|
|
|
// scoped_block_skip with C style comments
|
|
strl_t strref::scoped_block_comment_len()
|
|
{
|
|
char scope = get_first();
|
|
if (length && (scope == '(' || scope == '[' || scope == '{' || scope == '<'))
|
|
{
|
|
char close = scope == '<' ? '>' : (scope == '(' ? ')' : (scope == '[' ? ']' : '}'));
|
|
const char *scan = string;
|
|
strl_t depth = 0;
|
|
strl_t left = length;
|
|
do {
|
|
char c = *scan++;
|
|
left--;
|
|
if (c == '/' && left && (*scan == '/' || *scan == '*')) {
|
|
c = *scan++;
|
|
left--;
|
|
strl_t skip = c == '/' ? strref(scan, left).len_next_line() : strref(scan, left).find_or_full("*/");
|
|
scan += skip;
|
|
left -= skip;
|
|
} else if (c == scope)
|
|
depth++;
|
|
else if (c == close)
|
|
depth--;
|
|
} while (depth && left);
|
|
if (!depth)
|
|
return strl_t(scan-string);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
strl_t strref::scoped_block_utf8_comment_len()
|
|
{
|
|
strref str = *this;
|
|
size_t scope = str.pop_utf8();
|
|
if( length && ( scope == '(' || scope == '[' || scope == '{' || scope == '<' ) )
|
|
{
|
|
char close = scope == '<' ? '>' : ( scope == '(' ? ')' : ( scope == '[' ? ']' : '}' ) );
|
|
strl_t depth = 1;
|
|
do {
|
|
size_t c = str.pop_utf8();
|
|
if( c == '/' && str.get_len() && ( str[0] == '/' || str[1] == '*' ) ) {
|
|
c = str.pop_utf8();
|
|
strl_t skip = c == '/' ? str.len_next_line() : str.find_or_full( "*/" );
|
|
str += skip;
|
|
}
|
|
else if( c == scope )
|
|
depth++;
|
|
else if( c == close )
|
|
depth--;
|
|
} while( depth && str.valid() );
|
|
if( !depth )
|
|
return strl_t( str.string - string );
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
// return the current line of text and move this string ahead to the next.
|
|
// note: supports all known line feed configurations.
|
|
strref strref::next_line()
|
|
{
|
|
const char *start = string;
|
|
const char *scan = start;
|
|
strl_t left = length; // if not valid left=0 and no characters will be interpreted
|
|
strref ret;
|
|
while (left && *scan!=0x0a && *scan!=0x0d) {
|
|
scan++;
|
|
left--;
|
|
}
|
|
// this is the line to return
|
|
ret = strref(start, strl_t(scan-start));
|
|
if (left) {
|
|
char c = *scan++;
|
|
left--;
|
|
if (left && ((c==0x0a && *scan==0x0d) || (c==0x0d && *scan==0x0a))) {
|
|
scan++;
|
|
left--;
|
|
}
|
|
}
|
|
if (left) {
|
|
string = scan;
|
|
length = left;
|
|
} else {
|
|
string = nullptr;
|
|
length = 0;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
// get line from current string
|
|
strref strref::get_line() const
|
|
{
|
|
const char *start = string;
|
|
const char *scan = start;
|
|
strl_t left = length; // if not valid left=0 and no characters will be interpreted
|
|
strref ret;
|
|
while (left && *scan!=0x0a && *scan!=0x0d) {
|
|
scan++;
|
|
left--;
|
|
}
|
|
// this is the line to return
|
|
return strref(start, strl_t(scan-start));
|
|
}
|
|
|
|
// get a specific line number (0 indexed)
|
|
strref strref::get_line(strl_t line_num) const {
|
|
strref scan(*this);
|
|
while (scan) {
|
|
strref line = scan.next_line();
|
|
if (!line_num)
|
|
return line;
|
|
line_num--;
|
|
}
|
|
return strref();
|
|
}
|
|
|
|
// determine how many characters can be used for floating point
|
|
strl_t strref::len_float_number() const
|
|
{
|
|
// skip whitespace
|
|
const char *scan = string;
|
|
strl_t left = length;
|
|
|
|
// valid check
|
|
if (scan==nullptr || left==0)
|
|
return 0;
|
|
|
|
// not a floating point if just spaces and a dot
|
|
bool has_value = false;
|
|
|
|
// include whitespace
|
|
strl_t ws = len_whitespace();
|
|
scan += ws;
|
|
left -= ws;
|
|
|
|
// include sign
|
|
if (left && (*scan=='-' || *scan=='+')) {
|
|
scan++;
|
|
left--;
|
|
if (!left || !is_number(*scan))
|
|
return 0;
|
|
}
|
|
|
|
// integer portion
|
|
while (left && is_number(*scan)) {
|
|
scan++;
|
|
left--;
|
|
has_value = true;
|
|
}
|
|
|
|
// decimal
|
|
if (left && *scan=='.') {
|
|
scan++;
|
|
left--;
|
|
}
|
|
|
|
// fraction
|
|
while (left && is_number(*scan)) {
|
|
scan++;
|
|
left--;
|
|
has_value = true;
|
|
}
|
|
|
|
// exponent
|
|
if (left && (*scan=='e' || *scan=='E')) {
|
|
strl_t e = left;
|
|
scan++;
|
|
left--;
|
|
if (left && (*scan=='-' || *scan=='+')) {
|
|
scan++;
|
|
left--;
|
|
}
|
|
if (!left || !is_number(*scan))
|
|
return length-e;
|
|
while (left && is_number(*scan)) {
|
|
scan++;
|
|
left--;
|
|
has_value = true; // e-10 is a fine floating point number
|
|
}
|
|
}
|
|
|
|
// return size of floating point number
|
|
return has_value ? length-left : 0;
|
|
}
|
|
|
|
// count number of valid hexadecimal characters, leading 0x not valid
|
|
strl_t strref::len_hex() const
|
|
{
|
|
for (strl_t i = 0; i < length; i++) {
|
|
if (!is_hex((uint8_t)string[i]))
|
|
return i;
|
|
}
|
|
return length;
|
|
}
|
|
|
|
// insert a substring into a string
|
|
strl_t _strmod_insert(char *string, strl_t length, strl_t cap, const strref sub, strl_t pos)
|
|
{
|
|
if (pos>length)
|
|
return 0;
|
|
|
|
if (sub.get_len()==0)
|
|
return 0;
|
|
|
|
strl_t ins = sub.get_len();
|
|
strl_t end = length;
|
|
strl_t last = ins+end;
|
|
if (last>cap) {
|
|
if (ins+pos>cap) {
|
|
if (ins>cap)
|
|
ins = 0;
|
|
else
|
|
ins = cap-pos;
|
|
}
|
|
} else {
|
|
const char *src = string+end;
|
|
char *dst = string+ins+end;
|
|
strl_t move = length-pos;
|
|
for (; move; move--)
|
|
*--dst = *--src;
|
|
}
|
|
const char *src = sub.get();
|
|
uint8_t *dst = (uint8_t*)string + pos;
|
|
const uint8_t *e = (uint8_t*)string + cap;
|
|
strl_t left = sub.get_len();
|
|
while (left && dst < e) {
|
|
uint8_t c = (uint8_t)*src++;
|
|
left--;
|
|
*dst++ = c;
|
|
}
|
|
|
|
return ins + length;
|
|
}
|
|
|
|
// determine the size of this string with evaluated escape codes
|
|
static strl_t int_string_size_esc(const uint8_t *string, strl_t length)
|
|
{
|
|
strl_t size = 0;
|
|
while (length) {
|
|
uint8_t c = *string++;
|
|
length--;
|
|
if (c=='\\' && length) {
|
|
strl_t skip = int_get_esc_code(string, length, c);
|
|
string += skip;
|
|
length -= skip;
|
|
}
|
|
size++;
|
|
}
|
|
return size;
|
|
}
|
|
|
|
// insert a substring into a string allowing for escape codes
|
|
strl_t _strmod_insert_esc(char *string, strl_t length, strl_t cap, const strref sub, strl_t pos)
|
|
{
|
|
if (pos>length)
|
|
return 0;
|
|
|
|
if (sub.get_len()==0)
|
|
return 0;
|
|
|
|
strl_t ins = int_string_size_esc(sub.get_u(), sub.get_len());
|
|
strl_t end = length;
|
|
strl_t last = ins+end;
|
|
if (last>cap) {
|
|
if ((ins+pos)>cap) {
|
|
if (pos>cap)
|
|
ins = 0;
|
|
else
|
|
ins = cap-pos;
|
|
}
|
|
} else {
|
|
const char *src = string+end;
|
|
char *dst = string+ins+end;
|
|
strl_t move = length-pos;
|
|
for (; move; move--)
|
|
*--dst = *--src;
|
|
}
|
|
const uint8_t *src = sub.get_u();
|
|
uint8_t *dst = (uint8_t*)string + pos;
|
|
const uint8_t *e = (uint8_t*)string + cap;
|
|
strl_t left = sub.get_len();
|
|
while (left && dst < e) {
|
|
uint8_t c = *src++;
|
|
left--;
|
|
if (c=='\\' && left) {
|
|
strl_t skip = int_get_esc_code(src, left, c);
|
|
src += skip;
|
|
left -= skip;
|
|
}
|
|
*dst++ = c;
|
|
}
|
|
|
|
return ins + length;
|
|
}
|
|
|
|
// insert substrings by {n} notation
|
|
strl_t _strmod_format_insert(char *string, strl_t length, strl_t cap, strl_t pos,
|
|
strref format, const strref *args) {
|
|
// insert many things..
|
|
|
|
// can't insert at a position that is beyond the current size.
|
|
if (pos > length)
|
|
return length;
|
|
|
|
while (format) {
|
|
// scan for '{'
|
|
strl_t ins = format.find_or_full_esc('{', 0);
|
|
int close = format.find_after('}', ins);
|
|
if (close<0) {
|
|
ins = format.get_len();
|
|
}
|
|
|
|
// insert block before '{'
|
|
if (ins > 0) {
|
|
strl_t prev = length;
|
|
length = _strmod_insert_esc(string, length, cap, format.get_clipped(ins), pos);
|
|
pos += length - prev;
|
|
format += ins;
|
|
}
|
|
|
|
// if there was a {} process that..
|
|
if (format.get_first()=='{' && close>0) {
|
|
int64_t which = format.get_substr(1, close-ins).atoi();
|
|
strl_t prev = length;
|
|
length = _strmod_insert(string, length, cap, args[which], pos);
|
|
pos += length - prev;
|
|
format += close-ins+1;
|
|
}
|
|
}
|
|
return length;
|
|
}
|
|
|
|
strl_t _strmod_append_num( char* str, strl_t left, uint32_t num, strl_t size, uint32_t radix )
|
|
{
|
|
strl_t div = 1;
|
|
if( !size ) {
|
|
uint32_t mul = 1;
|
|
do { ++size; mul *= radix; } while( mul <= num );
|
|
}
|
|
for( strl_t n = 1; n<size; ++n ) { div *= radix; }
|
|
strl_t added = 0;
|
|
for( strl_t a = 0; a<size && left; ++a ) {
|
|
char v = (num / div) % radix + '0';
|
|
div /= radix;
|
|
*str++ = v <= '9' ? v : (v + 'a' - '0' - 10);
|
|
--left;
|
|
++added;
|
|
}
|
|
return added;
|
|
}
|
|
|
|
// remove all instances of a character from a string
|
|
strl_t _strmod_remove(char *string, strl_t length, char a)
|
|
{
|
|
char *scan = string;
|
|
strl_t left = length;
|
|
while (left && *scan!=a) {
|
|
left--;
|
|
scan++;
|
|
}
|
|
if (left) {
|
|
strl_t n = left;
|
|
char *write = scan;
|
|
while (left) {
|
|
while (left && *scan==a) {
|
|
left--;
|
|
scan++;
|
|
}
|
|
while (left && *scan!=a) {
|
|
*write++ = *scan++;
|
|
left--;
|
|
n--;
|
|
}
|
|
}
|
|
length -= n;
|
|
}
|
|
return length;
|
|
}
|
|
|
|
// remove a substring from a string
|
|
strl_t _strmod_remove(char *string, strl_t length, strl_t start, strl_t len)
|
|
{
|
|
if (start<length) {
|
|
if ((start+len)>length)
|
|
len = length-start;
|
|
int left = int(length-start-len);
|
|
if (left>0) {
|
|
const char *source = string+start+len;
|
|
char *dest = string+start;
|
|
for (int i = left; i; i--)
|
|
*dest++ = *source++;
|
|
}
|
|
length = length-len;
|
|
}
|
|
return length;
|
|
}
|
|
|
|
// exchange a substring
|
|
strl_t _strmod_exchange(char *string, strl_t length, strl_t cap, strl_t start, strl_t size, const strref insert)
|
|
{
|
|
if (start > length)
|
|
return length;
|
|
|
|
if ((start + size) > length)
|
|
size = length - start;
|
|
|
|
strl_t copy = insert.get_len();
|
|
if ((start + copy) > cap)
|
|
copy = cap - start;
|
|
|
|
if (copy < size) {
|
|
strl_t rem = size - insert.get_len();
|
|
length = _strmod_remove(string, length, start+size-rem, rem);
|
|
} else if (copy > size) {
|
|
strl_t ins = insert.get_len() - size;
|
|
strl_t left = length - size - start;
|
|
char *end = string + length + ins;
|
|
char *orig = string + length;
|
|
while (left--)
|
|
*--end = *--orig;
|
|
length += ins;
|
|
}
|
|
memcpy(string + start, insert.get(), copy);
|
|
return length;
|
|
}
|
|
|
|
|
|
// search and replace occurences of a string within a string
|
|
strl_t _strmod_inplace_replace_int(char *string, strl_t length, strl_t cap, const strref a, const strref b)
|
|
{
|
|
char *scan = string;
|
|
strl_t left = length;
|
|
strl_t c = cap;
|
|
strl_t len_a = a.get_len(), len_b = b.get_len();
|
|
if (len_a>left || !len_a)
|
|
return left;
|
|
|
|
char *ps = scan, *pd = scan;
|
|
if (len_a>=len_b) {
|
|
int ss = strref(ps, left-strl_t(ps-scan)).find(a);
|
|
if (ss>=0) {
|
|
pd += ss;
|
|
ps += ss;
|
|
while (ss>=0 && strl_t(ss)<left) {
|
|
ps += len_a;
|
|
int sl = strref(ps, left-ss-len_a).find(a);
|
|
if (sl<0)
|
|
sl = int(left-ss-len_a);
|
|
if (len_b) {
|
|
const char *po = b.get();
|
|
strl_t r = len_b;
|
|
while (r--)
|
|
*pd++ = *po++;
|
|
}
|
|
if (ps!=pd && sl) {
|
|
int r = sl;
|
|
while (r--)
|
|
*pd++ = *ps++;
|
|
}
|
|
ss += (int)len_a+sl;
|
|
}
|
|
return strl_t(pd-scan);
|
|
}
|
|
} else if (int cnt = strref(scan, left).substr_count(a)) {
|
|
strl_t nl = cnt * (len_b-len_a) + left; // new length
|
|
if (nl>c)
|
|
return left; // didn't fit in space
|
|
int ss = strref(scan, left).find_last(a);
|
|
int se = (int)left;
|
|
pd += nl;
|
|
ps += left;
|
|
while (ss>=0) {
|
|
strl_t cp = se-ss-len_a;
|
|
while (cp--)
|
|
*--pd = *--ps;
|
|
ps -= len_a;
|
|
const char *be = b.get()+len_b;
|
|
cp = len_b;
|
|
while (cp--)
|
|
*--pd = *--be;
|
|
se = ss;
|
|
ss = strref(scan, se).find_last(a);
|
|
}
|
|
return nl;
|
|
}
|
|
return left;
|
|
}
|
|
|
|
// search and replace occurences of a string within a string
|
|
strl_t _strmod_inplace_replace_bookend_int(char *string, strl_t length, strl_t cap, const strref a, const strref b, const strref bookend)
|
|
{
|
|
char *scan = string;
|
|
strl_t left = length;
|
|
strl_t c = cap;
|
|
strl_t len_a = a.get_len(), len_b = b.get_len();
|
|
if (len_a>left || !len_a)
|
|
return left;
|
|
|
|
char *ps = scan, *pd = scan;
|
|
if (len_a >= len_b) {
|
|
int ss = strref(ps, left - strl_t(ps - scan)).find_bookend(a, bookend);
|
|
if (ss >= 0) {
|
|
pd += ss;
|
|
ps += ss;
|
|
while (ss >= 0 && strl_t(ss)<left) {
|
|
ps += len_a;
|
|
int sl = strref(ps, left - ss - len_a).find_bookend(a, bookend);
|
|
if (sl<0)
|
|
sl = int(left - ss - len_a);
|
|
if (len_b && b.get()) {
|
|
const char *po = b.get();
|
|
strl_t r = len_b;
|
|
while (r--)
|
|
*pd++ = *po++;
|
|
}
|
|
if (sl) {
|
|
if (ps != pd) {
|
|
int r = sl;
|
|
while (r--)
|
|
*pd++ = *ps++;
|
|
} else {
|
|
pd += sl;
|
|
ps += sl;
|
|
}
|
|
}
|
|
ss += (int)len_a + sl;
|
|
}
|
|
return strl_t(pd - scan);
|
|
}
|
|
} else if (int cnt = strref(scan, left).substr_count_bookend(a, bookend)) {
|
|
strl_t nl = cnt * (len_b - len_a) + left; // new length
|
|
if (nl>c)
|
|
return left; // didn't fit in space
|
|
int ss = strref(scan, left).find_last_bookend(a, bookend);
|
|
int se = (int)left;
|
|
pd += nl;
|
|
ps += left;
|
|
while (ss >= 0) {
|
|
strl_t cp = se - ss - len_a;
|
|
while (cp--)
|
|
*--pd = *--ps;
|
|
ps -= len_a;
|
|
if (b.get()) {
|
|
const char *be = b.get() + len_b;
|
|
cp = len_b;
|
|
while (cp--)
|
|
*--pd = *--be;
|
|
}
|
|
se = ss;
|
|
ss = strref(scan, se).find_last_bookend(a, bookend);
|
|
}
|
|
return nl;
|
|
}
|
|
return left;
|
|
}
|
|
|
|
// convert a string to lowercase (7 bit ascii)
|
|
void _strmod_tolower(char *string, strl_t length)
|
|
{
|
|
if (string) {
|
|
uint8_t *s = (uint8_t*)string;
|
|
for (strl_t left = length; left>0; left--) {
|
|
*s = int_tolower_ascii7(*s);
|
|
s++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// convert a string to lowercase (windows extended ascii)
|
|
void _strmod_tolower_win_ascii(char *string, strl_t length)
|
|
{
|
|
if (string) {
|
|
uint8_t *s = (uint8_t*)string;
|
|
for (strl_t left = length; left>0; left--) {
|
|
*s = int_tolower_win_ascii(*s);
|
|
s++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// convert a string to lowercase (amiga extended ascii)
|
|
void _strmod_tolower_amiga_ascii(char *string, strl_t length)
|
|
{
|
|
if (string) {
|
|
uint8_t *scan = (uint8_t*)string;
|
|
for (strl_t left = length; left>0; left--) {
|
|
*scan = int_tolower_amiga_ascii(*scan);
|
|
scan++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// convert a string to lowercase (mac os extended ascii)
|
|
void _strmod_tolower_macos_ascii(char *string, strl_t length)
|
|
{
|
|
if (string) {
|
|
uint8_t *scan = (uint8_t*)string;
|
|
for (strl_t r = length; r>0; r--) {
|
|
*scan = int_tolower_macos_roman_ascii(*scan);
|
|
scan++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// convert a string to uppercase
|
|
void _strmod_toupper(char *string, strl_t length)
|
|
{
|
|
if (string) {
|
|
uint8_t *scan = (uint8_t*)string;
|
|
for (strl_t left = length; left>0; left--) {
|
|
*scan = int_toupper_ascii7(*scan);
|
|
scan++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// convert a string to uppercase
|
|
void _strmod_toupper_win_ascii(char *string, strl_t length)
|
|
{
|
|
if (string) {
|
|
uint8_t *scan = (uint8_t*)string;
|
|
for (strl_t left = length; left>0; left--) {
|
|
*scan = int_toupper_win_ascii(*scan);
|
|
scan++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// convert a string to uppercase
|
|
void _strmod_toupper_amiga_ascii(char *string, strl_t length)
|
|
{
|
|
if (string) {
|
|
uint8_t *scan = (uint8_t*)string;
|
|
for (strl_t left = length; left>0; left--) {
|
|
*scan = int_toupper_amiga_ascii(*scan);
|
|
scan++;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// convert a string to uppercase
|
|
void _strmod_toupper_macos_ascii(char *string, strl_t length)
|
|
{
|
|
if (string) {
|
|
uint8_t *scan = (uint8_t*)string;
|
|
for (strl_t left = length; left>0; left--) {
|
|
*scan = int_toupper_macos_roman_ascii(*scan);
|
|
scan++;
|
|
}
|
|
}
|
|
}
|
|
|
|
strl_t _strmod_copy(char *string, strl_t cap, const char *str)
|
|
{
|
|
strl_t length = 0;
|
|
if (str) {
|
|
while (*str && length < cap)
|
|
string[length++] = *str++;
|
|
}
|
|
return length;
|
|
}
|
|
|
|
strl_t _strmod_copy(char *string, strl_t cap, strref str)
|
|
{
|
|
strl_t length = 0;
|
|
if (str.valid()) {
|
|
const char *_str = str.get();
|
|
for (strl_t len = str.get_len(); len && length<cap; len--)
|
|
string[length++] = *_str++;
|
|
}
|
|
return length;
|
|
}
|
|
|
|
strl_t _strmod_append(char *string, strl_t length, strl_t cap, const char *str)
|
|
{
|
|
if (str) {
|
|
while (*str && length < cap)
|
|
string[length++] = *str++;
|
|
}
|
|
return length;
|
|
}
|
|
|
|
strl_t _strmod_append(char *string, strl_t length, strl_t cap, strref str)
|
|
{
|
|
if (str.valid()) {
|
|
const char *_str = str.get();
|
|
strl_t len = str.get_len();
|
|
for (; len && length<cap; len--)
|
|
string[length++] = *_str++;
|
|
}
|
|
return length;
|
|
}
|
|
|
|
void _strmod_substrcopy(char *string, strl_t length, strl_t cap, strl_t src, strl_t dst, strl_t chars) {
|
|
if (src<length && src!=dst && chars) {
|
|
if ((src+chars)>length)
|
|
chars = length - src;
|
|
if ((dst+chars)>cap)
|
|
chars = cap - dst;
|
|
char *ps = string+src, *pd = string+dst;
|
|
if (src>dst) {
|
|
while (chars--)
|
|
*pd++ = *ps++;
|
|
} else {
|
|
pd += chars;
|
|
ps += chars;
|
|
while (chars--)
|
|
*--pd = *--ps;
|
|
}
|
|
}
|
|
}
|
|
|
|
void _strmod_shift(char *string, int offs, int len) {
|
|
char *dest = string + offs;
|
|
if (offs>0) {
|
|
string += len;
|
|
dest += len;
|
|
while (len--)
|
|
*--dest = *--string;
|
|
} else {
|
|
while (len--)
|
|
*dest++ = *string++;
|
|
}
|
|
}
|
|
|
|
size_t _strmod_read_utf8(char *string, strl_t length, strl_t pos, strl_t &skip) {
|
|
if (pos >= length) {
|
|
skip = 0;
|
|
return 0;
|
|
}
|
|
|
|
string += pos;
|
|
length -= pos;
|
|
const char *start = string;
|
|
const char *end = string + length;
|
|
size_t c = (size_t)*string++;
|
|
c &= 0x7f;
|
|
for (size_t m = 0x40; (m & c) && string<end; m <<= 5) {
|
|
size_t n = (size_t)*string++;
|
|
c = ((c & ~m) << 6) | (n & 0x3f);
|
|
}
|
|
skip = strl_t(string - start);
|
|
return c;
|
|
}
|
|
|
|
strl_t _strmod_write_utf8(char *string, strl_t cap, size_t code, strl_t pos) {
|
|
if (pos>=cap)
|
|
return 0;
|
|
uint8_t *write = (uint8_t*)string + pos;
|
|
cap -= pos;
|
|
if (code < 0x80) {
|
|
*write++ = (uint8_t)code;
|
|
return 1;
|
|
} else if (cap>=2 && code < 0x800) {
|
|
*write++ = uint8_t(0xc0 | (code >> 6));
|
|
*write++ = 0x80 | (code & 0x3f);
|
|
return 2;
|
|
} else if (cap>=3 && code < 0x10000) {
|
|
*write++ = uint8_t(0xe0 | (code >> 12));
|
|
*write++ = 0x80 | ((code >> 6) & 0x3f);
|
|
*write++ = 0x80 | (code & 0x3f);
|
|
return 3;
|
|
} else if (cap>=4) {
|
|
*write++ = 0xf0 | ((code >> 18) & 7);
|
|
*write++ = 0x80 | ((code >> 12) & 0x3f);
|
|
*write++ = 0x80 | ((code >> 6) & 0x3f);
|
|
*write++ = 0x80 | (code & 0x3f);
|
|
return 4;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
strl_t _strmod_utf8_tolower(char *string, strl_t length, strl_t cap) {
|
|
char *scan = string;
|
|
char *write = string;
|
|
char *end = string + length;
|
|
|
|
while (scan<end) {
|
|
// get one character
|
|
strl_t skip;
|
|
size_t c = _strmod_read_utf8(scan, strl_t(end-scan), 0, skip);
|
|
scan += skip;
|
|
|
|
c = int_tolower_unicode(c);
|
|
|
|
strl_t add = c<size_t(0x80) ? strl_t(1) : (c<size_t(0x800) ? strl_t(2) : (c<size_t(0x10000) ? strl_t(3) : 4));
|
|
|
|
if (add > cap)
|
|
return (strl_t)(write-string);
|
|
|
|
// need to make room for new character code
|
|
if ((write+add)>scan) {
|
|
int m = (int)((write+add) - scan);
|
|
_strmod_shift(scan, m, (int)(end-scan));
|
|
scan += m;
|
|
end += m;
|
|
}
|
|
skip = _strmod_write_utf8(write, cap, c, 0);
|
|
write += skip;
|
|
cap -= skip;
|
|
}
|
|
return (strl_t)(end-string);
|
|
}
|
|
|
|
strl_t _strmod_utf8_toupper(char *string, strl_t length, strl_t cap) {
|
|
char *scan = string;
|
|
char *write = string;
|
|
char *end = string + length;
|
|
|
|
while (scan<end) {
|
|
// get one character
|
|
strl_t skip;
|
|
size_t c = _strmod_read_utf8(scan, strl_t(end-scan), 0, skip);
|
|
scan += skip;
|
|
|
|
c = int_toupper_unicode(c);
|
|
|
|
strl_t add = c<0x80 ? strl_t(1) : (c<0x800 ? strl_t(2) : (c<0x10000 ? strl_t(3) : strl_t(4)));
|
|
|
|
if (add > cap)
|
|
return (strl_t)(write-string);
|
|
|
|
// need to make room for new character code?
|
|
if ((write+add)>scan) {
|
|
int m = (int)((write+add) - scan);
|
|
_strmod_shift(scan, m, (int)(end-scan));
|
|
scan += m;
|
|
end += m;
|
|
}
|
|
skip = _strmod_write_utf8(write, cap, c, 0);
|
|
write += skip;
|
|
cap -= skip;
|
|
}
|
|
return (strl_t)(end-string);
|
|
}
|
|
|
|
strl_t _strmod_cleanup_path(char *file, strl_t len)
|
|
{
|
|
strl_t pos = 0;
|
|
char *trg = file;
|
|
while (len) {
|
|
len--;
|
|
char c = *file++;
|
|
if (c=='/')
|
|
c='\\';
|
|
trg[pos] = c;
|
|
if ((c=='/' || c=='\\') && len>=3 && *file=='.' && file[1]=='.' && (file[2] =='/' || file[2]=='\\') && pos) {
|
|
// attempt to rewind
|
|
strl_t rew = pos-1;
|
|
while (rew) {
|
|
if (trg[rew-1] == '/' || trg[rew-1]=='\\')
|
|
break;
|
|
--rew;
|
|
}
|
|
pos = rew;
|
|
file += 3;
|
|
len -= 3;
|
|
} else {
|
|
++pos;
|
|
}
|
|
}
|
|
return pos;
|
|
}
|
|
|
|
// determine a
|
|
strl_t _strmod_relative_path(char *out, strl_t cap, strref orig, strref target)
|
|
{
|
|
// remove trailing folder separator from source
|
|
char c = orig.get_last();
|
|
if (c=='/' || c=='\\')
|
|
orig.clip(1);
|
|
|
|
// skip as many characters as matches at start of path
|
|
strl_t same_count = orig.prefix_len(target, '/', '\\');
|
|
|
|
// make sure that prior character is a folder (sub paths may share a prefix)
|
|
if (same_count != orig.get_len()) {
|
|
while( same_count ) {
|
|
c = orig.get()[same_count-1];
|
|
if (c == '/' || c=='\\')
|
|
break;
|
|
--same_count;
|
|
}
|
|
}
|
|
|
|
// orig may be a path without ending in a folder separator
|
|
if (same_count == orig.get_len() && target.get_len() > same_count && (target.get()[same_count] == '/' || target.get()[same_count]=='\\'))
|
|
++same_count;
|
|
|
|
// skip the path of the path that is the same
|
|
orig += same_count;
|
|
target += same_count;
|
|
|
|
// count the number of folders to step up (number of folder separators)
|
|
strl_t step_up = orig.count_char('/') + orig.count_char('\\');
|
|
strl_t len = 0;
|
|
while (step_up-- && cap) {
|
|
strl_t add = _strmod_copy(out, cap, "../");
|
|
out += add;
|
|
len += add;
|
|
cap -= add;
|
|
}
|
|
c = target.get_first();
|
|
if (c=='/' || c=='\\')
|
|
++target;
|
|
|
|
if (cap)
|
|
len += _strmod_copy(out, cap, target);
|
|
return len;
|
|
}
|
|
|
|
#endif // STRUSE_IMPLEMENTATION
|
|
|
|
/* revision history
|
|
0.990 (2015-09-14) first public version
|
|
1.000 (2015-09-15) added XML parser sample
|
|
1.001 (2015-09-16) cleaned up XML parser
|
|
1.002 (2015-09-17) added JSON parser sample
|
|
1.003 (2015-09-20) straightening up of things
|
|
- wildcard add rewind & retry for multi step search, this caused valid finds to be ignored if invalid sub find occured
|
|
- fixed some minor wildcard search bugs, including word end including an extra character (whitespace)
|
|
- slightly more compact implementation, combining common code segments into static functions
|
|
- next_line() will return empty lines to match actual line count, line() works as before (returns only nonempty lines)
|
|
1.004 (2015-09-22) added text file diff / patch sample
|
|
1.005 (2015-09-28) added 6502 macro assembler sample
|
|
1.006 (2015-10-04) added get_line() to get first line, fixed errors with getting hex/binary value+skip (ahextoui_skip, abinarytoui_skip)
|
|
1.007 (2016-05-20) fixed wildcard errors and warnings in various configurations
|
|
*/
|
|
|
|
#endif // __STRUSE_H__
|