git.saurik.com Git - apple/javascriptcore.git/blob

1 /*

3 *

4 * This library is free software; you can redistribute it and/or

5 * modify it under the terms of the GNU Library General Public

6 * License as published by the Free Software Foundation; either

7 * version 2 of the License, or (at your option) any later version.

8 *

9 * This library is distributed in the hope that it will be useful,

10 * but WITHOUT ANY WARRANTY; without even the implied warranty of

11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

12 * Library General Public License for more details.

13 *

14 * You should have received a copy of the GNU Library General Public License

15 * along with this library; see the file COPYING.LIB. If not, write to

16 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

17 * Boston, MA 02110-1301, USA.

18 *

19 */

21 #include "config.h"

22 #include "RegExp.h"

24 #include <wtf/CurrentTime.h>

25 #include "InitializeThreading.h"

26 #include "JSCInlines.h"

27 #include "JSGlobalObject.h"

28 #include <errno.h>

29 #include <stdio.h>

30 #include <stdlib.h>

31 #include <string.h>

32 #include <wtf/text/StringBuilder.h>

34 #if !OS(WINDOWS)

35 #include <unistd.h>

36 #endif

38 #if HAVE(SYS_TIME_H)

39 #include <sys/time.h>

40 #endif

42 #if COMPILER(MSVC)

43 #include <crtdbg.h>

44 #include <mmsystem.h>

45 #include <windows.h>

46 #endif

48 namespace JSC {

49 WTF_IMPORT extern const struct HashTable globalObjectTable;

50 }

 const int MaxLineLength = 100 * 1024;

54 using namespace JSC;

55 using namespace WTF;

57 struct CommandLine {

58 CommandLine()

         : interactive(false)

         , verbose(false)

61 {

62 }

64 bool interactive;

65 bool verbose;

66 Vector<String> arguments;

67 Vector<String> files;

68 };

70 class StopWatch {

71 public:

72 void start();

73 void stop();

74 long getElapsedMS(); // call stop() first

76 private:

77 double m_startTime;

78 double m_stopTime;

79 };

 void StopWatch::start()

82 {

83 m_startTime = monotonicallyIncreasingTime();

84 }

 void StopWatch::stop()

87 {

88 m_stopTime = monotonicallyIncreasingTime();

89 }

 long StopWatch::getElapsedMS()

92 {

     return static_cast<long>((m_stopTime - m_startTime) * 1000);

94 }

96 struct RegExpTest {

97 RegExpTest()

         : offset(0)

         , result(0)

100 {

101 }

102

103 String subject;

104 int offset;

105 int result;

     Vector<int, 32> expectVector;

107 };

108

109 class GlobalObject : public JSGlobalObject {

110 private:

     GlobalObject(VM&, Structure*, const Vector<String>& arguments);

112

113 public:

114 typedef JSGlobalObject Base;

115

     static GlobalObject* create(VM& vm, Structure* structure, const Vector<String>& arguments)

117 {

         GlobalObject* globalObject = new (NotNull, allocateCell<GlobalObject>(vm.heap)) GlobalObject(vm, structure, arguments);

         vm.heap.addFinalizer(globalObject, destroy);

120 return globalObject;

121 }

122

123 DECLARE_INFO;

124

125 static const bool needsDestructor = false;

126

     static Structure* createStructure(VM& vm, JSValue prototype)

128 {

         return Structure::create(vm, 0, prototype, TypeInfo(GlobalObjectType, StructureFlags), info());

130 }

131

132 protected:

     void finishCreation(VM& vm, const Vector<String>& arguments)

134 {

         Base::finishCreation(vm);

136 UNUSED_PARAM(arguments);

137 }

138 };

139

 const ClassInfo GlobalObject::s_info = { "global", &JSGlobalObject::s_info, &globalObjectTable, CREATE_METHOD_TABLE(GlobalObject) };

141

 GlobalObject::GlobalObject(VM& vm, Structure* structure, const Vector<String>& arguments)

     : JSGlobalObject(vm, structure)

144 {

145 finishCreation(vm, arguments);

146 }

147

148 // Use SEH for Release builds only to get rid of the crash report dialog

