home *** CD-ROM | disk | FTP | other *** search
/ World of A1200 / World_Of_A1200.iso / programs / develop / galer / galer_deutsch / source / galersrcd.lha / Jedec.c < prev    next >
C/C++ Source or Header  |  1993-05-22  |  22KB  |  929 lines
  1. /****************************************************************/
  2. /*                                */
  3. /* Jedec.c - enthält Routinen zum Laden und Speichern der    */
  4. /* GAL-Daten im Jedec-Format                    */
  5. /*                                */
  6. /* compilieren: cc Jedec.c                    */
  7. /*                                */
  8. /****************************************************************/
  9.  
  10.  
  11.  
  12. #include <exec/types.h>
  13. #include <exec/memory.h>
  14. #include <libraries/dos.h>
  15. #include <stdio.h>
  16. #include <ctype.h>
  17. #include <stdio.h>
  18. #include <functions.h>
  19.  
  20. #include "GALer.h"
  21.  
  22.  
  23.  
  24. extern    int        MaxFuseAdr;
  25. extern    int        GALType;
  26. extern    char        path;
  27.  
  28. extern    struct    Configuration Config;
  29.  
  30. struct    JedecStruct    Jedec;
  31.  
  32.  
  33. int    linenum, JedecSecurity, JedecGALType;
  34.  
  35. UBYTE    *actptr, *buffend;
  36.  
  37.  
  38.  
  39.  
  40. /* PutJedec:
  41.    liest aus dem GAL die Jedec-Struktur ein und schreibt das Jedec-File 
  42.    Aufruf: PutJedec();
  43. */
  44. void PutJedec()
  45. {
  46.  if (MyRequest(GALTYPE_REQ,(UBYTE *)"GAL auslesen und JEDEC-Datei erstellen?")) {
  47.      if (ReadGALParameter(YES))            /*GAL-Parameter holen*/
  48.        return;                    /*bei Fehler return*/
  49.      PrintText((UBYTE *)"lese GAL...",1);
  50.      ReadGALToJedec();                    /*GAL einlesen*/
  51.      PrintText((UBYTE *)" o.k.",0);
  52.  
  53.      if (MyFileReq((UBYTE *)"JEDEC-File schreiben",(UBYTE *)".jed",YES))
  54.        WriteJedecFile();
  55.  
  56.   }
  57. }
  58.  
  59.  
  60.  
  61.  
  62.  
  63.  
  64. /* FileChecksum: berechnet die Checksumme über das Jedec-File
  65.          Enfang und Ende MUß mit <STX> und <ETX> gekennzeichnet sein!
  66.    Aufruf: checksum = FileChecksum(buff);
  67.          buff: ActBuffer-Struktur des File-Puffers
  68.    Ergebnis: checksum: 16-Bit Checksumme der Jedec-Struktur
  69. */
  70. int FileChecksum(buff)
  71. struct    ActBuffer buff;
  72. {
  73. int checksum;
  74.  
  75.  checksum = 0;
  76.  
  77.  while (*buff.Entry != 0x2)            /* <STX> suchen */
  78.    IncPointer(&buff);
  79.  
  80.  while (*buff.Entry != 0x3) {            /* <ETX> suchen und alle*/
  81.    checksum += *buff.Entry;            /* Zeichen aufaddieren*/
  82.    IncPointer(&buff);
  83.   }
  84.  
  85.  checksum += 0x3;                /* <ETX> noch dazuaddieren*/
  86.  
  87.  return(checksum);                /* fertig */
  88. }
  89.  
  90.  
  91.  
  92. /* FuseChecksum: berechnet aus der Jedec-Struktur die Fuse-Checksumme 
  93.    Aufruf: checksum = FuseChecksum(gal_type);
  94.        gal_type muß den GAL-Typ enthalten
  95.    Ergebnis: checksum: 16-Bit Checksumme der Jedec-Struktur
  96. */
  97. int FuseChecksum(gal_type)
  98. int gal_type;
  99. {
  100. int    checksum, byte, fuses;
  101. int    n;
  102. BYTE    *ptr;
  103.  
  104.  if (gal_type == GAL16V8)
  105.    fuses = NUMOFFUSES16;
  106.  else
  107.    fuses = NUMOFFUSES20;
  108.  
  109.  ptr = &Jedec.GALLogic[0];
  110.  checksum = byte = 0;
  111.  for (n=9; n<fuses+9; n++) {
  112.    byte |= (*ptr << (n-1) % 8);
  113.    if (!(n % 8)) {
  114.      checksum += byte;
  115.      byte = 0;
  116.     }
  117.  if (n == 2039)
  118.    n=n;
  119.    
  120.    if ((gal_type == GAL16V8) && (ptr == &Jedec.GALLogic[0]+(long)XOR16-1L))
  121.      ptr = &Jedec.GALXOR[0];
  122.    else
  123.      ptr++;
  124.   }
  125.  checksum += byte;
  126.  
  127.  return(checksum); 
  128. }
  129.  
  130.  
  131.  
  132. /* MakeJedecBuff: wertet Jedec-Struktur aus und legt das Jedec-File
  133.           im Speicher ab
  134.    Aufruf:   result = MakeJedecBuff(buff);
  135.             buff:    ActBuffer-Struktur für Speicherblock in dem
  136.               das Jedec-File abgelegt werden soll
  137.    Ergebnis: result:  0: alles o.k.
  138.              -1: nicht genug freier Speicher
  139. */
  140. int MakeJedecBuff(buff)
  141. struct    ActBuffer buff;
  142. {
  143. int    n, m, bitnum, bitnum2, flag;
  144. UBYTE    mystrng[8];
  145. struct    ActBuffer buff2;
  146.  
  147.  buff2 = buff;
  148.  
  149.  if (Config.JedecFileChk)
  150.    if (AddString(&buff, "\2\n"))            /*<STX>*/
  151.      return(-1);
  152.  
  153.  if (AddString(&buff, "Used Program:   GALer V1.4\n"))
  154.    return(-1);
  155.  if (AddString(&buff, "GAL-Assembler:  GALer V1.4\n"))
  156.    return(-1);
  157.  if (GALType == GAL16V8) {
  158.    if (AddString(&buff, "Device:         GAL16V8\n\n"))
  159.      return(-1);
  160.   }
  161.  else
  162.    if (AddString(&buff, "Device:         GAL20V8\n\n"))
  163.      return(-1);
  164.  
  165.  
  166.  if (AddString(&buff, "*F0\n"))            /*Default-Wert für Fuses*/
  167.    return(-1);
  168.  
  169.  if (Config.JedecSecBit) {            /*Security-Bit*/
  170.    if (AddString(&buff, "*G1\n"))
  171.      return(-1);
  172.   }
  173.  else
  174.    if (AddString(&buff, "*G0\n"))
  175.      return(-1);
  176.  
  177.  if (GALType == GAL16V8) {            /*Anzahl der Sicherungen*/
  178.    if (AddString(&buff, "*QF2194\n"))        /*im File*/
  179.      return(-1);
  180.   }
  181.  else
  182.    if (AddString(&buff, "*QF2706\n"))
  183.      return(-1);
  184.       
  185.                         /*Fuse-Matrix erstellen*/
  186.  bitnum = 0;
  187.  for (m=0; m<ROW_SIZE; m++) {
  188.    flag = 0;
  189.    bitnum2 = bitnum;
  190.    for (n=0; n<=MaxFuseAdr; n++) {
  191.      if (Jedec.GALLogic[bitnum2]) {
  192.        flag = 1;
  193.        break;
  194.       }
  195.      bitnum2++;
  196.     }
  197.  
  198.    if (flag) {
  199.      sprintf(&mystrng[0],"*L%04d \0",bitnum);
  200.      if (AddString(&buff, &mystrng[0]))
  201.        return(-1);
  202.      for (n=0; n<=MaxFuseAdr; n++) {
  203.        if (AddByte(&buff, Jedec.GALLogic[bitnum] + '0'))
  204.          return(-1);
  205.        bitnum++;
  206.       }
  207.      if (AddByte(&buff, '\n'))
  208.        return(-1);
  209.     }
  210.    else
  211.      bitnum = bitnum2;
  212.   }
  213.  if (!flag)
  214.    bitnum = bitnum2;
  215.  
  216.  
  217.                         /*XOR-Bits*/
  218.  sprintf(&mystrng[0],"*L%04d \0",bitnum);
  219.  if (AddString(&buff, &mystrng[0]))
  220.    return(-1);
  221.  for (n=0; n<XOR_SIZE; n++) {
  222.    if (AddByte(&buff, Jedec.GALXOR[n] + '0'))
  223.      return(-1);
  224.    bitnum++;
  225.   }
  226.  if (AddByte(&buff, '\n'))
  227.    return(-1);
  228.  
  229.                         /*Signatur*/
  230.  sprintf(&mystrng[0],"*L%04d \0",bitnum);
  231.  if (AddString(&buff, &mystrng[0]))
  232.    return(-1);
  233.  for (n=0; n<SIG_SIZE; n++) {
  234.    if (AddByte(&buff, Jedec.GALSig[n] + '0'))
  235.      return(-1);
  236.    bitnum++;
  237.   }
  238.  if (AddByte(&buff, '\n'))
  239.    return(-1);
  240.  
  241.                         /*AC1-Bits*/
  242.  sprintf(&mystrng[0],"*L%04d \0",bitnum);
  243.  if (AddString(&buff, &mystrng[0]))
  244.    return(-1);
  245.  for (n=0; n<AC1_SIZE; n++) {
  246.    if (AddByte(&buff, Jedec.GALAC1[n] + '0'))
  247.      return(-1);
  248.    bitnum++;
  249.   }
  250.  if (AddByte(&buff, '\n'))
  251.    return(-1);
  252.  
  253.                         /*PT-Bits*/
  254.  sprintf(&mystrng[0],"*L%04d \0",bitnum);
  255.  if (AddString(&buff, &mystrng[0]))
  256.    return(-1);
  257.  for (n=0; n<PT_SIZE; n++) {
  258.    if (AddByte(&buff, Jedec.GALPT[n] + '0'))
  259.      return(-1);
  260.    bitnum++;
  261.   }
  262.  if (AddByte(&buff, '\n'))
  263.    return(-1);
  264.  
  265.                         /*SYN-Bit*/
  266.  sprintf(&mystrng[0],"*L%04d \0",bitnum);
  267.  if (AddString(&buff, &mystrng[0]))
  268.    return(-1);
  269.  if (AddByte(&buff, Jedec.GALSYN + '0'))
  270.    return(-1);
  271.  if (AddByte(&buff, '\n'))
  272.    return(-1);
  273.  bitnum++;
  274.                         /*AC0-Bit*/
  275.  sprintf(&mystrng[0],"*L%04d \0",bitnum);
  276.  if (AddString(&buff, &mystrng[0]))
  277.    return(-1);
  278.  if (AddByte(&buff, Jedec.GALAC0 + '0'))
  279.    return(-1);
  280.  if (AddByte(&buff, '\n'))
  281.    return(-1);
  282.  
  283.  if (Config.JedecFuseChk) {            /*Checksumme der Sicherungen*/
  284.    sprintf(&mystrng[0],"*C%04x\n\0", FuseChecksum(GALType));
  285.    if (AddString(&buff, &mystrng[0]))
  286.      return(-1);
  287.   }
  288.  
  289.  if (AddString(&buff, "*\n"))            /*abschließendes '*' */
  290.    return(-1);
  291.  
  292.  if (Config.JedecFileChk) {
  293.    if (AddByte(&buff, 0x3))            /* <ETX> */
  294.      return(-1);
  295.    sprintf(&mystrng[0],"%04x\n\0", FileChecksum(buff2));
  296.    if (AddString(&buff, &mystrng[0]))
  297.      return(-1);
  298.   }
  299.  
  300.  return(0);
  301. }
  302.  
  303.  
  304.  
  305.  
  306. /* WriteJedecFile:
  307.    erstellt aus der Jedec-Struktur das Jedec-File 
  308.    Aufruf: WriteJedecFile();
  309.           die globale Variable "GALType" muß den GAL-Typ enthalten
  310. */
  311. void WriteJedecFile()
  312. {
  313. struct    ActBuffer    mybuff;
  314. struct    Buffer        *first_buff;
  315. struct    FileHandle    *fh;
  316. extern    char    path;
  317. UBYTE    *filebuffer, *filebuffer2;
  318. long    result;
  319.  
  320.  
  321.  if (!(first_buff = (struct Buffer *)AllocMem((long)sizeof(struct Buffer),MEMF_PUBLIC|MEMF_CLEAR))) {
  322.    ErrorReq(2);            /*kein Speicher mehr->Fehlermeldung*/
  323.    return;
  324.   }
  325.  
  326.  mybuff.ThisBuff = first_buff;
  327.  mybuff.Entry    = (UBYTE *)(&first_buff->Entries[0]);
  328.  mybuff.BuffEnd  = (UBYTE *)first_buff + (long)sizeof(struct Buffer);
  329.  
  330.  
  331.  
  332.  if (MakeJedecBuff(mybuff)) {            /*Jedec in Puffer ablegen*/
  333.    FreeBuffer(first_buff);            /*Fehler?, dann Abbruch*/
  334.    ErrorReq(2);
  335.    return;
  336.   }
  337.  
  338.  PrintText((UBYTE *)"schreibe JEDEC-File...",1);
  339.  if ((fh = Open(&path, (long)MODE_NEWFILE))) {
  340.    for (;;) {
  341.      filebuffer = filebuffer2 = mybuff.Entry;
  342.  
  343.      while (filebuffer2 < mybuff.BuffEnd) {    /*Größe des Puffers bestimmen*/
  344.        if (!*filebuffer2) 
  345.      break;
  346.        filebuffer2++;
  347.       }
  348.                         /*Puffer schreiben*/
  349.      result = Write(fh, filebuffer, (long)(filebuffer2-filebuffer));
  350.      if (result == -1L) {            /*Fehler beim Schreiben?*/
  351.        Close(fh);                /*ja, dann Ende*/
  352.        FreeBuffer(first_buff);
  353.        PrintText((UBYTE *)" Fehler!",0);
  354.        ErrorReq(13);
  355.        return;
  356.       }
  357.  
  358.      if (!mybuff.ThisBuff->Next)        /*noch ein Puffer da?*/
  359.        break;                    /*nein, dann for(;;)-Ende*/
  360.      mybuff.ThisBuff = mybuff.ThisBuff->Next;
  361.      mybuff.Entry    = (UBYTE *)(&mybuff.ThisBuff->Entries[0]);
  362.      mybuff.BuffEnd  = (UBYTE *)mybuff.ThisBuff + (long)sizeof(struct Buffer);
  363.     }
  364.    Close(fh);
  365.   }
  366.  else {
  367.    FreeBuffer(first_buff);            /*Fehler?, dann Abbruch*/
  368.    PrintText((UBYTE *)" Fehler!",0);
  369.    ErrorReq(13);            /*Datei läßt sich nicht öffnen*/
  370.    return;
  371.   }
  372.  PrintText((UBYTE *)" o.k.",0);
  373.  FreeBuffer(first_buff);
  374. }
  375.  
  376.  
  377.  
  378.  
  379.  
  380. /* SearchNextChar: stellt Zeiger auf nächstes Zeichen, das kein TAB
  381.            SPACE, CR ist - sucht von actptr + 1 ab
  382.    Aufruf:   result = SearchNextChar();
  383.    Ergebnis: result = 0: noch ein Zeichen gefunden
  384.             =-1: kein Zeichen mehr da (Fileende)
  385. */
  386. int SearchNextChar()
  387. {
  388.  actptr++;
  389.  while (*actptr) {
  390.    switch (*actptr) {
  391.      case  ' ':
  392.      case 0x09:    break;
  393.      case 0x0A: linenum++;
  394.         break;
  395.      default  : return(0);
  396.     }
  397.    actptr++;
  398.   } 
  399.  return(-1);
  400. }
  401.  
  402.  
  403. /* SearchNextAsterix: (hat nichts mit dem bekannten Gallier zu tun)
  404.               sucht bis zum Fileende das '*'-Zeichen - sucht von
  405.               actptr ab
  406.    Aufruf:   result = SearchNextAsterix();
  407.    Ergebnis: result = 0: Zeichen gefunden
  408.             =-1: kein Zeichen mehr da (Fileende)
  409. */
  410. int SearchNextAsterix()
  411. {
  412.   while (*actptr) {
  413.     if (*actptr == '*')
  414.       return(0);
  415.     if (*actptr == 0x0A)
  416.       linenum++;
  417.     actptr++;
  418.    }
  419.   return(-1);
  420. }
  421.  
  422.  
  423.  
  424. /* GetJedec:
  425.    liest Jedec-File ein, wertet es aus und füllt die Jedec-Struktur
  426.    Aufruf: error=GetJedec(jedecfile);
  427.        jedecfile  : Zeiger auf Filenamen (mit ".jed")
  428.        error      : Fehlernummer; 0:keine Fehler 
  429. */
  430. int GetJedec(jedecfile)
  431. UBYTE    *jedecfile;
  432. {
  433. extern    char    path;
  434. LONG    filesize;
  435. UBYTE    *filebuff, *ptr, *jedbuff, *jedptr;
  436. int    n;
  437. int    QFflag, QPflag, Fflag, Gflag, Cflag;
  438. int    Lflag, STXflag, ETXflag, FCHKflag;
  439. int    errornum, fuse_chk, file_chk;
  440. unsigned int    num, fuse;
  441. unsigned int    QF, QP, F;
  442.  
  443.  
  444.  JedecGALType = NOT_SPECIFIED;
  445.  
  446.  filesize = FileSize(jedecfile);
  447.  switch (filesize) {
  448.    case -1L: {
  449.      ErrorReq(1);
  450.      return(-1);
  451.      break;
  452.     }
  453.    case -2L: {
  454.      ErrorReq(2);
  455.      return(-2);
  456.      break;
  457.     }
  458.    case 0L: {
  459.      ErrorReq(4);
  460.      return(-4);
  461.      break;
  462.     }
  463.   }
  464.  
  465.  if ((filebuff=(UBYTE *)AllocMem(filesize+2L,MEMF_PUBLIC|MEMF_CLEAR))) {
  466.    if ((ReadFile(jedecfile,filesize,filebuff))) {
  467.      PrintText((UBYTE *)"Datei ist geladen",1);
  468.      actptr = filebuff;                /*Variablen initialisieren*/
  469.      linenum  = 1;
  470.      errornum = 0;
  471.      fuse     = 0;
  472.      QFflag = QPflag = Fflag = Gflag = Cflag = Lflag = STXflag = ETXflag = 0;
  473.      FCHKflag = 0;
  474.  
  475.      if (!(jedbuff=(UBYTE *)AllocMem((long)NUMOFFUSES20,MEMF_PUBLIC|MEMF_CLEAR))) {
  476.        FreeMem(filebuff,filesize);
  477.        ErrorReq(2);                    /*kein Speicher*/
  478.        return(-2);
  479.       }
  480.      jedptr = jedbuff;
  481.  
  482.  
  483.      if (SearchNextAsterix()) {            /*Zeiger auf ersten Befehl*/
  484.        FreeMem(jedbuff,(long)NUMOFFUSES20);    /*Puffer für Jedec-Struktur*/
  485.        FreeMem(filebuff,filesize);
  486.        JedecError(1,YES);            /*unerwartetes Dateiende*/
  487.        return(1);
  488.       }
  489.  
  490.      for (;;) {
  491.        if (SearchNextChar())            /*kein Zeichen mehr da?*/
  492.      break;                    /*dann for-Schleife beenden*/
  493.  
  494.        switch (*actptr) {
  495.      case 'Q':            /*Befehle, die mit Q beginnen*/
  496.        actptr++;
  497.        if (*actptr == 'F') {    /*Anzahl der Fuses*/
  498.          if (QFflag) {            /*Befehl darf innerhalb des*/
  499.            errornum = 7;            /*Jedec-Files nur einmal*/
  500.            break;                /*vorkommen*/
  501.           }
  502.          actptr++;
  503.          if (!isdigit(*actptr)) {        /*Zahl vorhanden?*/
  504.            errornum = 4;            /*nein, dann Fehler*/
  505.            break;
  506.           }
  507.          if (!sscanf(actptr,"%d",&QF)) {
  508.            errornum = 3;
  509.            break;
  510.           }
  511.          while (isdigit(*actptr))        /*eingelesene Zahl über-*/
  512.            actptr++;            /*springen*/
  513.          QFflag = 1;
  514.  
  515.          if ((QF != 2194) && (QF != 2706)) {
  516.            errornum = 22;            /*ungültiges QF, dann Fehler*/
  517.            break;
  518.           }
  519.  
  520.          if (QF == 2194)            /*aus *QF GAL-Typ bestimmen*/
  521.            JedecGALType = GAL16V8;
  522.          if (QF == 2706)
  523.            JedecGALType = GAL20V8;
  524.  
  525.          break;
  526.         }
  527.  
  528.        if (*actptr == 'P') {    /*Anzahl der Pins für Testvek.*/
  529.          if (QPflag) {            /*Befehl darf innerhalb des*/
  530.            errornum = 8;            /*Jedec-Files nur einmal*/
  531.            break;                /*vorkommen*/
  532.           }
  533.          actptr++;
  534.          if (!isdigit(*actptr)) {        /*Zahl vorhanden?*/
  535.            errornum = 4;            /*nein, dann Fehler*/
  536.            break;
  537.           }
  538.          if (!sscanf(actptr,"%d",&QP)) {
  539.            errornum = 3;
  540.            break;
  541.           }
  542.          while (isdigit(*actptr))        /*eingelesene Zahl über-*/
  543.            actptr++;            /*springen*/
  544.          QPflag = 1;
  545.          break;
  546.         }
  547.        errornum = 2;            /*kein QF,QP, dann Fehler*/
  548.        break;
  549.  
  550.  
  551.      case 'F':            /*Fuse-Default*/
  552.        actptr++;
  553.        if (*actptr == '0')
  554.          F = 0;
  555.        else
  556.          if (*actptr == '1')
  557.            F = 1;
  558.          else {                /*weder 0 noch 1 nach F*/
  559.            errornum = 5;            /*dann Fehler*/
  560.            break;
  561.           }
  562.        for (n=fuse; n<sizeof(Jedec); n++)    /*Default-Wert setzen*/
  563.          *(jedbuff + (long)n) = F;
  564.        Fflag = 1;
  565.        break;
  566.  
  567.  
  568.      case 'P':            /*Pins für Testvektoren*/
  569.      case 'V':            /*Testvektoren*/
  570.      case 'N':            /*Kommentar*/
  571.        break;                /*nichts machen*/
  572.  
  573.  
  574.      case 'C':            /*Fuse-Checksumme*/
  575.        if (Cflag) {                /*nur eine Checksumme*/
  576.          errornum = 24;            /*erlaubt*/
  577.          break;
  578.         }
  579.        actptr++;
  580.        if (!isxdigit(*actptr)) {        /*Hex-Zahl vorhanden?*/
  581.          errornum = 4;            /*nein, dann Fehler*/
  582.          break;
  583.         }
  584.        if (!sscanf(actptr,"%x",&fuse_chk)) {
  585.          errornum = 3;
  586.          break;
  587.         }
  588.        while (isxdigit(*actptr))        /*eingelesene Hex-Zahl über-*/
  589.          actptr++;                /*springen*/
  590.        Cflag = 1;
  591.        break;
  592.  
  593.  
  594.      case 'L':            /*Fuse-Adresse*/
  595.        if (Cflag) {            /*nach *C kein *L mehr*/
  596.          errornum = 10;
  597.          break;
  598.         }
  599.        actptr++;
  600.        if (!isdigit(*actptr)) {        /*Dez-Zahl vorhanden?*/
  601.          errornum = 4;            /*nein, dann Fehler*/
  602.          break;
  603.         }
  604.        if (!sscanf(actptr,"%d",&num)) {
  605.          errornum = 3;
  606.          break;
  607.         }
  608.        while (isdigit(*actptr))        /*eingelesene Zahl über-*/
  609.          actptr++;                /*springen*/
  610.        if (num < fuse) {            /* Fuse-Adresse zu klein?*/
  611.          errornum = 17;
  612.          break;
  613.         }
  614.        if ((num > fuse) && !Fflag) {    /*Fuse-Adresse übersprungen*/
  615.          errornum = 18;            /*aber kein *F vorhanden?*/
  616.          break;
  617.         }
  618.        if (SearchNextChar()) {        /*kein Zeichen mehr da?*/
  619.          errornum = 1;            /*dann unerwartetes Ende*/
  620.          break;
  621.         }
  622.        fuse = num;
  623.        for (;;) {                /*Fuses auswerten*/
  624.          if ((*actptr == '1') || (*actptr == '0')) {
  625.            *(jedbuff + (long)fuse) = *actptr - '0';
  626.           }
  627.          else {
  628.            if (*actptr == '*')        /*nächste Anweisung?*/
  629.          break;                /*ja, dann fertig*/
  630.            else {                /*nein, dann Fehler*/
  631.          errornum = 19;            /* '*' erwartet*/
  632.          break;
  633.         }
  634.           }
  635.          if (SearchNextChar()) {        /*kein Zeichen mehr da?*/
  636.            errornum = 1;            /*dann unerwartetes Ende*/
  637.            break;
  638.           }
  639.          fuse++;
  640.         }
  641.        Lflag = 1;
  642.        break;
  643.  
  644.  
  645.      case 'G':            /*Security*/
  646.        if (QPflag) {            /*Befehl darf innerhalb des*/
  647.          errornum = 8;            /*Jedec-Files nur einmal*/
  648.          break;                /*vorkommen*/
  649.         }
  650.        actptr++;
  651.        if (*actptr == '0')
  652.          JedecSecurity = 0;
  653.        else
  654.          if (*actptr == '1')
  655.            JedecSecurity = 1;
  656.          else {                /*weder 0 noch 1 nach G*/
  657.            errornum = 5;            /*dann Fehler*/
  658.            break;
  659.           }
  660.        Gflag = 1;
  661.        break;
  662.  
  663.  
  664.      case 0x02:            /* <STX> */
  665.        break;
  666.  
  667.  
  668.      case 0x03:            /* <ETX> gefolgt von File-Checksumme*/
  669.        ptr = filebuff;
  670.        file_chk = 0;
  671.        while (*ptr) {
  672.          if (*ptr == 0x02) {            /* <STX> */
  673.            if (STXflag) {                /*mehrfach vorhanden*/
  674.          errornum = 12;
  675.          break;
  676.         }
  677.            if (ETXflag) {                /* STX vor ETX? */
  678.          errornum = 14;
  679.          break;
  680.         }
  681.            STXflag = 1;
  682.           }
  683.          if (*ptr == 0x03) {            /* <ETX> */
  684.            if (ETXflag) {                /*mehrfach vorhanden*/
  685.          errornum = 13;
  686.          break;
  687.         }
  688.            if (!STXflag) {                /* STX vor ETX? */
  689.          errornum = 14;
  690.          break;
  691.         }
  692.            ETXflag = 1;
  693.           }
  694.          if (STXflag && !ETXflag)            /*Summe bilden*/
  695.            file_chk += *ptr;
  696.          ptr++;
  697.         }
  698.        file_chk += 0x03;                /*ETX dazuaddieren*/
  699.        actptr++;
  700.        if (!isxdigit(*actptr)) {        /*Hex-Zahl vorhanden?*/
  701.          errornum = 4;            /*nein, dann Fehler*/
  702.          break;
  703.         }
  704.        if (!sscanf(actptr,"%x",&num)) {
  705.          errornum = 3;
  706.          break;
  707.         }
  708.        while (isxdigit(*actptr))            /*Hex-Zahl überspringen*/
  709.          actptr++;
  710.        if (file_chk != num) {
  711.          if (!MyRequest(CONT_REQ, (UBYTE *)"File-Checksumme falsch: weiter machen?")) {
  712.            errornum = 16;
  713.            break;
  714.           }
  715.         }
  716.        FCHKflag = 1;
  717.        break;
  718.         }
  719.  
  720.  
  721.        if (errornum) {            /*Fehler aufgetreten? dann Ende*/
  722.          FreeMem(jedbuff,(long)NUMOFFUSES20);    /*Puffer für Jedec-Struktur*/
  723.      FreeMem(filebuff,filesize);        /*Puffer für Jedec-File*/
  724.      JedecError(errornum,YES);
  725.      return(errornum);
  726.     }
  727.  
  728.        if (FCHKflag)                /*File-Checksumme?*/
  729.      break;                    /*dann for-Schleife beenden*/
  730.  
  731.        if (SearchNextAsterix())         /*abschließendes '*' suchen*/
  732.      errornum = 9;
  733.  
  734.       }
  735.  
  736.  
  737.      if (!Lflag && !Fflag) {            /*keine Fuses angegeben?*/
  738.        FreeMem(filebuff,filesize);        /*dann Fehler*/
  739.        FreeMem(jedbuff,(long)NUMOFFUSES20);    /*Puffer für Jedec-Struktur*/
  740.        JedecError(21,NO);
  741.        return(21);
  742.       }
  743.  
  744.      if (QFflag) {            /*Diskrepanz zwischen *QF und *L..?*/
  745.        if (((fuse != QF) && !Fflag) || (fuse > QF)) {
  746.      FreeMem(filebuff,filesize);        /*dann Fehler*/
  747.          FreeMem(jedbuff,(long)NUMOFFUSES20);    /*Puffer für Jedec-Struktur*/
  748.      JedecError(20,NO);
  749.      return(20);
  750.     }
  751.        }
  752.      else {
  753.        if (Fflag) {
  754.      if ((fuse > 2194) && (fuse <= 2706))
  755.        JedecGALType = GAL20V8;
  756.      if (fuse <= 2194)
  757.        JedecGALType = GAL16V8;
  758.      if (fuse > 2706) {
  759.            FreeMem(jedbuff,(long)NUMOFFUSES20);    /*Puffer für Jedec-Struktur*/
  760.        FreeMem(filebuff,filesize);
  761.        JedecError(6,NO);
  762.        return(23);
  763.       }
  764.     }
  765.        else {
  766.          if ((fuse != 2194) && (fuse != 2706)) {
  767.            FreeMem(jedbuff,(long)NUMOFFUSES20); /*Puffer für Jedec-Struktur*/
  768.        FreeMem(filebuff,filesize);
  769.        JedecError(6,NO);
  770.        return(6);
  771.       }
  772.          if (fuse == 2194)
  773.        JedecGALType = GAL16V8;
  774.          if (fuse == 2706)
  775.        JedecGALType = GAL20V8;
  776.     }
  777.       }
  778.  
  779.      if (FCHKflag)                /*File-Checksumme?*/
  780.        if (!SearchNextChar()) {            /*noch Zeichen vorhanden?*/
  781.      FreeMem(filebuff,filesize);        /*dann Fehler*/
  782.          FreeMem(jedbuff,(long)NUMOFFUSES20);    /*Puffer für Jedec-Struktur*/
  783.      JedecError(15,YES);
  784.      return(15);
  785.     }
  786.  
  787.      for (n=0; n<sizeof(Jedec); n++) {        /*Jedec-Struktur init.*/
  788.        if (JedecGALType == GAL16V8) {
  789.      if ((n > 2047) && (n < 2560))
  790.        Jedec.GALLogic[n] = 0;
  791.      else {
  792.         Jedec.GALLogic[n] = *jedptr;
  793.        jedptr++;
  794.       }
  795.         }
  796.        if (JedecGALType == GAL20V8) {
  797.        Jedec.GALLogic[n] = *jedptr;
  798.          jedptr++;
  799.     }
  800.       }
  801.  
  802.      if (Cflag) {
  803.        if (fuse_chk != FuseChecksum(JedecGALType)) {
  804.          if (!MyRequest(CONT_REQ, (UBYTE *)"Fuse-Checksumme falsch: weiter machen?")) {
  805.        FreeMem(filebuff,filesize);        /*dann Fehler*/
  806.            FreeMem(jedbuff,(long)NUMOFFUSES20);    /*Puffer für Jedec-Struktur*/
  807.        JedecError(11,NO);
  808.        return(11);
  809.       }
  810.         }
  811.       }
  812.  
  813.      FreeMem(jedbuff,(long)NUMOFFUSES20);    /*Puffer für Jedec-Struktur*/
  814.      FreeMem(filebuff,filesize);        /*Puffer für Jedec-File*/
  815.      return(0);                    /*kein Fehler aufgetreten*/
  816.     }
  817.    else {
  818.      ErrorReq(3);                /*Lesefehler*/
  819.      FreeMem(filebuff,filesize);
  820.      return(-2);
  821.     }
  822.   }
  823.  else {
  824.    ErrorReq(2);                    /*kein Speicher*/
  825.    return(-2);
  826.   }
  827.  
  828. }
  829.  
  830.  
  831.  
  832.  
  833.  
  834.  
  835.  
  836. /*gibt Fehlermeldung aus
  837.   flag gibt an, ob mit oder ohne Zeilenangabe
  838. */
  839. void JedecError(errornum, flag)
  840. int    errornum, flag;
  841. {
  842.  if (flag)
  843.    PrintErrorLine(linenum);
  844.  
  845.  switch (errornum) {
  846.    case  1: { PrintText((UBYTE *)"unerwartetes Dateiende",1);
  847.           break;
  848.         }
  849.    case  2: { PrintText((UBYTE *)"unbekannte Anweisung gefunden",1);
  850.           break;
  851.         }
  852.    case  3: { PrintText((UBYTE *)"falsches Zahlenformat nach Anweisung",1);
  853.           break;
  854.         }
  855.    case  4: { PrintText((UBYTE *)"erwarte unmittelbar nach einer Anweisung eine Zahl",1);
  856.           break;
  857.         }
  858.    case  5: { PrintText((UBYTE *)"habe unmittelbar nach der Anweisung eine 0 oder 1 erwartet",1);
  859.           break;
  860.         }
  861.    case  6: { PrintText((UBYTE *)"keine eindeutige GAL-Typ-Bestimmung möglich",1);
  862.           break;
  863.         }
  864.    case  7: { PrintText((UBYTE *)"Anweisung QF mehrfach vorhanden",1);
  865.           break;
  866.         }
  867.    case  8: { PrintText((UBYTE *)"Anweisung QP mehrfach vorhanden",1);
  868.           break;
  869.         }
  870.    case  9: { PrintText((UBYTE *)"habe abschließendes '*' erwartet",1);
  871.           break;
  872.         }
  873.    case 10: { PrintText((UBYTE *)"nach 'C' keine weiteren 'L' mehr erlaubt",1);
  874.           break;
  875.         }
  876.    case 11: { PrintText((UBYTE *)"Fuse-Checksumme stimmt nicht",1);
  877.           break;
  878.         }
  879.    case 12: { PrintText((UBYTE *)"<STX> Steuerzeichen (= CTRL-B, 0x02) mehrfach vorhanden",1);
  880.           break;
  881.         }
  882.    case 13: { PrintText((UBYTE *)"<ETX> Steuerzeichen (= CTRL-C, 0x03) mehrfach vorhanden",1);
  883.           break;
  884.         }
  885.    case 14: { PrintText((UBYTE *)"Reihenfolge der Steuerzeichen <STX> und <ETX> stimmt nicht",1);
  886.           break;
  887.         }
  888.    case 15: { PrintText((UBYTE *)"nach der File-Checksumme wird das Datei-Ende erwartet",1);
  889.           break;
  890.         }
  891.    case 16: { PrintText((UBYTE *)"File-Checksumme stimmt nicht",1);
  892.           break;
  893.         }
  894.    case 17: { PrintText((UBYTE *)"Überlappung von Fuse-Adressen (L... zu klein)",1);
  895.           break;
  896.         }
  897.    case 18: { PrintText((UBYTE *)"Fuse-Adressen übersprungen, aber kein Default-Wert (F0/1) angegeben",1);
  898.           break;
  899.         }
  900.    case 19: { PrintText((UBYTE *)"habe '*' erwartet",1);
  901.           break;
  902.         }
  903.    case 20: { PrintText((UBYTE *)"Diskrepanz zwischen QF... und letzter Fuse-Adresse L...",1);
  904.           break;
  905.         }
  906.    case 21: { PrintText((UBYTE *)"keine Fuses (weder F0/1 noch L...) vorhanden",1);
  907.           break;
  908.         }
  909.    case 22: { PrintText((UBYTE *)"nur QF2194 * (GAL16V8) und QF2706 * (GAL20V8) erlaubt",1);
  910.           break;
  911.         }
  912.    case 23: { PrintText((UBYTE *)"es sind zu viele Sicherungen im JEDEC-File (>2706)",1);
  913.           break;
  914.         }
  915.    case 24: { PrintText((UBYTE *)"es sind mehrere Fuse-Checksummen vorhanden",1);
  916.           break;
  917.         }
  918.    case 25: { PrintText((UBYTE *)"eingestellter GAL-Typ paßt nicht zum JEDEC-File",1);
  919.           break;
  920.         }
  921.   }
  922.  ErrorReq(5);
  923.  
  924. }
  925.  
  926.  
  927.  
  928.  
  929.