import gdb-1999-07-07 post reformat

1 files changed, 154 insertions, 147 deletions

diff --git a/gdb/ax.h b/gdb/ax.h
index 069dd99750..0467626aeb 100644
--- a/gdb/ax.h
+++ b/gdb/ax.h
@@ -1,21 +1,22 @@
 /* Definitions for expressions designed to be executed on the agent
    Copyright 1998 Free Software Foundation, Inc.
 
-This file is part of GDB.
+   This file is part of GDB.
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
 
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
 
 #ifndef AGENTEXPR_H
 #define AGENTEXPR_H
@@ -47,8 +48,8 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
    is independent of symbolic information.  This means the agent can
    evaluate them on the fly without reference to data only available
    to the host GDB.  */
-
 
+
 /* Agent expression data structures.  */
 
 /* The type of an element of the agent expression stack.
@@ -56,18 +57,20 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
    the value itself has no typing information.  GDB generates all
    bytecode streams, so we don't have to worry about type errors.  */
 
-union agent_val {
-  LONGEST l;
-  DOUBLEST d;
-};
+union agent_val
+  {
+    LONGEST l;
+    DOUBLEST d;
+  };
 
 /* A buffer containing a agent expression.  */
-struct agent_expr {
-  unsigned char *buf;
-  int len;			/* number of characters used */
-  int size;			/* allocated size */
-  CORE_ADDR scope;
-};
+struct agent_expr
+  {
+    unsigned char *buf;
+    int len;			/* number of characters used */
+    int size;			/* allocated size */
+    CORE_ADDR scope;
+  };
 
 
 
