Sorry. It's easier to c+p into Pine than it is to upload+attach. I have a
feeling a few other patches I've submitted might be screwed up as well. If
this happens for anyone, please let me know.

Mike Lambert

Josh Wilmes wrote:

> Date: Mon, 25 Mar 2002 23:22:34 -0500
> From: Josh Wilmes <[EMAIL PROTECTED]>
> To: Michel J Lambert <[EMAIL PROTECTED]>
> Cc: [EMAIL PROTECTED]
> Subject: Re: [PATCH] tabs->spaces fix
>
>
> Mike,
>
> that doesn't want to apply for me- i suspect that the patch got garbled in
> the mail.  Can you MIME-attach or uuencode it?
>
> --Josh
>
> At 23:17 on 03/25/2002 EST, Michel J Lambert <[EMAIL PROTECTED]> wrote:
>
> > Below is a fix for the use of tabs in test_main.c and resources.c.
> >
> > Mike Lambert
> >
> >
> > Index: resources.c
> > ===================================================================
> > RCS file: /cvs/public/parrot/resources.c,v
> > retrieving revision 1.33
> > diff -r1.33 resources.c
> > 23,24c23,24
> > <                       struct free_pool *pool, void
> > <                       *to_add) {
> > ---
> > >                             struct free_pool *pool, void
> > >                             *to_add) {
> > 32,34c32,34
> > <                                        pool->pool_buffer.bufstart,
> > <                                        pool->pool_buffer.buflen,
> > <                                        (UINTVAL)(pool->pool_buffer.buflen
>  * 1.2));
> > ---
> > >                                              pool->pool_buffer.bufstart,
> > >                                              pool->pool_buffer.buflen,
> > >                                              (UINTVAL)(pool->pool_buffer.bu
> flen * 1.2));
> > 65,66c65,66
> > <                        thing, as the headers go into a single
> > <                        allocation pool */
> > ---
> > >                              thing, as the headers go into a single
> > >                              allocation pool */
> > 86,87c86,87
> > <               interpreter->arena_base->pmc_pool,
> > <               cur_pmc++);
> > ---
> > >                     interpreter->arena_base->pmc_pool,
> > >                     cur_pmc++);
> > 180,181c180,181
> > <                        thing, as the headers go into a single
> > <                        allocation pool */
> > ---
> > >                              thing, as the headers go into a single
> > >                              allocation pool */
> > 201,202c201,202
> > <                  interpreter->arena_base->buffer_header_pool,
> > <                  cur_buffer++);
> > ---
> > >                        interpreter->arena_base->buffer_header_pool,
> > >                        cur_buffer++);
> > 264,265c264,265
> > <                          struct free_pool *pool, void
> > <                          *to_add) {
> > ---
> > >                                struct free_pool *pool, void
> > >                                *to_add) {
> > 273,275c273,275
> > <                                        pool->pool_buffer.bufstart,
> > <                                        pool->pool_buffer.buflen,
> > <                                        (UINTVAL)(pool->pool_buffer.buflen
>  * 1.2));
> > ---
> > >                                              pool->pool_buffer.bufstart,
> > >                                              pool->pool_buffer.buflen,
> > >                                              (UINTVAL)(pool->pool_buffer.bu
> flen * 1.2));
> > 307c307
> > <   pmc_array[i].flags &= ~PMC_live_FLAG;
> > ---
> > >         pmc_array[i].flags &= ~PMC_live_FLAG;
> > 329c329
> > <   string_array[i].flags &= ~BUFFER_live_FLAG;
> > ---
> > >         string_array[i].flags &= ~BUFFER_live_FLAG;
> > 462,464c462,464
> > <   if(cur_chunk->SReg[j].registers[i]) {
> > <     buffer_lives((Buffer *)cur_chunk->SReg[j].registers[i]);
> > <   }
> > ---
> > >         if(cur_chunk->SReg[j].registers[i]) {
> > >           buffer_lives((Buffer *)cur_chunk->SReg[j].registers[i]);
> > >         }
> > 476c476
> > <   buffer_lives((Buffer *)cur_stack->entry[i].entry.string_val);
> > ---
> > >         buffer_lives((Buffer *)cur_stack->entry[i].entry.string_val);
> > 505c505
> > <   add_pmc_to_free(interpreter,
> > ---
> > >         add_pmc_to_free(interpreter,
> > 528,531c528,531
> > <                                BUFFER_on_free_list_FLAG))) {
> > <   add_header_to_free(interpreter,
> > <                      interpreter->arena_base->string_header_pool,
> > <                      &string_array[i]);
> > ---
> > >                                      BUFFER_on_free_list_FLAG))) {
> > >         add_header_to_free(interpreter,
> > >                            interpreter->arena_base->string_header_pool,
> > >                            &string_array[i]);
> > 586,587c586,587
> > <                        thing, as the headers go into a single
> > <                        allocation pool */
> > ---
> > >                              thing, as the headers go into a single
> > >                              allocation pool */
> > 607,608c607,608
> > <                  interpreter->arena_base->string_header_pool,
> > <                  cur_string++);
> > ---
> > >                        interpreter->arena_base->string_header_pool,
> > >                        cur_string++);
> > 662c662
> > <    NULL != cur_pool; cur_pool = cur_pool->prev) {
> > ---
> > >          NULL != cur_pool; cur_pool = cur_pool->prev) {
> > 673,675c673,675
> > <   struct Memory_Pool *new_block;  /* A pointer to our working pool */
> > <   char *cur_spot;         /* Where we're currently copying to */
> > <   UINTVAL cur_size;       /* How big our chunk is going to be */
> > ---
> > >   struct Memory_Pool *new_block;        /* A pointer to our working pool */
> > >   char *cur_spot;               /* Where we're currently copying to */
> > >   UINTVAL cur_size;     /* How big our chunk is going to be */
> > 693,694c693,694
> > <    interpreter->arena_base->string_header_pool->pool_buffer.bufstart,
> > <    interpreter->arena_base->string_header_pool->pool_buffer.buflen);
> > ---
> > >          interpreter->arena_base->string_header_pool->pool_buffer.bufstart,
> > >          interpreter->arena_base->string_header_pool->pool_buffer.buflen);
> > 705,706c705,706
> > <    interpreter->arena_base->pmc_pool->pool_buffer.bufstart,
> > <    interpreter->arena_base->pmc_pool->pool_buffer.buflen);
> > ---
> > >          interpreter->arena_base->pmc_pool->pool_buffer.bufstart,
> > >          interpreter->arena_base->pmc_pool->pool_buffer.buflen);
> > 717,718c717,718
> > <    interpreter->arena_base->buffer_header_pool->pool_buffer.bufstart,
> > <    interpreter->arena_base->buffer_header_pool->pool_buffer.buflen);
> > ---
> > >          interpreter->arena_base->buffer_header_pool->pool_buffer.bufstart,
> > >          interpreter->arena_base->buffer_header_pool->pool_buffer.buflen);
> > 736,746c736,746
> > <     && !(string_array[i].flags & BUFFER_immobile_FLAG)
> > <     && string_array[i].bufstart) {
> > <   memcpy(cur_spot, string_array[i].bufstart,
> > <          string_array[i].buflen);
> > <   string_array[i].bufstart = cur_spot;
> > <   cur_size = string_array[i].buflen;
> > <   if (cur_size & 0x0f) {
> > <     cur_size &= ~0x0f;
> > <     cur_size += 16;
> > <   }
> > <   cur_spot += cur_size;
> > ---
> > >           && !(string_array[i].flags & BUFFER_immobile_FLAG)
> > >           && string_array[i].bufstart) {
> > >         memcpy(cur_spot, string_array[i].bufstart,
> > >                string_array[i].buflen);
> > >         string_array[i].bufstart = cur_spot;
> > >         cur_size = string_array[i].buflen;
> > >         if (cur_size & 0x0f) {
> > >           cur_size &= ~0x0f;
> > >           cur_size += 16;
> > >         }
> > >         cur_spot += cur_size;
> > 769c769
> > <    this is enough to get rid of 'em both */
> > ---
> > >          this is enough to get rid of 'em both */
> > 796c796
> > <                  size_t size, UINTVAL public) {
> > ---
> > >                        size_t size, UINTVAL public) {
> > 862,864c862,864
> > <   return_val = interpreter->arena_base->memory_pool->top;
> > <   interpreter->arena_base->memory_pool->top += size;
> > <   interpreter->arena_base->memory_pool->free -= size;
> > ---
> > >         return_val = interpreter->arena_base->memory_pool->top;
> > >         interpreter->arena_base->memory_pool->top += size;
> > >         interpreter->arena_base->memory_pool->free -= size;
> > 868c868
> > <   return_val = NULL;
> > ---
> > >         return_val = NULL;
> > Index: test_main.c
> > ===================================================================
> > RCS file: /cvs/public/parrot/test_main.c,v
> > retrieving revision 1.49
> > diff -r1.49 test_main.c
> > 124,132c124,132
> > <   -b      Activate bounds checks\n\
> > <   -d      Activate debugging\n\
> > <   -h      Display this message\n\
> > <   -j      Activate Just-In-Time compiler\n\
> > <   -p      Activate profiling\n\
> > <   -P      Activate predereferencing\n\
> > <   -t      Activate tracing\n\
> > <   -v      Display version information\n\
> > <   -.      Wait for a keypress (gives Windows users time to attach a debug
> ger)\n\n"
> > ---
> > >   -b    Activate bounds checks\n\
> > >   -d    Activate debugging\n\
> > >   -h    Display this message\n\
> > >   -j    Activate Just-In-Time compiler\n\
> > >   -p    Activate profiling\n\
> > >   -P    Activate predereferencing\n\
> > >   -t    Activate tracing\n\
> > >   -v    Display version information\n\
> > >   -.    Wait for a keypress (gives Windows users time to attach a debugger)
> \n\n"
> >
> >
>
>
>
? tabs.txt

Index: resources.c

===================================================================

RCS file: /cvs/public/parrot/resources.c,v

retrieving revision 1.33

diff -r1.33 resources.c

23,24c23,24

<                           struct free_pool *pool, void

<                           *to_add) {

---

>                             struct free_pool *pool, void

>                             *to_add) {

32,34c32,34

<                                            pool->pool_buffer.bufstart,

<                                            pool->pool_buffer.buflen,

<                                            (UINTVAL)(pool->pool_buffer.buflen * 
1.2));

