bool kv(std::vector<KeyVal>* items, std::set<std::string>& seen)
{
std::string key;
nextword(key);
int ch = next();
if (ch == '>' && key.empty())
{
return false;
}
else if (ch == '#' && key.empty())
{
comment();
return true;
}
else if (ch != '=')
{
throw CoreException("Invalid character " + std::string(1, ch) + " in key (" + key + ")");
}
std::string value;
ch = next();
if (ch != '"')
{
throw CoreException("Invalid character in value of <" + tag->tag + ":" + key + ">");
}
while (1)
{
ch = next();
if (ch == '&' && !(flags & FLAG_USE_COMPAT))
{
std::string varname;
while (1)
{
ch = next();
if (isalnum(ch) || (varname.empty() && ch == '#'))
varname.push_back(ch);
else if (ch == ';')
break;
else
{
stack.errstr << "Invalid XML entity name in value of <" + tag->tag + ":" + key + ">\n"
<< "To include an ampersand or quote, use & or "\n";
throw CoreException("Parse error");
}
}
if (varname.empty())
throw CoreException("Empty XML entity reference");
else if (varname[0] == '#' && (varname.size() == 1 || (varname.size() == 2 && varname[1] == 'x')))
throw CoreException("Empty numeric character reference");
else if (varname[0] == '#')
{
const char* cvarname = varname.c_str();
char* endptr;
unsigned long lvalue;
if (cvarname[1] == 'x')
lvalue = strtoul(cvarname + 2, &endptr, 16);
else
lvalue = strtoul(cvarname + 1, &endptr, 10);
if (*endptr != '\0' || lvalue > 255)
throw CoreException("Invalid numeric character reference '&" + varname + ";'");
value.push_back(static_cast<char>(lvalue));
}
else
{
insp::flat_map<std::string, std::string>::iterator var = stack.vars.find(varname);
if (var == stack.vars.end())
throw CoreException("Undefined XML entity reference '&" + varname + ";'");
value.append(var->second);
}
}
else if (ch == '\\' && (flags & FLAG_USE_COMPAT))
{
int esc = next();
if (esc == 'n')
value.push_back('\n');
else if (isalpha(esc))
throw CoreException("Unknown escape character \\" + std::string(1, esc));
else
value.push_back(esc);
}
else if (ch == '"')
break;
else if (ch != '\r')
value.push_back(ch);
}
if (!seen.insert(key).second)
throw CoreException("Duplicate key '" + key + "' found");
items->push_back(KeyVal(key, value));
return true;
}
void AppEditMenu::createEditAdvancedMenu(QToolBar *toolbar)
{
editAdvancedMenu = new QMenu(tr("Advanced"));
editCommentAction=editAdvancedMenu->addAction(IconUtil::getIcon("comment"), tr("Co&mment/Uncomment"), this, SLOT(comment()), QKeySequence("Ctrl+/"));
editCommentAction->setStatusTip(tr("Comment/Uncomment line(s)"));
toolbar->addAction(editCommentAction);
editMoveUpAction=editAdvancedMenu->addAction(IconUtil::getIcon("move_up"), tr("Move &up"), this, SLOT(moveUp()), QKeySequence("Ctrl+Up"));
editMoveUpAction->setStatusTip(tr("Move lines(s) up"));
toolbar->addAction(editMoveUpAction);
editMoveDownAction=editAdvancedMenu->addAction(IconUtil::getIcon("move_down"), tr("Move &down"), this, SLOT(moveDown()), QKeySequence("Ctrl+Down"));
editMoveDownAction->setStatusTip(tr("Move lines(s) down"));
toolbar->addAction(editMoveDownAction);
editSelectBlockAction=editAdvancedMenu->addAction(tr("Select current block"), this, SLOT(selectBlock()), QKeySequence("Ctrl+B"));
editSelectBlockAction->setStatusTip(tr("Select current block"));
editToUpperCaseAction=editAdvancedMenu->addAction(tr("To upper case"), this, SLOT(toUpperCase()), QKeySequence("Ctrl+U"));
editToUpperCaseAction->setStatusTip(tr("Change selection or current word text to upper case"));
editToLowerCaseAction=editAdvancedMenu->addAction(tr("To lower case"), this, SLOT(toLowerCase()), QKeySequence("Ctrl+L"));
editToLowerCaseAction->setStatusTip(tr("Change selection or current word text to lower case"));
editCreateDuplicateAction=editAdvancedMenu->addAction(tr("Make duplicate"), this, SLOT(makeDuplicate()), QKeySequence("Ctrl+D"));
editCreateDuplicateAction->setStatusTip(tr("Create duplicate of current line or selection"));
editRemoveEmptyLinesAction=editAdvancedMenu->addAction(tr("Remove empty lines"), this, SLOT(removeEmptyLines()), QKeySequence("Ctrl+R"));
editRemoveEmptyLinesAction->setStatusTip(tr("Remove empty lines"));
editApplyCaseFoldingAction=editAdvancedMenu->addAction(tr("Apply case folding"), this, SLOT(applyCaseFolding()), QKeySequence("Ctrl+Shift+U"));
editApplyCaseFoldingAction->setStatusTip(tr("Apply automatic case folding rules to selection"));
editFormatCodeAction=editAdvancedMenu->addAction(tr("Format"), this, SLOT(formatCode()), QKeySequence("Ctrl+Shift+F"));
editFormatCodeAction->setStatusTip(tr("Auto format code to make it more readable"));
}
static void dt(int kind,
size_t minSize, size_t avgSize, size_t maxSize,
mps_count_t depth, mps_count_t fragLimit,
size_t mins, size_t maxs, int number, int iter)
{
mps_pool_t pool;
mps_ap_t ap;
int i, hd;
clock_t time0, time1;
size_t size;
int secs;
asserts(number <= MAXNUMBER, "number too big");
time0 = clock();
asserts(time0 != -1, "processor time not available");
die(
mps_pool_create(&pool, arena, mps_class_mv2(),
minSize, avgSize, maxSize, depth, fragLimit),
"create MV2 pool");
die(mps_ap_create(&ap, pool, mps_rank_ambig()), "create ap");
for(hd=0; hd<number; hd++)
{
size = ranrange(mins, maxs);
if ((ranint(2) && (kind & 2)) || (kind==DUMMY))
{
queue[hd].addr=NULL;
}
else
{
die(mv2_alloc(&queue[hd].addr, ap, size), "alloc");
setobj(queue[hd].addr, size, (unsigned char) (hd%256));
queue[hd].size = size;
}
};
hd=-1;
for(i=0; i<iter; i++)
{
if (kind & 1) hd = ranint(number);
else {ranint(number); hd=(hd+1)%number;} /* call raninit anyway
to use same time */
if (queue[hd].addr != NULL)
{
asserts(chkobj(queue[hd].addr, queue[hd].size, (unsigned char) (hd%256)),
"corrupt at %x (%s: %x, %x, %x, %i, %i, %x, %x, %i, %i)",
queue[hd].addr,
tdesc[kind], (int) minSize, (int) avgSize, (int) maxSize,
(int) depth, (int) fragLimit,
(int) mins, (int) maxs, number, iter);
mps_free(pool, queue[hd].addr, queue[hd].size);
}
size = ranrange(mins, maxs);
if ((ranint(2) && (kind & 2)) || (kind==DUMMY))
{
queue[hd].addr=NULL;
}
else
{
die(mv2_alloc(&queue[hd].addr, ap, size),"alloc");
setobj(queue[hd].addr, size, (unsigned char) (hd%256));
queue[hd].size = size;
}
}
mps_pool_destroy(pool);
time1=clock();
secs=(int) 100*(time1-time0)/CLOCKS_PER_SEC;
comment("%s test (%x, %x, %x, %i, %i, %x, %x, %i, %i) in %i centisecs",
tdesc[kind], (int) minSize, (int) avgSize, (int) maxSize,
(int) depth, (int) fragLimit,
(int) mins, (int) maxs, number, iter, secs);
}
static void test(void) {
long int i;
long int rsize;
int inramp;
mycell *r, *s;
cdie(mps_arena_create(&arena, mps_arena_class_vm(),
(size_t) ARENALIMIT),
"create arena");
cdie(mps_thread_reg(&thread, arena), "register thread");
cdie(
mps_root_create_reg(&root, arena, mps_rank_ambig(), 0, thread,
mps_stack_scan_ambig, stackpointer, 0),
"create root");
cdie(
mps_root_create_table(&root1, arena, mps_rank_exact(), 0, &objtab[0], TABSIZE),
"create root table");
cdie(
mps_fmt_create_A(&format, arena, &fmtA),
"create format");
cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create");
cdie(
mps_pool_create(&poolamc, arena, mps_class_amc(), format, chain),
"create pool");
cdie(
mps_ap_create(&apamc, poolamc, mps_rank_exact()),
"create ap");
inramp = 0;
for (i = 0; i < ITERATIONS; i++) {
if (i % 10000 == 0) {
comment("%ld of %ld", i, ITERATIONS);
}
alloc_back();
if (inramp) {
s = allocone(apamc, 3, mps_rank_exact());
setref(r, 0, s);
setref(s, 1, r);
r = s;
s = allocdumb(apamc, RAMPSIZE, mps_rank_exact());
setref(r, 2, s);
rsize ++;
if (ranint(LEAVERAMP) == 0) {
r = allocone(apamc, 2, mps_rank_exact());
s = allocone(apamc, 2, mps_rank_exact());
#ifdef RAMP_INTERFACE
mps_ap_alloc_pattern_end(apamc, mps_alloc_pattern_ramp());
#endif
#ifdef COLLECT_WORLD
mps_arena_collect(arena);
mps_arena_release(arena);
#endif
comment("ramp end, %ld objects", rsize);
inramp = 0;
}
} else {
if (ranint(ENTERRAMP) == 0) {
#ifdef RAMP_INTERFACE
mps_ap_alloc_pattern_begin(apamc, mps_alloc_pattern_ramp());
#endif
comment("ramp begin");
r = allocone(apamc, 3, mps_rank_exact());
inramp = 1;
rsize = 0;
}
}
}
mps_ap_destroy(apamc);
comment("Destroyed ap.");
mps_pool_destroy(poolamc);
comment("Destroyed pool.");
mps_fmt_destroy(format);
comment("Destroyed format.");
mps_chain_destroy(chain);
comment("Destroyed chain.");
mps_root_destroy(root1);
mps_root_destroy(root);
comment("Destroyed roots.");
mps_thread_dereg(thread);
comment("Deregistered thread.");
mps_arena_destroy(arena);
comment("Destroyed arena.");
}
static void test(void) {
mycell *p, *q;
int i;
mps_res_t res;
size_t lim0, avail0, lim1, avail1, commit1, lim2, avail2, commit2;
size_t lim3, avail3, commit3, lim4, avail4, commit4;
size_t lim5, avail5, commit5, lim6, avail6, commit6;
cdie(mps_arena_create(&arena, mps_arena_class_vm(), ARENA_SIZE),
"create space");
cdie(mps_thread_reg(&thread, arena), "register thread");
cdie(mps_root_create_reg(&root, arena, MPS_RANK_AMBIG, 0, thread,
mps_stack_scan_ambig, stackpointer, 0), "create stack root");
cdie(
mps_fmt_create_A(&format, arena, &fmtA),
"create format");
cdie(
mps_pool_create(&poolsnc, arena, mps_class_snc(), format),
"create pool");
cdie(
mps_ap_create(&apsnc, poolsnc, MPS_RANK_EXACT),
"create ap");
report("lim0", "%d", lim0 = mps_reservoir_limit(arena));
report("avail0", "%d", avail0 = mps_reservoir_available(arena));
mps_reservoir_limit_set(arena, (size_t) 0);
mps_reservoir_limit_set(arena, (size_t) (5ul*1024*1024));
report("lim1", "%d", lim1 = mps_reservoir_limit(arena));
report("avail1", "%d", avail1 = mps_reservoir_available(arena));
report("commit1", "%d", commit1 = arena_committed_and_used(arena));
report("defecit1", "%d", lim1-avail1);
mps_reservoir_limit_set(arena, (size_t) (1045));
report("lim2", "%d", lim2 = mps_reservoir_limit(arena));
report("avail2", "%d", avail2 = mps_reservoir_available(arena));
report("commit2", "%d", commit2 = arena_committed_and_used(arena));
report("defecit2", "%d", lim2-avail2);
/* set commit limit to whatever is currently committed plus 1 MB
*/
die(mps_arena_commit_limit_set(arena, arena_committed_and_used(arena)+1024*1024), "commit limit set");
mps_reservoir_limit_set(arena, (size_t) (10ul*1024*1024));
report("lim3", "%d", lim3 = mps_reservoir_limit(arena));
report("avail3", "%d", avail3 = mps_reservoir_available(arena));
report("commit3", "%d", commit3 = arena_committed_and_used(arena));
report("defecit3", "%d", lim3-avail3);
report("spill3", "%d", commit3-mps_arena_commit_limit(arena));
/* now raise it by 1/2 MB -- reservoir should grow
*/
die(mps_arena_commit_limit_set(arena, arena_committed_and_used(arena)+512*1024), "commit limit set");
report("lim4", "%d", lim4 = mps_reservoir_limit(arena));
report("avail4", "%d", avail4 = mps_reservoir_available(arena));
report("commit4", "%d", commit4 = arena_committed_and_used(arena));
report("grow4", "%d", avail4-avail3);
report("spill4", "%d", commit4-mps_arena_commit_limit(arena));
/* try some allocation -- more than a small amount should fail
*/
i = -1;
p = NULL;
res = MPS_RES_OK;
while (res == MPS_RES_OK) {
res = allocrone(&q, apsnc, 10, MPS_RANK_EXACT);
if (res == MPS_RES_OK) {
setref(q, 0, p);
p = q;
}
i++;
}
report("allocfail", "%d", i);
report_res("failres", res);
/* available shouldn't have changed since before allocation
*/
report("lim5", "%d", lim5 = mps_reservoir_limit(arena));
report("avail5", "%d", avail5 = mps_reservoir_available(arena));
report("commit5", "%d", commit5 = arena_committed_and_used(arena));
report("grow5", "%d", avail5-avail4);
report("spill5", "%d", commit5-mps_arena_commit_limit(arena));
/* try some allocation from reservoir -- not much should fail
*/
i = -1;
res = MPS_RES_OK;
while (res == MPS_RES_OK) {
res = reservoir_allocrone(&q, apsnc, 10, MPS_RANK_EXACT);
if (res == MPS_RES_OK) {
setref(q, 0, p);
p = q;
}
i++;
}
report("allocfail2", "%d", i);
report_res("failres2", res);
/* available should have changed now
*/
report("lim6", "%d", lim6 = mps_reservoir_limit(arena));
report("avail6", "%d", avail6 = mps_reservoir_available(arena));
report("commit6", "%d", commit6 = arena_committed_and_used(arena));
report("spill6", "%d", commit6-mps_arena_commit_limit(arena));
report("shrink6", "%d", avail5-avail6);
mps_root_destroy(root);
comment("Destroyed root.");
mps_ap_destroy(apsnc);
comment("Destroyed ap.");
mps_pool_destroy(poolsnc);
comment("Destroyed pool.");
mps_fmt_destroy(format);
comment("Destroyed format.");
mps_thread_dereg(thread);
comment("Deregistered thread.");
mps_arena_destroy(arena);
comment("Destroyed space.");
}
void string_instrumentationt::do_format_string_read(
goto_programt &dest,
goto_programt::const_targett target,
const code_function_callt::argumentst &arguments,
unsigned format_string_inx,
unsigned argument_start_inx,
const std::string &function_name)
{
const exprt &format_arg = arguments[format_string_inx];
if(format_arg.id()==ID_address_of &&
format_arg.op0().id()==ID_index &&
format_arg.op0().op0().id()==ID_string_constant)
{
format_token_listt token_list=
parse_format_string(format_arg.op0().op0().get_string(ID_value));
unsigned args=0;
for(format_token_listt::const_iterator it=token_list.begin();
it!=token_list.end();
it++)
{
if(it->type==format_tokent::STRING)
{
const exprt &arg = arguments[argument_start_inx+args];
const typet &arg_type = ns.follow(arg.type());
if(arg.id()!=ID_string_constant) // we don't need to check constants
{
goto_programt::targett assertion=dest.add_instruction();
assertion->source_location=target->source_location;
assertion->source_location.set_property_class("string");
std::string comment("zero-termination of string argument of ");
comment += function_name;
assertion->source_location.set_comment(comment);
exprt temp(arg);
if(arg_type.id()!=ID_pointer)
{
index_exprt index;
index.array()=temp;
index.index()=gen_zero(index_type());
index.type()=arg_type.subtype();
temp=address_of_exprt(index);
}
assertion->make_assertion(is_zero_string(temp));
}
}
if(it->type!=format_tokent::TEXT &&
it->type!=format_tokent::UNKNOWN) args++;
if(find(it->flags.begin(), it->flags.end(), format_tokent::ASTERISK)!=
it->flags.end())
args++; // just eat the additional argument
}
}
else // non-const format string
{
goto_programt::targett format_ass=dest.add_instruction();
format_ass->make_assertion(is_zero_string(arguments[1]));
format_ass->source_location=target->source_location;
format_ass->source_location.set_property_class("string");
std::string comment("zero-termination of format string of ");
comment += function_name;
format_ass->source_location.set_comment(comment);
for(unsigned i=2; i<arguments.size(); i++)
{
const exprt &arg = arguments[i];
const typet &arg_type=ns.follow(arguments[i].type());
if(arguments[i].id()!=ID_string_constant &&
is_string_type(arg_type))
{
goto_programt::targett assertion=dest.add_instruction();
assertion->source_location=target->source_location;
assertion->source_location.set_property_class("string");
std::string comment("zero-termination of string argument of ");
comment += function_name;
assertion->source_location.set_comment(comment);
exprt temp(arg);
if(arg_type.id()!=ID_pointer)
{
index_exprt index;
index.array()=temp;
index.index()=gen_zero(index_type());
index.type()=arg_type.subtype();
temp=address_of_exprt(index);
}
assertion->make_assertion(is_zero_string(temp));
}
}
}
}
int main(int argc, char * const *argv1)
{
int ch;
const char *arff_fn = 0;
const char *text_fn = 0;
string *xml_fn = 0;
const char *audit_file = 0;
bool opt_x = false;
string command_line = xml::make_command_line(argc,argv1);
bool opt_zap = false;
u_int sector_size=512; // defaults to 512; may be changed by AFF
struct timeval tv0;
struct timeval tv1;
gettimeofday(&tv0,0);
TSK_TCHAR * const *argv;
#ifdef TSK_WIN32
char *opt_arg = NULL;
char *argv_0 = NULL;
argv = CommandLineToArgvW(GetCommandLineW(), &argc);
if (argv == NULL) {
fprintf(stderr,"Error getting wide arguments\n");
exit(1);
}
#else
argv = (TSK_TCHAR * const*) argv1;
#endif
while ((ch = GETOPT(argc, argv, _TSK_T("A:a:C:dfG:gmv1IMX:S:T:VZn:c:b:xOzh?"))) > 0 ) { // s: removed
switch (ch) {
case _TSK_T('1'): opt_sha1 = true;break;
case _TSK_T('m'):
opt_body_file = 1;
opt_sha1 = 0;
opt_md5 = 1;
t = stdout;
break;
case _TSK_T('A'):
#ifdef TSK_WIN32
convert(OPTARG, &opt_arg);
arff_fn = opt_arg;
#else
arff_fn = OPTARG;
#endif
break;
case _TSK_T('C'): file_count_max = TATOI(OPTARG);break;
case _TSK_T('d'): opt_debug++; break;
case _TSK_T('f'): opt_magic = true;break;
case _TSK_T('g'): opt_no_data = true; break;
case _TSK_T('b'): opt_get_fragments = false; break;
case _TSK_T('G'): opt_maxgig = TATOI(OPTARG);break;
case _TSK_T('h'): usage(); break;
case _TSK_T('I'): opt_ignore_ntfs_system_files=true;break;
case _TSK_T('M'): opt_md5 = true;
case _TSK_T('O'): opt_allocated_only=true; break;
case _TSK_T('S'):
opt_sector_hash = true;
sectorhash_size = TATOI(OPTARG); break;
case _TSK_T('T'):
#ifdef TSK_WIN32
convert(OPTARG, &opt_arg);
text_fn = opt_arg;
#else
text_fn = OPTARG;
#endif
break;
case _TSK_T('V'): print_version();exit(0);
case _TSK_T('X'):
#ifdef TSK_WIN32
convert(OPTARG, &opt_arg);
xml_fn = new string(opt_arg);
#else
xml_fn = new string(OPTARG);
#endif
break;
case _TSK_T('x'): opt_x = true;break;
case _TSK_T('Z'): opt_zap = true;break;
case _TSK_T('a'):
#ifdef TSK_WIN32
convert(OPTARG, &opt_arg);
audit_file = opt_arg;
#else
audit_file = OPTARG;
#endif
break;
case _TSK_T('c'):
#ifdef TSK_WIN32
convert(OPTARG, &opt_arg);
config_file = opt_arg;
#else
config_file = OPTARG;
#endif
break;
case _TSK_T('n'):
#ifdef TSK_WIN32
convert(OPTARG, &opt_arg);
namelist.push_back(opt_arg);
#else
namelist.push_back(OPTARG);
#endif
break;
//case 's': save_outdir = optarg; opt_save = true; break;
case _TSK_T('v'): tsk_verbose++; break; // sleuthkit option
case _TSK_T('z'): opt_sha1=false;opt_md5=false;break;
case _TSK_T('?'): usage();break;
default:
fprintf(stderr, "Invalid argument: %s\n", argv[OPTIND]);
usage();
}
}
if (OPTIND >= argc) usage();
argc -= OPTIND;
argv += OPTIND;
argv1 += OPTIND;
#ifdef TSK_WIN32
convert(argv[0],&argv_0);
const char *filename = argv_0;
#else
const char *filename = argv[0];
#endif
opt_parent_tracking = true;
if(!filename){
errx(1,"must provide filename");
}
if(opt_no_data && (opt_md5 || opt_sha1 || opt_save || opt_magic)) {
errx(1, "-g conflicts with options requiring data access (-z may be needed)");
}
if(opt_save){
if(access(save_outdir.c_str(),F_OK)){
#ifdef WIN32
if(mkdir(save_outdir.c_str())) {
#else
if(mkdir(save_outdir.c_str(),0777)){
#endif
err(1,"Cannot make directory: %s",save_outdir.c_str());
}
}
if(access(save_outdir.c_str(),R_OK)){
err(1,"Cannot access directory: %s",save_outdir.c_str());
}
}
if(text_fn){
if(access(text_fn,F_OK)==0) errx(1,"%s: file exists",text_fn);
t = fopen(text_fn,"w");
if(!t) err(1,"%s",text_fn);
}
if(arff_fn){
if(access(arff_fn,F_OK)==0) errx(1,"%s: file exists",arff_fn);
a = new arff("fiwalk"); // the ARFF output object
a->set_outfile(arff_fn);
}
/* XML initialization */
if(opt_x){
x = new xml(); // default to stdout
}
if(xml_fn){
if(*xml_fn == "0"){
string newfn = filename;
*xml_fn = newfn.substr(0,newfn.rfind(".")) + ".xml";
}
if(x) errx(1,"Cannot write XML to stdout and file at same time\n");
if(access(xml_fn->c_str(),F_OK)==0){
if(opt_zap){
if(unlink(xml_fn->c_str())){
err(1,"%s: file exists and cannot unlink",xml_fn->c_str());
}
}
else{
errx(1,"%s: file exists",xml_fn->c_str());
}
}
x = new xml(*xml_fn,true); // we will make DTD going to a file
}
/* If no output file has been specified, output text to stdout */
if(a==0 && x==0 && t==0){
t = stdout;
}
if(strstr(filename,".aff") || strstr(filename,".afd") || strstr(filename,".afm")){
#ifndef HAVE_LIBAFFLIB
fprintf(stderr,"ERROR: fiwalk was compiled without AFF support.\n");
exit(0);
#else
#endif
}
/* If we are outputing ARFF, create the ARFF object and set the file types for the file system metadata */
if(a){
a->add_attribute("id",arff::NUMERIC);
a->add_attribute("partition",arff::NUMERIC);
a->add_attribute("filesize",arff::NUMERIC);
a->add_attribute("mtime",arff::DATE);
a->add_attribute("ctime",arff::DATE);
a->add_attribute("atime",arff::DATE);
a->add_attribute("fragments",arff::NUMERIC);
a->add_attribute("frag1startsector",arff::NUMERIC);
a->add_attribute("frag2startsector",arff::NUMERIC);
a->add_attribute("filename",arff::STRING);
if(opt_md5) a->add_attribute("md5",arff::STRING);
if(opt_sha1) a->add_attribute("sha1",arff::STRING);
}
/* output per-run metadata for XML output */
if(x){
/* Output Dublin Core information */
x->push("dfxml",
"\n xmlns='http://www.forensicswiki.org/wiki/Category:Digital_Forensics_XML'"
"\n xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'"
"\n xmlns:dc='http://purl.org/dc/elements/1.1/'"
"\n version='1.0'" );
x->push("metadata", "");
x->xmlout("dc:type","Disk Image",fw_empty,false);
x->pop();
/* Output carver information per photorec standard */
x->add_DFXML_creator("fiwalk",tsk_version_get_str(),command_line);
}
/* Can't use comment until after here... */
if(config_file){
comment("Reading configuration file %s",config_file);
config_read(config_file); /* Read the configuration file */
}
/* Check that we have a valid file format */
if(x) x->push("source");
partition_info("image_filename",filename);
if(!x){
partition_info("fiwalk_version",tsk_version_get_str());
partition_info("start_time",mytime());
partition_info("tsk_version",tsk_version_get_str());
}
if(x) x->pop();
if (opt_debug) printf("calling tsk_img_open(%s)\n",filename);
#ifdef SIGINFO
signal(SIGINFO,sig_info);
#endif
#ifdef TSK_WIN32
int count = process_image_file(argc,argv1,audit_file,sector_size);
if(count<=0 || sector_size!=512){
comment("Retrying with 512 byte sector size.");
count = process_image_file(argc,argv1,audit_file,512);
}
#else
int count = process_image_file(argc,argv,audit_file,sector_size);
if(count<=0 || sector_size!=512){
comment("Retrying with 512 byte sector size.");
count = process_image_file(argc,argv,audit_file,512);
}
#endif
/* Calculate time elapsed (reported as a comment and with rusage) */
struct timeval tv;
char tvbuf[64];
gettimeofday(&tv1,0);
tv.tv_sec = tv1.tv_sec - tv0.tv_sec;
if(tv1.tv_usec > tv0.tv_usec){
tv.tv_usec = tv1.tv_usec - tv0.tv_usec;
} else {
tv.tv_sec--;
tv.tv_usec = (tv1.tv_usec+1000000) - tv0.tv_usec;
}
sprintf(tvbuf, "%d.%06d",(int)tv.tv_sec, (int)tv.tv_usec);
comment("clock: %s",tvbuf);
#ifdef HAVE_SYS_RESOURCE_H
#ifdef HAVE_GETRUSAGE
/* Print usage information */
struct rusage ru;
memset(&ru,0,sizeof(ru));
if(getrusage(RUSAGE_SELF,&ru)==0){
if(x) x->push("rusage");
partition_info("utime",ru.ru_utime);
partition_info("stime",ru.ru_stime);
partition_info("maxrss",ru.ru_maxrss);
partition_info("minflt",ru.ru_minflt);
partition_info("majflt",ru.ru_majflt);
partition_info("nswap",ru.ru_nswap);
partition_info("inblock",ru.ru_inblock);
partition_info("oublock",ru.ru_oublock);
partition_info("clocktime",tv);
comment("stop_time: %s",cstr(mytime()));
if(x) x->pop();
}
#endif
#endif
// *** Added <finished time="(time_t)" duration="<seconds>" />
if(a){
a->write();
delete a;
}
if(t) comment("=EOF=");
if(x) {
x->pop(); // <dfxml>
x->close();
delete(x);
}
exit(0);
}
bool ZInstrument::loadSfz(const QString& s)
{
_program = 0;
QFileInfo fi(s);
QString path = fi.absolutePath();
QStringList fileContents = readFile(s);
if (fileContents.empty()) {
return false;
}
SfzControl c;
c.init();
c.defines.clear();
for (int i = 0;i < 128; i++)
c.set_cc[i] = -1;
int idx = 0;
bool inBlockComment = false;
// preprocessor
while(idx < fileContents.size()) {
QRegularExpression findWithSpaces("\"(.+)\"");
QRegularExpression comment("//.*$");
QRegularExpression trailingSpacesOrTab("^[\\s\\t]*");
QRegularExpressionMatch foundWithSpaces;
QString curLine = fileContents[idx];
QString curLineCopy = curLine;
bool nextIsImportant = false;
int idxBlockComment = 0;
int from = 0;
for (QChar chr : curLineCopy) {
bool terminated = false;
if (nextIsImportant) {
nextIsImportant = false;
if (inBlockComment && chr == '/') { // found block end
inBlockComment = false;
terminated = true;
curLine.remove(from, idxBlockComment - from + 1);
idxBlockComment = from - 1;
}
else if (!inBlockComment && chr == '*') { // found block start
inBlockComment = true;
terminated = true;
from = idxBlockComment - 1;
}
}
if (!terminated && inBlockComment && chr == '*')
nextIsImportant = true;
else if (!terminated && !inBlockComment && chr == '/')
nextIsImportant = true;
idxBlockComment++;
}
if (inBlockComment)
curLine.remove(from, curLine.size() - from);
curLine = curLine.remove(comment);
curLine.remove(trailingSpacesOrTab);
fileContents[idx] = curLine;
if (curLine.startsWith("#define")) {
QStringList define = curLine.split(" ");
foundWithSpaces = findWithSpaces.match(curLine);
if (define.size() == 3)
c.defines.insert(std::pair<QString, QString>(define[1], define[2]));
else if(foundWithSpaces.hasMatch())
c.defines.insert(std::pair<QString, QString>(define[1], foundWithSpaces.captured(1)));
fileContents.removeAt(idx);
}
else if (curLine.startsWith("#include")) {
foundWithSpaces = findWithSpaces.match(curLine);
if (foundWithSpaces.hasMatch()) {
QString newFilename = foundWithSpaces.captured(1);
for(auto define : c.defines) {
newFilename.replace(define.first, define.second);
}
QStringList newFileContents = readFile(path + "/" + newFilename);
if (newFileContents.empty())
return false;
int offset = 1;
for (QString newFileLine : newFileContents) {
fileContents.insert(idx+offset, newFileLine);
offset++;
}
fileContents.removeAt(idx);
}
}
else if (curLine.isEmpty())
fileContents.removeAt(idx);
else
idx++;
}
int total = fileContents.size();
SfzRegion r;
SfzRegion g; // group
SfzRegion glob;
r.init(path);
g.init(path);
glob.init(path);
bool groupMode = false;
bool globMode = false;
zerberus->setLoadProgress(0);
for (int idx = 0; idx < fileContents.size(); idx++) {
QString curLine = fileContents[idx];
zerberus->setLoadProgress(((qreal) idx * 100) / (qreal) total);
if (zerberus->loadWasCanceled())
return false;
if (curLine.startsWith("<global>")) {
if (!globMode && !groupMode && !r.isEmpty())
addRegion(r);
glob.init(path);
g.init(path); // global also resets group
r.init(path);
globMode = true;
}
if (curLine.startsWith("<group>")) {
if (!groupMode && !globMode && !r.isEmpty())
addRegion(r);
g.init(path);
if (globMode) {
glob = r;
globMode = false;
}
else {
r = glob; // initialize group with global values
}
groupMode = true;
curLine = curLine.mid(7);
}
else if (curLine.startsWith("<region>")) {
if (groupMode) {
g = r;
groupMode = false;
}
else if (globMode) {
glob = r;
g = glob;
globMode = false;
}
else {
if (!r.isEmpty())
addRegion(r);
r = g; // initialize next region with group values
}
curLine = curLine.mid(8);
}
else if (curLine.startsWith("<control>"))
c.init();
QRegularExpression re("\\s?([\\w\\$]+)="); // defines often use the $-sign
QRegularExpressionMatchIterator i = re.globalMatch(curLine);
while (i.hasNext()) {
QRegularExpressionMatch match = i.next();
int si = match.capturedEnd();
int ei;
if (i.hasNext()) {
QRegularExpressionMatch nextMatch = i.peekNext();
ei = nextMatch.capturedStart();
}
else
ei = curLine.size();
QString s = curLine.mid(si, ei-si);
r.readOp(match.captured(1), s, c);
}
}
for (int i = 0; i < 128; i++)
_setcc[i] = c.set_cc[i];
zerberus->setLoadProgress(100);
if (!groupMode && !globMode && !r.isEmpty())
addRegion(r);
return true;
}
void
match_trail(void)
{ int i, a, nst;
Element *dothis;
char snap[512], *q;
/*
* if source model name is leader.pml
* look for the trail file under these names:
* leader.pml.trail
* leader.pml.tra
* leader.trail
* leader.tra
*/
if (trailfilename)
{ if (strlen(*trailfilename) < sizeof(snap))
{ strcpy(snap, (const char *) *trailfilename);
} else
{ fatal("filename %s too long", *trailfilename);
}
} else
{ if (ntrail)
sprintf(snap, "%s%d.trail", oFname->name, ntrail);
else
sprintf(snap, "%s.trail", oFname->name);
}
if ((fd = fopen(snap, "r")) == NULL)
{ snap[strlen(snap)-2] = '\0'; /* .tra */
if ((fd = fopen(snap, "r")) == NULL)
{ if ((q = strchr(oFname->name, '.')) != NULL)
{ *q = '\0';
if (ntrail)
sprintf(snap, "%s%d.trail",
oFname->name, ntrail);
else
sprintf(snap, "%s.trail",
oFname->name);
*q = '.';
if ((fd = fopen(snap, "r")) != NULL)
goto okay;
snap[strlen(snap)-2] = '\0'; /* last try */
if ((fd = fopen(snap, "r")) != NULL)
goto okay;
}
printf("spin: cannot find trail file\n");
alldone(1);
} }
okay:
if (xspin == 0 && newer(oFname->name, snap))
printf("spin: warning, \"%s\" is newer than %s\n",
oFname->name, snap);
Tval = 1;
/*
* sets Tval because timeouts may be part of trail
* this used to also set m_loss to 1, but that is
* better handled with the runtime -m flag
*/
hookup();
while (fscanf(fd, "%d:%d:%d\n", &depth, &pno, &nst) == 3)
{ if (depth == -2) { start_claim(pno); continue; }
if (depth == -4) { merger = 1; ana_src(0, 1); continue; }
if (depth == -1)
{ if (verbose)
{ if (columns == 2)
dotag(stdout, " CYCLE>\n");
else
dotag(stdout, "<<<<<START OF CYCLE>>>>>\n");
}
continue;
}
if (cutoff > 0 && depth >= cutoff)
{ printf("-------------\n");
printf("depth-limit (-u%d steps) reached\n", cutoff);
break;
}
if (Skip_claim && pno == 0) continue;
for (dothis = Al_El; dothis; dothis = dothis->Nxt)
{ if (dothis->Seqno == nst)
break;
}
if (!dothis)
{ printf("%3d: proc %d, no matching stmnt %d\n",
depth, pno - Have_claim, nst);
lost_trail();
}
i = nproc - nstop + Skip_claim;
if (dothis->n->ntyp == '@')
{ if (pno == i-1)
{ run = run->nxt;
nstop++;
if (verbose&4)
{ if (columns == 2)
{ dotag(stdout, "<end>\n");
continue;
}
if (Have_claim && pno == 0)
printf("%3d: claim terminates\n",
depth);
else
printf("%3d: proc %d terminates\n",
depth, pno - Have_claim);
}
continue;
}
if (pno <= 1) continue; /* init dies before never */
printf("%3d: stop error, ", depth);
printf("proc %d (i=%d) trans %d, %c\n",
pno - Have_claim, i, nst, dothis->n->ntyp);
lost_trail();
}
if (!xspin && (verbose&32))
{ printf("i=%d pno %d\n", i, pno);
}
for (X = run; X; X = X->nxt)
{ if (--i == pno)
break;
}
if (!X)
{ if (verbose&32)
{ printf("%3d: no process %d (step %d)\n", depth, pno - Have_claim, nst);
printf(" max %d (%d - %d + %d) claim %d",
nproc - nstop + Skip_claim,
nproc, nstop, Skip_claim, Have_claim);
printf("active processes:\n");
for (X = run; X; X = X->nxt)
{ printf("\tpid %d\tproctype %s\n", X->pid, X->n->name);
}
printf("\n");
continue;
} else
{ printf("%3d:\tproc %d (?) ", depth, pno);
lost_trail();
}
} else
{ X->pc = dothis;
}
lineno = dothis->n->ln;
Fname = dothis->n->fn;
if (dothis->n->ntyp == D_STEP)
{ Element *g, *og = dothis;
do {
g = eval_sub(og);
if (g && depth >= jumpsteps
&& ((verbose&32) || ((verbose&4) && not_claim())))
{ if (columns != 2)
{ p_talk(og, 1);
if (og->n->ntyp == D_STEP)
og = og->n->sl->this->frst;
printf("\t[");
comment(stdout, og->n, 0);
printf("]\n");
}
if (verbose&1) dumpglobals();
if (verbose&2) dumplocal(X);
if (xspin) printf("\n");
}
og = g;
} while (g && g != dothis->nxt);
if (X != NULL)
{ X->pc = g?huntele(g, 0, -1):g;
}
} else
void petabricks::CodeGenerator::mkCreateGpuSpatialMethodCallTask(
const std::string& transname,
const std::string& taskname,
const std::string& objname,
const std::string& methodname,
const SimpleRegion& region,
std::vector<RegionNodeGroup>& regionNodesGroups,
int nodeID,
int gpuCopyOut,
RegionList to,
bool divisible) {
std::string taskclass
;
int dim_int = region.totalDimensions();
std::string lastdim = jalib::XToString(dim_int - 1);
std::string max = region.maxCoord()[dim_int - 1]->toString();
std::string min = region.minCoord()[dim_int - 1]->toString();
if(!divisible) {
taskclass = "petabricks::CreateGpuSpatialMethodCallTask<"+objname
+ ", " + jalib::XToString(region.totalDimensions())
+ ", &" + objname + "::" + methodname + TX_OPENCL_POSTFIX + "_createtasks"
+ ">";
//beginIf(min+"<"+max);
comment("MARKER 6");
write("IndexT _tmp_begin[] = {" + region.getIterationLowerBounds() + "};");
write("IndexT _tmp_end[] = {" + region.getIterationUpperBounds() + "};");
write("RegionNodeGroupMapPtr groups = new RegionNodeGroupMap();");
for(std::vector<RegionNodeGroup>::iterator group = regionNodesGroups.begin(); group != regionNodesGroups.end(); ++group){
write("{");
incIndent();
write("std::set<int> ids;");
for(std::vector<int>::iterator id = group->nodeIDs().begin(); id != group->nodeIDs().end(); ++id){
write("ids.insert("+jalib::XToString(*id)+");");
}
write("groups->insert(RegionNodeGroup(\""+group->matrixName()+"\",ids));");
decIndent();
write("}");
}
write(taskname+" = new "+taskclass+"(this,_tmp_begin, _tmp_end, "+jalib::XToString(nodeID)+", groups, "+jalib::XToString(gpuCopyOut)+");");
//endIf();
return;
}
std::string n_div = "cont_" + jalib::XToString(_contCounter++);
write(taskname + " = new petabricks::MethodCallTask<"+_curClass+", &"+_curClass+"::"+n_div+">( this );");
// Add divider function
CodeGenerator helper = forkhelper();
helper.beginFunc("DynamicTaskPtr", n_div);
helper.write("DynamicTaskPtr _fini = new NullDynamicTask();");
// Assign the gpu-cpu division point.
helper.write("ElementT gpu_ratio = "+transname+"_gpuratio/8.0;");
std::string div = "div";
RegionPtr proxy = to.front();
helper.write("IndexT totalRow = "+proxy->matrix()->name()+".size("+jalib::XToString(dim_int - 1)+");");
helper.write("IndexT div = ceil(gpu_ratio * totalRow);");
helper.beginIf("div > " + max);
helper.write("div = "+max+";");
helper.endIf();
// GPU
taskclass = "petabricks::CreateGpuSpatialMethodCallTask<"+objname
+ ", " + jalib::XToString(dim_int)
+ ", &" + objname + "::" + methodname + TX_OPENCL_POSTFIX + "_createtasks"
+ ">";
helper.comment("MARKER 6");
//helper.beginIf(min+" < div");
helper.write("IndexT _gpu_begin[] = {" + region.getIterationLowerBounds() + "};");
helper.write("IndexT _gpu_end[] = {" + region.getIterationMiddleEnd(div) + "};");
helper.write("RegionNodeGroupMapPtr groups = new RegionNodeGroupMap();");
for(std::vector<RegionNodeGroup>::iterator group = regionNodesGroups.begin(); group != regionNodesGroups.end(); ++group){
helper.write("{");
helper.incIndent();
helper.write("std::set<int> ids;");
for(std::vector<int>::iterator id = group->nodeIDs().begin(); id != group->nodeIDs().end(); ++id){
helper.write("ids.insert("+jalib::XToString(*id)+");");
}
helper.write("groups->insert(RegionNodeGroup(\""+group->matrixName()+"\",ids));");
helper.decIndent();
helper.write("}");
}
helper.write("DynamicTaskPtr gpu_task = new "+taskclass+"(this,_gpu_begin, _gpu_end, "+jalib::XToString(nodeID)+", groups, "+jalib::XToString(gpuCopyOut)+");");
helper.write("gpu_task->enqueue();");
helper.write("_fini->dependsOn(gpu_task);");
//helper.endIf();
// CPU
taskclass = "petabricks::SpatialMethodCallTask<CLASS"
", " + jalib::XToString(dim_int)
+ ", &CLASS::" + methodname + "_workstealing_wrap"
//+ ", &CLASS::" + methodname + "_workstealing"
+ ">";
helper.beginIf("div < " + max);
helper.beginIf("div < " + min);
helper.write("div = "+min+";");
helper.endIf();
helper.comment("MARKER 6");
helper.write("IndexT _cpu_begin[] = {" + region.getIterationMiddleBegin(div) + "};");
helper.write("IndexT _cpu_end[] = {" + region.getIterationUpperBounds() + "};");
helper.write("DynamicTaskPtr cpu_task = new "+taskclass+"(this,_cpu_begin, _cpu_end);");
helper.write("cpu_task->enqueue();");
helper.write("_fini->dependsOn(cpu_task);");
helper.endIf();
helper.write("return _fini;");
helper.endFunc();
}
static void test(void)
{
mps_arena_t arena;
mps_pool_t poolamc, poollo;
mps_thr_t thread;
mps_root_t root;
mps_fmt_t format;
mps_chain_t chain;
mps_ap_t apamc, aplo;
mycell *a, *b, *c, *d, *e, *f, *g;
int i;
int j;
RC;
cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE),
"create arena");
die(mps_thread_reg(&thread, arena), "register thread");
die(mps_root_create_reg(&root, arena, mps_rank_ambig(), 0, thread,
mps_stack_scan_ambig, stackpointer, 0),
"create root");
die(mps_fmt_create_A(&format, arena, &fmtA), "create format");
cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create");
die(mmqa_pool_create_chain(&poolamc, arena, mps_class_amc(), format, chain),
"create pool(amc)");
cdie(
mps_pool_create(&poollo, arena, mps_class_lo(), format),
"create pool");
cdie(
mps_ap_create(&apamc, poolamc, mps_rank_exact()),
"create ap");
cdie(
mps_ap_create(&aplo, poollo, mps_rank_exact()),
"create ap(lo)");
b = allocone(apamc, 1, 1);
for (j=1; j<100; j++) {
comment("%i of 100.", j);
UC;
a = allocone(apamc, 5, 1);
b = a;
c = a;
d = a;
e = a;
f = a;
g = a;
for (i=1; i<5000; i++) {
UC;
c = allocone(apamc, 20, 1);
d = allocone(apamc, 20, 1);
if (ranint(8) == 0) e = c;
if (ranint(8) == 0) f = c;
if (ranint(8) == 0) g = c;
UC;
setref(b, 0, c);
UC;
setref(c, 1, d);
UC;
setref(c, 2, e);
UC;
setref(c, 3, f);
UC;
setref(c, 4, g);
UC;
b = c;
}
DC;
DMC;
}
mps_ap_destroy(apamc);
mps_ap_destroy(aplo);
comment("Destroyed aps.");
mps_pool_destroy(poolamc);
mps_pool_destroy(poollo);
comment("Destroyed pools.");
mps_chain_destroy(chain);
mps_fmt_destroy(format);
mps_root_destroy(root);
mps_thread_dereg(thread);
mps_arena_destroy(arena);
comment("Destroyed arena.");
}
static void test(void)
{
mps_arena_t arena;
mps_pool_t poolamc, poolawl;
mps_thr_t thread;
mps_root_t root, root1;
mps_fmt_t format;
mps_chain_t chain;
mps_ap_t apamc, apawl;
mycell *a, *b, *c, *d, *e, *f, *g;
int i;
int j;
cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE),
"create arena");
die(mps_thread_reg(&thread, arena), "register thread");
die(mps_root_create_reg(&root, arena, mps_rank_ambig(), 0, thread,
mps_stack_scan_ambig, stackpointer, 0),
"create root");
cdie(
mps_root_create_table(&root1,arena,mps_rank_ambig(),0,&exfmt_root,1),
"create table root");
die(mps_fmt_create_A(&format, arena, &fmtA), "create format");
die(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create");
die(mmqa_pool_create_chain(&poolamc, arena, mps_class_amc(), format, chain),
"create pool(amc)");
die(mps_pool_create(&poolawl, arena, mps_class_awl(), format, getassociated),
"create pool(awl)");
die(mps_ap_create(&apawl, poolawl, mps_rank_exact()),
"create ap(awl)");
die(mps_ap_create(&apamc, poolamc, mps_rank_exact()),
"create ap(amc)");
b = allocone(apamc, 1, mps_rank_exact());
for (j=1; j<=10; j++) {
comment("%i of 10.", j);
a = allocone(apamc, 5, mps_rank_exact());
b = a;
c = a;
d = a;
e = a;
f = a;
g = a;
for (i=1; i<=3000; i++) {
c = allocone(apamc, 20, mps_rank_exact());
d = allocone(apawl, 20, mps_rank_exact());
if (ranint(8) == 0) e = c;
if (ranint(8) == 0) f = c;
if (ranint(8) == 0) g = c;
setref(b, 0, c);
setref(c, 1, d);
setref(c, 2, e);
setref(c, 3, f);
setref(c, 4, g);
b = c;
}
}
mps_arena_park(arena);
mps_ap_destroy(apawl);
mps_ap_destroy(apamc);
mps_pool_destroy(poolamc);
mps_pool_destroy(poolawl);
mps_chain_destroy(chain);
mps_fmt_destroy(format);
mps_root_destroy(root);
mps_root_destroy(root1);
mps_thread_dereg(thread);
mps_arena_destroy(arena);
comment("Destroyed arena.");
}
static void test(void)
{
mps_pool_t poolamc, poolawl, poolamcz;
mps_thr_t thread;
mps_root_t root0, root1;
mps_fmt_t format;
mps_chain_t chain;
mps_ap_t apamc, apawl, apamcz;
mycell *a, *b, *c, *d, *z;
long int j;
cdie(mps_arena_create_k(&arena, mps_arena_class_vm(), mps_args_none),
"create arena");
cdie(mps_thread_reg(&thread, arena), "register thread");
cdie(mps_root_create_reg(&root0, arena, mps_rank_ambig(), 0, thread,
mps_stack_scan_ambig, stackpointer, 0),
"create root");
cdie(mps_root_create_table(&root1, arena, mps_rank_ambig(), 0,
(mps_addr_t*)&exfmt_root, 1),
"create table root");
cdie(mps_fmt_create_A(&format, arena, &fmtA),
"create format");
cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create");
cdie(mmqa_pool_create_chain(&poolamc, arena, mps_class_amc(), format, chain),
"create pool(amc)");
cdie(mps_pool_create(&poolawl, arena, mps_class_awl(), format, getassociated),
"create pool(awl)");
cdie(mmqa_pool_create_chain(&poolamcz, arena, mps_class_amcz(), format, chain),
"create pool(amcz)");
cdie(mps_ap_create(&apawl, poolawl, mps_rank_weak()),
"create ap(awl)");
cdie(mps_ap_create(&apamc, poolamc, mps_rank_exact()),
"create ap(amc)");
cdie(mps_ap_create(&apamcz, poolamcz, mps_rank_exact()),
"create ap(amcz)");
mps_message_type_enable(arena, mps_message_type_finalization());
/* register loads of objects for finalization (1000*4) */
a = allocone(apamc, 2, 1);
b = a;
for (j=0; j<1000; j++) {
a = allocone(apamc, 2, mps_rank_exact());
c = allocone(apawl, 2, mps_rank_weak());
d = allocone(apamcz, 2, mps_rank_exact()); /* rank irrelevant here! */
mps_finalize(arena, (mps_addr_t*)&a);
mps_finalize(arena, (mps_addr_t*)&c);
mps_finalize(arena, (mps_addr_t*)&d);
mps_finalize(arena, (mps_addr_t*)&d);
final_count += 4;
setref(a, 0, b);
setref(a, 1, c);
setref(c, 1, d);
b = a;
}
/* throw them all away and collect everything */
a = NULL;
b = NULL;
c = NULL;
d = NULL;
mps_arena_collect(arena);
while (mps_message_poll(arena)) {
finalpoll(&z, FINAL_DISCARD);
}
/* How many are left? (Ideally, this would be 0 but there's no guarantee.) */
report("count1", "%i", final_count);
/* now to test leaving messages open for a long time! */
for (j=0; j<1000; j++) {
comment("%d of 1000", j+1);
a = allocone(apamc, 10000, mps_rank_exact());
mps_finalize(arena, (mps_addr_t*)&a);
final_count +=1;
comment("finalize");
finalpoll(&z, FINAL_QUEUE);
}
comment("reregister");
for (j=0; j<500; j++) {
comment("%d of 500", j+1);
qpoll(&z, FINAL_REREGISTER);
}
b = a;
z = a;
for (j=0; j<1000; j++) {
comment("%d of 1000", j+1);
finalpoll(&z, FINAL_QUEUE);
qpoll(&z, FINAL_STORE);
a = allocone(apamc, 2, mps_rank_exact());
setref(z, 0, b);
setref(a, 1, z);
b = a;
}
for (j=0; j<1000; j++) {
a = allocone(apamc, 2, mps_rank_exact());
qpoll(&z, FINAL_DISCARD);
finalpoll(&z, FINAL_DISCARD);
setref(a, 0, b);
b = a;
}
/* Force old objects to be killed */
while (qmt() == 0) {
qpoll(&z, FINAL_DISCARD);
}
mps_root_destroy(root0);
mps_root_destroy(root1);
comment("Destroyed roots.");
mps_arena_collect(arena);
comment("Collected arena.");
while (mps_message_poll(arena)) {
finalpoll(&z, FINAL_DISCARD);
}
report("count2", "%d", final_count);
mps_arena_park(arena);
mps_ap_destroy(apawl);
mps_ap_destroy(apamc);
mps_ap_destroy(apamcz);
comment("Destroyed aps.");
mps_pool_destroy(poolamc);
mps_pool_destroy(poolawl);
mps_pool_destroy(poolamcz);
comment("Destroyed pools.");
mps_chain_destroy(chain);
mps_fmt_destroy(format);
mps_thread_dereg(thread);
mps_arena_destroy(arena);
comment("Destroyed arena.");
}
static void test(void)
{
mps_arena_t arena;
mps_pool_t pool;
mps_thr_t thread;
mps_root_t root;
mps_chain_t chain;
mps_fmt_t format;
mps_ap_t ap;
mps_addr_t p;
mps_addr_t q;
cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE), "create arena");
cdie(mps_thread_reg(&thread, arena), "register thread");
cdie(
mps_root_create_reg(&root, arena, mps_rank_ambig(), 0, thread,
mps_stack_scan_ambig, stackpointer, 0),
"create root");
cdie(
mps_fmt_create_A(&format, arena, &fmtA),
"create format");
cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create");
cdie(
mps_pool_create(&pool, arena, mps_class_amc(), format, chain),
"create pool");
cdie(
mps_ap_create(&ap, pool, mps_rank_exact()),
"create ap");
do
{
cdie(mps_reserve(&p, ap, 0x100), "Reserve: ");
q = (mps_addr_t) ((char *)p + 0x10);
}
while (!mps_commit(ap, q, 0x100));
comment("Committed.");
mps_ap_destroy(ap);
comment("Destroyed ap.");
mps_pool_destroy(pool);
comment("Destroyed pool.");
mps_fmt_destroy(format);
comment("Destroyed format.");
mps_chain_destroy(chain);
comment("Destroyed chain.");
mps_root_destroy(root);
comment("Destroyed root.");
mps_thread_dereg(thread);
comment("Deregistered thread.");
mps_arena_destroy(arena);
comment("Destroyed arena.");
}
static void test(void)
{
mps_arena_t arena;
mps_pool_t poolamc;
mps_thr_t thread;
mps_root_t root, root2, root3, root4, root5, root6, root7, root1;
mps_fmt_t format;
mps_chain_t chain;
mps_ap_t apamc;
typedef mycell * myroot;
myroot a, b, c, d, e, f, g;
int i;
int j;
RC;
cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE),
"create arena");
die(mps_thread_reg(&thread, arena), "register thread");
cdie(
mps_root_create_table(&root1, arena, MPS_RANK_EXACT, 0, (mps_addr_t*)&a, 1),
"root");
cdie(
mps_root_create_table(&root2, arena, MPS_RANK_EXACT, 0, (mps_addr_t*)&b, 1),
"root");
cdie(
mps_root_create_table(&root3, arena, MPS_RANK_EXACT, 0, (mps_addr_t*)&c, 1),
"root");
cdie(
mps_root_create_table(&root4, arena, MPS_RANK_EXACT, 0, (mps_addr_t*)&d, 1),
"root");
cdie(
mps_root_create_table(&root5, arena, MPS_RANK_EXACT, 0, (mps_addr_t*)&e, 1),
"root");
cdie(
mps_root_create_table(&root6, arena, MPS_RANK_EXACT, 0, (mps_addr_t*)&f, 1),
"root");
cdie(
mps_root_create_table(&root7, arena, MPS_RANK_EXACT, 0, (mps_addr_t*)&g, 1),
"root");
cdie(
mps_root_create_table(&root, arena, MPS_RANK_EXACT, 0, &exfmt_root, 1),
"create exfmt root");
die(mps_fmt_create_A(&format, arena, &fmtA), "create format");
cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create");
die(mmqa_pool_create_chain(&poolamc, arena, mps_class_amc(), format, chain),
"create pool");
cdie(
mps_ap_create(&apamc, poolamc, MPS_RANK_EXACT),
"create ap");
comment("parking...");
mps_arena_park(arena);
b = allocone(apamc, 1, 1);
for (j=1; j<10; j++) {
comment("%i of 10.", j);
a = allocone(apamc, 5, 1);
cutoff_id = getid(a);
b = a;
c = a;
d = a;
e = a;
f = a;
g = a;
for (i=1; i<1000; i++) {
c = allocone(apamc, 1000, 1);
if (ranint(8) == 0) d = c;
if (ranint(8) == 0) e = c;
if (ranint(8) == 0) f = c;
if (ranint(8) == 0) g = c;
setref(c, 0, b);
setref(c, 1, d);
setref(c, 2, e);
setref(c, 3, f);
setref(c, 4, g);
b = c;
}
for (i=1; i<1000; i++) {
c = allocone(apamc, 1000, 1);
if (ranint(8) == 0) d = c;
if (ranint(8) == 0) e = c;
if (ranint(8) == 0) f = c;
if (ranint(8) == 0) g = c;
setref(c, 0, b);
setref(c, 1, d);
setref(c, 2, e);
setref(c, 3, f);
setref(c, 4, g);
b = c;
}
a = c;
b = c;
d = c;
e = c;
f = c;
g = c;
exfmt_root = c;
mps_arena_collect(arena);
comment(" reserved: %lu", (unsigned long) mps_arena_reserved(arena));
comment("committed: %lu", (unsigned long) mps_arena_committed(arena));
comment("calling amc_apply:");
checkfrom(c);
appcount = 0;
apppadcount = 0;
junk_size = 0;
mps_amc_apply(poolamc, &test_apply, NULL, MAGICSIZE);
comment("finished amc_apply");
report("junksize", "%lu", (unsigned long) junk_size);
report("appcount", "%ld", appcount);
report("apppadcount", "%ld", apppadcount);
RC;
}
mps_arena_release(arena);
comment("released.");
mps_ap_destroy(apamc);
mps_pool_destroy(poolamc);
mps_chain_destroy(chain);
mps_fmt_destroy(format);
mps_root_destroy(root);
mps_root_destroy(root1);
mps_root_destroy(root2);
mps_root_destroy(root3);
mps_root_destroy(root4);
mps_root_destroy(root5);
mps_root_destroy(root6);
mps_root_destroy(root7);
comment("Destroyed roots.");
mps_thread_dereg(thread);
mps_arena_destroy(arena);
comment("Destroyed arena.");
}
/*===========================================================================*/
bool KVSMLImageObject::write( const std::string& filename )
{
BaseClass::setFilename( filename );
BaseClass::setSuccess( false );
// XML document
std::string comment(" Generated by kvs::KVSMLImageObject::write() ");
kvs::XMLDocument document;
document.InsertEndChild( kvs::XMLDeclaration("1.0") );
document.InsertEndChild( kvs::XMLComment( comment.c_str() ) );
// <KVSML>
m_kvsml_tag.write( &document );
// <Object type="ImageObject">
m_object_tag.setType( "ImageObject" );
if ( !m_object_tag.write( m_kvsml_tag.node() ) )
{
kvsMessageError( "Cannot write <%s>.", m_object_tag.name().c_str() );
return false;
}
// <ImageObject width="xxx" height="xxx">
kvs::kvsml::ImageObjectTag image_object_tag;
image_object_tag.setWidth( m_width );
image_object_tag.setHeight( m_height );
if ( !image_object_tag.write( m_object_tag.node() ) )
{
kvsMessageError( "Cannot write <%s>.", image_object_tag.name().c_str() );
return false;
}
// <Pixel>
kvs::kvsml::PixelTag pixel_tag;
pixel_tag.setType( m_pixel_type );
if ( !pixel_tag.write( image_object_tag.node() ) )
{
kvsMessageError( "Cannot write <%s>.", pixel_tag.name().c_str() );
return false;
}
else
{
if ( m_pixels.size() > 0 )
{
// <DataArray>
kvs::kvsml::DataArrayTag data_tag;
if ( m_writing_type == kvs::KVSMLImageObject::ExternalAscii )
{
data_tag.setFile( kvs::kvsml::DataArray::GetDataFilename( filename, "pixel" ) );
data_tag.setFormat( "ascii" );
}
else if ( m_writing_type == kvs::KVSMLImageObject::ExternalBinary )
{
data_tag.setFile( kvs::kvsml::DataArray::GetDataFilename( filename, "pixel" ) );
data_tag.setFormat( "binary" );
}
const std::string pathname = kvs::File( filename ).pathName();
if ( !data_tag.write( pixel_tag.node(), m_pixels, pathname ) )
{
kvsMessageError( "Cannot write <%s> for <%s>.",
data_tag.name().c_str(),
pixel_tag.name().c_str() );
return false;
}
}
}
const bool success = document.write( filename );
BaseClass::setSuccess( success );
return success;
}
static void test(void) {
mycell *p, *q;
int i;
mps_res_t res;
size_t lim7, avail7, commit7, lim8, avail8, commit8;
size_t lim9, avail9, commit9;
cdie(mps_arena_create(&arena, mps_arena_class_vm(), ARENA_SIZE),
"create arena");
cdie(mps_thread_reg(&thread, arena), "register thread");
cdie(mps_root_create_reg(&root, arena, mps_rank_ambig(), 0, thread,
mps_stack_scan_ambig, stackpointer, 0), "create stack root");
cdie(
mps_fmt_create_A(&format, arena, &fmtA),
"create format");
cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create");
cdie(
mps_pool_create(&poolamc, arena, mps_class_amc(), format, chain),
"create pool");
cdie(
mps_ap_create(&apamc, poolamc, mps_rank_exact()),
"create ap");
mps_arena_commit_limit_set(arena, mps_arena_committed(arena)+1024*1024);
mps_reservoir_limit_set(arena, 0);
report("lim7", "%d", lim7 = mps_reservoir_limit(arena));
report("avail7", "%d", avail7 = mps_reservoir_available(arena));
report("commit7", "%d", commit7 = mps_arena_committed(arena));
/* available should be zero, but should be able to allocate with
reservoir permit, until commit_limit is reached
*/
i = -1;
p = NULL;
res = MPS_RES_OK;
while (res == MPS_RES_OK) {
res = reservoir_allocrone(&q, apamc, 10, mps_rank_exact());
if (res == MPS_RES_OK) {
setref(q, 0, p);
p = q;
}
i++;
}
report("allocfail3", "%d", i);
report_res("failres3", res);
/* should be none left to make available */
mps_reservoir_limit_set(arena, 10ul*1024*1024);
report("lim8", "%d", lim8 = mps_reservoir_limit(arena));
report("avail8", "%d", avail8 = mps_reservoir_available(arena));
report("commit8", "%d", commit8 = mps_arena_committed(arena));
report("spill8", "%d", commit8-mps_arena_commit_limit(arena));
/* throw away objects and collect world */
p = NULL;
q = NULL;
mps_root_destroy(root);
mps_arena_collect(arena);
/* available should have gone up now */
report("lim9", "%d", lim9 = mps_reservoir_limit(arena));
report("avail9", "%d", avail9 = mps_reservoir_available(arena));
report("commit9", "%d", commit9 = mps_arena_committed(arena));
report("grow9", "%d", avail9-avail8);
report("spill9", "%d", commit9-mps_arena_commit_limit(arena));
/* destroy everything remaining
*/
mps_ap_destroy(apamc);
comment("Destroyed ap.");
mps_pool_destroy(poolamc);
comment("Destroyed pool.");
mps_fmt_destroy(format);
comment("Destroyed format.");
mps_chain_destroy(chain);
comment("Destroyed chain.");
mps_thread_dereg(thread);
comment("Deregistered thread.");
mps_arena_destroy(arena);
comment("Destroyed arena.");
}
void operator() () {
comment();
clauses();
}
void string_instrumentationt::do_format_string_write(
goto_programt &dest,
goto_programt::const_targett target,
const code_function_callt::argumentst &arguments,
unsigned format_string_inx,
unsigned argument_start_inx,
const std::string &function_name)
{
const exprt &format_arg = arguments[format_string_inx];
if(format_arg.id()==ID_address_of &&
format_arg.op0().id()==ID_index &&
format_arg.op0().op0().id()==ID_string_constant) // constant format
{
format_token_listt token_list=
parse_format_string(format_arg.op0().op0().get_string(ID_value));
unsigned args=0;
for(format_token_listt::const_iterator it=token_list.begin();
it!=token_list.end();
it++)
{
if(find(it->flags.begin(), it->flags.end(), format_tokent::ASTERISK)!=
it->flags.end())
continue; // asterisk means `ignore this'
switch(it->type)
{
case format_tokent::STRING:
{
const exprt &argument=arguments[argument_start_inx+args];
const typet &arg_type=ns.follow(argument.type());
goto_programt::targett assertion=dest.add_instruction();
assertion->source_location=target->source_location;
assertion->source_location.set_property_class("string");
std::string comment("format string buffer overflow in ");
comment += function_name;
assertion->source_location.set_comment(comment);
if(it->field_width!=0)
{
exprt fwidth = from_integer(it->field_width, unsigned_int_type());
exprt fw_1(ID_plus, unsigned_int_type());
exprt one = gen_one(unsigned_int_type());
fw_1.move_to_operands(fwidth);
fw_1.move_to_operands(one); // +1 for 0-char
exprt fw_lt_bs;
if(arg_type.id()==ID_pointer)
fw_lt_bs=binary_relation_exprt(fw_1, ID_le, buffer_size(argument));
else
{
index_exprt index;
index.array()=argument;
index.index()=gen_zero(unsigned_int_type());
address_of_exprt aof(index);
fw_lt_bs=binary_relation_exprt(fw_1, ID_le, buffer_size(aof));
}
assertion->make_assertion(fw_lt_bs);
}
else
{
// this is a possible overflow.
assertion->make_assertion(false_exprt());
}
// now kill the contents
invalidate_buffer(dest, target, argument, arg_type, it->field_width);
args++;
break;
}
case format_tokent::TEXT:
case format_tokent::UNKNOWN:
{
// nothing
break;
}
default: // everything else
{
const exprt &argument=arguments[argument_start_inx+args];
const typet &arg_type=ns.follow(argument.type());
goto_programt::targett assignment=dest.add_instruction(ASSIGN);
assignment->source_location=target->source_location;
exprt lhs(ID_dereference, arg_type.subtype());
lhs.copy_to_operands(argument);
exprt rhs=side_effect_expr_nondett(lhs.type());
rhs.add_source_location()=target->source_location;
assignment->code=code_assignt(lhs, rhs);
args++;
break;
}
}
}
}
else // non-const format string
{
for(unsigned i=argument_start_inx; i<arguments.size(); i++)
{
const typet &arg_type=ns.follow(arguments[i].type());
// Note: is_string_type() is a `good guess' here. Actually
// any of the pointers could point into an array. But it
// would suck if we had to invalidate all variables.
// Luckily this case isn't needed too often.
if(is_string_type(arg_type))
{
goto_programt::targett assertion=dest.add_instruction();
assertion->source_location=target->source_location;
assertion->source_location.set_property_class("string");
std::string comment("format string buffer overflow in ");
comment += function_name;
assertion->source_location.set_comment(comment);
// as we don't know any field width for the %s that
// should be here during runtime, we just report a
// possibly false positive
assertion->make_assertion(false_exprt());
invalidate_buffer(dest, target, arguments[i], arg_type, 0);
}
else
{
goto_programt::targett assignment = dest.add_instruction(ASSIGN);
assignment->source_location=target->source_location;
exprt lhs(ID_dereference, arg_type.subtype());
lhs.copy_to_operands(arguments[i]);
exprt rhs=side_effect_expr_nondett(lhs.type());
rhs.add_source_location()=target->source_location;
assignment->code=code_assignt(lhs, rhs);
}
}
}
}
static void test(void)
{
int i = 0, f = 0;
mps_ap_t sap;
mps_arena_t arena;
mps_fmt_t format;
mps_pool_t spool;
mps_thr_t thread;
mps_frame_t frames[MAXFRAMES];
int nobj[MAXFRAMES+1];
mycell *p;
/* create an arena that can't grow beyond 30 M */
cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t)THIRTY_MEG),
"create arena");
cdie(mps_arena_commit_limit_set(arena, (size_t)THIRTY_MEG),
"commit limit set");
cdie(mps_thread_reg(&thread, arena), "register thread");
cdie(
mps_fmt_create_A(&format, arena, &fmtA),
"create format");
cdie(
mps_pool_create(&spool, arena, mps_class_snc(), format),
"create SNC pool");
cdie(
mps_ap_create(&sap, spool, mps_rank_exact()),
"create ap");
/* repeatedly push and pop stack frames, and allocate objects in them
at random. Parameters ensure that max allocation can't get too high.
*/
for (i=0; i < ITERATIONS; i++) {
switch (ranint(12)) {
case 1: case 2: case 3: case 4: case 5:
if (f < MAXFRAMES) {
die(mps_ap_frame_push(&frames[f], sap), "push");
comment("push %i", f);
f++;
nobj[f] = 0;
}
break;
case 6: case 7: case 8: case 9: case 10:
if (nobj[f] < MAXLEVOBJS) {
p = allocone(sap, 16, mps_rank_exact());
setref(p, 0, NULL);
nobj[f]++;
}
break;
case 11:
if (f>0) {
f -= 1+ranint(1+ranint(f)); /* new f is in [0, old f) */
die(mps_ap_frame_pop(sap, frames[f]), "pop");
comment("pop %i", f);
}
break;
}
}
mps_ap_destroy(sap);
comment("Destroyed ap.");
mps_pool_destroy(spool);
comment("Destroyed pool.");
mps_fmt_destroy(format);
comment("Destroyed format.");
mps_thread_dereg(thread);
comment("Deregistered thread.");
mps_arena_destroy(arena);
comment("Destroyed arena.");
}
static void test(void)
{
mps_arena_t arena;
mps_pool_t pool;
mps_thr_t thread;
mps_root_t root;
mps_fmt_t format;
mps_chain_t chain;
mycell *cells;
int h,i,j,k,l;
mycell *pobj;
mycell *ambig[NAPS];
size_t bytes;
size_t alignment;
mps_addr_t q;
int nextid = 0x1000000;
/* turn on comments about copying and scanning */
formatcomments = VERBOSE;
fixcomments = VERBOSE;
cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE),
"create arena");
cdie(mps_thread_reg(&thread, arena), "register thread");
cdie(mps_root_create_reg(&root, arena, mps_rank_ambig(), 0, thread,
mps_stack_scan_ambig, stackpointer, 0),
"create root");
cdie(mps_fmt_create_A(&format, arena, &fmtA), "create format");
cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create");
cdie(mmqa_pool_create_chain(&pool, arena, mps_class_amc(), format, chain),
"create pool");
for (i=0; i<NAPS; i++) {
die(mps_ap_create(&ap[i], pool, mps_rank_exact()), "create ap");
ap_state[i] = 0;
}
cells = allocone(ap[0], NCELLS);
/* ap_state can have the following values:
0 before reserve
1 after reverse
2 after init
3 after I=A
0 after commit
*/
for(h=0; h<ITERATIONS; h++) {
comment("%i of %i", h, ITERATIONS);
for(j=0; j<1000; j++) {
if (j == 500) {
mps_arena_collect(arena);
}
i = ranint(NAPS);
switch (ap_state[i]) {
case 0:
nrefs[i] = NUMREFS;
bytes = offsetof(struct data, ref)+nrefs[i]*sizeof(struct refitem);
alignment = MPS_PF_ALIGN;
bytes = (bytes+alignment-1)&~(alignment-1);
s[i] = bytes;
die(mps_reserve(&q, ap[i], s[i]), "reserve: ");
p[i] = q;
p[i]->data.tag = 0xD033E2A6;
p[i]->data.id = nextid;
ap_state[i] = 1;
commentif(VERBOSE, "%i: reserve %li at %p", i, nextid, q);
nextid +=1;
break;
case 1:
commentif(VERBOSE, "%i: init %li", i, p[i]->data.id);
p[i]->data.tag = MCdata;
p[i]->data.numrefs = nrefs[i];
p[i]->data.size = s[i];
ap_state[i] = 2;
for (k=0; k<nrefs[i]; k++) {
if PNULL {
p[i]->data.ref[k].addr = NULL;
p[i]->data.ref[k].id = 0;
} else {
l = ranint(NCELLS);
pobj = getref(cells, l);
p[i]->data.ref[k].addr = pobj;
p[i]->data.ref[k].id = (pobj==NULL ? 0 : pobj->data.id);
}
commentif(VERBOSE, " ref %i -> %li", k, p[i]->data.ref[k].id);
}
break;
case 2:
commentif(VERBOSE, "%i: begin commit %li", i, p[i]->data.id);
ambig[i] = p[i];
ap[i]->init = ap[i]->alloc;
ap_state[i] = 3;
break;
case 3:
commentif(VERBOSE, "%i: end commit %li", i, p[i]->data.id);
q = p[i];
if (ap[i]->limit != 0 || mps_ap_trip(ap[i], p[i], s[i])) {
l = ranint(NCELLS);
setref(cells, l, q);
commentif(VERBOSE, "%i -> %i", i, l);
}
ap_state[i] = 0;
ambig[i] = NULL;
break;
}
}
checkfrom(cells);
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
bool Parameter::removeComment(const CommentIndex& i) {
Comment* object = comment(i);
if ( object == NULL ) return false;
return remove(object);
}
static void test(void)
{
mps_arena_t arena;
mps_pool_t poolamc, poolawl;
mps_thr_t thread;
mps_root_t root;
mps_fmt_t format;
mps_chain_t chain;
mps_ap_t apamc, apawl;
mycell *a[100], *b;
int i;
int j;
int k,z;
alloccomments = 1;
formatcomments = 1;
cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE),
"create arena");
die(mps_thread_reg(&thread, arena), "register thread");
die(mps_root_create_reg(&root, arena, MPS_RANK_AMBIG, 0, thread,
mps_stack_scan_ambig, stackpointer, 0),
"create root");
die(mps_fmt_create_A(&format, arena, &fmtA), "create format");
cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create");
die(mmqa_pool_create_chain(&poolamc, arena, mps_class_amc(), format, chain),
"create pool");
cdie(
mps_pool_create(&poolawl, arena, mps_class_awl(), format),
"create pool");
cdie(
mps_ap_create(&apawl, poolawl, MPS_RANK_EXACT),
"create ap");
cdie(
mps_ap_create(&apamc, poolamc, MPS_RANK_EXACT),
"create ap");
for(i=0; i<100; i++) {
a[i] = allocone(apawl, 6, 1);
}
for(i=0; i<10000; i++) {
j = ranint(100);
k = 5 + ranint(50);
comment("New object %i, %i", j, k);
a[j] = allocone(apawl, k, 1);
k = ranint(100);
z = ranint(2);
comment("setting %i (%p) %i", k, a[k], z);
setref(a[k], z, a[j]);
b = allocdumb(apamc, 0x400*64, 0);
}
mps_ap_destroy(apawl);
mps_ap_destroy(apamc);
mps_pool_destroy(poolamc);
mps_pool_destroy(poolawl);
mps_chain_destroy(chain);
mps_fmt_destroy(format);
mps_root_destroy(root);
mps_thread_dereg(thread);
mps_arena_destroy(arena);
comment("Destroyed arena.");
}
static void test(void)
{
mps_pool_t pool;
mps_thr_t thread;
mps_root_t root;
mps_fmt_t format;
mps_chain_t chain;
mps_ap_t ap, ap2;
mycell *a, *b;
mps_res_t res;
int i;
/* create an arena that can't grow beyond 30 M */
cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t) (1024*1024*30)),
"create arena");
mps_arena_commit_limit_set(arena, (size_t) (1024*1024*40));
cdie(mps_thread_reg(&thread, arena), "register thread");
cdie(mps_root_create_reg(&root, arena, MPS_RANK_AMBIG, 0, thread,
mps_stack_scan_ambig, stackpointer, 0),
"create root");
cdie(mps_fmt_create_A(&format, arena, &fmtA),
"create format");
cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create");
die(mmqa_pool_create_chain(&pool, arena, mps_class_amc(), format, chain),
"create pool");
cdie(mps_ap_create(&ap, pool, MPS_RANK_EXACT),
"create ap");
/* allocate until full */
i = 0;
b = NULL;
while (allocrone(&a, ap, 128, MPS_RANK_EXACT) == MPS_RES_OK) {
i++;
setref(a, 0, b);
b = a;
}
comment("%d objs allocated.", i);
report("committed", "%ld", mps_arena_committed(arena));
/* try to allocate 10 times */
cdie(mps_ap_create(&ap2, pool, MPS_RANK_EXACT), "create second ap");
mps_ap_destroy(ap);
for (i = 0; i < 10; i++) {
res = allocrone(&a, ap2, 128, MPS_RANK_EXACT);
report("predie", "%s", err_text(res));
}
/* now let everything die, and try to allocate 10 times */
mps_root_destroy(root);
for (i = 0; i < 10; i++) {
res = allocrone(&a, ap2, 128, MPS_RANK_EXACT);
report("postdie", "%s", err_text(res));
}
die(allocrone(&a, ap2, 128, MPS_RANK_EXACT), "alloc failed");
mps_ap_destroy(ap2);
mps_pool_destroy(pool);
mps_chain_destroy(chain);
mps_fmt_destroy(format);
mps_thread_dereg(thread);
mps_arena_destroy(arena);
comment("Destroyed arena.");
}
static void d_mc(int i, char *name)
{
comment("%10d %s", maxcounters[i], name);
}
static void test(void)
{
mps_arena_t arena;
mps_pool_t poolamc, poolawl;
mps_thr_t thread;
mps_root_t root;
mps_fmt_t format;
mps_chain_t chain;
mps_ap_t apamc, apexact, apweak;
mycell *a, *b, *c, *d, *e, *f, *g;
int i;
int j;
RC;
cdie(mps_arena_create(&arena, mps_arena_class_vm(), mmqaArenaSIZE),
"create arena");
die(mps_thread_reg(&thread, arena), "register thread");
die(mps_root_create_reg(&root, arena, MPS_RANK_AMBIG, 0, thread,
mps_stack_scan_ambig, stackpointer, 0),
"create root");
die(mps_fmt_create_A(&format, arena, &fmtA), "create format");
cdie(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create");
die(mmqa_pool_create_chain(&poolamc, arena, mps_class_amc(), format, chain),
"create pool");
cdie(
mps_pool_create(&poolawl, arena, mps_class_awl(), format),
"create pool");
cdie(
mps_ap_create(&apexact, poolawl, MPS_RANK_EXACT),
"create ap");
cdie(
mps_ap_create(&apweak, poolawl, MPS_RANK_WEAK),
"create ap");
cdie(
mps_ap_create(&apamc, poolamc, MPS_RANK_EXACT),
"create ap");
b = allocone(apamc, 1, 1);
for (j=1; j<10; j++) {
comment("%i of 10.", j);
UC;
a = allocone(apexact, 5, 1);
setref(a, 0, b);
b = a;
c = a;
d = a;
e = a;
f = a;
g = a;
for (i=1; i<1000; i++) {
UC;
c = allocone(apamc, 1000, 0);
if (ranint(2) == 0) {
c = allocone(apweak, 100, 1);
} else {
c = allocone(apexact, 100, 1);
}
if (ranint(8) == 0) d = c;
if (ranint(8) == 0) e = c;
if (ranint(8) == 0) f = c;
if (ranint(8) == 0) g = c;
UC;
setref(c, 0, b);
UC;
setref(c, 1, d);
UC;
setref(c, 2, e);
UC;
setref(c, 3, f);
UC;
setref(c, 4, g);
UC;
b = c;
}
DC;
DMC;
}
mps_ap_destroy(apweak);
mps_ap_destroy(apexact);
mps_ap_destroy(apamc);
comment("Destroyed aps.");
mps_pool_destroy(poolamc);
mps_pool_destroy(poolawl);
mps_chain_destroy(chain);
mps_fmt_destroy(format);
mps_root_destroy(root);
mps_thread_dereg(thread);
mps_arena_destroy(arena);
comment("Destroyed arena.");
}
PrintcapEntry* LPRngToolHandler::createEntry(KMPrinter *prt)
{
QString prot = prt->deviceProtocol();
if (prot != "parallel" && prot != "lpd" && prot != "smb" && prot != "socket")
{
manager()->setErrorMsg(i18n("Unsupported backend: %1.").arg(prot));
return NULL;
}
PrintcapEntry *entry = new PrintcapEntry;
entry->addField("cm", Field::String, prt->description());
QString lp, comment("##LPRNGTOOL## ");
if (prot == "parallel")
{
comment.append("DEVICE ");
lp = prt->device().mid( 9 );
entry->addField("rw@", Field::Boolean);
}
else if (prot == "socket")
{
comment.append("SOCKET ");
KURL url( prt->device() );
lp = url.host();
if (url.port() == 0)
lp.append("%9100");
else
lp.append("%").append(QString::number(url.port()));
}
else if (prot == "lpd")
{
comment.append("QUEUE ");
KURL url( prt->device() );
lp = url.path().mid(1) + "@" + url.host();
}
else if (prot == "smb")
{
comment.append("SMB ");
lp = "| " + filterDir() + "/smbprint";
QString work, server, printer, user, passwd;
if ( splitSmbURI( prt->device(), work, server, printer, user, passwd ) )
{
entry->addField("xfer_options", Field::String, QString::fromLatin1("authfile=\"auth\" crlf=\"0\" hostip=\"\" host=\"%1\" printer=\"%2\" remote_mode=\"SMB\" share=\"//%3/%4\" workgroup=\"%5\"").arg(server).arg(printer).arg(server).arg(printer).arg(work));
QFile authfile(LprSettings::self()->baseSpoolDir() + "/" + prt->printerName() + "/auth");
if (authfile.open(IO_WriteOnly))
{
QTextStream t(&authfile);
t << "username="******"password="******"Invalid printer backend specification: %1" ).arg( prt->device() ) );
delete entry;
return NULL;
}
}
if (prt->driver())
{
DrMain *driver = prt->driver();
comment.append("filtertype=IFHP ifhp_options=status@,sync@,pagecount@,waitend@ printerdb_entry=");
comment.append(driver->get("driverID"));
entry->addField("ifhp", Field::String, QString::fromLatin1("model=%1,status@,sync@,pagecount@,waitend@").arg(driver->get("driverID")));
entry->addField("lprngtooloptions", Field::String, QString::fromLatin1("FILTERTYPE=\"IFHP\" IFHP_OPTIONS=\"status@,sync@,pagecount@,waitend@\" PRINTERDB_ENTRY=\"%1\"").arg(driver->get("driverID")));
QMap<QString,QString> opts;
QString optstr;
driver->getOptions(opts, false);
for (QMap<QString,QString>::ConstIterator it=opts.begin(); it!=opts.end(); ++it)
if (it.key() != "lpr")
optstr.append(*it).append(",");
if (!optstr.isEmpty())
{
optstr.truncate(optstr.length()-1);
entry->addField("prefix_z", Field::String, optstr);
}
if (!opts["lpr"].isEmpty())
entry->addField("lpr", Field::String, opts["lpr"]);
}
entry->addField("lp", Field::String, lp);
entry->comment = comment;
return entry;
}
static void t_alloc(int spare, int spare_total, int commit, int obj_size) {
size_t size, hisize, comsize, comlimit;
size_t spsize = 0, losize = 0; /* stop warnings */
mps_res_t res, res_expected;
if (obj_size == OBJ_SMALL) size = SMALL_SIZE; else size = BIG_SIZE;
switch (spare_total) {
case SPARE_EMPTY:
spsize = 0;
break;
case SPARE_LESS:
if (size > DIFF_SIZE) {
spsize = size-DIFF_SIZE;
} else {
spsize = 0;
}
break;
case SPARE_EXACT:
spsize = size;
break;
case SPARE_MORE:
spsize = size+DIFF_SIZE;
break;
default:
error("Illegal spare.\n");
break;
}
switch (spare) {
case SPARE_EMPTY:
losize = 0;
break;
case SPARE_LESS:
if (size > DIFF_SIZE) {
losize = size-DIFF_SIZE;
} else {
losize = 0;
}
break;
case SPARE_EXACT:
losize = size;
break;
case SPARE_MORE:
losize = size+DIFF_SIZE;
break;
}
if (losize > spsize) {
losize = spsize;
hisize = 0;
} else {
hisize = spsize-losize;
}
/* turn off commit limit for a moment */
mps_arena_commit_limit_set(arena, HUGE);
/* create low and high pools */
die(
mps_pool_create(&poolhi, arena, mps_class_mvff(), MVFF_HI_PARMS),
"create high pool");
die(
mps_pool_create(&poollo, arena, mps_class_mvff(), MVFF_LO_PARMS),
"create low pool");
/* flush hysteresis fund, then set limit */
mps_arena_spare_commit_limit_set(arena, SPARE_ZERO);
mps_arena_spare_commit_limit_set(arena, SPARE_LIMIT);
/* allocate something in each pool (to reduce risk of subsidiary
allocation being neede later */
die(mps_alloc(&objlo, poollo, EXTEND), "low alloc");
die(mps_alloc(&objhi, poolhi, EXTEND), "high alloc");
/* set up spare committed the way we want it */
if (losize>0) {
die(mps_alloc(&objlo, poollo, losize), "low setup");
mps_free(poollo, objlo, losize);
}
if (hisize>0) {
die(mps_alloc(&objhi, poolhi, hisize), "high setup");
mps_free(poolhi, objhi, hisize);
}
/* spare is now set up correctly */
/* now we need to set the commit limit correctly */
comsize = arena_committed_and_used(arena);
/* allow for 1/16th memory overhead in setting commit limit */
if (commit == COMMIT_EXACT) {
comlimit = comsize+size+(size/16);
} else if (commit == COMMIT_NOCHANGE) {
comlimit = mps_arena_committed(arena);
} else if (commit == COMMIT_PLENTY) {
comlimit = HUGE;
} else /* commit == COMMIT_LITTLE */ {
if (size > DIFF_SIZE) {
comlimit = comsize+size+(size/16)+DIFF_SIZE;
} else {
comlimit = comsize+size+(size/16);
}
}
die(mps_arena_commit_limit_set(arena, comlimit), "commit limit set");
res = mps_alloc(&objlo, poollo, size);
asserts(comlimit >= comsize, "comlimit was less than comsize!");
if (size <= (comlimit-comsize)) {
res_expected = MPS_RES_OK;
} else {
res_expected = MPS_RES_COMMIT_LIMIT;
}
if (res != res_expected) {
comment("Spare useful/total %i/%i. Limit %i. Size %i. Expected %s. Got %s", spare, spare_total, commit, obj_size, err_text(res_expected), err_text(res));
report("failed", "yes");
}
mps_pool_destroy(poollo);
mps_pool_destroy(poolhi);
}
Windowdef_simple* Windowdef_simple::copy() const
{
return new Windowdef_simple( comment(), title(), title_match_type(), wclass(),
wclass_match_type(), role(), role_match_type(), window_types());
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
bool FocalMechanism::removeComment(const CommentIndex& i) {
Comment* object = comment(i);
if ( object == NULL ) return false;
return remove(object);
}
