#include <stdio.h>
#include <string.h>
#include <ctype.h>
/* #include <StandardFile.h> */
/* #include <setjmp.h> */
#include <stdlib.h>
#include <math.h>
#include "seq.h"
/* #include "OSCAIO.h" */

int 						*macrosize;
unsigned short 				*macrovalue;
typedef char macroname_typ[256];
macroname_typ				*macroname;
 
OpenFile					OpFi[15];
FILE 						*fp;
static int 					openfiles;
static char 				*pststring[] = {"0","MACRO","INSERT",
                   	  		"ROUTINE","LOOP","SR_IN","OFFSET",
                     		"INCLUDE","END"};
                     	
unsigned short 				programPtr[2];
	
#define kNilFilterProc    	nil
#define kEmptyString	  	"\p"
#define kBaseResID	 	  	128	
#define kErrorAlertID	  	kBaseResID+3	
#define kMoveToFront        (WindowPtr)-1L	

#define kOn				  	1
#define kOff			 	0

#define kAlpha				20
#define kHex				21
#define kBin				22

#define	kOutputFilesDLOGID	3001

#define kImageFileCB		4	
#define kHexFileCB			5	
#define kMACROListingCB		6	
#define kSequencerFileCB	7	
#define kSummaryFileCB	 	8	

                     
//short 						LineInReadFile;
jmp_buf				       	env;
					
Seq							(*seqBuf)[2];
multipleSequence 			(*multSeq)[2];
unsigned int				seqCounter[2];

unsigned short 				memPart=0;
					
unsigned short				SQLM_used 	= 0;
unsigned short				SQHM_used 	= 0;

char 				errorString[256];

