src/base/utility/FBaseUtil_ScannerImpl.cpp

   1 #include <sys/stat.h>
   2 #include <stdio.h>
   3 #include <errno.h>
   4 #include <wchar.h>
   5
   6 #include <FBaseCharacter.h>
   7 #include <FBaseInt8.h>
   8 #include <FBaseInteger.h>
   9 #include <FBaseShort.h>
  10 #include <FBaseLong.h>
  11 #include <FBaseLongLong.h>
  12 #include <FBaseFloat.h>
  13 #include <FBaseDouble.h>
  14 #include <FBaseResult.h>
  15 #include "FBaseUtil_ScannerImpl.h"
  16 #include "FBaseUtilRegularExpression.h"
  17 #include <FBaseColArrayList.h>
  18 #include <FBaseSysLog.h>
  19 #include "FBaseUtil_RegularExpressionImpl.h"
  20 #include "FBase_StringConverter.h"
  21 #include "FBaseUtil_IcuConverter.h"
  22 #include "FBase_NativeError.h"
  23
  24 #define ANY_PATTERN L"\\s*[^\\s]*"
  25 #define DEFAULT_DELIMITER_PATTERN L"\\s*"
  26 //#define DEFAULT_LINE_SEPARATOR_PATTERN L".*(\r\n|[\u000A\n\r\u2028\u2029\u0085])|.+$"
  27 #define COMPLETE_LINE_PATTERN L".*(\r\n|[\u000A\n\r\u2028\u2029\u0085])|.+$"
  28 #define DEFAULT_LINE_SEPARATOR_PATTERN L"[\u000A\n\r\u2028\u2029\u0085]*"
  29
  30
  31 #define DEFAULT_GROUP_SEPARATOR L","
  32 #define DEFAULT_DECIMAL_SEPARATOR L"."
  33 #define DEFAULT_NEGATIVE_PREFIX L"-"
  34
  35 using namespace Tizen::Base::Collection;
  36 using namespace Tizen::Base::Utility;
  37 using namespace Tizen::Base;
  38
  39 namespace Tizen { namespace Base { namespace Utility
  40 {
  41 _ScannerImpl::_ScannerImpl(void)
  42         :__radix(10),
  43          __delimiter(DEFAULT_DELIMITER_PATTERN),
  44          __pParseStr(null),
  45          __isAllocatedOnHeap(false),
  46          __position(0)
  47 {
  48
  49 }
  50
  51 _ScannerImpl::~_ScannerImpl()
  52 {
  53         if(__isAllocatedOnHeap == true)
  54         {
  55                 delete[] __pParseStr;
  56                 __pParseStr = null;
  57         }
  58 }
  59
  60 result _ScannerImpl::Construct(const String& str)
  61 {
  62         result r = E_SUCCESS;
  63         __pParseStr = str.GetPointer();
  64         return r;
  65 }
  66
  67 result _ScannerImpl::Construct(const String& filePath, const String& encodingScheme)
  68 {
  69         result r = E_SUCCESS;
  70         FILE* pFile = null;
  71         char* pFilePath = null;
  72         bool res =  false;
  73         _ICUConverter converter;
  74         struct stat st;
  75         off_t fileSize = 0;
  76         char* buffer = null;
  77         int retVal = 0;
  78         long int readCnt = 0;
  79
  80         pFilePath = _StringConverter::CopyToCharArrayN(filePath);
  81         SysTryReturnResult(NID_BASE_UTIL, pFilePath != null, GetLastResult(), "File path length < 0 or E_OUT_OF_MEMORY");
  82
  83         res = converter.OpenConverter(encodingScheme);
  84         r = GetLastResult();
  85         SysTryCatch(NID_BASE_UTIL, res == true, , r, "[%s] Encoding scheme not supported", GetErrorMessage(r));
  86
  87         pFile = fopen(pFilePath, "r");
  88         SysTryCatch(NID_BASE_UTIL, pFile != null, r = E_FILE_NOT_FOUND, E_FILE_NOT_FOUND,
  89                         "[%s] Failed to open the file.", GetErrorMessage(__ConvertNativeErrorToResult(errno)));
  90
  91         retVal = stat(pFilePath, &st);
  92         SysTryCatch(NID_BASE_UTIL, retVal != 0, r = E_IO, E_IO,
  93                         "[%s] Failed to get information about the file.", GetErrorMessage(__ConvertNativeErrorToResult(errno)));
  94
  95         fileSize = st.st_size + 1;      // +1 for null-terminated string
  96
  97         buffer = static_cast<char*>(calloc(fileSize, sizeof(char)));
  98         SysTryCatch(NID_BASE_UTIL, buffer != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY]");
  99         readCnt = fread(buffer, 1, fileSize - 1, pFile);
 100
 101         if (readCnt < fileSize)
 102         {
 103                 int ret = ferror(pFile);
 104                 SysTryCatch(NID_BASE_UTIL, ret != 0, r = E_IO, E_IO, "[%s] Failed to perform read operation.", GetErrorMessage(E_IO));
 105         }
 106
 107         __pParseStr = converter.ConvertToUcharN(buffer, fileSize);
 108         SysTryCatch(NID_BASE_UTIL, __pParseStr != null, r = E_IO, E_IO , "[%s] charcater conversion failed.", GetErrorMessage(E_IO));
 109         __isAllocatedOnHeap = true;
 110
 111 CATCH:
 112         delete[] pFilePath;
 113         pFilePath = null;
 114
 115         delete[] buffer;
 116         buffer = null;
 117
 118         if(pFile != null)
 119         {
 120                 fclose(pFile);
 121                 pFile = null;
 122         }
 123
 124         return r;
 125 }
 126
 127 bool _ScannerImpl::HasNextToken(void)
 128 {
 129         String pattern(ANY_PATTERN);
 130         return HasNextToken(pattern);
 131 }
 132
 133 bool _ScannerImpl::HasNextToken(const RegularExpression& pattern)
 134 {
 135         String patStr(pattern.GetPattern());
 136         return HasNextToken(patStr);
 137 }
 138
 139 bool _ScannerImpl::HasNextToken(const String& pattern)
 140 {
 141         result r = E_SUCCESS;
 142         String token;
 143         int length = 0;
 144
 145         r = GetNextToken(pattern, token, length);
 146         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_DATA_NOT_FOUND, "[%s] Can not get the next token", GetErrorMessage(E_DATA_NOT_FOUND));
 147
 148         return true;
 149 }
 150
 151
 152 result _ScannerImpl::GetNextToken(String& nextStr)
 153 {
 154         result r = E_SUCCESS;
 155         String pattern(ANY_PATTERN);
 156         int length = 0;
 157
 158         r = GetNextToken(pattern, nextStr, length);
 159         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_DATA_NOT_ENOUGH, "Can not get the next token");
 160
 161         __position =  __position + length;
 162
 163         return r;
 164 }
 165
 166 result _ScannerImpl::GetNextToken(const RegularExpression& pattern, String& nextStr)
 167 {
 168         String patStr(pattern.GetPattern());
 169         return GetNextToken(patStr, nextStr);
 170 }
 171
 172 result _ScannerImpl::GetNextToken(const String& pattern, String& nextStr)
 173 {
 174         result r = E_SUCCESS;
 175         int length = 0;
 176
 177         String str1;
 178         String str2;
 179         String anyPattern(ANY_PATTERN);
 180
 181         r = GetNextToken(anyPattern, str1, length);
 182         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS || r == E_DATA_NOT_ENOUGH, E_DATA_NOT_ENOUGH, "Input has no remaining tokens");
 183
 184         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_DATA_NOT_FOUND, "The next token does not match to the pattern");
 185
 186         r = GetNextToken(pattern, str2, length);
 187         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS || r == E_DATA_NOT_ENOUGH, E_DATA_NOT_ENOUGH, "Input has no remaining tokens");
 188
 189         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_DATA_NOT_FOUND, "The next token does not match to the pattern");
 190
 191         if(str1 == str2)
 192         {
 193                 nextStr = str1;
 194                 __position =  __position + length;
 195         }
 196
 197         return r;
 198 }
 199
 200 result _ScannerImpl::GetNextSignedChar(signed char& nextSignedChar)
 201 {
 202         return GetNextSignedChar(nextSignedChar, __radix);
 203 }
 204
 205 result _ScannerImpl::GetNextSignedChar(signed char& nextSignedChar, int radix)
 206 {
 207         result r = E_SUCCESS;
 208         String out;
 209         int length = 0;
 210         char ch = 0x00;
 211         String pattern(ANY_PATTERN);
 212
 213         r = GetNextToken(pattern, out, length);
 214         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS || r == E_DATA_NOT_ENOUGH, E_DATA_NOT_ENOUGH, "Input has no remaining tokens");
 215
 216         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_NUM_FORMAT, "Can not parse the token to signed char");
 217 /*      if(out.GetLength() > 1)
 218         {
 219                 return E_OPERATION_FAILED;
 220         }*/
 221
 222         r = Int8::Parse(out, radix, ch);
 223         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_NUM_FORMAT, "Can not parse the token to signed char");
 224
 225         nextSignedChar = static_cast<signed char>(ch);
 226         __position =  __position + length;
 227
 228         return r;
 229 }
 230
 231 bool _ScannerImpl::IsNextTokenConvertibleToSignedChar(void)
 232 {
 233         return IsNextTokenConvertibleToSignedChar(__radix);
 234 }
 235
 236 bool _ScannerImpl::IsNextTokenConvertibleToSignedChar(int radix)
 237 {
 238         result r = E_SUCCESS;
 239         String out;
 240         int length = 0;
 241         String pattern(ANY_PATTERN);
 242         char ch = 0;
 243
 244         r = GetNextToken(pattern, out, length);
 245         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_NUM_FORMAT, "[%s] Can not get the next token as signed char", GetErrorMessage(E_NUM_FORMAT));
 246
 247 /*      if(out.GetLength() > 1)
 248         {
 249                 return E_OPERATION_FAILED;
 250         }*/
 251
 252         r = Int8::Parse(out, radix, ch);
 253         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_NUM_FORMAT, "[%s] Can not parse the token to signed char", GetErrorMessage(E_NUM_FORMAT));
 254
 255         return true;
 256 }
 257
 258 result _ScannerImpl::GetNextInt(int& nextInt)
 259 {
 260         return GetNextInt(nextInt, __radix);
 261 }
 262
 263 result _ScannerImpl::GetNextInt(int& nextInt, int radix)
 264 {
 265         result r = E_SUCCESS;
 266         String out;
 267         int length = 0;
 268         String pattern(ANY_PATTERN);
 269
 270         r = GetNextToken(pattern, out, length);
 271         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS || r == E_DATA_NOT_ENOUGH, E_DATA_NOT_ENOUGH, "Input has no remaining tokens");
 272
 273         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_NUM_FORMAT, "Can not parse the token to integer");
 274
 275         out.Replace(DEFAULT_GROUP_SEPARATOR, L"");
 276         r = Integer::Parse(out, radix, nextInt);
 277         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_NUM_FORMAT, "Can not parse the token to integer");
 278
 279         __position =  __position + length;
 280
 281         return r;
 282 }
 283
 284 bool _ScannerImpl::IsNextTokenConvertibleToInt(void)
 285 {
 286         return IsNextTokenConvertibleToInt(__radix);
 287 }
 288
 289 bool _ScannerImpl::IsNextTokenConvertibleToInt(int radix)
 290 {
 291         result r = E_SUCCESS;
 292         String out;
 293         int val = 0;
 294         int length = 0;
 295         String pattern(ANY_PATTERN);
 296
 297         r = GetNextToken(pattern, out, length);
 298         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_NUM_FORMAT, "[%s] Can not get the next token as integer", GetErrorMessage(E_NUM_FORMAT));
 299
 300         out.Replace(DEFAULT_GROUP_SEPARATOR, L"");
 301         r = Integer::Parse(out, radix, val);
 302         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_NUM_FORMAT, "[%s] Can not get next Integer", GetErrorMessage(E_NUM_FORMAT));
 303
 304         return true;
 305 }
 306
 307 result _ScannerImpl::GetNextShort(short& nextShort)
 308 {
 309         return GetNextShort(nextShort, __radix);
 310 }
 311
 312 result _ScannerImpl::GetNextShort(short& nextShort, int radix)
 313 {
 314         result r = E_SUCCESS;
 315         String out;
 316         int length = 0;
 317         String pattern(ANY_PATTERN);
 318
 319         r = GetNextToken(pattern, out, length);
 320         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS || r == E_DATA_NOT_ENOUGH, E_DATA_NOT_ENOUGH, "Input has no remaining tokens");
 321
 322         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_NUM_FORMAT, "Can not parse the token to short");
 323
 324         out.Replace(DEFAULT_GROUP_SEPARATOR, L"");
 325         r = Short::Parse(out, radix, nextShort);
 326         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_NUM_FORMAT, "Can not parse the token to short");
 327
 328         __position =  __position + length;
 329
 330         return r;
 331 }
 332
 333 bool _ScannerImpl::IsNextTokenConvertibleToShort(void)
 334 {
 335         return IsNextTokenConvertibleToShort(__radix);
 336 }
 337
 338 bool _ScannerImpl::IsNextTokenConvertibleToShort(int radix)
 339 {
 340         result r = E_SUCCESS;
 341         String out;
 342         short val = 0;
 343         int length = 0;
 344         String pattern(ANY_PATTERN);
 345
 346         r = GetNextToken(pattern, out, length);
 347         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_NUM_FORMAT, "[%s] Can not get next token as short", GetErrorMessage(E_NUM_FORMAT));
 348
 349         out.Replace(DEFAULT_GROUP_SEPARATOR, L"");
 350         r = Short::Parse(out, radix, val);
 351         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_NUM_FORMAT, "[%s] Can not get next short", GetErrorMessage(E_NUM_FORMAT));
 352
 353         return true;
 354 }
 355
 356 result _ScannerImpl::GetNextLongLong(long long& nextLongLong)
 357 {
 358         result r = E_SUCCESS;
 359         String out;
 360         int length = 0;
 361         String pattern(ANY_PATTERN);
 362
 363         r = GetNextToken(pattern, out, length);
 364         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS || r == E_DATA_NOT_ENOUGH, E_DATA_NOT_ENOUGH, "Input has no remaining tokens");
 365
 366         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_NUM_FORMAT, "Can not parse the token to long long");
 367
 368         out.Replace(DEFAULT_GROUP_SEPARATOR, L"");
 369         r = LongLong::Parse(out, nextLongLong);
 370         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_NUM_FORMAT, "Can not parse the token to long long");
 371
 372         __position =  __position + length;
 373
 374         return r;
 375 }
 376
 377 bool _ScannerImpl::IsNextTokenConvertibleToLongLong(void)
 378 {
 379         result r = E_SUCCESS;
 380         String out;
 381         long long val = 0;
 382         int length = 0;
 383         String pattern(ANY_PATTERN);
 384
 385         r = GetNextToken(pattern, out, length);
 386         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_NUM_FORMAT, "[E_NUM_FORMAT] Can not get next token as long long");
 387
 388         r = LongLong::Parse(out, val);
 389         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_NUM_FORMAT, "[E_NUM_FORMAT] Can not get next long long");
 390
 391         return true;
 392 }
 393
 394 result _ScannerImpl::GetNextFloat(float& nextFloat)
 395 {
 396         result r = E_SUCCESS;
 397         String out;
 398         int length = 0;
 399         String pattern(ANY_PATTERN);
 400
 401         r = GetNextToken(pattern, out, length);
 402         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS || r == E_DATA_NOT_ENOUGH, E_DATA_NOT_ENOUGH, "Input has no remaining tokens");
 403
 404         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_NUM_FORMAT, "Can not parse the token to float");
 405
 406         out.Replace(DEFAULT_GROUP_SEPARATOR, L"");
 407         r = Float::Parse(out, nextFloat);
 408         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_NUM_FORMAT, "Can not parse the token to float");
 409
 410         __position =  __position + length;
 411
 412         return r;
 413 }
 414
 415
 416 bool _ScannerImpl::IsNextTokenConvertibleToFloat(void)
 417 {
 418         result r = E_SUCCESS;
 419         String out;
 420         RegularExpression re;
 421         float val = 0.0f;
 422         int length = 0;
 423         String pattern(ANY_PATTERN);
 424
 425         r = GetNextToken(pattern, out, length);
 426         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_NUM_FORMAT, "[%s] Can not get next token as float", GetErrorMessage(E_NUM_FORMAT));
 427
 428         out.Replace(DEFAULT_GROUP_SEPARATOR, L"");
 429         r = Float::Parse(out, val);
 430         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_NUM_FORMAT, "[%s] Can not get next float", GetErrorMessage(E_NUM_FORMAT));
 431
 432         return true;
 433 }
 434
 435 result _ScannerImpl::GetNextDouble(double& nextDouble)
 436 {
 437         result r = E_SUCCESS;
 438         String out;
 439         int length = 0;
 440         String pattern(ANY_PATTERN);
 441
 442         r = GetNextToken(pattern, out, length);
 443         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS || r == E_DATA_NOT_ENOUGH, E_DATA_NOT_ENOUGH, "Input has no remaining tokens");
 444
 445         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_NUM_FORMAT, "Can not parse the token to double");
 446
 447         out.Replace(DEFAULT_GROUP_SEPARATOR, L"");
 448         r = Double::Parse(out, nextDouble);
 449         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_NUM_FORMAT, "Can not parse the token to double");
 450
 451         __position =  __position + length;
 452
 453         return r;
 454 }
 455
 456 bool _ScannerImpl::IsNextTokenConvertibleToDouble(void)
 457 {
 458         result r = E_SUCCESS;
 459         String out;
 460         double val = 0.0f;
 461         int length = 0;
 462         String pattern(ANY_PATTERN);
 463
 464         r = GetNextToken(pattern, out, length);
 465         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_NUM_FORMAT, "[%s] Can not get next token as double", GetErrorMessage(E_NUM_FORMAT));
 466
 467         out.Replace(DEFAULT_GROUP_SEPARATOR, L"");
 468         r = Double::Parse(out, val);
 469         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_NUM_FORMAT, "[%s] Can not get next token", GetErrorMessage(E_NUM_FORMAT));
 470
 471         return true;
 472 }
 473
 474 result _ScannerImpl::GetNextBool(bool& nextBool)
 475 {
 476         result r = E_SUCCESS;
 477         String out;
 478         int length = 0;
 479         String pattern(ANY_PATTERN);
 480
 481         r = GetNextToken(pattern, out, length);
 482         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS || r == E_DATA_NOT_ENOUGH, E_DATA_NOT_ENOUGH, "Input has no remaining tokens");
 483
 484         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_NUM_FORMAT, "Can not parse the token to bool");
 485
 486         String temp;
 487         r = out.ToUpper(temp);
 488         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_NUM_FORMAT, "Can not get next bool");
 489
 490         if(!temp.CompareTo(L"TRUE"))
 491         {
 492                 nextBool = true;
 493                 __position =  __position + length;
 494         }
 495         else if(!temp.CompareTo(L"FALSE"))
 496         {
 497                 nextBool = false;
 498                 __position =  __position + length;
 499         }
 500         else
 501         {
 502                 r =  E_NUM_FORMAT;
 503         }
 504
 505         return r;
 506 }
 507
 508 bool _ScannerImpl::IsNextTokenConvertibleToBool(void)
 509 {
 510         result r = E_SUCCESS;
 511         String out;
 512         bool ret = false;
 513         int length = 0;
 514         String pattern(ANY_PATTERN);
 515
 516         r = GetNextToken(pattern, out, length);
 517         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_NUM_FORMAT, "[%s] Can not get next token as bool", GetErrorMessage(E_NUM_FORMAT));
 518
 519         String temp;
 520         out.ToUpper(temp);
 521         if((!temp.CompareTo(L"TRUE")) || (!temp.CompareTo(L"FALSE")))
 522         {
 523                 ret = true;
 524         }
 525         else
 526         {
 527                 ret = false;
 528         }
 529
 530         return ret;
 531 }
 532
 533 bool _ScannerImpl::HasNextLine(void)
 534 {
 535         result r = E_SUCCESS;
 536         String pattern(DEFAULT_LINE_SEPARATOR_PATTERN);
 537         RegularExpression regex;
 538         ArrayList matchedStrList;
 539         bool res = false;
 540
 541         r = regex.Construct(pattern, REGEX_UNICODE);
 542         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_DATA_NOT_ENOUGH, "[%s] Regular expression construction failed", GetErrorMessage(E_DATA_NOT_ENOUGH));
 543
 544         r = matchedStrList.Construct();
 545         SysTryReturn(NID_BASE_UTIL, r == E_SUCCESS, false, E_DATA_NOT_ENOUGH, "[%s] Arraylist construction failed", GetErrorMessage(E_DATA_NOT_ENOUGH));
 546
 547         res = regex.Match(String(__pParseStr + __position), false, &matchedStrList);
 548         SysTryReturn(NID_BASE_UTIL, res == true, false, E_DATA_NOT_ENOUGH, "[%s] Match Failed", GetErrorMessage(E_DATA_NOT_ENOUGH));
 549
 550         return res;
 551 }
 552
 553
 554 result _ScannerImpl::GetNextLine(String& nextLine)
 555 {
 556         result r = E_SUCCESS;
 557         String pattern(COMPLETE_LINE_PATTERN);
 558         RegularExpression regex;
 559         ArrayList matchedStrList;
 560         bool res = false;
 561         int matches = 0;
 562
 563         r = regex.Construct(pattern, REGEX_UNICODE);
 564         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_DATA_NOT_ENOUGH, "Regular expression construction failed");
 565
 566         r = matchedStrList.Construct();
 567         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_DATA_NOT_ENOUGH, "Arraylist construction failed");
 568
 569         res = regex.Match(String(__pParseStr + __position), false, &matchedStrList);
 570         SysTryReturnResult(NID_BASE_UTIL, res == true, E_DATA_NOT_ENOUGH, "Match Failed");
 571
 572         matches = matchedStrList.GetCount();
 573         if(matches > 0)
 574         {
 575                 String temp = *(String *)matchedStrList.GetAt(0);
 576                 __position = __position + temp.GetLength();
 577
 578                 RegularExpression re;
 579                 r = re.Construct(DEFAULT_LINE_SEPARATOR_PATTERN, REGEX_UNICODE);
 580                 re.Replace(temp, L"", true);
 581                 nextLine = temp;
 582
 583                 matchedStrList.RemoveAll();
 584         }
 585
 586         return r;
 587
 588 }
 589
 590 result _ScannerImpl::FindInLine(const String& str, String& MatchedStr)
 591 {
 592         result r = E_SUCCESS;
 593         _RegularExpressionImpl regex;
 594         ArrayList matchedStrList;
 595         bool res = false;
 596         int matches = 0;
 597
 598         r = regex.Construct(str, REGEX_UNICODE);
 599         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_DATA_NOT_FOUND, "Regular expression construction failed");
 600
 601         r = matchedStrList.Construct();
 602         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_DATA_NOT_FOUND, "Arraylist construction failed");
 603
 604         res = regex.Match(String(__pParseStr + __position), false, &matchedStrList);
 605         SysTryReturnResult(NID_BASE_UTIL, res == true, E_DATA_NOT_FOUND, "Match Failed");
 606
 607         matches = matchedStrList.GetCount();
 608         if(matches > 0)
 609         {
 610                 MatchedStr = *(String *)matchedStrList.GetAt(0);
 611                 int matchEnd = regex.GetLastMatchEnd();
 612                 __position = __position + matchEnd;
 613                 matchedStrList.RemoveAll();
 614         }
 615         return r;
 616
 617 }
 618
 619 result _ScannerImpl::FindInLine(const RegularExpression& pattern, String& MatchedStr)
 620 {
 621         String patStr(pattern.GetPattern());
 622         return FindInLine(patStr, MatchedStr);
 623 }
 624
 625 void _ScannerImpl::Skip(const String& str)
 626 {
 627         result r = E_SUCCESS;
 628         RegularExpression regex;
 629         ArrayList matchedStrList;
 630         bool res = false;
 631         int matches = 0;
 632
 633         r = regex.Construct(str, REGEX_UNICODE);
 634         SysTryCatch(NID_BASE_UTIL, r == E_SUCCESS, , r, "[%s] Regular expression construction failed", GetErrorMessage(r));
 635
 636         r = matchedStrList.Construct();
 637         SysTryCatch(NID_BASE_UTIL, r == E_SUCCESS, , r, "[%s] ArrayList construction failed", GetErrorMessage(r));
 638
 639         res = regex.Match(String(__pParseStr + __position), false, &matchedStrList);
 640         SysTryCatch(NID_BASE_UTIL, res == true, , E_SYSTEM, "[%s] Regular expression match failed", GetErrorMessage(E_SYSTEM));
 641
 642         matches = matchedStrList.GetCount();
 643          if(matches > 0)
 644          {
 645                         String temp = *(String *)matchedStrList.GetAt(0);
 646                         int length = temp.GetLength();
 647                         const wchar_t* wstr1 = temp.GetPointer();
 648                         const wchar_t* wstr2 = __pParseStr + __position;
 649                         bool isSame = true;
 650
 651                         while(*wstr1 != 0x0000)
 652                         {
 653                                 if(*wstr1++ != *wstr2++)
 654                                 {
 655                                         isSame =  false;
 656                                         break;
 657                                 }
 658                         }
 659                         if(isSame == true)
 660                         {
 661                                 __position = __position + length;
 662                         }
 663                         matchedStrList.RemoveAll();
 664
 665                         //Skip if there is any delimiters before the next token
 666                         RegularExpression re;
 667                         r = re.Construct(DEFAULT_DELIMITER_PATTERN, REGEX_UNICODE);
 668                         res = re.Match(String(__pParseStr + __position), false, &matchedStrList);
 669                         matches = matchedStrList.GetCount();
 670                          if(matches > 0)
 671                          {
 672                                         String temp = *(String *)matchedStrList.GetAt(0);
 673                                         int length = temp.GetLength();
 674                                         __position = __position + length;
 675                                         matchedStrList.RemoveAll();
 676                          }
 677
 678          }
 679
 680 CATCH:
 681         return;
 682 }
 683
 684 void _ScannerImpl::Skip(const RegularExpression& pattern)
 685 {
 686         String patStr(pattern.GetPattern());
 687         return Skip(patStr);
 688 }
 689
 690 int _ScannerImpl::GetRadix(void)
 691 {
 692         return __radix;
 693 }
 694
 695 String _ScannerImpl::GetDelimiter(void)
 696 {
 697         return __delimiter;
 698 }
 699
 700 void _ScannerImpl::SetDelimiter(const String& delimiter)
 701 {
 702         __delimiter = delimiter;
 703 }
 704
 705 void _ScannerImpl::SetDelimiter(const RegularExpression& pattern)
 706 {
 707         __delimiter = pattern.GetPattern();
 708 }
 709
 710 void _ScannerImpl::SetRadix(int radix)
 711 {
 712         if(((radix == Character::RADIX_BINARY) || (radix == Character::RADIX_OCTAL) ||
 713                 (radix == Character::RADIX_DECIMAL) || (radix == Character::RADIX_HEXADECIMAL)))
 714         {
 715                 __radix = radix;
 716         }
 717 }
 718
 719 result _ScannerImpl::GetNextToken(const String& pattern, String& ret, int& length)
 720 {
 721         result r = E_SUCCESS;
 722         SysTryReturnResult(NID_BASE_UTIL, __pParseStr != null, E_DATA_NOT_ENOUGH, "Input has no remaining tokens.");
 723         SysTryReturnResult(NID_BASE_UTIL, *__pParseStr != 0x0000, E_DATA_NOT_ENOUGH, "Input has no remaining tokens.");
 724
 725         RegularExpression regex;
 726         ArrayList matchedStrList;
 727         bool res = false;
 728         int matches = 0;
 729         String regPattern(pattern);
 730
 731         regPattern.Append(__delimiter);
 732
 733         r = regex.Construct(regPattern, REGEX_UNICODE);
 734         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_OPERATION_FAILED, "Regular expression construction failed");
 735
 736         r = matchedStrList.Construct();
 737         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_OPERATION_FAILED, "Arraylist construction failed");
 738
 739         res = regex.Match(String(__pParseStr + __position), false, &matchedStrList);
 740         SysTryReturnResult(NID_BASE_UTIL, res == true, E_OPERATION_FAILED, "Match Failed");
 741
 742         matches = matchedStrList.GetCount();
 743         if(matches > 0)
 744         {
 745                 String temp = *(String *)matchedStrList.GetAt(0);
 746                 length = temp.GetLength();
 747                 RegularExpression re;
 748                 r = re.Construct(__delimiter, REGEX_UNICODE);
 749                 re.Replace(temp, L"", true);
 750                 ret = temp;
 751                 matchedStrList.RemoveAll();
 752         }
 753
 754         return r;
 755 }
 756
 757 result _ScannerImpl::GetNextMatchingString(const String& pattern, String& ret, int& length)
 758 {
 759         result r = E_SUCCESS;
 760         RegularExpression regex;
 761         ArrayList matchedStrList;
 762
 763         bool res = false;
 764         int matches = 0;
 765         String nextToken;
 766         String matchToken;
 767
 768         String strPat(ANY_PATTERN);
 769         strPat.Append(DEFAULT_DELIMITER_PATTERN);
 770
 771         r = regex.Construct(strPat, REGEX_UNICODE);
 772         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_OPERATION_FAILED, "Regular expression construction failed");
 773
 774         r = matchedStrList.Construct();
 775         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_OPERATION_FAILED, "Arraylist construction failed");
 776
 777         res = regex.Match(String(__pParseStr + __position), false, &matchedStrList);
 778
 779         SysTryReturnResult(NID_BASE_UTIL, res == true, E_OPERATION_FAILED, "Match Failed");
 780
 781         matches = matchedStrList.GetCount();
 782         if(matches > 0)
 783         {
 784                 nextToken = *(String *)matchedStrList.GetAt(0);
 785                 matchedStrList.RemoveAll();
 786         }
 787
 788         strPat = pattern;
 789         strPat.Append(DEFAULT_DELIMITER_PATTERN);
 790         r = regex.Construct(strPat, REGEX_UNICODE);
 791         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_OPERATION_FAILED, "Regular expression construction failed");
 792
 793         r = matchedStrList.Construct();
 794         SysTryReturnResult(NID_BASE_UTIL, r == E_SUCCESS, E_OPERATION_FAILED, "Arraylist construction failed");
 795
 796         res = regex.Match(String(__pParseStr + __position), false, &matchedStrList);
 797         SysTryReturnResult(NID_BASE_UTIL, res == true, E_OPERATION_FAILED, "Match Failed");
 798
 799         matches = matchedStrList.GetCount();
 800         if(matches > 0)
 801         {
 802                 matchToken = *(String *)matchedStrList.GetAt(0);
 803                 matchedStrList.RemoveAll();
 804
 805                 if((nextToken == matchToken) == true)
 806                 {
 807                         length = matchToken.GetLength();
 808                         RegularExpression re;
 809                         r = re.Construct(DEFAULT_DELIMITER_PATTERN, REGEX_UNICODE);
 810                         re.Replace(matchToken, L"", true);
 811                         ret = matchToken;
 812                 }
 813                 else
 814                 {
 815                         r = E_OPERATION_FAILED;
 816                 }
 817         }
 818
 819
 820         return r;
 821 }
 822 }}}   // Osp::Base::Utility