src/common/string.cpp

Idź do dokumentacji tego pliku.

/***********************************************************
*PANALIX 0.06, (c) Adrian Panasiuk 2002-4                  *
*adek336[at]o2.pl, panalix.prv.pl                          *
*under GPLv3 license                                       *
*                                                          *
*panalix - small osdev project                             *
************************************************************
*       string.cpp, version 1.2                                *
************************************************************
string.cpp, here we have a class which allocates strings
and takes care for not overflowing the buffer.


05'05'13- minor changes.(1.2.1)
18'04'04- fork from the 0.05 branch(1.2)
***********************************************************/
 
#include "src/common/shared.hpp"
#include "src/common/string.hpp"
// #include "LINKER/cpprtl.hpp"
// #include "LINKER/debug.hpp"
// #include "LINKER/teletype.hpp"
#include "src/memory/align.hpp"
#include "src/memory/memset.hpp"
#include "src/memory/heap.hpp"
#include "src/common/string.hpp"

const int DEF_ERROR = 1;
const int DEF_SUCCESS = 0;

#define kmalloc(size) ((char*)Memory::Heap::heap0.malloc(size, 1,"n/a",NULL))
#define kfree(ptr) (Memory::Heap::heap0.free(ptr))

char *krealloc_old(char *s, int ss)
 {
char *buf = kmalloc(ss);
        if (buf==NULL)
                return NULL;
        memmove(buf,s,ss);
        kfree(s);
        return buf;
 }


/*init without a string*/
string::string()
 {
/*to make sure nobody tries to read it*/
        asciiz = (char*) 0;
        mx_size = 0;
 }

/*init and set asciiz to str*/
string::string(char *str)
 {
/*just that string*/
        asciiz = str;
        mx_size = length();
 }

/*init and copy size bytes from str to asciiz*/
/*should not copy more than the string's size*/
string::string(char *str, uint32 size)
 {
/*allocate a buffer*/
        asciiz = kmalloc(size + 1);     /*count the zero in*/
        mx_size = size;
/*copy the string*/
        copy(str, size);
 }

/*init with a size*/
string::string (uint32 size)
 {
        asciiz = kmalloc(size + 1);     /*count the zero in*/
        mx_size = size;

/*make it an empty string*/
        asciiz[0] = 0;
 }

/*kill class*/
string::~string()
 {
        if (mx_size != 0)
         {
        /*dispose buffer*/
                kfree(asciiz);
                asciiz = 0; mx_size = 0;
         }
 }

/*leave the string unchanged and set the buffer as empty*/
void string::inval()
 {
/*make the pointer point at nothing*/
        asciiz = 0;
/*maxsize is 0*/
        mx_size = 0;
 }

/*get the string value*/
char *string::v()
 {
        return asciiz;
 }

/*realloc to size if buffer's smaller*/
uint32 string::verify(uint32 size)
 {
char *new_buf;

/*check if we've got a buffer*/
        if (mx_size == 0)
        {
                nw (size+1);
                return DEF_SUCCESS;
        }

/*check if buffer is big enough*/
        if (mx_size < size)
         {
        /*alloc additional 0x20 bytes, just for sake*/
                size+=0x20;

                new_buf = krealloc_old (asciiz, size + 1);      /*also count in the zero char*/
                if (new_buf == 0)
                /*if krealloc failed*/
                        return DEF_ERROR;

                kfree( asciiz );
                asciiz = new_buf;
                mx_size = size;
         }
        return DEF_SUCCESS;
 }

/*makes asciiz point at str*/
void string::set (char *str)
 {
        asciiz = str;
        mx_size = length();
 }

/*makes the buffer be buff*/
void string::set (char *buff, uint32 size)
 {
        asciiz=buff;mx_size = size;asciiz[0]=0;
 }

/*creates a new buffer*/
void string::nw (uint32 size)
 {
        asciiz = kmalloc(size + 1);             /*count the zero in*/
        mx_size = size;

        /*make it an empty string*/
        asciiz[0] = 0;
 }

/*disposes buffer*/
void string::done()
 {
/*check if there's a buffer to dispose*/
        if (mx_size == 0)
                return;

        kfree( asciiz );
        asciiz = (char*) NULL;
        mx_size = 0;
 }

/*copies a string to the buffer*/
void string::copy (char *str)
 {
/*is the buffer big enough?*/
        verify(lgth(str));

/*copy contents*/
        memmove (asciiz,str, lgth(str) + 1);    /*count the zero char in*/
 }