void	 CompileSequence(SFReply *reply, short *CompileError)
{
int 				i,j,macrofound ;
int 				stringid,macroid,pstid,macrocontid;
int					errorid;
int 				c;
unsigned short 		nbrofinserts;
unsigned short 		programpart;
int 				macronumber=1;
int 				oldmacronumber=0;

char 				openfilename[256];
char 				endstring[256];

unsigned short		 		oldaddress[2];
unsigned short		 		address[2];
unsigned short		 		nextaddress[2];

struct Point   		somewhere = { 20, 90 };
char 				readstring[256]; 

int					fsRefNum;

int 				debug=0;

unsigned short		PtrMem[512];
unsigned short		SeqMemPtr	= 0;

unsigned long 		BufSize    	= 65536;
unsigned int		max_MACROS 	=  1000;
unsigned int		max_PARTS  	=   512;
	
if((OpFi[0].fi = OpenReadFile(reply)) == NULL) // open File before memory allocation
	return;
else
	OpFi[0].LineInFile = 0;

seqBuf	    		= (SeqPtr) calloc(BufSize ,2 * sizeof(Seq));
multSeq			  	= (multipleSequencePtr) calloc(max_PARTS , sizeof(multipleSequence));

macrosize  = (int *)  			calloc(max_MACROS , sizeof(int));
macrovalue = (unsigned short *) calloc(max_MACROS , sizeof(unsigned short));
macroname  = (macroname_typ *) 	calloc(max_MACROS , 256 * sizeof(char)) ;

if((seqBuf==NULL)||(macrosize==NULL)||(macrovalue==NULL)||(macroname==NULL)||(multSeq==NULL))
{
	SeqDoError("\pNot enough memory...",false, env);
	return;
}
	
	
for(i=0;i<max_PARTS;i++)
	PtrMem[i]=0;

*CompileError 	= 	-1;
//LineInReadFile 	=	0;

for(i=0;i<2;i++) // initialize counters of both memory parts
{
	address[i]		= 	0;
	nextaddress[i]	= 	1;
	
	programPtr[i]	=	0;
	seqCounter[i] 	=   0;
}

if( setjmp(env) )
{

	for(i=0; i<=openfiles; i++)
	{
	  	fclose(OpFi[i].fi);
	}
	
 	*CompileError = OpFi[openfiles].LineInFile;
 	
 	free(seqBuf);
 	free(macrosize); 
 	free(macrovalue);
 	free(macroname);
 	free(multSeq);
  
	return;
}
	
while(strcmp("END",readstring))
{
    switch(nextnotblank())
    {
	case kAlpha : /* word */
    	fscanf(OpFi[openfiles].fi,"%s",readstring);
        if(!(pstid=MacroSearch(readstring,macronumber)))
        	{
        		char tmpstring[256] = "ERROR: unknown Sequence      ";
        		strcat(tmpstring,readstring); 
				SeqDoError(c2pstr(tmpstring), false, env);
			}
		else 
           	if(pstid>0)
	        {	
	      		if((0==strcmp(readstring,macroname[pstid])) 
	      	   	&& (0!=strcmp(readstring,"insertmacro")))
		 			for(j=0; j<macrosize[pstid]; j++)
		  				WriteCodeInTmpBuffer(address+memPart,nextaddress+memPart,macrovalue[pstid+j]);
	   		}
   		   	else
	  		{
		  		switch(pstid=abs(pstid))
		  		{ /* preset macro ! */   	 
		  	    	case 1 :     /* MACRO found in source file. */
		  	         	newMacroSave(readstring, &macronumber);
		       			break;
					case 2 : /* INSERT */
						insertMacro(readstring, &macronumber,address+memPart,nextaddress+memPart);
				        break; 
			    	case 3 : /* ROUTINE */
			    		
			    		if(nextnotblank()!=21) 								// hexadecimal ptr check
			    			SeqDoError("\pERROR: Ptr representation\n       should be hexadecimal!", false, env);
			    		else
			    			fscanf(OpFi[openfiles].fi,"$%x",&SeqMemPtr);
			    			
			    		if( SeqMemPtr < 0 )              	// valid ptr check
			    			SeqDoError("\pERROR: Ptr < 0", false, env);	  	//
			    		if( SeqMemPtr > 511)				//
			    			SeqDoError("\pERROR: Ptr > $FF", false, env);	//

						if( SeqMemPtr < 256 )
						{
							memPart 	= 0;		// SQLM
							SQLM_used 	= 1;
						} 
						else
						{
							memPart 	= 1;		// SQHM
							SQHM_used 	= 1;
						}	
							
						if( PtrMem[SeqMemPtr] == 0 )
							PtrMem[SeqMemPtr] =  1;
						else
							SeqDoError("\pERROR: Ptr already in  use ! ", false, env);
							
//Seq							(*seqBuf)[2];
//multipleSequence 			(*multSeq)[2];
						(multSeq[memPart]+seqCounter[memPart])->ROUTINE = SeqMemPtr;	
						
				    	if(nextnotblank()!=21) // save Big Sequence name,start,end and offset
				    	{
				    		fscanf(OpFi[openfiles].fi,"%s",&((multSeq[memPart]+seqCounter[memPart])->name));
				    		for(i=0;i<seqCounter[memPart];i++)
				    		{			 
				    			if(!strcmp(  (multSeq[memPart]+seqCounter[memPart])->name,(multSeq[memPart]+i)->name))
				    				SeqDoError("\pWarning: ROUTINE name used before !", false, env);
				    		}
				    	}	
				    	else
				    		strcpy((multSeq[memPart]+seqCounter[memPart])->name,"untitled");

						if(seqCounter[memPart]>0)
						{
							address[memPart]++;
				    		(multSeq[memPart]+seqCounter[memPart])->offset  = (multSeq[memPart]+seqCounter[memPart]-1)->end+1;
				    	}
				    	else	
				    	{
				    		address[memPart]=512;
				    		(multSeq[memPart]+seqCounter[memPart])->offset  = address[memPart];
				    	}
				    	
				    	(multSeq[memPart]+seqCounter[memPart])->start = (multSeq[memPart]+seqCounter[memPart])->offset;
						
         				(seqBuf[memPart]+programPtr[memPart])->seqAddress = (multSeq[memPart]+seqCounter[memPart])->ROUTINE;
						(seqBuf[memPart]+programPtr[memPart])->seqPointer = (multSeq[memPart]+seqCounter[memPart])->start;
						
						if( (multSeq[memPart]+seqCounter[memPart])->ROUTINE < 128 )
							(seqBuf[memPart]+programPtr[memPart])->seqValue   = 0;	// SQLM: SQD14 = 0
						else
							(seqBuf[memPart]+programPtr[memPart])->seqValue   = 32768;	// SQHM: SQD14 = 1
							
						programPtr[memPart]++; 
	
				    	nextaddress[memPart]=address[memPart]+1;
				    	
			        	break; 
			    	case 4 : /* LOOP */
						loop(readstring,&macronumber,address+memPart,nextaddress+memPart);
				    	(multSeq[memPart]+seqCounter[memPart])->end = address[memPart];
				    	seqCounter[memPart]++;
				        break;
				    case 5 :
				    {	/* 	SR_IN(CTRL_ON or CTRL_OFF,DEC or APC, 010111000) 
				    				DEC  	-> Bit 3 = 0 (default)
				    				APC 	-> Bit 3 = 1 
				    				
				    				CTRL_ON  -> Bit 4-6 = Bit 0-2 
				    				CTRL_OFF -> Bit 4-6 = constant (default)
				    				
				    				Daten (1) in SR: Bit 3-0  	x101
				    											x010 // geaendert 9.3.95 vorher x110
				    											
				    				Daten (0) in SR: Bit 3-0  	x001
				    											x010 */
				    	unsigned short dec=0,ctrl=0;
				    	
				    	while(1)
				    	{
				    		char tmpstring[256];
				    		
					    	if(nextnotblank()==kAlpha)
					    	{
					    		char tmpstring[256];
					    							    		
					    	 	fscanf(OpFi[openfiles].fi,"%s",tmpstring);
					    	 	if(!strcmp(tmpstring,"ENDSR_IN"))
					    	 		break;	
					    	 	else
					    	 	if(!strcmp(tmpstring,"DEC"))dec=0;
					    	 	else
					    	 	if(!strcmp(tmpstring,"APC"))dec=1;
					    	 	else
					    	 	if(!strcmp(tmpstring,"CTRL_ON")) ctrl=1;
					    	 	else
					    	 	if(!strcmp(tmpstring,"CTRL_OFF"))ctrl=0;
					    	 	else
									SeqDoError("\pError: unknown command after DEC_IN !", false, env);
					    	}
					    	else
					    	{
						    	if(nextnotblank()==kHex)
						    	{
						    		// to be implemented SP 4.1.95
						    	}
						    	else
						    	if(nextnotblank()==kBin)
						    	{
						    		char bit,inBit;
						    		unsigned short *prevCode,pCode;
						    		
									pCode = (seqBuf[memPart]+programPtr[memPart]-1)->seqValue;
									
									prevCode =&pCode;
						    		
						    		if(dec) // set out/sr bit
						    			SetBit(prevCode,3,1);
						    		else
		    							SetBit(prevCode,3,0);
	
						    		if((bit=fgetc(OpFi[openfiles].fi)) == '0')
						    			inBit=0;
						    		else 
						    			inBit=1;
	
					    			SetBit(prevCode,0,1);
					    			SetBit(prevCode,1,0);
						    		SetBit(prevCode,2,inBit);
	
					    			if(ctrl)
					    				for(i=0;i<4;i++)
	    									SetBit(prevCode,4+i,GetBit(*prevCode,i));
	
									WriteCodeInTmpBuffer(address,nextaddress,*prevCode);
					    			
					    			SetBit(prevCode,0,0);
					    			SetBit(prevCode,1,1);
						    		SetBit(prevCode,2,0);// geaendert 9.3.95 vorher SetBit(prevCode,2,inBit);
					    			
					    			if(ctrl)
					    				for(i=0;i<4;i++)
	    									SetBit(prevCode,4+i,GetBit(*prevCode,i));
	
									WriteCodeInTmpBuffer(address,nextaddress,*prevCode);
								}
							}		    		
			    			if(!strcmp(tmpstring,"ENDSR_IN"))
			    	 		break;	

				    	}
				    	break;
				    }
				    case 6 : /* OFFSET */
				    	if(nextnotblank()!=21) // save Big Sequence name,start,end and offset
				    		fscanf(OpFi[openfiles].fi,"%s",(multSeq[memPart]+seqCounter[memPart])->name);
				    	else
				    		strcpy((multSeq[memPart]+seqCounter[memPart])->name,"untitled");
				    		
				    	fscanf(OpFi[openfiles].fi," $%4x",&address);
				    	
				    	(multSeq[memPart]+seqCounter[memPart])->offset  	= address[memPart];
				    	(multSeq[memPart]+seqCounter[memPart])->start 		= address[memPart];
				    	
				    	nextaddress[memPart]=address[memPart]+1;
				    	
				    	if(seqCounter[memPart]>0) // if overlap with other BS current BS
					    	for(i=0;i<seqCounter[memPart];i++)
					    	{
					    		if(address[memPart]>=(multSeq[memPart]+i)->start && address[memPart]<=(multSeq[memPart]+i)->end)
					    		{
					    			(multSeq[memPart]+seqCounter[memPart])->start=(multSeq[memPart]+seqCounter[memPart]-1)->end+1;
					    			address[memPart]=(multSeq[memPart]+seqCounter[memPart]-1)->end+1;
					    		}
					    	}
				    	nextaddress[memPart]=address[memPart]+1;
				    	break;
				    case 7 : /* INCLUDE */
				    	fscanf(OpFi[openfiles].fi,"%s",openfilename);
			    		openfiles++;
						if ((OpFi[openfiles].fi = fopen(openfilename,"r")) == NULL)
							 SeqDoError("\pERROR: can't open SubFile", false, env);
						else
						{
							p2cstr(reply->fName);
							
							strcpy(OpFi[openfiles].prevFileName,(char *) reply->fName);
							strcpy((char *) reply->fName,openfilename);
							
							c2pstr((char *) reply->fName);
							
							OpFi[openfiles].LineInFile=0;
						}
			    		break;
			    	case 8 : /* END*/
	  	 				break;
	
			    	default : /* personal macro */
			        	break;
			    }
 			}
	  		break;
		case kHex : /* hexadecimal part of program */
	    	fscanf(OpFi[openfiles].fi,"$%4x",&programpart);
			WriteCodeInTmpBuffer(address+memPart,nextaddress+memPart,programpart);
	  	 	break;
		case kBin : /* binary part of program */
	    	programpart = ReadBinarySequence();
			WriteCodeInTmpBuffer(address+memPart,nextaddress+memPart,programpart);
	  	 	break;
		case 77 : /* end of file */
			// implemented to open faulty file ****************************
			
			
			/*p2cstr(reply->fName);
			strcpy((char *) reply->fName,openfilename);
			c2pstr((char *) reply->fName);*/
			
			
			//*************************************************************
			
			
			p2cstr(reply->fName);
			strcpy((char *) reply->fName,OpFi[openfiles].prevFileName);
			c2pstr((char *) reply->fName);
	  	 	fclose(OpFi[openfiles--].fi);
	  	 	if(openfiles < 0) // only if last open file has no END -> Error
	  	 		SeqDoError("\pERROR: File ended without END", false, env);
	  	 	break;
  	 	}	
	}


	HandleOutputFilesDialog(macronumber,reply);
	
	free(seqBuf);
	free(macrosize); 
 	free(macrovalue);
 	free(macroname);
  	free(multSeq); 
 

}

