/****************************************************************/
/*								*/
/* Reasm.c - this file includes the Reassembler			*/
/*								*/
/*								*/
/****************************************************************/


#include <exec/memory.h>
#include <libraries/dos.h>
#include <intuition/intuition.h>
#include <intuition/gadgetclass.h>
#include <libraries/gadtools.h>
#include <libraries/locale.h>
#include <ctype.h>
#include <string.h>

#include <proto/locale.h>
#include <proto/reqtools.h>
#include <proto/intuition.h>
#include <proto/gadtools.h>
#include <proto/exec.h>
#include <proto/dos.h>

#include "GALer.h"
#include "Localize.h"



/**************************** defines  *********************************/

#define GD_RAsmGad01		1	/* GadgetID muß mit Pinnummer */
#define GD_RAsmGad02		2	/* übereinstimmen */
#define GD_RAsmGad03		3
#define GD_RAsmGad04		4
#define GD_RAsmGad05		5
#define GD_RAsmGad06		6
#define GD_RAsmGad07		7
#define GD_RAsmGad08		8
#define GD_RAsmGad09		9
#define GD_RAsmGad10		10
#define GD_RAsmGad11		11
#define GD_RAsmGad12		12
#define GD_RAsmGad13		13
#define GD_RAsmGad14		14
#define GD_RAsmGad15		15
#define GD_RAsmGad16		16
#define GD_RAsmGad17		17
#define GD_RAsmGad18		18
#define GD_RAsmGad19		19
#define GD_RAsmGad20		20
#define GD_RAsmGad21		21
#define GD_RAsmGad22		22
#define GD_RAsmGad23		23
#define GD_RAsmGad24		24

#define GD_RAsmGad30		30
#define GD_RAsmGad31		31
#define GD_RAsmGad32		32
#define GD_RAsmGad33		33





/************************** extern variables ****************************/

extern	struct  AppString { LONG   as_ID;
		 	    STRPTR as_Str;
			  };

extern	struct  AppString AppStrings[];

extern	int OLMCSize22V10[];

extern	int ToOLMC20RA10[];


extern	char	path[];
extern	int	JedecGALType;
extern	char	filename[];			/*Puffer für Filenamen*/
extern	struct	JedecStruct	Jedec;
extern	struct	Window		*window;
extern	struct	Screen		*screen;
extern	struct	Gadget		*RAsm16GList, *RAsm20GList;
extern	struct	Catalog		*catalog;





/*************************** variables  *********************************/


					/* this vectors show which column of */
					/* the logic array is connected to */
					/* which pin */
int FuseToPin16Mode1[] = { 2,1,3,19,4,18,5,17,6,14,7,13,8,12,9,11 };
int FuseToPin16Mode2[] = { 2,1,3,18,4,17,5,16,6,15,7,14,8,13,9,11 };
int FuseToPin16Mode3[] = { 2,19,3,18,4,17,5,16,6,15,7,14,8,13,9,12 };

int FuseToPin20Mode1[] = { 2,1,3,23,4,22,5,21,6,20,7,17,8,16,9,15,10,14,11,13 };
int FuseToPin20Mode2[] = { 2,1,3,23,4,21,5,20,6,19,7,18,8,17,9,16,10,14,11,13 };
int FuseToPin20Mode3[] = { 2,23,3,22,4,21,5,20,6,19,7,18,8,17,9,16,10,15,11,14 };

int FuseToPin22V10[]   = { 1,23,2,22,3,21,4,20,5,19,6,18,7,17,8,16,9,15,10,14,11,13 };

int FuseToPin20RA10[]  = { 2,23,3,22,4,21,5,20,6,19,7,18,8,17,9,16,10,15,11,14 };


					/* this vector shows which OLMC is */
					/* connected to which row */
int OLMCToRow22V10[]   = { 1, 10, 21, 34, 49, 66, 83, 98, 111, 122 };



				/* gadgets for GAL16V8 */

UWORD RAsm16GTypes[] = {
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	BUTTON_KIND,
	BUTTON_KIND,
	BUTTON_KIND,
	BUTTON_KIND
};

struct NewGadget RAsm16NGad[] = {
	16, 11, 93, 12, (UBYTE *)" 1", NULL, GD_RAsmGad01, PLACETEXT_RIGHT, NULL, NULL,
	16, 23, 93, 12, (UBYTE *)" 2", NULL, GD_RAsmGad02, PLACETEXT_RIGHT, NULL, NULL,
	16, 35, 93, 12, (UBYTE *)" 3", NULL, GD_RAsmGad03, PLACETEXT_RIGHT, NULL, NULL,
	16, 47, 93, 12, (UBYTE *)" 4", NULL, GD_RAsmGad04, PLACETEXT_RIGHT, NULL, NULL,
	16, 59, 93, 12, (UBYTE *)" 5", NULL, GD_RAsmGad05, PLACETEXT_RIGHT, NULL, NULL,
	16, 71, 93, 12, (UBYTE *)" 6", NULL, GD_RAsmGad06, PLACETEXT_RIGHT, NULL, NULL,
	16, 83, 93, 12, (UBYTE *)" 7", NULL, GD_RAsmGad07, PLACETEXT_RIGHT, NULL, NULL,
	16, 95, 93, 12, (UBYTE *)" 8", NULL, GD_RAsmGad08, PLACETEXT_RIGHT, NULL, NULL,
	16, 107, 93, 12, (UBYTE *)" 9", NULL, GD_RAsmGad09, PLACETEXT_RIGHT, NULL, NULL,
	15, 119, 93, 12, (UBYTE *)"10", NULL, GD_RAsmGad10, PLACETEXT_RIGHT, NULL, NULL,
	179, 119, 93, 12, (UBYTE *)"11", NULL, GD_RAsmGad11, PLACETEXT_LEFT, NULL, NULL,
	179, 107, 93, 12, (UBYTE *)"12", NULL, GD_RAsmGad12, PLACETEXT_LEFT, NULL, NULL,
	179, 95, 93, 12, (UBYTE *)"13", NULL, GD_RAsmGad13, PLACETEXT_LEFT, NULL, NULL,
	179, 83, 93, 12, (UBYTE *)"14", NULL, GD_RAsmGad14, PLACETEXT_LEFT, NULL, NULL,
	179, 71, 93, 12, (UBYTE *)"15", NULL, GD_RAsmGad15, PLACETEXT_LEFT, NULL, NULL,
	179, 59, 93, 12, (UBYTE *)"16", NULL, GD_RAsmGad16, PLACETEXT_LEFT, NULL, NULL,
	179, 47, 93, 12, (UBYTE *)"17", NULL, GD_RAsmGad17, PLACETEXT_LEFT, NULL, NULL,
	179, 35, 93, 12, (UBYTE *)"18", NULL, GD_RAsmGad18, PLACETEXT_LEFT, NULL, NULL,
	179, 23, 93, 12, (UBYTE *)"19", NULL, GD_RAsmGad19, PLACETEXT_LEFT, NULL, NULL,
	179, 11, 93, 12, (UBYTE *)"20", NULL, GD_RAsmGad20, PLACETEXT_LEFT, NULL, NULL,
	193, 155, 79, 14, NULL, NULL, GD_RAsmGad30, PLACETEXT_IN, NULL, NULL,
	16,  155, 79, 14, NULL, NULL, GD_RAsmGad31, PLACETEXT_IN, NULL, NULL,
	117, 149, 54, 12, NULL, NULL, GD_RAsmGad32, PLACETEXT_IN, NULL, NULL,
	117, 163, 54, 12, NULL, NULL, GD_RAsmGad33, PLACETEXT_IN, NULL, NULL
};

