* expr.c: Fix formatting.
* flonum-copy.c: Likewise.
* flonum.h: Likewise.
* gasp.c: Likewise.
* hash.c: Likewise.
+2000-10-30 Kazu Hirata <kazu@hxi.com>
+
+ * expr.c: Fix formatting.
+ * flonum-copy.c: Likewise.
+ * flonum.h: Likewise.
+ * gasp.c: Likewise.
+ * hash.c: Likewise.
+
2000-10-30 Hans-Peter Nilsson <hp@bitrange.com>
* as.h (OPTION_MD_BASE): Bump to 190.
#undef __
#define __ O_illegal
-static const operatorT op_encoding[256] =
-{ /* Maps ASCII -> operators. */
-
+/* Maps ASCII -> operators. */
+static const operatorT op_encoding[256] = {
__, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
__, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with GAS; see the file COPYING. If not, write to
- the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+ along with GAS; see the file COPYING. If not, write to the Free
+ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA. */
#include "as.h"
FLONUM_TYPE *in;
FLONUM_TYPE *out;
{
- unsigned int in_length; /* 0 origin */
- unsigned int out_length; /* 0 origin */
+ unsigned int in_length; /* 0 origin */
+ unsigned int out_length; /* 0 origin */
out->sign = in->sign;
in_length = in->leader - in->low;
else
{
out_length = out->high - out->low;
- /*
- * Assume no GAPS in packing of littlenums.
- * I.e. sizeof(array) == sizeof(element) * number_of_elements.
- */
+ /* Assume no GAPS in packing of littlenums.
+ I.e. sizeof(array) == sizeof(element) * number_of_elements. */
if (in_length <= out_length)
{
{
- /*
- * For defensive programming, zero any high-order littlenums we don't need.
- * This is destroying evidence and wasting time, so why bother???
- */
+ /* For defensive programming, zero any high-order
+ littlenums we don't need. This is destroying evidence
+ and wasting time, so why bother??? */
if (in_length < out_length)
{
- memset ((char *) (out->low + in_length + 1), '\0', out_length - in_length);
+ memset ((char *) (out->low + in_length + 1), '\0',
+ out_length - in_length);
}
}
- memcpy ((void *) (out->low), (void *) (in->low), ((in_length + 1) * sizeof (LITTLENUM_TYPE)));
+ memcpy ((void *) (out->low), (void *) (in->low),
+ ((in_length + 1) * sizeof (LITTLENUM_TYPE)));
out->exponent = in->exponent;
out->leader = in->leader - in->low + out->low;
}
shorten = in_length - out_length;
/* Assume out_length >= 0 ! */
- memcpy ((void *) (out->low), (void *) (in->low + shorten), ((out_length + 1) * sizeof (LITTLENUM_TYPE)));
+ memcpy ((void *) (out->low), (void *) (in->low + shorten),
+ ((out_length + 1) * sizeof (LITTLENUM_TYPE)));
out->leader = out->high;
out->exponent = in->exponent + shorten;
}
} /* if any significant bits */
-} /* flonum_copy() */
-
-/* end of flonum_copy.c */
+}
A sign value of 'P' means we've been asked to assemble +Inf
A sign value of 'N' means we've been asked to assemble -Inf
*/
-struct FLONUM_STRUCT
-{
+struct FLONUM_STRUCT {
LITTLENUM_TYPE *low; /* low order littlenum of a bignum */
LITTLENUM_TYPE *high; /* high order littlenum of a bignum */
LITTLENUM_TYPE *leader; /* -> 1st non-zero littlenum */
extern const FLONUM_TYPE flonum_positive_powers_of_ten[];
extern const FLONUM_TYPE flonum_negative_powers_of_ten[];
extern const int table_size_of_flonum_powers_of_ten;
-/* Flonum_XXX_powers_of_ten[] table has */
-/* legal indices from 0 to */
-/* + this number inclusive. */
+/* Flonum_XXX_powers_of_ten[] table has legal indices from 0 to
+ + this number inclusive. */
/***********************************************************************\
* *
a bug in the user's macro structure. */
#define IFNESTING 100
-struct
-{
+struct {
int on; /* Is the level being output. */
int hadelse; /* Has an aelse been seen. */
-}
-ifstack[IFNESTING];
+} ifstack[IFNESTING];
+
int ifi;
/* The final and intermediate results of expression evaluation are kept in
exp_t's. Note that a symbol is not an sb, but a pointer into the input
line. It must be coped somewhere safe before the next line is read in. */
-typedef struct
-{
+typedef struct {
char *name;
int len;
-}
-symbol;
+} symbol;
-typedef struct
-{
+typedef struct {
int value; /* Constant part. */
symbol add_symbol; /* Name part. */
symbol sub_symbol; /* Name part. */
-}
-exp_t;
+} exp_t;
/* Hashing is done in a pretty standard way. A hash_table has a
pointer to a vector of pointers to hash_entrys, and the size of the
with the same hash are kept in a chain. */
/* What the data in a hash_entry means. */
-typedef enum
-{
+typedef enum {
hash_integer, /* Name->integer mapping. */
hash_string, /* Name->string mapping. */
hash_macro, /* Name is a macro. */
hash_formal /* Name is a formal argument. */
} hash_type;
-typedef struct hs
-{
+typedef struct hs {
sb key; /* Symbol name. */
hash_type type; /* Symbol meaning. */
- union
- {
+ union {
sb s;
int i;
struct macro_struct *m;
struct hs *next; /* Next hash_entry with same hash key. */
} hash_entry;
-typedef struct
-{
+typedef struct {
hash_entry **table;
int size;
} hash_table;
the same stack index. If we're being reasonable, we can detect
recusive expansion by checking the index is reasonably small. */
-typedef enum
-{
+typedef enum {
include_file, include_repeat, include_while, include_macro
} include_type;
-struct include_stack
-{
+struct include_stack {
sb pushback; /* Current pushback stream. */
int pushback_index; /* Next char to read from stream. */
FILE *handle; /* Open file. */
int linecount; /* Number of lines read so far. */
include_type type;
int index; /* Index of this layer. */
-}
-include_stack[MAX_INCLUDES];
+} include_stack[MAX_INCLUDES];
struct include_stack *sp;
#define isp (sp - include_stack)
/* Include file list. */
-typedef struct include_path
-{
+typedef struct include_path {
struct include_path *next;
sb path;
-} include_path;
+} include_path;
include_path *paths_head;
include_path *paths_tail;
#define K_IRP (PROCESS|54)
#define K_IRPC (PROCESS|55)
-struct keyword
-{
+struct keyword {
char *name;
int code;
int extra;
};
-static struct keyword kinfo[] =
-{
+static struct keyword kinfo[] = {
{ "EQU", K_EQU, 0 },
{ "ALTERNATE", K_ALTERNATE, 0 },
{ "ASSIGN", K_ASSIGN, 0 },
handle them here as well, in case they are used in a recursive
macro to end the recursion. */
-static struct keyword mrikinfo[] =
-{
+static struct keyword mrikinfo[] = {
{ "IFEQ", K_IFEQ, 0 },
{ "IFNE", K_IFNE, 0 },
{ "IFLT", K_IFLT, 0 },
/* An entry in a hash table. */
-struct hash_entry
-{
+struct hash_entry {
/* Next entry for this hash code. */
struct hash_entry *next;
/* String being hashed. */
/* A hash table. */
-struct hash_control
-{
+struct hash_control {
/* The hash array. */
struct hash_entry **table;
/* The number of slots in the hash table. */
projects / binutils-gdb.git / commitdiff