/*
 * pdbrec.c
 *
 * Summary:  Read or write a PDB record.
 *
 * Author:  David Hardy
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include "pdbrec.h"
#include "ihash.h"
#include "error.h"

/*
 * prototypes for standard PDB files
 */
static int pdbrec_to_header(const Pdbrec *p, Pdbrec_Data *data);
static int header_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_obslte(const Pdbrec *p, Pdbrec_Data *data);
static int obslte_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_title(const Pdbrec *p, Pdbrec_Data *data);
static int title_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_caveat(const Pdbrec *p, Pdbrec_Data *data);
static int caveat_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_compnd(const Pdbrec *p, Pdbrec_Data *data);
static int compnd_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_source(const Pdbrec *p, Pdbrec_Data *data);
static int source_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_keywds(const Pdbrec *p, Pdbrec_Data *data);
static int keywds_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_expdta(const Pdbrec *p, Pdbrec_Data *data);
static int expdta_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_author(const Pdbrec *p, Pdbrec_Data *data);
static int author_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_revdat(const Pdbrec *p, Pdbrec_Data *data);
static int revdat_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_sprsde(const Pdbrec *p, Pdbrec_Data *data);
static int sprsde_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_jrnl(const Pdbrec *p, Pdbrec_Data *data);
static int jrnl_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_remark(const Pdbrec *p, Pdbrec_Data *data);
static int remark_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_dbref(const Pdbrec *p, Pdbrec_Data *data);
static int dbref_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_seqadv(const Pdbrec *p, Pdbrec_Data *data);
static int seqadv_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_seqres(const Pdbrec *p, Pdbrec_Data *data);
static int seqres_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_modres(const Pdbrec *p, Pdbrec_Data *data);
static int modres_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_het(const Pdbrec *p, Pdbrec_Data *data);
static int het_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_hetnam(const Pdbrec *p, Pdbrec_Data *data);
static int hetnam_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_hetsyn(const Pdbrec *p, Pdbrec_Data *data);
static int hetsyn_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_formul(const Pdbrec *p, Pdbrec_Data *data);
static int formul_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_helix(const Pdbrec *p, Pdbrec_Data *data);
static int helix_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_sheet(const Pdbrec *p, Pdbrec_Data *data);
static int sheet_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_turn(const Pdbrec *p, Pdbrec_Data *data);
static int turn_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_ssbond(const Pdbrec *p, Pdbrec_Data *data);
static int ssbond_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_link(const Pdbrec *p, Pdbrec_Data *data);
static int link_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_hydbnd(const Pdbrec *p, Pdbrec_Data *data);
static int hydbnd_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_sltbrg(const Pdbrec *p, Pdbrec_Data *data);
static int sltbrg_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_cispep(const Pdbrec *p, Pdbrec_Data *data);
static int cispep_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_site(const Pdbrec *p, Pdbrec_Data *data);
static int site_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_cryst1(const Pdbrec *p, Pdbrec_Data *data);
static int cryst1_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_origx1(const Pdbrec *p, Pdbrec_Data *data);
static int origx1_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_origx2(const Pdbrec *p, Pdbrec_Data *data);
static int origx2_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_origx3(const Pdbrec *p, Pdbrec_Data *data);
static int origx3_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_scale1(const Pdbrec *p, Pdbrec_Data *data);
static int scale1_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_scale2(const Pdbrec *p, Pdbrec_Data *data);
static int scale2_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_scale3(const Pdbrec *p, Pdbrec_Data *data);
static int scale3_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_mtrix1(const Pdbrec *p, Pdbrec_Data *data);
static int mtrix1_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_mtrix2(const Pdbrec *p, Pdbrec_Data *data);
static int mtrix2_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_mtrix3(const Pdbrec *p, Pdbrec_Data *data);
static int mtrix3_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_tvect(const Pdbrec *p, Pdbrec_Data *data);
static int tvect_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_model(const Pdbrec *p, Pdbrec_Data *data);
static int model_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_atom(const Pdbrec *p, Pdbrec_Data *data);
static int atom_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_sigatm(const Pdbrec *p, Pdbrec_Data *data);
static int sigatm_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_anisou(const Pdbrec *p, Pdbrec_Data *data);
static int anisou_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_siguij(const Pdbrec *p, Pdbrec_Data *data);
static int siguij_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_ter(const Pdbrec *p, Pdbrec_Data *data);
static int ter_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_hetatm(const Pdbrec *p, Pdbrec_Data *data);
static int hetatm_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_endmdl(const Pdbrec *p, Pdbrec_Data *data);
static int endmdl_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_conect(const Pdbrec *p, Pdbrec_Data *data);
static int conect_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_master(const Pdbrec *p, Pdbrec_Data *data);
static int master_to_line(const Pdbrec_Data *data, char *line);

static int pdbrec_to_end(const Pdbrec *p, Pdbrec_Data *data);
static int end_to_line(const Pdbrec_Data *data, char *line);

#undef   KEYWDBUFSIZE
#define  KEYWDBUFSIZE   8
#undef   MAXFIELD
#define  MAXFIELD      35

struct Pdbrec_Info_Tag {
  char keywd[KEYWDBUFSIZE];
  int (*pdbrec_to_data)(const Pdbrec *, Pdbrec_Data *);
  int (*data_to_line)(const Pdbrec_Data *, char *);
  int colnum[MAXFIELD];
  const char *fmt;
};

typedef struct Pdbrec_Info_Tag Pdbrec_Info;

