[BACK]Return to pa_array.C CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/Attic/pa_array.C between versions 1.2 and 1.4

version 1.2, 2001/01/27 15:21:05 version 1.4, 2001/01/29 09:38:33
Line 15  void Array::construct(Pool *apool, int i Line 15  void Array::construct(Pool *apool, int i
         curr_chunk_rows=initial_rows;          curr_chunk_rows=initial_rows;
         head=static_cast<Chunk *>(          head=static_cast<Chunk *>(
                 pool->malloc(sizeof(int)+sizeof(Chunk::Row)*curr_chunk_rows+sizeof(Chunk *)));                  pool->malloc(sizeof(int)+sizeof(Chunk::Row)*curr_chunk_rows+sizeof(Chunk *)));
           head->count=curr_chunk_rows;
         append_here=head->rows;          append_here=head->rows;
         link_row=&head->rows[curr_chunk_rows];          link_row=&head->rows[curr_chunk_rows];
         link_row->link=0;          link_row->link=0;
         fused_rows=0;          fused_rows=0;
   
         cache_index=0;          cache_chunk_base=0;
         cache_row=0;          cache_chunk=head;
         cache_countdown=curr_chunk_rows;  
         cache_link_row=link_row;  
 }  }
   
 void Array::expand() {  void Array::expand() {
Line 48  Array& Array::operator += (Item src) { Line 47  Array& Array::operator += (Item src) {
         return *this;          return *this;
 }  }
   
 /*  Array::Item& Array::operator [] (int index) {
 char *Array::c_str() {          if(!(index>=0 && index<size())) {
         char *result=static_cast<char *>(pool->malloc(size()+1));                  // FIX: some sort of thread-global error
                   Item *result=0;
         char *copy_here=result;                  return *result;
         Chunk *chunk=&head;           }
         do {  
                 Chunk::Row *row=chunk->rows;  
                 for(int i=0; i<chunk->count; i++) {  
                         if(row==append_here)  
                                 goto break2;  
   
                         memcpy(copy_here, row->item.ptr, row->item.size);  
                         copy_here+=row->item.size;  
                         row++;  
                 }  
                 chunk=row->link;  
         } while(chunk);  
 break2:  
         *copy_here=0;  
         return result;  
 }  
 */  
 /*  
 void Array::put(int index, Item item) {  
 }  
   
 Array::Item Array::get(int index) {          // if they ask index to the left of cached position, forget cache
 }          if(index<cache_chunk_base) {
 */                  cache_chunk_base=0;
                   cache_chunk=head;
           }
   
 Array::Item& Array::operator [] (int index) {          // navigate to chunk with "index" row
         // we have cached row&index?          while(!(index>=cache_chunk_base && index<cache_chunk_base+cache_chunk->count)) {
         if(index>=cache_index && index<cache_index+cache_countdown) {                  int count=cache_chunk->count;
                   cache_chunk_base+=count;
                   cache_chunk=cache_chunk->rows[count].link;
         }          }
   
         int cache_index;          return cache_chunk->rows[index-cache_chunk_base].item;
         Chunk::Row *cache_row;  }
         int cache_countdown;  
         Chunk::Row *cache_link_row;  Array& Array::operator += (Array& src) {
           int src_size=src.size();
           int last_chunk_rows_left=link_row-append_here;
                   
         return 0;  
 }  
   
           // src fits into our lask chunk?
           if(src_size<=last_chunk_rows_left) {
                   Chunk *src_chunk=src.head; 
                   Chunk::Row *dest_rows=append_here;
                   int rows_left_to_copy=src_size;
                   while(true) {
                           int src_count=src_chunk->count;
                           Chunk *next_chunk=src_chunk->rows[src_count].link;
                           if(next_chunk) {
                                   // not last source chunk
                                   // taking it all
                                   memcpy(dest_rows, src_chunk->rows, sizeof(Chunk::Row)*src_count);
                                   dest_rows+=src_count;
                                   rows_left_to_copy-=src_count;
   
                                   src_chunk=next_chunk;
                           } else {
                                   // the last source chunk
                                   // taking only those rows of chunk that _left_to_copy
                                   memcpy(dest_rows, src_chunk->rows, sizeof(Chunk::Row)*rows_left_to_copy);
                                   break;
                           }
                   }
           } else {
           }
   
           return *this;
   }
   
   void Array::remove(int index, int count=1) {
   }
Removed from v.1.2  
changed lines
  Added in v.1.4

E-mail: