/****************************************************************************
/*  F i l e   D a t a                                                        
/*                                                                           
/*  Module       : BootStrap                                                   
/*  C.I. No.     :                                                           
/*  $Revision: 1.1.1.1 $
/*  $Date: 2003/08/04 09:40:21 $
/*  Belonging to :                                                           
/*               :                                                           
/*  $RCSfile: mkprom.c,v $
/*  Program Type :                                                           
/*  Sub-modules  :                                                           
/*                                                                           
/****************************************************************************
/*  S W   D e v e l o p m e n t   E n v i r o n m e n t                      
/*                                                                           
/*  Host system  :                                                           
/*  SW Compiler  :                                                           
/*  $Author: sebastiani $
/*               :                                                           
/****************************************************************************
/*  U p d a t i n g                                                          
/*                                                                           
/*  $Log: mkprom.c,v $
/*  Revision 1.1.1.1  2003/08/04 09:40:21  sebastiani
/*  Imported sources laben rel. 19.06.2003 integrated with pam2
/*
/*  Revision 1.2  2002/05/09 08:16:34  zulia
/*  *  acceptance release
/*
/*                                                                           
/*****************************************************************************/

/*
 * This file is part of MKPROM.
 * 
 * MKPROM, ERC32 boot-prom utility. Copyright (C) 1995 Jiri Gaisler, European
 * Space Agency
 * 
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 * 
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 * 
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 675
 * Mass Ave, Cambridge, MA 02139, USA.
 * 
 */

#include <string.h>
#include <stdlib.h>
#include <stdio.h>

#ifndef fprintf
extern          fprintf();
#endif

#define	VAL(x)	strtol(x,(char **)NULL,0)
#define	SECMAX	32
#define	SECNAME	16

typedef struct sectype {
    unsigned int    paddr;
    unsigned int    raddr;
    unsigned int    len;
    unsigned int    comp;
    unsigned char   name[SECNAME];
}tt;

struct sectype  secarr[SECMAX];
char            filename[128];
char            filecore[128];
char            fileload[128];
unsigned int    fileSeq =0;

#ifdef __sun
#define TOOLBASE "/opt/gnu"
#else
#define TOOLBASE "/usr/local"
#endif
const char      version[] = "v1.2.9";
int             secnum = 0;
FILE           *dumpfile;

int             verbose = 0;
#ifdef LEON
int             leon = 1;
#else
int             leon = 0;
#endif
main(argc, argv)
    int             argc;
    char          **argv;

