int Curl_debug(struct SessionHandle *data, curl_infotype type, char *ptr, size_t size, char *host) { int rc; if(data->set.printhost && host) { char buffer[160]; const char *t=NULL; switch (type) { case CURLINFO_HEADER_IN: case CURLINFO_DATA_IN: t = "from"; break; case CURLINFO_HEADER_OUT: case CURLINFO_DATA_OUT: t = "to"; break; default: break; } if(t) { snprintf(buffer, sizeof(buffer), "[Data %s %s]", t, host); rc = showit(data, CURLINFO_TEXT, buffer, strlen(buffer)); if(rc) return rc; } } rc = showit(data, type, ptr, size); return rc; }
int Curl_debug(struct SessionHandle *data, curl_infotype type, char *ptr, size_t size, struct connectdata *conn) { int rc; if(data->set.printhost && conn && conn->host.dispname) { char buffer[160]; const char *t=NULL; const char *w="Data"; switch (type) { case CURLINFO_HEADER_IN: w = "Header"; case CURLINFO_DATA_IN: t = "from"; break; case CURLINFO_HEADER_OUT: w = "Header"; case CURLINFO_DATA_OUT: t = "to"; break; default: break; } if(t) { snprintf(buffer, sizeof(buffer), "[%s %s %s]", w, t, conn->host.dispname); rc = showit(data, CURLINFO_TEXT, buffer, strlen(buffer)); if(rc) return rc; } } rc = showit(data, type, ptr, size); return rc; }
static void explode(int row, int col) { chtype bold; erase(); MvPrintw(row, col, "-"); showit(); init_pair(1, get_colour(&bold), my_bg); (void) attrset(COLOR_PAIR(1) | bold); MvPrintw(row - 1, col - 1, " - "); MvPrintw(row + 0, col - 1, "-+-"); MvPrintw(row + 1, col - 1, " - "); showit(); init_pair(1, get_colour(&bold), my_bg); (void) attrset(COLOR_PAIR(1) | bold); MvPrintw(row - 2, col - 2, " --- "); MvPrintw(row - 1, col - 2, "-+++-"); MvPrintw(row + 0, col - 2, "-+#+-"); MvPrintw(row + 1, col - 2, "-+++-"); MvPrintw(row + 2, col - 2, " --- "); showit(); init_pair(1, get_colour(&bold), my_bg); (void) attrset(COLOR_PAIR(1) | bold); MvPrintw(row - 2, col - 2, " +++ "); MvPrintw(row - 1, col - 2, "++#++"); MvPrintw(row + 0, col - 2, "+# #+"); MvPrintw(row + 1, col - 2, "++#++"); MvPrintw(row + 2, col - 2, " +++ "); showit(); init_pair(1, get_colour(&bold), my_bg); (void) attrset(COLOR_PAIR(1) | bold); MvPrintw(row - 2, col - 2, " # "); MvPrintw(row - 1, col - 2, "## ##"); MvPrintw(row + 0, col - 2, "# #"); MvPrintw(row + 1, col - 2, "## ##"); MvPrintw(row + 2, col - 2, " # "); showit(); init_pair(1, get_colour(&bold), my_bg); (void) attrset(COLOR_PAIR(1) | bold); MvPrintw(row - 2, col - 2, " # # "); MvPrintw(row - 1, col - 2, "# #"); MvPrintw(row + 0, col - 2, " "); MvPrintw(row + 1, col - 2, "# #"); MvPrintw(row + 2, col - 2, " # # "); showit(); }
int main(void) { void showit(char*); int i = 0; printf("Adr etext:%8x\tAdr edata:%8x \t Adr end :%8x \n\n", &etext, &edata, &end); SHW_ADR("main", main); SHW_ADR("showit", showit); SHW_ADR("cptr", cptr); SHW_ADR("buffer1", buffer1); SHW_ADR("i", i); strcpy(buffer1, "A demonstration\n"); write(1, buffer1, strlen(buffer1) + 1); for (; i < 1; ++i) { showit(cptr); } return 0; }
int main(int argc, char **argv) { FILE *tmpfd; char makeMacro[ BUFSIZ ]; char makefileMacro[ BUFSIZ ]; program = argv[0]; init(); SetOpts(argc, argv); Imakefile = FindImakefile(Imakefile); CheckImakefileC(ImakefileC); if (Makefile) tmpMakefile = Makefile; else { tmpMakefile = Strdup(tmpMakefile); (void) mkstemp(tmpMakefile); } AddMakeArg("-f"); AddMakeArg( tmpMakefile ); sprintf(makeMacro, "MAKE=%s", program); AddMakeArg( makeMacro ); sprintf(makefileMacro, "MAKEFILE=%s", Imakefile); AddMakeArg( makefileMacro ); if ((tmpfd = fopen(tmpMakefile, "w+")) == NULL) LogFatal("Cannot create temporary file %s.", tmpMakefile); cleanedImakefile = CleanCppInput(Imakefile); cppit(cleanedImakefile, Template, ImakefileC, tmpfd, tmpMakefile); if (show) { if (Makefile == NULL) showit(tmpfd); } else makeit(); wrapup(); exit(0); }
static void preview(DepositControls *controls, DepositArgs *args) { GwyDataField *dfield, *lfield, *zlfield, *zdfield; gint xres, yres, oxres, oyres; gint add, i, ii, m, k; gdouble size, width; gint xdata[10000]; gint ydata[10000]; gdouble disizes[10000]; gdouble rdisizes[10000]; gdouble rx[10000]; gdouble ry[10000]; gdouble rz[10000]; gdouble ax[10000]; gdouble ay[10000]; gdouble az[10000]; gdouble vx[10000]; gdouble vy[10000]; gdouble vz[10000]; gdouble fx[10000]; gdouble fy[10000]; gdouble fz[10000]; gint xpos, ypos, ndata, too_close; gdouble disize, mdisize; gdouble xreal, yreal, oxreal, oyreal; gdouble diff; gdouble mass = 1; gint presetval; gint nloc, maxloc = 1; gint max = 5000000; gdouble rxv, ryv, rzv, timestep = 3e-7; //5e-7 deposit_dialog_update_values(controls, args); dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(controls->mydata, "/0/data")); gwy_container_set_object_by_name(controls->mydata, "/0/data", gwy_data_field_duplicate(controls->old_dfield)); dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(controls->mydata, "/0/data")); if (controls->in_init) { gwy_data_field_data_changed(dfield); while (gtk_events_pending()) gtk_main_iteration(); return; } oxres = gwy_data_field_get_xres(dfield); oyres = gwy_data_field_get_yres(dfield); oxreal = gwy_data_field_get_xreal(dfield); oyreal = gwy_data_field_get_yreal(dfield); diff = oxreal/oxres/10; size = args->size*5e-9; // width = args->width*5e-9 + 2*size; //increased manually to fill boundaries width = 2*size; add = gwy_data_field_rtoi(dfield, size + width); mdisize = gwy_data_field_rtoi(dfield, size); xres = oxres + 2*add; yres = oyres + 2*add; xreal = oxreal + 2*(size+width); yreal = oyreal + 2*(size+width); // printf("For field of size %g and particle nominak %g, real %g (%g), the final size will change from %d to %d\n", // gwy_data_field_get_xreal(dfield), args->size, size, disize, oxres, xres); /*make copy of datafield, with mirrored boundaries*/ lfield = gwy_data_field_new(xres, yres, gwy_data_field_itor(dfield, xres), gwy_data_field_jtor(dfield, yres), TRUE); gwy_data_field_area_copy(dfield, lfield, 0, 0, oxres, oyres, add, add); gwy_data_field_invert(dfield, 1, 0, 0); gwy_data_field_area_copy(dfield, lfield, 0, oyres-add-1, oxres, add, add, 0); gwy_data_field_area_copy(dfield, lfield, 0, 0, oxres, add, add, yres-add-1); gwy_data_field_invert(dfield, 1, 0, 0); gwy_data_field_invert(dfield, 0, 1, 0); gwy_data_field_area_copy(dfield, lfield, oxres-add-1, 0, add, oyres, 0, add); gwy_data_field_area_copy(dfield, lfield, 0, 0, add, oyres, xres-add-1, add); gwy_data_field_invert(dfield, 0, 1, 0); gwy_data_field_invert(dfield, 1, 1, 0); gwy_data_field_area_copy(dfield, lfield, oxres-add-1, oyres-add-1, add, add, 0, 0); gwy_data_field_area_copy(dfield, lfield, 0, 0, add, add, xres-add-1, yres-add-1); gwy_data_field_area_copy(dfield, lfield, oxres-add-1, 0, add, add, 0, yres-add-1); gwy_data_field_area_copy(dfield, lfield, 0, oyres-add-1, add, add, xres-add-1, 0); gwy_data_field_invert(dfield, 1, 1, 0); zlfield = gwy_data_field_duplicate(lfield); zdfield = gwy_data_field_duplicate(dfield); /*determine number of spheres necessary for given coverage*/ for (i=0; i<10000; i++) { ax[i] = ay[i] = az[i] = vx[i] = vy[i] = vz[i] = 0; } srand ( time(NULL) ); ndata = 0; /* for test only */ /* disize = mdisize; xpos = oxres/2 - 2*disize; ypos = oyres/2; xdata[ndata] = xpos; ydata[ndata] = ypos; disizes[ndata] = disize; rdisizes[ndata] = size; rx[ndata] = (gdouble)xpos*oxreal/(gdouble)oxres; ry[ndata] = (gdouble)ypos*oyreal/(gdouble)oyres; rz[ndata] = 2.0*gwy_data_field_get_val(lfield, xpos, ypos) + rdisizes[ndata]; ndata++; xpos = oxres/2 + 2*disize; ypos = oyres/2; xdata[ndata] = xpos; ydata[ndata] = ypos; disizes[ndata] = disize; rdisizes[ndata] = size; rx[ndata] = (gdouble)xpos*oxreal/(gdouble)oxres; ry[ndata] = (gdouble)ypos*oyreal/(gdouble)oyres; rz[ndata] = 2.0*gwy_data_field_get_val(lfield, xpos, ypos) + rdisizes[ndata]; ndata++; */ /*end of test*/ i = 0; presetval = args->coverage*10; while (ndata < presetval && i<max) { //disize = mdisize*(0.8+(double)(rand()%20)/40.0); disize = mdisize; xpos = disize+(rand()%(xres-2*(gint)(disize+1))) + 1; ypos = disize+(rand()%(yres-2*(gint)(disize+1))) + 1; i++; { too_close = 0; /*sync real to integer positions*/ for (k=0; k<ndata; k++) { if (((xpos-xdata[k])*(xpos-xdata[k]) + (ypos-ydata[k])*(ypos-ydata[k]))<(4*disize*disize)) { too_close = 1; break; } } if (too_close) continue; if (ndata>=10000) { break; } xdata[ndata] = xpos; ydata[ndata] = ypos; disizes[ndata] = disize; rdisizes[ndata] = size; rx[ndata] = (gdouble)xpos*oxreal/(gdouble)oxres; ry[ndata] = (gdouble)ypos*oyreal/(gdouble)oyres; //printf("surface at %g, particle size %g\n", gwy_data_field_get_val(lfield, xpos, ypos), rdisizes[ndata]); rz[ndata] = 1.0*gwy_data_field_get_val(lfield, xpos, ypos) + rdisizes[ndata]; //2 ndata++; } }; // if (i==max) printf("Maximum reached, only %d particles depositd instead of %d\n", ndata, presetval); // else printf("%d particles depositd\n", ndata); /*refresh shown data and integer positions (necessary in md calculation)*/ gwy_data_field_copy(zlfield, lfield, 0); showit(lfield, zdfield, rdisizes, rx, ry, rz, xdata, ydata, ndata, oxres, oxreal, oyres, oyreal, add, xres, yres); gwy_data_field_area_copy(lfield, dfield, add, add, oxres, oyres, 0, 0); gwy_data_field_data_changed(dfield); for (i=0; i<(20*args->revise); i++) { // printf("###### step %d of %d ##########\n", i, (gint)(20*args->revise)); /*try to add some particles if necessary, do this only for first half of molecular dynamics*/ if (ndata<presetval && i<(10*args->revise)) { ii = 0; nloc = 0; while (ndata < presetval && ii<(max/1000) && nloc<maxloc) { disize = mdisize; xpos = disize+(rand()%(xres-2*(gint)(disize+1))) + 1; ypos = disize+(rand()%(yres-2*(gint)(disize+1))) + 1; ii++; { too_close = 0; rxv = ((gdouble)xpos*oxreal/(gdouble)oxres); ryv = ((gdouble)ypos*oyreal/(gdouble)oyres); rzv = gwy_data_field_get_val(zlfield, xpos, ypos) + 5*size; for (k=0; k<ndata; k++) { if (((rxv-rx[k])*(rxv-rx[k]) + (ryv-ry[k])*(ryv-ry[k]) + (rzv-rz[k])*(rzv-rz[k]))<(4.0*size*size)) { too_close = 1; break; } } if (too_close) continue; if (ndata>=10000) { // printf("Maximum reached!\n"); break; } xdata[ndata] = xpos; ydata[ndata] = ypos; disizes[ndata] = disize; rdisizes[ndata] = size; rx[ndata] = rxv; ry[ndata] = ryv; rz[ndata] = rzv; vz[ndata] = -0.01; ndata++; nloc++; } }; // if (ii==(max/100)) printf("Maximum reached, only %d particles now present instead of %d\n", ndata, presetval); // else printf("%d particles now at surface\n", ndata); } /*test succesive LJ steps on substrate (no relaxation)*/ for (k=0; k<ndata; k++) { fx[k] = fy[k] = fz[k] = 0; /*calculate forces for all particles on substrate*/ if (gwy_data_field_rtoi(lfield, rx[k])<0 || gwy_data_field_rtoj(lfield, ry[k])<0 || gwy_data_field_rtoi(lfield, rx[k])>=xres || gwy_data_field_rtoj(lfield, ry[k])>=yres) continue; for (m=0; m<ndata; m++) { if (m==k) continue; // printf("(%g %g %g) on (%g %g %g)\n", rx[m], ry[m], rz[m], rx[k], ry[k], rz[k]); fx[k] -= (get_lj_potential_spheres(rx[m], ry[m], rz[m], rx[k]+diff, ry[k], rz[k], gwy_data_field_itor(dfield, disizes[k])) -get_lj_potential_spheres(rx[m], ry[m], rz[m], rx[k]-diff, ry[k], rz[k], gwy_data_field_itor(dfield, disizes[k])))/2/diff; fy[k] -= (get_lj_potential_spheres(rx[m], ry[m], rz[m], rx[k], ry[k]+diff, rz[k], gwy_data_field_itor(dfield, disizes[k])) -get_lj_potential_spheres(rx[m], ry[m], rz[m], rx[k], ry[k]-diff, rz[k], gwy_data_field_itor(dfield, disizes[k])))/2/diff; fz[k] -= (get_lj_potential_spheres(rx[m], ry[m], rz[m], rx[k], ry[k], rz[k]+diff, gwy_data_field_itor(dfield, disizes[k])) -get_lj_potential_spheres(rx[m], ry[m], rz[m], rx[k], ry[k], rz[k]-diff, gwy_data_field_itor(dfield, disizes[k])))/2/diff; } fx[k] -= (integrate_lj_substrate(zlfield, rx[k]+diff, ry[k], rz[k], rdisizes[k]) - integrate_lj_substrate(zlfield, rx[k]-diff, ry[k], rz[k], rdisizes[k]))/2/diff; fy[k] -= (integrate_lj_substrate(zlfield, rx[k], ry[k]-diff, rz[k], rdisizes[k]) - integrate_lj_substrate(zlfield, rx[k], ry[k]+diff, rz[k], rdisizes[k]))/2/diff; fz[k] -= (integrate_lj_substrate(zlfield, rx[k], ry[k], rz[k]+diff, rdisizes[k]) - integrate_lj_substrate(zlfield, rx[k], ry[k], rz[k]-diff, rdisizes[k]))/2/diff; } for (k=0; k<ndata; k++) { if (gwy_data_field_rtoi(lfield, rx[k])<0 || gwy_data_field_rtoj(lfield, ry[k])<0 || gwy_data_field_rtoi(lfield, rx[k])>=xres || gwy_data_field_rtoj(lfield, ry[k])>=yres) continue; /*move all particles*/ rx[k] += vx[k]*timestep + 0.5*ax[k]*timestep*timestep; vx[k] += 0.5*ax[k]*timestep; ax[k] = fx[k]/mass; vx[k] += 0.5*ax[k]*timestep; vx[k] *= 0.9; if (fabs(vx[k])>0.01) vx[k] = 0; //0.2 ry[k] += vy[k]*timestep + 0.5*ay[k]*timestep*timestep; vy[k] += 0.5*ay[k]*timestep; ay[k] = fy[k]/mass; vy[k] += 0.5*ay[k]*timestep; vy[k] *= 0.9; if (fabs(vy[k])>0.01) vy[k] = 0; //0.2 rz[k] += vz[k]*timestep + 0.5*az[k]*timestep*timestep; vz[k] += 0.5*az[k]*timestep; az[k] = fz[k]/mass; vz[k] += 0.5*az[k]*timestep; vz[k] *= 0.9; if (fabs(vz[k])>0.01) vz[k] = 0; if (rx[k]<=gwy_data_field_itor(dfield, disizes[k])) rx[k] = gwy_data_field_itor(dfield, disizes[k]); if (ry[k]<=gwy_data_field_itor(dfield, disizes[k])) ry[k] = gwy_data_field_itor(dfield, disizes[k]); if (rx[k]>=(xreal-gwy_data_field_itor(dfield, disizes[k]))) rx[k] = xreal-gwy_data_field_itor(dfield, disizes[k]); if (ry[k]>=(yreal-gwy_data_field_itor(dfield, disizes[k]))) ry[k] = yreal-gwy_data_field_itor(dfield, disizes[k]); } gwy_data_field_copy(zlfield, lfield, 0); showit(lfield, zdfield, rdisizes, rx, ry, rz, xdata, ydata, ndata, oxres, oxreal, oyres, oyreal, add, xres, yres); gwy_data_field_area_copy(lfield, dfield, add, add, oxres, oyres, 0, 0); gwy_data_field_data_changed(dfield); while (gtk_events_pending()) gtk_main_iteration(); } gwy_data_field_area_copy(lfield, dfield, add, add, oxres, oyres, 0, 0); gwy_data_field_data_changed(dfield); args->computed = TRUE; gwy_object_unref(lfield); gwy_object_unref(zlfield); gwy_object_unref(zdfield); }
// Find the device, and set up to read it periodically, then send // the data out stdout so another process can pick it up and do // something reasonable with it. // int main(int argc, char **argv) { char *usage = {"usage: %s -u -n\n"}; int libusbDebug = 0; //This will turn on the DEBUG for libusb int noisy = 0; //This will print the packets as they come in libusb_device **devs; int r, err, c; ssize_t cnt; while ((c = getopt (argc, argv, "unh")) != -1) switch (c){ case 'u': libusbDebug = 1; break; case 'n': noisy = 1; break; case 'h': fprintf(stderr, usage, argv[0]); case '?': exit(1); default: exit(1); } fprintf(stderr,"%s Starting ... ",argv[0]); fprintf(stderr,"libusbDebug = %d, noisy = %d\n", libusbDebug, noisy); // The Pi linker can give you fits. If you get a linker error on // the next line, set LD_LIBRARY_PATH to /usr/local/lib fprintf(stderr,"This is not an error!! Checking linker, %s\n", libusb_strerror(0)); if (signal(SIGINT, sig_handler) == SIG_ERR) fprintf(stderr,"Couldn't set up signal handler\n"); err = libusb_init(NULL); if (err < 0){ fprintf(stderr,"Couldn't init usblib, %s\n", libusb_strerror(err)); exit(1); } // This is where you can get debug output from libusb. // just set it to LIBUSB_LOG_LEVEL_DEBUG if (libusbDebug) libusb_set_debug(NULL, LIBUSB_LOG_LEVEL_DEBUG); else libusb_set_debug(NULL, LIBUSB_LOG_LEVEL_INFO); cnt = libusb_get_device_list(NULL, &devs); if (cnt < 0){ fprintf(stderr,"Couldn't get device list, %s\n", libusb_strerror(err)); exit(1); } // go get the device; the device handle is saved in weatherStation struct. if (!findDevice(devs)){ fprintf(stderr,"Couldn't find the device\n"); exit(1); } // Now I've found the weather station and can start to try stuff // So, I'll get the device descriptor struct libusb_device_descriptor deviceDesc; err = libusb_get_device_descriptor(weatherStation.device, &deviceDesc); if (err){ fprintf(stderr,"Couldn't get device descriptor, %s\n", libusb_strerror(err)); exit(1); } fprintf(stderr,"got the device descriptor back\n"); // Open the device and save the handle in the weatherStation struct err = libusb_open(weatherStation.device, &weatherStation.handle); if (err){ fprintf(stderr,"Open failed, %s\n", libusb_strerror(err)); closeUpAndLeave(); } fprintf(stderr,"I was able to open it\n"); // Now that it's opened, I can free the list of all devices libusb_free_device_list(devs, 1); // Documentation says to get rid of the list // Once I have the device I need fprintf(stderr,"Released the device list\n"); err = libusb_set_auto_detach_kernel_driver(weatherStation.handle, 1); if(err){ fprintf(stderr,"Some problem with detach %s\n", libusb_strerror(err)); closeUpAndLeave(); } int activeConfig; err =libusb_get_configuration(weatherStation.handle, &activeConfig); if (err){ fprintf(stderr,"Can't get current active configuration, %s\n", libusb_strerror(err));; closeUpAndLeave(); } fprintf(stderr,"Currently active configuration is %d\n", activeConfig); if(activeConfig != 1){ err = libusb_set_configuration (weatherStation.handle, 1); if (err){ fprintf(stderr,"Cannot set configuration, %s\n", libusb_strerror(err));; closeUpAndLeave(); } fprintf(stderr,"Just did the set configuration\n"); } err = libusb_claim_interface(weatherStation.handle, 0); //claim interface 0 (the first) of device (mine had just 1) if(err) { fprintf(stderr,"Cannot claim interface, %s\n", libusb_strerror(err)); closeUpAndLeave(); } fprintf(stderr,"Claimed Interface\n"); // I don't want to just hang up and read the reports as fast as I can, so // I'll space them out a bit. It's weather, and it doesn't change very fast. sleep(1); fprintf(stderr,"Setting the device 'idle' before starting reads\n"); err = libusb_control_transfer(weatherStation.handle, 0x21, 0x0a, 0, 0, 0, 0, 1000); sleep(1); int tickcounter= 0; fprintf(stderr,"Starting reads\n"); while(1){ sleep(1); if(tickcounter++ % 10 == 0){ getit(1, noisy); } if(tickcounter % 30 == 0){ getit(2, noisy); } if (tickcounter % 15 == 0){ showit(); } } }
int foo(int bar) { switch (bar) { case 0: { showit(0); } c++; break; case 1: { showit(bar); break; } case 2: { break; } case 3: { int a = bar * 3; showit(a); } c++; break; case 4: { foo(bar - 1); { showit(0); } } case 10: { switch (gl_bug) { case 'a': { gl_foo = true; break; } case 'b': case 'c': { gl_foo = false; break; } default: { // nothing break; } } break; } default: { break; } } return(-1); }