/********************* nextnotblank **************/

int nextnotblank(void)
{
	int 	   		c,id;

	while(1)
	{
	    while( ( isspace( c = fgetc(OpFi[openfiles].fi)) )  )
	    {
	    	if(c == '\n')	/* count lines in source file */
	    		OpFi[openfiles].LineInFile++;
	    }

	    if (c=='\{')	/* ignore comments */
	    {
	    	while(1)
	    	{
	    		if((c=fgetc(OpFi[openfiles].fi)) == '\}')
	    			break;
	    		else
	    			if(c == '\n')	/* count lines in source file */
		    			OpFi[openfiles].LineInFile++;
		    }
	    }
	    else
	    	break;
	}
    
    id = 99;
    if (c == EOF)
    {
        id = 77; /* end of file */
    }     
    else 
    	if(isalpha(c))
    	{
    		id = 20; /* word */
	   	}
    	else 
    		if (isdigit(c))
    		{
    		    	id = 22; /* bit pattern */
    		}
    		else
    			if(c=='$')
    				id = 21;
	    		else 
	    		{
					SeqDoError("\pERROR: unexpected character", false, env);
					longjmp(env,1);
				}
	
	ungetc(c,OpFi[openfiles].fi);
    return id;
}

/******************* MacroSearch ************/
 