ULONG RAsm16GTags[] = {
	(GTST_String), (ULONG)"P1", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGRIGHT), (TAG_DONE),
	(GTST_String), (ULONG)"P2", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGRIGHT), (TAG_DONE),
	(GTST_String), (ULONG)"P3", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGRIGHT), (TAG_DONE),
	(GTST_String), (ULONG)"P4", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGRIGHT), (TAG_DONE),
	(GTST_String), (ULONG)"P5", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGRIGHT), (TAG_DONE),
	(GTST_String), (ULONG)"P6", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGRIGHT), (TAG_DONE),
	(GTST_String), (ULONG)"P7", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGRIGHT), (TAG_DONE),
	(GTST_String), (ULONG)"P8", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGRIGHT), (TAG_DONE),
	(GTST_String), (ULONG)"P9", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGRIGHT), (TAG_DONE),
	(GTST_String), (ULONG)"GND", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGRIGHT), (TAG_DONE),
	(GTST_String), (ULONG)"P11", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGLEFT), (TAG_DONE),
	(GTST_String), (ULONG)"P12", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGLEFT), (TAG_DONE),
	(GTST_String), (ULONG)"P13", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGLEFT), (TAG_DONE),
	(GTST_String), (ULONG)"P14", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGLEFT), (TAG_DONE),
	(GTST_String), (ULONG)"P15", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGLEFT), (TAG_DONE),
	(GTST_String), (ULONG)"P16", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGLEFT), (TAG_DONE),
	(GTST_String), (ULONG)"P17", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGLEFT), (TAG_DONE),
	(GTST_String), (ULONG)"P18", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGLEFT), (TAG_DONE),
	(GTST_String), (ULONG)"P19", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGLEFT), (TAG_DONE),
	(GTST_String), (ULONG)"VCC", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGLEFT), (TAG_DONE),
	(TAG_DONE),
	(TAG_DONE),
	(TAG_DONE),
	(TAG_DONE)
};




			/* gadgets for GAL20V8,22V10,20RA10 */


UWORD RAsm20GTypes[] = {
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	STRING_KIND,
	BUTTON_KIND,
	BUTTON_KIND,
	BUTTON_KIND,
	BUTTON_KIND
};

struct NewGadget RAsm20NGad[] = {
	16, 1, 93, 12, (UBYTE *)" 1", NULL, GD_RAsmGad01, PLACETEXT_RIGHT, NULL, NULL,
	16, 13, 93, 12, (UBYTE *)" 2", NULL, GD_RAsmGad02, PLACETEXT_RIGHT, NULL, NULL,
	16, 25, 93, 12, (UBYTE *)" 3", NULL, GD_RAsmGad03, PLACETEXT_RIGHT, NULL, NULL,
	16, 37, 93, 12, (UBYTE *)" 4", NULL, GD_RAsmGad04, PLACETEXT_RIGHT, NULL, NULL,
	16, 49, 93, 12, (UBYTE *)" 5", NULL, GD_RAsmGad05, PLACETEXT_RIGHT, NULL, NULL,
	16, 61, 93, 12, (UBYTE *)" 6", NULL, GD_RAsmGad06, PLACETEXT_RIGHT, NULL, NULL,
	16, 73, 93, 12, (UBYTE *)" 7", NULL, GD_RAsmGad07, PLACETEXT_RIGHT, NULL, NULL,
	16, 85, 93, 12, (UBYTE *)" 8", NULL, GD_RAsmGad08, PLACETEXT_RIGHT, NULL, NULL,
	16, 97, 93, 12, (UBYTE *)" 9", NULL, GD_RAsmGad09, PLACETEXT_RIGHT, NULL, NULL,
	16, 109, 93, 12, (UBYTE *)"10", NULL, GD_RAsmGad10, PLACETEXT_RIGHT, NULL, NULL,
	16, 121, 93, 12, (UBYTE *)"11", NULL, GD_RAsmGad11, PLACETEXT_RIGHT, NULL, NULL,
	16, 133, 93, 12, (UBYTE *)"12", NULL, GD_RAsmGad12, PLACETEXT_RIGHT, NULL, NULL,
	179, 133, 93, 12, (UBYTE *)"13", NULL, GD_RAsmGad13, PLACETEXT_LEFT, NULL, NULL,
	179, 121, 93, 12, (UBYTE *)"14", NULL, GD_RAsmGad14, PLACETEXT_LEFT, NULL, NULL,
	179, 109, 93, 12, (UBYTE *)"15", NULL, GD_RAsmGad15, PLACETEXT_LEFT, NULL, NULL,
	179, 97, 93, 12, (UBYTE *)"16", NULL, GD_RAsmGad16, PLACETEXT_LEFT, NULL, NULL,
	179, 85, 93, 12, (UBYTE *)"17", NULL, GD_RAsmGad17, PLACETEXT_LEFT, NULL, NULL,
	179, 73, 93, 12, (UBYTE *)"18", NULL, GD_RAsmGad18, PLACETEXT_LEFT, NULL, NULL,
	179, 61, 93, 12, (UBYTE *)"19", NULL, GD_RAsmGad19, PLACETEXT_LEFT, NULL, NULL,
	179, 49, 93, 12, (UBYTE *)"20", NULL, GD_RAsmGad20, PLACETEXT_LEFT, NULL, NULL,
	179, 37, 93, 12, (UBYTE *)"21", NULL, GD_RAsmGad21, PLACETEXT_LEFT, NULL, NULL,
	179, 25, 93, 12, (UBYTE *)"22", NULL, GD_RAsmGad22, PLACETEXT_LEFT, NULL, NULL,
	179, 13, 93, 12, (UBYTE *)"23", NULL, GD_RAsmGad23, PLACETEXT_LEFT, NULL, NULL,
	179, 1, 93, 12, (UBYTE *)"24", NULL, GD_RAsmGad24, PLACETEXT_LEFT, NULL, NULL,
	193, 155, 79, 14, NULL, NULL, GD_RAsmGad30, PLACETEXT_IN, NULL, NULL,
	16,  155, 79, 14, NULL, NULL, GD_RAsmGad31, PLACETEXT_IN, NULL, NULL,
	117, 149, 54, 12, NULL, NULL, GD_RAsmGad32, PLACETEXT_IN, NULL, NULL,
	117, 163, 54, 12, NULL, NULL, GD_RAsmGad33, PLACETEXT_IN, NULL, NULL
};

