ScXMLElt *
ScXMLLogEltReader::read(ScXMLElt * container, cc_xml_elt * xmlelt, ScXMLDocument * COIN_UNUSED_ARG(doc), ScXMLStateMachine * COIN_UNUSED_ARG(sm))
{
assert(container && xmlelt);
ScXMLLogElt * log = new ScXMLLogElt;
log->setContainer(container);
this->setXMLAttributes(log, xmlelt);
// handle XML attributes
if (unlikely(!log->handleXMLAttributes())) {
delete log;
return NULL;
}
const int numchildren = cc_xml_elt_get_num_children(xmlelt);
for (int c = 0; c < numchildren; ++c) {
cc_xml_elt * element = cc_xml_elt_get_child(xmlelt, c);
const char * elementtype = cc_xml_elt_get_type(element);
if (strcmp(elementtype, COIN_XML_CDATA_TYPE) == 0) {
// ignore CDATA
continue;
}
SoDebugError::post("ScXMLElseEltReader::read",
"<log> contains unexpected <%s> element", elementtype);
delete log;
return NULL;
}
return log;
}
ScXMLDataObj *
ScXMLEqualsOpExprDataObj::createFor(ScXMLDataObj * lhs, ScXMLDataObj * rhs)
{
if (lhs->getTypeId() == ScXMLRealDataObj::getClassTypeId() &&
rhs->getTypeId() == ScXMLRealDataObj::getClassTypeId()) {
ScXMLRealDataObj * reallhs = static_cast<ScXMLRealDataObj *>(lhs);
ScXMLRealDataObj * realrhs = static_cast<ScXMLRealDataObj *>(rhs);
ScXMLBoolDataObj * folded =
new ScXMLBoolDataObj(reallhs->getReal() == realrhs->getReal() ? TRUE : FALSE);
delete lhs;
delete rhs;
return folded;
}
if (lhs->getTypeId() == ScXMLBoolDataObj::getClassTypeId() &&
rhs->getTypeId() == ScXMLBoolDataObj::getClassTypeId()) {
ScXMLBoolDataObj * boollhs = static_cast<ScXMLBoolDataObj *>(lhs);
ScXMLBoolDataObj * boolrhs = static_cast<ScXMLBoolDataObj *>(rhs);
ScXMLBoolDataObj * folded =
new ScXMLBoolDataObj(boollhs->getBool() == boolrhs->getBool() ? TRUE : FALSE);
delete lhs;
delete rhs;
return folded;
}
if (lhs->getTypeId() == ScXMLStringDataObj::getClassTypeId() &&
rhs->getTypeId() == ScXMLStringDataObj::getClassTypeId()) {
ScXMLStringDataObj * stringlhs = static_cast<ScXMLStringDataObj *>(lhs);
ScXMLStringDataObj * stringrhs = static_cast<ScXMLStringDataObj *>(rhs);
ScXMLBoolDataObj * folded =
new ScXMLBoolDataObj(strcmp(stringlhs->getString(), stringrhs->getString()) == 0 ? TRUE : FALSE);
delete lhs;
delete rhs;
return folded;
}
return new ScXMLEqualsOpExprDataObj(lhs, rhs);
}
unsigned int GpgSignKeyEditInteractor::nextState( unsigned int status, const char * args, Error & err ) const {
d->started = true;
using namespace GpgSignKeyEditInteractor_Private;
static const Error GENERAL_ERROR = Error::fromCode( GPG_ERR_GENERAL );
//static const Error INV_TIME_ERROR = Error::fromCode( GPG_ERR_INV_TIME );
static const TransitionMap table( makeTable() );
if ( needsNoResponse( status ) ) {
return state();
}
using namespace GpgSignKeyEditInteractor_Private;
//lookup transition in map
const TransitionMap::const_iterator it = table.find( make_tuple( static_cast<SignKeyState>( state() ), status, std::string( args ) ) );
if ( it != table.end() ) {
return it->second;
}
//handle cases that cannot be handled via the map
switch ( const unsigned int st = state() ) {
case UIDS_ANSWER_SIGN_ALL:
if ( status == GPGME_STATUS_GET_LINE &&
strcmp( args, "keyedit.prompt" ) == 0 ) {
if ( !d->signAll() ) {
return UIDS_LIST_SEPARATELY;
}
err = Error::fromCode( GPG_ERR_UNUSABLE_PUBKEY );
return ERROR;
}
break;
default:
if ( st >= UIDS_LIST_SEPARATELY && st < UIDS_LIST_SEPARATELY_DONE ) {
if ( status == GPGME_STATUS_GET_LINE &&
strcmp( args, "keyedit.prompt" ) == 0 ) {
return d->allUserIDsListed() ? UIDS_LIST_SEPARATELY_DONE : st+1 ;
}
}
break;
case CONFIRM:
case ERROR:
err = lastError();
return ERROR;
}
err = GENERAL_ERROR;
return ERROR;
}
SbBool
ScXMLEqualsOpExprDataObj::evaluateNow(ScXMLStateMachine * sm, ScXMLDataObj *& pointer) const
{
assert(this->lhs && this->rhs);
ScXMLDataObj * lhsevaled = NULL, * rhsevaled = NULL;
if (this->lhs->isOfType(ScXMLExprDataObj::getClassTypeId())) {
ScXMLExprDataObj * lhsexpr = static_cast<ScXMLExprDataObj *>(this->lhs);
ScXMLDataObj * evaled = lhsexpr->evaluate(sm);
if (!evaled) {
return FALSE;
}
lhsevaled = evaled;
}
else {
lhsevaled = this->lhs;
}
if (this->rhs->isOfType(ScXMLExprDataObj::getClassTypeId())) {
ScXMLExprDataObj * rhsexpr = static_cast<ScXMLExprDataObj *>(this->rhs);
ScXMLDataObj * evaled = rhsexpr->evaluate(sm);
if (!evaled) { return FALSE; }
rhsevaled = evaled;
}
else {
rhsevaled = this->rhs;
}
if (lhsevaled->getTypeId() == rhsevaled->getTypeId()) {
if (lhsevaled->getTypeId() == ScXMLBoolDataObj::getClassTypeId()) {
ScXMLBoolDataObj * boollhs = static_cast<ScXMLBoolDataObj *>(lhsevaled);
ScXMLBoolDataObj * boolrhs = static_cast<ScXMLBoolDataObj *>(rhsevaled);
if (boollhs->getBool() == boolrhs->getBool()) {
pointer = new ScXMLBoolDataObj(TRUE);
return TRUE;
}
}
else if (lhsevaled->getTypeId() == ScXMLRealDataObj::getClassTypeId()) {
ScXMLRealDataObj * reallhs = static_cast<ScXMLRealDataObj *>(lhsevaled);
ScXMLRealDataObj * realrhs = static_cast<ScXMLRealDataObj *>(rhsevaled);
// FIXME: use epsilon comparison?
if (reallhs->getReal() == realrhs->getReal()) {
pointer = new ScXMLBoolDataObj(TRUE);
return TRUE;
}
}
else if (lhsevaled->getTypeId() == ScXMLStringDataObj::getClassTypeId()) {
ScXMLStringDataObj * stringlhs = static_cast<ScXMLStringDataObj *>(lhsevaled);
ScXMLStringDataObj * stringrhs = static_cast<ScXMLStringDataObj *>(rhsevaled);
if (strcmp(stringlhs->getString(), stringrhs->getString()) == 0) {
pointer = new ScXMLBoolDataObj(TRUE);
return TRUE;
}
}
}
pointer = new ScXMLBoolDataObj(FALSE);
return TRUE;
}
void LiLFeSRegEx::addFlags( FSP arg ) {
while ( arg.GetType() != nil ) {
if ( arg.GetType() == cons ) {
FSP p = arg.Follow( hd );
arg = arg.Follow( tl );
if ( p.IsString() ) {
const char* option = p.ReadString();
if ( strcmp( option, "ICASE" ) == 0 ) {
cflags |= REG_ICASE;
} else if ( strcmp( option, "i" ) == 0 ) {
cflags |= REG_ICASE;
} else if ( strcmp( option, "NEWLINE" ) == 0 ) {
cflags |= REG_NEWLINE;
} else if ( strcmp( option, "NOTBOL" ) == 0 ) {
eflags |= REG_NOTBOL;
} else if ( strcmp( option, "NOTEOL" ) == 0 ) {
eflags |= REG_NOTEOL;
} else if ( strcmp( option, "GLOBAL" ) == 0 ) {
global = true;
} else if ( strcmp( option, "g" ) == 0 ) {
global = true;
} else {
string msg( "Invalid option for regex: " );
msg.append( option );
throw LiLFeSRegExError( msg );
}
} else {
throw LiLFeSRegExError( "regex: Option must be specified with string" );
}
} else {
throw LiLFeSRegExError( "regex: Option must be specified with string" );
}
}
}
const char *windowsCharsetNameByOriginalCharset(const char *name)
{
if (strcmp(name, "Shift_JIS") == 0)
{
return "windows-932";
}
if (strcmp(name, "GB18030") == 0)
{
return "windows-936";
}
if (strcmp(name, "Big5") == 0)
{
return "windows-950";
}
if (strcmp(name, "ISO-8859-1") == 0)
{
return "windows-1252";
}
if (strcmp(name, "ISO-8859-2") == 0)
{
return "windows-1250";
}
if (strcmp(name, "windows-1251") == 0)
{
return "windows-1251";
}
if (strcmp(name, "windows-1256") == 0)
{
return "windows-1256";
}
return nullptr;
}
const ScXMLElt *
ScXMLParamElt::search(const char * attrname, const char * attrvalue) const
{
const ScXMLElt * hit = inherited::search(attrname, attrvalue);
if (hit) {
return hit;
}
if (strcmp(attrname, "name") == 0) {
if (this->name && strcmp(attrvalue, this->name) == 0) {
return this;
}
}
if (strcmp(attrname, "expr") == 0) {
if (this->expr && strcmp(attrvalue, this->expr) == 0) {
return this;
}
}
return NULL;
}
SPObject * SPObject::findFirstChild(gchar const *tagname) const
{
for (SPObject *child = children; child; child = child->next)
{
if (child->repr->type() == Inkscape::XML::ELEMENT_NODE &&
!strcmp(child->repr->name(), tagname)) {
return child;
}
}
return NULL;
}
int main(int argc, char *argv[]) {
bool pass = true;
unsigned int old_cw;
fpu_fix_start(&old_cw);
/* Parse the arguments. */
char *arg;
for (int i = 1; i < argc; i++) {
arg = argv[i];
if (strcmp(arg, "-h") == 0 || strcmp(arg, "-help") == 0) {
print_usage();
exit(0);
} else if (strcmp(arg, "-dd") == 0) {
flag_test_dd = true;
} else if (strcmp(arg, "-qd") == 0) {
flag_test_qd = true;
} else if (strcmp(arg, "-all") == 0) {
flag_test_dd = flag_test_qd = true;
} else if (strcmp(arg, "-v") == 0 || strcmp(arg, "-verbose") == 0) {
flag_verbose = true;
} else {
cerr << "Unknown flag `" << arg << "'." << endl;
}
}
/* If no flag, test both double-double and quad-double. */
if (!flag_test_dd && !flag_test_qd) {
flag_test_dd = true;
flag_test_qd = true;
}
if (flag_test_dd) {
TestSuite<dd_real> dd_test;
cout << endl;
cout << "Testing dd_real ..." << endl;
if (flag_verbose)
cout << "sizeof(dd_real) = " << sizeof(dd_real) << endl;
pass &= dd_test.testall();
}
if (flag_test_qd) {
TestSuite<qd_real> qd_test;
cout << endl;
cout << "Testing qd_real ..." << endl;
if (flag_verbose)
cout << "sizeof(qd_real) = " << sizeof(qd_real) << endl;
pass &= qd_test.testall();
}
fpu_fix_end(&old_cw);
return (pass ? 0 : 1);
}
unsigned int GpgSetExpiryTimeEditInteractor::nextState(unsigned int status, const char *args, Error &err) const
{
static const Error GENERAL_ERROR = Error::fromCode(GPG_ERR_GENERAL);
static const Error INV_TIME_ERROR = Error::fromCode(GPG_ERR_INV_TIME);
if (needsNoResponse(status)) {
return state();
}
using namespace GpgSetExpiryTimeEditInteractor_Private;
switch (state()) {
case START:
if (status == GPGME_STATUS_GET_LINE &&
strcmp(args, "keyedit.prompt") == 0) {
return COMMAND;
}
err = GENERAL_ERROR;
return ERROR;
case COMMAND:
if (status == GPGME_STATUS_GET_LINE &&
strcmp(args, "keygen.valid") == 0) {
return DATE;
}
err = GENERAL_ERROR;
return ERROR;
case DATE:
if (status == GPGME_STATUS_GET_LINE &&
strcmp(args, "keyedit.prompt") == 0) {
return QUIT;
} else if (status == GPGME_STATUS_GET_LINE &&
strcmp(args, "keygen.valid")) {
err = INV_TIME_ERROR;
return ERROR;
}
err = GENERAL_ERROR;
return ERROR;
case QUIT:
if (status == GPGME_STATUS_GET_BOOL &&
strcmp(args, "keyedit.save.okay") == 0) {
return SAVE;
}
err = GENERAL_ERROR;
return ERROR;
case ERROR:
if (status == GPGME_STATUS_GET_LINE &&
strcmp(args, "keyedit.prompt") == 0) {
return QUIT;
}
err = lastError();
return ERROR;
default:
err = GENERAL_ERROR;
return ERROR;
}
}
int main(int argc, char *argv[]) {
if (3 <= argc && argc <= 4) {
int nbytes= atoi(argv[2]);
if (nbytes <= 0) {
cerr << "bitcount: nbytes must be greater than zero\n";
return EXIT_FAILURE;
}
int nthreads= (argc > 3) ? atoi(argv[3]) : 0;
if (nthreads < 0) {
cerr << "bitcount: nthreads must not be less than zero\n";
return EXIT_FAILURE;
}
vector<unsigned char> space(atol(argv[2]));
fillMemory(space);
if (strcmp(argv[1], "shift") == 0) {
if (nthreads == 0)
cout << bitCount(&space[0], space.size(), bits_shift);
else
cout << bitCount_mt(&space[0], space.size(), nthreads, bits_shift);
cout << endl;
return EXIT_SUCCESS;
}
if (strcmp(argv[1], "lookup") == 0) {
if (nthreads == 0)
cout << bitCount(&space[0], space.size(), bits_lookup);
else
cout << bitCount_mt(&space[0], space.size(), nthreads, bits_lookup);
cout << endl;
return EXIT_SUCCESS;
}
}
cerr << "Usage: bitcount [shift|lookup] nbytes [nthreads]\n";
return EXIT_FAILURE;
}
ScXMLDocument *
ScXMLDocument::readXMLData(cc_xml_doc * xmldoc)
{
// get a handle on the root element
cc_xml_elt * root = cc_xml_doc_get_root(xmldoc);
if (unlikely(strcmp(cc_xml_elt_get_type(root), "scxml") != 0)) {
SoDebugError::post("ScXMLDocument::readXMLData",
"expected root to be an <scxml> element, not '%s'",
cc_xml_elt_get_type(root));
return NULL;
}
ScXMLEltReader * reader = ScXMLScxmlElt::getElementReader();
ScXMLDocument * scxmldoc = new ScXMLDocument;
ScXMLElt * elt = reader->read(NULL, root, scxmldoc, NULL);
if (unlikely(!elt)) {
delete scxmldoc;
return NULL;
}
assert(elt->isOfType(ScXMLScxmlElt::getClassTypeId()));
scxmldoc->setRoot(static_cast<ScXMLScxmlElt *>(elt));
return scxmldoc;
}
const ScXMLElt *
ScXMLLogElt::search(const char * attrname, const char * attrvalue) const
{
const ScXMLElt * hit = inherited::search(attrname, attrvalue);
if (hit) {
return hit;
}
if (strcmp(attrname, "label") == 0) {
if (this->label && strcmp(attrvalue, this->label) == 0) {
return this;
}
}
else if (strcmp(attrname, "expr") == 0) {
if (this->expr && strcmp(attrvalue, this->expr) == 0) {
return this;
}
}
else if (strcmp(attrname, "level") == 0) {
if (this->level && strcmp(attrvalue, this->level) == 0) {
return this;
}
}
return NULL;
}
bool parseCinematic(Cinematic * c, const char * data, size_t size) {
const char * cinematicId = safeGetString(data, size);
if(!cinematicId) {
LogError << "error parsing file magic number";
return false;
}
if(strcmp(cinematicId, "KFA")) {
LogError << "wrong magic number";
return false;
}
s32 version;
if(!safeGet(version, data, size)) {
LogError << "error reading file version";
return false;
}
LogDebug("version " << version);
if(version < CINEMATIC_VERSION_1_75) {
LogError << "too old version " << version << " expected at least " << CINEMATIC_VERSION_1_75;
}
if(version > CINEMATIC_VERSION_1_76) {
LogError << "wrong version " << version << " expected max " << CINEMATIC_VERSION_1_76;
return false;
}
// Ignore a string.
safeGetString(data, size);
// Load bitmaps.
s32 nbitmaps;
if(!safeGet(nbitmaps, data, size)) {
LogError << "error reading bitmap count";
return false;
}
LogDebug(nbitmaps << " images:");
c->m_bitmaps.reserve(nbitmaps);
for(int i = 0; i < nbitmaps; i++) {
s32 scale = 0;
if(!safeGet(scale, data, size)) {
LogError << "error reading bitmap scale";
return false;
}
const char * str = safeGetString(data, size);
if(!str) {
LogError << "error reading bitmap path";
return false;
}
LogDebug(" - " << i << ": \"" << str << '"');
res::path path = fixTexturePath(str);
LogDebug(" => " << path << " (scale x" << scale << ')');
CinematicBitmap * newBitmap = CreateCinematicBitmap(path, scale);
if(newBitmap) {
c->m_bitmaps.push_back(newBitmap);
}
}
// Load sounds.
s32 nsounds;
if(!safeGet(nsounds, data, size)) {
LogError << "error reading sound count";
return false;
}
LogDebug(nsounds << " sounds:");
for(int i = 0; i < nsounds; i++) {
if(version >= CINEMATIC_VERSION_1_76) {
s16 ignored;
if(!safeGet(ignored, data, size)) {
LogError << "error reading sound id";
return false;
}
}
const char * str = safeGetString(data, size);
if(!str) {
LogError << "error reading sound path";
return false;
}
LogDebug(" - " << i << ": \"" << str << '"');
std::pair<res::path, bool> path = fixSoundPath(str);
LogDebug(" => " << path.first << (path.second ? " (speech)" : ""));
AddSoundToList(path.first, path.second);
}
// Load track and keys.
SavedCinematicTrack t;
if(!safeGet(t, data, size)) {
LogError << "error reading track";
return false;
}
AllocTrack(t.startframe, t.endframe, t.fps);
LogDebug(t.nbkey << " keyframes:");
for(int i = 0; i < t.nbkey; i++) {
C_KEY k;
int idsound;
if(version <= CINEMATIC_VERSION_1_75) {
C_KEY_1_75 k175;
if(!safeGet(k175, data, size)) {
LogError << "error reading key v1.75";
return false;
}
k.angz = k175.angz;
k.color = k175.color;
k.colord = k175.colord;
k.colorf = k175.colorf;
k.frame = k175.frame;
k.fx = k175.fx;
k.numbitmap = k175.numbitmap;
k.pos = k175.pos;
k.speed = k175.speed;
k.typeinterp = k175.typeinterp;
k.force = k175.force;
idsound = k175.idsound;
k.idsound = -1;
k.light = k175.light;
k.posgrille = k175.posgrille;
k.angzgrille = k175.angzgrille;
k.speedtrack = k175.speedtrack;
} else {
C_KEY_1_76 k176;
if(!safeGet(k176, data, size)) {
LogError << "error reading key v1.76";
return false;
}
k.angz = k176.angz;
k.color = k176.color;
k.colord = k176.colord;
k.colorf = k176.colorf;
k.frame = k176.frame;
k.fx = k176.fx;
k.numbitmap = k176.numbitmap;
k.pos = k176.pos;
k.speed = k176.speed;
k.typeinterp = k176.typeinterp;
k.force = k176.force;
k.light = k176.light;
k.posgrille = k176.posgrille;
k.angzgrille = k176.angzgrille;
k.speedtrack = k176.speedtrack;
idsound = k176.idsound[0]; // 0 was the language code for 'French'
k.idsound = k176.idsound[3]; // 3 was the language code for 'English'
}
if(k.force < 0) {
k.force = 1;
}
FillKeyTemp(&k.pos, k.angz, k.frame, k.numbitmap, k.fx, k.typeinterp, k.color, k.colord, k.colorf, k.speed, k.idsound, k.force, &k.light, &k.posgrille, k.angzgrille, k.speedtrack);
AddKeyLoad(&KeyTemp);
LogDebug(" - " << i << ": frame " << k.frame << " image: " << k.numbitmap);
if(k.idsound >= 0) {
LogDebug(" + sound: " << k.idsound);
}
if(i == 0) {
c->pos = k.pos;
c->angz = k.angz;
c->numbitmap = k.numbitmap;
c->fx = k.fx;
c->ti = c->tichoose = k.typeinterp;
c->color = c->colorchoose = k.color;
c->colord = c->colorchoosed = k.colord;
c->colorflash = c->colorflashchoose = k.colorf;
c->speed = c->speedchoose = k.speed;
c->idsound = idsound;
c->force = k.force;
c->light = c->lightchoose = k.light;
c->posgrille = k.posgrille;
c->angzgrille = k.angzgrille;
c->speedtrack = k.speedtrack;
}
}
UpDateAllKeyLight();
SetCurrFrame(0);
GereTrackNoPlay(c);
c->projectload = true;
LogDebug("loaded cinematic");
return true;
}
int cpp_main(int argc, char *argv[])
{
for (int a = 0; a < argc; ++a)
{
command_args += argv[a];
if (a != argc-1)
command_args += ' ';
}
cout << "command line arguments: " << command_args << '\n';
cout << "*******************************************************************\n"
"* WARNING: DUMPING AND RELOADING STATE FOR RESTART NOT WORKING; *\n"
"* COMMENTED OUT CODE NEEDS TO BE FIXED TO RESTART RNG AND *\n"
"* DUMP AND RESTORE mapped_type DATA IF PRESENT. *\n"
"*******************************************************************\n\n";
for (; argc > 1; ++argv, --argc)
{
if (*argv[1] != '-')
path_prefix = argv[1];
else
{
if (strncmp(argv[1]+1, "max=", 4) == 0)
max = atol(argv[1]+5);
else if (strncmp(argv[1]+1, "min=", 4) == 0)
min = atol(argv[1]+5);
else if (strncmp(argv[1]+1, "low=", 4) == 0)
low = atol(argv[1]+5);
else if (strncmp(argv[1]+1, "high=", 5) == 0)
high = atol(argv[1]+6);
else if (strncmp(argv[1]+1, "cycles=", 7) == 0)
cycles = atol(argv[1]+8);
else if (strncmp(argv[1]+1, "seed=", 5) == 0)
rng_seed = atol(argv[1]+6);
else if (strncmp(argv[1]+1, "node=", 5) == 0)
node_sz = atol(argv[1]+6);
else if (strncmp(argv[1]+1, "cache=", 6) == 0)
cache_sz = atol(argv[1]+7);
else if (strncmp(argv[1]+1, "dump=", 5) == 0)
dump = atol(argv[1]+6);
else if (strncmp(argv[1]+1, "restart", 7) == 0)
restart = true;
else if (strcmp(argv[1]+1, "v") == 0)
verbose = true;
else if ( memcmp( argv[2]+1, "sep=", 4 )==0
&& (std::ispunct(*(argv[2]+5)) || *(argv[2]+5)== '\0') )
thou_separator = *(argv[2]+5) ? *(argv[2]+5) : ' ';
else
{
cout << "Error - unknown option: " << argv[1] << "\n\n";
argc = -1;
break;
}
}
}
if (argc < 2)
{
cout << "Usage: stl_test [Options]\n"
"The argument n specifies the number of test cases to run\n"
"Options:\n"
" path-prefix Test files path-prefix; default '" << path_prefix << "'\n"
" Two files will be created; path-prefix.btr and path-prefix.stl\n"
" -max=# Maximum number of test elements; default " << max << "\n"
" -min=# Minimum number of test elements; default " << min << "\n"
" -low=# Random key distribution low value; default 0\n"
" -high=# Random key distribution high value; default max*2.\n"
" (high-low) must be >max, so that max is reached\n"
" -cycles=# Cycle tests specified number of times; default " << cycles << "\n"
" -cycles=0 causes tests to cycle forever\n"
" -seed=# Seed for random number generator; default " << rng_seed << "\n"
" -node=# Node size (>=128); default " << node_sz << "\n"
" Small node sizes increase stress\n"
" -cache=# Cache size; default " << cache_sz << " nodes\n"
" -dump=# Dump restart files when cycles run mod dump # == 0, except \n"
" dump # -1 means dump at end only, 0 means never dump;\n"
" default " << dump << "\n"
" -restart Restart using restart files from previous run\n"
" -v Verbose output statistics\n"
" -sep=[punct] cout thousands separator; space if punct omitted, default -sep,\n"
"\n Each test cycle inserts the same random values into both a btree_map\n"
"and a std::map until the maximum number of elements is reached.\n"
"The same sequence of random elements will then be erased, until the minimum\n"
"number of elements is reached. The btree, std::map, and program state are\n"
"copied to files, and the cycle ends.\n"
" At the maximum and minimum points of each cycle, forward iteration,\n"
"backward iteration, find, lower_bound, and upper_bound tests are run\n"
"against both containers. If results are not identical, the program\n"
"issues an error message and returns 1.\n"
" The -restart argument causes the btree, std::map, and program to be\n"
"initialized to the state saved in the restart files from the prior run.\n"
;
}
if (argc == -1)
return 1;
if (high == 0)
high = max * 2;
if ((high-low) <= max)
{
cout << "Error: (high-low) must be greater than max\n";
return 1;
}
cout.imbue(std::locale(std::locale(), new thousands_separator));
tester<boost::btree::detail::set_index_string_view> testr;
testr.r_tests();
cout << "all test cycles complete" << endl;
return boost::report_errors();
}
Inkscape::XML::Node* SPObject::write(Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags) {
if (!repr && (flags & SP_OBJECT_WRITE_BUILD)) {
repr = this->getRepr()->duplicate(doc);
if (!( flags & SP_OBJECT_WRITE_EXT )) {
repr->setAttribute("inkscape:collect", NULL);
}
} else if (repr) {
repr->setAttribute("id", this->getId());
if (this->xml_space.set) {
char const *xml_space;
xml_space = sp_xml_get_space_string(this->xml_space.value);
repr->setAttribute("xml:space", xml_space);
}
if ( flags & SP_OBJECT_WRITE_EXT &&
this->collectionPolicy() == SPObject::ALWAYS_COLLECT )
{
repr->setAttribute("inkscape:collect", "always");
} else {
repr->setAttribute("inkscape:collect", NULL);
}
SPStyle const *const obj_style = this->style;
if (obj_style) {
gchar *s = sp_style_write_string(obj_style, SP_STYLE_FLAG_IFSET);
// Check for valid attributes. This may be time consuming.
// It is useful, though, for debugging Inkscape code.
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
if( prefs->getBool("/options/svgoutput/check_on_editing") ) {
unsigned int flags = sp_attribute_clean_get_prefs();
Glib::ustring s_cleaned = sp_attribute_clean_style( repr, s, flags );
g_free( s );
s = (s_cleaned.empty() ? NULL : g_strdup (s_cleaned.c_str()));
}
if( s == NULL || strcmp(s,"") == 0 ) {
repr->setAttribute("style", NULL);
} else {
repr->setAttribute("style", s);
}
g_free(s);
} else {
/** \todo I'm not sure what to do in this case. Bug #1165868
* suggests that it can arise, but the submitter doesn't know
* how to do so reliably. The main two options are either
* leave repr's style attribute unchanged, or explicitly clear it.
* Must also consider what to do with property attributes for
* the element; see below.
*/
char const *style_str = repr->attribute("style");
if (!style_str) {
style_str = "NULL";
}
g_warning("Item's style is NULL; repr style attribute is %s", style_str);
}
/** \note We treat this->style as authoritative. Its effects have
* been written to the style attribute above; any properties that are
* unset we take to be deliberately unset (e.g. so that clones can
* override the property).
*
* Note that the below has an undesirable consequence of changing the
* appearance on renderers that lack CSS support (e.g. SVG tiny);
* possibly we should write property attributes instead of a style
* attribute.
*/
sp_style_unset_property_attrs (this);
}
return repr;
}
int main(int argc, char *argv[]) {
unsigned int old_cw;
fpu_fix_start(&old_cw);
/* Parse the arguments. */
char *arg;
for (int i = 1; i < argc; i++) {
arg = argv[i];
if (strcmp(arg, "-h") == 0 || strcmp(arg, "-help") == 0) {
print_usage();
std::exit(0);
} else if (strcmp(arg, "-double") == 0) {
flag_test_double = true;
} else if (strcmp(arg, "-dd") == 0) {
flag_test_dd = true;
} else if (strcmp(arg, "-qd") == 0) {
flag_test_qd = true;
} else if (strcmp(arg, "-all") == 0) {
flag_test_double = flag_test_dd = flag_test_qd = true;
} else if (strcmp(arg, "-v") == 0) {
flag_verbose = true;
} else if (strcmp(arg, "-long") == 0) {
long_factor *= 10;
} else {
cerr << "Unknown flag `" << arg << "'." << endl;
}
}
/* If no flag, test both double-double and quad-double. */
if (!flag_test_double && !flag_test_dd && !flag_test_qd) {
flag_test_dd = true;
flag_test_qd = true;
}
if (flag_test_double) {
TestSuite<double> test;
cout << endl;
cout << "Timing double" << endl;
cout << "-------------" << endl;
test.testall();
}
if (flag_test_dd) {
TestSuite<dd_real> test;
cout << endl;
cout << "Timing dd_real" << endl;
cout << "--------------" << endl;
test.testall();
}
if (flag_test_qd) {
TestSuite<qd_real> test;
cout << endl;
cout << "Timing qd_real" << endl;
cout << "--------------" << endl;
test.testall();
}
fpu_fix_end(&old_cw);
return 0;
}
bool operator()(const char* a, const char* b) const {
return strcmp(a, b) < 0;
}
int
sc_string_old::cmp( const sc_string_old& s ) const
{
return strcmp( rep->str, s.rep->str );
}
bool operator () (const UnitTest::Test* const test) const { return strcmp(test->m_details.testName, tname) == 0; }
int
sc_string_old::cmp( const char* s ) const
{
return strcmp( rep->str, s );
}
const char* min(const char* a, const char* b) {
return (strcmp(a, b) < 0) ? a : b;
}
void lilfes_flag::ParseOptions(machine *mach, int argc, const char **argv)
{
#ifdef DEBUG
cout << "ParseOptions" << argc << endl;
#endif
int warn = 0;
#ifdef DEBUG
cout << "ParseOptions..." << argc << endl;
#endif
#ifdef DEBUG
cout << "ParseOptions " << argc << endl;
#endif
for( int i=1; i<argc; i++ )
{
#ifdef DEBUG
cout << "ParseOptions " << i << "/" << argc << " " << argv[i] << endl;
#endif
if( argv[i][0] == '-' && argv[i][1] )
{
if( argv[i][1] == '-' ) /// オプションが "--なんとか"の場合
{
const char *p = strchr(argv[i]+2, '='); //最も末尾側に出現する'='へのポインタを取得
if( p ) //'='があれば・・・
{
lilfes_flag *f = lilfes_flag::Search(string(argv[i]+2, p - (argv[i] + 2)));
if( f == NULL )
{
RUNERR( "Unknown option: --" << argv[i]+2 );
}
else
{
f->SetFlagFromString(p+1);
}
}
else
{
lilfes_flag *f = lilfes_flag::Search(argv[i]+2);
if( f == NULL )
{
RUNERR( "Unknown option: --" << argv[i]+2 );
}
else if( strcmp( (argv[i]+2), "argv" ) == 0 )
{
//lilfes_arg_flag::SetFlagFromStringArray(argc, argv, i);
//i += comargc - 1;
lilfes_arg_flag::SetFlagFromStringArray(argc-i-1, argv+i+1);
break;
}
else
{
bool ret = f->SetFlagFromString(argv[i+1]);
if( ret )
{
i++;
}
}
}
}
else /// オプションが "-なんとか"の場合
{
lilfes_flag *f = lilfes_flag::GetFlagMap(argv[i][1]);
if( f == NULL )
{
RUNERR( "Unknown option: -" << argv[i][1] );
}
else if( argv[i][1] == 'a' )
{
lilfes_arg_flag::SetFlagFromStringArray(argc-i-1, argv+i+1);
break;
}
else if( argv[i][2] )
{
f->SetFlagFromString(argv[i]+2);
}
else
{
bool ret = f->SetFlagFromString(argv[i+1]);
if( ret ) // 次のオプション文字列を消費した場合は、そいつの処理をとばしてその次へ。
{
i++;
}
}
}
}
else
{
if( !warn )
{
RUNWARN( "obsolete commandline" );
warn = 1;
}
lilfes_load_flag::pushNewModule( argv[ i ], module::NMT_INCLUDE );
}
}
#ifdef DEBUG
cout << "ParseOptions q" << endl;
#endif
for ( int i = lilfes_load_flag::getNumLoadModule() - 1; i >= 0; --i )
{
module::new_module(*mach, "command line",
lilfes_load_flag::getLoadModule( i ).c_str(),
lilfes_load_flag::getLoadModuleType( i ));
}
#ifdef DEBUG
cout << "ParseOptions r" << endl;
#endif
if( ! lilfes_flag::Search("no_user_initialize")->GetIntVal() )
{
string path;
const char *init = getenv("LILFESRC");
if( init != NULL )
{
path = init;
}
else
{
const char *path_ptr = getenv(LOCAL_INITIALIZATION_PATH_ENV);
if (path_ptr)
{
path = path_ptr;
path += PATH_SEPARATOR;
}
path += LOCAL_INITIALIZATION_FILE;
}
module::new_module(*mach, "initialization phase", path, module::NMT_INITIALIZE, module::UserModule());
}
#ifdef DEBUG
cout << "ParseOptions s" << endl;
#endif
if( ! lilfes_flag::Search("no_initialize")->GetIntVal() )
{
module::new_module(*mach, "initialization phase", GLOBAL_INITIALIZATION_FILE, module::NMT_INITIALIZE, module::UserModule());
}
#ifdef DEBUG
cout << "ParseOptions t" << endl;
#endif
#ifdef DEBUG
cout << "ParseOptions x" << endl;
#endif
}
// parse command line options
void parsecmdoptions(int argc, char *argv[], Cmdopt* cmdopt) {
if (argc < 7) { // no enough arguments
buildcontighelp();
exit(1);
}
bool tag = false;
for (int i = 1; i < argc; i += 2) { // read each option
if (strcmp(argv[i], "-m") == 0 || strcmp(argv[i], "--mapfile") == 0) { // read mapping file
cmdopt->mapfile = argv[i+1];
cmdopt->filetype = "map";
}
else if (strcmp(argv[i], "-s") == 0 || strcmp(argv[i], "--samfile") == 0) { // read mapping file
cmdopt->mapfile = argv[i+1];
cmdopt->filetype = "sam";
}
else if (strcmp(argv[i], "-r") == 0 || strcmp(argv[i], "--refseq") == 0) // ref seq file
cmdopt->reffile = argv[i+1];
else if (strcmp(argv[i], "-o") == 0 || strcmp(argv[i], "--prefix") == 0) // output prefix
cmdopt->outprefix = argv[i+1];
else if (strcmp(argv[i], "-c") == 0 || strcmp(argv[i], "--mincov") == 0) { // min depcov for outputing contigs
if (atoi(argv[i+1]) < 1)
tag = true;
cmdopt->mindepcov = atoi(argv[i+1]);
}
else if (strcmp(argv[i], "-l") == 0 || strcmp(argv[i], "--minlen") == 0) { // min length for outputing contigs
if (atoi(argv[i+1]) < 1)
tag = true;
cmdopt->minlen = atoi(argv[i+1]);
}
else if (strcmp(argv[i], "-t") == 0 || strcmp(argv[i], "--thread") == 0) { // min length for outputing contigs
if (atoi(argv[i+1]) < 1)
tag = true;
cmdopt->nump = atoi(argv[i+1]);
}
else if (strcmp(argv[i], "-b") == 0 || strcmp(argv[i], "--prof") == 0) { // print .baseprof file or not
if (argv[i+1][0] == 'T')
cmdopt->printbaseprof = true;
else if (argv[i+1][0] == 'F')
cmdopt->printbaseprof = false;
else
tag = true;
}
else if (strcmp(argv[i], "-n") == 0 || strcmp(argv[i], "--newref") == 0) { // print .newref file or not
if (argv[i+1][0] == 'T')
cmdopt->printnewref = true;
else if (argv[i+1][0] == 'F')
cmdopt->printnewref = false;
else
tag = true;
}
else if (strcmp(argv[i], "-u") == 0 || strcmp(argv[i], "--usedmap") == 0) { // print .usedmap file or not
if (argv[i+1][0] == 'T')
cmdopt->printusedmap = true;
else if (argv[i+1][0] == 'F')
cmdopt->printusedmap = false;
else
tag = true;
}
else if (strcmp(argv[i], "-k") == 0 || strcmp(argv[i], "--pickref") == 0) { // how to pick ref seq
if (strcmp(argv[i+1], "all") == 0)
cmdopt->pickref = "all";
else if (strcmp(argv[i+1], "breadth") == 0)
cmdopt->pickref = "breadth";
else if (strcmp(argv[i+1], "random") == 0)
cmdopt->pickref = "random";
else if (strcmp(argv[i+1], "depth") == 0)
cmdopt->pickref = "depth";
else
tag = true;
}
else // does not match, then something goes wrong
tag = true;
}
// these parameters must be specified
if (cmdopt->mapfile == "" || cmdopt->reffile == "" || cmdopt->outprefix == "")
tag = true;
if (tag) {
buildcontighelp();
exit(1);
}
}
void SPObject::set(unsigned int key, gchar const* value) {
g_assert(key != SP_ATTR_INVALID);
SPObject* object = this;
switch (key) {
case SP_ATTR_ID:
//XML Tree being used here.
if ( !object->cloned && object->getRepr()->type() == Inkscape::XML::ELEMENT_NODE ) {
SPDocument *document=object->document;
SPObject *conflict=NULL;
gchar const *new_id = value;
if (new_id) {
conflict = document->getObjectById((char const *)new_id);
}
if ( conflict && conflict != object ) {
if (!document->isSeeking()) {
sp_object_ref(conflict, NULL);
// give the conflicting object a new ID
gchar *new_conflict_id = sp_object_get_unique_id(conflict, NULL);
conflict->getRepr()->setAttribute("id", new_conflict_id);
g_free(new_conflict_id);
sp_object_unref(conflict, NULL);
} else {
new_id = NULL;
}
}
if (object->getId()) {
document->bindObjectToId(object->getId(), NULL);
SPObjectImpl::setId(object, 0);
}
if (new_id) {
SPObjectImpl::setId(object, new_id);
document->bindObjectToId(object->getId(), object);
}
g_free(object->_default_label);
object->_default_label = NULL;
}
break;
case SP_ATTR_INKSCAPE_LABEL:
g_free(object->_label);
if (value) {
object->_label = g_strdup(value);
} else {
object->_label = NULL;
}
g_free(object->_default_label);
object->_default_label = NULL;
break;
case SP_ATTR_INKSCAPE_COLLECT:
if ( value && !strcmp(value, "always") ) {
object->setCollectionPolicy(SPObject::ALWAYS_COLLECT);
} else {
object->setCollectionPolicy(SPObject::COLLECT_WITH_PARENT);
}
break;
case SP_ATTR_XML_SPACE:
if (value && !strcmp(value, "preserve")) {
object->xml_space.value = SP_XML_SPACE_PRESERVE;
object->xml_space.set = TRUE;
} else if (value && !strcmp(value, "default")) {
object->xml_space.value = SP_XML_SPACE_DEFAULT;
object->xml_space.set = TRUE;
} else if (object->parent) {
SPObject *parent;
parent = object->parent;
object->xml_space.value = parent->xml_space.value;
}
object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
break;
case SP_ATTR_STYLE:
sp_style_read_from_object(object->style, object);
object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
break;
default:
break;
}
}
// Is this String less than right String?
bool String::operator<( const String &right ) const
{
return strcmp( sPtr, right.sPtr ) < 0;
} // end function operator<
ScXMLElt *
ScXMLParallelEltReader::read(ScXMLElt * container, cc_xml_elt * xmlelt, ScXMLDocument * doc, ScXMLStateMachine * sm)
{
assert(container && xmlelt);
ScXMLParallelElt * parallel = new ScXMLParallelElt;
parallel->setContainer(container);
this->setXMLAttributes(parallel, xmlelt);
// handle XML attributes
if (unlikely(!parallel->handleXMLAttributes())) {
SoDebugError::post("ScXMLParallelEltReader::read",
"invalid XML attributes");
delete parallel;
return NULL;
}
const char * extref = parallel->getSrcAttribute();
if ((extref != NULL) && (extref[0] != '\0')) {
SbString reference(extref);
char * eltnameref = const_cast<char *>(strchr(reference.getString(), '#'));
if (eltnameref) {
eltnameref[0] = '\0';
++eltnameref;
}
ScXMLDocument * refdoc = ScXMLDocument::readFile(reference.getString());
if (refdoc) {
ScXMLElt * parentelt = refdoc->getRoot();
if (eltnameref) {
parentelt = refdoc->getStateById(SbName(eltnameref));
}
if (parentelt) {
if (parentelt->isOfType(ScXMLScxmlElt::getClassTypeId())) {
ScXMLScxmlElt * parent =
coin_assert_cast<ScXMLScxmlElt *>(parentelt);
int c = 0;
#if 0
if (parent->getInitial()) {
ScXMLInitialElt * initialelt =
coin_assert_cast<ScXMLInitialElt *>(parent->getInitial()->clone());
parallel->setInitial(initialelt);
}
#endif
for (c = 0; c < parent->getNumStates(); ++c) {
ScXMLStateElt * stateelt = ::ScXMLParallelNS::clone(parent->getState(c));
// coin_assert_cast<ScXMLStateElt *>(parent->getState(c)->clone());
parallel->addState(stateelt);
}
for (c = 0; c < parent->getNumParallels(); ++c) {
ScXMLParallelElt * parallelelt =
coin_assert_cast<ScXMLParallelElt *>(parent->getParallel(c)->clone());
parallel->addParallel(parallelelt);
}
for (c = 0; c < parent->getNumFinals(); ++c) {
ScXMLFinalElt * finalelt =
coin_assert_cast<ScXMLFinalElt *>(parent->getFinal(c)->clone());
parallel->addFinal(finalelt);
}
if (parent->getDataModel()) {
ScXMLDataModelElt * datamodelelt =
coin_assert_cast<ScXMLDataModelElt *>(parent->getDataModel()->clone());
parallel->setDataModel(datamodelelt);
}
#if 0
for (c = 0; c < parent->getNumScripts(); ++c) {
ScXMLScriptElt * scriptelt =
coin_assert_cast<ScXMLScriptElt *>(parent->getScript(c)->clone());
parallel->addScript(scriptelt);
}
#endif
}
else if (parentelt->isOfType(ScXMLStateElt::getClassTypeId())) {
ScXMLStateElt * parent =
coin_assert_cast<ScXMLStateElt *>(parentelt);
int c = 0;
if (parent->getOnEntry()) {
ScXMLOnEntryElt * onentryelt =
coin_assert_cast<ScXMLOnEntryElt *>(parent->getOnEntry()->clone());
parallel->setOnEntry(onentryelt);
}
if (parent->getOnExit()) {
ScXMLOnExitElt * onexitelt =
coin_assert_cast<ScXMLOnExitElt *>(parent->getOnExit()->clone());
parallel->setOnExit(onexitelt);
}
for (c = 0; c < parent->getNumTransitions(); ++c) {
ScXMLTransitionElt * transitionelt =
coin_assert_cast<ScXMLTransitionElt *>(parent->getTransition(c)->clone());
parallel->addTransition(transitionelt);
}
#if 0
if (parent->getInitial()) {
ScXMLInitialElt * initialelt =
coin_assert_cast<ScXMLInitialElt *>(parent->getInitial()->clone());
parallel->setInitial(initialelt);
}
#endif
for (c = 0; c < parent->getNumStates(); ++c) {
ScXMLStateElt * stateelt =
coin_assert_cast<ScXMLStateElt *>(parent->getState(c)->clone());
parallel->addState(stateelt);
}
for (c = 0; c < parent->getNumParallels(); ++c) {
ScXMLParallelElt * parallelelt =
coin_assert_cast<ScXMLParallelElt *>(parent->getParallel(c)->clone());
parallel->addParallel(parallelelt);
}
for (c = 0; c < parent->getNumFinals(); ++c) {
ScXMLFinalElt * finalelt =
coin_assert_cast<ScXMLFinalElt *>(parent->getFinal(c)->clone());
parallel->addFinal(finalelt);
}
for (c = 0; c < parent->getNumHistories(); ++c) {
ScXMLHistoryElt * historyelt =
coin_assert_cast<ScXMLHistoryElt *>(parent->getHistory(c)->clone());
parallel->addHistory(historyelt);
}
for (c = 0; c < parent->getNumAnchors(); ++c) {
ScXMLAnchorElt * anchorelt =
coin_assert_cast<ScXMLAnchorElt *>(parent->getAnchor(c)->clone());
parallel->addAnchor(anchorelt);
}
if (parent->getDataModel()) {
ScXMLDataModelElt * datamodelelt =
coin_assert_cast<ScXMLDataModelElt *>(parent->getDataModel()->clone());
parallel->setDataModel(datamodelelt);
}
}
else if (parentelt->isOfType(ScXMLParallelElt::getClassTypeId())) {
ScXMLParallelElt * parent =
coin_assert_cast<ScXMLParallelElt *>(parentelt);
int c = 0;
if (parent->getOnEntry()) {
ScXMLOnEntryElt * onentryelt =
coin_assert_cast<ScXMLOnEntryElt *>(parent->getOnEntry()->clone());
parallel->setOnEntry(onentryelt);
}
if (parent->getOnExit()) {
ScXMLOnExitElt * onexitelt =
coin_assert_cast<ScXMLOnExitElt *>(parent->getOnExit()->clone());
parallel->setOnExit(onexitelt);
}
for (c = 0; c < parent->getNumTransitions(); ++c) {
ScXMLTransitionElt * transitionelt =
coin_assert_cast<ScXMLTransitionElt *>(parent->getTransition(c)->clone());
parallel->addTransition(transitionelt);
}
#if 0
if (parent->getInitial()) {
ScXMLInitialElt * initialelt =
coin_assert_cast<ScXMLInitialElt *>(parent->getInitial()->clone());
parallel->setInitial(initialelt);
}
#endif
for (c = 0; c < parent->getNumStates(); ++c) {
ScXMLStateElt * stateelt =
coin_assert_cast<ScXMLStateElt *>(parent->getState(c)->clone());
parallel->addState(stateelt);
}
for (c = 0; c < parent->getNumParallels(); ++c) {
ScXMLParallelElt * parallelelt =
coin_assert_cast<ScXMLParallelElt *>(parent->getParallel(c)->clone());
parallel->addParallel(parallelelt);
}
for (c = 0; c < parent->getNumFinals(); ++c) {
ScXMLFinalElt * finalelt =
coin_assert_cast<ScXMLFinalElt *>(parent->getFinal(c)->clone());
parallel->addFinal(finalelt);
}
for (c = 0; c < parent->getNumHistories(); ++c) {
ScXMLHistoryElt * historyelt =
coin_assert_cast<ScXMLHistoryElt *>(parent->getHistory(c)->clone());
parallel->addHistory(historyelt);
}
for (c = 0; c < parent->getNumAnchors(); ++c) {
ScXMLAnchorElt * anchorelt =
coin_assert_cast<ScXMLAnchorElt *>(parent->getAnchor(c)->clone());
parallel->addAnchor(anchorelt);
}
if (parent->getDataModel()) {
ScXMLDataModelElt * datamodelelt =
coin_assert_cast<ScXMLDataModelElt *>(parent->getDataModel()->clone());
parallel->setDataModel(datamodelelt);
}
}
else if (parentelt->isOfType(ScXMLFinalElt::getClassTypeId())) {
// huh?
}
}
delete refdoc;
}
}
// read in all children, and recurse down
const int numchildren = cc_xml_elt_get_num_children(xmlelt);
for (int c = 0; c < numchildren; ++c) {
cc_xml_elt * element = cc_xml_elt_get_child(xmlelt, c);
const char * elementtype = cc_xml_elt_get_type(element);
if (strcmp(elementtype, COIN_XML_CDATA_TYPE) == 0) {
// ignore CDATA
continue;
}
if (strcmp(elementtype, "onentry") == 0) {
// <onentry> - zero or one time
if (unlikely(parallel->getOnEntry())) {
SoDebugError::post("ScXMLParallelEltReader::read",
"<parallel> elements can only have one <onentry> element");
delete parallel;
return NULL;
}
ScXMLEltReader * onentryreader = ScXMLOnEntryElt::getElementReader();
ScXMLElt * onentryobj = onentryreader->read(parallel, element, doc, sm);
if (unlikely(!onentryobj)) {
delete parallel;
return NULL;
}
assert(onentryobj->isOfType(ScXMLOnEntryElt::getClassTypeId()));
parallel->setOnEntry(static_cast<ScXMLOnEntryElt *>(onentryobj));
}
else if (strcmp(elementtype, "onexit") == 0) {
// <onexit> - zero or one time
if (unlikely(parallel->getOnExit())) {
SoDebugError::post("ScXMLParallelEltReader::read",
"<parallel> elements can only have one <onexit> element");
delete parallel;
return NULL;
}
ScXMLEltReader * onexitreader = ScXMLOnExitElt::getElementReader();
ScXMLElt * onexitobj = onexitreader->read(parallel, element, doc, sm);
if (unlikely(!onexitobj)) {
delete parallel;
return NULL;
}
assert(onexitobj->isOfType(ScXMLOnExitElt::getClassTypeId()));
parallel->setOnExit(static_cast<ScXMLOnExitElt *>(onexitobj));
}
else if (strcmp(elementtype, "transition") == 0) {
// <transition> - zero or more times
ScXMLEltReader * transitionreader = ScXMLTransitionElt::getElementReader();
ScXMLElt * transitionobj = transitionreader->read(parallel, element, doc, sm);
if (unlikely(!transitionobj)) {
delete parallel;
return NULL;
}
assert(transitionobj->isOfType(ScXMLTransitionElt::getClassTypeId()));
parallel->addTransition(static_cast<ScXMLTransitionElt *>(transitionobj));
}
else if (strcmp(elementtype, "initial") == 0) {
// <initial> - must occur iff states+parallels >= 1
if (unlikely(parallel->getInitial())) {
SoDebugError::post("ScXMLInitialEltReader::read",
"<parallel> elements can contain only one <initial> element");
delete parallel;
return NULL;
}
ScXMLEltReader * initialreader = ScXMLInitialElt::getElementReader();
ScXMLElt * initialobj = initialreader->read(parallel, element, doc, sm);
if (unlikely(!initialobj)) {
delete parallel;
return NULL;
}
assert(initialobj->isOfType(ScXMLInitialElt::getClassTypeId()));
parallel->setInitial(static_cast<ScXMLInitialElt *>(initialobj));
}
else if (strcmp(elementtype, "state") == 0) {
// <state> - zero or more times
ScXMLEltReader * statereader = ScXMLStateElt::getElementReader();
ScXMLElt * stateobj = statereader->read(parallel, element, doc, sm);
if (unlikely(!stateobj)) {
delete parallel;
return NULL;
}
assert(stateobj->isOfType(ScXMLStateElt::getClassTypeId()));
parallel->addState(static_cast<ScXMLStateElt *>(stateobj));
}
else if (strcmp(elementtype, "parallel") == 0) {
// <parallel> - zero or more times
ScXMLEltReader * parallelreader = ScXMLParallelElt::getElementReader();
ScXMLElt * parallelobj = parallelreader->read(parallel, element, doc, sm);
if (unlikely(!parallelobj)) {
delete parallel;
return NULL;
}
assert(parallelobj->isOfType(ScXMLParallelElt::getClassTypeId()));
parallel->addParallel(static_cast<ScXMLParallelElt *>(parallelobj));
}
else if (strcmp(elementtype, "final") == 0) {
// <final> - zero or more times
ScXMLEltReader * finalreader = ScXMLFinalElt::getElementReader();
ScXMLElt * finalobj = finalreader->read(parallel, element, doc, sm);
if (unlikely(!finalobj)) {
delete parallel;
return NULL;
}
assert(finalobj->isOfType(ScXMLFinalElt::getClassTypeId()));
parallel->addFinal(static_cast<ScXMLFinalElt *>(finalobj));
}
else if (strcmp(elementtype, "history") == 0) {
// <history> - zero or more times
ScXMLEltReader * historyreader = ScXMLHistoryElt::getElementReader();
ScXMLElt * historyobj = historyreader->read(parallel, element, doc, sm);
if (unlikely(!historyobj)) {
delete parallel;
return NULL;
}
assert(historyobj->isOfType(ScXMLHistoryElt::getClassTypeId()));
parallel->addHistory(static_cast<ScXMLHistoryElt *>(historyobj));
}
else if (strcmp(elementtype, "anchor") == 0) {
// <anchor> - zero or more times
ScXMLEltReader * anchorreader = ScXMLAnchorElt::getElementReader();
ScXMLElt * anchorobj = anchorreader->read(parallel, element, doc, sm);
if (unlikely(!anchorobj)) {
delete parallel;
return NULL;
}
assert(anchorobj->isOfType(ScXMLAnchorElt::getClassTypeId()));
parallel->addAnchor(static_cast<ScXMLAnchorElt *>(anchorobj));
}
else if (strcmp(elementtype, "datamodel") == 0) {
// <datamodel> - zero or one time
if (unlikely(parallel->getDataModel())) {
SoDebugError::post("ScXMLParallelEltReader::read",
"<parallel> elements can only have one <datamodel> element");
delete parallel;
return NULL;
}
ScXMLEltReader * datamodelreader = ScXMLDataModelElt::getElementReader();
ScXMLElt * datamodelobj = datamodelreader->read(parallel, element, doc, sm);
if (unlikely(!datamodelobj)) {
delete parallel;
return NULL;
}
assert(datamodelobj->isOfType(ScXMLDataModelElt::getClassTypeId()));
parallel->setDataModel(static_cast<ScXMLDataModelElt *>(datamodelobj));
}
#if 0
#if 0
// <invoke> - one time iff states+parallel == 0
else if (strcmp(elementtype, "invoke") == 0) {
ScXMLObject * invokeobj = ScXMLP::readScXMLInvokeElt(state, element, xmlns);
if (invokeobj) {
assert(invokeobj->isOfType(ScXMLInvokeElt::getClassTypeId()));
state->addInvoke(static_cast<ScXMLInvokeElt *>(invokeobj));
} else {
SoDebugError::post("ScXML::readFile", "error reading <%s> element", elementtype);
delete state;
return NULL;
}
}
#endif
#endif
else {
SoDebugError::post("ScXML::readFile",
"unexpected XML element '<%s>' found in <parallel>",
elementtype);
delete parallel;
return NULL;
}
}
return parallel;
}
int compare(const char (&p1)[N], const char (&p2)[M])
{
cout << "array template" << endl;
return strcmp(p1, p2);
}
static ExitCode parseArgs(int argc, char **argv)
{
JSLock lock;
GlobalImp *global = new GlobalImp();
// create interpreter
RefPtr<Interpreter> interp = new Interpreter(global);
// add some global extension functions
ExecState *gexec = interp->globalExec();
global->put(gexec, "print",
new TestFunctionImp(TestFunctionImp::Print, 1));
global->put(gexec, "quit",
new TestFunctionImp(TestFunctionImp::Quit, 0));
global->put(gexec, "load",
new TestFunctionImp(TestFunctionImp::Load, 1));
global->put(gexec, "gc",
new TestFunctionImp(TestFunctionImp::GC, 0));
// enable package support
StandardGlobalPackage package;
interp->setGlobalPackage(&package);
const char *script = 0, *command = 0;
int ai = 1;
bool ranOtherScript = false;
for (ai = 1; ai < argc; ++ai) {
const char *a = argv[ai];
if (strcmp(a, "-v") == 0 || strcmp(a, "-version") == 0 ||
strcmp(a, "--version") == 0) {
printf("KDE: %s\n", KJS_VERSION_STRING);
return ErrorNone;
} else if (strcmp(a, "-h") == 0 || strcmp(a, "-help") == 0 ||
strcmp(a, "--help") == 0) {
printUsage(argv[0]);
return ErrorNone;
} else if (strcmp(a, "-e") == 0) {
++ai;
if (argc <= ai) {
fprintf(stderr, "Missing -e argument.\n");
return ErrorMissingArg;
}
command = argv[ai];
++ai;
break;
} else if (strcmp(a, "-f") == 0) { // Compatibility mode, for SunSpider
++ai;
if (argc <= ai) {
fprintf(stderr, "Missing -f argument.\n");
return ErrorMissingArg;
}
ExitCode result = evaluateFile(interp.get(), argv[ai]);
if (result != ErrorNone) {
return result;
}
ranOtherScript = true;
} else if (a[0] == '-') {
fprintf(stderr, "Unknown switch %s.\n", a);
return ErrorUnknownSwitch;
} else {
script = a;
++ai;
break;
}
}
// ###
if (argc > ai) {
fprintf(stderr, "Warning: ignoring extra arguments\n");
}
if (script) {
return evaluateFile(interp.get(), script);
} else if (command) {
return evaluateString(interp.get(), "(eval)", command);
} else if (!ranOtherScript) {
return evaluateInteractive(interp.get());
}
return ErrorNone;
}
int compare(const char* const &p1, const char* const &p2)
{
cout << "specialized template" << endl;
return strcmp(p1, p2);
}