int MacroSearch(char *readstring, int macronumber)
{
	int macrofound=0;
	int i;
	
	for(i=1;i<9;i++)
	{
  	    if(0==strcmp(pststring[i],readstring))
  	    {
  	        macrofound=-i;
  	        break;
  	    }
  	}
  	
	if(0==macrofound)
	{ 
		for(i=1;i<macronumber;i++)
		{
	  	    if(0==strcmp(macroname[i],readstring))
	  	    {
	  	        macrofound=i;
	  	        break;
	  	    }
	  	}
  	}
  	return macrofound;
}
 
void macrocopy(int *macronumber, int *macrofound)
{
	int j;
	for(j=0;j<macrosize[*macrofound];j++)
	{
		macrovalue[*macronumber]=macrovalue[*macrofound+j];
		(*macronumber)++;	
	}
}

/**************** macroSave **************/

void macroSave(int *macronumber, char *readstring, char *endstring)
{
	int		oldmacronumber;
	int		macrocontid;
	int		i,j;
	int		macrofound;
	unsigned short	nbrofinserts;
	int		totalmacrosize;
	
 	oldmacronumber = *macronumber;
  	macrosize[*macronumber]=0;	      	        	
    if(0!=strcmp(readstring,"insertmacro"))
    	strcpy(macroname[*macronumber],readstring);

    totalmacrosize=0;
    
    
    while(1)
    {
       	if(0==strcmp(endstring,readstring))
      	{
     		(*macronumber)+=totalmacrosize;
  	        break;
  	    }	                       	
		macrocontid=nextnotblank();
		switch(macrocontid)
		{
		case kAlpha : /* known macro */
			fscanf(OpFi[openfiles].fi,"%s",readstring);
			if(0==strcmp(endstring,readstring))
			{
  	            for(i=*macronumber-totalmacrosize; i<*macronumber;i++)
  	            {
  	            	macrosize[i]=totalmacrosize;
  	            	strcpy(macroname[i],macroname[*macronumber-totalmacrosize]);
  	            }
  	            break;	
  	        }
  	        macrofound=MacroSearch(readstring,*macronumber);
  	        if(macrofound<=0)
  	        {
  	        	if(0==strcmp("INSERT",readstring))
  	        	{
  	        	    fscanf(OpFi[openfiles].fi,"%d",&nbrofinserts);
 	                fscanf(OpFi[openfiles].fi,"%s",readstring);
 	                if(0!=strcmp(readstring,"TIMES"))
							 SeqDoError("\pERROR: TIMES expected", false, env);

 	                oldmacronumber=*macronumber;
	                strcpy(readstring,"insertmacro");
	                macroSave(macronumber,readstring,"ENDINSERT");
	                totalmacrosize+=(nbrofinserts)*macrosize[oldmacronumber];
	                for(i=0;i<nbrofinserts-1;i++)
	                {
	                	macrocopy(macronumber,&oldmacronumber);
	                }
	                break; 
   	        	}
  	        	else
  	        	{
  	        		sprintf(errorString,"ERROR: undefined macro in file %s, line %d",
  	        		OpFi[openfiles].fi,OpFi[openfiles].LineInFile);
					SeqDoError(c2pstr(errorString), false, env);
				}
  	        }
  	        else
  	        {
  	        	macrocopy(macronumber,&macrofound);			  	            	
  	        	totalmacrosize+=macrosize[macrofound];
  	        	break;
  	        }
       	case kHex : /* bit pattern */
            fscanf(OpFi[openfiles].fi,"$%4x",&macrovalue[*macronumber]);
            totalmacrosize++;
            (*macronumber)++;
  		    break;
		case kBin : /* bit pattern */
	    	macrovalue[*macronumber] = ReadBinarySequence();
            totalmacrosize++;
            (*macronumber)++;
  		    break;
	   	}	
   	   	if(0==strcmp(endstring,readstring))
   	   	{
 		   	break;
       	}	                       	
	}
}



