245 lines
6.9 KiB
C
245 lines
6.9 KiB
C
#include "tstring.h"
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
|
|
void TStringCopyGlyph(const char* glyph, int length, TString* string);
|
|
int ResizeTStringCapacity(int newTextLength, TString* string);
|
|
int GetGlyphByteWidth(char glyph);
|
|
|
|
struct __tstring {
|
|
char* Characters;
|
|
int Length;
|
|
int ByteCount;
|
|
int Capacity;
|
|
};
|
|
|
|
TString* TStringCreate(void) {
|
|
TString* string = malloc(sizeof(TString));
|
|
|
|
if (!string) {
|
|
fprintf(stderr, "Failed to malloc space for TString. %s.\n", strerror(errno));
|
|
|
|
return NULL;
|
|
}
|
|
|
|
string->Characters = calloc(DEFAULT_TSTRING_BYTE_BUFFER, sizeof(char));
|
|
|
|
if (!string->Characters) {
|
|
fprintf(stderr, "Failed to malloc space for TString character array. %s.\n", strerror(errno));
|
|
|
|
free(string);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
string->Capacity = DEFAULT_TSTRING_BYTE_BUFFER;
|
|
string->ByteCount = 0;
|
|
string->Length = 0;
|
|
|
|
return string;
|
|
}
|
|
|
|
int TStringLength(const TString* string) {
|
|
if (!string) return -1;
|
|
|
|
return string->Length;
|
|
}
|
|
|
|
int ResizeTStringCapacity(int additionalLength, TString* string) {
|
|
if (!string) return 0;
|
|
if (string->ByteCount + additionalLength < string->Capacity) return 1;
|
|
|
|
unsigned int newCapacity = string->Capacity;
|
|
|
|
while (additionalLength > newCapacity) newCapacity = string->Capacity * 2;
|
|
|
|
char* buffer = realloc(string->Characters, string->Capacity * 2);
|
|
|
|
if (!buffer) {
|
|
fprintf(stderr, "Failed to realloc space for text insertion. %s.\n", strerror(errno));
|
|
|
|
return 0;
|
|
}
|
|
|
|
string->Characters = buffer;
|
|
string->Capacity *= 2;
|
|
|
|
return 1;
|
|
}
|
|
|
|
void TStringPop(char buffer[8], TString* string) {
|
|
if (!string) return;
|
|
if (string->ByteCount == 0) return;
|
|
|
|
for (int i = string->ByteCount; i >= 0; i--) {
|
|
unsigned int width = GetGlyphByteWidth(string->Characters[i]);
|
|
|
|
if (width) {
|
|
//If we've been provided a buffer, then populate it with the glyph we're removing.
|
|
if (buffer) {
|
|
memset(buffer, '\0', 8);
|
|
memcpy(buffer, &string->Characters[i], width);
|
|
}
|
|
|
|
memset(&string->Characters[i], '\0', width);
|
|
string->Length--;
|
|
string->ByteCount -= width;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void TStringInsertText(const char* text, int index, TString* string) {
|
|
if (!text || !string) return;
|
|
if (index < 0 || index > string->Length) index = string->Length;
|
|
|
|
unsigned int insertionTextLength = strlen(text);
|
|
unsigned int startByte = 0;
|
|
unsigned int endByte = string->ByteCount + insertionTextLength;
|
|
|
|
if (!ResizeTStringCapacity(insertionTextLength, string)) return;
|
|
|
|
char buffer[256] = { 0 };
|
|
|
|
for (int glyphCount = 0; glyphCount != index; glyphCount++) startByte += GetGlyphByteWidth(string->Characters[startByte]);
|
|
for (unsigned int offset = 0; offset < insertionTextLength; string->Length++) offset += GetGlyphByteWidth(text[offset]);
|
|
|
|
unsigned int fullBuffers = (string->ByteCount - startByte) / sizeof buffer;
|
|
unsigned int remainder = (string->ByteCount - startByte) - fullBuffers * sizeof buffer;
|
|
|
|
for (int i = fullBuffers; i > 0; i--) {
|
|
memcpy(buffer, &string->Characters[string->ByteCount - i * sizeof buffer], sizeof buffer);
|
|
memcpy(&string->Characters[endByte - sizeof buffer * i], buffer, sizeof buffer);
|
|
}
|
|
|
|
if (remainder > 0) {
|
|
memcpy(buffer, &string->Characters[startByte], remainder);
|
|
memcpy(&string->Characters[insertionTextLength + startByte], buffer, remainder);
|
|
}
|
|
|
|
memcpy(&string->Characters[startByte], text, insertionTextLength);
|
|
|
|
string->ByteCount += insertionTextLength;
|
|
}
|
|
|
|
void TStringAppendText(const char* text, TString* string) {
|
|
if (!text || !string) return;
|
|
|
|
int totalLength = strlen(text);
|
|
int glyphLength = GetGlyphByteWidth(text[0]);
|
|
|
|
//If the two lengths are the same then that means we have a single character.
|
|
//Simply append it to the list and return.
|
|
if (totalLength == glyphLength) {
|
|
TStringCopyGlyph(text, glyphLength, string);
|
|
|
|
return;
|
|
}
|
|
|
|
//If we've made it here, than that means we have a full on string of characters.
|
|
for(int i = 0; i < totalLength;) {
|
|
TStringCopyGlyph(&text[i], glyphLength, string);
|
|
|
|
i += glyphLength;
|
|
glyphLength = GetGlyphByteWidth(text[i]);
|
|
}
|
|
}
|
|
|
|
char* TStringGetString(const TString* string) {
|
|
if (!string) return NULL;
|
|
|
|
char* text = calloc(string->ByteCount + 1, sizeof(char));
|
|
|
|
if (!text) {
|
|
fprintf(stderr, "Failed to calloc memory for TString text. %s.\n", strerror(errno));
|
|
|
|
return NULL;
|
|
}
|
|
|
|
memcpy(text, string->Characters, string->ByteCount);
|
|
|
|
return text;
|
|
}
|
|
|
|
void TStringGetGlyph(int index, char buffer[8], const TString* string) {
|
|
if (!buffer || !string) return;
|
|
|
|
memset(buffer, '\0', sizeof *buffer);
|
|
|
|
int glyphCount = 0;
|
|
|
|
for (int i = 0; i < string->ByteCount;) {
|
|
int glyphWidth = GetGlyphByteWidth(string->Characters[i]);
|
|
|
|
if (glyphCount == index) {
|
|
memcpy(buffer, &string->Characters[i], glyphWidth);
|
|
return;
|
|
}
|
|
|
|
glyphCount++;
|
|
i += glyphWidth;
|
|
}
|
|
}
|
|
|
|
void TStringFree(TString* string) {
|
|
if (!string) return;
|
|
|
|
if (string->Characters) free(string->Characters);
|
|
|
|
free(string);
|
|
}
|
|
|
|
int GetGlyphByteWidth(char glyph) {
|
|
//ANDing 0x80 (1000 0000) should result in 0 if this code point is 1 byte long.
|
|
if ((glyph & 0x80) == 0) return 1;
|
|
|
|
//ANDing 0xE0 (1110 0000) will result in 0xC0 (1100 0000) if this code point is 2 bytes long.
|
|
if ((glyph & 0xE0) == 0xC0) return 2;
|
|
|
|
//ANDing 0xF0 (1111 0000) will result in 0xE0 (1110 0000) if this code point is 3 bytes long.
|
|
if ((glyph & 0xF0) == 0xE0) return 3;
|
|
|
|
//ANDing 0xE0 (1111 1000) will result in 0xF0 (1111 0000) if this code point is 4 bytes long.
|
|
if ((glyph & 0xF8) == 0xF0) return 4;
|
|
|
|
//Else we either have a continuation point (pattern: 10XX XXXX) or its just a junk value
|
|
//as far as we're concerned.
|
|
return 0;
|
|
}
|
|
|
|
void TStringCopyGlyph(const char* glyph, int length, TString* string) {
|
|
if (!glyph || !string) return;
|
|
if (length < 1) return;
|
|
|
|
if (!ResizeTStringCapacity(length, string)) return;
|
|
|
|
memcpy(&string->Characters[string->ByteCount], glyph, length);
|
|
|
|
string->ByteCount += length;
|
|
string->Length++;
|
|
}
|
|
|
|
void TStringPrintDetails(const TString* string, int statsOnly) {
|
|
if (!string) return;
|
|
|
|
printf("Stats: Length %d; Size %d byte(s); Capacity: %d bytes\n", string->Length, string->ByteCount, string->Capacity);
|
|
|
|
if (statsOnly) return;
|
|
|
|
printf("Stored String:\n");
|
|
|
|
if (string->Characters) {
|
|
char* text = TStringGetString(string);
|
|
printf("%s\n", text);
|
|
free(text);
|
|
}
|
|
|
|
printf("\nBytes:\n");
|
|
for(int i = 0; i < string->Capacity; i++) {
|
|
if (i != 0 && i % 80 == 0) printf("\n");
|
|
printf("%02X ", string->Characters[i] & 0xFF);
|
|
}
|
|
printf("\n");
|
|
} |