---

>                                              pool->pool_buffer.bufstart,

>                                              pool->pool_buffer.buflen,

>                                              (UINTVAL)(pool->pool_buffer.buflen * 
>1.2));

65,66c65,66

<                            thing, as the headers go into a single

<                            allocation pool */

---

>                              thing, as the headers go into a single

>                              allocation pool */

86,87c86,87

<                   interpreter->arena_base->pmc_pool,

<                   cur_pmc++);

---

>                     interpreter->arena_base->pmc_pool,

>                     cur_pmc++);

180,181c180,181

<                            thing, as the headers go into a single

<                            allocation pool */

---

>                              thing, as the headers go into a single

>                              allocation pool */

201,202c201,202

<                      interpreter->arena_base->buffer_header_pool,

<                      cur_buffer++);

---

>                        interpreter->arena_base->buffer_header_pool,

>                        cur_buffer++);

264,265c264,265

<                              struct free_pool *pool, void

<                              *to_add) {

---

>                                struct free_pool *pool, void

>                                *to_add) {

273,275c273,275

<                                            pool->pool_buffer.bufstart,

<                                            pool->pool_buffer.buflen,

<                                            (UINTVAL)(pool->pool_buffer.buflen * 
1.2));

---

>                                              pool->pool_buffer.bufstart,

