Compare commits
2 Commits
| Author | SHA1 | Date |
|---|---|---|
Maciej Samborski
|
c308aa8ecc | |
|
Maciej Samborski
|
5170ab1501 |
|
|
@ -0,0 +1,114 @@
|
|||
#ifndef CGC_H_
|
||||
#define CGC_H_
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#define GC_DEFAULT_CAP 16
|
||||
#include <string.h>
|
||||
|
||||
typedef struct {
|
||||
void * ptr;
|
||||
size_t id;
|
||||
} GCItem;
|
||||
|
||||
typedef struct {
|
||||
GCItem * items;
|
||||
size_t size;
|
||||
size_t capacity;
|
||||
} GC;
|
||||
|
||||
typedef size_t GCIndex;
|
||||
|
||||
GC gcInit(void);
|
||||
void gcDeinit(GC gc);
|
||||
void gcGrowBuffer(GC * gc);
|
||||
GCIndex gcAddItem(GC * gc, void * ptr);
|
||||
void * gcAlloc(GC * gc, size_t elemNo, size_t elemSize);
|
||||
void gcUpdateItem(GC * gc, GCIndex id, void * ptr);
|
||||
void * gcGetPtrAt(GC gc, GCIndex id);
|
||||
|
||||
#ifdef CGC_IMPLEMENTATION
|
||||
|
||||
GC gcInit()
|
||||
{
|
||||
void * items = calloc(GC_DEFAULT_CAP, sizeof(GCItem));
|
||||
if (items == NULL) {
|
||||
fprintf(stderr, "ERROR: Failed to allocate GC!\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
return (GC) {
|
||||
.items = items,
|
||||
.size = 0,
|
||||
.capacity = GC_DEFAULT_CAP,
|
||||
};
|
||||
}
|
||||
|
||||
void gcDeinit(GC gc)
|
||||
{
|
||||
for (size_t i = 0; i < gc.size; ++i)
|
||||
free(gc.items[i].ptr);
|
||||
|
||||
free(gc.items);
|
||||
}
|
||||
|
||||
void gcGrowBuffer(GC * gc)
|
||||
{
|
||||
if (gc->items == NULL)
|
||||
{
|
||||
fprintf(stderr, "ERROR: GC is not initialized!\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
size_t newCap = gc->capacity * 2;
|
||||
|
||||
void * items = calloc(newCap, sizeof(GCItem));
|
||||
if (items == NULL) {
|
||||
fprintf(stderr, "ERROR: Failed to allocate GC!\n");
|
||||
exit(1);
|
||||
}
|
||||
memcpy(items, gc->items, gc->capacity * sizeof(GCItem));
|
||||
free(gc->items);
|
||||
gc->items = items;
|
||||
gc->capacity = newCap;
|
||||
}
|
||||
|
||||
GCIndex gcAddItem(GC * gc, void * ptr)
|
||||
{
|
||||
if (gc->size >= gc->capacity)
|
||||
gcGrowBuffer(gc);
|
||||
|
||||
gc->size += 1;
|
||||
gc->items[gc->size - 1] = (GCItem) {
|
||||
.id = gc->size - 1,
|
||||
.ptr = ptr,
|
||||
};
|
||||
|
||||
return gc->size - 1;
|
||||
}
|
||||
|
||||
void * gcAlloc(GC * gc, size_t elemNo, size_t elemSize)
|
||||
{
|
||||
void * ptr = calloc(elemNo, elemSize);
|
||||
if (ptr == NULL) return NULL;
|
||||
|
||||
gcAddItem(gc, ptr);
|
||||
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void gcUpdateItem(GC * gc, GCIndex id, void * ptr)
|
||||
{
|
||||
free(gc->items[id].ptr);
|
||||
gc->items[id].ptr = ptr;
|
||||
}
|
||||
|
||||
void * gcGetPtrAt(GC gc, GCIndex id)
|
||||
{
|
||||
return gc.items[id].ptr;
|
||||
}
|
||||
|
||||
#endif // CGC_IMPLEMENTATION
|
||||
|
||||
#endif // CGC_H_
|
||||
367
da.h
367
da.h
|
|
@ -5,24 +5,28 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
|
||||
#define EHAN_IMPLEMENTATION
|
||||
#include "ehan.h"
|
||||
|
||||
#define CGC_IMPLEMENTATION
|
||||
#include "cgc.h"
|
||||
|
||||
enum daFields {
|
||||
SIZE = 0,
|
||||
CAPACITY = 1,
|
||||
TYPE = 2,
|
||||
DATA = 3,
|
||||
};
|
||||
|
||||
|
||||
typedef void * dynarr;
|
||||
GenericReturn _daCreate(size_t initCapacity, size_t type, size_t size);
|
||||
dynarr _daCreate(size_t initCapacity, size_t type, size_t size);
|
||||
GenericReturn _daPushLit(dynarr * da, size_t item);
|
||||
GenericReturn _daPushFlt(dynarr * da, float item);
|
||||
GenericReturn _daPushStr(dynarr * da, const char * str);
|
||||
GenericReturn daCopy(dynarr da);
|
||||
GenericReturn daResize(dynarr da);
|
||||
dynarr daCopy(dynarr da);
|
||||
dynarr daResize(dynarr da);
|
||||
void _daPop(dynarr da, void * element);
|
||||
void daPopDiscard(dynarr da);
|
||||
void daFree(dynarr da);
|
||||
|
|
@ -52,23 +56,57 @@ void daBzero(dynarr da);
|
|||
#define daPop(da, item) _daPop(da, &item)
|
||||
#define daGet(da, index) (da[index])
|
||||
|
||||
#endif // DA_H_
|
||||
|
||||
#define daAppend(daImpl, value) ({ \
|
||||
if (daImpl != NULL) \
|
||||
{ \
|
||||
if (daSize(daImpl) >= daCap(daImpl)) \
|
||||
daImpl = daResize(daImpl); \
|
||||
\
|
||||
if (daImpl != NULL) { \
|
||||
daImpl[daSize(daImpl)] = value; \
|
||||
*(((size_t *) daImpl) - 3) += 1; \
|
||||
errno = 0; \
|
||||
} else { \
|
||||
errno = 1; \
|
||||
} \
|
||||
} else { \
|
||||
errno = 1; \
|
||||
} \
|
||||
})
|
||||
|
||||
#ifdef DA_IMPLEMENTATION
|
||||
|
||||
GenericReturn _daCreate(size_t cap, size_t type, size_t size)
|
||||
{
|
||||
if (cap == 0) cap = 1;
|
||||
#ifdef DA_GC
|
||||
GC daGarbageCollector = {0};
|
||||
|
||||
size_t * da = (size_t *) malloc(type * cap + DATA * sizeof(size_t));
|
||||
void daInitGC()
|
||||
{
|
||||
daGarbageCollector = gcInit();
|
||||
}
|
||||
|
||||
void daDeinitGC()
|
||||
{
|
||||
gcDeinit(daGarbageCollector);
|
||||
}
|
||||
#endif
|
||||
|
||||
dynarr _daCreate(size_t cap, size_t type, size_t size)
|
||||
{
|
||||
size_t realCap = (((int)(cap / 8)) + 1 ) * 8;
|
||||
#ifdef DA_GC
|
||||
size_t * da = (size_t *) gcAlloc(&daGarbageCollector, 1, type * realCap + DATA * sizeof(size_t));
|
||||
#else
|
||||
size_t * da = (size_t *) calloc(1, type * realCap + DATA * sizeof(size_t));
|
||||
#endif
|
||||
|
||||
if (da == NULL)
|
||||
return ehanError("Failed to allocate resources for a dynamic array!");
|
||||
return NULL;
|
||||
|
||||
da[SIZE] = size;
|
||||
da[CAPACITY] = cap;
|
||||
da[CAPACITY] = realCap;
|
||||
da[TYPE] = type;
|
||||
|
||||
return ehanValue((dynarr) (da + DATA));
|
||||
return (dynarr) (da + DATA);
|
||||
}
|
||||
|
||||
void daFree(dynarr da)
|
||||
|
|
@ -77,140 +115,139 @@ void daFree(dynarr da)
|
|||
free((size_t *) da - DATA);
|
||||
}
|
||||
|
||||
GenericReturn daCopy(dynarr da)
|
||||
dynarr daCopy(dynarr da)
|
||||
{
|
||||
if (da == NULL)
|
||||
return ehanError("Expected: 'dynarr' got 'NULL'");
|
||||
if (da == NULL) return NULL;
|
||||
|
||||
GenericReturn temp = _daCreate(daCap(da), daType(da), daSize(da));
|
||||
dynarr newArr = _daCreate(daCap(da), daType(da), daSize(da));
|
||||
|
||||
if (ehanCheck(temp))
|
||||
return ehanError(resultError(temp));
|
||||
|
||||
dynarr newArr = resultGeneric(dynarr, temp);
|
||||
if (newArr == NULL)
|
||||
return NULL;
|
||||
|
||||
memcpy(newArr, da, daSize(da) * daType(da));
|
||||
return ehanValue(newArr);
|
||||
return newArr;
|
||||
}
|
||||
|
||||
GenericReturn daResize(dynarr da)
|
||||
dynarr daResize(dynarr da)
|
||||
{
|
||||
if (da == NULL)
|
||||
return ehanError("Expected: 'dynarr' got 'NULL'");
|
||||
return NULL;
|
||||
|
||||
GenericReturn temp = _daCreate(daCap(da) * 2, daType(da), daSize(da));
|
||||
dynarr newArr = _daCreate((size_t) daCap(da) * 1.5, daType(da), daSize(da));
|
||||
|
||||
if (ehanCheck(temp))
|
||||
return ehanError(resultError(temp));
|
||||
|
||||
dynarr newArr = resultGeneric(dynarr, temp);
|
||||
if (newArr == NULL)
|
||||
return NULL;
|
||||
|
||||
memcpy(newArr, da, daSize(da) * daType(da));
|
||||
|
||||
// TODO: Make use of the GCIndex returned from gcAlloc !
|
||||
for (size_t i = 0; i < daGarbageCollector.size; ++i)
|
||||
{
|
||||
if (daGarbageCollector.items[i].ptr == da)
|
||||
gcUpdateItem(&daGarbageCollector, i, newArr);
|
||||
}
|
||||
|
||||
#ifndef DA_GC
|
||||
daFree(da);
|
||||
return ehanValue(newArr);
|
||||
#endif
|
||||
|
||||
return newArr;
|
||||
}
|
||||
|
||||
GenericReturn _daPushLit(dynarr * da, size_t item)
|
||||
{
|
||||
if (daSize(*da) >= daCap(*da))
|
||||
{
|
||||
GenericReturn temp = daResize(*da);
|
||||
|
||||
if (ehanCheck(temp))
|
||||
return ehanError(resultError(temp));
|
||||
|
||||
*da = resultGeneric(dynarr, temp);
|
||||
}
|
||||
|
||||
switch (daType(*da))
|
||||
{
|
||||
case 1: {
|
||||
*((char *)*da + daType(*da) * daSize(*da)) = item;
|
||||
} break;
|
||||
|
||||
case 2: {
|
||||
*(short *)((char *)*da + daType(*da) * daSize(*da)) = item;
|
||||
} break;
|
||||
|
||||
case 4: {
|
||||
*(int *)((char *)*da + daType(*da) * daSize(*da)) = item;
|
||||
} break;
|
||||
|
||||
case 8: {
|
||||
*(long long int *)((char *)*da + daType(*da) * daSize(*da)) = item;
|
||||
} break;
|
||||
|
||||
default:
|
||||
return ehanError("Wrong type size");
|
||||
}
|
||||
*daField(*da, SIZE) += 1;
|
||||
|
||||
return ehanValue(0);
|
||||
}
|
||||
|
||||
GenericReturn _daPushFlt(dynarr * da, float item)
|
||||
{
|
||||
if (daSize(*da) >= daCap(*da))
|
||||
{
|
||||
GenericReturn temp = daResize(*da);
|
||||
|
||||
if (ehanCheck(temp))
|
||||
return ehanError(resultError(temp));
|
||||
|
||||
*da = resultGeneric(dynarr, temp);
|
||||
}
|
||||
|
||||
switch (daType(*da))
|
||||
{
|
||||
case 4: {
|
||||
*(float *)((char *)*da + daType(*da) * daSize(*da)) = item;
|
||||
} break;
|
||||
|
||||
case 8: {
|
||||
*(double *)((char *)*da + daType(*da) * daSize(*da)) = item;
|
||||
} break;
|
||||
|
||||
case 16: {
|
||||
*(long double *)((char *)*da + daType(*da) * daSize(*da)) = item;
|
||||
} break;
|
||||
|
||||
default:
|
||||
return ehanError("Wrong type size");
|
||||
}
|
||||
|
||||
*daField(*da, SIZE) += 1;
|
||||
|
||||
return ehanValue(0);
|
||||
}
|
||||
|
||||
GenericReturn _daPushStr(dynarr * da, const char * str)
|
||||
{
|
||||
if (daSize(*da) >= daCap(*da))
|
||||
{
|
||||
GenericReturn temp = daResize(*da);
|
||||
|
||||
if (ehanCheck(temp))
|
||||
return ehanError(resultError(temp));
|
||||
|
||||
*da = resultGeneric(dynarr, temp);
|
||||
}
|
||||
|
||||
memcpy((char *)(*da) + daSize(*da) * daType(*da), &str, daType(*da));
|
||||
*daField(*da, SIZE) += 1;
|
||||
|
||||
return ehanValue(0);
|
||||
}
|
||||
|
||||
void _daPop(dynarr da, void * elem)
|
||||
{
|
||||
*daField(da, SIZE) -= 1;
|
||||
memcpy(elem, (char *)da + daSize(da) * daType(da), daType(da));
|
||||
}
|
||||
|
||||
void daPopDiscard(dynarr da)
|
||||
{
|
||||
*daField(da, SIZE) -= 1;
|
||||
}
|
||||
//GenericReturn _daPushLit(dynarr * da, size_t item)
|
||||
//{
|
||||
// if (daSize(*da) >= daCap(*da))
|
||||
// {
|
||||
// *da = daResize(*da);
|
||||
//
|
||||
// if (da == NULL)
|
||||
// return ehanError("Failed to reallocate new da!");
|
||||
// }
|
||||
//
|
||||
// printf("A %zu\n", daType(*da));
|
||||
//
|
||||
// switch (daType(*da))
|
||||
// {
|
||||
// case 1: {
|
||||
// *((char *)*da + daType(*da) * daSize(*da)) = item;
|
||||
// } break;
|
||||
//
|
||||
// case 2: {
|
||||
// *(short *)((char *)*da + daType(*da) * daSize(*da)) = item;
|
||||
// } break;
|
||||
//
|
||||
// case 4: {
|
||||
// *(int *)((char *)*da + daType(*da) * daSize(*da)) = item;
|
||||
// } break;
|
||||
//
|
||||
// case 8: {
|
||||
// *(long long int *)((char *)*da + daType(*da) * daSize(*da)) = item;
|
||||
// } break;
|
||||
//
|
||||
// default:
|
||||
// return ehanError("Wrong type size");
|
||||
// }
|
||||
// printf("B\n");
|
||||
// *daField(*da, SIZE) += 1;
|
||||
//
|
||||
// return ehanValue(0);
|
||||
//}
|
||||
//
|
||||
//GenericReturn _daPushFlt(dynarr * da, float item)
|
||||
//{
|
||||
// if (daSize(*da) >= daCap(*da))
|
||||
// {
|
||||
// if (!daResize(*da))
|
||||
// return ehanError("Failed to reallocate new da!");
|
||||
// }
|
||||
//
|
||||
// switch (daType(*da))
|
||||
// {
|
||||
// case 4: {
|
||||
// *(float *)((char *)*da + daType(*da) * daSize(*da)) = item;
|
||||
// } break;
|
||||
//
|
||||
// case 8: {
|
||||
// *(double *)((char *)*da + daType(*da) * daSize(*da)) = item;
|
||||
// } break;
|
||||
//
|
||||
// case 16: {
|
||||
// *(long double *)((char *)*da + daType(*da) * daSize(*da)) = item;
|
||||
// } break;
|
||||
//
|
||||
// default:
|
||||
// return ehanError("Wrong type size");
|
||||
// }
|
||||
//
|
||||
// *daField(*da, SIZE) += 1;
|
||||
//
|
||||
// return ehanValue(0);
|
||||
//}
|
||||
//
|
||||
//GenericReturn _daPushStr(dynarr * da, const char * str)
|
||||
//{
|
||||
// if (daSize(*da) >= daCap(*da))
|
||||
// {
|
||||
// if (!daResize(*da))
|
||||
// return ehanError("Failed to reallocate new da!");
|
||||
// }
|
||||
//
|
||||
// memcpy((char *)(*da) + daSize(*da) * daType(*da), &str, daType(*da));
|
||||
// *daField(*da, SIZE) += 1;
|
||||
//
|
||||
// return ehanValue(0);
|
||||
//}
|
||||
//
|
||||
//void _daPop(dynarr da, void * elem)
|
||||
//{
|
||||
// *daField(da, SIZE) -= 1;
|
||||
// memcpy(elem, (char *)da + daSize(da) * daType(da), daType(da));
|
||||
//}
|
||||
//
|
||||
//void daPopDiscard(dynarr da)
|
||||
//{
|
||||
// *daField(da, SIZE) -= 1;
|
||||
//}
|
||||
|
||||
size_t * daField(dynarr da, enum daFields field)
|
||||
{
|
||||
|
|
@ -242,38 +279,40 @@ size_t daType(dynarr da)
|
|||
return ((size_t *) da - DATA)[TYPE];
|
||||
}
|
||||
|
||||
void daForeach(dynarr da, func f)
|
||||
{
|
||||
for (size_t i = 0; i < daSize(da); ++i)
|
||||
f((char *) da + i * daType(da));
|
||||
}
|
||||
|
||||
heapstr daToCStr(dynarr da)
|
||||
{
|
||||
char * buffer = (char *) calloc(1, daSize(da) + 1);
|
||||
if (buffer == NULL) return NULL;
|
||||
|
||||
memcpy(buffer, da, daSize(da) * daType(da));
|
||||
return buffer;
|
||||
}
|
||||
|
||||
void daBzero(dynarr da)
|
||||
{
|
||||
memset(da, '\0', daCap(da));
|
||||
*daField(da, SIZE) = 0;
|
||||
}
|
||||
|
||||
void * daGetRef(dynarr da, size_t index)
|
||||
{
|
||||
if (index >= daSize(da))
|
||||
{
|
||||
fprintf(stderr, ("*------------------------------*\n"));
|
||||
fprintf(stderr, ("ERROR: Access out of bounds\n"));
|
||||
fprintf(stderr, ("*------------------------------*\n"));
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return (void *)((char *)da + index * daType(da));
|
||||
}
|
||||
//void daForeach(dynarr da, func f)
|
||||
//{
|
||||
// for (size_t i = 0; i < daSize(da); ++i)
|
||||
// f((char *) da + i * daType(da));
|
||||
//}
|
||||
//
|
||||
//heapstr daToCStr(dynarr da)
|
||||
//{
|
||||
// char * buffer = (char *) calloc(1, daSize(da) + 1);
|
||||
// if (buffer == NULL) return NULL;
|
||||
//
|
||||
// memcpy(buffer, da, daSize(da) * daType(da));
|
||||
// return buffer;
|
||||
//}
|
||||
//
|
||||
//void daBzero(dynarr da)
|
||||
//{
|
||||
// memset(da, '\0', daCap(da));
|
||||
// *daField(da, SIZE) = 0;
|
||||
//}
|
||||
//
|
||||
//void * daGetRef(dynarr da, size_t index)
|
||||
//{
|
||||
// if (index >= daSize(da))
|
||||
// {
|
||||
// fprintf(stderr, ("*------------------------------*\n"));
|
||||
// fprintf(stderr, ("ERROR: Access out of bounds\n"));
|
||||
// fprintf(stderr, ("*------------------------------*\n"));
|
||||
// return NULL;
|
||||
// }
|
||||
//
|
||||
// return (void *)((char *)da + index * daType(da));
|
||||
//}
|
||||
|
||||
#endif // DA_IMPLEMENTATION
|
||||
|
||||
#endif // DA_H_
|
||||
|
|
|
|||
152
example.c
152
example.c
|
|
@ -1,24 +1,58 @@
|
|||
#include <errno.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#define DA_GC
|
||||
#define DA_IMPLEMENTATION
|
||||
#include "da.h"
|
||||
|
||||
#define EHAN_IMPLEMENTATION
|
||||
#include "ehan.h"
|
||||
#if 1
|
||||
#include <stdio.h>
|
||||
|
||||
#if 0
|
||||
int main(void)
|
||||
{
|
||||
dynarr(char *) da = daCreate(char *,4).val;
|
||||
daInitGC();
|
||||
|
||||
for (size_t i = 0; i < 1000; ++i) {
|
||||
daPushStr(da, "hi");
|
||||
dynarr(int) da = daCreate(int, 8);
|
||||
dynarr(char *) da2 = daCreate(char *, 8);
|
||||
dynarr(float) da3 = daCreate(float, 1);
|
||||
if (!da) goto exit;
|
||||
if (!da2) goto exit;
|
||||
if (!da3) goto exit;
|
||||
|
||||
printf("%zu %zu %zu\n", daSize(da), daCap(da), daType(da));
|
||||
printf("errno: %d\n", errno);
|
||||
daAppend(da, 69);
|
||||
printf("errno: %d\n", errno);
|
||||
printf("%d\n", da[0]);
|
||||
printf("%zu %zu %zu\n", daSize(da), daCap(da), daType(da));
|
||||
|
||||
da = daResize(da);
|
||||
if (!da) goto exit;
|
||||
printf("%zu %zu %zu\n", daSize(da), daCap(da), daType(da));
|
||||
|
||||
printf("DA2 -----\n");
|
||||
|
||||
daAppend(da2, "Hello, ");
|
||||
daAppend(da2, "World!");
|
||||
|
||||
#define N 100000
|
||||
for (size_t i = 0; i < N; ++i)
|
||||
{
|
||||
daAppend(da2, "AAA");
|
||||
if (errno == 1) goto exit;
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < daSize(da); ++i) {
|
||||
ILog("%zu: %s\n", i, da[i]);
|
||||
}
|
||||
printf("%s%s\n", da2[0], da2[1]);
|
||||
printf("%zu %zu %zu\n", daSize(da2), daCap(da2), daType(da2));
|
||||
|
||||
daFree(da);
|
||||
printf("DA3 -----\n");
|
||||
|
||||
daAppend(da3, 69.69);
|
||||
daAppend(da3, 420.420);
|
||||
printf("%.2f:%.3f\n", da3[0], da3[1]);
|
||||
|
||||
exit:
|
||||
daDeinitGC();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -39,21 +73,13 @@ int main(void)
|
|||
printf("DA1\n");
|
||||
printf("----------\n");
|
||||
|
||||
GenericReturn gr = daCreate(unsigned short, 1);
|
||||
if (ehanCheck(gr))
|
||||
{
|
||||
ELog("%s\n", resultError(gr));
|
||||
exit(1);
|
||||
}
|
||||
|
||||
dynarr(unsigned short) da = resultGeneric(dynarr(unsigned short), gr);
|
||||
dynarr(unsigned short) da = daCreate(unsigned short, 1);
|
||||
|
||||
daPush(da, 69);
|
||||
daPush(da, 420);
|
||||
daPush(da, 1337);
|
||||
daPush(da, 34);
|
||||
daPush(da, 35);
|
||||
|
||||
daPush(da, 1667);
|
||||
|
||||
unsigned short x = 0;
|
||||
|
|
@ -65,69 +91,69 @@ int main(void)
|
|||
|
||||
printf("%zu %zu %zu\n", daSize(da), daCap(da), daType(da));
|
||||
|
||||
printf("----------\n");
|
||||
printf("DA2\n");
|
||||
printf("----------\n");
|
||||
//printf("----------\n");
|
||||
//printf("DA2\n");
|
||||
//printf("----------\n");
|
||||
|
||||
dynarr(char) da2 = daCreate(char, 1).val;
|
||||
//dynarr(char) da2 = daCreate(char, 1);
|
||||
|
||||
daPush(da2, 'H');
|
||||
daPush(da2, 'i');
|
||||
daPush(da2, ' ');
|
||||
daPush(da2, 'm');
|
||||
daPush(da2, 'o');
|
||||
daPush(da2, 'm');
|
||||
daPush(da2, '?');
|
||||
daPush(da2, '?');
|
||||
//daPush(da2, 'H');
|
||||
//daPush(da2, 'i');
|
||||
//daPush(da2, ' ');
|
||||
//daPush(da2, 'm');
|
||||
//daPush(da2, 'o');
|
||||
//daPush(da2, 'm');
|
||||
//daPush(da2, '?');
|
||||
//daPush(da2, '?');
|
||||
|
||||
*(char *)daGetRef(da2, 6) = '!';
|
||||
//*(char *)daGetRef(da2, 6) = '!';
|
||||
|
||||
daPopDiscard(da2);
|
||||
//daPopDiscard(da2);
|
||||
|
||||
heapstr message = daToCStr(da2);
|
||||
//heapstr message = daToCStr(da2);
|
||||
|
||||
printf("%s\n", message);
|
||||
//printf("%s\n", message);
|
||||
|
||||
printf("----------\n");
|
||||
printf("DA3\n");
|
||||
printf("----------\n");
|
||||
//printf("----------\n");
|
||||
//printf("DA3\n");
|
||||
//printf("----------\n");
|
||||
|
||||
dynarr(char *) da3 = daCreate(char *, 1).val;
|
||||
//dynarr(char *) da3 = daCreate(char *, 1);
|
||||
|
||||
for (size_t i = 0; i < 1000000; ++i) {
|
||||
daPush(da3, "Test");
|
||||
}
|
||||
//for (size_t i = 0; i < 1000000; ++i) {
|
||||
// daPush(da3, "Test");
|
||||
//}
|
||||
|
||||
char * str;
|
||||
daPop(da3, str);
|
||||
printf("%s\n", str);
|
||||
//char * str;
|
||||
//daPop(da3, str);
|
||||
//printf("%s\n", str);
|
||||
|
||||
printf("----------\n");
|
||||
printf("DA4\n");
|
||||
printf("----------\n");
|
||||
//printf("----------\n");
|
||||
//printf("DA4\n");
|
||||
//printf("----------\n");
|
||||
|
||||
dynarr(double) da4 = daCreate(double, 1).val;
|
||||
//dynarr(double) da4 = daCreate(double, 1);
|
||||
|
||||
daPush(da4, 69.692343);
|
||||
printf("float: %F\n", da4[0]);
|
||||
//daPush(da4, 69.692343);
|
||||
//printf("float: %F\n", da4[0]);
|
||||
|
||||
printf("----------\n");
|
||||
printf("DA5\n");
|
||||
printf("----------\n");
|
||||
//printf("----------\n");
|
||||
//printf("DA5\n");
|
||||
//printf("----------\n");
|
||||
|
||||
dynarr(char *) da5 = daCreate(char *, 1).val;
|
||||
//dynarr(char *) da5 = daCreate(char *, 1);
|
||||
|
||||
daPush(da5, "Hello, ");
|
||||
daPush(da5, "World!");
|
||||
//daPush(da5, "Hello, ");
|
||||
//daPush(da5, "World!");
|
||||
|
||||
DLog("%s%s\n", da5[0], da5[1]);
|
||||
//DLog("%s%s\n", da5[0], da5[1]);
|
||||
|
||||
cleanup:
|
||||
daFree(da5);
|
||||
daFree(da4);
|
||||
daFree(da3);
|
||||
free(message);
|
||||
daFree(da2);
|
||||
//daFree(da5);
|
||||
//daFree(da4);
|
||||
//daFree(da3);
|
||||
//free(message);
|
||||
//daFree(da2);
|
||||
daFree(da);
|
||||
|
||||
return 0;
|
||||
|
|
|
|||
Loading…
Reference in New Issue