ULONG RAsm20GTags[] = {
	(GTST_String), (ULONG)"P1", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGRIGHT), (TAG_DONE),
	(GTST_String), (ULONG)"P2", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGRIGHT), (TAG_DONE),
	(GTST_String), (ULONG)"P3", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGRIGHT), (TAG_DONE),
	(GTST_String), (ULONG)"P4", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGRIGHT), (TAG_DONE),
	(GTST_String), (ULONG)"P5", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGRIGHT), (TAG_DONE),
	(GTST_String), (ULONG)"P6", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGRIGHT), (TAG_DONE),
	(GTST_String), (ULONG)"P7", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGRIGHT), (TAG_DONE),
	(GTST_String), (ULONG)"P8", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGRIGHT), (TAG_DONE),
	(GTST_String), (ULONG)"P9", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGRIGHT), (TAG_DONE),
	(GTST_String), (ULONG)"P10", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGRIGHT), (TAG_DONE),
	(GTST_String), (ULONG)"P11", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGRIGHT), (TAG_DONE),
	(GTST_String), (ULONG)"GND", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGRIGHT), (TAG_DONE),
	(GTST_String), (ULONG)"P13", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGLEFT), (TAG_DONE),
	(GTST_String), (ULONG)"P14", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGLEFT), (TAG_DONE),
	(GTST_String), (ULONG)"P15", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGLEFT), (TAG_DONE),
	(GTST_String), (ULONG)"P16", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGLEFT), (TAG_DONE),
	(GTST_String), (ULONG)"P17", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGLEFT), (TAG_DONE),
	(GTST_String), (ULONG)"P18", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGLEFT), (TAG_DONE),
	(GTST_String), (ULONG)"P19", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGLEFT), (TAG_DONE),
	(GTST_String), (ULONG)"P20", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGLEFT), (TAG_DONE),
	(GTST_String), (ULONG)"P21", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGLEFT), (TAG_DONE),
	(GTST_String), (ULONG)"P22", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGLEFT), (TAG_DONE),
	(GTST_String), (ULONG)"P23", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGLEFT), (TAG_DONE),
	(GTST_String), (ULONG)"VCC", (GTST_MaxChars), 9, (STRINGA_Justification), (GACT_STRINGLEFT), (TAG_DONE),
	(TAG_DONE),
	(TAG_DONE),
	(TAG_DONE),
	(TAG_DONE)
};



/***************************** routines  ********************************/



/* this routine returns the pointer to the String-Gadget-text of the
** pin 'pinnum'
*/
UBYTE *PinNamePtr(int pinnum, struct Gadget *gadget)
{

 while (gadget) {

   if (gadget->GadgetID == pinnum)
     return (((struct StringInfo *)gadget->SpecialInfo)->Buffer);

   gadget = gadget->NextGadget;

 }

 return((UBYTE *)0);
}