/************** newMacroSave *******************/

void newMacroSave(char *readstring, int *macronumber)
{
	int errorid;
	
	if(nextnotblank() != kAlpha)
		SeqDoError("\pERROR: macroname starts with digit ! ", false, env);
 
	while(strcmp("ENDMACRO",readstring))
  	{
  		fscanf(OpFi[openfiles].fi,"%s",readstring);
  		
  	    if(!strcmp("ENDMACRO",readstring))
				SeqDoError("\pERROR: empty MACRO", false, env);

		if( 0 != (errorid = MacroSearch(readstring,*macronumber) ) )
  	    	{
  	        	if(errorid>0)
	 				SeqDoError("\pERROR: MACRO doubly defined", false, env);
  	            else
	 				SeqDoError("\pERROR: invalid macroname", false, env);
  	        }
  	            	
  	    macroSave(macronumber,readstring,"ENDMACRO");
  	    
	}
}

/**************** insertMacro ***************/


void insertMacro(char *readstring, int *macronumber, unsigned short *add, unsigned short *nextadd)
{
	int			 	oldmacronumber; 
	unsigned short	nbrofinserts;
	int				i,j;

	if(nextnotblank()==kBin)
	{
    	fscanf(OpFi[openfiles].fi,"%d",&nbrofinserts);
    	fscanf(OpFi[openfiles].fi,"%s",readstring);
    	if(strcmp(readstring,"TIMES"))
			SeqDoError("\pERROR: TIMES expected", false, env);
	}
    else
		SeqDoError("\pERROR: number expected", false, env);
			
    oldmacronumber = *macronumber;
    strcpy(readstring,"insertmacro");
    macroSave(macronumber,readstring,"ENDINSERT");
    for(i=0;i<nbrofinserts;i++)
    	for(j=0;j<macrosize[oldmacronumber];j++)
			WriteCodeInTmpBuffer(add,nextadd,macrovalue[oldmacronumber+j]);
    
    *macronumber=oldmacronumber;
}