149 // (luckily the same tests fail in Release and Debug builds so far). Need to

150 // be in a separate main function because the realMain function requires object

151 // unwinding.

152

153 #if COMPILER(MSVC) && !defined(_DEBUG)

154 #define TRY __try {

155 #define EXCEPT(x) } __except (EXCEPTION_EXECUTE_HANDLER) { x; }

156 #else

157 #define TRY

158 #define EXCEPT(x)

159 #endif

160

 int realMain(int argc, char** argv);

162

 int main(int argc, char** argv)

164 {

165 #if OS(WINDOWS)

166 #if defined(_M_X64) || defined(__x86_64__)

167 // The VS2013 runtime has a bug where it mis-detects AVX-capable processors

168 // if the feature has been disabled in firmware. This causes us to crash

169 // in some of the math functions. For now, we disable those optimizations

170 // because Microsoft is not going to fix the problem in VS2013.

171 // FIXME: http://webkit.org/b/141449: Remove this workaround when we switch to VS2015+.

172 _set_FMA3_enable(0);

173 #endif

174

175 // Cygwin calls ::SetErrorMode(SEM_FAILCRITICALERRORS), which we will inherit. This is bad for

176 // testing/debugging, as it causes the post-mortem debugger not to be invoked. We reset the

177 // error mode here to work around Cygwin's behavior. See <http://webkit.org/b/55222>.

     ::SetErrorMode(0);

179

180 #if defined(_DEBUG)

181 _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);

182 _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);

183 _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);

184 _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE);

185 _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);

186 _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);

187 #endif

188

189 timeBeginPeriod(1);

190 #endif

191

192 // Initialize JSC before getting VM.

193 JSC::initializeThreading();

194

195 // We can't use destructors in the following code because it uses Windows

196 // Structured Exception Handling

197 int res = 0;

198 TRY

         res = realMain(argc, argv);

     EXCEPT(res = 3)

201 return res;

202 }

203

 static bool testOneRegExp(VM& vm, RegExp* regexp, RegExpTest* regExpTest, bool verbose, unsigned int lineNumber)

205 {

206 bool result = true;

     Vector<int, 32> outVector;

     outVector.resize(regExpTest->expectVector.size());

     int matchResult = regexp->match(vm, regExpTest->subject, regExpTest->offset, outVector);

210

     if (matchResult != regExpTest->result) {

212 result = false;

213 if (verbose)

             printf("Line %d: results mismatch - expected %d got %d\n", lineNumber, regExpTest->result, matchResult);

     } else if (matchResult != -1) {

         if (outVector.size() != regExpTest->expectVector.size()) {

217 result = false;

218 if (verbose) {

219 #if OS(WINDOWS)

                 printf("Line %d: output vector size mismatch - expected %Iu got %Iu\n", lineNumber, regExpTest->expectVector.size(), outVector.size());

221 #else

                 printf("Line %d: output vector size mismatch - expected %zu got %zu\n", lineNumber, regExpTest->expectVector.size(), outVector.size());

223 #endif

224 }

         } else if (outVector.size() % 2) {

226 result = false;

227 if (verbose) {

228 #if OS(WINDOWS)

                 printf("Line %d: output vector size is odd (%Iu), should be even\n", lineNumber, outVector.size());

230 #else

                 printf("Line %d: output vector size is odd (%zu), should be even\n", lineNumber, outVector.size());

232 #endif

233 }

234 } else {

235 // Check in pairs since the first value of the pair could be -1 in which case the second doesn't matter.

             size_t pairCount = outVector.size() / 2;

             for (size_t i = 0; i < pairCount; ++i) {

                 size_t startIndex = i*2;

                 if (outVector[startIndex] != regExpTest->expectVector[startIndex]) {

240 result = false;

241 if (verbose) {

242 #if OS(WINDOWS)

                         printf("Line %d: output vector mismatch at index %Iu - expected %d got %d\n", lineNumber, startIndex, regExpTest->expectVector[startIndex], outVector[startIndex]);

244 #else

                         printf("Line %d: output vector mismatch at index %zu - expected %d got %d\n", lineNumber, startIndex, regExpTest->expectVector[startIndex], outVector[startIndex]);

246 #endif

247 }

248 }

                 if ((i > 0) && (regExpTest->expectVector[startIndex] != -1) && (outVector[startIndex+1] != regExpTest->expectVector[startIndex+1])) {

250 result = false;

251 if (verbose) {

252 #if OS(WINDOWS)

                         printf("Line %d: output vector mismatch at index %Iu - expected %d got %d\n", lineNumber, startIndex + 1, regExpTest->expectVector[startIndex + 1], outVector[startIndex + 1]);

254 #else

                         printf("Line %d: output vector mismatch at index %zu - expected %d got %d\n", lineNumber, startIndex + 1, regExpTest->expectVector[startIndex + 1], outVector[startIndex + 1]);

256 #endif

257 }

258 }

259 }

260 }

261 }

262

263 return result;

264 }

