Ejemplo n.º 1
0
festring& festring::operator=(cchar* CStr)
{DBGEXEC(bugTrackInvalidChars(CStr,strlen(CStr)));
  CheckNull(CStr);

  sizetype NewSize = strlen(CStr);

  if(OwnsData)
  {
    if(!REFS(Data) && NewSize <= Reserved)
    {
      memcpy(Data, CStr, NewSize);
      Size = NewSize;
      return *this;
    }

    if(!REFS(Data)--)
      delete [] &REFS(Data);
  }

  if(NewSize)
    CreateOwnData(CStr, NewSize);
  else
    Empty();

  return *this;
}
Ejemplo n.º 2
0
/// Erase the substring starting from the specified position.
void festring::Erase(sizetype Pos, sizetype Length)
{
  if(!Length || Size <= Pos)
    return;

  if(Pos == 0 && Pos + Length >= Size)
  {
    Empty();
    return;
  }

  char* OldData = Data;
  sizetype OldSize = Size;
  sizetype NewSize = (Pos + Length < Size) ? (Size - Length) : Pos;
  sizetype EraseEnd = (Pos + Length < Size) ? (Pos + Length) : OldSize;

  if(OwnsData)
  {
    if(!REFS(OldData))
    {
      memmove(OldData + Pos, OldData + EraseEnd, OldSize - EraseEnd);
      Size = NewSize;
      return;
    }
    else
      --REFS(OldData);
  }

  CreateNewData(NewSize);
  memcpy(Data, OldData, Pos);
  memcpy(Data + Pos, OldData + EraseEnd, OldSize - EraseEnd);
  Size = NewSize;
}
Ejemplo n.º 3
0
/// Set the data to a string of the same char.
void festring::Assign(sizetype NewSize, char Char)
{
  if(!NewSize)
  {
    Empty();
    return;
  }

  if(OwnsData)
  {
    if(!REFS(Data) && NewSize <= Reserved)
    {
      memset(Data, Char, NewSize);
      Size = NewSize;
      return;
    }

    if(!REFS(Data)--)
      delete [] &REFS(Data);
  }

  CreateNewData(NewSize);
  memset(Data, Char, NewSize);
  Size = NewSize;
}
Ejemplo n.º 4
0
void festring::SlowAppend(char Char)
{
    char* OldPtr = Data;

    if(OldPtr)
    {
        sizetype OldSize = Size++;
        sizetype NewSize = OldSize + 1;
        ulong* DeletePtr = 0;

        if(OwnsData && !REFS(OldPtr)--)
            DeletePtr = &REFS(OldPtr);

        Reserved = NewSize|FESTRING_PAGE;
        char* NewPtr = sizeof(ulong) + new char[Reserved + sizeof(ulong) + 1];
        REFS(NewPtr) = 0;
        Data = NewPtr;
        memcpy(NewPtr, OldPtr, OldSize);
        NewPtr[OldSize] = Char;

        if(DeletePtr)
            delete [] DeletePtr;
    }
    else
    {
        Size = 1;
        Reserved = FESTRING_PAGE;
        char* Ptr = sizeof(ulong) + new char[FESTRING_PAGE + sizeof(ulong) + 1];
        REFS(Ptr) = 0;
        Ptr[0] = Char;
        Data = Ptr;
    }

    OwnsData = true;
}
Ejemplo n.º 5
0
festring& festring::operator=(cfestring& Str)
{DBGEXEC(bugTrackInvalidChars(Str.Data,Str.Size));
  char* CStr = Str.Data;
  sizetype NewSize = Str.Size;

  if(OwnsData)
  {
    if(!REFS(Data) && NewSize <= Reserved)
    {
      memcpy(Data, CStr, NewSize);
      Size = NewSize;
      return *this;
    }

    if(!REFS(Data)--)
      delete [] &REFS(Data);
  }

  Size = NewSize;
  Data = CStr;
  OwnsData = Str.OwnsData;

  if(OwnsData)
  {
    if(REFS(Data) < FESTRING_REF_MAX)
    {
      ++REFS(Data);
      Reserved = Str.Reserved;
    }
    else
      CreateOwnData(CStr, NewSize);
  }

  return *this;
}
Ejemplo n.º 6
0
void festring::SlowAppend(const char* CStr, sizetype N)
{
    char* OldPtr = Data;

    if(OldPtr)
    {
        sizetype OldSize = Size;
        sizetype NewSize = OldSize + N;
        Size = NewSize;
        ulong* DeletePtr = 0;

        if(OwnsData && !REFS(OldPtr)--)
            DeletePtr = &REFS(OldPtr);

        Reserved = NewSize|FESTRING_PAGE;
        char* NewPtr = sizeof(ulong) + new char[Reserved + sizeof(ulong) + 1];
        REFS(NewPtr) = 0;
        Data = NewPtr;
        memcpy(NewPtr, OldPtr, OldSize);
        memcpy(NewPtr + OldSize, CStr, N);
        OwnsData = true;

        if(DeletePtr)
            delete [] DeletePtr;
    }
    else
        CreateOwnData(CStr, N);
}
Ejemplo n.º 7
0
festring& festring::operator=(const festring& Str)
{
    sizetype NewSize = Str.Size;
    Size = NewSize;
    char* Ptr = Data;
    char* StrPtr = Str.Data;

    if(Ptr && OwnsData)
    {
        if(!REFS(Ptr) && NewSize <= Reserved)
        {
            if(StrPtr)
                memcpy(Ptr, StrPtr, NewSize);

            return *this;
        }

        if(!REFS(Ptr)--)
            delete [] &REFS(Ptr);
    }

    if((Data = StrPtr) && (OwnsData = Str.OwnsData))
    {
        ++REFS(StrPtr);
        Reserved = Str.Reserved;
    }

    return *this;
}
Ejemplo n.º 8
0
festring& festring::operator=(staticstring SStr)
{DBGEXEC(bugTrackInvalidChars(SStr.Data,SStr.Size));
  CheckNull(SStr.Data);

  cchar* CStr = SStr.Data;
  sizetype NewSize = SStr.Size;

  if(OwnsData)
  {
    if(!REFS(Data) && NewSize <= Reserved)
    {
      memcpy(Data, CStr, NewSize);
      Size = NewSize;
      return *this;
    }

    if(!REFS(Data)--)
      delete [] &REFS(Data);
  }

  Size = NewSize;
  Data = const_cast<char*>(CStr);
  OwnsData = false;
  return *this;
}
Ejemplo n.º 9
0
void festring::EnsureOwnsData(bool Unique)
{
  if(!OwnsData)
    CreateOwnData(Data, Size);
  else if(Unique && REFS(Data))
  {
    --REFS(Data);
    CreateOwnData(Data, Size);
  }
}
Ejemplo n.º 10
0
void festring::Insert(sizetype Pos, const char* CStr, sizetype N)
{
    if(N)
    {
        sizetype OldSize = Size;

        if(Pos < OldSize) // this implies Data != 0
        {
            char* OldPtr = Data;
            ulong* DeletePtr = 0;
            sizetype NewSize = OldSize + N;
            Size = NewSize;

            if(OwnsData)
            {
                if(!REFS(OldPtr))
                {
                    if(NewSize <= Reserved)
                    {
                        char* Ptr = OldPtr + Pos;
                        memmove(Ptr + N, Ptr, OldSize - Pos);
                        memcpy(Ptr, CStr, N);
                        return;
                    }
                    else
                        DeletePtr = &REFS(OldPtr);
                }
                else
                    --REFS(OldPtr);
            }

            Reserved = NewSize|FESTRING_PAGE;
            char* NewPtr = sizeof(ulong) + new char[Reserved + sizeof(ulong) + 1];
            REFS(NewPtr) = 0;
            Data = NewPtr;
            memcpy(NewPtr, OldPtr, Pos);
            memcpy(NewPtr + Pos, CStr, N);
            memcpy(NewPtr + Pos + N, OldPtr + Pos, OldSize - Pos);
            OwnsData = true;

            if(DeletePtr)
                delete [] DeletePtr;
        }
        else if(Pos == OldSize)
            Append(CStr, N);
        else
            ABORT("Illegal festring insertion detected!");
    }
}
Ejemplo n.º 11
0
void festring::Erase(sizetype Pos, sizetype Length)
{
    char* OldPtr = Data;

    if(OldPtr && Length)
    {
        sizetype OldSize = Size;

        if(Pos < OldSize)
        {
            truth MoveReq = Length < OldSize - Pos;

            if(OwnsData)
            {
                if(!REFS(OldPtr))
                {
                    if(MoveReq)
                    {
                        sizetype End = Pos + Length;
                        memmove(OldPtr + Pos, OldPtr + End, OldSize - End);
                    }

                    Size -= Length;
                    return;
                }
                else
                    --REFS(OldPtr);
            }

            sizetype NewSize = MoveReq ? OldSize - Length : Pos;
            Size = NewSize;
            Reserved = NewSize|FESTRING_PAGE;
            char* Ptr = sizeof(ulong) + new char[Reserved + sizeof(ulong) + 1];
            REFS(Ptr) = 0;
            Data = Ptr;
            OwnsData = true;

            if(Pos)
                memcpy(Ptr, OldPtr, Pos);

            if(MoveReq)
            {
                sizetype End = Pos + Length;
                memcpy(Ptr + Pos, OldPtr + End, OldSize - End);
            }
        }
    }
}
Ejemplo n.º 12
0
void festring::CreateNewData(sizetype N)
{
  Reserved = N|FESTRING_PAGE;
  Data = sizeof(int*) + new char[Reserved + sizeof(int*) + 1];
  OwnsData = true;
  REFS(Data) = 0;
  Size = 0;
}
Ejemplo n.º 13
0
char *
     make_shared_string (const char * str)
{
    block_t *b;
    int h;

    b = hfindblock(str, h);     /* hfindblock macro sets h = StrHash(s) */
    if (!b) {
        b = alloc_new_string(str, h);
    } else {
        if (REFS(b))
            REFS(b)++;
        ADD_STRING(SIZE(b));
    }
    NDBG(b);
    return (STRING(b));
}
Ejemplo n.º 14
0
/// Insert a string at the specified position.
void festring::Insert(sizetype Pos, cchar* CStr, sizetype N)
{
  if(!N)
    return;

  if(Size < Pos)
    ABORT("Illegal festring insertion detected!");

  if(Size == Pos)
  {
    Append(CStr, N);
    return;
  }

  char* OldData = Data;
  sizetype OldSize = Size;
  sizetype NewSize = OldSize + N;
  decltype(&REFS(Data)) FreePtr = 0;

  if(OwnsData)
  {
    if(!REFS(OldData))
    {
      if(NewSize <= Reserved)
      {
        memmove(OldData + Pos + N, OldData + Pos, OldSize - Pos);
        memcpy(OldData + Pos, CStr, N);
        Size = NewSize;
        return;
      }
      else
        FreePtr = &REFS(OldData);
    }
    else
      --REFS(OldData);
  }

  CreateNewData(NewSize);
  memcpy(Data, OldData, Pos);
  memcpy(Data + Pos, CStr, N);
  memcpy(Data + Pos + N, OldData + Pos, OldSize - Pos);
  Size = NewSize;

  if(FreePtr)
    delete [] FreePtr;
}
Ejemplo n.º 15
0
const char *
ref_string (const char * str)
{
    block_t *b;

    b = BLOCK(str);
#ifdef DEBUG
    if (b != findblock(str)) {
        fatal("stralloc.c: called ref_string on non-shared string: %s.\n", str);
    }
#endif                          /* defined(DEBUG) */
    if (REFS(b))
        REFS(b)++;
    NDBG(b);
    ADD_STRING(SIZE(b));
    return str;
}
Ejemplo n.º 16
0
festring& festring::Append(char Char)
{
  if(OwnsData && !REFS(Data) && Size < Reserved)
    Data[Size++] = Char;
  else
    SlowAppend(&Char, 1);

  return *this;
}
Ejemplo n.º 17
0
festring& festring::Capitalize()
{
    char* OldPtr = Data;

    if(*OldPtr > 0x60 && *OldPtr < 0x7B)
    {
        if(!OwnsData)
            CreateOwnData(OldPtr, Size);
        else if(REFS(OldPtr))
        {
            --REFS(OldPtr);
            CreateOwnData(OldPtr, Size);
        }

        *Data ^= 0x20;
    }

    return *this;
}
Ejemplo n.º 18
0
void festring::CreateOwnData(const char* CStr, sizetype N)
{
    Size = N;
    Reserved = N|FESTRING_PAGE;
    char* Ptr = sizeof(ulong) + new char[Reserved + sizeof(ulong) + 1];
    REFS(Ptr) = 0;
    Data = Ptr;
    memcpy(Ptr, CStr, N);
    OwnsData = true;
}
Ejemplo n.º 19
0
/// Always allocate new memory before append data.
void festring::SlowAppend(cchar* CStr, sizetype N)
{
  if(!N)
    return;

  char* OldData = Data;
  sizetype OldSize = Size;
  sizetype NewSize = OldSize + N;
  decltype(&REFS(Data)) FreePtr = 0;

  if(OwnsData && !REFS(OldData)--)
    FreePtr = &REFS(OldData);

  CreateNewData(NewSize);
  memcpy(Data, OldData, OldSize);
  memcpy(Data + OldSize, CStr, N);
  Size = NewSize;

  if(FreePtr)
    delete [] FreePtr;
}
Ejemplo n.º 20
0
void  coup_mu_mesag( const short *message )
{
	GRECT *rect ;
	short dummy ;

	switch( message[0] )
	{
		case WM_REDRAW :
			form_redraw( message, &coup_form ) ;
			break ;
		case WM_MOVED :
			rect = (GRECT *) &(message[4]) ;
			wind_set( coup_form.fm_handle, WF_CURRXYWH, PTRS( rect ) ) ;
			coup_form.fm_box = *rect ;
			wind_calc( WC_WORK, wind_form_kind, ELTS( coup_form.fm_box ),
					&coup_form.fm_ptr[ROOT].ob_x, &coup_form.fm_ptr[ROOT].ob_y,
					&dummy, &dummy ) ;
			break ;
		case WM_TOPPED :
			if( message[3] == coup_form.fm_handle )
				wind_set( coup_form.fm_handle, WF_TOP ) ;
			break ;
		case WM_BOTTOM :
			wind_set( coup_form.fm_handle, WF_BOTTOM ) ;
			break ;
		case WM_CLOSED :
			save_couple( edit_coup_ref, edit_coup_block, edit_coup_cptr ) ;
			close_couple() ;
			break ;
		case WM_ALLICONIFY :
			iconify_all( coup_form.fm_box.g_x ) ;
			break ;
		case WM_ICONIFY :
			wind_set( coup_form.fm_handle, WF_UNICONIFYXYWH, ELTS( coup_form.fm_box ) ) ;
			coup_form.fm_box = *(GRECT *)&message[4] ;
			coup_form.iconified = TRUE ;
			wind_set( coup_form.fm_handle, WF_ICONIFY, ELTS( coup_form.fm_box ) ) ;
			wind_title( coup_form.fm_handle, coup_form.icon_title ) ;
			send_redraw_message( &coup_form.fm_box, coup_form.fm_handle ) ;
			break ;
		case WM_UNICONIFY :
			wind_get( coup_form.fm_handle, WF_UNICONIFY, REFS( coup_form.fm_box ) ) ;
			wind_calc( WC_WORK, wind_form_kind, ELTS( coup_form.fm_box ),
					&coup_form.fm_ptr[ROOT].ob_x, &coup_form.fm_ptr[ROOT].ob_y,
					&dummy, &dummy ) ;
			wind_set( coup_form.fm_handle, WF_UNICONIFY, ELTS( coup_form.fm_box ) ) ;
			wind_title( coup_form.fm_handle, coup_form.title_str ) ;
			coup_form.iconified = FALSE ;
			break ;
		default :
			break ;
	}
}
Ejemplo n.º 21
0
void
free_string (const char * str)
{
    block_t **prev, *b;
    int h;

    b = BLOCK(str);
    DEBUG_CHECK1(b != findblock(str),"stralloc.c: free_string called on non-shared string: %s.\n", str);
    
    /*
     * if a string has been ref'd USHRT_MAX times then we assume that its used
     * often enough to justify never freeing it.
     */
    if (!REFS(b))
        return;

    REFS(b)--;
    SUB_STRING(SIZE(b));

    NDBG(b);
    if (REFS(b) > 0)
        return;

    h = StrHash(str);
    prev = base_table + h;
    while ((b = *prev)) {
        if (STRING(b) == str) {
            *prev = NEXT(b);
            break;
        }
        prev = &(NEXT(b));
    }

    DEBUG_CHECK1(!b, "free_string: not found in string table! (\"%s\")\n", str);

    SUB_NEW_STRING(SIZE(b), sizeof(block_t));
    FREE(b);
    CHECK_STRING_STATS;
}
Ejemplo n.º 22
0
festring& festring::operator=(const char* CStr)
{
    sizetype NewSize = strlen(CStr);
    Size = NewSize;
    char* Ptr = Data;

    if(Ptr && OwnsData)
    {
        if(!REFS(Ptr) && NewSize <= Reserved)
        {
            memcpy(Ptr, CStr, NewSize);
            return *this;
        }

        if(!REFS(Ptr)--)
            delete [] &REFS(Ptr);
    }

    Data = const_cast<char*>(CStr);
    OwnsData = false;
    return *this;
}
Ejemplo n.º 23
0
void festring::Resize(sizetype N, char C)
{
    sizetype OldSize = Size;
    char* OldPtr = Data;
    char* NewPtr;
    Size = N;

    if(OldSize < N)
    {
        ulong* DeletePtr = 0;

        if(OwnsData && OldPtr)
        {
            if(!REFS(OldPtr))
            {
                if(N <= Reserved)
                {
                    memset(OldPtr + OldSize, C, N - OldSize);
                    return;
                }
                else
                    DeletePtr = &REFS(OldPtr);
            }
            else
                --REFS(OldPtr);
        }

        Reserved = N|FESTRING_PAGE;
        NewPtr = sizeof(ulong) + new char[Reserved + sizeof(ulong) + 1];
        REFS(NewPtr) = 0;
        Data = NewPtr;
        memcpy(NewPtr, OldPtr, OldSize);
        memset(NewPtr + OldSize, C, N - OldSize);
        OwnsData = true;

        if(DeletePtr)
            delete [] DeletePtr;
    }
    else
    {
        if(OwnsData && OldPtr)
            if(!REFS(OldPtr))
                return;
            else
                --REFS(OldPtr);

        Reserved = N|FESTRING_PAGE;
        NewPtr = sizeof(ulong) + new char[Reserved + sizeof(ulong) + 1];
        REFS(NewPtr) = 0;
        Data = NewPtr;
        memcpy(NewPtr, OldPtr, N);
        OwnsData = true;
    }
}
Ejemplo n.º 24
0
void festring::Assign(sizetype N, char C)
{
    Size = N;
    char* Ptr = Data;

    if(OwnsData && Ptr)
    {
        if(!REFS(Ptr) && N <= Reserved)
        {
            memset(Ptr, C, N);
            return;
        }
        else
            delete [] &REFS(Ptr);
    }

    Reserved = N|FESTRING_PAGE;
    Ptr = sizeof(ulong) + new char[Reserved + sizeof(ulong) + 1];
    REFS(Ptr) = 0;
    Data = Ptr;
    memset(Ptr, C, N);
    OwnsData = true;
}
Ejemplo n.º 25
0
festring& festring::Append(const char* CStr, sizetype N)
{
    sizetype OldSize = Size;
    sizetype NewSize = OldSize + N;
    char* OldPtr = Data;

    if(OwnsData && OldPtr && !REFS(OldPtr) && NewSize <= Reserved)
    {
        memcpy(OldPtr + OldSize, CStr, N);
        Size = NewSize;
    }
    else
        SlowAppend(CStr, N);

    return *this;
}
Ejemplo n.º 26
0
festring& festring::Append(cchar* CStr, sizetype N)
{
  if(!N)
    return *this;

  sizetype OldSize = Size;
  sizetype NewSize = OldSize + N;

  if(OwnsData && !REFS(Data) && NewSize <= Reserved)
  {
    memcpy(Data + OldSize, CStr, N);
    Size = NewSize;
  }
  else
    SlowAppend(CStr, N);

  return *this;
}
Ejemplo n.º 27
0
/// Resize the string and use a char for padding.
void festring::Resize(sizetype NewSize, char Char)
{
  if(Size > NewSize)
  {
    if(OwnsData)
    {
      if(!REFS(Data))
      {
        Size = NewSize;
        return;
      }

      --REFS(Data);
    }

    CreateOwnData(Data, NewSize);
    return;
  }
  else if(Size < NewSize)
  {
    char* OldData = Data;
    sizetype OldSize = Size;
    decltype(&REFS(Data)) FreePtr = 0;

    if(OwnsData)
    {
      if(!REFS(OldData))
      {
        if(NewSize <= Reserved)
        {
          memset(OldData + OldSize, Char, NewSize - OldSize);
          Size = NewSize;
          return;
        }
        else
          FreePtr = &REFS(OldData);
      }
      else
        --REFS(OldData);
    }

    CreateNewData(NewSize);
    memcpy(Data, OldData, OldSize);
    memset(Data + OldSize, Char, NewSize - OldSize);
    Size = NewSize;

    if(FreePtr)
      delete [] FreePtr;
  }
  else
    return;
}
Ejemplo n.º 28
0
festring& festring::Append(cfestring& Str)
{
  if(!Str.Size)
    return *this;

  sizetype N = Str.Size;
  sizetype OldSize = Size;
  sizetype NewSize = OldSize + N;
  char* OldPtr = Data;
  char* OtherPtr = Str.Data;

  if(OwnsData && !REFS(Data) && NewSize <= Reserved)
  {
    memcpy(Data + OldSize, Str.Data, N);
    Size = NewSize;
  }
  else
    SlowAppend(Str.Data, N);

  return *this;
}
Ejemplo n.º 29
0
INLINE_STATIC block_t *
alloc_new_string (const char * string, int h)
{
    block_t *b;
    int len = strlen(string);
    int size;

    if (len > max_string_length) {
        len = max_string_length;
    }
    size = sizeof(block_t) + len + 1;
    b = (block_t *) DXALLOC(size, TAG_SHARED_STRING, "alloc_new_string");
    strncpy(STRING(b), string, len);
    STRING(b)[len] = '\0';      /* strncpy doesn't put on \0 if 'from' too
                                 * long */
    SIZE(b) = (len > USHRT_MAX ? USHRT_MAX : len);
    REFS(b) = 1;
    NEXT(b) = base_table[h];
    base_table[h] = b;
    ADD_NEW_STRING(SIZE(b), sizeof(block_t));
    ADD_STRING(SIZE(b));
    return (b);
}