stau.space
Serilazer and deserealizer written in C.
1#include "string.h"
2#include <stdio.h>
3#include <stdint.h>
4#include <stdlib.h>
5
6typedef uint8_t Byte;
7
8typedef struct {
9 Byte* buf;
10 size_t cap;
11} Buffer;
12
13typedef struct {
14 char* str;
15 size_t cap;
16} String;
17
18typedef struct {
19 void* data;
20 String name;
21 size_t size;
22} Member;
23
24typedef struct {
25 Member* members;
26 size_t cap;
27} Members;
28
29Buffer serialize(Members src) {
30 Buffer buffer = {
31 .buf = (Byte*)malloc(sizeof(Byte) * 0xFF),
32 .cap = 0x100,
33 };
34
35 size_t total_size = 0;
36 for (size_t i = 0; i < src.cap; ++i) {
37 Member mem = src.members[i];
38
39 size_t required_size = sizeof(size_t) + mem.name.cap + sizeof(size_t) + mem.size;
40
41 while (total_size + required_size >= buffer.cap) {
42 buffer.buf = realloc(buffer.buf, buffer.cap * 2);
43 buffer.cap *= 2;
44 }
45
46 printf("[INFO]: New member:\n");
47 printf("\tcap: %zu\n", mem.name.cap);
48 printf("\tname: %s\n", mem.name.str);
49 printf("\tsize: %zu\n", mem.size);
50 printf("\tdata location: %zu\n", (size_t)mem.data);
51
52 memcpy(buffer.buf + total_size, &mem.name.cap, sizeof(size_t));
53 total_size += sizeof(size_t);
54
55 memcpy(buffer.buf + total_size, mem.name.str, mem.name.cap);
56 total_size += mem.name.cap;
57
58 memcpy(buffer.buf + total_size, &mem.size, sizeof(size_t));
59 total_size += sizeof(size_t);
60
61 memcpy(buffer.buf + total_size, mem.data, mem.size);
62 total_size += mem.size;
63 }
64
65
66 buffer.buf = realloc(buffer.buf, total_size);
67 buffer.cap = total_size;
68
69 return buffer;
70}
71
72typedef struct {
73 size_t a;
74 uint32_t b;
75 uint8_t* c;
76 union {
77 uint16_t t16;
78 uint8_t t8_2[2];
79 } d;
80} MyStruct;
81
82Members to_members(MyStruct ms) {
83
84 size_t cap = sizeof(size_t) + sizeof(uint32_t) + sizeof(uint8_t*) + sizeof(uint16_t);
85 Member* members = malloc(sizeof(Member) * cap);
86
87 members[0] = (Member){
88 .data = &ms.a,
89 .name = {
90 .str = (char*)"a",
91 .cap = 2,
92 },
93 .size = sizeof(size_t)
94 };
95
96 members[1] = (Member){
97 .data = &ms.b,
98 .name = {
99 .str = (char*)"b",
100 .cap = 2,
101 },
102 .size = sizeof(uint32_t)
103 };
104
105 members[2] = (Member){
106 .data = &*ms.c,
107 .name = {
108 .str = (char*)"c",
109 .cap = 2,
110 },
111 .size = sizeof(uint8_t*)
112 };
113
114 members[3] = (Member){
115 .data = &ms.d,
116 .name = {
117 .str = (char*)"c",
118 .cap = 2,
119 },
120 .size = sizeof(uint16_t)
121 };
122
123 return (Members){
124 .members = members,
125 .cap = cap,
126 };
127}
128
129int main() {
130 size_t a = 420;
131 void* aa = &a;
132 Byte buf[100] = {0};
133 Buffer buffer = {
134 .buf = buf,
135 .cap = 100,
136 };
137 memcpy(buffer.buf, aa, 8);
138 printf("[INFO]: %d\n", buffer.buf[0]);
139 printf("[INFO]: %d\n", buffer.buf[1]);
140 printf("[INFO]: %d\n", buffer.buf[2]);
141 printf("[INFO]: %d\n", buffer.buf[3]);
142 printf("[INFO]: %d\n", buffer.buf[4]);
143 printf("[INFO]: %d\n", buffer.buf[5]);
144 printf("[INFO]: %d\n", buffer.buf[7]);
145 /*
146 MyStruct ms = {
147 .a = 420,
148 .b = 60000,
149 .c = malloc(sizeof(uint8_t)),
150 .d.t8_2 = {[0] = 1, [1] = 2}
151 };
152
153 Members mem = to_members(ms);
154
155 Buffer buffer = serialize(mem);
156
157 for (size_t i = 0; i < buffer.cap; ++i) {
158 printf("[%d] ", buffer.buf[i]);
159 }
160
161 free(buffer.buf);
162 free(mem.members);
163 */
164 return 0;
165}