265

 static int scanString(char* buffer, int bufferLength, StringBuilder& builder, char termChar)

267 {

268 bool escape = false;

269

     for (int i = 0; i < bufferLength; ++i) {

271 UChar c = buffer[i];

272

273 if (escape) {

274 switch (c) {

275 case '0':

276 c = '\0';

277 break;

278 case 'a':

                 c = '\a';

280 break;

281 case 'b':

                 c = '\b';

283 break;

284 case 'f':

                 c = '\f';

286 break;

287 case 'n':

                 c = '\n';

289 break;

290 case 'r':

                 c = '\r';

292 break;

293 case 't':

                 c = '\t';

295 break;

296 case 'v':

                 c = '\v';

298 break;

             case '\\':

                 c = '\\';

301 break;

302 case '?':

                 c = '\?';

304 break;

305 case 'u':

                 if ((i + 4) >= bufferLength)

307 return -1;

308 unsigned int charValue;

                 if (sscanf(buffer+i+1, "%04x", &charValue) != 1)

310 return -1;

                 c = static_cast<UChar>(charValue);

312 i += 4;

313 break;

314 }

315

316 builder.append(c);

317 escape = false;

318 } else {

319 if (c == termChar)

320 return i;

321

             if (c == '\\')

323 escape = true;

324 else

325 builder.append(c);

326 }

327 }

328

329 return -1;

330 }

331

 static RegExp* parseRegExpLine(VM& vm, char* line, int lineLength)

333 {

334 StringBuilder pattern;

335

     if (line[0] != '/')

337 return 0;

338

     int i = scanString(line + 1, lineLength - 1, pattern, '/') + 1;

340

     if ((i >= lineLength) || (line[i] != '/'))

342 return 0;

343

344 ++i;

345

     return RegExp::create(vm, pattern.toString(), regExpFlags(line + i));

347 }

348

 static RegExpTest* parseTestLine(char* line, int lineLength)

350 {

351 StringBuilder subjectString;

352

     if ((line[0] != ' ') || (line[1] != '"'))

354 return 0;

355

     int i = scanString(line + 2, lineLength - 2, subjectString, '"') + 2;

357

     if ((i >= (lineLength - 2)) || (line[i] != '"') || (line[i+1] != ',') || (line[i+2] != ' '))

359 return 0;

360

361 i += 3;

362

363 int offset;

364

     if (sscanf(line + i, "%d, ", &offset) != 1)

366 return 0;

367

     while (line[i] && line[i] != ' ')

369 ++i;

370

371 ++i;

372

373 int matchResult;

374

     if (sscanf(line + i, "%d, ", &matchResult) != 1)

376 return 0;

377

     while (line[i] && line[i] != ' ')

379 ++i;

380

381 ++i;

382

     if (line[i++] != '(')

384 return 0;

385

386 int start, end;

387

     RegExpTest* result = new RegExpTest();

389

     result->subject = subjectString.toString();

391 result->offset = offset;

392 result->result = matchResult;

393

     while (line[i] && line[i] != ')') {

         if (sscanf(line + i, "%d, %d", &start, &end) != 2) {

396 delete result;

397 return 0;

398 }

399

         result->expectVector.append(start);

         result->expectVector.append(end);

402

         while (line[i] && (line[i] != ',') && (line[i] != ')'))

404 i++;

405 i++;

         while (line[i] && (line[i] != ',') && (line[i] != ')'))

407 i++;

408

         if (line[i] == ')')

410 break;

         if (!line[i] || (line[i] != ',')) {

412 delete result;

413 return 0;

414 }

415 i++;

416 }

417

418 return result;

419 }

