spicefile/ss_hspice.c

   1 /*
   2  * ss_hspice.c: HSPICE routines for SpiceStream
   3  *
   4  * Copyright (C) 1998-2002  Stephen G. Tell
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public
  17  * License along with this library; if not, write to the Free
  18  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  *
  20  */
  21
  22 #include "ssintern.h"
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <ctype.h>
  27 #include <float.h>
  28 #include <sys/types.h>
  29 #include <sys/stat.h>
  30
  31 #include <config.h>
  32 #include <glib.h>
  33 #include "spicestream.h"
  34
  35 SpiceStream *sf_rdhdr_hspice(char *name, FILE *fp);
  36 SpiceStream *sf_rdhdr_hsascii(char *name, FILE *fp);
  37 SpiceStream *sf_rdhdr_hsbin(char *name, FILE *fp);
  38
  39 static int sf_readrow_hsascii(SpiceStream *sf, double *ivar, double *dvars);
  40 static int sf_readrow_hsbin(SpiceStream *sf, double *ivar, double *dvars);
  41 static SpiceStream *hs_process_header(int nauto, int nprobe,
  42                                       int nsweepparam, char *line, char *name);
  43 static int sf_readsweep_hsascii(SpiceStream *sf, double *svar);
  44 static int sf_readsweep_hsbin(SpiceStream *sf, double *svar);
  45 static int sf_readblock_hsbin(FILE *fp, char **bufp, int *bufsize, int offset);
  46
  47 struct hsblock_header {  /* structure of binary tr0 block headers */
  48         gint32 h1;
  49         gint32 h2;
  50         gint32 h3;
  51         gint32 block_nbytes;
  52 };
  53
  54 union gint32bytes {
  55         gint32 i;
  56         gchar b[4];
  57 };
  58
  59 static void swap_gint32(gint32 *pi, size_t n);
  60
  61 /* Read spice-type file header - autosense hspice binary or ascii */
  62 SpiceStream *
  63 sf_rdhdr_hspice(char *name, FILE *fp)
  64 {
  65         int c;
  66         if((c = getc(fp)) == EOF)
  67                 return NULL;
  68         ungetc(c, fp);
  69
  70         if((c & 0xff) < ' ')
  71                 return sf_rdhdr_hsbin(name, fp);
  72         else
  73                 return sf_rdhdr_hsascii(name, fp);
  74
  75         return NULL;
  76 }
  77
  78 /* Read spice-type file header - hspice ascii */
  79 SpiceStream *
  80 sf_rdhdr_hsascii(char *name, FILE *fp)
  81 {
  82         SpiceStream *sf = NULL;
  83         char *line = NULL;
  84         int nauto, nprobe, nsweepparam, ntables;
  85         int lineno = 0;
  86         int linesize = 1024;
  87         int lineused;
  88         char lbuf[256];
  89         char nbuf[16];
  90         char *cp;
  91         int maxlines;
  92
  93         if(fgets(lbuf, sizeof(lbuf), fp) == NULL)
  94                 return NULL;
  95         lineno++;
  96
  97         /* version of post format */
  98         if(strncmp(&lbuf[16], "9007", 4) != 0
  99            && strncmp(&lbuf[16], "9601", 4) != 0)
 100                 return NULL;
 101         strncpy(nbuf, &lbuf[0], 4);
 102         nbuf[4] = 0;
 103         nauto = atoi(nbuf);
 104
 105         strncpy(nbuf, &lbuf[4], 4);
 106         nbuf[4] = 0;
 107         nprobe = atoi(nbuf);
 108
 109         strncpy(nbuf, &lbuf[8], 4);
 110         nbuf[4] = 0;
 111         nsweepparam = atoi(nbuf);
 112
 113         if(fgets(lbuf, sizeof(lbuf), fp) == NULL) /* date, time etc. */
 114                 return NULL;
 115         lineno++;
 116         /* number of sweeps, possibly with cruft at the start of the line */
 117         if(fgets(lbuf, sizeof(lbuf), fp) == NULL)
 118                 return NULL;
 119         cp = strchr(lbuf, ' ');
 120         if(!cp)
 121                 cp = lbuf;
 122         ntables = atoi(cp);
 123         if(ntables == 0)
 124                 ntables = 1;
 125         lineno++;
 126
 127         maxlines = nauto + nprobe + nsweepparam + 100;
 128         /* lines making up a fixed-field structure with variable-types and
 129          * variable names.
 130          * variable names can get split across lines! so we remove newlines,
 131          * paste all of the lines together, and then deal with the
 132          * whole header at once.
 133          * A variable name of "$&%#" indicates the end!
 134          */
 135         line = g_new0(char, linesize);
 136         lineused = 0;
 137         do {
 138                 int len;
 139                 if(fgets(lbuf, sizeof(lbuf), fp) == NULL)
 140                         return NULL;
 141                 lineno++;
 142                 if((cp = strchr(lbuf, '\n')) != NULL)
 143                         *cp = 0;
 144                 len = strlen(lbuf);
 145                 if(lineused + len + 1 > linesize) {
 146                         linesize *= 2;
 147                         if(linesize > 1050000) {
 148                                 ss_msg(ERR, "rdhdr_ascii", "internal error - failed to find end of header\n; linesize=%d line=\n%.200s\n", linesize, line);
 149                                 exit(4);
 150                         }
 151
 152                         line = g_realloc(line, linesize);
 153                 }
 154                 strcat(line, lbuf);
 155                 lineused += len;
 156
 157         } while(!strstr(line, "$&%#") && lineno < maxlines);
 158         if(lineno == maxlines) {
 159                 ss_msg(DBG, "rdhdr_hsascii", "%s:%d: end of hspice header not found", name,lineno);
 160                 goto fail;
 161         }
 162
 163         sf = hs_process_header(nauto, nprobe, nsweepparam, line, name);
 164         if(!sf)
 165                 goto fail;
 166         sf->fp = fp;
 167         sf->readrow = sf_readrow_hsascii;
 168         sf->linebuf = line;
 169         sf->linep = NULL;
 170         sf->lbufsize = linesize;
 171         sf->ntables = ntables;
 172         sf->read_tables = 0;
 173         sf->read_rows = 0;
 174         sf->read_sweepparam = 0;
 175         sf->readsweep = sf_readsweep_hsascii;
 176         sf->lineno = lineno;
 177
 178         ss_msg(DBG, "rdhdr_hsascii", "ntables=%d; expect %d columns",
 179                sf->ntables, sf->ncols);
 180
 181         return sf;
 182
 183  fail:
 184         if(line)
 185                 g_free(line);
 186         return NULL;
 187
 188 }
 189
 190 /* Read spice-type file header - hspice binary */
 191 SpiceStream *
 192 sf_rdhdr_hsbin(char *name, FILE *fp)
 193 {
 194
 195         SpiceStream *sf = NULL;
 196         char *ahdr = NULL;
 197         int ahdrsize = 0;
 198         int ahdrend = 0;
 199         int n;
 200         int datasize;
 201         int nauto, nprobe, nsweepparam, ntables;
 202         char nbuf[16];
 203         struct hsblock_header hh;
 204
 205         do {
 206                 n = sf_readblock_hsbin(fp, &ahdr, &ahdrsize, ahdrend);
 207                 if(n <= 0)
 208                         goto fail;
 209                 ahdrend += n;
 210                 ahdr[ahdrend] = '\0';
 211
 212         } while(!strstr(ahdr, "$&%#"));
 213
 214         /* ahdr is an ascii header that describes the variables in
 215          * much the same way that the first lines of the ascii format do,
 216          * except that there are no newlines
 217          */
 218
 219         if(strncmp(&ahdr[16], "9007", 4) != 0   /* version of post format */
 220            && strncmp(&ahdr[16], "9601", 4) != 0)
 221                 goto fail;
 222         strncpy(nbuf, &ahdr[0], 4);
 223         nbuf[4] = 0;
 224         nauto = atoi(nbuf);     /* number of automaticly-included variables,
 225                                    first one is independent variable */
 226         strncpy(nbuf, &ahdr[4], 4);
 227         nbuf[4] = 0;
 228         nprobe = atoi(nbuf);    /* number of user-requested columns */
 229
 230         strncpy(nbuf, &ahdr[8], 4);
 231         nbuf[4] = 0;
 232         nsweepparam = atoi(nbuf);       /* number of sweep parameters */
 233
 234         ntables = atoi(&ahdr[176]);
 235         if(ntables == 0)
 236                 ntables = 1;
 237
 238         sf = hs_process_header(nauto, nprobe, nsweepparam, &ahdr[256], name);
 239         if(!sf)
 240                 goto fail;
 241
 242         if(fread(&hh, sizeof(hh), 1, fp) != 1) {
 243                 ss_msg(DBG, "sf_rdhdr_hsbin", "EOF reading block header");
 244                 goto fail;
 245         }
 246         if(hh.h1 == 0x04000000 && hh.h3 == 0x04000000) {
 247                 /* detected endian swap */
 248                 sf->flags |= SSF_ESWAP;
 249                 swap_gint32((gint32*)&hh, sizeof(hh)/sizeof(gint32));
 250         }
 251         if(hh.h1 != 4 || hh.h3 != 4) {
 252                 ss_msg(DBG, "sf_rdhdr_hsbin", "unexepected values in data block header");
 253                 goto fail;
 254         }
 255
 256         datasize = hh.block_nbytes;
 257         sf->expected_vals = datasize / sizeof(float);
 258         sf->read_vals = 0;
 259
 260         ss_msg(DBG, "sf_rdhdr_hsbin", "datasize=%d expect %d columns, %d values;\n  reading first data block at 0x%lx", datasize, sf->ncols, sf->expected_vals, (long)ftello64(fp));
 261
 262
 263         sf->fp = fp;
 264         sf->readrow = sf_readrow_hsbin;
 265         sf->readsweep = sf_readsweep_hsbin;
 266
 267         sf->ntables = ntables;
 268         sf->read_tables = 0;
 269         sf->read_rows = 0;
 270         sf->read_sweepparam = 0;
 271
 272         return sf;
 273  fail:
 274         if(ahdr)
 275                 g_free(ahdr);
 276         if(sf) {
 277                 if(sf->dvar)
 278                         g_free(sf->dvar);
 279                 g_free(sf);
 280         }
 281
 282         return NULL;
 283 }
 284
 285 /* common code for reading ascii or binary hspice headers.
 286  * Given a string of ascii header information, set up the
 287  * SpiceStream structure appropriately.
 288  * Returns NULL on failure.
 289  */
 290 static SpiceStream *
 291 hs_process_header(int nauto, int nprobe, int nsweepparam, char *line, char *name)
 292 {
 293         char *cp;
 294         char *signam;
 295         SpiceStream *sf;
 296         int i;
 297         int hstype;
 298
 299 /* type of independent variable */
 300         cp = strtok(line, " \t\n");
 301         if(!cp) {
 302                 ss_msg(DBG, "hs_process_header", "%s: initial vartype not found on header line.", name);
 303                 return NULL;
 304         }
 305         sf = ss_new(NULL, name, nauto-1 + nprobe, nsweepparam);
 306         hstype = atoi(cp);
 307         switch(hstype) {
 308         case 1:
 309                 sf->ivar->type = TIME;
 310                 break;
 311         case 2:
 312                 sf->ivar->type = FREQUENCY;
 313                 break;
 314         case 3:
 315                 sf->ivar->type = VOLTAGE;
 316                 break;
 317         default:
 318                 sf->ivar->type = UNKNOWN;
 319                 break;
 320         }
 321         sf->ivar->col = 0;
 322         sf->ivar->ncols = 1;
 323         sf->ncols = 1;
 324
 325 /* dependent variable types */
 326         for(i = 0; i < sf->ndv; i++) {
 327                 cp = strtok(NULL, " \t\n");
 328                 if(!cp) {
 329                         ss_msg(DBG, "hs_process_header", "%s: not enough vartypes on header line", name);
 330                         return NULL;
 331                 }
 332                 if(!isdigit(cp[0])) {
 333                         ss_msg(DBG, "hs_process_header", "%s: bad vartype %d [%s] on header line", name, i, cp);
 334                         return NULL;
 335                 }
 336                 hstype = atoi(cp);
 337                 switch(hstype) {
 338                 case 1:
 339                 case 2:
 340                         sf->dvar[i].type = VOLTAGE;
 341                         break;
 342                 case 8:
 343                 case 15:
 344                 case 22:
 345                         sf->dvar[i].type = CURRENT;
 346                         break;
 347                 default:
 348                         sf->dvar[i].type = UNKNOWN;
 349                         break;
 350                 }
 351
 352                 /* how many columns comprise this variable? */
 353                 sf->dvar[i].col = sf->ncols;
 354                 if(i < nauto-1 && sf->ivar->type == FREQUENCY) {
 355                         sf->dvar[i].ncols = 2;
 356                 } else {
 357                         sf->dvar[i].ncols = 1;
 358                 }
 359                 sf->ncols += sf->dvar[i].ncols;
 360         }
 361
 362 /* independent variable name */
 363         signam = strtok(NULL, " \t\n");
 364         if(!signam) {
 365                 ss_msg(DBG, "hs_process_header", "%s: no IV name found on header line", name);
 366                 goto fail;
 367         }
 368         sf->ivar->name = g_strdup(signam);
 369
 370  /* dependent variable names */
 371         for(i = 0; i < sf->ndv; i++) {
 372                 if((signam = strtok(NULL, " \t\n")) == NULL) {
 373                         ss_msg(DBG, "hs_process_header", "%s: not enough DV names found on header line", name);
 374                         goto fail;
 375                 }
 376                 sf->dvar[i].name = g_strdup(signam);
 377         }
 378 /* sweep parameter names */
 379         for(i = 0; i < sf->nsweepparam; i++) {
 380                 if((signam = strtok(NULL, " \t\n")) == NULL) {
 381                         ss_msg(DBG, "hs_process_header", "%s: not enough sweep parameter names found on header line", name);
 382                         goto fail;
 383                 }
 384                 sf->spar[i].name = g_strdup(signam);
 385         }
 386
 387         return sf;
 388
 389  fail:
 390         ss_delete(sf);
 391         return NULL;
 392 }
 393
 394 /*
 395  * Read a "block" from an HSPICE binary file.
 396  * Returns number of bytes read, 0 for EOF, negative for error.
 397  * The body of the block is copied into the buffer pointed to by the
 398  * buffer-pointer pointed to by bufp, at offset offset.
 399  * The buffer is expanded with g_realloc if necessary.
 400  * If bufp is NULL, a new buffer  is allocated.   The buffer
 401  * size is maintained in the int pointed to by bufsize.
 402  *
 403  */
 404 static int
 405 sf_readblock_hsbin(FILE *fp, char **bufp, int *bufsize, int offset)
 406 {
 407         struct hsblock_header hh;
 408         gint32 trailer;
 409         int eswap = 0;
 410
 411         if(fread(&hh, sizeof(hh), 1, fp) != 1) {
 412                 ss_msg(DBG, "sf_readblock_hsbin", "EOF reading block header");
 413                 return 0;
 414         }
 415         if(hh.h1 == 0x04000000 && hh.h3 == 0x04000000) {
 416                 /* detected endian swap */
 417                 eswap = 1;
 418                 swap_gint32((gint32*)&hh, sizeof(hh)/sizeof(gint32));
 419         }
 420         if(hh.h1 != 0x00000004 || hh.h3 != 0x00000004) {
 421                 ss_msg(DBG, "sf_readblock_hsbin", "unexepected values in block header");
 422                 return -1;
 423         }
 424         if(bufp == NULL) {   /* new buffer: exact fit */
 425                 *bufsize = hh.block_nbytes;
 426                 *bufp = g_new(char, *bufsize);
 427         }
 428
 429         /* need to expand: double buffer size or make room for two blocks
 430          * this size, whichever is larger.  Better to realloc more now and
 431          * cut down on the number of future reallocs.
 432          */
 433         if(*bufsize < offset + hh.block_nbytes) {
 434                 if(2 * *bufsize > (*bufsize + 2 * hh.block_nbytes))
 435                         *bufsize *= 2;
 436                 else
 437                         *bufsize += 2 * hh.block_nbytes;
 438                 *bufp = g_realloc(*bufp, *bufsize);
 439         }
 440         if(fread(*bufp + offset, sizeof(char), hh.block_nbytes, fp) != hh.block_nbytes) {
 441                 ss_msg(DBG, "sf_readblock_hsbin", "EOF reading block body");
 442                 return 0;
 443         }
 444         if(fread(&trailer, sizeof(gint32), 1, fp) != 1) {
 445                 ss_msg(DBG, "sf_readblock_hsbin", "EOF reading block trailer");
 446                 return 0;
 447         }
 448         if(eswap) {
 449                 swap_gint32(&trailer, 1);
 450         }
 451         if(trailer != hh.block_nbytes) {
 452                 ss_msg(DBG, "sf_readblock_hsbin", "block trailer mismatch");
 453                 return -2;
 454         }
 455         return hh.block_nbytes;
 456 }
 457
 458 /*
 459  * helper routine: get next floating-point value from data part of binary
 460  * hspice file.   Handles the block-structure of hspice files; all blocks
 461  * encountered are assumed to be data blocks.  We don't use readblock_hsbin because
 462  * some versions of hspice write very large blocks, which would require a
 463  * very large buffer.
 464  *
 465  * Returns 0 on EOF, 1 on success, negative on error.
 466  */
 467 static int
 468 sf_getval_hsbin(SpiceStream *sf, double *dval)
 469 {
 470         off64_t pos;
 471         float val;
 472         struct hsblock_header hh;
 473         gint32 trailer;
 474
 475         if(sf->read_vals >= sf->expected_vals) {
 476                 pos = ftello64(sf->fp);
 477                 if(fread(&trailer, sizeof(gint32), 1, sf->fp) != 1) {
 478                         ss_msg(DBG, "sf_getval_hsbin", "EOF reading block trailer at offset 0x%lx", (long) pos);
 479                         return 0;
 480                 }
 481                 if(sf->flags & SSF_ESWAP) {
 482                         swap_gint32(&trailer, 1);
 483                 }
 484                 if(trailer != sf->expected_vals * sizeof(float)) {
 485                         ss_msg(DBG, "sf_getval_hsbin", "block trailer mismatch at offset 0x%lx", (long) pos);
 486                         return -2;
 487                 }
 488
 489                 pos = ftello64(sf->fp);
 490                 if(fread(&hh, sizeof(hh), 1, sf->fp) != 1) {
 491                         ss_msg(DBG, "sf_getval_hsbin", "EOF reading block header at offset 0x%lx", (long) pos);
 492                         return 0;
 493                 }
 494                 if(hh.h1 == 0x04000000 && hh.h3 == 0x04000000) {
 495                         /* detected endian swap */
 496                         sf->flags |= SSF_ESWAP;
 497                         swap_gint32((gint32*)&hh, sizeof(hh)/sizeof(gint32));
 498                 } else {
 499                         sf->flags &= ~SSF_ESWAP;
 500                 }
 501                 if(hh.h1 != 0x00000004 || hh.h3 != 0x00000004) {
 502                         ss_msg(ERR, "sf_getval_hsbin", "unexepected values in block header at offset 0x%lx", pos);
 503                         return -1;
 504                 }
 505                 sf->expected_vals = hh.block_nbytes / sizeof(float);
 506                 sf->read_vals = 0;
 507         }
 508         if(fread(&val, sizeof(float), 1, sf->fp) != 1) {
 509                 pos = ftello64(sf->fp);
 510                 ss_msg(ERR, "sf_getval_hsbin", "unexepected EOF in data at offset 0x%lx", (long) pos);
 511                 return 0;
 512         }
 513         sf->read_vals++;
 514
 515         if(sf->flags & SSF_ESWAP) {
 516                 swap_gint32((gint32 *)&val, 1);
 517         }
 518         *dval = val;
 519         return 1;
 520 }
 521
 522 /*
 523  * helper routine: get next value from ascii hspice file.
 524  * the file is line-oriented, with fixed-width fields on each line.
 525  * Lines may look like either of these two examples:
 526 0.66687E-090.21426E+010.00000E+000.00000E+000.25000E+010.71063E-090.17877E+01
 527  .00000E+00 .30000E+01 .30000E+01 .30000E+01 .30000E+01 .30000E+01 .30092E-05
 528  * There may be whitespace at the end of the line before the newline.
 529  *
 530  * Returns 0 on EOF, 1 on success.
 531  */
 532 static int
 533 sf_getval_hsascii(SpiceStream *sf, double *val)
 534 {
 535         char vbuf[16];
 536         char *vp;
 537         char *cp;
 538         int l;
 539
 540         if(!sf->linep || (*sf->linep==0) || *sf->linep == '\n') {
 541                 if(fgets(sf->linebuf, sf->lbufsize, sf->fp) == NULL)
 542                         return 0;
 543
 544                 l = strlen(sf->linebuf);
 545                 if(l) {  /* delete whitespace at end of line */
 546                         cp = sf->linebuf + l - 1;
 547                         while(cp > sf->linebuf && *cp && isspace(*cp))
 548                                 *cp-- = '\0';
 549                 }
 550                 sf->linep = sf->linebuf;
 551                 sf->line_length = strlen(sf->linep);
 552                 /* fprintf(stderr, "#line: \"%s\"\n", sf->linebuf); */
 553         }
 554         if(sf->linep > sf->linebuf + sf->line_length) {
 555                 ss_msg(WARN, "sf_getval_hsascii",
 556                        "%s: internal error or bad line in file", sf->filename);
 557                 return 0;
 558         }
 559
 560         strncpy(vbuf, sf->linep, 11);
 561         sf->linep += 11;
 562         vbuf[11] = 0;
 563         if(strlen(vbuf) != 11) {
 564                 /* incomplete float value - probably truncated or
 565                    partialy-written file */
 566                 return 0;
 567         }
 568         vp = vbuf;
 569         while(isspace(*vp)) /* atof doesn't like spaces */
 570                 vp++;
 571         *val = atof(vp);
 572         /* fprintf(stderr, "#vp=\"%s\" val=%f\n", vp, *val); */
 573         return 1;
 574 }
 575
 576 /* Read row of values from ascii hspice-format file.
 577  * Returns:
 578  *      1 on success.  also fills in *ivar scalar and *dvars vector
 579  *      0 on EOF
 580  *      -1 on error  (may change some ivar/dvar values)
 581  *      -2 on end of table, with more tables supposedly still to be read.
 582  */
 583
 584 static int
 585 sf_readrow_hsascii(SpiceStream *sf, double *ivar, double *dvars)
 586 {
 587         int i;
 588
 589         if(!sf->read_sweepparam) { /* first row of table */
 590                 if(sf_readsweep_hsascii(sf, NULL) <= 0) /* discard sweep parameters, if any */
 591                         return -1;
 592         }
 593         if(sf_getval_hsascii(sf, ivar) == 0)
 594                 return 0;
 595         if(*ivar >= 1.0e29) { /* "infinity" at end of data table */
 596                 sf->read_tables++;
 597                 if(sf->read_tables == sf->ntables)
 598                         return 0; /* EOF */
 599                 else
 600                         sf->read_sweepparam = 0;
 601                         sf->read_rows = 0;
 602                         return -2;  /* end of table, more tables follow */
 603         }
 604
 605         sf->read_rows++;
 606         for(i = 0; i < sf->ncols-1; i++) {
 607                 if(sf_getval_hsascii(sf, &dvars[i]) == 0) {
 608                         ss_msg(WARN, "sf_readrow_hsascii", "%s: EOF or error reading data field %d in row %d of table %d; file is incomplete.", sf->filename, i, sf->read_rows, sf->read_tables);
 609                         return 0;
 610                 }
 611         }
 612         return 1;
 613 }
 614
 615 /* Read row of values from binary hspice-format file.
 616  * Returns:
 617  *      1 on success.  also fills in *ivar scalar and *dvars vector
 618  *      0 on EOF
 619  *      -1 on error  (may change some ivar/dvar values)
 620  */
 621 static int
 622 sf_readrow_hsbin(SpiceStream *sf, double *ivar, double *dvars)
 623 {
 624         int i;
 625         int rc;
 626
 627         if(!sf->read_sweepparam) { /* first row of table */
 628                 if(sf_readsweep_hsbin(sf, NULL) <= 0) /* discard sweep parameters, if any */
 629                         return -1;
 630         }
 631
 632         rc = sf_getval_hsbin(sf, ivar);
 633         if(rc == 0)             /* file EOF */
 634                 return 0;
 635         if(rc < 0)
 636                 return -1;
 637         if(*ivar >= 1.0e29) { /* "infinity" at end of data table */
 638                 sf->read_tables++;
 639                 if(sf->read_tables == sf->ntables)
 640                         return 0; /* end of data, should also be EOF but we don't check */
 641                 else {
 642                         sf->read_sweepparam = 0;
 643                         sf->read_rows = 0;
 644                         return -2;  /* end of table, more tables follow */
 645                 }
 646         }
 647         sf->read_rows++;
 648         for(i = 0; i < sf->ncols-1; i++) {
 649                 if(sf_getval_hsbin(sf, &dvars[i]) != 1) {
 650                         ss_msg(WARN, "sf_readrow_hsbin", "%s: EOF or error reading data field %d in row %d of table %d; file is incomplete.", sf->filename, i, sf->read_rows, sf->read_tables);
 651                         return 0;
 652                 }
 653         }
 654         return 1;
 655 }
 656
 657 /*
 658  * Read the sweep parameters from an HSPICE ascii or binary file
 659  * This routine must be called before the first sf_readrow_hsascii call in each data
 660  * table.  If it has not been called before the first readrow call, it will be called
 661  * with a NULL svar pointer to read and discard the sweep data.
 662  *
 663  * returns:
 664  *      1 on success
 665  *      -1 on error
 666  */
 667 static int
 668 sf_readsweep_hsascii(SpiceStream *sf, double *svar)
 669 {
 670         int i;
 671         double val;
 672         for(i = 0; i < sf->nsweepparam; i++) {
 673                 if(sf_getval_hsascii(sf, &val) == 0) {
 674                         ss_msg(ERR, "sf_readsweep_hsascii", "unexpected EOF reading sweep parameters\n");
 675                         return -1;
 676                 }
 677                 if(svar)
 678                         svar[i] = val;
 679         }
 680
 681         sf->read_sweepparam = 1;
 682         return 1;
 683 }
 684
 685 static int
 686 sf_readsweep_hsbin(SpiceStream *sf, double *svar)
 687 {
 688         int i;
 689         double val;
 690         for(i = 0; i < sf->nsweepparam; i++) {
 691                 if(sf_getval_hsbin(sf, &val) != 1) {
 692                         ss_msg(ERR, "sf_readsweep_hsbin", "EOF or error reading sweep parameter\n");
 693                         return -1;
 694                 }
 695                 if(svar)
 696                         svar[i] = val;
 697         }
 698
 699         sf->read_sweepparam = 1;
 700         return 1;
 701 }
 702
 703
 704 /*
 705  * Estimate how many rows are in the file associated with sf.
 706  * We base our estimate on the size of the file.
 707  * This can be useful to aid in memory-use planning by programs planning to
 708  * read the entire file.
 709  *
 710  * If the file descriptor is not associated with an ordinary file, we return 0
 711  * to indicate that the length cannot be estimated.
 712  * If an error occurs, -1 is returned.
 713  */
 714 static long
 715 sf_guessrows_hsbin(SpiceStream *sf)
 716 {
 717         int rc;
 718         struct stat st;
 719
 720         rc = fstat(fileno(sf->fp), &st);
 721         if(rc < 0)
 722                 return -1;
 723         if((st.st_mode & S_IFMT) != S_IFREG)
 724                 return 0;
 725
 726         return st.st_size / (sizeof(float)  * sf->ncols);
 727 }
 728
 729
 730 static void
 731 swap_gint32(gint32 *pi, size_t n)
 732 {
 733         union gint32bytes *p = (union gint32bytes *)pi;
 734         size_t i;
 735         gchar temp;
 736         for(i = 0; i < n; i++) {
 737                 temp = p[i].b[3] ;
 738                 p[i].b[3] = p[i].b[0];
 739                 p[i].b[0] = temp;
 740
 741                 temp = p[i].b[2] ;
 742                 p[i].b[2] = p[i].b[1];
 743                 p[i].b[1] = temp;
 744         }
 745 }