/*no more than size bytes*/
void string::copy (char *str, uint32 size)
 {
/*is the buffer big enough?*/
        verify(size);

        if (lgth(str) > size)
         {
        /*too big and we can only copy size bytes*/
                memmove (asciiz,str, size);
                asciiz[size+1] = 0;     /*zero sign*/
         }
                 else
                /*the string is shorter than size bytes*/
                        memmove (asciiz,str, lgth(str) + 1);    /*zero sign*/
 }

/*concats to the end of asciiz*/
char *string::strncat(const char *str)
 {
/*verify length asciiz + length str*/
        verify(length() + lgth(str) + 1);

/*copy: from str; to asciiz + length asciiz; size lgth str*/
        memmove(asciiz+length(),str, lgth(str)+1); /*count in the zero sign*/

/*may be useful*/
        return asciiz;
 }

/*concats one char*/
char *string::add_char(char ch)
 {
/*verify length asciiz + 1 char*/
        verify(length() + 1);
/*add the zero char*/
        asciiz[length()+1]=0;
/*add the char*/
        asciiz[length()] = ch;

/*return asciiz, may be useful*/
        return asciiz;
 }

/*cuts so the string's length will be n*/
char *string::cut(uint32 n)
 {
uint32 i;
/*check, if n is smaller than the length*/
        if (n < length())
         {
        /*put the null character*/
                asciiz[n]=0;
        /*and run*/
                return asciiz;
         }
/*if we want to make it larger, 1)verify buffer*/
        verify(n);
/*now delete all characters from the new part*/
        for (i=length(); i<n; i++)
                asciiz[i] = ' ';
/*put a null char*/
        asciiz[n] = 0;
/*run*/
        return asciiz;
 }

/*string length*/
uint32 string::length()
 {
/*check if we've got a buffer*/
        if (asciiz == 0) return 0;

        return lgth (asciiz);
 }

/*compare string with asciiz*/
uint32 string::strcmp(char *s)
 {
uint32 i;
/*check lengths*/
        if (lgth(s) != length())
                return 0;

/*check byte after byte*/
        for (i=0; i<lgth(s); i++)
                if (asciiz[i] != s[i])  return 0;

/*if we've got here, they are all equal*/
        return 1;
 }

/*regular function for checking string length*/
uint32 lgth (const char *str)
 {
const char *s;
/*find the last char*/
        for (s = str; *s; s++);

/*return value*/
        return (uint32) s - (uint32) str;
 }

//format text. asciiz must be initialized; asciiz gets emptied
char *string::formatText(char *text, char *tokens)
 {
/*constant size growth of our buffer*/
const uint32 el_size = 0x20;
/*used to count decimals*/
string str (0x20);
/*our counter*/
uint32 count = 0;
int flag;       //bit 0- whether we still analyze the format identifiers; bit 1- pad; bit 2- pad with zeroes
uint32 pad_size; //padding to what how much
/*verify the buffer's at least el_size of length*/
        verify(el_size);

/*empty the buffer*/
        asciiz[0] = 0;

/*check each letter*/
        for (text = text; *text; text++)
         {
                flag=0;pad_size=0;
/*check for a percent sign*/
                if (*text == '%') {
                do {
                        text++;
                        switch (*text)
                         {
                        /*a single character*/
                                case 'c':
                                        asciiz [count] = *(tokens + 3);count++;
                                        tokens += 4;
                                        flag=0;break;
                        /*a percent sign*/
                                case '%':
                                        asciiz [count] = '%';count++;
                                        flag=0;break;
                        /*a full string*/
                                case 's':
                                        asciiz[count] = 0;      /*necessary for strncat to work properly*/
                                        strncat((char*)(*(uint32*)(tokens + 3)));
                                        count += lgth((char*)(*(uint32*)(tokens + 3))); tokens+=4;
                                        flag=0;break;
                        /*decimal*/
                                case 'd':
                                        asciiz[count] = 0;      /*necessary for strncat to work properly*/
                                        strncat(str.decim( *(uint32*)(tokens + 3) ));
                                        count += str.length();tokens+=4;
                                        flag=0;break;
                                case 'x':
                                 asciiz[count] = 0;     //necessary for strncat to work properly
                                 strncat(str.hex( *(uint32*)(tokens + 3), '0', 8-pad_size));
                                 count += str.length();tokens+=4;
                                flag=0;break;
                        /*uin64*/
//                              case 'q':
//                                      asciiz[count] = 0;
//                                      strncat(str.quad( *(uint64*)(tokens
                        /*0 filling*/
                                case '0':
                                        if (!(flag & 4)) {
                                                flag|= 1|4; //cont analyze and pad with zeroes
                                                break; }
                                case'1':case'2':case'3':case'4':case'5':
                                case'6':case'7':case'8':case'9':
                                        flag|=2;
                                        pad_size*=10;
                                        pad_size+=*text - '0';
                                        break;                                  
/*                                      text++;
                                //decimal
                                        if (*text == 'd'){
                                         asciiz[count] = 0;     //necessary for strncat to work properly
                                         strncat(str.decim( *(uint32*)(tokens + 3), '0'));
                                         count += str.length();tokens+=4;}
                                //hex
                                        if (*text == 'x'){
                                         asciiz[count] = 0;     //necessary for strncat to work properly
                                         strncat(str.hex( *(uint32*)(tokens + 3), '0'));
                                         count += str.length();tokens+=4;}
                                        break;*/
                        default: flag=0;break;
                         }
                 } while(flag);} else
                        {asciiz [count] = *text;count++;}

        /*the buffer's full*/
                if (count > mx_size)
                        verify (mx_size + el_size);
         }

        asciiz [count] = 0;
        str.done();

        return asciiz;
 }

