Exec_stat MCVariableValue::fetch(MCExecPoint& ep, bool p_copy) { switch(get_type()) { case VF_UNDEFINED: ep . setboth("", 0.0); break; case VF_STRING: assert(is_string()); ep . setsvalue(get_string()); if (p_copy) ep . grabsvalue(); break; case VF_NUMBER: ep . setnvalue(get_real()); break; case VF_BOTH: ep . setboth(get_string(), get_real()); if (p_copy) ep . grabsvalue(); break; case VF_ARRAY: if (!p_copy) ep . setarray(this, False); else ep . setarray(new MCVariableValue(*this), True); break; } return ES_NORMAL; }
void test_align() { { const std::size_t size = 1; const std::size_t alignment = 1; const std::size_t real_size = need_alloc(size, alignment); void *real = malloc(real_size); assert(real != nullptr); void *result = align(real, alignment); assert(reinterpret_cast<std::size_t>(result) % alignment == 0); assert(get_real(result) == real); assert(reinterpret_cast<char *>(real) + real_size >= reinterpret_cast<char *>(result) + size); free(real); } { const std::size_t size = sizeof(void *); const std::size_t alignment = 1; const std::size_t real_size = need_alloc(size, alignment); void *real = malloc(real_size); assert(real != nullptr); void *result = align(real, alignment); assert(reinterpret_cast<std::size_t>(result) % alignment == 0); assert(get_real(result) == real); assert(reinterpret_cast<char *>(real) + real_size >= reinterpret_cast<char *>(result) + size); free(real); } { const std::size_t size = sizeof(void *); const std::size_t alignment = sizeof(void *); const std::size_t real_size = need_alloc(size, alignment); void *real = malloc(real_size); assert(real != nullptr); void *result = align(real, alignment); assert(reinterpret_cast<std::size_t>(result) % alignment == 0); assert(get_real(result) == real); assert(reinterpret_cast<char *>(real) + real_size >= reinterpret_cast<char *>(result) + size); free(real); } { const std::size_t size = sizeof(void *); const std::size_t alignment = sizeof(void *) + 1; const std::size_t real_size = need_alloc(size, alignment); void *real = malloc(real_size); assert(real != nullptr); void *result = align(real, alignment); assert(reinterpret_cast<std::size_t>(result) % alignment == 0); assert(get_real(result) == real); assert(reinterpret_cast<char *>(real) + real_size >= reinterpret_cast<char *>(result) + size); free(real); } }
int Jenarix::colorsphere( jx_ob ob ) { GLdouble xyz[3], r, rgb[3]; unsigned int ixyz = 0; unsigned int irgb = 1; unsigned int irad = 2; assert (jx_list_check(ob)); int nval = jx_list_size(ob); //printf ("%d sphere\n", nval); for ( int index = 0; index < nval; ++index ) { jx_ob xyz_rgb_rad = jx_list_shift(ob); glPushMatrix(); //printf ("%d\n", value[index].size()); get_point(jx_list_get(xyz_rgb_rad, ixyz), xyz); glTranslated(xyz[0], xyz[1], xyz[2]); get_point(jx_list_get(xyz_rgb_rad, irgb), rgb); color(rgb[0], rgb[1], rgb[2], 0.0); GLUquadricObj* quadric = gluNewQuadric(); gluQuadricDrawStyle(quadric, GLU_FILL); gluQuadricOrientation(quadric, GLU_OUTSIDE); gluQuadricNormals(quadric, GLU_SMOOTH); //printf ("%f %f %f\n", xyz[0], xyz[1], xyz[2]); r = get_real(jx_list_get(xyz_rgb_rad, irad)); gluSphere(quadric, r, 20, 20); //printf ("%f\n", r); gluDeleteQuadric(quadric); glPopMatrix(); } return nval; }
void print_object(pointer P, symbol_table* table) { FILE* out = stdout; if(P == NIL) { fputs("NIL", out); return; } switch(get_type_id(P)) { case DT_Pair: if(is_type(pair_car(P), DT_Pair)) { putc('(', out); print_object(pair_car(P), table); putc(')', out); } else print_object(pair_car(P), table); putc(' ', out); if(pair_cdr(P) != NIL) { if(!is_type(pair_cdr(P), DT_Pair)) fputs(". ", out); print_object(pair_cdr(P), table); } break; case DT_Symbol: fputs(string_from_symbol(table, *get_symbol(P)), out); break; case DT_Int: fprintf(out, "%d", get_int(P)); break; case DT_Real: fprintf(out, "%f", get_real(P)); break; case DT_String: fputs(get_string(P), out); break; case DT_Char: putc(get_char(P), out); break; case DT_TypeInfo: print_typeinfo(P, table, out); break; case DT_Invalid: fputs("#INVALID#", out); break; case DT_Any: fputs("#ANY#", out); break; } }
int get_point( jx_ob ob, GLdouble xyz[3] ) { assert (jx_list_check(ob)); assert (jx_list_size(ob) == 3); for (unsigned int index=0; index < 3; ++index) { xyz[index] = get_real(jx_list_shift(ob)); } return 3; }
void zerophase(int window_size, void* args, Spectra source, Spectra result) { gsl_rng* r = gsl_rng_alloc(gsl_rng_default); int i; for (i = 0; i < window_size / 2 + 1; i++) { set_by_polar(result, i, get_magnitude(source, i), gsl_rng_uniform (r) * 2 * M_PI); fprintf(stderr, "%f\n", get_phase(result, i)); if (i > 0 && i < window_size / 2) { set_value(result, window_size - i, get_real(result, i), get_imag(result, i)); } } }
int Jenarix::cylinder( jx_ob ob) { GLdouble bxyz[3], txyz[3], r; GLdouble dx, dy, dz, h; unsigned int ibxyz = 0; unsigned int itxyz = 1; unsigned int irad = 2; assert (jx_list_check(ob)); int nval = jx_list_size(ob); //printf ("%d cylinder\n", nval); for ( int index = 0; index < nval; ++index ) { jx_ob base_tip_rad = jx_list_shift(ob); //printf ("%d\n", value[index].size()); get_point(jx_list_get(base_tip_rad,ibxyz), bxyz); //printf ("%f %f %f\n", bxyz[0], bxyz[1], bxyz[2]); get_point(jx_list_get(base_tip_rad,itxyz), txyz); //printf ("%f %f %f\n", txyz[0], txyz[1], txyz[2]); dx = txyz[0] - bxyz[0]; dy = txyz[1] - bxyz[1]; dz = txyz[2] - bxyz[2]; h = sqrt(dx*dx + dy*dy + dz*dz); glPushMatrix(); align_from_z(bxyz, txyz); GLUquadricObj* quadric = gluNewQuadric(); gluQuadricDrawStyle(quadric, GLU_FILL); gluQuadricOrientation(quadric, GLU_OUTSIDE); gluQuadricNormals(quadric, GLU_SMOOTH); r = get_real(jx_list_get(base_tip_rad, irad)); //printf ("%f\n", r); gluCylinder(quadric, r, r, h, 20, 20); gluDeleteQuadric(quadric); glPopMatrix(); } return nval; }
int print_histograms (IO_BUFFER *iobuf) { int mhisto, ihisto, rc, ncounts; char title[256]; char type, cdummy; long ident; unsigned long entries=0, tentries=0; int nbins=0, nbins_2d=0, ibin; double content=0., content_inside=0.; int ls; IO_ITEM_HEADER item_header; if ( iobuf == (IO_BUFFER *) NULL ) return -1; item_header.type = 100; if ( (rc = get_item_begin(iobuf,&item_header)) != 0 ) return rc; printf("Histogram block, version %d, size %ld:\n", item_header.version, iobuf->item_length[iobuf->item_level-1]); if ( item_header.version < 1 || item_header.version > 2 ) { Warning("Wrong version no. of histogram data to be read"); return -1; } mhisto = get_short(iobuf); for (ihisto=0; ihisto<mhisto; ihisto++) { type = (char) get_byte(iobuf); if ( (ls = get_string(title,sizeof(title)-1,iobuf)) % 2 == 0 ) cdummy = get_byte(iobuf); // Compiler may warn about it but this is OK. if ( ls < 0 ) ls = 0; else if ( (size_t) ls >= sizeof(title) ) ls = sizeof(title)-1; title[ls] = '\0'; /* Make sure title is properly truncated */ ident = get_long(iobuf); nbins = (int) get_short(iobuf); nbins_2d = (int) get_short(iobuf); entries = (uint32_t) get_long(iobuf); /* 32 bit number */ tentries = (uint32_t) get_long(iobuf); (void) get_long(iobuf); (void) get_long(iobuf); // printf(" Histogram %ld of type %c with %dx%d bins and %lu/%lu entries: %s\n", // ident, type, nbins, nbins_2d, tentries, entries, title); if ( type == 'R' || type == 'r' || type == 'F' || type == 'D' ) { (void) get_real(iobuf); (void) get_real(iobuf); (void) get_real(iobuf); (void) get_real(iobuf); } else if ( type == 'I' || type == 'i' ) { (void) get_long(iobuf); (void) get_long(iobuf); (void) get_long(iobuf); (void) get_long(iobuf); } else { printf(" Histogram %ld of type %c with %dx%d bins and %ld/%ld entries: %s\n", ident, type, nbins, nbins_2d, tentries, entries, title); Warning("Invalid histogram type"); return -1; } if ( nbins_2d > 0 ) { (void) get_long(iobuf); (void) get_long(iobuf); if ( type == 'R' || type == 'r' || type == 'F' || type == 'D' ) { (void) get_real(iobuf); (void) get_real(iobuf); (void) get_real(iobuf); (void) get_real(iobuf); } else { (void) get_long(iobuf); (void) get_long(iobuf); (void) get_long(iobuf); (void) get_long(iobuf); } ncounts = nbins * nbins_2d; } else ncounts = nbins; /* Don't attempt to allocate histograms without data. */ if ( ncounts <= 0 ) { printf(" Histogram %ld of type %c with %dx%d bins and %lu/%lu entries: %s\n HAS NO CONTENTS!\n", ident, type, nbins, nbins_2d, tentries, entries, title); continue; } if ( type == 'F' || type == 'D' ) { content = get_real(iobuf); content_inside = get_real(iobuf); for (ibin=0; ibin<8; ibin++ ) (void) get_real(iobuf); /* content_outside... in histogram extension */ } if ( tentries > 0 ) for (ibin=0; ibin<ncounts; ibin++) (void) get_long(iobuf); /* long and real is the same length */ if ( type == 'F' || type == 'D' ) printf(" Histogram %ld of type %c with %dx%d bins and %lu/%lu entries (contents: %g/%g): %s\n", ident, type, nbins, nbins_2d, tentries, entries, content_inside, content, title); else printf(" Histogram %ld of type %c with %dx%d bins and %lu/%lu entries: %s\n", ident, type, nbins, nbins_2d, tentries, entries, title); } if ( (rc = get_item_end(iobuf,&item_header)) != 0 ) return rc; return(mhisto); }
int read_histograms_x (HISTOGRAM **phisto, int nhisto, const long *xcld_ids, int nxcld, IO_BUFFER *iobuf) { int mhisto, ihisto, rc, ncounts; char title[256]; char type, cdummy; long ident; double rlower[2] = {0., 0.}, rupper[2] = {0., 0.}, rsum[2] = {0., 0.}, rtsum[2] = {0., 0.}; long ilower[2] = {0,0}, iupper[2] = {0,0}, isum[2] = {0,0}, itsum[2] = {0,0}; long entries=0, tentries=0, underflow[2] = {0,0}, overflow[2] = {0,0}; int nbins=0, nbins_2d=0, ibin, mbins[2] = {0,0}; HISTOGRAM *thisto=NULL, *ohisto=NULL; IO_ITEM_HEADER item_header; int adding = 0; if ( nhisto < 0 ) { adding = 1; nhisto = -nhisto; } if ( iobuf == (IO_BUFFER *) NULL ) return -1; item_header.type = 100; if ( (rc = get_item_begin(iobuf,&item_header)) != 0 ) return rc; if ( item_header.version < 1 || item_header.version > 2 ) { Warning("Wrong version no. of histogram data to be read"); return -1; } // fprintf(stderr,"Read histograms called, with %d histograms excluded\n",nxcld); mhisto = get_short(iobuf); for (ihisto=0; ihisto<mhisto; ihisto++) { int add_this = 0, exclude_this = 0; type = (char) get_byte(iobuf); if ( get_string(title,sizeof(title)-1,iobuf) % 2 == 0 ) cdummy = get_byte(iobuf); // Compiler may warn about it but this is OK. ident = get_long(iobuf); nbins = (int) get_short(iobuf); nbins_2d = (int) get_short(iobuf); entries = (uint32_t) get_long(iobuf); tentries = (uint32_t) get_long(iobuf); underflow[0] = (uint32_t) get_long(iobuf); overflow[0] = (uint32_t) get_long(iobuf); if ( type == 'R' || type == 'r' || type == 'F' || type == 'D' ) { rlower[0] = get_real(iobuf); rupper[0] = get_real(iobuf); rsum[0] = get_real(iobuf); rtsum[0] = get_real(iobuf); } else { ilower[0] = get_long(iobuf); iupper[0] = get_long(iobuf); isum[0] = get_long(iobuf); itsum[0] = get_long(iobuf); } if ( nbins_2d > 0 ) { underflow[1] = (uint32_t) get_long(iobuf); overflow[1] = (uint32_t) get_long(iobuf); if ( type == 'R' || type == 'r' || type == 'F' || type == 'D' ) { rlower[1] = get_real(iobuf); rupper[1] = get_real(iobuf); rsum[1] = get_real(iobuf); rtsum[1] = get_real(iobuf); } else { ilower[1] = get_long(iobuf); iupper[1] = get_long(iobuf); isum[1] = get_long(iobuf); itsum[1] = get_long(iobuf); } ncounts = nbins * nbins_2d; } else ncounts = nbins; /* Don't attempt to allocate histograms without data. */ if ( ncounts <= 0 ) continue; if ( xcld_ids != (const long *) NULL && nxcld > 0 ) { int ixcld; for ( ixcld=0; ixcld<nxcld && xcld_ids[ixcld] > 0; ixcld++ ) { if ( xcld_ids[ixcld] == ident ) { exclude_this = 1; break; } } } /* If the histogram has a numerical identifier delete a */ /* previously existing histogram with the same identifier. */ ohisto = NULL; if ( ident != 0 ) { if ( (ohisto=get_histogram_by_ident(ident)) != (HISTOGRAM *)NULL ) { if ( adding && ! exclude_this ) add_this = 1; else free_histogram(ohisto); } } /* (Re-) Allocate the new histogram according to its type. */ thisto = NULL; // if ( ! exclude_this ) /* Would really exclude all histograms of this ID but we just don't want to add it up */ { if ( nbins_2d > 0 ) { if ( type == 'R' || type == 'r' ) thisto = alloc_2d_real_histogram(rlower[0],rupper[0],nbins, rlower[1],rupper[1],nbins_2d); else if ( type == 'F' || type == 'D' ) { mbins[0] = nbins; mbins[1] = nbins_2d; thisto = allocate_histogram(&type,2,rlower,rupper,mbins); } else thisto = alloc_2d_int_histogram(ilower[0],iupper[0],nbins, ilower[1],iupper[1],nbins_2d); } else { if ( type == 'R' || type == 'r' ) thisto = alloc_real_histogram(rlower[0],rupper[0],nbins); else if ( type == 'F' || type == 'D' ) thisto = allocate_histogram(&type,1,rlower,rupper,&nbins); else thisto = alloc_int_histogram(ilower[0],iupper[0],nbins); } } /* If the allocation failed or the histogram should be excluded, skip the histogram contents. */ /* This should guarantee that reading the input doesn't get */ /* confused when there is not enough memory available to allocate */ /* a histogram. The drawback is that, so far, there is no failure */ /* indicator for the caller. */ if ( thisto == (HISTOGRAM *) NULL ) { if ( type == 'F' || type == 'D' ) for (ibin=0; ibin<10; ibin++ ) (void) get_real(iobuf); /* contents... in histogram extension */ if ( tentries > 0 ) for (ibin=0; ibin<ncounts; ibin++) (void) get_long(iobuf); /* long and real is the same length */ continue; } else thisto->type = type; /* Give the histogram its title and identifier. */ if ( *title ) describe_histogram(thisto,title,add_this?0:ident); #ifdef _REENTRANT histogram_lock(thisto); #endif /* Set the values for histogram statistics. */ thisto->entries = entries; thisto->tentries = tentries; thisto->underflow = underflow[0]; thisto->overflow = overflow[0]; if ( type == 'R' || type == 'r' || type == 'F' || type == 'D' ) { thisto->specific.real.sum = rsum[0]; thisto->specific.real.tsum = rtsum[0]; } else { thisto->specific.integer.sum = isum[0]; thisto->specific.integer.tsum = itsum[0]; } if ( nbins_2d > 0 ) { thisto->underflow_2d = underflow[1]; thisto->overflow_2d = overflow[1]; if ( type == 'R' || type == 'r' || type == 'F' || type == 'D' ) { thisto->specific_2d.real.sum = rsum[1]; thisto->specific_2d.real.tsum = rtsum[1]; } else { thisto->specific_2d.integer.sum = isum[1]; thisto->specific_2d.integer.tsum = itsum[1]; } } /* If wanted and possible, return the pointer to caller. */ if ( phisto != (HISTOGRAM **) NULL && ihisto < nhisto ) phisto[ihisto] = (add_this ? ohisto : thisto); /* Finally, read the histogram contents. */ if ( type == 'F' || type == 'D' ) { struct Histogram_Extension *he = thisto->extension; he->content_all = get_real(iobuf); he->content_inside = get_real(iobuf); get_vector_of_real(he->content_outside,8,iobuf); if ( type == 'F' ) { if ( thisto->tentries > 0 ) for ( ibin=0; ibin<ncounts; ibin++ ) he->fdata[ibin] = (float) get_real(iobuf); else for ( ibin=0; ibin<ncounts; ibin++ ) he->fdata[ibin] = (float) 0.; } else { if ( thisto->tentries > 0 ) get_vector_of_real(he->ddata,ncounts,iobuf); else for ( ibin=0; ibin<ncounts; ibin++ ) he->ddata[ibin] = 0.; } } else { if ( thisto->tentries > 0 ) get_vector_of_long((long *)thisto->counts,ncounts,iobuf); else for ( ibin=0; ibin<nbins; ibin++ ) thisto->counts[ibin] = 0; } #ifdef _REENTRANT histogram_unlock(thisto); #endif if ( add_this ) { // fprintf(stderr,"Adding histogram ID %ld\n", ident); add_histogram(ohisto,thisto); free_histogram(thisto); } } if ( (rc = get_item_end(iobuf,&item_header)) != 0 ) return rc; return(mhisto); }
/************************************************************************ ** can_expand: tries to expand the macro passed to it - returns ** true if it succeeded in expanding it. It will only return FALSE ** if a macro name was found, a paren was expected, and a paren was ** not the next non white character. ************************************************************************/ int can_expand(pdefn_t pdef) { UCHAR c; int n_formals; int return_value = FALSE; Tiny_lexer_nesting = 0; Save_Exp_ptr = Exp_ptr; /* not necessarily EXP_BUFFER */ Macro_line = Linenumber; expand_name: P_actuals = Act_ptr; N_actuals = 0; n_formals = DEFN_NFORMALS(pdef); if( PRE_DEFINED(pdef) ) { push_macro(pdef); DEFN_EXPANDING(CURRENT_MACRO)++; if(rescan_expansion()) { return(TRUE); /* could expand macro */ } } else if( n_formals == 0 ) { return_value = TRUE; if(DEFN_TEXT(pdef)) { push_macro(pdef); expand_definition(); } else { /* ** Macro expands to nothing (no definition). Since it ** didn't have any actuals, Act_ptr is already correct. ** Exp_ptr must be changed however to delete the ** identifier from the expanded text. */ Exp_ptr = Save_Exp_ptr; } } else { if( n_formals == -1 ) { n_formals = 0; } name_comment_paren: if( can_get_non_white()) { if(CHARMAP(CHECKCH()) == LX_SLASH) { SKIPCH(); if(skip_comment()) { goto name_comment_paren; } else { UNGETCH(); } } if(CHARMAP(CHECKCH())==LX_OPAREN) { SKIPCH(); return_value = TRUE; get_actuals(pdef, n_formals); } else { /* ** #define xx(a) a ** xx bar(); ** don't lose white space between "xx" and "bar" */ ptext_t p = Exp_ptr; push_macro(pdef); DEFN_EXPANDING(CURRENT_MACRO)++; Exp_ptr = p; if( rescan_expansion() ) { return(FALSE); } } } else { } } /* ** makes sure a macro is being worked on. At this point, there will ** be a macro to expand, unless the macro expand_the_named_macro was ** passed had no definition text. If it had no defintion text, ** Tiny_lexer_nesting was not incremented. */ while(Tiny_lexer_nesting != 0) { if(Exp_ptr >= ELIMIT) { fatal_in_macro(10056); } switch(CHARMAP(c = GETCH())) { case LX_ID: case LX_MACFORMAL: Save_Exp_ptr = Exp_ptr; if(tl_getid(c) && ((pdef = get_defined())!= 0)) { if(DEFN_EXPANDING(pdef)) { /* ** the macro is already being expanded, so just ** write the do not expand marker and the ** identifier to the expand area. The do not ** expand marker is necessary so this macro ** doesn't get expanded on the rescan */ int len = Reuse_1_length - 1; *Exp_ptr++ = LX_NOEXPANDMARK; *Exp_ptr++ = ((UCHAR)len); } else { /* ** a legal identifier was read, it is defined, and ** it is not currently being expanded. This means ** there is reason to believe it can be expanded. */ goto expand_name; } } if(InIf &&(memcmp(Reuse_1, "defined", 8) ==0)) { do_defined(Reuse_1); } continue; break; case LX_NUMBER: /* getnum with Prep on to keep leading 0x on number */ { int Save_prep = Prep; Prep = TRUE; getnum(c); Prep = Save_prep; } continue; break; case LX_DOT: *Exp_ptr++ = '.'; dot_switch: switch(CHARMAP(c = GETCH())) { case LX_EOS: if(handle_eos() != BACKSLASH_EOS) { if(Tiny_lexer_nesting > 0) { goto dot_switch; } continue; } break; case LX_DOT: *Exp_ptr++ = '.'; if( ! checkop('.')) { break; /* error will be caught on rescan */ } *Exp_ptr++ = '.'; continue; break; case LX_NUMBER: *Exp_ptr++ = c; get_real(Exp_ptr); continue; } UNGETCH(); continue; case LX_CHARFORMAL: move_to_exp_esc('\'', do_strformal()); continue; break; case LX_STRFORMAL: move_to_exp_esc('"', do_strformal()); continue; break; case LX_DQUOTE: case LX_SQUOTE: /* ** gather_chars is called even though the error reported ** on overflow may need to be changed. */ Exp_ptr = gather_chars(Exp_ptr, c); continue; break; case LX_WHITE: while(LXC_IS_WHITE(GETCH())) { ; } UNGETCH(); c = ' '; break; case LX_EOS: if(handle_eos() == BACKSLASH_EOS) { *Exp_ptr++ = c; c = GETCH(); break; } continue; break; } *Exp_ptr++ = c; } return(return_value); }
static int oct_parser_lex (){ int c; char *symbuf = 0; int length = 0; /* Ignore whitespace, get first nonwhite character. */ while ((c = par_string[par_pos++]) == ' ' || c == '\t'); if (c == '\0') return '\n'; /* Char starts a number => parse the number. */ if (c == '.' || isdigit (c)){ par_pos--; par_pos += get_real(&par_string[par_pos], &GSL_REAL(yylval.val)); return NUM; } /* get the logical operators */ if (c == '<' && par_string[par_pos] == '='){ par_pos++; return LE; } if (c == '>' && par_string[par_pos] == '='){ par_pos++; return GE; } if (c == '=' && par_string[par_pos] == '='){ par_pos++; return EQUAL; } /* if (c == ':' && par_string[par_pos] == '='){ par_pos++; return SET; } */ if (c == '&' && par_string[par_pos] == '&'){ par_pos++; return LAND; } if (c == '|' && par_string[par_pos] == '|'){ par_pos++; return LOR; } /* Char starts an identifier => read the name. */ if (isalpha (c) || c == '\'' || c == '\"'){ symrec *s; char startc = c; int i; /* Initially make the buffer long enough for a 40-character symbol name. */ if (length == 0) length = 40, symbuf = (char *)malloc (length + 1); if(startc == '\'' || startc == '\"') c = par_string[par_pos++]; else startc = 0; /* false */ i = 0; do{ /* If buffer is full, make it larger. */ if (i == length){ length *= 2; symbuf = (char *)realloc (symbuf, length + 1); } /* Add this character to the buffer. */ symbuf[i++] = c; /* Get another character. */ c = par_string[par_pos++]; }while (c != '\0' && ((startc && c!=startc) || (!startc && (isalnum(c) || c == '_' )))); if(!startc) par_pos--; symbuf[i] = '\0'; if(!startc){ s = getsym (symbuf); if (s == 0){ int jj; for (jj = 0; reserved_symbols[jj] != 0; jj++){ if(strcmp(symbuf, reserved_symbols[jj]) == 0){ fprintf(stderr, "Error: trying to redefine reserved symbol '%s'", symbuf); exit(1); } } s = putsym (symbuf, S_CMPLX); } yylval.tptr = s; free(symbuf); if(s->type == S_CMPLX) return VAR; else return FNCT; }else{ yylval.str = strdup(symbuf); free(symbuf); return STR; } } /* Any other character is a token by itself. */ return c; }
/************************************************************************ * GETNUM - Get a number from the input stream. * * ARGUMENTS * radix - the radix of the number to be accumulated. Can only be 8, 10, * or 16 * pval - a pointer to a VALUE union to be filled in with the value * * RETURNS - type of the token (L_CINTEGER or L_CFLOAT) * * SIDE EFFECTS - * does push back on the input stream. * writes into pval by reference * uses buffer Reuse_W * * DESCRIPTION - * Accumulate the number according to the rules for each radix. * Set up the format string according to the radix (or distinguish * integer from float if radix is 10) and convert to binary. * * AUTHOR - Ralph Ryan, Sept. 8, 1982 * * MODIFICATIONS - none * ************************************************************************/ token_t getnum(REG WCHAR c) { REG WCHAR *p; WCHAR *start; int radix; token_t tok; value_t value; tok = L_CINTEGER; start = (Tiny_lexer_nesting ? Exp_ptr : Reuse_W); p = start; if( c == L'0' ) { c = get_non_eof(); if( IS_X(c) ) { radix = 16; if( Prep ) { *p++ = L'0'; *p++ = L'x'; } for(c = get_non_eof(); LXC_IS_XDIGIT(c); c = get_non_eof()) { /* no check for overflow? */ *p++ = c; } if((p == Reuse_W) && (Tiny_lexer_nesting == 0)) { strcpy (Msg_Text, GET_MSG (2153)); error(2153); } goto check_suffix; } else { radix = 8; *p++ = L'0'; /* for preprocessing or 0.xxx case */ } } else { radix = 10; } while( LXC_IS_DIGIT((WCHAR)c) ) { *p++ = c; c = get_non_eof(); } if( IS_DOT(c) || IS_E(c) ) { UNGETCH(); return(get_real(p)); } check_suffix: if( IS_EL(c) ) { if( Prep ) { *p++ = c; } c = get_non_eof(); if( IS_U(c) ) { if(Prep) { *p++ = c; } tok = L_LONGUNSIGNED; } else { tok = L_LONGINT; UNGETCH(); } } else if( IS_U(c) ) { if( Prep ) { *p++ = c; } c = get_non_eof(); if( IS_EL(c) ) { if( Prep ) { *p++ = c; } tok = L_LONGUNSIGNED; } else { tok = L_CUNSIGNED; UNGETCH(); } } else { UNGETCH(); } *p = L'\0'; if( start == Exp_ptr ) { Exp_ptr = p; return(L_NOTOKEN); } else if( Prep ) { myfwrite( Reuse_W, (size_t)(p - Reuse_W) * sizeof(WCHAR), 1, OUTPUTFILE); return(L_NOTOKEN); } value.v_long = matol(Reuse_W,radix); switch(tok) { case L_CINTEGER: tok = (radix == 10) ? c_size(value.v_long) : uc_size(value.v_long) ; break; case L_LONGINT: tok = l_size(value.v_long); break; case L_CUNSIGNED: tok = ul_size(value.v_long); break; } yylval.yy_tree = build_const(tok, &value); return(tok); }
int exec_menu(MENU menu) { int i=0, cidx=0, fine; int off, ecnt=1; char tmp[MAXLEN]; char output[MAXLEN]; MENU tmenu = menu; int ret; int cpid; fine=1; while(cidx < tmenu.ncmd && fine) { off=1; switch(tmenu.cmd[cidx][0]) { case '-': if(*(tmenu.cmd[cidx] + off)=='!') off++; parsecmd(tmenu.cmd[cidx] +off, tmp); cpid = fork(); if(cpid) { waitpid(cpid,&ret,0); if(ret!=-1 && WIFEXITED(ret)) ret = WEXITSTATUS(ret); } else { close(comport); ret=system(tmp); if(ret!=-1 && WIFEXITED(ret)) ret = WEXITSTATUS(ret); exit(ret); } if(off==1) ret=1; break; case '+': if(*(tmenu.cmd[cidx] + off)=='!') off++; parsecmd(tmenu.cmd[cidx] +off, tmp); ret=execute(tmp, output, MAXLEN); sprintf(tmp, "$%d", ecnt++); setvar(tmp, output); if(off==1) ret=1; break; case '<': argcnt = split(tmenu.cmd[cidx]+1, args[0], MAXARGS, MAXARGLEN); substvar(args[0], MAXARGS, MAXARGLEN); /*for(i=0; i<argcnt; i++) printf("%d: --%s--\n",i,args[i]);*/ if(strcmp(args[0],"YesNo")==0 && argcnt==2) { ret=get_yesno(args[1]); sprintf(output,"%d",ret-1); setvar("$YesNo",output); } if(strcmp(args[0],"OnOff")==0 && argcnt==3) { ret=get_onoff(args[1], atoi(args[2])); sprintf(output,"%d",ret-1); setvar("$OnOff",output); } if(strcmp(args[0],"Percent")==0 && argcnt==4) { ret=get_percent(args[1], atoi(args[2]), atoi(args[3])); sprintf(output,"%d",ret-1); setvar("$Percent",output); } if(strcmp(args[0],"Choice")==0 && argcnt>=4) { init_choice(); for(i=3; i<argcnt; i++) addchoice(args[i]); ret=get_choice(args[1], atoi(args[2])); sprintf(output,"%d",ret); setvar("$Choice",output); } if(strcmp(args[0],"Real")==0 && (argcnt==4 || argcnt==5)) { if(argcnt==4) strcpy(args[4],""); ret=get_real(output, args[1], args[2], args[3], args[4]); setvar("$Real",output); } if(strcmp(args[0],"Int")==0 && (argcnt==5 || argcnt==6)) { if(argcnt==5) strcpy(args[5],"0"); ret=get_integer(output, args[1], args[2], atoi(args[3]), atoi(args[4]), atoi(args[5])); setvar("$Int",output); } if(strcmp(args[0],"Phone")==0 && (argcnt==3 || argcnt==4)) { if(argcnt==3) strcpy(args[3],""); ret=get_phone(output, args[1], args[2], args[3]); setvar("$Phone",output); } if(strcmp(args[0],"Date")==0 && argcnt==2) { ret=get_date(output, args[1]); setvar("$Date",output); } if(strcmp(args[0],"Text")==0 && (argcnt==4 || argcnt==5)) { if(argcnt==4) strcpy(args[4],""); ret=get_text(output, args[1], args[2], atoi(args[3]), args[4]); setvar("$Text",output); } if(strcmp(args[0],"Secret")==0 && argcnt==4) { ret=get_secret(output, args[1], args[2], atoi(args[3])); setvar("$Secret",output); } break; case '>': argcnt = split(tmenu.cmd[cidx]+1, args[0], MAXARGS, MAXARGLEN); substvar(args[0], MAXARGS, MAXARGLEN); /*for(i=0; i<argcnt; i++) printf("%d: --%s--\n",i,args[i]);*/ if(strcmp(args[0],"MsgBox")==0 && (argcnt==2 || argcnt==3)) { if(argcnt==2) strcpy(args[2],""); ret=msgbox(args[1], atoi(args[2])); } if(strcmp(args[0],"Info")==0 && argcnt>=3) ret=info(args[1], args[2]); if(strcmp(args[0],"Status")==0 && argcnt>=2) ret=status(args[1]); break; case ':': for(i=0; i<fncnt; i++) if(strcmp(tmenu.cmd[cidx]+1,flist[i].name)==0) ret = flist[i].fn(); break; } if(ret<=0) fine=0; cidx++; } return 0; }
void sum_menu() { short board, value; short address; float tvalue = 0; float DesiredTiming = 0;//should be global? char *verb; char *tablepath; int4 iverb,eDelay,rate, patchnumber, ecount ; CPLD_disconect(); while(True) { verb = action_menu( "SUM_BOARD_MENU", &iverb); if(strcmp(verb,"ENABLE_THR")==0) { STInfo.threshold_control_flag=true; printf("Threshold control ON \n"); } if(strcmp(verb,"DISABLE_THR")==0) { STInfo.threshold_control_flag=false; printf("Threshold control OFF\n"); } if(strcmp(verb,"LOAD_THRE_TABLE")==0) { printf("LOADING..\n"); } if(strcmp(verb,"SAVE_THRESHOLDS")==0) { FILE *Tfile; int i; Tfile= fopen ((char *)ASData.thr_outputname, "a" ); fprintf(Tfile,"#Macrocell #Threshold [V]\n"); for(i=0;i<55;i++) { fprintf(Tfile,"%i %f\n",i+1,ASData.threshold[i]); } fclose ( Tfile ); } if(strcmp(verb,"PRINT_THRESHOLDS")==0) { printf("#Macrocell #Threshold [V]\n"); int i; for(i=0;i<55;i++) { printf("%i %f\n", i+1, ASData.threshold[i]); } } if(strcmp(verb,"PRINT_Rates")==0) { printf("#Macrocell: Rates: \n"); int i; for(i=0;i<55;i++) { printf("%i %f\n", i+1, (float)ASData.rate[i]); } printf("Total rate: %f", (float)ASData.globalrate); } if(strcmp(verb,"CHANGE_ONE_THRE_DB")==0) { int board=0; int addres=0; int macro=0; int data=0; float tvalue=0; float db=0; get_short("Macrocell",(int2*) ¯o,1,55); get_real("Set attenuation",&db, 0,0); tvalue=ASData.threshold[macro-1]*pow(10.0,db/20.0); data=(tvalue +2.0)*thre_conv; board=(int)macro/3.; address=(int)macro%3; printf("board %i, address %i\n",(int)board,address); if (tvalue >-2 && tvalue < 2) { printf("Threshold %f, on Macrocell %i\n",tvalue,macro); printf(" DBG Threshold %i, on Macrocell %i\n",(unsigned short)data,macro); transfer(FUNC_SUM_THR ,board,address,(unsigned short)data); ASData.threshold[macro-1]=tvalue; } else printf("Threshold value outside limits\n"); } if(strcmp(verb,"CHANGE_ALL_THRE_DB")==0) { int board=0; int addres=0; int data=0; int i=0; float tvalue=0; float db=0; get_real("Set attenuation",&db, 0,0); for(i=0;i<55;i++) { tvalue=ASData.threshold[i]*pow(10.0,db/20.0); if (tvalue>2) tvalue=2; if (tvalue<0) tvalue=0; data=(tvalue +2.0)*thre_conv; board=(int)i/3.; address=(int)i%3; printf("Threshold %f, on Macrocell %i\n",tvalue,i+1); printf(" DBG Threshold %i, on Macrocell %i\n",(unsigned short)data,i+1); printf(" DBG Board %i, Addres %i\n",board, address); transfer(FUNC_SUM_THR ,board,address,(unsigned short)data); ASData.threshold[i]=tvalue; } } if(strcmp(verb,"PRINT_AVERAGE_THR")==0) { int i; float average=0; for(i=0;i<55;i++) { average+=ASData.threshold[i]; } printf(" Average Threshold %f [V] \n", average/55.); } if(strcmp(verb,"OUTPUTNAME_THR")==0) { get_text("Enter Sum-Board Table name",(char *)ASData.thr_outputname); } if(strcmp(verb,"PATHSUMTABLES")==0) { get_text("Enter Sum-Board Table(s) path",(char *)tablepath); } if(strcmp(verb,"SET_ONE_MAX")==0) { get_short("Macrocell",(int2*) &board,1,55); get_short("Maximum rate",(int2*) &value,1,10000); ASData.rate_max[board-1]=value; } if(strcmp(verb,"SET_ONE_MIN")==0) { get_short("Macrocell",(int2*) &board,1,55); get_short("Minimum rate",(int2*) &value,1,10000); ASData.rate_min[board-1]=value; } if(strcmp(verb,"SET_ALL_MAX")==0) { get_short("Maximum rate", &value,1,10000); int i; for(i=0;i<55;i++) { ASData.rate_max[i]=value; } } if(strcmp(verb,"SET_ALL_MIN")==0) { get_short("Minimum rate", &value,1,10000); int i; for(i=0;i<55;i++) { ASData.rate_min[i]=value; } } if(strcmp(verb,"SET_ONE_T")==0) { float data; get_short("Board",(int2*) &board,1,19); get_short("Address",(int2*) &address,1,3); get_real("Threshold Value (-2,2)",&tvalue, 0,0); data=(tvalue +2.0)*thre_conv; transfer(FUNC_SUM_THR ,board-1,address-1,(unsigned short)data); printf("Set %f Threshold on address %i on board %i\n", tvalue, address,board); ASData.threshold[address-1+board*3]=tvalue; } if(strcmp(verb,"SET_BOARD_T")==0) { float data; get_short("Board",(int2*) &board,1,19); get_real("Threshold Value (-2,2)",&tvalue, 0,0); data=(tvalue +2.0)*thre_conv; int i; for (i=0;i<3;i++) { transfer(FUNC_SUM_THR ,board-1,i,(unsigned short)data); ASData.threshold[i+board*3]=tvalue; } printf("%f Threshold on all the address on board %i\n", tvalue,board); } if(strcmp(verb,"SET_CRATE_T")==0) { float data; get_real("Threshold Value (-2,2)",&tvalue, 0,0); data=(tvalue +2.0)*thre_conv; int i,j; for (j=0;j<19;j++) { for (i=0;i<3;i++) { transfer(FUNC_SUM_THR ,j,i,(unsigned short)data); ASData.threshold[i+j*3]=tvalue; } } printf("*********************************\n"); printf("%f Threshold on all the crate\n", tvalue); printf("*********************************\n"); } if(strcmp(verb,"RETURN")==0) return; } }
void astro_menu(void) { float DesiredPatch ; float DesiredDelay = 0; float DesiredDelay1 = 0; float DesiredDelay2 = 0; float DesiredDelay3 = 0; float DesiredRateCounts = 0; float DesiredRateTime = 0; float DesiredRate = 0; float DesiredTiming = 0; short data = 0; float datat = 0; int Macrocell = 0; short Refchannel = 0; char *verb; char *tablepath; int status; int4 iverb,eDelay,Delay,rate, patchnumber, ecount; int data1; int data2; int data3; data1=1; data2=2; CPLD_disconect(); while(True) { verb = action_menu( "ASTRO_BOARD_MENU", &iverb); if(strcmp(verb,"TMWAIT")==0) { printf("Maximum time,%i ",ASData.Tmax*1000); usleep(ASData.Tmax*1000); } if(strcmp(verb,"RESET_START")==0) { status = transfer(FUNC_ASTRO_RES,0,0,0); printf("Reset every MCPs and start counting\n"); } if(strcmp(verb,"TMAX")==0) { printf("Default 20 ms\n"); get_real("Set desired maximum time [ms]",&DesiredRateTime,1,65000); status = transfer(FUNC_ASTRO_TOUT,0,0,DesiredRateTime); ASData.Tmax=DesiredRateTime; } if(strcmp(verb,"CMAX")==0) { printf("Default 65000 counts\n"); get_real("set desired maximum number of counts",&DesiredRateCounts,10.,65000); status = transfer(FUNC_ASTRO_MCNT,0,0,DesiredRateCounts); ASData.Cmax=DesiredRateCounts; } if(strcmp(verb,"GLOBALREAD")==0) { int Macrocell; status = transfer_c(0xA7,&data1,&data2,&Macrocell); ASData.globalrate=Macrocell; printf("counts %i, elapsed time %i [ms],rate %i[Hz]\n ",data1,data2,Macrocell); } if(strcmp(verb,"TIM_ONEREAD")==0) { int j=0; get_short("Macrocell",(int2*) &Macrocell,1,55); j=Macrocell; status = transfer_c(FUNC_ASTRO_TIM,&data1,&data2,&Macrocell); ASData.tim[j-1]=Macrocell; printf("counts %i, elapsed time %i [ms], " "rate %i[Hz]\n ",data1,data2,Macrocell); } if(strcmp(verb,"TIM_ALLREAD")==0) { int i; printf("Reading all Astro-Board Macrocells\n"); for ( i=0;i<55;i++) { data3=i; status = transfer_c(FUNC_ASTRO_TIM,&data1,&data2,&data3); printf("counts %i, elapsed time %i [ms], " "rate %i[Hz] \n",data1,data2,data3); ASData.tim[i]=data3; } } if(strcmp(verb,"AMP_ONEREAD")==0) { int j=0; get_short("Macrocell",(int2*) &Macrocell,1,55); j=Macrocell; status = transfer_c(FUNC_ASTRO_AMP,&data1,&data2,&Macrocell); ASData.amp[j-1]=Macrocell; printf("counts %i, elapsed time %i [ms],rate %i[Hz]\n ",data1,data2,Macrocell); } if(strcmp(verb,"ALLREAD")==0) { int i; printf(" DBG Reading all Astro-Board Macrocells\n"); for ( i=0;i<55;i++) { data3=i; status = transfer_c(FUNC_ASTRO_AMP,&data1,&data2,&data3); ASData.rate[i]=data3; printf("macrocell %d counts %d elapsed time %d [ms], " "rate %i[Hz] \n",i+1, data1,data2,data3); } status = transfer_c(0xA7,&data1,&data2,&data3); ASData.globalrate=data3; printf("Total rate: counts %d elapsed time %d [ms], " "total rate %i[Hz] \n", data1,data2,data3); } if(strcmp(verb,"ONEREAD")==0) { int j=0; get_short("Macrocell",(int2*) &Macrocell,1,55); j=Macrocell; status = transfer_c(FUNC_ASTRO_RATES,&data1,&data2,&Macrocell); ASData.rate[j-1]=Macrocell; printf("counts %i, elapsed time %i [ms],rate %i[Hz]\n ",data1,data2,Macrocell); } /* if(strcmp(verb,"ALLREAD")==0) { int i; printf("Reading all Astro-Board Macrocells\n"); for ( i=0;i<55;i++) { data3=i; status = transfer_c(FUNC_ASTRO_RATES,&data1,&data2,&data3); ASData.rate[i]=data3; printf("counts %i, elapsed time %i [ms],rate %i[Hz]\n ",data1,data2,data3); } } */ if(strcmp(verb,"SAVE_RATES")==0) { FILE *Tfile; int i; printf("Saving all Astro-Board Macrocells\n"); Tfile= fopen ((char *)ASData.rates_outputname, "a" ); fprintf(Tfile,"#Macrocell #Rates [Hz]\n"); for(i=0;i<55;i++) { fprintf(Tfile,"%i %f\n",i+1,ASData.rate[i]); } fprintf(Tfile,"Total rate: %d\n" , (int)ASData.globalrate); fclose ( Tfile ); } if(strcmp(verb,"OUTPUTNAME_RATES")==0) { get_text("Enter Sum-Board Table name",(char *)ASData.rates_outputname); } if(strcmp(verb,"COMPARATOR")==0) { int channel=0; float datat=0; get_short("Channel",(int2*) &channel,1,2); get_real("Threshold value [0,2.5]", &datat,0,2.5); printf("Comparator threshold on channel %i is %f\n",channel,datat); ASData.cthreshold[channel-1]=datat; } if(strcmp(verb,"ALLDDEL")==0) { int i; get_real("Set desired delay (ns)",&DesiredDelay,0.0,5.6); for (i=0;i<55;i++) { ASData.ddelay[Macrocell-1]=DesiredDelay; status = transfer(FUNC_ASTRO_DEL,i,0,(unsigned short)(DesiredDelay*ddel_conv)); printf("%d ns delay on Macrocell %d\n", (int)(DesiredDelay*ddel_conv),i); } } if(strcmp(verb,"ONEDDEL")==0) { get_short("Macrocell",(int2*) &Macrocell,1,55); get_real("Set desired delay (ns)",&DesiredDelay,0.0,5.6); status = transfer(FUNC_ASTRO_DEL,Macrocell-1,0,(int)(DesiredDelay*ddel_conv)); ASData.ddelay[Macrocell-1]=DesiredDelay; printf("%i ns delay on Macrocell %i\n", DesiredDelay,Macrocell); } if(strcmp(verb,"ONEDREF")==0) { get_short("Macrocell",(int2*) &Refchannel,0,1); get_real("set desired delay (ns)",&DesiredDelay,0.0,5.6); status = transfer(FUNC_ASTRO_ADEL, Refchannel,0,(int)(DesiredDelay*ddel_conv)); ASData.dref[Refchannel]=DesiredDelay; printf("%f ns delay on analog signal on anlaog input %i\n", DesiredDelay,Refchannel); } if(strcmp(verb,"LDDEL")==0) { printf("Loading Delay tables...\n"); //load_tables(astro_Delay); } if(strcmp(verb,"SDDEL")==0) { //load_tables(astro_Delay); } if(strcmp(verb,"ATABLEPATH")==0) { //get_text("Enter AStro-Board Table(s) path:",(char *)tablepath); // printf("The astrotables path is: "); } if(strcmp(verb,"WAIT")==0) { int4 secs=5; get_integer("How many secs?",&secs,0,0); usleep(secs); } if(strcmp(verb,"EDEL")==0) { int line=0; float edel_conv=0; get_short("Select delay line",(int2*) &line,1,6); if (line < 4) { get_real("Set desired delay (ns)",&DesiredDelay1,0.,510.); edel_conv=edel_conv1; } if (line > 3 && line < 7) { get_real("Set desired delay (ns)",&DesiredDelay1,0.,64); edel_conv=edel_conv2; } status = transfer(FUNC_ASTRO_ED,line,0,(int)(DesiredDelay1*edel_conv)); ASData.edel[line-1] = DesiredDelay1; } if(strcmp(verb,"ALLEDEL")==0) { int i; get_real("Set desired delay (ns)",&DesiredDelay1,0.,64.); status = transfer(FUNC_ASTRO_ED,0x00,7,DesiredDelay1); for (i=0;i<7;i++) ASData.edel[i] = DesiredDelay1; } if(strcmp(verb,"ATEMP")==0) { short data=0; status = transfer_t(FUNC_ASTRO_TEM,0 ,0,&data); printf("AStro-Board Temperature %i\n",data); ASData.TAst=data; } if(strcmp(verb,"STATUS")==0) { short data=0; transfer_t(FUNC_ASTRO_ERR,0 ,0,&data); ASData.Astatus= data; switch (data) { case 0: printf("AStro-Board status OK\n"); break; case 1: printf(" Error on temperature device\n"); break; case 2: printf(" Error on set-read threshold\n"); break; case 3: printf(" Error on temperature device & on set-read threshold\n"); break; // case 4: // printf(" STATUS not checked\n"); // break; } } if(strcmp(verb,"VERSION")==0) { status = transfer(FUNC_ASTRO_VER,0,0,0); printf("Reading AStro-Version\n"); } if(strcmp(verb,"ENGATE")==0) { status = transfer(FUNC_ASTRO_GEN,0,0,0); ASData.Gate=1; printf("Gate Enable\n"); } if(strcmp(verb,"DISGATE")==0) { status = transfer(FUNC_ASTRO_GDIS,0,0,0); ASData.Gate=0; printf("Gate disable\n"); } if(strcmp(verb,"PRINT")==0) { int i; printf("******************************************* \n"); printf(" One shot delays \n"); printf(" Macrocell Delay [ns]\n"); for (i=0;i<55;i++) { printf(" %i %f \n",i+1,ASData.ddelay[i]); } printf("\n"); printf("******************************************* \n"); printf(" One shot anlogue delays \n"); printf("Analogue Delay [ns]\n"); for (i=0;i<2;i++) { printf(" %i %f \n",i,ASData.dref[i]); } printf("\n"); printf("******************************************* \n"); printf(" Last rates value \n"); printf(" Macrocell Rate [counts/ms]\n"); for (i=0;i<55;i++) { printf(" %i %f \n",i+1,ASData.rate[i]); } printf("\n"); printf("******************************************* \n"); printf(" Thresholds \n"); printf(" Macrocell Threshold [V]\n"); for (i=0;i<55;i++) { printf(" %i %f \n",i+1,ASData.threshold[i]); } printf("\n"); printf("******************************************* \n"); printf(" One shot anlogue delays \n"); printf("Analogue Delay [ns]\n"); for (i=0;i<2;i++) { printf(" %i %f \n",i,ASData.dref[i]); } printf("\n"); printf("******************************************* \n"); printf(" One shot anlogue delays \n"); printf("Analogue Threshold [V]\n"); for (i=0;i<2;i++) { printf(" %i %f \n",i,ASData.cthreshold[i]); } printf("\n"); printf("******************************************* \n"); printf(" External delays \n"); printf("Analogue Delay [ns]\n"); for (i=0;i<6;i++) { printf(" %i %f \n",i,ASData.edel[i]); } printf("\n"); printf("******************************************* \n"); printf(" STATUS \n"); data= ASData.Astatus; switch (data) { case 0: printf("AStro-Board status OK\n"); break; case 1: printf(" Error on temperature device\n"); break; case 2: printf(" Error on set-read threshold\n"); break; case 3: printf(" Error on temperature device & on set-read threshold\n"); break; } printf("\n"); printf("******************************************* \n"); } if(strcmp(verb,"RETURN")==0) return; } }
int read_test1(TEST_DATA *data, IO_BUFFER *iobuf) { IO_ITEM_HEADER item_header; int i; item_header.type = 99; /* test data */ if ( get_item_begin(iobuf,&item_header) < 0 ) { Warning("Missing or invalid test data block."); return -4; } data->lvar[0] = get_long(iobuf); data->lvar[1] = get_long(iobuf); data->ilvar[0] = get_long(iobuf); data->ilvar[1] = get_long(iobuf); data->isvar[0] = get_short(iobuf); data->isvar[1] = get_short(iobuf); data->svar[0] = get_short(iobuf); data->svar[1] = get_short(iobuf); data->svar[2] = get_short(iobuf); data->fvar[0] = get_real(iobuf); data->fvar[1] = get_real(iobuf); data->dvar[0] = get_double(iobuf); data->dvar[1] = get_double(iobuf); data->hvar[0] = get_sfloat(iobuf); data->hvar[1] = get_sfloat(iobuf); data->i8var[0] = get_byte(iobuf); data->i8var[1] = get_byte(iobuf); data->u8var[0] = get_byte(iobuf); data->u8var[1] = get_byte(iobuf); data->i16var[0] = get_short(iobuf); data->i16var[1] = get_short(iobuf); data->u16var[0] = get_short(iobuf); data->u16var[1] = get_short(iobuf); data->i32var[0] = get_int32(iobuf); data->i32var[1] = get_int32(iobuf); data->u32var[0] = get_uint32(iobuf); data->u32var[1] = get_uint32(iobuf); #ifdef HAVE_64BIT_INT get_vector_of_int64(&data->i64var[0],1,iobuf); get_vector_of_int64(&data->i64var[1],1,iobuf); get_vector_of_uint64(&data->u64var[0],1,iobuf); get_vector_of_uint64(&data->u64var[1],1,iobuf); #endif data->nbvar = get_count(iobuf); data->bvar[0] = get_byte(iobuf); data->bvar[1] = get_byte(iobuf); for (i=0; i<4; i++) data->cnt16var[i] = get_count16(iobuf); for (i=0; i<6; i++) data->cnt32var[i] = get_count32(iobuf); for (i=0; i<6; i++) data->cntzvar[i] = get_count(iobuf); for (i=0; i<8; i++) data->cntvar[i] = get_count(iobuf); for (i=0; i<10; i++) data->scnt16var[i] = get_scount16(iobuf); for (i=0; i<12; i++) data->scnt32var[i] = get_scount32(iobuf); for (i=0; i<12; i++) data->scntzvar[i] = get_scount(iobuf); for (i=0; i<14; i++) data->scntvar[i] = get_scount(iobuf); get_string(data->str16var,sizeof(data->str16var),iobuf); get_long_string(data->str32var,sizeof(data->str32var),iobuf); get_var_string(data->strvvar,sizeof(data->strvvar),iobuf); return(get_item_end(iobuf,&item_header)); }
void aligned_free(void* chunk) { return free(chunk == nullptr ? chunk : get_real(chunk)); }
static void verify (int d1, int d2, int d3, int nt, boolean *verified, char *cclass) { /*-------------------------------------------------------------------- c-------------------------------------------------------------------*/ int ierr, size, i; double err, epsilon; /*-------------------------------------------------------------------- c Sample size reference checksums c-------------------------------------------------------------------*/ /*-------------------------------------------------------------------- c Class S size reference checksums c-------------------------------------------------------------------*/ double vdata_real_s[6+1] = { 0.0, 5.546087004964e+02, 5.546385409189e+02, 5.546148406171e+02, 5.545423607415e+02, 5.544255039624e+02, 5.542683411902e+02 }; double vdata_imag_s[6+1] = { 0.0, 4.845363331978e+02, 4.865304269511e+02, 4.883910722336e+02, 4.901273169046e+02, 4.917475857993e+02, 4.932597244941e+02 }; /*-------------------------------------------------------------------- c Class W size reference checksums c-------------------------------------------------------------------*/ double vdata_real_w[6+1] = { 0.0, 5.673612178944e+02, 5.631436885271e+02, 5.594024089970e+02, 5.560698047020e+02, 5.530898991250e+02, 5.504159734538e+02 }; double vdata_imag_w[6+1] = { 0.0, 5.293246849175e+02, 5.282149986629e+02, 5.270996558037e+02, 5.260027904925e+02, 5.249400845633e+02, 5.239212247086e+02 }; /*-------------------------------------------------------------------- c Class A size reference checksums c-------------------------------------------------------------------*/ double vdata_real_a[6+1] = { 0.0, 5.046735008193e+02, 5.059412319734e+02, 5.069376896287e+02, 5.077892868474e+02, 5.085233095391e+02, 5.091487099959e+02 }; double vdata_imag_a[6+1] = { 0.0, 5.114047905510e+02, 5.098809666433e+02, 5.098144042213e+02, 5.101336130759e+02, 5.104914655194e+02, 5.107917842803e+02 }; /*-------------------------------------------------------------------- c Class B size reference checksums c-------------------------------------------------------------------*/ double vdata_real_b[20+1] = { 0.0, 5.177643571579e+02, 5.154521291263e+02, 5.146409228649e+02, 5.142378756213e+02, 5.139626667737e+02, 5.137423460082e+02, 5.135547056878e+02, 5.133910925466e+02, 5.132470705390e+02, 5.131197729984e+02, 5.130070319283e+02, 5.129070537032e+02, 5.128182883502e+02, 5.127393733383e+02, 5.126691062020e+02, 5.126064276004e+02, 5.125504076570e+02, 5.125002331720e+02, 5.124551951846e+02, 5.124146770029e+02 }; double vdata_imag_b[20+1] = { 0.0, 5.077803458597e+02, 5.088249431599e+02, 5.096208912659e+02, 5.101023387619e+02, 5.103976610617e+02, 5.105948019802e+02, 5.107404165783e+02, 5.108576573661e+02, 5.109577278523e+02, 5.110460304483e+02, 5.111252433800e+02, 5.111968077718e+02, 5.112616233064e+02, 5.113203605551e+02, 5.113735928093e+02, 5.114218460548e+02, 5.114656139760e+02, 5.115053595966e+02, 5.115415130407e+02, 5.115744692211e+02 }; /*-------------------------------------------------------------------- c Class C size reference checksums c-------------------------------------------------------------------*/ double vdata_real_c[20+1] = { 0.0, 5.195078707457e+02, 5.155422171134e+02, 5.144678022222e+02, 5.140150594328e+02, 5.137550426810e+02, 5.135811056728e+02, 5.134569343165e+02, 5.133651975661e+02, 5.132955192805e+02, 5.132410471738e+02, 5.131971141679e+02, 5.131605205716e+02, 5.131290734194e+02, 5.131012720314e+02, 5.130760908195e+02, 5.130528295923e+02, 5.130310107773e+02, 5.130103090133e+02, 5.129905029333e+02, 5.129714421109e+02 }; double vdata_imag_c[20+1] = { 0.0, 5.149019699238e+02, 5.127578201997e+02, 5.122251847514e+02, 5.121090289018e+02, 5.121143685824e+02, 5.121496764568e+02, 5.121870921893e+02, 5.122193250322e+02, 5.122454735794e+02, 5.122663649603e+02, 5.122830879827e+02, 5.122965869718e+02, 5.123075927445e+02, 5.123166486553e+02, 5.123241541685e+02, 5.123304037599e+02, 5.123356167976e+02, 5.123399592211e+02, 5.123435588985e+02, 5.123465164008e+02 }; epsilon = 1.0e-12; *verified = TRUE; *cclass = 'U'; if (d1 == 64 && d2 == 64 && d3 == 64 && nt == 6) { *cclass = 'S'; for (i = 1; i <= nt; i++) { err = (get_real(sums[i]) - vdata_real_s[i]) / vdata_real_s[i]; if (fabs(err) > epsilon) { *verified = FALSE; break; } err = (get_imag(sums[i]) - vdata_imag_s[i]) / vdata_imag_s[i]; if (fabs(err) > epsilon) { *verified = FALSE; break; } } } else if (d1 == 128 && d2 == 128 && d3 == 32 && nt == 6) { *cclass = 'W'; for (i = 1; i <= nt; i++) { err = (get_real(sums[i]) - vdata_real_w[i]) / vdata_real_w[i]; if (fabs(err) > epsilon) { *verified = FALSE; break; } err = (get_imag(sums[i]) - vdata_imag_w[i]) / vdata_imag_w[i]; if (fabs(err) > epsilon) { *verified = FALSE; break; } } } else if (d1 == 256 && d2 == 256 && d3 == 128 && nt == 6) { *cclass = 'A'; for (i = 1; i <= nt; i++) { err = (get_real(sums[i]) - vdata_real_a[i]) / vdata_real_a[i]; if (fabs(err) > epsilon) { *verified = FALSE; break; } err = (get_imag(sums[i]) - vdata_imag_a[i]) / vdata_imag_a[i]; if (fabs(err) > epsilon) { *verified = FALSE; break; } } } else if (d1 == 512 && d2 == 256 && d3 == 256 && nt == 20) { *cclass = 'B'; for (i = 1; i <= nt; i++) { err = (get_real(sums[i]) - vdata_real_b[i]) / vdata_real_b[i]; if (fabs(err) > epsilon) { *verified = FALSE; break; } err = (get_imag(sums[i]) - vdata_imag_b[i]) / vdata_imag_b[i]; if (fabs(err) > epsilon) { *verified = FALSE; break; } } } else if (d1 == 512 && d2 == 512 && d3 == 512 && nt == 20) { *cclass = 'C'; for (i = 1; i <= nt; i++) { err = (get_real(sums[i]) - vdata_real_c[i]) / vdata_real_c[i]; if (fabs(err) > epsilon) { *verified = FALSE; break; } err = (get_imag(sums[i]) - vdata_imag_c[i]) / vdata_imag_c[i]; if (fabs(err) > epsilon) { *verified = FALSE; break; } } } if (*cclass != 'U') { printf("Result verification successful\n"); } else { printf("Result verification failed\n"); } printf("cclass = %1c\n", *cclass); }