Changeset 257


Ignore:
Timestamp:
12/03/14 18:52:05 (7 years ago)
Author:
Maciej Komosinski
Message:
  • added strmove(): strcpy() for overlapping strings
  • ExtObject? operator== can handle NULL arguments
  • source formatting and improved genetic operator messages
Location:
cpp
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • cpp/common/Convert.cpp

    r247 r257  
    9090#if defined LINUX // || android?
    9191        return *::localtime_r(&timep,&ret);
    92 #elif defined _WIN32 && !defined __BORLANDC__ // and not bada?
     92#elif defined _WIN32 && !defined __BORLANDC__
    9393        ::localtime_s(&ret, &timep);
    9494        return ret;
     
    115115#if defined LINUX // || android?
    116116        ret=::asctime_r(&tm,buf);
    117 #elif defined _WIN32 && !defined __BORLANDC__ // and not bada?
     117#elif defined _WIN32 && !defined __BORLANDC__
    118118        asctime_s(buf, sizeof(buf), &tm);
    119119        ret = buf;
  • cpp/common/stl-util.cpp

    r247 r257  
    1111#include <assert.h>
    1212#ifdef USE_VIRTFILE
    13  #include <frams/virtfile/virtfile.h>
     13#include <frams/virtfile/virtfile.h>
    1414#endif
    1515#ifdef __BORLANDC__
    16  #define va_copy(to,from) to=from //borland does not have va_copy() at all; va_list is just a pointer in borland
     16#define va_copy(to,from) to=from //borland does not have va_copy() at all; va_list is just a pointer in borland
    1717#endif
    1818
     
    2727        //almost like SString::sprintf, but there is no common code to share because SString can use its directWrite to avoid double allocating/copying
    2828#ifdef USE_VSCPRINTF
    29         va_copy(ap_copy,ap);
     29        va_copy(ap_copy, ap);
    3030        size = _vscprintf(format, ap_copy) + 1; //+1 for terminating null character
    3131        va_end(ap_copy);
     
    3636                buf = (char*)malloc(size);
    3737                assert(buf != NULL);
    38                 va_copy(ap_copy,ap);
     38                va_copy(ap_copy, ap);
    3939                int n = vsnprintf(buf, size, format, ap_copy);
    4040                va_end(ap_copy);
     
    5555}
    5656
     57char* strmove(char *a, char *b) //strcpy that works well for overlapping strings ("Source and destination overlap")
     58{
     59        if (a == NULL || b == NULL)
     60                return NULL;
     61        memmove(a, b, strlen(b) + 1);
     62        return a;
     63}
     64
    5765string ssprintf(const char* format, ...)
    5866{
     
    6674bool readCompleteFile(const char* filename, vector<char>& data, bool warn_on_missing_file)
    6775{
    68     bool ok=false;
     76        bool ok = false;
    6977#ifdef USE_VIRTFILE
    7078        if (!isAbsolutePath(filename))
    71                 {
     79        {
    7280                VirtFILE *f=Vfopen(filename,FOPEN_READ_BINARY);
    7381                if (f)
    74                         {
     82                {
    7583                        int size=f->getSize();
    7684                        data.resize(size);
     
    7886                        ok = przeczytane == 1;
    7987                        delete f;
    80                         }
    8188                }
     89        }
    8290        else
    8391#endif
    8492        {
    85         MFILE *f = mfopen(filename, FOPEN_READ_BINARY);
    86         if (f)
    87         {
    88                 int size=getFileSize(f);
    89                 data.resize(size);
    90                 int przeczytane = mfread(&data[0], size, 1, f);
    91                 mfclose(f);
    92                 ok = przeczytane == 1;
    93         }
     93                MFILE *f = mfopen(filename, FOPEN_READ_BINARY);
     94                if (f)
     95                {
     96                        int size = getFileSize(f);
     97                        data.resize(size);
     98                        int przeczytane = mfread(&data[0], size, 1, f);
     99                        mfclose(f);
     100                        ok = przeczytane == 1;
     101                }
    94102        }
    95103        if (warn_on_missing_file && !ok)
  • cpp/common/stl-util.h

    r246 r257  
    1111template<typename T, std::size_t N> void push_back(vector<T>& v, T(&d)[N])
    1212{
    13 for(unsigned int i=0;i<N;i++)
    14         v.push_back(d[i]);
     13        for (unsigned int i = 0; i < N; i++)
     14                v.push_back(d[i]);
    1515}
    1616
    1717template<typename T> void erase(vector<T>& v, const T& e)
    1818{
    19 typename vector<T>::iterator it=std::find(v.begin(),v.end(),e);
    20 if (it!=v.end())
    21         v.erase(it);
     19        typename vector<T>::iterator it = std::find(v.begin(), v.end(), e);
     20        if (it != v.end())
     21                v.erase(it);
    2222}
    2323
    2424template<typename T> void deleteVectorElements(vector<T*>& v)
    2525{
    26 for(typename vector<T*>::iterator it=v.begin();it!=v.end();it++)
    27         delete *it;
    28 v.clear();
     26        for (typename vector<T*>::iterator it = v.begin(); it != v.end(); it++)
     27                delete *it;
     28        v.clear();
    2929}
    3030
    3131template<typename T> int findIndex(vector<T>& v, const T& e)
    3232{
    33 typename vector<T>::iterator it=find(v.begin(),v.end(),e);
    34 if (it!=v.end())
    35         return &*it-&v.front();
    36 return -1;
     33        typename vector<T>::iterator it = find(v.begin(), v.end(), e);
     34        if (it != v.end())
     35                return &*it - &v.front();
     36        return -1;
    3737}
     38
     39
     40char* strmove(char *a, char *b); //strcpy that works well for overlapping strings ("Source and destination overlap")
    3841
    3942string ssprintf(const char* format, ...);
     
    4548
    4649
    47 bool readCompleteFile(const char* filename, vector<char>& data, bool warn_on_missing_file=true);
    48 bool readCompleteFile(const char* filename, string& out, bool warn_on_missing_file=true);
    49 bool writeCompleteFile(const char* filename, const std::string& text,bool warn_on_fail=true);
    50 bool writeCompleteFile(const char* filename, vector<char>& data, bool warn_on_fail=true);
     50bool readCompleteFile(const char* filename, vector<char>& data, bool warn_on_missing_file = true);
     51bool readCompleteFile(const char* filename, string& out, bool warn_on_missing_file = true);
     52bool writeCompleteFile(const char* filename, const std::string& text, bool warn_on_fail = true);
     53bool writeCompleteFile(const char* filename, vector<char>& data, bool warn_on_fail = true);
    5154
    5255template<class T> class DeletingVector  // deletes the elements (pointers) in destructor
    5356{
    54   public:
    55 std::vector<T*> vector;
    56 ~DeletingVector()
     57public:
     58        std::vector<T*> vector;
     59        ~DeletingVector()
    5760        {
    58         for(int i=vector.size()-1;i>=0;i--)
    59                 delete vector[i];
     61                for (int i = vector.size() - 1; i >= 0; i--)
     62                        delete vector[i];
    6063        }
    61 T* operator[](int i) {return vector[i];}
    62 int size() {return vector.size();}
    63 void push_back(T* x) {vector.push_back(x);}
     64        T* operator[](int i) { return vector[i]; }
     65        int size() { return vector.size(); }
     66        void push_back(T* x) { vector.push_back(x); }
    6467};
    6568
  • cpp/frams/genetics/genman.cpp

    r247 r257  
    300300{
    301301        char format = g1.getFormat();
    302         if (format != g2.getFormat()) return Geno(SString::empty(), -1, SString::empty(), SString::sprintf("GENOPER_NOOPER: CrossOver() does not know how to handle parents with differing genetic formats (%c and %c)", format, g2.getFormat()));
     302        if (format != g2.getFormat()) return Geno(SString::empty(), -1, SString::empty(), SString::sprintf("GENOPER_NOOPER: CrossOver(): does not work for parents with differing genetic formats (%c and %c)", format, g2.getFormat()));
    303303        GenoOperators *gf = getOper_f(format);
    304304        if (gf == NULL)
    305                 return Geno(SString::empty(), -1, SString::empty(), SString::sprintf("GENOPER_NOOPER: CrossOver(): don't know how to handle genetic format %c", format));
     305                return Geno(SString::empty(), -1, SString::empty(), SString::sprintf("GENOPER_NOOPER: CrossOver(): no operators found for genetic format %c", format));
    306306        Geno g1v = g1, g2v = g2;
    307307
  • cpp/frams/util/extvalue.cpp

    r247 r257  
    5151        if (destroy) delete dbobject;
    5252        }
     53}
     54
     55bool ExtObject::operator==(const ExtObject& src) const
     56{
     57if (object!=src.object) return false;
     58const char* n1=interfaceName();
     59const char* n2=src.interfaceName();
     60return (n1==n2) || (strcmp(n1,n2)==0);
    5361}
    5462
  • cpp/frams/util/extvalue.h

    r247 r257  
    6565bool makeUnique();//< @return false if nothing has changed
    6666
    67 int operator==(const ExtObject& src) const {if (object!=src.object) return 0; return (object==0)?(!strcmp(param->getName(),src.param->getName())):1;}
     67bool operator==(const ExtObject& src) const;
    6868
    6969SString toString() const;
  • cpp/frams/util/sstringutils.cpp

    r210 r257  
    88#include <common/nonstd.h>
    99
    10 int loadSString(const char* filename,SString& s,const char* framsgmodule,const char* error)
    11 {
    12 VirtFILE *f;
    13 int ret=0;
    14 if (f=Vfopen(filename,FOPEN_READ_BINARY))
    15         {
    16         loadSString(f,s);
    17         ret=1;
    18         fclose(f);
    19         }
    20 else if (framsgmodule)
    21         FMprintf(framsgmodule,"loadSString",FMLV_WARN,error?error:"can't open file \"%s\"",filename);
    22 return ret;
    23 }
    24 
    25 void loadSString(VirtFILE *f,SString& s)
    26 {
    27 char buf[1024];
    28 int len;
    29 while(!f->Veof())
    30         {
    31         len=fread(buf,1,sizeof(buf),f);
    32         s.append(buf,len);
    33         }
    34 removeCR(s);
     10int loadSString(const char* filename, SString& s, const char* framsgmodule, const char* error)
     11{
     12        VirtFILE *f;
     13        int ret = 0;
     14        if (f = Vfopen(filename, FOPEN_READ_BINARY))
     15        {
     16                loadSString(f, s);
     17                ret = 1;
     18                fclose(f);
     19        }
     20        else if (framsgmodule)
     21                FMprintf(framsgmodule, "loadSString", FMLV_WARN, error ? error : "can't open file \"%s\"", filename);
     22        return ret;
     23}
     24
     25void loadSString(VirtFILE *f, SString& s)
     26{
     27        char buf[1024];
     28        int len;
     29        while (!f->Veof())
     30        {
     31                len = fread(buf, 1, sizeof(buf), f);
     32                s.append(buf, len);
     33        }
     34        removeCR(s);
    3535}
    3636
    3737//load single line, discarding any \r or \n found at the end, return false if nothing could be loaded (error or eof)
    38 bool loadSStringLine(VirtFILE* f,SString& s)
    39 {
    40 char buf[100];
    41 bool eolfound=false;
    42 bool ret=false;
    43 s=SString::empty();
    44 while(!eolfound)
    45         {
    46         char *r=fgets(buf,sizeof(buf),f);
    47         if (r==NULL) break;
    48         ret=true;
    49         int d=strlen(r);
    50         if (d>0)
    51                 {
    52                 if (r[d-1]=='\n') {d--; eolfound=true;}
    53                 if (d>0) if (r[d-1]=='\r') d--;
    54                 s+=SString(r,d);
    55                 }
    56         }
    57 return ret;
     38bool loadSStringLine(VirtFILE* f, SString& s)
     39{
     40        char buf[100];
     41        bool eolfound = false;
     42        bool ret = false;
     43        s = SString::empty();
     44        while (!eolfound)
     45        {
     46                char *r = fgets(buf, sizeof(buf), f);
     47                if (r == NULL) break;
     48                ret = true;
     49                int d = strlen(r);
     50                if (d > 0)
     51                {
     52                        if (r[d - 1] == '\n') { d--; eolfound = true; }
     53                        if (d > 0) if (r[d - 1] == '\r') d--;
     54                        s += SString(r, d);
     55                }
     56        }
     57        return ret;
    5858}
    5959
     
    6363int quoteTilde(SString &target)
    6464{
    65 const char* x=target;
    66 SString tmp;
    67 char *f;
    68 while(1)
    69         {
    70         f=strchr((char*)x,'~');
    71         if (f)
    72                 {
    73                 tmp.append(x,f-x);
    74                 tmp+="\\~";
    75                 x=f+1;
    76                 }
    77         else
    78                 {
    79                 if (tmp.len()==0) return 0; // nothing was changed!
    80                 tmp+=x;
    81                 target=tmp;
    82                 return 1;
     65        const char* x = target;
     66        SString tmp;
     67        char *f;
     68        while (1)
     69        {
     70                f = strchr((char*)x, '~');
     71                if (f)
     72                {
     73                        tmp.append(x, f - x);
     74                        tmp += "\\~";
     75                        x = f + 1;
     76                }
     77                else
     78                {
     79                        if (tmp.len() == 0) return 0; // nothing was changed!
     80                        tmp += x;
     81                        target = tmp;
     82                        return 1;
    8383                }
    8484        }
     
    8888int unquoteTilde(SString &target)
    8989{
    90 const char* x=target;
    91 SString tmp;
    92 char *f;
    93 while(1)
    94         {
    95         f=strchr((char*)x,'\\');
    96         if (f)
    97                 {
    98                 tmp.append(x,f-x);
    99                 if (f[1]=='~')
     90        const char* x = target;
     91        SString tmp;
     92        char *f;
     93        while (1)
     94        {
     95                f = strchr((char*)x, '\\');
     96                if (f)
     97                {
     98                        tmp.append(x, f - x);
     99                        if (f[1] == '~')
    100100                        {
    101                         tmp+='~';
    102                         x=f+2;
     101                                tmp += '~';
     102                                x = f + 2;
    103103                        }
    104                 else
     104                        else
    105105                        {
    106                         tmp+="\\";
    107                         x=f+1;
     106                                tmp += "\\";
     107                                x = f + 1;
    108108                        }
    109109                }
     110                else
     111                {
     112                        if (tmp.len() == 0) return 0; // nothing was changed!
     113                        tmp += x;
     114                        target = tmp;
     115                        return 1;
     116                }
     117        }
     118}
     119
     120/////////////////
     121
     122bool strContainsOneOf(const char* str, const char* chars)
     123{
     124        while (*str)
     125        {
     126                if (strchr(chars, *str)) return 1;
     127                str++;
     128        }
     129        return 0;
     130}
     131
     132//////////////
     133
     134bool sstringQuote(SString& target)
     135{
     136        const char* x = target;
     137        bool changed = 0;
     138        SString tmp;
     139        tmp.memoryHint(target.len());
     140        while (*x)
     141        {
     142                switch (*x)
     143                {
     144                case '\n': tmp += "\\n"; changed = 1; break;
     145                case '\r': tmp += "\\r"; changed = 1; break;
     146                case '\t': tmp += "\\t"; changed = 1; break;
     147                case '\"': tmp += "\\\""; changed = 1; break;
     148                case '\\': tmp += "\\\\"; changed = 1; break;
     149                default: tmp += *x;
     150                }
     151                x++;
     152        }
     153        if (changed) target = tmp;
     154        return changed;
     155}
     156
     157const char* skipQuoteString(const char* txt, const char* limit)
     158{
     159        while (*txt)
     160        {
     161                if (*txt == '\"') return txt;
     162                if (*txt == '\\') txt++;
     163                txt++;
     164                if (txt == limit) break;
     165        }
     166        return txt;
     167}
     168
     169int sstringUnquote(SString &target)
     170{
     171        const char* x = target;
     172        SString tmp;
     173        char *f;
     174        while (1)
     175        {
     176                f = strchr((char*)x, '\\');
     177                if (f)
     178                {
     179                        tmp.append(x, f - x);
     180                        switch (f[1])
     181                        {
     182                        case 'n': tmp += '\n'; break;
     183                        case 'r': tmp += '\r'; break;
     184                        case 't': tmp += '\t'; break;
     185                        case '\"': tmp += '\"'; break;
     186                        default: tmp += f[1];
     187                        }
     188                        x = f + 2;
     189                }
     190                else
     191                {
     192                        if (tmp.len() == 0) return 0; // nothing was changed!
     193                        tmp += x;
     194                        target = tmp;
     195                        return 1;
     196                }
     197        }
     198}
     199
     200int strFindField(const SString& txt, const SString& name, int &end)
     201{
     202        const char* t = txt, *n;
     203        int pos = 0;
     204        while (1)
     205        {
     206                n = strchr(t + pos, ',');
     207                if ((!strncmp(t + pos, name, name.len())) && (t[pos + name.len()] == '='))
     208                {
     209                        if (n) end = n - t; else end = txt.len();
     210                        return pos;
     211                }
     212                if (n) pos = n - t + 1; else break;
     213        }
     214        return -1;
     215}
     216
     217SString strGetField(const SString& txt, const SString& name)
     218{
     219        int p, e;
     220        p = strFindField(txt, name, e);
     221        if (p < 0) return SString();
     222        p += name.len() + 1;
     223        return SString(txt.substr(p, e - p));
     224}
     225
     226void strSetField(SString& txt, const SString& name, const SString& value)
     227{
     228        int p, e;
     229        p = strFindField(txt, name, e);
     230        if (p < 0)
     231        {
     232                if (!value.len()) return;
     233                char *t = txt.directAppend(1 + name.len() + value.len());
     234                char *b = t;
     235                if (txt.len()) *(t++) = ',';
     236                strcpy(t, name); t += name.len();
     237                *(t++) = '=';
     238                strcpy(t, value); t += value.len();
     239                txt.endAppend(t - b);
     240        }
    110241        else
    111                 {
    112                 if (tmp.len()==0) return 0; // nothing was changed!
    113                 tmp+=x;
    114                 target=tmp;
    115                 return 1;
    116                 }
    117         }
    118 }
    119 
    120 /////////////////
    121 
    122 bool strContainsOneOf(const char* str,const char* chars)
    123 {
    124 while(*str)
    125         {
    126         if (strchr(chars,*str)) return 1;
    127         str++;
    128         }
    129 return 0;
    130 }
    131 
    132 //////////////
    133 
    134 bool sstringQuote(SString& target)
    135 {
    136 const char* x=target;
    137 bool changed=0;
    138 SString tmp;
    139 tmp.memoryHint(target.len());
    140 while(*x)
    141         {
    142         switch(*x)
    143                 {
    144                 case '\n': tmp+="\\n"; changed=1; break;
    145                 case '\r': tmp+="\\r"; changed=1; break;
    146                 case '\t': tmp+="\\t"; changed=1; break;
    147                 case '\"': tmp+="\\\""; changed=1; break;
    148                 case '\\': tmp+="\\\\"; changed=1; break;
    149                 default: tmp+=*x;
    150                 }
    151         x++;
    152         }
    153 if (changed) target=tmp;
    154 return changed;
    155 }
    156 
    157 const char* skipQuoteString(const char* txt, const char* limit)
    158 {
    159 while(*txt)
    160         {
    161         if (*txt=='\"') return txt;
    162         if (*txt=='\\') txt++;
    163         txt++;
    164         if (txt==limit) break;
    165         }
    166 return txt;
    167 }
    168 
    169 int sstringUnquote(SString &target)
    170 {
    171 const char* x=target;
    172 SString tmp;
    173 char *f;
    174 while(1)
    175         {
    176         f=strchr((char*)x,'\\');
    177         if (f)
    178                 {
    179                 tmp.append(x,f-x);
    180                 switch(f[1])
    181                         {
    182                         case 'n': tmp+='\n'; break;
    183                         case 'r': tmp+='\r'; break;
    184                         case 't': tmp+='\t'; break;
    185                         case '\"': tmp+='\"'; break;
    186                         default: tmp+=f[1];
    187                         }
    188                 x=f+2;
    189                 }
     242        {
     243                if (!value.len())
     244                {
     245                        if (p > 0) p--; else if (e < txt.len()) e++;
     246                        char *t = txt.directWrite(0);
     247                        memmove(t + p, t + e, txt.len() - e);
     248                        txt.endWrite(txt.len() + value.len() - (e - p));
     249                }
     250                else
     251                {
     252                        p += name.len() + 1;
     253                        char *t = txt.directWrite(txt.len() + value.len() - (e - p));
     254                        memmove(t + p + value.len(), t + e, txt.len() - e);
     255                        memmove(t + p, value, value.len());
     256                        txt.endWrite(txt.len() + value.len() - (e - p));
     257                }
     258        }
     259}
     260
     261SString trim(SString& s)
     262{
     263        const unsigned char*b = (const unsigned char*)(const char*)s;
     264        const unsigned char*e = b + s.len();
     265        while ((b < e) && (*b <= ' ')) b++;
     266        while ((b < e) && (e[-1] <= ' ')) e--;
     267        if ((e - b) == s.len()) return s;
     268        SString newstring;
     269        char* t = newstring.directWrite(e - b);
     270        memmove(t, b, e - b);
     271        newstring.endWrite(e - b);
     272        return newstring;
     273}
     274
     275bool removeCR(SString& s)
     276{
     277        const char* p = (const char*)s;
     278        const char* cr = strchr(p, '\r');
     279        if (!cr) return false;
     280        char* begin = s.directWrite();
     281        char* src = begin + (cr - p), *dst = src;
     282        while (*src)
     283                if (*src == '\r')
     284                        src++;
     285                else
     286                        *(dst++) = *(src++);
     287        s.endWrite(dst - begin);
     288        return true;
     289}
     290
     291bool matchWildcard(const SString& word, const SString& pattern)
     292{
     293        if (pattern.len() == 0)
     294                return word.len() == 0;
     295        int aster = pattern.indexOf('*');
     296        if (aster >= 0)
     297        {
     298                SString before = pattern.substr(0, aster);
     299                SString after = pattern.substr(aster + 1);
     300                int pos = 0;
     301                if (!word.len()) return false;
     302                if (before.len()) if (!word.startsWith(before)) return false;
     303                if (after.len())
     304                        if ((word.len() < after.len())
     305                                || (strcmp((const char*)after, ((const char*)word) + word.len() - after.len())))
     306                                return false;
     307                return true;
     308        }
    190309        else
    191                 {
    192                 if (tmp.len()==0) return 0; // nothing was changed!
    193                 tmp+=x;
    194                 target=tmp;
    195                 return 1;
    196                 }
    197         }
    198 }
    199 
    200 int strFindField(const SString& txt,const SString& name,int &end)
    201 {
    202 const char* t=txt,*n;
    203 int pos=0;
    204 while(1)
    205         {
    206         n=strchr(t+pos,',');
    207         if ((!strncmp(t+pos,name,name.len()))&&(t[pos+name.len()]=='='))
    208                 {
    209                 if (n) end=n-t; else end=txt.len();
    210                 return pos;
    211                 }
    212         if (n) pos=n-t+1; else break;
    213         }
    214 return -1;
    215 }
    216 
    217 SString strGetField(const SString& txt,const SString& name)
    218 {
    219 int p,e;
    220 p=strFindField(txt,name,e);
    221 if (p<0) return SString();
    222 p+=name.len()+1;
    223 return SString(txt.substr(p,e-p));
    224 }
    225 
    226 void strSetField(SString& txt,const SString& name,const SString& value)
    227 {
    228 int p,e;
    229 p=strFindField(txt,name,e);
    230 if (p<0)
    231         {
    232         if (!value.len()) return;
    233         char *t=txt.directAppend(1+name.len()+value.len());
    234         char *b=t;
    235         if (txt.len()) *(t++)=',';
    236         strcpy(t,name); t+=name.len();
    237         *(t++)='=';
    238         strcpy(t,value); t+=value.len();
    239         txt.endAppend(t-b);
    240         }
    241 else
    242         {
    243         if (!value.len())
    244                 {
    245                 if (p>0) p--; else if (e<txt.len()) e++;
    246                 char *t=txt.directWrite(0);
    247                 memmove(t+p,t+e,txt.len()-e);
    248                 txt.endWrite(txt.len()+value.len()-(e-p));
    249                 }
    250         else
    251                 {
    252                 p+=name.len()+1;
    253                 char *t=txt.directWrite(txt.len()+value.len()-(e-p));
    254                 memmove(t+p+value.len(),t+e,txt.len()-e);
    255                 memmove(t+p,value,value.len());
    256                 txt.endWrite(txt.len()+value.len()-(e-p));
    257                 }
    258         }
    259 }
    260 
    261 SString trim(SString& s)
    262 {
    263 const unsigned char*b=(const unsigned char*)(const char*)s;
    264 const unsigned char*e=b+s.len();
    265 while((b<e)&&(*b<=' ')) b++;
    266 while((b<e)&&(e[-1]<=' ')) e--;
    267 if ((e-b)==s.len()) return s;
    268 SString newstring;
    269 char* t=newstring.directWrite(e-b);
    270 memmove(t,b,e-b);
    271 newstring.endWrite(e-b);
    272 return newstring;
    273 }
    274 
    275 bool removeCR(SString& s)
    276 {
    277 const char* p=(const char*)s;
    278 const char* cr=strchr(p,'\r');
    279 if (!cr) return false;
    280 char* begin=s.directWrite();
    281 char* src=begin+(cr-p),*dst=src;
    282 while(*src)
    283         if (*src=='\r')
    284                 src++;
    285         else
    286                 *(dst++)=*(src++);
    287 s.endWrite(dst-begin);
    288 return true;
    289 }
    290 
    291 bool matchWildcard(const SString& word,const SString& pattern)
    292 {
    293 if (pattern.len()==0)
    294         return word.len()==0;
    295 int aster=pattern.indexOf('*');
    296 if (aster>=0)
    297         {
    298         SString before=pattern.substr(0,aster);
    299         SString after=pattern.substr(aster+1);
    300         int pos=0;
    301         if (!word.len()) return false;
    302         if (before.len()) if (!word.startsWith(before)) return false;
    303         if (after.len())
    304                 if ((word.len()<after.len())
    305                     ||(strcmp((const char*)after,((const char*)word)+word.len()-after.len())))
    306                         return false;
    307         return true;
    308         }
    309 else
    310         return word==pattern;
    311 }
    312 
    313 bool matchWildcardList(const SString& word,const SString& patterns)
    314 {
    315 if (patterns.len()==0)
    316         return word.len()==0;
    317 int pos=0;
    318 SString pattern;
    319 while(patterns.getNextToken(pos,pattern,','))
    320         if (matchWildcard(word,pattern))
    321                 return true;
    322 return false;
    323 }
    324 
     310                return word == pattern;
     311}
     312
     313bool matchWildcardList(const SString& word, const SString& patterns)
     314{
     315        if (patterns.len() == 0)
     316                return word.len() == 0;
     317        int pos = 0;
     318        SString pattern;
     319        while (patterns.getNextToken(pos, pattern, ','))
     320                if (matchWildcard(word, pattern))
     321                        return true;
     322        return false;
     323}
     324
  • cpp/frams/util/sstringutils.h

    r210 r257  
    1010
    1111/// return: 1=ok 0=error
    12 int loadSString(const char* filename,SString& s,const char* framsgmodule=0,const char* error=0);
    13 void loadSString(VirtFILE *f,SString& s);
    14 bool loadSStringLine(VirtFILE* f,SString &s);
     12int loadSString(const char* filename, SString& s, const char* framsgmodule = 0, const char* error = 0);
     13void loadSString(VirtFILE *f, SString& s);
     14bool loadSStringLine(VirtFILE* f, SString &s);
    1515
    1616int quoteTilde(SString &target);
    1717int unquoteTilde(SString &target);
    1818
    19 bool strContainsOneOf(const char* str,const char* chars);
     19bool strContainsOneOf(const char* str, const char* chars);
    2020bool sstringQuote(SString& target);
    2121const char* skipQuoteString(const char* txt, const char* limit);
    2222int sstringUnquote(SString &target);
    2323
    24 int strFindField(const SString& txt,const SString& name,int &end);
    25 SString strGetField(const SString& txt,const SString& name);
    26 void strSetField(SString& txt,const SString& name,const SString& value);
     24int strFindField(const SString& txt, const SString& name, int &end);
     25SString strGetField(const SString& txt, const SString& name);
     26void strSetField(SString& txt, const SString& name, const SString& value);
    2727
    2828SString trim(SString& s); ///< remove leading/trailing whitespace
    2929bool removeCR(SString& s); ///< remove '\r' return true if changed
    30 bool matchWildcard(const SString& word,const SString& pattern);///< '*' in pattern matches any substring
    31 bool matchWildcardList(const SString& word,const SString& patterns);///< patterns is a list of patterns (separated by ',')
     30bool matchWildcard(const SString& word, const SString& pattern);///< '*' in pattern matches any substring
     31bool matchWildcardList(const SString& word, const SString& patterns);///< patterns is a list of patterns (separated by ',')
    3232
    3333#endif
    34 
Note: See TracChangeset for help on using the changeset viewer.