libstdf: stdf2xtdf.c

00001 
00004 /*
00005  * Copyright (C) 2004-2006 Mike Frysinger <vapier@gmail.com>
00006  * Released under the BSD license.  For more information,
00007  * please see: http://opensource.org/licenses/bsd-license.php
00008  *
00009  * $Header: /cvsroot/freestdf/libstdf/examples/stdf2xtdf.c,v 1.13 2005/12/08 04:07:43 vapier Exp $
00010  */
00011 
00012 #include <libstdf.h>
00013 
00014 #define print_fmt(n,f,v) printf("\t<" n " value=" f "/>\n", v)
00015 #define print_int(n,i) print_fmt(n, "%i", i)
00016 #define print_str(n,s) \
00017     do { \
00018         if (*s) \
00019             print_fmt(n, "\"%s\"", s+1); \
00020     } while (0)
00021 #define print_chr(n,c) print_fmt(n, "'%c'", c)
00022 #define print_tim(n,d) print_int(n,d)
00023 #define print_hex(n,h) print_fmt(n, "%X", h)
00024 #define print_rel(n,r) print_fmt(n, "%f", r)
00025 
00026 #define print_x(xFunc, xType, format) \
00027     void xFunc(char *n, xType u, int c) \
00028     { \
00029         int i; \
00030         printf("\t<%s value='", n); \
00031         for (i=0; i<c; ++i) { \
00032             printf(format, u[i]); \
00033             if (i+1 < c) printf(","); \
00034         } \
00035         printf("'/>\n"); \
00036     }
00037 print_x(print_xU1, dtc_xU1, "%i")
00038 print_x(print_xU2, dtc_xU2, "%i")
00039 print_x(print_xR4, dtc_xR4, "%f")
00040 
00041 void print_xN1(char *member, dtc_xN1 xN1, dtc_U2 c)
00042 {
00043     dtc_N1 *n = xN1;
00044     printf("\t<%s value='", member);
00045     while (c > 0) {
00046         if (c > 1) {
00047             printf("%X,%X", ((*n) & 0xF0) >> 4, (*n) & 0x0F);
00048             c -= 2;
00049             if (c) printf(",");
00050         } else {
00051             printf("%X", ((*n) & 0xF0) >> 4);
00052             break;
00053         }
00054         ++n;
00055     }
00056     printf("'/>\n");
00057 }
00058 
00059 void print_Vn(char *n, dtc_Vn v, int c)
00060 {
00061     int i;
00062     --c;
00063     printf("\t<%s>\n", n);
00064     for (i=0; i<=c; ++i) {
00065         printf("\t\t<%s value='", stdf_get_Vn_name(v[i].type));
00066         switch (v[i].type) {
00067             case GDR_B0: printf("(pad)"); break;
00068             case GDR_U1: printf("%i", *((dtc_U1*)v[i].data)); break;
00069             case GDR_U2: printf("%i", *((dtc_U2*)v[i].data)); break;
00070             case GDR_U4: printf("%i", *((dtc_U4*)v[i].data)); break;
00071             case GDR_I1: printf("%i", *((dtc_I1*)v[i].data)); break;
00072             case GDR_I2: printf("%i", *((dtc_I2*)v[i].data)); break;
00073             case GDR_I4: printf("%i", *((dtc_I4*)v[i].data)); break;
00074             case GDR_R4: printf("%f", *((dtc_R4*)v[i].data)); break;
00075             case GDR_R8: printf("%f", *((dtc_R8*)v[i].data)); break;
00076             case GDR_Cn: {
00077                 dtc_Cn Cn = *((dtc_Cn*)v[i].data);
00078                 printf("%s", (*Cn ? Cn+1 : "(null"));
00079                 break;
00080             }
00081             case GDR_Bn: printf("[??]"); break;
00082             case GDR_Dn: printf("[??]"); break;
00083             case GDR_N1: printf("%X", *((dtc_N1*)v[i].data)); break;
00084         }
00085         printf("'/>\n");
00086     }
00087     printf("\t</%s>\n", n);
00088 }
00089 
00090 void print_Bn(char *n, dtc_Bn b)
00091 {
00092     int i;
00093     printf("\t<%s value='", n);
00094     for (i=1; i<=*b; ++i)
00095         printf("%X", *(b+i));
00096     printf("'/>\n");
00097 }
00098 
00099 void print_Dn(char *n, dtc_Dn d)
00100 {
00101     int i;
00102     dtc_U2 *num_bits = (dtc_U2*)d, len;
00103     len = *num_bits / 8;
00104     if (*num_bits % 8) ++len;
00105     printf("\t<%s value='", n);
00106     for (i=2; i<len; ++i)
00107         printf("%X", *(d+i));
00108     printf("'/>\n");
00109 }
00110 
00111 #define print_UNK(n) \
00112     do { \
00113         fprintf(stderr, "******************************************\n"); \
00114         fprintf(stderr, "This field (" n ") has not been tested!\n"); \
00115         fprintf(stderr, "Please consider sending this file to\n"); \
00116         fprintf(stderr, "vapier@gmail.com to help out the\n"); \
00117         fprintf(stderr, "FreeSTDF project and make sure this code\n"); \
00118         fprintf(stderr, "works exactly the way it should!\n"); \
00119         fprintf(stderr, "******************************************\n"); \
00120     } while (0)
00121 
00122 int main(int argc, char *argv[])
00123 {
00124     stdf_file *f;
00125     char *recname;
00126     rec_unknown *rec;
00127     int i;
00128     dtc_U4 stdf_ver;
00129 
00130     if (argc <= 1) {
00131         printf("Need some files to open!\n");
00132         return EXIT_FAILURE;
00133     }
00134 
00135 printf("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
00136        "<!DOCTYPE guide SYSTEM \"http://freestdf.sourceforge.net/specs/xtdf.dtd\">\n");
00137 
00138 for (i=1; i<argc; ++i) {
00139     f = stdf_open(argv[i]);
00140     if (!f) {
00141         perror("Could not open file");
00142         continue;
00143     }
00144     stdf_get_setting(f, STDF_SETTING_VERSION, &stdf_ver);
00145 
00146     printf("<stdf source=\"%s\">\n", argv[i]);
00147     while ((rec=stdf_read_record(f)) != NULL) {
00148         recname = stdf_get_rec_name(rec->header.REC_TYP, rec->header.REC_SUB);
00149         if (HEAD_TO_REC(rec->header) != REC_UNKNOWN)
00150             printf("<%s>\n", recname);
00151         switch (HEAD_TO_REC(rec->header)) {
00152             case REC_FAR: {
00153                 rec_far *far = (rec_far*)rec;
00154                 print_int("CPU_TYPE", far->CPU_TYPE);
00155                 print_int("STDF_VER", far->STDF_VER);
00156                 break;
00157             }
00158             case REC_ATR: {
00159                 rec_atr *atr = (rec_atr*)rec;
00160                 print_tim("MOD_TIM", atr->MOD_TIM);
00161                 print_str("CMD_LINE", atr->CMD_LINE);
00162                 break;
00163             }
00164             case REC_MIR: {
00165                 rec_mir *mir = (rec_mir*)rec;
00166 #ifdef STDF_VER3
00167                 if (stdf_ver == 4) {
00168 #endif
00169                 print_tim("SETUP_T", mir->SETUP_T);
00170                 print_tim("START_T", mir->START_T);
00171                 print_int("STAT_NUM", mir->STAT_NUM);
00172                 print_chr("MODE_COD", mir->MODE_COD);
00173                 print_chr("RTST_COD", mir->RTST_COD);
00174                 print_chr("PROT_COD", mir->PROT_COD);
00175                 print_int("BURN_TIM", mir->BURN_TIM);
00176                 print_chr("CMOD_COD", mir->CMOD_COD);
00177                 print_str("LOT_ID", mir->LOT_ID);
00178                 print_str("PART_TYP", mir->PART_TYP);
00179                 print_str("NODE_NAM", mir->NODE_NAM);
00180                 print_str("TSTR_TYP", mir->TSTR_TYP);
00181                 print_str("JOB_NAM", mir->JOB_NAM);
00182                 print_str("JOB_REV", mir->JOB_REV);
00183                 print_str("SBLOT_ID", mir->SBLOT_ID);
00184                 print_str("OPER_NAM", mir->OPER_NAM);
00185                 print_str("EXEC_TYP", mir->EXEC_TYP);
00186                 print_str("EXEC_VER", mir->EXEC_VER);
00187                 print_str("TEST_COD", mir->TEST_COD);
00188                 print_str("TST_TEMP", mir->TST_TEMP);
00189                 print_str("USER_TXT", mir->USER_TXT);
00190                 print_str("AUX_FILE", mir->AUX_FILE);
00191                 print_str("PKG_TYP", mir->PKG_TYP);
00192                 print_str("FAMILY_ID", mir->FAMILY_ID);
00193                 print_str("DATE_COD", mir->DATE_COD);
00194                 print_str("FACIL_ID", mir->FACIL_ID);
00195                 print_str("FLOOR_ID", mir->FLOOR_ID);
00196                 print_str("PROC_ID", mir->PROC_ID);
00197                 print_str("OPER_FRQ", mir->OPER_FRQ);
00198                 print_str("SPEC_NAM", mir->SPEC_NAM);
00199                 print_str("SPEC_VER", mir->SPEC_VER);
00200                 print_str("FLOW_ID", mir->FLOW_ID);
00201                 print_str("SETUP_ID", mir->SETUP_ID);
00202                 print_str("DSGN_REV", mir->DSGN_REV);
00203                 print_str("ENG_ID", mir->ENG_ID);
00204                 print_str("ROM_COD", mir->ROM_COD);
00205                 print_str("SERL_NUM", mir->SERL_NUM);
00206                 print_str("SUPR_NAM", mir->SUPR_NAM);
00207 #ifdef STDF_VER3
00208                 } else {
00209                 print_int("CPU_TYPE", mir->CPU_TYPE);
00210                 print_int("STDF_VER", mir->STDF_VER);
00211                 print_chr("MODE_COD", mir->MODE_COD);
00212                 print_int("STAT_NUM", mir->STAT_NUM);
00213                 print_str("TEST_COD", mir->TEST_COD);
00214                 print_chr("RTST_COD", mir->RTST_COD);
00215                 print_chr("PROT_COD", mir->PROT_COD);
00216                 print_chr("CMOD_COD", mir->CMOD_COD);
00217                 print_tim("SETUP_T", mir->SETUP_T);
00218                 print_tim("START_T", mir->START_T);
00219                 print_str("LOT_ID", mir->LOT_ID);
00220                 print_str("PART_TYP", mir->PART_TYP);
00221                 print_str("JOB_NAM", mir->JOB_NAM);
00222                 print_str("OPER_NAM", mir->OPER_NAM);
00223                 print_str("NODE_NAM", mir->NODE_NAM);
00224                 print_str("TSTR_TYP", mir->TSTR_TYP);
00225                 print_str("EXEC_TYP", mir->EXEC_TYP);
00226                 print_str("SUPR_NAM", mir->SUPR_NAM);
00227                 print_str("HAND_ID", mir->HAND_ID);
00228                 print_str("SBLOT_ID", mir->SBLOT_ID);
00229                 print_str("JOB_REV", mir->JOB_REV);
00230                 print_str("PROC_ID", mir->PROC_ID);
00231                 print_str("PRB_CARD", mir->PRB_CARD);
00232                 }
00233 #endif
00234                 break;
00235             }
00236             case REC_MRR: {
00237                 rec_mrr *mrr = (rec_mrr*)rec;
00238                 print_tim("FINISH_T", mrr->FINISH_T);
00239 #ifdef STDF_VER3
00240                 if (stdf_ver == 3) {
00241                 print_int("PART_CNT", mrr->PART_CNT);
00242                 print_int("RTST_CNT", mrr->RTST_CNT);
00243                 print_int("ABRT_CNT", mrr->ABRT_CNT);
00244                 print_int("GOOD_CNT", mrr->GOOD_CNT);
00245                 print_int("FUNC_CNT", mrr->FUNC_CNT);
00246                 }
00247 #endif
00248                 print_chr("DISP_COD", mrr->DISP_COD);
00249                 print_str("USR_DESC", mrr->USR_DESC);
00250                 print_str("EXC_DESC", mrr->EXC_DESC);
00251                 break;
00252             }
00253             case REC_PCR: {
00254                 rec_pcr *pcr = (rec_pcr*)rec;
00255                 print_int("HEAD_NUM", pcr->HEAD_NUM);
00256                 print_int("SITE_NUM", pcr->SITE_NUM);
00257                 print_int("PART_CNT", pcr->PART_CNT);
00258                 print_int("RTST_CNT", pcr->RTST_CNT);
00259                 print_int("ABRT_CNT", pcr->ABRT_CNT);
00260                 print_int("GOOD_CNT", pcr->GOOD_CNT);
00261                 print_int("FUNC_CNT", pcr->FUNC_CNT);
00262                 break;
00263             }
00264             case REC_HBR: {
00265                 rec_hbr *hbr = (rec_hbr*)rec;
00266                 print_int("HEAD_NUM", hbr->HEAD_NUM);
00267                 print_int("SITE_NUM", hbr->SITE_NUM);
00268                 print_int("HBIN_NUM", hbr->HBIN_NUM);
00269                 print_int("HBIN_CNT", hbr->HBIN_CNT);
00270                 print_chr("HBIN_PF", hbr->HBIN_PF);
00271                 print_str("HBIN_NAM", hbr->HBIN_NAM);
00272                 break;
00273             }
00274             case REC_SBR: {
00275                 rec_sbr *sbr = (rec_sbr*)rec;
00276                 print_int("HEAD_NUM", sbr->HEAD_NUM);
00277                 print_int("SITE_NUM", sbr->SITE_NUM);
00278                 print_int("SBIN_NUM", sbr->SBIN_NUM);
00279                 print_int("SBIN_CNT", sbr->SBIN_CNT);
00280                 print_chr("SBIN_PF", sbr->SBIN_PF);
00281                 print_str("SBIN_NAM", sbr->SBIN_NAM);
00282                 break;
00283             }
00284             case REC_PMR: {
00285                 rec_pmr *pmr = (rec_pmr*)rec;
00286                 print_int("PMR_INDX", pmr->PMR_INDX);
00287                 print_int("CHAN_TYP", pmr->CHAN_TYP);
00288                 print_str("CHAN_NAM", pmr->CHAN_NAM);
00289                 print_str("PHY_NAM", pmr->PHY_NAM);
00290                 print_str("LOG_NAM", pmr->LOG_NAM);
00291                 print_int("HEAD_NUM", pmr->HEAD_NUM);
00292                 print_int("SITE_NUM", pmr->SITE_NUM);
00293                 break;
00294             }
00295             case REC_PGR: {
00296                 rec_pgr *pgr = (rec_pgr*)rec;
00297                 print_int("GRP_INDX", pgr->GRP_INDX);
00298                 print_str("GRP_NAM", pgr->GRP_NAM);
00299                 print_int("INDX_CNT", pgr->INDX_CNT);
00300                 print_xU2("PMR_INDX", pgr->PMR_INDX, pgr->INDX_CNT);
00301                 break;
00302             }
00303             case REC_PLR: {
00304                 rec_plr *plr = (rec_plr*)rec;
00305                 print_int("GRP_CNT", plr->GRP_CNT);
00306                 print_xU2("GRP_INDX", plr->GRP_INDX, plr->GRP_CNT);
00307                 print_xU2("GRP_MODE", plr->GRP_MODE, plr->GRP_CNT);
00308                 print_xU1("GRP_RADX", plr->GRP_RADX, plr->GRP_CNT);
00309                 print_UNK("PGM_CHAR");
00310                 print_UNK("RTN_CHAR");
00311                 print_UNK("PGM_CHAL");
00312                 print_UNK("RTN_CHAL");
00313                 break;
00314             }
00315             case REC_RDR: {
00316                 rec_rdr *rdr = (rec_rdr*)rec;
00317                 print_int("NUM_BINS", rdr->NUM_BINS);
00318                 print_xU2("RTST_BIN", rdr->RTST_BIN, rdr->NUM_BINS);
00319                 break;
00320             }
00321             case REC_SDR: {
00322                 rec_sdr *sdr = (rec_sdr*)rec;
00323                 print_int("HEAD_NUM", sdr->HEAD_NUM);
00324                 print_int("SITE_GRP", sdr->SITE_GRP);
00325                 print_int("SITE_CNT", sdr->SITE_CNT);
00326                 print_xU1("SITE_NUM", sdr->SITE_NUM, sdr->SITE_CNT);
00327                 print_str("HAND_TYP", sdr->HAND_TYP);
00328                 print_str("HAND_ID", sdr->HAND_ID);
00329                 print_str("CARD_TYP", sdr->CARD_TYP);
00330                 print_str("CARD_ID", sdr->CARD_ID);
00331                 print_str("LOAD_TYP", sdr->LOAD_TYP);
00332                 print_str("LOAD_ID", sdr->LOAD_ID);
00333                 print_str("DIB_TYP", sdr->DIB_TYP);
00334                 print_str("DIB_ID", sdr->DIB_ID);
00335                 print_str("CABL_TYP", sdr->CABL_TYP);
00336                 print_str("CABL_ID", sdr->CABL_ID);
00337                 print_str("CONT_TYP", sdr->CONT_TYP);
00338                 print_str("CONT_ID", sdr->CONT_ID);
00339                 print_str("LASR_TYP", sdr->LASR_TYP);
00340                 print_str("LASR_ID", sdr->LASR_ID);
00341                 print_str("EXTR_TYP", sdr->EXTR_TYP);
00342                 print_str("EXTR_ID", sdr->EXTR_ID);
00343                 break;
00344             }
00345             case REC_WIR: {
00346                 rec_wir *wir = (rec_wir*)rec;
00347                 print_int("HEAD_NUM", wir->HEAD_NUM);
00348 #ifdef STDF_VER3
00349                 if (stdf_ver == 3)
00350                 print_hex("PAD_BYTE", wir->PAD_BYTE);
00351                 else
00352 #endif
00353                 print_int("SITE_GRP", wir->SITE_GRP);
00354                 print_tim("START_T", wir->START_T);
00355                 print_str("WAFER_ID", wir->WAFER_ID);
00356                 break;
00357             }
00358             case REC_WRR: {
00359                 rec_wrr *wrr = (rec_wrr*)rec;
00360 #ifdef STDF_VER3
00361                 if (stdf_ver == 4) {
00362 #endif
00363                 print_int("HEAD_NUM", wrr->HEAD_NUM);
00364                 print_int("SITE_GRP", wrr->SITE_GRP);
00365                 print_tim("FINISH_T", wrr->FINISH_T);
00366 #ifdef STDF_VER3
00367                 } else {
00368                 print_tim("FINISH_T", wrr->FINISH_T);
00369                 print_int("HEAD_NUM", wrr->HEAD_NUM);
00370                 print_hex("PAD_BYTE", wrr->PAD_BYTE);
00371                 }
00372 #endif
00373                 print_int("PART_CNT", wrr->PART_CNT);
00374                 print_int("RTST_CNT", wrr->RTST_CNT);
00375                 print_int("ABRT_CNT", wrr->ABRT_CNT);
00376                 print_int("GOOD_CNT", wrr->GOOD_CNT);
00377                 print_int("FUNC_CNT", wrr->FUNC_CNT);
00378                 print_str("WAFER_ID", wrr->WAFER_ID);
00379 #ifdef STDF_VER3
00380                 if (stdf_ver == 4) {
00381 #endif
00382                 print_str("FABWF_ID", wrr->FABWF_ID);
00383                 print_str("FRAME_ID", wrr->FRAME_ID);
00384                 print_str("MASK_ID", wrr->MASK_ID);
00385 #ifdef STDF_VER3
00386                 } else {
00387                 print_str("HAND_ID", wrr->HAND_ID);
00388                 print_str("PRB_CARD", wrr->PRB_CARD);
00389                 }
00390 #endif
00391                 print_str("USR_DESC", wrr->USR_DESC);
00392                 print_str("EXC_DESC", wrr->EXC_DESC);
00393                 break;
00394             }
00395             case REC_WCR: {
00396                 rec_wcr *wcr = (rec_wcr*)rec;
00397                 print_rel("WAFR_SIZ", wcr->WAFR_SIZ);
00398                 print_rel("DIE_HT", wcr->DIE_HT);
00399                 print_rel("DIE_WID", wcr->DIE_WID);
00400                 print_int("WF_UNITS", wcr->WF_UNITS);
00401                 print_chr("WF_FLAT", wcr->WF_FLAT);
00402                 print_int("CENTER_X", wcr->CENTER_X);
00403                 print_int("CENTER_Y", wcr->CENTER_Y);
00404                 print_chr("POS_X", wcr->POS_X);
00405                 print_chr("POS_Y", wcr->POS_Y);
00406                 break;
00407             }
00408             case REC_PIR: {
00409                 rec_pir *pir = (rec_pir*)rec;
00410                 print_int("HEAD_NUM", pir->HEAD_NUM);
00411                 print_int("SITE_NUM", pir->SITE_NUM);
00412 #ifdef STDF_VER3
00413                 if (stdf_ver == 3) {
00414                 print_int("X_COORD", pir->X_COORD);
00415                 print_int("Y_COORD", pir->Y_COORD);
00416                 print_str("PART_ID", pir->PART_ID);
00417                 }
00418 #endif
00419                 break;
00420             }
00421             case REC_PRR: {
00422                 rec_prr *prr = (rec_prr*)rec;
00423                 print_int("HEAD_NUM", prr->HEAD_NUM);
00424                 print_int("SITE_NUM", prr->SITE_NUM);
00425 #ifdef STDF_VER3
00426                 if (stdf_ver == 4)
00427 #endif
00428                 print_hex("PART_FLG", prr->PART_FLG);
00429                 print_int("NUM_TEST", prr->NUM_TEST);
00430                 print_int("HARD_BIN", prr->HARD_BIN);
00431                 print_int("SOFT_BIN", prr->SOFT_BIN);
00432 #ifdef STDF_VER3
00433                 if (stdf_ver == 3) {
00434                 print_hex("PART_FLG", prr->PART_FLG);
00435                 print_hex("PAD_BYTE", prr->PAD_BYTE);
00436                 }
00437 #endif
00438                 print_int("X_COORD", prr->X_COORD);
00439                 print_int("Y_COORD", prr->Y_COORD);
00440 #ifdef STDF_VER3
00441                 if (stdf_ver == 4)
00442 #endif
00443                 print_tim("TEST_T", prr->TEST_T);
00444                 print_str("PART_ID", prr->PART_ID);
00445                 print_str("PART_TXT", prr->PART_TXT);
00446                 print_Bn("PART_FIX", prr->PART_FIX);
00447                 break;
00448             }
00449 #ifdef STDF_VER3
00450             case REC_PDR: {
00451                 rec_pdr *pdr = (rec_pdr*)rec;
00452                 print_int("TEST_NUM", pdr->TEST_NUM);
00453                 print_hex("DESC_FLG", pdr->DESC_FLG);
00454                 print_hex("OPT_FLAG", pdr->OPT_FLAG);
00455                 print_int("RES_SCAL", pdr->RES_SCAL);
00456                 print_str("UNITS", pdr->UNITS);
00457                 print_int("RES_LDIG", pdr->RES_LDIG);
00458                 print_int("RES_RDIG", pdr->RES_RDIG);
00459                 print_int("LLM_SCAL", pdr->LLM_SCAL);
00460                 print_int("HLM_SCAL", pdr->HLM_SCAL);
00461                 print_int("LLM_LDIG", pdr->LLM_LDIG);
00462                 print_int("LLM_RDIG", pdr->LLM_RDIG);
00463                 print_int("HLM_LDIG", pdr->HLM_LDIG);
00464                 print_int("HLM_RDIG", pdr->HLM_RDIG);
00465                 print_rel("LO_LIMIT", pdr->LO_LIMIT);
00466                 print_rel("HI_LIMIT", pdr->HI_LIMIT);
00467                 print_str("TEST_NAM", pdr->TEST_NAM);
00468                 print_str("SEQ_NAME", pdr->SEQ_NAME);
00469                 break;
00470             }
00471             case REC_FDR: {
00472                 rec_fdr *fdr = (rec_fdr*)rec;
00473                 print_int("TEST_NUM", fdr->TEST_NUM);
00474                 print_hex("DESC_FLG", fdr->DESC_FLG);
00475                 print_str("TEST_NAM", fdr->TEST_NAM);
00476                 print_str("SEQ_NAME", fdr->SEQ_NAME);
00477                 break;
00478             }
00479 #endif
00480             case REC_TSR: {
00481                 rec_tsr *tsr = (rec_tsr*)rec;
00482                 print_int("HEAD_NUM", tsr->HEAD_NUM);
00483                 print_int("SITE_NUM", tsr->SITE_NUM);
00484 #ifdef STDF_VER3
00485                 if (stdf_ver == 4)
00486 #endif
00487                 print_chr("TEST_TYP", tsr->TEST_TYP);
00488                 print_int("TEST_NUM", tsr->TEST_NUM);
00489                 print_int("EXEC_CNT", tsr->EXEC_CNT);
00490                 print_int("FAIL_CNT", tsr->FAIL_CNT);
00491                 print_int("ALRM_CNT", tsr->ALRM_CNT);
00492 #ifdef STDF_VER3
00493                 if (stdf_ver == 4) {
00494 #endif
00495                 print_str("TEST_NAM", tsr->TEST_NAM);
00496                 print_str("SEQ_NAME", tsr->SEQ_NAME);
00497                 print_str("TEST_LBL", tsr->TEST_LBL);
00498                 print_hex("OPT_FLAG", tsr->OPT_FLAG);
00499                 print_rel("TEST_TIM", tsr->TEST_TIM);
00500                 print_rel("TEST_MIN", tsr->TEST_MIN);
00501                 print_rel("TEST_MAX", tsr->TEST_MAX);
00502                 print_rel("TST_SUMS", tsr->TST_SUMS);
00503                 print_rel("TST_SQRS", tsr->TST_SQRS);
00504 #ifdef STDF_VER3
00505                 } else {
00506                 print_hex("OPT_FLAG", tsr->OPT_FLAG);
00507                 print_hex("PAD_BYTE", tsr->PAD_BYTE);
00508                 print_rel("TEST_MIN", tsr->TEST_MIN);
00509                 print_rel("TEST_MAX", tsr->TEST_MAX);
00510                 print_rel("TST_MEAN", tsr->TST_MEAN);
00511                 print_rel("TST_SDEV", tsr->TST_SDEV);
00512                 print_rel("TST_SUMS", tsr->TST_SUMS);
00513                 print_rel("TST_SQRS", tsr->TST_SQRS);
00514                 print_str("TEST_NAM", tsr->TEST_NAM);
00515                 print_str("SEQ_NAME", tsr->SEQ_NAME);
00516                 }
00517 #endif
00518                 break;
00519             }
00520             case REC_PTR: {
00521                 rec_ptr *ptr = (rec_ptr*)rec;
00522                 print_int("TEST_NUM", ptr->TEST_NUM);
00523                 print_int("HEAD_NUM", ptr->HEAD_NUM);
00524                 print_int("SITE_NUM", ptr->SITE_NUM);
00525                 print_hex("TEST_FLG", ptr->TEST_FLG);
00526                 print_hex("PARM_FLG", ptr->PARM_FLG);
00527                 print_rel("RESULT", ptr->RESULT);
00528                 print_str("TEST_TXT", ptr->TEST_TXT);
00529                 print_str("ALARM_ID", ptr->ALARM_ID);
00530                 print_hex("OPT_FLAG", ptr->OPT_FLAG);
00531                 print_int("RES_SCAL", ptr->RES_SCAL);
00532                 print_int("LLM_SCAL", ptr->LLM_SCAL);
00533                 print_int("HLM_SCAL", ptr->HLM_SCAL);
00534                 print_rel("LO_LIMIT", ptr->LO_LIMIT);
00535                 print_rel("HI_LIMIT", ptr->HI_LIMIT);
00536                 print_str("UNITS", ptr->UNITS);
00537                 print_str("C_RESFMT", ptr->C_RESFMT);
00538                 print_str("C_LLMFMT", ptr->C_LLMFMT);
00539                 print_str("C_HLMFMT", ptr->C_HLMFMT);
00540                 print_rel("LO_SPEC", ptr->LO_SPEC);
00541                 print_rel("HI_SPEC", ptr->HI_SPEC);
00542                 break;
00543             }
00544             case REC_MPR: {
00545                 rec_mpr *mpr = (rec_mpr*)rec;
00546                 print_int("TEST_NUM", mpr->TEST_NUM);
00547                 print_int("HEAD_NUM", mpr->HEAD_NUM);
00548                 print_int("SITE_NUM", mpr->SITE_NUM);
00549                 print_hex("TEST_FLG", mpr->TEST_FLG);
00550                 print_hex("PARM_FLG", mpr->PARM_FLG);
00551                 print_int("RTN_ICNT", mpr->RTN_ICNT);
00552                 print_int("RSLT_CNT", mpr->RSLT_CNT);
00553                 print_xN1("RTN_STAT", mpr->RTN_STAT, mpr->RTN_ICNT);
00554                 print_xR4("RTN_RSLT", mpr->RTN_RSLT, mpr->RSLT_CNT);
00555                 print_str("TEST_TXT", mpr->TEST_TXT);
00556                 print_str("ALARM_ID", mpr->ALARM_ID);
00557                 print_hex("OPT_FLAG", mpr->OPT_FLAG);
00558                 print_int("RES_SCAL", mpr->RES_SCAL);
00559                 print_int("LLM_SCAL", mpr->LLM_SCAL);
00560                 print_int("HLM_SCAL", mpr->HLM_SCAL);
00561                 print_rel("LO_LIMIT", mpr->LO_LIMIT);
00562                 print_rel("HI_LIMIT", mpr->HI_LIMIT);
00563                 print_rel("START_IN", mpr->START_IN);
00564                 print_rel("INCR_IN", mpr->INCR_IN);
00565                 print_xU2("RTN_INDX", mpr->RTN_INDX, mpr->RTN_ICNT);
00566                 print_str("UNITS", mpr->UNITS);
00567                 print_str("UNITS_IN", mpr->UNITS_IN);
00568                 print_str("C_RESFMT", mpr->C_RESFMT);
00569                 print_str("C_LLMFMT", mpr->C_LLMFMT);
00570                 print_str("C_HLMFMT", mpr->C_HLMFMT);
00571                 print_rel("LO_SPEC", mpr->LO_SPEC);
00572                 print_rel("HI_SPEC", mpr->HI_SPEC);
00573                 break;
00574             }
00575             case REC_FTR: {
00576                 rec_ftr *ftr = (rec_ftr*)rec;
00577                 print_int("TEST_NUM", ftr->TEST_NUM);
00578                 print_int("HEAD_NUM", ftr->HEAD_NUM);
00579                 print_int("SITE_NUM", ftr->SITE_NUM);
00580                 print_hex("TEST_FLG", ftr->TEST_FLG);
00581                 print_hex("OPT_FLAG", ftr->OPT_FLAG);
00582                 print_int("CYCL_CNT", ftr->CYCL_CNT);
00583                 print_int("REL_VADR", ftr->REL_VADR);
00584                 print_int("REPT_CNT", ftr->REPT_CNT);
00585                 print_int("NUM_FAIL", ftr->NUM_FAIL);
00586                 print_int("XFAIL_AD", ftr->XFAIL_AD);
00587                 print_int("YFAIL_AD", ftr->YFAIL_AD);
00588                 print_int("VECT_OFF", ftr->VECT_OFF);
00589                 print_int("RTN_ICNT", ftr->RTN_ICNT);
00590                 print_int("PGM_ICNT", ftr->PGM_ICNT);
00591                 print_xU2("RTN_INDX", ftr->RTN_INDX, ftr->RTN_ICNT);
00592                 print_xN1("RTN_STAT", ftr->RTN_STAT, ftr->RTN_ICNT);
00593                 print_xU2("PGM_INDX", ftr->PGM_INDX, ftr->PGM_ICNT);
00594                 print_xN1("PGM_STAT", ftr->PGM_STAT, ftr->PGM_ICNT);
00595                 print_Dn("FAIL_PIN", ftr->FAIL_PIN);
00596                 print_str("VECT_NAM", ftr->VECT_NAM);
00597                 print_str("TIME_SET", ftr->TIME_SET);
00598                 print_str("OP_CODE", ftr->OP_CODE);
00599                 print_str("TEST_TXT", ftr->TEST_TXT);
00600                 print_str("ALARM_ID", ftr->ALARM_ID);
00601                 print_str("PROG_TXT", ftr->PROG_TXT);
00602                 print_str("RSLT_TXT", ftr->RSLT_TXT);
00603                 print_int("PATG_NUM", ftr->PATG_NUM);
00604                 print_Dn("SPIN_MAP", ftr->SPIN_MAP);
00605                 break;
00606             }
00607             case REC_BPS: {
00608                 rec_bps *bps = (rec_bps*)rec;
00609                 print_str("SEQ_NAME", bps->SEQ_NAME);
00610                 break;
00611             }
00612             case REC_EPS: {
00613                 /*rec_eps *eps = (rec_eps*)rec;*/
00614                 break;
00615             }
00616 #ifdef STDF_VER3
00617             case REC_SHB: {
00618                 rec_shb *shb = (rec_shb*)rec;
00619                 print_int("HEAD_NUM", shb->HEAD_NUM);
00620                 print_int("SITE_NUM", shb->SITE_NUM);
00621                 print_int("HBIN_NUM", shb->HBIN_NUM);
00622                 print_int("HBIN_CNT", shb->HBIN_CNT);
00623                 print_str("HBIN_NAM", shb->HBIN_NAM);
00624                 break;
00625             }
00626             case REC_SSB: {
00627                 rec_ssb *ssb = (rec_ssb*)rec;
00628                 print_int("HEAD_NUM", ssb->HEAD_NUM);
00629                 print_int("SITE_NUM", ssb->SITE_NUM);
00630                 print_int("SBIN_NUM", ssb->SBIN_NUM);
00631                 print_int("SBIN_CNT", ssb->SBIN_CNT);
00632                 print_str("SBIN_NAM", ssb->SBIN_NAM);
00633                 break;
00634             }
00635             case REC_STS: {
00636                 rec_sts *sts = (rec_sts*)rec;
00637                 print_int("HEAD_NUM", sts->HEAD_NUM);
00638                 print_int("SITE_NUM", sts->SITE_NUM);
00639                 print_int("TEST_NUM", sts->TEST_NUM);
00640                 print_int("EXEC_CNT", sts->EXEC_CNT);
00641                 print_int("FAIL_CNT", sts->FAIL_CNT);
00642                 print_int("ALRM_CNT", sts->ALRM_CNT);
00643                 print_hex("OPT_FLAG", sts->OPT_FLAG);
00644                 print_hex("PAD_BYTE", sts->PAD_BYTE);
00645                 print_rel("TEST_MIN", sts->TEST_MIN);
00646                 print_rel("TEST_MAX", sts->TEST_MAX);
00647                 print_rel("TST_MEAN", sts->TST_MEAN);
00648                 print_rel("TST_SDEV", sts->TST_SDEV);
00649                 print_rel("TST_SUMS", sts->TST_SUMS);
00650                 print_rel("TST_SQRS", sts->TST_SQRS);
00651                 print_str("TEST_NAM", sts->TEST_NAM);
00652                 print_str("SEQ_NAME", sts->SEQ_NAME);
00653                 print_str("TEST_LBL", sts->TEST_LBL);
00654                 break;
00655             }
00656             case REC_SCR: {
00657                 rec_scr *scr = (rec_scr*)rec;
00658                 print_int("HEAD_NUM", scr->HEAD_NUM);
00659                 print_int("SITE_NUM", scr->SITE_NUM);
00660                 print_int("FINISH_T", scr->FINISH_T);
00661                 print_int("PART_CNT", scr->PART_CNT);
00662                 print_int("RTST_CNT", scr->RTST_CNT);
00663                 print_int("ABRT_CNT", scr->ABRT_CNT);
00664                 print_int("GOOD_CNT", scr->GOOD_CNT);
00665                 print_int("FUNC_CNT", scr->FUNC_CNT);
00666                 break;
00667             }
00668 #endif
00669             case REC_GDR: {
00670                 rec_gdr *gdr = (rec_gdr*)rec;
00671                 print_int("FLD_CNT", gdr->FLD_CNT);
00672                 print_Vn("GEN_DATA", gdr->GEN_DATA, gdr->FLD_CNT);
00673                 break;
00674             }
00675             case REC_DTR: {
00676                 rec_dtr *dtr = (rec_dtr*)rec;
00677                 print_str("TEXT_DAT", dtr->TEXT_DAT);
00678                 break;
00679             }
00680         }
00681         if (HEAD_TO_REC(rec->header) != REC_UNKNOWN)
00682             printf("</%s>\n", recname);
00683         stdf_free_record(rec);
00684     }
00685     printf("</stdf>\n");
00686     stdf_close(f);
00687 }
00688     return EXIT_SUCCESS;
00689 }