/* CheckPinNames: checks 'syntax' pinnames
   Call:    result = CheckPinNames();
	    JedecGALType must be the type of GAL
   Result:  result = 0: o.k.
	           <>0: error number
*/
int CheckPinNames(void)
{
struct	Gadget	*glist;
UBYTE	*ptr;
int	numofpins, i, j, l, n;


  if (JedecGALType == GAL16V8) {
    numofpins = 20;
    glist = RAsm16GList;
  }
  else {
    numofpins = 24;
    glist = RAsm20GList;
  }

					/*** check the pin names ***/
  for (n = 0; n < numofpins; n++) {

    ptr = PinNamePtr(n+1, glist);		/*are all characters of the*/
						/*pin name allowed? */
    if (*ptr == '/')
      ptr++;

    if (!*ptr) {				/*no characters? => error*/
      ReasmError(4, n+1);
      return(4);
    }

    while (isalpha(*ptr) || isdigit(*ptr))
      ptr++;

    if (*ptr == '/') {
      ReasmError(6, n+1);
      return(6);
    }

    if (*ptr) {
      ReasmError(3, n+1);
      return(3);
    }

    for (l=0; l<n; l++) {			/*pin name twice?*/
      if (strcmp((char *)PinNamePtr(l+1, glist), "NC")) {
        i = j = 0;

        if (*(PinNamePtr(l+1, glist)) == '/') i = 1;

        if (*(PinNamePtr(n+1, glist)) == '/') j = 1;

        if (!strcmp((char *)PinNamePtr(l+1, glist) + (long)i, (char *)PinNamePtr(n+1, glist) + (long)j)) {
	  ReasmError(2, n+1);
	  return(2);
        }
      }
    }
					/*GND as pin name at GAL's GND pin?*/
    if (!strcmp((char *)PinNamePtr(n+1, glist), "GND")) {
      if (n+1 != numofpins/2) {
        ReasmError(5, n+1);
        return(5);
      }
    }

    if (n+1 == numofpins/2) {
      if (strcmp((char *)PinNamePtr(n+1, glist), "GND")) {
        ReasmError(7, n+1);
        return(7);
      }
    }
					/*VCC as pin name at GAL's VCC pin?*/
    if (!strcmp((char *)PinNamePtr(n+1, glist), "VCC")) {
      if (n+1 != numofpins) {
        ReasmError(5, n+1);
        return(5);
      }
    }

    if (n+1 == numofpins) {
      if (strcmp((char *)PinNamePtr(n+1, glist), "VCC")) {
        ReasmError(8, n+1);
        return(8);
      }
     }
					/* AR and SP are key words for 22V10 */
					/* they are not allowed in the pin */
					/* declaration */
    if (JedecGALType == GAL22V10) {
      if (!strcmp((char *)PinNamePtr(n+1, glist), "AR")) {
        ReasmError(9, n+1);
        return(9);
      }

      if (!strcmp((char *)PinNamePtr(n+1, glist), "SP")) {
        ReasmError(10, n+1);
        return(10);
      }
    }


  }

  return(0);
}




/* PinNameRequester: brings up requester in which you can edit the names
		    of the pins
   Call     : result = PinNameRequester(galtype);
   Parameter: galtype: type of GAL
   Result   : result = 0: Continue selected
		     = 1: Cancel selected or error
*/
int PinNameRequester(int galtype)
{
struct	Window 	        *reasmwin;
struct	IntuiMessage	*imsg;
struct	Gadget		*glist, *gadget;
ULONG	class;
USHORT	code, gadID;
UWORD   offy = screen->WBorTop + screen->RastPort.TxHeight + 1;
int	n, numofpins;
char	name[4], numstrng[3];

  if (galtype == GAL16V8) {		/* initialize variables */
    numofpins = 20;
    glist     = RAsm16GList;
  }
  else {
    numofpins = 24;
    glist     = RAsm20GList;
  }

					/* open window */
  if (!(reasmwin = OpenWindowTags( NULL,
			WA_Left,	 171,
			WA_Top,		 5,
			WA_Width,	 297,
			WA_Height,	 180 + offy,
			WA_IDCMP,	 STRINGIDCMP|BUTTONIDCMP|IDCMP_REFRESHWINDOW|IDCMP_VANILLAKEY,
			WA_Flags,	 WFLG_DRAGBAR|WFLG_DEPTHGADGET|WFLG_SMART_REFRESH|WFLG_ACTIVATE,
			WA_Gadgets,	 glist,
			WA_Title,	 (UBYTE *)"Reassembler",
			WA_CustomScreen, screen,
			TAG_DONE )))
    return(1);


  GT_RefreshWindow(reasmwin, NULL);




  for (;;) {

    Wait (1 << reasmwin->UserPort->mp_SigBit);

    while (imsg = GT_GetIMsg(reasmwin->UserPort)) {

      class = imsg->Class;
      code  = imsg->Code;

      if (class == GADGETUP)
	gadID = ((struct Gadget *)imsg->IAddress)->GadgetID;

      GT_ReplyIMsg(imsg);


      if (class == VANILLAKEY) {
	if (code == 13) {			/* Return-key => Continue */
	  if (!CheckPinNames()) {
	    CloseWindow(reasmwin);
	    return(0);
	  }
	}

	if (code == 0x1B) {			/* ESC-key => Cancel */
	  CloseWindow(reasmwin);
	  return(1);
        }
      }

      if (class == GADGETUP) {

	switch (gadID) {

	  case GD_RAsmGad30:				/* Cancel */
		CloseWindow(reasmwin);
		return(1);

	  case GD_RAsmGad31:				/* Continue */
		if (!CheckPinNames()) {
		  CloseWindow(reasmwin);
		  return(0);
		}
		break;

	  case GD_RAsmGad32:				/* Clear */
		gadget = glist;			/* reset name of pins */

		while (gadget) {
		  if ((gadget->GadgetID < numofpins) &&
		      (gadget->GadgetID != numofpins/2))
		    GT_SetGadgetAttrs(gadget, reasmwin, NULL, GTST_String, NULL, TAG_END);

		  gadget = gadget->NextGadget;
		}
		break;

	  case GD_RAsmGad33:				/* Set */
		gadget = glist;

		while (gadget) {
		  n = (int)gadget->GadgetID;

		  if (n <= numofpins) {
		    if (n == numofpins/2)
		      GT_SetGadgetAttrs(gadget, reasmwin, NULL, GTST_String, "GND", TAG_END);
		    else
		      if (n == numofpins)
		        GT_SetGadgetAttrs(gadget, reasmwin, NULL, GTST_String, "VCC", TAG_END);
		      else {
			name[0] = 'P';
			name[1] = (char)0;

			sprintf(numstrng, "%d", n);

			strcat(name, numstrng);

		        GT_SetGadgetAttrs(gadget, reasmwin, NULL, GTST_String, name, TAG_END);
		      }
		  }

		  gadget = gadget->NextGadget;
		}
		break;

	}
      }
    }
  }

  return(1);
}




