int
main (void)
{
marker1 ();
syscall (SYS_time, &time_global);
marker2 ();
return 0;
}
int
main (void)
{
marker1 ();
pipe (fds);
marker2 ();
return 0;
}
int
main (void)
{
marker1 ();
int fd = open ("/", O_PATH);
fstatat( fd, ".", &buf, 0);
marker2 ();
return 0;
}
int
main (void)
{
marker1 ();
getresuid (&ruid, &euid, &suid);
getresgid (&rgid, &egid, &sgid);
marker2 ();
return 0;
}
int
main (void)
{
struct foo the_foo;
foo_ptr = &the_foo;
foz_ptr = &the_foo;
return marker1 ();
}
int main(void)
{
A a_instance;
marker1(); // marker1-returns-here
a_instance.a = 20; // marker1-returns-here
a_instance.aa = 21;
return 0;
}
int
main (void)
{
marker1 ();
pipe (fds);
write (fds[1], "UNIX", 4);
readv (fds[0], v, 4);
marker2 ();
return 0;
}
int
main (void)
{
marker1 ();
if (!fork ())
_exit (123);
else
waitpid (-1, &status, 0);
marker2 ();
return 0;
}
int main ()
{
#ifdef usestubs
set_debug_traps();
breakpoint();
#endif
struct1.val = 1;
struct2.val = 2;
ptr1 = &struct1;
ptr2 = &struct2;
marker1 ();
func1 ();
for (count = 0; count < 4; count++) {
ival1 = count;
ival3 = count; ival4 = count;
}
ival1 = count; /* Outside loop */
ival2 = count;
ival3 = count; ival4 = count;
marker2 ();
if (doread)
{
static char msg[] = "type stuff for buf now:";
write (1, msg, sizeof (msg) - 1);
read (0, &buf[0], 5);
}
marker4 ();
/* We have a watchpoint on ptr1->val. It should be triggered if
ptr1's value changes. */
ptr1 = ptr2;
/* This should not trigger the watchpoint. If it does, then we
used the wrong value chain to re-insert the watchpoints or we
are not evaluating the watchpoint expression correctly. */
struct1.val = 5;
marker5 ();
/* We have a watchpoint on ptr1->val. It should be triggered if
ptr1's value changes. */
ptr1 = ptr2;
/* This should not trigger the watchpoint. If it does, then we
used the wrong value chain to re-insert the watchpoints or we
are not evaluating the watchpoint expression correctly. */
struct1.val = 5;
marker5 ();
return 0;
}
int
main (int argc, char **argv, char **envp)
{
if (argc == 12345) { /* an unlikely value < 2^16, in case uninited */ /* set breakpoint 6 here */
fprintf (stderr, "usage: factorial <number>\n");
return 1;
}
printf ("%d\n", factorial (atoi ("6"))); /* set breakpoint 1 here */
/* set breakpoint 12 here */
marker1 (); /* set breakpoint 11 here */
marker2 (43);
marker3 ("stack", "trace");
marker4 (177601976L);
argc = (argc == 12345); /* This is silly, but we can step off of it */ /* set breakpoint 2 here */
return argc; /* set breakpoint 10 here */
}
int main()
{
char C, *pC, **ppC, ***pppC, ****ppppC, *****pppppC, ******ppppppC;
unsigned char UC, *pUC;
short S, *pS;
unsigned short US, *pUS;
int I, *pI;
unsigned int UI, *pUI;
long L, *pL;
unsigned long UL, *pUL;
float F, *pF;
double D, *pD;
C = 'A';
UC = 21;
S = -14;
US = 7;
I = 102;
UI = 1002;
L = -234;
UL = 234;
F = 1.25E10;
D = -1.375E-123;
pC = &C;
ppC = &pC;
pppC = &ppC;
ppppC = &pppC;
pppppC = &ppppC;
ppppppC = &pppppC;
pUC = &UC;
pS = &S;
pUS = &US;
pI = &I;
pUI = &UI;
pL = &L;
pUL = &UL;
pF = &F;
pD = &D;
#ifdef usestubs
set_debug_traps();
breakpoint();
#endif
marker1();
return 0;
}
int
main ()
{
struct {
char c[100];
} cbig;
struct {
int i[800];
} ibig;
struct {
long l[900];
} lbig;
struct {
float f[200];
} fbig;
struct {
double d[300];
} dbig;
struct {
short s[400];
} sbig;
ibig.i[100] = 5;
cbig.c[0] = '\0';
cbig.c[100] = 'A';
fbig.f[100] = 11.99999;
dbig.d[202] = 9.99999999;
sbig.s[90] = 255;
lbig.l[333] = 999999999;
#ifdef usestubs
set_debug_traps ();
breakpoint ();
#endif
marker1 ();
return 0;
}
int
main (int argc, char **argv, char **envp)
{
if (argc == 12345) { /* an unlikely value < 2^16, in case uninited */ /* set breakpoint 6 here */
fprintf (stderr, "usage: factorial <number>\n");
return 1;
}
printf ("%d\n", factorial (atoi ("6"))); /* set breakpoint 1 here */
/* set breakpoint 12 here */
marker1 (); /* set breakpoint 11 here */
marker2 (43); /* set breakpoint 20 here */
marker3 ("stack", "trace"); /* set breakpoint 21 here */
marker4 (177601976L);
/* We're used by a test that requires malloc, so make sure it is
in the executable. */
(void)malloc (1);
argc = (argc == 12345); /* This is silly, but we can step off of it */ /* set breakpoint 2 here */
return argc; /* set breakpoint 10 here */
} /* set breakpoint 10a here */
int
main (int argc, char **argv, char **envp)
{
if (argc == 12345)
{
/* We're used by a test that requires malloc, so make sure it is
in the executable. */
(void) malloc (1);
return 1;
}
factorial (atoi ("6")); /* set breakpoint 1 here */
/* set breakpoint 12 here */
marker1 (); /* set breakpoint 11 here */
marker2 (43); /* set breakpoint 20 here */
marker3 ("stack", "trace"); /* set breakpoint 21 here */
marker4 (177601976L);
argc = (argc == 12345); /* This is silly, but we can step off of it */ /* set breakpoint 2 here */
return argc; /* set breakpoint 10 here */
} /* set breakpoint 10a here */
int main(int argc, char* argv[]) {
std::cout << "GO" << std::endl;
cv::VideoCapture cap(VIDEO); // open the default camera
if(!cap.isOpened()) // check if we succeeded
return -1;
cv::Mat frame;
cv::Mat hsv;
cap >> frame;
Image3D image(frame.cols, frame.rows, NULL);
Rectangle dummyRect;
//Marker marker1(false, yellowMin, yellowMax, redMin, redMax, binary);
Marker marker1(false, yellowRect, redRect, dummyRect);
PositionMarker pm1;
//Marker marker2(false, redMin, redMax, yellowMin, yellowMax, binary);
Marker marker2(false, redRect, yellowRect, dummyRect);
PositionMarker pm2;
//Marker marker3(false, greenMin, greenMax, blueMin, blueMax, binary);
Marker marker3(true, greenRect, blueRect, dummyRect);
PositionMarker pm3;
//Marker marker4(false, blueMin, blueMax, greenMin, greenMax, binary);
Marker marker4(true, blueRect, greenRect, dummyRect);
PositionMarker pm4;
std::cout << "start loop" << std::endl;
int count = 0;
while(1) {
cap >> frame; // get a new frame from camera
cv::cvtColor(frame, hsv, CV_BGR2Luv);
image.setData(hsv.data);
image.id = count;
if (count % 20 == 0)
std::cout << "NEXT POS " << count << std::endl;
bool result;
result = marker1.getNextPos(image, pm1);
if (!result) {
std::cout << "POS " << count << std::endl;
std::cout << "NOP (1)" << std::endl;
}
result = marker2.getNextPos(image, pm2);
if (!result) {
std::cout << "POS " << count << std::endl;
std::cout << "NOP (2)" << std::endl;
}
// result = marker3.getNextPos(image, pm3);
// if (!result) {
// std::cout << "POS " << count << std::endl;
// std::cout << "NOP (3)" << std::endl;
// }
// result = marker4.getNextPos(image, pm4);
// if (!result) {
// std::cout << "POS " << count << std::endl;
// std::cout << "NOP (4)" << std::endl;
// }
// Image &mask = marker1.masks[0];
// for (unsigned int im=0; im<mask.height; ++im) {
// for (unsigned int jm=0; jm<mask.width; ++jm) {
// if (mask.getValue(im, jm) == 1)
// cv::line(frame, cv::Point(jm, im), cv::Point(jm, im), cv::Scalar(255, 0, 0));
// }
// }
// Image &mask1 = marker3.masks[0];
// for (unsigned int im=0; im<mask1.height; ++im) {
// for (unsigned int jm=0; jm<mask1.width; ++jm) {
// if (mask1.getValue(im, jm) == 1)
// cv::line(frame, cv::Point(jm, im), cv::Point(jm, im), cv::Scalar(255, 0, 255));
// }
// }
cv::rectangle(frame, cv::Point(pm1.x - pm1.size/2, pm1.minI), cv::Point(pm1.x + pm1.size/2, pm1.maxI), cv::Scalar(0, 0, 0));
cv::rectangle(frame, cv::Point(pm1.x - pm1.size/2 + 1, pm1.minI + 1), cv::Point(pm1.x + pm1.size/2 - 1, pm1.maxI - 1), cv::Scalar(0, 0, 0));
cv::rectangle(frame, cv::Point(pm2.x - pm2.size/2, pm2.minI), cv::Point(pm2.x + pm2.size/2, pm2.maxI), cv::Scalar(0, 0, 0));
cv::rectangle(frame, cv::Point(pm2.x - pm2.size/2 + 1, pm2.minI + 1), cv::Point(pm2.x + pm2.size/2 - 1, pm2.maxI - 1), cv::Scalar(0, 0, 0));
cv::rectangle(frame, cv::Point(pm3.x - pm3.size/2, pm3.minI), cv::Point(pm3.x + pm3.size/2, pm3.maxI), cv::Scalar(0, 0, 255));
cv::rectangle(frame, cv::Point(pm3.x - pm3.size/2 + 1, pm3.minI + 1), cv::Point(pm3.x + pm3.size/2 - 1, pm3.maxI - 1), cv::Scalar(0, 0, 0));
cv::rectangle(frame, cv::Point(pm4.x - pm4.size/2, pm4.minI), cv::Point(pm4.x + pm4.size/2, pm4.maxI), cv::Scalar(0, 0, 255));
cv::rectangle(frame, cv::Point(pm4.x - pm4.size/2 + 1, pm4.minI + 1), cv::Point(pm4.x + pm4.size/2 - 1, pm4.maxI - 1), cv::Scalar(0, 0, 0));
// cv::line(frame, cv::Point(pm1.x - pm1.size/2, 183), cv::Point(pm1.x + pm1.size/2, 211), cv::Scalar(0, 0, 255));
// cv::line(frame, cv::Point(565, 220), cv::Point(575, 230), cv::Scalar(0, 0, 255));
cv::imshow("img", frame);
cv::waitKey(10);
if (count > 472 && count < 480)
cv::waitKey(1000);
// if (count > 2250)
// cv::waitKey(2);
count++;
}
}
int
main (void)
{
char lave = 'B';
unsigned char lavish = 10;
short lax = 20;
unsigned short lecherous = 30;
long lechery = 40;
unsigned long lectern = 50;
float leeway = 60;
double legacy = 70;
signed char lemonade = 35;
const char laconic = 'A';
const unsigned char laggard = 1;
const short lagoon = 2;
const unsigned short laity = 3;
const long lambent = 4;
const unsigned long laminated = 5;
const float lampoon = 6;
const double languid = 7;
/* pointers to constant variables */
const char *legend = &lave;
const unsigned char *legerdemain = &lavish;
const short *leniency = &lax;
const unsigned short *leonine = &lecherous;
const long *lesion = &lechery;
const unsigned long *lethal = &lectern;
const float *lethargic = &leeway;
const double *levity = &legacy;
/* constant pointers to constant variables */
const char *const lewd = &laconic;
const unsigned char *const lexicographer = &laggard;
const short *const lexicon = &lagoon;
const unsigned short *const liaison = &laity;
const long *const libation = &lambent;
const unsigned long *const libelous = &laminated;
const float *const libertine = &lampoon;
const double *const libidinous = &languid;
/* this is the same as const char * legend .... */
char const *languish = &laconic;
unsigned char const *languor = &laggard;
short const *lank = &lagoon;
unsigned short const *lapidary = &laity;
long const *larceny = &lambent;
unsigned long const *largess = &laminated;
float const *lascivious = &lampoon;
double const *lassitude = &languid;
/* constant pointers to variable */
char *const lamprey = &lave;
unsigned char *const lariat = &lavish;
short *const laudanum = &lax;
unsigned short *const lecithin = &lecherous;
long *const leviathan = &lechery;
unsigned long *const libretto = &lectern;
float *const lissome = &leeway;
double *const locust = &legacy;
/* volatile variables */
volatile char vox = 'X';
volatile unsigned char victuals = 13;
volatile short vixen = 200;
volatile unsigned short vitriol = 300;
volatile long vellum = 1000;
volatile unsigned long valve = 2000;
volatile float vacuity = 3.0;
volatile double vertigo = 10.3;
/* pointers to volatile variables */
volatile char * vampire = &vox;
volatile unsigned char * viper = &victuals;
volatile short * vigour = &vixen;
volatile unsigned short * vapour = &vitriol;
volatile long * ventricle = &vellum;
volatile unsigned long * vigintillion = &valve;
volatile float * vocation = &vacuity;
volatile double * veracity = &vertigo;
/* volatile pointers to volatile variables */
volatile char * volatile vapidity = &vox;
volatile unsigned char * volatile velocity = &victuals;
volatile short * volatile veneer = &vixen;
volatile unsigned short * volatile video = &vitriol;
volatile long * volatile vacuum = &vellum;
volatile unsigned long * volatile veniality = &valve;
volatile float * volatile vitality = &vacuity;
volatile double * volatile voracity = &vertigo;
/* const volatile vars */
const volatile char victor = 'Y';
const volatile unsigned char vicar = 11;
/* pointers to const volatiles */
const volatile char * victory = &victor;
const volatile unsigned char * vicarage = &vicar;
/* const pointers to volatile vars */
volatile char * const vein = &vox;
volatile unsigned char * const vogue = &victuals;
/* const pointers to const volatile vars */
const volatile char * const cavern = &victor;
const volatile unsigned char * const coverlet = &vicar;
/* volatile pointers to const vars */
const char * volatile caveat = &laconic;
const unsigned char * volatile covenant = &laggard;
/* volatile pointers to const volatile vars */
const volatile char * volatile vizier = &victor;
const volatile unsigned char * volatile vanadium = &vicar;
/* const volatile pointers */
char * const volatile vane = &lave;
unsigned char * const volatile veldt = &lavish;
/* const volatile pointers to const vars */
const char * const volatile cove = &laconic;
const unsigned char * const volatile cavity = &laggard;
/* const volatile pointers to volatile vars */
volatile char * const volatile vagus = &vox;
volatile unsigned char * const volatile vagrancy = &victuals;
/* const volatile pointers to const volatile */
const volatile char * const volatile vagary = &victor;
const volatile unsigned char * const volatile vendor = &vicar;
/* various structs with const members */
struct crass { char * const ptr; } crass;
struct crisp { char * const *ptr; } crisp;
/* misc. references */
/*
const char & radiation = laconic;
volatile signed char & remuneration = lemonade;
*/
#ifdef usestubs
set_debug_traps ();
breakpoint ();
#endif
marker1 ();
return 0;
}
int main ()
{
struct1.val = 1;
struct2.val = 2;
ptr1 = &struct1;
ptr2 = &struct2;
marker1 ();
func1 ();
for (count = 0; count < 4; count++) {
ival1 = count;
ival3 = count; ival4 = count;
}
ival1 = count; /* Outside loop */
ival2 = count;
ival3 = count; ival4 = count;
marker2 ();
if (doread)
{
static char msg[] = "type stuff for buf now:";
write (1, msg, sizeof (msg) - 1);
read (0, &buf[0], 5);
}
marker4 ();
/* We have a watchpoint on ptr1->val. It should be triggered if
ptr1's value changes. */
ptr1 = ptr2;
/* This should not trigger the watchpoint. If it does, then we
used the wrong value chain to re-insert the watchpoints or we
are not evaluating the watchpoint expression correctly. */
struct1.val = 5;
marker5 ();
/* We have a watchpoint on ptr1->val. It should be triggered if
ptr1's value changes. */
ptr1 = ptr2;
/* This should not trigger the watchpoint. If it does, then we
used the wrong value chain to re-insert the watchpoints or we
are not evaluating the watchpoint expression correctly. */
struct1.val = 5;
marker5 ();
/* We're going to watch locals of func2, to see that out-of-scope
watchpoints are detected and properly deleted.
*/
marker6 ();
/* This invocation is used for watches of a single
local variable. */
func2 ();
/* This invocation is used for watches of an expression
involving a local variable. */
func2 ();
/* This invocation is used for watches of a static
(non-stack-based) local variable. */
func2 ();
/* This invocation is used for watches of a local variable
when recursion happens.
*/
marker6 ();
recurser (2);
marker6 ();
func3 ();
func4 ();
return 0;
} /* end of main */
void StaticModelLoader::vload()
{
v_num = 0, vt_num = 0, vn_num = 0;
std::string marker;
std::string marker1("v"), marker2("vt"), marker3("vn");
double u, v;
double x, y, z;
std::string line;
/*
count number of vertices
*/
while (std::getline(infile, line)) {
std::istringstream iss(line);
iss >> marker;
if (marker.compare(marker1) == 0) {
v_num++;
continue;
}
if (marker.compare(marker2) == 0) {
vt_num++;
continue;
}
if (marker.compare(marker3) == 0) {
vn_num++;
continue;
}
}
/*
return cursor to the beginning of the file
*/
infile.clear();
infile.seekg(0, ios::beg);
/*
allocate memory
*/
v_array = (v_struct*)calloc(v_num, sizeof(v_struct));
vt_array = (vt_struct*)calloc(vt_num, sizeof(vt_struct));
vn_array = (vn_struct*)calloc(vn_num, sizeof(vn_struct));
int iv = 0, ivt = 0, ivn = 0;
while (std::getline(infile, line)) {
std::istringstream iss(line);
iss >> marker;
/*
save coordinates of vertices
*/
if (marker.compare(marker1) == 0) {
iss >> x >> y >> z;
v_array[iv].ox = x, v_array[iv].x = x;
v_array[iv].oy = y, v_array[iv].y = y;
v_array[iv].oz = z, v_array[iv].z = z;
v_array[iv].ow = 1, v_array[iv].w = 1;
v_array[iv].index = iv;
if (fabs(x) > rx) rx = fabs(x);
if (fabs(y) > ry) ry = fabs(y);
if (fabs(z) > rz) rz = fabs(z);
iv++;
continue;
}
/*
save coordinates of textures
*/
if (marker.compare(marker2) == 0) {
iss >> u >> v;
vt_array[ivt].u = u;
vt_array[ivt].v = v;
vt_array[ivt].w = 1;
vt_array[ivt].index = ivt;
ivt++;
continue;
}
int
main (void)
{
char lave = 'B';
unsigned char lavish = 10;
short lax = 20;
unsigned short lecherous = 30;
long lechery = 40;
unsigned long lectern = 50;
float leeway = 60;
double legacy = 70;
signed char lemonade = 35;
const char laconic = 'A';
const unsigned char laggard = 1;
const short lagoon = 2;
const unsigned short laity = 3;
const long lambent = 4;
const unsigned long laminated = 5;
const float lampoon = 6;
const double languid = 7;
/* pointers to constant variables */
const char *legend = &lave;
const unsigned char *legerdemain = &lavish;
const short *leniency = &lax;
const unsigned short *leonine = &lecherous;
const long *lesion = &lechery;
const unsigned long *lethal = &lectern;
const float *lethargic = &leeway;
const double *levity = &legacy;
/* constant pointers to constant variables */
const char *const lewd = &laconic;
const unsigned char *const lexicographer = &laggard;
const short *const lexicon = &lagoon;
const unsigned short *const liaison = &laity;
const long *const libation = &lambent;
const unsigned long *const libelous = &laminated;
const float *const libertine = &lampoon;
const double *const libidinous = &languid;
/* this is the same as const char * legend .... */
char const *languish = &laconic;
unsigned char const *languor = &laggard;
short const *lank = &lagoon;
unsigned short const *lapidary = &laity;
long const *larceny = &lambent;
unsigned long const *largess = &laminated;
float const *lascivious = &lampoon;
double const *lassitude = &languid;
/* constant pointers to variable */
char *const lamprey = &lave;
unsigned char *const lariat = &lavish;
short *const laudanum = &lax;
unsigned short *const lecithin = &lecherous;
long *const leviathan = &lechery;
unsigned long *const libretto = &lectern;
float *const lissome = &leeway;
double *const locust = &legacy;
/* constant arrays */
const char logical[2] = {laconic, laconic};
const unsigned char lugged[2] = {laggard, laggard};
const short luck[2] = {lagoon, lagoon};
const unsigned short lunar[2] = {laity, laity};
const long lumen[2] = {lambent, lambent};
const unsigned long lurk[2] = {laminated, laminated};
const float lush[2] = {lampoon, lampoon};
const double lynx[2] = {languid, languid};
/* volatile variables */
volatile char vox = 'X';
volatile unsigned char victuals = 13;
volatile short vixen = 200;
volatile unsigned short vitriol = 300;
volatile long vellum = 1000;
volatile unsigned long valve = 2000;
volatile float vacuity = 3.0;
volatile double vertigo = 10.3;
/* pointers to volatile variables */
volatile char * vampire = &vox;
volatile unsigned char * viper = &victuals;
volatile short * vigour = &vixen;
volatile unsigned short * vapour = &vitriol;
volatile long * ventricle = &vellum;
volatile unsigned long * vigintillion = &valve;
volatile float * vocation = &vacuity;
volatile double * veracity = &vertigo;
/* volatile pointers to volatile variables */
volatile char * volatile vapidity = &vox;
volatile unsigned char * volatile velocity = &victuals;
volatile short * volatile veneer = &vixen;
volatile unsigned short * volatile video = &vitriol;
volatile long * volatile vacuum = &vellum;
volatile unsigned long * volatile veniality = &valve;
volatile float * volatile vitality = &vacuity;
volatile double * volatile voracity = &vertigo;
/* volatile arrays */
volatile char violent[2] = {vox, vox};
volatile unsigned char violet[2] = {victuals, victuals};
volatile short vips[2] = {vixen, vixen};
volatile unsigned short virgen[2] = {vitriol, vitriol};
volatile long vulgar[2] = {vellum, vellum};
volatile unsigned long vulture[2] = {valve, valve};
volatile float vilify[2] = {vacuity, vacuity};
volatile double villar[2] = {vertigo, vertigo};
/* const volatile vars */
const volatile char victor = 'Y';
const volatile unsigned char vicar = 11;
/* pointers to const volatiles */
const volatile char * victory = &victor;
const volatile unsigned char * vicarage = &vicar;
/* const pointers to volatile vars */
volatile char * const vein = &vox;
volatile unsigned char * const vogue = &victuals;
/* const pointers to const volatile vars */
const volatile char * const cavern = &victor;
const volatile unsigned char * const coverlet = &vicar;
/* volatile pointers to const vars */
const char * volatile caveat = &laconic;
const unsigned char * volatile covenant = &laggard;
/* volatile pointers to const volatile vars */
const volatile char * volatile vizier = &victor;
const volatile unsigned char * volatile vanadium = &vicar;
/* const volatile pointers */
char * const volatile vane = &lave;
unsigned char * const volatile veldt = &lavish;
/* const volatile pointers to const vars */
const char * const volatile cove = &laconic;
const unsigned char * const volatile cavity = &laggard;
/* const volatile pointers to volatile vars */
volatile char * const volatile vagus = &vox;
volatile unsigned char * const volatile vagrancy = &victuals;
/* const volatile pointers to const volatile */
const volatile char * const volatile vagary = &victor;
const volatile unsigned char * const volatile vendor = &vicar;
/* const volatile arrays */
const volatile char vindictive[2] = {victor, victor};
const volatile unsigned char vegetation[2] = {vicar, vicar};
/* various structs with const members */
struct crass { char * const ptr; } crass = { lamprey };
struct crisp { char * const *ptr; } crisp = { &lamprey };
/* Reference the structs so that they are not discarded. */
struct crass *creed = &crass;
struct crisp *crow = &crisp;
/* misc. references */
/*
const char & radiation = laconic;
volatile signed char & remuneration = lemonade;
*/
marker1 ();
return 0;
}