>                                              pool->pool_buffer.buflen,

>                                              (UINTVAL)(pool->pool_buffer.buflen * 
>1.2));

307c307

<       pmc_array[i].flags &= ~PMC_live_FLAG;

---

>         pmc_array[i].flags &= ~PMC_live_FLAG;

329c329

<       string_array[i].flags &= ~BUFFER_live_FLAG;

---

>         string_array[i].flags &= ~BUFFER_live_FLAG;

462,464c462,464

<       if(cur_chunk->SReg[j].registers[i]) {

<         buffer_lives((Buffer *)cur_chunk->SReg[j].registers[i]);

<       }

---

>         if(cur_chunk->SReg[j].registers[i]) {

>           buffer_lives((Buffer *)cur_chunk->SReg[j].registers[i]);

>         }

476c476

<       buffer_lives((Buffer *)cur_stack->entry[i].entry.string_val);

---

>         buffer_lives((Buffer *)cur_stack->entry[i].entry.string_val);

505c505

<       add_pmc_to_free(interpreter,

---

>         add_pmc_to_free(interpreter,

528,531c528,531

<                                    BUFFER_on_free_list_FLAG))) {

<       add_header_to_free(interpreter,

<                          interpreter->arena_base->string_header_pool,

<                          &string_array[i]);

---

>                                      BUFFER_on_free_list_FLAG))) {

>         add_header_to_free(interpreter,

>                            interpreter->arena_base->string_header_pool,

>                            &string_array[i]);

586,587c586,587

<                            thing, as the headers go into a single

<                            allocation pool */

---

>                              thing, as the headers go into a single

>                              allocation pool */

607,608c607,608

<                      interpreter->arena_base->string_header_pool,

<                      cur_string++);

