dtrace: Make D style more D-ish

1 files changed, 298 insertions, 296 deletions

diff --git a/src/v8ustack.d b/src/v8ustack.d
index f55148cfda..9dabfe0481 100644
--- a/src/v8ustack.d
+++ b/src/v8ustack.d
@@ -17,9 +17,9 @@
  * V8 represents small integers (SMI) using the upper 31 bits of a 32/64-bit
  * value.  To extract the actual integer value, we must shift it over.
  */
-#define IS_SMI(value) \
+#define	IS_SMI(value)	\
     ((value & V8_SmiTagMask) == V8_SmiTag)
-#define SMI_VALUE(value) \
+#define	SMI_VALUE(value)	\
     ((uint32_t) ((value) >> V8_SmiValueShift))
 
 /*
@@ -28,143 +28,143 @@
  * pointer (which are normally 01) are used to record GC state.  Of course, we
  * have no idea if we're in GC or not, so we must always normalize the pointer.
  */
-#define V8_MAP_PTR(ptr) \
+#define	V8_MAP_PTR(ptr)		\
     ((ptr & ~V8_HeapObjectTagMask) | V8_HeapObjectTag)
 
 /*
  * Determine the encoding and representation of a V8 string.
  */
-#define V8_TYPE_STRING(type) \
+#define	V8_TYPE_STRING(type)	\
     (((type) & V8_IsNotStringMask) == V8_StringTag)
 
-#define V8_STRENC_ASCII(type) \
+#define	V8_STRENC_ASCII(type)	\
     (((type) & V8_StringEncodingMask) == V8_AsciiStringTag)
 
-#define V8_STRREP_SEQ(type) \
+#define	V8_STRREP_SEQ(type)	\
     (((type) & V8_StringRepresentationMask) == V8_SeqStringTag)
-#define V8_STRREP_CONS(type) \
+#define	V8_STRREP_CONS(type)	\
     (((type) & V8_StringRepresentationMask) == V8_ConsStringTag)
-#define V8_STRREP_EXT(type) \
+#define	V8_STRREP_EXT(type)	\
     (((type) & V8_StringRepresentationMask) == V8_ExternalStringTag)
 
 /*
  * String type predicates
  */
-#define ASCII_SEQSTR(value) \
+#define	ASCII_SEQSTR(value)	\
     (V8_TYPE_STRING(value) && V8_STRENC_ASCII(value) && V8_STRREP_SEQ(value))
 
-#define ASCII_CONSSTR(value) \
+#define	ASCII_CONSSTR(value)	\
     (V8_TYPE_STRING(value) && V8_STRENC_ASCII(value) && V8_STRREP_CONS(value))
 
-#define ASCII_EXTSTR(value) \
+#define	ASCII_EXTSTR(value)	\
     (V8_TYPE_STRING(value) && V8_STRENC_ASCII(value) && V8_STRREP_EXT(value))
 
 /*
  * General helper macros
  */
-#define COPYIN_UINT8(addr) (*(uint8_t*) copyin((addr), sizeof(uint8_t)))
-#define COPYIN_UINT32(addr) (*(uint32_t*) copyin((addr), sizeof(uint32_t)))
-#define COPYIN_UINT64(addr) (*(uint64_t*) copyin((addr), sizeof(uint64_t)))
+#define	COPYIN_UINT8(addr) (*(uint8_t*) copyin((addr), sizeof(uint8_t)))
+#define	COPYIN_UINT32(addr) (*(uint32_t*) copyin((addr), sizeof(uint32_t)))
+#define	COPYIN_UINT64(addr) (*(uint64_t*) copyin((addr), sizeof(uint64_t)))
 
 #if defined(__i386)
-# define COPYIN_PTR(addr) COPYIN_UINT32(addr)
-# define off_t uint32_t
-# define APPEND_PTR(p) APPEND_PTR_32(p)
+# define	COPYIN_PTR(addr) COPYIN_UINT32(addr)
+# define	off_t uint32_t
+# define	APPEND_PTR(p) APPEND_PTR_32(p)
 #else
-# define COPYIN_PTR(addr) COPYIN_UINT64(addr)
-# define off_t uint64_t
-# define APPEND_PTR(p) APPEND_PTR_64(p)
+# define	COPYIN_PTR(addr) COPYIN_UINT64(addr)
+# define	off_t uint64_t
+# define	APPEND_PTR(p) APPEND_PTR_64(p)
 #endif
 
-#define APPEND_CHR(c) (this->buf[this->off++] = (c))
-#define APPEND_CHR4(s0, s1, s2, s3) \
-    APPEND_CHR(s0); \
-    APPEND_CHR(s1); \
-    APPEND_CHR(s2); \
+#define	APPEND_CHR(c)			(this->buf[this->off++] = (c))
+#define	APPEND_CHR4(s0, s1, s2, s3)	\
+    APPEND_CHR(s0);	\
+    APPEND_CHR(s1);	\
+    APPEND_CHR(s2);	\
     APPEND_CHR(s3);
-#define APPEND_CHR8(s0, s1, s2, s3, s4, s5, s6, s7) \
-    APPEND_CHR4(s0, s1, s2, s3) \
+#define	APPEND_CHR8(s0, s1, s2, s3, s4, s5, s6, s7)	\
+    APPEND_CHR4(s0, s1, s2, s3)	\
     APPEND_CHR4(s4, s5, s6, s7)
 
-#define APPEND_DGT(i, d) \
-    (((i) / (d)) ? APPEND_CHR('0' + ((i)/(d) % 10)) : 0)
+#define	APPEND_DGT(i, d)	\
+	(((i) / (d)) ? APPEND_CHR('0' + ((i)/(d) % 10)) : 0)
 
-#define APPEND_NUM(i) \
-    APPEND_DGT((i), 100000); \
-    APPEND_DGT((i), 10000); \
-    APPEND_DGT((i), 1000); \
-    APPEND_DGT((i), 100); \
-    APPEND_DGT((i), 10); \
-    APPEND_DGT((i), 1);
+#define	APPEND_NUM(i)		\
+	APPEND_DGT((i), 100000);	\
+	APPEND_DGT((i), 10000);	\
+	APPEND_DGT((i), 1000);	\
+	APPEND_DGT((i), 100);	\
+	APPEND_DGT((i), 10);	\
+	APPEND_DGT((i), 1);
 
-#define APPEND_HEX(d) \
+#define	APPEND_HEX(d)	\
     APPEND_CHR((d) < 10 ? '0' + (d) : 'a' - 10 + (d))
 
-#define APPEND_PTR_32(p) \
-    APPEND_HEX((p >> 28) & 0xf); \
-    APPEND_HEX((p >> 24) & 0xf); \
-    APPEND_HEX((p >> 20) & 0xf); \
-    APPEND_HEX((p >> 16) & 0xf); \
-    APPEND_HEX((p >> 12) & 0xf); \
-    APPEND_HEX((p >> 8) & 0xf); \
-    APPEND_HEX((p >> 4) & 0xf); \
+#define	APPEND_PTR_32(p)	\
+    APPEND_HEX((p >> 28) & 0xf);	\
+    APPEND_HEX((p >> 24) & 0xf);	\
+    APPEND_HEX((p >> 20) & 0xf);	\
+    APPEND_HEX((p >> 16) & 0xf);	\
+    APPEND_HEX((p >> 12) & 0xf);	\
+    APPEND_HEX((p >> 8) & 0xf);	\
+    APPEND_HEX((p >> 4) & 0xf);	\
     APPEND_HEX((p) & 0xf);
 
-#define APPEND_PTR_64(p) \
-    APPEND_PTR_32(p >> 32) \
+#define	APPEND_PTR_64(p)	\
+    APPEND_PTR_32(p >> 32)	\
     APPEND_PTR_32(p)
 
 /*
  * The following macros are used to output ASCII SeqStrings, ConsStrings, and
  * Node.js ExternalStrings.  To represent each string, we use three fields:
  *
- *    "str":  a pointer to the string itself
+ *    "str":	a pointer to the string itself
  *
- *    "len":  the string length
+ *    "len":	the string length
  *
- *    "attrs":  the type identifier for the string, which indicates the
- *        encoding and representation.  We're only interested in ASCII
- *        encoded strings whose representation is one of:
+ *    "attrs":	the type identifier for the string, which indicates the
+ *    		encoding and representation.  We're only interested in ASCII
+ *    		encoded strings whose representation is one of:
  *
- *  SeqString  stored directly as a char array inside the object
+ *	SeqString	stored directly as a char array inside the object
  *
- *  ConsString  pointer to two strings that should be concatenated
+ *	ConsString	pointer to two strings that should be concatenated
  *
- *   ExternalString  pointer to a char* outside the V8 heap
+ * 	ExternalString	pointer to a char* outside the V8 heap
  */
 
 /*
  * Load "len" and "attrs" for the given "str".
  */
-#define LOAD_STRFIELDS(str, len, attrs) \
-    len = SMI_VALUE(COPYIN_PTR(str + V8_OFF_STR_LENGTH)); \
-    this->map = V8_MAP_PTR(COPYIN_PTR(str + V8_OFF_HEAPOBJ_MAP)); \
+#define	LOAD_STRFIELDS(str, len, attrs)					\
+    len = SMI_VALUE(COPYIN_PTR(str + V8_OFF_STR_LENGTH));	\
+    this->map = V8_MAP_PTR(COPYIN_PTR(str + V8_OFF_HEAPOBJ_MAP));	\
     attrs = COPYIN_UINT8(this->map + V8_OFF_MAP_ATTRS);
 
 /*
  * Print out the given SeqString, or do nothing if the string is not an ASCII
  * SeqString.
  */
