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