char **messages = (char **)NULL;

int trace_size = 0;

trace_size = 0;

while (trace[trace_size]) trace_size++;

messages = backtrace_symbols(trace, trace_size);

printf("%s\n", header);

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

printf("%s\n", messages[i]);

}

//free(messages);

/* Restore all old hooks */

__malloc_hook = old_malloc_hook;

__free_hook = old_free_hook;

/* Call recursively */

free (ptr);

/* we call malloc here, so protect it too. */

//printf ("freed pointer %p\n", ptr);

if (malloced.find(ptr) == malloced.end()) {

/*fprintf(stderr, "INVALID FREE\n");

} else

malloced.erase(ptr);

/* Restore our own hooks */

__malloc_hook = my_malloc_hook;

__free_hook = my_free_hook;

old_malloc_hook = __malloc_hook;

old_free_hook = __free_hook;

__malloc_hook = my_malloc_hook;

__free_hook = my_free_hook;

unsigned long hash = 0;

while (*trace) {

hash = (hash<<1) ^ (hash>>63) ^ (unsigned long)*trace;

trace++;

}

return hash;

/* Restore all old hooks */

__malloc_hook = old_malloc_hook;

__free_hook = old_free_hook;

map<long, void**> hashToReal;

map<long, int> counts;

map<void *, void **>::iterator it = malloced.begin();

while (it!=malloced.end()) {

long hash = gethash(it->second);

hashToReal[hash] = it->second;

if (counts.find(hash) == counts.end())

counts[hash] = 1;

else

counts[hash]++;

it++;

}

vector<pair<int, long> > sorting;

map<long, int>::iterator countit = counts.begin();

while (countit!=counts.end()) {

sorting.push_back(pair<int, long>(countit->second, countit->first));

countit++;

}

// sort

bool done = false;

while (!done) {

done = true;

for (int i=0;i<sorting.size()-1;i++) {

if (sorting[i].first < sorting[i+1].first) {

pair<int, long> t = sorting[i];

sorting[i] = sorting[i+1];

sorting[i+1] = t;

done = false;

}

}

}

for (int i=0;i<sorting.size();i++) {

long hash = sorting[i].second;

int count = sorting[i].first;

char header[256];

sprintf(header, "--------------------------- LEAKED %d", count);

print_stackframe(header, hashToReal[hash]);

}

printf("TEST %s ", filename);

struct stat results;

if (!stat(filename, &results) == 0) {

printf("Cannot stat file! '%s'\n", filename);

return false;

}

int size = results.st_size;

FILE *file = fopen( filename, "rb" );

/* if we open as text, the number of bytes read may be > the size we read */

if( !file ) {

printf("Unable to open file! '%s'\n", filename);

return false;

}

char *buffer = new char[size+1];

long actualRead = fread(buffer,1,size,file);

buffer[actualRead]=0;

buffer[size]=0;

fclose(file);

CTinyJS s;

registerFunctions(&s);

registerMathFunctions(&s);

s.root->addChild("result", new CScriptVar("0",SCRIPTVAR_INTEGER));

try {

s.execute(buffer);

} catch (CScriptException *e) {

printf("ERROR: %s\n", e->text.c_str());

}

bool pass = s.root->getParameter("result")->getBool();

if (pass)

printf("PASS\n");

else {

char fn[64];

sprintf(fn, "%s.fail.js", filename);

FILE *f = fopen(fn, "wt");

if (f) {

std::ostringstream symbols;

s.root->getJSON(symbols);

fprintf(f, "%s", symbols.str().c_str());

fclose(f);

}

printf("FAIL - symbols written to %s\n", fn);

}

delete[] buffer;

return pass;

{

#ifdef MTRACE

mtrace();

#endif

#ifdef INSANE_MEMORY_DEBUG

memtracing_init();

#endif

printf("TinyJS test runner\n");

printf("USAGE:\n");

printf(" ./run_tests test.js : run just one test\n");

printf(" ./run_tests : run all tests\n");

if (argc==2) {

return !run_test(argv[1]);

}

int test_num = 1;

int count = 0;

int passed = 0;

while (test_num<1000) {

char fn[32];

sprintf(fn, "tests/test%03d.js", test_num);

// check if the file exists - if not, assume we're at the end of our tests

FILE *f = fopen(fn,"r");

if (!f) break;

fclose(f);

if (run_test(fn))

passed++;

count++;

test_num++;

}

printf("Done. %d tests, %d pass, %d fail\n", count, passed, count-passed);

#ifdef INSANE_MEMORY_DEBUG

memtracing_kill();

#endif

#ifdef _DEBUG

#ifdef _WIN32

_CrtDumpMemoryLeaks();

#endif

#endif

#ifdef MTRACE

muntrace();

#endif

return 0;