vhdlparser/vhdlstring.h

   1 #ifndef VHDLSTRING_H
   2 #define VHDLSTRING_H
   3
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7
   8
   9 /** @brief Minimal string class with std::string like behaviour that fulfills the JavaCC
  10  *  string requirements.
  11  */
  12
  13 class VhdlString
  14 {
  15   public:
  16     VhdlString()
  17     {
  18       init();
  19     }
  20     VhdlString(const VhdlString &other)
  21     {
  22       m_str = (char*)malloc(other.m_len+1);
  23       memcpy(m_str,other.m_str,other.m_len);
  24       m_len = other.m_len;
  25       m_str[m_len]=0;
  26     }
  27     VhdlString &operator=(const VhdlString &other)
  28     {
  29       if (this!=&other)
  30       {
  31         free(m_str);
  32         m_str = (char*)malloc(other.m_len+1);
  33         memcpy(m_str,other.m_str,other.m_len);
  34         m_len = other.m_len;
  35         m_str[m_len]=0;
  36       }
  37       return *this;
  38     }
  39     VhdlString(const char *s)
  40     {
  41       m_len = strlen(s);
  42       m_str=(char*)malloc(m_len+1);
  43       memcpy(m_str,s,m_len+1);
  44     }
  45     VhdlString(const char *s,int size)
  46     {
  47       m_str = (char*)malloc(size+1);
  48       memcpy(m_str,s,size);
  49       m_str[size]=0;
  50       m_len=size;
  51     }
  52    ~VhdlString()
  53     {
  54       free(m_str);
  55     }
  56     VhdlString& append(const char *s,int size)
  57     {
  58       int oldlen = m_len;
  59       m_len+=size+1;
  60       if (m_len)
  61       {
  62         m_str = (char*)realloc(m_str,m_len);
  63         memcpy(m_str+oldlen,s,m_len-oldlen-1);
  64         m_str[m_len-1]=0;
  65       }
  66       return *this;
  67     }
  68     VhdlString& append(const char *s)
  69     {
  70       return append(s,strlen(s));
  71     }
  72     VhdlString& append(const VhdlString &other)
  73     {
  74       return append(other.m_str,other.m_len);
  75     }
  76     VhdlString substr(int pos=0,int len=-1)
  77     {
  78       return VhdlString(m_str?m_str+pos:0,len==-1?m_len-pos:m_len);
  79     }
  80     int copy(char *s,int len,int pos=0) const
  81     {
  82       if (len==0) return 0;
  83       if (pos>=m_len) { s[0]=0; return 0; }
  84       int r=m_len<pos+len ? m_len-pos : len;
  85       memcpy(s,m_str+pos,r);
  86       return r;
  87     }
  88     const char *c_str() const           { return m_str; }
  89     const char *data() const            { return m_str; }
  90     int         size() const            { return m_len; }
  91     int         length() const          { return m_len; }
  92     char &      operator[](int i)       { return m_str[i]; }
  93     const char &operator[](int i) const { return m_str[i]; }
  94     void        clear()                 { free(m_str); init(); }
  95     VhdlString  &operator+=(char c)      { char s[2]; s[0]=c; s[1]=0; return append(s); }
  96     VhdlString  &operator+=(const char *s) { return append(s); }
  97     VhdlString  &operator+=(VhdlString s) { return append(s); }
  98     VhdlString   operator+ (const char *s) { return append(s); }
  99
 100   private:
 101     void init() { m_str=(char*)calloc(1,1); m_len=0; }
 102     char *m_str;
 103     int   m_len;
 104 };
 105
 106 // declare it static otherwise we will get:
 107 //   multiple definition of `operator+(char const*, VhdlString)'
 108 // as we are in an include file
 109 static VhdlString   operator+ (const char *s, VhdlString v) { return VhdlString(s).append(v); }
 110
 111 #endif