Until David Mmmmmmmmmitchell gets them online, we'll stick with obvious
things, like line lengths. I, for the most part, left strings alone
('cause I''ll be anal with them separately), as well as some of the files.
This is for *.c files.
Index: interpreter.c
===================================================================
RCS file: /home/perlcvs/parrot/interpreter.c,v
retrieving revision 1.42
diff -u -r1.42 interpreter.c
--- interpreter.c 27 Dec 2001 17:08:47 -0000 1.42
+++ interpreter.c 29 Dec 2001 21:43:45 -0000
@@ -41,7 +41,8 @@
if (strncmp(OPCODE_FINGERPRINT, fp_data, fp_len)) {
fprintf(stderr, "Error: Opcode table fingerprint in bytecode does not
match interpreter!\n");
- fprintf(stderr, " Bytecode: %*s\n", (int)-fp_len, fp_data);
+ fprintf(stderr, " Bytecode: %*s\n",
+ (int) -fp_len, fp_data);
fprintf(stderr, " Interpreter: %s\n", OPCODE_FINGERPRINT);
exit(1);
}
@@ -56,7 +57,8 @@
* Generic runops, which takes a function pointer for the core.
*/
void
-runops_generic (opcode_t * (*core)(struct Parrot_Interp *, opcode_t *), struct
Parrot_Interp *interpreter, opcode_t * pc) {
+runops_generic (opcode_t * (*core)(struct Parrot_Interp *, opcode_t *),
+ struct Parrot_Interp *interpreter, opcode_t * pc) {
opcode_t * code_start;
INTVAL code_size;
opcode_t * code_end;
@@ -106,7 +108,8 @@
if (!prederef_oplib_handle) {
fprintf(stderr, "Unable to dynamically load oplib file '%s' for oplib
'%s_prederef' version %d.%d!\n",
- file_name, PARROT_CORE_OPLIB_NAME, PARROT_CORE_OPLIB_MAJOR_VERSION,
PARROT_CORE_OPLIB_MINOR_VERSION);
+ file_name, PARROT_CORE_OPLIB_NAME, PARROT_CORE_OPLIB_MAJOR_VERSION,
+ PARROT_CORE_OPLIB_MINOR_VERSION);
exit(1);
}
@@ -120,7 +123,8 @@
if (!prederef_oplib_init) {
fprintf(stderr, "No exported symbol for oplib init function '%s' from oplib file
'%s' for oplib '%s_prederef' version %d.%d!\n",
func_name, file_name,
- PARROT_CORE_OPLIB_NAME, PARROT_CORE_OPLIB_MAJOR_VERSION,
PARROT_CORE_OPLIB_MINOR_VERSION);
+ PARROT_CORE_OPLIB_NAME, PARROT_CORE_OPLIB_MAJOR_VERSION,
+ PARROT_CORE_OPLIB_MINOR_VERSION);
exit(1);
}
@@ -134,7 +138,8 @@
if (!prederef_oplib) {
fprintf(stderr, "No oplib info returned by oplib init function '%s' from oplib
file '%s' for oplib '%s_prederef' version %d.%d!\n",
func_name, file_name,
- PARROT_CORE_OPLIB_NAME, PARROT_CORE_OPLIB_MAJOR_VERSION,
PARROT_CORE_OPLIB_MINOR_VERSION);
+ PARROT_CORE_OPLIB_NAME, PARROT_CORE_OPLIB_MAJOR_VERSION,
+ PARROT_CORE_OPLIB_MINOR_VERSION);
exit(1);
}
@@ -147,7 +152,8 @@
if (prederef_op_count <= 0) {
fprintf(stderr, "Illegal op count (%d) from oplib file '%s' for oplib
'%s_prederef' version %d.%d!\n",
prederef_op_count, file_name,
- PARROT_CORE_OPLIB_NAME, PARROT_CORE_OPLIB_MAJOR_VERSION,
PARROT_CORE_OPLIB_MINOR_VERSION);
+ PARROT_CORE_OPLIB_NAME, PARROT_CORE_OPLIB_MAJOR_VERSION,
+ PARROT_CORE_OPLIB_MINOR_VERSION);
exit(1);
}
@@ -160,7 +166,8 @@
if (!prederef_op_info) {
fprintf(stderr, "No op info table in oplib file '%s' for oplib '%s_prederef'
version %d.%d!\n",
file_name,
- PARROT_CORE_OPLIB_NAME, PARROT_CORE_OPLIB_MAJOR_VERSION,
PARROT_CORE_OPLIB_MINOR_VERSION);
+ PARROT_CORE_OPLIB_NAME, PARROT_CORE_OPLIB_MAJOR_VERSION,
+ PARROT_CORE_OPLIB_MINOR_VERSION);
exit(1);
}
@@ -173,7 +180,8 @@
if (!prederef_op_func) {
fprintf(stderr, "No op func table in oplib file '%s' for oplib '%s_prederef'
version %d.%d!\n",
file_name,
- PARROT_CORE_OPLIB_NAME, PARROT_CORE_OPLIB_MAJOR_VERSION,
PARROT_CORE_OPLIB_MINOR_VERSION);
+ PARROT_CORE_OPLIB_NAME, PARROT_CORE_OPLIB_MAJOR_VERSION,
+ PARROT_CORE_OPLIB_MINOR_VERSION);
exit(1);
}
}
@@ -233,17 +241,20 @@
break;
case PARROT_ARG_NC:
- pc_prederef[i] = (void
*)&interpreter->code->const_table->constants[pc[i]]->number;
+ pc_prederef[i] = (void *)
+ &interpreter->code->const_table->constants[pc[i]]->number;
break;
case PARROT_ARG_PC:
-/* pc_prederef[i] = (void
*)&interpreter->code->const_table->constants[pc[i]]->pmc; */
+/* pc_prederef[i] = (void *)
+ &interpreter->code->const_table->constants[pc[i]]->pmc; */
fprintf(stderr, "PMC constants not yet supported!\n");
exit(1);
break;
case PARROT_ARG_SC:
- pc_prederef[i] = (void
*)&interpreter->code->const_table->constants[pc[i]]->string;
+ pc_prederef[i] = (void *)
+ &interpreter->code->const_table->constants[pc[i]]->string;
break;
default:
@@ -284,7 +295,8 @@
/*=for api interpreter runops_prederef
*/
void
-runops_prederef (struct Parrot_Interp *interpreter, opcode_t * pc, void **
pc_prederef) {
+runops_prederef (struct Parrot_Interp *interpreter, opcode_t * pc,
+ void ** pc_prederef) {
opcode_t * code_start;
INTVAL code_size;
opcode_t * code_end;
@@ -301,7 +313,8 @@
init_prederef(interpreter);
while (pc_prederef) {
- pc_prederef = ((op_func_prederef_t)*pc_prederef)(pc_prederef, interpreter);
+ pc_prederef =
+ ((op_func_prederef_t)*pc_prederef) (pc_prederef, interpreter);
}
stop_prederef();
@@ -324,7 +337,8 @@
* run parrot operations until the program is complete
*/
void
-runops (struct Parrot_Interp *interpreter, struct PackFile * code, size_t offset) {
+runops (struct Parrot_Interp *interpreter, struct PackFile * code,
+ size_t offset) {
opcode_t * (*core)(struct Parrot_Interp *, opcode_t *);
interpreter->code = code;
@@ -333,7 +347,8 @@
while (interpreter->resume_flag) {
int which = 0;
- opcode_t * pc = (opcode_t *)interpreter->code->byte_code +
interpreter->resume_offset;
+ opcode_t * pc = (opcode_t *)
+ interpreter->code->byte_code + interpreter->resume_offset;
interpreter->resume_offset = 0;
interpreter->resume_flag = 0;
@@ -348,7 +363,8 @@
int i;
if (interpreter->profile == NULL) {
- interpreter->profile = (INTVAL
*)mem_sys_allocate(interpreter->op_count * sizeof(INTVAL));
+ interpreter->profile = (INTVAL *)
+ mem_sys_allocate(interpreter->op_count * sizeof(INTVAL));
}
for (i = 0; i < interpreter->op_count; i++) {
@@ -371,11 +387,13 @@
interpreter->prederef_code = temp;
}
- runops_prederef(interpreter, pc, interpreter->prederef_code + offset);
+ runops_prederef(interpreter, pc,
+ interpreter->prederef_code + offset);
}
else if ((interpreter->flags & PARROT_JIT_FLAG) != 0) {
if (!JIT_CAPABLE) {
- fprintf(stderr, "Error: PARROT_JIT_FLAG is set, but interpreter is not
JIT_CAPABLE!\n");
+ fprintf(stderr,
+ "Error: PARROT_JIT_FLAG is set, but interpreter is not JIT_CAPABLE!\n");
exit(1);
}
@@ -414,7 +432,8 @@
/* Set up the initial register chunks */
interpreter->int_reg_base = mem_allocate_aligned(sizeof(struct IRegChunk));
interpreter->num_reg_base = mem_allocate_aligned(sizeof(struct NRegChunk));
- interpreter->string_reg_base = mem_allocate_aligned(sizeof(struct SRegChunk));
+ interpreter->string_reg_base =
+ mem_allocate_aligned(sizeof(struct SRegChunk));
interpreter->pmc_reg_base = mem_allocate_aligned(sizeof(struct PRegChunk));
/* Set up the initial register frame pointers */
@@ -453,7 +472,8 @@
Parrot_clear_p(interpreter);
/* Need a user stack */
- interpreter->user_stack_base = mem_allocate_aligned(sizeof(struct StackChunk));
+ interpreter->user_stack_base =
+ mem_allocate_aligned(sizeof(struct StackChunk));
interpreter->user_stack_top = &interpreter->user_stack_base->entry[0];
/* Unlike the registers, we start with zero used */
interpreter->user_stack_base->used = 0;
@@ -462,8 +482,10 @@
interpreter->user_stack_base->prev = NULL;
/* And a control stack */
- interpreter->control_stack_base = mem_allocate_aligned(sizeof(struct StackChunk));
- interpreter->control_stack_top = &interpreter->control_stack_base->entry[0];
+ interpreter->control_stack_base =
+ mem_allocate_aligned(sizeof(struct StackChunk));
+ interpreter->control_stack_top =
+ &interpreter->control_stack_base->entry[0];
/* Unlike the registers, we start with zero used */
interpreter->control_stack_base->used = 0;
interpreter->control_stack_base->free = STACK_CHUNK_DEPTH;
Index: key.c
===================================================================
RCS file: /home/perlcvs/parrot/key.c,v
retrieving revision 1.3
diff -u -r1.3 key.c
--- key.c 13 Dec 2001 16:21:55 -0000 1.3
+++ key.c 29 Dec 2001 21:43:46 -0000
@@ -126,7 +126,8 @@
=cut
*/
-INTVAL key_element_type(struct Parrot_Interp *interpreter, KEY* key, INTVAL index) {
+INTVAL key_element_type(struct Parrot_Interp *interpreter, KEY* key,
+ INTVAL index) {
if(key != NULL) {
if((index >= 0) || (index < key->size)) {
KEY_PAIR* pair = &key->keys[index];
@@ -148,7 +149,8 @@
=cut
*/
-KEY_PAIR* key_element_value_i(struct Parrot_Interp *interpreter, KEY* key, INTVAL
index) {
+KEY_PAIR* key_element_value_i(struct Parrot_Interp *interpreter, KEY* key,
+ INTVAL index) {
if(key != NULL) {
if((index >= 0) || (index < key->size)) {
KEY_PAIR* pair = &key->keys[index];
@@ -167,7 +169,8 @@
return NULL;
}
-KEY_PAIR* key_element_value_s(struct Parrot_Interp *interpreter, KEY* key, STRING*
index) {
+KEY_PAIR* key_element_value_s(struct Parrot_Interp *interpreter, KEY* key,
+ STRING* index) {
if(key != NULL) {
/*
if((index >= 0) || (index < key->size)) {
@@ -195,13 +198,15 @@
=cut
*/
-void key_set_element_value_i(struct Parrot_Interp *interpreter, KEY* key, INTVAL
index, KEY_PAIR* value) {
+void key_set_element_value_i(struct Parrot_Interp *interpreter, KEY* key,
+ INTVAL index, KEY_PAIR* value) {
if(key != NULL) {
if((index >= 0) || (index < key->size)) {
memcpy(&key->keys[index],value,sizeof(KEY_PAIR));
}
else {
- fprintf(stderr,"*** key_set_element_value_i setting value out of bounds\n");
+ fprintf(stderr,
+ "*** key_set_element_value_i setting value out of bounds\n");
}
}
else {
@@ -216,7 +221,8 @@
=cut
*/
-void key_set_element_value_s(struct Parrot_Interp *interpreter, KEY* key, STRING*
index, KEY_PAIR* value) {
+void key_set_element_value_s(struct Parrot_Interp *interpreter, KEY* key,
+ STRING* index, KEY_PAIR* value) {
if(key != NULL) {
/*
if((index >= 0) || (index < key->size)) {
Index: register.c
===================================================================
RCS file: /home/perlcvs/parrot/register.c,v
retrieving revision 1.12
diff -u -r1.12 register.c
--- register.c 22 Oct 2001 18:02:24 -0000 1.12
+++ register.c 29 Dec 2001 21:43:47 -0000
@@ -95,7 +95,8 @@
}
/* Nope. So pitch a fit */
else {
- INTERNAL_EXCEPTION(NO_REG_FRAMES, "No more I register frames to pop!");
+ INTERNAL_EXCEPTION(NO_REG_FRAMES,
+ "No more I register frames to pop!");
}
}
}
@@ -200,7 +201,8 @@
}
/* Nope. So pitch a fit */
else {
- INTERNAL_EXCEPTION(NO_REG_FRAMES, "No more S register frames to pop!");
+ INTERNAL_EXCEPTION(NO_REG_FRAMES,
+ "No more S register frames to pop!");
}
}
}
@@ -299,7 +301,8 @@
}
/* Nope. So pitch a fit */
else {
- INTERNAL_EXCEPTION(NO_REG_FRAMES, "No more N register frames to pop!");
+ INTERNAL_EXCEPTION(NO_REG_FRAMES,
+ "No more N register frames to pop!");
}
}
}
@@ -402,7 +405,8 @@
}
/* Nope. So pitch a fit */
else {
- INTERNAL_EXCEPTION(NO_REG_FRAMES, "No more P register frames to pop!");
+ INTERNAL_EXCEPTION(NO_REG_FRAMES,
+ "No more P register frames to pop!");
}
}
}
Index: stacks.c
===================================================================
RCS file: /home/perlcvs/parrot/stacks.c,v
retrieving revision 1.13
diff -u -r1.13 stacks.c
--- stacks.c 21 Dec 2001 19:32:43 -0000 1.13
+++ stacks.c 29 Dec 2001 21:43:48 -0000
@@ -26,7 +26,8 @@
}
struct Stack_Entry *
-stack_entry(struct Parrot_Interp *interpreter, struct StackChunk *chunk, INTVAL
depth) {
+stack_entry(struct Parrot_Interp *interpreter, struct StackChunk *chunk,
+ INTVAL depth) {
while (chunk->next) {
chunk = chunk->next;
}
@@ -39,7 +40,8 @@
}
/* Rotate the top N entries by one */
-void rotate_entries(struct Parrot_Interp *interpreter, struct StackChunk *base_chunk,
struct Stack_Entry *top, INTVAL depth) {
+void rotate_entries(struct Parrot_Interp *interpreter,
+ struct StackChunk *base_chunk, struct Stack_Entry *top, INTVAL depth) {
struct Stack_Entry temp;
INTVAL i;
@@ -58,7 +60,8 @@
temp = *(top);
for(i = 0; i < depth - 1; i++) {
- *stack_entry(interpreter, base_chunk, i) = *stack_entry(interpreter,
base_chunk, i + 1);
+ *stack_entry(interpreter, base_chunk, i) =
+ *stack_entry(interpreter, base_chunk, i + 1);
}
*stack_entry(interpreter, base_chunk, depth - 1) = temp;
@@ -72,7 +75,9 @@
place when an entry is removed, such as when you push a lexical
lock onto the call stack, or localize (or tempify, or whatever
we're calling it) variable or something */
-struct Stack_Entry *push_generic_entry(struct Parrot_Interp *interpreter, struct
Stack_Entry **top, void *thing, INTVAL type, void (*cleanup)(struct Stack_Entry *)) {
+struct Stack_Entry *push_generic_entry(struct Parrot_Interp *interpreter,
+ struct Stack_Entry **top, void *thing, INTVAL type,
+ void (*cleanup)(struct Stack_Entry *)) {
struct StackChunk *chunk_base;
chunk_base = STACK_CHUNK_BASE(*top);
@@ -109,7 +114,8 @@
chunk_base->entry[chunk_base->used-1].entry.int_val = *(INTVAL *)thing;
break;
case STACK_ENTRY_FLOAT:
- chunk_base->entry[chunk_base->used-1].entry.num_val = *(FLOATVAL *)thing;
+ chunk_base->entry[chunk_base->used-1].entry.num_val =
+ *(FLOATVAL *)thing;
break;
case STACK_ENTRY_PMC:
chunk_base->entry[chunk_base->used-1].entry.pmc_val = thing;
@@ -140,7 +146,8 @@
}
/* Types of 0 mean we don't care */
if (type && (*top)->entry_type != type) {
- INTERNAL_EXCEPTION(ERROR_BAD_STACK_TYPE, "Wrong type on top of stack!\n");
+ INTERNAL_EXCEPTION(ERROR_BAD_STACK_TYPE,
+ "Wrong type on top of stack!\n");
}
/* Snag the value */
@@ -188,7 +195,8 @@
#if 0
/* If we didn't mind the extra call, we'd do this: */
void * dest;
- pop_generic_entry(interpreter, &interpreter->control_stack_top, &dest,
STACK_ENTRY_DESTINATION)
+ pop_generic_entry(interpreter, &interpreter->control_stack_top,
+ &dest, STACK_ENTRY_DESTINATION)
return dest;
#endif
@@ -203,7 +211,8 @@
}
if ((*top)->entry_type != STACK_ENTRY_DESTINATION) {
- INTERNAL_EXCEPTION(ERROR_BAD_STACK_TYPE, "Wrong type on top of stack!\n");
+ INTERNAL_EXCEPTION(ERROR_BAD_STACK_TYPE,
+ "Wrong type on top of stack!\n");
}
dest = (*top)->entry.generic_pointer;
@@ -228,13 +237,15 @@
}
/* Pop off an entry and throw it out */
-void toss_generic_entry(struct Parrot_Interp *interpreter, struct Stack_Entry **top,
INTVAL type) {
+void toss_generic_entry(struct Parrot_Interp *interpreter,
+ struct Stack_Entry **top, INTVAL type) {
void *foo;
pop_generic_entry(interpreter, top, &foo, type);
}
/* get the type of the topmost stack entry */
-INTVAL get_entry_type(struct Parrot_Interp *interpreter, struct Stack_Entry *entry) {
+INTVAL get_entry_type(struct Parrot_Interp *interpreter,
+ struct Stack_Entry *entry) {
return( entry->entry_type);
}
Index: string.c
===================================================================
RCS file: /home/perlcvs/parrot/string.c,v
retrieving revision 1.26
diff -u -r1.26 string.c
--- string.c 28 Dec 2001 18:20:12 -0000 1.26
+++ string.c 29 Dec 2001 21:43:49 -0000
@@ -31,7 +31,8 @@
* and compute its string length
*/
STRING *
-string_make(struct Parrot_Interp *interpreter, void *buffer, INTVAL buflen, const
ENCODING *encoding, INTVAL flags, const CHARTYPE *type) {
+string_make(struct Parrot_Interp *interpreter, void *buffer, INTVAL buflen,
+ const ENCODING *encoding, INTVAL flags, const CHARTYPE *type) {
STRING *s = new_string_header(interpreter);
if (!type) {
@@ -129,14 +130,17 @@
*/
STRING*
string_copy(struct Parrot_Interp *interpreter, STRING *s) {
- return string_make(interpreter, s->bufstart, s->bufused, s->encoding, s->flags,
s->type);
+ return string_make(interpreter, s->bufstart, s->bufused, s->encoding,
+ s->flags, s->type);
}
/*=for api string string_transcode
* create a transcoded copy of the argument passed in
*/
STRING*
-string_transcode(struct Parrot_Interp *interpreter, STRING *src, const ENCODING
*encoding, const CHARTYPE *type, STRING *dest) {
+string_transcode(struct Parrot_Interp *interpreter, STRING *src,
+ const ENCODING *encoding, const CHARTYPE *type,
+ STRING *dest) {
if (!dest) {
dest = string_make(interpreter, NULL, 0, encoding, 0, type);
}
@@ -163,8 +167,10 @@
if (src->type != dest->type) {
transcoder1 = chartype_lookup_transcoder(src->type, dest->type);
if (!transcoder1) {
- transcoder1 = chartype_lookup_transcoder(src->type,
string_unicode_type);
- transcoder2 = chartype_lookup_transcoder(string_unicode_type,
dest->type);
+ transcoder1 = chartype_lookup_transcoder(src->type,
+ string_unicode_type);
+ transcoder2 = chartype_lookup_transcoder(string_unicode_type,
+ dest->type);
}
}
@@ -215,7 +221,8 @@
* concatenate two strings
*/
STRING*
-string_concat(struct Parrot_Interp *interpreter, STRING* a, STRING* b, INTVAL flags) {
+string_concat(struct Parrot_Interp *interpreter, STRING* a, STRING* b,
+ INTVAL flags) {
if(a != NULL) {
if (b == NULL || b->strlen == 0) {
return a;
@@ -224,7 +231,8 @@
b = string_transcode(interpreter, b, a->encoding, a->type, NULL);
}
string_grow(a, a->strlen + b->strlen);
- mem_sys_memcopy((void*)((ptrcast_t)a->bufstart + a->bufused), b->bufstart,
b->bufused);
+ mem_sys_memcopy((void*)((ptrcast_t)a->bufstart + a->bufused),
+ b->bufstart, b->bufused);
a->strlen = a->strlen + b->strlen;
a->bufused = a->bufused + b->bufused;
}
@@ -243,7 +251,8 @@
* Allocates I<d> if needed, also returns d.
*/
STRING*
-string_repeat(struct Parrot_Interp *interpreter, STRING* s, INTVAL num, STRING** d) {
+string_repeat(struct Parrot_Interp *interpreter, STRING* s, INTVAL num,
+ STRING** d) {
STRING* dest;
INTVAL i;
@@ -287,7 +296,8 @@
* Allocate memory for d if necessary.
*/
STRING*
-string_substr(struct Parrot_Interp *interpreter, STRING* src, INTVAL offset, INTVAL
length, STRING** d) {
+string_substr(struct Parrot_Interp *interpreter, STRING* src, INTVAL offset,
+ INTVAL length, STRING** d) {
STRING *dest;
char *substart;
char *subend;
@@ -350,8 +360,10 @@
INTVAL cmp = 0;
if (s1->type != s2->type || s1->encoding != s2->encoding) {
- s1 = string_transcode(interpreter, s1, NULL, string_unicode_type, NULL);
- s2 = string_transcode(interpreter, s2, NULL, string_unicode_type, NULL);
+ s1 =
+ string_transcode(interpreter, s1, NULL, string_unicode_type, NULL);
+ s2 =
+ string_transcode(interpreter, s2, NULL, string_unicode_type, NULL);
}
s1start = s1->bufstart;
Index: test_main.c
===================================================================
RCS file: /home/perlcvs/parrot/test_main.c,v
retrieving revision 1.25
diff -u -r1.25 test_main.c
--- test_main.c 27 Dec 2001 17:08:47 -0000 1.25
+++ test_main.c 29 Dec 2001 21:43:49 -0000
@@ -161,7 +161,8 @@
program_code = (opcode_t*)mem_sys_allocate(program_size);
read(fd, (void*)program_code, program_size);
#else
- program_code = (opcode_t*)mmap(0, program_size, PROT_READ, MAP_SHARED, fd, 0);
+ program_code =
+ (opcode_t *) mmap(0, program_size, PROT_READ, MAP_SHARED, fd, 0);
#endif
if (!program_code) {
@@ -170,7 +171,8 @@
}
pf = PackFile_new();
- if( !PackFile_unpack(interpreter, pf, (char *)program_code, program_size) ) {
+ if( !PackFile_unpack(interpreter, pf, (char *)program_code,
+ program_size) ) {
printf( "Can't unpack.\n" );
return 1;
}
@@ -200,8 +202,9 @@
op_count++;
call_count += interpreter->profile[i];
- printf(" %5d %-12s %12ld\n",i,
interpreter->op_info_table[i].full_name,
- interpreter->profile[i]);
+ printf(" %5d %-12s %12ld\n", i,
+ interpreter->op_info_table[i].full_name,
+ interpreter->profile[i]);
}
}
Index: trace.c
===================================================================
RCS file: /home/perlcvs/parrot/trace.c,v
retrieving revision 1.4
diff -u -r1.4 trace.c
--- trace.c 27 Dec 2001 17:08:47 -0000 1.4
+++ trace.c 29 Dec 2001 21:43:49 -0000
@@ -15,11 +15,12 @@
/*
*=for api interpreter trace_op_dump
- * TODO: This isn't really part of the API, but here's its documentation. Prints the
PC, OP
- * and ARGS. Used by trace_op
+ * TODO: This isn't really part of the API, but here's its documentation.
+ * Prints the PC, OP and ARGS. Used by trace_op
*/
void
-trace_op_dump(struct Parrot_Interp *interpreter, opcode_t *code_start, opcode_t *pc) {
+trace_op_dump(struct Parrot_Interp *interpreter, opcode_t *code_start,
+ opcode_t *pc) {
INTVAL i;
fprintf(stderr, "PC=%ld; OP=%ld (%s)", (long)(pc - code_start), *pc,
@@ -34,20 +35,25 @@
fprintf(stderr, "%ld", (long) *(pc + i));
break;
case PARROT_ARG_NC:
- fprintf(stderr, "%f", interpreter->code->const_table->constants[*(pc
+ i)]->number);
+ fprintf(stderr, "%f", interpreter->code->const_table->
+ constants[*(pc + i)]->number);
break;
case PARROT_ARG_PC:
/* what is a PMC constant look like? */
fprintf(stderr, "%ld", (long) *(pc + i));
break;
case PARROT_ARG_SC:
- fprintf(stderr, "\"%s\"",
(char*)interpreter->code->const_table->constants[*(pc + i)]->string->bufstart);
+ fprintf(stderr, "\"%s\"",
+ (char *) interpreter->code->const_table->
+ constants[*(pc + i)]->string->bufstart);
break;
case PARROT_ARG_I:
- fprintf(stderr, "I%ld=%ld", (long) *(pc + i), (long)
interpreter->int_reg->registers[*(pc + i)]);
+ fprintf(stderr, "I%ld=%ld", (long) *(pc + i),
+ (long) interpreter->int_reg->registers[*(pc + i)]);
break;
case PARROT_ARG_N:
- fprintf(stderr, "N%ld=%f", (long) *(pc + i),
interpreter->num_reg->registers[*(pc + i)]);
+ fprintf(stderr, "N%ld=%f", (long) *(pc + i),
+ interpreter->num_reg->registers[*(pc + i)]);
break;
case PARROT_ARG_P:
/* what does a PMC constant look like? */
@@ -55,7 +61,9 @@
break;
case PARROT_ARG_S:
if(interpreter->string_reg->registers[*(pc + i)]) {
- fprintf(stderr, "S%ld=\"%s\"", (long) *(pc + i),
(char*)interpreter->string_reg->registers[*(pc + i)]->bufstart);
+ fprintf(stderr, "S%ld=\"%s\"", (long) *(pc + i),
+ (char *) interpreter->string_reg->
+ registers[*(pc + i)]->bufstart);
} else {
fprintf(stderr, "S%ld=(null)", (long) *(pc + i));
}
@@ -71,13 +79,14 @@
/*
*=for api interpreter trace_op
- * TODO: This isn't really part of the API, but here's its documentation. Prints the
PC, OP
- * and ARGS. Used by runops_trace.
+ * TODO: This isn't really part of the API, but here's its documentation.
+ * Prints the PC, OP and ARGS. Used by runops_trace.
*
* With bounds checking.
*/
void
-trace_op(struct Parrot_Interp *interpreter, opcode_t * code_start, opcode_t *
code_end, opcode_t *pc) {
+trace_op(struct Parrot_Interp *interpreter, opcode_t * code_start,
+ opcode_t * code_end, opcode_t *pc) {
if (!pc) {
return;
@@ -90,8 +99,9 @@
else if (pc) {
fprintf(stderr, "PC=%ld; OP=<err>\n", (long)(pc - code_start));
}
-
- (void)fflush(stderr); /* Flush *stderr* now that we've output the trace info */
+
+ /* Flush *stderr* now that we've output the trace info */
+ (void)fflush(stderr);
}
--
Bryan C. Warnock
[EMAIL PROTECTED]