{

    char	        cmd[512];
    char	        msg[128];
    int             baud = 19200;	/* 19200 baud */
    int             edac = 1;
    int             par = 1;
#ifdef LEON
    double          freq = 5E7;
#else
    double          freq = 1E7;
#endif
    double          wdfreq = 0.0;
    int             i;
    int             mctrl = 0x0088001f;
    int             memcfg = 0;
    int             prot = 1;
    int             wrp = 0;
    int             ramcs = 0;
    int             rambanks = 1;
    int             ramsize = 0x200000;	/* 2M ram */
    int             romsize = 0x80000;	/* 512K rom */
    int             ramws = 0;
    int             ramrws = 0;
    int             ramwws = 0;
    int             romws = 2;
    int             romrws = 2;
    int             romwws = 2;
    int             stack = 0;
    int             rom8 = 0;
    int             ram8 = 0;
    int             stat = 1;
    int             bdinit = 0;
    int             waitcfg = 0x33330000;
    int             wdog = 1;
    int             comp = 0;
    int             dump = 0;
    char	        ofile[128] = "prom.out";
    int             tmp, iows, ioarea;


    printf("\nMKPROM - ERC32 boot-prom builder %s,  copyright Jiri Gaisler, ESA/ESTEC 1997\n", version);
    printf("Bug-reports to jgais@ws.estec.esa.nl\n\n");
    if ((dumpfile = fopen("dump.s", "w+")) == NULL) {
	printf("Failed to open temporary file\n");
	exit(1);
    }
    while (stat < argc) {
	if (argv[stat][0] == '-') {
	    if (strcmp(argv[stat], "-v") == 0) {
		verbose = 1;
	    } else if (strcmp(argv[stat], "-baud") == 0) {
		if ((stat + 1) < argc)
		    baud = VAL(argv[++stat]);
	    } else if (strcmp(argv[stat], "-wdog") == 0) {
		wdog = 0;
	    } else if (strcmp(argv[stat], "-dump") == 0) {
		dump = 1;
	    } else if (strcmp(argv[stat], "-nopar") == 0) {
		par = 0;
	    } else if (strcmp(argv[stat], "-noedac") == 0) {
		edac = 0;
	    } else if (strcmp(argv[stat], "-wrp") == 0) {
		wrp = 1;
	    } else if (strcmp(argv[stat], "-leon") == 0) {
		leon = 1;
	    } else if (strcmp(argv[stat], "-rom8") == 0) {
		rom8 = 1;
	    } else if (strcmp(argv[stat], "-ram8") == 0) {
		ram8 = 1;
	    } else if (strcmp(argv[stat], "-bdinit") == 0) {
		bdinit = 1;
	    } else if (strcmp(argv[stat], "-freq") == 0) {
		if ((stat + 1) < argc)
		    freq = atof(argv[++stat]);
		    freq *= 1E6;
	    } else if (strcmp(argv[stat], "-wdfreq") == 0) {
		if ((stat + 1) < argc)
		    wdfreq = atof(argv[++stat]);
		    wdfreq *= 1E6;
	    } else if (strcmp(argv[stat], "-noprot") == 0) {
		prot = 0; mctrl &= ~0x8;
	    } else if (strcmp(argv[stat], "-o") == 0) {
		strncpy(ofile,argv[++stat],127);
		ofile[127] = 0;
	    } else if (strcmp(argv[stat], "-ramsize") == 0) {
		if ((stat + 1) < argc) {
		    ramsize = (VAL(argv[++stat])) & 0x03ffff;
		    ramsize *= 1024;
		}
	    } else if (strcmp(argv[stat], "-romws") == 0) {
		if ((stat + 1) < argc)
		    romws = (VAL(argv[++stat])) & 0xf;
	    } else if (strcmp(argv[stat], "-romsize") == 0) {
		if ((stat + 1) < argc) {
		    romsize = (VAL(argv[++stat])) & 0x01ffff;
		    romsize *= 1024;
		}
	    } else if (strcmp(argv[stat], "-ramcs") == 0) {
		if ((stat + 1) < argc)
		    rambanks = (VAL(argv[++stat])) & 0x0f;
		switch (rambanks) {
		case 1:
		    ramcs = 0;
		    break;
		case 2:
		    ramcs = 1;
		    break;
		case 4:
		    ramcs = 2;
		    break;
		case 8:
		    ramcs = 3;
		    break;
		default:
		    ramcs = 0;
		}
	    } else if (strcmp(argv[stat], "-stack") == 0) {
		if ((stat + 1) < argc)
		    stack = (VAL(argv[++stat])) & ~0x01f;
	    } else if (strcmp(argv[stat], "-ramws") == 0) {
		if ((stat + 1) < argc)
		    ramws = (VAL(argv[++stat])) & 0x3;
	    } else if (strcmp(argv[stat], "-ramrws") == 0) {
		if ((stat + 1) < argc)
		    ramrws = (VAL(argv[++stat])) & 0x3;
	    } else if (strcmp(argv[stat], "-ramwws") == 0) {
		if ((stat + 1) < argc)
		    ramwws = (VAL(argv[++stat])) & 0x3;
	    } else if (strncmp(argv[stat], "-iows", 5) == 0) {
		if ((stat + 1) < argc) {
		    ioarea = argv[stat][5] - '0';
		    iows = VAL(argv[++stat]);
		    if ((ioarea >= 0) && (ioarea < 4) && (iows >=0) && (iows <= 14)) {
			if (verbose)
			  printf("\nI/O area %d: %d waitstates\n", ioarea, iows);
			iows++;
			waitcfg &= ~(0x000f0000 << (ioarea * 4));
			waitcfg |= iows << (ioarea * 4 + 16);
		    }
		}
	    } else {
		printf("unknown option %s\n", argv[stat]);
		usage();
		exit(1);
	    }
	} else {
            if (fileSeq == 0)	
            {	
                strcpy(filecore, argv[stat]);	
                fileSeq++;	
            }	
            else if (fileSeq == 1)	
            {	
                strcpy(fileload, argv[stat]);	
                fileSeq++;	
            }	
            else if (fileSeq == 2)	
            {                	
                if (secnum == 0)	
                    strcpy(filename, argv[stat]);	
                bfd_load(argv[stat], comp);
            }	
	}
	stat++;
    }
    fprintf(dumpfile, "\n\t.global _filename\n");
    fprintf(dumpfile, "_filename:\n");
    fprintf(dumpfile, "\t.string\t\"%s\"\n", filename);
    fprintf(dumpfile, "\n\t.align 32\n");
    fprintf(dumpfile, "\t.global _sections\n");
    fprintf(dumpfile, "_sections:\n");
    for (i = 0; i < secnum; i++) {
	fprintf(dumpfile, "\t.word\t0x%x\n", secarr[i].paddr);
	fprintf(dumpfile, "\t.word\t_section%d\n", i);
	fprintf(dumpfile, "\t.word\t0x%x\n", secarr[i].len);
	fprintf(dumpfile, "\t.word\t0x%x\n", secarr[i].comp);
	fprintf(dumpfile, "\t.string\t\"%s\"\n", secarr[i].name);
	fprintf(dumpfile, "\n\t.align 32\n");
    }
    fprintf(dumpfile, "\t.word\t0\n");

    if (leon) {
        fprintf(dumpfile, "\n\t.global _memcfg1, _memcfg2, _uart, _scaler \n");
    } else {
        fprintf(dumpfile, "\n\t.global _wdog, _mctrl \n");
        fprintf(dumpfile, "\t.global _waitcfg, _memcfg, _prot\n");
    }
    fprintf(dumpfile, "\n\t.global _ramsize, _stack\n");
    fprintf(dumpfile, "\t.global _freq, _configmsg\n");
    fprintf(dumpfile, "_freq:\n");
    fprintf(dumpfile, "\t.word\t%d\n", (int) (freq/1000000));
    if (leon) {
        tmp = romsize; tmp >>= 16; i = 0;
        while (tmp) { i++; tmp >>= 1; }
	tmp = (i << 14) | romws | (romws << 4);
	if (!rom8) tmp |= 0x300;
	if (edac) tmp |= 0x400;
        fprintf(dumpfile, "_memcfg1:\n");
        fprintf(dumpfile, "\t.word\t0x%x\n", tmp);
        tmp = ramsize; tmp >>= 16; i = 0;
        while (tmp) { i++; tmp >>= 1; }
	tmp = (i << 9) | ramrws | (ramwws << 4);
	if (!ram8) tmp |= 0x30;
	if (edac) tmp |= 0x80;
        fprintf(dumpfile, "_memcfg2:\n");
        fprintf(dumpfile, "\t.word\t0x%x\n", tmp);
        tmp = (int)(freq / (8 * baud) - 1);
        fprintf(dumpfile, "_uart:\n");
        fprintf(dumpfile, "\t.word\t%d\n", tmp);
        if (!stack) stack = 0x40000000 + ramsize - 32;
    } else {
        fprintf(dumpfile, "_wdog:\n");
        fprintf(dumpfile, "\t.word\t%d\n", wdog);
        fprintf(dumpfile, "_mctrl:\n");
        if (wdfreq > 0.0) {
            mctrl |= (int)(wdfreq / (32 * baud) - 1) << 24;
	    mctrl &= 0xff7fffff;
        } else
            mctrl |= (int)(freq / (32 * baud) - 1) << 24;
        fprintf(dumpfile, "\t.word\t0x%x\n", mctrl);
        fprintf(dumpfile, "_waitcfg:\n");
        if (romws)
	    romws++;
        waitcfg |= romws << 4;
        if (ramws) {
          waitcfg |= (0x3 & ramws);
          waitcfg |= (0x3 & ramws) << 2;
        } else {
          waitcfg |= (0x3 & ramrws);
          waitcfg |= (0x3 & ramwws) << 2;
        }
        fprintf(dumpfile, "\t.word\t0x%x\n", waitcfg);
        fprintf(dumpfile, "_prot:\n");
        fprintf(dumpfile, "\t.word\t%d\n", prot);
        if (!stack) stack = 0x2000000 + ramsize - 32;
        fprintf(dumpfile, "_memcfg:\n");
        memcfg |= (memcfg & ~3) | ramcs;
        i = 0; tmp = ramsize; tmp >>= 18;
        while (tmp) { i++; tmp >>= 1; }
        if (i) i--;
        memcfg |= (memcfg & ~0x1c00) | (i << 10);
        i = 0; tmp = romsize; tmp >>= 17;
        while (tmp) { i++; tmp >>= 1; }
        if (i) i--;
        memcfg |= (memcfg & ~0x1c0000) | (i << 18);
        memcfg |= (edac << 14);
        memcfg |= (par << 13);
        if (wrp) memcfg |= (1 << 16);
        fprintf(dumpfile, "\t.word\t0x%x\n", memcfg);
    }
    fprintf(dumpfile, "_ramsize:\n");
    fprintf(dumpfile, "\t.word\t0x%x\n", ramsize);
    fprintf(dumpfile, "_stack:\n");
        fprintf(dumpfile, "\t.word\t0x%x\n", stack);

    sprintf(cmd, "  system clock   : %3.1f MHz\\n\\r", freq/1E6);
    if (wdfreq > 0.0) {
	sprintf(msg, "  watchdog clock : %4.1f MHz\\n\\r", wdfreq/1E6);
        strcat(cmd, msg);
    }
    sprintf(msg, "  baud rate      : %d baud\\n\\r", baud); strcat(cmd, msg);
    sprintf(msg, "  prom           : %d K, %d ws\\n\\r", romsize>>10, romws); 
    strcat(cmd, msg);
    if (rambanks > 1)
      sprintf(msg, "  ram            : %d K, %d banks,", ramsize>>10, rambanks); 
    else
      sprintf(msg, "  ram            : %d K, %d bank,", ramsize>>10, rambanks); 
    strcat(cmd, msg);
    if (ramws) {
      sprintf(msg, " %d/%d ws (r/w)\\n\\r", ramws, ramws); 
    } else {
      sprintf(msg, " %d/", ramrws); 
      strcat(cmd, msg);
      sprintf(msg, "%d ws (r/w)\\n\\r", ramwws); 
    }
    strcat(cmd, msg);
    if (edac) 
      sprintf(msg, "  edac           : enabled\\n\\r"); 
    else
      sprintf(msg, "  edac           : disabled\\n\\r"); 
    strcat(cmd, msg);
    if (!leon) {
        if (edac || par) sprintf(msg, "  parity         : enabled\\n\\r"); 
        else sprintf(msg, "  parity         : disabled\\n\\r"); 
        strcat(cmd, msg);
    }
    if (prot && !leon)
      sprintf(msg, "  write-protect  : 0x%08x - 0x%08x\\n\\r",
      	secarr[0].paddr + 0x1000, secarr[0].paddr + secarr[0].len ); 
    else
      sprintf(msg, "  write-protect  : disabled\\n\\r"); 
    strcat(cmd, msg);
    if (!wdog)
      sprintf(msg, "  watchdog       : enabled\\n\\r"); 
    else
      sprintf(msg, "  watchdog       : disabled\\n\\r"); 
    strcat(cmd, msg);
    fprintf(dumpfile, "_configmsg:\n");
    fprintf(dumpfile, "\t.string\t\"%s\"\n", cmd);
    fclose(dumpfile);

    sprintf(cmd,"sparc-rtems-gcc -O2 -g -N -mkprom -nostartfiles -Ttext 0 %s %s -nostdlib dump.s -lmkprom -o",filecore,fileload);
    // sprintf(cmd,"sparc-rtems-gcc -O2 -g -N -mkprom -nostartfiles -Ttext 0 %s -nostdlib dump.s -lmkprom -o",filecore);
    strcat(cmd,ofile);
    if (verbose) printf("\n%s\n", cmd);
    system(cmd);
    // if (!dump) system("rm -f dump.s");

    exit(0);
}


