#ident "@(#) dump_vidf.c 1.25 05/08/19 SwRI"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "SDDAS_types.h"
#include "libVIDF.h"

SDDAS_LONG      fd;


int main (int argc, SDDAS_CHAR * argv[])
{

    SDDAS_CHAR      carr[80000], car, smp_id;
    SDDAS_SHORT     sarr[5000], sar, num_bkgd_tbls;
    SDDAS_LONG      larr[5000], lar;
    int      i, j, rval;
    SDDAS_CHAR      n_qual;
    SDDAS_CHAR      cal_sets;
    SDDAS_CHAR      num_tbls;
    SDDAS_CHAR      num_consts;
    SDDAS_CHAR      status, bkgd_def;
    SDDAS_CHAR      pa_def, pmi_def, pot_src_def, spin_start_def, cs_def, cp_def;
    SDDAS_SHORT     pa_apps, sen;
    SDDAS_LONG      tbl_sca_sz;
    SDDAS_LONG      tbl_ele_sz;
    SDDAS_LONG      BASE;
    SDDAS_CHAR      tbl_type;
    SDDAS_CHAR      tbl_var;
    SDDAS_FLOAT     version, fvalue, farr[5000];

    char           *sptrs[20000];
    memset (sptrs, 0, sizeof (sptrs));
    if (argc != 2) {
        fprintf (stderr, "Usage: %s <new VIDF (.v3)/binary VIDF file>\n", argv[0]);
        exit (2);
    }

    if (InitializeVIDFFromFile (argv [1]) != ALL_OKAY) {
        fprintf (stderr, "Error opening %s!\n", argv [1]);
        exit (1);
    }

    ReadFromCurrentVIDF ((SDDAS_CHAR *) &version, _VERSION, 0, 0, -1);
    printf ("                  VIDF VERSION %.2f\n\n", version);
    ReadFromCurrentVIDF (&sptrs [0], _MISSION, 0, 0, -1);
    printf ("mission     : %.55s\n", sptrs [0]);
    ReadFromCurrentVIDF (&sptrs [0], _SPACECRAFT, 0, 0, -1);
    printf ("spacecraft  : %.55s\n", sptrs [0]);
    ReadFromCurrentVIDF (&sptrs [0], _EXP_DESC, 0, 0, -1);
    printf ("exp_desc    : %.55s\n", sptrs [0]);
    ReadFromCurrentVIDF (&sptrs [0], _INST_DESC, 0, 0, -1);
    printf ("inst_desc   : %.55s\n", sptrs [0]);
    ReadFromCurrentVIDF ((SDDAS_CHAR *) sptrs, _CONTACT, 0, 0, -1);
    i = 0;
    while (sptrs [i] != NULL) {
        printf ("contact L%d  : %.55s\n", i, sptrs[i]);
        i++;
    } 
    ReadFromCurrentVIDF ((SDDAS_CHAR *) & car, _NUM_COMNTS, 0, 0, -1);
    printf ("num_comnts  : %d\n", car);
    if (car > 0) {
        ReadFromCurrentVIDF (carr, _COMMENTS, 0, 0, -1);
        for (i = 0; i < car; ++i)
            printf ("comment %d  : %.55s\n", i, &carr[i * 80]);
    }
    ReadFromCurrentVIDF ((SDDAS_CHAR *) & sar, _DS_YEAR, 0, 0, -1);
    printf ("ds_year     : %d\n", sar);
    ReadFromCurrentVIDF ((SDDAS_CHAR *) & sar, _DS_DAY, 0, 0, -1);
    printf ("ds_day      : %d\n", sar);
    ReadFromCurrentVIDF ((SDDAS_CHAR *) & lar, _DS_MSEC, 0, 0, -1);
    printf ("ds_msec     : %ld\n", (long) lar);
    ReadFromCurrentVIDF ((SDDAS_CHAR *) & sar, _DS_USEC, 0, 0, -1);
    printf ("ds_usec     : %d\n", sar);
    ReadFromCurrentVIDF ((SDDAS_CHAR *) & sar, _DE_YEAR, 0, 0, -1);
    printf ("de_year     : %d\n", sar);
    ReadFromCurrentVIDF ((SDDAS_CHAR *) & sar, _DE_DAY, 0, 0, -1);
    printf ("de_day      : %d\n", sar);
    ReadFromCurrentVIDF ((SDDAS_CHAR *) & lar, _DE_MSEC, 0, 0, -1);
    printf ("de_msec     : %ld\n", (long) lar);
    ReadFromCurrentVIDF ((SDDAS_CHAR *) & sar, _DE_USEC, 0, 0, -1);
    printf ("de_usec     : %d\n", sar);
    ReadFromCurrentVIDF (&car, _DATA_LAT_UNITS, 0, 0, -1);
    printf ("data_lat_units   : %d\n", car);
    ReadFromCurrentVIDF (&car, _SWP_RESET_UNITS, 0, 0, -1);
    printf ("swp_reset_units  : %d\n", car);
    ReadFromCurrentVIDF (&car, _SEN_RESET_UNITS, 0, 0, -1);
    printf ("sen_reset_units  : %d\n", car);
    rval = ReadFromCurrentVIDF (&car, _HEADER_FORMAT, 0, 0, -1);
    if (rval == ALL_OKAY)
     {
       printf ("header_format  : %d\n", car);
       if (car == TENSOR_SINGLE_HEADER)
        {
          rval = ReadFromCurrentVIDF ((SDDAS_CHAR *) &sar, _TENSOR_RANK, 0, 0, -1);
          if (rval == ALL_OKAY)
            printf ("tensor_rank    : %d\n", sar);

          memset (sptrs, 0, sizeof (sptrs));
          rval = ReadFromCurrentVIDF ((SDDAS_CHAR *) sptrs, _TENSOR_DNAMES, 0, 0, -1);
          if (rval == ALL_OKAY)
           {
             for (i = 0; i < sar; ++i)
               printf ("dimension_name  %d : %.55s\n", i, sptrs[i]);
           }

          rval = ReadFromCurrentVIDF ((SDDAS_CHAR *) larr, _TENSOR_LENGTHS, 0, 0, -1);
          if (rval == ALL_OKAY)
           {
             for (i = 0; i < sar; ++i)
               printf ("dimension_length  %d : %ld\n", i, (long) larr[i]);
           }

          rval = ReadFromCurrentVIDF ((SDDAS_CHAR *) farr, _TENSOR_MIN_VALS, 0, 0, -1);
          if (rval == ALL_OKAY)
           {
             for (i = 0; i < sar; ++i)
               printf ("dimension_min  %d : %10.6e\n", i, farr[i]);
           }
          rval = ReadFromCurrentVIDF ((SDDAS_CHAR *) farr, _TENSOR_MAX_VALS, 0, 0, -1);
          if (rval == ALL_OKAY)
           {
             for (i = 0; i < sar; ++i)
               printf ("dimension_max  %d : %10.6e\n", i, farr[i]);
           }
        }
     }

    ReadFromCurrentVIDF (&smp_id, _SMP_ID, 0, 0, -1);
    printf ("smp_id      : %d\n", smp_id);

    ReadFromCurrentVIDF (&pa_def, _PA_DEFINED, 0, 0, -1);
    ReadFromCurrentVIDF (&car, _SEN_MODE, 0, 0, -1);
    printf ("sen_mode    : %d\n", car);
    ReadFromCurrentVIDF (&n_qual, _N_QUAL, 0, 0, -1);
    printf ("n_qual      : %d\n", n_qual);
    ReadFromCurrentVIDF (&cal_sets, _CAL_SETS, 0, 0, -1);
    printf ("cal_sets    : %d\n", cal_sets);
    ReadFromCurrentVIDF (&num_tbls, _NUM_TBLS, 0, 0, -1);
    printf ("num_tbls    : %d\n", num_tbls);
    ReadFromCurrentVIDF (&num_consts, _NUM_CONSTS, 0, 0, -1);
    printf ("num_consts  : %d\n", num_consts);
    ReadFromCurrentVIDF (&status, _STATUS, 0, 0, -1);
    printf ("status      : %d\n", status);
    ReadFromCurrentVIDF ((SDDAS_CHAR *) & sen, _SEN, 0, 0, -1);
    printf ("sen         : %d\n", sen);
    ReadFromCurrentVIDF ((SDDAS_CHAR *) & sar, _SWP_LEN, 0, 0, -1);
    printf ("swp_len     : %d\n", sar);

    /*  Applicable to scalar instruments only.    */

    if (smp_id == 2)
     {
       ReadFromCurrentVIDF ((SDDAS_CHAR *) &sar, _MAX_PACKING, 0, 0, -1);
       printf ("max_packing : %d\n", sar);
     }

    ReadFromCurrentVIDF ((SDDAS_CHAR *) & sar, _MAX_NSS, 0, 0, -1);
    printf ("max_nss     : %d\n", sar);
    ReadFromCurrentVIDF ((SDDAS_CHAR *) & lar, _DATA_LEN, 0, 0, -1);
    printf ("data_len    : %ld\n", (long) lar);
    ReadFromCurrentVIDF (&car, _FILL_FLG, 0, 0, -1);
    printf ("fill_flg    : %d\n", car);
    if (car == 1) {
        ReadFromCurrentVIDF ((SDDAS_CHAR *) & lar, _FILL, 0, 0, -1);
        printf ("fill        : %ld\n", (long) lar);
    }
    ReadFromCurrentVIDF (&car, _DA_METHOD, 0, 0, -1);
    printf ("da_method   : %d\n", car);
    rval = ReadFromCurrentVIDF (&car, _PHI_METHOD, 0, 0, -1);
    printf ("phi_method  : %d\n", car);
    ReadFromCurrentVIDF (&car, _NANO_DEFINED, 0, 0, -1);
    printf ("nano_defined  : %d\n", car);
    if (status > 0) {
        for (i = 0; i < status; ++i) {
            ReadFromCurrentVIDF (&sptrs [0], _STATUS_NAME, i, 0, 1);
            printf ("state_name  %d : %.55s\n", i, sptrs[0]);
        }
        ReadFromCurrentVIDF ((SDDAS_CHAR *) sarr, _STATES, 0, 0, -1);
        for (i = 0; i < status; ++i)
            printf ("states  %d : %d\n", i, sarr[i]);
    }
    if (sen > 0) {
        for (i = 0; i < sen; ++i) {
            ReadFromCurrentVIDF (&sptrs[0], _SEN_NAME, i, 0, 1);
            printf ("sen_name  %d : %.55s\n", i, sptrs[0]);
        }
    }
    if (cal_sets > 0) {
        for (i = 0; i < cal_sets; ++i) {
            ReadFromCurrentVIDF (&sptrs [0], _CAL_NAMES, i, 0, 1);
            printf ("cal_name  %d : %.55s\n", i, sptrs[0]);
        }
    }
    if (n_qual > 0) {
        ReadFromCurrentVIDF ((SDDAS_CHAR *) sptrs, _QUAL_NAME, 0, 0, -1);
        for (i = 0; i < n_qual; ++i) {
            printf ("qual_name  %d : %.55s\n", i, sptrs[i]);
        }
        fflush (stdout);
    }
    if (sen > 0) {
        ReadFromCurrentVIDF (carr, _D_TYPE, 0, 0, -1);
        for (i = 0; i < sen; ++i)
            printf ("d_type  %d : %d\n", i, carr[i]);
        fflush (stdout);

        ReadFromCurrentVIDF (carr, _TDW_LEN, 0, 0, -1);
        for (i = 0; i < sen; ++i)
            printf ("tdw_len  %d : %d\n", i, carr[i]);
        fflush (stdout);

        ReadFromCurrentVIDF (carr, _SEN_STATUS, 0, 0, -1);
        for (i = 0; i < sen; ++i)
            printf ("sen_status  %d : %d\n", i, carr[i]);
        fflush (stdout);

        ReadFromCurrentVIDF ((SDDAS_CHAR *) larr, _TIME_OFF, 0, 0, -1);
        for (i = 0; i < sen; ++i)
            printf ("time_off  %d : %ld\n", i, (long) larr[i]);
        fflush (stdout);

        ReadFromCurrentVIDF ((SDDAS_CHAR *) larr, _SPIN_TIME_OFF, 0, 0, -1);
        for (i = 0; i < sen; ++i)
            printf ("spin_time_off  %d : %ld\n", i, (long) larr[i]);
        fflush (stdout);
    }
    if (cal_sets > 0) {
        ReadFromCurrentVIDF ((SDDAS_CHAR *) sarr, _CAL_USE, 0, 0, -1);
        for (i = 0; i < cal_sets; ++i)
            printf ("cal_use    %d : %d\n", i, sarr[i]);

        ReadFromCurrentVIDF (carr, _CAL_WLEN, 0, 0, -1);
        for (i = 0; i < cal_sets; ++i)
            printf ("cal_wlen   %d : %d\n", i, carr[i]);

        ReadFromCurrentVIDF (carr, _CAL_TARGET, 0, 0, -1);
        for (i = 0; i < cal_sets; ++i)
            printf ("cal_target   %d : %d\n", i, carr[i]);

        ReadFromCurrentVIDF (carr, _CAL_SCOPE, 0, 0, -1);
        for (i = 0; i < cal_sets; ++i)
            printf ("cal_scope    %d : %d\n", i, carr[i]);

        ReadFromCurrentVIDF (carr, _CAL_D_TYPE, 0, 0, -1);
        for (i = 0; i < cal_sets; ++i)
            printf ("cal_d_type  %d : %d\n", i, carr[i]);
    }
    fflush (stdout);

    if (pa_def == 1) {
        ReadFromCurrentVIDF ((SDDAS_CHAR *) & sar, _PA_FORMAT, 0, 0, -1);
        printf ("pa_format  : %d\n", sar);

        /*  Look at value for pa_format to see if other fields are defined. */

        if (sar == 1)
         {
           ReadFromCurrentVIDF (&sptrs [0], _PA_PROJECT, 0, 0, -1);
           printf ("pa_project  : %.55s\n", sptrs [0]);
           ReadFromCurrentVIDF (&sptrs [0], _PA_MISSION, 0, 0, -1);
           printf ("pa_mission  : %.55s\n", sptrs [0]);
           ReadFromCurrentVIDF (&sptrs [0], _PA_EXPER, 0, 0, -1);
           printf ("pa_exper    : %.55s\n", sptrs [0]);
           ReadFromCurrentVIDF (&sptrs [0], _PA_INST, 0, 0, -1);
           printf ("pa_inst     : %.55s\n", sptrs [0]);
           ReadFromCurrentVIDF (&sptrs [0], _PA_VINST, 0, 0, -1);
           printf ("pa_vinst    : %.55s\n", sptrs [0]);
           ReadFromCurrentVIDF ((SDDAS_CHAR *) sarr, _PA_BXBYBZ, 0, 0, -1);
           printf ("pa_bxbybz   : %d : %d : %d\n", sarr[0], sarr[1], sarr[2]);
           ReadFromCurrentVIDF ((SDDAS_CHAR *) & pa_apps, _PA_APPS, 0, 0, -1);
           printf ("pa_apps     : %d\n", pa_apps);
           ReadFromCurrentVIDF ((SDDAS_CHAR *) sarr, _PA_TBLS, 0, 0, -1);
           for (i = 0; i < pa_apps; ++i)
               printf ("pa_tbls[%02d] : %d\n", i, sarr[i]);
           ReadFromCurrentVIDF ((SDDAS_CHAR *) larr, _PA_OPS, 0, 0, -1);
           for (i = 0; i < pa_apps; ++i)
               printf ("pa_ops[%02d]  : %ld\n", i, (long) larr[i]);
        }
    }
    fflush (stdout);

    ReadFromCurrentVIDF ((SDDAS_CHAR *) &sar, _ORBITING_BODY, 0, 0, -1);
    printf ("orbiting_body : %d\n", sar);
    ReadFromCurrentVIDF ((SDDAS_CHAR *) &fvalue, _REF_SEN_DELAY, 0, 0, -1);
    printf ("reference sensor delay : %10.6e\n", fvalue);
    ReadFromCurrentVIDF ((SDDAS_CHAR *) &sar, _REF_SEN_DELAY_UNIT, 0, 0, -1);
    printf ("reference sensor delay unit : %d\n", sar);

    ReadFromCurrentVIDF (&cs_def, _COORD_SYSTEM_DEFINED, 0, 0, -1);
    printf ("coordinate_system_defined  : %d\n", cs_def);
    if (cs_def == 1) {
       ReadFromCurrentVIDF (&sptrs [0], _COORD_SYSTEM, 0, 0, -1);
       printf ("coordinate_system  : %.55s\n", sptrs [0]);

       ReadFromCurrentVIDF (&pmi_def, _PMI_DEFINED, 0, 0, -1);
       printf ("pmi_defined  : %d\n", pmi_def);
       if (pmi_def == 1) {
           ReadFromCurrentVIDF ((SDDAS_CHAR *) &sar, _PMI_FORMAT, 0, 0, -1);
           printf ("pmi_format  : %d\n", sar);
   
           /*  Look at value for pmi_format to see if other fields are defined. */
   
           if (sar == 1)
            {
              ReadFromCurrentVIDF ((SDDAS_CHAR *) &sar, _NUM_PMI_ANGLES, 0, 0, -1);
              printf ("num_pmi_angles  : %d\n", sar);
   
              ReadFromCurrentVIDF (&sptrs [0], _PMI_PROJECT, 0, 0, -1);
              printf ("pmi_project  : %.55s\n", sptrs [0]);
              ReadFromCurrentVIDF (&sptrs [0], _PMI_MISSION, 0, 0, -1);
              printf ("pmi_mission  : %.55s\n", sptrs [0]);
              ReadFromCurrentVIDF (&sptrs [0], _PMI_EXPER, 0, 0, -1);
              printf ("pmi_exper    : %.55s\n", sptrs [0]);
              ReadFromCurrentVIDF (&sptrs [0], _PMI_INST, 0, 0, -1);
              printf ("pmi_inst     : %.55s\n", sptrs [0]);
              ReadFromCurrentVIDF (&sptrs [0], _PMI_VINST, 0, 0, -1);
              printf ("pmi_vinst    : %.55s\n", sptrs [0]);
              ReadFromCurrentVIDF ((SDDAS_CHAR *) sarr, _PMI_SENSORS, 0, 0, -1);
              for (i = 0; i < sar; ++i)
                 printf ("pmi_sensor[%d]   : %d\n", i, sarr[i]);
              ReadFromCurrentVIDF ((SDDAS_CHAR *) sarr, _PMI_ROTATION_AXIS, 0, 0, -1);
              for (i = 0; i < sar; ++i)
                 printf ("pmi_rotation_axis[%d]   : %d\n", i, sarr[i]);
              ReadFromCurrentVIDF ((SDDAS_CHAR *) &pa_apps, _PMI_APPS, 0, 0, -1);
              printf ("pmi_apps     : %d\n", pa_apps);
              ReadFromCurrentVIDF ((SDDAS_CHAR *) sarr, _PMI_TBLS, 0, 0, -1);
              for (i = 0; i < pa_apps; ++i)
                  printf ("pmi_tbls[%d] : %d\n", i, sarr[i]);
              ReadFromCurrentVIDF ((SDDAS_CHAR *) larr, _PMI_OPS, 0, 0, -1);
              for (i = 0; i < pa_apps; ++i)
                  printf ("pmi_ops[%d]  : %ld\n", i, (long) larr[i]);
          }
         else if (sar == 0)
          {
            ReadFromCurrentVIDF ((SDDAS_CHAR *) &sar, _NUM_PMI_ANGLES, 0, 0, -1);
            printf ("num_pmi_angles  : %d\n", sar);
          }
       }

       ReadFromCurrentVIDF (&cp_def, _CP_DEFINED, 0, 0, -1);
       printf ("celestial position defined  : %d\n", cp_def);
       if (cp_def == 1) {
           ReadFromCurrentVIDF ((SDDAS_CHAR *) &sar, _CP_FORMAT, 0, 0, -1);
           printf ("cp_format  : %d\n", sar);
   
           /*  Look at value for pmi_format to see if other fields are defined. */
           if (sar == 1)
            {
              ReadFromCurrentVIDF (&sptrs [0], _CP_PROJECT, 0, 0, -1);
              printf ("cp_project  : %.55s\n", sptrs [0]);
              ReadFromCurrentVIDF (&sptrs [0], _CP_MISSION, 0, 0, -1);
              printf ("cp_mission  : %.55s\n", sptrs [0]);
              ReadFromCurrentVIDF (&sptrs [0], _CP_EXPER, 0, 0, -1);
              printf ("cp_exper    : %.55s\n", sptrs [0]);
              ReadFromCurrentVIDF (&sptrs [0], _CP_INST, 0, 0, -1);
              printf ("cp_inst     : %.55s\n", sptrs [0]);
              ReadFromCurrentVIDF (&sptrs [0], _CP_VINST, 0, 0, -1);
              printf ("cp_vinst    : %.55s\n", sptrs [0]);

              ReadFromCurrentVIDF ((SDDAS_CHAR *) &sar, _CP_DECLINATION_SENSOR, 0, 0, -1);
              printf ("cp_declination_sensor   : %d\n", sar);
              ReadFromCurrentVIDF ((SDDAS_CHAR *) &pa_apps, _CP_DECLINATION_APPS, 0, 0, -1);
              printf ("cp_declination_apps     : %d\n", pa_apps);
              ReadFromCurrentVIDF ((SDDAS_CHAR *) sarr, _CP_DECLINATION_TBLS, 0, 0, -1);
              for (i = 0; i < pa_apps; ++i)
                  printf ("cp_declination_tbls[%d] : %d\n", i, sarr[i]);
              ReadFromCurrentVIDF ((SDDAS_CHAR *) larr, _CP_DECLINATION_OPS, 0, 0, -1);
              for (i = 0; i < pa_apps; ++i)
                  printf ("cp_declination_ops[%d]  : %ld\n", i, (long) larr[i]);

              ReadFromCurrentVIDF ((SDDAS_CHAR *) &sar, _CP_RT_ASCENSION_SENSOR, 0, 0, -1);
              printf ("cp_rt_ascension_sensor   : %d\n", sar);
              ReadFromCurrentVIDF ((SDDAS_CHAR *) &pa_apps, _CP_RT_ASCENSION_APPS, 0, 0, -1);
              printf ("cp_rt_ascension_apps     : %d\n", pa_apps);
              ReadFromCurrentVIDF ((SDDAS_CHAR *) sarr, _CP_RT_ASCENSION_TBLS, 0, 0, -1);
              for (i = 0; i < pa_apps; ++i)
                  printf ("cp_rt_ascension_tbls[%d] : %d\n", i, sarr[i]);
              ReadFromCurrentVIDF ((SDDAS_CHAR *) larr, _CP_RT_ASCENSION_OPS, 0, 0, -1);
              for (i = 0; i < pa_apps; ++i)
                  printf ("cp_rt_ascension_ops[%d]  : %ld\n", i, (long) larr[i]);
           }
       }
    }
    fflush (stdout);

    ReadFromCurrentVIDF (&pot_src_def, _POT_SRC_DEFINED, 0, 0, -1);
    printf ("potential_src_defined  : %d\n", pot_src_def);
    if (pot_src_def == 1) {
        ReadFromCurrentVIDF ((SDDAS_CHAR *) &sar, _POT_SRC_FORMAT, 0, 0, -1);
        printf ("potential_src_format   : %d\n", sar);

        /*  Look at value for format to see if other fields are defined. */

        if (sar == 1)
         {
           ReadFromCurrentVIDF (&sptrs [0], _POT_SRC_PROJECT, 0, 0, -1);
           printf ("potential_src_project  : %.55s\n", sptrs [0]);
           ReadFromCurrentVIDF (&sptrs [0], _POT_SRC_MISSION, 0, 0, -1);
           printf ("potential_src_mission  : %.55s\n", sptrs [0]);
           ReadFromCurrentVIDF (&sptrs [0], _POT_SRC_EXPER, 0, 0, -1);
           printf ("potential_src_exper    : %.55s\n", sptrs [0]);
           ReadFromCurrentVIDF (&sptrs [0], _POT_SRC_INST, 0, 0, -1);
           printf ("potential_src_inst     : %.55s\n", sptrs [0]);
           ReadFromCurrentVIDF (&sptrs [0], _POT_SRC_VINST, 0, 0, -1);
           printf ("potential_src_vinst    : %.55s\n", sptrs [0]);

           ReadFromCurrentVIDF ((SDDAS_CHAR *) &sar, _POT_SRC_SENSOR, 0, 0, -1);
           printf ("potential_src_sensor   : %d\n", sar);
           ReadFromCurrentVIDF ((SDDAS_CHAR *) &pa_apps, _POT_SRC_APPS, 0, 0, -1);
           printf ("potential_src_apps     : %d\n", pa_apps);
           ReadFromCurrentVIDF ((SDDAS_CHAR *) sarr, _POT_SRC_TBLS, 0, 0, -1);
           for (i = 0; i < pa_apps; ++i)
               printf ("potential_src_tbls[%d]  : %d\n", i, sarr[i]);
           ReadFromCurrentVIDF ((SDDAS_CHAR *) larr, _POT_SRC_OPS, 0, 0, -1);
           for (i = 0; i < pa_apps; ++i)
               printf ("potential_src_ops[%d]   : %ld\n", i, (long) larr[i]);

           fvalue = -99999;
           ReadFromCurrentVIDF ((SDDAS_CHAR *) &fvalue, _POT_CONSTANT_VAL, 0, 0, -1);
           printf ("potential_constant_value   : %10.6e\n", fvalue);
       }
      else if (sar == 0)
       {
           fvalue = -99999;
           ReadFromCurrentVIDF ((SDDAS_CHAR *) &fvalue, _POT_CONSTANT_VAL, 0, 0, -1);
           printf ("potential_constant_value   : %10.6e\n", fvalue);
       }
    }
    fflush (stdout);

    ReadFromCurrentVIDF (&spin_start_def, _START_SPIN_DEFINED, 0, 0, -1);
    printf ("start_of_spin_defined  : %d\n", spin_start_def);
    if (spin_start_def == 1) {
           ReadFromCurrentVIDF (&sptrs [0], _START_SPIN_PROJECT, 0, 0, -1);
           printf ("spin_start_project  : %.55s\n", sptrs [0]);
           ReadFromCurrentVIDF (&sptrs [0], _START_SPIN_MISSION, 0, 0, -1);
           printf ("spin_start_mission  : %.55s\n", sptrs [0]);
           ReadFromCurrentVIDF (&sptrs [0], _START_SPIN_EXPER, 0, 0, -1);
           printf ("spin_start_exper    : %.55s\n", sptrs [0]);
           ReadFromCurrentVIDF (&sptrs [0], _START_SPIN_INST, 0, 0, -1);
           printf ("spin_start_inst     : %.55s\n", sptrs [0]);
           ReadFromCurrentVIDF (&sptrs [0], _START_SPIN_VINST, 0, 0, -1);
           printf ("spin_start_vinst    : %.55s\n", sptrs [0]);

           ReadFromCurrentVIDF ((SDDAS_CHAR *) &sar, _START_SPIN_SENSOR, 0, 0, -1);
           printf ("spin_start_sensor   : %d\n", sar);
           ReadFromCurrentVIDF ((SDDAS_CHAR *) &lar, _START_SPIN_MSEC_ADJ, 0, 0, -1);
           printf ("spin_start_msec_adj   : %ld\n", (long) lar);
           ReadFromCurrentVIDF ((SDDAS_CHAR *) &lar, _START_SPIN_NSEC_ADJ, 0, 0, -1);
           printf ("spin_start_nsec_adj   : %ld\n", (long) lar);
    }
    fflush (stdout);

    ReadFromCurrentVIDF (&bkgd_def, _BKGD_DEFINED, 0, 0, -1);
    printf ("background_defined  : %d\n", bkgd_def);
    if (bkgd_def == 1) {
        ReadFromCurrentVIDF ((SDDAS_CHAR *) &sar, _BKGD_FORMAT, 0, 0, -1);
        printf ("background_format   : %d\n", sar);

        /*  Look at value for format to see if other fields are defined. */

        if (sar == 1)
         {
           ReadFromCurrentVIDF (&sptrs [0], _BKGD_PROJECT, 0, 0, -1);
           printf ("background_project  : %.55s\n", sptrs [0]);
           ReadFromCurrentVIDF (&sptrs [0], _BKGD_MISSION, 0, 0, -1);
           printf ("background_mission  : %.55s\n", sptrs [0]);
           ReadFromCurrentVIDF (&sptrs [0], _BKGD_EXPER, 0, 0, -1);
           printf ("background_exper    : %.55s\n", sptrs [0]);
           ReadFromCurrentVIDF (&sptrs [0], _BKGD_INST, 0, 0, -1);
           printf ("background_inst     : %.55s\n", sptrs [0]);
           ReadFromCurrentVIDF (&sptrs [0], _BKGD_VINST, 0, 0, -1);
           printf ("background_vinst    : %.55s\n", sptrs [0]);
           ReadFromCurrentVIDF ((SDDAS_CHAR *) sarr, _BKGD_SENSORS, 0, 0, -1);
           for (i = 0; i < sen; ++i)
             printf ("background_sensor[%d]   : %d\n", i, sarr[i]);

           num_bkgd_tbls = 0;
           ReadFromCurrentVIDF ((SDDAS_CHAR *) sarr, _BKGD_APPS, 0, 0, -1);
           for (i = 0; i < sen; ++i) {
             num_bkgd_tbls += sarr[i];
             printf ("background_apps[%d]     : %d\n", i, sarr[i]);
           }

           ReadFromCurrentVIDF ((SDDAS_CHAR *) sarr, _BKGD_TBLS, 0, 0, -1);
           for (i = 0; i < num_bkgd_tbls; ++i)
               printf ("background_tbls[%d]  : %d\n", i, sarr[i]);
           ReadFromCurrentVIDF ((SDDAS_CHAR *) larr, _BKGD_OPS, 0, 0, -1);
           for (i = 0; i < num_bkgd_tbls; ++i)
               printf ("background_ops[%d]   : %ld\n", i, (long) larr[i]);
       }
    }
    fflush (stdout);

    for (j = 0; j < num_tbls; ++j) {
        printf ("\n                         DATA FOR TABLE %d\n\n", j);
        ReadFromCurrentVIDF ((SDDAS_CHAR *) & tbl_sca_sz, _TBL_SCA_SZ, j, 0, -1);
        printf ("tbl_sca_sz  : %ld\n", (long) tbl_sca_sz);
        ReadFromCurrentVIDF ((SDDAS_CHAR *) & tbl_ele_sz, _TBL_ELE_SZ, j, 0, -1);
        printf ("tbl_ele_sz  : %ld\n", (long) tbl_ele_sz);
        ReadFromCurrentVIDF (&tbl_type, _TBL_TYPE, j, 0, -1);
        printf ("tbl_type  : %d\n", tbl_type);
        ReadFromCurrentVIDF ((SDDAS_CHAR *) & sar, _TBL_DESC_LEN, j, 0, -1);
        printf ("tbl_desc_len  : %d\n", sar);
        if (sar > 0) {
            ReadFromCurrentVIDF (carr, _TBL_DESC, j, 0, -1);
            for (i = 0; i < sar; ++i)
                printf ("comment %d  : %.55s\n", i, &carr[i * 80]);
        }
        ReadFromCurrentVIDF (&tbl_var, _TBL_VAR, j, 0, -1);
        printf ("tbl_var  : %d\n", tbl_var);
        ReadFromCurrentVIDF (&car, _TBL_EXPAND, j, 0, -1);
        printf ("tbl_expand : %d\n", car);

        ReadFromCurrentVIDF ((SDDAS_CHAR *) & lar, _CRIT_ACT_SZ, j, 0, -1);
        printf ("crit_action : %ld\n", (long) lar);

        BASE = (tbl_var == 4) ? status : sen;
        if (BASE > 0 && lar > 0) {
            ReadFromCurrentVIDF (carr, _CRIT_STATUS, j, 0, -1);
            printf ("\ncrit_status:");
            for (i = 0; i < BASE; ++i) {
                if (i % 5 == 0)
                    printf ("\n          ");
                printf (" %10d ", carr[i]);
            }

            ReadFromCurrentVIDF ((SDDAS_CHAR *) sarr, _CRIT_OFF, j, 0, -1);
            printf ("\ncrit_off:");
            for (i = 0; i < BASE; ++i) {
                if (i % 5 == 0)
                    printf ("\n          ");
                printf (" %10d ", sarr[i]);
            }

        }
        if (lar > 0) {
            ReadFromCurrentVIDF ((SDDAS_CHAR *) larr, _CRIT_ACTION, j, 0, -1);
            printf ("\ncrit_action");
            for (i = 0; i < lar; ++i) {
                if (i % 5 == 0)
                    printf ("\n          ");
                printf (" %10ld ", (long) larr[i]);
            }
        }
        if (BASE > 0) {
            ReadFromCurrentVIDF (carr, _TBL_FMT, j, 0, -1);
            printf ("\ntbl_fmt:");
            for (i = 0; i < BASE; ++i) {
                if (i % 5 == 0)
                    printf ("\n          ");
                printf (" %10d ", carr[i]);
            }
        }
        if (BASE > 0) {
            ReadFromCurrentVIDF ((SDDAS_CHAR *) larr, _TBL_OFF, j, 0, -1);
            printf ("\ntbl_off");
            for (i = 0; i < BASE; ++i) {
                if (i % 5 == 0)
                    printf ("\n          ");
                printf (" %10ld ", (long) larr[i]);
            }
        }
        if (tbl_sca_sz < 0)
            tbl_sca_sz = -tbl_sca_sz;
        if (tbl_sca_sz > 0) {
            ReadFromCurrentVIDF (carr, _TBL_SCA, j, 0, -1);
            printf ("\ntbl_sca");
            for (i = 0; i < tbl_sca_sz; ++i) {
                if (i % 5 == 0)
                    printf ("\n          ");
                printf (" %10d ", carr[i]);
            }
        }
        if (tbl_ele_sz > 0) {
            if (tbl_type != 1) {
                ReadFromCurrentVIDF ((SDDAS_CHAR *) larr, _TBL, j, 0, -1);
                printf ("\ntbl");
                for (i = 0; i < tbl_ele_sz; ++i) {
                    if (i % 5 == 0)
                        printf ("\n          ");
                    printf (" %10ld ", (long) larr[i]);
                }
            } else {
                printf ("\ntbl\n");
                ReadFromCurrentVIDF ((SDDAS_CHAR *) sptrs, _TBL, j, 0, -1);
                for (i = 0; i < tbl_ele_sz; ++i) {
                    printf ("      Entry %03d     %.21s\n", i, sptrs [i]);
                }
            }
            printf ("\n");
        }
    }
    for (j = 0; j < num_consts; ++j) {
        printf ("\n                         DATA FOR CONSTANT %d\n\n", j);
        ReadFromCurrentVIDF (&car, _CONST_ID, j, 0, -1);
        printf ("const_id  : %d\n", car);
        ReadFromCurrentVIDF ((SDDAS_CHAR *) & sar, _CONST_DESC_LEN, j, 0, -1);
        printf ("tbl_desc_len  : %d\n", sar);
        if (sar > 0) {
            ReadFromCurrentVIDF (carr, _CONST_DESC, j, 0, -1);
            for (i = 0; i < sar; ++i)
                printf ("comment %d  : %.55s\n", i, &carr[i * 80]);
        }
        if (sen > 0) {
            ReadFromCurrentVIDF (carr, _CONST_SCA, j, 0, -1);
            printf ("\nconst_sca");
            for (i = 0; i < sen; ++i) {
                if (i % 5 == 0)
                    printf ("\n          ");
                printf (" %10d ", carr[i]);
            }
        }
        if (sen > 0) {
            ReadFromCurrentVIDF ((SDDAS_CHAR *) larr, _VIDF_CONST, j, 0, -1);
            printf ("\nconst");
            for (i = 0; i < sen; ++i) {
                if (i % 5 == 0)
                    printf ("\n          ");
                printf (" %10ld ", (long) larr[i]);
            }
        }
        printf ("\n");
    }
   
    CloseVIDF ();
    return (0);
}