/*RowActive: tests whether a row of the logic array is active or not
	     checks PT-bit (16V8, 20V8 and searchs for the
	     expression A * /A
  Call:   result = RowActive(row, galtype);
  Para.:    row: row which should be tested
	    galtype: type of GAL
  Result: result = 0: row is not active
		 = 1: row is active
		 = 2: row is active but includes only '1' (means VCC)
*/
int RowActive(int row, int galtype)
{
int n, colsize, flag;


  switch (galtype) {				/* get number of columns */
    case GAL16V8:
      colsize = MAX_FUSE_ADR16 + 1;
      break;

    case GAL20V8:
      colsize = MAX_FUSE_ADR20 + 1;
      break;

    case GAL22V10:
      colsize = MAX_FUSE_ADR22V10 + 1;
      break;

    case GAL20RA10:
      colsize = MAX_FUSE_ADR20RA10 + 1;
      break;
  }


  if (galtype == GAL16V8 || galtype == GAL20V8)
    if (!Jedec.GALPT[row])			/* check PT-bit which */
      return(0);				/* enables/disables a row */

  flag = 0;
  for (n = 0; n < colsize; n++) {		/* search for "A * /A" */
    if (!Jedec.GALLogic[row*colsize+n]) {
      flag = 1;
      if (!(n % 2))
        if (!Jedec.GALLogic[row*colsize+n+1])
          return(0);
    }
  }

  if (flag)
    return(1);
  else
    return(2);
}





/*OLMCOutput: checks whether a OLMC pin is programmed as output
  Call:       result = OLMCOutput(olmc);
  	      olmc:    OLMC which should be tested
	      mode:    mode of GAL (only when 16V8, 20V8)
	      JedecGALType: type of GAL
  Result:     result = 0:  no output
	   	     = 1:  output (there is a equation which describes
				   this output pin)
*/
int OLMCOutput(int olmc, int mode)
{
int n, flag;


  flag = 0;

  if (JedecGALType == GAL16V8 || JedecGALType == GAL20V8) {
    if ((mode == 1) && (Jedec.GALAC1[olmc]))
      return(0);

    for (n = 0; n < 8; n++) {
      if (!n && ((mode == 2) || ((mode == 3) && Jedec.GALAC1[olmc]))) {
        if (!RowActive(olmc * 8, JedecGALType))	/*tristate enable = GND?*/
          return(0);				/*yes, then input pin*/
      }
      else {
        if (RowActive(olmc * 8 + n, JedecGALType))
          flag = 1;
      }
    }
  }


  if (JedecGALType == GAL22V10)		 /* pin is output when tristate */
    if (RowActive(OLMCToRow22V10[olmc], JedecGALType)) /* can be HIGH/LOW */
      return(1);

  if (JedecGALType == GAL20RA10)	 /* pin is output when tristate */
    if (RowActive(olmc * 8, JedecGALType))  /* can be HIGH/LOW */
      return(1);


  return(flag);
}



/*MakeEquation: examines the rows of a OLMC and generates the equation
  Call: result = MakeEquation(buff, olmc, colsize, mode, rowoffset, numofrows);

  Result:   result =  0: no errors
	   	   = -1: error (out of memory)
*/
int MakeEquation(struct ActBuffer *buff, int olmc, int colsize, int mode,
                 int rowoffset, int numofrows)
{
int	ORflag, ANDflag, pin, m, n, result, numofchar;
int	offset, row, lastrow;
struct	ActBuffer  startbuff;


  startbuff = *buff;				/* save pointer*/

  numofchar = 8;
  ORflag    = 0;

  n       = rowoffset;
  lastrow = numofrows + rowoffset;

  while (n < lastrow) {

    if (JedecGALType == GAL22V10) {		/* 22V10 => different sizes */
						/* of OLMCs and additional  */
      row = OLMCToRow22V10[olmc];		/* AS and RS rows           */

      if (mode == 4)
	row = 0;				/* asynch. reset */
      else
	if (mode == 5)
	  row = 131;				/* synch. preset */
    }
    else
      row = olmc * 8;				/* 16V8,20V8,20RA10: OLMC size */
   						/* is constant (=8) */

    result = RowActive(row + n, JedecGALType);


    if (result == 1) {				/* is row active? */

      if (ORflag) {				/* yes, then OR*/
        if (AddString(buff, (UBYTE *)" + "))
	  return(-1);
        numofchar += 3;				/* count characters */
      }

      ORflag  = 1;
      ANDflag = 0;

      for (m = 0; m < colsize; m++) {

	if (JedecGALType == GAL22V10) {		/* 22V10 => different sizes */
						/* of OLMCs and additional  */
	  offset = (OLMCToRow22V10[olmc] + n) * colsize;
						/* AS and RS rows           */
	  if (mode == 4)
	    offset = 0;					/* asynch. reset */
 	  else
	    if (mode == 5)
	      offset = 5764;				/* synch. preset */
	}
	else
	  offset = (olmc * 8 + n) * colsize;	/* 16V8,20V8,20RA10: OLMC size */
						/* is constant (=8) */

        if (!Jedec.GALLogic[offset + m]) {	/* fuse = 0? */

          if (ANDflag) {
            if (AddByte(buff, (UBYTE)'*'))	/* evaluate product term */
 	      return(-1);
	    numofchar++;
          }

          ANDflag = 1;
					/*** GAL16V8 ***/

          if (JedecGALType == GAL16V8) {
            if (mode == 1)			/* get pin number */
	      pin = FuseToPin16Mode1[m/2];

	    if (mode == 2)
	     pin = FuseToPin16Mode2[m/2];

	    if (mode == 3)
	      pin = FuseToPin16Mode3[m/2];
						/* was there a negation in */
						/* in the declaration? */
	    if (((*PinNamePtr(pin, RAsm16GList) == '/') && !(m % 2)) ||
	        ((*PinNamePtr(pin, RAsm16GList) != '/') &&  (m % 2))) {
	      if (AddByte(buff, (UBYTE)'/'))
	        return(-1);
	      numofchar++;
	    }
						/* write pin name without '/' */
	    if (*PinNamePtr(pin, RAsm16GList) == '/') {
	      if (AddString(buff, (PinNamePtr(pin, RAsm16GList) + 1L)))
                return(-1);
	    }
	    else {
	      if (AddString(buff, PinNamePtr(pin, RAsm16GList)))
                return(-1);
	    }

	    numofchar += (int)strlen((char *)PinNamePtr(pin, RAsm16GList));
          }
	  else {			/*** GAL20V8, 22V10, 20RA10 ***/

	    if (JedecGALType == GAL20V8) {
	      if (mode == 1)				/* get pin number */
		pin = FuseToPin20Mode1[m/2];

	      if (mode == 2)
		pin = FuseToPin20Mode2[m/2];

	      if (mode == 3)
		pin = FuseToPin20Mode3[m/2];
	    }

	    if (JedecGALType == GAL22V10)
	      pin = FuseToPin22V10[m/2];

	    if (JedecGALType == GAL20RA10)
	      pin = FuseToPin20RA10[m/2];
						/* was there a negation in */
						/* the pin declaration? */
	    if (((*PinNamePtr(pin, RAsm20GList) == '/') && !(m % 2)) ||
	        ((*PinNamePtr(pin, RAsm20GList) != '/') &&  (m % 2))) {
	      if (AddByte(buff, (UBYTE)'/'))
	        return(-1);
	      numofchar++;
	    }
						/* write pin name without '/' */
	    if (*PinNamePtr(pin, RAsm20GList) == '/') {
	      if (AddString(buff, PinNamePtr(pin, RAsm20GList) + 1L))
                return(-1);
	    }
	    else {
	      if (AddString(buff, PinNamePtr(pin, RAsm20GList)))
                return(-1);
	    }

	    numofchar += (int)strlen((char *)PinNamePtr(pin, RAsm20GList));
	  }


	  if (numofchar > 60) {				/* new line? */
	    if (AddString(buff, (UBYTE *)"\n        "))
	      return(-1);
	    numofchar = 8;
	  }
        }
      }
    }

    if (result == 2) {				/* only '1' in all rows? */
      *buff = startbuff;			/* then VCC */
      if (AddString(buff, (UBYTE *)"VCC"))
        return(-1);
        break;
    }

    n++;
  }

  if (AddString(buff, (UBYTE *)"\n\n"))		/* end of the equation */
    return(-1);

  return(0);
}







