Attachment #850368 for bug #891533

View | Details | Raw Unified | Return to bug 891533
Collapse All | Expand All




   FILE is the name of the file (for error messages).  */

void
mywrite (int desc, void *pbuf, int bytes, char *file)
     int desc;
     void *pbuf;
     int bytes;
     char *file;
{
  register int val;
  register char * buf = pbuf;

}

int
main (int argc, char **argv)
     int argc;
     char **argv;
{
  int i;


}

void
scan (
#ifdef __STDC__
  void (*function) (struct member_desc member, FILE *istream),
#else
  void (*function) (),
#endif
  int crflag)
{
  FILE *arcstream = fopen (archive, "r");


}

void
print_descr (struct member_desc member, FILE * instream)
     struct member_desc member;
     FILE * instream;
{
  char *timestring;
  if (!verbose)

}

void
print_modes (int modes)
     int modes;
{
  putchar (modes & 0400 ? 'r' : '-');
  putchar (modes & 0200 ? 'w' : '-');

#define BUFSIZE 1024

void
extract_member (struct member_desc member, FILE *istream)
     struct member_desc member;
     FILE *istream;
{
  int ncopied = 0;
  FILE *ostream;

}

void
print_contents (struct member_desc member, FILE *istream)
     struct member_desc member;
     FILE *istream;
{
  int ncopied = 0;


 create a new archive.  */

struct mapelt *
make_map (int nonexistent_ok)
     int nonexistent_ok;
{
  struct mapelt mapstart;
  mapstart.next = 0;

}

void
add_to_map (struct member_desc member, FILE * istream)
     struct member_desc member;
     FILE * istream;
{
  struct mapelt *mapelt = (struct mapelt *) xmalloc (sizeof (struct mapelt));
  mapelt->info = member;

/* Return the last element of the specified map.  */

struct mapelt *
last_mapelt (struct mapelt *map)
     struct mapelt *map;
{
  struct mapelt *tail = map;
  while (tail->next) tail = tail->next;

/* Return the element of the specified map which precedes elt.  */

struct mapelt *
prev_mapelt (struct mapelt *map, struct mapelt *elt)
     struct mapelt *map, *elt;
{
  struct mapelt *tail = map;
  while (tail->next && tail->next != elt)

/* Return the element of the specified map which has the specified name.  */

struct mapelt *
find_mapelt_noerror (struct mapelt *map, register char *name)
     struct mapelt *map;
     register char *name;
{
  register struct mapelt *tail;
  unsigned int len;

}

struct mapelt *
find_mapelt (struct mapelt *map, char *name)
     struct mapelt *map;
     char *name;
{
  register struct mapelt *found = find_mapelt_noerror (map, name);
  if (found == 0)

*/

void
write_archive (struct mapelt *map, int appendflag)
     struct mapelt *map;
     int appendflag;
{
  char *tempname = make_tempname (archive);
  int indesc = lock_indesc;

}

void
header_from_map (struct ar_hdr *header, struct mapelt *mapelt)
     struct ar_hdr *header;
     struct mapelt *mapelt;
{
  unsigned int namelen;
  char *p;

/* gets just the file part of name */

char *
basename (char *path)
     char *path;
{
  char *save, *start;
  for (start = save = path; *path; path++)


/* writes to file open on OUTDESC with name OUTNAME.  */
void
copy_out_member (struct mapelt *mapelt, int archive_indesc, int outdesc, char *outname)
     struct mapelt *mapelt;
     int archive_indesc;
     int outdesc;
     char *outname;
{
  struct ar_hdr header;
  int indesc;

   It is open on OUTDESC and its name is OUTNAME.  */

void
touch_symdef_member (int outdesc, char *outname)
     int outdesc;
     char *outname;
{
  struct stat statbuf;
  int i;

}

char *
make_tempname (char *name)
     char *name;
{
#if defined(USG) || defined(SHORT_FILENAME)
  /* sigh. 14 character filenames are *wonderful*, just *wonderful*. */

}

void
delete_from_map (char *name, struct mapelt *map)
     char *name;
     struct mapelt *map;
{
  struct mapelt *this = find_mapelt (map, name);


}

int
move_in_map (char *name, struct mapelt *map, struct mapelt *after)
     char *name;
     struct mapelt *map, *after;
{
  struct mapelt *this = find_mapelt (map, name);
  struct mapelt *prev;

   exist or (optionally) is older.  */

int
insert_in_map (char *name, struct mapelt *map, struct mapelt *after)
     char *name;
     struct mapelt *map, *after;
{
  struct mapelt *old = find_mapelt_noerror (map, name);
  struct mapelt *this;

*/

void
extract_members (
#ifdef __STDC__
     void (*function) (struct member_desc member, FILE *istream))
#else
     void (*function) ())
#endif
{
  struct mapelt *map;

   are descriptor and name of file to write to.  */

void
write_symdef_member (struct mapelt *mapelt, struct mapelt *map, int outdesc, char *outname)
     struct mapelt *mapelt;
     struct mapelt *map;
     int outdesc;
     char *outname;
{
  struct ar_hdr header;
  struct mapelt *mapptr;

}

void
read_old_symdefs (struct mapelt *map, int archive_indesc)
     struct mapelt *map;
     int archive_indesc;
{
  struct mapelt *mapelt;
  char *data;

   Return 0 for failure or 1 for success.  */

int
read_header_info (struct mapelt *mapelt, int desc, long int offset, long int *syms_offset,
                  unsigned int *syms_size, long int *strs_offset, unsigned int *strs_size)
     int desc;
     long int offset;
     long int *syms_offset;
     unsigned int *syms_size;
     long int *strs_offset;
     unsigned int *strs_size;
{
    struct exec hdr;
    int len;

   by reading the file it is coming from.  */

void
make_new_symdefs (struct mapelt *mapelt, int archive_indesc)
     struct mapelt *mapelt;
     int archive_indesc;
{
  int indesc;
  char *name = mapelt->info.name;

   Return the number of symbols left.  */

int
filter_symbols (struct nlist *syms, unsigned int symcount)
     struct nlist *syms;
     unsigned int symcount;
{
  struct nlist *from, *to;
  struct nlist *end = syms + symcount;

/* Update the __.SYMDEF data before writing a new archive.  */

void
update_symdefs (struct mapelt *map, int archive_indesc)
     struct mapelt *map;
     int archive_indesc;
{
  struct mapelt *tail;
  int pos;

/* Print error message and usage message, and exit.  */

void
usage (char *s1, int val)
     char *s1;
     int val;
{
  char vbuf[16];
  sprintf(vbuf, "%d", val);

/* Print error message and exit.  */

void
fatal (char *s1, char *s2)
     char *s1, *s2;
{
  error (s1, s2);
  exit (1);

/* Print error message.  `s1' is printf control string, the rest are args.  */

void
error (char *s1, char *s2)
     char *s1, *s2;
{
  fprintf (stderr, "%s: ", program_name);
  fprintf (stderr, s1, s2);

}

void
error3 (char *s1, char *s2, char *s3)
     char *s1, *s2, *s3;
{
  fprintf (stderr, "%s: ", program_name);
  fprintf (stderr, s1, s2, s3);

}

void
error_with_file (char *string, struct mapelt *mapelt)
     char *string;
     struct mapelt *mapelt;
{
  fprintf (stderr, "%s: ", program_name);
  fprintf (stderr, "%s", string);

}

void
perror_with_name (char *name)
     char *name;
{
  error (concat ("", strerror(errno), " for %s"), name);
}

void
pfatal_with_name (char *name)
     char *name;
{
  fatal (concat ("", strerror(errno), " for %s"), name);
}

   concatenate those of S1, S2, and S3.  */

char *
concat (const char *s1, const char *s2, const char *s3)
     const char *s1, *s2, *s3;
{
  int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
  char *result = (char *) xmalloc (len1 + len2 + len3 + 1);

/* Like malloc but get fatal error if memory is exhausted.  */

char *
xmalloc (unsigned int size)
     unsigned int size;
{
#ifdef MALLOC_0_RETURNS_NULL
  char *result = malloc (size ? size : 1);

}

char *
xrealloc (char *ptr, unsigned int size)
     char *ptr;
     unsigned int size;
{
  char *result = realloc (ptr, size);
  if (result == 0)


#ifndef HAVE_RENAME
int
rename (char *from, char *to)
     char *from, *to;
{
  (void)unlink (to);
  if (link (from, to) < 0




}

void * 
asalloc(unsigned int size)
unsigned int size;
{
    void * rv;
#ifdef USE_FIXED_HEAP



void * 
asrealloc(void * oldptr, unsigned int size)
void * oldptr;
unsigned int size;
{
    void * rv;
#ifdef USE_FIXED_HEAP




FORWARD void summ_number P((unsigned num));
FORWARD void usage P((void));

PUBLIC int main(int argc, char **argv)
int argc;
char **argv;
{
    init_heap();
    initp1();

    return 0;
}

PUBLIC void as_abort(char *message)
char *message;
{
    write(STDOUT, "as: ", 4);
    write(STDOUT, message, strlen(message));

      ptext();
}

PRIVATE int my_creat(char *name, char *message)
char *name;
char *message;
{
    int fd;


    return fd;
}

PRIVATE void process_args(int argc, char **argv)
int argc;
char **argv;
{
    char *arg;
    bool_t isnextarg;

    inidata = (~binaryg & inidata) | (RELBIT | UNDBIT);
}				/* IMPBIT from inidata unless binaryg */

PRIVATE void summary(int fd)
int fd;
{
    outfd = fd;
    writenl();

    writesn(" warnings");
}

PRIVATE void summ_number(unsigned num)
unsigned num;
{
    /* format number like line numbers */
    char buf[16];

Lines 33-40 Link Here

(-)a/as/express.c (-2 / +1 lines)
33	}	33	}
34	}	34	}
35		35
36	PRIVATE void experror(err_str)	36	PRIVATE void experror(char * err_str)
37	char * err_str;
38	{	37	{
39	error(err_str);	38	error(err_str);
40	expundefined();	39	expundefined();





/* write char to binary file or directly to memory */

PUBLIC void putbin(opcode_pt ch)
opcode_pt ch;
{
    if (binfil != 0x0)
    {


/* write sized offset to binary file or directly to memory */

PRIVATE void putbinoffset(offset_t offset, count_t size)
offset_t offset;
count_t size;
{
    char buf[sizeof offset];






/* format 1 byte number as 2 hex digits, return ptr to end */

PRIVATE char *build_1hex_number(opcode_pt num, register char *where)
opcode_pt num;
register char *where;
{
    where[0] = hexdigit[((unsigned) num % 256) / 16];
    where[1] = hexdigit[(unsigned) num % 16];


/* format 2 byte number as 4 hex digits, return ptr to end */

PUBLIC char *build_2hex_number(unsigned num, char *where)
unsigned num;
char *where;
{
    return build_1hex_number((opcode_pt) num,
			     build_1hex_number((opcode_pt) (num / 256), where));

/* format 2 byte number as decimal with given width (pad with leading '0's) */
/* return ptr to end */

PUBLIC char *build_number(unsigned num, unsigned width, register char *where)
unsigned num;
unsigned width;
register char *where;
{
    static unsigned powers_of_10[] = {1, 10, 100, 1000, 10000,};
    unsigned char digit;


/* record number and position of error (or error buffer overflow) */

PUBLIC void warning(char * err_str)
char * err_str;
{
    if (!as_warn.current) return;
    ++totwarn;

    error(err_str);
}

PUBLIC void error(char * err_str)
char * err_str;
{
    register struct error_s *errptr;
    register struct error_s *errptrlow;


/* list 1 line unconditionally */

PRIVATE void list1(fd_t fd)
fd_t fd;
{
    outfd = fd;
    listcode();


/* pad out error line to begin under 1st char of source listing */

PRIVATE void paderrorline(unsigned nspaces)
unsigned nspaces;
{
    int nstars = LINUM_LEN;



/* write 1 character */

PUBLIC void writec(char ch)
char ch;
{
    write(outfd, &ch, 1);
}


/* write 1 offset_t, order to suit target */

PUBLIC void writeoff(offset_t offset)
offset_t offset;
{
    char buf[sizeof offset];



/* write string */

PUBLIC void writes(char *s)
char *s;
{
    write(outfd, s, strlen(s));
}

/* write string followed by newline */

PUBLIC void writesn(char *s)
char *s;
{
    writes(s);
    writenl();


/* write 1 word, order to suit target */

PUBLIC void writew(unsigned word)
unsigned word;
{
    char buf[2];






FORWARD void flushabs P((void));
FORWARD void flushrmb P((void));
FORWARD void genobjadr P((struct address_s *adrptr, smallcount_t size));
FORWARD void putobj1 P((opcode_pt ch));
FORWARD void putobj4 P((u32_T offset));
FORWARD void putobjoffset P((offset_t offset, count_t size));


/* accumulate RMB requests into 1 (so + and - requests cancel) */

PUBLIC void accumulate_rmb(offset_t offset)
offset_t offset;
{
    if (objectc)
    {


/* generate object code for current address */

PRIVATE void genobjadr(struct address_s *adrptr, smallcount_t size)
struct address_s *adrptr;
smallcount_t size;
{
    unsigned char byte;
    unsigned symnum;


/* write char to absolute object code buffer, flush if necessary */

PUBLIC void putabs(opcode_pt ch)
opcode_pt ch;
{
    if (objectc)
    {


/* write char to object code buffer, flush if necessary */

PUBLIC void putobj(opcode_pt ch)
opcode_pt ch;
{
    if (objectc)
    {


/* write char to object code buffer assuming nothing in absolute & rmb bufs */

PRIVATE void putobj1(opcode_pt ch)
opcode_pt ch;
{
    if (objbufptr >= objbufend)
	flushobj();


/* write 32 bit offset to object code buffer assuming ... */

PRIVATE void putobj4(u32_T offset)
u32_T offset;
{
    char buf[sizeof offset];



/* write sized offset to object code buffer assuming ... */

PRIVATE void putobjoffset(offset_t offset, count_t size)
offset_t offset;
count_t size;
{
    char buf[sizeof offset];



/* write word to object code buffer assuming ... */

PRIVATE void putobjword(unsigned word)
unsigned word;
{
    char buf[sizeof word];



/* write several bytes to object code buffer assuming ... */

PRIVATE void writeobj(char *buf, unsigned count)
char *buf;
unsigned count;
{
    do
	putobj1(*buf++);





/* print symbol nicely formatted for given column */

PRIVATE int printsym(register struct sym_s *symptr, unsigned column)
register struct sym_s *symptr;
unsigned column;
{
    unsigned char length;
    register struct sym_listing_s *listptr;


/* shell sort symbols */

PRIVATE void sort(struct sym_s **array, struct sym_s **top, bool_pt nameflag)
struct sym_s **array;
struct sym_s **top;
bool_pt nameflag;
{
    int gap;
    int i;

Lines 15-22 Link Here

(-)a/as/macro.c (-2 / +1 lines)
15	next:string. The first string is the macro number in 4 bytes.	15	next:string. The first string is the macro number in 4 bytes.
16	*/	16	*/
17		17
18	PUBLIC void entermac(symptr)	18	PUBLIC void entermac(struct sym_s *symptr)
19	struct sym_s *symptr;
20	{	19	{
21	if (maclevel >= MAXMAC)	20	if (maclevel >= MAXMAC)
22	error(MACOV);	21	error(MACOV);




FORWARD void yesimmed P((struct ea_s *eap));
FORWARD void yes_samesize P((void));

PRIVATE void Eb(register struct ea_s *eap)
register struct ea_s *eap;
{
    Ex(eap);
    if (eap->size != 0x1)

    }
}

PRIVATE void Ew(register struct ea_s *eap)
register struct ea_s *eap;
{
    Ex(eap);
    if (eap->size != 0x2)

    }
}

PRIVATE void Ev(register struct ea_s *eap)
register struct ea_s *eap;
{
    Ex(eap);
    notbytesize(eap);
}

PRIVATE void Ex(register struct ea_s *eap)
register struct ea_s *eap;
{
    getea(eap);
    notimmed(eap);
    notsegorspecreg(eap);
}

PRIVATE void Gd(register struct ea_s *eap)
register struct ea_s *eap;
{
    Gx(eap);
    if (eap->size != 0x4)
	kgerror(ILL_SIZE);
}

PRIVATE void Gw(register struct ea_s *eap)
register struct ea_s *eap;
{
    Gx(eap);
    if (eap->size != 0x2)
	kgerror(ILL_SIZE);
}

PRIVATE void Gv(register struct ea_s *eap)
register struct ea_s *eap;
{
    Gx(eap);
    notbytesize(eap);
}

PRIVATE void Gx(register struct ea_s *eap)
register struct ea_s *eap;
{
    Ex(eap);
    notindirect(eap);
}

PRIVATE void buildea(register struct ea_s *eap)
register struct ea_s *eap;
{
    opsize_t asize;


    opcode = ESCAPE_OPCODE_BASE | ((opcode & 0x70) >> 0x4);
}

PRIVATE void buildimm(register struct ea_s *eap, bool_pt signflag)
register struct ea_s *eap;
bool_pt signflag;
{
    immadr = eap->displ;
    immcount = eap->size;


/* Check size and build segword. */

PRIVATE void buildsegword(register struct ea_s *eap)
register struct ea_s *eap;
{
    if (eap->size == 0x0)
#ifdef NODEFAULTSIZE

	segword = regsegword[eap->base];
}

PRIVATE void buildunary(opcode_pt opc)
opcode_pt opc;
{
    if (mcount != 0x0)
    {

    }
}

PRIVATE opsize_pt displsize(register struct ea_s *eap)
register struct ea_s *eap;
{
    opsize_t asize;


    return fpreg;
}

PRIVATE bool_pt getaccumreg(register struct ea_s * eap)
register struct ea_s *eap;
{
    if ((eap->base = regchk()) != AXREG && eap->base != ALREG
	&& eap->base != EAXREG)

    buildsegword(&source);
}

PRIVATE bool_pt getdxreg(register struct ea_s *eap)
register struct ea_s *eap;
{
    if ((eap->base = regchk()) != DXREG)
	return FALSE;

  optional-imediate-prefix displ(scaled index)     -- anachronism
*/

PRIVATE void getea(register struct ea_s *eap)
register struct ea_s *eap;
{
    bool_t leading_displ;
    bool_t leading_immed;

    needcpu(eap->size==4?3:0);
}

PRIVATE void getimmed(struct ea_s *eap, count_t immed_count)
struct ea_s *eap; 
count_t immed_count;
{
    getea(eap);
    yesimmed(eap);

    }
}

PRIVATE void getindirect(register struct ea_s *eap)
register struct ea_s *eap;
{
    getea(eap);
    if (eap->indcount == 0x0)
	kgerror(IND_REQ);
}

PRIVATE void getshift(register struct ea_s *eap)
register struct ea_s *eap;
{
    getcomma();
    getea(eap);

  Return register number (adjusted if necessary to a legal index) or NOREG.
*/

PRIVATE reg_pt indregchk(reg_pt matchreg)
reg_pt matchreg;
{
    reg_pt reg;


    return reg;
}

PRIVATE void kgerror(char * err_str)
char * err_str;
{
    error(err_str);
    sprefix = oprefix = aprefix = mcount = 0x0;
}

PRIVATE void lbranch(int backamount)
int backamount;
{
    mcount += defsize + 0x1;
    segadj();

    buildregular();
}

PRIVATE void notbytesize(register struct ea_s *eap)
register struct ea_s *eap;
{
    if (eap->size == 0x1)
	kgerror(ILL_SIZE);
}

PRIVATE void notimmed(register struct ea_s *eap)
register struct ea_s *eap;
{
    if (eap->indcount == 0x0 && eap->base == NOREG)
	kgerror(ILL_IMM_MODE);
}

PRIVATE void notindirect(register struct ea_s *eap)
register struct ea_s *eap;
{
    if (eap->indcount != 0x0)
	kgerror(ILL_IND);
}

PRIVATE void notsegorspecreg(register struct ea_s *eap)
register struct ea_s *eap;
{
    if (regsegword[eap->base] >= SEGMOV)
	kgerror(ILLREG);
}

PRIVATE void yesimmed(register struct ea_s *eap)
register struct ea_s *eap;
{
    if (eap->indcount == 0x1)
	eap->indcount = 0x0;




FORWARD void constdata P((unsigned size));
FORWARD void docomm P((void));
FORWARD void doelseif P((pfv func));
FORWARD void doequset P((unsigned char labits));
FORWARD void doentexp P((unsigned char entbits, unsigned char impbits));
FORWARD void dofcc P((void));
FORWARD void doif P((pfv func));
FORWARD struct sym_s *needlabel P((void));
FORWARD void showredefinedlabel P((void));
FORWARD void setloc P((unsigned seg));

PRIVATE void bumpsem(register struct flags_s *flagptr, int defval)
register struct flags_s *flagptr;
int defval;
{
    int newcount;


/* check symbol is either undefined */
/* or has the same segment & relocatability as lc */

PUBLIC bool_pt checksegrel(register struct sym_s *symptr)
register struct sym_s *symptr;
{
    if ((symptr->type & LABIT ||
	(symptr->data & IMPBIT && !(symptr->data & UNDBIT))) &&


/* allocate constant data (zero except for size 1), default zero for size 1 */

PRIVATE void constdata(unsigned size)
unsigned size;
{
    offset_t remaining;



/* common routine for ELSEIF/ELSEIFC */

PRIVATE void doelseif(pfv func)
pfv func;
{
    if (iflevel == 0)
	error(ELSEIFBAD);


/* common routine for EQU/SET */

PRIVATE void doequset(unsigned char labits)
unsigned char labits;
{
    register struct sym_s *labptr;
    unsigned char olddata;


/* common routine for ENTRY/EXPORT */

PRIVATE void doentexp(unsigned char entbits, unsigned char impbits)
unsigned char entbits;
unsigned char impbits;
{
    struct sym_s *symptr;



/* common routine for IF/IFC */

PRIVATE void doif(pfv func)
pfv func;
{
    if (iflevel >= MAXIF)
	error(IFOV);

    }
}

PUBLIC void fatalerror(char * err_str)
char * err_str;
{
    error(err_str);
    skipline();

/* swap position with label position, do error, put back posn */
/* also clear label ptr */

PUBLIC void labelerror(char * err_str)
char * err_str;
{
    struct sym_s *oldgsymptr;
    char *oldlineptr;


/* set location segment */

PRIVATE void setloc(unsigned seg)
unsigned seg;
{
    if (pass == last_pass && seg != (lcdata & SEGM))
	putobj((opcode_pt) (seg | OBJ_SET_SEG));

Lines 34-40 Link Here

(-)a/as/proto.h (-1 / +1 lines)
34	void warning P((char * errorstr));	34	void warning P((char * errorstr));
35	void error P((char * errorstr));	35	void error P((char * errorstr));
36	void listline P((void));	36	void listline P((void));
37	void writec P((int ch));	37	void writec P((char ch));
38	void writenl P((void));	38	void writenl P((void));
39	void writeoff P((offset_t offset));	39	void writeoff P((offset_t offset));
40	void writes P((char *s));	40	void writes P((char *s));




    clearsource();		/* sentinel to invoke blank skipping */
}

PUBLIC fd_t open_input(char *name)
char *name;
{
    fd_t fd;
#if BIGBUFFER == 1

PRIVATE long ftpos = 0;
PRIVATE int  lastfd = -1;

PRIVATE int inp_line(int fd, char * buf, int size)
int fd;
char * buf;
int size;
{
   int offt = 0;
   if( fd!=lastfd ) inp_seek(-1, 0L);

   return offt;
}

PRIVATE long inp_tell(int fd)
int fd;
{
   if( fd != lastfd )
      return lseek(fd, 0L, 1);

      return ftpos + in_start;
}

PRIVATE void inp_seek(int fd, long posn)
int fd;
long posn;
{
   if( lastfd != -1 )
      lseek(lastfd, ftpos+in_start, 0);




FORWARD void printchain P((void));
#endif

FORWARD void install P((register char *keyptr, unsigned char data));

PUBLIC void inst_keywords()
{

#endif
}

PRIVATE void install(register char *keyptr, unsigned char data)
register char *keyptr;
unsigned char data;
{
    char lowcasebuf[20];
    unsigned namelength;




#include "globvar.h"

void xxerr P((char *));
void xxerr(char *x) { write(2, x, strlen(x)); }

#ifdef __AS386_16__
static int no_swap   = 1;

static int long_off[4] = {0,1,2,3};
static int int_off[2] = {0,1};

PUBLIC bool_pt typeconv_init(bool_pt big_endian, bool_pt long_big_endian)
bool_pt big_endian;
bool_pt long_big_endian;
{
   int i;
#ifdef __AS386_16__

   return 1;
}

PUBLIC void u2c2(char *buf, u2_pt offset)
char *buf;
u2_pt offset;
{
#ifdef __AS386_16__
   if( no_swap )

   buf[int_off[1]] = (offset>>8);
}

PUBLIC void u4c4(char *buf, u4_t offset)
char *buf;
u4_t offset;
{
   int i;
#ifdef __AS386_16__

   }
}

PUBLIC void u4cn(char *buf, u4_t offset, unsigned count)
char *buf;
u4_t offset;
unsigned count;
{
    switch(count)
    {

    }
}

PUBLIC void u2cn(char *buf, u2_pt offset, unsigned count)
char *buf;
u2_pt offset;
unsigned count;
{
    switch(count)
    {

    }
}

PUBLIC u2_pt c2u2(char *buf)
char *buf;
{
    u2_pt res;
#ifdef __AS386_16__

    return res;
}

PUBLIC u4_t c4u4(char *buf)
char *buf;
{
    u4_t res;
    int i;

    return res;
}

PUBLIC u4_t cnu4(char *buf, unsigned count)
char *buf;
unsigned count;
{
    switch (count)
    {

    }
}

PUBLIC u2_pt cnu2(char *buf, unsigned count)
char *buf;
unsigned count;
{
    switch (count)
    {




		      struct symstruct *source, uoffset_T size));
FORWARD void fconvert P((struct symstruct *source, struct typestruct *type));

PUBLIC void assign(struct symstruct *source, struct symstruct *target)
struct symstruct *source;
struct symstruct *target;
{
    store_pt regpushed;
    store_pt sourcereg;


/* block move assumes itypesize == accregsize && BREG size == 1 */

PRIVATE void blockmove(struct symstruct *source, struct symstruct *target)
struct symstruct *source;
struct symstruct *target;
{
    struct symstruct oldtarget;
    uoffset_T typesize;

    *target = oldtarget;
}

PRIVATE void call3(char *funcname, struct symstruct *target, struct symstruct *source, uoffset_T size)
char *funcname;
struct symstruct *target;
struct symstruct *source;
uoffset_T size;
{
    store_pt regpushed;
    offset_T spmark;

    }
}

PUBLIC void cast(struct typestruct *type, struct symstruct *target)
struct typestruct *type;
struct symstruct *target;
{
    scalar_t newscalar;
    uoffset_T newsize;


/* extend char or short to int (unsigned if from unsigned) */

PUBLIC void extend(struct symstruct *target)
struct symstruct *target;
{
    scalar_t tscalar;


    }
}

PRIVATE void fconvert(struct symstruct *source, struct typestruct *type)
struct symstruct *source;
struct typestruct *type;
{
    offset_T spmark;





char * libc = "-lc";

int
main(int argc, char ** argv)
int argc;
char ** argv;
{
   struct file_list * next_file;
   char * temp;

}

char *
copystr(char * str)
char * str;
{
   return strcpy(xalloc(strlen(str)+1), str);
}

char *
catstr(char * str, char * str2)
char * str, * str2;
{
   return strcat(strcpy(xalloc(strlen(str)+strlen(str2)+1), str), str2);
}

void
run_aspreproc(struct file_list * file)
struct file_list * file;
{
   static char cc1bcc[] = CC1BCC;


}

void
run_preproc(struct file_list * file)
struct file_list * file;
{
   int last_stage = 0;
   int combined_cpp;

}

void
run_unproto(struct file_list * file)
struct file_list * file;
{
   command.cmd = UNPROTO;
   command_reset();

}

void
run_compile(struct file_list * file)
struct file_list * file;
{
   if (opt_arch == 3)   command.cmd = CC1C386;
   else if (opt_arch<5) command.cmd = CC1BCC;

}

void
run_optim(struct file_list * file)
struct file_list * file;
{
   char buf[32];
   if (opt_arch<5) command.cmd = OPTIM;

}

void
run_as(struct file_list * file)
struct file_list * file;
{
   char * buf;
   switch(opt_arch)

}

void
validate_link_opt(char * option)
char * option;
{
   int err = 0;
   if (option[0] != '-') return;

}

void
command_opt(char * option)
char * option;
{
   if (command.maxargs <= command.numargs+1) {
      char ** newbuf = xalloc(command.maxargs*2*sizeof(char**));

}

void
command_opts(int optkey)
int optkey;
{
   struct opt_list * ol;
   for(ol=options; ol; ol=ol->next)

	 command_opt(ol->opt);
}

void newfilename(struct file_list * file, int last_stage, int new_extn, int use_o)
struct file_list * file;
int last_stage;
int new_extn;
int use_o;
{
   file->filetype = new_extn;
   if (file->oldfile) free(file->oldfile);

}

void
getargs(int argc, char ** argv)
int argc;
char ** argv;
{
   int ar;
   char * pflag = 0;

}

void
build_prefix(char * path1, char * path2, char * path3)
char * path1, * path2, * path3;
{
   char * newstr;
   int l;

}

void
add_prefix(char * path)
char * path;
{
   char ** p; 
   if (!path || !*path) return;

   fatal("Too many -B options");
}

void append_file (char * filename, int ftype)
char * filename;
int ftype;
{
   struct file_list * newfile = xalloc(sizeof(struct file_list));
   char * s;

}

void 
append_option (char * option, int otype)
char * option;
int otype;
{
   struct opt_list * newopt = xalloc(sizeof(struct opt_list));


}

void 
prepend_option (char * option, int otype)
char * option;
int otype;
{
   struct opt_list * newopt = xalloc(sizeof(struct opt_list));


   options = newopt;
}

char * build_libpath(char * opt, char * str, char * suffix)
char * opt, * str, * suffix;
{
   char * newstr;
   newstr = xalloc(strlen(opt)+strlen(str)+strlen(prefix_path)+strlen(suffix)+1);

}

void *
xalloc (int size)
int size;
{
   void * p = malloc(size);
   if (!p) fatal("Out of memory");

   exit(1);
}

void fatal(char * str)
char * str;
{
   fprintf(stderr, "%s: Fatal error: %s.\n", progname, str);
   exit(1);

#endif

void
run_command(struct file_list * file)
struct file_list * file;
{
#ifdef __BCC__
static char ** minienviron[] = {

Lines 4-12 Link Here

(-)a/bcc/bcc-cc1.c (-3 / +1 lines)
4		4
5	#include "bcc.h"	5	#include "bcc.h"
6		6
7	PUBLIC int main(argc, argv)	7	PUBLIC int main(int argc, char **argv)
8	int argc;
9	char **argv;
10	{	8	{
11	debug(1, "Start");	9	debug(1, "Start");
12	growheap(0); /* init order is important */	10	growheap(0); /* init order is important */





/* add constant to register */

PUBLIC void addconst(offset_T offset, store_pt reg)
offset_T offset;
store_pt reg;
{
#ifdef I8088
#ifdef I80386


/* adjust lc for signed offset */

PUBLIC void adjlc(offset_T offset, store_pt reg)
offset_T offset;
store_pt reg;
{
    if (!(reg & CHARREGS))
    {


/* adjust stack ptr by adding a labelled constant less current sp */

PUBLIC void adjsp(label_no label)
label_no label;
{
    outaddsp();
    outbyte(LOCALSTARTCHAR);


/* and accumulator with constant */

PUBLIC void andconst(offset_T offset)
offset_T offset;
{
    char_t botbits;
    uoffset_T topbits;


/* clear register to 0 */

PRIVATE void clr(store_pt reg)
store_pt reg;
{
    loadconst((offset_T) 0, reg);
}

/* define common storage */

PUBLIC void common(char *name)
char *name;
{
#ifdef I8088
    outcommon();


/* define long */

PUBLIC void deflong(uoffset_T value)
uoffset_T value;
{
    uoffset_T longhigh;
    uoffset_T longlow;


/* define null storage */

PUBLIC void defnulls(uoffset_T nullcount)
uoffset_T nullcount;
{
    if (nullcount != 0)
    {


/* define string */

PUBLIC label_no defstr(char *sptr, char *stop, bool_pt dataflag)
char *sptr;
char *stop;
bool_pt dataflag;
{
    int byte;			/* promoted char for output */
    label_no strlab;


/* divide D register by a constant if it is easy to do with shifts */

PUBLIC bool_pt diveasy(value_t divisor, bool_pt uflag)
value_t divisor;
bool_pt uflag;
{
    bool_t sign;



/* equate a name to an EOL-terminated string */

PUBLIC void equ(char *name, char *string)
char *name;
char *string;
{
    outstr(name);
    outequate();


/* equate a local label to a value */

PUBLIC void equlab(label_no label, offset_T offset)
label_no label;
offset_T offset;
{
    outbyte(LOCALSTARTCHAR);
    outlabel(label);


/* import or export a variable */

PUBLIC void globl(char *name)
char *name;
{
    outglobl();
    outnccname(name);


/* import a variable */

PUBLIC void import(char *name)
char *name;
{
    outimport();
    outnccname(name);


/* extend an int to a long */

PUBLIC void itol(store_pt reg)
store_pt reg;
{
#define TEMP_LABEL_FOR_REGRESSION_TESTS
#ifdef TEMP_LABEL_FOR_REGRESSION_TESTS


/* define local common storage */

PUBLIC void lcommlab(label_no label)
label_no label;
{
    outlabel(label);
    outlcommon();
}

PUBLIC void lcommon(char *name)
char *name;
{
    outccname(name);
    outlcommon();


/* load effective address */

PUBLIC void lea(offset_T offset, store_pt sourcereg, store_pt targreg)
offset_T offset;
store_pt sourcereg;
store_pt targreg;
{
    outlea();
    outregname(targreg);


/* load constant into given register */

PUBLIC void loadconst(offset_T offset, store_pt reg)
offset_T offset;
store_pt reg;
{
#ifdef I8088
    if (offset == 0)


/* partially long shift left register by a constant (negative = infinity) */

PUBLIC int lslconst(value_t shift, store_pt reg)
value_t shift;
store_pt reg;
{
    if ((uvalue_t) shift >= INT16BITSTO)
    {


/* partially long shift right register by a constant (negative = infinity) */

PUBLIC int lsrconst(value_t shift, store_pt reg, bool_pt uflag)
value_t shift;
store_pt reg;
bool_pt uflag;
{
    if ((uvalue_t) shift >= INT16BITSTO)
    {


/* take D register modulo a constant if it is easy to do with a mask */

PUBLIC bool_pt modeasy(value_t divisor, bool_pt uflag)
value_t divisor;
bool_pt uflag;
{
    bool_t sign;



/* multiply register by a constant if it is easy to do with shifts */

PUBLIC bool_pt muleasy(uvalue_t factor, store_pt reg)
uvalue_t factor;
store_pt reg;
{
    int mulstack[MAXINTBITSTO / 2 + 1];	/* must be signed, not a fastin_t */
    fastin_pt count;


/* negate a register */

PUBLIC void negreg(store_pt reg)
store_pt reg;
{
    if ((store_t) reg == BREG)
	extBnegD();


/* return string of operator */

PUBLIC char *opstring(op_pt op)
op_pt op;
{
    switch (op)
    {


/* print a c compiler name with leading CCNAMEPREXFIX */

PUBLIC void outccname(char *name)
char *name;
{
    outbyte(CCNAMEPREFIX);
    outstr(name);


/* print immediate address */

PUBLIC void outimmadr(offset_T offset)
offset_T offset;
{
#ifdef I8088
    if (!isbyteoffset(offset))


/* print register, comma, immediate address and adjust lc */

PUBLIC void outimadj(offset_T offset, store_pt targreg)
offset_T offset;
store_pt targreg;
{
    outregname(targreg);
    adjlc(offset, targreg);


/* print cc name, then newline */

PUBLIC void outnccname(char *name)
char *name;
{
    outccname(name);
    outnl();


/* print separator, immediate address, newline */

PUBLIC void outncimmadr(offset_T offset)
offset_T offset;
{
#ifdef I8088
    outcomma();


/* print signed offset and adjust lc */

PUBLIC void outoffset(offset_T offset)
offset_T offset;
{
#ifdef MC6809
    if (!is5bitoffset(offset))

    outstr(stackregstr);
}

PUBLIC void public(char *name)
char *name;
{
#ifndef AS09
    outexport();


/* print cc name as a private label */

PUBLIC void private(char *name)
char *name;
{
#ifdef LABELENDCHAR
    outccname(name);


/* exchange registers */

PUBLIC void regexchange(store_pt sourcereg, store_pt targreg)
store_pt sourcereg;
store_pt targreg;
{
    outexchange();
    outregname(sourcereg);


/* transfer a register */

PUBLIC void regtransfer(store_pt sourcereg, store_pt targreg)
store_pt sourcereg;
store_pt targreg;
{
    outtransfer();
#ifdef TARGET_FIRST


/* set a name to a value */

PUBLIC void set(char *name, offset_T value)
char *name;
offset_T value;
{
    outccname(funcname);
    outbyte(LOCALSTARTCHAR);


/* shift left register by 1 */

PUBLIC void sl1(store_pt reg)
store_pt reg;
{
    outsl();
#ifdef I8088


/* shift left register by a constant (negative = infinity) */

PUBLIC void slconst(value_t shift, store_pt reg)
value_t shift;
store_pt reg;
{
#ifdef I80386
    if (i386_32)


/* shift right D register by a constant (negative = infinity) */

PUBLIC void srconst(value_t shift, bool_pt uflag)
value_t shift;
bool_pt uflag;
{
#ifdef I80386
    if (i386_32)


/* extend an unsigned in DREG to a long */

PUBLIC void uitol(store_pt reg)
store_pt reg;
{
    if (lowregisDreg())
	clr(reg);





FORWARD void outindchars P((int byte, indn_pt count));

PUBLIC void dbitem(struct symstruct *item)
struct symstruct *item;
{
    dbtype(item->type);
    if (item->storage == NOSTORAGE)

    outindchars(']', item->indcount);
}

PUBLIC void dbtype(struct typestruct *type)
struct typestruct *type;
{
    for ( ; type != NULL; type = type->nexttype)
    {

    }
}

PUBLIC void dbnode(struct nodestruct *exp)		/* sub-nodes must be leaves */
struct nodestruct *exp;
{
    if (!dbnodeon)
	return;

	outnstr("! Debug: expression subtree swapping");
}

PRIVATE void outindchars(int byte, indn_pt count)
int byte;
indn_pt count;
{
    while (count--)
	outbyte(byte);

Lines 1-6 Link Here

(-)a/bcc/dbprintf.c (-3 / +5 lines)
1		1
2	#include <sys/types.h>	2	#include <sys/types.h>
3	#include <fcntl.h>	3	#include <fcntl.h>
		4	#include <string.h>
		5	#include <unistd.h>
4		6
5	#if defined(__STDC__) && !defined(__FIRST_ARG_IN_AX__)	7	#if defined(__STDC__) && !defined(__FIRST_ARG_IN_AX__)
6	#include <stdarg.h>	8	#include <stdarg.h>
Lines 10-15 Link Here
10	#define va_strt(p,i) va_start(p)	12	#define va_strt(p,i) va_start(p)
11	#endif	13	#endif
12		14
		15	int vdbprintf(register __const char *fmt, register va_list ap);
		16
13	#if defined(__STDC__) && !defined(__FIRST_ARG_IN_AX__)	17	#if defined(__STDC__) && !defined(__FIRST_ARG_IN_AX__)
14	int dbprintf(const char * fmt, ...)	18	int dbprintf(const char * fmt, ...)
15	#else	19	#else
Lines 30-38 Link Here
30	static void putch(int ch) { static char buf[2]; *buf = ch; write(2,buf,1); }	34	static void putch(int ch) { static char buf[2]; *buf = ch; write(2,buf,1); }
31		35
32	int	36	int
33	vdbprintf(fmt, ap)	37	vdbprintf(register __const char *fmt, register va_list ap)
34	register __const char *fmt;
35	register va_list ap;
36	{	38	{
37	int c;	39	int c;
38	int count = 0;	40	int count = 0;




FORWARD void rdeclarator P((void));
FORWARD bool_pt regdecl P((void));

PRIVATE struct typestruct *chainprefix(struct typestruct *pretype, struct typestruct *sufftype)
struct typestruct *pretype;
struct typestruct *sufftype;
{
    if (pretype->nexttype != NULL)
    {


/* declselt - get list of declarations for a structure/union member */

PRIVATE void declselt(struct typestruct *structype, offset_T *psoffset, struct typelist **ptypelist)
struct typestruct *structype;
offset_T *psoffset;
struct typelist **ptypelist;
{
    struct typestruct *basetype;
    value_t fieldwidth;

    argsallowed = FALSE;
}

PRIVATE void initarray(struct typestruct *type)
struct typestruct *type;
{
    uoffset_T basesize;
    struct typestruct *basetype;

	defnulls(remaining * basesize);
}

PRIVATE void inititem(struct typestruct *type)
struct typestruct *type;
{
    sym_t startsym;


    }
}

PRIVATE void initstruct(struct typestruct *type)
struct typestruct *type;
{
    struct typestruct *memtype;
    uoffset_T newoffset;

	nextsym();
}

PRIVATE void multidecl(char *sname)
char *sname;
{
    error2error(sname, " already declared");
}

PRIVATE void need(int charneeded)
int charneeded;
{
    static char message[] = "need 'x'";


    return anons;
}

PUBLIC void anonname(char *name, int i)
char *name;
int i;
{
    if (i == 0xfff)
        fatalerror("Too many anonymous structs/unions");




    return lhs;
}

PRIVATE struct nodestruct *exp3to12(fastin_pt lprecedence)
fastin_pt lprecedence;
{
    struct nodestruct *lhs;
    op_pt op;

    return parent;
}

PRIVATE struct nodestruct *postfix_exp(bool_pt seenlp)
bool_pt seenlp;
{
    struct nodestruct *nodeptr;
    struct symstruct *symptr;




FORWARD int redscalar P((struct nodestruct *nodeptr));
FORWARD struct nodestruct *unconvert P((struct nodestruct *nodeptr));

PRIVATE void badlvalue(struct nodestruct *nodeptr)
struct nodestruct *nodeptr;
{
    error("invalid lvalue");
    fixnode(nodeptr);
}

PRIVATE void binconvert(register struct nodestruct *nodeptr)
register struct nodestruct *nodeptr;
{
    bool_t bothscalar;
    value_t divisor;

	nodeptr->nodetype = itype;
}

PRIVATE void castiright(struct nodestruct *nodeptr)
struct nodestruct *nodeptr;
{
    nodeptr->right = castnode(itype, nodeptr->right);
}

PUBLIC struct nodestruct *castnode(struct typestruct *type, struct nodestruct *nodeptr)
struct typestruct *type;
struct nodestruct *nodeptr;
{
    struct symstruct *symptr;


    ettop = (etptr = etree) + ETREESIZE;
}

PRIVATE void fixnode(register struct nodestruct *nodeptr)
register struct nodestruct *nodeptr;
{
    nodeptr->tag = LEAF;
    nodeptr->flags = nodeptr->weight = 0;

    nodeptr->nodetype = errtype;
}

PRIVATE bool_pt isconst0(register struct nodestruct *nodeptr)
register struct nodestruct *nodeptr;
{
    register struct symstruct *symptr;


	   symptr->type->scalar & ISCALAR;
}

PRIVATE bool_pt isnodecharconst(register struct nodestruct *nodeptr)
register struct nodestruct *nodeptr;
{
    register struct symstruct *symptr;


    return FALSE;
}

PUBLIC struct nodestruct *leafnode(struct symstruct *source)
struct symstruct *source;
{
    register struct nodestruct *leafptr;


    return leafptr;
}

PRIVATE void needint(struct nodestruct *nodeptr)
struct nodestruct *nodeptr;
{
    if (!(nodeptr->nodetype->scalar & ISCALAR))
    {

    }
}

PRIVATE void neednonstruct(struct nodestruct *nodeptr)
struct nodestruct *nodeptr;
{
    if (nodeptr->nodetype->constructor & STRUCTU)
    {

    }
}

PRIVATE void needscalar(struct nodestruct *nodeptr)
struct nodestruct *nodeptr;
{
    if (!nodeptr->nodetype->scalar)
    {

    }
}

PRIVATE void needspv(struct nodestruct *nodeptr)
struct nodestruct *nodeptr;
{
    if (nodeptr->nodetype->constructor & (ARRAY | FUNCTION | STRUCTU))
    {

    }
}

PUBLIC struct nodestruct *node(op_pt t, struct nodestruct *p1, struct nodestruct *p2)
op_pt t;
struct nodestruct *p1;
struct nodestruct *p2;
{
#if MAXREGS != 1
    weight_t rightweight;

    }
}

PRIVATE struct typestruct *nodetype(struct nodestruct *nodeptr)
struct nodestruct *nodeptr;
{
    scalar_t bothscalar;
    scalar_t lscalar;

    return left->nodetype;
}

PRIVATE int redscalar(register struct nodestruct *nodeptr)
register struct nodestruct *nodeptr;
{
    if (isnodecharconst(nodeptr))
	return CHAR;
    return nodeptr->nodetype->scalar;
}

PRIVATE struct nodestruct *unconvert(struct nodestruct *nodeptr)
struct nodestruct *nodeptr;
{
    if (nodeptr->nodetype->constructor & (ARRAY | FUNCTION))
	return castnode(pointype(nodeptr->nodetype->constructor & ARRAY ?




	return nonzero iff the result is a temp double on the base of the stack
-----------------------------------------------------------------------------*/

PUBLIC bool_pt f_indirect(struct symstruct *target)
struct symstruct *target;
{
    if (target->indcount == 0)
    {

	result is double on stack (or in condition codes for EQOP)
-----------------------------------------------------------------------------*/

PUBLIC void float1op(op_pt op, struct symstruct *source)
op_pt op;
struct symstruct *source;
{
    saveopreg();
    pointat(source);

	result is double on stack (or in condition codes for EQOP)
----------------------------------------------------------------------------*/

PUBLIC void floatop(op_pt op, struct symstruct *source, struct symstruct *target)
op_pt op;
struct symstruct *source;
struct symstruct *target;
{
    store_t regmark;
    bool_t sflag;

	OPREG must be free
-----------------------------------------------------------------------------*/

PUBLIC void fpush(struct symstruct *source)
struct symstruct *source;
{
    scalar_t scalar;


	records that target has just been pushed to a double on the stack
-----------------------------------------------------------------------------*/

PUBLIC void justpushed(struct symstruct *target)
struct symstruct *target;
{
    sp -= dtypesize;
    onstack(target);





/* call a named (assembly interface) procedure, don't print newline after */

PUBLIC void call(char *name)
char *name;
{
    out_callstring();
    outstr(name);
}

PUBLIC void function(struct symstruct *source)
struct symstruct *source;
{
    if (source->indcount == 0 && source->storage == GLOBAL &&
	!(source->flags & LABELLED) && *source->name.namep != 0)

    }
}

PUBLIC void listo(struct symstruct *target, offset_T lastargsp)
struct symstruct *target;
offset_T lastargsp;
{
    extend(target);
    push(target);

    }
}

PUBLIC void listroot(struct symstruct *target)
struct symstruct *target;
{
    extend(target);
    /* necessary regs are free since they were saved for function */




FORWARD void smakeleaf P((struct nodestruct *exp));
FORWARD void tcheck P((struct nodestruct *exp));

PRIVATE void abop(op_pt op, struct symstruct *source, struct symstruct *target)
op_pt op;
struct symstruct *source;
struct symstruct *target;
{
    store_pt regmark;
    store_pt regpushed;

    recovlist(regpushed);
}

PUBLIC void bileaf(struct nodestruct *exp)
struct nodestruct *exp;
{
    bool_t commutop;
    bool_t tookaddress;

    }
}

PUBLIC fastin_pt bitcount(register uvalue_t number)
register uvalue_t number;
{
    register fastin_pt count;


#endif
}

PUBLIC fastin_pt highbit(register uvalue_t number)
register uvalue_t number;
{
    register fastin_pt bit;


    return bit;
}

PUBLIC void makeleaf(struct nodestruct *exp)
struct nodestruct *exp;
{
    ccode_t condtrue;
    op_pt op;

#endif
}

PRIVATE void smakeleaf(struct nodestruct *exp)
struct nodestruct *exp;
{
    struct nodestruct *left;



#ifdef SELFTYPECHECK

PRIVATE void tcheck(register struct nodestruct *exp)
register struct nodestruct *exp;
{
    register struct symstruct *target;





FORWARD void outnnadr P((struct symstruct *adr));
FORWARD fastin_pt pushpull P((store_pt reglist, bool_pt pushflag));

PUBLIC void addoffset(struct symstruct *source)
struct symstruct *source;
{
#ifdef I8088
    if (source->level == OFFKLUDGELEVEL)

    }
}

PUBLIC void address(struct symstruct *source)
struct symstruct *source;
{
    if (source->indcount == 0)
	bugerror("taking address of non-lvalue");

    bugerror("bad address");
}

PRIVATE void blockpush(struct symstruct *source)
struct symstruct *source;
{
    struct symstruct *length;
    offset_T spmark;

    indirec(source);
}

PUBLIC void exchange(struct symstruct *source, struct symstruct *target)
struct symstruct *source;
struct symstruct *target;
{
    store_t tempreg;


	(except for PC register direct, since there is no LEAX D,PC)
-----------------------------------------------------------------------------*/

PUBLIC void indexadr(struct symstruct *source, struct symstruct *target)
struct symstruct *source;
struct symstruct *target;
{
#ifdef MC6809
    bool_t canABX;

    target->storage = targreg;
}

PUBLIC void indirec(struct symstruct *source)
struct symstruct *source;
{
    if (!(source->type->constructor & (ARRAY | POINTER)))
	bugerror("illegal indirection");

	the result has no offset
-----------------------------------------------------------------------------*/

PUBLIC void load(struct symstruct *source, store_pt targreg)
struct symstruct *source;
store_pt targreg;
{
    if (source->type->scalar & DLONG)
    {

	bugerror("attempting to load non-scalar non-pointer");
}

PRIVATE void loadadr(struct symstruct *source, store_pt targreg)
struct symstruct *source;
store_pt targreg;
{
    if ((store_t) targreg & ALLDATREGS)
    {

	loadreg(source, targreg);
}

PUBLIC void loadany(struct symstruct *source)
struct symstruct *source;
{
    if (source->indcount != 0 || source->offset.offi != 0 || /* kludge u cmp */
	source->level == OFFKLUDGELEVEL || !(source->storage & allregs))

    }
}

PRIVATE void loadlongindirect(struct symstruct *source, store_pt targreg)
struct symstruct *source;
store_pt targreg;
{
    sc_t flags;
    offset_T offset;

    source->type = type;
}

PUBLIC void loadreg(struct symstruct *source, store_pt targreg)
struct symstruct *source;
store_pt targreg;
{
    offset_T longhigh;
    offset_T longlow;

    }
}

PUBLIC void makelessindirect(struct symstruct *source)
struct symstruct *source;
{
    store_pt lreg;


#endif
}

PUBLIC void movereg(struct symstruct *source, store_pt targreg)
struct symstruct *source;
store_pt targreg;
{
    if ((store_t) targreg & ALLDATREGS && source->type->scalar & CHAR)
	targreg = BREG;

    source->offset.offi = 0;	/* indcount was adjusted by outadr */
}

PUBLIC void onstack(register struct symstruct *target)
register struct symstruct *target;
{
    target->storage = LOCAL;
    target->flags = TEMP;

    target->offset.offi = sp;
}

PUBLIC void outadr(struct symstruct *adr)
struct symstruct *adr;
{
    outnnadr(adr);
    outnl();
}

PUBLIC void outcregname(store_pt reg)
store_pt reg;
{
    outcomma();
    outregname(reg);
}

PRIVATE void outnamoffset(struct symstruct *adr)
struct symstruct *adr;
{
    if (adr->flags & LABELLED)
	outlabel(adr->name.label);


/* print comma, then register name, then newline */

PUBLIC void outncregname(store_pt reg)
store_pt reg;
{
    outcomma();
    outnregname(reg);
}

PRIVATE void outnnadr(struct symstruct *adr)
struct symstruct *adr;
{
    bool_t indflag;



/* print register name, then newline */

PUBLIC void outnregname(store_pt reg)
store_pt reg;
{
    outregname(reg);
    outnl();


/* print register name */

PUBLIC void outregname(store_pt reg)
store_pt reg;
{
    switch ((store_t) reg)
    {

#if defined(I8088) && defined(I80386)
/* print register name for short type */

PUBLIC void outshortregname(store_pt reg)
store_pt reg;
{
    switch ((store_t) reg)
    {

	target must be singly indirect or float or double
-----------------------------------------------------------------------------*/

PUBLIC void pointat(struct symstruct *target)
struct symstruct *target;
{
    if (target->type->scalar & RSCALAR)
	(void) f_indirect(target);

    target->type = target->type->nexttype;
}

PUBLIC void poplist(store_pt reglist)
store_pt reglist;
{
    if (reglist)
	sp += pushpull(reglist, FALSE);
}

PUBLIC void push(struct symstruct *source)
struct symstruct *source;
{
    store_t reg;
#ifdef I8088

    onstack(source);
}

PUBLIC void pushlist(store_pt reglist)
store_pt reglist;
{
    if ((store_t) reglist)
	sp -= pushpull(reglist, TRUE);
}

PRIVATE fastin_pt pushpull(store_pt reglist, bool_pt pushflag)
store_pt reglist;
bool_pt pushflag;
{
    store_pt lastregbit;
    void (*ppfunc) P((void));

    return bytespushed;
}

PUBLIC void pushreg(store_pt reg)
store_pt reg;
{
    outpshs();
    outtab();

    sp -= pshregsize;
}

PUBLIC void storereg(store_pt sourcereg, struct symstruct *target)
store_pt sourcereg;
struct symstruct *target;
{
    store_pt targreg;


		structure.element
-----------------------------------------------------------------------------*/

PUBLIC void struc(struct symstruct *source, struct symstruct *target)
struct symstruct *source;
struct symstruct *target;
{
    address(target);
    if (source->offset.offi != 0 || source->level == OFFKLUDGELEVEL)

    }
}

PUBLIC void transfer(struct symstruct *source, store_pt targreg)
struct symstruct *source;
store_pt targreg;
{
    regtransfer(source->storage, targreg);
    source->storage = targreg;




FORWARD void testcond P((struct nodestruct *exp, label_no truelab,
			  label_no falselab, bool_pt nojump));

PUBLIC void cmp(struct symstruct *source, struct symstruct *target, ccode_t *pcondtrue)
struct symstruct *source;
struct symstruct *target;
ccode_t *pcondtrue;
{
    label_no falselab;


    loadlogical(target, falselab);
}

PRIVATE void cmplocal(struct symstruct *source, struct symstruct *target, ccode_t *pcondtrue)
struct symstruct *source;
struct symstruct *target;
ccode_t *pcondtrue;
{
    scalar_t sscalar;
    scalar_t tempscalar;


#ifdef MC6809

PRIVATE void cmporsub(struct symstruct *target)
struct symstruct *target;
{
    if (target->storage & ALLDATREGS)
	outsub();

    }
}

PRIVATE bool_pt cmpsmallconst(value_t intconst, struct symstruct *target, ccode_t *pcondtrue)
value_t intconst;
struct symstruct *target;
ccode_t *pcondtrue;
{
    store_pt targreg;



#endif

PRIVATE void comparecond(struct nodestruct *exp,
                         label_no truelab,
                         label_no falselab,
                         bool_pt nojump /* NB if nonzero, is ~0 so complement is 0 */)
bool_pt nojump;			/* NB if nonzero, is ~0 so complement is 0 */
{
    ccode_t condtrue;
    store_t regmark;

	lbranch(condtrue, truelab);
}

PUBLIC void condop(struct nodestruct *exp)
struct nodestruct *exp;
{
    label_no exitlab;
    label_no falselab;

    exp->left.symptr = truesym;
}

PRIVATE void jumpcond(struct nodestruct *exp,
                      label_no truelab,
                      label_no falselab,
                      bool_pt nojump /* NB if nonzero, is ~0 so complement is 0 */)
bool_pt nojump;			/* NB if nonzero, is ~0 so complement is 0 */
{
    switch (exp->tag)
    {

    }
}

PUBLIC void jumpfalse(struct nodestruct *exp, label_no label)
struct nodestruct *exp;
label_no label;
{
    label_no truelab;


    deflabel(truelab);
}

PUBLIC void jumptrue(struct nodestruct *exp, label_no label)
struct nodestruct *exp;
label_no label;
{
    label_no falselab;


    deflabel(falselab);
}

PRIVATE void loadlogical(struct symstruct *source, label_no falselab)
struct symstruct *source;
label_no falselab;
{
    label_no exitlab;
    struct symstruct *target;

    outnlabel(exitlab);
}

PRIVATE void logandcond(struct nodestruct *exp,
                        label_no truelab,
                        label_no falselab,
                        bool_pt nojump /* NB if nonzero, is ~0 so complement is 0 */)
bool_pt nojump;			/* NB if nonzero, is ~0 so complement is 0 */
{
    label_no andlab;


    jumpcond(exp->right, truelab, falselab, nojump);
}

PUBLIC void logop(struct nodestruct *exp)
struct nodestruct *exp;
{
    label_no falselab;
    struct symstruct *target;

    exp->left.symptr = target;
}

PRIVATE void logorcond(struct nodestruct *exp,
                       label_no truelab,
                       label_no falselab,
                       bool_pt nojump /* NB if nonzero, is ~0 so complement is 0 */)
bool_pt nojump;			/* NB if nonzero, is ~0 so complement is 0 */
{
    label_no orlab;


    jumpcond(exp->right, truelab, falselab, nojump);
}

PRIVATE void reduceconst(struct symstruct *source)
struct symstruct *source;
{
    if (source->storage == CONSTANT && ischarconst(source->offset.offv) &&
	(source->type->scalar & (CHAR | SHORT | INT | DLONG)) != DLONG)

    }
}

PRIVATE void test(struct symstruct *target, ccode_t *pcondtrue)
struct symstruct *target;
ccode_t *pcondtrue;
{
#ifdef I8088
    store_t targreg;


/* test expression and jump depending on NE/EQ */

PRIVATE void testcond(struct nodestruct *exp,
                      label_no truelab,
                      label_no falselab,
                      bool_pt nojump /* NB if nonzero, is ~0 so complement is 0 */)
bool_pt nojump;			/* NB if nonzero, is ~0 so complement is 0 */
{
    ccode_t condtrue;
    struct symstruct *source;





FORWARD void sub1 P((struct symstruct *source, struct symstruct *target));

PUBLIC void add(struct symstruct *source, struct symstruct *target)
struct symstruct *source;
struct symstruct *target;
{
    scalar_t sscalar;


    target->type = iscalartotype(target->type->scalar | sscalar);
}

PUBLIC void incdec(op_pt op, struct symstruct *source)
op_pt op;
struct symstruct *source;
{
    offset_T bump;
    bool_t postflag;

#endif
}

PUBLIC void neg(struct symstruct *target)
struct symstruct *target;
{
    scalar_t scalar;
    struct symstruct *source;

    }
}

PUBLIC void not(struct symstruct *target)
struct symstruct *target;
{
    if (target->type->scalar & DLONG)
	long1op(NOTOP, target);


/* 1-byte ops like AND acting on integers (not both constant) */

PUBLIC void op1(op_pt op, struct symstruct *source, struct symstruct *target)
op_pt op;
struct symstruct *source;
struct symstruct *target;
{
    char *opstr;
#ifdef OP1

    }
}

PUBLIC void ptrsub(struct symstruct *source, struct symstruct *target)
struct symstruct *source;
struct symstruct *target;
{
    label_no exitlab;
    uoffset_T factor;

    }
}

PUBLIC void sub(struct symstruct *source, struct symstruct *target)
struct symstruct *source;
struct symstruct *target;
{
    scalar_t sscalar;


    target->type = iscalartotype(target->type->scalar | sscalar);
}

PRIVATE void sub1(struct symstruct *source, struct symstruct *target)
struct symstruct *source;
struct symstruct *target;
{
    if (source->storage == CONSTANT)
	source->type = itype;




}

#ifdef BUILTIN_CPP
PRIVATE void definefile(char *fname)
char *fname;
{
    char *def;



/* initialise current input file */

PRIVATE void inputinit(char *fname, fd_t fd)
char *fname;
fd_t fd;
{
    register struct fbufstruct *newinputbuf;



/* open input and output files and get options */

PUBLIC void openio(int argc, char *argv[])
int argc;
char *argv[];
{
    register char *arg;
    int argn;





/* add label to circular list */

PRIVATE void addlabel(ccode_pt cond, label_no label, char *patch)
ccode_pt cond;
label_no label;
char *patch;
{
    register struct labdatstruct *labptr;



/* clear out labels no longer in buffer */

PUBLIC void clearlabels(char *patchbuf, char *patchtop)
char *patchbuf;
char *patchtop;
{
    register struct labdatstruct *labptr;
    struct labdatstruct *labtop;


/* define location of label and backpatch references to it */

PUBLIC void deflabel(label_no label)
label_no label;
{
    char *cnameptr;
    struct labdatstruct *labmin;

    addlabel((ccode_pt) 0, label, (char *) NULL);
}

PRIVATE struct labdatstruct *findlabel(label_no label)
label_no label;
{
    register struct labdatstruct *labptr;
    struct labdatstruct *labtop;


/* jump to label */

PUBLIC void jump(label_no label)
label_no label;
{
    lbranch(RA, label);
}

/* long branch on condition to label */

PUBLIC void lbranch(ccode_pt cond, label_no label)
ccode_pt cond;
label_no label;
{
#ifdef I8088
    char *cnameptr;


/* print condition code name */

PUBLIC void outcond(ccode_pt cond)
ccode_pt cond;
{
    char *cnameptr;



/* print label */

PUBLIC void outlabel(label_no label)
label_no label;
{
    outbyte(LABELSTARTCHAR);
    outhexdigs((uoffset_T) label);


/* print label and newline */

PUBLIC void outnlabel(label_no label)
label_no label;
{
    outlabel(label);
#ifdef LABELENDCHAR


/* short branch on condition to label */

PUBLIC void sbranch(ccode_pt cond, label_no label)
ccode_pt cond;
label_no label;
{
#ifdef I8088
    char *cnameptr;




    return 1;
}

PUBLIC void initexpression(struct typestruct *type)
struct typestruct *type;
{
    struct nodestruct *etmark;
    struct nodestruct *exp;

    exprptr = exprmark;
}

PUBLIC struct typestruct *loadexpression(store_pt targreg, struct typestruct *targtype)
store_pt targreg;
struct typestruct *targtype;
{
    struct nodestruct *etmark;
    struct nodestruct *exp;




	or singly indirect (local, global, or from an index reg)
-----------------------------------------------------------------------------*/

PUBLIC void longop(op_pt op, struct symstruct *source, struct symstruct *target)
op_pt op;
struct symstruct *source;
struct symstruct *target;
{
    store_pt reglist;
    store_t regmark;

	or singly indirect (local, global, or from an index reg)
-----------------------------------------------------------------------------*/

PUBLIC void long1op(op_pt op, struct symstruct *target)
op_pt op;
struct symstruct *target;
{
    pushlist(reguse & OPREG);
    load(target, OPREG);




#endif
#endif

PUBLIC void bugerror(char *message)
char *message;
{
    error2error("compiler bug? - ", message);
}


/* error handler */

PUBLIC void error(char *message)
char *message;
{
    error2error(message, "");
}

/* error handler - concatenate 2 messages */

PUBLIC void error2error(char *message1, char *message2)
char *message1;
char *message2;
{
    char *warning;



/* fatal error, exit early */

PUBLIC void fatalerror(char *message)
char *message;
{
    error(message);
    finishup();

    output = 1;			/* standard output */
}

PUBLIC void limiterror(char *message)
char *message;
{
    error2error("compiler limit exceeded - ", message);
    finishup();
}

PUBLIC void openout(char *oname)
char *oname;
{
    if (output != 1)
	fatalerror("more than one output file");


/* print character */

PUBLIC void outbyte(int c)
int c;
{
#if C_CODE || __AS09__ + __AS386_16__ + __AS386_32__ != 1
    register char *outp;


/* print line number in format ("# %u \"%s\"%s", nr, fname, str) */

PUBLIC void outcpplinenumber(unsigned nr, char *fname, char *str)
unsigned nr;
char *fname;
char *str;
{
    outstr("# ");
    outudec(nr);


/* print unsigned offset, hex format */

PUBLIC void outhex(uoffset_T num)
uoffset_T num;
{
#ifdef HEXSTARTCHAR
    if (num >= 10)


/* print unsigned offset, hex format with digits only (no hex designator) */

PUBLIC void outhexdigs(register uoffset_T num)
register uoffset_T num;
{
    if (num >= 0x10)
    {


/* print string terminated by EOL */

PUBLIC void outline(char *s)
char *s;
{
    register char *outp;
    register char *rs;


/* print character, then newline */

PUBLIC void outnbyte(int byte)
int byte;
{
    outbyte(byte);
    outnl();


/* print unsigned offset, hex format, then newline */

PUBLIC void outnhex(uoffset_T num)
uoffset_T num;
{
    outhex(num);
    outnl();


/* print opcode and newline, bump lc by 1 */

PUBLIC void outnop1str(char *s)
char *s;
{
    opcodeleadin();
    outstr(s);


/* print opcode and newline, bump lc by 2 */

PUBLIC void outnop2str(char *s)
char *s;
{
    opcodeleadin();
    outstr(s);


/* print string, then newline */

PUBLIC void outnstr(char *s)
char *s;
{
    outstr(s);
    outnl();


/* print opcode */

PUBLIC void outop0str(char *s)
char *s;
{
    opcodeleadin();
    outstr(s);


/* print opcode, bump lc by 1 */

PUBLIC void outop1str(char *s)
char *s;
{
    opcodeleadin();
    outstr(s);


/* print opcode, bump lc by 2 */

PUBLIC void outop2str(char *s)
char *s;
{
    opcodeleadin();
    outstr(s);


/* print opcode, bump lc by 3 */

PUBLIC void outop3str(char *s)
char *s;
{
    opcodeleadin();
    outstr(s);


/* print signed offset, hex format */

PUBLIC void outshex(offset_T num)
offset_T num;
{
    if (num >= -(maxoffsetto + 1))
    {


/* print string  */

PUBLIC void outstr(char *s)
char *s;
{
#if C_CODE || __AS09__ + __AS386_16__ + __AS386_32__ != 1
    register char *outp;


/* print unsigned, decimal format */

PUBLIC void outudec(unsigned num)
unsigned num;
{
    char str[10 + 1];



/* print unsigned value, hex format (like outhex except value_t is larger) */

PUBLIC void outuvalue(uvalue_t num)
uvalue_t num;
{
#ifdef HEXSTARTCHAR
    if (num >= 10)


/* print unsigned value, hex format with digits only (no hex designator) */

PRIVATE void outvaldigs(register uvalue_t num)
register uvalue_t num;
{
    if (num >= 0x10)
    {


/* print signed value, hex format (like outshex except value_t is larger) */

PUBLIC void outvalue(register value_t num)
register value_t num;
{
    if (num < 0)
    {


/* push decimal digits of an unsigned onto a stack of chars */

PUBLIC char *pushudec(register char *s, register unsigned num)
register char *s;
register unsigned num;
{
    register unsigned reduction;





    symptr->prev = hashptr;
}

PRIVATE void defineorundefinestring(char *str /* "name[=def]" or "name def" */,
									bool_pt defineflag)
bool_pt defineflag;
{
    char *fakeline;
    unsigned len;

    ourfree(fakeline - 3);
}

PUBLIC void definestring(char *str /* "name[=def]" or "name def" */)
char *str;			/* "name[=def]" or "name def" */
{
    defineorundefinestring(str, TRUE);
}


/* ifcontrol - process #if, #ifdef, #ifndef */

PRIVATE void ifcontrol(sym_pt ifcase)
sym_pt ifcase;
{
    bool_t iftrue;
    struct symstruct *symptr;

	delsym(symptr);
}

PUBLIC void undefinestring(char *str)
char *str;
{
    defineorundefinestring(str, FALSE);
}





/* change stack ptr without changing condition codes */

PUBLIC void changesp(offset_T newsp, bool_pt absflag)
offset_T newsp;
bool_pt absflag;
{
    if (newsp != sp || ((bool_t) absflag && switchnow != NULL))
    {


/* load source to any while preserving target */

PUBLIC void loadpres(struct symstruct *source, struct symstruct *target)
struct symstruct *source;
struct symstruct *target;
{
    store_t regmark;



/* change stack ptr */

PUBLIC void modstk(offset_T newsp)
offset_T newsp;
{
    if (newsp != sp)
    {


/* preserve target without changing source */

PUBLIC void pres2(struct symstruct *source, struct symstruct *target)
struct symstruct *source;
struct symstruct *target;
{
    if (target->storage & allregs)
    {


/* preserve source */

PUBLIC void preserve(struct symstruct *source)
struct symstruct *source;
{
    if (source->storage & allregs)
    {


/* preserve lvalue target without changing source or target */

PUBLIC store_pt preslval(struct symstruct *source, struct symstruct *target)
struct symstruct *source;
struct symstruct *target;
{
    store_pt regpushed;


    return regpushed;
}

PUBLIC void recovlist(store_pt reglist)
store_pt reglist;
{
    poplist(reglist);
    reguse |= (store_t) reglist;

 /* CONSTANT, BREG, DREG, XREG = INDREG0, UREG = INDREG1, YREG = INDREG2 */
#endif

PUBLIC void savereturn(store_pt savelist, offset_T saveoffset)
store_pt savelist;
offset_T saveoffset;
{
    store_t reg;
    smalin_t *regoffptr;




    }
}

PUBLIC void cppscan(int asm_only)
int asm_only;
{
    int start_of_line = 1;
#ifndef ASM_BARE

    }
}

PUBLIC void eofin(char *message)
char *message;
{
    error2error("end of file in ", message);
}

Lines 19-28 Link Here

(-)a/bcc/softop.c (-4 / +1 lines)
19	considerable effort goes into avoiding unnecessary pushes	19	considerable effort goes into avoiding unnecessary pushes
20	-----------------------------------------------------------------------------*/	20	-----------------------------------------------------------------------------*/
21		21
22	PUBLIC void softop(op, source, target)	22	PUBLIC void softop(op_pt op, struct symstruct source, struct symstruct target)
23	op_pt op;
24	struct symstruct *source;
25	struct symstruct *target;
26	{	23	{
27	store_t regpushed;	24	store_t regpushed;
28	store_t regmark;	25	store_t regmark;





/* --- utility routines --- */

PRIVATE void addloop(struct loopstruct *newloop)
struct loopstruct *newloop;
{
    newloop->breaklab = getlabel();
    newloop->contlab = getlabel();

    loopnow = loopnow->prevloop;
}

PRIVATE void evalexpression(struct nodestruct *exp)
struct nodestruct *exp;
{
    offset_T spmark;


    exprptr = exprmark;
}

PRIVATE bool_pt isforever(register struct nodestruct *exp)
register struct nodestruct *exp;
{
    return exp == NULL ||
	(exp->tag == LEAF && exp->left.symptr->storage == CONSTANT &&
	exp->left.symptr->offset.offv != 0);
}

PRIVATE void sort(struct casestruct *caselist, int count)	/* shell sort */
struct casestruct *caselist;
int count;
{
    register int gap;
    register int i;

	jump(dfaultlab);
}

PUBLIC void outswoffset (offset_T offset)
offset_T offset;
{
#ifdef FRAMEPOINTER
    outoffset(offset - softsp - framep);




FORWARD struct symstruct *addkeyword P((char *name, sym_pt code));
FORWARD void heapcorrupterror P((void));

PUBLIC struct symstruct *addglb(char *name, struct typestruct *type)
char *name;
struct typestruct *type;
{
    struct symstruct **hashptr;
    struct symstruct *oldsymptr = NULL; /* for -Wall */

    return symptr;
}

PRIVATE struct symstruct *addkeyword(char *name, sym_pt code)
char *name;
sym_pt code;
{
    struct symstruct *symptr;


    return symptr;
}

PUBLIC struct symstruct *addloc(char *name, struct typestruct *type)
char *name;
struct typestruct *type;
{
    struct symstruct **hashptr;
    register struct symstruct *symptr;

    return symptr;
}

PUBLIC struct symstruct *addlorg(char *name, struct typestruct *type)
char *name;
struct typestruct *type;
{
    if (level != GLBLEVEL)
	return addloc(name, type);
    return addglb(name, type);
}

PUBLIC void addsym(char *name, struct typestruct *type, register struct symstruct *symptr)
char *name;
struct typestruct *type;
register struct symstruct *symptr;
{
    if (type->constructor & (ARRAY | FUNCTION))
	symptr->indcount = 0;

    strcpy(symptr->name.namea, name);
}

PUBLIC struct symstruct *constsym(value_t longconst)
value_t longconst;
{
    register struct symstruct *symptr;


    return symptr;
}

PUBLIC void delsym(register struct symstruct *symptr)
register struct symstruct *symptr;
{
    if ((*(symptr->prev) = symptr->next) != NULL)
	symptr->next->prev = symptr->prev;


#endif

PUBLIC struct symstruct *exprsym(struct symstruct *symptr)
struct symstruct *symptr;
{
    register struct symstruct *newsymptr;


    return newsymptr;
}

PUBLIC struct symstruct *findlorg(char *name)
char *name;
{
    struct symstruct *symptr;


    return symptr;
}

PUBLIC struct symstruct *findstruct(char *name)
char *name;
{
    struct symstruct *symptr;



/* convert name to a hash table ptr */

PUBLIC struct symstruct **gethashptr(char *sname)
char *sname;
{
    register int hashval;
    register char *rsname;


/* hold string for dumping at end, to avoid mixing it with other data */

PUBLIC label_no holdstr(char *sptr, char *stop)
char *sptr;
char *stop;
{
    register struct string *stringp;


	    delsym(symptr);
}

PUBLIC void ourfree(void *ptr)
void *ptr;
{
    free(ptr);
}

PUBLIC void *ourmalloc(unsigned nbytes)
unsigned nbytes;
{
    void *ptr;


    return ptr;
}

PUBLIC void outofmemoryerror(char *message)
char *message;
{
    error2error("compiler out of memory", message);


    finishup();
}

PUBLIC void *growobject(void *object, unsigned extra)
void *object;
unsigned extra;
{
    /* size_t */ unsigned oblength;


#define ALLOC_OVERHEAD (sizeof (unsigned))
#endif

PUBLIC void growheap(unsigned size)
unsigned size;
{
    register char *newptr;


    *(unsigned *) newptr = MARKER;
}

PUBLIC void *qmalloc(unsigned size)
unsigned size;
{
    register char *ptr;


    return ptr;
}

PUBLIC void swapsym(struct symstruct *sym1, struct symstruct *sym2)
struct symstruct *sym1;
struct symstruct *sym2;
{
    struct symstruct swaptemp;


}

#ifndef VERY_SMALL_MEMORY
PUBLIC struct symstruct *findstrm(struct typestruct *type, char *name)
struct typestruct *type;
char *name;
{
    struct symstruct *symptr;
    int i;




PRIVATE char skey0;
PRIVATE char skey1;

PUBLIC struct typestruct *addstruct(char *structname)
char *structname;
{
    unsigned namelength;
    struct symstruct *symptr;

}
#endif

PUBLIC struct typestruct *iscalartotype(scalar_pt scalar)
scalar_pt scalar;
{
    if (scalar & LONG)
    {

    return type;
}

PUBLIC void outntypechar(struct typestruct *type)
struct typestruct *type;
{
    outnbyte(*type->tname);
}

PUBLIC struct typestruct *pointype(struct typestruct *type)
struct typestruct *type;
{
    return prefix(POINTER, ptypesize, type);
}

PUBLIC struct typestruct *prefix(constr_pt constructor, uoffset_T size, struct typestruct *type)
constr_pt constructor;
uoffset_T size;
struct typestruct *type;
{
    register struct typestruct *searchtype;


    return type->prevtype = searchtype;
}

PUBLIC struct typestruct *promote(struct typestruct *type)
struct typestruct *type;
{
    scalar_t scalar;


    return type;
}

PUBLIC struct typestruct *tosigned(struct typestruct *type)
struct typestruct *type;
{
    switch (type->scalar & ~(UNSIGNED | DLONG))
    {

    }
}

PUBLIC struct typestruct *tounsigned(struct typestruct *type)
struct typestruct *type;
{
    switch (type->scalar & ~(UNSIGNED | DLONG))
    {




unsigned char bpb_flags[100];
int has_bpb_overrides = 0;

// Forward declarations
static void check_msdos();
int set_superfield(char * setstr);
int Usage();
int open_disk(char * diskname);
int read_sector(int sectno, char * loadaddr);
int check_simpledos(int bb_fatbits);
int check_tar();
int check_zapped();
int check_mbr();
int copy_tarblock();
int copy_mbr(char * boot_data, int boot_size);
int copy_superfields(char * bootsect);
int save_super(char * bootsect);
int print_super(char * bootsect);
int close_disk();
int set_dosname(int boot_name);
int set_asciz(int boot_name);
int write_sector(int sectno, char * loadaddr);

int
main(int argc, char ** argv)
char ** argv;
{
   FILE * fd;
   struct bblist *ptr = bblocks;

   exit(0);
}

int
Usage()
{
   struct bblist *ptr = bblocks;

/**************************************************************************/

int
open_disk(char * diskname)
char * diskname;
{
#ifdef __MSDOS__
   /* Freedos fix */

   return 0;
}

int
close_disk()
{
   if( diskfd && disktype == 0 ) fclose(diskfd);

}

int
write_sector(int sectno, char * loadaddr)
int sectno;
char * loadaddr;
{
#ifdef __MSDOS__
   if( disktype == 1 || disktype == 2 || disktype == 129 )

}

int
read_sector(int sectno, char * loadaddr)
int sectno;
char * loadaddr;
{
   int cc;
#ifdef __MSDOS__

#endif
/**************************************************************************/

int
check_zapped()
{
   int i;

#define buff_tar	(*(struct tar_head*) buffer)
#define boot_tar	(*(struct tar_head*) tarboot_data)

unsigned int oct(char *s)
char *s;
{
   unsigned int val = 0;
   int i;

   return val;
}

int
check_tar()
{
   char vbuf[100];

   return 0;
}

int
copy_tarblock()
{
   char lbuf[20];

   { 0, -1,0,0}
};

int
print_super(char * bootsect)
{
static char * fieldnames[] = {
   "System ID",

   }
}

int
decode_super(char * bootsect)
{
   int i;


     copy_zero = 0;
}

int
save_super(char * bootsect)
{
   FILE * fd;
   char * fname = "makeboot.sav";

   fclose(fd);
}

int set_superfield(char * setstr)
char * setstr;
{
   int i, l;
   char * av;

   }
}

int
copy_superfields(char * bootsect)
{
   int i, j;


   if(!force) exit(2);
}

int
check_simpledos(int bb_fatbits)
{
   long numclust = 0xFFFF;
   char * err = 0;

   }
}

int
set_dosname(int boot_name)
{
   char dos_name[20];
   int i,j;

   memcpy(buffer+boot_name, dos_name, 11);
}

int
set_asciz(int boot_name)
{
   int i, j;


   }
}

int
check_mbr()
{
   int i = 0;

   }
}

int
copy_mbr(char * boot_data, int boot_size)
int boot_size;
{
   int boot_to_copy = 446;





{ int rv; dont_subst++; rv=get_onetok(SKIP_SPACE); dont_subst--; return rv; }

static int
get_onetok(int keep)
int keep;
{
   char * p;
   int state;

}

static void 
unchget(int ch)
{
#if CPP_DEBUG
   fprintf(stderr, "\b", ch);

}

static int
do_proc_if(int type)
int type;
{
   int ch = 0;
   if(if_false && if_hidden)

}

static int_type
get_expression(int prio)
int prio;
{
   int_type lvalue;
   int_type rvalue;

}

void
gen_substrings(char * macname, char * data_str, int arg_count, int is_vararg)
char * macname;
char * data_str;
int arg_count;
int is_vararg;
{
   char * mac_text = 0;
   struct arg_store *arg_list;

}

static char * 
insert_substrings(char * data_str, struct arg_store *arg_list, int arg_count)
char * data_str;
struct arg_store *arg_list;
int arg_count;
{
   int ac, ch;
   char * p, * s;




static int hashvalue P((int namespace, char * word));

void *
read_entry(int namespace, char * word)
int namespace;
char * word;
{
   int hash_val;
   struct hashentry * hashline;

}

char *
set_entry(int namespace, char * word, void * value)
int namespace;
char * word;
void * value;
{
   int hash_val, i;
   struct hashentry * hashline, *prev;

   return hashline->word;
}

static int hashvalue(int namespace, char * word)
int namespace;
char * word;
{
   int val = namespace;
   char *p = word;




FILE * ofd = 0;

int
main(int argc, char ** argv)
int argc;
char ** argv;
{
   int ar, i;
   char * p;

}

void
undefine_macro(char * name)
char * name;
{
   struct define_item * ptr;


}

void
define_macro(char * name)
char * name;
{
   char * p;
   char * value;

}

FILE *
open_include(char * fname, char * mode, int checkrel)
char * fname;
char * mode;
int checkrel;
{
   FILE * fd = 0;
   int i;

static int outpos = 0;

void
cmsg(char * mtype, char * str)
char * mtype;
char * str;
{
   if (c_fname && (*c_fname || c_lineno))
      fprintf(stderr, "%s:%d: ", c_fname, c_lineno);

}

void
cfatal(char * str)
char * str;
{
   cmsg("CPP-FATAL error", str);
   exit(255);
}

void
cerror(char * str)
char * str;
{
   exit_code = 1;
   cmsg("error", str);
}

void
cwarn(char * str)
char * str;
{
   cmsg("warning", str);
}

void
pr_indent(int count)
int count;
{
   if(count>10) count=10;
   while(count>0) {fprintf(ofd, "\t"); count--; }

}

char *
token_txn(int token)
int token;
{
   char * s = "UNKNOWN";
   static char buf[17];




__inline
#endif
static unsigned int
hash1 (register const char *str, register unsigned int len)
     register const char *str;
     register unsigned int len;
{
  static unsigned char asso_values[] =
    {

__inline
#endif
struct token_trans *
is_ctok (register const char *str, register unsigned int len)
     register const char *str;
     register unsigned int len;
{
  static struct token_trans wordlist[] =
    {




__inline
#endif
static unsigned int
hash2 (register const char *str, register unsigned int len)
     register const char *str;
     register unsigned int len;
{
  static unsigned char asso_values[] =
    {

__inline
#endif
struct token_trans *
is_ckey (register const char *str, register unsigned int len)
     register const char *str;
     register unsigned int len;
{
  static struct token_trans wordlist[] =
    {




void manifest_constant P((void));

int
main(int argc, char ** argv)

char ** argv;
{
   int ar;
   char * ptr;

   exit(0);
}

void Usage(char * prog)
char * prog;
{
   fprintf(stderr, "Usage: %s [-DFLAG] [-UFLAG] [-blcrhMDU] [-C##] files\n",
		   prog);

}

void
save_name(char * varname, int state)
char * varname;
int state;
{
   struct varrec * curr;
   struct varrec * prev = 0;

}

void
do_file(char * fname)
char * fname;
{
   filename = fname;
   prline = lineno = 0;

}

void
set_line(int lineno)
int lineno;
{
   if( prline+2 == lineno )
      printf("\n");

}

int
do_ifdef(char * p, int which)
char * p;
int which;
{
   char * nm;
   char * s;


#if 0

do_if(char * p)
char * p;
{
   /*
    * Look for:

#endif

void
check_name(char * nm)
char * nm;
{
   char * p;
   char * s;

}

void
fatal(char * msg)
char * msg;
{
   fprintf(stderr, "Fatal error:%s\n", msg);
   exit(1);




FORWARD void refer P((void));
FORWARD void stderr_out P((void));

PUBLIC void ioinit(char *progname)
char *progname;
{
    infd = ERR;
    if (*progname)

#endif
}

PUBLIC void errtrace(char *name, int level)
char *name;
int level;
{
    while (level-- > 0)
	putbyte(' ');

}
#endif

PUBLIC void openin(char *filename)
char *filename;
{
#if 0 /* XXX - this probably won't work with constructed lib names? */
    if (infd == ERR || strcmp(inputname, filename) != 0)

    }
}

PUBLIC void openout(char *filename)
char *filename;
{
    mode_t oldmask;


#endif
}

PRIVATE void outhexdigs(register bin_off_t num)
register bin_off_t num;
{
    if (num >= 0x10)
    {

    putbyte(hexdigit[num]);
}

PRIVATE void put04x(register unsigned  num)
register unsigned num;
{
    putbyte(hexdigit[num / 0x1000]);
    putbyte(hexdigit[(num / 0x100) & 0x0F]);


#ifdef LONG_OFFSETS

PUBLIC void put08lx(register bin_off_t num)
register bin_off_t num;
{
    put04x(num / 0x10000);
    put04x(num % 0x10000);


#else /* not LONG_OFFSETS */

PUBLIC void put08x(register bin_off_t num)
register bin_off_t num;
{
    putstr("0000");
    put04x(num);


#endif /* not LONG_OFFSETS */

PUBLIC void putbstr(unsigned width, char *str)
unsigned width;
char *str;
{
    unsigned length;
    

    putstr(str);
}

PUBLIC void putbyte(int ch)
int ch;
{
    register char *ebuf;


    errbufptr = ebuf;
}

PUBLIC void putstr(char *message)
char *message;
{
    while (*message != 0)
	putbyte(*message++);
}

PRIVATE void putstrn(char *message)
char *message;
{
    putstr(message);
    putbyte('\n');

    return ch;
}

PUBLIC void readin(char *buf, unsigned count)
char *buf;
unsigned count;
{
    int ch;
    

    }
}

PUBLIC bool_pt readineofok(char *buf, unsigned count)
char *buf;
unsigned count;
{
    int ch;
    

    return FALSE;
}

PUBLIC void seekin(unsigned long offset)
unsigned long offset;
{
    inbufptr = inbufend = inbuf;
    if (lseek(infd, (off_t) offset, SEEK_SET) != offset)
	prematureeof();
}

PUBLIC void seekout(unsigned long offset)
unsigned long offset;
{
    flushout();
    if (lseek(outfd, (off_t) offset, SEEK_SET) != offset)

}

#ifdef REL_OUTPUT
PUBLIC void seektrel(unsigned long offset)
unsigned long offset;
{
    flushtrel();
    if (lseek(trelfd, (off_t) offset, SEEK_SET) != offset)

}
#endif

PUBLIC void writechar(int ch)
int ch;
{
    register char *obuf;


}

#ifdef REL_OUTPUT
PUBLIC void writedrel(register char *buf, unsigned count)
register char *buf;
unsigned count;
{
    register char *rbuf;


}
#endif

PUBLIC void writeout(register char *buf, unsigned count)
register char *buf;
unsigned count;
{
    register char *obuf;


}

#ifdef REL_OUTPUT
PUBLIC void writetrel(register char *buf, unsigned count)
register char *buf;
unsigned count;
{
    register char *rbuf;



/* error module */

PRIVATE void errexit(char *message)
char *message;
{
    putstrn(message);
    exit(2);
}

PUBLIC void fatalerror(char *message)
char *message;
{
    refer();
    errexit(message);
}

PUBLIC void inputerror(char *message)
char *message;
{
    refer();
    putstr(message);

    errexit(inputname);
}

PUBLIC void input1error(char *message)
char *message;
{
    refer();
    putstr(inputname);
    errexit(message);
}

PRIVATE void outputerror(char *message)
char *message;
{
    refer();
    putstr(message);

    inputerror("premature end of");
}

PUBLIC void redefined(char *name, char *message, char *archentry, char *deffilename, char *defarchentry)
char *name;
char *message;
char *archentry;
char *deffilename;
char *defarchentry;
{
    ++warncount;
    refer();

    putstrn("");
}

PUBLIC void interseg(char *fname, char *aname, char *name)
char *fname, *aname, *name;
{
    ++errcount;
    refer();

    putstr(": ");
}

PUBLIC void reserved(char *name)
char *name;
{
    ++errcount;
    stderr_out();

    putstrn(name);
}

PUBLIC void size_error(int seg, bin_off_t count, bin_off_t size)
int seg;
bin_off_t count;
bin_off_t size;
{
    refer();
    putstr("seg ");

    errexit("");
}

PUBLIC void undefined(char *name)
char *name;
{
    ++errcount;
    stderr_out();

#endif
}

PUBLIC void use_error(char *message)
char *message;
{
    refer();
    putstrn(message);




FORWARD char *buildname P((char *pre, char *mid, char *suf));
FORWARD char *expandlib P((char *fn));

PRIVATE char *buildname(char *pre, char *mid, char *suf)
char *pre;
char *mid;
char *suf;
{
    char *name;


    return name;
}

PRIVATE char *expandlib(char *fn)
char *fn;
{
    char *path, *s;
    int i;

    return NUL_PTR;
}

PUBLIC int main(int argc, char **argv)
int argc;
char **argv;
{
    register char *arg;
    int argn;





/* link all symbols connected to entry symbols */

PUBLIC void linksyms(bool_pt argreloc_output)
bool_pt argreloc_output;
{
    char needlink;
    struct entrylist *elptr;

    while (needlink);
}

PRIVATE void linkrefs(struct modstruct *modptr)
struct modstruct *modptr;
{
    register struct symstruct **symparray;
    register struct symstruct *symptr;




long tot_size_text=0, tot_size_data=0, tot_size_bss=0;

int
main(int argc, char ** argv)
int argc;
char ** argv;
{
   int ar;
   char * p;

}

void
do_file(char * fname)
char * fname;
{
   unsigned int magic;
   long 	filelength;


/* read archive header and return length */
long
read_arheader(char *archentry)
char *archentry;
{
   char *	  endptr;
   struct ar_hdr  arheader;

}

void
do_module(char * fname, char * archive)
char * fname;
char * archive;
{
   int  modno, i;


}

int
error(char * str)
char * str;
{
   switch( display_mode )
   {

}

long
get_sized(int sz)
int sz;
{
   switch(sz)
   {

}

void
hex_output(int ch)
int ch;
{
static char linebuf[80];
static char buf[20];





/* read all symbol definitions in an object file */

PUBLIC void readsyms(char *filename, bool_pt trace)
char *filename;
bool_pt trace;
{
    char *archentry;
    long filelength;


/* read archive header and return length */

PRIVATE long readarheader(char **parchentry)
char **parchentry;
{
    struct ar_hdr arheader;
    char *endptr;


/* read the next module */

PRIVATE void readmodule(char *filename, char *archentry)
char *filename;
char *archentry;
{
    struct symdstruct		/* to save parts of symbol before name known */
    {


/* put symbol on entry symbol list if it is not already */

PUBLIC void entrysym(struct symstruct *symptr)
struct symstruct *symptr;
{
    register struct entrylist *elptr;


    modlast = modptr;
}

PRIVATE bool_pt redsym(register struct symstruct *symptr, bin_off_t value)
register struct symstruct *symptr;
bin_off_t value;
{
    register struct redlist *rlptr;
    char class;

    return TRUE;
}

PRIVATE unsigned checksum(char *string, unsigned length)
char *string;
unsigned length;
{
    unsigned char sum;		/* this is a 1-byte checksum */


    return sum;
}

PUBLIC bin_off_t readconvsize(unsigned countindex)
unsigned countindex;
{
    return readsize(convertsize[countindex]);
}

PUBLIC bin_off_t readsize(unsigned count)
unsigned count;
{
    char buf[MAX_OFFSET_SIZE];


    return cntooffset(buf, count);
}

PRIVATE unsigned segbits(unsigned seg, char *sizedesc)
unsigned seg;
char *sizedesc;
{
    return 3 & ((unsigned) sizedesc[((NSEG - 1) - seg) / 4] >> (2 * (seg % 4)));
    /* unsigned to give logical shift */
}

PUBLIC unsigned segsizecount(unsigned seg, struct modstruct *modptr)
unsigned seg;
struct modstruct *modptr;
{
    return convertsize[segbits(seg, modptr->segsizedesc)];
}




/* add named symbol to end of table - initialise only name and next fields */
/* caller must not duplicate names of externals for findsym() to work */

PUBLIC struct symstruct *addsym(char *name)
char *name;
{
    struct symstruct **hashptr;
    struct symstruct *oldsymptr = 0;


/* lookup named symbol */

PUBLIC struct symstruct *findsym(char *name)
char *name;
{
    struct symstruct *symptr;



/* convert name to a hash table ptr */

PRIVATE struct symstruct **gethashptr(char *name)
register char *name;
{
    register unsigned hashval;



/* move symbol descriptor entries to top of table (no error checking) */

PUBLIC char *moveup(unsigned nbytes)
unsigned nbytes;
{
    register char *source;
    register char *target;


/* our version of malloc */

PUBLIC char *ourmalloc(unsigned nbytes)
unsigned nbytes;
{
    char *allocptr;



/* our version of free (release from bottom of table) */

PUBLIC void ourfree(char *cptr)
char *cptr;
{
    check_used();
    tableptr = cptr;


/* release from top of table */

PUBLIC void release(char *cptr)
char *cptr;
{
    check_used();
    mainavail += cptr - tableend;


/* allocate space for string */

PUBLIC char *stralloc(char *s)
char *s;
{
    return strcpy(ourmalloc((unsigned) strlen(s) + 1), s);
}




#include "globvar.h"

void xxerr P((char *));
void xxerr(char * x) { write(2, x, strlen(x)); }

static int no_swap   = 1;

static int long_off[4] = {0,1,2,3};
static int int_off[2] = {0,1};

PUBLIC bool_pt typeconv_init(bool_pt big_endian, bool_pt long_big_endian)
bool_pt big_endian;
bool_pt long_big_endian;
{
   int i;
   no_swap = (!big_endian && !long_big_endian);

   return 1;
}

PUBLIC void u2c2(char *buf, u2_pt offset)
char *buf;
u2_pt offset;
{
#ifdef __AS386_16__
   if( no_swap )

   buf[int_off[1]] = (offset>>8);
}

PUBLIC void u4c4(char *buf, u4_t offset)
char *buf;
u4_t offset;
{
   int i;
#ifdef __AS386_16__

   }
}

PUBLIC void u4cn(char *buf, u4_t offset, unsigned count)
char *buf;
u4_t offset;
unsigned count;
{
    switch(count)
    {

    }
}

PUBLIC void u2cn(char *buf, u2_pt offset, unsigned count)
char *buf;
u2_pt offset;
unsigned count;
{
    switch(count)
    {

    }
}

PUBLIC u2_pt c2u2(char *buf)
char *buf;
{
    u2_pt res;
#ifdef __AS386_16__

    return res;
}

PUBLIC u4_t c4u4(char *buf)
char *buf;
{
    u4_t res;
    int i;

    return res;
}

PUBLIC u4_t cnu4(char *buf, unsigned count)
char *buf;
unsigned count;
{
    switch (count)
    {

    }
}

PUBLIC u2_pt cnu2(char *buf, unsigned count)
char *buf;
unsigned count;
{
    switch (count)
    {




#define FUNCNAME writebin
#endif

PUBLIC void FUNCNAME(char *outfilename, bool_pt argsepid, bool_pt argbits32,
					 bool_pt argstripflag, bool_pt arguzp)
bool_pt argsepid;
bool_pt argbits32;
bool_pt argstripflag;
bool_pt arguzp;
{
    char buf4[4];
#ifdef EDOS


#endif /* EDOS */

PRIVATE void linkmod(struct modstruct *modptr)
struct modstruct *modptr;
{
    char buf[ABS_TEXT_MAX];
    int command;

    }
}

PRIVATE void padmod(struct modstruct *modptr)
struct modstruct *modptr;
{
    bin_off_t count;
    fastin_t seg;

    }
}

PRIVATE void setsym(char *name, bin_off_t value)
char *name;
bin_off_t value;
{
    struct symstruct *symptr;


	    symptr->value = value;
}

PRIVATE void symres(register char *name)
register char *name;
{
    register struct symstruct *symptr;



/* set new segment */

PRIVATE void setseg(fastin_pt newseg)
fastin_pt newseg;
{
    if (newseg != curseg)
    {

    }
}

PRIVATE void skip(unsigned countsize)
unsigned countsize;
{
    writenulls((bin_off_t) readsize(countsize));
}

#ifdef EDOS

PRIVATE void writeheader(char *commandname)
char *commandname;
{
    char buf[MAX_OFFSET_SIZE];
    bin_off_t offset;


#endif /* MINIX */

PRIVATE void writenulls(bin_off_t count)
bin_off_t count;
{
    long lcount = count;
    if( lcount < 0 )

#define FUNCNAME writebin
#endif

PUBLIC void FUNCNAME(char *outfilename, bool_pt argsepid, bool_pt argbits32,
					 bool_pt argstripflag, bool_pt arguzp)
bool_pt argsepid;
bool_pt argbits32;
bool_pt argstripflag;
bool_pt arguzp;
{
    char * s  = "WARNING: Native a.out generation not included, sorry\n";
    write(2, s, strlen(s));





/* write binary file */

PUBLIC void write_elks(char *outfilename, bool_pt argsepid, bool_pt argbits32,
					   bool_pt argstripflag, bool_pt arguzp, bool_pt argxsym)
bool_pt argsepid;
bool_pt argbits32;
bool_pt argstripflag;
bool_pt arguzp;
bool_pt argxsym;
{
    char buf4[4];
    char *cptr;

    executable();
}

PRIVATE void linkmod(struct modstruct *modptr)
struct modstruct *modptr;
{
    char buf[ABS_TEXT_MAX];
    int command;

    }
}

PRIVATE void padmod(struct modstruct *modptr)
struct modstruct *modptr;
{
    bin_off_t count;
    fastin_t seg;

    }
}

PRIVATE void setsym(char *name, bin_off_t value)
char *name;
bin_off_t value;
{
    struct symstruct *symptr;


	symptr->value = value;
}

PRIVATE void symres(register char *name)
register char *name;
{
    register struct symstruct *symptr;



/* set new segment */

PRIVATE void setseg(fastin_pt newseg)
fastin_pt newseg;
{
    if (newseg != curseg)
    {

    }
}

PRIVATE void skip(unsigned countsize)
unsigned countsize;
{
    writenulls((bin_off_t) readsize(countsize));
}

}
#endif

PRIVATE void writenulls(bin_off_t count)
bin_off_t count;
{
    long lcount = count;
    spos += count;

Lines 31-39 Link Here

(-)a/unproto/hash.c (-3 / +1 lines)
31		31
32	/* hash - hash a string; original author: P. J. Weinberger at Bell Labs. */	32	/* hash - hash a string; original author: P. J. Weinberger at Bell Labs. */
33		33
34	int hash(s, size)	34	int hash(register char *s, unsigned size)
35	register char *s;
36	unsigned size;
37	{	35	{
38	register unsigned long h = 0;	36	register unsigned long h = 0;
39	register unsigned long g;	37	register unsigned long g;





static char strsave_sccsid[] = "@(#) strsave.c 1.1 92/01/15 21:53:13";

/* C library */

extern char *strcpy();
extern char *malloc();

/* Application-specific stuff */

#include "error.h"

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

extern int hash(register char *s, unsigned size);

#define	STR_TABSIZE	100

struct string {

Lines 51-58 Link Here

(-)a/unproto/symbol.c (+4 lines)
51	#include "token.h"	51	#include "token.h"
52	#include "symbol.h"	52	#include "symbol.h"
53		53
		54	#include <string.h>
		55
54	#define SYM_TABSIZE 20	56	#define SYM_TABSIZE 20
55		57
		58	extern int hash(register char *s, unsigned size);
		59
56	static struct symbol *sym_tab[SYM_TABSIZE] = {0,};	60	static struct symbol *sym_tab[SYM_TABSIZE] = {0,};
57		61
58	/* More string stuff. Maybe it should go to an #include file. */	62	/* More string stuff. Maybe it should go to an #include file. */

Lines 49-54 Link Here

(-)a/unproto/tok_class.c (+1 lines)
49	/* C library */	49	/* C library */
50		50
51	#include <stdio.h>	51	#include <stdio.h>
		52	#include <string.h>
52		53
53	extern char *strcpy();	54	extern char *strcpy();
54	extern long time();	55	extern long time();

Lines 79-91 Link Here

(-)a/unproto/tok_io.c (-5 / +2 lines)
79	/* C library */	79	/* C library */
80		80
81	#include <stdio.h>	81	#include <stdio.h>
		82	#include <stdlib.h>
		83	#include <string.h>
82	#include <ctype.h>	84	#include <ctype.h>
83		85
84	extern char *strchr();
85	extern char *malloc();
86	extern char *realloc();
87	extern char *strcpy();
88
89	/* Application-specific stuff */	86	/* Application-specific stuff */
90		87
91	#include "token.h"	88	#include "token.h"

Lines 137-142 Link Here

(-)a/unproto/unproto.c (+1 lines)
137	#include <sys/types.h>	137	#include <sys/types.h>
138	#include <sys/stat.h>	138	#include <sys/stat.h>
139	#include <stdio.h>	139	#include <stdio.h>
		140	#include <string.h>
140	#include <errno.h>	141	#include <errno.h>
141		142
142	extern void exit();	143	extern void exit();

Return to bug 891533

Lines 192-199 Link Here

(-)a/as/genbin.c (-5 / +2 lines)
192		192
193	/* write char to binary file or directly to memory */	193	/* write char to binary file or directly to memory */
194		194
195	PUBLIC void putbin(ch)	195	PUBLIC void putbin(opcode_pt ch)
196	opcode_pt ch;
197	{	196	{
198	if (binfil != 0x0)	197	if (binfil != 0x0)
199	{	198	{
Lines 253-261 Link Here
253		252
254	/* write sized offset to binary file or directly to memory */	253	/* write sized offset to binary file or directly to memory */
255		254
256	PRIVATE void putbinoffset(offset, size)	255	PRIVATE void putbinoffset(offset_t offset, count_t size)
257	offset_t offset;
258	count_t size;
259	{	256	{
260	char buf[sizeof offset];	257	char buf[sizeof offset];
261		258

Lines 84-92 Link Here

(-)a/as/genlist.c (-28 / +12 lines)
84		84
85	/* format 1 byte number as 2 hex digits, return ptr to end */	85	/* format 1 byte number as 2 hex digits, return ptr to end */
86		86
87	PRIVATE char *build_1hex_number(num, where)	87	PRIVATE char build_1hex_number(opcode_pt num, register char where)
88	opcode_pt num;
89	register char *where;
90	{	88	{
91	where[0] = hexdigit[((unsigned) num % 256) / 16];	89	where[0] = hexdigit[((unsigned) num % 256) / 16];
92	where[1] = hexdigit[(unsigned) num % 16];	90	where[1] = hexdigit[(unsigned) num % 16];
Lines 95-103 Link Here
95		93
96	/* format 2 byte number as 4 hex digits, return ptr to end */	94	/* format 2 byte number as 4 hex digits, return ptr to end */
97		95
98	PUBLIC char *build_2hex_number(num, where)	96	PUBLIC char build_2hex_number(unsigned num, char where)
99	unsigned num;
100	char *where;
101	{	97	{
102	return build_1hex_number((opcode_pt) num,	98	return build_1hex_number((opcode_pt) num,
103	build_1hex_number((opcode_pt) (num / 256), where));	99	build_1hex_number((opcode_pt) (num / 256), where));
Lines 106-115 Link Here
106	/* format 2 byte number as decimal with given width (pad with leading '0's) */	102	/* format 2 byte number as decimal with given width (pad with leading '0's) */
107	/* return ptr to end */	103	/* return ptr to end */
108		104
109	PUBLIC char *build_number(num, width, where)	105	PUBLIC char build_number(unsigned num, unsigned width, register char where)
110	unsigned num;
111	unsigned width;
112	register char *where;
113	{	106	{
114	static unsigned powers_of_10[] = {1, 10, 100, 1000, 10000,};	107	static unsigned powers_of_10[] = {1, 10, 100, 1000, 10000,};
115	unsigned char digit;	108	unsigned char digit;
Lines 131-138 Link Here
131		124
132	/* record number and position of error (or error buffer overflow) */	125	/* record number and position of error (or error buffer overflow) */
133		126
134	PUBLIC void warning(err_str)	127	PUBLIC void warning(char * err_str)
135	char * err_str;
136	{	128	{
137	if (!as_warn.current) return;	129	if (!as_warn.current) return;
138	++totwarn;	130	++totwarn;
Lines 140-147 Link Here
140	error(err_str);	132	error(err_str);
141	}	133	}
142		134
143	PUBLIC void error(err_str)	135	PUBLIC void error(char * err_str)
144	char * err_str;
145	{	136	{
146	register struct error_s *errptr;	137	register struct error_s *errptr;
147	register struct error_s *errptrlow;	138	register struct error_s *errptrlow;
Lines 189-196 Link Here
189		180
190	/* list 1 line unconditionally */	181	/* list 1 line unconditionally */
191		182
192	PRIVATE void list1(fd)	183	PRIVATE void list1(fd_t fd)
193	fd_t fd;
194	{	184	{
195	outfd = fd;	185	outfd = fd;
196	listcode();	186	listcode();
Lines 413-420 Link Here
413		403
414	/* pad out error line to begin under 1st char of source listing */	404	/* pad out error line to begin under 1st char of source listing */
415		405
416	PRIVATE void paderrorline(nspaces)	406	PRIVATE void paderrorline(unsigned nspaces)
417	unsigned nspaces;
418	{	407	{
419	int nstars = LINUM_LEN;	408	int nstars = LINUM_LEN;
420		409
Lines 426-433 Link Here
426		415
427	/* write 1 character */	416	/* write 1 character */
428		417
429	PUBLIC void writec(ch)	418	PUBLIC void writec(char ch)
430	char ch;
431	{	419	{
432	write(outfd, &ch, 1);	420	write(outfd, &ch, 1);
433	}	421	}
Lines 441-448 Link Here
441		429
442	/* write 1 offset_t, order to suit target */	430	/* write 1 offset_t, order to suit target */
443		431
444	PUBLIC void writeoff(offset)	432	PUBLIC void writeoff(offset_t offset)
445	offset_t offset;
446	{	433	{
447	char buf[sizeof offset];	434	char buf[sizeof offset];
448		435
Lines 456-471 Link Here
456		443
457	/* write string */	444	/* write string */
458		445
459	PUBLIC void writes(s)	446	PUBLIC void writes(char *s)
460	char *s;
461	{	447	{
462	write(outfd, s, strlen(s));	448	write(outfd, s, strlen(s));
463	}	449	}
464		450
465	/* write string followed by newline */	451	/* write string followed by newline */
466		452
467	PUBLIC void writesn(s)	453	PUBLIC void writesn(char *s)
468	char *s;
469	{	454	{
470	writes(s);	455	writes(s);
471	writenl();	456	writenl();
Lines 473-480 Link Here
473		458
474	/* write 1 word, order to suit target */	459	/* write 1 word, order to suit target */
475		460
476	PUBLIC void writew(word)	461	PUBLIC void writew(unsigned word)
477	unsigned word;
478	{	462	{
479	char buf[2];	463	char buf[2];
480		464

Lines 28-34 Link Here

(-)a/as/genobj.c (-22 / +10 lines)
28		28
29	FORWARD void flushabs P((void));	29	FORWARD void flushabs P((void));
30	FORWARD void flushrmb P((void));	30	FORWARD void flushrmb P((void));
31	FORWARD void genobjadr P((struct address_s *adrptr, int size));	31	FORWARD void genobjadr P((struct address_s *adrptr, smallcount_t size));
32	FORWARD void putobj1 P((opcode_pt ch));	32	FORWARD void putobj1 P((opcode_pt ch));
33	FORWARD void putobj4 P((u32_T offset));	33	FORWARD void putobj4 P((u32_T offset));
34	FORWARD void putobjoffset P((offset_t offset, count_t size));	34	FORWARD void putobjoffset P((offset_t offset, count_t size));
Lines 37-44 Link Here
37		37
38	/* accumulate RMB requests into 1 (so + and - requests cancel) */	38	/* accumulate RMB requests into 1 (so + and - requests cancel) */
39		39
40	PUBLIC void accumulate_rmb(offset)	40	PUBLIC void accumulate_rmb(offset_t offset)
41	offset_t offset;
42	{	41	{
43	if (objectc)	42	if (objectc)
44	{	43	{
Lines 212-220 Link Here
212		211
213	/* generate object code for current address */	212	/* generate object code for current address */
214		213
215	PRIVATE void genobjadr(adrptr, size)	214	PRIVATE void genobjadr(struct address_s *adrptr, smallcount_t size)
216	struct address_s *adrptr;
217	smallcount_t size;
218	{	215	{
219	unsigned char byte;	216	unsigned char byte;
220	unsigned symnum;	217	unsigned symnum;
Lines 590-597 Link Here
590		587
591	/* write char to absolute object code buffer, flush if necessary */	588	/* write char to absolute object code buffer, flush if necessary */
592		589
593	PUBLIC void putabs(ch)	590	PUBLIC void putabs(opcode_pt ch)
594	opcode_pt ch;
595	{	591	{
596	if (objectc)	592	if (objectc)
597	{	593	{
Lines 605-612 Link Here
605		601
606	/* write char to object code buffer, flush if necessary */	602	/* write char to object code buffer, flush if necessary */
607		603
608	PUBLIC void putobj(ch)	604	PUBLIC void putobj(opcode_pt ch)
609	opcode_pt ch;
610	{	605	{
611	if (objectc)	606	if (objectc)
612	{	607	{
Lines 618-625 Link Here
618		613
619	/* write char to object code buffer assuming nothing in absolute & rmb bufs */	614	/* write char to object code buffer assuming nothing in absolute & rmb bufs */
620		615
621	PRIVATE void putobj1(ch)	616	PRIVATE void putobj1(opcode_pt ch)
622	opcode_pt ch;
623	{	617	{
624	if (objbufptr >= objbufend)	618	if (objbufptr >= objbufend)
625	flushobj();	619	flushobj();
Lines 628-635 Link Here
628		622
629	/* write 32 bit offset to object code buffer assuming ... */	623	/* write 32 bit offset to object code buffer assuming ... */
630		624
631	PRIVATE void putobj4(offset)	625	PRIVATE void putobj4(u32_T offset)
632	u32_T offset;
633	{	626	{
634	char buf[sizeof offset];	627	char buf[sizeof offset];
635		628
Lines 639-647 Link Here
639		632
640	/* write sized offset to object code buffer assuming ... */	633	/* write sized offset to object code buffer assuming ... */
641		634
642	PRIVATE void putobjoffset(offset, size)	635	PRIVATE void putobjoffset(offset_t offset, count_t size)
643	offset_t offset;
644	count_t size;
645	{	636	{
646	char buf[sizeof offset];	637	char buf[sizeof offset];
647		638
Lines 662-669 Link Here
662		653
663	/* write word to object code buffer assuming ... */	654	/* write word to object code buffer assuming ... */
664		655
665	PRIVATE void putobjword(word)	656	PRIVATE void putobjword(unsigned word)
666	unsigned word;
667	{	657	{
668	char buf[sizeof word];	658	char buf[sizeof word];
669		659
Lines 674-682 Link Here
674		664
675	/* write several bytes to object code buffer assuming ... */	665	/* write several bytes to object code buffer assuming ... */
676		666
677	PRIVATE void writeobj(buf, count)	667	PRIVATE void writeobj(char *buf, unsigned count)
678	char *buf;
679	unsigned count;
680	{	668	{
681	do	669	do
682	putobj1(*buf++);	670	putobj1(*buf++);

Lines 17-33 Link Here

(-)a/as/pops.c (-24 / +12 lines)
17	FORWARD void constdata P((unsigned size));	17	FORWARD void constdata P((unsigned size));
18	FORWARD void docomm P((void));	18	FORWARD void docomm P((void));
19	FORWARD void doelseif P((pfv func));	19	FORWARD void doelseif P((pfv func));
20	FORWARD void doequset P((int labits));	20	FORWARD void doequset P((unsigned char labits));
21	FORWARD void doentexp P((int entbits, int impbits));	21	FORWARD void doentexp P((unsigned char entbits, unsigned char impbits));
22	FORWARD void dofcc P((void));	22	FORWARD void dofcc P((void));
23	FORWARD void doif P((pfv func));	23	FORWARD void doif P((pfv func));
24	FORWARD struct sym_s *needlabel P((void));	24	FORWARD struct sym_s *needlabel P((void));
25	FORWARD void showredefinedlabel P((void));	25	FORWARD void showredefinedlabel P((void));
26	FORWARD void setloc P((unsigned seg));	26	FORWARD void setloc P((unsigned seg));
27		27
28	PRIVATE void bumpsem(flagptr, defval)	28	PRIVATE void bumpsem(register struct flags_s *flagptr, int defval)
29	register struct flags_s *flagptr;
30	int defval;
31	{	29	{
32	int newcount;	30	int newcount;
33		31
Lines 70-77 Link Here
70	/* check symbol is either undefined */	68	/* check symbol is either undefined */
71	/* or has the same segment & relocatability as lc */	69	/* or has the same segment & relocatability as lc */
72		70
73	PUBLIC bool_pt checksegrel(symptr)	71	PUBLIC bool_pt checksegrel(register struct sym_s *symptr)
74	register struct sym_s *symptr;
75	{	72	{
76	if ((symptr->type & LABIT \|\|	73	if ((symptr->type & LABIT \|\|
77	(symptr->data & IMPBIT && !(symptr->data & UNDBIT))) &&	74	(symptr->data & IMPBIT && !(symptr->data & UNDBIT))) &&
Lines 94-101 Link Here
94		91
95	/* allocate constant data (zero except for size 1), default zero for size 1 */	92	/* allocate constant data (zero except for size 1), default zero for size 1 */
96		93
97	PRIVATE void constdata(size)	94	PRIVATE void constdata(unsigned size)
98	unsigned size;
99	{	95	{
100	offset_t remaining;	96	offset_t remaining;
101		97
Lines 157-164 Link Here
157		153
158	/* common routine for ELSEIF/ELSEIFC */	154	/* common routine for ELSEIF/ELSEIFC */
159		155
160	PRIVATE void doelseif(func)	156	PRIVATE void doelseif(pfv func)
161	pfv func;
162	{	157	{
163	if (iflevel == 0)	158	if (iflevel == 0)
164	error(ELSEIFBAD);	159	error(ELSEIFBAD);
Lines 186-193 Link Here
186		181
187	/* common routine for EQU/SET */	182	/* common routine for EQU/SET */
188		183
189	PRIVATE void doequset(labits)	184	PRIVATE void doequset(unsigned char labits)
190	unsigned char labits;
191	{	185	{
192	register struct sym_s *labptr;	186	register struct sym_s *labptr;
193	unsigned char olddata;	187	unsigned char olddata;
Lines 230-238 Link Here
230		224
231	/* common routine for ENTRY/EXPORT */	225	/* common routine for ENTRY/EXPORT */
232		226
233	PRIVATE void doentexp(entbits, impbits)	227	PRIVATE void doentexp(unsigned char entbits, unsigned char impbits)
234	unsigned char entbits;
235	unsigned char impbits;
236	{	228	{
237	struct sym_s *symptr;	229	struct sym_s *symptr;
238		230
Lines 389-396 Link Here
389		381
390	/* common routine for IF/IFC */	382	/* common routine for IF/IFC */
391		383
392	PRIVATE void doif(func)	384	PRIVATE void doif(pfv func)
393	pfv func;
394	{	385	{
395	if (iflevel >= MAXIF)	386	if (iflevel >= MAXIF)
396	error(IFOV);	387	error(IFOV);
Lines 420-427 Link Here
420	}	411	}
421	}	412	}
422		413
423	PUBLIC void fatalerror(err_str)	414	PUBLIC void fatalerror(char * err_str)
424	char * err_str;
425	{	415	{
426	error(err_str);	416	error(err_str);
427	skipline();	417	skipline();
Lines 432-439 Link Here
432	/* swap position with label position, do error, put back posn */	422	/* swap position with label position, do error, put back posn */
433	/* also clear label ptr */	423	/* also clear label ptr */
434		424
435	PUBLIC void labelerror(err_str)	425	PUBLIC void labelerror(char * err_str)
436	char * err_str;
437	{	426	{
438	struct sym_s *oldgsymptr;	427	struct sym_s *oldgsymptr;
439	char *oldlineptr;	428	char *oldlineptr;
Lines 1095-1102 Link Here
1095		1084
1096	/* set location segment */	1085	/* set location segment */
1097		1086
1098	PRIVATE void setloc(seg)	1087	PRIVATE void setloc(unsigned seg)
1099	unsigned seg;
1100	{	1088	{
1101	if (pass == last_pass && seg != (lcdata & SEGM))	1089	if (pass == last_pass && seg != (lcdata & SEGM))
1102	putobj((opcode_pt) (seg \| OBJ_SET_SEG));	1090	putobj((opcode_pt) (seg \| OBJ_SET_SEG));

Lines 87-94 Link Here

(-)a/as/readsrc.c (-11 / +4 lines)
87	clearsource(); /* sentinel to invoke blank skipping */	87	clearsource(); /* sentinel to invoke blank skipping */
88	}	88	}
89		89
90	PUBLIC fd_t open_input(name)	90	PUBLIC fd_t open_input(char *name)
91	char *name;
92	{	91	{
93	fd_t fd;	92	fd_t fd;
94	#if BIGBUFFER == 1	93	#if BIGBUFFER == 1
Lines 455-464 Link Here
455	PRIVATE long ftpos = 0;	454	PRIVATE long ftpos = 0;
456	PRIVATE int lastfd = -1;	455	PRIVATE int lastfd = -1;
457		456
458	PRIVATE int inp_line(fd, buf, size)	457	PRIVATE int inp_line(int fd, char * buf, int size)
459	int fd;
460	char * buf;
461	int size;
462	{	458	{
463	int offt = 0;	459	int offt = 0;
464	if( fd!=lastfd ) inp_seek(-1, 0L);	460	if( fd!=lastfd ) inp_seek(-1, 0L);
Lines 479-486 Link Here
479	return offt;	475	return offt;
480	}	476	}
481		477
482	PRIVATE long inp_tell(fd)	478	PRIVATE long inp_tell(int fd)
483	int fd;
484	{	479	{
485	if( fd != lastfd )	480	if( fd != lastfd )
486	return lseek(fd, 0L, 1);	481	return lseek(fd, 0L, 1);
Lines 488-496 Link Here
488	return ftpos + in_start;	483	return ftpos + in_start;
489	}	484	}
490		485
491	PRIVATE void inp_seek(fd, posn)	486	PRIVATE void inp_seek(int fd, long posn)
492	int fd;
493	long posn;
494	{	487	{
495	if( lastfd != -1 )	488	if( lastfd != -1 )
496	lseek(lastfd, ftpos+in_start, 0);	489	lseek(lastfd, ftpos+in_start, 0);

Lines 295-305 Link Here

(-)a/ar/ar.c (-118 / +46 lines)
295	FILE is the name of the file (for error messages). */	295	FILE is the name of the file (for error messages). */
296		296
297	void	297	void
298	mywrite (desc, pbuf, bytes, file)	298	mywrite (int desc, void pbuf, int bytes, char file)
299	int desc;
300	void *pbuf;
301	int bytes;
302	char *file;
303	{	299	{
304	register int val;	300	register int val;
305	register char * buf = pbuf;	301	register char * buf = pbuf;
Lines 315-323 Link Here
315	}	311	}
316		312
317	int	313	int
318	main (argc, argv)	314	main (int argc, char **argv)
319	int argc;
320	char **argv;
321	{	315	{
322	int i;	316	int i;
323		317
Lines 513-525 Link Here
513	}	507	}
514		508
515	void	509	void
516	scan (function, crflag)	510	scan (
517	#ifdef __STDC__	511	#ifdef __STDC__
518	void (function) (struct member_desc member, FILE istream);	512	void (function) (struct member_desc member, FILE istream),
519	#else	513	#else
520	void (*function) ();	514	void (*function) (),
521	#endif	515	#endif
522	int crflag;	516	int crflag)
523	{	517	{
524	FILE *arcstream = fopen (archive, "r");	518	FILE *arcstream = fopen (archive, "r");
525		519
Lines 601-609 Link Here
601	}	595	}
602		596
603	void	597	void
604	print_descr (member, instream)	598	print_descr (struct member_desc member, FILE * instream)
605	struct member_desc member;
606	FILE * instream;
607	{	599	{
608	char *timestring;	600	char *timestring;
609	if (!verbose)	601	if (!verbose)
Lines 620-627 Link Here
620	}	612	}
621		613
622	void	614	void
623	print_modes (modes)	615	print_modes (int modes)
624	int modes;
625	{	616	{
626	putchar (modes & 0400 ? 'r' : '-');	617	putchar (modes & 0400 ? 'r' : '-');
627	putchar (modes & 0200 ? 'w' : '-');	618	putchar (modes & 0200 ? 'w' : '-');
Lines 637-645 Link Here
637	#define BUFSIZE 1024	628	#define BUFSIZE 1024
638		629
639	void	630	void
640	extract_member (member, istream)	631	extract_member (struct member_desc member, FILE *istream)
641	struct member_desc member;
642	FILE *istream;
643	{	632	{
644	int ncopied = 0;	633	int ncopied = 0;
645	FILE *ostream;	634	FILE *ostream;
Lines 695-703 Link Here
695	}	684	}
696		685
697	void	686	void
698	print_contents (member, istream)	687	print_contents (struct member_desc member, FILE *istream)
699	struct member_desc member;
700	FILE *istream;
701	{	688	{
702	int ncopied = 0;	689	int ncopied = 0;
703		690
Lines 729-736 Link Here
729	create a new archive. */	716	create a new archive. */
730		717
731	struct mapelt *	718	struct mapelt *
732	make_map (nonexistent_ok)	719	make_map (int nonexistent_ok)
733	int nonexistent_ok;
734	{	720	{
735	struct mapelt mapstart;	721	struct mapelt mapstart;
736	mapstart.next = 0;	722	mapstart.next = 0;
Lines 740-748 Link Here
740	}	726	}
741		727
742	void	728	void
743	add_to_map (member, istream)	729	add_to_map (struct member_desc member, FILE * istream)
744	struct member_desc member;
745	FILE * istream;
746	{	730	{
747	struct mapelt mapelt = (struct mapelt ) xmalloc (sizeof (struct mapelt));	731	struct mapelt mapelt = (struct mapelt ) xmalloc (sizeof (struct mapelt));
748	mapelt->info = member;	732	mapelt->info = member;
Lines 755-762 Link Here
755	/* Return the last element of the specified map. */	739	/* Return the last element of the specified map. */
756		740
757	struct mapelt *	741	struct mapelt *
758	last_mapelt (map)	742	last_mapelt (struct mapelt *map)
759	struct mapelt *map;
760	{	743	{
761	struct mapelt *tail = map;	744	struct mapelt *tail = map;
762	while (tail->next) tail = tail->next;	745	while (tail->next) tail = tail->next;
Lines 766-773 Link Here
766	/* Return the element of the specified map which precedes elt. */	749	/* Return the element of the specified map which precedes elt. */
767		750
768	struct mapelt *	751	struct mapelt *
769	prev_mapelt (map, elt)	752	prev_mapelt (struct mapelt map, struct mapelt elt)
770	struct mapelt map, elt;
771	{	753	{
772	struct mapelt *tail = map;	754	struct mapelt *tail = map;
773	while (tail->next && tail->next != elt)	755	while (tail->next && tail->next != elt)
Lines 779-787 Link Here
779	/* Return the element of the specified map which has the specified name. */	761	/* Return the element of the specified map which has the specified name. */
780		762
781	struct mapelt *	763	struct mapelt *
782	find_mapelt_noerror (map, name)	764	find_mapelt_noerror (struct mapelt map, register char name)
783	struct mapelt *map;
784	register char *name;
785	{	765	{
786	register struct mapelt *tail;	766	register struct mapelt *tail;
787	unsigned int len;	767	unsigned int len;
Lines 816-824 Link Here
816	}	796	}
817		797
818	struct mapelt *	798	struct mapelt *
819	find_mapelt (map, name)	799	find_mapelt (struct mapelt map, char name)
820	struct mapelt *map;
821	char *name;
822	{	800	{
823	register struct mapelt *found = find_mapelt_noerror (map, name);	801	register struct mapelt *found = find_mapelt_noerror (map, name);
824	if (found == 0)	802	if (found == 0)
Lines 934-942 Link Here
934	*/	912	*/
935		913
936	void	914	void
937	write_archive (map, appendflag)	915	write_archive (struct mapelt *map, int appendflag)
938	struct mapelt *map;
939	int appendflag;
940	{	916	{
941	char *tempname = make_tempname (archive);	917	char *tempname = make_tempname (archive);
942	int indesc = lock_indesc;	918	int indesc = lock_indesc;
Lines 1059-1067 Link Here
1059	}	1035	}
1060		1036
1061	void	1037	void
1062	header_from_map (header, mapelt)	1038	header_from_map (struct ar_hdr header, struct mapelt mapelt)
1063	struct ar_hdr *header;
1064	struct mapelt *mapelt;
1065	{	1039	{
1066	unsigned int namelen;	1040	unsigned int namelen;
1067	char *p;	1041	char *p;
Lines 1116-1123 Link Here
1116	/* gets just the file part of name */	1090	/* gets just the file part of name */
1117		1091
1118	char *	1092	char *
1119	basename (path)	1093	basename (char *path)
1120	char *path;
1121	{	1094	{
1122	char save, start;	1095	char save, start;
1123	for (start = save = path; *path; path++)	1096	for (start = save = path; *path; path++)
Lines 1132-1142 Link Here
1132		1105
1133	/* writes to file open on OUTDESC with name OUTNAME. */	1106	/* writes to file open on OUTDESC with name OUTNAME. */
1134	void	1107	void
1135	copy_out_member (mapelt, archive_indesc, outdesc, outname)	1108	copy_out_member (struct mapelt mapelt, int archive_indesc, int outdesc, char outname)
1136	struct mapelt *mapelt;
1137	int archive_indesc;
1138	int outdesc;
1139	char *outname;
1140	{	1109	{
1141	struct ar_hdr header;	1110	struct ar_hdr header;
1142	int indesc;	1111	int indesc;
Lines 1192-1200 Link Here
1192	It is open on OUTDESC and its name is OUTNAME. */	1161	It is open on OUTDESC and its name is OUTNAME. */
1193		1162
1194	void	1163	void
1195	touch_symdef_member (outdesc, outname)	1164	touch_symdef_member (int outdesc, char *outname)
1196	int outdesc;
1197	char *outname;
1198	{	1165	{
1199	struct stat statbuf;	1166	struct stat statbuf;
1200	int i;	1167	int i;
Lines 1215-1222 Link Here
1215	}	1182	}
1216		1183
1217	char *	1184	char *
1218	make_tempname (name)	1185	make_tempname (char *name)
1219	char *name;
1220	{	1186	{
1221	#if defined(USG) \|\| defined(SHORT_FILENAME)	1187	#if defined(USG) \|\| defined(SHORT_FILENAME)
1222	/* sigh. 14 character filenames are wonderful, just wonderful. */	1188	/* sigh. 14 character filenames are wonderful, just wonderful. */
Lines 1264-1272 Link Here
1264	}	1230	}
1265		1231
1266	void	1232	void
1267	delete_from_map (name, map)	1233	delete_from_map (char name, struct mapelt map)
1268	char *name;
1269	struct mapelt *map;
1270	{	1234	{
1271	struct mapelt *this = find_mapelt (map, name);	1235	struct mapelt *this = find_mapelt (map, name);
1272		1236
Lines 1321-1329 Link Here
1321	}	1285	}
1322		1286
1323	int	1287	int
1324	move_in_map (name, map, after)	1288	move_in_map (char name, struct mapelt map, struct mapelt *after)
1325	char *name;
1326	struct mapelt map, after;
1327	{	1289	{
1328	struct mapelt *this = find_mapelt (map, name);	1290	struct mapelt *this = find_mapelt (map, name);
1329	struct mapelt *prev;	1291	struct mapelt *prev;
Lines 1430-1438 Link Here
1430	exist or (optionally) is older. */	1392	exist or (optionally) is older. */
1431		1393
1432	int	1394	int
1433	insert_in_map (name, map, after)	1395	insert_in_map (char name, struct mapelt map, struct mapelt *after)
1434	char *name;
1435	struct mapelt map, after;
1436	{	1396	{
1437	struct mapelt *old = find_mapelt_noerror (map, name);	1397	struct mapelt *old = find_mapelt_noerror (map, name);
1438	struct mapelt *this;	1398	struct mapelt *this;
Lines 1474-1484 Link Here
1474	*/	1434	*/
1475		1435
1476	void	1436	void
1477	extract_members (function)	1437	extract_members (
1478	#ifdef __STDC__	1438	#ifdef __STDC__
1479	void (function) (struct member_desc member, FILE istream);	1439	void (function) (struct member_desc member, FILE istream))
1480	#else	1440	#else
1481	void (*function) ();	1441	void (*function) ())
1482	#endif	1442	#endif
1483	{	1443	{
1484	struct mapelt *map;	1444	struct mapelt *map;
Lines 1513-1523 Link Here
1513	are descriptor and name of file to write to. */	1473	are descriptor and name of file to write to. */
1514		1474
1515	void	1475	void
1516	write_symdef_member (mapelt, map, outdesc, outname)	1476	write_symdef_member (struct mapelt mapelt, struct mapelt map, int outdesc, char *outname)
1517	struct mapelt *mapelt;
1518	struct mapelt *map;
1519	int outdesc;
1520	char *outname;
1521	{	1477	{
1522	struct ar_hdr header;	1478	struct ar_hdr header;
1523	struct mapelt *mapptr;	1479	struct mapelt *mapptr;
Lines 1590-1598 Link Here
1590	}	1546	}
1591		1547
1592	void	1548	void
1593	read_old_symdefs (map, archive_indesc)	1549	read_old_symdefs (struct mapelt *map, int archive_indesc)
1594	struct mapelt *map;
1595	int archive_indesc;
1596	{	1550	{
1597	struct mapelt *mapelt;	1551	struct mapelt *mapelt;
1598	char *data;	1552	char *data;
Lines 1636-1649 Link Here
1636	Return 0 for failure or 1 for success. */	1590	Return 0 for failure or 1 for success. */
1637		1591
1638	int	1592	int
1639	read_header_info (mapelt, desc, offset, syms_offset, syms_size, strs_offset, strs_size)	1593	read_header_info (struct mapelt mapelt, int desc, long int offset, long int syms_offset,
1640	struct mapelt *mapelt;	1594	unsigned int syms_size, long int strs_offset, unsigned int *strs_size)
1641	int desc;
1642	long int offset;
1643	long int *syms_offset;
1644	unsigned int *syms_size;
1645	long int *strs_offset;
1646	unsigned int *strs_size;
1647	{	1595	{
1648	struct exec hdr;	1596	struct exec hdr;
1649	int len;	1597	int len;
Lines 1683-1691 Link Here
1683	by reading the file it is coming from. */	1631	by reading the file it is coming from. */
1684		1632
1685	void	1633	void
1686	make_new_symdefs (mapelt, archive_indesc)	1634	make_new_symdefs (struct mapelt *mapelt, int archive_indesc)
1687	struct mapelt *mapelt;
1688	int archive_indesc;
1689	{	1635	{
1690	int indesc;	1636	int indesc;
1691	char *name = mapelt->info.name;	1637	char *name = mapelt->info.name;
Lines 1798-1806 Link Here
1798	Return the number of symbols left. */	1744	Return the number of symbols left. */
1799		1745
1800	int	1746	int
1801	filter_symbols (syms, symcount)	1747	filter_symbols (struct nlist *syms, unsigned int symcount)
1802	struct nlist *syms;
1803	unsigned int symcount;
1804	{	1748	{
1805	struct nlist from, to;	1749	struct nlist from, to;
1806	struct nlist *end = syms + symcount;	1750	struct nlist *end = syms + symcount;
Lines 1817-1825 Link Here
1817	/* Update the __.SYMDEF data before writing a new archive. */	1761	/* Update the __.SYMDEF data before writing a new archive. */
1818		1762
1819	void	1763	void
1820	update_symdefs (map, archive_indesc)	1764	update_symdefs (struct mapelt *map, int archive_indesc)
1821	struct mapelt *map;
1822	int archive_indesc;
1823	{	1765	{
1824	struct mapelt *tail;	1766	struct mapelt *tail;
1825	int pos;	1767	int pos;
Lines 1987-1995 Link Here
1987	/* Print error message and usage message, and exit. */	1929	/* Print error message and usage message, and exit. */
1988		1930
1989	void	1931	void
1990	usage (s1, val)	1932	usage (char *s1, int val)
1991	char *s1;
1992	int val;
1993	{	1933	{
1994	char vbuf[16];	1934	char vbuf[16];
1995	sprintf(vbuf, "%d", val);	1935	sprintf(vbuf, "%d", val);
Lines 2003-2010 Link Here
2003	/* Print error message and exit. */	1943	/* Print error message and exit. */
2004		1944
2005	void	1945	void
2006	fatal (s1, s2)	1946	fatal (char s1, char s2)
2007	char s1, s2;
2008	{	1947	{
2009	error (s1, s2);	1948	error (s1, s2);
2010	exit (1);	1949	exit (1);
Lines 2013-2020 Link Here
2013	/* Print error message. `s1' is printf control string, the rest are args. */	1952	/* Print error message. `s1' is printf control string, the rest are args. */
2014		1953
2015	void	1954	void
2016	error (s1, s2)	1955	error (char s1, char s2)
2017	char s1, s2;
2018	{	1956	{
2019	fprintf (stderr, "%s: ", program_name);	1957	fprintf (stderr, "%s: ", program_name);
2020	fprintf (stderr, s1, s2);	1958	fprintf (stderr, s1, s2);
Lines 2022-2029 Link Here
2022	}	1960	}
2023		1961
2024	void	1962	void
2025	error3 (s1, s2, s3)	1963	error3 (char s1, char s2, char *s3)
2026	char s1, s2, *s3;
2027	{	1964	{
2028	fprintf (stderr, "%s: ", program_name);	1965	fprintf (stderr, "%s: ", program_name);
2029	fprintf (stderr, s1, s2, s3);	1966	fprintf (stderr, s1, s2, s3);
Lines 2031-2039 Link Here
2031	}	1968	}
2032		1969
2033	void	1970	void
2034	error_with_file (string, mapelt)	1971	error_with_file (char string, struct mapelt mapelt)
2035	char *string;
2036	struct mapelt *mapelt;
2037	{	1972	{
2038	fprintf (stderr, "%s: ", program_name);	1973	fprintf (stderr, "%s: ", program_name);
2039	fprintf (stderr, "%s", string);	1974	fprintf (stderr, "%s", string);
Lines 2045-2059 Link Here
2045	}	1980	}
2046		1981
2047	void	1982	void
2048	perror_with_name (name)	1983	perror_with_name (char *name)
2049	char *name;
2050	{	1984	{
2051	error (concat ("", strerror(errno), " for %s"), name);	1985	error (concat ("", strerror(errno), " for %s"), name);
2052	}	1986	}
2053		1987
2054	void	1988	void
2055	pfatal_with_name (name)	1989	pfatal_with_name (char *name)
2056	char *name;
2057	{	1990	{
2058	fatal (concat ("", strerror(errno), " for %s"), name);	1991	fatal (concat ("", strerror(errno), " for %s"), name);
2059	}	1992	}
Lines 2062-2069 Link Here
2062	concatenate those of S1, S2, and S3. */	1995	concatenate those of S1, S2, and S3. */
2063		1996
2064	char *	1997	char *
2065	concat (s1, s2, s3)	1998	concat (const char s1, const char s2, const char *s3)
2066	const char s1, s2, *s3;
2067	{	1999	{
2068	int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);	2000	int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
2069	char result = (char ) xmalloc (len1 + len2 + len3 + 1);	2001	char result = (char ) xmalloc (len1 + len2 + len3 + 1);
Lines 2079-2086 Link Here
2079	/* Like malloc but get fatal error if memory is exhausted. */	2011	/* Like malloc but get fatal error if memory is exhausted. */
2080		2012
2081	char *	2013	char *
2082	xmalloc (size)	2014	xmalloc (unsigned int size)
2083	unsigned int size;
2084	{	2015	{
2085	#ifdef MALLOC_0_RETURNS_NULL	2016	#ifdef MALLOC_0_RETURNS_NULL
2086	char *result = malloc (size ? size : 1);	2017	char *result = malloc (size ? size : 1);
Lines 2093-2101 Link Here
2093	}	2024	}
2094		2025
2095	char *	2026	char *
2096	xrealloc (ptr, size)	2027	xrealloc (char *ptr, unsigned int size)
2097	char *ptr;
2098	unsigned int size;
2099	{	2028	{
2100	char *result = realloc (ptr, size);	2029	char *result = realloc (ptr, size);
2101	if (result == 0)	2030	if (result == 0)
Lines 2106-2113 Link Here
2106		2035
2107	#ifndef HAVE_RENAME	2036	#ifndef HAVE_RENAME
2108	int	2037	int
2109	rename (from, to)	2038	rename (char from, char to)
2110	char from, to;
2111	{	2039	{
2112	(void)unlink (to);	2040	(void)unlink (to);
2113	if (link (from, to) < 0	2041	if (link (from, to) < 0

Lines 53-60 Link Here

(-)a/as/alloc.c (-5 / +2 lines)
53	}	53	}
54		54
55	void *	55	void *
56	asalloc(size)	56	asalloc(unsigned int size)
57	unsigned int size;
58	{	57	{
59	void * rv;	58	void * rv;
60	#ifdef USE_FIXED_HEAP	59	#ifdef USE_FIXED_HEAP
Lines 75-83 Link Here
75		74
76		75
77	void *	76	void *
78	asrealloc(oldptr, size)	77	asrealloc(void * oldptr, unsigned int size)
79	void * oldptr;
80	unsigned int size;
81	{	78	{
82	void * rv;	79	void * rv;
83	#ifdef USE_FIXED_HEAP	80	#ifdef USE_FIXED_HEAP

Lines 37-45 Link Here

(-)a/as/as.c (-15 / +6 lines)
37	FORWARD void summ_number P((unsigned num));	37	FORWARD void summ_number P((unsigned num));
38	FORWARD void usage P((void));	38	FORWARD void usage P((void));
39		39
40	PUBLIC int main(argc, argv)	40	PUBLIC int main(int argc, char **argv)
41	int argc;
42	char **argv;
43	{	41	{
44	init_heap();	42	init_heap();
45	initp1();	43	initp1();
Lines 62-69 Link Here
62	return 0;	60	return 0;
63	}	61	}
64		62
65	PUBLIC void as_abort(message)	63	PUBLIC void as_abort(char *message)
66	char *message;
67	{	64	{
68	write(STDOUT, "as: ", 4);	65	write(STDOUT, "as: ", 4);
69	write(STDOUT, message, strlen(message));	66	write(STDOUT, message, strlen(message));
Lines 138-146 Link Here
138	ptext();	135	ptext();
139	}	136	}
140		137
141	PRIVATE int my_creat(name, message)	138	PRIVATE int my_creat(char name, char message)
142	char *name;
143	char *message;
144	{	139	{
145	int fd;	140	int fd;
146		141
Lines 153-161 Link Here
153	return fd;	148	return fd;
154	}	149	}
155		150
156	PRIVATE void process_args(argc, argv)	151	PRIVATE void process_args(int argc, char **argv)
157	int argc;
158	char **argv;
159	{	152	{
160	char *arg;	153	char *arg;
161	bool_t isnextarg;	154	bool_t isnextarg;
Lines 315-322 Link Here
315	inidata = (~binaryg & inidata) \| (RELBIT \| UNDBIT);	308	inidata = (~binaryg & inidata) \| (RELBIT \| UNDBIT);
316	} /* IMPBIT from inidata unless binaryg */	309	} /* IMPBIT from inidata unless binaryg */
317		310
318	PRIVATE void summary(fd)	311	PRIVATE void summary(int fd)
319	int fd;
320	{	312	{
321	outfd = fd;	313	outfd = fd;
322	writenl();	314	writenl();
Lines 326-333 Link Here
326	writesn(" warnings");	318	writesn(" warnings");
327	}	319	}
328		320
329	PRIVATE void summ_number(num)	321	PRIVATE void summ_number(unsigned num)
330	unsigned num;
331	{	322	{
332	/* format number like line numbers */	323	/* format number like line numbers */
333	char buf[16];	324	char buf[16];

Lines 137-145 Link Here

(-)a/as/gensym.c (-7 / +2 lines)
137		137
138	/* print symbol nicely formatted for given column */	138	/* print symbol nicely formatted for given column */
139		139
140	PRIVATE int printsym(symptr, column)	140	PRIVATE int printsym(register struct sym_s *symptr, unsigned column)
141	register struct sym_s *symptr;
142	unsigned column;
143	{	141	{
144	unsigned char length;	142	unsigned char length;
145	register struct sym_listing_s *listptr;	143	register struct sym_listing_s *listptr;
Lines 187-196 Link Here
187		185
188	/* shell sort symbols */	186	/* shell sort symbols */
189		187
190	PRIVATE void sort(array, top, nameflag)	188	PRIVATE void sort(struct sym_s array, struct sym_s top, bool_pt nameflag)
191	struct sym_s **array;
192	struct sym_s **top;
193	bool_pt nameflag;
194	{	189	{
195	int gap;	190	int gap;
196	int i;	191	int i;

Lines 418-425 Link Here

(-)a/as/mops.c (-56 / +27 lines)
418	FORWARD void yesimmed P((struct ea_s *eap));	418	FORWARD void yesimmed P((struct ea_s *eap));
419	FORWARD void yes_samesize P((void));	419	FORWARD void yes_samesize P((void));
420		420
421	PRIVATE void Eb(eap)	421	PRIVATE void Eb(register struct ea_s *eap)
422	register struct ea_s *eap;
423	{	422	{
424	Ex(eap);	423	Ex(eap);
425	if (eap->size != 0x1)	424	if (eap->size != 0x1)
Lines 433-440 Link Here
433	}	432	}
434	}	433	}
435		434
436	PRIVATE void Ew(eap)	435	PRIVATE void Ew(register struct ea_s *eap)
437	register struct ea_s *eap;
438	{	436	{
439	Ex(eap);	437	Ex(eap);
440	if (eap->size != 0x2)	438	if (eap->size != 0x2)
Lines 448-500 Link Here
448	}	446	}
449	}	447	}
450		448
451	PRIVATE void Ev(eap)	449	PRIVATE void Ev(register struct ea_s *eap)
452	register struct ea_s *eap;
453	{	450	{
454	Ex(eap);	451	Ex(eap);
455	notbytesize(eap);	452	notbytesize(eap);
456	}	453	}
457		454
458	PRIVATE void Ex(eap)	455	PRIVATE void Ex(register struct ea_s *eap)
459	register struct ea_s *eap;
460	{	456	{
461	getea(eap);	457	getea(eap);
462	notimmed(eap);	458	notimmed(eap);
463	notsegorspecreg(eap);	459	notsegorspecreg(eap);
464	}	460	}
465		461
466	PRIVATE void Gd(eap)	462	PRIVATE void Gd(register struct ea_s *eap)
467	register struct ea_s *eap;
468	{	463	{
469	Gx(eap);	464	Gx(eap);
470	if (eap->size != 0x4)	465	if (eap->size != 0x4)
471	kgerror(ILL_SIZE);	466	kgerror(ILL_SIZE);
472	}	467	}
473		468
474	PRIVATE void Gw(eap)	469	PRIVATE void Gw(register struct ea_s *eap)
475	register struct ea_s *eap;
476	{	470	{
477	Gx(eap);	471	Gx(eap);
478	if (eap->size != 0x2)	472	if (eap->size != 0x2)
479	kgerror(ILL_SIZE);	473	kgerror(ILL_SIZE);
480	}	474	}
481		475
482	PRIVATE void Gv(eap)	476	PRIVATE void Gv(register struct ea_s *eap)
483	register struct ea_s *eap;
484	{	477	{
485	Gx(eap);	478	Gx(eap);
486	notbytesize(eap);	479	notbytesize(eap);
487	}	480	}
488		481
489	PRIVATE void Gx(eap)	482	PRIVATE void Gx(register struct ea_s *eap)
490	register struct ea_s *eap;
491	{	483	{
492	Ex(eap);	484	Ex(eap);
493	notindirect(eap);	485	notindirect(eap);
494	}	486	}
495		487
496	PRIVATE void buildea(eap)	488	PRIVATE void buildea(register struct ea_s *eap)
497	register struct ea_s *eap;
498	{	489	{
499	opsize_t asize;	490	opsize_t asize;
500		491
Lines 586-594 Link Here
586	opcode = ESCAPE_OPCODE_BASE \| ((opcode & 0x70) >> 0x4);	577	opcode = ESCAPE_OPCODE_BASE \| ((opcode & 0x70) >> 0x4);
587	}	578	}
588		579
589	PRIVATE void buildimm(eap, signflag)	580	PRIVATE void buildimm(register struct ea_s *eap, bool_pt signflag)
590	register struct ea_s *eap;
591	bool_pt signflag;
592	{	581	{
593	immadr = eap->displ;	582	immadr = eap->displ;
594	immcount = eap->size;	583	immcount = eap->size;
Lines 623-630 Link Here
623		612
624	/* Check size and build segword. */	613	/* Check size and build segword. */
625		614
626	PRIVATE void buildsegword(eap)	615	PRIVATE void buildsegword(register struct ea_s *eap)
627	register struct ea_s *eap;
628	{	616	{
629	if (eap->size == 0x0)	617	if (eap->size == 0x0)
630	#ifdef NODEFAULTSIZE	618	#ifdef NODEFAULTSIZE
Lines 642-649 Link Here
642	segword = regsegword[eap->base];	630	segword = regsegword[eap->base];
643	}	631	}
644		632
645	PRIVATE void buildunary(opc)	633	PRIVATE void buildunary(opcode_pt opc)
646	opcode_pt opc;
647	{	634	{
648	if (mcount != 0x0)	635	if (mcount != 0x0)
649	{	636	{
Lines 653-660 Link Here
653	}	640	}
654	}	641	}
655		642
656	PRIVATE opsize_pt displsize(eap)	643	PRIVATE opsize_pt displsize(register struct ea_s *eap)
657	register struct ea_s *eap;
658	{	644	{
659	opsize_t asize;	645	opsize_t asize;
660		646
Lines 708-715 Link Here
708	return fpreg;	694	return fpreg;
709	}	695	}
710		696
711	PRIVATE bool_pt getaccumreg(eap)	697	PRIVATE bool_pt getaccumreg(register struct ea_s * eap)
712	register struct ea_s *eap;
713	{	698	{
714	if ((eap->base = regchk()) != AXREG && eap->base != ALREG	699	if ((eap->base = regchk()) != AXREG && eap->base != ALREG
715	&& eap->base != EAXREG)	700	&& eap->base != EAXREG)
Lines 769-776 Link Here
769	buildsegword(&source);	754	buildsegword(&source);
770	}	755	}
771		756
772	PRIVATE bool_pt getdxreg(eap)	757	PRIVATE bool_pt getdxreg(register struct ea_s *eap)
773	register struct ea_s *eap;
774	{	758	{
775	if ((eap->base = regchk()) != DXREG)	759	if ((eap->base = regchk()) != DXREG)
776	return FALSE;	760	return FALSE;
Lines 809-816 Link Here
809	optional-imediate-prefix displ(scaled index) -- anachronism	793	optional-imediate-prefix displ(scaled index) -- anachronism
810	*/	794	*/
811		795
812	PRIVATE void getea(eap)	796	PRIVATE void getea(register struct ea_s *eap)
813	register struct ea_s *eap;
814	{	797	{
815	bool_t leading_displ;	798	bool_t leading_displ;
816	bool_t leading_immed;	799	bool_t leading_immed;
Lines 967-975 Link Here
967	needcpu(eap->size==4?3:0);	950	needcpu(eap->size==4?3:0);
968	}	951	}
969		952
970	PRIVATE void getimmed(eap, immed_count)	953	PRIVATE void getimmed(struct ea_s *eap, count_t immed_count)
971	struct ea_s *eap;
972	count_t immed_count;
973	{	954	{
974	getea(eap);	955	getea(eap);
975	yesimmed(eap);	956	yesimmed(eap);
Lines 980-995 Link Here
980	}	961	}
981	}	962	}
982		963
983	PRIVATE void getindirect(eap)	964	PRIVATE void getindirect(register struct ea_s *eap)
984	register struct ea_s *eap;
985	{	965	{
986	getea(eap);	966	getea(eap);
987	if (eap->indcount == 0x0)	967	if (eap->indcount == 0x0)
988	kgerror(IND_REQ);	968	kgerror(IND_REQ);
989	}	969	}
990		970
991	PRIVATE void getshift(eap)	971	PRIVATE void getshift(register struct ea_s *eap)
992	register struct ea_s *eap;
993	{	972	{
994	getcomma();	973	getcomma();
995	getea(eap);	974	getea(eap);
Lines 1003-1010 Link Here
1003	Return register number (adjusted if necessary to a legal index) or NOREG.	982	Return register number (adjusted if necessary to a legal index) or NOREG.
1004	*/	983	*/
1005		984
1006	PRIVATE reg_pt indregchk(matchreg)	985	PRIVATE reg_pt indregchk(reg_pt matchreg)
1007	reg_pt matchreg;
1008	{	986	{
1009	reg_pt reg;	987	reg_pt reg;
1010		988
Lines 1050-1064 Link Here
1050	return reg;	1028	return reg;
1051	}	1029	}
1052		1030
1053	PRIVATE void kgerror(err_str)	1031	PRIVATE void kgerror(char * err_str)
1054	char * err_str;
1055	{	1032	{
1056	error(err_str);	1033	error(err_str);
1057	sprefix = oprefix = aprefix = mcount = 0x0;	1034	sprefix = oprefix = aprefix = mcount = 0x0;
1058	}	1035	}
1059		1036
1060	PRIVATE void lbranch(backamount)	1037	PRIVATE void lbranch(int backamount)
1061	int backamount;
1062	{	1038	{
1063	mcount += defsize + 0x1;	1039	mcount += defsize + 0x1;
1064	segadj();	1040	segadj();
Lines 2314-2349 Link Here
2314	buildregular();	2290	buildregular();
2315	}	2291	}
2316		2292
2317	PRIVATE void notbytesize(eap)	2293	PRIVATE void notbytesize(register struct ea_s *eap)
2318	register struct ea_s *eap;
2319	{	2294	{
2320	if (eap->size == 0x1)	2295	if (eap->size == 0x1)
2321	kgerror(ILL_SIZE);	2296	kgerror(ILL_SIZE);
2322	}	2297	}
2323		2298
2324	PRIVATE void notimmed(eap)	2299	PRIVATE void notimmed(register struct ea_s *eap)
2325	register struct ea_s *eap;
2326	{	2300	{
2327	if (eap->indcount == 0x0 && eap->base == NOREG)	2301	if (eap->indcount == 0x0 && eap->base == NOREG)
2328	kgerror(ILL_IMM_MODE);	2302	kgerror(ILL_IMM_MODE);
2329	}	2303	}
2330		2304
2331	PRIVATE void notindirect(eap)	2305	PRIVATE void notindirect(register struct ea_s *eap)
2332	register struct ea_s *eap;
2333	{	2306	{
2334	if (eap->indcount != 0x0)	2307	if (eap->indcount != 0x0)
2335	kgerror(ILL_IND);	2308	kgerror(ILL_IND);
2336	}	2309	}
2337		2310
2338	PRIVATE void notsegorspecreg(eap)	2311	PRIVATE void notsegorspecreg(register struct ea_s *eap)
2339	register struct ea_s *eap;
2340	{	2312	{
2341	if (regsegword[eap->base] >= SEGMOV)	2313	if (regsegword[eap->base] >= SEGMOV)
2342	kgerror(ILLREG);	2314	kgerror(ILLREG);
2343	}	2315	}
2344		2316
2345	PRIVATE void yesimmed(eap)	2317	PRIVATE void yesimmed(register struct ea_s *eap)
2346	register struct ea_s *eap;
2347	{	2318	{
2348	if (eap->indcount == 0x1)	2319	if (eap->indcount == 0x1)
2349	eap->indcount = 0x0;	2320	eap->indcount = 0x0;

Lines 30-36 Link Here

(-)a/as/table.c (-4 / +2 lines)
30	FORWARD void printchain P((void));	30	FORWARD void printchain P((void));
31	#endif	31	#endif
32		32
33	FORWARD void install P((register char *keyptr, int data));	33	FORWARD void install P((register char *keyptr, unsigned char data));
34		34
35	PUBLIC void inst_keywords()	35	PUBLIC void inst_keywords()
36	{	36	{
Lines 48-56 Link Here
48	#endif	48	#endif
49	}	49	}
50		50
51	PRIVATE void install(keyptr, data)	51	PRIVATE void install(register char *keyptr, unsigned char data)
52	register char *keyptr;
53	unsigned char data;
54	{	52	{
55	char lowcasebuf[20];	53	char lowcasebuf[20];
56	unsigned namelength;	54	unsigned namelength;

Lines 11-17 Link Here

(-)a/as/typeconv.c (-28 / +10 lines)
11	#include "globvar.h"	11	#include "globvar.h"
12		12
13	void xxerr P((char *));	13	void xxerr P((char *));
14	void xxerr(x) char * x; { write(2, x, strlen(x)); }	14	void xxerr(char *x) { write(2, x, strlen(x)); }
15		15
16	#ifdef __AS386_16__	16	#ifdef __AS386_16__
17	static int no_swap = 1;	17	static int no_swap = 1;
Lines 20-28 Link Here
20	static int long_off[4] = {0,1,2,3};	20	static int long_off[4] = {0,1,2,3};
21	static int int_off[2] = {0,1};	21	static int int_off[2] = {0,1};
22		22
23	PUBLIC bool_pt typeconv_init(big_endian, long_big_endian)	23	PUBLIC bool_pt typeconv_init(bool_pt big_endian, bool_pt long_big_endian)
24	bool_pt big_endian;
25	bool_pt long_big_endian;
26	{	24	{
27	int i;	25	int i;
28	#ifdef __AS386_16__	26	#ifdef __AS386_16__
Lines 47-55 Link Here
47	return 1;	45	return 1;
48	}	46	}
49		47
50	PUBLIC void u2c2(buf, offset)	48	PUBLIC void u2c2(char *buf, u2_pt offset)
51	char *buf;
52	u2_pt offset;
53	{	49	{
54	#ifdef __AS386_16__	50	#ifdef __AS386_16__
55	if( no_swap )	51	if( no_swap )
Lines 62-70 Link Here
62	buf[int_off[1]] = (offset>>8);	58	buf[int_off[1]] = (offset>>8);
63	}	59	}
64		60
65	PUBLIC void u4c4(buf, offset)	61	PUBLIC void u4c4(char *buf, u4_t offset)
66	char *buf;
67	u4_t offset;
68	{	62	{
69	int i;	63	int i;
70	#ifdef __AS386_16__	64	#ifdef __AS386_16__
Lines 81-90 Link Here
81	}	75	}
82	}	76	}
83		77
84	PUBLIC void u4cn(buf, offset, count)	78	PUBLIC void u4cn(char *buf, u4_t offset, unsigned count)
85	char *buf;
86	u4_t offset;
87	unsigned count;
88	{	79	{
89	switch(count)	80	switch(count)
90	{	81	{
Lines 103-112 Link Here
103	}	94	}
104	}	95	}
105		96
106	PUBLIC void u2cn(buf, offset, count)	97	PUBLIC void u2cn(char *buf, u2_pt offset, unsigned count)
107	char *buf;
108	u2_pt offset;
109	unsigned count;
110	{	98	{
111	switch(count)	99	switch(count)
112	{	100	{
Lines 125-132 Link Here
125	}	113	}
126	}	114	}
127		115
128	PUBLIC u2_pt c2u2(buf)	116	PUBLIC u2_pt c2u2(char *buf)
129	char *buf;
130	{	117	{
131	u2_pt res;	118	u2_pt res;
132	#ifdef __AS386_16__	119	#ifdef __AS386_16__
Lines 138-145 Link Here
138	return res;	125	return res;
139	}	126	}
140		127
141	PUBLIC u4_t c4u4(buf)	128	PUBLIC u4_t c4u4(char *buf)
142	char *buf;
143	{	129	{
144	u4_t res;	130	u4_t res;
145	int i;	131	int i;
Lines 154-162 Link Here
154	return res;	140	return res;
155	}	141	}
156		142
157	PUBLIC u4_t cnu4(buf, count)	143	PUBLIC u4_t cnu4(char *buf, unsigned count)
158	char *buf;
159	unsigned count;
160	{	144	{
161	switch (count)	145	switch (count)
162	{	146	{
Lines 174-182 Link Here
174	}	158	}
175	}	159	}
176		160
177	PUBLIC u2_pt cnu2(buf, count)	161	PUBLIC u2_pt cnu2(char *buf, unsigned count)
178	char *buf;
179	unsigned count;
180	{	162	{
181	switch (count)	163	switch (count)
182	{	164	{

Lines 15-23 Link Here

(-)a/bcc/assign.c (-19 / +6 lines)
15	struct symstruct *source, uoffset_T size));	15	struct symstruct *source, uoffset_T size));
16	FORWARD void fconvert P((struct symstruct source, struct typestruct type));	16	FORWARD void fconvert P((struct symstruct source, struct typestruct type));
17		17
18	PUBLIC void assign(source, target)	18	PUBLIC void assign(struct symstruct source, struct symstruct target)
19	struct symstruct *source;
20	struct symstruct *target;
21	{	19	{
22	store_pt regpushed;	20	store_pt regpushed;
23	store_pt sourcereg;	21	store_pt sourcereg;
Lines 148-156 Link Here
148		146
149	/* block move assumes itypesize == accregsize && BREG size == 1 */	147	/* block move assumes itypesize == accregsize && BREG size == 1 */
150		148
151	PRIVATE void blockmove(source, target)	149	PRIVATE void blockmove(struct symstruct source, struct symstruct target)
152	struct symstruct *source;
153	struct symstruct *target;
154	{	150	{
155	struct symstruct oldtarget;	151	struct symstruct oldtarget;
156	uoffset_T typesize;	152	uoffset_T typesize;
Lines 196-206 Link Here
196	*target = oldtarget;	192	*target = oldtarget;
197	}	193	}
198		194
199	PRIVATE void call3(funcname, target, source, size)	195	PRIVATE void call3(char funcname, struct symstruct target, struct symstruct *source, uoffset_T size)
200	char *funcname;
201	struct symstruct *target;
202	struct symstruct *source;
203	uoffset_T size;
204	{	196	{
205	store_pt regpushed;	197	store_pt regpushed;
206	offset_T spmark;	198	offset_T spmark;
Lines 222-230 Link Here
222	}	214	}
223	}	215	}
224		216
225	PUBLIC void cast(type, target)	217	PUBLIC void cast(struct typestruct type, struct symstruct target)
226	struct typestruct *type;
227	struct symstruct *target;
228	{	218	{
229	scalar_t newscalar;	219	scalar_t newscalar;
230	uoffset_T newsize;	220	uoffset_T newsize;
Lines 343-350 Link Here
343		333
344	/* extend char or short to int (unsigned if from unsigned) */	334	/* extend char or short to int (unsigned if from unsigned) */
345		335
346	PUBLIC void extend(target)	336	PUBLIC void extend(struct symstruct *target)
347	struct symstruct *target;
348	{	337	{
349	scalar_t tscalar;	338	scalar_t tscalar;
350		339
Lines 376-384 Link Here
376	}	365	}
377	}	366	}
378		367
379	PRIVATE void fconvert(source, type)	368	PRIVATE void fconvert(struct symstruct source, struct typestruct type)
380	struct symstruct *source;
381	struct typestruct *type;
382	{	369	{
383	offset_T spmark;	370	offset_T spmark;
384		371

Lines 191-199 Link Here

(-)a/bcc/bcc.c (-54 / +23 lines)
191	char * libc = "-lc";	191	char * libc = "-lc";
192		192
193	int	193	int
194	main(argc, argv)	194	main(int argc, char ** argv)
195	int argc;
196	char ** argv;
197	{	195	{
198	struct file_list * next_file;	196	struct file_list * next_file;
199	char * temp;	197	char * temp;
Lines 277-298 Link Here
277	}	275	}
278		276
279	char *	277	char *
280	copystr(str)	278	copystr(char * str)
281	char * str;
282	{	279	{
283	return strcpy(xalloc(strlen(str)+1), str);	280	return strcpy(xalloc(strlen(str)+1), str);
284	}	281	}
285		282
286	char *	283	char *
287	catstr(str, str2)	284	catstr(char * str, char * str2)
288	char * str, * str2;
289	{	285	{
290	return strcat(strcpy(xalloc(strlen(str)+strlen(str2)+1), str), str2);	286	return strcat(strcpy(xalloc(strlen(str)+strlen(str2)+1), str), str2);
291	}	287	}
292		288
293	void	289	void
294	run_aspreproc(file)	290	run_aspreproc(struct file_list * file)
295	struct file_list * file;
296	{	291	{
297	static char cc1bcc[] = CC1BCC;	292	static char cc1bcc[] = CC1BCC;
298		293
Lines 319-326 Link Here
319	}	314	}
320		315
321	void	316	void
322	run_preproc(file)	317	run_preproc(struct file_list * file)
323	struct file_list * file;
324	{	318	{
325	int last_stage = 0;	319	int last_stage = 0;
326	int combined_cpp;	320	int combined_cpp;
Lines 373-380 Link Here
373	}	367	}
374		368
375	void	369	void
376	run_unproto(file)	370	run_unproto(struct file_list * file)
377	struct file_list * file;
378	{	371	{
379	command.cmd = UNPROTO;	372	command.cmd = UNPROTO;
380	command_reset();	373	command_reset();
Lines 385-392 Link Here
385	}	378	}
386		379
387	void	380	void
388	run_compile(file)	381	run_compile(struct file_list * file)
389	struct file_list * file;
390	{	382	{
391	if (opt_arch == 3) command.cmd = CC1C386;	383	if (opt_arch == 3) command.cmd = CC1C386;
392	else if (opt_arch<5) command.cmd = CC1BCC;	384	else if (opt_arch<5) command.cmd = CC1BCC;
Lines 410-417 Link Here
410	}	402	}
411		403
412	void	404	void
413	run_optim(file)	405	run_optim(struct file_list * file)
414	struct file_list * file;
415	{	406	{
416	char buf[32];	407	char buf[32];
417	if (opt_arch<5) command.cmd = OPTIM;	408	if (opt_arch<5) command.cmd = OPTIM;
Lines 451-458 Link Here
451	}	442	}
452		443
453	void	444	void
454	run_as(file)	445	run_as(struct file_list * file)
455	struct file_list * file;
456	{	446	{
457	char * buf;	447	char * buf;
458	switch(opt_arch)	448	switch(opt_arch)
Lines 539-546 Link Here
539	}	529	}
540		530
541	void	531	void
542	validate_link_opt(option)	532	validate_link_opt(char * option)
543	char * option;
544	{	533	{
545	int err = 0;	534	int err = 0;
546	if (option[0] != '-') return;	535	if (option[0] != '-') return;
Lines 685-692 Link Here
685	}	674	}
686		675
687	void	676	void
688	command_opt(option)	677	command_opt(char * option)
689	char * option;
690	{	678	{
691	if (command.maxargs <= command.numargs+1) {	679	if (command.maxargs <= command.numargs+1) {
692	char ** newbuf = xalloc(command.maxargs2sizeof(char**));	680	char ** newbuf = xalloc(command.maxargs2sizeof(char**));
Lines 708-715 Link Here
708	}	696	}
709		697
710	void	698	void
711	command_opts(optkey)	699	command_opts(int optkey)
712	int optkey;
713	{	700	{
714	struct opt_list * ol;	701	struct opt_list * ol;
715	for(ol=options; ol; ol=ol->next)	702	for(ol=options; ol; ol=ol->next)
Lines 717-727 Link Here
717	command_opt(ol->opt);	704	command_opt(ol->opt);
718	}	705	}
719		706
720	void newfilename(file, last_stage, new_extn, use_o)	707	void newfilename(struct file_list * file, int last_stage, int new_extn, int use_o)
721	struct file_list * file;
722	int last_stage;
723	int new_extn;
724	int use_o;
725	{	708	{
726	file->filetype = new_extn;	709	file->filetype = new_extn;
727	if (file->oldfile) free(file->oldfile);	710	if (file->oldfile) free(file->oldfile);
Lines 787-795 Link Here
787	}	770	}
788		771
789	void	772	void
790	getargs(argc, argv)	773	getargs(int argc, char ** argv)
791	int argc;
792	char ** argv;
793	{	774	{
794	int ar;	775	int ar;
795	char * pflag = 0;	776	char * pflag = 0;
Lines 1122-1129 Link Here
1122	}	1103	}
1123		1104
1124	void	1105	void
1125	build_prefix(path1, path2, path3)	1106	build_prefix(char * path1, char * path2, char * path3)
1126	char * path1, * path2, * path3;
1127	{	1107	{
1128	char * newstr;	1108	char * newstr;
1129	int l;	1109	int l;
Lines 1142-1149 Link Here
1142	}	1122	}
1143		1123
1144	void	1124	void
1145	add_prefix(path)	1125	add_prefix(char * path)
1146	char * path;
1147	{	1126	{
1148	char ** p;	1127	char ** p;
1149	if (!path \|\| !*path) return;	1128	if (!path \|\| !*path) return;
Lines 1162-1170 Link Here
1162	fatal("Too many -B options");	1141	fatal("Too many -B options");
1163	}	1142	}
1164		1143
1165	void append_file (filename, ftype)	1144	void append_file (char * filename, int ftype)
1166	char * filename;
1167	int ftype;
1168	{	1145	{
1169	struct file_list * newfile = xalloc(sizeof(struct file_list));	1146	struct file_list * newfile = xalloc(sizeof(struct file_list));
1170	char * s;	1147	char * s;
Lines 1202-1210 Link Here
1202	}	1179	}
1203		1180
1204	void	1181	void
1205	append_option (option, otype)	1182	append_option (char * option, int otype)
1206	char * option;
1207	int otype;
1208	{	1183	{
1209	struct opt_list * newopt = xalloc(sizeof(struct opt_list));	1184	struct opt_list * newopt = xalloc(sizeof(struct opt_list));
1210		1185
Lines 1222-1230 Link Here
1222	}	1197	}
1223		1198
1224	void	1199	void
1225	prepend_option (option, otype)	1200	prepend_option (char * option, int otype)
1226	char * option;
1227	int otype;
1228	{	1201	{
1229	struct opt_list * newopt = xalloc(sizeof(struct opt_list));	1202	struct opt_list * newopt = xalloc(sizeof(struct opt_list));
1230		1203
Lines 1235-1242 Link Here
1235	options = newopt;	1208	options = newopt;
1236	}	1209	}
1237		1210
1238	char * build_libpath(opt, str, suffix)	1211	char * build_libpath(char * opt, char * str, char * suffix)
1239	char * opt, * str, * suffix;
1240	{	1212	{
1241	char * newstr;	1213	char * newstr;
1242	newstr = xalloc(strlen(opt)+strlen(str)+strlen(prefix_path)+strlen(suffix)+1);	1214	newstr = xalloc(strlen(opt)+strlen(str)+strlen(prefix_path)+strlen(suffix)+1);
Lines 1248-1255 Link Here
1248	}	1220	}
1249		1221
1250	void *	1222	void *
1251	xalloc (size)	1223	xalloc (int size)
1252	int size;
1253	{	1224	{
1254	void * p = malloc(size);	1225	void * p = malloc(size);
1255	if (!p) fatal("Out of memory");	1226	if (!p) fatal("Out of memory");
Lines 1273-1280 Link Here
1273	exit(1);	1244	exit(1);
1274	}	1245	}
1275		1246
1276	void fatal(str)	1247	void fatal(char * str)
1277	char * str;
1278	{	1248	{
1279	fprintf(stderr, "%s: Fatal error: %s.\n", progname, str);	1249	fprintf(stderr, "%s: Fatal error: %s.\n", progname, str);
1280	exit(1);	1250	exit(1);
Lines 1377-1384 Link Here
1377	#endif	1347	#endif
1378		1348
1379	void	1349	void
1380	run_command(file)	1350	run_command(struct file_list * file)
1381	struct file_list * file;
1382	{	1351	{
1383	#ifdef __BCC__	1352	#ifdef __BCC__
1384	static char ** minienviron[] = {	1353	static char ** minienviron[] = {

Lines 617-625 Link Here

(-)a/bcc/codefrag.c (-101 / +40 lines)
617		617
618	/* add constant to register */	618	/* add constant to register */
619		619
620	PUBLIC void addconst(offset, reg)	620	PUBLIC void addconst(offset_T offset, store_pt reg)
621	offset_T offset;
622	store_pt reg;
623	{	621	{
624	#ifdef I8088	622	#ifdef I8088
625	#ifdef I80386	623	#ifdef I80386
Lines 670-678 Link Here
670		668
671	/* adjust lc for signed offset */	669	/* adjust lc for signed offset */
672		670
673	PUBLIC void adjlc(offset, reg)	671	PUBLIC void adjlc(offset_T offset, store_pt reg)
674	offset_T offset;
675	store_pt reg;
676	{	672	{
677	if (!(reg & CHARREGS))	673	if (!(reg & CHARREGS))
678	{	674	{
Lines 693-700 Link Here
693		689
694	/* adjust stack ptr by adding a labelled constant less current sp */	690	/* adjust stack ptr by adding a labelled constant less current sp */
695		691
696	PUBLIC void adjsp(label)	692	PUBLIC void adjsp(label_no label)
697	label_no label;
698	{	693	{
699	outaddsp();	694	outaddsp();
700	outbyte(LOCALSTARTCHAR);	695	outbyte(LOCALSTARTCHAR);
Lines 721-728 Link Here
721		716
722	/* and accumulator with constant */	717	/* and accumulator with constant */
723		718
724	PUBLIC void andconst(offset)	719	PUBLIC void andconst(offset_T offset)
725	offset_T offset;
726	{	720	{
727	char_t botbits;	721	char_t botbits;
728	uoffset_T topbits;	722	uoffset_T topbits;
Lines 805-820 Link Here
805		799
806	/* clear register to 0 */	800	/* clear register to 0 */
807		801
808	PRIVATE void clr(reg)	802	PRIVATE void clr(store_pt reg)
809	store_pt reg;
810	{	803	{
811	loadconst((offset_T) 0, reg);	804	loadconst((offset_T) 0, reg);
812	}	805	}
813		806
814	/* define common storage */	807	/* define common storage */
815		808
816	PUBLIC void common(name)	809	PUBLIC void common(char *name)
817	char *name;
818	{	810	{
819	#ifdef I8088	811	#ifdef I8088
820	outcommon();	812	outcommon();
Lines 840-847 Link Here
840		832
841	/* define long */	833	/* define long */
842		834
843	PUBLIC void deflong(value)	835	PUBLIC void deflong(uoffset_T value)
844	uoffset_T value;
845	{	836	{
846	uoffset_T longhigh;	837	uoffset_T longhigh;
847	uoffset_T longlow;	838	uoffset_T longlow;
Lines 877-884 Link Here
877		868
878	/* define null storage */	869	/* define null storage */
879		870
880	PUBLIC void defnulls(nullcount)	871	PUBLIC void defnulls(uoffset_T nullcount)
881	uoffset_T nullcount;
882	{	872	{
883	if (nullcount != 0)	873	if (nullcount != 0)
884	{	874	{
Lines 889-898 Link Here
889		879
890	/* define string */	880	/* define string */
891		881
892	PUBLIC label_no defstr(sptr, stop, dataflag)	882	PUBLIC label_no defstr(char sptr, char stop, bool_pt dataflag)
893	char *sptr;
894	char *stop;
895	bool_pt dataflag;
896	{	883	{
897	int byte; /* promoted char for output */	884	int byte; /* promoted char for output */
898	label_no strlab;	885	label_no strlab;
Lines 981-989 Link Here
981		968
982	/* divide D register by a constant if it is easy to do with shifts */	969	/* divide D register by a constant if it is easy to do with shifts */
983		970
984	PUBLIC bool_pt diveasy(divisor, uflag)	971	PUBLIC bool_pt diveasy(value_t divisor, bool_pt uflag)
985	value_t divisor;
986	bool_pt uflag;
987	{	972	{
988	bool_t sign;	973	bool_t sign;
989		974
Lines 1034-1042 Link Here
1034		1019
1035	/* equate a name to an EOL-terminated string */	1020	/* equate a name to an EOL-terminated string */
1036		1021
1037	PUBLIC void equ(name, string)	1022	PUBLIC void equ(char name, char string)
1038	char *name;
1039	char *string;
1040	{	1023	{
1041	outstr(name);	1024	outstr(name);
1042	outequate();	1025	outequate();
Lines 1045-1053 Link Here
1045		1028
1046	/* equate a local label to a value */	1029	/* equate a local label to a value */
1047		1030
1048	PUBLIC void equlab(label, offset)	1031	PUBLIC void equlab(label_no label, offset_T offset)
1049	label_no label;
1050	offset_T offset;
1051	{	1032	{
1052	outbyte(LOCALSTARTCHAR);	1033	outbyte(LOCALSTARTCHAR);
1053	outlabel(label);	1034	outlabel(label);
Lines 1058-1065 Link Here
1058		1039
1059	/* import or export a variable */	1040	/* import or export a variable */
1060		1041
1061	PUBLIC void globl(name)	1042	PUBLIC void globl(char *name)
1062	char *name;
1063	{	1043	{
1064	outglobl();	1044	outglobl();
1065	outnccname(name);	1045	outnccname(name);
Lines 1067-1074 Link Here
1067		1047
1068	/* import a variable */	1048	/* import a variable */
1069		1049
1070	PUBLIC void import(name)	1050	PUBLIC void import(char *name)
1071	char *name;
1072	{	1051	{
1073	outimport();	1052	outimport();
1074	outnccname(name);	1053	outnccname(name);
Lines 1076-1083 Link Here
1076		1055
1077	/* extend an int to a long */	1056	/* extend an int to a long */
1078		1057
1079	PUBLIC void itol(reg)	1058	PUBLIC void itol(store_pt reg)
1080	store_pt reg;
1081	{	1059	{
1082	#define TEMP_LABEL_FOR_REGRESSION_TESTS	1060	#define TEMP_LABEL_FOR_REGRESSION_TESTS
1083	#ifdef TEMP_LABEL_FOR_REGRESSION_TESTS	1061	#ifdef TEMP_LABEL_FOR_REGRESSION_TESTS
Lines 1108-1122 Link Here
1108		1086
1109	/* define local common storage */	1087	/* define local common storage */
1110		1088
1111	PUBLIC void lcommlab(label)	1089	PUBLIC void lcommlab(label_no label)
1112	label_no label;
1113	{	1090	{
1114	outlabel(label);	1091	outlabel(label);
1115	outlcommon();	1092	outlcommon();
1116	}	1093	}
1117		1094
1118	PUBLIC void lcommon(name)	1095	PUBLIC void lcommon(char *name)
1119	char *name;
1120	{	1096	{
1121	outccname(name);	1097	outccname(name);
1122	outlcommon();	1098	outlcommon();
Lines 1126-1135 Link Here
1126		1102
1127	/* load effective address */	1103	/* load effective address */
1128		1104
1129	PUBLIC void lea(offset, sourcereg, targreg)	1105	PUBLIC void lea(offset_T offset, store_pt sourcereg, store_pt targreg)
1130	offset_T offset;
1131	store_pt sourcereg;
1132	store_pt targreg;
1133	{	1106	{
1134	outlea();	1107	outlea();
1135	outregname(targreg);	1108	outregname(targreg);
Lines 1142-1150 Link Here
1142		1115
1143	/* load constant into given register */	1116	/* load constant into given register */
1144		1117
1145	PUBLIC void loadconst(offset, reg)	1118	PUBLIC void loadconst(offset_T offset, store_pt reg)
1146	offset_T offset;
1147	store_pt reg;
1148	{	1119	{
1149	#ifdef I8088	1120	#ifdef I8088
1150	if (offset == 0)	1121	if (offset == 0)
Lines 1200-1208 Link Here
1200		1171
1201	/* partially long shift left register by a constant (negative = infinity) */	1172	/* partially long shift left register by a constant (negative = infinity) */
1202		1173
1203	PUBLIC int lslconst(shift, reg)	1174	PUBLIC int lslconst(value_t shift, store_pt reg)
1204	value_t shift;
1205	store_pt reg;
1206	{	1175	{
1207	if ((uvalue_t) shift >= INT16BITSTO)	1176	if ((uvalue_t) shift >= INT16BITSTO)
1208	{	1177	{
Lines 1236-1245 Link Here
1236		1205
1237	/* partially long shift right register by a constant (negative = infinity) */	1206	/* partially long shift right register by a constant (negative = infinity) */
1238		1207
1239	PUBLIC int lsrconst(shift, reg, uflag)	1208	PUBLIC int lsrconst(value_t shift, store_pt reg, bool_pt uflag)
1240	value_t shift;
1241	store_pt reg;
1242	bool_pt uflag;
1243	{	1209	{
1244	if ((uvalue_t) shift >= INT16BITSTO)	1210	if ((uvalue_t) shift >= INT16BITSTO)
1245	{	1211	{
Lines 1287-1295 Link Here
1287		1253
1288	/* take D register modulo a constant if it is easy to do with a mask */	1254	/* take D register modulo a constant if it is easy to do with a mask */
1289		1255
1290	PUBLIC bool_pt modeasy(divisor, uflag)	1256	PUBLIC bool_pt modeasy(value_t divisor, bool_pt uflag)
1291	value_t divisor;
1292	bool_pt uflag;
1293	{	1257	{
1294	bool_t sign;	1258	bool_t sign;
1295		1259
Lines 1317-1325 Link Here
1317		1281
1318	/* multiply register by a constant if it is easy to do with shifts */	1282	/* multiply register by a constant if it is easy to do with shifts */
1319		1283
1320	PUBLIC bool_pt muleasy(factor, reg)	1284	PUBLIC bool_pt muleasy(uvalue_t factor, store_pt reg)
1321	uvalue_t factor;
1322	store_pt reg;
1323	{	1285	{
1324	int mulstack[MAXINTBITSTO / 2 + 1]; /* must be signed, not a fastin_t */	1286	int mulstack[MAXINTBITSTO / 2 + 1]; /* must be signed, not a fastin_t */
1325	fastin_pt count;	1287	fastin_pt count;
Lines 1397-1404 Link Here
1397		1359
1398	/* negate a register */	1360	/* negate a register */
1399		1361
1400	PUBLIC void negreg(reg)	1362	PUBLIC void negreg(store_pt reg)
1401	store_pt reg;
1402	{	1363	{
1403	if ((store_t) reg == BREG)	1364	if ((store_t) reg == BREG)
1404	extBnegD();	1365	extBnegD();
Lines 1408-1415 Link Here
1408		1369
1409	/* return string of operator */	1370	/* return string of operator */
1410		1371
1411	PUBLIC char *opstring(op)	1372	PUBLIC char *opstring(op_pt op)
1412	op_pt op;
1413	{	1373	{
1414	switch (op)	1374	switch (op)
1415	{	1375	{
Lines 1432-1439 Link Here
1432		1392
1433	/* print a c compiler name with leading CCNAMEPREXFIX */	1393	/* print a c compiler name with leading CCNAMEPREXFIX */
1434		1394
1435	PUBLIC void outccname(name)	1395	PUBLIC void outccname(char *name)
1436	char *name;
1437	{	1396	{
1438	outbyte(CCNAMEPREFIX);	1397	outbyte(CCNAMEPREFIX);
1439	outstr(name);	1398	outstr(name);
Lines 1448-1455 Link Here
1448		1407
1449	/* print immediate address */	1408	/* print immediate address */
1450		1409
1451	PUBLIC void outimmadr(offset)	1410	PUBLIC void outimmadr(offset_T offset)
1452	offset_T offset;
1453	{	1411	{
1454	#ifdef I8088	1412	#ifdef I8088
1455	if (!isbyteoffset(offset))	1413	if (!isbyteoffset(offset))
Lines 1464-1472 Link Here
1464		1422
1465	/* print register, comma, immediate address and adjust lc */	1423	/* print register, comma, immediate address and adjust lc */
1466		1424
1467	PUBLIC void outimadj(offset, targreg)	1425	PUBLIC void outimadj(offset_T offset, store_pt targreg)
1468	offset_T offset;
1469	store_pt targreg;
1470	{	1426	{
1471	outregname(targreg);	1427	outregname(targreg);
1472	adjlc(offset, targreg);	1428	adjlc(offset, targreg);
Lines 1491-1498 Link Here
1491		1447
1492	/* print cc name, then newline */	1448	/* print cc name, then newline */
1493		1449
1494	PUBLIC void outnccname(name)	1450	PUBLIC void outnccname(char *name)
1495	char *name;
1496	{	1451	{
1497	outccname(name);	1452	outccname(name);
1498	outnl();	1453	outnl();
Lines 1500-1507 Link Here
1500		1455
1501	/* print separator, immediate address, newline */	1456	/* print separator, immediate address, newline */
1502		1457
1503	PUBLIC void outncimmadr(offset)	1458	PUBLIC void outncimmadr(offset_T offset)
1504	offset_T offset;
1505	{	1459	{
1506	#ifdef I8088	1460	#ifdef I8088
1507	outcomma();	1461	outcomma();
Lines 1515-1522 Link Here
1515		1469
1516	/* print signed offset and adjust lc */	1470	/* print signed offset and adjust lc */
1517		1471
1518	PUBLIC void outoffset(offset)	1472	PUBLIC void outoffset(offset_T offset)
1519	offset_T offset;
1520	{	1473	{
1521	#ifdef MC6809	1474	#ifdef MC6809
1522	if (!is5bitoffset(offset))	1475	if (!is5bitoffset(offset))
Lines 1532-1539 Link Here
1532	outstr(stackregstr);	1485	outstr(stackregstr);
1533	}	1486	}
1534		1487
1535	PUBLIC void public(name)	1488	PUBLIC void public(char *name)
1536	char *name;
1537	{	1489	{
1538	#ifndef AS09	1490	#ifndef AS09
1539	outexport();	1491	outexport();
Lines 1545-1552 Link Here
1545		1497
1546	/* print cc name as a private label */	1498	/* print cc name as a private label */
1547		1499
1548	PUBLIC void private(name)	1500	PUBLIC void private(char *name)
1549	char *name;
1550	{	1501	{
1551	#ifdef LABELENDCHAR	1502	#ifdef LABELENDCHAR
1552	outccname(name);	1503	outccname(name);
Lines 1558-1566 Link Here
1558		1509
1559	/* exchange registers */	1510	/* exchange registers */
1560		1511
1561	PUBLIC void regexchange(sourcereg, targreg)	1512	PUBLIC void regexchange(store_pt sourcereg, store_pt targreg)
1562	store_pt sourcereg;
1563	store_pt targreg;
1564	{	1513	{
1565	outexchange();	1514	outexchange();
1566	outregname(sourcereg);	1515	outregname(sourcereg);
Lines 1573-1581 Link Here
1573		1522
1574	/* transfer a register */	1523	/* transfer a register */
1575		1524
1576	PUBLIC void regtransfer(sourcereg, targreg)	1525	PUBLIC void regtransfer(store_pt sourcereg, store_pt targreg)
1577	store_pt sourcereg;
1578	store_pt targreg;
1579	{	1526	{
1580	outtransfer();	1527	outtransfer();
1581	#ifdef TARGET_FIRST	1528	#ifdef TARGET_FIRST
Lines 1610-1618 Link Here
1610		1557
1611	/* set a name to a value */	1558	/* set a name to a value */
1612		1559
1613	PUBLIC void set(name, value)	1560	PUBLIC void set(char *name, offset_T value)
1614	char *name;
1615	offset_T value;
1616	{	1561	{
1617	outccname(funcname);	1562	outccname(funcname);
1618	outbyte(LOCALSTARTCHAR);	1563	outbyte(LOCALSTARTCHAR);
Lines 1658-1665 Link Here
1658		1603
1659	/* shift left register by 1 */	1604	/* shift left register by 1 */
1660		1605
1661	PUBLIC void sl1(reg)	1606	PUBLIC void sl1(store_pt reg)
1662	store_pt reg;
1663	{	1607	{
1664	outsl();	1608	outsl();
1665	#ifdef I8088	1609	#ifdef I8088
Lines 1674-1682 Link Here
1674		1618
1675	/* shift left register by a constant (negative = infinity) */	1619	/* shift left register by a constant (negative = infinity) */
1676		1620
1677	PUBLIC void slconst(shift, reg)	1621	PUBLIC void slconst(value_t shift, store_pt reg)
1678	value_t shift;
1679	store_pt reg;
1680	{	1622	{
1681	#ifdef I80386	1623	#ifdef I80386
1682	if (i386_32)	1624	if (i386_32)
Lines 1725-1733 Link Here
1725		1667
1726	/* shift right D register by a constant (negative = infinity) */	1668	/* shift right D register by a constant (negative = infinity) */
1727		1669
1728	PUBLIC void srconst(shift, uflag)	1670	PUBLIC void srconst(value_t shift, bool_pt uflag)
1729	value_t shift;
1730	bool_pt uflag;
1731	{	1671	{
1732	#ifdef I80386	1672	#ifdef I80386
1733	if (i386_32)	1673	if (i386_32)
Lines 1795-1802 Link Here
1795		1735
1796	/* extend an unsigned in DREG to a long */	1736	/* extend an unsigned in DREG to a long */
1797		1737
1798	PUBLIC void uitol(reg)	1738	PUBLIC void uitol(store_pt reg)
1799	store_pt reg;
1800	{	1739	{
1801	if (lowregisDreg())	1740	if (lowregisDreg())
1802	clr(reg);	1741	clr(reg);

Lines 44-51 Link Here

(-)a/bcc/dbnode.c (-9 / +4 lines)
44		44
45	FORWARD void outindchars P((int byte, indn_pt count));	45	FORWARD void outindchars P((int byte, indn_pt count));
46		46
47	PUBLIC void dbitem(item)	47	PUBLIC void dbitem(struct symstruct *item)
48	struct symstruct *item;
49	{	48	{
50	dbtype(item->type);	49	dbtype(item->type);
51	if (item->storage == NOSTORAGE)	50	if (item->storage == NOSTORAGE)
Lines 126-133 Link Here
126	outindchars(']', item->indcount);	125	outindchars(']', item->indcount);
127	}	126	}
128		127
129	PUBLIC void dbtype(type)	128	PUBLIC void dbtype(struct typestruct *type)
130	struct typestruct *type;
131	{	129	{
132	for ( ; type != NULL; type = type->nexttype)	130	for ( ; type != NULL; type = type->nexttype)
133	{	131	{
Lines 156-163 Link Here
156	}	154	}
157	}	155	}
158		156
159	PUBLIC void dbnode(exp) /* sub-nodes must be leaves */	157	PUBLIC void dbnode(struct nodestruct exp) / sub-nodes must be leaves */
160	struct nodestruct *exp;
161	{	158	{
162	if (!dbnodeon)	159	if (!dbnodeon)
163	return;	160	return;
Lines 189-197 Link Here
189	outnstr("! Debug: expression subtree swapping");	186	outnstr("! Debug: expression subtree swapping");
190	}	187	}
191		188
192	PRIVATE void outindchars(byte, count)	189	PRIVATE void outindchars(int byte, indn_pt count)
193	int byte;
194	indn_pt count;
195	{	190	{
196	while (count--)	191	while (count--)
197	outbyte(byte);	192	outbyte(byte);

Lines 54-62 Link Here

(-)a/bcc/declare.c (-20 / +8 lines)
54	FORWARD void rdeclarator P((void));	54	FORWARD void rdeclarator P((void));
55	FORWARD bool_pt regdecl P((void));	55	FORWARD bool_pt regdecl P((void));
56		56
57	PRIVATE struct typestruct *chainprefix(pretype, sufftype)	57	PRIVATE struct typestruct chainprefix(struct typestruct pretype, struct typestruct *sufftype)
58	struct typestruct *pretype;
59	struct typestruct *sufftype;
60	{	58	{
61	if (pretype->nexttype != NULL)	59	if (pretype->nexttype != NULL)
62	{	60	{
Lines 324-333 Link Here
324		322
325	/* declselt - get list of declarations for a structure/union member */	323	/* declselt - get list of declarations for a structure/union member */
326		324
327	PRIVATE void declselt(structype, psoffset, ptypelist)	325	PRIVATE void declselt(struct typestruct structype, offset_T psoffset, struct typelist **ptypelist)
328	struct typestruct *structype;
329	offset_T *psoffset;
330	struct typelist **ptypelist;
331	{	326	{
332	struct typestruct *basetype;	327	struct typestruct *basetype;
333	value_t fieldwidth;	328	value_t fieldwidth;
Lines 959-966 Link Here
959	argsallowed = FALSE;	954	argsallowed = FALSE;
960	}	955	}
961		956
962	PRIVATE void initarray(type)	957	PRIVATE void initarray(struct typestruct *type)
963	struct typestruct *type;
964	{	958	{
965	uoffset_T basesize;	959	uoffset_T basesize;
966	struct typestruct *basetype;	960	struct typestruct *basetype;
Lines 1001-1008 Link Here
1001	defnulls(remaining * basesize);	995	defnulls(remaining * basesize);
1002	}	996	}
1003		997
1004	PRIVATE void inititem(type)	998	PRIVATE void inititem(struct typestruct *type)
1005	struct typestruct *type;
1006	{	999	{
1007	sym_t startsym;	1000	sym_t startsym;
1008		1001
Lines 1034-1041 Link Here
1034	}	1027	}
1035	}	1028	}
1036		1029
1037	PRIVATE void initstruct(type)	1030	PRIVATE void initstruct(struct typestruct *type)
1038	struct typestruct *type;
1039	{	1031	{
1040	struct typestruct *memtype;	1032	struct typestruct *memtype;
1041	uoffset_T newoffset;	1033	uoffset_T newoffset;
Lines 1074-1087 Link Here
1074	nextsym();	1066	nextsym();
1075	}	1067	}
1076		1068
1077	PRIVATE void multidecl(sname)	1069	PRIVATE void multidecl(char *sname)
1078	char *sname;
1079	{	1070	{
1080	error2error(sname, " already declared");	1071	error2error(sname, " already declared");
1081	}	1072	}
1082		1073
1083	PRIVATE void need(charneeded)	1074	PRIVATE void need(int charneeded)
1084	int charneeded;
1085	{	1075	{
1086	static char message[] = "need 'x'";	1076	static char message[] = "need 'x'";
1087		1077
Lines 1240-1248 Link Here
1240	return anons;	1230	return anons;
1241	}	1231	}
1242		1232
1243	PUBLIC void anonname(name, i)	1233	PUBLIC void anonname(char *name, int i)
1244	char *name;
1245	int i;
1246	{	1234	{
1247	if (i == 0xfff)	1235	if (i == 0xfff)
1248	fatalerror("Too many anonymous structs/unions");	1236	fatalerror("Too many anonymous structs/unions");

Lines 98-105 Link Here

(-)a/bcc/express.c (-4 / +2 lines)
98	return lhs;	98	return lhs;
99	}	99	}
100		100
101	PRIVATE struct nodestruct *exp3to12(lprecedence)	101	PRIVATE struct nodestruct *exp3to12(fastin_pt lprecedence)
102	fastin_pt lprecedence;
103	{	102	{
104	struct nodestruct *lhs;	103	struct nodestruct *lhs;
105	op_pt op;	104	op_pt op;
Lines 206-213 Link Here
206	return parent;	205	return parent;
207	}	206	}
208		207
209	PRIVATE struct nodestruct *postfix_exp(seenlp)	208	PRIVATE struct nodestruct *postfix_exp(bool_pt seenlp)
210	bool_pt seenlp;
211	{	209	{
212	struct nodestruct *nodeptr;	210	struct nodestruct *nodeptr;
213	struct symstruct *symptr;	211	struct symstruct *symptr;

Lines 39-53 Link Here

(-)a/bcc/exptree.c (-35 / +16 lines)
39	FORWARD int redscalar P((struct nodestruct *nodeptr));	39	FORWARD int redscalar P((struct nodestruct *nodeptr));
40	FORWARD struct nodestruct unconvert P((struct nodestruct nodeptr));	40	FORWARD struct nodestruct unconvert P((struct nodestruct nodeptr));
41		41
42	PRIVATE void badlvalue(nodeptr)	42	PRIVATE void badlvalue(struct nodestruct *nodeptr)
43	struct nodestruct *nodeptr;
44	{	43	{
45	error("invalid lvalue");	44	error("invalid lvalue");
46	fixnode(nodeptr);	45	fixnode(nodeptr);
47	}	46	}
48		47
49	PRIVATE void binconvert(nodeptr)	48	PRIVATE void binconvert(register struct nodestruct *nodeptr)
50	register struct nodestruct *nodeptr;
51	{	49	{
52	bool_t bothscalar;	50	bool_t bothscalar;
53	value_t divisor;	51	value_t divisor;
Lines 118-132 Link Here
118	nodeptr->nodetype = itype;	116	nodeptr->nodetype = itype;
119	}	117	}
120		118
121	PRIVATE void castiright(nodeptr)	119	PRIVATE void castiright(struct nodestruct *nodeptr)
122	struct nodestruct *nodeptr;
123	{	120	{
124	nodeptr->right = castnode(itype, nodeptr->right);	121	nodeptr->right = castnode(itype, nodeptr->right);
125	}	122	}
126		123
127	PUBLIC struct nodestruct *castnode(type, nodeptr)	124	PUBLIC struct nodestruct castnode(struct typestruct type, struct nodestruct *nodeptr)
128	struct typestruct *type;
129	struct nodestruct *nodeptr;
130	{	125	{
131	struct symstruct *symptr;	126	struct symstruct *symptr;
132		127
Lines 148-155 Link Here
148	ettop = (etptr = etree) + ETREESIZE;	143	ettop = (etptr = etree) + ETREESIZE;
149	}	144	}
150		145
151	PRIVATE void fixnode(nodeptr)	146	PRIVATE void fixnode(register struct nodestruct *nodeptr)
152	register struct nodestruct *nodeptr;
153	{	147	{
154	nodeptr->tag = LEAF;	148	nodeptr->tag = LEAF;
155	nodeptr->flags = nodeptr->weight = 0;	149	nodeptr->flags = nodeptr->weight = 0;
Lines 157-164 Link Here
157	nodeptr->nodetype = errtype;	151	nodeptr->nodetype = errtype;
158	}	152	}
159		153
160	PRIVATE bool_pt isconst0(nodeptr)	154	PRIVATE bool_pt isconst0(register struct nodestruct *nodeptr)
161	register struct nodestruct *nodeptr;
162	{	155	{
163	register struct symstruct *symptr;	156	register struct symstruct *symptr;
164		157
Lines 168-175 Link Here
168	symptr->type->scalar & ISCALAR;	161	symptr->type->scalar & ISCALAR;
169	}	162	}
170		163
171	PRIVATE bool_pt isnodecharconst(nodeptr)	164	PRIVATE bool_pt isnodecharconst(register struct nodestruct *nodeptr)
172	register struct nodestruct *nodeptr;
173	{	165	{
174	register struct symstruct *symptr;	166	register struct symstruct *symptr;
175		167
Lines 181-188 Link Here
181	return FALSE;	173	return FALSE;
182	}	174	}
183		175
184	PUBLIC struct nodestruct *leafnode(source)	176	PUBLIC struct nodestruct leafnode(struct symstruct source)
185	struct symstruct *source;
186	{	177	{
187	register struct nodestruct *leafptr;	178	register struct nodestruct *leafptr;
188		179
Lines 196-203 Link Here
196	return leafptr;	187	return leafptr;
197	}	188	}
198		189
199	PRIVATE void needint(nodeptr)	190	PRIVATE void needint(struct nodestruct *nodeptr)
200	struct nodestruct *nodeptr;
201	{	191	{
202	if (!(nodeptr->nodetype->scalar & ISCALAR))	192	if (!(nodeptr->nodetype->scalar & ISCALAR))
203	{	193	{
Lines 206-213 Link Here
206	}	196	}
207	}	197	}
208		198
209	PRIVATE void neednonstruct(nodeptr)	199	PRIVATE void neednonstruct(struct nodestruct *nodeptr)
210	struct nodestruct *nodeptr;
211	{	200	{
212	if (nodeptr->nodetype->constructor & STRUCTU)	201	if (nodeptr->nodetype->constructor & STRUCTU)
213	{	202	{
Lines 216-223 Link Here
216	}	205	}
217	}	206	}
218		207
219	PRIVATE void needscalar(nodeptr)	208	PRIVATE void needscalar(struct nodestruct *nodeptr)
220	struct nodestruct *nodeptr;
221	{	209	{
222	if (!nodeptr->nodetype->scalar)	210	if (!nodeptr->nodetype->scalar)
223	{	211	{
Lines 226-233 Link Here
226	}	214	}
227	}	215	}
228		216
229	PRIVATE void needspv(nodeptr)	217	PRIVATE void needspv(struct nodestruct *nodeptr)
230	struct nodestruct *nodeptr;
231	{	218	{
232	if (nodeptr->nodetype->constructor & (ARRAY \| FUNCTION \| STRUCTU))	219	if (nodeptr->nodetype->constructor & (ARRAY \| FUNCTION \| STRUCTU))
233	{	220	{
Lines 236-245 Link Here
236	}	223	}
237	}	224	}
238		225
239	PUBLIC struct nodestruct *node(t, p1, p2)	226	PUBLIC struct nodestruct node(op_pt t, struct nodestruct p1, struct nodestruct *p2)
240	op_pt t;
241	struct nodestruct *p1;
242	struct nodestruct *p2;
243	{	227	{
244	#if MAXREGS != 1	228	#if MAXREGS != 1
245	weight_t rightweight;	229	weight_t rightweight;
Lines 812-819 Link Here
812	}	796	}
813	}	797	}
814		798
815	PRIVATE struct typestruct *nodetype(nodeptr)	799	PRIVATE struct typestruct nodetype(struct nodestruct nodeptr)
816	struct nodestruct *nodeptr;
817	{	800	{
818	scalar_t bothscalar;	801	scalar_t bothscalar;
819	scalar_t lscalar;	802	scalar_t lscalar;
Lines 1097-1112 Link Here
1097	return left->nodetype;	1080	return left->nodetype;
1098	}	1081	}
1099		1082
1100	PRIVATE int redscalar(nodeptr)	1083	PRIVATE int redscalar(register struct nodestruct *nodeptr)
1101	register struct nodestruct *nodeptr;
1102	{	1084	{
1103	if (isnodecharconst(nodeptr))	1085	if (isnodecharconst(nodeptr))
1104	return CHAR;	1086	return CHAR;
1105	return nodeptr->nodetype->scalar;	1087	return nodeptr->nodetype->scalar;
1106	}	1088	}
1107		1089
1108	PRIVATE struct nodestruct *unconvert(nodeptr)	1090	PRIVATE struct nodestruct unconvert(struct nodestruct nodeptr)
1109	struct nodestruct *nodeptr;
1110	{	1091	{
1111	if (nodeptr->nodetype->constructor & (ARRAY \| FUNCTION))	1092	if (nodeptr->nodetype->constructor & (ARRAY \| FUNCTION))
1112	return castnode(pointype(nodeptr->nodetype->constructor & ARRAY ?	1093	return castnode(pointype(nodeptr->nodetype->constructor & ARRAY ?

Lines 15-22 Link Here

(-)a/bcc/floatop.c (-13 / +5 lines)
15	return nonzero iff the result is a temp double on the base of the stack	15	return nonzero iff the result is a temp double on the base of the stack
16	-----------------------------------------------------------------------------*/	16	-----------------------------------------------------------------------------*/
17		17
18	PUBLIC bool_pt f_indirect(target)	18	PUBLIC bool_pt f_indirect(struct symstruct *target)
19	struct symstruct *target;
20	{	19	{
21	if (target->indcount == 0)	20	if (target->indcount == 0)
22	{	21	{
Lines 72-80 Link Here
72	result is double on stack (or in condition codes for EQOP)	71	result is double on stack (or in condition codes for EQOP)
73	-----------------------------------------------------------------------------*/	72	-----------------------------------------------------------------------------*/
74		73
75	PUBLIC void float1op(op, source)	74	PUBLIC void float1op(op_pt op, struct symstruct *source)
76	op_pt op;
77	struct symstruct *source;
78	{	75	{
79	saveopreg();	76	saveopreg();
80	pointat(source);	77	pointat(source);
Lines 94-103 Link Here
94	result is double on stack (or in condition codes for EQOP)	91	result is double on stack (or in condition codes for EQOP)
95	----------------------------------------------------------------------------*/	92	----------------------------------------------------------------------------*/
96		93
97	PUBLIC void floatop(op, source, target)	94	PUBLIC void floatop(op_pt op, struct symstruct source, struct symstruct target)
98	op_pt op;
99	struct symstruct *source;
100	struct symstruct *target;
101	{	95	{
102	store_t regmark;	96	store_t regmark;
103	bool_t sflag;	97	bool_t sflag;
Lines 156-163 Link Here
156	OPREG must be free	150	OPREG must be free
157	-----------------------------------------------------------------------------*/	151	-----------------------------------------------------------------------------*/
158		152
159	PUBLIC void fpush(source)	153	PUBLIC void fpush(struct symstruct *source)
160	struct symstruct *source;
161	{	154	{
162	scalar_t scalar;	155	scalar_t scalar;
163		156
Lines 183-190 Link Here
183	records that target has just been pushed to a double on the stack	176	records that target has just been pushed to a double on the stack
184	-----------------------------------------------------------------------------*/	177	-----------------------------------------------------------------------------*/
185		178
186	PUBLIC void justpushed(target)	179	PUBLIC void justpushed(struct symstruct *target)
187	struct symstruct *target;
188	{	180	{
189	sp -= dtypesize;	181	sp -= dtypesize;
190	onstack(target);	182	onstack(target);

Lines 24-38 Link Here

(-)a/bcc/function.c (-9 / +4 lines)
24		24
25	/* call a named (assembly interface) procedure, don't print newline after */	25	/* call a named (assembly interface) procedure, don't print newline after */
26		26
27	PUBLIC void call(name)	27	PUBLIC void call(char *name)
28	char *name;
29	{	28	{
30	out_callstring();	29	out_callstring();
31	outstr(name);	30	outstr(name);
32	}	31	}
33		32
34	PUBLIC void function(source)	33	PUBLIC void function(struct symstruct *source)
35	struct symstruct *source;
36	{	34	{
37	if (source->indcount == 0 && source->storage == GLOBAL &&	35	if (source->indcount == 0 && source->storage == GLOBAL &&
38	!(source->flags & LABELLED) && *source->name.namep != 0)	36	!(source->flags & LABELLED) && *source->name.namep != 0)
Lines 223-231 Link Here
223	}	221	}
224	}	222	}
225		223
226	PUBLIC void listo(target, lastargsp)	224	PUBLIC void listo(struct symstruct *target, offset_T lastargsp)
227	struct symstruct *target;
228	offset_T lastargsp;
229	{	225	{
230	extend(target);	226	extend(target);
231	push(target);	227	push(target);
Lines 246-253 Link Here
246	}	242	}
247	}	243	}
248		244
249	PUBLIC void listroot(target)	245	PUBLIC void listroot(struct symstruct *target)
250	struct symstruct *target;
251	{	246	{
252	extend(target);	247	extend(target);
253	/* necessary regs are free since they were saved for function */	248	/* necessary regs are free since they were saved for function */

Lines 149-158 Link Here

(-)a/bcc/gencode.c (-16 / +7 lines)
149	FORWARD void smakeleaf P((struct nodestruct *exp));	149	FORWARD void smakeleaf P((struct nodestruct *exp));
150	FORWARD void tcheck P((struct nodestruct *exp));	150	FORWARD void tcheck P((struct nodestruct *exp));
151		151
152	PRIVATE void abop(op, source, target)	152	PRIVATE void abop(op_pt op, struct symstruct source, struct symstruct target)
153	op_pt op;
154	struct symstruct *source;
155	struct symstruct *target;
156	{	153	{
157	store_pt regmark;	154	store_pt regmark;
158	store_pt regpushed;	155	store_pt regpushed;
Lines 210-217 Link Here
210	recovlist(regpushed);	207	recovlist(regpushed);
211	}	208	}
212		209
213	PUBLIC void bileaf(exp)	210	PUBLIC void bileaf(struct nodestruct *exp)
214	struct nodestruct *exp;
215	{	211	{
216	bool_t commutop;	212	bool_t commutop;
217	bool_t tookaddress;	213	bool_t tookaddress;
Lines 367-374 Link Here
367	}	363	}
368	}	364	}
369		365
370	PUBLIC fastin_pt bitcount(number)	366	PUBLIC fastin_pt bitcount(register uvalue_t number)
371	register uvalue_t number;
372	{	367	{
373	register fastin_pt count;	368	register fastin_pt count;
374		369
Lines 457-464 Link Here
457	#endif	452	#endif
458	}	453	}
459		454
460	PUBLIC fastin_pt highbit(number)	455	PUBLIC fastin_pt highbit(register uvalue_t number)
461	register uvalue_t number;
462	{	456	{
463	register fastin_pt bit;	457	register fastin_pt bit;
464		458
Lines 467-474 Link Here
467	return bit;	461	return bit;
468	}	462	}
469		463
470	PUBLIC void makeleaf(exp)	464	PUBLIC void makeleaf(struct nodestruct *exp)
471	struct nodestruct *exp;
472	{	465	{
473	ccode_t condtrue;	466	ccode_t condtrue;
474	op_pt op;	467	op_pt op;
Lines 690-697 Link Here
690	#endif	683	#endif
691	}	684	}
692		685
693	PRIVATE void smakeleaf(exp)	686	PRIVATE void smakeleaf(struct nodestruct *exp)
694	struct nodestruct *exp;
695	{	687	{
696	struct nodestruct *left;	688	struct nodestruct *left;
697		689
Lines 714-721 Link Here
714		706
715	#ifdef SELFTYPECHECK	707	#ifdef SELFTYPECHECK
716		708
717	PRIVATE void tcheck(exp)	709	PRIVATE void tcheck(register struct nodestruct *exp)
718	register struct nodestruct *exp;
719	{	710	{
720	register struct symstruct *target;	711	register struct symstruct *target;
721		712

Lines 20-27 Link Here

(-)a/bcc/genloads.c (-73 / +31 lines)
20	FORWARD void outnnadr P((struct symstruct *adr));	20	FORWARD void outnnadr P((struct symstruct *adr));
21	FORWARD fastin_pt pushpull P((store_pt reglist, bool_pt pushflag));	21	FORWARD fastin_pt pushpull P((store_pt reglist, bool_pt pushflag));
22		22
23	PUBLIC void addoffset(source)	23	PUBLIC void addoffset(struct symstruct *source)
24	struct symstruct *source;
25	{	24	{
26	#ifdef I8088	25	#ifdef I8088
27	if (source->level == OFFKLUDGELEVEL)	26	if (source->level == OFFKLUDGELEVEL)
Lines 47-54 Link Here
47	}	46	}
48	}	47	}
49		48
50	PUBLIC void address(source)	49	PUBLIC void address(struct symstruct *source)
51	struct symstruct *source;
52	{	50	{
53	if (source->indcount == 0)	51	if (source->indcount == 0)
54	bugerror("taking address of non-lvalue");	52	bugerror("taking address of non-lvalue");
Lines 68-75 Link Here
68	bugerror("bad address");	66	bugerror("bad address");
69	}	67	}
70		68
71	PRIVATE void blockpush(source)	69	PRIVATE void blockpush(struct symstruct *source)
72	struct symstruct *source;
73	{	70	{
74	struct symstruct *length;	71	struct symstruct *length;
75	offset_T spmark;	72	offset_T spmark;
Lines 98-106 Link Here
98	indirec(source);	95	indirec(source);
99	}	96	}
100		97
101	PUBLIC void exchange(source, target)	98	PUBLIC void exchange(struct symstruct source, struct symstruct target)
102	struct symstruct *source;
103	struct symstruct *target;
104	{	99	{
105	store_t tempreg;	100	store_t tempreg;
106		101
Lines 151-159 Link Here
151	(except for PC register direct, since there is no LEAX D,PC)	146	(except for PC register direct, since there is no LEAX D,PC)
152	-----------------------------------------------------------------------------*/	147	-----------------------------------------------------------------------------*/
153		148
154	PUBLIC void indexadr(source, target)	149	PUBLIC void indexadr(struct symstruct source, struct symstruct target)
155	struct symstruct *source;
156	struct symstruct *target;
157	{	150	{
158	#ifdef MC6809	151	#ifdef MC6809
159	bool_t canABX;	152	bool_t canABX;
Lines 289-296 Link Here
289	target->storage = targreg;	282	target->storage = targreg;
290	}	283	}
291		284
292	PUBLIC void indirec(source)	285	PUBLIC void indirec(struct symstruct *source)
293	struct symstruct *source;
294	{	286	{
295	if (!(source->type->constructor & (ARRAY \| POINTER)))	287	if (!(source->type->constructor & (ARRAY \| POINTER)))
296	bugerror("illegal indirection");	288	bugerror("illegal indirection");
Lines 315-323 Link Here
315	the result has no offset	307	the result has no offset
316	-----------------------------------------------------------------------------*/	308	-----------------------------------------------------------------------------*/
317		309
318	PUBLIC void load(source, targreg)	310	PUBLIC void load(struct symstruct *source, store_pt targreg)
319	struct symstruct *source;
320	store_pt targreg;
321	{	311	{
322	if (source->type->scalar & DLONG)	312	if (source->type->scalar & DLONG)
323	{	313	{
Lines 422-430 Link Here
422	bugerror("attempting to load non-scalar non-pointer");	412	bugerror("attempting to load non-scalar non-pointer");
423	}	413	}
424		414
425	PRIVATE void loadadr(source, targreg)	415	PRIVATE void loadadr(struct symstruct *source, store_pt targreg)
426	struct symstruct *source;
427	store_pt targreg;
428	{	416	{
429	if ((store_t) targreg & ALLDATREGS)	417	if ((store_t) targreg & ALLDATREGS)
430	{	418	{
Lines 468-475 Link Here
468	loadreg(source, targreg);	456	loadreg(source, targreg);
469	}	457	}
470		458
471	PUBLIC void loadany(source)	459	PUBLIC void loadany(struct symstruct *source)
472	struct symstruct *source;
473	{	460	{
474	if (source->indcount != 0 \|\| source->offset.offi != 0 \|\| /* kludge u cmp */	461	if (source->indcount != 0 \|\| source->offset.offi != 0 \|\| /* kludge u cmp */
475	source->level == OFFKLUDGELEVEL \|\| !(source->storage & allregs))	462	source->level == OFFKLUDGELEVEL \|\| !(source->storage & allregs))
Lines 492-500 Link Here
492	}	479	}
493	}	480	}
494		481
495	PRIVATE void loadlongindirect(source, targreg)	482	PRIVATE void loadlongindirect(struct symstruct *source, store_pt targreg)
496	struct symstruct *source;
497	store_pt targreg;
498	{	483	{
499	sc_t flags;	484	sc_t flags;
500	offset_T offset;	485	offset_T offset;
Lines 517-525 Link Here
517	source->type = type;	502	source->type = type;
518	}	503	}
519		504
520	PUBLIC void loadreg(source, targreg)	505	PUBLIC void loadreg(struct symstruct *source, store_pt targreg)
521	struct symstruct *source;
522	store_pt targreg;
523	{	506	{
524	offset_T longhigh;	507	offset_T longhigh;
525	offset_T longlow;	508	offset_T longlow;
Lines 629-636 Link Here
629	}	612	}
630	}	613	}
631		614
632	PUBLIC void makelessindirect(source)	615	PUBLIC void makelessindirect(struct symstruct *source)
633	struct symstruct *source;
634	{	616	{
635	store_pt lreg;	617	store_pt lreg;
636		618
Lines 650-658 Link Here
650	#endif	632	#endif
651	}	633	}
652		634
653	PUBLIC void movereg(source, targreg)	635	PUBLIC void movereg(struct symstruct *source, store_pt targreg)
654	struct symstruct *source;
655	store_pt targreg;
656	{	636	{
657	if ((store_t) targreg & ALLDATREGS && source->type->scalar & CHAR)	637	if ((store_t) targreg & ALLDATREGS && source->type->scalar & CHAR)
658	targreg = BREG;	638	targreg = BREG;
Lines 685-692 Link Here
685	source->offset.offi = 0; /* indcount was adjusted by outadr */	665	source->offset.offi = 0; /* indcount was adjusted by outadr */
686	}	666	}
687		667
688	PUBLIC void onstack(target)	668	PUBLIC void onstack(register struct symstruct *target)
689	register struct symstruct *target;
690	{	669	{
691	target->storage = LOCAL;	670	target->storage = LOCAL;
692	target->flags = TEMP;	671	target->flags = TEMP;
Lines 696-717 Link Here
696	target->offset.offi = sp;	675	target->offset.offi = sp;
697	}	676	}
698		677
699	PUBLIC void outadr(adr)	678	PUBLIC void outadr(struct symstruct *adr)
700	struct symstruct *adr;
701	{	679	{
702	outnnadr(adr);	680	outnnadr(adr);
703	outnl();	681	outnl();
704	}	682	}
705		683
706	PUBLIC void outcregname(reg)	684	PUBLIC void outcregname(store_pt reg)
707	store_pt reg;
708	{	685	{
709	outcomma();	686	outcomma();
710	outregname(reg);	687	outregname(reg);
711	}	688	}
712		689
713	PRIVATE void outnamoffset(adr)	690	PRIVATE void outnamoffset(struct symstruct *adr)
714	struct symstruct *adr;
715	{	691	{
716	if (adr->flags & LABELLED)	692	if (adr->flags & LABELLED)
717	outlabel(adr->name.label);	693	outlabel(adr->name.label);
Lines 732-746 Link Here
732		708
733	/* print comma, then register name, then newline */	709	/* print comma, then register name, then newline */
734		710
735	PUBLIC void outncregname(reg)	711	PUBLIC void outncregname(store_pt reg)
736	store_pt reg;
737	{	712	{
738	outcomma();	713	outcomma();
739	outnregname(reg);	714	outnregname(reg);
740	}	715	}
741		716
742	PRIVATE void outnnadr(adr)	717	PRIVATE void outnnadr(struct symstruct *adr)
743	struct symstruct *adr;
744	{	718	{
745	bool_t indflag;	719	bool_t indflag;
746		720
Lines 971-978 Link Here
971		945
972	/* print register name, then newline */	946	/* print register name, then newline */
973		947
974	PUBLIC void outnregname(reg)	948	PUBLIC void outnregname(store_pt reg)
975	store_pt reg;
976	{	949	{
977	outregname(reg);	950	outregname(reg);
978	outnl();	951	outnl();
Lines 980-987 Link Here
980		953
981	/* print register name */	954	/* print register name */
982		955
983	PUBLIC void outregname(reg)	956	PUBLIC void outregname(store_pt reg)
984	store_pt reg;
985	{	957	{
986	switch ((store_t) reg)	958	switch ((store_t) reg)
987	{	959	{
Lines 1053-1060 Link Here
1053	#if defined(I8088) && defined(I80386)	1025	#if defined(I8088) && defined(I80386)
1054	/* print register name for short type */	1026	/* print register name for short type */
1055		1027
1056	PUBLIC void outshortregname(reg)	1028	PUBLIC void outshortregname(store_pt reg)
1057	store_pt reg;
1058	{	1029	{
1059	switch ((store_t) reg)	1030	switch ((store_t) reg)
1060	{	1031	{
Lines 1090-1097 Link Here
1090	target must be singly indirect or float or double	1061	target must be singly indirect or float or double
1091	-----------------------------------------------------------------------------*/	1062	-----------------------------------------------------------------------------*/
1092		1063
1093	PUBLIC void pointat(target)	1064	PUBLIC void pointat(struct symstruct *target)
1094	struct symstruct *target;
1095	{	1065	{
1096	if (target->type->scalar & RSCALAR)	1066	if (target->type->scalar & RSCALAR)
1097	(void) f_indirect(target);	1067	(void) f_indirect(target);
Lines 1100-1114 Link Here
1100	target->type = target->type->nexttype;	1070	target->type = target->type->nexttype;
1101	}	1071	}
1102		1072
1103	PUBLIC void poplist(reglist)	1073	PUBLIC void poplist(store_pt reglist)
1104	store_pt reglist;
1105	{	1074	{
1106	if (reglist)	1075	if (reglist)
1107	sp += pushpull(reglist, FALSE);	1076	sp += pushpull(reglist, FALSE);
1108	}	1077	}
1109		1078
1110	PUBLIC void push(source)	1079	PUBLIC void push(struct symstruct *source)
1111	struct symstruct *source;
1112	{	1080	{
1113	store_t reg;	1081	store_t reg;
1114	#ifdef I8088	1082	#ifdef I8088
Lines 1192-1207 Link Here
1192	onstack(source);	1160	onstack(source);
1193	}	1161	}
1194		1162
1195	PUBLIC void pushlist(reglist)	1163	PUBLIC void pushlist(store_pt reglist)
1196	store_pt reglist;
1197	{	1164	{
1198	if ((store_t) reglist)	1165	if ((store_t) reglist)
1199	sp -= pushpull(reglist, TRUE);	1166	sp -= pushpull(reglist, TRUE);
1200	}	1167	}
1201		1168
1202	PRIVATE fastin_pt pushpull(reglist, pushflag)	1169	PRIVATE fastin_pt pushpull(store_pt reglist, bool_pt pushflag)
1203	store_pt reglist;
1204	bool_pt pushflag;
1205	{	1170	{
1206	store_pt lastregbit;	1171	store_pt lastregbit;
1207	void (*ppfunc) P((void));	1172	void (*ppfunc) P((void));
Lines 1290-1297 Link Here
1290	return bytespushed;	1255	return bytespushed;
1291	}	1256	}
1292		1257
1293	PUBLIC void pushreg(reg)	1258	PUBLIC void pushreg(store_pt reg)
1294	store_pt reg;
1295	{	1259	{
1296	outpshs();	1260	outpshs();
1297	outtab();	1261	outtab();
Lines 1299-1307 Link Here
1299	sp -= pshregsize;	1263	sp -= pshregsize;
1300	}	1264	}
1301		1265
1302	PUBLIC void storereg(sourcereg, target)	1266	PUBLIC void storereg(store_pt sourcereg, struct symstruct *target)
1303	store_pt sourcereg;
1304	struct symstruct *target;
1305	{	1267	{
1306	store_pt targreg;	1268	store_pt targreg;
1307		1269
Lines 1373-1381 Link Here
1373	structure.element	1335	structure.element
1374	-----------------------------------------------------------------------------*/	1336	-----------------------------------------------------------------------------*/
1375		1337
1376	PUBLIC void struc(source, target)	1338	PUBLIC void struc(struct symstruct source, struct symstruct target)
1377	struct symstruct *source;
1378	struct symstruct *target;
1379	{	1339	{
1380	address(target);	1340	address(target);
1381	if (source->offset.offi != 0 \|\| source->level == OFFKLUDGELEVEL)	1341	if (source->offset.offi != 0 \|\| source->level == OFFKLUDGELEVEL)
Lines 1393-1401 Link Here
1393	}	1353	}
1394	}	1354	}
1395		1355
1396	PUBLIC void transfer(source, targreg)	1356	PUBLIC void transfer(struct symstruct *source, store_pt targreg)
1397	struct symstruct *source;
1398	store_pt targreg;
1399	{	1357	{
1400	regtransfer(source->storage, targreg);	1358	regtransfer(source->storage, targreg);
1401	source->storage = targreg;	1359	source->storage = targreg;

Lines 54-63 Link Here

(-)a/bcc/glogcode.c (-57 / +31 lines)
54	FORWARD void testcond P((struct nodestruct *exp, label_no truelab,	54	FORWARD void testcond P((struct nodestruct *exp, label_no truelab,
55	label_no falselab, bool_pt nojump));	55	label_no falselab, bool_pt nojump));
56		56
57	PUBLIC void cmp(source, target, pcondtrue)	57	PUBLIC void cmp(struct symstruct source, struct symstruct target, ccode_t *pcondtrue)
58	struct symstruct *source;
59	struct symstruct *target;
60	ccode_t *pcondtrue;
61	{	58	{
62	label_no falselab;	59	label_no falselab;
63		60
Lines 93-102 Link Here
93	loadlogical(target, falselab);	90	loadlogical(target, falselab);
94	}	91	}
95		92
96	PRIVATE void cmplocal(source, target, pcondtrue)	93	PRIVATE void cmplocal(struct symstruct source, struct symstruct target, ccode_t *pcondtrue)
97	struct symstruct *source;
98	struct symstruct *target;
99	ccode_t *pcondtrue;
100	{	94	{
101	scalar_t sscalar;	95	scalar_t sscalar;
102	scalar_t tempscalar;	96	scalar_t tempscalar;
Lines 189-196 Link Here
189		183
190	#ifdef MC6809	184	#ifdef MC6809
191		185
192	PRIVATE void cmporsub(target)	186	PRIVATE void cmporsub(struct symstruct *target)
193	struct symstruct *target;
194	{	187	{
195	if (target->storage & ALLDATREGS)	188	if (target->storage & ALLDATREGS)
196	outsub();	189	outsub();
Lines 202-211 Link Here
202	}	195	}
203	}	196	}
204		197
205	PRIVATE bool_pt cmpsmallconst(intconst, target, pcondtrue)	198	PRIVATE bool_pt cmpsmallconst(value_t intconst, struct symstruct target, ccode_t pcondtrue)
206	value_t intconst;
207	struct symstruct *target;
208	ccode_t *pcondtrue;
209	{	199	{
210	store_pt targreg;	200	store_pt targreg;
211		201
Lines 228-238 Link Here
228		218
229	#endif	219	#endif
230		220
231	PRIVATE void comparecond(exp, truelab, falselab, nojump)	221	PRIVATE void comparecond(struct nodestruct *exp,
232	struct nodestruct *exp;	222	label_no truelab,
233	label_no truelab;	223	label_no falselab,
234	label_no falselab;	224	bool_pt nojump /* NB if nonzero, is ~0 so complement is 0 */)
235	bool_pt nojump; /* NB if nonzero, is ~0 so complement is 0 */
236	{	225	{
237	ccode_t condtrue;	226	ccode_t condtrue;
238	store_t regmark;	227	store_t regmark;
Lines 275-282 Link Here
275	lbranch(condtrue, truelab);	264	lbranch(condtrue, truelab);
276	}	265	}
277		266
278	PUBLIC void condop(exp)	267	PUBLIC void condop(struct nodestruct *exp)
279	struct nodestruct *exp;
280	{	268	{
281	label_no exitlab;	269	label_no exitlab;
282	label_no falselab;	270	label_no falselab;
Lines 316-326 Link Here
316	exp->left.symptr = truesym;	304	exp->left.symptr = truesym;
317	}	305	}
318		306
319	PRIVATE void jumpcond(exp, truelab, falselab, nojump)	307	PRIVATE void jumpcond(struct nodestruct *exp,
320	struct nodestruct *exp;	308	label_no truelab,
321	label_no truelab;	309	label_no falselab,
322	label_no falselab;	310	bool_pt nojump /* NB if nonzero, is ~0 so complement is 0 */)
323	bool_pt nojump; /* NB if nonzero, is ~0 so complement is 0 */
324	{	311	{
325	switch (exp->tag)	312	switch (exp->tag)
326	{	313	{
Lines 347-355 Link Here
347	}	334	}
348	}	335	}
349		336
350	PUBLIC void jumpfalse(exp, label)	337	PUBLIC void jumpfalse(struct nodestruct *exp, label_no label)
351	struct nodestruct *exp;
352	label_no label;
353	{	338	{
354	label_no truelab;	339	label_no truelab;
355		340
Lines 357-365 Link Here
357	deflabel(truelab);	342	deflabel(truelab);
358	}	343	}
359		344
360	PUBLIC void jumptrue(exp, label)	345	PUBLIC void jumptrue(struct nodestruct *exp, label_no label)
361	struct nodestruct *exp;
362	label_no label;
363	{	346	{
364	label_no falselab;	347	label_no falselab;
365		348
Lines 367-375 Link Here
367	deflabel(falselab);	350	deflabel(falselab);
368	}	351	}
369		352
370	PRIVATE void loadlogical(source, falselab)	353	PRIVATE void loadlogical(struct symstruct *source, label_no falselab)
371	struct symstruct *source;
372	label_no falselab;
373	{	354	{
374	label_no exitlab;	355	label_no exitlab;
375	struct symstruct *target;	356	struct symstruct *target;
Lines 386-396 Link Here
386	outnlabel(exitlab);	367	outnlabel(exitlab);
387	}	368	}
388		369
389	PRIVATE void logandcond(exp, truelab, falselab, nojump)	370	PRIVATE void logandcond(struct nodestruct *exp,
390	struct nodestruct *exp;	371	label_no truelab,
391	label_no truelab;	372	label_no falselab,
392	label_no falselab;	373	bool_pt nojump /* NB if nonzero, is ~0 so complement is 0 */)
393	bool_pt nojump; /* NB if nonzero, is ~0 so complement is 0 */
394	{	374	{
395	label_no andlab;	375	label_no andlab;
396		376
Lines 400-407 Link Here
400	jumpcond(exp->right, truelab, falselab, nojump);	380	jumpcond(exp->right, truelab, falselab, nojump);
401	}	381	}
402		382
403	PUBLIC void logop(exp)	383	PUBLIC void logop(struct nodestruct *exp)
404	struct nodestruct *exp;
405	{	384	{
406	label_no falselab;	385	label_no falselab;
407	struct symstruct *target;	386	struct symstruct *target;
Lines 416-426 Link Here
416	exp->left.symptr = target;	395	exp->left.symptr = target;
417	}	396	}
418		397
419	PRIVATE void logorcond(exp, truelab, falselab, nojump)	398	PRIVATE void logorcond(struct nodestruct *exp,
420	struct nodestruct *exp;	399	label_no truelab,
421	label_no truelab;	400	label_no falselab,
422	label_no falselab;	401	bool_pt nojump /* NB if nonzero, is ~0 so complement is 0 */)
423	bool_pt nojump; /* NB if nonzero, is ~0 so complement is 0 */
424	{	402	{
425	label_no orlab;	403	label_no orlab;
426		404
Lines 430-437 Link Here
430	jumpcond(exp->right, truelab, falselab, nojump);	408	jumpcond(exp->right, truelab, falselab, nojump);
431	}	409	}
432		410
433	PRIVATE void reduceconst(source)	411	PRIVATE void reduceconst(struct symstruct *source)
434	struct symstruct *source;
435	{	412	{
436	if (source->storage == CONSTANT && ischarconst(source->offset.offv) &&	413	if (source->storage == CONSTANT && ischarconst(source->offset.offv) &&
437	(source->type->scalar & (CHAR \| SHORT \| INT \| DLONG)) != DLONG)	414	(source->type->scalar & (CHAR \| SHORT \| INT \| DLONG)) != DLONG)
Lines 443-451 Link Here
443	}	420	}
444	}	421	}
445		422
446	PRIVATE void test(target, pcondtrue)	423	PRIVATE void test(struct symstruct target, ccode_t pcondtrue)
447	struct symstruct *target;
448	ccode_t *pcondtrue;
449	{	424	{
450	#ifdef I8088	425	#ifdef I8088
451	store_t targreg;	426	store_t targreg;
Lines 530-540 Link Here
530		505
531	/* test expression and jump depending on NE/EQ */	506	/* test expression and jump depending on NE/EQ */
532		507
533	PRIVATE void testcond(exp, truelab, falselab, nojump)	508	PRIVATE void testcond(struct nodestruct *exp,
534	struct nodestruct *exp;	509	label_no truelab,
535	label_no truelab;	510	label_no falselab,
536	label_no falselab;	511	bool_pt nojump /* NB if nonzero, is ~0 so complement is 0 */)
537	bool_pt nojump; /* NB if nonzero, is ~0 so complement is 0 */
538	{	512	{
539	ccode_t condtrue;	513	ccode_t condtrue;
540	struct symstruct *source;	514	struct symstruct *source;

Lines 14-22 Link Here

(-)a/bcc/hardop.c (-23 / +8 lines)
14		14
15	FORWARD void sub1 P((struct symstruct source, struct symstruct target));	15	FORWARD void sub1 P((struct symstruct source, struct symstruct target));
16		16
17	PUBLIC void add(source, target)	17	PUBLIC void add(struct symstruct source, struct symstruct target)
18	struct symstruct *source;
19	struct symstruct *target;
20	{	18	{
21	scalar_t sscalar;	19	scalar_t sscalar;
22		20
Lines 60-68 Link Here
60	target->type = iscalartotype(target->type->scalar \| sscalar);	58	target->type = iscalartotype(target->type->scalar \| sscalar);
61	}	59	}
62		60
63	PUBLIC void incdec(op, source)	61	PUBLIC void incdec(op_pt op, struct symstruct *source)
64	op_pt op;
65	struct symstruct *source;
66	{	62	{
67	offset_T bump;	63	offset_T bump;
68	bool_t postflag;	64	bool_t postflag;
Lines 182-189 Link Here
182	#endif	178	#endif
183	}	179	}
184		180
185	PUBLIC void neg(target)	181	PUBLIC void neg(struct symstruct *target)
186	struct symstruct *target;
187	{	182	{
188	scalar_t scalar;	183	scalar_t scalar;
189	struct symstruct *source;	184	struct symstruct *source;
Lines 213-220 Link Here
213	}	208	}
214	}	209	}
215		210
216	PUBLIC void not(target)	211	PUBLIC void not(struct symstruct *target)
217	struct symstruct *target;
218	{	212	{
219	if (target->type->scalar & DLONG)	213	if (target->type->scalar & DLONG)
220	long1op(NOTOP, target);	214	long1op(NOTOP, target);
Lines 228-237 Link Here
228		222
229	/* 1-byte ops like AND acting on integers (not both constant) */	223	/* 1-byte ops like AND acting on integers (not both constant) */
230		224
231	PUBLIC void op1(op, source, target)	225	PUBLIC void op1(op_pt op, struct symstruct source, struct symstruct target)
232	op_pt op;
233	struct symstruct *source;
234	struct symstruct *target;
235	{	226	{
236	char *opstr;	227	char *opstr;
237	#ifdef OP1	228	#ifdef OP1
Lines 424-432 Link Here
424	}	415	}
425	}	416	}
426		417
427	PUBLIC void ptrsub(source, target)	418	PUBLIC void ptrsub(struct symstruct source, struct symstruct target)
428	struct symstruct *source;
429	struct symstruct *target;
430	{	419	{
431	label_no exitlab;	420	label_no exitlab;
432	uoffset_T factor;	421	uoffset_T factor;
Lines 461-469 Link Here
461	}	450	}
462	}	451	}
463		452
464	PUBLIC void sub(source, target)	453	PUBLIC void sub(struct symstruct source, struct symstruct target)
465	struct symstruct *source;
466	struct symstruct *target;
467	{	454	{
468	scalar_t sscalar;	455	scalar_t sscalar;
469		456
Lines 489-497 Link Here
489	target->type = iscalartotype(target->type->scalar \| sscalar);	476	target->type = iscalartotype(target->type->scalar \| sscalar);
490	}	477	}
491		478
492	PRIVATE void sub1(source, target)	479	PRIVATE void sub1(struct symstruct source, struct symstruct target)
493	struct symstruct *source;
494	struct symstruct *target;
495	{	480	{
496	if (source->storage == CONSTANT)	481	if (source->storage == CONSTANT)
497	source->type = itype;	482	source->type = itype;

Lines 153-160 Link Here

(-)a/bcc/input.c (-8 / +3 lines)
153	}	153	}
154		154
155	#ifdef BUILTIN_CPP	155	#ifdef BUILTIN_CPP
156	PRIVATE void definefile(fname)	156	PRIVATE void definefile(char *fname)
157	char *fname;
158	{	157	{
159	char *def;	158	char *def;
160		159
Lines 366-374 Link Here
366		365
367	/* initialise current input file */	366	/* initialise current input file */
368		367
369	PRIVATE void inputinit(fname, fd)	368	PRIVATE void inputinit(char *fname, fd_t fd)
370	char *fname;
371	fd_t fd;
372	{	369	{
373	register struct fbufstruct *newinputbuf;	370	register struct fbufstruct *newinputbuf;
374		371
Lines 478-486 Link Here
478		475
479	/* open input and output files and get options */	476	/* open input and output files and get options */
480		477
481	PUBLIC void openio(argc, argv)	478	PUBLIC void openio(int argc, char *argv[])
482	int argc;
483	char *argv[];
484	{	479	{
485	register char *arg;	480	register char *arg;
486	int argn;	481	int argn;

Lines 70-79 Link Here

(-)a/bcc/label.c (-25 / +10 lines)
70		70
71	/* add label to circular list */	71	/* add label to circular list */
72		72
73	PRIVATE void addlabel(cond, label, patch)	73	PRIVATE void addlabel(ccode_pt cond, label_no label, char *patch)
74	ccode_pt cond;
75	label_no label;
76	char *patch;
77	{	74	{
78	register struct labdatstruct *labptr;	75	register struct labdatstruct *labptr;
79		76
Lines 128-136 Link Here
128		125
129	/* clear out labels no longer in buffer */	126	/* clear out labels no longer in buffer */
130		127
131	PUBLIC void clearlabels(patchbuf, patchtop)	128	PUBLIC void clearlabels(char patchbuf, char patchtop)
132	char *patchbuf;
133	char *patchtop;
134	{	129	{
135	register struct labdatstruct *labptr;	130	register struct labdatstruct *labptr;
136	struct labdatstruct *labtop;	131	struct labdatstruct *labtop;
Lines 166-173 Link Here
166		161
167	/* define location of label and backpatch references to it */	162	/* define location of label and backpatch references to it */
168		163
169	PUBLIC void deflabel(label)	164	PUBLIC void deflabel(label_no label)
170	label_no label;
171	{	165	{
172	char *cnameptr;	166	char *cnameptr;
173	struct labdatstruct *labmin;	167	struct labdatstruct *labmin;
Lines 240-247 Link Here
240	addlabel((ccode_pt) 0, label, (char *) NULL);	234	addlabel((ccode_pt) 0, label, (char *) NULL);
241	}	235	}
242		236
243	PRIVATE struct labdatstruct *findlabel(label)	237	PRIVATE struct labdatstruct *findlabel(label_no label)
244	label_no label;
245	{	238	{
246	register struct labdatstruct *labptr;	239	register struct labdatstruct *labptr;
247	struct labdatstruct *labtop;	240	struct labdatstruct *labtop;
Lines 273-289 Link Here
273		266
274	/* jump to label */	267	/* jump to label */
275		268
276	PUBLIC void jump(label)	269	PUBLIC void jump(label_no label)
277	label_no label;
278	{	270	{
279	lbranch(RA, label);	271	lbranch(RA, label);
280	}	272	}
281		273
282	/* long branch on condition to label */	274	/* long branch on condition to label */
283		275
284	PUBLIC void lbranch(cond, label)	276	PUBLIC void lbranch(ccode_pt cond, label_no label)
285	ccode_pt cond;
286	label_no label;
287	{	277	{
288	#ifdef I8088	278	#ifdef I8088
289	char *cnameptr;	279	char *cnameptr;
Lines 361-368 Link Here
361		351
362	/* print condition code name */	352	/* print condition code name */
363		353
364	PUBLIC void outcond(cond)	354	PUBLIC void outcond(ccode_pt cond)
365	ccode_pt cond;
366	{	355	{
367	char *cnameptr;	356	char *cnameptr;
368		357
Lines 375-382 Link Here
375		364
376	/* print label */	365	/* print label */
377		366
378	PUBLIC void outlabel(label)	367	PUBLIC void outlabel(label_no label)
379	label_no label;
380	{	368	{
381	outbyte(LABELSTARTCHAR);	369	outbyte(LABELSTARTCHAR);
382	outhexdigs((uoffset_T) label);	370	outhexdigs((uoffset_T) label);
Lines 384-391 Link Here
384		372
385	/* print label and newline */	373	/* print label and newline */
386		374
387	PUBLIC void outnlabel(label)	375	PUBLIC void outnlabel(label_no label)
388	label_no label;
389	{	376	{
390	outlabel(label);	377	outlabel(label);
391	#ifdef LABELENDCHAR	378	#ifdef LABELENDCHAR
Lines 397-405 Link Here
397		384
398	/* short branch on condition to label */	385	/* short branch on condition to label */
399		386
400	PUBLIC void sbranch(cond, label)	387	PUBLIC void sbranch(ccode_pt cond, label_no label)
401	ccode_pt cond;
402	label_no label;
403	{	388	{
404	#ifdef I8088	389	#ifdef I8088
405	char *cnameptr;	390	char *cnameptr;

Lines 32-39 Link Here

(-)a/bcc/loadexp.c (-5 / +2 lines)
32	return 1;	32	return 1;
33	}	33	}
34		34
35	PUBLIC void initexpression(type)	35	PUBLIC void initexpression(struct typestruct *type)
36	struct typestruct *type;
37	{	36	{
38	struct nodestruct *etmark;	37	struct nodestruct *etmark;
39	struct nodestruct *exp;	38	struct nodestruct *exp;
Lines 142-150 Link Here
142	exprptr = exprmark;	141	exprptr = exprmark;
143	}	142	}
144		143
145	PUBLIC struct typestruct *loadexpression(targreg, targtype)	144	PUBLIC struct typestruct loadexpression(store_pt targreg, struct typestruct targtype)
146	store_pt targreg;
147	struct typestruct *targtype;
148	{	145	{
149	struct nodestruct *etmark;	146	struct nodestruct *etmark;
150	struct nodestruct *exp;	147	struct nodestruct *exp;

Lines 18-27 Link Here

(-)a/bcc/longop.c (-7 / +2 lines)
18	or singly indirect (local, global, or from an index reg)	18	or singly indirect (local, global, or from an index reg)
19	-----------------------------------------------------------------------------*/	19	-----------------------------------------------------------------------------*/
20		20
21	PUBLIC void longop(op, source, target)	21	PUBLIC void longop(op_pt op, struct symstruct source, struct symstruct target)
22	op_pt op;
23	struct symstruct *source;
24	struct symstruct *target;
25	{	22	{
26	store_pt reglist;	23	store_pt reglist;
27	store_t regmark;	24	store_t regmark;
Lines 138-146 Link Here
138	or singly indirect (local, global, or from an index reg)	135	or singly indirect (local, global, or from an index reg)
139	-----------------------------------------------------------------------------*/	136	-----------------------------------------------------------------------------*/
140		137
141	PUBLIC void long1op(op, target)	138	PUBLIC void long1op(op_pt op, struct symstruct *target)
142	op_pt op;
143	struct symstruct *target;
144	{	139	{
145	pushlist(reguse & OPREG);	140	pushlist(reguse & OPREG);
146	load(target, OPREG);	141	load(target, OPREG);

Lines 37-44 Link Here

(-)a/bcc/output.c (-58 / +27 lines)
37	#endif	37	#endif
38	#endif	38	#endif
39		39
40	PUBLIC void bugerror(message)	40	PUBLIC void bugerror(char *message)
41	char *message;
42	{	41	{
43	error2error("compiler bug? - ", message);	42	error2error("compiler bug? - ", message);
44	}	43	}
Lines 60-76 Link Here
60		59
61	/* error handler */	60	/* error handler */
62		61
63	PUBLIC void error(message)	62	PUBLIC void error(char *message)
64	char *message;
65	{	63	{
66	error2error(message, "");	64	error2error(message, "");
67	}	65	}
68		66
69	/* error handler - concatenate 2 messages */	67	/* error handler - concatenate 2 messages */
70		68
71	PUBLIC void error2error(message1, message2)	69	PUBLIC void error2error(char message1, char message2)
72	char *message1;
73	char *message2;
74	{	70	{
75	char *warning;	71	char *warning;
76		72
Lines 147-154 Link Here
147		143
148	/* fatal error, exit early */	144	/* fatal error, exit early */
149		145
150	PUBLIC void fatalerror(message)	146	PUBLIC void fatalerror(char *message)
151	char *message;
152	{	147	{
153	error(message);	148	error(message);
154	finishup();	149	finishup();
Lines 233-247 Link Here
233	output = 1; /* standard output */	228	output = 1; /* standard output */
234	}	229	}
235		230
236	PUBLIC void limiterror(message)	231	PUBLIC void limiterror(char *message)
237	char *message;
238	{	232	{
239	error2error("compiler limit exceeded - ", message);	233	error2error("compiler limit exceeded - ", message);
240	finishup();	234	finishup();
241	}	235	}
242		236
243	PUBLIC void openout(oname)	237	PUBLIC void openout(char *oname)
244	char *oname;
245	{	238	{
246	if (output != 1)	239	if (output != 1)
247	fatalerror("more than one output file");	240	fatalerror("more than one output file");
Lines 254-261 Link Here
254		247
255	/* print character */	248	/* print character */
256		249
257	PUBLIC void outbyte(c)	250	PUBLIC void outbyte(int c)
258	int c;
259	{	251	{
260	#if C_CODE \|\| __AS09__ + __AS386_16__ + __AS386_32__ != 1	252	#if C_CODE \|\| __AS09__ + __AS386_16__ + __AS386_32__ != 1
261	register char *outp;	253	register char *outp;
Lines 343-352 Link Here
343		335
344	/* print line number in format ("# %u \"%s\"%s", nr, fname, str) */	336	/* print line number in format ("# %u \"%s\"%s", nr, fname, str) */
345		337
346	PUBLIC void outcpplinenumber(nr, fname, str)	338	PUBLIC void outcpplinenumber(unsigned nr, char fname, char str)
347	unsigned nr;
348	char *fname;
349	char *str;
350	{	339	{
351	outstr("# ");	340	outstr("# ");
352	outudec(nr);	341	outudec(nr);
Lines 358-365 Link Here
358		347
359	/* print unsigned offset, hex format */	348	/* print unsigned offset, hex format */
360		349
361	PUBLIC void outhex(num)	350	PUBLIC void outhex(uoffset_T num)
362	uoffset_T num;
363	{	351	{
364	#ifdef HEXSTARTCHAR	352	#ifdef HEXSTARTCHAR
365	if (num >= 10)	353	if (num >= 10)
Lines 374-381 Link Here
374		362
375	/* print unsigned offset, hex format with digits only (no hex designator) */	363	/* print unsigned offset, hex format with digits only (no hex designator) */
376		364
377	PUBLIC void outhexdigs(num)	365	PUBLIC void outhexdigs(register uoffset_T num)
378	register uoffset_T num;
379	{	366	{
380	if (num >= 0x10)	367	if (num >= 0x10)
381	{	368	{
Lines 387-394 Link Here
387		374
388	/* print string terminated by EOL */	375	/* print string terminated by EOL */
389		376
390	PUBLIC void outline(s)	377	PUBLIC void outline(char *s)
391	char *s;
392	{	378	{
393	register char *outp;	379	register char *outp;
394	register char *rs;	380	register char *rs;
Lines 426-433 Link Here
426		412
427	/* print character, then newline */	413	/* print character, then newline */
428		414
429	PUBLIC void outnbyte(byte)	415	PUBLIC void outnbyte(int byte)
430	int byte;
431	{	416	{
432	outbyte(byte);	417	outbyte(byte);
433	outnl();	418	outnl();
Lines 435-442 Link Here
435		420
436	/* print unsigned offset, hex format, then newline */	421	/* print unsigned offset, hex format, then newline */
437		422
438	PUBLIC void outnhex(num)	423	PUBLIC void outnhex(uoffset_T num)
439	uoffset_T num;
440	{	424	{
441	outhex(num);	425	outhex(num);
442	outnl();	426	outnl();
Lines 457-464 Link Here
457		441
458	/* print opcode and newline, bump lc by 1 */	442	/* print opcode and newline, bump lc by 1 */
459		443
460	PUBLIC void outnop1str(s)	444	PUBLIC void outnop1str(char *s)
461	char *s;
462	{	445	{
463	opcodeleadin();	446	opcodeleadin();
464	outstr(s);	447	outstr(s);
Lines 468-475 Link Here
468		451
469	/* print opcode and newline, bump lc by 2 */	452	/* print opcode and newline, bump lc by 2 */
470		453
471	PUBLIC void outnop2str(s)	454	PUBLIC void outnop2str(char *s)
472	char *s;
473	{	455	{
474	opcodeleadin();	456	opcodeleadin();
475	outstr(s);	457	outstr(s);
Lines 479-486 Link Here
479		461
480	/* print string, then newline */	462	/* print string, then newline */
481		463
482	PUBLIC void outnstr(s)	464	PUBLIC void outnstr(char *s)
483	char *s;
484	{	465	{
485	outstr(s);	466	outstr(s);
486	outnl();	467	outnl();
Lines 488-495 Link Here
488		469
489	/* print opcode */	470	/* print opcode */
490		471
491	PUBLIC void outop0str(s)	472	PUBLIC void outop0str(char *s)
492	char *s;
493	{	473	{
494	opcodeleadin();	474	opcodeleadin();
495	outstr(s);	475	outstr(s);
Lines 497-504 Link Here
497		477
498	/* print opcode, bump lc by 1 */	478	/* print opcode, bump lc by 1 */
499		479
500	PUBLIC void outop1str(s)	480	PUBLIC void outop1str(char *s)
501	char *s;
502	{	481	{
503	opcodeleadin();	482	opcodeleadin();
504	outstr(s);	483	outstr(s);
Lines 507-514 Link Here
507		486
508	/* print opcode, bump lc by 2 */	487	/* print opcode, bump lc by 2 */
509		488
510	PUBLIC void outop2str(s)	489	PUBLIC void outop2str(char *s)
511	char *s;
512	{	490	{
513	opcodeleadin();	491	opcodeleadin();
514	outstr(s);	492	outstr(s);
Lines 517-524 Link Here
517		495
518	/* print opcode, bump lc by 3 */	496	/* print opcode, bump lc by 3 */
519		497
520	PUBLIC void outop3str(s)	498	PUBLIC void outop3str(char *s)
521	char *s;
522	{	499	{
523	opcodeleadin();	500	opcodeleadin();
524	outstr(s);	501	outstr(s);
Lines 534-541 Link Here
534		511
535	/* print signed offset, hex format */	512	/* print signed offset, hex format */
536		513
537	PUBLIC void outshex(num)	514	PUBLIC void outshex(offset_T num)
538	offset_T num;
539	{	515	{
540	if (num >= -(maxoffsetto + 1))	516	if (num >= -(maxoffsetto + 1))
541	{	517	{
Lines 547-554 Link Here
547		523
548	/* print string */	524	/* print string */
549		525
550	PUBLIC void outstr(s)	526	PUBLIC void outstr(char *s)
551	char *s;
552	{	527	{
553	#if C_CODE \|\| __AS09__ + __AS386_16__ + __AS386_32__ != 1	528	#if C_CODE \|\| __AS09__ + __AS386_16__ + __AS386_32__ != 1
554	register char *outp;	529	register char *outp;
Lines 725-732 Link Here
725		700
726	/* print unsigned, decimal format */	701	/* print unsigned, decimal format */
727		702
728	PUBLIC void outudec(num)	703	PUBLIC void outudec(unsigned num)
729	unsigned num;
730	{	704	{
731	char str[10 + 1];	705	char str[10 + 1];
732		706
Lines 739-746 Link Here
739		713
740	/* print unsigned value, hex format (like outhex except value_t is larger) */	714	/* print unsigned value, hex format (like outhex except value_t is larger) */
741		715
742	PUBLIC void outuvalue(num)	716	PUBLIC void outuvalue(uvalue_t num)
743	uvalue_t num;
744	{	717	{
745	#ifdef HEXSTARTCHAR	718	#ifdef HEXSTARTCHAR
746	if (num >= 10)	719	if (num >= 10)
Lines 755-762 Link Here
755		728
756	/* print unsigned value, hex format with digits only (no hex designator) */	729	/* print unsigned value, hex format with digits only (no hex designator) */
757		730
758	PRIVATE void outvaldigs(num)	731	PRIVATE void outvaldigs(register uvalue_t num)
759	register uvalue_t num;
760	{	732	{
761	if (num >= 0x10)	733	if (num >= 0x10)
762	{	734	{
Lines 768-775 Link Here
768		740
769	/* print signed value, hex format (like outshex except value_t is larger) */	741	/* print signed value, hex format (like outshex except value_t is larger) */
770		742
771	PUBLIC void outvalue(num)	743	PUBLIC void outvalue(register value_t num)
772	register value_t num;
773	{	744	{
774	if (num < 0)	745	if (num < 0)
775	{	746	{
Lines 784-792 Link Here
784		755
785	/* push decimal digits of an unsigned onto a stack of chars */	756	/* push decimal digits of an unsigned onto a stack of chars */
786		757
787	PUBLIC char *pushudec(s, num)	758	PUBLIC char pushudec(register char s, register unsigned num)
788	register char *s;
789	register unsigned num;
790	{	759	{
791	register unsigned reduction;	760	register unsigned reduction;
792		761

Lines 477-485 Link Here

(-)a/bcc/preproc.c (-9 / +5 lines)
477	symptr->prev = hashptr;	477	symptr->prev = hashptr;
478	}	478	}
479		479
480	PRIVATE void defineorundefinestring(str, defineflag)	480	PRIVATE void defineorundefinestring(char str / "name[=def]" or "name def" */,
481	char str; / "name[=def]" or "name def" */	481	bool_pt defineflag)
482	bool_pt defineflag;
483	{	482	{
484	char *fakeline;	483	char *fakeline;
485	unsigned len;	484	unsigned len;
Lines 531-538 Link Here
531	ourfree(fakeline - 3);	530	ourfree(fakeline - 3);
532	}	531	}
533		532
534	PUBLIC void definestring(str)	533	PUBLIC void definestring(char str / "name[=def]" or "name def" */)
535	char str; / "name[=def]" or "name def" */
536	{	534	{
537	defineorundefinestring(str, TRUE);	535	defineorundefinestring(str, TRUE);
538	}	536	}
Lines 873-880 Link Here
873		871
874	/* ifcontrol - process #if, #ifdef, #ifndef */	872	/* ifcontrol - process #if, #ifdef, #ifndef */
875		873
876	PRIVATE void ifcontrol(ifcase)	874	PRIVATE void ifcontrol(sym_pt ifcase)
877	sym_pt ifcase;
878	{	875	{
879	bool_t iftrue;	876	bool_t iftrue;
880	struct symstruct *symptr;	877	struct symstruct *symptr;
Lines 1073-1080 Link Here
1073	delsym(symptr);	1070	delsym(symptr);
1074	}	1071	}
1075		1072
1076	PUBLIC void undefinestring(str)	1073	PUBLIC void undefinestring(char *str)
1077	char *str;
1078	{	1074	{
1079	defineorundefinestring(str, FALSE);	1075	defineorundefinestring(str, FALSE);
1080	}	1076	}

Lines 10-18 Link Here

(-)a/bcc/preserve.c (-21 / +8 lines)
10		10
11	/* change stack ptr without changing condition codes */	11	/* change stack ptr without changing condition codes */
12		12
13	PUBLIC void changesp(newsp, absflag)	13	PUBLIC void changesp(offset_T newsp, bool_pt absflag)
14	offset_T newsp;
15	bool_pt absflag;
16	{	14	{
17	if (newsp != sp \|\| ((bool_t) absflag && switchnow != NULL))	15	if (newsp != sp \|\| ((bool_t) absflag && switchnow != NULL))
18	{	16	{
Lines 56-64 Link Here
56		54
57	/* load source to any while preserving target */	55	/* load source to any while preserving target */
58		56
59	PUBLIC void loadpres(source, target)	57	PUBLIC void loadpres(struct symstruct source, struct symstruct target)
60	struct symstruct *source;
61	struct symstruct *target;
62	{	58	{
63	store_t regmark;	59	store_t regmark;
64		60
Lines 83-90 Link Here
83		79
84	/* change stack ptr */	80	/* change stack ptr */
85		81
86	PUBLIC void modstk(newsp)	82	PUBLIC void modstk(offset_T newsp)
87	offset_T newsp;
88	{	83	{
89	if (newsp != sp)	84	if (newsp != sp)
90	{	85	{
Lines 108-116 Link Here
108		103
109	/* preserve target without changing source */	104	/* preserve target without changing source */
110		105
111	PUBLIC void pres2(source, target)	106	PUBLIC void pres2(struct symstruct source, struct symstruct target)
112	struct symstruct *source;
113	struct symstruct *target;
114	{	107	{
115	if (target->storage & allregs)	108	if (target->storage & allregs)
116	{	109	{
Lines 130-137 Link Here
130		123
131	/* preserve source */	124	/* preserve source */
132		125
133	PUBLIC void preserve(source)	126	PUBLIC void preserve(struct symstruct *source)
134	struct symstruct *source;
135	{	127	{
136	if (source->storage & allregs)	128	if (source->storage & allregs)
137	{	129	{
Lines 145-153 Link Here
145		137
146	/* preserve lvalue target without changing source or target */	138	/* preserve lvalue target without changing source or target */
147		139
148	PUBLIC store_pt preslval(source, target)	140	PUBLIC store_pt preslval(struct symstruct source, struct symstruct target)
149	struct symstruct *source;
150	struct symstruct *target;
151	{	141	{
152	store_pt regpushed;	142	store_pt regpushed;
153		143
Lines 164-171 Link Here
164	return regpushed;	154	return regpushed;
165	}	155	}
166		156
167	PUBLIC void recovlist(reglist)	157	PUBLIC void recovlist(store_pt reglist)
168	store_pt reglist;
169	{	158	{
170	poplist(reglist);	159	poplist(reglist);
171	reguse \|= (store_t) reglist;	160	reguse \|= (store_t) reglist;
Lines 181-189 Link Here
181	/* CONSTANT, BREG, DREG, XREG = INDREG0, UREG = INDREG1, YREG = INDREG2 */	170	/* CONSTANT, BREG, DREG, XREG = INDREG0, UREG = INDREG1, YREG = INDREG2 */
182	#endif	171	#endif
183		172
184	PUBLIC void savereturn(savelist, saveoffset)	173	PUBLIC void savereturn(store_pt savelist, offset_T saveoffset)
185	store_pt savelist;
186	offset_T saveoffset;
187	{	174	{
188	store_t reg;	175	store_t reg;
189	smalin_t *regoffptr;	176	smalin_t *regoffptr;

Lines 141-148 Link Here

(-)a/bcc/scan.c (-4 / +2 lines)
141	}	141	}
142	}	142	}
143		143
144	PUBLIC void cppscan(asm_only)	144	PUBLIC void cppscan(int asm_only)
145	int asm_only;
146	{	145	{
147	int start_of_line = 1;	146	int start_of_line = 1;
148	#ifndef ASM_BARE	147	#ifndef ASM_BARE
Lines 290-297 Link Here
290	}	289	}
291	}	290	}
292		291
293	PUBLIC void eofin(message)	292	PUBLIC void eofin(char *message)
294	char *message;
295	{	293	{
296	error2error("end of file in ", message);	294	error2error("end of file in ", message);
297	}	295	}

Lines 75-82 Link Here

(-)a/bcc/state.c (-11 / +5 lines)
75		75
76	/* --- utility routines --- */	76	/* --- utility routines --- */
77		77
78	PRIVATE void addloop(newloop)	78	PRIVATE void addloop(struct loopstruct *newloop)
79	struct loopstruct *newloop;
80	{	79	{
81	newloop->breaklab = getlabel();	80	newloop->breaklab = getlabel();
82	newloop->contlab = getlabel();	81	newloop->contlab = getlabel();
Lines 101-108 Link Here
101	loopnow = loopnow->prevloop;	100	loopnow = loopnow->prevloop;
102	}	101	}
103		102
104	PRIVATE void evalexpression(exp)	103	PRIVATE void evalexpression(struct nodestruct *exp)
105	struct nodestruct *exp;
106	{	104	{
107	offset_T spmark;	105	offset_T spmark;
108		106
Lines 123-139 Link Here
123	exprptr = exprmark;	121	exprptr = exprmark;
124	}	122	}
125		123
126	PRIVATE bool_pt isforever(exp)	124	PRIVATE bool_pt isforever(register struct nodestruct *exp)
127	register struct nodestruct *exp;
128	{	125	{
129	return exp == NULL \|\|	126	return exp == NULL \|\|
130	(exp->tag == LEAF && exp->left.symptr->storage == CONSTANT &&	127	(exp->tag == LEAF && exp->left.symptr->storage == CONSTANT &&
131	exp->left.symptr->offset.offv != 0);	128	exp->left.symptr->offset.offv != 0);
132	}	129	}
133		130
134	PRIVATE void sort(caselist, count) /* shell sort */	131	PRIVATE void sort(struct casestruct caselist, int count) / shell sort */
135	struct casestruct *caselist;
136	int count;
137	{	132	{
138	register int gap;	133	register int gap;
139	register int i;	134	register int i;
Lines 668-675 Link Here
668	jump(dfaultlab);	663	jump(dfaultlab);
669	}	664	}
670		665
671	PUBLIC void outswoffset (offset)	666	PUBLIC void outswoffset (offset_T offset)
672	offset_T offset;
673	{	667	{
674	#ifdef FRAMEPOINTER	668	#ifdef FRAMEPOINTER
675	outoffset(offset - softsp - framep);	669	outoffset(offset - softsp - framep);

Lines 154-162 Link Here

(-)a/bcc/table.c (-50 / +20 lines)
154	FORWARD struct symstruct addkeyword P((char name, sym_pt code));	154	FORWARD struct symstruct addkeyword P((char name, sym_pt code));
155	FORWARD void heapcorrupterror P((void));	155	FORWARD void heapcorrupterror P((void));
156		156
157	PUBLIC struct symstruct *addglb(name, type)	157	PUBLIC struct symstruct addglb(char name, struct typestruct *type)
158	char *name;
159	struct typestruct *type;
160	{	158	{
161	struct symstruct **hashptr;	159	struct symstruct **hashptr;
162	struct symstruct oldsymptr = NULL; / for -Wall */	160	struct symstruct oldsymptr = NULL; / for -Wall */
Lines 190-198 Link Here
190	return symptr;	188	return symptr;
191	}	189	}
192		190
193	PRIVATE struct symstruct *addkeyword(name, code)	191	PRIVATE struct symstruct addkeyword(char name, sym_pt code)
194	char *name;
195	sym_pt code;
196	{	192	{
197	struct symstruct *symptr;	193	struct symstruct *symptr;
198		194
Lines 201-209 Link Here
201	return symptr;	197	return symptr;
202	}	198	}
203		199
204	PUBLIC struct symstruct *addloc(name, type)	200	PUBLIC struct symstruct addloc(char name, struct typestruct *type)
205	char *name;
206	struct typestruct *type;
207	{	201	{
208	struct symstruct **hashptr;	202	struct symstruct **hashptr;
209	register struct symstruct *symptr;	203	register struct symstruct *symptr;
Lines 232-250 Link Here
232	return symptr;	226	return symptr;
233	}	227	}
234		228
235	PUBLIC struct symstruct *addlorg(name, type)	229	PUBLIC struct symstruct addlorg(char name, struct typestruct *type)
236	char *name;
237	struct typestruct *type;
238	{	230	{
239	if (level != GLBLEVEL)	231	if (level != GLBLEVEL)
240	return addloc(name, type);	232	return addloc(name, type);
241	return addglb(name, type);	233	return addglb(name, type);
242	}	234	}
243		235
244	PUBLIC void addsym(name, type, symptr)	236	PUBLIC void addsym(char name, struct typestruct type, register struct symstruct *symptr)
245	char *name;
246	struct typestruct *type;
247	register struct symstruct *symptr;
248	{	237	{
249	if (type->constructor & (ARRAY \| FUNCTION))	238	if (type->constructor & (ARRAY \| FUNCTION))
250	symptr->indcount = 0;	239	symptr->indcount = 0;
Lines 257-264 Link Here
257	strcpy(symptr->name.namea, name);	246	strcpy(symptr->name.namea, name);
258	}	247	}
259		248
260	PUBLIC struct symstruct *constsym(longconst)	249	PUBLIC struct symstruct *constsym(value_t longconst)
261	value_t longconst;
262	{	250	{
263	register struct symstruct *symptr;	251	register struct symstruct *symptr;
264		252
Lines 267-274 Link Here
267	return symptr;	255	return symptr;
268	}	256	}
269		257
270	PUBLIC void delsym(symptr)	258	PUBLIC void delsym(register struct symstruct *symptr)
271	register struct symstruct *symptr;
272	{	259	{
273	if ((*(symptr->prev) = symptr->next) != NULL)	260	if ((*(symptr->prev) = symptr->next) != NULL)
274	symptr->next->prev = symptr->prev;	261	symptr->next->prev = symptr->prev;
Lines 432-439 Link Here
432		419
433	#endif	420	#endif
434		421
435	PUBLIC struct symstruct *exprsym(symptr)	422	PUBLIC struct symstruct exprsym(struct symstruct symptr)
436	struct symstruct *symptr;
437	{	423	{
438	register struct symstruct *newsymptr;	424	register struct symstruct *newsymptr;
439		425
Lines 450-457 Link Here
450	return newsymptr;	436	return newsymptr;
451	}	437	}
452		438
453	PUBLIC struct symstruct *findlorg(name)	439	PUBLIC struct symstruct findlorg(char name)
454	char *name;
455	{	440	{
456	struct symstruct *symptr;	441	struct symstruct *symptr;
457		442
Lines 462-469 Link Here
462	return symptr;	447	return symptr;
463	}	448	}
464		449
465	PUBLIC struct symstruct *findstruct(name)	450	PUBLIC struct symstruct findstruct(char name)
466	char *name;
467	{	451	{
468	struct symstruct *symptr;	452	struct symstruct *symptr;
469		453
Lines 476-483 Link Here
476		460
477	/* convert name to a hash table ptr */	461	/* convert name to a hash table ptr */
478		462
479	PUBLIC struct symstruct **gethashptr(sname)	463	PUBLIC struct symstruct *gethashptr(char sname)
480	char *sname;
481	{	464	{
482	register int hashval;	465	register int hashval;
483	register char *rsname;	466	register char *rsname;
Lines 506-514 Link Here
506		489
507	/* hold string for dumping at end, to avoid mixing it with other data */	490	/* hold string for dumping at end, to avoid mixing it with other data */
508		491
509	PUBLIC label_no holdstr(sptr, stop)	492	PUBLIC label_no holdstr(char sptr, char stop)
510	char *sptr;
511	char *stop;
512	{	493	{
513	register struct string *stringp;	494	register struct string *stringp;
514		495
Lines 553-566 Link Here
553	delsym(symptr);	534	delsym(symptr);
554	}	535	}
555		536
556	PUBLIC void ourfree(ptr)	537	PUBLIC void ourfree(void *ptr)
557	void *ptr;
558	{	538	{
559	free(ptr);	539	free(ptr);
560	}	540	}
561		541
562	PUBLIC void *ourmalloc(nbytes)	542	PUBLIC void *ourmalloc(unsigned nbytes)
563	unsigned nbytes;
564	{	543	{
565	void *ptr;	544	void *ptr;
566		545
Lines 569-576 Link Here
569	return ptr;	548	return ptr;
570	}	549	}
571		550
572	PUBLIC void outofmemoryerror(message)	551	PUBLIC void outofmemoryerror(char *message)
573	char *message;
574	{	552	{
575	error2error("compiler out of memory", message);	553	error2error("compiler out of memory", message);
576		554
Lines 594-602 Link Here
594	finishup();	572	finishup();
595	}	573	}
596		574
597	PUBLIC void *growobject(object, extra)	575	PUBLIC void growobject(void object, unsigned extra)
598	void *object;
599	unsigned extra;
600	{	576	{
601	/* size_t */ unsigned oblength;	577	/* size_t */ unsigned oblength;
602		578
Lines 627-634 Link Here
627	#define ALLOC_OVERHEAD (sizeof (unsigned))	603	#define ALLOC_OVERHEAD (sizeof (unsigned))
628	#endif	604	#endif
629		605
630	PUBLIC void growheap(size)	606	PUBLIC void growheap(unsigned size)
631	unsigned size;
632	{	607	{
633	register char *newptr;	608	register char *newptr;
634		609
Lines 647-654 Link Here
647	(unsigned ) newptr = MARKER;	622	(unsigned ) newptr = MARKER;
648	}	623	}
649		624
650	PUBLIC void *qmalloc(size)	625	PUBLIC void *qmalloc(unsigned size)
651	unsigned size;
652	{	626	{
653	register char *ptr;	627	register char *ptr;
654		628
Lines 659-667 Link Here
659	return ptr;	633	return ptr;
660	}	634	}
661		635
662	PUBLIC void swapsym(sym1, sym2)	636	PUBLIC void swapsym(struct symstruct sym1, struct symstruct sym2)
663	struct symstruct *sym1;
664	struct symstruct *sym2;
665	{	637	{
666	struct symstruct swaptemp;	638	struct symstruct swaptemp;
667		639
Lines 693-701 Link Here
693	}	665	}
694		666
695	#ifndef VERY_SMALL_MEMORY	667	#ifndef VERY_SMALL_MEMORY
696	PUBLIC struct symstruct *findstrm(type, name)	668	PUBLIC struct symstruct findstrm(struct typestruct type, char *name)
697	struct typestruct *type;
698	char *name;
699	{	669	{
700	struct symstruct *symptr;	670	struct symstruct *symptr;
701	int i;	671	int i;