// -----------------------------------------------------------------
// Zero of the (derivative of the) error function
// Assuming that exactly one zero exists
static double zero(double (*fptr)(int, double*, double, double), int n,
double *c, double epsilon, double a, double b,
double prec) {
int counter = 0;
double h1, h2, hmid, mid;
double prec2 = prec*prec;
h1 = fptr(n, c, a, epsilon);
h2 = fptr(n, c, b, epsilon);
if (h1 * h1 < prec2)
return a;
if (h2 * h2 < prec2)
return b;
while(1) {
mid = (a + b) / 2.0;
counter++;
hmid = fptr(n, c, mid, epsilon);
if (hmid * hmid < prec2)
return mid;
if (h1 * hmid > 0.0) {
a = mid;
h1 = hmid;
}
else {
b = mid;
h2 = hmid;
}
}
return 0.0;
}
int main() {
printf("all of the following should be 1 except xs[259] = 0");
a = 3;
b = 259;
fptr = (volatile int (*)(unsigned char x))&testUcharX;
if ((((long)fptr)&((long)1)<<32) == 1) fptr = NULL;
printf("compiled with: '%s'\nxs[3] = %d\nxs[259] = %d\ntestUcharX(3) = %d\ntestUcharX(%d) = %d\nfptr(3) = %d\nfptr(259) = %d\n",
xstr(CC), xs[a], xs[b], testUcharX(a), b, testUcharX(b), fptr(a), fptr(b));
}
int prod(int m,int n,int (*fptr)(int x))
{
if(m==n)
{
return fptr(m);
}
else
{
return fptr(m) * prod(m+1,n,fptr);
}
}
/*
* insertionsort() sorts an array of integers
* @array : pointer to the integer array to be sorted
* @n : number of elements in the array
* @fptr : pointer to the comparison function
*
* employs insertion sort for sorting
* returns 0 upon success
*/
int insertionSort(int *array, int n, bool(*fptr)(int, int)){
/*array already sorted*/
if(n < 2)
return 0;
int i = 0;
int j = 0;
int element = 0;
/*out loop to iterate over all the elements to be inserted*/
for(i = 1; i <= (n - 1); i++){
element = *(array + i);
/*inner loop to compare and shift elements*/
for(j = (i - 1); j >= 0; j--){
if(fptr(element, *(array + j))){
/*condition for shifting*/
*(array + j + 1) = *(array + j);
}else{
/*found the right position for this element*/
*(array + j + 1) = element;
break;
}
}
/*insert the element at the start of the array*/
if(j < 0){
*(array) = element;
}
}
return 0;
}
void wrong_arguments_func_pointer_017 ()
{
int flag;
int (*fptr)(int,float);
fptr =wrong_arguments_func_pointer_017_func_002;
flag = fptr(1,4.5);
}
void wrong_arguments_func_pointer_015 ()
{
/*char str2[][15] = {{"STRING"},
{"TEST"},{"STRING#"},{"TEST!"},{"TRIAL"}};*/
int i;
wrong_arguments_func_pointer_015_dst1_gbl = (char**) malloc(5*sizeof(char*));
for(i=0;i<5;i++)
{
wrong_arguments_func_pointer_015_dst1_gbl[i]=(char*) malloc(15*sizeof(char));
}
while(1)
{
void (*fptr)(char **);
fptr = (void (*)(char**))wrong_arguments_func_pointer_015_func_002;
fptr(wrong_arguments_func_pointer_015_dst1_gbl);/*Tool should detect this line as error*//*ERROR:Wrong arguments passed to a function pointer*/
break;
}
for(i=0;i<5;i++)
{
free(wrong_arguments_func_pointer_015_dst1_gbl[i]);
wrong_arguments_func_pointer_015_dst1_gbl[i] = NULL;
}
free(wrong_arguments_func_pointer_015_dst1_gbl);
wrong_arguments_func_pointer_015_dst1_gbl = NULL;
}
void wrong_arguments_func_pointer_010 ()
{
wrong_arguments_func_pointer_010_s_001 st;
void (*fptr)(wrong_arguments_func_pointer_010_s_001);
fptr = (void (*)(wrong_arguments_func_pointer_010_s_001))wrong_arguments_func_pointer_010_func_001;
fptr(st);/*Tool should detect this line as error*//*ERROR:Wrong arguments passed to a function pointer*/
}
/********************************************************************
* Function: JumpToApp()
********************************************************************/
void JumpToApp(void)
{
printString("APP");
void (*fptr)(void);
fptr = (void (*)(void))0;
fptr();
}
void command_prompt(void *pvParameters)
{
char buf[128];
char *argv[20];
char hint[] = USER_NAME "@" USER_NAME "-STM32:~$ ";
fio_printf(1, "\rWelcome to FreeRTOS Shell\r\n");
while(1){
fio_printf(1, "%s", hint);
fio_read(0, buf, 127);
int n=parse_command(buf, argv);
/* will return pointer to the command function */
//if (*argv[0]=='\0')
cmdfunc *fptr=do_command(argv[0]);
if(fptr!=NULL)
fptr(n, argv);
else if (*argv[0]!='\0')
fio_printf(2, "\r\n\"%s\" command not found.\r\n", argv[0]);
else
fio_printf(1, "\r\n");
}
}
//---------------------------------------------------------------------------
// This function reads an OBJ file and generates vertices
// and triangles.
// The function will throw ReadOBJError types if the file
// read is not entirely successful.
// Note that this function does not collapse duplicate
// vertices; it simply parses the file. Freeform-specific
// operations such as removing duplicate vertices and checking
// if the file is a valid solid FF model should be performed at
// a higher level.
//
//---------------------------------------------------------------------------
bool readOBJAscii(const char *filename,
VertContainer* verts,
TriContainer* tris,
hduBoundBox3Df* vertBox)
{
FileHandle fptr(filename,"r");
if (!fptr) return false;
long numverts = 0;
// Do first pass through file.
// Read vertices and other appropriate numerically
// ordered information (e.g. textures, normals) and store those.
// These will then be used as information to
// generate the entities (e.g. polygons, surfaces) during
// the second pass.
if (!readObjVertices(fptr,verts,vertBox))
throw "readObjAscii vertex read failed.";
// Do second pass through file.
// Read entities and construct using vertex information stored from
// first pass.
if (verts->size() == 0)
throw "readOBJAscii zero vertices read.";
rewind(fptr);
if (!readObjFaces(fptr,verts, tris))
throw "readObjAscii faces read failed.";
if (tris->size() == 0)
throw "readOBJAscii zero faces read.";
return true;
}
int test27() {
switch (j) {
case 1:
do { } while (1);
break;
case 2:
for (;;) ;
break;
case 3:
for (;1;) ;
for (;0;) {
goto done;
}
return 1;
case 4:
while (0) { goto done; }
return 1;
case 5:
while (1) { return 1; }
break;
case 6:
fptr();
break;
default:
return 1;
}
done: ;
}
// formats and routes the record to all sinks
void log_backend_record(int level, const char* section, const char* fmt, va_list arguments)
{
const auto& sinks = log_formatter_getSinks();
if (sinks.empty())
return;
cur_record.sec = section;
cur_record.fmt = fmt;
cur_record.lvl = level;
// format the record
log_formatter_format(&cur_record, arguments);
// check for duplicates after formatting; can not be
// done in log_frontend_record or log_filter_record
const int cmp = (prv_record.msg[0] != 0 && STRCASECMP(cur_record.msg, prv_record.msg) == 0);
cur_record.cnt += cmp;
cur_record.cnt *= cmp;
if (cur_record.cnt >= log_filter_getRepeatLimit())
return;
// sink the record into each registered sink
for (log_sink_ptr fptr: sinks) {
fptr(level, section, cur_record.msg);
}
if (cur_record.cnt > 0)
return;
memcpy(prv_record.msg, cur_record.msg, sizeof(cur_record.msg));
}
int main(int argc, char **argv){
extern int bar;
extern int (*fptr) (void);
extern struct Bozza buzz;
printf("%s %d\n", "bar is ", bar);
int c = somefunc();
printf("%s%d\n", "Hello World, c is ", c);
c = somefunc();
printf("%s%d\n", "Hello World, c is ", c);
c = somefunc();
printf("%s%d\n", "Hello World, c is ", c);
c = somefunc();
printf("%s%d\n", "Hello World, c is ", c);
c = fptr();
printf("%s%d\n", "Hello World, c is ", c);
buzz.foobar = "Hello Foo";
return 0;
}
int main(int argc, char **argv) {
void (*fptr)(int) = signal(101, foo);
fptr(6667); //in this case => bar
return 0;
}
void func_pointer_014 ()
{
int flag;
int (*fptr)(int);
fptr = func_pointer_014_func_002;
flag = fptr(1);
}
/* <string> .libfile <string> false */
int /* exported for zsysvm.c */
zlibfile(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
int code;
byte cname[DEFAULT_BUFFER_SIZE];
uint clen;
gs_parsed_file_name_t pname;
stream *s;
gx_io_device *iodev_dflt;
check_ostack(2);
code = parse_file_name(op, &pname, i_ctx_p->LockFilePermissions, imemory);
if (code < 0)
return code;
iodev_dflt = iodev_default(imemory);
if (pname.iodev == NULL)
pname.iodev = iodev_dflt;
if (pname.iodev != iodev_dflt) { /* Non-OS devices don't have search paths (yet). */
code = zopen_file(i_ctx_p, &pname, "r", &s, imemory);
if (code >= 0) {
code = ssetfilename(s, op->value.const_bytes, r_size(op));
if (code < 0) {
sclose(s);
return_error(e_VMerror);
}
}
if (code < 0) {
push(1);
make_false(op);
return 0;
}
make_stream_file(op, s, "r");
} else {
ref fref;
code = lib_file_open(i_ctx_p->lib_path, imemory, i_ctx_p, pname.fname, pname.len,
(char *)cname, sizeof(cname), &clen, &fref);
if (code >= 0) {
s = fptr(&fref);
code = ssetfilename(s, cname, clen);
if (code < 0) {
sclose(s);
return_error(e_VMerror);
}
}
if (code < 0) {
if (code == e_VMerror || code == e_invalidfileaccess)
return code;
push(1);
make_false(op);
return 0;
}
ref_assign(op, &fref);
}
push(1);
make_true(op);
return 0;
}
void func_pointer_002 ()
{
char buf[10] = "string";
void (*fptr)(char);
/* int a; */
fptr = (void (*)(char ))func_pointer_002_func_001;
fptr(buf[0]);/*Tool should detect this line as error*/ /*ERROR:Bad function pointer casting*/
}
void func_pointer_007 ()
{
char buf[10] = "A string";
char ** (*fptr)(char []);
char ** a = NULL;
fptr = (char ** (*)(char []))func_pointer_007_func_001;
a =fptr(buf);/*Tool should detect this line as error*/ /*ERROR:Bad function pointer casting*/
}
void wrong_arguments_func_pointer_002 ()
{
char buf[10] = "string";
int (*fptr)(char *);
int a;
fptr = (int (*)(char *))wrong_arguments_func_pointer_002_func_001;
a =fptr(buf);/*Tool should detect this line as error*//*ERROR:Wrong arguments passed to a function pointer*/
}
void wrong_arguments_func_pointer_001 ()
{
int arr[5] = {1,2,3,4,5} ;
int (*fptr)(int *);
int a;
fptr = (int (*)(int *))wrong_arguments_func_pointer_001_func_001;
a =fptr(arr);/*Tool should detect this line as error*//*ERROR:Wrong arguments passed to a function pointer*/
}
/********************************************************************
* Function: JumpToApp()
*
* Precondition:
*
* Input: None.
*
* Output:
*
* Side Effects: No return from here.
*
* Overview: Jumps to application.
*
*
* Note: None.
********************************************************************/
void JumpToApp(void)
{
void (*fptr)(void);
INTDisableInterrupts();
fptr = (void (*)(void))USER_APP_RESET_ADDRESS;
fptr();
}
void AVL_PostTW(treenode * root, void (*fptr) (treenode *, void *), void *arg)
{ /* postorder tree walk, note root must not be null */
if (root->Lchild != NULL)
AVL_PostTW(root->Lchild, fptr, arg);
if (root->Rchild != NULL)
AVL_PostTW(root->Rchild, fptr, arg);
if (fptr != NULL)
fptr(root, arg);
}
raw_ios::pos_type raw_fstreambase<RawStream>::seekoff(raw_ios::off_type offs,
raw_ios::seekdir dir)
{
int whence ;
switch (dir)
{
case raw_ios::cur: whence = SEEK_CUR ; break ;
case raw_ios::beg:
if (!offs)
return std::ftell(fptr()) ;
whence = SEEK_SET ;
break ;
case raw_ios::end: whence = SEEK_END ; break ;
default: return raw_ios::pos_type(-1) ;
}
return fseek_i(fptr(), offs, whence) ? -1 : std::ftell(fptr()) ;
}
int main()
{
int x = 3;
int (*fptr)(int *) = foo;
fptr(&x);
return 0;
}
int main() {
int a, b ;
int (* fptr) (int) ;
a = 7 ;
printf("a = %d\n", a) ;
fptr = add3 ;
b = fptr(a) ;
printf("fptr(a) = %d\n", b ) ;
fptr = add5 ;
b = fptr(a) ;
printf("fptr(a) = %d\n", b ) ;
return 0 ;
}
int main()
{
{
std::FILE* f = std::fopen("test.txt", "r");
boost::shared_ptr<FILE> fptr(f, deleter);
std::fseek(fptr.get(), 42, SEEK_SET); // note -- this will cause a seg fault if test.txt is an empty file
} // deleter(FILE*) is called as the file goes out of scope
std::cout << "By now, the FILE has been closed!" << std::endl;
}
int main()
{
void (*fptr)();
printf("func1 is at %p\n", func1);
printf("func2 is at %p\n", func2);
printf("Which to execute? ");
scanf("%p", &fptr);
fptr();
return 0;
}
// CHECK-LABEL: foo
void foo(int a, int b) {
void (*fptr)(void) noexcept = fnoexcp;
// CHECK: call {{.+}} @__kmpc_fork_call({{.+}} [[REGNAME2:@.*]] to void (i32*, i32*, ...)*), void ()** %{{.+}})
#pragma omp parallel
{
fptr();
}
// CHECK: ret void
}
void func_pointer_009 ()
{
int ret;
func_pointer_009_u_001 *p = NULL;
func_pointer_009_u_001 (*fptr)();
fptr = (func_pointer_009_u_001 (*)(void))func_pointer_009_func_001;
*p = fptr();/*Tool should detect this line as error*/ /*ERROR:Bad function pointer casting*/
ret = p->b;
free(p);
p= NULL;
}
int main() {
fprintf(stderr,"all of the following should be 1 except xs[259] = 0\n");
a = 3;
b = 259;
fptr = (volatile int (*)(unsigned char x))&testUcharX;
if ((((size_t)fptr)&((size_t)1)) == 1) fptr = NULL;
fprintf(stderr,"compiled with: '%s'\nxs[3] = %d\nxs[259] = %d\ntestUcharX(3) = %d\ntestUcharX(%d) = %d\nfptr(3) = %d\nfptr(259) = %d\n",
xstr(CC), xs[a], xs[b], testUcharX(a), b, testUcharX((unsigned char)b), fptr(a), fptr(b));
fprintf(stderr,"misc tests:\n");
struct1 a = {352.39422e23, 19.287577};
a = test_1(a);
}