/*Reasm: reassemble a JEDEC file and generate the appropriate source file
	 the source file is stored in 'buff'
  Call:  result = Reasm(buff);
  	 buff: ActBuffer structure for buffer in which the source file
	       should be stored
  Result: result = 0: no errors
		 <>0: error
*/
int Reasm(struct ActBuffer buff)
{
int	mode, n, numofpins, byte, tricon;
int	firstOLMC, olmc, colsize, numofOLMCs;
UBYTE   *ptr;

					/*** write type of GAL ***/
  switch (JedecGALType) {
    case GAL16V8:
	if (AddString(&buff, (UBYTE *)"GAL16V8\n"))
	  return(-1);
	numofpins  = 20;
	numofOLMCs = 8;
	colsize    = MAX_FUSE_ADR16 + 1;
	break;
       
    case GAL20V8:
	if (AddString(&buff, (UBYTE *)"GAL20V8\n"))
	  return(-1);
	numofpins  = 24;
	numofOLMCs = 8;
	firstOLMC  = 22;
	colsize    = MAX_FUSE_ADR20 + 1;
	break;

    case GAL22V10:
	if (AddString(&buff, (UBYTE *)"GAL22V10\n"))
	  return(-1);
	numofpins  = 24;
	numofOLMCs = 10;
	firstOLMC  = 23;
	colsize    = MAX_FUSE_ADR22V10 + 1;
	break;

    case GAL20RA10:
	if (AddString(&buff, (UBYTE *)"GAL20RA10\n"))
	  return(-1);
	numofpins  = 24;
	numofOLMCs = 10;
	firstOLMC  = 23;
	colsize    = MAX_FUSE_ADR20RA10 + 1;
	break;
  }



  byte = 0;				/*** write signature ***/
  for (n = 0; n < SIG_SIZE; n++) {
    byte |= Jedec.GALSig[n];			/* put 8 bits to one byte */

    if (!((n+1)%8)) {				/* together */
      if (!isprint(byte))
        byte = '.';

      if (AddByte(&buff, (UBYTE)byte))
        return(-1);

      byte = 0;
    }

    byte <<= 1;
  } 

  if (AddString(&buff, (UBYTE *)"\n\n"))	/* new lines */
    return(-1);


					/*** write pin declaration ***/
  for (n = 1; n <= numofpins; n++) {
    if (JedecGALType == GAL16V8) {
      if (AddString(&buff, PinNamePtr(n, RAsm16GList)))
	return(-1);
    }
    else
      if (AddString(&buff, PinNamePtr(n, RAsm20GList)))
	return(-1);

    if (n == numofpins/2) {
      if (AddString(&buff, (UBYTE *)"\n"))
	return(-1);
    }
    else {
      if (AddString(&buff, (UBYTE *)" "))
	return(-1);
    }
  }

  if (AddString(&buff, (UBYTE *)"\n\n"))
    return(-1);


  mode = 0;

  if (JedecGALType == GAL16V8 || JedecGALType == GAL20V8) {

    if (!Jedec.GALAC0 && !Jedec.GALSYN) {	/* check mode of GAL */
      ReasmError(1, 0);				/* error? then return */
      return(1);
    }
						/* get mode of GAL */
    if (!Jedec.GALSYN) {			/* if SYN = 0 then mode 3 */
      mode = 3;					/* (register) */
    }
    else {
      if (Jedec.GALSYN && Jedec.GALAC0)
        mode = 2;				/* tristate mode */
      else
         mode = 1;				/* combinational mode */
    }
  }

					/*** generate the equations ***/

  for (olmc = 0; olmc < numofOLMCs; olmc++) {	/* all OLMCs */

    tricon = 0;

    if (OLMCOutput(olmc, mode)) {		/* is OLMC a output? */

      if (JedecGALType == GAL16V8) {		/* is there a negation in */
						/* the pin declaration */
        if (((*PinNamePtr(19 - olmc, RAsm16GList) == '/') && Jedec.GALXOR[olmc]) ||
	    ((*PinNamePtr(19 - olmc, RAsm16GList) != '/') && !Jedec.GALXOR[olmc])) {
	  if (AddByte(&buff, (UBYTE)'/'))
	    return(-1);
        }

						/* write pin name without '/' */
        if (*PinNamePtr(19 - olmc, RAsm16GList) == '/') {
	  if (AddString(&buff, ptr = PinNamePtr(19 - olmc, RAsm16GList) + 1L))
            return(-1);
        }
        else {
	  if (AddString(&buff, ptr = PinNamePtr(19 - olmc, RAsm16GList)))
            return(-1);
        }
      }
      else {
						/* write pin name without '/' */
        if (((*PinNamePtr(firstOLMC-olmc, RAsm20GList) == '/') && Jedec.GALXOR[olmc]) ||
	    ((*PinNamePtr(firstOLMC-olmc, RAsm20GList) != '/') && !Jedec.GALXOR[olmc])) {
	  if (AddByte(&buff, (UBYTE)'/'))
	    return(-1);
        }
						/* write pin name without '/' */
        if (*PinNamePtr(firstOLMC - olmc, RAsm20GList) == '/') {
	  if (AddString(&buff, ptr = PinNamePtr(firstOLMC - olmc, RAsm20GList) + 1L))
            return(-1);
        }
        else {
	  if (AddString(&buff, ptr = PinNamePtr(firstOLMC - olmc, RAsm20GList)))
            return(-1);
        }
      }
					/*** get type of output ***/

      if (JedecGALType == GAL16V8 || JedecGALType == GAL20V8) {

        if ((mode == 2) || ((mode == 3) && (Jedec.GALAC1[olmc]))) {
          if (AddString(&buff, (UBYTE *)".T"))
            return(-1);
          tricon = 1;				/* there is a tristate output, */
        }					/* so set tricon flag */

        if ((mode == 3) && (!Jedec.GALAC1[olmc]))
          if (AddString(&buff, (UBYTE *)".R"))
            return(-1);

        if (AddString(&buff, (UBYTE *)" = "))
          return(-1);

        n = 0;					/* if there is a tristate control */
        if ((mode == 2) || ((mode == 3) && Jedec.GALAC1[olmc]))
          n++;					/* skip first row of OLMC */

        if (MakeEquation(&buff, olmc, colsize, mode, n, 8))
          return(-1);

						/* write equation of */
	if (tricon) {				/* tristate control  */

	  if (AddString(&buff, ptr))			/* write pin name */
	    return(-1);

	  if (AddString(&buff, (UBYTE *)".E = "))	/* tristate enable */
	    return(-1);

	  if (MakeEquation(&buff, olmc, colsize, mode, 0, 1)) /* write equation */
	    return(-1);
	}

      }



      if (JedecGALType == GAL22V10) {

	if (Jedec.GALS1[olmc]) {		/* get type of output */
	  if (AddString(&buff, (UBYTE *)".T = "))
	    return(-1);
	}
	else
	  if (AddString(&buff, (UBYTE *)".R = "))
	    return(-1);

						/* write output's equation */
        if (MakeEquation(&buff, olmc, colsize, 0, 1, OLMCSize22V10[olmc]))
          return(-1);

						/* write equation of */
						/* tristate control  */
	if (AddString(&buff, ptr))			/* write pin name */
	  return(-1);

	if (AddString(&buff, (UBYTE *)".E = "))		  /* tristate enable */
	  return(-1);

	if (MakeEquation(&buff, olmc, colsize, mode, 0, 1)) /* write equation */
	  return(-1);

      }



      if (JedecGALType == GAL20RA10) {
						/* write equation of output */
	if (RowActive(ToOLMC20RA10[9 - olmc] + 2, JedecGALType) == 2 &&
	    RowActive(ToOLMC20RA10[9 - olmc] + 3, JedecGALType) == 2) {
	  if (AddString(&buff, (UBYTE *)" = "))		/* if ARST and APRST */
	    return(-1);					/* = VCC, then */
	}						/* tristate output */
	else {
	  if (AddString(&buff, (UBYTE *)".R = "))
	    return(-1);
	}

        if (MakeEquation(&buff, olmc, colsize, 0, 4, 4))
          return(-1);


	if (AddString(&buff, ptr))			/* write equation of */
	  return(-1);					/* tristate enable   */

	if (AddString(&buff, (UBYTE *)".E = "))
	  return(-1);

	if (MakeEquation(&buff, olmc, colsize, 0, 0, 1))
	  return(-1);


	if (RowActive(olmc * 8 + 1, JedecGALType)) {
	  if (AddString(&buff, ptr))			/* write equation of */
	    return(-1);					/* Clock */

	  if (AddString(&buff, (UBYTE *)".CLK = "))
	    return(-1);

	  if (MakeEquation(&buff, olmc, colsize, 0, 1, 1))
	    return(-1);
	}


	if (RowActive(olmc * 8 + 2, JedecGALType)) {
	  if (AddString(&buff, ptr))			/* write equation of */
	    return(-1);					/* asynchronous reset */

	  if (AddString(&buff, (UBYTE *)".ARST = "))
	    return(-1);

	  if (MakeEquation(&buff, olmc, colsize, 0, 2, 1))
	    return(-1);
	}


	if (RowActive(olmc * 8 + 3, JedecGALType)) {
	  if (AddString(&buff, ptr))			/* write equation of */
	    return(-1);					/* asynchronous preset */

	  if (AddString(&buff, (UBYTE *)".APRST = "))
	    return(-1);

	  if (MakeEquation(&buff, olmc, colsize, 0, 3, 1))
	    return(-1);
	}
      }


    }
  }


					/*** write asynchronous reset and ***/
					/*** synchronous preset 	  ***/
  if (JedecGALType == GAL22V10) {

    if (RowActive(0, JedecGALType)) {
      if (AddString(&buff, (UBYTE *)"AR = "))	  /* asyn. reset */
        return(-1);

      if (MakeEquation(&buff, olmc, colsize, 4, 0, 1))
        return(-1);
    }

    if (RowActive(131, JedecGALType)) {
      if (AddString(&buff, (UBYTE *)"SP = "))	  /* synch. preset */
        return(-1);

      if (MakeEquation(&buff, olmc, colsize, 5, 0, 1))
        return(-1);
    }

  }

					/*** write ending text ***/

  if (AddString(&buff,"DESCRIPTION:\nThis is a reassembled file. Used JEDEC file: '"))
    return(-1);

  if (AddString(&buff, (UBYTE *)&filename[0]))
    return(-1);

  if (AddString(&buff, (UBYTE *)"'\n\n"))
    return(-1);

  return(0);				/* no errors, finish*/
}