static const Pdbrec_Info INFO[] = {
  {
    "HEADER", pdbrec_to_header, header_to_line, 
    {0,6,10,50,59,62,66}, 
    "sussus"
  },
  {
    "OBSLTE", pdbrec_to_obslte, obslte_to_line, 
    {0,6,8,10,11,20,21,25,31,35,36,40,41,45,46,50,51,55,56,60,61,65,66,70},
    "suiusususususususususus"
  },
  {
    "TITLE ", pdbrec_to_title, title_to_line,
    {0,6,8,10,70},
    "suis"
  },
  {
    "CAVEAT", pdbrec_to_caveat, caveat_to_line,
    {0,6,8,10,11,15,19,70},
    "suiusus"
  },
  {
    "COMPND", pdbrec_to_compnd, compnd_to_line,
    {0,6,8,10,70},
    "suis"
  },
  {
    "SOURCE", pdbrec_to_source, source_to_line,
    {0,6,8,10,70},
    "suis"
  },
  {
    "KEYWDS", pdbrec_to_keywds, keywds_to_line,
    {0,6,8,10,70},
    "suis"
  },
  {
    "EXPDTA", pdbrec_to_expdta, expdta_to_line,
    {0,6,8,10,70},
    "suis"
  },
  {
    "AUTHOR", pdbrec_to_author, author_to_line,
    {0,6,8,10,70},
    "suis"
  },
  {
    "REVDAT", pdbrec_to_revdat, revdat_to_line,
    {0,6,7,10,12,13,22,23,28,31,32,39,45,46,52,53,59,60,66},
    "suiiususuiusususus"
  },
  {
    "SPRSDE", pdbrec_to_sprsde, sprsde_to_line,
    {0,6,8,10,11,20,21,25,31,35,36,40,41,45,46,50,51,55,56,60,61,65,66,70},
    "suiusususususususususus"
  },
  {
    "JRNL  ", pdbrec_to_jrnl, jrnl_to_line,
    {0,6,12,70},
    "sus"
  },
  {
    "REMARK", pdbrec_to_remark, remark_to_line,
    {0,6,7,10,11,70},
    "suius"
  },
  {
    "DBREF ", pdbrec_to_dbref, dbref_to_line,
    {0,6,7,11,12,13,14,18,19,20,24,25,26,32,33,41,42,54,55,60,61,62,67,68},
    "susucuicuicusususuicuic"
  },
  {
    "SEQADV", pdbrec_to_seqadv, seqadv_to_line,
    {0,6,7,11,12,15,16,17,18,22,23,24,28,29,38,39,42,43,48,49,70},
    "sususucuicusususuius"
  },
  {
    "SEQRES", pdbrec_to_seqres, seqres_to_line,
    {0,6,8,10,11,12,13,17,19,22,23,26,27,30,31,34,35,38,39,42,43,46,47,50,
      51,54,55,58,59,62,63,66,67,70},
    "suiucuiususususususususususususus"
  },
  {
    "MODRES", pdbrec_to_modres, modres_to_line,
    {0,6,7,11,12,15,16,17,18,22,23,24,27,29,70},
    "sususucuicusus"
  },
  {
    "HET   ", pdbrec_to_het, het_to_line,
    {0,6,7,10,12,13,17,18,20,25,30,70},
    "susucicuius"
  },
  {
    "HETNAM", pdbrec_to_hetnam, hetnam_to_line,
    {0,6,8,10,11,14,15,70},
    "suiusus"
  },
  {
    "HETSYN", pdbrec_to_hetsyn, hetsyn_to_line,
    {0,6,8,10,11,14,15,70},
    "suiusus"
  },
  {
    "FORMUL", pdbrec_to_formul, formul_to_line,
    {0,6,8,10,12,15,16,18,19,70},
    "suiusuics"
  },
  {
    "HELIX ", pdbrec_to_helix, helix_to_line,
    {0,6,7,10,11,14,15,18,19,20,21,25,26,27,30,31,32,33,37,38,40,70,71,76},
    "suiususucuicusucuicisui"
  },
  {
    "SHEET ", pdbrec_to_sheet, sheet_to_line,
    {0,6,7,10,11,14,16,17,20,21,22,26,27,28,31,32,33,37,38,40,41,45,48,49,
      50,54,55,56,60,63,64,65,69,70},
    "suiusiusucicusuciciussucicussucic"
  },
  {
    "TURN  ", pdbrec_to_turn, turn_to_line,
    {0,6,7,10,11,14,15,18,19,20,24,25,26,29,30,31,35,36,40,70},
    "suiususucicusucicus"
  },
  {
    "SSBOND", pdbrec_to_ssbond, ssbond_to_line,
    {0,6,7,10,11,14,15,16,17,21,22,25,28,29,30,31,35,36,59,65,66,72},
    "suiusucuicusucuicusus"
  },
  {
    "LINK  ", pdbrec_to_link, link_to_line,
    {0,6,12,16,17,20,21,22,26,27,42,46,47,50,51,52,56,57,59,65,66,72},
    "suscsucicuscsucicusus"
  },
  {
    "HYDBND", pdbrec_to_hydbnd, hydbnd_to_line,
    {0,6,12,16,17,20,21,22,27,28,29,33,34,35,36,41,42,43,47,48,51,52,53,58,
      59,65,66,72},
    "suscsucicuscucicuscsucicsus"
  },
  {
    "SLTBRG", pdbrec_to_sltbrg, sltbrg_to_line,
    {0,6,12,16,17,20,21,22,26,27,42,46,47,50,51,52,56,57,59,65,66,72},
    "suscsucicuscsucicusus"
  },
  {
    "CISPEP", pdbrec_to_cispep, cispep_to_line,
    {0,6,7,10,11,14,15,16,17,21,22,25,28,29,30,31,35,36,43,46,53,59},
    "suiusucuicusucuicuiuf"
  },
  {
    "SITE  ", pdbrec_to_site, site_to_line,
    {0,6,7,10,11,14,15,17,18,21,22,23,27,28,29,32,33,34,38,39,40,43,44,45,
      49,50,51,54,55,56,60,61},
    "suiusuiusucicusucicusucicusucic"
  },
  {
    "CRYST1", pdbrec_to_cryst1, cryst1_to_line,
    {0,6,15,24,33,40,47,54,55,66,70},
    "sgggfffusi"
  },
  {
    "ORIGX1", pdbrec_to_origx1, origx1_to_line,
    {0,6,10,20,30,40,45,55},
    "suyyyux"
  },
  {
    "ORIGX2", pdbrec_to_origx2, origx2_to_line,
    {0,6,10,20,30,40,45,55},
    "suyyyux"
  },
  {
    "ORIGX3", pdbrec_to_origx3, origx3_to_line,
    {0,6,10,20,30,40,45,55},
    "suyyyux"
  },
  {
    "SCALE1", pdbrec_to_scale1, scale1_to_line,
    {0,6,10,20,30,40,45,55},
    "suyyyux"
  },
  {
    "SCALE2", pdbrec_to_scale2, scale2_to_line,
    {0,6,10,20,30,40,45,55},
    "suyyyux"
  },
  {
    "SCALE3", pdbrec_to_scale3, scale3_to_line,
    {0,6,10,20,30,40,45,55},
    "suyyyux"
  },
  {
    "MTRIX1", pdbrec_to_mtrix1, mtrix1_to_line,
    {0,6,7,10,20,30,40,45,55,59,60},
    "suiyyyuxui"
  },
  {
    "MTRIX2", pdbrec_to_mtrix2, mtrix2_to_line,
    {0,6,7,10,20,30,40,45,55,59,60},
    "suiyyyuxui"
  },
  {
    "MTRIX3", pdbrec_to_mtrix3, mtrix3_to_line,
    {0,6,7,10,20,30,40,45,55,59,60},
    "suiyyyuxui"
  },
  {
    "TVECT ", pdbrec_to_tvect, tvect_to_line,
    {0,6,7,10,20,30,40,70},
    "suixxxs"
  },
  {
    "MODEL ", pdbrec_to_model, model_to_line,
    {0,6,10,14},
    "sui"
  },
  {
    "ATOM  ", pdbrec_to_atom, atom_to_line,
    {0,6,11,12,16,17,20,21,22,26,27,30,38,46,54,60,66,72,76,78,80},
    "siuscsucicugggffusss"
  },
  {
    "SIGATM", pdbrec_to_sigatm, sigatm_to_line,
    {0,6,11,12,16,17,20,21,22,26,27,30,38,46,54,60,66,72,76,78,80},
    "siuscsucicugggffusss"
  },
  {
    "ANISOU", pdbrec_to_anisou, anisou_to_line,
    {0,6,11,12,16,17,20,21,22,26,27,28,35,42,49,56,63,70,72,76,78,80},
    "siuscsucicuiiiiiiusss"
  },
  {
    "SIGUIJ", pdbrec_to_siguij, siguij_to_line,
    {0,6,11,12,16,17,20,21,22,26,27,28,35,42,49,56,63,70,72,76,78,80},
    "siuscsucicuiiiiiiusss"
  },
  {
    "TER   ", pdbrec_to_ter, ter_to_line,
    {0,6,11,17,20,21,22,26,27},
    "siusucic"
  },
  {
    "HETATM", pdbrec_to_hetatm, hetatm_to_line,
    {0,6,11,12,16,17,20,21,22,26,27,30,38,46,54,60,66,72,76,78,80},
    "siuscsucicugggffusss"
  },
  {
    "ENDMDL", pdbrec_to_endmdl, endmdl_to_line,
    {0,6},
    "s"
  },
  {
    "CONECT", pdbrec_to_conect, conect_to_line,
    {0,6,11,16,21,26,31,36,41,46,51,56,61},
    "siiiiiiiiiii"
  },
  {
    "MASTER", pdbrec_to_master, master_to_line,
    {0,6,10,15,20,25,30,35,40,45,50,55,60,65,70},
    "suiiiiiiiiiiii"
  },
  {
    "END   ", pdbrec_to_end, end_to_line,
    {0,6},
    "s"
  }
};