usage()
{
}


#define N   4096		/* size of ring buffer (maximum is 4096
				 * because the pointer is coded in 12 bits */
#define F   18			/* upper limit for match_length (maximum is
				 * 15 + THRESHOLD + 1 because the length is
				 * coded in 4 bits) */

#define THRESHOLD  2		/* encode string into position and length if
				 * match_length is greater than this
				 * (compression) */
#define NIL  N			/* index for root of binary search trees */
#define MAGIC_NUMBER '\xaa'
#define EOP '\x55'
#ifndef SEEK_SET
#define SEEK_SET 0
#endif
#ifndef SEEK_CUR
#define SEEK_CUR 1
#endif
#ifndef SEEK_END
#define SEEK_END 2
#endif

unsigned char
                text_buf[N + F - 1];	/* ring buffer of size N, with extra
					 * F-1 bytes to facilitate string
					 * comparison */

int
                match_position, match_length,	/* of longest match.  These
						 * are set by the
						 * InsertNode() procedure. */
                lson[N + 1], rson[N + 257], dad[N + 1];	/* left & right children
							 * & parents -- These
							 * constitute binary
							 * search trees. */
unsigned long
                textsize = 0,	/* text size counter */
                codesize = 0,	/* code size counter */
                printcount = 0;	/* counter for reporting progress every 1K
				 * bytes */


