Return to pa_string.C CVS log

Up to [parser3project] / parser3 / src / main

Annotation of parser3/src/main/pa_string.C, revision 1.7

1.4       paf         1: /*
1.7     ! paf         2:   $Id: pa_string.C,v 1.6 2001/01/26 18:55:55 paf Exp $
1.4       paf         3: */
                      4: 
1.1       paf         5: #include <string.h>
                      6: 
                      7: #include "pa_pool.h"
1.5       paf         8: #include "pa_hash.h"
1.1       paf         9: 
                     10: void *String::operator new(size_t size, Pool *apool) {
1.5       paf        11:        return apool->malloc(size);
1.1       paf        12: }
                     13: 
1.2       paf        14: void String::construct(Pool *apool) {
1.1       paf        15:        pool=apool;
1.2       paf        16:        head.count=curr_chunk_rows=CR_PREALLOCATED_COUNT;
1.5       paf        17:        append_here=head.rows;
1.2       paf        18:        head.preallocated_link=0;
1.5       paf        19:        link_row=&head.rows[curr_chunk_rows];
1.1       paf        20: }
                     21: 
                     22: void String::expand() {
1.2       paf        23:        curr_chunk_rows=curr_chunk_rows*100/CR_GROW_PERCENT;
                     24:        Chunk *chunk=static_cast<Chunk *>(
                     25:                pool->calloc(sizeof(Chunk::Row)*curr_chunk_rows+sizeof(Chunk *)));
                     26:        chunk->count=curr_chunk_rows;
                     27:        link_row->link=chunk;
1.5       paf        28:        append_here=chunk->rows;
                     29:        link_row=&chunk->rows[curr_chunk_rows];
1.1       paf        30: }
                     31: 
1.5       paf        32: String::String(String& src) {/*
                     33:        int src_used_rows=src.used_rows(); {
                     34:                curr_chunk_rows=src_total_rows
                     35:                        Chunk *chunk=static_cast<Chunk *>(
                     36:                        pool->calloc(sizeof(Chunk::Row)*curr_chunk_rows+sizeof(Chunk *)));
                     37:                chunk->count=curr_chunk_rows;
                     38:                link_row->link=chunk;
                     39:                append_here=chunk->rows;
                     40:                link_row=&chunk->rows[curr_chunk_rows];
                     41:        }
                     42: 
                     43:        Chunk *chunk=&head; 
                     44:        do {
                     45:                result+=chunk->count;
                     46:                chunk=row->link;
                     47:        } while(chunk);
                     48: break2:
                     49:        return result;*/
                     50: 
                     51: }
                     52: 
1.6       paf        53: String& String::operator = (String& src) {
                     54:        return *this;
                     55: }
                     56: 
1.5       paf        57: 
1.1       paf        58: String& String::operator += (char *src) {
                     59:        if(chunk_is_full())
                     60:                expand();
                     61: 
                     62:        append_here->item.ptr=src;
                     63:        append_here->item.size=strlen(src);
                     64:        append_here++;
                     65: 
                     66:        return *this;
                     67: }
                     68: 
                     69: size_t String::size() {
                     70:        int result=0;
1.5       paf        71: 
1.2       paf        72:        Chunk *chunk=&head; 
                     73:        do {
1.5       paf        74:                Chunk::Row *row=chunk->rows;
1.2       paf        75:                for(int i=0; i<chunk->count; i++) {
1.1       paf        76:                        if(row==append_here)
                     77:                                goto break2;
                     78: 
                     79:                        result+=row->item.size;
                     80:                        row++;
                     81:                }
1.2       paf        82:                chunk=row->link;
                     83:        } while(chunk);
1.1       paf        84: break2:
                     85:        return result;
                     86: }
                     87: 
                     88: char *String::c_str() {
1.5       paf        89:        char *result=static_cast<char *>(pool->malloc(size()+1));
1.1       paf        90: 
                     91:        char *copy_here=result;
1.2       paf        92:        Chunk *chunk=&head; 
                     93:        do {
1.5       paf        94:                Chunk::Row *row=chunk->rows;
1.2       paf        95:                for(int i=0; i<chunk->count; i++) {
1.1       paf        96:                        if(row==append_here)
                     97:                                goto break2;
                     98: 
                     99:                        memcpy(copy_here, row->item.ptr, row->item.size);
                    100:                        copy_here+=row->item.size;
                    101:                        row++;
                    102:                }
1.2       paf       103:                chunk=row->link;
                    104:        } while(chunk);
1.1       paf       105: break2:
                    106:        *copy_here=0;
                    107:        return result;
                    108: }
                    109: 
1.5       paf       110: int String::used_rows() {
                    111:        int result=0;
                    112: 
                    113:        Chunk *chunk=&head; 
                    114:        do {
                    115:                int count=chunk->count;
                    116:                result+=count;
                    117:                chunk=chunk->rows[count].link;
                    118:        } while(chunk);
                    119: 
                    120:        result-=link_row-append_here;
                    121: 
                    122:        return result;
                    123: }
                    124: 
1.7     ! paf       125: uint String::hash_code() {
        !           126:        uint result=0;
1.5       paf       127: 
                    128:        Chunk *chunk=&head; 
                    129:        do {
                    130:                Chunk::Row *row=chunk->rows;
                    131:                for(int i=0; i<chunk->count; i++) {
                    132:                        if(row==append_here)
                    133:                                goto break2;
                    134: 
1.6       paf       135:                        result=Hash::generic_code(result, row->item.ptr, row->item.size);
1.5       paf       136:                        row++;
                    137:                }
                    138:                chunk=row->link;
                    139:        } while(chunk);
                    140: break2:
                    141:        return result;
                    142: }
                    143: 
                    144: bool String::operator == (String& src) {
                    145:        return false;
                    146: }