static const int INFOLEN = sizeof(INFO) / sizeof(INFO[0]);

static Ihash TABLE;


int pdbrec_startup(void)
{
  int ret, i;

  MDIO_ASSERT(INFOLEN == PDBREC_END + 1);
  ret = ihash_init(&TABLE, 2 * INFOLEN);
  MDIO_ASSERT(ret == 0);
  for (i = 0;  i < INFOLEN;  i++) {
    ret = ihash_insert(&TABLE, INFO[i].keywd, i);
    MDIO_ASSERT(ret == IHASH_FAIL);
  }
  return 0;
}


void pdbrec_shutdown(void)
{
  ihash_destroy(&TABLE);
}


/***
int read_line(FILE *f, char *buf, int buflen)
{
  if (fgets(buf, buflen, f) == NULL) return -1; */ /* found EOF */ /*
  return 0;
}

int write_line(FILE *f, const char *buf)
{
  int ret;
  ret = fputs(buf, f);
  MDIO_ASSERT(ret == strlen(buf));
  return 0;
}
***/


int pdbrec_init(Pdbrec *p, int type)
{
  int i;

  p->recid = -1;
  memset(p->buf, 0, sizeof(p->buf));
  for (i = 0;  i < INFOLEN;  i++) {
    p->info[i] = &INFO[i];
  }
/*
  p->type = type;
*/
/* ignore type for right now */
  return 0;
}


void pdbrec_destroy(Pdbrec *p)
{
  memset(p, 0, sizeof(Pdbrec));
}  


int pdbrec_extract(Pdbrec *p, register const char *line)
{
  register int i;
  register char *bufptr = p->buf;
  int k, nfield, colnum;
  const Pdbrec_Info *info;

  for (i = 0;  i < 6;  i++)  *bufptr++ = *line++;
  *bufptr++ = '\0';
  p->recid = ihash_lookup(&TABLE, p->buf);
  MDIO_ASSERT(p->recid >= 0);
  info = p->info[p->recid];
  nfield = strlen(info->fmt) + 1;
  for (k = 2;  k < nfield;  k++) {
    colnum = info->colnum[k];
    while (i < colnum) {
      *bufptr++ = *line++;
      i++;
    }
    *bufptr++ = '\0';
  }
  while (i < 80) {
    *bufptr++ = *line++;
    i++;
  }
  *bufptr++ = '\0';
/* now the jth data field starts in column p->buf[ info->colnum[j] + j ]  */
/* for  j = 0 ... strlen( info->fmt ),  where  info = p->info[p->recid]   */
  return (p->recid);
}


int pdbrec_getdata(const Pdbrec *p, Pdbrec_Data *data)
{
  data->recid = p->recid;
  MDIO_ASSERT( p->info[ p->recid ]->pdbrec_to_data != NULL );
  return p->info[ p->recid ]->pdbrec_to_data(p, data);
}


int pdbrec_combine(const Pdbrec *p, Pdbrec_Data *data, char *line)
{
  MDIO_ASSERT( data->recid >= 0 && data->recid <= PDBREC_END );
  data->info = p->info[data->recid];
  MDIO_ASSERT( data->info->data_to_line != NULL );
  return data->info->data_to_line(data, line);
}