-#define APPEND_SEQSTR(str, len, attrs) \
-    dtrace:helper:ustack: \
-    /!this->done && len > 0 && ASCII_SEQSTR(attrs)/ \
-    { \
-      copyinto(str + V8_OFF_STR_CHARS, len, this->buf + this->off); \
-      this->off += len; \
+#define	APPEND_SEQSTR(str, len, attrs) 					\
+    dtrace:helper:ustack:	\
+    /!this->done && len > 0 && ASCII_SEQSTR(attrs)/	\
+    {	\
+	copyinto(str + V8_OFF_STR_CHARS, len, this->buf + this->off);	\
+	this->off += len;						\
     }
 
 /*
  * Print out the given Node.js ExternalString, or do nothing if the string is
  * not an ASCII ExternalString.
  */
-#define APPEND_NODESTR(str, len, attrs) \
-    dtrace:helper:ustack: \
-    /!this->done && len > 0 && ASCII_EXTSTR(attrs)/ \
-    { \
-      this->resource = COPYIN_PTR(str + V8_OFF_EXTSTR_RSRC); \
-      this->dataptr = COPYIN_PTR(this->resource + NODE_OFF_EXTSTR_DATA); \
-      copyinto(this->dataptr, len, this->buf + this->off); \
-      this->off += len; \
+#define	APPEND_NODESTR(str, len, attrs)					\
+    dtrace:helper:ustack:	\
+    /!this->done && len > 0 && ASCII_EXTSTR(attrs)/	\
+    {	\
+	this->resource = COPYIN_PTR(str + V8_OFF_EXTSTR_RSRC);	\
+	this->dataptr = COPYIN_PTR(this->resource + NODE_OFF_EXTSTR_DATA);	\
+	copyinto(this->dataptr, len, this->buf + this->off);			\
+	this->off += len;							\
     }
 
 /*
@@ -180,9 +180,9 @@
  *
  *                   +----  str  ----+
  *                  /                 \                  <--  1st expansion
- *                 / \
+ *                 /                   \
  *              s0                       s7
- *            /    \                  / \
+ *            /    \                  /     \
  *           /      \                /       \           <--  2nd expansion
  *          /        \              /         \
  *        s1          s4          s8           s11
@@ -196,27 +196,27 @@
  * all non-zero-length strings in order (including both internal nodes and
  * leafs in the tree above) to get the final output.
  */
-#define EXPAND_START() \
-    dtrace:helper:ustack: \
-    /!this->done/ \
-    { \
-      this->s0str = this->s1str = this->s2str = (off_t) 0; \
-      this->s3str = this->s4str = this->s5str = (off_t) 0; \
-      this->s6str = this->s7str = this->s8str = (off_t) 0; \
-      this->s9str = this->s10str = this->s11str = (off_t) 0; \
-      this->s12str = this->s13str = (off_t) 0; \
-      \
-      this->s0len = this->s1len = this->s2len = (off_t) 0; \
-      this->s3len = this->s4len = this->s5len = (off_t) 0; \
-      this->s6len = this->s7len = this->s8len = (off_t) 0; \
-      this->s9len = this->s10len = this->s11len = (off_t) 0; \
-      this->s12len = this->s13len = (off_t) 0; \
-      \
-      this->s0attrs = this->s1attrs = this->s2attrs = 0; \
-      this->s3attrs = this->s4attrs = this->s5attrs = 0; \
-      this->s6attrs = this->s7attrs = this->s8attrs = 0; \
-      this->s9attrs = this->s10attrs = this->s11attrs = 0; \
-      this->s12attrs = this->s13attrs = 0; \
+#define	EXPAND_START()							\
+    dtrace:helper:ustack:	\
+    /!this->done/	\
+    {	\
+	this->s0str = this->s1str = this->s2str = (off_t) 0;	\
+	this->s3str = this->s4str = this->s5str = (off_t) 0;	\
+	this->s6str = this->s7str = this->s8str = (off_t) 0;	\
+	this->s9str = this->s10str = this->s11str = (off_t) 0;	\
+	this->s12str = this->s13str = (off_t) 0;	\
+									\
+	this->s0len = this->s1len = this->s2len = (off_t) 0;	\
+	this->s3len = this->s4len = this->s5len = (off_t) 0;	\
+	this->s6len = this->s7len = this->s8len = (off_t) 0;	\
+	this->s9len = this->s10len = this->s11len = (off_t) 0;	\
+	this->s12len = this->s13len = (off_t) 0;	\
+									\
+	this->s0attrs = this->s1attrs = this->s2attrs = 0;		\
+	this->s3attrs = this->s4attrs = this->s5attrs = 0;		\
+	this->s6attrs = this->s7attrs = this->s8attrs = 0;		\
+	this->s9attrs = this->s10attrs = this->s11attrs = 0;		\
+	this->s12attrs = this->s13attrs = 0;				\
     }
 
 /*
@@ -224,62 +224,62 @@
  * strings "s1" (represented by "s1s", "s1l", and "s1a") and "s2" (represented
  * by "s2s", "s2l", "s2a").  If "str" is not a ConsString, do nothing.
  */
-#define EXPAND_STR(str, len, attrs, s1s, s1l, s1a, s2s, s2l, s2a) \
-    dtrace:helper:ustack: \
-    /!this->done && len > 0 && ASCII_CONSSTR(attrs)/ \
-    { \
-      len = 0; \
-      \
-      s1s = COPYIN_PTR(str + V8_OFF_CONSSTR_CAR); \
-      LOAD_STRFIELDS(s1s, s1l, s1a) \
-      \
-      s2s = COPYIN_PTR(str + V8_OFF_CONSSTR_CDR); \
-      LOAD_STRFIELDS(s2s, s2l, s2a) \
+#define	EXPAND_STR(str, len, attrs, s1s, s1l, s1a, s2s, s2l, s2a)	\
+    dtrace:helper:ustack:	\
+    /!this->done && len > 0 && ASCII_CONSSTR(attrs)/	\
+    {	\
+	len = 0;							\
+									\
+	s1s = COPYIN_PTR(str + V8_OFF_CONSSTR_CAR);	\
+	LOAD_STRFIELDS(s1s, s1l, s1a)					\
+									\
+	s2s = COPYIN_PTR(str + V8_OFF_CONSSTR_CDR);	\
+	LOAD_STRFIELDS(s2s, s2l, s2a)					\
     }
 
 /*
  * Print out a ConsString by expanding it up to three levels and printing out
  * the resulting SeqStrings.
  */
-#define APPEND_CONSSTR(str, len, attrs) \
-    EXPAND_START() \
-    EXPAND_STR(str, len, attrs, \
-               this->s0str, this->s0len, this->s0attrs, \
-               this->s7str, this->s7len, this->s7attrs) \
-    EXPAND_STR(this->s0str, this->s0len, this->s0attrs, \
-               this->s1str, this->s1len, this->s1attrs, \
-               this->s4str, this->s4len, this->s4attrs) \
-    EXPAND_STR(this->s1str, this->s1len, this->s1attrs, \
-               this->s2str, this->s2len, this->s2attrs, \
-               this->s3str, this->s3len, this->s3attrs) \
-    EXPAND_STR(this->s4str, this->s4len, this->s4attrs, \
-               this->s5str, this->s5len, this->s5attrs, \
-               this->s6str, this->s6len, this->s6attrs) \
-    EXPAND_STR(this->s7str, this->s7len, this->s7attrs, \
-               this->s8str, this->s8len, this->s8attrs, \
-               this->s11str, this->s11len, this->s11attrs) \
-    EXPAND_STR(this->s8str, this->s8len, this->s8attrs, \
-               this->s9str, this->s9len, this->s9attrs, \
-               this->s10str, this->s10len, this->s10attrs) \
-    EXPAND_STR(this->s11str, this->s11len, this->s11attrs, \
-               this->s12str, this->s12len, this->s12attrs, \
-               this->s13str, this->s13len, this->s13attrs) \
-    \
-    APPEND_SEQSTR(str, len, attrs) \
-    APPEND_SEQSTR(this->s0str, this->s0len, this->s0attrs) \
-    APPEND_SEQSTR(this->s1str, this->s1len, this->s1attrs) \
-    APPEND_SEQSTR(this->s2str, this->s2len, this->s2attrs) \
-    APPEND_SEQSTR(this->s3str, this->s3len, this->s3attrs) \
-    APPEND_SEQSTR(this->s4str, this->s4len, this->s4attrs) \
-    APPEND_SEQSTR(this->s5str, this->s5len, this->s5attrs) \
-    APPEND_SEQSTR(this->s6str, this->s6len, this->s6attrs) \
-    APPEND_SEQSTR(this->s7str, this->s7len, this->s7attrs) \
-    APPEND_SEQSTR(this->s8str, this->s8len, this->s8attrs) \
-    APPEND_SEQSTR(this->s9str, this->s9len, this->s9attrs) \
-    APPEND_SEQSTR(this->s10str, this->s10len, this->s10attrs) \
-    APPEND_SEQSTR(this->s11str, this->s11len, this->s11attrs) \
-    APPEND_SEQSTR(this->s12str, this->s12len, this->s12attrs) \
-    APPEND_SEQSTR(this->s13str, this->s13len, this->s13attrs) \
+#define	APPEND_CONSSTR(str, len, attrs)					\
+	EXPAND_START()							\
+	EXPAND_STR(str, len, attrs,					\
+	    this->s0str, this->s0len, this->s0attrs,			\
+	    this->s7str, this->s7len, this->s7attrs)			\
+	EXPAND_STR(this->s0str, this->s0len, this->s0attrs,		\
+	    this->s1str, this->s1len, this->s1attrs,			\
+	    this->s4str, this->s4len, this->s4attrs)			\
+	EXPAND_STR(this->s1str, this->s1len, this->s1attrs,		\
+	    this->s2str, this->s2len, this->s2attrs,			\
+	    this->s3str, this->s3len, this->s3attrs)			\
+	EXPAND_STR(this->s4str, this->s4len, this->s4attrs,		\
+	    this->s5str, this->s5len, this->s5attrs,			\
+	    this->s6str, this->s6len, this->s6attrs)			\
+	EXPAND_STR(this->s7str, this->s7len, this->s7attrs,		\
+	    this->s8str, this->s8len, this->s8attrs,			\
+	    this->s11str, this->s11len, this->s11attrs)			\
+	EXPAND_STR(this->s8str, this->s8len, this->s8attrs,		\
+	    this->s9str, this->s9len, this->s9attrs,			\
+	    this->s10str, this->s10len, this->s10attrs)			\
+	EXPAND_STR(this->s11str, this->s11len, this->s11attrs,		\
+	    this->s12str, this->s12len, this->s12attrs,			\
+	    this->s13str, this->s13len, this->s13attrs)			\
+									\
+	APPEND_SEQSTR(str, len, attrs)					\
+	APPEND_SEQSTR(this->s0str, this->s0len, this->s0attrs)		\
+	APPEND_SEQSTR(this->s1str, this->s1len, this->s1attrs)		\
+	APPEND_SEQSTR(this->s2str, this->s2len, this->s2attrs)		\
+	APPEND_SEQSTR(this->s3str, this->s3len, this->s3attrs)		\
+	APPEND_SEQSTR(this->s4str, this->s4len, this->s4attrs)		\
+	APPEND_SEQSTR(this->s5str, this->s5len, this->s5attrs)		\
+	APPEND_SEQSTR(this->s6str, this->s6len, this->s6attrs)		\
+	APPEND_SEQSTR(this->s7str, this->s7len, this->s7attrs)		\
+	APPEND_SEQSTR(this->s8str, this->s8len, this->s8attrs)		\
+	APPEND_SEQSTR(this->s9str, this->s9len, this->s9attrs)		\
+	APPEND_SEQSTR(this->s10str, this->s10len, this->s10attrs)	\
+	APPEND_SEQSTR(this->s11str, this->s11len, this->s11attrs)	\
+	APPEND_SEQSTR(this->s12str, this->s12len, this->s12attrs)	\
+	APPEND_SEQSTR(this->s13str, this->s13len, this->s13attrs)	\
 
 
 /*
@@ -287,9 +287,9 @@
  * APPEND_CONSSTR implicitly handles SeqStrings as the degenerate case of an
  * expanded ConsString.
  */
-#define APPEND_V8STR(str, len, attrs) \
-    APPEND_CONSSTR(str, len, attrs) \
-    APPEND_NODESTR(str, len, attrs)
+#define	APPEND_V8STR(str, len, attrs)					\
+	APPEND_CONSSTR(str, len, attrs)					\
+	APPEND_NODESTR(str, len, attrs)
 
 /*
  * In this first clause we initialize all variables.  We must explicitly clear
@@ -297,36 +297,36 @@
  */
 dtrace:helper:ustack:
 {
-  /* input */
-  this->fp = arg1;
-
-  /* output/flow control */
-  this->buf = (char*) alloca(128);
-  this->off = 0;
-  this->done = 0;
-
-  /* program state */
-  this->ctx = (off_t) 0;
-  this->marker = (off_t) 0;
-  this->func = (off_t) 0;
-  this->shared = (off_t) 0;
-  this->map = (off_t) 0;
-  this->attrs = 0;
-  this->funcnamestr = (off_t) 0;
-  this->funcnamelen = 0;
-  this->funcnameattrs = 0;
-  this->script = (off_t) 0;
-  this->scriptnamestr = (off_t) 0;
-  this->scriptnamelen = 0;
-  this->scriptnameattrs = 0;
-  this->position = 0;
-  this->line_ends = (off_t) 0;
-  this->le_attrs = 0;
-
-  /* binary search fields */
-  this->bsearch_min = 0;
-  this->bsearch_max = 0;
-  this->ii = 0;
+	/* input */
+	this->fp = arg1;
+
+	/* output/flow control */
+	this->buf = (char*) alloca(128);
+	this->off = 0;
+	this->done = 0;
+
+	/* program state */
+	this->ctx = (off_t) 0;
+	this->marker = (off_t) 0;
+	this->func = (off_t) 0;
+	this->shared = (off_t) 0;
+	this->map = (off_t) 0;
+	this->attrs = 0;
+	this->funcnamestr = (off_t) 0;
+	this->funcnamelen = 0;
+	this->funcnameattrs = 0;
+	this->script = (off_t) 0;
+	this->scriptnamestr = (off_t) 0;
+	this->scriptnamelen = 0;
+	this->scriptnameattrs = 0;
+	this->position = 0;
+	this->line_ends = (off_t) 0;
+	this->le_attrs = 0;
+
+	/* binary search fields */
+	this->bsearch_min = 0;
+	this->bsearch_max = 0;
+	this->ii = 0;
 }
 
 /*
@@ -335,16 +335,16 @@ dtrace:helper:ustack:
  */
 dtrace:helper:ustack:
 {
-  this->ctx = COPYIN_PTR(this->fp + V8_OFF_FP_CONTEXT);
+	this->ctx = COPYIN_PTR(this->fp + V8_OFF_FP_CONTEXT);
 }
 
 dtrace:helper:ustack:
 /IS_SMI(this->ctx) && SMI_VALUE(this->ctx) == V8_FT_ADAPTOR/
 {
-  this->done = 1;
-  APPEND_CHR8('<','<',' ','a','d','a','p','t');
-  APPEND_CHR8('o','r',' ','>','>','\0','\0','\0');
-  stringof(this->buf);
+	this->done = 1;
+	APPEND_CHR8('<','<',' ','a','d','a','p','t');
+	APPEND_CHR8('o','r',' ','>','>','\0','\0','\0');
+	stringof(this->buf);
 }
 
 /*
@@ -353,60 +353,60 @@ dtrace:helper:ustack:
 dtrace:helper:ustack:
 /!this->done/
 {
-  this->marker = COPYIN_PTR(this->fp + V8_OFF_FP_MARKER);
+	this->marker = COPYIN_PTR(this->fp + V8_OFF_FP_MARKER);
 }
 
 dtrace:helper:ustack:
 /!this->done && IS_SMI(this->marker) &&
  SMI_VALUE(this->marker) == V8_FT_ENTRY/
 {
-  this->done = 1;
-  APPEND_CHR8('<','<',' ','e','n','t','r','y');
-  APPEND_CHR4(' ','>','>','\0');
-  stringof(this->buf);
+	this->done = 1;
+	APPEND_CHR8('<','<',' ','e','n','t','r','y');
+	APPEND_CHR4(' ','>','>','\0');
+	stringof(this->buf);
 }
 
 dtrace:helper:ustack:
 /!this->done && IS_SMI(this->marker) &&
  SMI_VALUE(this->marker) == V8_FT_ENTRYCONSTRUCT/
 {
-  this->done = 1;
-  APPEND_CHR8('<','<',' ','e','n','t','r','y');
-  APPEND_CHR8('_','c','o','n','s','t','r','u');
-  APPEND_CHR4('t',' ','>','>');
-  APPEND_CHR('\0');
-  stringof(this->buf);
+	this->done = 1;
+	APPEND_CHR8('<','<',' ','e','n','t','r','y');
+	APPEND_CHR8('_','c','o','n','s','t','r','u');
+	APPEND_CHR4('t',' ','>','>');
+	APPEND_CHR('\0');
+	stringof(this->buf);
 }
 
 dtrace:helper:ustack:
 /!this->done && IS_SMI(this->marker) &&
  SMI_VALUE(this->marker) == V8_FT_EXIT/
 {
-  this->done = 1;
-  APPEND_CHR8('<','<',' ','e','x','i','t',' ');
-  APPEND_CHR4('>','>','\0','\0');
-  stringof(this->buf);
+	this->done = 1;
+	APPEND_CHR8('<','<',' ','e','x','i','t',' ');
+	APPEND_CHR4('>','>','\0','\0');
+	stringof(this->buf);
 }
 
 dtrace:helper:ustack:
 /!this->done && IS_SMI(this->marker) &&
  SMI_VALUE(this->marker) == V8_FT_INTERNAL/
 {
-  this->done = 1;
-  APPEND_CHR8('<','<',' ','i','n','t','e','r');
-  APPEND_CHR8('n','a','l',' ','>','>','\0','\0');
-  stringof(this->buf);
+	this->done = 1;
+	APPEND_CHR8('<','<',' ','i','n','t','e','r');
+	APPEND_CHR8('n','a','l',' ','>','>','\0','\0');
+	stringof(this->buf);
 }
 
 dtrace:helper:ustack:
 /!this->done && IS_SMI(this->marker) &&
  SMI_VALUE(this->marker) == V8_FT_CONSTRUCT/
 {
-  this->done = 1;
-  APPEND_CHR8('<','<',' ','c','o','n','s','t');
-  APPEND_CHR8('r','u','c','t','o','r',' ','>');
-  APPEND_CHR4('>','\0','\0','\0');
-  stringof(this->buf);
+	this->done = 1;
+	APPEND_CHR8('<','<',' ','c','o','n','s','t');
+	APPEND_CHR8('r','u','c','t','o','r',' ','>');
+	APPEND_CHR4('>','\0','\0','\0');
+	stringof(this->buf);
 }
 
 /*
@@ -417,19 +417,19 @@ dtrace:helper:ustack:
 dtrace:helper:ustack:
 /!this->done/
 {
-  this->func = COPYIN_PTR(this->fp + V8_OFF_FP_FUNC);
-  this->map = V8_MAP_PTR(COPYIN_PTR(this->func + V8_OFF_HEAPOBJ_MAP));
-  this->attrs = COPYIN_UINT8(this->map + V8_OFF_MAP_ATTRS);
+	this->func = COPYIN_PTR(this->fp + V8_OFF_FP_FUNC);
+	this->map = V8_MAP_PTR(COPYIN_PTR(this->func + V8_OFF_HEAPOBJ_MAP));
+	this->attrs = COPYIN_UINT8(this->map + V8_OFF_MAP_ATTRS);
 }
 
 dtrace:helper:ustack:
 /!this->done && this->attrs == V8_IT_CODE/
 {
-  this->done = 1;
-  APPEND_CHR8('<','<',' ','i','n','t','e','r');
-  APPEND_CHR8('n','a','l',' ','c','o','d','e');
-  APPEND_CHR4(' ','>','>','\0');
-  stringof(this->buf);
+	this->done = 1;
+	APPEND_CHR8('<','<',' ','i','n','t','e','r');
+	APPEND_CHR8('n','a','l',' ','c','o','d','e');
+	APPEND_CHR4(' ','>','>','\0');
+	stringof(this->buf);
 }
 
 /*
@@ -440,38 +440,38 @@ dtrace:helper:ustack:
 dtrace:helper:ustack:
 /!this->done/
 {
-  this->map = 0;
-  this->attrs = 0;
+	this->map = 0;
+	this->attrs = 0;
 
-  this->shared = COPYIN_PTR(this->func + V8_OFF_FUNC_SHARED);
-  this->funcnamestr = COPYIN_PTR(this->shared + V8_OFF_SHARED_NAME);
-  LOAD_STRFIELDS(this->funcnamestr, this->funcnamelen,
-                 this->funcnameattrs);
+	this->shared = COPYIN_PTR(this->func + V8_OFF_FUNC_SHARED);
+	this->funcnamestr = COPYIN_PTR(this->shared + V8_OFF_SHARED_NAME);
+	LOAD_STRFIELDS(this->funcnamestr, this->funcnamelen,
+	    this->funcnameattrs);
 }
 
 dtrace:helper:ustack:
 /!this->done && this->funcnamelen == 0/
 {
-  /*
-   * This is an anonymous function, but if it was invoked as a method of
-   * some object then V8 will have computed an inferred name that we can
-   * include in the stack trace.
-   */
-  APPEND_CHR8('(','a','n','o','n',')',' ','a');
-  APPEND_CHR('s');
-  APPEND_CHR(' ');
-
-  this->funcnamestr = COPYIN_PTR(this->shared + V8_OFF_SHARED_INFERRED);
-  LOAD_STRFIELDS(this->funcnamestr, this->funcnamelen,
-                 this->funcnameattrs);
+	/*
+	 * This is an anonymous function, but if it was invoked as a method of
+	 * some object then V8 will have computed an inferred name that we can
+	 * include in the stack trace.
+	 */
+	APPEND_CHR8('(','a','n','o','n',')',' ','a');
+	APPEND_CHR('s');
+	APPEND_CHR(' ');
+
+	this->funcnamestr = COPYIN_PTR(this->shared + V8_OFF_SHARED_INFERRED);
+	LOAD_STRFIELDS(this->funcnamestr, this->funcnamelen,
+	    this->funcnameattrs);
 }
 
 dtrace:helper:ustack:
 /!this->done && this->funcnamelen == 0/
 {
-  APPEND_CHR('(');
-  APPEND_CHR4('a','n','o','n');
-  APPEND_CHR(')');
+	APPEND_CHR('(');
+	APPEND_CHR4('a','n','o','n');
+	APPEND_CHR(')');
 }
 
 APPEND_V8STR(this->funcnamestr, this->funcnamelen, this->funcnameattrs)
@@ -482,19 +482,19 @@ APPEND_V8STR(this->funcnamestr, this->funcnamelen, this->funcnameattrs)
 dtrace:helper:ustack:
 /!this->done/
 {
-  this->script = COPYIN_PTR(this->shared + V8_OFF_SHARED_SCRIPT);
-  this->scriptnamestr = COPYIN_PTR(this->script + V8_OFF_SCRIPT_NAME);
-  LOAD_STRFIELDS(this->scriptnamestr, this->scriptnamelen,
-                 this->scriptnameattrs);
+	this->script = COPYIN_PTR(this->shared + V8_OFF_SHARED_SCRIPT);
+	this->scriptnamestr = COPYIN_PTR(this->script + V8_OFF_SCRIPT_NAME);
+	LOAD_STRFIELDS(this->scriptnamestr, this->scriptnamelen,
+	    this->scriptnameattrs);
 
-  APPEND_CHR4(' ','a','t',' ');
+	APPEND_CHR4(' ','a','t',' ');
 }
 
 dtrace:helper:ustack:
 /!this->done && this->scriptnamelen == 0/
 {
-  APPEND_CHR8('<','u','n','k','n','o','w','n');
-  APPEND_CHR('>');
+	APPEND_CHR8('<','u','n','k','n','o','w','n');
+	APPEND_CHR('>');
 }
 
 APPEND_V8STR(this->scriptnamestr, this->scriptnamelen, this->scriptnameattrs)
@@ -505,27 +505,27 @@ APPEND_V8STR(this->scriptnamestr, this->scriptnamelen, this->scriptnameattrs)
 dtrace:helper:ustack:
 /!this->done/
 {
-  this->position = COPYIN_UINT32(this->shared + V8_OFF_SHARED_FUNTOK);
-  this->line_ends = COPYIN_PTR(this->script + V8_OFF_SCRIPT_LENDS);
-  this->map = V8_MAP_PTR(COPYIN_PTR(this->line_ends + V8_OFF_HEAPOBJ_MAP));
-  this->le_attrs = COPYIN_UINT8(this->map + V8_OFF_MAP_ATTRS);
+	this->position = COPYIN_UINT32(this->shared + V8_OFF_SHARED_FUNTOK);
+	this->line_ends = COPYIN_PTR(this->script + V8_OFF_SCRIPT_LENDS);
+	this->map = V8_MAP_PTR(COPYIN_PTR(this->line_ends + V8_OFF_HEAPOBJ_MAP));
+	this->le_attrs = COPYIN_UINT8(this->map + V8_OFF_MAP_ATTRS);
 }
 
 dtrace:helper:ustack:
 /!this->done && this->le_attrs != V8_IT_FIXEDARRAY/
 {
-  /*
-   * If the line number array was not a valid FixedArray, it's probably
-   * undefined because V8 has not had to compute it yet.  In this case we
-   * just show the raw position and call it a day.
-   */
-  APPEND_CHR8(' ','p','o','s','i','t','i','o');
-  APPEND_CHR('n');
-  APPEND_CHR(' ');
-  APPEND_NUM(this->position);
-  APPEND_CHR('\0');
-  this->done = 1;
-  stringof(this->buf);
+	/*
+	 * If the line number array was not a valid FixedArray, it's probably
+	 * undefined because V8 has not had to compute it yet.  In this case we
+	 * just show the raw position and call it a day.
+	 */
+	APPEND_CHR8(' ','p','o','s','i','t','i','o');
+	APPEND_CHR('n');
+	APPEND_CHR(' ');
+	APPEND_NUM(this->position);
+	APPEND_CHR('\0');
+	this->done = 1;
+	stringof(this->buf);
 }
 
 /*
@@ -537,12 +537,12 @@ dtrace:helper:ustack:
 dtrace:helper:ustack:
 /!this->done/
 {
-  /* initialize binary search */
-  this->bsearch_line = this->position <
-      SMI_VALUE(COPYIN_PTR(this->line_ends + V8_OFF_FA_DATA)) ? 1 : 0;
-  this->bsearch_min = 0;
-  this->bsearch_max = this->bsearch_line != 0 ? 0 :
-      SMI_VALUE(COPYIN_PTR(this->line_ends + V8_OFF_FA_SIZE)) - 1;
+	/* initialize binary search */
+	this->bsearch_line = this->position <
+	SMI_VALUE(COPYIN_PTR(this->line_ends + V8_OFF_FA_DATA)) ? 1 : 0;
+	this->bsearch_min = 0;
+	this->bsearch_max = this->bsearch_line != 0 ? 0 :
+	SMI_VALUE(COPYIN_PTR(this->line_ends + V8_OFF_FA_SIZE)) - 1;
 }
 
 /*
@@ -550,29 +550,29 @@ dtrace:helper:ustack:
  * iterations.  That's enough to precisely identify the line number in files up
  * to 32768 lines of code.
  */
-#define BSEARCH_LOOP \
-    dtrace:helper:ustack: \
-    /!this->done && this->bsearch_max >= 1/ \
-    { \
-      this->ii = (this->bsearch_min + this->bsearch_max) >> 1; \
-    } \
-    \
-    dtrace:helper:ustack: \
-    /!this->done && this->bsearch_max >= 1 && \
-     this->position > SMI_VALUE( \
-         COPYIN_PTR(this->line_ends + V8_OFF_FA_DATA + \
-                    this->ii * sizeof (uint32_t)))/ \
-    { \
-      this->bsearch_min = this->ii + 1; \
-    } \
-    \
-    dtrace:helper:ustack: \
-    /!this->done && this->bsearch_max >= 1 && \
-     this->position <= SMI_VALUE( \
-         COPYIN_PTR(this->line_ends + V8_OFF_FA_DATA + \
-                    (this->ii - 1) * sizeof (uint32_t)))/ \
-    { \
-      this->bsearch_max = this->ii - 1; \
+#define	BSEARCH_LOOP							\
+    dtrace:helper:ustack:	\
+    /!this->done && this->bsearch_max >= 1/	\
+    {	\
+	this->ii = (this->bsearch_min + this->bsearch_max) >> 1;	\
+    }	\
+									\
+    dtrace:helper:ustack:	\
+    /!this->done && this->bsearch_max >= 1 &&	\
+     this->position > SMI_VALUE(	\
+         COPYIN_PTR(this->line_ends + V8_OFF_FA_DATA +	\
+                    this->ii * sizeof (uint32_t)))/	\
+    {	\
+	this->bsearch_min = this->ii + 1;				\
+    }	\
+									\
+    dtrace:helper:ustack:	\
+    /!this->done && this->bsearch_max >= 1 &&	\
+     this->position <= SMI_VALUE(	\
+         COPYIN_PTR(this->line_ends + V8_OFF_FA_DATA +	\
+                    (this->ii - 1) * sizeof (uint32_t)))/	\
+    {	\
+	this->bsearch_max = this->ii - 1;				\
     }
 
 BSEARCH_LOOP
@@ -594,17 +594,19 @@ BSEARCH_LOOP
 dtrace:helper:ustack:
 /!this->done && !this->bsearch_line/
 {
-  this->bsearch_line = this->ii + 1;
+	this->bsearch_line = this->ii + 1;
 }
 
 dtrace:helper:ustack:
 /!this->done/
 {
-  APPEND_CHR(' ');
-  APPEND_CHR4('l','i','n','e');
-  APPEND_CHR(' ');
-  APPEND_NUM(this->bsearch_line);
-  APPEND_CHR('\0');
-  this->done = 1;
-  stringof(this->buf);
+	APPEND_CHR(' ');
+	APPEND_CHR4('l','i','n','e');
+	APPEND_CHR(' ');
+	APPEND_NUM(this->bsearch_line);
+	APPEND_CHR('\0');
+	this->done = 1;
+	stringof(this->buf);
 }
+
+/* vim: set tabstop=8 softtabstop=8 shiftwidth=8 noexpandtab: */