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();
}
}
}
}