/*Reassembler: reassemble JEDEC file and generate source file
*/
void Reassembler(void)
{
struct	Buffer		*reasm_buff;
struct	ActBuffer	mybuff;
BPTR 	fh;
UBYTE	*filebuffer, *filebuffer2;
int	result;

 if (MyFileReq(AppStrings[MSG_LOADJED].as_Str, ".jed", YES, LOAD)) {
   if (!(GetJedec((UBYTE *)&path[0]))) {	/*JEDEC-File holen*/

     if (PinNameRequester(JedecGALType))
       return;


     if (!(reasm_buff = (struct Buffer *)AllocMem((long)sizeof(struct Buffer),MEMF_PUBLIC|MEMF_CLEAR))) {
       ErrorReq(2);			/*kein Speicher mehr->Fehlermeldung*/
       return;
     }
     mybuff.ThisBuff = reasm_buff;
     mybuff.Entry    = (UBYTE *)(&reasm_buff->Entries[0]);
     mybuff.BuffEnd  = (UBYTE *)reasm_buff + (long)sizeof(struct Buffer);


     if (!Reasm(mybuff) && MyFileReq(AppStrings[MSG_WRITE_SOURCE].as_Str, ".pld", YES, SAVE)) {
       PrintText(AppStrings[MSG_WRITING_SOURCE].as_Str, 1);
       if ((fh = Open(&path[0], (long)MODE_NEWFILE))) {
         for (;;) {
	   filebuffer = filebuffer2 = mybuff.Entry;

	   while (filebuffer2 < mybuff.BuffEnd) {	/*Größe des Puffers bestimmen*/
	     if (!*filebuffer2) 
	       break;
             filebuffer2++;
	   }
						/*Puffer schreiben*/
	   result = Write(fh, (char *)filebuffer, (long)(filebuffer2-filebuffer));
	   if (result == -1L) {			/*Fehler beim Schreiben?*/
	     Close(fh);				/*ja, dann Ende*/
	     FreeBuffer(reasm_buff);
	     PrintText(AppStrings[MSG_ERROR].as_Str, 0);
	     ErrorReq(13);
	     return;
	   }

	   if (!mybuff.ThisBuff->Next)		/*noch ein Puffer da?*/
	     break;					/*nein, dann for(;;)-Ende*/
	   mybuff.ThisBuff = mybuff.ThisBuff->Next;
	   mybuff.Entry    = (UBYTE *)(&mybuff.ThisBuff->Entries[0]);
	   mybuff.BuffEnd  = (UBYTE *)mybuff.ThisBuff + (long)sizeof(struct Buffer);
         }
         Close(fh);
       }
       else {
         FreeBuffer(reasm_buff);		/*Fehler?, dann Abbruch*/
         PrintText(AppStrings[MSG_ERROR].as_Str, 0);
         ErrorReq(13);			/*Datei läßt sich nicht öffnen*/
         return;
       }

       PrintText(AppStrings[MSG_LOWER_OK].as_Str, 0);
     }
     FreeBuffer(reasm_buff);			/*Speicher freigeben*/
   }
 }
}