static int get_data(const Pdbrec *p, int mask, const Pdbrec_Info **info,
                    int *isblank, ...)
{
  va_list v;
  int bitmask, j;
  const int *colnum;
  const char *fmt;
  const char *buf;
  char *cp;
  int *ip;
  float *fp;

  va_start(v, isblank);
  *info = p->info[p->recid];
  colnum = (*info)->colnum;
  fmt = (*info)->fmt;
  buf = p->buf;
  *isblank = 0;  /* to start with */

  j = 1;
  bitmask = 2;
  while (*++fmt != '\0') {
    switch (*fmt) {

    case 'u':  /* unused field */
      break;

    case 's':  /* string field */
      cp = va_arg(v,char*);
      if ((bitmask & mask) == 0) {
        strcpy(cp, buf + colnum[j] + j);
      }
      bitmask <<= 1;
      break;

    case 'c':  /* char field */
      cp = va_arg(v,char*);
      if ((bitmask & mask) == 0) {
        *cp = buf[ colnum[j] + j ];
      }
      bitmask <<= 1;
      break;

    case 'i':  /* int field */
      ip = va_arg(v,int*);
      if ((bitmask & mask) == 0 
          && sscanf(buf + colnum[j] + j, "%d", ip) != 1) {
        *isblank |= bitmask;
      }
      bitmask <<= 1;
      break;

    case 'e':  /* float field, precision n.1 */
    case 'f':  /* float field, precision n.2 */
    case 'g':  /* float field, precision n.3 */
    case 'h':  /* float field, precision n.4 */
    case 'x':  /* float field, precision n.5 */
    case 'y':  /* float field, precision n.6 */
      fp = va_arg(v,float*);
      if ((bitmask & mask) == 0 
          && sscanf(buf + colnum[j] + j, "%f", fp) == 0) {
        *isblank |= bitmask;
      }
      bitmask <<= 1;
      break;

    default:   /* unrecognized format character */
      va_end(v);
      return -1;
    }
    j++;
  }
  va_end(v);
  return 0;
}


static int store_line(char *line, const Pdbrec_Info *info, int isblank, ...)
{
  va_list v;
  int bitmask, j;
  const int *colnum;
  const char *fmt;
  const char *cptr;
  int slen;
  char fmtbuf[64], buf[64];
  int numch = 0;
  int i;
  float f;

  va_start(v, isblank);
  colnum = info->colnum;
  fmt = info->fmt;

  cptr = info->keywd;
  while (*cptr != '\0') *line++ = *cptr++, numch++;
  j = 1;
  bitmask = 2;
  while (*++fmt != '\0') {
    switch (*fmt) {

    case 'u':  /* unused field */
      slen = colnum[j+1] - colnum[j];
      while (slen-- > 0) *line++ = ' ', numch++;
      break;

    case 's':  /* string field */
      cptr = va_arg(v,char*);
      while (*cptr != '\0') *line++ = *cptr++, numch++;
      bitmask <<= 1;
      break;

    case 'c':  /* char field */
      *line++ = (char) va_arg(v,int), numch++;
      bitmask <<= 1;
      break;

    case 'i':  /* int field */
      i = va_arg(v,int);
      slen = colnum[j+1] - colnum[j];
      if ((bitmask & isblank) == 0) {
        sprintf(fmtbuf, "%%%dd", slen);
        sprintf(buf, fmtbuf, i);
        if (strlen(buf) != slen) return -1;  /* range error */
        cptr = buf;
        while (*cptr != '\0') *line++ = *cptr++, numch++;
      }
      else {
        while (slen-- > 0) *line++ = ' ', numch++;
      }
      bitmask <<= 1;
      break;

    case 'e':  /* float field, precision n.1 */
      f = (float) va_arg(v,double);
      slen = colnum[j+1] - colnum[j];
      if ((bitmask & isblank) == 0) {
        sprintf(fmtbuf, "%%%d.1f", slen);
        sprintf(buf, fmtbuf, (double)f);
        if (strlen(buf) != slen) return -1;  /* range error */
        cptr = buf;
        while (*cptr != '\0') *line++ = *cptr++, numch++;
      }
      else {
        while (slen-- > 0) *line++ = ' ', numch++;
      }
      bitmask <<= 1;
      break;

    case 'f':  /* float field, precision n.2 */
      f = (float) va_arg(v,double);
      slen = colnum[j+1] - colnum[j];
      if ((bitmask & isblank) == 0) {
        sprintf(fmtbuf, "%%%d.2f", slen);
        sprintf(buf, fmtbuf, (double)f);
        if (strlen(buf) != slen) return -1;  /* range error */
        cptr = buf;
        while (*cptr != '\0') *line++ = *cptr++, numch++;
      }
      else {
        while (slen-- > 0) *line++ = ' ', numch++;
      }
      bitmask <<= 1;
      break;

    case 'g':  /* float field, precision n.3 */
      f = (float) va_arg(v,double);
      slen = colnum[j+1] - colnum[j];
      if ((bitmask & isblank) == 0) {
        sprintf(fmtbuf, "%%%d.3f", slen);
        sprintf(buf, fmtbuf, (double)f);
        if (strlen(buf) != slen) return -1;  /* range error */
        cptr = buf;
        while (*cptr != '\0') *line++ = *cptr++, numch++;
      }
      else {
        while (slen-- > 0) *line++ = ' ', numch++;
      }
      bitmask <<= 1;
      break;

    case 'h':  /* float field, precision n.4 */
      f = (float) va_arg(v,double);
      slen = colnum[j+1] - colnum[j];
      if ((bitmask & isblank) == 0) {
        sprintf(fmtbuf, "%%%d.4f", slen);
        sprintf(buf, fmtbuf, (double)f);
        if (strlen(buf) != slen) return -1;  /* range error */
        cptr = buf;
        while (*cptr != '\0') *line++ = *cptr++, numch++;
      }
      else {
        while (slen-- > 0) *line++ = ' ', numch++;
      }
      bitmask <<= 1;
      break;

    case 'x':  /* float field, precision n.5 */
      f = (float) va_arg(v,double);
      slen = colnum[j+1] - colnum[j];
      if ((bitmask & isblank) == 0) {
        sprintf(fmtbuf, "%%%d.5f", slen);
        sprintf(buf, fmtbuf, (double)f);
        if (strlen(buf) != slen) return -1;  /* range error */
        cptr = buf;
        while (*cptr != '\0') *line++ = *cptr++, numch++;
      }
      else {
        while (slen-- > 0) *line++ = ' ', numch++;
      }
      bitmask <<= 1;
      break;

    case 'y':  /* float field, precision n.6 */
      f = (float) va_arg(v,double);
      slen = colnum[j+1] - colnum[j];
      if ((bitmask & isblank) == 0) {
        sprintf(fmtbuf, "%%%d.6f", slen);
        sprintf(buf, fmtbuf, (double)f);
        if (strlen(buf) != slen) return -1;  /* range error */
        cptr = buf;
        while (*cptr != '\0') *line++ = *cptr++, numch++;
      }
      else {
        while (slen-- > 0) *line++ = ' ', numch++;
      }
      bitmask <<= 1;
      break;

    default:
      va_end(v);
      return -1;
    }
    j++;
  }
  while (numch < 80) *line++ = ' ', numch++;  /* pad out rest of line */
  va_end(v);
  return 0;
}


int pdbrec_to_header(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Header *d = &(data->d.header);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      d->classification, d->depDate, d->idCode);
}

int header_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Header *d = &(data->d.header);
  return store_line(line, data->info, d->isblank,
      d->classification, d->depDate, d->idCode);
}

int pdbrec_to_obslte(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Obslte *d = &(data->d.obslte);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->continuation), d->repDate, d->idCode,
      d->rIdCode1, d->rIdCode2, d->rIdCode3, d->rIdCode4,
      d->rIdCode5, d->rIdCode6, d->rIdCode7, d->rIdCode8);
}

int obslte_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Obslte *d = &(data->d.obslte);
  return store_line(line, data->info, d->isblank,
      d->continuation, d->repDate, d->idCode,
      d->rIdCode1, d->rIdCode2, d->rIdCode3, d->rIdCode4,
      d->rIdCode5, d->rIdCode6, d->rIdCode7, d->rIdCode8);
}

int pdbrec_to_title(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Title *d = &(data->d.title);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->continuation), d->title);
}

int title_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Title *d = &(data->d.title);
  return store_line(line, data->info, d->isblank,
      d->continuation, d->title);
}

int pdbrec_to_caveat(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Caveat *d = &(data->d.caveat);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->continuation), d->idCode, d->comment);
}

int caveat_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Caveat *d = &(data->d.caveat);
  return store_line(line, data->info, d->isblank,
      d->continuation, d->idCode, d->comment);
}

int pdbrec_to_compnd(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Compnd *d = &(data->d.compnd);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->continuation), d->compound);
}

int compnd_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Compnd *d = &(data->d.compnd);
  return store_line(line, data->info, d->isblank,
      d->continuation, d->compound);
}

int pdbrec_to_source(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Source *d = &(data->d.source);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->continuation), d->srcName);
}

int source_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Source *d = &(data->d.source);
  return store_line(line, data->info, d->isblank,
      d->continuation, d->srcName);
}

int pdbrec_to_keywds(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Keywds *d = &(data->d.keywds);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->continuation), d->keywds);
}

int keywds_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Keywds *d = &(data->d.keywds);
  return store_line(line, data->info, d->isblank,
      d->continuation, d->keywds);
}

int pdbrec_to_expdta(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Expdta *d = &(data->d.expdta);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->continuation), d->technique);
}

int expdta_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Expdta *d = &(data->d.expdta);
  return store_line(line, data->info, d->isblank,
      d->continuation, d->technique);
}

int pdbrec_to_author(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Author *d = &(data->d.author);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->continuation), d->authorList);
}

int author_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Author *d = &(data->d.author);
  return store_line(line, data->info, d->isblank,
      d->continuation, d->authorList);
}

int pdbrec_to_revdat(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Revdat *d = &(data->d.revdat);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->modNum), &(d->continuation), d->modDate, d->modId,
      &(d->modType), d->record1, d->record2, d->record3, d->record4);
}

int revdat_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Revdat *d = &(data->d.revdat);
  return store_line(line, data->info, d->isblank,
      d->modNum, d->continuation, d->modDate, d->modId,
      d->modType, d->record1, d->record2, d->record3, d->record4);
}

int pdbrec_to_sprsde(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Sprsde *d = &(data->d.sprsde);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->continuation), d->sprsdeDate, d->idCode,
      d->sIdCode1, d->sIdCode2, d->sIdCode3, d->sIdCode4,
      d->sIdCode5, d->sIdCode6, d->sIdCode7, d->sIdCode8);
}

int sprsde_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Sprsde *d = &(data->d.sprsde);
  return store_line(line, data->info, d->isblank,
      d->continuation, d->sprsdeDate, d->idCode,
      d->sIdCode1, d->sIdCode2, d->sIdCode3, d->sIdCode4,
      d->sIdCode5, d->sIdCode6, d->sIdCode7, d->sIdCode8);
}

int pdbrec_to_jrnl(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Jrnl *d = &(data->d.jrnl);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      d->text);
}

int jrnl_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Jrnl *d = &(data->d.jrnl);
  return store_line(line, data->info, d->isblank,
      d->text);
}

int pdbrec_to_remark(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Remark *d = &(data->d.remark);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->remarkNum), d->text);
}

int remark_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Remark *d = &(data->d.remark);
  return store_line(line, data->info, d->isblank,
      d->remarkNum, d->text);
}

int pdbrec_to_dbref(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Dbref *d = &(data->d.dbref);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      d->idCode, &(d->chainId), &(d->seqBegin), &(d->insertBegin),
      &(d->seqEnd), &(d->insertEnd), d->database, d->dbAccession,
      d->dbIdCode, &(d->dbseqBegin), &(d->dbinsBegin),
      &(d->dbseqEnd), &(d->dbinsEnd));
}

int dbref_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Dbref *d = &(data->d.dbref);
  return store_line(line, data->info, d->isblank,
      d->idCode, d->chainId, d->seqBegin, d->insertBegin,
      d->seqEnd, d->insertEnd, d->database, d->dbAccession,
      d->dbIdCode, d->dbseqBegin, d->dbinsBegin,
      d->dbseqEnd, d->dbinsEnd);
}

int pdbrec_to_seqadv(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Seqadv *d = &(data->d.seqadv);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      d->idCode, d->resName, &(d->chainId), &(d->seqNum), &(d->iCode),
      d->database, d->dbIdCode, d->dbRes, &(d->dbSeq), d->conflict);
}

int seqadv_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Seqadv *d = &(data->d.seqadv);
  return store_line(line, data->info, d->isblank,
      d->idCode, d->resName, d->chainId, d->seqNum, d->iCode,
      d->database, d->dbIdCode, d->dbRes, d->dbSeq, d->conflict);
}

int pdbrec_to_seqres(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Seqres *d = &(data->d.seqres);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->serNum), &(d->chainId), &(d->numRes), d->resName1,
      d->resName2, d->resName3, d->resName4, d->resName5,
      d->resName6, d->resName7, d->resName8, d->resName9,
      d->resName10, d->resName11, d->resName12, d->resName13);
}