420

 static bool runFromFiles(GlobalObject* globalObject, const Vector<String>& files, bool verbose)

422 {

423 String script;

424 String fileName;

425 Vector<char> scriptBuffer;

426 unsigned tests = 0;

427 unsigned failures = 0;

     char* lineBuffer = new char[MaxLineLength + 1];

429

     VM& vm = globalObject->vm();

431

432 bool success = true;

     for (size_t i = 0; i < files.size(); i++) {

         FILE* testCasesFile = fopen(files[i].utf8().data(), "rb");

435

436 if (!testCasesFile) {

             printf("Unable to open test data file \"%s\"\n", files[i].utf8().data());

438 continue;

439 }

440

441 RegExp* regexp = 0;

442 size_t lineLength = 0;

         char* linePtr = 0;

444 unsigned int lineNumber = 0;

445

         while ((linePtr = fgets(&lineBuffer[0], MaxLineLength, testCasesFile))) {

447 lineLength = strlen(linePtr);

             if (linePtr[lineLength - 1] == '\n') {

                 linePtr[lineLength - 1] = '\0';

450 --lineLength;

451 }

452 ++lineNumber;

453

             if (linePtr[0] == '#')

455 continue;

456

             if (linePtr[0] == '/') {

                 regexp = parseRegExpLine(vm, linePtr, lineLength);

             } else if (linePtr[0] == ' ') {

                 RegExpTest* regExpTest = parseTestLine(linePtr, lineLength);

461

462 if (regexp && regExpTest) {

463 ++tests;

                     if (!testOneRegExp(vm, regexp, regExpTest, verbose, lineNumber)) {

465 failures++;

                         printf("Failure on line %u\n", lineNumber);

467 }

468 }

469

470 if (regExpTest)

471 delete regExpTest;

472 }

473 }

474

475 fclose(testCasesFile);

476 }

477

478 if (failures)

         printf("%u tests run, %u failures\n", tests, failures);

480 else

         printf("%u tests passed\n", tests);

482

483 delete[] lineBuffer;

484

     vm.dumpSampleData(globalObject->globalExec());

486 #if ENABLE(REGEXP_TRACING)

487 vm.dumpRegExpTrace();

488 #endif

489 return success;

490 }

491

492 #define RUNNING_FROM_XCODE 0

493

 static NO_RETURN void printUsageStatement(bool help = false)

495 {

     fprintf(stderr, "Usage: regexp_test [options] file\n");

     fprintf(stderr, "  -h|--help  Prints this help message\n");

     fprintf(stderr, "  -v|--verbose  Verbose output\n");

499

     exit(help ? EXIT_SUCCESS : EXIT_FAILURE);

501 }

502

 static void parseArguments(int argc, char** argv, CommandLine& options)

504 {

505 int i = 1;

     for (; i < argc; ++i) {

         const char* arg = argv[i];

         if (!strcmp(arg, "-h") || !strcmp(arg, "--help"))

509 printUsageStatement(true);

         if (!strcmp(arg, "-v") || !strcmp(arg, "--verbose"))

511 options.verbose = true;

512 else

             options.files.append(argv[i]);

514 }

515

     for (; i < argc; ++i)

         options.arguments.append(argv[i]);

518 }

519

 int realMain(int argc, char** argv)

521 {

     VM* vm = &VM::create(LargeHeap).leakRef();

523 JSLockHolder locker(vm);

524

525 CommandLine options;

     parseArguments(argc, argv, options);

527

     GlobalObject* globalObject = GlobalObject::create(*vm, GlobalObject::createStructure(*vm, jsNull()), options.arguments);

     bool success = runFromFiles(globalObject, options.files, options.verbose);

530

     return success ? 0 : 3;

532 }

533

534 #if OS(WINDOWS)

 extern "C" __declspec(dllexport) int WINAPI dllLauncherEntryPoint(int argc, const char* argv[])

536 {

     return main(argc, const_cast<char**>(argv));

538 }

539 #endif