/**************** loop ***************/


void loop(char *readstring, int *macronumber, unsigned short *add,
					unsigned short *nextadd)
{
	int			 	oldmacronumber; 
	unsigned short		 	oldadd; 
//	unsigned short			nbrofinserts;
	int				i,j;

	oldmacronumber 	= *macronumber; 					// save macronumber and address 
	oldadd     		= *add;
	
	strcpy(readstring,"loopmacro");
	macroSave(macronumber,readstring,"ENDLOOP");	// "loopmacro" is just a temporary macro
	
	for(j=0;j<macrosize[oldmacronumber]-1;j++)
		WriteCodeInTmpBuffer(add,nextadd,macrovalue[oldmacronumber+j]);
	
 	(seqBuf[memPart]+programPtr[memPart])->seqAddress = *add;
	(seqBuf[memPart]+programPtr[memPart])->seqPointer = oldadd;
	(seqBuf[memPart]+programPtr[memPart])->seqValue   = macrovalue[oldmacronumber+j];
	programPtr[memPart]++; 
	
    *macronumber=oldmacronumber;

}

/************SeqDoError ***/

void SeqDoError(Str255	errorString, Boolean fatal,jmp_buf	env)
{	

	ParamText(errorString, kEmptyString, kEmptyString, kEmptyString);
	StopAlert(kErrorAlertID, kNilFilterProc);
	
	if(fatal)
		ExitToShell();
	else
		longjmp(env,1);
}


/************ WriteCodeInTmpBuffer ***************/

void WriteCodeInTmpBuffer(unsigned short *add, unsigned short *nextadd, unsigned short code)
{
	
	(seqBuf[memPart]+programPtr[memPart])->seqAddress = *add;
	(seqBuf[memPart]+programPtr[memPart])->seqPointer = *nextadd;
	(seqBuf[memPart]+programPtr[memPart])->seqValue   = code;
	programPtr[memPart]++; 
	
    (*add)++;
    (*nextadd)++;

}

/************ GetBit ***********/