int seqres_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Seqres *d = &(data->d.seqres);
  return store_line(line, data->info, d->isblank,
      d->serNum, d->chainId, d->numRes, d->resName1,
      d->resName2, d->resName3, d->resName4, d->resName5,
      d->resName6, d->resName7, d->resName8, d->resName9,
      d->resName10, d->resName11, d->resName12, d->resName13);
}

int pdbrec_to_modres(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Modres *d = &(data->d.modres);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      d->idCode, d->resName, &(d->chainId), &(d->seqNum), &(d->iCode),
      d->stdRes, d->comment);
}

int modres_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Modres *d = &(data->d.modres);
  return store_line(line, data->info, d->isblank,
      d->idCode, d->resName, d->chainId, d->seqNum, d->iCode,
      d->stdRes, d->comment);
}

int pdbrec_to_het(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Het *d = &(data->d.het);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      d->hetId, &(d->chainId), &(d->seqNum), &(d->iCode),
      &(d->numHetAtoms), d->text);
}

int het_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Het *d = &(data->d.het);
  return store_line(line, data->info, d->isblank,
      d->hetId, d->chainId, d->seqNum, d->iCode,
      d->numHetAtoms, d->text);
}

int pdbrec_to_hetnam(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Hetnam *d = &(data->d.hetnam);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->continuation), d->hetId, d->text);
}

int hetnam_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Hetnam *d = &(data->d.hetnam);
  return store_line(line, data->info, d->isblank,
      d->continuation, d->hetId, d->text);
}

int pdbrec_to_hetsyn(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Hetsyn *d = &(data->d.hetsyn);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->continuation), d->hetId, d->hetSynonyms);
}

int hetsyn_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Hetsyn *d = &(data->d.hetsyn);
  return store_line(line, data->info, d->isblank,
      d->continuation, d->hetId, d->hetSynonyms);
}

int pdbrec_to_formul(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Formul *d = &(data->d.formul);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->compNum), d->hetId, &(d->continuation), &(d->asterisk), d->text);
}

int formul_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Formul *d = &(data->d.formul);
  return store_line(line, data->info, d->isblank,
      d->compNum, d->hetId, d->continuation, d->asterisk, d->text);
}

int pdbrec_to_helix(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Helix *d = &(data->d.helix);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->serNum), d->helixId, d->initResName, &(d->initChainId),
      &(d->initSeqNum), &(d->initICode), d->endResName, &(d->endChainId),
      &(d->endSeqNum), &(d->endICode), &(d->helixClass),
      d->comment, &(d->length));
}

int helix_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Helix *d = &(data->d.helix);
  return store_line(line, data->info, d->isblank,
      d->serNum, d->helixId, d->initResName, d->initChainId,
      d->initSeqNum, d->initICode, d->endResName, d->endChainId,
      d->endSeqNum, d->endICode, d->helixClass,
      d->comment, d->length);
}

int pdbrec_to_sheet(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Sheet *d = &(data->d.sheet);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->strand), d->sheetId, &(d->numStrands), d->initResName,
      &(d->initChainId), &(d->initSeqNum), &(d->initICode),
      d->endResName, &(d->endChainId), &(d->endSeqNum), &(d->endICode),
      &(d->sense), d->curAtom, d->curResName, &(d->curChainId),
      &(d->curResSeq), &(d->curICode), d->prevAtom, d->prevResName,
      &(d->prevChainId), &(d->prevResSeq), &(d->prevICode));
}

int sheet_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Sheet *d = &(data->d.sheet);
  return store_line(line, data->info, d->isblank,
      d->strand, d->sheetId, d->numStrands, d->initResName,
      d->initChainId, d->initSeqNum, d->initICode,
      d->endResName, d->endChainId, d->endSeqNum, d->endICode,
      d->sense, d->curAtom, d->curResName, d->curChainId,
      d->curResSeq, d->curICode, d->prevAtom, d->prevResName,
      d->prevChainId, d->prevResSeq, d->prevICode);
}

int pdbrec_to_turn(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Turn *d = &(data->d.turn);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->seq), d->turnId, d->initResName, &(d->initChainId),
      &(d->initSeqNum), &(d->initICode), d->endResName, &(d->endChainId),
      &(d->endSeqNum), &(d->endICode), d->comment);
}

int turn_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Turn *d = &(data->d.turn);
  return store_line(line, data->info, d->isblank,
      d->seq, d->turnId, d->initResName, d->initChainId,
      d->initSeqNum, d->initICode, d->endResName, d->endChainId,
      d->endSeqNum, d->endICode, d->comment);
}

int pdbrec_to_ssbond(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Ssbond *d = &(data->d.ssbond);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->serNum), d->cys1, &(d->chainId1), &(d->seqNum1), &(d->iCode1),
      d->cys2, &(d->chainId2), &(d->seqNum2), &(d->iCode2), d->sym1, d->sym2);
}

int ssbond_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Ssbond *d = &(data->d.ssbond);
  return store_line(line, data->info, d->isblank,
      d->serNum, d->cys1, d->chainId1, d->seqNum1, d->iCode1,
      d->cys2, d->chainId2, d->seqNum2, d->iCode2, d->sym1, d->sym2);
}

int pdbrec_to_link(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Link *d = &(data->d.link);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      d->name1, &(d->altLoc1), d->resName1, &(d->chainId1), &(d->resSeq1),
      &(d->iCode1), d->name2, &(d->altLoc2), d->resName2, &(d->chainId2),
      &(d->resSeq2), &(d->iCode2), d->sym1, d->sym2);
}

int link_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Link *d = &(data->d.link);
  return store_line(line, data->info, d->isblank,
      d->name1, d->altLoc1, d->resName1, d->chainId1, d->resSeq1,
      d->iCode1, d->name2, d->altLoc2, d->resName2, d->chainId2,
      d->resSeq2, d->iCode2, d->sym1, d->sym2);
}

int pdbrec_to_hydbnd(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Hydbnd *d = &(data->d.hydbnd);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      d->name1, &(d->altLoc1), d->resName1, &(d->chainId1), &(d->resSeq1),
      &(d->iCode1), d->nameH, &(d->altLocH), &(d->chainIdH),
      &(d->resSeqH), &(d->iCodeH), d->name2, &(d->altLoc2), d->resName2,
      &(d->chainId2), &(d->resSeq2), &(d->iCode2), d->sym1, d->sym2);
}