---

>                        interpreter->arena_base->string_header_pool,

>                        cur_string++);

662c662

<        NULL != cur_pool; cur_pool = cur_pool->prev) {

---

>          NULL != cur_pool; cur_pool = cur_pool->prev) {

673,675c673,675

<   struct Memory_Pool *new_block;      /* A pointer to our working pool */

<   char *cur_spot;             /* Where we're currently copying to */

<   UINTVAL cur_size;   /* How big our chunk is going to be */

---

>   struct Memory_Pool *new_block;        /* A pointer to our working pool */

>   char *cur_spot;               /* Where we're currently copying to */

>   UINTVAL cur_size;     /* How big our chunk is going to be */

693,694c693,694

<        interpreter->arena_base->string_header_pool->pool_buffer.bufstart, 

<        interpreter->arena_base->string_header_pool->pool_buffer.buflen);

---

>          interpreter->arena_base->string_header_pool->pool_buffer.bufstart, 

>          interpreter->arena_base->string_header_pool->pool_buffer.buflen);

705,706c705,706

<        interpreter->arena_base->pmc_pool->pool_buffer.bufstart, 

<        interpreter->arena_base->pmc_pool->pool_buffer.buflen);

---

>          interpreter->arena_base->pmc_pool->pool_buffer.bufstart, 

>          interpreter->arena_base->pmc_pool->pool_buffer.buflen);

717,718c717,718

<        interpreter->arena_base->buffer_header_pool->pool_buffer.bufstart, 

<        interpreter->arena_base->buffer_header_pool->pool_buffer.buflen);

---

>          interpreter->arena_base->buffer_header_pool->pool_buffer.bufstart, 

>          interpreter->arena_base->buffer_header_pool->pool_buffer.buflen);

736,746c736,746

<         && !(string_array[i].flags & BUFFER_immobile_FLAG)

<         && string_array[i].bufstart) {

<       memcpy(cur_spot, string_array[i].bufstart,

<              string_array[i].buflen);

<       string_array[i].bufstart = cur_spot;

<       cur_size = string_array[i].buflen;

<       if (cur_size & 0x0f) {

<         cur_size &= ~0x0f;

<         cur_size += 16;

<       }

<       cur_spot += cur_size;

---

>           && !(string_array[i].flags & BUFFER_immobile_FLAG)

>           && string_array[i].bufstart) {

>         memcpy(cur_spot, string_array[i].bufstart,

>                string_array[i].buflen);

>         string_array[i].bufstart = cur_spot;

>         cur_size = string_array[i].buflen;

>         if (cur_size & 0x0f) {

>           cur_size &= ~0x0f;

>           cur_size += 16;

>         }

>         cur_spot += cur_size;

769c769

<        this is enough to get rid of 'em both */

---

>          this is enough to get rid of 'em both */

796c796

<                      size_t size, UINTVAL public) {

---

>                        size_t size, UINTVAL public) {

862,864c862,864

<       return_val = interpreter->arena_base->memory_pool->top;

<       interpreter->arena_base->memory_pool->top += size;

<       interpreter->arena_base->memory_pool->free -= size;

---

>         return_val = interpreter->arena_base->memory_pool->top;

>         interpreter->arena_base->memory_pool->top += size;

>         interpreter->arena_base->memory_pool->free -= size;

868c868

<       return_val = NULL;

---

>         return_val = NULL;

Index: test_main.c

===================================================================

RCS file: /cvs/public/parrot/test_main.c,v

retrieving revision 1.49

diff -r1.49 test_main.c

124,132c124,132

<   -b  Activate bounds checks\n\

<   -d  Activate debugging\n\

<   -h  Display this message\n\

<   -j  Activate Just-In-Time compiler\n\

<   -p  Activate profiling\n\

<   -P  Activate predereferencing\n\

<   -t  Activate tracing\n\

<   -v  Display version information\n\

<   -.  Wait for a keypress (gives Windows users time to attach a debugger)\n\n"

---

>   -b    Activate bounds checks\n\

>   -d    Activate debugging\n\

>   -h    Display this message\n\

>   -j    Activate Just-In-Time compiler\n\

>   -p    Activate profiling\n\

>   -P    Activate predereferencing\n\

>   -t    Activate tracing\n\

>   -v    Display version information\n\

>   -.    Wait for a keypress (gives Windows users time to attach a debugger)\n\n"

Reply via email to