unsigned char   CHECKSUM;

typedef struct {
    char            MAGIC;
    unsigned char   PARAMS;
    unsigned char   CHECKSUM;
    unsigned char   dummy;
    unsigned char   ENCODED_SIZE[4];
    unsigned char   DECODED_SIZE[4];
}               packet_header;

#define PH_SIZE 12

int
PutPacketInfo(buf)
    char           *buf;
{
    packet_header   PH;

    PH.MAGIC = MAGIC_NUMBER;
    PH.PARAMS = (unsigned char) (((N >> 6) & 0xf0) |
			  ((((F / 18) % 3) << 2) & 0x0c) | (THRESHOLD - 1));
    PH.CHECKSUM = CHECKSUM;
    PH.ENCODED_SIZE[0] = (codesize >> 24);
    PH.ENCODED_SIZE[1] = (codesize >> 16);
    PH.ENCODED_SIZE[2] = (codesize >> 8);
    PH.ENCODED_SIZE[3] = codesize;
    PH.DECODED_SIZE[0] = textsize >> 24;
    PH.DECODED_SIZE[1] = textsize >> 16;
    PH.DECODED_SIZE[2] = textsize >> 8;
    PH.DECODED_SIZE[3] = textsize;
    memcpy(buf, &PH, sizeof(packet_header));
/*
    printf("Packet info:\n" "params: %x\n" "checksum: %x\n", PH.PARAMS, PH.CHECKSUM);
*/
    return 0;
}