int hydbnd_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Hydbnd *d = &(data->d.hydbnd);
  return store_line(line, data->info, d->isblank,
      d->name1, d->altLoc1, d->resName1, d->chainId1, d->resSeq1,
      d->iCode1, d->nameH, d->altLocH, d->chainIdH,
      d->resSeqH, d->iCodeH, d->name2, d->altLoc2, d->resName2,
      d->chainId2, d->resSeq2, d->iCode2, d->sym1, d->sym2);
}

int pdbrec_to_sltbrg(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Sltbrg *d = &(data->d.sltbrg);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      d->atom1, &(d->altLoc1), d->resName1, &(d->chainId1), &(d->resSeq1),
      &(d->iCode1), d->atom2, &(d->altLoc2), d->resName2, &(d->chainId2),
      &(d->resSeq2), &(d->iCode2), d->sym1, d->sym2);
}

int sltbrg_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Sltbrg *d = &(data->d.sltbrg);
  return store_line(line, data->info, d->isblank,
      d->atom1, d->altLoc1, d->resName1, d->chainId1, d->resSeq1,
      d->iCode1, d->atom2, d->altLoc2, d->resName2, d->chainId2,
      d->resSeq2, d->iCode2, d->sym1, d->sym2);
}

int pdbrec_to_cispep(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Cispep *d = &(data->d.cispep);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->serNum), d->pep1, &(d->chainId1), &(d->seqNum1), &(d->iCode1),
      d->pep2, &(d->chainId2), &(d->seqNum2), &(d->iCode2), 
      &(d->modNum), &(d->measure));
}

int cispep_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Cispep *d = &(data->d.cispep);
  return store_line(line, data->info, d->isblank,
      d->serNum, d->pep1, d->chainId1, d->seqNum1, d->iCode1,
      d->pep2, d->chainId2, d->seqNum2, d->iCode2,
      d->modNum, d->measure);
}

int pdbrec_to_site(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Site *d = &(data->d.site);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->seqNum), d->siteId, &(d->numRes), d->resName1, &(d->chainId1),
      &(d->seq1), &(d->iCode1), d->resName2, &(d->chainId2), &(d->seq2),
      &(d->iCode2), d->resName3, &(d->chainId3), &(d->seq3), &(d->iCode3),
      d->resName4, &(d->chainId4), &(d->seq4), &(d->iCode4));
}

int site_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Site *d = &(data->d.site);
  return store_line(line, data->info, d->isblank,
      d->seqNum, d->siteId, d->numRes, d->resName1, d->chainId1,
      d->seq1, d->iCode1, d->resName2, d->chainId2, d->seq2,
      d->iCode2, d->resName3, d->chainId3, d->seq3, d->iCode3,
      d->resName4, d->chainId4, d->seq4, d->iCode4);
}

int pdbrec_to_cryst1(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Cryst1 *d = &(data->d.cryst1);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->a), &(d->b), &(d->c), &(d->alpha), &(d->beta), &(d->gamma),
      d->sGroup, &(d->z));
}

int cryst1_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Cryst1 *d = &(data->d.cryst1);
  return store_line(line, data->info, d->isblank,
      d->a, d->b, d->c, d->alpha, d->beta, d->gamma,
      d->sGroup, d->z);
}

int pdbrec_to_origx1(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Origx1 *d = &(data->d.origx1);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->o11), &(d->o12), &(d->o13), &(d->t1));
}

int origx1_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Origx1 *d = &(data->d.origx1);
  return store_line(line, data->info, d->isblank,
      d->o11, d->o12, d->o13, d->t1);
}

int pdbrec_to_origx2(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Origx2 *d = &(data->d.origx2);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->o21), &(d->o22), &(d->o23), &(d->t2));
}

int origx2_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Origx2 *d = &(data->d.origx2);
  return store_line(line, data->info, d->isblank,
      d->o21, d->o22, d->o23, d->t2);
}

int pdbrec_to_origx3(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Origx3 *d = &(data->d.origx3);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->o31), &(d->o32), &(d->o33), &(d->t3));
}

int origx3_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Origx3 *d = &(data->d.origx3);
  return store_line(line, data->info, d->isblank,
      d->o31, d->o32, d->o33, d->t3);
}

int pdbrec_to_scale1(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Scale1 *d = &(data->d.scale1);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->s11), &(d->s12), &(d->s13), &(d->u1));
}

int scale1_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Scale1 *d = &(data->d.scale1);
  return store_line(line, data->info, d->isblank,
      d->s11, d->s12, d->s13, d->u1);
}

int pdbrec_to_scale2(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Scale2 *d = &(data->d.scale2);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->s21), &(d->s22), &(d->s23), &(d->u2));
}

int scale2_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Scale2 *d = &(data->d.scale2);
  return store_line(line, data->info, d->isblank,
      d->s21, d->s22, d->s23, d->u2);
}

int pdbrec_to_scale3(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Scale3 *d = &(data->d.scale3);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->s31), &(d->s32), &(d->s33), &(d->u3));
}

int scale3_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Scale3 *d = &(data->d.scale3);
  return store_line(line, data->info, d->isblank,
      d->s31, d->s32, d->s33, d->u3);
}

int pdbrec_to_mtrix1(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Mtrix1 *d = &(data->d.mtrix1);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->serial), &(d->m11), &(d->m12), &(d->m13), &(d->v1), &(d->iGiven));
}

int mtrix1_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Mtrix1 *d = &(data->d.mtrix1);
  return store_line(line, data->info, d->isblank,
      d->serial, d->m11, d->m12, d->m13, d->v1, d->iGiven);
}

int pdbrec_to_mtrix2(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Mtrix2 *d = &(data->d.mtrix2);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->serial), &(d->m21), &(d->m22), &(d->m23), &(d->v2), &(d->iGiven));
}

int mtrix2_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Mtrix2 *d = &(data->d.mtrix2);
  return store_line(line, data->info, d->isblank,
      d->serial, d->m21, d->m22, d->m23, d->v2, d->iGiven);
}

int pdbrec_to_mtrix3(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Mtrix3 *d = &(data->d.mtrix3);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->serial), &(d->m31), &(d->m32), &(d->m33), &(d->v3), &(d->iGiven));
}

int mtrix3_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Mtrix3 *d = &(data->d.mtrix3);
  return store_line(line, data->info, d->isblank,
      d->serial, d->m31, d->m32, d->m33, d->v3, d->iGiven);
}