@@ -82,56 +85,57 @@ struct agent_expr {
    agentexpr.h behaves like an opcode map.  If you want to see them
    grouped logically, see doc/agentexpr.texi.  */
 
-enum agent_op {
-  aop_float = 0x01,
-  aop_add = 0x02,
-  aop_sub = 0x03,
-  aop_mul = 0x04,
-  aop_div_signed = 0x05,
-  aop_div_unsigned = 0x06,
-  aop_rem_signed = 0x07,
-  aop_rem_unsigned = 0x08,
-  aop_lsh = 0x09,
-  aop_rsh_signed = 0x0a,
-  aop_rsh_unsigned = 0x0b,
-  aop_trace = 0x0c,
-  aop_trace_quick = 0x0d,
-  aop_log_not = 0x0e,
-  aop_bit_and = 0x0f,
-  aop_bit_or = 0x10,
-  aop_bit_xor = 0x11,
-  aop_bit_not = 0x12,
-  aop_equal = 0x13,
-  aop_less_signed = 0x14,
-  aop_less_unsigned = 0x15,
-  aop_ext = 0x16,
-  aop_ref8 = 0x17,
-  aop_ref16 = 0x18,
-  aop_ref32 = 0x19,
-  aop_ref64 = 0x1a,
-  aop_ref_float = 0x1b,
-  aop_ref_double = 0x1c,
-  aop_ref_long_double = 0x1d,
-  aop_l_to_d = 0x1e,
-  aop_d_to_l = 0x1f,
-  aop_if_goto = 0x20,
-  aop_goto = 0x21,
-  aop_const8 = 0x22,
-  aop_const16 = 0x23,
-  aop_const32 = 0x24,
-  aop_const64 = 0x25,
-  aop_reg = 0x26,
-  aop_end = 0x27,
-  aop_dup = 0x28,
-  aop_pop = 0x29,
-  aop_zero_ext = 0x2a,
-  aop_swap = 0x2b,
-  aop_trace16 = 0x30,
-  aop_last
-};
+enum agent_op
+  {
+    aop_float = 0x01,
+    aop_add = 0x02,
+    aop_sub = 0x03,
+    aop_mul = 0x04,
+    aop_div_signed = 0x05,
+    aop_div_unsigned = 0x06,
+    aop_rem_signed = 0x07,
+    aop_rem_unsigned = 0x08,
+    aop_lsh = 0x09,
+    aop_rsh_signed = 0x0a,
+    aop_rsh_unsigned = 0x0b,
+    aop_trace = 0x0c,
+    aop_trace_quick = 0x0d,
+    aop_log_not = 0x0e,
+    aop_bit_and = 0x0f,
+    aop_bit_or = 0x10,
+    aop_bit_xor = 0x11,
+    aop_bit_not = 0x12,
+    aop_equal = 0x13,
+    aop_less_signed = 0x14,
+    aop_less_unsigned = 0x15,
+    aop_ext = 0x16,
+    aop_ref8 = 0x17,
+    aop_ref16 = 0x18,
+    aop_ref32 = 0x19,
+    aop_ref64 = 0x1a,
+    aop_ref_float = 0x1b,
+    aop_ref_double = 0x1c,
+    aop_ref_long_double = 0x1d,
+    aop_l_to_d = 0x1e,
+    aop_d_to_l = 0x1f,
+    aop_if_goto = 0x20,
+    aop_goto = 0x21,
+    aop_const8 = 0x22,
+    aop_const16 = 0x23,
+    aop_const32 = 0x24,
+    aop_const64 = 0x25,
+    aop_reg = 0x26,
+    aop_end = 0x27,
+    aop_dup = 0x28,
+    aop_pop = 0x29,
+    aop_zero_ext = 0x2a,
+    aop_swap = 0x2b,
+    aop_trace16 = 0x30,
+    aop_last
+  };
+
 
 
-
 /* Functions for building expressions.  */
 
 /* Allocate a new, empty agent expression.  */
@@ -141,19 +145,19 @@ extern struct agent_expr *new_agent_expr PARAMS ((CORE_ADDR));
 extern void free_agent_expr PARAMS ((struct agent_expr *));
 
 /* Append a simple operator OP to EXPR.  */
-extern void ax_simple PARAMS ((struct agent_expr *EXPR, enum agent_op OP));
+extern void ax_simple PARAMS ((struct agent_expr * EXPR, enum agent_op OP));
 
 /* Append the floating-point prefix, for the next bytecode.  */
 #define ax_float(EXPR) (ax_simple ((EXPR), aop_float))
 
 /* Append a sign-extension instruction to EXPR, to extend an N-bit value.  */
-extern void ax_ext PARAMS ((struct agent_expr *EXPR, int N));
+extern void ax_ext PARAMS ((struct agent_expr * EXPR, int N));
 
 /* Append a zero-extension instruction to EXPR, to extend an N-bit value.  */
-extern void ax_zero_ext PARAMS ((struct agent_expr *EXPR, int N));
+extern void ax_zero_ext PARAMS ((struct agent_expr * EXPR, int N));
 
 /* Append a trace_quick instruction to EXPR, to record N bytes.  */
-extern void ax_trace_quick PARAMS ((struct agent_expr *EXPR, int N));
+extern void ax_trace_quick PARAMS ((struct agent_expr * EXPR, int N));
 
 /* Append a goto op to EXPR.  OP is the actual op (must be aop_goto or
    aop_if_goto).  We assume we don't know the target offset yet,
@@ -161,123 +165,126 @@ extern void ax_trace_quick PARAMS ((struct agent_expr *EXPR, int N));
    for the target, and return the offset in EXPR of that space, so we
    can backpatch it once we do know the target offset.  Use ax_label
    to do the backpatching.  */
-extern int ax_goto PARAMS ((struct agent_expr *EXPR, enum agent_op OP));
+extern int ax_goto PARAMS ((struct agent_expr * EXPR, enum agent_op OP));
 
 /* Suppose a given call to ax_goto returns some value PATCH.  When you
    know the offset TARGET that goto should jump to, call
-	ax_label (EXPR, PATCH, TARGET)
+   ax_label (EXPR, PATCH, TARGET)
    to patch TARGET into the ax_goto instruction.  */
-extern void ax_label PARAMS ((struct agent_expr *EXPR, int patch, int target));
+extern void ax_label PARAMS ((struct agent_expr * EXPR, int patch, int target));
 
 /* Assemble code to push a constant on the stack.  */
-extern void ax_const_l PARAMS ((struct agent_expr *EXPR, LONGEST l));
-extern void ax_const_d PARAMS ((struct agent_expr *EXPR, LONGEST d));
+extern void ax_const_l PARAMS ((struct agent_expr * EXPR, LONGEST l));
+extern void ax_const_d PARAMS ((struct agent_expr * EXPR, LONGEST d));
 
 /* Assemble code to push the value of register number REG on the
    stack.  */
-extern void ax_reg PARAMS ((struct agent_expr *EXPR, int REG));
-
+extern void ax_reg PARAMS ((struct agent_expr * EXPR, int REG));
 
+
 /* Functions for printing out expressions, and otherwise debugging
    things.  */
 
 /* Disassemble the expression EXPR, writing to F.  */
-extern void ax_print PARAMS ((GDB_FILE *f, struct agent_expr *EXPR));
+extern void ax_print PARAMS ((GDB_FILE * f, struct agent_expr * EXPR));
 
 /* An entry in the opcode map.  */
-struct aop_map {
+struct aop_map
+  {
 
-  /* The name of the opcode.  Null means that this entry is not a
-     valid opcode --- a hole in the opcode space.  */
-  char *name;
+    /* The name of the opcode.  Null means that this entry is not a
+       valid opcode --- a hole in the opcode space.  */
+    char *name;
 
-  /* All opcodes take no operands from the bytecode stream, or take
-     unsigned integers of various sizes.  If this is a positive number
-     n, then the opcode is followed by an n-byte operand, which should
-     be printed as an unsigned integer.  If this is zero, then the
-     opcode takes no operands from the bytecode stream.
+    /* All opcodes take no operands from the bytecode stream, or take
+       unsigned integers of various sizes.  If this is a positive number
+       n, then the opcode is followed by an n-byte operand, which should
+       be printed as an unsigned integer.  If this is zero, then the
+       opcode takes no operands from the bytecode stream.
 
-     If we get more complicated opcodes in the future, don't add other
-     magic values of this; that's a crock.  Add an `enum encoding'
-     field to this, or something like that.  */
-  int op_size;
+       If we get more complicated opcodes in the future, don't add other
+       magic values of this; that's a crock.  Add an `enum encoding'
+       field to this, or something like that.  */
+    int op_size;
 
-  /* The size of the data operated upon, in bits, for bytecodes that
-     care about that (ref and const).  Zero for all others.  */
-  int data_size;
+    /* The size of the data operated upon, in bits, for bytecodes that
+       care about that (ref and const).  Zero for all others.  */
+    int data_size;
 
-  /* Number of stack elements consumed, and number produced.  */
-  int consumed, produced;
-};
+    /* Number of stack elements consumed, and number produced.  */
+    int consumed, produced;
+  };
 
 /* Map of the bytecodes, indexed by bytecode number.  */
 extern struct aop_map aop_map[];
 
 /* Different kinds of flaws an agent expression might have, as
    detected by agent_reqs.  */
-enum agent_flaws {
-  agent_flaw_none = 0,		/* code is good */
+enum agent_flaws
+  {
+    agent_flaw_none = 0,	/* code is good */
 
-  /* There is an invalid instruction in the stream.  */
-  agent_flaw_bad_instruction,
+    /* There is an invalid instruction in the stream.  */
+    agent_flaw_bad_instruction,
 
-  /* There is an incomplete instruction at the end of the expression.  */
-  agent_flaw_incomplete_instruction,
+    /* There is an incomplete instruction at the end of the expression.  */
+    agent_flaw_incomplete_instruction,
 
-  /* agent_reqs was unable to prove that every jump target is to a
-     valid offset.  Valid offsets are within the bounds of the
-     expression, and to a valid instruction boundary.  */
-  agent_flaw_bad_jump,
+    /* agent_reqs was unable to prove that every jump target is to a
+       valid offset.  Valid offsets are within the bounds of the
+       expression, and to a valid instruction boundary.  */
+    agent_flaw_bad_jump,
 
-  /* agent_reqs was unable to prove to its satisfaction that, for each
-     jump target location, the stack will have the same height whether
-     that location is reached via a jump or by straight execution.  */
-  agent_flaw_height_mismatch,
+    /* agent_reqs was unable to prove to its satisfaction that, for each
+       jump target location, the stack will have the same height whether
+       that location is reached via a jump or by straight execution.  */
+    agent_flaw_height_mismatch,
 
-  /* agent_reqs was unable to prove that every instruction following
-     an unconditional jump was the target of some other jump.  */
-  agent_flaw_hole
-};
+    /* agent_reqs was unable to prove that every instruction following
+       an unconditional jump was the target of some other jump.  */
+    agent_flaw_hole
+  };
 
 /* Structure describing the requirements of a bytecode expression.  */
-struct agent_reqs {
+struct agent_reqs
+  {
+
+    /* If the following is not equal to agent_flaw_none, the rest of the
+       information in this structure is suspect.  */
+    enum agent_flaws flaw;
 
-  /* If the following is not equal to agent_flaw_none, the rest of the
-     information in this structure is suspect.  */
-  enum agent_flaws flaw;
+    /* Number of elements left on stack at end; may be negative if expr
+       only consumes elements.  */
+    int final_height;
 
-  /* Number of elements left on stack at end; may be negative if expr
-     only consumes elements.  */
-  int final_height;
+    /* Maximum and minimum stack height, relative to initial height.  */
+    int max_height, min_height;
 
-  /* Maximum and minimum stack height, relative to initial height.  */
-  int max_height, min_height;
+    /* Largest `ref' or `const' opcode used, in bits.  Zero means the
+       expression has no such instructions.  */
+    int max_data_size;
 
-  /* Largest `ref' or `const' opcode used, in bits.  Zero means the
-     expression has no such instructions.  */
-  int max_data_size;
+    /* Bit vector of registers used.  Register R is used iff
 
-  /* Bit vector of registers used.  Register R is used iff
-  
-	reg_mask[R / 8] & (1 << (R % 8))
+       reg_mask[R / 8] & (1 << (R % 8))
 
-     is non-zero.  Note!  You may not assume that this bitmask is long
-     enough to hold bits for all the registers of the machine; the
-     agent expression code has no idea how many registers the machine
-     has.  However, the bitmask is reg_mask_len bytes long, so the
-     valid register numbers run from 0 to reg_mask_len * 8 - 1.  
+       is non-zero.  Note!  You may not assume that this bitmask is long
+       enough to hold bits for all the registers of the machine; the
+       agent expression code has no idea how many registers the machine
+       has.  However, the bitmask is reg_mask_len bytes long, so the
+       valid register numbers run from 0 to reg_mask_len * 8 - 1.  
 
-     We're assuming eight-bit bytes.  So sue me.
+       We're assuming eight-bit bytes.  So sue me.
 
-     The caller should free reg_list when done.  */
-  int reg_mask_len;
-  unsigned char *reg_mask;
-};
+       The caller should free reg_list when done.  */
+    int reg_mask_len;
+    unsigned char *reg_mask;
+  };
 
 
 /* Given an agent expression AX, fill in an agent_reqs structure REQS
    describing it.  */
-extern void ax_reqs PARAMS ((struct agent_expr *ax,
-			     struct agent_reqs *reqs));
+extern void ax_reqs PARAMS ((struct agent_expr * ax,
+			     struct agent_reqs * reqs));
 
 #endif /* AGENTEXPR_H */