src/squirrel/sqstdlib/sqstdstring.cpp

   1 /* see copyright notice in squirrel.h */\r
   2 #include <squirrel.h>\r
   3 #include <sqstdstring.h>\r
   4 #include <string.h>\r
   5 #include <stdlib.h>\r
   6 #include <stdio.h>\r
   7 #include <ctype.h>\r
   8 #include <assert.h>\r
   9 \r
  10 #ifdef _UNICODE\r
  11 #define scstrchr wcschr\r
  12 #define scsnprintf wsnprintf\r
  13 #define scatoi _wtoi\r
  14 #define scstrtok wcstok\r
  15 #else\r
  16 #define scstrchr strchr\r
  17 #define scsnprintf snprintf\r
  18 #define scatoi atoi\r
  19 #define scstrtok strtok\r
  20 #endif\r
  21 #define MAX_FORMAT_LEN  20\r
  22 #define MAX_WFORMAT_LEN 3\r
  23 #define ADDITIONAL_FORMAT_SPACE (100*sizeof(SQChar))\r
  24 \r
  25 static SQInteger validate_format(HSQUIRRELVM v, SQChar *fmt, const SQChar *src, SQInteger n,SQInteger &width)\r
  26 {\r
  27         SQChar swidth[MAX_WFORMAT_LEN];\r
  28         SQInteger wc = 0;\r
  29         SQInteger start = n;\r
  30         fmt[0] = '%';\r
  31         while (scstrchr(_SC("-+ #0"), src[n])) n++;\r
  32         while (scisdigit(src[n])) {\r
  33                 swidth[wc] = src[n];\r
  34                 n++;\r
  35                 wc++;\r
  36                 if(wc>=MAX_WFORMAT_LEN)\r
  37                         return sq_throwerror(v,_SC("width format too long"));\r
  38         }\r
  39         swidth[wc] = '\0';\r
  40         if(wc > 0) {\r
  41                 width = scatoi(swidth);\r
  42         }\r
  43         else\r
  44                 width = 0;\r
  45         if (src[n] == '.') {\r
  46             n++;\r
  47         \r
  48                 wc = 0;\r
  49                 while (scisdigit(src[n])) {\r
  50                         swidth[wc] = src[n];\r
  51                         n++;\r
  52                         wc++;\r
  53                         if(wc>=MAX_WFORMAT_LEN)\r
  54                                 return sq_throwerror(v,_SC("precision format too long"));\r
  55                 }\r
  56                 swidth[wc] = '\0';\r
  57                 if(wc > 0) {\r
  58                         width += scatoi(swidth);\r
  59                 }\r
  60         }\r
  61         if (n-start > MAX_FORMAT_LEN )\r
  62                 return sq_throwerror(v,_SC("format too long"));\r
  63         memcpy(&fmt[1],&src[start],((n-start)+1)*sizeof(SQChar));\r
  64         fmt[(n-start)+2] = '\0';\r
  65         return n;\r
  66 }\r
  67 \r
  68 static SQInteger _string_format(HSQUIRRELVM v)\r
  69 {\r
  70         const SQChar *format;\r
  71         SQChar *dest;\r
  72         SQChar fmt[MAX_FORMAT_LEN];\r
  73         sq_getstring(v,2,&format);\r
  74         SQInteger allocated = (sq_getsize(v,2)+1)*sizeof(SQChar);\r
  75         dest = sq_getscratchpad(v,allocated);\r
  76         SQInteger n = 0,i = 0, nparam = 3, w = 0;\r
  77         while(format[n] != '\0') {\r
  78                 if(format[n] != '%') {\r
  79                         assert(i < allocated);\r
  80                         dest[i++] = format[n];\r
  81                         n++;\r
  82                 }\r
  83                 else if(format[n+1] == '%') { //handles %%\r
  84                                 dest[i++] = '%';\r
  85                                 n += 2; \r
  86                 }\r
  87                 else {\r
  88                         n++;\r
  89                         if( nparam > sq_gettop(v) )\r
  90                                 return sq_throwerror(v,_SC("not enough paramters for the given format string"));\r
  91                         n = validate_format(v,fmt,format,n,w);\r
  92                         if(n < 0) return -1;\r
  93                         SQInteger addlen = 0;\r
  94                         SQInteger valtype = 0;\r
  95                         const SQChar *ts;\r
  96                         SQInteger ti;\r
  97                         SQFloat tf;\r
  98                         switch(format[n]) {\r
  99                         case 's':\r
 100                                 if(SQ_FAILED(sq_getstring(v,nparam,&ts))) \r
 101                                         return sq_throwerror(v,_SC("string expected for the specified format"));\r
 102                                 addlen = (sq_getsize(v,nparam)*sizeof(SQChar))+((w+1)*sizeof(SQChar));\r
 103                                 valtype = 's';\r
 104                                 break;\r
 105                         case 'i': case 'd': case 'c':case 'o':  case 'u':  case 'x':  case 'X':\r
 106                                 if(SQ_FAILED(sq_getinteger(v,nparam,&ti))) \r
 107                                         return sq_throwerror(v,_SC("integer expected for the specified format"));\r
 108                                 addlen = (ADDITIONAL_FORMAT_SPACE)+((w+1)*sizeof(SQChar));\r
 109                                 valtype = 'i';\r
 110                                 break;\r
 111                         case 'f': case 'g': case 'G': case 'e':  case 'E':\r
 112                                 if(SQ_FAILED(sq_getfloat(v,nparam,&tf))) \r
 113                                         return sq_throwerror(v,_SC("float expected for the specified format"));\r
 114                                 addlen = (ADDITIONAL_FORMAT_SPACE)+((w+1)*sizeof(SQChar));\r
 115                                 valtype = 'f';\r
 116                                 break;\r
 117                         default:\r
 118                                 return sq_throwerror(v,_SC("invalid format"));\r
 119                         }\r
 120                         n++;\r
 121                         allocated += addlen;\r
 122                         dest = sq_getscratchpad(v,allocated);\r
 123                         switch(valtype) {\r
 124                         case 's': i += scsprintf(&dest[i],fmt,ts); break;\r
 125                         case 'i': i += scsprintf(&dest[i],fmt,ti); break;\r
 126                         case 'f': i += scsprintf(&dest[i],fmt,tf); break;\r
 127                         };\r
 128                         nparam ++;\r
 129                 }\r
 130         }\r
 131         sq_pushstring(v,dest,i);\r
 132         return 1;\r
 133 }\r
 134 \r
 135 static void __strip_l(const SQChar *str,const SQChar **start)\r
 136 {\r
 137         const SQChar *t = str;\r
 138         while(((*t) != '\0') && scisspace(*t)){ t++; }\r
 139         *start = t;\r
 140 }\r
 141 \r
 142 static void __strip_r(const SQChar *str,SQInteger len,const SQChar **end)\r
 143 {\r
 144         if(len == 0) {\r
 145                 *end = str;\r
 146                 return;\r
 147         }\r
 148         const SQChar *t = &str[len-1];\r
 149         while(t != str && scisspace(*t)) { t--; }\r
 150         *end = t+1;\r
 151 }\r
 152 \r
 153 static SQInteger _string_strip(HSQUIRRELVM v)\r
 154 {\r
 155         const SQChar *str,*start,*end;\r
 156         sq_getstring(v,2,&str);\r
 157         SQInteger len = sq_getsize(v,2);\r
 158         __strip_l(str,&start);\r
 159         __strip_r(str,len,&end);\r
 160         sq_pushstring(v,start,end - start);\r
 161         return 1;\r
 162 }\r
 163 \r
 164 static SQInteger _string_lstrip(HSQUIRRELVM v)\r
 165 {\r
 166         const SQChar *str,*start;\r
 167         sq_getstring(v,2,&str);\r
 168         __strip_l(str,&start);\r
 169         sq_pushstring(v,start,-1);\r
 170         return 1;\r
 171 }\r
 172 \r
 173 static SQInteger _string_rstrip(HSQUIRRELVM v)\r
 174 {\r
 175         const SQChar *str,*end;\r
 176         sq_getstring(v,2,&str);\r
 177         SQInteger len = sq_getsize(v,2);\r
 178         __strip_r(str,len,&end);\r
 179         sq_pushstring(v,str,end - str);\r
 180         return 1;\r
 181 }\r
 182 \r
 183 static SQInteger _string_split(HSQUIRRELVM v)\r
 184 {\r
 185         const SQChar *str,*seps;\r
 186         SQChar *stemp,*tok;\r
 187         sq_getstring(v,2,&str);\r
 188         sq_getstring(v,3,&seps);\r
 189         if(sq_getsize(v,3) == 0) return sq_throwerror(v,_SC("empty separators string"));\r
 190         SQInteger memsize = (sq_getsize(v,2)+1)*sizeof(SQChar);\r
 191         stemp = sq_getscratchpad(v,memsize);\r
 192         memcpy(stemp,str,memsize);\r
 193         tok = scstrtok(stemp,seps);\r
 194         sq_newarray(v,0);\r
 195         while( tok != NULL ) {\r
 196                 sq_pushstring(v,tok,-1);\r
 197                 sq_arrayappend(v,-2);\r
 198                 tok = scstrtok( NULL, seps );\r
 199         }\r
 200         return 1;\r
 201 }\r
 202 \r
 203 #define SETUP_REX(v) \\r
 204         SQRex *self = NULL; \\r
 205         sq_getinstanceup(v,1,(SQUserPointer *)&self,0); \r
 206 \r
 207 static SQInteger _rexobj_releasehook(SQUserPointer p, SQInteger size)\r
 208 {\r
 209         SQRex *self = ((SQRex *)p);\r
 210         sqstd_rex_free(self);\r
 211         return 1;\r
 212 }\r
 213 \r
 214 static SQInteger _regexp_match(HSQUIRRELVM v)\r
 215 {\r
 216         SETUP_REX(v);\r
 217         const SQChar *str;\r
 218         sq_getstring(v,2,&str);\r
 219         if(sqstd_rex_match(self,str) == SQTrue)\r
 220         {\r
 221                 sq_pushbool(v,SQTrue);\r
 222                 return 1;\r
 223         }\r
 224         sq_pushbool(v,SQFalse);\r
 225         return 1;\r
 226 }\r
 227 \r
 228 static void _addrexmatch(HSQUIRRELVM v,const SQChar *str,const SQChar *begin,const SQChar *end)\r
 229 {\r
 230         sq_newtable(v);\r
 231         sq_pushstring(v,_SC("begin"),-1);\r
 232         sq_pushinteger(v,begin - str);\r
 233         sq_rawset(v,-3);\r
 234         sq_pushstring(v,_SC("end"),-1);\r
 235         sq_pushinteger(v,end - str);\r
 236         sq_rawset(v,-3);\r
 237 }\r
 238 \r
 239 static SQInteger _regexp_search(HSQUIRRELVM v)\r
 240 {\r
 241         SETUP_REX(v);\r
 242         const SQChar *str,*begin,*end;\r
 243         SQInteger start = 0;\r
 244         sq_getstring(v,2,&str);\r
 245         if(sq_gettop(v) > 2) sq_getinteger(v,3,&start);\r
 246         if(sqstd_rex_search(self,str+start,&begin,&end) == SQTrue) {\r
 247                 _addrexmatch(v,str,begin,end);\r
 248                 return 1;\r
 249         }\r
 250         return 0;\r
 251 }\r
 252 \r
 253 static SQInteger _regexp_capture(HSQUIRRELVM v)\r
 254 {\r
 255         SETUP_REX(v);\r
 256         const SQChar *str,*begin,*end;\r
 257         SQInteger start = 0;\r
 258         sq_getstring(v,2,&str);\r
 259         if(sq_gettop(v) > 2) sq_getinteger(v,3,&start);\r
 260         if(sqstd_rex_search(self,str+start,&begin,&end) == SQTrue) {\r
 261                 SQInteger n = sqstd_rex_getsubexpcount(self);\r
 262                 SQRexMatch match;\r
 263                 sq_newarray(v,0);\r
 264                 for(SQInteger i = 0;i < n; i++) {\r
 265                         sqstd_rex_getsubexp(self,i,&match);\r
 266                         if(match.len > 0)\r
 267                                 _addrexmatch(v,str,match.begin,match.begin+match.len);\r
 268                         else\r
 269                                 _addrexmatch(v,str,str,str); //empty match\r
 270                         sq_arrayappend(v,-2);\r
 271                 }\r
 272                 return 1;\r
 273         }\r
 274         return 0;\r
 275 }\r
 276 \r
 277 static SQInteger _regexp_subexpcount(HSQUIRRELVM v)\r
 278 {\r
 279         SETUP_REX(v);\r
 280         sq_pushinteger(v,sqstd_rex_getsubexpcount(self));\r
 281         return 1;\r
 282 }\r
 283 \r
 284 static SQInteger _regexp_constructor(HSQUIRRELVM v)\r
 285 {\r
 286         const SQChar *error,*pattern;\r
 287         sq_getstring(v,2,&pattern);\r
 288         SQRex *rex = sqstd_rex_compile(pattern,&error);\r
 289         if(!rex) return sq_throwerror(v,error);\r
 290         sq_setinstanceup(v,1,rex);\r
 291         sq_setreleasehook(v,1,_rexobj_releasehook);\r
 292         return 0;\r
 293 }\r
 294 \r
 295 static SQInteger _regexp__typeof(HSQUIRRELVM v)\r
 296 {\r
 297         sq_pushstring(v,_SC("regexp"),-1);\r
 298         return 1;\r
 299 }\r
 300 \r
 301 #define _DECL_REX_FUNC(name,nparams,pmask) {_SC(#name),_regexp_##name,nparams,pmask}\r
 302 static SQRegFunction rexobj_funcs[]={\r
 303         _DECL_REX_FUNC(constructor,2,_SC(".s")),\r
 304         _DECL_REX_FUNC(search,-2,_SC("xsn")),\r
 305         _DECL_REX_FUNC(match,2,_SC("xs")),\r
 306         _DECL_REX_FUNC(capture,-2,_SC("xsn")),\r
 307         _DECL_REX_FUNC(subexpcount,1,_SC("x")),\r
 308         _DECL_REX_FUNC(_typeof,1,_SC("x")),\r
 309         {0,0}\r
 310 };\r
 311 \r
 312 #define _DECL_FUNC(name,nparams,pmask) {_SC(#name),_string_##name,nparams,pmask}\r
 313 static SQRegFunction stringlib_funcs[]={\r
 314         _DECL_FUNC(format,-2,_SC(".s")),\r
 315         _DECL_FUNC(strip,2,_SC(".s")),\r
 316         _DECL_FUNC(lstrip,2,_SC(".s")),\r
 317         _DECL_FUNC(rstrip,2,_SC(".s")),\r
 318         _DECL_FUNC(split,3,_SC(".ss")),\r
 319         {0,0}\r
 320 };\r
 321 \r
 322 \r
 323 SQInteger sqstd_register_stringlib(HSQUIRRELVM v)\r
 324 {\r
 325         sq_pushstring(v,_SC("regexp"),-1);\r
 326         sq_newclass(v,SQFalse);\r
 327         SQInteger i = 0;\r
 328         while(rexobj_funcs[i].name != 0) {\r
 329                 SQRegFunction &f = rexobj_funcs[i];\r
 330                 sq_pushstring(v,f.name,-1);\r
 331                 sq_newclosure(v,f.f,0);\r
 332                 sq_setparamscheck(v,f.nparamscheck,f.typemask);\r
 333                 sq_setnativeclosurename(v,-1,f.name);\r
 334                 sq_createslot(v,-3);\r
 335                 i++;\r
 336         }\r
 337         sq_createslot(v,-3);\r
 338 \r
 339         i = 0;\r
 340         while(stringlib_funcs[i].name!=0)\r
 341         {\r
 342                 sq_pushstring(v,stringlib_funcs[i].name,-1);\r
 343                 sq_newclosure(v,stringlib_funcs[i].f,0);\r
 344                 sq_setparamscheck(v,stringlib_funcs[i].nparamscheck,stringlib_funcs[i].typemask);\r
 345                 sq_setnativeclosurename(v,-1,stringlib_funcs[i].name);\r
 346                 sq_createslot(v,-3);\r
 347                 i++;\r
 348         }\r
 349         return 1;\r
 350 }\r