int pdbrec_to_tvect(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Tvect *d = &(data->d.tvect);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->serial), &(d->t1), &(d->t2), &(d->t3), d->text);
}

int tvect_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Tvect *d = &(data->d.tvect);
  return store_line(line, data->info, d->isblank,
      d->serial, d->t1, d->t2, d->t3, d->text);
}

int pdbrec_to_model(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Model *d = &(data->d.model);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->serial));
}

int model_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Model *d = &(data->d.model);
  return store_line(line, data->info, d->isblank,
      d->serial);
}

int pdbrec_to_atom(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Atom *d = &(data->d.atom);
  return get_data(p, d->mask, &(data->info), &(d->isblank), 
      &(d->serial), d->name, &(d->altLoc), d->resName, &(d->chainId),
      &(d->resSeq), &(d->iCode), &(d->x), &(d->y), &(d->z),
      &(d->occupancy), &(d->tempFactor), d->segId, d->element, d->charge);
}

int atom_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Atom *d = &(data->d.atom);
  return store_line(line, data->info, d->isblank,
      d->serial, d->name, d->altLoc, d->resName, d->chainId,
      d->resSeq, d->iCode, d->x, d->y, d->z,
      d->occupancy, d->tempFactor, d->segId, d->element, d->charge);
}

int pdbrec_to_sigatm(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Sigatm *d = &(data->d.sigatm);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->serial), d->name, &(d->altLoc), d->resName, &(d->chainId),
      &(d->resSeq), &(d->iCode), &(d->sigX), &(d->sigY), &(d->sigZ),
      &(d->sigOcc), &(d->sigTemp), d->segId, d->element, d->charge);
}

int sigatm_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Sigatm *d = &(data->d.sigatm);
  return store_line(line, data->info, d->isblank,
      d->serial, d->name, d->altLoc, d->resName, d->chainId,
      d->resSeq, d->iCode, d->sigX, d->sigY, d->sigZ,
      d->sigOcc, d->sigTemp, d->segId, d->element, d->charge);
}

int pdbrec_to_anisou(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Anisou *d = &(data->d.anisou);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->serial), d->name, &(d->altLoc), d->resName, &(d->chainId),
      &(d->resSeq), &(d->iCode), &(d->u11), &(d->u22), &(d->u33),
      &(d->u12), &(d->u13), &(d->u23), d->segId, d->element, d->charge);
}

int anisou_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Anisou *d = &(data->d.anisou);
  return store_line(line, data->info, d->isblank,
      d->serial, d->name, d->altLoc, d->resName, d->chainId,
      d->resSeq, d->iCode, d->u11, d->u22, d->u33,
      d->u12, d->u13, d->u23, d->segId, d->element, d->charge);
}

int pdbrec_to_siguij(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Siguij *d = &(data->d.siguij);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->serial), d->name, &(d->altLoc), d->resName, &(d->chainId),
      &(d->resSeq), &(d->iCode), &(d->sig11), &(d->sig22), &(d->sig33),
      &(d->sig12), &(d->sig13), &(d->sig23), d->segId, d->element, d->charge);
}

int siguij_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Siguij *d = &(data->d.siguij);
  return store_line(line, data->info, d->isblank,
      d->serial, d->name, d->altLoc, d->resName, d->chainId,
      d->resSeq, d->iCode, d->sig11, d->sig22, d->sig33,
      d->sig12, d->sig13, d->sig23, d->segId, d->element, d->charge);
}

int pdbrec_to_ter(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Ter *d = &(data->d.ter);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->serial), d->resName, &(d->chainId), &(d->resSeq), &(d->iCode));
}

int ter_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Ter *d = &(data->d.ter);
  return store_line(line, data->info, d->isblank,
      d->serial, d->resName, d->chainId, d->resSeq, d->iCode);
}

int pdbrec_to_hetatm(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Hetatm *d = &(data->d.hetatm);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->serial), d->name, &(d->altLoc), d->resName, &(d->chainId),
      &(d->resSeq), &(d->iCode), &(d->x), &(d->y), &(d->z),
      &(d->occupancy), &(d->tempFactor), d->segId, d->element, d->charge);
}

int hetatm_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Hetatm *d = &(data->d.hetatm);
  return store_line(line, data->info, d->isblank,
      d->serial, d->name, d->altLoc, d->resName, d->chainId,
      d->resSeq, d->iCode, d->x, d->y, d->z,
      d->occupancy, d->tempFactor, d->segId, d->element, d->charge);
}

int pdbrec_to_endmdl(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Endmdl *d = &(data->d.endmdl);
  return get_data(p, d->mask, &(data->info), &(d->isblank));
}

int endmdl_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Endmdl *d = &(data->d.endmdl);
  return store_line(line, data->info, d->isblank);
}

int pdbrec_to_conect(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Conect *d = &(data->d.conect);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->serial1), &(d->serial2), &(d->serial3), &(d->serial4),
      &(d->serial5), &(d->serial6), &(d->serial7), &(d->serial8),
      &(d->serial9), &(d->serial10), &(d->serial11));
}

int conect_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Conect *d = &(data->d.conect);
  return store_line(line, data->info, d->isblank,
      d->serial1, d->serial2, d->serial3, d->serial4,
      d->serial5, d->serial6, d->serial7, d->serial8,
      d->serial9, d->serial10, d->serial11);
}

int pdbrec_to_master(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_Master *d = &(data->d.master);
  return get_data(p, d->mask, &(data->info), &(d->isblank),
      &(d->numRemark), &(d->zero), &(d->numHet), &(d->numHelix),
      &(d->numSheet), &(d->numTurn), &(d->numSite), &(d->numXform),
      &(d->numCoord), &(d->numTer), &(d->numConect), &(d->numSeq));
}

int master_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_Master *d = &(data->d.master);
  return store_line(line, data->info, d->isblank,
      d->numRemark, d->zero, d->numHet, d->numHelix,
      d->numSheet, d->numTurn, d->numSite, d->numXform,
      d->numCoord, d->numTer, d->numConect, d->numSeq);
}

int pdbrec_to_end(const Pdbrec *p, Pdbrec_Data *data)
{
  Pdbrec_End *d = &(data->d.end);
  return get_data(p, d->mask, &(data->info), &(d->isblank));
}

int end_to_line(const Pdbrec_Data *data, char *line)
{
  const Pdbrec_End *d = &(data->d.end);
  return store_line(line, data->info, d->isblank);
}