external/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 SQUNICODE\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 \r
  69 SQRESULT sqstd_format(HSQUIRRELVM v,SQInteger nformatstringidx,SQInteger *outlen,SQChar **output)\r
  70 {\r
  71         const SQChar *format;\r
  72         SQChar *dest;\r
  73         SQChar fmt[MAX_FORMAT_LEN];\r
  74         sq_getstring(v,nformatstringidx,&format);\r
  75         SQInteger allocated = (sq_getsize(v,nformatstringidx)+2)*sizeof(SQChar);\r
  76         dest = sq_getscratchpad(v,allocated);\r
  77         SQInteger n = 0,i = 0, nparam = nformatstringidx+1, w = 0;\r
  78         while(format[n] != '\0') {\r
  79                 if(format[n] != '%') {\r
  80                         assert(i < allocated);\r
  81                         dest[i++] = format[n];\r
  82                         n++;\r
  83                 }\r
  84                 else if(format[n+1] == '%') { //handles %%\r
  85                                 dest[i++] = '%';\r
  86                                 n += 2; \r
  87                 }\r
  88                 else {\r
  89                         n++;\r
  90                         if( nparam > sq_gettop(v) )\r
  91                                 return sq_throwerror(v,_SC("not enough paramters for the given format string"));\r
  92                         n = validate_format(v,fmt,format,n,w);\r
  93                         if(n < 0) return -1;\r
  94                         SQInteger addlen = 0;\r
  95                         SQInteger valtype = 0;\r
  96                         const SQChar *ts;\r
  97                         SQInteger ti;\r
  98                         SQFloat tf;\r
  99                         switch(format[n]) {\r
 100                         case 's':\r
 101                                 if(SQ_FAILED(sq_getstring(v,nparam,&ts))) \r
 102                                         return sq_throwerror(v,_SC("string expected for the specified format"));\r
 103                                 addlen = (sq_getsize(v,nparam)*sizeof(SQChar))+((w+1)*sizeof(SQChar));\r
 104                                 valtype = 's';\r
 105                                 break;\r
 106                         case 'i': case 'd': case 'c':case 'o':  case 'u':  case 'x':  case 'X':\r
 107                                 if(SQ_FAILED(sq_getinteger(v,nparam,&ti))) \r
 108                                         return sq_throwerror(v,_SC("integer expected for the specified format"));\r
 109                                 addlen = (ADDITIONAL_FORMAT_SPACE)+((w+1)*sizeof(SQChar));\r
 110                                 valtype = 'i';\r
 111                                 break;\r
 112                         case 'f': case 'g': case 'G': case 'e':  case 'E':\r
 113                                 if(SQ_FAILED(sq_getfloat(v,nparam,&tf))) \r
 114                                         return sq_throwerror(v,_SC("float expected for the specified format"));\r
 115                                 addlen = (ADDITIONAL_FORMAT_SPACE)+((w+1)*sizeof(SQChar));\r
 116                                 valtype = 'f';\r
 117                                 break;\r
 118                         default:\r
 119                                 return sq_throwerror(v,_SC("invalid format"));\r
 120                         }\r
 121                         n++;\r
 122                         allocated += addlen + sizeof(SQChar);\r
 123                         dest = sq_getscratchpad(v,allocated);\r
 124                         switch(valtype) {\r
 125                         case 's': i += scsprintf(&dest[i],fmt,ts); break;\r
 126                         case 'i': i += scsprintf(&dest[i],fmt,ti); break;\r
 127                         case 'f': i += scsprintf(&dest[i],fmt,tf); break;\r
 128                         };\r
 129                         nparam ++;\r
 130                 }\r
 131         }\r
 132         *outlen = i;\r
 133         dest[i] = '\0';\r
 134         *output = dest;\r
 135         return SQ_OK;\r
 136 }\r
 137 \r
 138 static SQInteger _string_format(HSQUIRRELVM v)\r
 139 {\r
 140         SQChar *dest = NULL;\r
 141         SQInteger length = 0;\r
 142         if(SQ_FAILED(sqstd_format(v,2,&length,&dest)))\r
 143                 return -1;\r
 144         sq_pushstring(v,dest,length);\r
 145         return 1;\r
 146 }\r
 147 \r
 148 static void __strip_l(const SQChar *str,const SQChar **start)\r
 149 {\r
 150         const SQChar *t = str;\r
 151         while(((*t) != '\0') && scisspace(*t)){ t++; }\r
 152         *start = t;\r
 153 }\r
 154 \r
 155 static void __strip_r(const SQChar *str,SQInteger len,const SQChar **end)\r
 156 {\r
 157         if(len == 0) {\r
 158                 *end = str;\r
 159                 return;\r
 160         }\r
 161         const SQChar *t = &str[len-1];\r
 162         while(t != str && scisspace(*t)) { t--; }\r
 163         *end = t+1;\r
 164 }\r
 165 \r
 166 static SQInteger _string_strip(HSQUIRRELVM v)\r
 167 {\r
 168         const SQChar *str,*start,*end;\r
 169         sq_getstring(v,2,&str);\r
 170         SQInteger len = sq_getsize(v,2);\r
 171         __strip_l(str,&start);\r
 172         __strip_r(str,len,&end);\r
 173         sq_pushstring(v,start,end - start);\r
 174         return 1;\r
 175 }\r
 176 \r
 177 static SQInteger _string_lstrip(HSQUIRRELVM v)\r
 178 {\r
 179         const SQChar *str,*start;\r
 180         sq_getstring(v,2,&str);\r
 181         __strip_l(str,&start);\r
 182         sq_pushstring(v,start,-1);\r
 183         return 1;\r
 184 }\r
 185 \r
 186 static SQInteger _string_rstrip(HSQUIRRELVM v)\r
 187 {\r
 188         const SQChar *str,*end;\r
 189         sq_getstring(v,2,&str);\r
 190         SQInteger len = sq_getsize(v,2);\r
 191         __strip_r(str,len,&end);\r
 192         sq_pushstring(v,str,end - str);\r
 193         return 1;\r
 194 }\r
 195 \r
 196 static SQInteger _string_split(HSQUIRRELVM v)\r
 197 {\r
 198         const SQChar *str,*seps;\r
 199         SQChar *stemp,*tok;\r
 200         sq_getstring(v,2,&str);\r
 201         sq_getstring(v,3,&seps);\r
 202         if(sq_getsize(v,3) == 0) return sq_throwerror(v,_SC("empty separators string"));\r
 203         SQInteger memsize = (sq_getsize(v,2)+1)*sizeof(SQChar);\r
 204         stemp = sq_getscratchpad(v,memsize);\r
 205         memcpy(stemp,str,memsize);\r
 206         tok = scstrtok(stemp,seps);\r
 207         sq_newarray(v,0);\r
 208         while( tok != NULL ) {\r
 209                 sq_pushstring(v,tok,-1);\r
 210                 sq_arrayappend(v,-2);\r
 211                 tok = scstrtok( NULL, seps );\r
 212         }\r
 213         return 1;\r
 214 }\r
 215 \r
 216 #define SETUP_REX(v) \\r
 217         SQRex *self = NULL; \\r
 218         sq_getinstanceup(v,1,(SQUserPointer *)&self,0); \r
 219 \r
 220 static SQInteger _rexobj_releasehook(SQUserPointer p, SQInteger size)\r
 221 {\r
 222         SQRex *self = ((SQRex *)p);\r
 223         sqstd_rex_free(self);\r
 224         return 1;\r
 225 }\r
 226 \r
 227 static SQInteger _regexp_match(HSQUIRRELVM v)\r
 228 {\r
 229         SETUP_REX(v);\r
 230         const SQChar *str;\r
 231         sq_getstring(v,2,&str);\r
 232         if(sqstd_rex_match(self,str) == SQTrue)\r
 233         {\r
 234                 sq_pushbool(v,SQTrue);\r
 235                 return 1;\r
 236         }\r
 237         sq_pushbool(v,SQFalse);\r
 238         return 1;\r
 239 }\r
 240 \r
 241 static void _addrexmatch(HSQUIRRELVM v,const SQChar *str,const SQChar *begin,const SQChar *end)\r
 242 {\r
 243         sq_newtable(v);\r
 244         sq_pushstring(v,_SC("begin"),-1);\r
 245         sq_pushinteger(v,begin - str);\r
 246         sq_rawset(v,-3);\r
 247         sq_pushstring(v,_SC("end"),-1);\r
 248         sq_pushinteger(v,end - str);\r
 249         sq_rawset(v,-3);\r
 250 }\r
 251 \r
 252 static SQInteger _regexp_search(HSQUIRRELVM v)\r
 253 {\r
 254         SETUP_REX(v);\r
 255         const SQChar *str,*begin,*end;\r
 256         SQInteger start = 0;\r
 257         sq_getstring(v,2,&str);\r
 258         if(sq_gettop(v) > 2) sq_getinteger(v,3,&start);\r
 259         if(sqstd_rex_search(self,str+start,&begin,&end) == SQTrue) {\r
 260                 _addrexmatch(v,str,begin,end);\r
 261                 return 1;\r
 262         }\r
 263         return 0;\r
 264 }\r
 265 \r
 266 static SQInteger _regexp_capture(HSQUIRRELVM v)\r
 267 {\r
 268         SETUP_REX(v);\r
 269         const SQChar *str,*begin,*end;\r
 270         SQInteger start = 0;\r
 271         sq_getstring(v,2,&str);\r
 272         if(sq_gettop(v) > 2) sq_getinteger(v,3,&start);\r
 273         if(sqstd_rex_search(self,str+start,&begin,&end) == SQTrue) {\r
 274                 SQInteger n = sqstd_rex_getsubexpcount(self);\r
 275                 SQRexMatch match;\r
 276                 sq_newarray(v,0);\r
 277                 for(SQInteger i = 0;i < n; i++) {\r
 278                         sqstd_rex_getsubexp(self,i,&match);\r
 279                         if(match.len > 0)\r
 280                                 _addrexmatch(v,str,match.begin,match.begin+match.len);\r
 281                         else\r
 282                                 _addrexmatch(v,str,str,str); //empty match\r
 283                         sq_arrayappend(v,-2);\r
 284                 }\r
 285                 return 1;\r
 286         }\r
 287         return 0;\r
 288 }\r
 289 \r
 290 static SQInteger _regexp_subexpcount(HSQUIRRELVM v)\r
 291 {\r
 292         SETUP_REX(v);\r
 293         sq_pushinteger(v,sqstd_rex_getsubexpcount(self));\r
 294         return 1;\r
 295 }\r
 296 \r
 297 static SQInteger _regexp_constructor(HSQUIRRELVM v)\r
 298 {\r
 299         const SQChar *error,*pattern;\r
 300         sq_getstring(v,2,&pattern);\r
 301         SQRex *rex = sqstd_rex_compile(pattern,&error);\r
 302         if(!rex) return sq_throwerror(v,error);\r
 303         sq_setinstanceup(v,1,rex);\r
 304         sq_setreleasehook(v,1,_rexobj_releasehook);\r
 305         return 0;\r
 306 }\r
 307 \r
 308 static SQInteger _regexp__typeof(HSQUIRRELVM v)\r
 309 {\r
 310         sq_pushstring(v,_SC("regexp"),-1);\r
 311         return 1;\r
 312 }\r
 313 \r
 314 #define _DECL_REX_FUNC(name,nparams,pmask) {_SC(#name),_regexp_##name,nparams,pmask}\r
 315 static SQRegFunction rexobj_funcs[]={\r
 316         _DECL_REX_FUNC(constructor,2,_SC(".s")),\r
 317         _DECL_REX_FUNC(search,-2,_SC("xsn")),\r
 318         _DECL_REX_FUNC(match,2,_SC("xs")),\r
 319         _DECL_REX_FUNC(capture,-2,_SC("xsn")),\r
 320         _DECL_REX_FUNC(subexpcount,1,_SC("x")),\r
 321         _DECL_REX_FUNC(_typeof,1,_SC("x")),\r
 322         {0,0}\r
 323 };\r
 324 \r
 325 #define _DECL_FUNC(name,nparams,pmask) {_SC(#name),_string_##name,nparams,pmask}\r
 326 static SQRegFunction stringlib_funcs[]={\r
 327         _DECL_FUNC(format,-2,_SC(".s")),\r
 328         _DECL_FUNC(strip,2,_SC(".s")),\r
 329         _DECL_FUNC(lstrip,2,_SC(".s")),\r
 330         _DECL_FUNC(rstrip,2,_SC(".s")),\r
 331         _DECL_FUNC(split,3,_SC(".ss")),\r
 332         {0,0}\r
 333 };\r
 334 \r
 335 \r
 336 SQInteger sqstd_register_stringlib(HSQUIRRELVM v)\r
 337 {\r
 338         sq_pushstring(v,_SC("regexp"),-1);\r
 339         sq_newclass(v,SQFalse);\r
 340         SQInteger i = 0;\r
 341         while(rexobj_funcs[i].name != 0) {\r
 342                 SQRegFunction &f = rexobj_funcs[i];\r
 343                 sq_pushstring(v,f.name,-1);\r
 344                 sq_newclosure(v,f.f,0);\r
 345                 sq_setparamscheck(v,f.nparamscheck,f.typemask);\r
 346                 sq_setnativeclosurename(v,-1,f.name);\r
 347                 sq_createslot(v,-3);\r
 348                 i++;\r
 349         }\r
 350         sq_createslot(v,-3);\r
 351 \r
 352         i = 0;\r
 353         while(stringlib_funcs[i].name!=0)\r
 354         {\r
 355                 sq_pushstring(v,stringlib_funcs[i].name,-1);\r
 356                 sq_newclosure(v,stringlib_funcs[i].f,0);\r
 357                 sq_setparamscheck(v,stringlib_funcs[i].nparamscheck,stringlib_funcs[i].typemask);\r
 358                 sq_setnativeclosurename(v,-1,stringlib_funcs[i].name);\r
 359                 sq_createslot(v,-3);\r
 360                 i++;\r
 361         }\r
 362         return 1;\r
 363 }\r