/* print error messages
*/
void ReasmError(int errornum, int pinnum)
{
char    string[40];

 switch (errornum) {
   case  1:
     MyRequest(ERR_REQ, AppStrings[MSG_REASM_ERR].as_Str);
     PrintText(AppStrings[MSG_ERR_REASM1].as_Str, 1);
     break;

   case  2:
     strcpy(string, AppStrings[MSG_ERR_REASM2].as_Str);
     sprintf(&string[4], "%2d", pinnum);
     string[6] = ':';
     MyRequest(ERR_REQ, string);
     break;

   case  3:
     strcpy(string, AppStrings[MSG_ERR_REASM3].as_Str);
     sprintf(&string[4], "%2d", pinnum);
     string[6] = ':';
     MyRequest(ERR_REQ, string);
     break;

   case  4:
     strcpy(string, AppStrings[MSG_ERR_REASM4].as_Str);
     sprintf(&string[4], "%2d", pinnum);
     string[6] = ':';
     MyRequest(ERR_REQ, string);
     break;

   case  5:
     strcpy(string, AppStrings[MSG_ERR_REASM5].as_Str);
     sprintf(&string[4], "%2d", pinnum);
     string[6] = ':';
     MyRequest(ERR_REQ, string);
     break;

   case  6:
     strcpy(string, AppStrings[MSG_ERR_REASM6].as_Str);
     sprintf(&string[4], "%2d", pinnum);
     string[6] = ':';
     MyRequest(ERR_REQ, string);
     break;

   case  7:
     strcpy(string, AppStrings[MSG_ERR_REASM7].as_Str);
     sprintf(&string[4], "%2d", pinnum);
     string[6] = ':';
     MyRequest(ERR_REQ, string);
     break;

   case  8:
     strcpy(string, AppStrings[MSG_ERR_REASM8].as_Str);
     sprintf(&string[4], "%2d", pinnum);
     string[6] = ':';
     MyRequest(ERR_REQ, string);
     break;

   case  9:
     strcpy(string, AppStrings[MSG_ERR_REASM9].as_Str);
     sprintf(&string[4], "%2d", pinnum);
     string[6] = ':';
     MyRequest(ERR_REQ, string);
     break;

   case 10:
     strcpy(string, AppStrings[MSG_ERR_REASM10].as_Str);
     sprintf(&string[4], "%2d", pinnum);
     string[6] = ':';
     MyRequest(ERR_REQ, string);
     break;

 }
}




