libs/stringio.h

   1 /*
   2 Copyright (C) 2001-2006, William Joseph.
   3 All Rights Reserved.
   4
   5 This file is part of GtkRadiant.
   6
   7 GtkRadiant is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 GtkRadiant is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GtkRadiant; if not, write to the Free Software
  19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20 */
  21
  22 #if !defined (INCLUDED_STRINGIO_H)
  23 #define INCLUDED_STRINGIO_H
  24
  25 #include <stdlib.h>
  26 #include <cctype>
  27
  28 #include "generic/vector.h"
  29 #include "iscriplib.h"
  30 #include "string/string.h"
  31 #include "generic/callback.h"
  32
  33 inline float string_read_float(const char* string)
  34 {
  35   return static_cast<float>(atof(string));
  36 }
  37
  38 inline int string_read_int(const char* string)
  39 {
  40   return atoi(string);
  41 }
  42
  43 inline bool char_is_whitespace(char c)
  44 {
  45   return c == ' ' || c == '\t';
  46 }
  47
  48 inline const char* string_remove_whitespace(const char* string)
  49 {
  50   for(;;)
  51   {
  52     if(!char_is_whitespace(*string))
  53     {
  54       break;
  55     }
  56     ++string;
  57   }
  58   return string;
  59 }
  60
  61 inline const char* string_remove_zeros(const char* string)
  62 {
  63   for(;;)
  64   {
  65     char c = *string;
  66     if(c != '0')
  67     {
  68       break;
  69     }
  70     ++string;
  71   }
  72   return string;
  73 }
  74
  75 inline const char* string_remove_sign(const char* string)
  76 {
  77   if(*string == '-' || *string == '+') // signed zero - acceptable
  78   {
  79     return ++string;
  80   }
  81   return string;
  82 }
  83
  84 inline bool string_is_unsigned_zero(const char* string)
  85 {
  86   for(;*string != '\0'; ++string)
  87   {
  88     if(*string != '0')
  89     {
  90       return false;
  91     }
  92   }
  93   return true;
  94 }
  95
  96 inline bool string_is_signed_zero(const char* string)
  97 {
  98   return string_is_unsigned_zero(string_remove_sign(string));
  99 }
 100
 101 //[whitespaces][+|-][nnnnn][.nnnnn][e|E[+|-]nnnn]
 102 //(where whitespaces are any tab or space character and nnnnn may be any number of digits)
 103 inline bool string_is_float_zero(const char* string)
 104 {
 105   string = string_remove_whitespace(string);
 106   if(string_empty(string))
 107   {
 108     return false;
 109   }
 110
 111   string = string_remove_sign(string);
 112   if(string_empty(string))
 113   {
 114     // no whole number or fraction part
 115     return false;
 116   }
 117
 118   // whole-number part
 119   string = string_remove_zeros(string);
 120   if(string_empty(string))
 121   {
 122     // no fraction or exponent
 123     return true;
 124   }
 125   if(*string == '.')
 126   {
 127     // fraction part
 128     if(*string++ != '0')
 129     {
 130       // invalid fraction
 131       return false;
 132     }
 133     string = string_remove_zeros(++string);
 134     if(string_empty(string))
 135     {
 136       // no exponent
 137       return true;
 138     }
 139   }
 140   if(*string == 'e' || *string == 'E')
 141   {
 142     // exponent part
 143     string = string_remove_sign(++string);
 144     if(*string++ != '0')
 145     {
 146       // invalid exponent
 147       return false;
 148     }
 149     string = string_remove_zeros(++string);
 150     if(string_empty(string))
 151     {
 152       // no trailing whitespace
 153       return true;
 154     }
 155   }
 156   string = string_remove_whitespace(string);
 157   return string_empty(string);
 158 }
 159
 160 inline double buffer_parse_floating_literal(const char*& buffer)
 161 {
 162   return strtod(buffer, const_cast<char**>(&buffer));
 163 }
 164
 165 inline int buffer_parse_signed_decimal_integer_literal(const char*& buffer)
 166 {
 167   return strtol(buffer, const_cast<char**>(&buffer), 10);
 168 }
 169
 170 inline int buffer_parse_unsigned_decimal_integer_literal(const char*& buffer)
 171 {
 172   return strtoul(buffer, const_cast<char**>(&buffer), 10);
 173 }
 174
 175 // [+|-][nnnnn][.nnnnn][e|E[+|-]nnnnn]
 176 inline bool string_parse_float(const char* string, float& f)
 177 {
 178   if(string_empty(string))
 179   {
 180     return false;
 181   }
 182   f = float(buffer_parse_floating_literal(string));
 183   return string_empty(string);
 184 }
 185
 186 // format same as float
 187 inline bool string_parse_double(const char* string, double& f)
 188 {
 189   if(string_empty(string))
 190   {
 191     return false;
 192   }
 193   f = buffer_parse_floating_literal(string);
 194   return string_empty(string);
 195 }
 196
 197 // <float><space><float><space><float>
 198 template<typename Element>
 199 inline bool string_parse_vector3(const char* string, BasicVector3<Element>& v)
 200 {
 201   if(string_empty(string) || *string == ' ')
 202   {
 203     return false;
 204   }
 205   v[0] = float(buffer_parse_floating_literal(string));
 206   if(*string++ != ' ')
 207   {
 208     return false;
 209   }
 210   v[1] = float(buffer_parse_floating_literal(string));
 211   if(*string++ != ' ')
 212   {
 213     return false;
 214   }
 215   v[2] = float(buffer_parse_floating_literal(string));
 216   return string_empty(string);
 217 }
 218
 219 template<typename Float>
 220 inline bool string_parse_vector(const char* string, Float* first, Float* last)
 221 {
 222   if(first != last && (string_empty(string) || *string == ' '))
 223   {
 224     return false;
 225   }
 226   for(;;)
 227   {
 228     *first = float(buffer_parse_floating_literal(string));
 229     if(++first == last)
 230     {
 231       return string_empty(string);
 232     }
 233     if(*string++ != ' ')
 234     {
 235       return false;
 236     }
 237   }
 238 }
 239
 240 // decimal signed integer
 241 inline bool string_parse_int(const char* string, int& i)
 242 {
 243   if(string_empty(string))
 244   {
 245     return false;
 246   }
 247   i = buffer_parse_signed_decimal_integer_literal(string);
 248   return string_empty(string);
 249 }
 250
 251 // decimal unsigned integer
 252 inline bool string_parse_size(const char* string, std::size_t& i)
 253 {
 254   if(string_empty(string))
 255   {
 256     return false;
 257   }
 258   i = buffer_parse_unsigned_decimal_integer_literal(string);
 259   return string_empty(string);
 260 }
 261
 262
 263 #define RETURN_FALSE_IF_FAIL(expression) if(!expression) return false; else
 264
 265 inline void Tokeniser_unexpectedError(Tokeniser& tokeniser, const char* token, const char* expected)
 266 {
 267   globalErrorStream() << Unsigned(tokeniser.getLine()) << ":" << Unsigned(tokeniser.getColumn()) << ": parse error at '" << (token != 0 ? token : "#EOF") << "': expected '" << expected << "'\n";
 268 }
 269
 270
 271 inline bool Tokeniser_getFloat(Tokeniser& tokeniser, float& f)
 272 {
 273   const char* token = tokeniser.getToken();
 274   if(token != 0 && string_parse_float(token, f))
 275   {
 276     return true;
 277   }
 278   Tokeniser_unexpectedError(tokeniser, token, "#number");
 279   return false;
 280 }
 281
 282 inline bool Tokeniser_getDouble(Tokeniser& tokeniser, double& f)
 283 {
 284   const char* token = tokeniser.getToken();
 285   if(token != 0 && string_parse_double(token, f))
 286   {
 287     return true;
 288   }
 289   Tokeniser_unexpectedError(tokeniser, token, "#number");
 290   return false;
 291 }
 292
 293 inline bool Tokeniser_getInteger(Tokeniser& tokeniser, int& i)
 294 {
 295   const char* token = tokeniser.getToken();
 296   if(token != 0 && string_parse_int(token, i))
 297   {
 298     return true;
 299   }
 300   Tokeniser_unexpectedError(tokeniser, token, "#integer");
 301   return false;
 302 }
 303
 304 inline bool Tokeniser_getSize(Tokeniser& tokeniser, std::size_t& i)
 305 {
 306   const char* token = tokeniser.getToken();
 307   if(token != 0 && string_parse_size(token, i))
 308   {
 309     return true;
 310   }
 311   Tokeniser_unexpectedError(tokeniser, token, "#unsigned-integer");
 312   return false;
 313 }
 314
 315 inline bool Tokeniser_parseToken(Tokeniser& tokeniser, const char* expected)
 316 {
 317   const char* token = tokeniser.getToken();
 318   if(token != 0 && string_equal(token, expected))
 319   {
 320     return true;
 321   }
 322   Tokeniser_unexpectedError(tokeniser, token, expected);
 323   return false;
 324 }
 325
 326 inline bool Tokeniser_nextTokenIsDigit(Tokeniser& tokeniser)
 327 {
 328   const char* token = tokeniser.getToken();
 329   if(token == 0)
 330   {
 331     return false;
 332   }
 333   char c = *token;
 334   tokeniser.ungetToken();
 335   return std::isdigit(c) != 0;
 336 }
 337
 338 template<typename TextOutputStreamType>
 339 inline TextOutputStreamType& ostream_write(TextOutputStreamType& outputStream, const Vector3& v)
 340 {
 341   return outputStream << '(' << v.x() << ' ' << v.y() << ' ' << v.z() << ')';
 342 }
 343
 344
 345
 346
 347 inline void CopiedString_importString(CopiedString& self, const char* string)
 348 {
 349   self = string;
 350 }
 351 typedef ReferenceCaller1<CopiedString, const char*, CopiedString_importString> CopiedStringImportStringCaller;
 352 inline void CopiedString_exportString(const CopiedString& self, const StringImportCallback& importer)
 353 {
 354   importer(self.c_str());
 355 }
 356 typedef ConstReferenceCaller1<CopiedString, const StringImportCallback&, CopiedString_exportString> CopiedStringExportStringCaller;
 357
 358 inline void Bool_importString(bool& self, const char* string)
 359 {
 360   self = string_equal(string, "true");
 361 }
 362 typedef ReferenceCaller1<bool, const char*, Bool_importString> BoolImportStringCaller;
 363 inline void Bool_exportString(const bool& self, const StringImportCallback& importer)
 364 {
 365   importer(self ? "true" : "false");
 366 }
 367 typedef ConstReferenceCaller1<bool, const StringImportCallback&, Bool_exportString> BoolExportStringCaller;
 368
 369 inline void Int_importString(int& self, const char* string)
 370 {
 371   if(!string_parse_int(string, self))
 372   {
 373     self = 0;
 374   }
 375 }
 376 typedef ReferenceCaller1<int, const char*, Int_importString> IntImportStringCaller;
 377 inline void Int_exportString(const int& self, const StringImportCallback& importer)
 378 {
 379   char buffer[16];
 380   sprintf(buffer, "%d", self);
 381   importer(buffer);
 382 }
 383 typedef ConstReferenceCaller1<int, const StringImportCallback&, Int_exportString> IntExportStringCaller;
 384
 385 inline void Size_importString(std::size_t& self, const char* string)
 386 {
 387   int i;
 388   if(string_parse_int(string, i) && i >= 0)
 389   {
 390     self = i;
 391   }
 392   else
 393   {
 394     self = 0;
 395   }
 396 }
 397 typedef ReferenceCaller1<std::size_t, const char*, Size_importString> SizeImportStringCaller;
 398 inline void Size_exportString(const std::size_t& self, const StringImportCallback& importer)
 399 {
 400   char buffer[16];
 401   sprintf(buffer, "%u", Unsigned(self));
 402   importer(buffer);
 403 }
 404 typedef ConstReferenceCaller1<std::size_t, const StringImportCallback&, Size_exportString> SizeExportStringCaller;
 405
 406 inline void Float_importString(float& self, const char* string)
 407 {
 408   if(!string_parse_float(string, self))
 409   {
 410     self = 0;
 411   }
 412 }
 413 typedef ReferenceCaller1<float, const char*, Float_importString> FloatImportStringCaller;
 414 inline void Float_exportString(const float& self, const StringImportCallback& importer)
 415 {
 416   char buffer[16];
 417   sprintf(buffer, "%g", self);
 418   importer(buffer);
 419 }
 420 typedef ConstReferenceCaller1<float, const StringImportCallback&, Float_exportString> FloatExportStringCaller;
 421
 422 inline void Vector3_importString(Vector3& self, const char* string)
 423 {
 424   if(!string_parse_vector3(string, self))
 425   {
 426     self = Vector3(0, 0, 0);
 427   }
 428 }
 429 typedef ReferenceCaller1<Vector3, const char*, Vector3_importString> Vector3ImportStringCaller;
 430 inline void Vector3_exportString(const Vector3& self, const StringImportCallback& importer)
 431 {
 432   char buffer[64];
 433   sprintf(buffer, "%g %g %g", self[0], self[1], self[2]);
 434   importer(buffer);
 435 }
 436 typedef ConstReferenceCaller1<Vector3, const StringImportCallback&, Vector3_exportString> Vector3ExportStringCaller;
 437
 438
 439
 440 template<typename FirstArgument, typename Caller, typename FirstConversion>
 441 class ImportConvert1
 442 {
 443 public:
 444   static void thunk(void* environment, FirstArgument firstArgument)
 445   {
 446     Caller::thunk(environment, FirstConversion(firstArgument));
 447   }
 448 };
 449
 450
 451 class BoolFromString
 452 {
 453   bool m_value;
 454 public:
 455   BoolFromString(const char* string)
 456   {
 457     Bool_importString(m_value, string);
 458   }
 459   operator bool() const
 460   {
 461     return m_value;
 462   }
 463 };
 464
 465 inline void Bool_toString(const StringImportCallback& self, bool value)
 466 {
 467   Bool_exportString(value, self);
 468 }
 469 typedef ConstReferenceCaller1<StringImportCallback, bool, Bool_toString> BoolToString;
 470
 471
 472 template<typename Caller>
 473 inline StringImportCallback makeBoolStringImportCallback(const Caller& caller)
 474 {
 475   return StringImportCallback(caller.getEnvironment(), ImportConvert1<StringImportCallback::first_argument_type, Caller, BoolFromString>::thunk);
 476 }
 477
 478 template<typename Caller>
 479 inline StringExportCallback makeBoolStringExportCallback(const Caller& caller)
 480 {
 481   return StringExportCallback(caller.getEnvironment(), ImportConvert1<StringExportCallback::first_argument_type, Caller, BoolToString>::thunk);
 482 }
 483
 484
 485 class IntFromString
 486 {
 487   int m_value;
 488 public:
 489   IntFromString(const char* string)
 490   {
 491     Int_importString(m_value, string);
 492   }
 493   operator int() const
 494   {
 495     return m_value;
 496   }
 497 };
 498
 499 inline void Int_toString(const StringImportCallback& self, int value)
 500 {
 501   Int_exportString(value, self);
 502 }
 503 typedef ConstReferenceCaller1<StringImportCallback, int, Int_toString> IntToString;
 504
 505
 506 template<typename Caller>
 507 inline StringImportCallback makeIntStringImportCallback(const Caller& caller)
 508 {
 509   return StringImportCallback(caller.getEnvironment(), ImportConvert1<StringImportCallback::first_argument_type, Caller, IntFromString>::thunk);
 510 }
 511
 512 template<typename Caller>
 513 inline StringExportCallback makeIntStringExportCallback(const Caller& caller)
 514 {
 515   return StringExportCallback(caller.getEnvironment(), ImportConvert1<StringExportCallback::first_argument_type, Caller, IntToString>::thunk);
 516 }
 517
 518
 519
 520 class SizeFromString
 521 {
 522   std::size_t m_value;
 523 public:
 524   SizeFromString(const char* string)
 525   {
 526     Size_importString(m_value, string);
 527   }
 528   operator std::size_t() const
 529   {
 530     return m_value;
 531   }
 532 };
 533
 534 inline void Size_toString(const StringImportCallback& self, std::size_t value)
 535 {
 536   Size_exportString(value, self);
 537 }
 538 typedef ConstReferenceCaller1<StringImportCallback, std::size_t, Size_toString> SizeToString;
 539
 540
 541 template<typename Caller>
 542 inline StringImportCallback makeSizeStringImportCallback(const Caller& caller)
 543 {
 544   return StringImportCallback(caller.getEnvironment(), ImportConvert1<StringImportCallback::first_argument_type, Caller, SizeFromString>::thunk);
 545 }
 546
 547 template<typename Caller>
 548 inline StringExportCallback makeSizeStringExportCallback(const Caller& caller)
 549 {
 550   return StringExportCallback(caller.getEnvironment(), ImportConvert1<StringExportCallback::first_argument_type, Caller, SizeToString>::thunk);
 551 }
 552
 553 #endif