int main() {
// print seed
std::cout << "Random seed: " << rd.get_seed() << std::endl;
// options
CGAL::Quadratic_program_options options;
options.set_auto_validation(true);
// generate a set of small random qp's
for (int i=0; i<tries; ++i) {
// first choose dimensions
int n = rd.get_int(1,max_dim);
int m = rd.get_int(1,max_dim);
// construct matrix D as C^T C, for C randomly chosen with n columns
int k = rd.get_int (1, 2*n); // number of rows of C
std::vector<std::vector<int> > C (k, std::vector<int>(n, 0));
for (int j=0; j<k+n; ++j) // sparse C
C[rd.get_int(0, k)][rd.get_int(0,n)] =
rd.get_int(-max_entry, max_entry);
// now fill the program
Program p;
// A
for (int j=0; j<n+m; ++j)
p.set_a (rd.get_int(0,n), rd.get_int(0,m), rd.get_double());
// b, r
for (int i=0; i<m/2; ++i) {
p.set_b (rd.get_int(0,m), rd.get_double());
p.set_r (rd.get_int(0,m), random_rel());
}
// fl, l, fu, u
for (int j=0; j<n; ++j) {
double l = rd.get_double();
double u = rd.get_double();
if (l > u) std::swap (l, u);
p.set_l(j, rd.get_bool(), l);
p.set_u(j, rd.get_bool(), u);
}
// D
for (int i=0; i<n; ++i)
for (int j=0; j<=i; ++j) {
double entry = 0;
for (int l=0; l<k; ++l)
entry += C[l][i] * C[l][j];
p.set_d(i, j, entry);
}
// c
for (int j=0; j<n/2; ++j)
p.set_c (rd.get_int(0, n), rd.get_double());
// c0
p.set_c0(rd.get_double());
// solve it
Solution s = CGAL::solve_quadratic_program (p, ET(), options);
assert(s.is_valid());
statistics (s, qp_optimal, qp_infeasible, qp_unbounded);
// also solve it as nqp, lp, nlp
s = CGAL::solve_nonnegative_quadratic_program (p, ET(), options);
assert(s.is_valid());
statistics (s, nqp_optimal, nqp_infeasible, nqp_unbounded);
s = CGAL::solve_linear_program (p, ET(), options);
assert(s.is_valid());
statistics (s, lp_optimal, lp_infeasible, lp_unbounded);
s = CGAL::solve_nonnegative_linear_program (p, ET(), options);
assert(s.is_valid());
statistics (s, nlp_optimal, nlp_infeasible, nlp_unbounded);
}
// output statistics
std::cout << "Solved " << tries
<< " random QP / NQP / LP / NLP .\n"
<< " Optimal: "
<< qp_optimal << " / "
<< nqp_optimal << " / "
<< lp_optimal << " / "
<< nlp_optimal << "\n"
<< " Infeasible: "
<< qp_infeasible << " / "
<< nqp_infeasible << " / "
<< lp_infeasible << " / "
<< nlp_infeasible << "\n"
<< " Unbounded: "
<< qp_unbounded << " / "
<< nqp_unbounded << " / "
<< lp_unbounded << " / "
<< nlp_unbounded << std::endl;
return 0;
}
return ___2039; } ___372 FileStreamWriter::close(bool ___3361) { return m_fileIOStream.close(___3361); } ___1393 FileStreamWriter::fileLoc() { REQUIRE(___2041()); return m_fileIOStream.fileLoc(); } ___372 FileStreamWriter::___3460() { REQUIRE(___2041()); return m_fileIOStream.___3460(); } ___372 FileStreamWriter::___3459(___1393 fileLoc) { REQUIRE(___2041()); REQUIRE(fileLoc != ___330); return m_fileIOStream.___3459(fileLoc); } ___372 FileStreamWriter::seekToFileEnd() { REQUIRE(___2041()); return m_fileIOStream.seekToFileEnd(); } std::string const& FileStreamWriter::___1394() const { return m_fileIOStream.___1394(); } void FileStreamWriter::___3494(___372 ___2002) { REQUIRE(VALID_BOOLEAN(___2002)); m_fileIOStream.___3494(___2002); } ___372 FileStreamWriter::___2002() const { return m_fileIOStream.___2002(); } void FileStreamWriter::setDataFileType(DataFileType_e ___844) { REQUIRE(VALID_ENUM(___844, DataFileType_e)); m_fileIOStream.setDataFileType(___844); } DataFileType_e FileStreamWriter::___844() const { return m_fileIOStream.___844(); } class FileIOStatistics& FileStreamWriter::statistics() { return m_fileIOStream.statistics(); } size_t FileStreamWriter::fwrite(void const* ___416, size_t size, size_t count) { REQUIRE(___2041()); REQUIRE(VALID_REF(___416)); size_t ___3358 = ::fwrite(___416, size, count, m_fileIOStream.handle());
#ifdef PROFILE_FILE_ACCESS
if ( ___3358 > 0 ) { statistics().numReadWritesPerformed++; statistics().___2780 += ___3358*size; }
#endif
return ___3358; } int FileStreamWriter::fprintf(char const* format, ...) { REQUIRE(___2041()); REQUIRE(VALID_NON_ZERO_LEN_STR(format)); va_list args; va_start(args, format); int ___3358 = ::vfprintf(m_fileIOStream.handle(), format, args); va_end (args);
return ___3358; } int FileStreamWriter::fprintf(char const* format, ...) { REQUIRE(___2041()); REQUIRE(VALID_NON_ZERO_LEN_STR(format)); va_list args; va_start(args, format); int ___3358 = ::vfprintf(m_fileIOStream.handle(), format, args); va_end (args);
#ifdef PROFILE_FILE_ACCESS
if (___3358 > 0) { statistics().numReadWritesPerformed++; statistics().___2780 += ___3358; }
#endif
return ___3358; } }}
void aig_prop_solvert::usage_count(std::vector<unsigned> &p_usage_count, std::vector<unsigned> &n_usage_count) {
for (constraintst::const_iterator
c_it=constraints.begin();
c_it!=constraints.end();
c_it++) {
if (!((*c_it).is_constant())) {
if ((*c_it).sign()) {
++n_usage_count[(*c_it).var_no()];
} else {
++p_usage_count[(*c_it).var_no()];
}
}
}
for (unsigned n=0; n<aig.nodes.size(); n++) {
const aigt::nodet &node=aig.nodes[n];
if (node.is_and()) {
if (node.a.sign()) {
++n_usage_count[node.a.var_no()];
} else {
++p_usage_count[node.a.var_no()];
}
if (node.b.sign()) {
++n_usage_count[node.b.var_no()];
} else {
++p_usage_count[node.b.var_no()];
}
}
}
#if 1
// Compute stats
unsigned unused = 0;
unsigned usedOncePositive = 0;
unsigned usedOnceNegative = 0;
unsigned usedTwicePositive = 0;
unsigned usedTwiceNegative = 0;
unsigned usedTwiceMixed = 0;
unsigned usedThreeTimes = 0;
unsigned usedMore = 0;
for (unsigned n=0; n<aig.nodes.size(); n++) {
switch (p_usage_count[n] + n_usage_count[n]) {
case 0 : ++unused; break;
case 1 :
if (p_usage_count[n] == 1) {
++usedOncePositive;
} else {
++usedOnceNegative;
}
break;
case 2 :
if (p_usage_count[n] >= 2) {
++usedTwicePositive;
} else if (n_usage_count[n] >= 2) {
++usedTwiceNegative;
} else {
assert(p_usage_count[n] == 1 && n_usage_count[n] == 1);
++usedTwiceMixed;
}
break;
case 3 : ++usedThreeTimes; break;
default : ++usedMore; break;
}
}
statistics() << "Unused: " << unused << " "
<< "Used once: " << usedOncePositive + usedOnceNegative
<< " (P: " << usedOncePositive
<< ", N: " << usedOnceNegative << ") "
<< "Used twice: " << usedTwicePositive + usedTwiceNegative + usedTwiceMixed
<< " (P: " << usedTwicePositive
<< ", N: " << usedTwiceNegative
<< ", M: " << usedTwiceMixed << ") "
<< "Used three times: " << usedThreeTimes << " "
<< "Used more: " << usedMore
<< eom;
#endif
}
int main(int argc, char *argv[])
{
struct thread_data *threads;
struct thread_data *thread;
int i, ret, ch;
if (argc > 1)
{
if (strcmp(argv[1], "--help") == 0)
{
usage_error(argv[0]);
}
init_program_parameter(argc, argv);
}
program_parameter(argv[0]);
create_matrix(&matrix_a);
create_matrix(&matrix_b);
create_matrix(&matrix_c);
create_matrix(&matrix_d);
random_matrix(matrix_a);
random_matrix(matrix_b);
nonmal_matrix_multipy(matrix_a, matrix_b, matrix_d);
threads = (struct thread_data *)malloc(pthread_max * sizeof(struct thread_data));
if (threads == NULL)
{
unix_error("malloc threads failed");
}
cpu_online = sysconf(_SC_NPROCESSORS_CONF);
for(i = 0; i < pthread_max; i++)
{
thread = threads + i;
thread->index = i;
if ((ret = pthread_create(&thread->thread_id, NULL, thread_func, thread)) != 0)
{
posix_error(ret, "pthread_create failed");
}
}
for(i = 0; i < pthread_max; i++)
{
thread = threads + i;
if ((ret = pthread_join(thread->thread_id, NULL)) != 0)
{
posix_error(ret, "pthread_join failed");
}
}
if (matrix_equal(matrix_c, matrix_d) == 0)
{
unix_error("runtime error");
}
if (dump)
{
dump_matrix("matrix A", matrix_a);
dump_matrix("matrix B", matrix_b);
dump_matrix("matrix C", matrix_c);
dump_matrix("matrix D", matrix_d);
}
statistics(threads);
free_matrix(matrix_a);
free_matrix(matrix_b);
free_matrix(matrix_c);
free_matrix(matrix_d);
free(threads);
return 0;
}
//aux to call stats functions
void statistics(char stat)
{
if(stopApp==1)main();
char tmp[1024]= {0x0};
int fldcnt=0;
char arr[MAXFLDS][MAXFLDSIZE]= {0x0};
int recordcnt=0;
if(stat=='a') strcpy(filename,"");
if (!strcmp(filename,""))
{
printf("Enter key [d] to assume defaults [logcsv.csv],\n");
printf("or insert the name of the CSV file [file.csv]: ");
scanf("%s", filename);
}
if (!strcmp(filename,"d"))
strcpy(filename,"logcsv.csv");
in = fopen(filename,"r");/* open file on command line */
if(checkFileIn()==-1)
{
optionSaveStats='3';
printf("Error loading file...[%s]\n\n", filename);
statistics('a');
}
if(checkFileIn()==0)
{
if(stat=='a')printf("Loading file...[%s]\n\n", filename);
fgets(tmp,sizeof(tmp),in); /*jump over header*/
while(fgets(tmp,sizeof(tmp),in)!=0) /* read a record */
{
i=0;
j=0;
recordcnt++;
parse(tmp,",",arr,&fldcnt); /* whack record into fields */
for(i; i<fldcnt; i++)
{
//copy all records to strs
strcpy(strs[recordcnt-1][i],arr[i]);
}
}
if(stat=='a')printf("Done!!!\n", filename);
if(stat=='a')PressEnterToReturn();
}
if (stat=='b') {
system("clear");
print_all_macip(recordcnt, 2,"Source devices:\n"); //list of all source devices - print mac and ip
PressEnterToReturn();
fclose(in);
optionSaveStats='3';
system("clear");
statsMenu();
}
if (stat=='c') {
system("clear");
print_all(recordcnt, 8, "Source ports:\n"); //list of all source ports
PressEnterToReturn();
fclose(in);
optionSaveStats='3';
system("clear");
statsMenu();
}
if (stat=='d') {
system("clear");
print_all_macip(recordcnt, 3,"\nDestination devices:\n"); //list of all destination devices - print mac and ip
PressEnterToReturn();
fclose(in);
optionSaveStats='3';
system("clear");
statsMenu();
}
if (stat=='e') {
system("clear");
print_all(recordcnt, 9, "Destination ports:\n"); //list of all destination ports
PressEnterToReturn();
fclose(in);
optionSaveStats='3';
system("clear");
statsMenu();
}
if (stat=='f') {
system("clear");
rep_count(recordcnt, 12, "0", "\nNº of Queries: "); //count number of queries, verifying the flag response=o
PressEnterToReturn();
fclose(in);
optionSaveStats='3';
system("clear");
statsMenu();
}
if (stat=='g') {
system("clear");
rep_count(recordcnt, 12, "1", "\nNº of Responses: "); //count number of responses, verifying the flag response=1
PressEnterToReturn();
fclose(in);
optionSaveStats='3';
system("clear");
statsMenu();
}
if (stat=='h') {
system("clear");
rep_count(recordcnt, 13, "3", "\nNº of Rcodes: "); //count number of Rcodes errors
PressEnterToReturn();
fclose(in);
optionSaveStats='3';
system("clear");
statsMenu();
}
if (stat=='i') {
system("clear");
check_times(recordcnt, 10); //verify delay between question and answer
PressEnterToReturn();
fclose(in);
optionSaveStats='3';
system("clear");
statsMenu();
}
if (stat=='j') {
system("clear");
print_all_stats(recordcnt, 2, "\nMAC source:"); //stats MAC Source
PressEnterToReturn();
fclose(in);
optionSaveStats='3';
system("clear");
statsMenu();
}
if (stat=='k') {
system("clear");
print_all_stats(recordcnt, 3, "\nMAC destination:");//stats MAC destination
PressEnterToReturn();
fclose(in);
optionSaveStats='3';
system("clear");
statsMenu();
}
if (stat=='l') {
system("clear");
print_all_stats(recordcnt, 18, "\nNames:");//stats Name
PressEnterToReturn();
fclose(in);
optionSaveStats='3';
system("clear");
statsMenu();
}
if (stat=='m') {
system("clear");
string keyword;
printf("Insert the keyword to search in all queries: ");
scanf("%s", keyword);
count_occurrences(recordcnt, 18, "\nThe selected keyword:", keyword);
PressEnterToReturn();
fclose(in);
optionSaveStats='3';
system("clear");
statsMenu();
}
if (stat=='n') {
system("clear");
check_blacklisted(recordcnt, 21, "\nCheck queries responses:\n");//Check queries responses
PressEnterToReturn();
fclose(in);
optionSaveStats='3';
system("clear");
statsMenu();
}
statsMenu();
}
int main() {
// print seed
std::cout << "Random seed: " << rd.get_seed() << std::endl;
// options
CGAL::Quadratic_program_options options;
options.set_auto_validation(true);
// generate a set of small random qp's
for (int i=0; i<tries; ++i) {
int Ax[] = {random_signed(), random_signed()};
int Ay[] = {random_signed(), random_signed()};
int* A[] = {Ax, Ay};
int b[] = {random_signed(), random_signed()};
CGAL::Comparison_result
r[] = {random_rel(), random_rel()};
bool fl[] = {rd.get_bool(), rd.get_bool()};
int l[] = {random_signed(),random_signed()};
bool fu[] = {rd.get_bool(), rd.get_bool()};
int u[] = {random_signed(),random_signed()};
// make sure that l<=u
if (l[0] > u[0]) {int h = l[0]; l[0] = u[0]; u[0] = h;}
if (l[1] > u[1]) {int h = l[1]; l[1] = u[1]; u[1] = h;}
int D1[] = {random_unsigned()};
int D2[] = {0, random_unsigned()};
// can still change D_21 as long as D remains positive-semidefinite
if (D1[0] < D2[1])
D2[0] = rd.get_int(-D1[0], D1[0]+1);
else
D2[0] = rd.get_int(-D2[1], D2[1]+1);
assert(D1[0] * D2[1] >= D2[0] * D2[0]);
int* D[] = {D1, D2};
int c[] = {random_signed(), random_signed()};
int c0 = random_signed();
// now construct the quadratic program; the first two parameters are
// the number of variables and the number of constraints (rows of A)
Program qp (2, 2, A, b, r, fl, l, fu, u, D, c, c0);
// write/read it and check equality
std::stringstream inout;
CGAL::print_quadratic_program (inout, qp);
CGAL::Quadratic_program_from_mps<int> qp2 (inout);
assert(CGAL::QP_functions_detail::are_equal_qp (qp, qp2));
// solve it
Solution s = CGAL::solve_quadratic_program (qp, ET(), options);
assert(s.is_valid());
statistics (s, qp_optimal, qp_infeasible, qp_unbounded);
// also solve it as nqp, lp, nlp
s = CGAL::solve_nonnegative_quadratic_program (qp, ET(), options);
assert(s.is_valid());
statistics (s, nqp_optimal, nqp_infeasible, nqp_unbounded);
s = CGAL::solve_linear_program (qp, ET(), options);
assert(s.is_valid());
statistics (s, lp_optimal, lp_infeasible, lp_unbounded);
s = CGAL::solve_nonnegative_linear_program (qp, ET(), options);
assert(s.is_valid());
statistics (s, nlp_optimal, nlp_infeasible, nlp_unbounded);
}
// output statistics
std::cout << "Solved " << tries
<< " random QP / NQP / LP / NLP .\n"
<< " Optimal: "
<< qp_optimal << " / "
<< nqp_optimal << " / "
<< lp_optimal << " / "
<< nlp_optimal << "\n"
<< " Infeasible: "
<< qp_infeasible << " / "
<< nqp_infeasible << " / "
<< lp_infeasible << " / "
<< nlp_infeasible << "\n"
<< " Unbounded: "
<< qp_unbounded << " / "
<< nqp_unbounded << " / "
<< lp_unbounded << " / "
<< nlp_unbounded << std::endl;
return 0;
}
namespace tecplot { namespace ___3933 { FileStreamReader::FileStreamReader(std::string const& ___1394) : m_fileIOStream(___1394) { } FileStreamReader::~FileStreamReader() { m_fileIOStream.close(true); } ___372 FileStreamReader::___2041() const { return m_fileIOStream.___2041(); } ___372 FileStreamReader::open() { REQUIRE(!___2041()); ___372 ___2039 = m_fileIOStream.open("rb"); if (!___2039) ___1186("Cannot read file %s", ___1394().c_str());
#ifdef PROFILE_FILE_ACCESS
___478(statistics().numFSeeksPerformed == 0 && statistics().numReadWritesPerformed == 0 && statistics().___2780 == 0);
#endif
return ___2039; } ___372 FileStreamReader::close(bool ___3361) { return m_fileIOStream.close(___3361); } ___1393 FileStreamReader::fileLoc() { REQUIRE(___2041()); return m_fileIOStream.fileLoc(); } ___372 FileStreamReader::___3460() { REQUIRE(___2041()); return m_fileIOStream.___3460(); } ___372 FileStreamReader::___3459(___1393 fileLoc) { REQUIRE(___2041()); REQUIRE(fileLoc != ___330); return m_fileIOStream.___3459(fileLoc); } ___372 FileStreamReader::seekToFileEnd() { REQUIRE(___2041()); return m_fileIOStream.seekToFileEnd(); } std::string const& FileStreamReader::___1394() const { return m_fileIOStream.___1394(); } void FileStreamReader::___3494(___372 ___2002) { REQUIRE(VALID_BOOLEAN(___2002)); m_fileIOStream.___3494(___2002); } ___372 FileStreamReader::___2002() const { return m_fileIOStream.___2002(); } void FileStreamReader::setDataFileType(DataFileType_e ___844) { REQUIRE(VALID_ENUM(___844, DataFileType_e)); m_fileIOStream.setDataFileType(___844); } DataFileType_e FileStreamReader::___844() const { return m_fileIOStream.___844(); } class FileIOStatistics& FileStreamReader::statistics() { return m_fileIOStream.statistics(); } size_t FileStreamReader::fread(void* ___416, size_t size, size_t count) { REQUIRE(VALID_REF(___416)); REQUIRE(___2041()); size_t ___3358 = ::fread(___416, size, count, m_fileIOStream.handle());
return ___2039; } ___372 FileStreamReader::close(bool ___3361) { return m_fileIOStream.close(___3361); } ___1393 FileStreamReader::fileLoc() { REQUIRE(___2041()); return m_fileIOStream.fileLoc(); } ___372 FileStreamReader::___3460() { REQUIRE(___2041()); return m_fileIOStream.___3460(); } ___372 FileStreamReader::___3459(___1393 fileLoc) { REQUIRE(___2041()); REQUIRE(fileLoc != ___330); return m_fileIOStream.___3459(fileLoc); } ___372 FileStreamReader::seekToFileEnd() { REQUIRE(___2041()); return m_fileIOStream.seekToFileEnd(); } std::string const& FileStreamReader::___1394() const { return m_fileIOStream.___1394(); } void FileStreamReader::___3494(___372 ___2002) { REQUIRE(VALID_BOOLEAN(___2002)); m_fileIOStream.___3494(___2002); } ___372 FileStreamReader::___2002() const { return m_fileIOStream.___2002(); } void FileStreamReader::setDataFileType(DataFileType_e ___844) { REQUIRE(VALID_ENUM(___844, DataFileType_e)); m_fileIOStream.setDataFileType(___844); } DataFileType_e FileStreamReader::___844() const { return m_fileIOStream.___844(); } class FileIOStatistics& FileStreamReader::statistics() { return m_fileIOStream.statistics(); } size_t FileStreamReader::fread(void* ___416, size_t size, size_t count) { REQUIRE(VALID_REF(___416)); REQUIRE(___2041()); size_t ___3358 = ::fread(___416, size, count, m_fileIOStream.handle());
#ifdef PROFILE_FILE_ACCESS
if ( ___3358 > 0 ) { statistics().numReadWritesPerformed++; statistics().___2780 += ___3358*size; }
#endif
return ___3358; } char* FileStreamReader::fgets(char* s, int size) { REQUIRE(VALID_REF(s)); REQUIRE(size >= 0); REQUIRE(___2041()); char* ___3358 = ::fgets(s, size, m_fileIOStream.handle());
return ___3358; } int FileStreamReader::feof() { REQUIRE(___2041()); return ::feof(m_fileIOStream.handle()); } int FileStreamReader::getc() { REQUIRE(___2041()); int ___3358 = ::getc(m_fileIOStream.handle());
#ifdef PROFILE_FILE_ACCESS
statistics().numReadWritesPerformed++; statistics().___2780++;
#endif
return ___3358; } int FileStreamReader::ungetc(int c) { REQUIRE(___2041()); int ___3358 = ::ungetc(c, m_fileIOStream.handle());
return ___3358; } int FileStreamReader::ungetc(int c) { REQUIRE(___2041()); int ___3358 = ::ungetc(c, m_fileIOStream.handle());
#ifdef PROFILE_FILE_ACCESS
___478(statistics().___2780>0); statistics().___2780--;
#endif
return ___3358; } int FileStreamReader::fscanf(char const* format, void* ___3251) { REQUIRE(___2041()); REQUIRE(VALID_NON_ZERO_LEN_STR(format)); REQUIRE(VALID_REF(___3251));
return ___3358; } char* FileStreamReader::fgets(char* s, int size) { REQUIRE(VALID_REF(s)); REQUIRE(size >= 0); REQUIRE(___2041()); char* ___3358 = ::fgets(s, size, m_fileIOStream.handle());
#ifdef PROFILE_FILE_ACCESS
if ( ___3358 != NULL ) { statistics().numReadWritesPerformed++; statistics().___2780 += ___3358 ? strlen(s) : 0; }
#endif
return ___3358; } int FileStreamReader::feof() { REQUIRE(___2041()); return ::feof(m_fileIOStream.handle()); } int FileStreamReader::getc() { REQUIRE(___2041()); int ___3358 = ::getc(m_fileIOStream.handle());
void BVH4Statistics::statistics(NodeRef node, const float A, size_t& depth)
{
if (node.isNode())
{
hash += 0x1234;
numAlignedNodes++;
AlignedNode* n = node.node();
bvhSAH += A*BVH4::travCostAligned;
depth = 0;
for (size_t i=0; i<BVH4::N; i++) {
if (n->child(i) == BVH4::emptyNode) continue;
childrenAlignedNodes++;
const float Ai = max(0.0f,halfArea(n->extend(i)));
size_t cdepth; statistics(n->child(i),Ai,cdepth);
depth=max(depth,cdepth);
}
depth++;
hash += 0x76767*depth;
}
else if (node.isUnalignedNode())
{
hash += 0x1232344;
numUnalignedNodes++;
UnalignedNode* n = node.unalignedNode();
bvhSAH += A*BVH4::travCostUnaligned;
depth = 0;
for (size_t i=0; i<BVH4::N; i++) {
if (n->child(i) == BVH4::emptyNode) continue;
childrenUnalignedNodes++;
const float Ai = max(0.0f,halfArea(n->extend(i)));
size_t cdepth; statistics(n->child(i),Ai,cdepth);
depth=max(depth,cdepth);
}
depth++;
hash += 0x76767*depth;
}
else if (node.isNodeMB())
{
hash += 0xEF343;
numAlignedNodesMB++;
BVH4::NodeMB* n = node.nodeMB();
bvhSAH += A*BVH4::travCostAligned;
depth = 0;
for (size_t i=0; i<BVH4::N; i++) {
if (n->child(i) == BVH4::emptyNode) continue;
childrenAlignedNodesMB++;
const float Ai = max(0.0f,halfArea(n->extend0(i)));
size_t cdepth; statistics(n->child(i),Ai,cdepth);
depth=max(depth,cdepth);
}
depth++;
hash += 0x76767*depth;
}
else if (node.isUnalignedNodeMB())
{
hash += 0x1EEF4;
numUnalignedNodesMB++;
BVH4::UnalignedNodeMB* n = node.unalignedNodeMB();
bvhSAH += A*BVH4::travCostUnaligned;
depth = 0;
for (size_t i=0; i<BVH4::N; i++) {
if (n->child(i) == BVH4::emptyNode) continue;
childrenUnalignedNodesMB++;
const float Ai = max(0.0f,halfArea(n->extend0(i)));
size_t cdepth; statistics(n->child(i),Ai,cdepth);
depth=max(depth,cdepth);
}
depth++;
hash += 0x76767*depth;
}
else
{
depth = 0;
size_t num; const char* tri = node.leaf(num);
hash += 0xDD776*num+0x878;
if (!num) return;
hash += bvh->primTy.hash(tri,num);
numLeaves++;
numPrims += num;
float sah = A * BVH4::intCost * num;
bvhSAH += sah;
}
}
LRESULT CProcessorUsageDialog::OnUsageUpdate( UINT /*uMsg*/,
WPARAM wParam,
LPARAM lParam,
BOOL& /*bHandled*/ )
{
std::auto_ptr< ProcessStatistics > statistics( ( ProcessStatistics* )wParam );
unsigned int total_used = static_cast< unsigned int >( lParam );
static short int token = 0;
LVFINDINFO find = { 0 };
find.flags = LVFI_STRING;
process_list_ctrl_.SetRedraw( FALSE );
for( ProcessStatistics::const_iterator it = statistics->begin();
it != statistics->end();
++it )
{
// locate the process name in our list view. if it doesn't exist, add it.
find.psz = it->first.c_str();
int found = process_list_ctrl_.FindItem( &find, -1 );
if( found == -1 )
{
found = process_list_ctrl_.InsertItem( 0, it->first.c_str() );
}
// format the user time and display it in the list view
std::wstringstream user_time;
user_time.precision( 1 );
user_time << std::fixed << it->second.user << L"%";
process_list_ctrl_.AddItem( found, 1, user_time.str().c_str() );
// format the kernel time and display it in the list view
std::wstringstream kernel_time;
kernel_time.precision( 1 );
kernel_time << std::fixed << it->second.kernel << L"%";
process_list_ctrl_.AddItem( found, 2, kernel_time.str().c_str() );
// mark the item with our token to show that it is still active
process_list_ctrl_.SetItemData( found, token + 1 );
}
// locate all the list view items that were not updated with the new token
// in this round and remove them - they represent processes that have exited.
find.flags = LVFI_PARAM;
find.psz = NULL;
find.lParam = token;
int found = -1;
while( ( found = process_list_ctrl_.FindItem( &find, found ) ) > -1 )
{
process_list_ctrl_.DeleteItem( found );
}
// if the list view has grown longer than 1 page, scroll bars will appear.
// re-layout the columns to account for that.
if( process_list_ctrl_.GetItemCount() > process_list_ctrl_.GetCountPerPage() )
{
CRect list_rc;
process_list_ctrl_.GetClientRect( &list_rc );
process_list_ctrl_.SetColumnWidth( 0, static_cast< int >( list_rc.Width() * 0.5 ) );
process_list_ctrl_.SetColumnWidth( 1, static_cast< int >( list_rc.Width() * 0.25 ) );
process_list_ctrl_.SetColumnWidth( 2, LVSCW_AUTOSIZE_USEHEADER );
}
process_list_ctrl_.SetRedraw( TRUE );
/// format & display the number of running processes
std::wstringstream count_str;
count_str << statistics->size();
process_count_.SetWindowText( count_str.str().c_str() );
/// format & display the total cpu usage
std::wstringstream usage_str;
usage_str.precision( 1 );
usage_str << total_used << L"%";
cpu_usage_.SetWindowText( usage_str.str().c_str() );
++token;
return 0;
}
void turnaroundtime(enum priority p, int n, int info) {
statistics(p, n, info, "total time");
}
int main(int argc, char **argv) {
pcap_t *pcap;
char errbuf[PCAP_ERRBUF_SIZE];
const u_char *pkt;
struct pcap_pkthdr hdr;
struct ether_header *eptr;
struct ip *ip_hdr;
struct tcphdr *tcp_hdr;
unsigned long nbp,nbip,nbtcp;
unsigned long long totalSize;
flow * flowrec;
int c,optpkt;
struct timeval t0,t1;
uint32_t last_expiration,current_ts;
// Default Paramaters for the classification
labeling=clusterport;
SSL_labeling=SSL_clusterport;
sslparsing=0;
threshold=-255;
action=ACTION_LABEL;
memory=NOOPTMEM;
pktlimit=model.nbpackets;
optpkt=pktlimit;
stats.nbstats=0;
bzero(stats.timeidx,sizeof(stats.timeidx));
bzero(stats.creations,sizeof(stats.creations));
bzero(stats.deletions,sizeof(stats.deletions));
nbflows=0;
last_expiration=0;
// Parsing options
while ((c = getopt (argc, argv, "m:hCDPLSt:p:")) != -1)
switch (c) {
case 'h':
usage(argv);
break;
case 'P':
action=ACTION_PARSE;
break;
case 'L':
action=ACTION_LABEL;
break;
case 'D':
labeling=dominant;
SSL_labeling=dominant;
break;
case 'C':
labeling=clusterport;
SSL_labeling=SSL_clusterport;
break;
case 'm':
if (atoi(optarg)>=0) {
memory=atoi(optarg);
break;
} else {
fprintf(stderr,"Invalid Memory option\n");
usage(argv);
}
break;
case 'S':
sslparsing=1;
break;
case 't':
if (atoi(optarg)>0) {
threshold=-atoi(optarg);
break;
} else {
fprintf(stderr,"Invalid threshold value\n");
usage(argv);
}
case 'p':
if (atoi(optarg)>0) {
optpkt=atoi(optarg);
break;
} else {
fprintf(stderr,"Invalid packet value\n");
usage(argv);
}
case '?':
if (isprint (optopt))
fprintf (stderr, "Unknown option `-%c'.\n", optopt);
else
fprintf (stderr, "Unknown option character `\\x%x'.\n", optopt);
usage(argv);
default:
usage(argv);
}
if (action==ACTION_PARSE) pktlimit=optpkt;
if (optind>=argc) {
fprintf(stderr,"No file specified\n");
usage(argv);
}
// Opening pcap file
fprintf(stderr,"Opening file : %s\n",argv[optind]);
if ((pcap = pcap_open_offline(argv[optind], errbuf)) == NULL) {
fprintf(stderr,"Error opening pcap file : %s\n",errbuf);
usage(argv);
}
init_hashes ();
// Empty connection to start list
first_flow=(flow*)malloc(sizeof(flow));
first_flow->src.s_addr=0;
first_flow->dst.s_addr=0;
first_flow->sport=0;
first_flow->dport=0;
active_flows=first_flow;
// Parse packets one by one
nbp=0;nbip=0;nbtcp=0;
totalSize=0;
gettimeofday (&t0,NULL);
while (pkt = pcap_next( pcap, &hdr )) {
nbp++;
totalSize+=hdr.len;
current_ts=hdr.ts.tv_sec;
if (last_expiration==0) last_expiration=current_ts;
if (current_ts-last_expiration>CLEAN_TIME) {
if (memory>=OPT_GARBAGE) clean_flows(first_flow->next,current_ts);
statistics(current_ts-last_expiration);
last_expiration=current_ts;
}
if (nbp % PRINTPKT== 0) {
fprintf(stderr, "Pkt : %lu",nbp);
fprintf(stderr, "\r");
fflush(stderr);
}
eptr = (struct ether_header *) pkt;
if (ntohs (eptr->ether_type) != ETHERTYPE_IP) {
continue;
} else {
nbip++;
ip_hdr=(struct ip *)(pkt+14);
if (ip_hdr->ip_p==IPPROTO_TCP && ((ntohs (ip_hdr->ip_off) & IP_OFFMASK)==0)) {
nbtcp++;
count_flow(ip_hdr,hdr.caplen-14,hdr.ts.tv_sec);
}
}
}
if (memory>=OPT_GARBAGE) clean_flows(first_flow->next,current_ts);
statistics(current_ts-last_expiration);
last_expiration=current_ts;
dump_flows(first_flow->next);
statistics(1);
gettimeofday (&t1,NULL);
pcap_close(pcap);
fprintf(stderr,"\n%lu Packets parsed in %.2fms\n(%lu non-ip / %lu non-tcp)\n"
"TCP Connections with Syn: %lu\n"
"Total Volume: %llu\n"
"Duration: %lu\n",
nbp,
(float)((t1.tv_sec-t0.tv_sec)*1000000 + (t1.tv_usec-t0.tv_usec))/1000,
nbp-nbip,nbp-nbtcp,flow_hash->total_insert,totalSize,stats.timeidx[stats.nbstats]);
//dump_hashtab_stats(flow_hash);
//print_statistics();
}
//Print Stats Menu
char statsMenu()
{
system("clear");
char select;
printf("\n");
printf("%60s","######## S T A T I S T I C S M E N U #########\n");
printf("%60s","# ################## D N S ################## #\n");
printf("%60s","# # # #\n");
printf("%60s","# # a -> Load file [csv] # #\n");
printf("%60s","# # b -> Source devices # #\n");
printf("%60s","# # c -> Source ports # #\n");
printf("%60s","# # d -> Destination devices # #\n");
printf("%60s","# # e -> Destination ports # #\n");
printf("%60s","# # f -> Number of queries # #\n");
printf("%60s","# # g -> Number of responses # #\n");
printf("%60s","# # h -> Number of Rcodes # #\n");
printf("%60s","# # i -> Delay between questions/answers # #\n");
printf("%60s","# # j -> Frequencies for MAC source # #\n");
printf("%60s","# # k -> Frequencies for MAC destination # #\n");
printf("%60s","# # l -> Frequencies for Names # #\n");
printf("%60s","# # m -> Search keywords occurencies # #\n");
printf("%60s","# # n -> Check answers in blacklist # #\n");
printf("%60s","# # # #\n");
printf("%60s","# # q -> RETURN TO MAIN MENU # #\n");
printf("%60s","# # # #\n");
printf("%60s","# ########################################### #\n");
printf("%60s","###############################################\n");
printf("Option: ");
scanf("%1s", &select);
switch (select)
{
case 'a':
system("clear");
statistics(select);
optionSaveStats=='3';
statsMenu();
break;
case 'b':
system("clear");
statistics(select);
optionSaveStats=='3';
statsMenu();
break;
case 'c':
system("clear");
statistics(select);
optionSaveStats=='3';
statsMenu();
break;
case 'd':
system("clear");
statistics(select);
optionSaveStats=='3';
statsMenu();
break;
case 'e':
system("clear");
statistics(select);
optionSaveStats=='3';
statsMenu();
break;
case 'f':
system("clear");
statistics(select);
optionSaveStats=='3';
statsMenu();
break;
case 'g':
system("clear");
statistics(select);
optionSaveStats=='3';
statsMenu();
break;
case 'h':
system("clear");
statistics(select);
optionSaveStats=='3';
statsMenu();
break;
case 'i':
system("clear");
statistics(select);
optionSaveStats=='3';
statsMenu();
break;
case 'j':
system("clear");
statistics(select);
optionSaveStats=='3';
statsMenu();
break;
case 'k':
system("clear");
statistics(select);
optionSaveStats=='3';
statsMenu();
break;
case 'l':
system("clear");
statistics(select);
optionSaveStats=='3';
statsMenu();
break;
case 'm':
system("clear");
statistics(select);
optionSaveStats=='3';
statsMenu();
break;
case 'n':
system("clear");
statistics(select);
optionSaveStats=='3';
statsMenu();
break;
case 'q':
optionSave = 'm';
optionSaveStats='3';
system("clear");
mainMenu();
break;
default:
system("clear");
printf(" Invalid option - please select options [a-n] or [q] to return!!! \n ");
sleep(1);
optionSaveStats='3';
statsMenu();
break;
}
}
// Boilerplate program options code from http://www.radmangames.com/programming/how-to-use-boost-program_options
int main(int argc, char** argv)
{
bool enable_sorting = true;
double seed = 0;
double power_mean = 300.0; // Watts
double power_stdev = power_mean/10.0;
double power_estimate_error_stdev = power_stdev/10.0;
double arrival_rate = 1000.0; // Jobs per second
double completion_time_mean = 0.9*NUM_SERVERS/arrival_rate; // Seconds
double completion_time_stdev = completion_time_mean/10.0;
double sorting_time_min = completion_time_mean/1000.0;
double sorting_time_max = sorting_time_min*2.0;
double routing_time_min = sorting_time_min;
double routing_time_max = sorting_time_max;
try
{
/** Define and parse the program options
*/
namespace po = boost::program_options;
po::options_description desc("Options");
desc.add_options()
("help", "Print help messages")
("seed", po::value<double>(&seed), "Seed for random number generator")
("power_estimate_error_stdev", po::value<double>(&power_estimate_error_stdev), "Power estimate standard deviation")
("completion_time_stdev", po::value<double>(&completion_time_stdev), "Completion time standard deviation")
("enable_sorting", po::value<bool>(&enable_sorting), "Enable sorting")
;
po::variables_map vm;
try
{
po::store(po::parse_command_line(argc, argv, desc),
vm); // can throw
/** --help option
*/
if ( vm.count("help") )
{
std::cout << "Basic Command Line Parameter App" << std::endl
<< desc << std::endl;
return SUCCESS;
}
po::notify(vm); // throws on error, so do after help in case
// there are any problems
}
catch(po::error& e)
{
std::cerr << "ERROR: " << e.what() << std::endl << std::endl;
std::cerr << desc << std::endl;
return ERROR_IN_COMMAND_LINE;
}
// BEGIN APPLICATION CODE //
DataCenterRandomPtr rand(new DataCenterRandom(
seed,
power_mean,
power_stdev,
arrival_rate,
completion_time_mean,
completion_time_stdev,
sorting_time_min,
sorting_time_max,
routing_time_min,
routing_time_max,
power_estimate_error_stdev));
PriorityTypePtr sortOrder(new JobEvent::PriorityType(JobEvent::TIME));
PriorityQueueEventListPtr eventList(new PriorityQueueEventList(
EVENT_LIST_LEN,
sortOrder));
PriorityQueueWorkingServers::SortingDomain sortingDomain;
if(enable_sorting){
sortingDomain = PriorityQueueWorkingServers::POWER_AWARE;
}
else{
sortingDomain = PriorityQueueWorkingServers::RANDOM;
}
std::ostringstream s;
s << seed;
AccumulatorStatistics statistics(s.str());
PriorityQueueWorkingServersPtr workingServersQueue(new PriorityQueueWorkingServers(
NUM_SERVERS,
rand,
eventList,
statistics.getAccumulator(AccumulatorStatistics::LATENCY),
statistics.getAccumulator(AccumulatorStatistics::TOTAL_ENERGY),
sortOrder,
s.str() + "server_currents.csv",
sortingDomain));
PriorityQueueJobSorterPtr sortedJobQueue(new PriorityQueueJobSorter(
SORTED_JOBS_LIST_LEN,
rand,
workingServersQueue,
eventList,
sortOrder,
enable_sorting));
QueueJobBufferPtr unsortedJobQueue(new QueueJobBuffer(
UNSORTED_JOBS_LIST_LEN,
statistics.getAccumulator(AccumulatorStatistics::TIME_BETWEEN_REJECTED_JOBS),
sortedJobQueue));
#ifndef UNITTEST
double time = 0;
JobEventPtr arrival(new JobEvent(0, Event::JOB_ARRIVAL, sortOrder));
_NOTEL(0,"Welcome to the data center stacked server simulator.");
_LOGL(1,"Initialization parameters: ");
_LOGL(1,"Sorting enabled: " << enable_sorting);
_LOGL(1,"Simulation time: " << MAX_TIME);
_LOGL(1,"Event list length: " << EVENT_LIST_LEN);
_LOGL(1,"Unsorted jobs list length: " << UNSORTED_JOBS_LIST_LEN);
_LOGL(1,"Sorted jobs list length: " << SORTED_JOBS_LIST_LEN);
_LOGL(1,"Number of servers: " << NUM_SERVERS);
_LOGL(1, *rand);
// Queue up initial arrival.
_NOTEL(2,"Creating initial arrival event.");
eventList->enqueue(arrival);
while(time < MAX_TIME){
EventPtr e = eventList->dequeue();
time = e->time;
_NOTEL(2, time);
if(e->type == Event::JOB_ARRIVAL || e->type == Event::JOB_FINISHED){
JobEventPtr job = boost::static_pointer_cast<JobEvent>(e);
if(job->type == Event::JOB_ARRIVAL){
double t = time + rand->sample_arrivalTime();
_NOTEL(2,"Processing job arrival event. Scheduling next job arrival for time " << t);
JobEventPtr nextJob(new JobEvent(t, Event::JOB_ARRIVAL, sortOrder));
eventList->enqueue(nextJob);
if(!unsortedJobQueue->enqueue(job)){
if(!sortedJobQueue->enqueue(job,time)){
workingServersQueue->enqueue(job,time);
}
}
}
else{ // if(job->type == Event::JOB_FINISHED){
_NOTEL(2,"Processing job removal event.");
workingServersQueue->remove(job,time);
if(enable_sorting){
if(!sortedJobQueue->is_busy() && !sortedJobQueue->is_empty()){
JobEventPtr job = sortedJobQueue->dequeueJob();
workingServersQueue->enqueue(job,time);
}
}
else{
if(!unsortedJobQueue->is_empty()){
JobEventPtr job = unsortedJobQueue->dequeue();
workingServersQueue->enqueue(job,time);
}
}
}
}
else if(e->type == Event::SORTED_QUEUE_READY){
if(enable_sorting){
_NOTEL(2,"Processing sorted queue ready event.");
sortedJobQueue->reset_busy();
if(!sortedJobQueue->is_empty() && !workingServersQueue->is_busy() && !workingServersQueue->is_full()){
JobEventPtr job = sortedJobQueue->dequeueJob();
workingServersQueue->enqueue(job,time);
}
if(!unsortedJobQueue->is_empty()){
JobEventPtr job = unsortedJobQueue->dequeue();
if(!sortedJobQueue->enqueue(job,time)){
workingServersQueue->enqueue(job,time);
}
}
else{
_NOTEL(2,"Nothing for sorted queue to do.");
}
}
else{
_NOTEL(0,"PROBLEM!!!");
}
}
else{ // if(e->type == Event::WORKING_SERVERS_QUEUE_READY){
_NOTEL(2,"Processing working servers queue ready event.");
workingServersQueue->reset_busy();
if(enable_sorting){
if(!sortedJobQueue->is_busy() && !sortedJobQueue->is_empty()){
JobEventPtr job = sortedJobQueue->dequeueJob();
workingServersQueue->enqueue(job,time);
}
}
else{
if(!unsortedJobQueue->is_empty()){
JobEventPtr job = unsortedJobQueue->dequeue();
workingServersQueue->enqueue(job,time);
}
}
}
//_NOTE(3, (*eventList) << std::endl);
}
_NOTEL(1,"Finished simulation of " << time << " virtual seconds.");
_LOGL(0,"Simulation results: " << std::endl << statistics);
AccumulatorPtr latency = statistics.getAccumulator(AccumulatorStatistics::LATENCY);
AccumulatorPtr total_energy = statistics.getAccumulator(AccumulatorStatistics::TOTAL_ENERGY);
_LOGL(0, latency->getMean() << "$\\pm$" << latency->getCI(0.95) << " & " << total_energy->getMean() << "$\\pm$" << total_energy->getCI(0.95));
return 0;
// Run the Unit tests
#else
_NOTEL(0,"Welcome to the unit tests.");
test_accumulator(rand,statistics);
test_working_servers(workingServersQueue,sortOrder,statistics);
return 0;
#endif
// END APPLICATION CODE //
}
catch(std::exception& e)
{
std::cerr << "Unhandled Exception reached the top of main: "
<< e.what() << ", application will now exit" << std::endl;
return ERROR_UNHANDLED_EXCEPTION;
}
return SUCCESS;
} // main
int main(int anz,char *paramstring[]) {
satz = (char *)calloc(1,300);
teil = (char *)calloc(1,12);
dateinameein = (char *)calloc(1,255);
dateinameaus = (char *)calloc(1,255);
printf("Umwandeln einer Ascii-Datei in ein Festformat\r\n");
if (anz<2) {
printf("\n");
printf("usage: ascigrid <Ascii-Datei> <festformatdatei>\r\n");
printf("\n");
printf(" Ascii-Datei: Dateikopf mit : \r\n");
printf(" ncols,nrows,xll,yll,cs,nodata jeweils ein Wert pro Zeile\r\n");
printf(" alle weiteren Werte von links oben nach rechts unten zeilenweise\r\n");
printf("\n");
printf("Eingabedatei : ");
dateinameein=gets(dateinameein);
printf("\r\nAusgabedatei : ");
dateinameaus=gets(dateinameaus);
printf("\r\n");
} else {
if (paramstring[1]!=NULL) strcpy(dateinameein,paramstring[1]);
if (anz>1) if (paramstring[2]!=NULL) strcpy(dateinameaus,paramstring[2]);
}
while ((dateiein=fopen((char *)dateinameein,"r"))==NULL) {
printf("Kann Eingabedatei %s nicht finden bzw ÷ffnen!\r\n",dateinameein);
printf("Bitte neuen Namen angeben : ");
dateinameein=gets((char *)dateinameein);
if (*(char *)dateinameein=='\0') exit(1);
printf("\r\n");
}
while ((dateiaus=fopen(dateinameaus,"wb"))==NULL) {
printf("Kann Ausgabedatei %s nicht finden bzw ÷ffnen!\r\n",dateinameaus);
printf("Bitte neuen Namen angeben : ");
dateinameaus=gets(dateinameaus);
if (*dateinameaus=='\0') exit(1);
printf("\r\n");
}
fscanf(dateiein,"%12s%d",teil,&ncols);
fscanf(dateiein,"%12s%d",teil,&nrows);
fscanf(dateiein,"%12s%f",teil,&xll);
fscanf(dateiein,"%12s%f",teil,&yll);
fscanf(dateiein,"%12s%f",teil,&cs);
fscanf(dateiein,"%12s%f",teil,&nodata);
x[1]=ncols;
x[2]=nrows;
x[3]=xll;
x[4]=yll;
x[5]=cs;
x[6]=nodata;
groesse=sizeof(x[1]);
clearstat(nodata);
fwrite(&x[1],sizeof(float),12,dateiaus);
for (j=1; j<=nrows; j++) {
for (i=1; i<=ncols; i++) {
fscanf(dateiein,"%f",&x[1]);
fwrite(&x[1],groesse,1,dateiaus);
addstat(x[1]);
}
fgets(satz,300,dateiein);
printf(".");
}
printf("\n");
statistics(&x[6],&x[7],&x[8],&x[9],&x[10],&x[11]);
fseek(dateiaus,6*sizeof(float),0);
fwrite(&x[6],sizeof(float),6,dateiaus);
fclose(dateiein);
fclose(dateiaus);
free(satz);
free(teil);
free(dateinameein);
free(dateinameaus);
}
PetriDish::~PetriDish()
{
#if DEBUG
cout << statistics();
#endif//DEBUG
}
int main(int argc,char **argv)
{
int i;
for(i=1; i<argc; i++) {
if(argv[i][0]=='-'&&argv[i][1]=='F') {
output_format=argv[i]+2;
argv[i][0]=0;
}
if(!strcmp("-quiet",argv[i])) {
verbose=0;
argv[i][0]=0;
}
}
if(!init_output(output_format))
general_error(16,output_format);
if(!init_main())
general_error(10,"main");
if(verbose)
printf("%s\n%s\n%s\n%s\n",copyright,cpu_copyright,syntax_copyright,output_copyright);
for(i=1; i<argc; i++) {
if(argv[i][0]==0)
continue;
if(argv[i][0]!='-') {
if(inname)
general_error(11);
inname=argv[i];
continue;
}
if(!strcmp("-o",argv[i])&&i<argc-1) {
if(outname)
general_error(28,'o');
outname=argv[++i];
continue;
}
if(!strcmp("-L",argv[i])&&i<argc-1) {
if(listname)
general_error(28,'L');
listname=argv[++i];
produce_listing=1;
continue;
}
if(!strcmp("-Lnf",argv[i])) {
listformfeed=0;
continue;
}
if(!strcmp("-Lns",argv[i])) {
listnosyms=1;
continue;
}
if(!strncmp("-Ll",argv[i],3)) {
sscanf(argv[i]+3,"%i",&listlinesperpage);
continue;
}
if(!strncmp("-D",argv[i],2)) {
char *def=NULL;
expr *val;
if(argv[i][2])
def=&argv[i][2];
else if (i<argc-1)
def=argv[++i];
if(def) {
char *s=def;
if(ISIDSTART(*s)) {
s++;
while(ISIDCHAR(*s))
s++;
def=cnvstr(def,s-def);
if(*s=='=') {
s++;
val=parse_expr(&s);
}
else
val=number_expr(1);
if(*s)
general_error(23,'D'); /* trailing garbage after option */
new_abs(def,val);
myfree(def);
continue;
}
}
}
if(!strncmp("-I",argv[i],2)) {
char *path=NULL;
if(argv[i][2])
path=&argv[i][2];
else if (i<argc-1)
path=argv[++i];
if(path) {
new_include_path(path);
continue;
}
}
if(!strcmp("-unnamed-sections",argv[i])) {
unnamed_sections=1;
continue;
}
if(!strcmp("-ignore-mult-inc",argv[i])) {
ignore_multinc=1;
continue;
}
if(!strcmp("-nocase",argv[i])) {
nocase=1;
continue;
}
if(!strcmp("-noesc",argv[i])) {
esc_sequences=0;
continue;
}
if(!strcmp("-nosym",argv[i])) {
no_symbols=1;
continue;
}
if(!strncmp("-nowarn=",argv[i],8)) {
int wno;
sscanf(argv[i]+8,"%i",&wno);
disable_warning(wno);
continue;
}
else if(!strcmp("-w",argv[i])) {
no_warn=1;
continue;
}
if(!strncmp("-maxerrors=",argv[i],11)) {
sscanf(argv[i]+11,"%i",&max_errors);
continue;
}
else if(!strcmp("-pic",argv[i])) {
pic_check=1;
continue;
}
if(cpu_args(argv[i]))
continue;
if(syntax_args(argv[i]))
continue;
if(output_args(argv[i]))
continue;
if (!strncmp("-x",argv[i],2)) {
auto_import=0;
continue;
}
general_error(14,argv[i]);
}
if(inname) {
setfilename(inname);
setdebugname(inname);
include_source(inname);
} else
general_error(15);
if(!init_parse())
general_error(10,"parse");
if(!init_syntax())
general_error(10,"syntax");
if(!init_cpu())
general_error(10,"cpu");
parse();
if(errors==0||produce_listing)
resolve();
if(errors==0||produce_listing)
assemble();
if(errors==0&&!auto_import)
undef_syms();
if(!listname)
listname="a.lst";
if(produce_listing)
write_listing(listname);
if(!outname)
outname="a.out";
if(errors==0) {
if(verbose)
statistics();
outfile=fopen(outname,"wb");
if(!outfile)
general_error(13,outname);
write_object(outfile,first_section,first_symbol);
}
leave();
return 0; /* not reached */
}
void ArtemisWebPage::javaScriptAlert(QWebFrame*, const QString& msg)
{
statistics()->accumulate("WebKit::alerts", 1);
qDebug() << "JAVASCRIPT ALERT: " << msg;
}