void
InitTree(void)
{				/* initialize trees */
    int             i;

    /*
     * For i = 0 to N - 1, rson[i] and lson[i] will be the right and left
     * children of node i.  These nodes need not be initialized. Also, dad[i]
     * is the parent of node i.  These are initialized to NIL (= N), which
     * stands for 'not used.' For i = 0 to 255, rson[N + i + 1] is the root
     * of the tree for strings that begin with character i.  These are
     * initialized to NIL.  Note there are 256 trees.
     */

    for (i = N + 1; i <= N + 256; i++)
	rson[i] = NIL;
    for (i = 0; i < N; i++)
	dad[i] = NIL;
}

void
InsertNode(int r)
/*
 * Inserts string of length F, text_buf[r..r+F-1], into one of the trees
 * (text_buf[r]'th tree) and returns the longest-match position and length
 * via the global variables match_position and match_length. If match_length
 * = F, then removes the old node in favor of the new one, because the old
 * one will be deleted sooner. Note r plays double role, as tree node and
 * position in buffer.
 */
{
    int             i, p, cmp;
    unsigned char  *key;

    cmp = 1;
    key = &text_buf[r];
    p = N + 1 + key[0];
    rson[r] = lson[r] = NIL;
    match_length = 0;
    for (;;) {
	if (cmp >= 0) {
	    if (rson[p] != NIL)
		p = rson[p];
	    else {
		rson[p] = r;
		dad[r] = p;
		return;
	    }
	} else {
	    if (lson[p] != NIL)
		p = lson[p];
	    else {
		lson[p] = r;
		dad[r] = p;
		return;
	    }
	}
	for (i = 1; i < F; i++)
	    if ((cmp = key[i] - text_buf[p + i]) != 0)
		break;
	if (i > match_length) {
	    match_position = p;
	    if ((match_length = i) >= F)
		break;
	}
    }
    dad[r] = dad[p];
    lson[r] = lson[p];
    rson[r] = rson[p];
    dad[lson[p]] = r;
    dad[rson[p]] = r;
    if (rson[dad[p]] == p)
	rson[dad[p]] = r;
    else
	lson[dad[p]] = r;
    dad[p] = NIL;		/* remove p */
}