/*how many tokens, divided by div*/
uint32 string::token_count(char div)
 {
char *ptr;
char last_char = div;
uint32 count = 0, flag = 0;

/*each time there's a char-div or a div-char combination of two chars, count it*/
        for (ptr = asciiz;*ptr;ptr++)
         {
        /*the previous was a div char, the current isn't*/
                if ((*ptr != div) && (last_char == div)) {
                        if (!flag) {count++;flag=1;} else flag=0;       /*so we do not count each block twice*/
      }

        /*the previous wasn't a div char, the current is*/
                if ((*ptr == div) && (last_char != div)) {
                        if (!flag) {count++;flag=1;} else flag=0;       /*so we do not count each block twice*/
      }

        /*the last character seen*/
                last_char = *ptr;
         }

/*return the count*/
        return count;
 }

/*returns token #i (first i=0) divided by div. independent from asciiz, have to dispose string manually*/
char *string::token(uint32 i, char div)
 {
uint32 count;
char *ptr = asciiz;
string str;
char *ret_val;

/*check if there are so many tokens*/
        if (i >= token_count(div))
                return 0;

/*find the first non-div character*/
        while (*ptr == div)
                ptr++;
/*continue as long as we find the correct block*/
        for (count=0; count < i; count++)
         {
        /*ignore the next non-div chars*/
                while (*ptr != div)     ptr++;
        /*and ignore the div chars*/
                while (*ptr == div)     ptr++;
         }
/*now copy the token*/
        while ((*ptr) && (*ptr != div))
         {
                str.add_char(*ptr);
                ptr++;
         }

/*save return value*/
        ret_val = str.v();
/*against auto-disposal*/
        str.inval();
/*return token. has to be disposed manually*/
        return ret_val;
 }

/*sets asciiz to a number in decimal*/
char *string::decim(uint32 n)
 {
        number (n,              /*the number*/
                        10,             /*the radix*/
                        1000000000,/*the biggest decimal pos*/
                        0,              /*do not fill zeroes*/
                        0,30);          /*not used*/

/*return value, may be useful*/
        return asciiz;
 }

/*sets asciiz to a number in decimal, but fill in space*/
char *string::decim(uint32 n, char zero)
 {
        number (n,              /*the number*/
                        10,             /*the radix*/
                        1000000000,/*the biggest decimal pos*/
                        1,              /*fill in zeroes*/
                        zero, 0);       /*what to put in place of zero*/

/*return value, may be useful*/
        return asciiz;
 }

/*sets asciiz to a number in decimal*/
char *string::hex(uint32 n)
 {
        number (n,                      /*the number*/
                        0x10,           /*the radix*/
                        0x10000000,     /*the biggest decimal pos*/
                        0,              /*do not fill zeroes*/
                        0,40);          /*not used*/

/*return value, may be useful*/
        return asciiz;
 }

/*sets asciiz to a number in decimal, but fill in space*/
char *string::hex(uint32 n, char zero) {
        return hex(n,zero,0);
 }
