void print_message_text (int level, const char *text) { if (level >= 0) { begin_line (); print_spaces (level); } while (*text) { if (!strncmp (text, "<br>", 4)) { end_line (); begin_line (); print_spaces (level); text += 4; } else if (!strncmp (text, "<", 4)) { add_char_line ('<'); text += 4; } else if (!strncmp (text, ">", 4)) { add_char_line ('>'); text += 4; } else { add_char_line (*(text ++)); } } if (line_pos) { end_line (); } }
void write_unstructured_mesh(const char *filename, int ub, int npts, float *pts, int ncells, int *celltypes, int *conn, int nvars, int *vardim, int *centering, const char * const *varnames, float **vars) { int i, j; char str[128]; int conn_size = 0; int *curr_conn = conn; useBinary = ub; open_file(filename); write_header(); write_string("DATASET UNSTRUCTURED_GRID\n"); sprintf(str, "POINTS %d float\n", npts); write_string(str); for (i = 0 ; i < 3*npts ; i++) { write_float(pts[i]); } new_section(); for (i = 0 ; i < ncells ; i++) { int npts = num_points_for_cell(celltypes[i]); conn_size += npts+1; } sprintf(str, "CELLS %d %d\n", ncells, conn_size); write_string(str); for (i = 0 ; i < ncells ; i++) { int npts = num_points_for_cell(celltypes[i]); write_int(npts); for (j = 0 ; j < npts ; j++) write_int(*curr_conn++); end_line(); } new_section(); sprintf(str, "CELL_TYPES %d\n", ncells); write_string(str); for (i = 0 ; i < ncells ; i++) { write_int(celltypes[i]); end_line(); } write_variables(nvars, vardim, centering, varnames, vars, npts, ncells); close_file(); }
static int check_cond(char *buff, char **line, int count, int *first_go) { char *cpy_buff; char *cpy; if ((ft_strchr(buff, (int)'\n')) == NULL && *first_go) { *line = ft_strncpy(*line, buff, count); first_go = 0; } else if ((ft_strchr(buff, (int)'\n')) == NULL) { cpy_buff = (char *)ft_memalloc(sizeof(cpy_buff) * (count + 1)); cpy_buff = ft_strncpy(cpy_buff, buff, count); cpy = ft_strjoin(*line, cpy_buff); free(*line); free(cpy_buff); *line = cpy; } else if ((ft_strchr(buff, (int)'\n')) != NULL) { end_line(buff, line, (-1), *first_go); return (1); } return (0); }
int get_next_line(int const fd, char **line) { static char *rest[256] = {NULL}; int ret; char *buf; char *tmp; if (fd < 0 || fd == 1 || fd == 2 || BUFF_SIZE <= 0 || !line) return (-1); if (!rest[fd % 256]) { if (!(rest[fd % 256] = ft_strnew(BUFF_SIZE))) return (-1); if (read(fd, rest[fd % 256], BUFF_SIZE) == -1) return (-1); } if (!init_char(line, &buf)) return (-1); tmp = buf; ret = end_line(&rest[fd % 256], line, fd, buf); ft_memdel((void **)&tmp); if (ret == 0 && ft_strlen(rest[fd % 256]) > 0) { ft_memdel((void**)&rest[fd % 256]); return (1); } return (ret); }
void print_item(string tag) { string type, *tags, *tp; int *dims; type = get_type(instr, tag); if (streq(type, SetType)) { get_set(instr, tag); print_set(tag); tags = list_tags(instr); for (tp = tags; *tp != NULL; tp++) print_item(*tp); get_tes(instr, tag); print_tes(tag); for (tp = tags; *tp != NULL; tp++) free(*tp); free((char *)tags); } else { dims = get_dims(instr, tag); print_header(tag, type, dims); (void) outstr(" "); print_data(tag, type, dims); end_line(); if (dims != NULL) free((char *)dims); } free(type); }
static void showmbuf(struct if_info *ifi, int p, int showif) { if (showif) print_fld_str(FLD_MB_IFACE, ifi->name); if (p == -1 && ifi == interfaces) { print_fld_uint(FLD_MB_LLOCKS, mcllivelocks_diff); print_fld_size(FLD_MB_MSIZE, mbpool.pr_size); print_fld_size(FLD_MB_MALIVE, mbpool.pr_nget - mbpool.pr_nput); print_fld_size(FLD_MB_MHWM, mbpool.pr_hiwat); } if (p >= 0 && p < mclpool_count) { struct if_rxring_info *ifr = &ifi->data.ifri_entries[p]; struct if_rxring *rxr= &ifr->ifr_info; print_fld_uint(FLD_MB_MSIZE, ifr->ifr_size); print_fld_uint(FLD_MB_MALIVE, rxr->rxr_alive); if (rxr->rxr_lwm) print_fld_size(FLD_MB_MLWM, rxr->rxr_lwm); if (rxr->rxr_hwm) print_fld_size(FLD_MB_MHWM, rxr->rxr_hwm); if (rxr->rxr_cwm) print_fld_size(FLD_MB_MCWM, rxr->rxr_cwm); } end_line(); }
int get_next_line(int fd, char **line) { static char buff[BUFF_SIZE]; int first_passage; int nb; int count; if (BUFF_SIZE <= 0 || !line || (fd < 2 && fd != 0)) return (-1); *line = (char *)ft_memalloc(sizeof(*line) * (BUFF_SIZE + 1)); first_passage = 1; if ((nb = empty_buffer(buff, line, (-1), 0)) == 1) return (1); else first_passage = 0; while ((count = read(fd, buff, BUFF_SIZE)) > 0) { if ((check_cond(buff, line, count, &first_passage)) == 1) return (1); end_line(buff, line, (-1), (-1)); } if (count == -1) return (-1); if (nb == 2 || **line) return (1); return (0); }
void showtotal(void) { double rsum, wsum, rtsum, wtsum, mssum; int dn; rsum = wsum = rtsum = wtsum = mssum = 0.0; for (dn = 0; dn < cur.dk_ndrive; dn++) { rsum += cur.dk_rbytes[dn] / etime; wsum += cur.dk_wbytes[dn] / etime; rtsum += cur.dk_rxfer[dn] / etime; wtsum += cur.dk_wxfer[dn] / etime; mssum += ATIME(cur.dk_time, dn) / etime; } print_fld_str(FLD_IO_DEVICE, "Totals"); print_fld_size(FLD_IO_READ, rsum); print_fld_size(FLD_IO_WRITE, wsum); print_fld_size(FLD_IO_RTPS, rtsum); print_fld_size(FLD_IO_WTPS, wtsum); print_fld_float(FLD_IO_SEC, mssum, 1); end_line(); }
int get_next_line(int const fd, char **line) { int i; int ret; char *buffer; char *retline; static char *backline; i = 0; retline = ((backline) ? ft_strdup(backline) : ft_strnew(BUFF_SIZE)); while (!ft_strchr(retline, '\n') && retline && fd >= 0 && BUFF_SIZE > 0) { if ((buffer = ft_strnew(BUFF_SIZE))) { if ((ret = read(fd, buffer, BUFF_SIZE)) > 0) retline = ft_strjoin(retline, buffer); else if (ret == 0) return (end_line(line, retline, backline)); free(buffer); } } if (!fill_line(line, retline, &i, fd)) return (-1); backline = ft_strsub(retline, i + 1, (ft_strlen(retline) - i)); free(retline); return (1); }
void showpool(int k) { struct pool_info *p = pools + k; if (k < 0 || k >= num_pools) return; print_fld_str(FLD_POOL_NAME, p->name); print_fld_uint(FLD_POOL_SIZE, p->pool.pr_size); print_fld_size(FLD_POOL_REQS, p->pool.pr_nget); print_fld_size(FLD_POOL_FAIL, p->pool.pr_nfail); print_fld_ssize(FLD_POOL_INUSE, p->pool.pr_nget - p->pool.pr_nput); print_fld_size(FLD_POOL_PGREQ, p->pool.pr_npagealloc); print_fld_size(FLD_POOL_PGREL, p->pool.pr_npagefree); print_fld_size(FLD_POOL_NPAGE, p->pool.pr_npages); print_fld_size(FLD_POOL_HIWAT, p->pool.pr_hiwat); print_fld_size(FLD_POOL_MINPG, p->pool.pr_minpages); if (p->pool.pr_maxpages == UINT_MAX) print_fld_str(FLD_POOL_MAXPG, "inf"); else print_fld_size(FLD_POOL_MAXPG, p->pool.pr_maxpages); print_fld_size(FLD_POOL_IDLE, p->pool.pr_nidle); end_line(); }
void write_point_mesh(const char *filename, int ub, int npts, float *pts, int nvars, int *vardim, const char * const *varnames, float **vars) { int i; char str[128]; int *centering = NULL; useBinary = ub; open_file(filename); write_header(); write_string("DATASET UNSTRUCTURED_GRID\n"); sprintf(str, "POINTS %d float\n", npts); write_string(str); for (i = 0 ; i < 3*npts ; i++) { write_float(pts[i]); } new_section(); sprintf(str, "CELLS %d %d\n", npts, 2*npts); write_string(str); for (i = 0 ; i < npts ; i++) { write_int(1); write_int(i); end_line(); } new_section(); sprintf(str, "CELL_TYPES %d\n", npts); write_string(str); for (i = 0 ; i < npts ; i++) { write_int(VISIT_VERTEX); end_line(); } centering = (int *) malloc(nvars*sizeof(int)); for (i = 0 ; i < nvars ; i++) centering[i] = 1; write_variables(nvars, vardim, centering, varnames, vars, npts, npts); free(centering); close_file(); }
void Writer::end_write() { end_line(); if (callback != NULL) { callback->on_end_write (&data); } assert (state == w_running); state = w_stopped; }
void showbcache(void) { print_fld_str(FLD_IO_SSTR, "total bufs"); print_fld_ssize(FLD_IO_SVAL, bccur.numbufs); end_line(); print_fld_str(FLD_IO_SSTR, "total pages"); print_fld_ssize(FLD_IO_SVAL, bccur.numbufpages); end_line(); print_fld_str(FLD_IO_SSTR, "dirty pages"); print_fld_ssize(FLD_IO_SVAL, bccur.numdirtypages); end_line(); print_fld_str(FLD_IO_SSTR, "delwri bufs"); print_fld_ssize(FLD_IO_SVAL, bccur.delwribufs); end_line(); print_fld_str(FLD_IO_SSTR, "busymap bufs"); print_fld_ssize(FLD_IO_SVAL, bccur.busymapped); end_line(); print_fld_str(FLD_IO_SSTR, "avail kvaslots"); print_fld_ssize(FLD_IO_SVAL, bccur.kvaslots_avail); end_line(); print_fld_str(FLD_IO_SSTR, "kvaslots"); print_fld_ssize(FLD_IO_SVAL, bccur.kvaslots); end_line(); print_fld_str(FLD_IO_SSTR, "pending writes"); print_fld_ssize(FLD_IO_SVAL, bccur.pendingwrites); end_line(); print_fld_str(FLD_IO_SSTR, "pending reads"); print_fld_ssize(FLD_IO_SVAL, bccur.pendingreads); end_line(); print_fld_str(FLD_IO_SSTR, "cache hits"); print_fld_ssize(FLD_IO_SVAL, bccur.cachehits - bclast.cachehits); end_line(); }
void id_monst(int monster) { int i; for (i = 1; i <= nummonst + 2; i++) if (monsters[i].m_appear == monster) add_line("A %s ", monsters[i].m_name); end_line(); }
void print_set(string tag) { char buf[BUFLEN]; /* danger: buffer overflow */ if (xml) sprintf(buf, "<%s>", tag); else sprintf(buf, "set %s", tag); (void) outstr(buf); end_line(); change_indent(indent); }
void showdrive(int dn) { print_fld_str(FLD_IO_DEVICE, cur.dk_name[dn]); print_fld_size(FLD_IO_READ, cur.dk_rbytes[dn]/etime); print_fld_size(FLD_IO_WRITE, cur.dk_wbytes[dn]/ etime); print_fld_size(FLD_IO_RTPS, cur.dk_rxfer[dn] / etime); print_fld_size(FLD_IO_WTPS, cur.dk_wxfer[dn] / etime); print_fld_float(FLD_IO_SEC, ATIME(cur.dk_time, dn) / etime, 1); end_line(); }
void print_tes(string tag) { char buf[BUFLEN]; /* danger: buffer overflow */ change_indent(- indent); if (xml) sprintf(buf, "</%s>",tag); else sprintf(buf, "tes"); (void) outstr(buf); end_line(); }
void add_string_line (char *c, int len) { while (len > 0) { int x = len > LINE_SIZE - line_pos ? LINE_SIZE - line_pos : len; memcpy (line + line_pos, c, x); line_pos += x; c += x; len -= x; if (line_pos == LINE_SIZE) { end_line (); begin_line (); } } }
void print_message_array (int num, struct message **msg, int reverse) { int i; if (!reverse) { for (i = 0; i < num; i++) { begin_line (); add_string_line ("----------", 10); end_line (); print_message (0, msg[i]); } begin_line (); add_string_line ("----------", 10); end_line (); } else { for (i = num - 1; i >= 0; i--) { begin_line (); add_string_line ("----------", 10); end_line (); print_message (0, msg[i]); } begin_line (); add_string_line ("----------", 10); end_line (); } }
static void write_float(float val) { if (useBinary) { force_big_endian((unsigned char *) &val); fwrite(&val, sizeof(float), 1, fp); } else { fprintf(fp, "%20.12e ", val); if (((numInColumn++) % 9) == 8) { end_line(); } } }
static el_status_t meta(void) { int c; el_keymap_t *kp; if ((c = tty_get()) == EOF) return CSeof; #ifdef CONFIG_ANSI_ARROWS /* Also include VT-100 arrows. */ if (c == '[' || c == 'O') { switch (tty_get()) { case EOF: return CSeof; case '2': tty_get(); return CSstay; /* Insert */ case '3': tty_get(); return del_char(); /* Delete */ case '5': tty_get(); return CSstay; /* PgUp */ case '6': tty_get(); return CSstay; /* PgDn */ case 'A': return h_prev(); /* Up */ case 'B': return h_next(); /* Down */ case 'C': return fd_char(); /* Left */ case 'D': return bk_char(); /* Right */ case 'F': return end_line(); /* End */ case 'H': return beg_line(); /* Home */ default: /* Fall through */ break; } return el_ring_bell(); } #endif /* CONFIG_ANSI_ARROWS */ if (isdigit(c)) { for (Repeat = c - '0'; (c = tty_get()) != EOF && isdigit(c); ) Repeat = Repeat * 10 + c - '0'; tty_push(c); return CSstay; } if (isupper(c)) return do_macro(c); for (kp = MetaMap; kp->Function; kp++) { if (kp->Key == c) return kp->Function(); } return el_ring_bell(); }
void showbucket(int k) { struct kmembuckets *kp = buckets + k; if (k < 0 || k >= num_buckets) return; print_fld_size(FLD_BUCKET_SIZE, bucket_sizes[k]); print_fld_size(FLD_BUCKET_INUSE, kp->kb_total - kp->kb_totalfree); print_fld_size(FLD_BUCKET_FREE, kp->kb_totalfree); print_fld_size(FLD_BUCKET_REQUESTS, kp->kb_calls); print_fld_size(FLD_BUCKET_HIWAT, kp->kb_highwat); print_fld_size(FLD_BUCKET_COULDFREE, kp->kb_couldfree); end_line(); }
void print_ns(void) { int n, count = 0; if (kd == NULL) { print_fld_str(FLD_NS_LOCAL, "Failed to initialize KVM!"); print_fld_str(FLD_NS_FOREIGN, "Failed to initialize KVM!"); end_line(); return; } for (n = dispstart; n < num_disp; n++) { shownetstat(netinfos + n); count++; if (maxprint > 0 && count >= maxprint) break; } }
/* * inventory: * List what is in the pack. Return TRUE if there is something of * the given type. */ bool inventory(THING *list, int type) { static char inv_temp[MAXSTR]; n_objs = 0; for (; list != NULL; list = next(list)) { if (type && type != list->o_type && !(type == CALLABLE && list->o_type != FOOD && list->o_type != AMULET) && !(type == R_OR_S && (list->o_type == RING || list->o_type == STICK))) continue; n_objs++; #ifdef MASTER if (!list->o_packch) strcpy(inv_temp, "%s"); else #endif sprintf(inv_temp, "%c) %%s", list->o_packch); msg_esc = TRUE; if (add_line(inv_temp, inv_name(list, FALSE)) == ESCAPE) { msg_esc = FALSE; msg(""); return TRUE; } msg_esc = FALSE; } if (n_objs == 0) { if (terse) msg(type == 0 ? "empty handed" : "nothing appropriate"); else msg(type == 0 ? "you are empty handed" : "you don't have anything appropriate"); return FALSE; } end_line(); return TRUE; }
static void showtotal(void) { int conv = show_bits ? 8 : 1; int div = show_bits ? 1000 : 1024; print_fld_str(FLD_IF_IFACE, "Totals"); print_fld_sdiv(FLD_IF_IBYTES, sum.ifc_ib * conv, div); print_fld_size(FLD_IF_IPKTS, sum.ifc_ip); print_fld_size(FLD_IF_IERRS, sum.ifc_ie); print_fld_sdiv(FLD_IF_OBYTES, sum.ifc_ob * conv, div); print_fld_size(FLD_IF_OPKTS, sum.ifc_op); print_fld_size(FLD_IF_OERRS, sum.ifc_oe); print_fld_size(FLD_IF_COLLS, sum.ifc_co); end_line(); }
void showtype(int k) { struct type_info *t = types + k; if (k < 0 || k >= num_types) return; print_fld_str(FLD_TYPE_NAME, t->name ? t->name : "undefined"); print_fld_size(FLD_TYPE_INUSE, t->stats.ks_inuse); print_fld_size(FLD_TYPE_MEMUSE, t->stats.ks_memuse); print_fld_size(FLD_TYPE_HIGHUSE, t->stats.ks_maxused); print_fld_size(FLD_TYPE_LIMIT, t->stats.ks_limit); print_fld_size(FLD_TYPE_REQUESTS, t->stats.ks_calls); print_fld_size(FLD_TYPE_TLIMIT, t->stats.ks_limblocks); print_fld_size(FLD_TYPE_KLIMIT, t->stats.ks_mapblocks); print_fld_str(FLD_TYPE_SIZES, t->buckets); end_line(); }
void inventory(struct linked_list *container, int type) { int cnt; if (type == 0) { msg("What kind of item <%s> to inventory (* for all)?", type_list); type = readchar(); if (type == ESCAPE) { after = FALSE; msg(""); return; } } /* * Get a list of items to print out. If the user selects '*', list * them all. */ if (type == '*') type = 0; /* no type passed ->use them all */ mpos = 0; if ((cnt = count_bag(container, type, NULL)) == 0) msg("You don't have any %s.", name_type(type)); else { apply_to_bag(container, type, NULL, baf_print_item, &type); end_line(); msg(""); } return; }
static void showifstat(struct ifstat *ifs) { int conv = show_bits ? 8 : 1; int div = show_bits ? 1000 : 1024; print_fld_str(FLD_IF_IFACE, ifs->ifs_name); tb_start(); tbprintf("%s", ifs->ifs_cur.ifc_flags & IFF_UP ? "up" : "dn"); switch (ifs->ifs_cur.ifc_state) { case LINK_STATE_UP: case LINK_STATE_HALF_DUPLEX: case LINK_STATE_FULL_DUPLEX: tbprintf(":U"); break; case LINK_STATE_DOWN: tbprintf (":D"); break; } print_fld_tb(FLD_IF_STATE); print_fld_str(FLD_IF_DESC, ifs->ifs_description); print_fld_sdiv(FLD_IF_IBYTES, ifs->ifs_cur.ifc_ib * conv, div); print_fld_size(FLD_IF_IPKTS, ifs->ifs_cur.ifc_ip); print_fld_size(FLD_IF_IERRS, ifs->ifs_cur.ifc_ie); print_fld_sdiv(FLD_IF_OBYTES, ifs->ifs_cur.ifc_ob * conv, div); print_fld_size(FLD_IF_OPKTS, ifs->ifs_cur.ifc_op); print_fld_size(FLD_IF_OERRS, ifs->ifs_cur.ifc_oe); print_fld_size(FLD_IF_COLLS, ifs->ifs_cur.ifc_co); end_line(); }
static void shownetstat(struct netinfo *p) { switch (p->nif_family) { case AF_INET: inetprint(&p->nif_laddr, p->nif_lport, p->nif_proto, FLD_NS_LOCAL); inetprint(&p->nif_faddr, p->nif_fport, p->nif_proto, FLD_NS_FOREIGN); break; case AF_INET6: inet6print(&p->nif_laddr6, p->nif_lport, p->nif_proto, FLD_NS_LOCAL); inet6print(&p->nif_faddr6, p->nif_fport, p->nif_proto, FLD_NS_FOREIGN); break; } tb_start(); tbprintf("%s", p->nif_proto); if (p->nif_family == AF_INET6) tbprintf("6"); print_fld_tb(FLD_NS_PROTO); print_fld_size(FLD_NS_RECV_Q, p->nif_rcvcc); print_fld_size(FLD_NS_SEND_Q, p->nif_sndcc); if (streq(p->nif_proto, "tcp")) { if (p->nif_state < 0 || p->nif_state >= TCP_NSTATES) print_fld_uint(FLD_NS_STATE, p->nif_state); else print_fld_str(FLD_NS_STATE, tcpstates[p->nif_state]); } end_line(); }
void write_variables(int nvars, int *vardim, int *centering, const char * const * varname, float **vars, int npts, int ncells) { char str[1024]; int i, j, first_scalar, first_vector; int num_scalars, num_vectors; int num_field = 0; new_section(); sprintf(str, "CELL_DATA %d\n", ncells); write_string(str); first_scalar = 0; first_vector = 0; num_scalars = 0; num_vectors = 0; /* The field data is where the non-primary scalars and vectors are * stored. They must all be grouped together at the end of the point * data. So write out the primary scalars and vectors first. */ for (i = 0 ; i < nvars ; i++) { if (centering[i] == 0) { int num_to_write = 0; int should_write = 0; if (vardim[i] == 1) { if (first_scalar == 0) { should_write = 1; sprintf(str, "SCALARS %s float\n", varname[i]); write_string(str); write_string("LOOKUP_TABLE default\n"); first_scalar = 1; } else num_scalars++; } else if (vardim[i] == 3) { if (first_vector == 0) { should_write = 1; sprintf(str, "VECTORS %s float\n", varname[i]); write_string(str); first_vector = 1; } else num_vectors++; } else { printf("Only supported variable dimensions are 1 and 3.\n"); printf("Ignoring variable %s.\n", varname[i]); continue; } if (should_write) { num_to_write = ncells*vardim[i]; for (j = 0 ; j < num_to_write ; j++) { write_float(vars[i][j]); } end_line(); } } } first_scalar = 0; if (num_scalars > 0) { sprintf(str, "FIELD FieldData %d\n", num_scalars); write_string(str); for (i = 0 ; i < nvars ; i++) { int should_write = 0; if (centering[i] == 0) { if (vardim[i] == 1) { if (first_scalar == 0) { first_scalar = 1; } else { should_write = 1; sprintf(str, "%s 1 %d float\n", varname[i], ncells); write_string(str); } } } if (should_write) { int num_to_write = ncells*vardim[i]; for (j = 0 ; j < num_to_write ; j++) { write_float(vars[i][j]); } end_line(); } } } first_vector = 0; if (num_vectors > 0) { sprintf(str, "FIELD FieldData %d\n", num_vectors); write_string(str); for (i = 0 ; i < nvars ; i++) { int should_write = 0; if (centering[i] == 0) { int num_to_write = 0; if (vardim[i] == 3) { if (first_vector == 0) { first_vector = 1; } else { should_write = 1; sprintf(str, "%s 3 %d float\n", varname[i], ncells); write_string(str); } } } if (should_write) { int num_to_write = ncells*vardim[i]; for (j = 0 ; j < num_to_write ; j++) { write_float(vars[i][j]); } end_line(); } } } new_section(); sprintf(str, "POINT_DATA %d\n", npts); write_string(str); first_scalar = 0; first_vector = 0; num_scalars = 0; num_vectors = 0; /* The field data is where the non-primary scalars and vectors are * stored. They must all be grouped together at the end of the point * data. So write out the primary scalars and vectors first. */ for (i = 0 ; i < nvars ; i++) { if (centering[i] != 0) { int num_to_write = 0; int should_write = 0; if (vardim[i] == 1) { if (first_scalar == 0) { should_write = 1; sprintf(str, "SCALARS %s float\n", varname[i]); write_string(str); write_string("LOOKUP_TABLE default\n"); first_scalar = 1; } else num_scalars++; } else if (vardim[i] == 3) { if (first_vector == 0) { should_write = 1; sprintf(str, "VECTORS %s float\n", varname[i]); write_string(str); first_vector = 1; } else num_vectors++; } else { printf("Only supported variable dimensions are 1 and 3.\n"); printf("Ignoring variable %s.\n", varname[i]); continue; } if (should_write) { num_to_write = npts*vardim[i]; for (j = 0 ; j < num_to_write ; j++) { write_float(vars[i][j]); } end_line(); } } } first_scalar = 0; if (num_scalars > 0) { sprintf(str, "FIELD FieldData %d\n", num_scalars); write_string(str); for (i = 0 ; i < nvars ; i++) { int should_write = 0; if (centering[i] != 0) { if (vardim[i] == 1) { if (first_scalar == 0) { first_scalar = 1; } else { should_write = 1; sprintf(str, "%s 1 %d float\n", varname[i], npts); write_string(str); } } } if (should_write) { int num_to_write = npts*vardim[i]; for (j = 0 ; j < num_to_write ; j++) { write_float(vars[i][j]); } end_line(); } } } first_vector = 0; if (num_vectors > 0) { sprintf(str, "FIELD FieldData %d\n", num_vectors); write_string(str); for (i = 0 ; i < nvars ; i++) { int should_write = 0; if (centering[i] != 0) { int num_to_write = 0; if (vardim[i] == 3) { if (first_vector == 0) { first_vector = 1; } else { should_write = 1; sprintf(str, "%s 3 %d float\n", varname[i], npts); write_string(str); } } } if (should_write) { int num_to_write = npts*vardim[i]; for (j = 0 ; j < num_to_write ; j++) { write_float(vars[i][j]); } end_line(); } } } }