void
DeleteNode(int p)
{				/* deletes node p from tree */
    int             q;

    if (dad[p] == NIL)
	return;			/* not in tree */
    if (rson[p] == NIL)
	q = lson[p];
    else if (lson[p] == NIL)
	q = rson[p];
    else {
	q = lson[p];
	if (rson[q] != NIL) {
	    do {
		q = rson[q];
	    } while (rson[q] != NIL);
	    rson[dad[q]] = lson[q];
	    dad[lson[q]] = dad[q];
	    lson[q] = lson[p];
	    dad[lson[p]] = q;
	}
	rson[q] = rson[p];
	dad[rson[p]] = q;
    }
    dad[q] = dad[p];
    if (rson[dad[p]] == p)
	rson[dad[p]] = q;
    else
	lson[dad[p]] = q;
    dad[p] = NIL;
}

int
Encode(inbuf, outbuf, buflen, oindex)
    unsigned char           *inbuf;
    unsigned char           *outbuf;
    int             buflen, oindex;
{
    int             i, c, len, r, s, last_match_length, code_buf_ptr;
    unsigned char   code_buf[17], mask;

    int             lindex = 0;

    CHECKSUM = 0xff;
    InitTree();			/* initialize trees */
    code_buf[0] = 0;		/* code_buf[1..16] saves eight units of code,
				 * and code_buf[0] works as eight flags, "1"
				 * representing that the unit is an unencoded
				 * letter (1 byte), "0" a position-and-length
				 * pair (2 bytes).  Thus, eight units require
				 * at most 16 bytes of code. */
    code_buf_ptr = mask = 1;
    s = 0;
    r = N - F;
    for (i = s; i < r; i++)
	text_buf[i] = ' ';	/* Clear the buffer with any character that
				 * will appear often. */
    for (len = 0; len < F && (lindex < buflen); len++) {
	c = inbuf[lindex++];
	CHECKSUM ^= c;
	text_buf[r + len] = c;	/* Read F bytes into the last F bytes of the
				 * buffer */
    }
    if ((textsize = len) == 0)
	return;			/* text of size zero */
    for (i = 1; i <= F; i++)
	InsertNode(r - i);	/* Insert the F strings, each of which begins
				 * with one or more 'space' characters.  Note
				 * the order in which these strings are
				 * inserted.  This way, degenerate trees will
				 * be less likely to occur. */
    InsertNode(r);		/* Finally, insert the whole string just
				 * read.  The global variables match_length
				 * and match_position are set. */
    do {
	if (match_length > len)
	    match_length = len;	/* match_length may be spuriously long near
				 * the end of text. */
	if (match_length <= THRESHOLD) {
	    match_length = 1;	/* Not long enough match.  Send one byte. */
	    code_buf[0] |= mask;/* 'send one byte' flag */
	    code_buf[code_buf_ptr++] = text_buf[r];	/* Send uncoded. */
	} else {
	    code_buf[code_buf_ptr++] = (unsigned char) match_position;
	    code_buf[code_buf_ptr++] = (unsigned char)
		(((match_position >> 4) & 0xf0)
		 | (match_length - (THRESHOLD + 1)));	/* Send position and
							 * length pair. Note
							 * match_length >
							 * THRESHOLD. */
	}
	if ((mask <<= 1) == 0) {/* Shift mask left one bit. */
	    memcpy(&outbuf[oindex], code_buf, code_buf_ptr);
	    oindex += code_buf_ptr;
	    codesize += code_buf_ptr;
	    code_buf[0] = 0;
	    code_buf_ptr = mask = 1;
	}
	last_match_length = match_length;
	for (i = 0; i < last_match_length && (lindex < buflen); i++) {
	    c = inbuf[lindex++];
	    CHECKSUM ^= c;
	    DeleteNode(s);	/* Delete old strings and */
	    text_buf[s] = c;	/* read new bytes */
	    if (s < F - 1)
		text_buf[s + N] = c;	/* If the position is near the end of
					 * buffer, extend the buffer to make
					 * string comparison easier. */
	    s = (s + 1) & (N - 1);
	    r = (r + 1) & (N - 1);
	    /*
	     * Since this is a ring buffer, increment the position modulo N.
	     */
	    InsertNode(r);	/* Register the string in text_buf[r..r+F-1] */
	}
	if ((textsize += i) > printcount) {
	    if (verbose) printf("%12ld\r", textsize);
	    printcount += 1024;
	    /*
	     * Reports progress each time the textsize exceeds multiples of
	     * 1024.
	     */
	}
	while (i++ < last_match_length) {	/* After the end of text, */
	    DeleteNode(s);	/* no need to read, but */
	    s = (s + 1) & (N - 1);
	    r = (r + 1) & (N - 1);
	    if (--len)
		InsertNode(r);	/* buffer may not be empty. */
	}
    } while (len > 0);		/* until length of string to be processed is
				 * zero */
    if (code_buf_ptr > 1) {	/* Send remaining code. */
	memcpy(&outbuf[oindex], code_buf, code_buf_ptr);
	oindex += code_buf_ptr;
	codesize += code_buf_ptr;
    }
    outbuf[oindex++] = EOP;
    if (verbose) {
        printf("Uncoded stream length: %ld bytes\n", textsize);	/* Encoding is done. */
        printf("Coded stream length: %ld bytes\n", codesize);
        printf("Compression Ratio: %.3f\n", (double) textsize / codesize);
    }
}