char *string::hex(uint32 n, char zero, uint8 pad_size)
 {
        number (n,                      /*the number*/
                        0x10,           /*the radix*/
                        0x10000000,/*the biggest hex pos*/
                        1,                      /*fill in zeroes*/
                        zero,pad_size);         /*what to put in place of zero*/

/*return value, may be useful*/
        return asciiz;
 }

/*sets asciiz to a string with the number n in radix. if zeroes = 1 then zero fill the space*/
char *string::number (uint32 n, uint32 radix, uint32 n_pos, uint32 zeroes, char zero, uint8 nps)
 {
union
 {
        uint32 u32[2];
        uint64 u64;
 };
        u32[0]=n; u32[1]=0;
        return num64(u64,radix,n_pos,zeroes,zero,nps);
  }

/*sets asciiz to a string with the number n in radix. if zeroes = 1 then zero fill the space*/
//nps= (the max count of ciphers) - (requested minimum result size)
char *string::num64 (uint64 n, uint32 radix, uint64 n_pos, uint32 zeroes, char zero, uint8 nps)
 {
char first_letter = 'A';
uint64 cipher;
char fl = 0;    /*flag if non-zero letter were already displayed*/
uint32 count = 0;       /*how many letter already written*/
        verify (10);    /*no more space necessary*/
uint32 count2=0;

        while (n_pos)
         {
                count2++;
                cipher = n / n_pos;
                if (cipher <= 9)
                        {
                        /*put the number*/
                         if (cipher||fl){
                          fl = 1;
                          asciiz[count] = cipher + (char) '0';
                          count++;}
                         /*put a filler*/
                         if ((!fl)&&((!cipher)&&(zeroes)&&(count2>nps))){
                          asciiz[count] = zero;
                          count++;};
                        }
                        else
                                {
                                        fl = 1;
                                        asciiz[count]=cipher + first_letter - 0xA;
                                        count++;
                                }

                n -= cipher * n_pos;
                n_pos = n_pos / radix;
         }

/*if the number's a zero*/
        if (count == 0)
         {
                asciiz[count] = '0';
                count++;
         }

/*close string*/
        asciiz[count] = 0;

/*return value, may be useful*/
        return asciiz;
 }

/*returns the value of the string, if non-int then error != 0*/
uint32 string::int_val(uint32 radix, uint32 *error)
 {
uint32 n;
uint32 value;
uint32 pos = 1;
char *ch;
/*no error*/
        *error = 0; value=0;
/*for each char*/
        n = length() - 1;
        while ((int)n>=0)
         {
        /*the processed char*/
                ch = asciiz + n;
        /*check if correct*/
                if (cipher(*ch, radix) == (uint32)DEF_ERROR)
                        {*error=n+1;return value;}
        /*increase value*/
                value += pos * (cipher(*ch, radix));
        /*increase pos*/
                pos = pos * radix; 
                n--;
         }

/*return value*/
        return value;
 }

/*return cipher represented in ch in radix, returns DEF_ERROR if incorrect*/
uint32 cipher(char ch, uint32 radix)
 {
uint32 val;
/*'a' > 'A' > '0'*/
/*check if 0-9 range*/
        if (ch >= '0')
                        val = ch - '0';
/*big letter range*/
        if (ch >= 'A')
                        val = ch - 'A' + 10;
/*not 0-9 range, check small letter range*/
        if (ch >= 'a')
                        val = ch - 'a' + 10;

/*check if is inbounds for the radix*/
        if (val < radix)
                return val;
        else
                return DEF_ERROR;
 }

/*returns 1 if *ch contains only c chars, else 0*/
uint32 all_chars(char *ch, char c)
 {
char *ptr;
/*if empty string, return 0*/
        if (lgth(ch)==0)
                return 0;
/*check every char*/
        for (ptr=ch; *ptr; ptr++)
                if (*ptr!=c) return 0;

/*return yes*/
        return 1;
 }

/*returns first char which differs, 0 if equal*/
uint32 str_dif(char *ch1, char *ch2)
 {
uint32 n = 0;
/*check all chars*/
        while (*ch1 == *ch2)
         {
        /*if is equal and the strings ended, they're equal. return DEF_ERROR*/
                if (*ch1 == 0)
                        return DEF_ERROR;
        /*next char*/
                ch1++;ch2++;n++;
         }

/*return difference*/
        return n;
 }

/***********************************************************
*                                                          *
*panalix 0.06 (c) Adrian Panasiuk 2002-4                   *
*adek336[at]o2.pl, panalix.prv.pl                          *
*                                                          *
***********************************************************/

---