int GetBit(unsigned short a, unsigned short nthBit)
{
	unsigned short bit;

	if( a & (1 << nthBit))
		bit = 1;
	else
		bit = 0;
		
	return bit;
	
}


/************ SetBit ***********/

void SetBit(unsigned short *a, unsigned short nthBit, unsigned short ON)
{
	unsigned short bit=0;

	if(ON)
		*a = *a | (1 << nthBit);
	else
	{
		bit = (1 << nthBit);
		*a = *a & ~bit;
	}
		
}


/************ ReadBinarySequence ***********/

unsigned short ReadBinarySequence()
{
	int				c;
	unsigned short 	i, hex;
	
	hex =0;
	
	for(i=16; i>0; i--)
	{	
		while(isspace(c=fgetc(OpFi[openfiles].fi)))
			;
			
		if( c == '1')
			hex = hex + pow(2,i-1);
	}
	
	return hex;
		
}

/************ HandleOutputFilesDialog *******/

void		HandleOutputFilesDialog(int macronumber,SFReply *reply)
{
	DialogPtr				dialog;
	Boolean					dialogDone = false;
	short					itemHit, itemType;
	Handle					itemHandle;
	Handle					okItemHandle;
	Rect					itemRect;
	
	dialog = GetNewDialog(kOutputFilesDLOGID, nil, kMoveToFront );
	
	ShowWindow( dialog );
	SetPort( dialog );
	
	SetDialogDefaultItem(dialog, ok);
	SetDialogCancelItem(dialog, cancel);
		
	GetDItem( dialog, ok, &itemType, &okItemHandle, &itemRect);	
	
	GetDItem(dialog, kImageFileCB, &itemType, &itemHandle, &itemRect);
	SetCtlValue((ControlHandle) itemHandle, kOff);
	
	GetDItem(dialog, kHexFileCB, &itemType, &itemHandle, &itemRect);
	SetCtlValue((ControlHandle) itemHandle, kOff);
	
	GetDItem(dialog, kMACROListingCB, &itemType, &itemHandle, &itemRect);
	SetCtlValue((ControlHandle) itemHandle, kOff);
	
	GetDItem(dialog, kSequencerFileCB, &itemType, &itemHandle, &itemRect);
	SetCtlValue((ControlHandle) itemHandle, kOn);
	
	GetDItem(dialog, kSummaryFileCB, &itemType, &itemHandle, &itemRect);
	SetCtlValue((ControlHandle) itemHandle, kOn);
	
	while(! dialogDone)
	{
			
		ModalDialog( nil, &itemHit);
		
		switch( itemHit )
		{
			case ok:
			case cancel:
				dialogDone = true;
				break;

			case kImageFileCB:
			case kHexFileCB:
			case kMACROListingCB:
			case kSequencerFileCB:
			case kSummaryFileCB:
				GetDItem(dialog, itemHit, &itemType, &itemHandle, &itemRect);
				SetCtlValue( (ControlHandle) itemHandle, !GetCtlValue((ControlHandle)itemHandle));
				break;
				
		}
	}
	
	if(itemHit==ok)
	{
		GetDItem(dialog, kImageFileCB, &itemType, &itemHandle, &itemRect);
		if(GetCtlValue((ControlHandle)itemHandle))
			PrintImageFile(macronumber,reply);
			
		GetDItem(dialog, kHexFileCB, &itemType, &itemHandle, &itemRect);
		if(GetCtlValue((ControlHandle)itemHandle))
			PrintHexFile(macronumber,reply);
			
		GetDItem(dialog, kMACROListingCB, &itemType, &itemHandle, &itemRect);
		if(GetCtlValue((ControlHandle)itemHandle))
			PrintMACROListing(macronumber,reply);
			
		GetDItem(dialog, kSequencerFileCB, &itemType, &itemHandle, &itemRect);
		if(GetCtlValue((ControlHandle)itemHandle))
			WriteSeqFile(reply); 
			
		
		GetDItem(dialog, kSummaryFileCB, &itemType, &itemHandle, &itemRect);
		if(GetCtlValue((ControlHandle)itemHandle))
			WriteSummaryFile(macronumber,reply); 
		
	}
		
	DisposDialog(dialog);
	
}