int
lzss(inbuf, outbuf, len, comp)
    char           *inbuf;
    char           *outbuf;
    int             len;
    int             comp;
{
    int             index;

    textsize = 0;		/* text size counter */
    codesize = 0;		/* code size counter */
    printcount = 0;		/* counter for reporting progress every 1K */

    if (comp) {
	index = sizeof(packet_header);
	Encode(inbuf, outbuf, len, index);
	if (PutPacketInfo(outbuf)) {
	    printf("Error:couldn't write packet header\n");
	}
    }
    return (codesize);
}

#include "ansidecl.h"

#ifdef ANSI_PROTOTYPES
#include <stdarg.h>
#else
#include <varargs.h>
#endif

#include "bfd.h"

#define min(A, B) (((A) < (B)) ? (A) : (B))
#define LOAD_ADDRESS 0


dump(section_address, buffer, count)
    int             section_address;
    unsigned char  *buffer;
    int             count;
{
    int             i;

    for (i = 0; i < count; i += 4) {
	fprintf(dumpfile, "\t.word\t0x%02x%02x%02x%02x\n",
		buffer[i], buffer[i + 1], buffer[i + 2], buffer[i + 3]);
    }
}

int
bfd_load(fname, comp)
    char           *fname;
    int             comp;
{
    int             cc, c;
    unsigned char   buf[10];
    asection       *section;
    bfd            *pbfd;
    unsigned long   entry;
    char           *sec_buf;
    char           *lzss_buf;

    pbfd = bfd_openr(fname, 0);

    if (pbfd == NULL) {
	printf("open of %s failed\n", fname);
	return (0);
    }
    if (!bfd_check_format(pbfd, bfd_object)) {
	printf("file %s  doesn't seem to be an object file\n", fname);
	return (0);
    }
    if (verbose) printf("loading %s:", fname);
    fprintf(dumpfile, "\t .text\n");
    for (section = pbfd->sections; section; section = section->next) {
	if (bfd_get_section_flags(pbfd, section) & SEC_ALLOC) {
	    bfd_vma         section_address;
	    unsigned long   section_size;
	    const char     *section_name;

	    section_name = bfd_get_section_name(pbfd, section);

	    section_address = bfd_get_section_vma(pbfd, section);
	    /*
	     * Adjust sections from a.out files, since they don't carry their
	     * addresses with.
	     */
	    if (bfd_get_flavour(pbfd) == bfd_target_aout_flavour)
		section_address += bfd_get_start_address(pbfd);
	    section_size = bfd_section_size(pbfd, section);

	    if (verbose) printf("\nsection %s at 0x%08lx (%ld bytes)",
		   section_name, section_address, section_size);

	    /* Text, data or lit */
	    if (bfd_get_section_flags(pbfd, section) & SEC_LOAD) {
		file_ptr        fptr;

		/* Register section in table */
		secarr[secnum].paddr = section_address;
		secarr[secnum].len = section_size;
		secarr[secnum].comp = comp;
		strcpy(secarr[secnum].name, section_name);

		/* Add section entry in dump file */
		fprintf(dumpfile, "\n\t.global _section%1d\n", secnum);
		fprintf(dumpfile, "_section%1d:\n", secnum);

		fptr = 0;

		/* Get buffers if compressing */
		if (comp) {
		    sec_buf = (char *) malloc(section_size);
		    lzss_buf = (char *) malloc(section_size + 200);
		}
		while (section_size > 0) {
		    char            buffer[1024];
		    int             count;

		    count = min(section_size, 1024);

		    bfd_get_section_contents(pbfd, section, buffer, fptr, count);

		    if (comp)
			memcpy(&sec_buf[fptr], buffer, count);
		    else
			dump(section_address, buffer, count);

		    section_address += count;
		    fptr += count;
		    section_size -= count;
		}
		secnum++;
		if (comp) {
		    if (verbose) printf("\n");
		    fptr = lzss(sec_buf, lzss_buf, fptr, 1);
		    dump(section_address, lzss_buf, fptr+13);
		    free(sec_buf);
		    free(lzss_buf);
		}
	    } else		/* BSS */
		if (verbose) printf("(not loaded)");
	}
    }
    if (verbose) printf("\n");

    /*
     * entry = bfd_get_start_address (pbfd);
     * 
     * printf ("[Starting %s at 0x%lx]\n", fname, entry);
     */
    return (0);
}