* archive.c: Fix formatting.
* coff-arm.c: Likewise.
* doc/chew.c: Likewise.
+2000-09-08 Kazu Hirata <kazu@hxi.com>
+
+ * archive.c: Fix formatting.
+ * coff-arm.c: Likewise.
+ * doc/chew.c: Likewise.
+
2000-09-08 Alan Modra <alan@linuxcare.com.au>
* section.c (bfd_get_unique_section_name): Put a dot before the
}
\f
/* The name begins with space. Hence the rest of the name is an index into
- the string table. */
+ the string table. */
static char *
get_extended_arelt_filename (arch, name)
unsigned long index = 0;
/* Should extract string so that I can guarantee not to overflow into
- the next region, but I'm too lazy. */
+ the next region, but I'm too lazy. */
errno = 0;
- /* Skip first char, which is '/' in SVR4 or ' ' in some other variants. */
+ /* Skip first char, which is '/' in SVR4 or ' ' in some other variants. */
index = strtol (name + 1, NULL, 10);
if (errno != 0)
{
{
/* We judge the end of the name by looking for '/' or ' '.
Note: The SYSV format (terminated by '/') allows embedded
- spaces, so only look for ' ' if we don't find '/'. */
+ spaces, so only look for ' ' if we don't find '/'. */
char *e;
e = memchr (hdr.ar_name, '\0', ar_maxnamelen (abfd));
unsigned int size = arelt_size (last_file);
/* Pad to an even boundary...
Note that last_file->origin can be odd in the case of
- BSD-4.4-style element with a long odd size. */
+ BSD-4.4-style element with a long odd size. */
filestart = last_file->origin + size;
filestart += filestart % 2;
}
return _bfd_get_elt_at_filepos (archive, filestart);
}
-
const bfd_target *
bfd_generic_archive_p (abfd)
bfd *abfd;
#endif
/* We are setting bfd_ardata(abfd) here, but since bfd_ardata
- involves a cast, we can't do it as the left operand of assignment. */
+ involves a cast, we can't do it as the left operand of assignment. */
abfd->tdata.aout_ar_data = ((struct artdata *)
bfd_zalloc (abfd, sizeof (struct artdata)));
if (mapdata == NULL)
return false;
parsed_size = mapdata->parsed_size;
- bfd_release (abfd, (PTR) mapdata); /* Don't need it any more. */
+ bfd_release (abfd, (PTR) mapdata); /* Don't need it any more. */
raw_armap = (bfd_byte *) bfd_zalloc (abfd, parsed_size);
if (raw_armap == (bfd_byte *) NULL)
ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
/* FIXME, we should provide some way to free raw_ardata when
we are done using the strings from it. For now, it seems
- to be allocated on an objalloc anyway... */
+ to be allocated on an objalloc anyway... */
bfd_has_map (abfd) = true;
return true;
}
unsigned int stringsize;
unsigned int parsed_size;
carsym *carsyms;
- unsigned int nsymz; /* Number of symbols in armap. */
+ unsigned int nsymz; /* Number of symbols in armap. */
bfd_vma (*swap) PARAMS ((const bfd_byte *));
char int_buf[sizeof (long)];
unsigned int carsym_size, ptrsize, i;
if (mapdata == NULL)
return false;
parsed_size = mapdata->parsed_size;
- bfd_release (abfd, (PTR) mapdata); /* Don't need it any more. */
+ bfd_release (abfd, (PTR) mapdata); /* Don't need it any more. */
if (bfd_read ((PTR) int_buf, 1, 4, abfd) != 4)
{
return false;
}
/* It seems that all numeric information in a coff archive is always
- in big endian format, nomatter the host or target. */
+ in big endian format, nomatter the host or target. */
swap = bfd_getb32;
nsymz = bfd_getb32 ((PTR) int_buf);
stringsize = parsed_size - (4 * nsymz) - 4;
#endif
/* The coff armap must be read sequentially. So we construct a
- bsd-style one in core all at once, for simplicity. */
+ bsd-style one in core all at once, for simplicity. */
carsym_size = (nsymz * sizeof (carsym));
ptrsize = (4 * nsymz);
carsyms = ardata->symdefs;
stringbase = ((char *) ardata->symdefs) + carsym_size;
- /* Allocate and read in the raw offsets. */
+ /* Allocate and read in the raw offsets. */
raw_armap = (int *) bfd_alloc (abfd, ptrsize);
if (raw_armap == NULL)
goto release_symdefs;
/* Pad to an even boundary if you have to */
ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
-
bfd_has_map (abfd) = true;
bfd_release (abfd, (PTR) raw_armap);
-
/* Check for a second archive header (as used by PE) */
{
struct areltdata *tmp;
/* Returns false on error, true otherwise */
/* flavor 2 of a bsd armap, similar to bfd_slurp_bsd_armap except the
header is in a slightly different order and the map name is '/'.
- This flavour is used by hp300hpux. */
+ This flavour is used by hp300hpux. */
#define HPUX_SYMDEF_COUNT_SIZE 2
ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
/* FIXME, we should provide some way to free raw_ardata when
we are done using the strings from it. For now, it seems
- to be allocated on an objalloc anyway... */
+ to be allocated on an objalloc anyway... */
bfd_has_map (abfd) = true;
return true;
}
(bfd_ardata (abfd)->first_file_filepos) % 2;
/* FIXME, we can't release namedata here because it was allocated
- below extended_names on the objalloc... */
+ below extended_names on the objalloc... */
/* bfd_release (abfd, namedata); */
}
return true;
{
const char *filename = strrchr (file, '/');
-
#ifdef HAVE_DOS_BASED_FILE_SYSTEM
{
/* We could have foo/bar\\baz, or foo\\bar, or d:bar. */
{
/* Works for now; may need to be re-engineered if we
encounter an oddball archive format and want to
- generalise this hack. */
+ generalise this hack. */
struct ar_hdr *hdr = arch_hdr (current);
strcpy (strptr, normal);
if (! trailing_slash)
}
hdr->ar_name[0] = ar_padchar (current);
/* We know there will always be enough room (one of the few
- cases where you may safely use sprintf). */
+ cases where you may safely use sprintf). */
sprintf ((hdr->ar_name) + 1, "%-d", (unsigned) (strptr - *tabloc));
/* Kinda Kludgy. We should just use the returned value of
sprintf but not all implementations get this right */
/* Takes a filename, returns an arelt_data for it, or NULL if it can't
make one. The filename must refer to a filename in the filesystem.
The filename field of the ar_hdr will NOT be initialized. If member
- is set, and it's an in-memory bfd, we fake it. */
+ is set, and it's an in-memory bfd, we fake it. */
static struct areltdata *
bfd_ar_hdr_from_filesystem (abfd, filename, member)
return (struct ar_hdr *) ar_elt->arch_header;
}
-
/* Analogous to stat call */
int
bfd_generic_stat_arch_elt (abfd, buf)
/* FIXME: This interacts unpleasantly with ar's quick-append option.
Fortunately ic960 users will never use that option. Fixing this
is very hard; fortunately I know how to do it and will do so once
- intel's release is out the door. */
+ intel's release is out the door. */
struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
size_t length;
4> truncate it before the .o, append .o, stuff THAT in. */
/* This is what gnu ar does. It's better but incompatible with the
- bsd ar. */
+ bsd ar. */
void
bfd_gnu_truncate_arname (abfd, pathname, arhdr)
long syms_max = 0;
boolean ret;
- /* Dunno if this is the best place for this info... */
+ /* Dunno if this is the best place for this info... */
if (elength != 0)
elength += sizeof (struct ar_hdr);
elength += elength % 2;
int padit = stridx & 1;
unsigned int ranlibsize = orl_count * BSD_SYMDEF_SIZE;
unsigned int stringsize = stridx + padit;
- /* Include 8 bytes to store ranlibsize and stringsize in output. */
+ /* Include 8 bytes to store ranlibsize and stringsize in output. */
unsigned int mapsize = ranlibsize + stringsize + 8;
file_ptr firstreal;
bfd *current = arch->archive_head;
}
/* The spec sez this should be a newline. But in order to be
- bug-compatible for sun's ar we use a null. */
+ bug-compatible for sun's ar we use a null. */
if (padit)
{
if (bfd_write ("", 1, 1, arch) != 1)
}
/* The spec sez this should be a newline. But in order to be
- bug-compatible for arc960 we use a null. */
+ bug-compatible for arc960 we use a null. */
if (padit)
{
if (bfd_write ("", 1, 1, arch) != 1)
#ifndef NUM_ELEM
#define NUM_ELEM(a) ((sizeof (a)) / sizeof ((a)[0]))
#endif
-
+
typedef enum {bunknown, b9, b12, b23} thumb_pcrel_branchtype;
/* some typedefs for holding instructions */
typedef unsigned long int insn32;
typedef unsigned short int insn16;
-
/* Forward declarations for stupid compilers. */
static boolean coff_arm_relocate_section
PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
static boolean coff_arm_adjust_symndx
PARAMS ((bfd *, struct bfd_link_info *, bfd *,
asection *, struct internal_reloc *, boolean *));
-static reloc_howto_type * coff_arm_rtype_to_howto
+static reloc_howto_type * coff_arm_rtype_to_howto
PARAMS ((bfd *, asection *, struct internal_reloc *,
struct coff_link_hash_entry *, struct internal_syment *, bfd_vma *));
static bfd_reloc_status_type coff_thumb_pcrel_common
Given a function name, and its type, the stub can be found. The
name can be changed. The only requirement is the %s be present.
*/
-
+
#define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
#define THUMB2ARM_GLUE_ENTRY_NAME "__%s_from_thumb"
#define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
#define ARM2THUMB_GLUE_ENTRY_NAME "__%s_from_arm"
-/* Used by the assembler. */
+/* Used by the assembler. */
static bfd_reloc_status_type
coff_arm_reloc (abfd, reloc_entry, symbol, data, input_section, output_bfd,
error_message)
#define ARM_SECREL 15
#endif
-static reloc_howto_type aoutarm_std_reloc_howto[] =
+static reloc_howto_type aoutarm_std_reloc_howto[] =
{
/* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */
#ifdef ARM_WINCE
EMPTY_HOWTO (-1),
- HOWTO (ARM_32,
+ HOWTO (ARM_32,
0,
- 2,
+ 2,
32,
false,
0,
0xffffffff,
0xffffffff,
PCRELOFFSET),
- HOWTO (ARM_RVA32,
+ HOWTO (ARM_RVA32,
0,
- 2,
+ 2,
32,
false,
0,
"ARM_26",
false,
0x00ffffff,
- 0x00ffffff,
+ 0x00ffffff,
PCRELOFFSET),
HOWTO (ARM_THUMB12,
1,
"ARM_THUMB12",
false,
0x000007ff,
- 0x000007ff,
+ 0x000007ff,
PCRELOFFSET),
- HOWTO (ARM_26D,
- 2,
+ HOWTO (ARM_26D,
+ 2,
2,
24,
false,
0,
complain_overflow_dont,
- aoutarm_fix_pcrel_26_done,
+ aoutarm_fix_pcrel_26_done,
"ARM_26D",
true,
0x00ffffff,
EMPTY_HOWTO (-1),
EMPTY_HOWTO (-1),
EMPTY_HOWTO (-1),
- HOWTO (ARM_SECTION,
- 0,
- 1,
- 16,
+ HOWTO (ARM_SECTION,
+ 0,
+ 1,
+ 16,
false,
0,
complain_overflow_bitfield,
coff_arm_reloc,
- "ARM_16",
+ "ARM_16",
true,
0x0000ffff,
- 0x0000ffff,
+ 0x0000ffff,
PCRELOFFSET),
- HOWTO (ARM_SECREL,
+ HOWTO (ARM_SECREL,
0,
- 2,
+ 2,
32,
false,
0,
0x000000ff, /* src_mask */
0x000000ff, /* dst_mask */
PCRELOFFSET /* pcrel_offset */),
- HOWTO(ARM_16,
- 0,
- 1,
- 16,
+ HOWTO(ARM_16,
+ 0,
+ 1,
+ 16,
false,
0,
complain_overflow_bitfield,
coff_arm_reloc,
- "ARM_16",
+ "ARM_16",
true,
0x0000ffff,
- 0x0000ffff,
+ 0x0000ffff,
PCRELOFFSET),
- HOWTO(ARM_32,
+ HOWTO(ARM_32,
0,
- 2,
+ 2,
32,
false,
0,
"ARM_26",
false,
0x00ffffff,
- 0x00ffffff,
+ 0x00ffffff,
PCRELOFFSET),
- HOWTO(ARM_DISP8,
+ HOWTO(ARM_DISP8,
0,
0,
- 8,
+ 8,
true,
0,
- complain_overflow_signed,
+ complain_overflow_signed,
coff_arm_reloc,
- "ARM_DISP8",
+ "ARM_DISP8",
true,
0x000000ff,
0x000000ff,
true),
- HOWTO( ARM_DISP16,
+ HOWTO( ARM_DISP16,
0,
1,
16,
true,
0,
- complain_overflow_signed,
+ complain_overflow_signed,
coff_arm_reloc,
"ARM_DISP16",
true,
32,
true,
0,
- complain_overflow_signed,
+ complain_overflow_signed,
coff_arm_reloc,
"ARM_DISP32",
true,
0xffffffff,
0xffffffff,
true),
- HOWTO( ARM_26D,
- 2,
+ HOWTO( ARM_26D,
+ 2,
2,
24,
false,
0,
complain_overflow_dont,
- aoutarm_fix_pcrel_26_done,
+ aoutarm_fix_pcrel_26_done,
"ARM_26D",
true,
0x00ffffff,
-1,
16,
false,
- 0,
+ 0,
complain_overflow_bitfield,
coff_arm_reloc,
"ARM_NEG16",
- true,
+ true,
+ 0x0000ffff,
0x0000ffff,
- 0x0000ffff,
false),
- HOWTO( ARM_NEG32,
- 0,
+ HOWTO( ARM_NEG32,
+ 0,
-2,
32,
false,
0xffffffff,
0xffffffff,
false),
- HOWTO( ARM_RVA32,
+ HOWTO( ARM_RVA32,
0,
- 2,
+ 2,
32,
false,
0,
"ARM_THUMB9",
false,
0x000000ff,
- 0x000000ff,
+ 0x000000ff,
PCRELOFFSET),
HOWTO( ARM_THUMB12,
1,
"ARM_THUMB12",
false,
0x000007ff,
- 0x000007ff,
+ 0x000007ff,
PCRELOFFSET),
HOWTO( ARM_THUMB23,
1,
"ARM_THUMB23",
false,
0x07ff07ff,
- 0x07ff07ff,
+ 0x07ff07ff,
PCRELOFFSET)
#endif /* not ARM_WINCE */
};
#ifdef COFF_WITH_PE
/* Return true if this relocation should
- appear in the output .reloc section. */
+ appear in the output .reloc section. */
static boolean
in_reloc_p (abfd, howto)
reloc_howto_type * howto;
{
return !howto->pc_relative && howto->type != ARM_RVA32;
-}
+}
#endif
#define RTYPE2HOWTO(cache_ptr, dst) \
if (rel->r_type >= NUM_RELOCS)
return NULL;
-
+
howto = aoutarm_std_reloc_howto + rel->r_type;
if (rel->r_type == ARM_RVA32)
return howto;
}
-/* Used by the assembler. */
+/* Used by the assembler. */
static bfd_reloc_status_type
aoutarm_fix_pcrel_26_done (abfd, reloc_entry, symbol, data, input_section,
return bfd_reloc_ok;
}
-/* Used by the assembler. */
+/* Used by the assembler. */
static bfd_reloc_status_type
aoutarm_fix_pcrel_26 (abfd, reloc_entry, symbol, data, input_section,
bfd_size_type addr = reloc_entry->address;
long target = bfd_get_32 (abfd, (bfd_byte *) data + addr);
bfd_reloc_status_type flag = bfd_reloc_ok;
-
+
/* If this is an undefined symbol, return error */
if (symbol->section == &bfd_und_section
&& (symbol->flags & BSF_WEAK) == 0)
relocation -= input_section->output_section->vma;
relocation -= input_section->output_offset;
relocation -= addr;
-
+
if (relocation & 3)
return bfd_reloc_overflow;
default:
abort ();
}
-
+
/* If this is an undefined symbol, return error */
if (symbol->section == &bfd_und_section
&& (symbol->flags & BSF_WEAK) == 0)
/* Now the ARM magic... Change the reloc type so that it is marked as done.
Strictly this is only necessary if we are doing a partial relocation. */
reloc_entry->howto = & aoutarm_std_reloc_howto [ARM_26D];
-
+
/* TODO: We should possibly have DONE entries for the THUMB PCREL relocations */
return flag;
}
input_section, output_bfd, error_message, b9);
}
-
static CONST struct reloc_howto_struct *
coff_arm_reloc_type_lookup (abfd, code)
bfd * abfd;
bfd_reloc_code_real_type code;
{
#define ASTD(i,j) case i: return aoutarm_std_reloc_howto + j
-
+
if (code == BFD_RELOC_CTOR)
switch (bfd_get_arch_info (abfd)->bits_per_address)
{
ASTD (BFD_RELOC_THUMB_PCREL_BRANCH9, ARM_THUMB9);
ASTD (BFD_RELOC_THUMB_PCREL_BRANCH12, ARM_THUMB12);
ASTD (BFD_RELOC_THUMB_PCREL_BRANCH23, ARM_THUMB23);
-#endif
+#endif
default: return (CONST struct reloc_howto_struct *) 0;
}
}
{
/* The original coff_link_hash_table structure. MUST be first field. */
struct coff_link_hash_table root;
-
+
/* The size in bytes of the section containg the Thumb-to-ARM glue. */
long int thumb_glue_size;
-
+
/* The size in bytes of the section containg the ARM-to-Thumb glue. */
long int arm_glue_size;
/* An arbitary input BFD chosen to hold the glue sections. */
bfd * bfd_of_glue_owner;
- /* Support interworking with old, non-interworking aware ARM code. */
+ /* Support interworking with old, non-interworking aware ARM code. */
int support_old_code;
};
\f
/* The thumb form of a long branch is a bit finicky, because the offset
encoding is split over two fields, each in it's own instruction. They
- can occur in any order. So given a thumb form of long branch, and an
+ can occur in any order. So given a thumb form of long branch, and an
offset, insert the offset into the thumb branch and return finished
- instruction.
+ instruction.
- It takes two thumb instructions to encode the target address. Each has
+ It takes two thumb instructions to encode the target address. Each has
11 bits to invest. The upper 11 bits are stored in one (identifed by
- H-0.. see below), the lower 11 bits are stored in the other (identified
- by H-1).
+ H-0.. see below), the lower 11 bits are stored in the other (identified
+ by H-1).
- Combine together and shifted left by 1 (it's a half word address) and
+ Combine together and shifted left by 1 (it's a half word address) and
there you have it.
Op: 1111 = F,
Op: 1111 = F,
H-1, lower address-0 = 800
- They can be ordered either way, but the arm tools I've seen always put
+ They can be ordered either way, but the arm tools I've seen always put
the lower one first. It probably doesn't matter. krk@cygnus.com
XXX: Actually the order does matter. The second instruction (H-1)
unsigned int low_bits;
unsigned int high_bits;
-
BFD_ASSERT((rel_off & 1) != 1);
rel_off >>= 1; /* half word aligned address */
BFD_ASSERT (tmp_name);
sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
-
+
myh = coff_link_hash_lookup
(coff_hash_table (info), tmp_name, false, false, true);
-
+
if (myh == NULL)
/* xgettext:c-format */
_bfd_error_handler (_("%s: unable to find THUMB glue '%s' for `%s'"),
bfd_get_filename (input_bfd), tmp_name, name);
-
+
free (tmp_name);
return myh;
BFD_ASSERT (tmp_name);
sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
-
+
myh = coff_link_hash_lookup
(coff_hash_table (info), tmp_name, false, false, true);
/* xgettext:c-format */
_bfd_error_handler (_("%s: unable to find ARM glue '%s' for `%s'"),
bfd_get_filename (input_bfd), tmp_name, name);
-
+
free (tmp_name);
return myh;
ldmia r13! {r6, lr}
bx lr
__func_addr:
- .word func
+ .word func
*/
#define THUMB2ARM_GLUE_SIZE (globals->support_old_code ? 20 : 8)
instruction we should generate a trampoline stub (needed to
address the complete 32bit address space). */
-/* The standard COFF backend linker does not cope with the special
+/* The standard COFF backend linker does not cope with the special
Thumb BRANCH23 relocation. The alternative would be to split the
BRANCH23 into seperate HI23 and LO23 relocations. However, it is a
- bit simpler simply providing our own relocation driver. */
+ bit simpler simply providing our own relocation driver. */
/* The reloc processing routine for the ARM/Thumb COFF linker. NOTE:
This code is a very slightly modified copy of
sym = NULL;
}
else
- {
+ {
h = obj_coff_sym_hashes (input_bfd)[symndx];
sym = syms + symndx;
}
else
addend = 0;
-
howto = coff_rtype_to_howto (input_bfd, input_section, rel, h,
sym, &addend);
if (howto == NULL)
|| h->root.type == bfd_link_hash_defweak)
&& h->root.u.def.section->output_section == input_section->output_section)
{
- static reloc_howto_type fake_arm26_reloc =
+ static reloc_howto_type fake_arm26_reloc =
HOWTO (ARM_26,
2,
2,
"ARM_26",
false,
0x00ffffff,
- 0x00ffffff,
+ 0x00ffffff,
false);
addend -= rel->r_vaddr - input_section->vma;
#ifdef ARM_WINCE
/* MS ARM-CE makes the reloc relative to the opcode's pc, not
- the next opcode's pc, so is off by one. */
+ the next opcode's pc, so is off by one. */
if (howto->pc_relative && !info->relocateable)
addend -= 8;
#endif
-
+
/* If we are doing a relocateable link, then we can just ignore
a PC relative reloc that is pcrel_offset. It will already
have the correct value. If this is not a relocateable link,
relocatable output file, since we may as well leave the
stub generation to the final linker pass. If we fail to
verify that the name is defined, we'll try to build stubs
- for an undefined name... */
+ for an undefined name... */
if (! info->relocateable
&& ( h->root.type == bfd_link_hash_defined
|| h->root.type == bfd_link_hash_defweak))
{
asection * h_sec = h->root.u.def.section;
const char * name = h->root.root.string;
-
+
/* h locates the symbol referenced in the reloc. */
h_val = (h->root.u.def.value
+ h_sec->output_section->vma
long int my_offset;
asection * s;
long int ret_offset;
- struct coff_link_hash_entry * myh;
+ struct coff_link_hash_entry * myh;
struct coff_arm_link_hash_table * globals;
-
+
myh = find_arm_glue (info, name, input_bfd);
if (myh == NULL)
return false;
BFD_ASSERT (globals != NULL);
BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
-
+
my_offset = myh->root.u.def.value;
-
- s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
+
+ s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
ARM2THUMB_GLUE_SECTION_NAME);
BFD_ASSERT (s != NULL);
BFD_ASSERT (s->contents != NULL);
bfd_put_32 (output_bfd, a2t1_ldr_insn,
s->contents + my_offset);
-
+
bfd_put_32 (output_bfd, a2t2_bx_r12_insn,
s->contents + my_offset + 4);
-
+
/* It's a thumb address. Add the low order bit. */
bfd_put_32 (output_bfd, h_val | a2t3_func_addr_insn,
s->contents + my_offset + 8);
if (info->base_file)
- arm_emit_base_file_entry (info, output_bfd, s,
+ arm_emit_base_file_entry (info, output_bfd, s,
my_offset + 8);
}
tmp = bfd_get_32 (input_bfd, contents + rel->r_vaddr
- input_section->vma);
-
+
tmp = tmp & 0xFF000000;
- /* Somehow these are both 4 too far, so subtract 8. */
+ /* Somehow these are both 4 too far, so subtract 8. */
ret_offset =
s->output_offset
- + my_offset
+ + my_offset
+ s->output_section->vma
- (input_section->output_offset
- + input_section->output_section->vma
+ + input_section->output_section->vma
+ rel->r_vaddr)
- 8;
tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
-
+
bfd_put_32 (output_bfd, tmp, contents + rel->r_vaddr
- input_section->vma);
done = 1;
}
}
-
+
#ifndef ARM_WINCE
/* Note: We used to check for ARM_THUMB9 and ARM_THUMB12 */
else if (howto->type == ARM_THUMB23)
{
- if ( h->class == C_EXT
+ if ( h->class == C_EXT
|| h->class == C_STAT
|| h->class == C_LABEL)
{
return false;
globals = coff_arm_hash_table (info);
-
+
BFD_ASSERT (globals != NULL);
BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
-
+
my_offset = myh->root.u.def.value;
-
- s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
+
+ s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
THUMB2ARM_GLUE_SECTION_NAME);
-
+
BFD_ASSERT (s != NULL);
BFD_ASSERT (s->contents != NULL);
BFD_ASSERT (s->output_section != NULL);
-
+
if ((my_offset & 0x01) == 0x01)
{
if (h_sec->owner != NULL
_bfd_error_handler
(_(" consider relinking with --support-old-code enabled"));
}
-
+
-- my_offset;
myh->root.u.def.value = my_offset;
{
bfd_put_16 (output_bfd, t2a1_push_insn,
s->contents + my_offset);
-
+
bfd_put_16 (output_bfd, t2a2_ldr_insn,
s->contents + my_offset + 2);
bfd_put_16 (output_bfd, t2a4_bx_insn,
s->contents + my_offset + 6);
-
+
bfd_put_32 (output_bfd, t2a5_pop_insn,
s->contents + my_offset + 8);
-
+
bfd_put_32 (output_bfd, t2a6_bx_insn,
s->contents + my_offset + 12);
-
+
/* Store the address of the function in the last word of the stub. */
bfd_put_32 (output_bfd, h_val,
s->contents + my_offset + 16);
{
bfd_put_16 (output_bfd, t2a1_bx_pc_insn,
s->contents + my_offset);
-
+
bfd_put_16 (output_bfd, t2a2_noop_insn,
s->contents + my_offset + 2);
-
+
ret_offset =
((bfd_signed_vma) h_val) /* Address of destination of the stub */
- ((bfd_signed_vma)
+ s->output_section->vma) /* Address of the start of the current section. */
+ 4 /* The branch instruction is 4 bytes into the stub. */
+ 8); /* ARM branches work from the pc of the instruction + 8. */
-
+
bfd_put_32 (output_bfd,
t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
s->contents + my_offset + 4);
- (input_section->output_offset
+ rel->r_vaddr)
-4;
-
+
tmp = bfd_get_32 (input_bfd, contents + rel->r_vaddr
- input_section->vma);
insert_thumb_branch (tmp, ret_offset),
contents + rel->r_vaddr
- input_section->vma);
-
+
done = 1;
}
}
#endif
}
-
+
/* If the relocation type and destination symbol does not
fall into one of the above categories, then we can just
- perform a direct link. */
+ perform a direct link. */
if (done)
rstat = bfd_reloc_ok;
- else
+ else
#endif /* THUMBEXTENSION */
if ( h->root.type == bfd_link_hash_defined
|| h->root.type == bfd_link_hash_defweak)
if (info->base_file)
{
- /* Emit a reloc if the backend thinks it needs it. */
+ /* Emit a reloc if the backend thinks it needs it. */
if (sym && pe_data(output_bfd)->in_reloc_p(output_bfd, howto))
arm_emit_base_file_entry (info, output_bfd, input_section, rel->r_vaddr);
}
-
+
#if 1 /* THUMBEXTENSION */
if (done)
rstat = bfd_reloc_ok;
instruction. Again, it would probably be simpler adding a
ThumbBRANCH23 specific macro expansion into the default
code. */
-
+
bfd_vma address = rel->r_vaddr - input_section->vma;
-
+
if (address > input_section->_raw_size)
rstat = bfd_reloc_outofrange;
else
bfd_signed_vma signed_add;
BFD_ASSERT (size == 4);
-
+
/* howto->pc_relative should be TRUE for type 14 BRANCH23 */
relocation -= (input_section->output_section->vma
+ input_section->output_offset);
-
+
/* howto->pcrel_offset should be TRUE for type 14 BRANCH23 */
relocation -= address;
-
- /* No need to negate the relocation with BRANCH23. */
+
+ /* No need to negate the relocation with BRANCH23. */
/* howto->complain_on_overflow == complain_overflow_signed for BRANCH23. */
/* howto->rightshift == 1 */
/* Drop unwanted bits from the value we are relocating to. */
-
+
check = relocation >> howto->rightshift;
-
+
/* If this is a signed value, the rightshift just dropped
leading 1 bits (assuming twos complement). */
if ((bfd_signed_vma) relocation >= 0)
signed_check = (check
| ((bfd_vma) - 1
& ~((bfd_vma) - 1 >> howto->rightshift)));
-
+
/* Get the value from the object file. */
if (bfd_big_endian (input_bfd))
{
can not get the upper bit, but that does not matter since
signed_add needs no adjustment to become negative in that
case. */
-
+
signed_add = add;
-
+
if ((add & (((~ src_mask) >> 1) & src_mask)) != 0)
signed_add -= (((~ src_mask) >> 1) & src_mask) << 1;
-
+
/* Add the value from the object file, shifted so that it is a
straight number. */
/* howto->bitpos == 0 */
-
+
signed_check += signed_add;
relocation += signed_add;
if ( signed_check > reloc_signed_max
|| signed_check < reloc_signed_min)
overflow = true;
-
+
/* Put RELOCATION into the correct bits: */
-
+
if (bfd_big_endian (input_bfd))
{
relocation = (((relocation & 0xffe) >> 1) | ((relocation << 4) & 0x07ff0000));
{
relocation = (((relocation & 0xffe) << 15) | ((relocation >> 12) & 0x7ff));
}
-
+
/* Add RELOCATION to the correct bits of X: */
x = ((x & ~howto->dst_mask) | relocation);
rel->r_vaddr - input_section->vma,
val, addend);
#if 1 /* THUMBEXTENSION */
- /* FIXME:
+ /* FIXME:
Is this the best way to fix up thumb addresses? krk@cygnus.com
Probably not, but it works, and if it works it don't need fixing! nickc@cygnus.com */
/* Only perform this fix during the final link, not a relocatable link. nickc@cygnus.com */
{
/* Determine if we need to set the bottom bit of a relocated address
because the address is the address of a Thumb code symbol. */
-
+
int patchit = false;
-
+
if (h != NULL
&& ( h->class == C_THUMBSTATFUNC
|| h->class == C_THUMBEXTFUNC))
bfd_put_32 (input_bfd, x | 1, location);
}
}
-#endif /* THUMBEXTENSION */
-
+#endif /* THUMBEXTENSION */
+
switch (rstat)
{
default:
#ifndef COFF_IMAGE_WITH_PE
boolean
-bfd_arm_allocate_interworking_sections (info)
+bfd_arm_allocate_interworking_sections (info)
struct bfd_link_info * info;
{
asection * s;
#endif
globals = coff_arm_hash_table (info);
-
+
BFD_ASSERT (globals != NULL);
if (globals->arm_glue_size != 0)
{
BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
-
+
s = bfd_get_section_by_name
(globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
BFD_ASSERT (s != NULL);
-
+
foo = (bfd_byte *) bfd_alloc
(globals->bfd_of_glue_owner, globals->arm_glue_size);
#if 0
memset (foo, test_char, globals->arm_glue_size);
#endif
-
+
s->_raw_size = s->_cooked_size = globals->arm_glue_size;
s->contents = foo;
}
if (globals->thumb_glue_size != 0)
{
BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
-
+
s = bfd_get_section_by_name
(globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
BFD_ASSERT (s != NULL);
-
+
foo = (bfd_byte *) bfd_alloc
(globals->bfd_of_glue_owner, globals->thumb_glue_size);
#if 0
memset (foo, test_char, globals->thumb_glue_size);
#endif
-
+
s->_raw_size = s->_cooked_size = globals->thumb_glue_size;
s->contents = foo;
}
BFD_ASSERT (tmp_name);
sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
-
+
myh = coff_link_hash_lookup
(coff_hash_table (info), tmp_name, false, false, true);
-
+
if (myh != NULL)
{
free (tmp_name);
it. */
bfd_coff_link_add_one_symbol (info, globals->bfd_of_glue_owner, tmp_name,
- BSF_GLOBAL,
+ BSF_GLOBAL,
s, globals->arm_glue_size + 1,
- NULL, true, false,
+ NULL, true, false,
(struct bfd_link_hash_entry **) & myh);
-
+
free (tmp_name);
-
+
globals->arm_glue_size += ARM2THUMB_GLUE_SIZE;
return;
struct coff_link_hash_entry * myh;
struct coff_arm_link_hash_table * globals;
-
globals = coff_arm_hash_table (info);
-
+
BFD_ASSERT (globals != NULL);
BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
myh = coff_link_hash_lookup
(coff_hash_table (info), tmp_name, false, false, true);
-
+
if (myh != NULL)
{
free (tmp_name);
bfd_coff_link_add_one_symbol (info, globals->bfd_of_glue_owner, tmp_name,
BSF_GLOBAL, s, globals->thumb_glue_size + 1,
- NULL, true, false,
+ NULL, true, false,
(struct bfd_link_hash_entry **) & myh);
-
+
/* If we mark it 'thumb', the disassembler will do a better job. */
myh->class = C_THUMBEXTFUNC;
free (tmp_name);
/* Allocate another symbol to mark where we switch to arm mode. */
-
+
#define CHANGE_TO_ARM "__%s_change_to_arm"
#define BACK_FROM_ARM "__%s_back_from_arm"
-
+
tmp_name = (char *) bfd_malloc (strlen (name) + strlen (CHANGE_TO_ARM) + 1);
-
+
BFD_ASSERT (tmp_name);
-
+
sprintf (tmp_name, globals->support_old_code ? BACK_FROM_ARM : CHANGE_TO_ARM, name);
myh = NULL;
-
+
bfd_coff_link_add_one_symbol (info, globals->bfd_of_glue_owner, tmp_name,
BSF_LOCAL, s, globals->thumb_glue_size
+ (globals->support_old_code ? 8 : 4),
- NULL, true, false,
+ NULL, true, false,
(struct bfd_link_hash_entry **) & myh);
- free (tmp_name);
-
+ free (tmp_name);
+
globals->thumb_glue_size += THUMB2ARM_GLUE_SIZE;
return;
struct coff_arm_link_hash_table * globals;
flagword flags;
asection * sec;
-
+
/* If we are only performing a partial link do not bother
getting a bfd to hold the glue. */
if (info->relocateable)
return true;
-
+
globals = coff_arm_hash_table (info);
-
+
BFD_ASSERT (globals != NULL);
if (globals->bfd_of_glue_owner != NULL)
return true;
-
+
sec = bfd_get_section_by_name (abfd, ARM2THUMB_GLUE_SECTION_NAME);
-
- if (sec == NULL)
+
+ if (sec == NULL)
{
flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE | SEC_READONLY;
-
+
sec = bfd_make_section (abfd, ARM2THUMB_GLUE_SECTION_NAME);
-
+
if (sec == NULL
|| ! bfd_set_section_flags (abfd, sec, flags)
|| ! bfd_set_section_alignment (abfd, sec, 2))
sec = bfd_get_section_by_name (abfd, THUMB2ARM_GLUE_SECTION_NAME);
- if (sec == NULL)
+ if (sec == NULL)
{
flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE | SEC_READONLY;
-
+
sec = bfd_make_section (abfd, THUMB2ARM_GLUE_SECTION_NAME);
-
+
if (sec == NULL
|| ! bfd_set_section_flags (abfd, sec, flags)
|| ! bfd_set_section_alignment (abfd, sec, 2))
return false;
}
-
+
/* Save the bfd for later use. */
globals->bfd_of_glue_owner = abfd;
-
+
return true;
}
to construct any glue. */
if (info->relocateable)
return true;
-
+
/* Here we have a bfd that is to be included on the link. We have a hook
to do reloc rummaging, before section sizes are nailed down. */
_bfd_coff_get_external_symbols (abfd);
globals = coff_arm_hash_table (info);
-
+
BFD_ASSERT (globals != NULL);
BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
globals->support_old_code = support_old_code;
-
+
/* Rummage around all the relocs and map the glue vectors. */
sec = abfd->sections;
struct internal_reloc * i;
struct internal_reloc * rel;
- if (sec->reloc_count == 0)
+ if (sec->reloc_count == 0)
continue;
/* Load the relocs. */
- /* FIXME: there may be a storage leak here. */
-
+ /* FIXME: there may be a storage leak here. */
+
i = _bfd_coff_read_internal_relocs (abfd, sec, 1, 0, 0, 0);
-
+
BFD_ASSERT (i != 0);
- for (rel = i; rel < i + sec->reloc_count; ++rel)
+ for (rel = i; rel < i + sec->reloc_count; ++rel)
{
unsigned short r_type = rel->r_type;
long symndx;
symndx = rel->r_symndx;
- /* If the relocation is not against a symbol it cannot concern us. */
+ /* If the relocation is not against a symbol it cannot concern us. */
if (symndx == -1)
continue;
bfd_get_filename (abfd), symndx);
continue;
}
-
+
h = obj_coff_sym_hashes (abfd)[symndx];
/* If the relocation is against a static symbol it must be within
/* This one is a call from arm code. We need to look up
the target of the call. If it is a thumb target, we
insert glue. */
-
+
if (h->class == C_THUMBEXTFUNC)
record_arm_to_thumb_glue (info, h);
break;
-
+
#ifndef ARM_WINCE
case ARM_THUMB23:
/* This one is a call from thumb code. We used to look
}
break;
#endif
-
+
default:
break;
}
#define coff_bfd_copy_private_bfd_data coff_arm_copy_private_bfd_data
#define coff_bfd_link_hash_table_create coff_arm_link_hash_table_create
-
/* When doing a relocateable link, we want to convert ARM26 relocs
into ARM26D relocs. */
bfd_set_error (bfd_error_wrong_format);
return false;
}
-
+
if (APCS_FLOAT_FLAG (obfd) != APCS_FLOAT_FLAG (ibfd))
{
const char *msg;
else
/* xgettext: c-format */
msg = _("%s: ERROR: passes floats in integer registers whereas target %s uses float registers");
-
+
_bfd_error_handler (msg, bfd_get_filename (ibfd),
bfd_get_filename (obfd));
bfd_set_error (bfd_error_wrong_format);
return false;
}
-
+
if (PIC_FLAG (obfd) != PIC_FLAG (ibfd))
{
const char * msg;
else
{
SET_APCS_FLAGS (obfd, APCS_26_FLAG (ibfd) | APCS_FLOAT_FLAG (ibfd) | PIC_FLAG (ibfd));
-
+
/* Set up the arch and fields as well as these are probably wrong. */
bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
}
else
/* xgettext: c-format */
msg = _("Warning: input file %s does not support interworking, whereas %s does.");
-
+
_bfd_error_handler (msg, bfd_get_filename (ibfd),
bfd_get_filename (obfd));
}
return true;
}
-
/* Display the flags field. */
static boolean
PTR ptr;
{
FILE * file = (FILE *) ptr;
-
+
BFD_ASSERT (abfd != NULL && ptr != NULL);
-
+
/* xgettext:c-format */
fprintf (file, _("private flags = %x:"), coff_data (abfd)->flags);
-
+
if (APCS_SET (abfd))
{
/* xgettext: APCS is ARM Prodecure Call Standard, it should not be translated. */
else
fprintf (file, _(" [absolute position]"));
}
-
+
if (! INTERWORK_SET (abfd))
fprintf (file, _(" [interworking flag not initialised]"));
else if (INTERWORK_FLAG (abfd))
fprintf (file, _(" [interworking supported]"));
else
fprintf (file, _(" [interworking not supported]"));
-
+
fputc ('\n', file);
-
+
return true;
}
-
/* Copies the given flags into the coff_tdata.flags field.
Typically these flags come from the f_flags[] field of
the COFF filehdr structure, which contains important,
BFD_ASSERT (abfd != NULL);
flag = (flags & F_APCS26) ? F_APCS_26 : 0;
-
+
/* Make sure that the APCS field has not been initialised to the opposite
value. */
if (APCS_SET (abfd)
return false;
flag |= (flags & (F_APCS_FLOAT | F_PIC));
-
+
SET_APCS_FLAGS (abfd, flag);
flag = (flags & F_INTERWORK);
-
+
/* If the BFD has already had its interworking flag set, but it
is different from the value that we have been asked to set,
then assume that that merged code will not support interworking
return true;
}
-
/* Copy the important parts of the target specific data
from one instance of a BFD to another. */
bfd * dest;
{
BFD_ASSERT (src != NULL && dest != NULL);
-
+
if (src == dest)
return true;
/* If the src and dest have different APCS flag bits set, fail. */
if (APCS_26_FLAG (dest) != APCS_26_FLAG (src))
return false;
-
+
if (APCS_FLOAT_FLAG (dest) != APCS_FLOAT_FLAG (src))
return false;
-
+
if (PIC_FLAG (dest) != PIC_FLAG (src))
return false;
}
bfd_get_filename (dest),
bfd_get_filename (src));
}
-
+
SET_INTERWORK_FLAG (dest, 0);
}
}
#ifdef LOCAL_LABEL_PREFIX
/* If there is a prefix for local labels then look for this.
- If the prefix exists, but it is empty, then ignore the test. */
-
+ If the prefix exists, but it is empty, then ignore the test. */
+
if (LOCAL_LABEL_PREFIX[0] != 0)
{
int len = strlen (LOCAL_LABEL_PREFIX);
-
+
if (strncmp (name, LOCAL_LABEL_PREFIX, len) != 0)
return false;
-
+
/* Perform the checks below for the rest of the name. */
name += len;
}
#endif
-
+
return name[0] == 'L';
}
/* This piece of machinery exists only to guarantee that the bfd that holds
- the glue section is written last.
+ the glue section is written last.
This does depend on bfd_make_section attaching a new section to the
- end of the section list for the bfd.
+ end of the section list for the bfd.
krk@cygnus.com */
struct coff_arm_link_hash_table * globals;
globals = coff_arm_hash_table (pfinfo->info);
-
+
BFD_ASSERT (globals != NULL);
-
+
if (globals->bfd_of_glue_owner != NULL)
{
if (! _bfd_coff_link_input_bfd (pfinfo, globals->bfd_of_glue_owner))
return false;
-
+
globals->bfd_of_glue_owner->output_has_begun = true;
}
-
+
return true;
}
/* Yet another way of extracting documentation from source.
No, I haven't finished it yet, but I hope you people like it better
than the old way
-
+
sac
Basically, this is a sort of string forth, maybe we should call it
Foo. */
-
#include <ansidecl.h>
#include "sysdep.h"
#include <assert.h>
int warning;
-/* Here is a string type ... */
+/* Here is a string type ... */
-typedef struct buffer
+typedef struct buffer
{
char *ptr;
unsigned long write_idx;
unsigned long size;
} string_type;
-
#ifdef __STDC__
static void init_string_with_size (string_type *, unsigned int);
static void init_string (string_type *);
static void catstr (string_type *, string_type *);
#endif
-
static void
init_string_with_size (buffer, size)
string_type *buffer;
unsigned int size;
{
- buffer->write_idx = 0;
- buffer->size = size;
- buffer->ptr = malloc(size);
+ buffer->write_idx = 0;
+ buffer->size = size;
+ buffer->ptr = malloc (size);
}
static void
init_string (buffer)
string_type *buffer;
{
- init_string_with_size(buffer, DEF_SIZE);
-
+ init_string_with_size (buffer, DEF_SIZE);
}
static int
string_type *str;
char *what;
{
- unsigned int i;
- char *p;
- p = what;
- for (i = 0; i < str->write_idx && *p; i++)
+ unsigned int i;
+ char *p;
+ p = what;
+ for (i = 0; i < str->write_idx && *p; i++)
{
- if (*p == str->ptr[i])
- p++;
- else
- p = what;
+ if (*p == str->ptr[i])
+ p++;
+ else
+ p = what;
}
- return (*p == 0);
-
+ return (*p == 0);
}
static void
string_type *buffer;
FILE *f;
{
- fwrite(buffer->ptr, buffer->write_idx, 1, f);
+ fwrite (buffer->ptr, buffer->write_idx, 1, f);
}
-
static void
delete_string (buffer)
string_type *buffer;
{
- free(buffer->ptr);
+ free (buffer->ptr);
}
-
static char *
addr (buffer, idx)
string_type *buffer;
unsigned int idx;
{
- return buffer->ptr + idx;
+ return buffer->ptr + idx;
}
static char
string_type *buffer;
unsigned int pos;
{
- if (pos >= buffer->write_idx)
+ if (pos >= buffer->write_idx)
return 0;
return buffer->ptr[pos];
}
string_type *buffer;
int ch;
{
- if (buffer->write_idx == buffer->size)
+ if (buffer->write_idx == buffer->size)
{
- buffer->size *=2;
- buffer->ptr = realloc(buffer->ptr, buffer->size);
+ buffer->size *= 2;
+ buffer->ptr = realloc (buffer->ptr, buffer->size);
}
- buffer->ptr[buffer->write_idx ++ ] = ch;
+ buffer->ptr[buffer->write_idx++] = ch;
}
-
static void
overwrite_string (dst, src)
string_type *dst;
string_type *src;
{
- free(dst->ptr);
- dst->size = src->size;
- dst->write_idx = src->write_idx;
- dst->ptr = src->ptr;
+ free (dst->ptr);
+ dst->size = src->size;
+ dst->write_idx = src->write_idx;
+ dst->ptr = src->ptr;
}
static void
catbuf (dst, src->ptr, src->write_idx);
}
-
-static unsigned int
+static unsigned int
skip_white_and_stars (src, idx)
string_type *src;
unsigned int idx;
{
char c;
- while ((c = at(src,idx)),
+ while ((c = at (src, idx)),
isspace ((unsigned char) c)
|| (c == '*'
/* Don't skip past end-of-comment or star as first
character on its line. */
- && at(src,idx +1) != '/'
- && at(src,idx -1) != '\n'))
+ && at (src, idx +1) != '/'
+ && at (src, idx -1) != '\n'))
idx++;
return idx;
}
/***********************************************************************/
-
string_type stack[STACK];
string_type *tos;
typedef int *word_type;
-
-
struct dict_struct
{
- char *word;
- struct dict_struct *next;
- stinst_type *code;
- int code_length;
- int code_end;
- int var;
-
+ char *word;
+ struct dict_struct *next;
+ stinst_type *code;
+ int code_length;
+ int code_end;
+ int var;
};
+
typedef struct dict_struct dict_type;
+
#define WORD(x) static void x()
static void
dict_type *word;
{
pc = word->code;
- while (*pc)
- (*pc)();
+ while (*pc)
+ (*pc) ();
}
-WORD(call)
-{
- stinst_type *oldpc = pc;
- dict_type *e;
- e = (dict_type *)(pc [1]);
- exec(e);
- pc = oldpc + 2;
-
+
+WORD (call)
+{
+ stinst_type *oldpc = pc;
+ dict_type *e;
+ e = (dict_type *) (pc[1]);
+ exec (e);
+ pc = oldpc + 2;
}
-WORD(remchar)
+WORD (remchar)
{
if (tos->write_idx)
- tos->write_idx--;
+ tos->write_idx--;
pc++;
}
pc++;
}
-WORD(push_number)
+WORD (push_number)
{
- isp++;
- icheck_range ();
- pc++;
- *isp = (long)(*pc);
- pc++;
+ isp++;
+ icheck_range ();
+ pc++;
+ *isp = (long) (*pc);
+ pc++;
}
-WORD(push_text)
+WORD (push_text)
{
- tos++;
- check_range ();
- init_string(tos);
- pc++;
- cattext(tos,*((char **)pc));
- pc++;
-
+ tos++;
+ check_range ();
+ init_string (tos);
+ pc++;
+ cattext (tos, *((char **) pc));
+ pc++;
}
-
/* This function removes everything not inside comments starting on
the first char of the line from the string, also when copying
comments, removes blank space and leading *'s.
Blank lines are turned into one blank line. */
-static void
-remove_noncomments (src,dst)
+static void
+remove_noncomments (src, dst)
string_type *src;
string_type *dst;
{
- unsigned int idx = 0;
-
- while (at(src,idx))
+ unsigned int idx = 0;
+
+ while (at (src, idx))
{
- /* Now see if we have a comment at the start of the line */
- if (at(src,idx) == '\n'
- && at(src,idx+1) == '/'
- && at(src,idx+2) == '*')
+ /* Now see if we have a comment at the start of the line. */
+ if (at (src, idx) == '\n'
+ && at (src, idx + 1) == '/'
+ && at (src, idx + 2) == '*')
{
- idx+=3;
-
- idx = skip_white_and_stars(src,idx);
-
- /* Remove leading dot */
- if (at(src, idx) == '.')
- idx++;
-
- /* Copy to the end of the line, or till the end of the
- comment */
- while (at(src, idx))
+ idx += 3;
+
+ idx = skip_white_and_stars (src, idx);
+
+ /* Remove leading dot */
+ if (at (src, idx) == '.')
+ idx++;
+
+ /* Copy to the end of the line, or till the end of the
+ comment. */
+ while (at (src, idx))
{
- if (at(src, idx) == '\n')
+ if (at (src, idx) == '\n')
{
- /* end of line, echo and scrape of leading blanks */
- if (at(src,idx +1) == '\n')
- catchar(dst,'\n');
- catchar(dst,'\n');
- idx++;
- idx = skip_white_and_stars(src, idx);
+ /* end of line, echo and scrape of leading blanks */
+ if (at (src, idx + 1) == '\n')
+ catchar (dst, '\n');
+ catchar (dst, '\n');
+ idx++;
+ idx = skip_white_and_stars (src, idx);
}
- else if (at(src, idx) == '*' && at(src,idx+1) == '/')
+ else if (at (src, idx) == '*' && at (src, idx + 1) == '/')
{
- idx +=2 ;
- cattext(dst,"\nENDDD\n");
- break;
+ idx += 2;
+ cattext (dst, "\nENDDD\n");
+ break;
}
- else
+ else
{
- catchar(dst, at(src, idx));
- idx++;
+ catchar (dst, at (src, idx));
+ idx++;
}
}
}
- else idx++;
+ else
+ idx++;
}
}
static void
paramstuff (void)
{
- unsigned int openp;
- unsigned int fname;
- unsigned int idx;
- string_type out;
- init_string(&out);
-
+ unsigned int openp;
+ unsigned int fname;
+ unsigned int idx;
+ string_type out;
+ init_string (&out);
- /* make sure that it's not already param'd or proto'd */
- if(find(tos,"PARAMS") || find(tos,"PROTO") || !find(tos,"(")) {
- catstr(&out,tos);
- }
- else
+ /* Make sure that it's not already param'd or proto'd. */
+ if (find (tos, "PARAMS") || find (tos, "PROTO") || !find (tos, "("))
{
- /* Find the open paren */
- for (openp = 0; at(tos, openp) != '(' && at(tos,openp); openp++)
- ;
-
- fname = openp;
- /* Step back to the fname */
+ catstr (&out, tos);
+ }
+ else
+ {
+ /* Find the open paren. */
+ for (openp = 0; at (tos, openp) != '(' && at (tos, openp); openp++)
+ ;
+
+ fname = openp;
+ /* Step back to the fname. */
+ fname--;
+ while (fname && isspace ((unsigned char) at (tos, fname)))
+ fname--;
+ while (fname
+ && !isspace ((unsigned char) at (tos,fname))
+ && at (tos,fname) != '*')
fname--;
- while (fname && isspace((unsigned char) at(tos, fname)))
- fname --;
- while (fname
- && !isspace((unsigned char) at(tos,fname))
- && at(tos,fname) != '*')
- fname--;
-
- fname++;
-
- for (idx = 0; idx < fname; idx++) /* Output type */
+
+ fname++;
+
+ for (idx = 0; idx < fname; idx++) /* Output type */
{
- catchar(&out, at(tos,idx));
+ catchar (&out, at (tos, idx));
}
-
- cattext(&out, "\n"); /* Insert a newline between type and fnname */
- for (idx = fname; idx < openp; idx++) /* Output fnname */
+ cattext (&out, "\n"); /* Insert a newline between type and fnname */
+
+ for (idx = fname; idx < openp; idx++) /* Output fnname */
{
- catchar(&out, at(tos,idx));
+ catchar (&out, at (tos, idx));
}
- cattext(&out," PARAMS (");
+ cattext (&out, " PARAMS (");
- while (at(tos,idx) && at(tos,idx) !=';')
+ while (at (tos, idx) && at (tos, idx) != ';')
{
- catchar(&out, at(tos, idx));
- idx++;
+ catchar (&out, at (tos, idx));
+ idx++;
}
- cattext(&out,");\n\n");
+ cattext (&out, ");\n\n");
}
- overwrite_string(tos, &out);
- pc++;
-
-}
-
+ overwrite_string (tos, &out);
+ pc++;
+}
/* turn {*
and *} into comments */
-WORD(translatecomments)
+WORD (translatecomments)
{
- unsigned int idx = 0;
- string_type out;
- init_string(&out);
-
- while (at(tos, idx))
+ unsigned int idx = 0;
+ string_type out;
+ init_string (&out);
+
+ while (at (tos, idx))
{
- if (at(tos,idx) == '{' && at(tos,idx+1) =='*')
+ if (at (tos, idx) == '{' && at (tos, idx + 1) == '*')
{
- cattext(&out,"/*");
- idx+=2;
+ cattext (&out, "/*");
+ idx += 2;
}
- else if (at(tos,idx) == '*' && at(tos,idx+1) =='}')
+ else if (at (tos, idx) == '*' && at (tos, idx + 1) == '}')
{
- cattext(&out,"*/");
- idx+=2;
+ cattext (&out, "*/");
+ idx += 2;
}
- else
+ else
{
- catchar(&out, at(tos, idx));
- idx++;
+ catchar (&out, at (tos, idx));
+ idx++;
}
}
+ overwrite_string (tos, &out);
- overwrite_string(tos, &out);
-
- pc++;
-
+ pc++;
}
#if 0
/* turn everything not starting with a . into a comment */
-WORD(manglecomments)
+WORD (manglecomments)
{
- unsigned int idx = 0;
- string_type out;
- init_string(&out);
-
- while (at(tos, idx))
+ unsigned int idx = 0;
+ string_type out;
+ init_string (&out);
+
+ while (at (tos, idx))
{
- if (at(tos,idx) == '\n' && at(tos,idx+1) =='*')
+ if (at (tos, idx) == '\n' && at (tos, idx + 1) == '*')
{
- cattext(&out," /*");
- idx+=2;
+ cattext (&out, " /*");
+ idx += 2;
}
- else if (at(tos,idx) == '*' && at(tos,idx+1) =='}')
+ else if (at (tos, idx) == '*' && at (tos, idx + 1) == '}')
{
- cattext(&out,"*/");
- idx+=2;
+ cattext (&out, "*/");
+ idx += 2;
}
- else
+ else
{
- catchar(&out, at(tos, idx));
- idx++;
+ catchar (&out, at (tos, idx));
+ idx++;
}
}
+ overwrite_string (tos, &out);
- overwrite_string(tos, &out);
-
- pc++;
-
+ pc++;
}
#endif
static void
outputdots (void)
{
- unsigned int idx = 0;
- string_type out;
- init_string(&out);
-
- while (at(tos, idx))
+ unsigned int idx = 0;
+ string_type out;
+ init_string (&out);
+
+ while (at (tos, idx))
{
- if (at(tos, idx) == '\n' && at(tos, idx+1) == '.')
+ if (at (tos, idx) == '\n' && at (tos, idx + 1) == '.')
{
char c;
idx += 2;
-
- while ((c = at(tos, idx)) && c != '\n')
+
+ while ((c = at (tos, idx)) && c != '\n')
{
- if (c == '{' && at(tos,idx+1) =='*')
+ if (c == '{' && at (tos, idx + 1) == '*')
{
- cattext(&out,"/*");
- idx+=2;
+ cattext (&out, "/*");
+ idx += 2;
}
- else if (c == '*' && at(tos,idx+1) =='}')
+ else if (c == '*' && at (tos, idx + 1) == '}')
{
- cattext(&out,"*/");
- idx+=2;
+ cattext (&out, "*/");
+ idx += 2;
}
else
{
- catchar(&out, c);
- idx++;
+ catchar (&out, c);
+ idx++;
}
}
- catchar(&out,'\n');
+ catchar (&out, '\n');
}
- else
+ else
{
- idx++;
+ idx++;
}
- }
+ }
- overwrite_string(tos, &out);
- pc++;
-
+ overwrite_string (tos, &out);
+ pc++;
}
/* Find lines starting with . and | and put example around them on tos */
-WORD(courierize)
-{
- string_type out;
- unsigned int idx = 0;
- int command = 0;
-
- init_string(&out);
-
- while (at(tos, idx))
+WORD (courierize)
+{
+ string_type out;
+ unsigned int idx = 0;
+ int command = 0;
+
+ init_string (&out);
+
+ while (at (tos, idx))
{
- if (at(tos, idx) == '\n'
- && (at(tos, idx +1 ) == '.'
- || at(tos,idx+1) == '|'))
+ if (at (tos, idx) == '\n'
+ && (at (tos, idx +1 ) == '.'
+ || at (tos, idx + 1) == '|'))
{
- cattext(&out,"\n@example\n");
- do
+ cattext (&out, "\n@example\n");
+ do
{
- idx += 2;
-
- while (at(tos, idx) && at(tos, idx)!='\n')
+ idx += 2;
+
+ while (at (tos, idx) && at (tos, idx) != '\n')
{
- if (at(tos,idx)=='{' && at(tos,idx+1) =='*')
+ if (at (tos, idx) == '{' && at (tos, idx + 1) == '*')
{
- cattext(&out,"/*");
- idx+=2;
+ cattext (&out, "/*");
+ idx += 2;
}
- else if (at(tos,idx)=='*' && at(tos,idx+1) =='}')
+ else if (at (tos, idx) == '*' && at (tos, idx + 1) == '}')
{
- cattext(&out,"*/");
- idx+=2;
+ cattext (&out, "*/");
+ idx += 2;
}
- else if (at(tos,idx) == '{' && !command)
+ else if (at (tos, idx) == '{' && !command)
{
- cattext(&out,"@{");
- idx++;
+ cattext (&out, "@{");
+ idx++;
}
- else if (at(tos,idx) == '}' && !command)
+ else if (at (tos, idx) == '}' && !command)
{
- cattext(&out,"@}");
- idx++;
+ cattext (&out, "@}");
+ idx++;
}
- else
+ else
{
- if (at(tos,idx) == '@')
- command = 1;
- else if (isspace((unsigned char) at(tos,idx))
- || at(tos,idx) == '}')
- command = 0;
- catchar(&out, at(tos, idx));
- idx++;
+ if (at (tos, idx) == '@')
+ command = 1;
+ else if (isspace ((unsigned char) at (tos, idx))
+ || at (tos, idx) == '}')
+ command = 0;
+ catchar (&out, at (tos, idx));
+ idx++;
}
-
+
}
- catchar(&out,'\n');
- }
- while (at(tos, idx) == '\n'
- && ((at(tos, idx+1) == '.')
- || (at(tos,idx+1) == '|')))
- ;
- cattext(&out,"@end example");
+ catchar (&out, '\n');
+ }
+ while (at (tos, idx) == '\n'
+ && ((at (tos, idx + 1) == '.')
+ || (at (tos, idx + 1) == '|')))
+ ;
+ cattext (&out, "@end example");
}
- else
- {
- catchar(&out, at(tos, idx));
- idx++;
+ else
+ {
+ catchar (&out, at (tos, idx));
+ idx++;
}
- }
-
- overwrite_string(tos, &out);
- pc++;
+ }
-
+ overwrite_string (tos, &out);
+ pc++;
}
/* Finds any lines starting with "o ", if there are any, then turns
on @itemize @bullet, and @items each of them. Then ends with @end
itemize, inplace at TOS*/
-
-WORD(bulletize)
+WORD (bulletize)
{
- unsigned int idx = 0;
- int on = 0;
- string_type out;
- init_string(&out);
-
- while (at(tos, idx)) {
- if (at(tos, idx) == '@' &&
- at(tos, idx+1) == '*')
+ unsigned int idx = 0;
+ int on = 0;
+ string_type out;
+ init_string (&out);
+
+ while (at (tos, idx))
+ {
+ if (at (tos, idx) == '@'
+ && at (tos, idx + 1) == '*')
{
- cattext(&out,"*");
- idx+=2;
+ cattext (&out, "*");
+ idx += 2;
}
-
- else
- if (at(tos, idx) == '\n' &&
- at(tos, idx+1) == 'o' &&
- isspace((unsigned char) at(tos, idx +2)))
+ else if (at (tos, idx) == '\n'
+ && at (tos, idx + 1) == 'o'
+ && isspace ((unsigned char) at (tos, idx + 2)))
+ {
+ if (!on)
{
- if (!on)
- {
- cattext(&out,"\n@itemize @bullet\n");
- on = 1;
-
- }
- cattext(&out,"\n@item\n");
- idx+=3;
+ cattext (&out, "\n@itemize @bullet\n");
+ on = 1;
+
}
- else
+ cattext (&out, "\n@item\n");
+ idx += 3;
+ }
+ else
+ {
+ catchar (&out, at (tos, idx));
+ if (on && at (tos, idx) == '\n'
+ && at (tos, idx + 1) == '\n'
+ && at (tos, idx + 2) != 'o')
{
- catchar(&out, at(tos, idx));
- if (on && at(tos, idx) == '\n' &&
- at(tos, idx+1) == '\n' &&
- at(tos, idx+2) != 'o')
- {
- cattext(&out, "@end itemize");
- on = 0;
- }
- idx++;
-
+ cattext (&out, "@end itemize");
+ on = 0;
}
+ idx++;
+
}
- if (on)
+ }
+ if (on)
{
- cattext(&out,"@end itemize\n");
- }
+ cattext (&out, "@end itemize\n");
+ }
- delete_string(tos);
- *tos = out;
- pc++;
-
+ delete_string (tos);
+ *tos = out;
+ pc++;
}
/* Turn <<foo>> into @code{foo} in place at TOS*/
-
-WORD(do_fancy_stuff)
+WORD (do_fancy_stuff)
{
- unsigned int idx = 0;
- string_type out;
- init_string(&out);
- while (at(tos, idx))
+ unsigned int idx = 0;
+ string_type out;
+ init_string (&out);
+ while (at (tos, idx))
{
- if (at(tos, idx) == '<'
- && at(tos, idx+1) == '<'
- && !isspace((unsigned char) at(tos,idx + 2)))
+ if (at (tos, idx) == '<'
+ && at (tos, idx + 1) == '<'
+ && !isspace ((unsigned char) at (tos, idx + 2)))
{
- /* This qualifies as a << startup */
- idx +=2;
- cattext(&out,"@code{");
- while(at(tos,idx) &&
- at(tos,idx) != '>' )
+ /* This qualifies as a << startup. */
+ idx += 2;
+ cattext (&out, "@code{");
+ while (at (tos, idx)
+ && at (tos, idx) != '>' )
{
- catchar(&out, at(tos, idx));
- idx++;
-
+ catchar (&out, at (tos, idx));
+ idx++;
+
}
- cattext(&out,"}");
- idx+=2;
+ cattext (&out, "}");
+ idx += 2;
}
- else
+ else
{
- catchar(&out, at(tos, idx));
- idx++;
+ catchar (&out, at (tos, idx));
+ idx++;
}
}
- delete_string(tos);
- *tos = out;
- pc++;
-
+ delete_string (tos);
+ *tos = out;
+ pc++;
+
}
-/* A command is all upper case,and alone on a line */
-static int
+
+/* A command is all upper case,and alone on a line. */
+
+static int
iscommand (ptr, idx)
string_type *ptr;
unsigned int idx;
{
- unsigned int len = 0;
- while (at(ptr,idx)) {
- if (isupper((unsigned char) at(ptr,idx)) || at(ptr,idx) == ' ' ||
- at(ptr,idx) == '_')
- {
- len++;
- idx++;
- }
- else if(at(ptr,idx) == '\n')
- {
- if (len > 3) return 1;
- return 0;
- }
- else return 0;
+ unsigned int len = 0;
+ while (at (ptr, idx))
+ {
+ if (isupper ((unsigned char) at (ptr, idx))
+ || at (ptr, idx) == ' ' || at (ptr, idx) == '_')
+ {
+ len++;
+ idx++;
}
- return 0;
-
+ else if (at (ptr, idx) == '\n')
+ {
+ if (len > 3)
+ return 1;
+ return 0;
+ }
+ else
+ return 0;
+ }
+ return 0;
}
-
static int
copy_past_newline (ptr, idx, dst)
string_type *ptr;
unsigned int idx;
string_type *dst;
{
- int column = 0;
+ int column = 0;
- while (at(ptr, idx) && at(ptr, idx) != '\n')
+ while (at (ptr, idx) && at (ptr, idx) != '\n')
{
- if (at (ptr, idx) == '\t')
- {
- /* Expand tabs. Neither makeinfo nor TeX can cope well with
- them. */
- do
- catchar (dst, ' ');
- while (++column & 7);
- }
- else
- {
- catchar(dst, at(ptr, idx));
- column++;
- }
- idx++;
-
- }
- catchar(dst, at(ptr, idx));
- idx++;
- return idx;
+ if (at (ptr, idx) == '\t')
+ {
+ /* Expand tabs. Neither makeinfo nor TeX can cope well with
+ them. */
+ do
+ catchar (dst, ' ');
+ while (++column & 7);
+ }
+ else
+ {
+ catchar (dst, at (ptr, idx));
+ column++;
+ }
+ idx++;
+
+ }
+ catchar (dst, at (ptr, idx));
+ idx++;
+ return idx;
}
-WORD(icopy_past_newline)
+WORD (icopy_past_newline)
{
- tos++;
- check_range ();
- init_string(tos);
- idx = copy_past_newline(ptr, idx, tos);
- pc++;
+ tos++;
+ check_range ();
+ init_string (tos);
+ idx = copy_past_newline (ptr, idx, tos);
+ pc++;
}
/* indent
- Take the string at the top of the stack, do some prettying */
+ Take the string at the top of the stack, do some prettying. */
-
-WORD(kill_bogus_lines)
+WORD (kill_bogus_lines)
{
- int sl ;
-
- int idx = 0;
- int c;
- int dot = 0 ;
-
- string_type out;
- init_string(&out);
- /* Drop leading nl */
- while (at(tos,idx) == '\n')
+ int sl;
+
+ int idx = 0;
+ int c;
+ int dot = 0;
+
+ string_type out;
+ init_string (&out);
+ /* Drop leading nl. */
+ while (at (tos, idx) == '\n')
{
- idx++;
+ idx++;
}
- c = idx;
-
- /* If the first char is a '.' prepend a newline so that it is
- recognized properly later. */
- if (at (tos, idx) == '.')
- catchar (&out, '\n');
-
- /* Find the last char */
- while (at(tos,idx))
+ c = idx;
+
+ /* If the first char is a '.' prepend a newline so that it is
+ recognized properly later. */
+ if (at (tos, idx) == '.')
+ catchar (&out, '\n');
+
+ /* Find the last char. */
+ while (at (tos, idx))
{
- idx++;
+ idx++;
}
-
- /* find the last non white before the nl */
+
+ /* Find the last non white before the nl. */
+ idx--;
+
+ while (idx && isspace ((unsigned char) at (tos, idx)))
idx--;
-
- while (idx && isspace((unsigned char) at(tos,idx)))
- idx--;
- idx++;
-
- /* Copy buffer upto last char, but blank lines before and after
- dots don't count */
- sl = 1;
+ idx++;
- while (c < idx)
+ /* Copy buffer upto last char, but blank lines before and after
+ dots don't count. */
+ sl = 1;
+
+ while (c < idx)
{
- if (at(tos,c) == '\n'
- && at(tos,c+1) == '\n'
- && at(tos,c+2) == '.')
+ if (at (tos, c) == '\n'
+ && at (tos, c + 1) == '\n'
+ && at (tos, c + 2) == '.')
{
- /* Ignore two newlines before a dot*/
- c++;
+ /* Ignore two newlines before a dot. */
+ c++;
}
- else if (at(tos,c) == '.' && sl)
+ else if (at (tos, c) == '.' && sl)
{
- /* remember that this line started with a dot */
- dot=2;
+ /* remember that this line started with a dot. */
+ dot = 2;
}
- else if (at(tos,c) == '\n'
- && at(tos,c+1) == '\n'
- && dot)
+ else if (at (tos, c) == '\n'
+ && at (tos, c + 1) == '\n'
+ && dot)
{
- c++;
- /* Ignore two newlines when last line was dot */
+ c++;
+ /* Ignore two newlines when last line was dot. */
}
- catchar(&out, at(tos,c));
- if (at(tos,c) == '\n')
+ catchar (&out, at (tos, c));
+ if (at (tos, c) == '\n')
{
- sl = 1;
-
- if (dot == 2)dot=1;else dot = 0;
+ sl = 1;
+
+ if (dot == 2)
+ dot = 1;
+ else
+ dot = 0;
}
- else
- sl = 0;
-
- c++;
+ else
+ sl = 0;
+
+ c++;
}
-
- /* Append nl*/
- catchar(&out, '\n');
- pc++;
- delete_string(tos);
- *tos = out;
-
-
+
+ /* Append nl. */
+ catchar (&out, '\n');
+ pc++;
+ delete_string (tos);
+ *tos = out;
+
}
-WORD(indent)
+WORD (indent)
{
- string_type out;
- int tab = 0;
- int idx = 0;
- int ol =0;
- init_string(&out);
- while (at(tos,idx)) {
- switch (at(tos,idx))
+ string_type out;
+ int tab = 0;
+ int idx = 0;
+ int ol = 0;
+ init_string (&out);
+ while (at (tos, idx))
+ {
+ switch (at (tos, idx))
+ {
+ case '\n':
+ cattext (&out, "\n");
+ idx++;
+ if (tab && at (tos, idx))
{
- case '\n':
- cattext(&out,"\n");
- idx++;
- if (tab && at(tos,idx))
- {
- cattext(&out," ");
- }
- ol = 0;
- break;
- case '(':
- tab++;
- if (ol == 0)
- cattext(&out," ");
- idx++;
- cattext(&out,"(");
- ol = 1;
- break;
- case ')':
- tab--;
- cattext(&out,")");
- idx++;
- ol=1;
-
- break;
- default:
- catchar(&out,at(tos,idx));
- ol=1;
-
- idx++;
- break;
+ cattext (&out, " ");
}
- }
+ ol = 0;
+ break;
+ case '(':
+ tab++;
+ if (ol == 0)
+ cattext (&out, " ");
+ idx++;
+ cattext (&out, "(");
+ ol = 1;
+ break;
+ case ')':
+ tab--;
+ cattext (&out, ")");
+ idx++;
+ ol = 1;
+
+ break;
+ default:
+ catchar (&out, at (tos, idx));
+ ol = 1;
+
+ idx++;
+ break;
+ }
+ }
- pc++;
- delete_string(tos);
- *tos = out;
+ pc++;
+ delete_string (tos);
+ *tos = out;
}
-
-WORD(get_stuff_in_command)
+WORD (get_stuff_in_command)
{
- tos++;
- check_range ();
- init_string(tos);
+ tos++;
+ check_range ();
+ init_string (tos);
- while (at(ptr, idx)) {
- if (iscommand(ptr, idx)) break;
- idx = copy_past_newline(ptr, idx, tos);
- }
- pc++;
+ while (at (ptr, idx))
+ {
+ if (iscommand (ptr, idx))
+ break;
+ idx = copy_past_newline (ptr, idx, tos);
+ }
+ pc++;
}
-WORD(swap)
+WORD (swap)
{
- string_type t;
-
- t = tos[0];
- tos[0] = tos[-1];
- tos[-1] =t;
- pc++;
-
+ string_type t;
+
+ t = tos[0];
+ tos[0] = tos[-1];
+ tos[-1] = t;
+ pc++;
}
-WORD(other_dup)
+WORD (other_dup)
{
- tos++;
- check_range ();
- init_string(tos);
- catstr(tos, tos-1);
- pc++;
+ tos++;
+ check_range ();
+ init_string (tos);
+ catstr (tos, tos - 1);
+ pc++;
}
-WORD(drop)
+WORD (drop)
{
tos--;
check_range ();
pc++;
}
-WORD(idrop)
+WORD (idrop)
{
isp--;
icheck_range ();
pc++;
}
-WORD(icatstr)
+WORD (icatstr)
{
- tos--;
- check_range ();
- catstr(tos, tos+1);
- delete_string(tos+1);
- pc++;
+ tos--;
+ check_range ();
+ catstr (tos, tos + 1);
+ delete_string (tos + 1);
+ pc++;
}
-WORD(skip_past_newline)
+WORD (skip_past_newline)
{
- while (at(ptr,idx)
- && at(ptr,idx) != '\n')
- idx++;
+ while (at (ptr, idx)
+ && at (ptr, idx) != '\n')
idx++;
- pc++;
+ idx++;
+ pc++;
}
-
-WORD(internalmode)
+WORD (internalmode)
{
- internal_mode = *(isp);
- isp--;
- icheck_range ();
- pc++;
+ internal_mode = *(isp);
+ isp--;
+ icheck_range ();
+ pc++;
}
-WORD(maybecatstr)
+WORD (maybecatstr)
{
- if (internal_wanted == internal_mode)
+ if (internal_wanted == internal_mode)
{
- catstr(tos-1, tos);
+ catstr (tos - 1, tos);
}
- delete_string(tos);
- tos--;
- check_range ();
- pc++;
+ delete_string (tos);
+ tos--;
+ check_range ();
+ pc++;
}
char *
char *string;
char **word;
{
- char *word_start;
- int idx;
- char *dst;
- char *src;
-
- int length = 0;
-
- while (isspace((unsigned char) *string) || *string == '-') {
- if (*string == '-')
- {
- while (*string && *string != '\n')
- string++;
-
- }
- else {
- string++;
- }
- }
- if (!*string) return 0;
-
- word_start = string;
- if (*string == '"')
- {
- do
- {
- string++;
- length++;
- if (*string == '\\')
- {
- string += 2;
- length += 2;
- }
- }
- while (*string != '"');
- }
- else
- {
- while (!isspace((unsigned char) *string))
+ char *word_start;
+ int idx;
+ char *dst;
+ char *src;
+
+ int length = 0;
+
+ while (isspace ((unsigned char) *string) || *string == '-')
+ {
+ if (*string == '-')
{
+ while (*string && *string != '\n')
string++;
- length++;
-
+
+ }
+ else
+ {
+ string++;
}
}
-
- *word = malloc(length + 1);
-
- dst = *word;
- src = word_start;
-
+ if (!*string)
+ return 0;
- for (idx= 0; idx < length; idx++)
- {
- if (src[idx] == '\\')
- switch (src[idx+1])
+ word_start = string;
+ if (*string == '"')
+ {
+ do
+ {
+ string++;
+ length++;
+ if (*string == '\\')
{
- case 'n':
- *dst++ = '\n';
- idx++;
- break;
- case '"':
- case '\\':
- *dst++ = src[idx+1];
- idx++;
- break;
- default:
- *dst++ = '\\';
- break;
+ string += 2;
+ length += 2;
}
- else
- *dst++ = src[idx];
+ }
+ while (*string != '"');
}
- *dst++ = 0;
+ else
+ {
+ while (!isspace ((unsigned char) *string))
+ {
+ string++;
+ length++;
+ }
+ }
+ *word = malloc (length + 1);
+ dst = *word;
+ src = word_start;
+ for (idx = 0; idx < length; idx++)
+ {
+ if (src[idx] == '\\')
+ switch (src[idx + 1])
+ {
+ case 'n':
+ *dst++ = '\n';
+ idx++;
+ break;
+ case '"':
+ case '\\':
+ *dst++ = src[idx + 1];
+ idx++;
+ break;
+ default:
+ *dst++ = '\\';
+ break;
+ }
+ else
+ *dst++ = src[idx];
+ }
+ *dst++ = 0;
- if(*string)
- return string + 1;
- else
- return 0;
-
+ if (*string)
+ return string + 1;
+ else
+ return 0;
}
+
dict_type *root;
+
dict_type *
lookup_word (word)
char *word;
{
dict_type *ptr = root;
- while (ptr) {
- if (strcmp(ptr->word, word) == 0) return ptr;
+ while (ptr)
+ {
+ if (strcmp (ptr->word, word) == 0)
+ return ptr;
ptr = ptr->next;
-
}
if (warning)
- fprintf(stderr,"Can't find %s\n",word);
+ fprintf (stderr, "Can't find %s\n", word);
return 0;
-
-
}
static void
perform (void)
{
tos = stack;
-
- while (at(ptr, idx)) {
- /* It's worth looking through the command list */
- if (iscommand(ptr, idx))
- {
- char *next;
- dict_type *word ;
-
- (void) nextword(addr(ptr, idx), &next);
+ while (at (ptr, idx))
+ {
+ /* It's worth looking through the command list. */
+ if (iscommand (ptr, idx))
+ {
+ char *next;
+ dict_type *word;
- word = lookup_word(next);
+ (void) nextword (addr (ptr, idx), &next);
+ word = lookup_word (next);
-
+ if (word)
+ {
+ exec (word);
+ }
+ else
+ {
+ if (warning)
+ fprintf (stderr, "warning, %s is not recognised\n", next);
+ skip_past_newline ();
+ }
- if (word)
- {
- exec(word);
}
- else
- {
- if (warning)
- fprintf(stderr,"warning, %s is not recognised\n", next);
- skip_past_newline();
- }
-
- }
- else skip_past_newline();
-
+ else
+ skip_past_newline ();
}
}
newentry (word)
char *word;
{
- dict_type *new = (dict_type *)malloc(sizeof(dict_type));
- new->word = word;
- new->next = root;
- root = new;
- new->code = (stinst_type *)malloc(sizeof(stinst_type ));
- new->code_length = 1;
- new->code_end = 0;
- return new;
-
+ dict_type *new = (dict_type *) malloc (sizeof (dict_type));
+ new->word = word;
+ new->next = root;
+ root = new;
+ new->code = (stinst_type *) malloc (sizeof (stinst_type));
+ new->code_length = 1;
+ new->code_end = 0;
+ return new;
}
-
unsigned int
add_to_definition (entry, word)
dict_type *entry;
stinst_type word;
{
- if (entry->code_end == entry->code_length)
+ if (entry->code_end == entry->code_length)
{
- entry->code_length += 2;
- entry->code =
- (stinst_type *) realloc((char *)(entry->code),
- entry->code_length *sizeof(word_type));
+ entry->code_length += 2;
+ entry->code =
+ (stinst_type *) realloc ((char *) (entry->code),
+ entry->code_length * sizeof (word_type));
}
- entry->code[entry->code_end] = word;
-
-return entry->code_end++;
-}
-
-
-
-
-
+ entry->code[entry->code_end] = word;
+ return entry->code_end++;
+}
void
add_intrinsic (name, func)
char *name;
- void (*func)();
+ void (*func) ();
{
- dict_type *new = newentry(name);
- add_to_definition(new, func);
- add_to_definition(new, 0);
+ dict_type *new = newentry (name);
+ add_to_definition (new, func);
+ add_to_definition (new, 0);
}
void
add_var (name)
char *name;
{
- dict_type *new = newentry(name);
- add_to_definition(new, push_number);
- add_to_definition(new, (stinst_type)(&(new->var)));
- add_to_definition(new,0);
+ dict_type *new = newentry (name);
+ add_to_definition (new, push_number);
+ add_to_definition (new, (stinst_type) (&(new->var)));
+ add_to_definition (new, 0);
}
-
-void
+void
compile (string)
char *string;
{
- /* add words to the dictionary */
- char *word;
- string = nextword(string, &word);
- while (string && *string && word[0])
+ /* Add words to the dictionary. */
+ char *word;
+ string = nextword (string, &word);
+ while (string && *string && word[0])
{
- if (strcmp(word,"var")==0)
+ if (strcmp (word, "var") == 0)
{
- string=nextword(string, &word);
-
- add_var(word);
- string=nextword(string, &word);
+ string = nextword (string, &word);
+
+ add_var (word);
+ string = nextword (string, &word);
}
-else
-
- if (word[0] == ':')
+ else if (word[0] == ':')
{
- dict_type *ptr;
- /* Compile a word and add to dictionary */
- string = nextword(string, &word);
-
- ptr = newentry(word);
- string = nextword(string, &word);
- while (word[0] != ';' )
+ dict_type *ptr;
+ /* Compile a word and add to dictionary. */
+ string = nextword (string, &word);
+
+ ptr = newentry (word);
+ string = nextword (string, &word);
+ while (word[0] != ';')
{
- switch (word[0])
- {
- case '"':
- /* got a string, embed magic push string
- function */
- add_to_definition(ptr, push_text);
- add_to_definition(ptr, (stinst_type)(word+1));
- break;
- case '0':
- case '1':
- case '2':
- case '3':
- case '4':
- case '5':
- case '6':
- case '7':
- case '8':
- case '9':
- /* Got a number, embedd the magic push number
- function */
- add_to_definition(ptr, push_number);
- add_to_definition(ptr, (stinst_type)atol(word));
- break;
- default:
- add_to_definition(ptr, call);
- add_to_definition(ptr, (stinst_type)lookup_word(word));
- }
-
- string = nextword(string, &word);
+ switch (word[0])
+ {
+ case '"':
+ /* got a string, embed magic push string
+ function */
+ add_to_definition (ptr, push_text);
+ add_to_definition (ptr, (stinst_type) (word + 1));
+ break;
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ /* Got a number, embedd the magic push number
+ function */
+ add_to_definition (ptr, push_number);
+ add_to_definition (ptr, (stinst_type) atol (word));
+ break;
+ default:
+ add_to_definition (ptr, call);
+ add_to_definition (ptr, (stinst_type) lookup_word (word));
+ }
+
+ string = nextword (string, &word);
}
- add_to_definition(ptr,0);
- string = nextword(string, &word);
+ add_to_definition (ptr, 0);
+ string = nextword (string, &word);
}
- else
+ else
{
- fprintf(stderr,"syntax error at %s\n",string-1);
- }
+ fprintf (stderr, "syntax error at %s\n", string - 1);
+ }
}
-
}
-
static void
bang (void)
{
- *(long *)((isp[0])) = isp[-1];
- isp-=2;
+ *(long *) ((isp[0])) = isp[-1];
+ isp -= 2;
icheck_range ();
pc++;
}
-WORD(atsign)
+WORD (atsign)
{
- isp[0] = *(long *)(isp[0]);
- pc++;
+ isp[0] = *(long *) (isp[0]);
+ pc++;
}
-WORD(hello)
+WORD (hello)
{
- printf("hello\n");
- pc++;
+ printf ("hello\n");
+ pc++;
}
-WORD(stdout_)
+WORD (stdout_)
{
isp++;
icheck_range ();
pc++;
}
-WORD(stderr_)
+WORD (stderr_)
{
isp++;
icheck_range ();
pc++;
}
-WORD(print)
+WORD (print)
{
if (*isp == 1)
write_buffer (tos, stdout);
pc++;
}
-
static void
read_in (str, file)
- string_type *str;
- FILE *file;
+ string_type *str;
+ FILE *file;
{
- char buff[10000];
- unsigned int r;
- do
+ char buff[10000];
+ unsigned int r;
+ do
{
- r = fread(buff, 1, sizeof(buff), file);
- catbuf(str, buff, r);
+ r = fread (buff, 1, sizeof (buff), file);
+ catbuf (str, buff, r);
}
- while (r);
- buff[0] = 0;
-
- catbuf(str, buff,1);
-}
+ while (r);
+ buff[0] = 0;
+ catbuf (str, buff, 1);
+}
static void
usage (void)
{
- fprintf(stderr,"usage: -[d|i|g] <file >file\n");
- exit(33);
+ fprintf (stderr, "usage: -[d|i|g] <file >file\n");
+ exit (33);
}
/* There is no reliable way to declare exit. Sometimes it returns
}
int
-main (ac,av)
+main (ac, av)
int ac;
char *av[];
{
string_type buffer;
string_type pptr;
- init_string(&buffer);
- init_string(&pptr);
- init_string(stack+0);
- tos=stack+1;
+ init_string (&buffer);
+ init_string (&pptr);
+ init_string (stack + 0);
+ tos = stack + 1;
ptr = &pptr;
-
- add_intrinsic("push_text", push_text);
- add_intrinsic("!", bang);
- add_intrinsic("@", atsign);
- add_intrinsic("hello",hello);
- add_intrinsic("stdout",stdout_);
- add_intrinsic("stderr",stderr_);
- add_intrinsic("print",print);
- add_intrinsic("skip_past_newline", skip_past_newline );
- add_intrinsic("catstr", icatstr );
- add_intrinsic("copy_past_newline", icopy_past_newline );
- add_intrinsic("dup", other_dup );
- add_intrinsic("drop", drop);
- add_intrinsic("idrop", idrop);
- add_intrinsic("remchar", remchar );
- add_intrinsic("get_stuff_in_command", get_stuff_in_command );
- add_intrinsic("do_fancy_stuff", do_fancy_stuff );
- add_intrinsic("bulletize", bulletize );
- add_intrinsic("courierize", courierize );
+
+ add_intrinsic ("push_text", push_text);
+ add_intrinsic ("!", bang);
+ add_intrinsic ("@", atsign);
+ add_intrinsic ("hello", hello);
+ add_intrinsic ("stdout", stdout_);
+ add_intrinsic ("stderr", stderr_);
+ add_intrinsic ("print", print);
+ add_intrinsic ("skip_past_newline", skip_past_newline);
+ add_intrinsic ("catstr", icatstr);
+ add_intrinsic ("copy_past_newline", icopy_past_newline);
+ add_intrinsic ("dup", other_dup);
+ add_intrinsic ("drop", drop);
+ add_intrinsic ("idrop", idrop);
+ add_intrinsic ("remchar", remchar);
+ add_intrinsic ("get_stuff_in_command", get_stuff_in_command);
+ add_intrinsic ("do_fancy_stuff", do_fancy_stuff);
+ add_intrinsic ("bulletize", bulletize);
+ add_intrinsic ("courierize", courierize);
/* If the following line gives an error, exit() is not declared in the
../hosts/foo.h file for this host. Fix it there, not here! */
/* No, don't fix it anywhere; see comment on chew_exit--Ian Taylor. */
- add_intrinsic("exit", chew_exit );
- add_intrinsic("swap", swap );
- add_intrinsic("outputdots", outputdots );
- add_intrinsic("paramstuff", paramstuff );
- add_intrinsic("maybecatstr", maybecatstr );
- add_intrinsic("translatecomments", translatecomments );
- add_intrinsic("kill_bogus_lines", kill_bogus_lines);
- add_intrinsic("indent", indent);
- add_intrinsic("internalmode", internalmode);
- add_intrinsic("print_stack_level", print_stack_level);
- add_intrinsic("strip_trailing_newlines", strip_trailing_newlines);
-
- /* Put a nl at the start */
- catchar(&buffer,'\n');
-
- read_in(&buffer, stdin);
- remove_noncomments(&buffer, ptr);
- for (i= 1; i < (unsigned int) ac; i++)
- {
- if (av[i][0] == '-')
+ add_intrinsic ("exit", chew_exit);
+ add_intrinsic ("swap", swap);
+ add_intrinsic ("outputdots", outputdots);
+ add_intrinsic ("paramstuff", paramstuff);
+ add_intrinsic ("maybecatstr", maybecatstr);
+ add_intrinsic ("translatecomments", translatecomments);
+ add_intrinsic ("kill_bogus_lines", kill_bogus_lines);
+ add_intrinsic ("indent", indent);
+ add_intrinsic ("internalmode", internalmode);
+ add_intrinsic ("print_stack_level", print_stack_level);
+ add_intrinsic ("strip_trailing_newlines", strip_trailing_newlines);
+
+ /* Put a nl at the start. */
+ catchar (&buffer, '\n');
+
+ read_in (&buffer, stdin);
+ remove_noncomments (&buffer, ptr);
+ for (i = 1; i < (unsigned int) ac; i++)
{
- if (av[i][1] == 'f')
- {
- string_type b;
- FILE *f;
- init_string(&b);
-
- f = fopen(av[i+1],"r");
- if (!f)
+ if (av[i][0] == '-')
{
- fprintf(stderr,"Can't open the input file %s\n",av[i+1]);
- return 33;
- }
+ if (av[i][1] == 'f')
+ {
+ string_type b;
+ FILE *f;
+ init_string (&b);
- read_in(&b, f);
- compile(b.ptr);
- perform();
- }
- else if (av[i][1] == 'i')
- {
- internal_wanted = 1;
- }
- else if (av[i][1] == 'w')
- {
- warning = 1;
- }
- else
- usage ();
+ f = fopen (av[i + 1], "r");
+ if (!f)
+ {
+ fprintf (stderr, "Can't open the input file %s\n",
+ av[i + 1]);
+ return 33;
+ }
+
+ read_in (&b, f);
+ compile (b.ptr);
+ perform ();
+ }
+ else if (av[i][1] == 'i')
+ {
+ internal_wanted = 1;
+ }
+ else if (av[i][1] == 'w')
+ {
+ warning = 1;
+ }
+ else
+ usage ();
+ }
}
- }
- write_buffer(stack+0, stdout);
+ write_buffer (stack + 0, stdout);
if (tos != stack)
{
- fprintf (stderr, "finishing with current stack level %d\n", tos - stack);
+ fprintf (stderr, "finishing with current stack level %d\n",
+ tos - stack);
return 1;
}
return 0;
projects / binutils-gdb.git / commitdiff