// Prints a horizontal bar chart element in a grid box void grid_bar(struct kingrid_info *data, int c, int percent) { int charcount; if(percent > 100) { percent = 100; } else if(percent < 0) { percent = 0; } charcount = percent * data->boxwidth / 100; printf("| "); repeat_char(c, charcount); repeat_char(' ', data->boxwidth - charcount); putchar(' '); }
// Prints horizontal border between grid rows void grid_hline(struct kingrid_info *data) { int i; for(i = 0; i < data->divisions; i++) { putchar('+'); repeat_char('-', data->boxwidth + 2); } puts("+"); }
struct cat* _cat_read(FILE* fptr, size_t nlines, int64 nside, double radius_arcsec, int verbose) { int radius_in_file=0; double ra=0, dec=0; double radius_radians=0; double cos_radius_global=0; struct vector* listpix = vector_new(0,sizeof(int64)); size_t index=0; int barsize=70; struct cat* self = cat_new(nlines, nside); if (verbose) { wlog(" reading and building hash table\n"); repeat_char('.', barsize); wlog("\n"); } radius_in_file = _cat_get_radius(radius_arcsec,&radius_radians, &cos_radius_global); struct point_hash* pthash = NULL; struct point* pt = &self->pts[0]; for (size_t i=0; i<self->size; i++) { pt->index=index; if (2 != fscanf(fptr, "%lf %lf", &ra, &dec)) { wlog("expected to read point at line %lu\n", i); exit(EXIT_FAILURE); } if (radius_in_file) { if (1 != fscanf(fptr, "%lf", &radius_arcsec)) { wlog("expected to read radius at line %lu\n", i); exit(EXIT_FAILURE); } radius_radians = radius_arcsec/3600.*D2R; pt->cos_radius = cos(radius_radians); } else { pt->cos_radius = cos_radius_global; } hpix_eq2xyz(ra,dec,&pt->x,&pt->y,&pt->z); hpix_disc_intersect(self->hpix, pt->x, pt->y, pt->z, radius_radians, listpix); // insert a pointer to this point for each pixel it intersected int64* pix_ptr = vector_front(listpix); int64* end = vector_end(listpix); while (pix_ptr != end) { pthash=point_hash_insert(pthash, (*pix_ptr), pt); pix_ptr++; } pt++; index++; if (verbose) incr_bar(i+1, self->size, barsize, '='); } self->pthash=pthash; listpix=vector_delete(listpix); if (verbose) wlog("\n"); if (index != self->size) { wlog("expected %lu lines but read %lu\n", self->size, index); exit(EXIT_FAILURE); } return self; }
char * format_editorial(char *s, int width, int flags, HANDLE_S **handlesp, gf_io_t pc) { gf_io_t gc; int *margin; EDITORIAL_S es; URL_HILITE_S uh; /* ASSUMPTION #2,341: All MIME-decoding is done by now */ gf_set_readc(&gc, s, strlen(s), CharStar, 0); margin = format_view_margin(); if(flags & FM_NOINDENT) margin[0] = margin[1] = 0; /* safety net */ if(width - (margin[0] + margin[1]) < 5){ margin[0] = margin[1] = 0; if(width < 5) width = 80; } width -= (margin[0] + margin[1]); if(width > 40){ width -= 12; es.prelen = MAX(2, MIN(margin[0] + 6, sizeof(es.prefix) - 3)); snprintf(es.prefix, sizeof(es.prefix), "%s[ ", repeat_char(es.prelen - 2, ' ')); es.postlen = 2; strncpy(es.postfix, " ]", sizeof(es.postfix)); es.postfix[sizeof(es.postfix)-1] = '\0'; } else if(width > 20){ width -= 6; es.prelen = MAX(2, MIN(margin[0] + 3, sizeof(es.prefix) - 3)); snprintf(es.prefix, sizeof(es.prefix), "%s[ ", repeat_char(es.prelen - 2, ' ')); es.postlen = 2; strncpy(es.postfix, " ]", sizeof(es.postfix)); es.postfix[sizeof(es.postfix)-1] = '\0'; } else{ width -= 2; strncpy(es.prefix, "[", sizeof(es.prefix)); es.prefix[sizeof(es.prefix)-1] = '\0'; strncpy(es.postfix, "]", sizeof(es.postfix)); es.postfix[sizeof(es.postfix)-1] = '\0'; es.prelen = 1; es.postlen = 1; } es.do_color = (!(flags & FM_NOCOLOR) && (flags & FM_DISPLAY) && pico_usingcolor()); gf_filter_init(); /* catch urls */ if((F_ON(F_VIEW_SEL_URL, ps_global) || F_ON(F_VIEW_SEL_URL_HOST, ps_global) || F_ON(F_SCAN_ADDR, ps_global)) && handlesp){ gf_link_filter(gf_line_test, gf_line_test_opt(url_hilite, gf_url_hilite_opt(&uh,handlesp,0))); } gf_link_filter(gf_wrap, gf_wrap_filter_opt(width, width, NULL, 0, (handlesp ? GFW_HANDLES : GFW_NONE))); gf_link_filter(gf_line_test, gf_line_test_opt(quote_editorial, &es)); /* If not for display, change to local end of line */ if(!(flags & FM_DISPLAY)) gf_link_filter(gf_nvtnl_local, NULL); return(gf_pipe(gc, pc)); }
/* * This one is a little more complicated because it comes late in the * filtering sequence after colors have been added and url's hilited and * so on. So if it wants to look at the beginning of the line it has to * wade through some stuff done by the other filters first. This one is * skipping the leading indent added by the viewer-margin stuff and leading * tags. */ int delete_quotes(long int linenum, char *line, LT_INS_S **ins, void *local) { DELQ_S *dq; char *lp; int i, lines, not_a_quote = 0, code; size_t len; dq = (DELQ_S *) local; if(!dq) return(0); if(dq->lines > 0 || dq->lines == Q_DEL_ALL){ lines = (dq->lines == Q_DEL_ALL) ? 0 : dq->lines; /* * First determine if this line is part of a quote. */ /* skip over indent added by viewer-margin-left */ lp = line; for(i = dq->indent_length; i > 0 && !not_a_quote && *lp; i--) if(*lp++ != SPACE) not_a_quote++; while(isspace((unsigned char) *lp)) lp++; /* skip over leading tags */ while(!not_a_quote && ((unsigned char) (*lp) == (unsigned char) TAG_EMBED)){ switch(*++lp){ case '\0': not_a_quote++; break; default: ++lp; break; case TAG_FGCOLOR: case TAG_BGCOLOR: case TAG_HANDLE: switch(*lp){ case TAG_FGCOLOR: case TAG_BGCOLOR: len = RGBLEN + 1; break; case TAG_HANDLE: len = *++lp + 1; break; } if(strlen(lp) < len) not_a_quote++; else lp += len; break; case TAG_EMBED: break; } } len = lp - line; if(strlen(tmp_20k_buf) > len) strcpy(tmp_20k_buf, tmp_20k_buf+len); code = (dq->is_flowed ? IS_FLOWED : NO_FLOWED) | DELETEQUO; select_quote(linenum, lp, ins, &code); if (!not_a_quote && !tmp_20k_buf[0]) not_a_quote++; if(not_a_quote){ if(dq->in_quote > lines+1 && !dq->delete_all){ char tmp[500]; COLOR_PAIR *col = NULL; char cestart[2 * RGBLEN + 5]; char ceend[2 * RGBLEN + 5]; /* * Display how many lines were hidden. */ cestart[0] = ceend[0] = '\0'; if(dq->do_color && ps_global->VAR_METAMSG_FORE_COLOR && ps_global->VAR_METAMSG_BACK_COLOR && (col = new_color_pair(ps_global->VAR_METAMSG_FORE_COLOR, ps_global->VAR_METAMSG_BACK_COLOR))) if(!pico_is_good_colorpair(col)) free_color_pair(&col); if(col){ strncpy(cestart, color_embed(col->fg, col->bg), sizeof(cestart)); cestart[sizeof(cestart)-1] = '\0'; strncpy(ceend, color_embed(ps_global->VAR_NORM_FORE_COLOR, ps_global->VAR_NORM_BACK_COLOR), sizeof(ceend)); ceend[sizeof(ceend)-1] = '\0'; free_color_pair(&col); } snprintf(tmp, sizeof(tmp), "%s[ %s%d lines of quoted text hidden from view%s ]\r\n", repeat_char(dq->indent_length, SPACE), cestart, dq->in_quote - lines, ceend); if(strlen(tmp)-strlen(cestart)-strlen(ceend)-2 > ps_global->ttyo->screen_cols){ snprintf(tmp, sizeof(tmp), "%s[ %s%d lines of quoted text hidden%s ]\r\n", repeat_char(dq->indent_length, SPACE), cestart, dq->in_quote - lines, ceend); if(strlen(tmp)-strlen(cestart)-strlen(ceend)-2 > ps_global->ttyo->screen_cols){ snprintf(tmp, sizeof(tmp), "%s[ %s%d lines hidden%s ]\r\n", repeat_char(dq->indent_length, SPACE), cestart, dq->in_quote - lines, ceend); if(strlen(tmp)-strlen(cestart)-strlen(ceend)-2 > ps_global->ttyo->screen_cols){ snprintf(tmp, sizeof(tmp), "%s[ %s%d hidden%s ]\r\n", repeat_char(dq->indent_length, SPACE), cestart, dq->in_quote - lines, ceend); if(strlen(tmp)-strlen(cestart)-strlen(ceend)-2 > ps_global->ttyo->screen_cols){ snprintf(tmp, sizeof(tmp), "%s[...]\r\n", repeat_char(dq->indent_length, SPACE)); if(strlen(tmp)-2 > ps_global->ttyo->screen_cols){ snprintf(tmp, sizeof(tmp), "%s...\r\n", repeat_char(dq->indent_length, SPACE)); if(strlen(tmp)-2 > ps_global->ttyo->screen_cols){ snprintf(tmp, sizeof(tmp), "%s\r\n", repeat_char(MIN(ps_global->ttyo->screen_cols,3), '.')); } } } } } } ins = gf_line_test_new_ins(ins, line, tmp, strlen(tmp)); mark_handles_in_line(line, dq->handlesp, 1); ps_global->some_quoting_was_suppressed = 1; } else if(dq->in_quote == lines+1 && dq->saved_line && *dq->saved_line){ /* * We would have only had to delete a single line. Instead * of deleting it, just show it. */ ins = gf_line_test_new_ins(ins, line, *dq->saved_line, strlen(*dq->saved_line)); mark_handles_in_line(*dq->saved_line, dq->handlesp, 1); } else mark_handles_in_line(line, dq->handlesp, 1); if(dq->saved_line && *dq->saved_line) fs_give((void **) dq->saved_line); dq->in_quote = 0; } else{ dq->in_quote++; /* count it */ if(dq->in_quote > lines){ /* * If the hidden part is a single line we'll show it instead. */ if(dq->in_quote == lines+1 && !dq->delete_all){ if(dq->saved_line && *dq->saved_line) fs_give((void **) dq->saved_line); *dq->saved_line = fs_get(strlen(line) + 3); snprintf(*dq->saved_line, strlen(line)+3, "%s\r\n", line); } mark_handles_in_line(line, dq->handlesp, 0); /* skip it, at least for now */ return(2); } mark_handles_in_line(line, dq->handlesp, 1); } } return(0); }
/* * Prints a separation line */ void print_sep() { PRINT_COLUMNS("+", "-", repeat_char("-", 36), \ repeat_char("-", 10), repeat_char("-", 10),repeat_char("-", 14), \ repeat_char("-", 50)); }
/* * do_busy_cue - paint the busy cue and return how long caller * should pause before calling us again */ int do_busy_cue(void *data) { int space_left, slots_used, period; char dbuf[MAX_SCREEN_COLS+1]; /* Don't wipe out any displayed status message prematurely */ if(status_message_remaining() || busy_cue_pause) return(BUSY_MSG_RETRY); space_left = (ps_global->ttyo ? ps_global->ttyo->screen_cols : 80) - busy_width - 2; /* 2 is for [] */ slots_used = MAX(0, MIN(space_left-3, 10)); if(percent_done_ptr && slots_used >= 4){ int completed, pd; char *s; pd = (*percent_done_ptr)(); pd = MIN(MAX(0, pd), 100); completed = (pd * slots_used) / 100; snprintf(dbuf, sizeof(dbuf), "%s |%s%s%*s|", busy_message, completed > 1 ? repeat_char(completed-1, pd==100 ? ' ' : '-') : "", (completed > 0 && pd != 100) ? ">" : "", slots_used - completed, ""); dbuf[sizeof(dbuf)-1] = '\0'; if(slots_used == 10){ s = dbuf + strlen(dbuf) - 8; if(pd < 10){ s++; s++; *s++ = '0' + pd; } else if(pd < 100){ s++; *s++ = '0' + pd / 10; *s++ = '0' + pd % 10; } else{ *s++ = '1'; *s++ = '0'; *s++ = '0'; } *s = '%'; } period = BUSY_PERIOD_PERCENT; } else{ char b[MAX_SPINNER_WIDTH + 2]; int ind; ind = (dotcount % spinners[spinner].elements); spinners[spinner].used_this_round = 1; if(space_left >= spinners[spinner].width + 1){ b[0] = SPACE; strncpy(b+1, (ps_global->active_status_interval > 0) ? spinners[spinner].bars[ind] : "... ", sizeof(b)-1); b[sizeof(b)-1] = '\0'; } else if(space_left >= 2 && space_left < sizeof(b)){ b[0] = '.'; b[1] = '.'; b[2] = '.'; b[space_left] = '\0'; } else b[0] = '\0'; snprintf(dbuf, sizeof(dbuf), "%s%s", busy_message, b); dbuf[sizeof(dbuf)-1] = '\0'; /* convert interval to delay in 100ths of second */ period = (ps_global->active_status_interval > 0) ? (100 / MIN(10, ps_global->active_status_interval)) : BUSY_MSG_DONE; } status_message_write(dbuf, 1); dotcount++; fflush(stdout); return(period); }
/* Command line arguments are three char[]s of digits: * integer (binary digits) * exponent (decimal value) * fraction (binary digits) * Outputs are normalized decimal and binary representations * of the input value, one part per line: * decimal integer * decimal fraction * decimal exponent * decimal recurrence digits * decimal recurrence start position * binary recurrence digits * binary recurrence start * binary integer * binary fraction * binary exponent */ int main(int argc, char* argv[]) { if (argc != 4) { puts("Need arguments!"); exit(1); } //const int BINARY_PRECISION = 128; int decimal_exponent; int binary_exponent_v; char* binary_integer_v = malloc(BUF); char* binary_fraction_v = malloc(BUF); char* decimal_fraction = malloc(BUF); char* decimal_integer = malloc(BUF); int decimal_recurrence_start = -1; int binary_recurrence_start = -1; char* decimal_recurrence = malloc(BUF); strcpy(decimal_recurrence, "0"); char* binary_recurrence = malloc(BUF); strcpy(binary_recurrence, "0"); char* temp = malloc(BUF); //int precision_so_far = 0; strcpy(binary_integer_v, argv[1]); binary_exponent_v = atoi(argv[2]); strcpy(binary_fraction_v, argv[3]); //printf("bfv %s\n", binary_fraction_v); mpz_t result; mpz_init(result); //char* binfractemp = binary_fraction_v; // The n versions of the variable are the ones that are normalized and used // for the binary ouput but are not used for generating the decimal values char* binary_integer_n = malloc(BUF); strcpy(binary_integer_n, binary_integer_v); char* binary_fraction_n = malloc(BUF); strcpy(binary_fraction_n, binary_fraction_v); int binary_exponent_n = binary_exponent_v; while(atoi(binary_integer_n) > 1) { temp[0] = binary_integer_n[strlen(binary_integer_n)-1]; temp[1] = '\0'; // strcpy(temp,&(binary_integer_n[strlen(binary_integer_n)-1])); strcpy(binary_fraction_n, strcat(temp, binary_fraction_n)); //strcpy(binary_integer_n, substr(binary_integer_n,0, strlen(binary_integer_n) - 1)); binary_integer_n[strlen(binary_integer_n)-1] = '\0'; binary_exponent_n++; } while (strcmp(binary_integer_n,"0") == 0) { binary_integer_n[0] = binary_fraction_n[0]; binary_integer_n[1] = '\0'; // strcpy(binary_integer_n, binary_fraction_n); // strcpy(binary_fraction_n, substr(binary_fraction_n,1,strlen(binary_fraction_n)-1)); substr1(binary_fraction_n); binary_exponent_n--; } if (binary_fraction_n[0] == '\0') { strcpy(binary_fraction_n, "0"); } //printf("bi %s\n",binary_integer_v); //these are copies of the originals char* binary_integer = malloc(BUF); strcpy(binary_integer, binary_integer_v); char* binary_fraction = malloc(BUF); strcpy(binary_fraction, binary_fraction_v); int binary_exponent = binary_exponent_v; //printf("bi %s\n",binary_integer); while (binary_exponent > 0) { int a = strlen(binary_integer); binary_integer[a] = binary_fraction[0]; binary_integer[a+1] = '\0'; //strcpy(binary_fraction, substr(binary_fraction,1,strlen(binary_fraction-1))); substr1(binary_fraction); if (binary_fraction[0] == '\0') { strcpy(binary_fraction, "0"); } binary_exponent--; } ////printf("space needed: %d\n", (int) binary_fraction - (int) binary_fraction_backing); //printf("bi %s\n",binary_integer); while (binary_exponent < 0) { //strcpy(temp, &(binary_integer[strlen(binary_integer) - 1])); temp[0] = binary_integer[strlen(binary_integer) - 1]; temp[1] = '\0'; strcpy(binary_fraction, strcat(temp, binary_fraction)); //strcpy(binary_integer, substr(binary_integer,0, strlen(binary_integer) - 1)); binary_integer[strlen(binary_integer)-1] = '\0'; if (binary_integer[0] == '\0') { strcpy(binary_integer, "0"); } binary_exponent++; } // Decimal integer part strcpy(decimal_integer, "0"); mpz_t power_of_two; mpz_init(power_of_two); mpz_set_ui(power_of_two, 1); mpz_t di; mpz_init(di); mpz_set_ui(di, 0); //printf("bin int len: %s\n", binary_integer); //int aa = 0, b = 0; for (int i = strlen(binary_integer) - 1; i > -1; i--) { // if it's a 1 you add the decimal integer to the power of two (power of // two starts at 1) if (binary_integer[i] == '1') { mpz_add(di, di, power_of_two); //printf("di %s\n", mpz_get_str(NULL,10,power_of_two)); //aa++; } mpz_add(power_of_two, power_of_two, power_of_two); //double the power_of_two //printf("power_of_two b=%d %s\n", b, mpz_get_str(NULL,10,power_of_two)); //b++; } //printf("aa = %d\nb = %d\n",aa,b); // Decimal fraction part // reset the power_of_two back to 1 mpz_set_ui(power_of_two, 1); mpz_t df; mpz_init(df); mpz_set_ui(df, 0); strcpy(decimal_fraction, "0"); //printf("binary_fraction pre-add: %s\n", binary_fraction); int j = 0, k = 0; for (int i = strlen(binary_fraction) - 1; i > -1; i--) { // if it is 1 add the decimal fraction to the power of two if (binary_fraction[i] == '1') { j++; mpz_add(df, df, power_of_two); } mpz_add(power_of_two, power_of_two, power_of_two); //double the power_of_two k++; } //printf("j = %d\nk = %d\n",j,k); //printf("df %s\n", mpz_get_str(NULL, 10, df)); //printf("powtwo %s\n", mpz_get_str(NULL, 10, power_of_two)); mpf_set_default_prec(1000); mpf_t decf; mpf_init(decf); mpf_set_z(decf, df); //int n = 10; mpf_t powtwo; mpf_init(powtwo); mpf_set_z(powtwo, power_of_two); mpf_div(decf, decf, powtwo); // Normalize decimal_exponent = 0; char* ditemp = malloc(BUF); char* dftemp = malloc(BUF); mpz_get_str(ditemp, 10, di); //printf("ditemp %s\n", ditemp); strcpy(decimal_integer, ditemp); mp_exp_t a; mpf_get_str(dftemp, &a, 10, 10000, decf); strcpy(decimal_fraction, dftemp); /* while( a <0) { strcpy(decimal_fraction, strcat("0", decimal_fraction)); a++; } */ prepend(decimal_fraction, repeat_char('0', abs(a))); while (strlen(decimal_integer)>1) { temp[0] = decimal_integer[strlen(decimal_integer)-1]; temp[1] = '\0'; //strcpy(temp, &(decimal_integer[strlen(decimal_integer)-1])); strcpy(decimal_fraction, strcat(temp, decimal_fraction)); //strcpy(decimal_integer, substr(decimal_integer,0, strlen(decimal_integer) - 1)); decimal_integer[strlen(decimal_integer)-1] = '\0'; decimal_exponent++; } while (strcmp(decimal_integer, "0") == 0) { decimal_integer[0] = decimal_fraction[0]; decimal_integer[1] = '\0'; //strcpy(decimal_integer, decimal_fraction); //strcpy(decimal_fraction, substr(decimal_fraction,1,strlen(decimal_fraction)-1)); substr1(decimal_fraction); decimal_exponent--; } if (decimal_integer[0] == '\0') { strcpy(decimal_integer, "0"); } if (decimal_fraction[0] == '\0') { strcpy(decimal_fraction, "0"); } char* tempDI = malloc(BUF); strcpy( tempDI, decimal_integer); while (tempDI[0] == '0') { //strcpy(tempDI, substr(tempDI,1,strlen(tempDI)-1)); substr1(tempDI); } if (tempDI[0] == '\0') strcpy(tempDI, "0"); strcpy(decimal_integer, tempDI); printf("%s\n", decimal_integer); printf("%s\n", decimal_fraction); printf("%d\n", decimal_exponent); printf("%s\n", decimal_recurrence); printf("%d\n", decimal_recurrence_start); printf("%s\n", binary_recurrence); printf("%d\n", binary_recurrence_start); // These bottom three are the normalized binary values that also have to be // returned to the Javascript printf("%s\n", binary_integer_n); printf("%s\n", binary_fraction_n); printf("%d\n", binary_exponent_n); mpf_clear(decf); mpf_clear(powtwo); mpz_clear(result); mpz_clear(di); mpz_clear(df); free(binary_integer_n); free(binary_fraction_n); free(binary_integer_v); free(binary_fraction_v); free(binary_integer); free(binary_fraction); free(binary_recurrence); free(decimal_recurrence); free(decimal_integer); free(decimal_fraction); free(tempDI); free(ditemp); free(dftemp); free(temp); return 0; }
/*---------------------------------------------------------------------- Function to control flag set/clearing Basically, turn the flags into a fake list of features... Returns 0 unless user has added a keyword, then 1. ----*/ int flag_maintenance_screen(struct pine *ps, struct flag_screen *flags) { int i, lv, lc, maxwidth, offset, need, rv = 0; char tmp[1200], **p, *spacer; CONF_S *ctmpa, *first_line; struct flag_table *fp; OPT_SCREEN_S screen; try_again: maxwidth = MAX(MIN((ps->ttyo ? ps->ttyo->screen_cols : 80), 150), 30); first_line = NULL; ctmpa = NULL; for(p = flags->explanation; p && *p; p++) { new_confline(&ctmpa); ctmpa->keymenu = &flag_keymenu; ctmpa->help = NO_HELP; ctmpa->tool = flag_checkbox_tool; ctmpa->flags |= CF_NOSELECT; ctmpa->valoffset = 0; ctmpa->value = cpystr(_(*p)); } /* Now wire flags checkboxes together */ for(lv = 0, lc = 0, fp = (flags->flag_table ? *flags->flag_table : NULL); fp && fp->name; fp++) { /* longest name */ if(fp->flag != F_COMMENT) { if(lv < (i = utf8_width(_(fp->name)))) lv = i; if(fp->comment && lc < (i = utf8_width(fp->comment))) lc = i; } } lv = MIN(lv,100); lc = MIN(lc,100); if(lc > 0) spacer = " "; else spacer = ""; offset = 6; if((need = offset + 5 + lv + strlen(spacer) + lc) > maxwidth) { offset -= (need - maxwidth); offset = MAX(0,offset); if((need = offset + 5 + lv + strlen(spacer) + lc) > maxwidth) { spacer = " "; if((need = offset + 5 + lv + strlen(spacer) + lc) > maxwidth) { lc -= (need - maxwidth); lc = MAX(0,lc); if(lc == 0) spacer = ""; } } } new_confline(&ctmpa); ctmpa->keymenu = &flag_keymenu; ctmpa->help = NO_HELP; ctmpa->tool = flag_checkbox_tool; ctmpa->flags |= CF_NOSELECT; ctmpa->valoffset = 0; ctmpa->value = cpystr(""); new_confline(&ctmpa); ctmpa->keymenu = &flag_keymenu; ctmpa->help = NO_HELP; ctmpa->tool = flag_checkbox_tool; ctmpa->flags |= CF_NOSELECT; ctmpa->valoffset = 0; utf8_snprintf(tmp, sizeof(tmp), "%*.*w %s", offset+3, offset+3, _("Set"), _("Flag/Keyword Name")); tmp[sizeof(tmp)-1] = '\0'; ctmpa->value = cpystr(tmp); new_confline(&ctmpa); ctmpa->keymenu = &flag_keymenu; ctmpa->help = NO_HELP; ctmpa->tool = flag_checkbox_tool; ctmpa->flags |= CF_NOSELECT; ctmpa->valoffset = 0; snprintf(tmp, sizeof(tmp), "%*.*s--- %.*s", offset, offset, "", lv+lc+strlen(spacer), repeat_char(lv+lc+strlen(spacer), '-')); tmp[sizeof(tmp)-1] = '\0'; ctmpa->value = cpystr(tmp); for(fp = (flags->flag_table ? *flags->flag_table : NULL); fp && fp->name; fp++) { /* build the list */ new_confline(&ctmpa); if(!first_line && (fp->flag != F_COMMENT)) first_line = ctmpa; ctmpa->keymenu = &flag_keymenu; ctmpa->tool = flag_checkbox_tool; ctmpa->valoffset = offset; if(fp->flag == F_COMMENT) { ctmpa->help = NO_HELP; ctmpa->flags |= CF_NOSELECT; ctmpa->value = cpystr(fp->name); } else { ctmpa->help = fp->help; ctmpa->d.f.ftbl = flags->flag_table; ctmpa->d.f.fp = fp; utf8_snprintf(tmp, sizeof(tmp), "[%c] %-*.*w%s%-*.*w", (fp->set == 0) ? ' ' : (fp->set == 1) ? 'X' : '?', lv, lv, _(fp->name), spacer, lc, lc, fp->comment ? fp->comment : ""); ctmpa->value = cpystr(tmp); } } memset(&screen, 0, sizeof(screen)); /* * TRANSLATORS: FLAG MAINTENANCE is a screen title. * Print something1 using something2. configuration is something1 */ if(conf_scroll_screen(ps, &screen, first_line, _("FLAG MAINTENANCE"), _("configuration"), 0) == FLAG_ADD_RETURN) { int flags, r; char keyword[500]; char nickname[500]; char prompt[500]; char *error = NULL; KEYWORD_S *kw; HelpType help; /* * User is asking to add a new keyword. We will add it to the * mailbox if necessary and add it to the keywords list from * Setup/Config. Then we will modify the flag_table and present * the flag modification screen again. */ ps->mangled_screen = 1; keyword[0] = '\0'; flags = OE_APPEND_CURRENT; help = NO_HELP; do { if(error) { q_status_message(SM_ORDER, 3, 4, error); fs_give((void **) &error); } strncpy(prompt, _("Keyword to be added : "), sizeof(prompt)-1); prompt[sizeof(prompt)-1] = '\0'; r = optionally_enter(keyword, -FOOTER_ROWS(ps_global), 0, sizeof(keyword), prompt, NULL, help, &flags); if(r == 3) help = help == NO_HELP ? h_type_keyword : NO_HELP; else if(r == 1) { cmd_cancelled("Add Keyword"); goto try_again; } removing_leading_and_trailing_white_space(keyword); } while(r == 3 || keyword_check(keyword, &error)); for(kw = ps->keywords; kw; kw = kw->next) { if(kw->kw && !strucmp(kw->kw, keyword)) { q_status_message(SM_ORDER, 3, 4, _("Keyword already configured, changing nickname")); break; } } snprintf(prompt, sizeof(prompt), _("Optional nickname for \"%s\" : "), keyword); nickname[0] = '\0'; help = NO_HELP; do { r = optionally_enter(nickname, -FOOTER_ROWS(ps_global), 0, sizeof(nickname), prompt, NULL, help, &flags); if(r == 3) help = help == NO_HELP ? h_type_keyword_nickname : NO_HELP; else if(r == 1) { cmd_cancelled("Add Keyword"); goto try_again; } removing_leading_and_trailing_white_space(nickname); } while(r == 3); if(keyword[0]) { char ***alval; int offset = -1; struct variable *var; var = &ps_global->vars[V_KEYWORDS]; alval = ALVAL(var, Main); for(kw = ps->keywords; kw; kw = kw->next) { offset++; if(kw->kw && !strucmp(kw->kw, keyword)) { /* looks like it should already exist at offset */ break; } } if(!kw) offset = -1; if(offset >= 0 && (*alval) && (*alval)[offset]) { fs_give((void **) &(*alval)[offset]); (*alval)[offset] = put_pair(nickname, keyword); } else if(!*alval) { offset = 0; *alval = (char **) fs_get(2*sizeof(char *)); (*alval)[offset] = put_pair(nickname, keyword); (*alval)[offset+1] = NULL; } else { for(offset=0; (*alval)[offset]; offset++); ; fs_resize((void **) alval, (offset + 2) * sizeof(char *)); (*alval)[offset] = put_pair(nickname, keyword); (*alval)[offset+1] = NULL; } set_current_val(var, TRUE, FALSE); if(ps_global->prc) ps_global->prc->outstanding_pinerc_changes = 1; if(ps_global->keywords) free_keyword_list(&ps_global->keywords); if(var->current_val.l && var->current_val.l[0]) ps_global->keywords = init_keyword_list(var->current_val.l); clear_index_cache(ps_global->mail_stream, 0); rv = 1; } } ps->mangled_screen = 1; return(rv); }
struct cat* read_cat(const char* fname, int64 nside, double radius_arcsec, int verbose) { int barsize=70; FILE* fptr=open_file(fname); size_t nlines=countlines(fptr); if (verbose) wlog(" found %lu lines\n", nlines); rewind(fptr); struct cat* cat = alloc_or_die(sizeof(struct cat), "catalog struct"); double radius_radians=0; if (radius_arcsec <= 0) { cat->radius_in_file=1; cat->cos_radius = alloc_or_die(nlines*sizeof(double), "cos_radius array"); } else { cat->radius_in_file=0; cat->cos_radius = alloc_or_die(sizeof(double), "cos_radius"); radius_radians = radius_arcsec/3600.*D2R; cat->cos_radius[0] = cos(radius_radians); } cat->hpix=NULL; cat->tree=NULL; cat->pts = alloc_or_die(nlines*sizeof(struct point),"points"); cat->size = nlines; if (verbose) wlog(" creating hpix\n"); cat->hpix = hpix_new(nside); if (verbose) { wlog(" reading and building tree\n"); repeat_char('.', barsize); wlog("\n"); } double ra=0, dec=0; struct i64stack* listpix = i64stack_new(0); // this will produce a more balanced tree across the whole sky int64 half_npix=cat->hpix->npix/2; size_t count=0; struct point* pt = &cat->pts[0]; for (size_t i=0; i<cat->size; i++) { if (2 != fscanf(fptr, "%lf %lf", &ra, &dec)) { wlog("expected to read point at line %lu\n", i); exit(EXIT_FAILURE); } if (cat->radius_in_file) { if (1 != fscanf(fptr, "%lf", &radius_arcsec)) { wlog("expected to read radius at line %lu\n", i); exit(EXIT_FAILURE); } radius_radians = radius_arcsec/3600.*D2R; cat->cos_radius[i] = cos(radius_radians); } hpix_eq2xyz(ra,dec,&pt->x,&pt->y,&pt->z); hpix_disc_intersect(cat->hpix, pt->x, pt->y, pt->z, radius_radians, listpix); int64* ptr=listpix->data; while (ptr < listpix->data + listpix->size) { tree_insert(&cat->tree, (*ptr)-half_npix, count); ptr++; } pt++; count++; if (verbose) incr_bar(i+1, cat->size, barsize, '='); } listpix=i64stack_delete(listpix); if (verbose) wlog("\n"); if (count != nlines) { wlog("expected %lu lines but read %lu\n", nlines, count); exit(EXIT_FAILURE); } if (verbose) wlog("fullest node has %lu members\n", tree_most_members(cat->tree)); fclose(fptr); return cat; }