9052 lines
254 KiB
C
Raw Normal View History

New build.
2024-12-08 15:19:17 +00:00
// RETOOR - Dec 5 2024
#ifndef SORM_H
#define SORM_H
#ifndef SORM_STR_H
#define SORM_STR_H
// RETOOR - Nov 28 2024
// MIT License
// ===========
// Copyright (c) 2024 Retoor
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
#ifndef RLIB_H
#define RLIB_H
// BEGIN OF RLIB
/*
* Line below will be filtered by rmerge
<script language="Javva script" type="woeiii" src="Pony.html" after-tag="after
tag" />
*/
#ifndef RTYPES_H
#define RTYPES_H
#ifdef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE_TEMP _POSIX_C_SOURCE
#undef _POSIX_C_SOURCE
#endif
#ifndef _POSIX_C_SOURCE
#undef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 200112L
#endif
#include <stdbool.h>
#include <stdint.h> // uint
#include <string.h>
#include <sys/types.h> // ulong
#ifndef ulonglong
#define ulonglong unsigned long long
#endif
#ifndef uint
typedef unsigned int uint;
#endif
#ifndef byte
typedef unsigned char byte;
#endif
#ifdef _POSIX_C_SOURCE_TEMP
#undef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE _POSIX_C_SOURCE_TEMP
#undef _POSIX_C_SOURCE_TEMP
#else
#undef _POSIX_C_SOURCE
#endif
#endif
#ifndef NSOCK_H
#define NSOCK_H
#ifndef RMALLOC_H
#define RMALLOC_H
#ifndef RMALLOC_OVERRIDE
#define RMALLOC_OVERRIDE 1
#endif
#ifdef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE_TEMP _POSIX_C_SOURCE
#undef _POSIX_C_SOURCE
#endif
#ifndef _POSIX_C_SOURCE
#undef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 200112L
#endif
#ifndef ulonglong
#define ulonglong unsigned long long
#endif
#include <locale.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifndef RTEMP_H
#define RTEMP_H
#include <pthread.h>
#ifndef RTEMPC_SLOT_COUNT
#define RTEMPC_SLOT_COUNT 20
#endif
#ifndef RTEMPC_SLOT_SIZE
#define RTEMPC_SLOT_SIZE 1024 * 64 * 128
#endif
bool _rtempc_initialized = 0;
pthread_mutex_t _rtempc_thread_lock;
bool rtempc_use_mutex = true;
byte _current_rtempc_slot = 1;
char _rtempc_buffer[RTEMPC_SLOT_COUNT][RTEMPC_SLOT_SIZE];
char *rtempc(char *data) {
if (rtempc_use_mutex) {
if (!_rtempc_initialized) {
_rtempc_initialized = true;
pthread_mutex_init(&_rtempc_thread_lock, NULL);
}
pthread_mutex_lock(&_rtempc_thread_lock);
}
uint current_rtempc_slot = _current_rtempc_slot;
_rtempc_buffer[current_rtempc_slot][0] = 0;
strcpy(_rtempc_buffer[current_rtempc_slot], data);
_current_rtempc_slot++;
if (_current_rtempc_slot == RTEMPC_SLOT_COUNT) {
_current_rtempc_slot = 0;
}
if (rtempc_use_mutex)
pthread_mutex_unlock(&_rtempc_thread_lock);
return _rtempc_buffer[current_rtempc_slot];
}
#define sstring(_pname, _psize) \
static char _##_pname[_psize]; \
_##_pname[0] = 0; \
char *_pname = _##_pname;
#define string(_pname, _psize) \
char _##_pname[_psize]; \
_##_pname[0] = 0; \
char *_pname = _##_pname;
#define sreset(_pname, _psize) _pname = _##_pname;
#define sbuf(val) rtempc(val)
#endif
#ifdef _POSIX_C_SOURCE_TEMP
#undef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE _POSIX_C_SOURCE_TEMP
#undef _POSIX_C_SOURCE_TEMP
#else
#undef _POSIX_C_SOURCE
#endif
ulonglong rmalloc_count = 0;
ulonglong rmalloc_alloc_count = 0;
ulonglong rmalloc_free_count = 0;
ulonglong rmalloc_total_bytes_allocated = 0;
void *_rmalloc_prev_realloc_obj = NULL;
size_t _rmalloc_prev_realloc_obj_size = 0;
void *rmalloc(size_t size) {
void *result;
while (!(result = malloc(size))) {
fprintf(stderr, "Warning: malloc failed, trying again.\n");
}
rmalloc_count++;
rmalloc_alloc_count++;
rmalloc_total_bytes_allocated += size;
return result;
}
void *rcalloc(size_t count, size_t size) {
void *result;
while (!(result = calloc(count, size))) {
fprintf(stderr, "Warning: calloc failed, trying again.\n");
}
rmalloc_alloc_count++;
rmalloc_count++;
rmalloc_total_bytes_allocated += count * size;
return result;
}
void *rrealloc(void *obj, size_t size) {
if (!obj) {
rmalloc_count++;
}
rmalloc_alloc_count++;
if (obj == _rmalloc_prev_realloc_obj) {
rmalloc_total_bytes_allocated += size - _rmalloc_prev_realloc_obj_size;
_rmalloc_prev_realloc_obj_size = size - _rmalloc_prev_realloc_obj_size;
} else {
_rmalloc_prev_realloc_obj_size = size;
}
void *result;
while (!(result = realloc(obj, size))) {
fprintf(stderr, "Warning: realloc failed, trying again.\n");
}
_rmalloc_prev_realloc_obj = result;
return result;
}
char *rstrdup(const char *s) {
if (!s)
return NULL;
char *result;
size_t size = strlen(s) + 1;
result = rmalloc(size);
memcpy(result, s, size);
rmalloc_total_bytes_allocated += size;
return result;
}
void *rfree(void *obj) {
rmalloc_count--;
rmalloc_free_count++;
free(obj);
return NULL;
}
#if RMALLOC_OVERRIDE
#define malloc rmalloc
#define calloc rcalloc
#define realloc rrealloc
#define free rfree
#define strdup rstrdup
#endif
char *rmalloc_lld_format(ulonglong num) {
char res[100];
res[0] = 0;
sprintf(res, "%'lld", num);
char *resp = res;
while (*resp) {
if (*resp == ',')
*resp = '.';
resp++;
}
return sbuf(res);
}
char *rmalloc_bytes_format(int factor, ulonglong num) {
char *sizes[] = {"B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"};
if (num > 1024) {
return rmalloc_bytes_format(factor + 1, num / 1024);
}
char res[100];
sprintf(res, "%s %s", rmalloc_lld_format(num), sizes[factor]);
return sbuf(res);
}
char *rmalloc_stats() {
static char res[200];
res[0] = 0;
// int original_locale = localeconv();
setlocale(LC_NUMERIC, "en_US.UTF-8");
sprintf(res, "Memory usage: %s, %s (re)allocated, %s unqiue free'd, %s in use.", rmalloc_bytes_format(0, rmalloc_total_bytes_allocated),
rmalloc_lld_format(rmalloc_alloc_count), rmalloc_lld_format(rmalloc_free_count),
rmalloc_lld_format(rmalloc_count));
// setlocale(LC_NUMERIC, original_locale);
setlocale(LC_NUMERIC, "");
return res;
}
#endif
#include <arpa/inet.h>
#include <errno.h>
#include <fcntl.h>
#include <netdb.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <unistd.h>
#ifndef RLIB_RIO
#define RLIB_RIO
#include <dirent.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <sys/dir.h>
#include <sys/select.h>
#include <sys/stat.h>
#include <unistd.h>
#ifndef RSTRING_LIST_H
#define RSTRING_LIST_H
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
typedef struct rstring_list_t {
unsigned int size;
unsigned int count;
char **strings;
} rstring_list_t;
rstring_list_t *rstring_list_new() {
rstring_list_t *rsl = (rstring_list_t *)malloc(sizeof(rstring_list_t));
memset(rsl, 0, sizeof(rstring_list_t));
return rsl;
}
void rstring_list_free(rstring_list_t *rsl) {
for (unsigned int i = 0; i < rsl->size; i++) {
free(rsl->strings[i]);
}
if (rsl->strings)
free(rsl->strings);
free(rsl);
rsl = NULL;
}
void rstring_list_add(rstring_list_t *rsl, char *str) {
if (rsl->count == rsl->size) {
rsl->size++;
rsl->strings = (char **)realloc(rsl->strings, sizeof(char *) * rsl->size);
}
rsl->strings[rsl->count] = strdup(str);
rsl->count++;
}
bool rstring_list_contains(rstring_list_t *rsl, char *str) {
for (unsigned int i = 0; i < rsl->count; i++) {
if (!strcmp(rsl->strings[i], str))
return true;
}
return false;
}
#endif
bool rfile_exists(char *path) {
struct stat s;
return !stat(path, &s);
}
void rjoin_path(char *p1, char *p2, char *output) {
output[0] = 0;
strcpy(output, p1);
if (output[strlen(output) - 1] != '/') {
char slash[] = "/";
strcat(output, slash);
}
if (p2[0] == '/') {
p2++;
}
strcat(output, p2);
}
int risprivatedir(const char *path) {
struct stat statbuf;
if (stat(path, &statbuf) != 0) {
perror("stat");
return -1;
}
if (!S_ISDIR(statbuf.st_mode)) {
return -2;
}
if ((statbuf.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) == S_IRWXU) {
return 1; // Private (owner has all permissions, others have none)
}
return 0;
}
bool risdir(const char *path) { return !risprivatedir(path); }
void rforfile(char *path, void callback(char *)) {
if (!rfile_exists(path))
return;
DIR *dir = opendir(path);
struct dirent *d;
while ((d = readdir(dir)) != NULL) {
if (!d)
break;
if ((d->d_name[0] == '.' && strlen(d->d_name) == 1) || d->d_name[1] == '.') {
continue;
}
char full_path[4096];
rjoin_path(path, d->d_name, full_path);
if (risdir(full_path)) {
callback(full_path);
rforfile(full_path, callback);
} else {
callback(full_path);
}
}
closedir(dir);
}
bool rfd_wait(int fd, int ms) {
fd_set read_fds;
struct timeval timeout;
FD_ZERO(&read_fds);
FD_SET(fd, &read_fds);
timeout.tv_sec = 0;
timeout.tv_usec = 1000 * ms;
int ret = select(fd + 1, &read_fds, NULL, NULL, &timeout);
return ret > 0 && FD_ISSET(fd, &read_fds);
}
bool rfd_wait_forever(int fd) {
while ((!rfd_wait(fd, 10))) {
}
return true;
}
size_t rfile_size(char *path) {
struct stat s;
stat(path, &s);
return s.st_size;
}
size_t rfile_readb(char *path, void *data, size_t size) {
FILE *fd = fopen(path, "r");
if (!fd) {
return 0;
}
size_t bytes_read = fread(data, sizeof(char), size, fd);
fclose(fd);
((char *)data)[bytes_read] = 0;
return bytes_read;
}
#endif
int *nsock_socks = NULL;
int *nsock_readable = NULL;
void **nsock_data = NULL;
int nsock_server_fd = 0;
int nsock_max_socket_fd = 0;
typedef enum nsock_type_t { NSOCK_NONE = 0, NSOCK_SERVER, NSOCK_CLIENT, NSOCK_UPSTREAM } nsock_type_t;
typedef struct nsock_it {
int fd;
int *upstreams;
bool connected;
bool downstream;
unsigned int upstream_count;
nsock_type_t type;
} nsock_t;
nsock_t **nsocks = NULL;
int nsocks_count = 0;
void (*nsock_on_connect)(int fd) = NULL;
void (*nsock_on_data)(int fd) = NULL;
void (*nsock_on_close)(int fd) = NULL;
void nsock_on_before_data(int fd);
nsock_t *nsock_get(int fd) {
if (nsock_socks[fd] == 0) {
return NULL;
}
if (fd >= nsocks_count || nsocks[fd] == NULL) {
if (fd >= nsocks_count) {
nsocks_count = fd + 1;
nsocks = (nsock_t **)realloc(nsocks, sizeof(nsock_t *) * sizeof(nsock_t) * (nsocks_count));
nsocks[fd] = (nsock_t *)calloc(1, sizeof(nsock_t));
}
nsocks[fd]->upstreams = NULL;
nsocks[fd]->fd = fd;
nsocks[fd]->connected = false;
nsocks[fd]->downstream = false;
nsocks[fd]->upstream_count = 0;
nsocks[fd]->type = NSOCK_CLIENT;
return nsocks[fd];
}
return nsocks[fd];
}
void nsock_close(int fd) {
if (nsock_on_close)
nsock_on_close(fd);
nsock_t *sock = nsock_get(fd);
if (sock) {
for (unsigned int i = 0; i < sock->upstream_count; i++) {
nsock_close(sock->upstreams[i]);
sock->upstreams[i] = 0;
}
if (sock->upstream_count) {
free(sock->upstreams);
}
sock->upstream_count = 0;
sock->connected = false;
}
nsock_socks[fd] = 0;
close(fd);
}
nsock_t *nsock_create(int fd, nsock_type_t type) {
if (fd <= 0)
return NULL;
nsock_socks[fd] = fd;
nsock_t *sock = nsock_get(fd);
sock->connected = true;
sock->downstream = false;
sock->type = type;
return sock;
}
int *nsock_init(int socket_count) {
if (nsock_socks) {
return nsock_socks;
}
nsock_socks = (int *)calloc(1, sizeof(int) * sizeof(int *) * socket_count + 1);
if (nsock_data) {
free(nsock_data);
nsock_data = NULL;
}
nsock_data = (void **)malloc(sizeof(void **) * socket_count + 1);
nsock_socks[socket_count] = -1;
return nsock_socks;
}
void nsock_free() {
if (nsock_socks)
free(nsock_socks);
if (nsock_readable)
free(nsock_readable);
nsock_server_fd = 0;
nsock_max_socket_fd = 0;
if (nsock_data) {
exit(1);
}
}
void nsock_add_upstream(int source, int target, bool downstream) {
if (!nsock_socks[target])
return;
if (!nsock_socks[source])
return;
nsock_t *sock = nsock_get(source);
nsock_t *sock_target = nsock_get(target);
sock_target->type = NSOCK_UPSTREAM;
sock->upstreams = (int *)realloc(sock->upstreams, sizeof(int) * (sock->upstream_count + 1));
sock->downstream = downstream;
sock->upstreams[sock->upstream_count] = target;
sock->upstream_count++;
}
void *nsock_get_data(int socket) { return nsock_data[socket]; }
void nsock_set_data(int socket, void *data) { nsock_data[socket] = data; }
int nsock_connect(const char *host, unsigned int port) {
char port_str[10] = {0};
sprintf(port_str, "%d", port);
int status;
int socket_fd = 0;
struct addrinfo hints;
struct addrinfo *res;
struct addrinfo *p;
if ((socket_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
return false;
}
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
if ((status = getaddrinfo(host, port_str, &hints, &res)) != 0) {
return 0;
}
for (p = res; p != NULL; p = p->ai_next) {
if ((socket_fd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) {
continue;
}
if (connect(socket_fd, p->ai_addr, p->ai_addrlen) == -1) {
close(socket_fd);
continue;
}
break;
}
if (p == NULL) {
freeaddrinfo(res);
return 0;
}
freeaddrinfo(res);
if (socket_fd) {
if (nsock_socks == NULL) {
nsock_init(2048);
}
nsock_socks[socket_fd] = socket_fd;
nsock_t *sock = nsock_create(socket_fd, NSOCK_CLIENT);
sock->connected = true;
}
return socket_fd;
}
void nsock_listen(int port) {
int server_fd;
struct sockaddr_in address;
if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
perror("Socket failed");
exit(EXIT_FAILURE);
}
int opt = 1;
if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) {
perror("setsockopt failed");
close(server_fd);
exit(EXIT_FAILURE);
}
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(port);
if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
perror("Bind failed");
close(server_fd);
exit(EXIT_FAILURE);
}
if (listen(server_fd, 8096) < 0) {
perror("Listen failed");
close(server_fd);
exit(EXIT_FAILURE);
}
nsock_server_fd = server_fd;
}
int *nsock_select(suseconds_t timeout) {
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = timeout;
int server_fd = nsock_server_fd;
fd_set rfds;
FD_ZERO(&rfds);
FD_SET(server_fd, &rfds);
int *socks = nsock_socks;
fd_set efds;
FD_ZERO(&efds);
nsock_max_socket_fd = server_fd;
for (int i = 0; socks[i] != -1; i++) {
if (i == server_fd)
continue;
;
if (!socks[i])
continue;
if (socks[i] > nsock_max_socket_fd) {
nsock_max_socket_fd = socks[i];
}
FD_SET(socks[i], &rfds);
FD_SET(socks[i], &efds);
}
int activity = select(nsock_max_socket_fd + 1, &rfds, NULL, &efds, timeout == 0 ? NULL : &tv);
if ((activity < 0) && (errno != EINTR)) {
perror("Select error\n");
return NULL;
} else if (activity == 0) {
return NULL;
}
if (FD_ISSET(server_fd, &rfds)) {
struct sockaddr_in address;
int addrlen = sizeof(address);
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
int new_socket = 0;
if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t *)&addrlen)) < 0) {
perror("Accept failed");
} else {
nsock_socks[new_socket] = new_socket;
nsock_create(new_socket, NSOCK_CLIENT);
if (nsock_on_connect)
nsock_on_connect(new_socket);
if (new_socket > nsock_max_socket_fd)
nsock_max_socket_fd = new_socket;
}
}
if (nsock_readable) {
free(nsock_readable);
}
nsock_readable = (int *)calloc(1, sizeof(int *) + sizeof(int) * (nsock_max_socket_fd + 2));
nsock_readable[nsock_max_socket_fd + 1] = -1;
nsock_readable[0] = 0;
int readable_count = 0;
for (int i = 0; i < nsock_max_socket_fd + 1; i++) {
nsock_t *sock = nsock_get(i);
if (!sock)
continue;
if (FD_ISSET(i, &efds)) {
nsock_close(nsock_socks[i]);
nsock_socks[i] = 0;
nsock_readable[i] = 0;
} else if (FD_ISSET(i, &rfds) && i != server_fd) {
nsock_readable[i] = i;
readable_count++;
nsock_on_before_data(i);
} else {
nsock_readable[i] = 0;
sock->connected = false;
}
}
return nsock_readable;
}
unsigned char *nsock_read(int fd, int length) {
if (!nsock_socks[fd])
return NULL;
unsigned char *buffer = (unsigned char *)malloc(length + 1);
int bytes_read = read(fd, buffer, length);
if (bytes_read <= 0) {
nsock_close(fd);
return NULL;
}
buffer[bytes_read] = 0;
return buffer;
}
unsigned char *nsock_read_all(int fd, int length) {
if (!nsock_socks[fd])
return NULL;
unsigned char *buffer = (unsigned char *)malloc(length + 1);
int bytes_read = 0;
while (bytes_read < length) {
int bytes_chunk = read(fd, buffer + bytes_read, length - bytes_read);
if (bytes_chunk <= 0) {
nsock_close(fd);
return NULL;
}
bytes_read += bytes_chunk;
}
buffer[bytes_read] = 0;
return buffer;
}
int nsock_write_all(int fd, unsigned char *data, int length) {
if (!nsock_socks[fd])
return 0;
int bytes_written = 0;
while (bytes_written < length) {
int bytes_chunk = write(fd, data + bytes_written, length - bytes_written);
if (bytes_chunk <= 0) {
nsock_close(fd);
return 0;
}
bytes_written += bytes_chunk;
}
return bytes_written;
}
int nsock_execute_upstream(int source, size_t buffer_size) {
int result = 0;
nsock_t *sock = nsock_get(source);
unsigned char data[buffer_size];
memset(data, 0, buffer_size);
int bytes_read = read(source, data, buffer_size);
if (bytes_read <= 0) {
nsock_close(source);
return 0;
}
bool downstreamed = false;
for (unsigned int i = 0; i < sock->upstream_count; i++) {
if (!nsock_socks[sock->upstreams[i]])
continue;
int bytes_sent = nsock_write_all(sock->upstreams[i], data, bytes_read);
if (bytes_sent <= 0) {
nsock_close(sock->upstreams[i]);
continue;
}
if (sock->downstream && downstreamed == false) {
downstreamed = true;
unsigned char data[4096];
memset(data, 0, 4096);
int bytes_read = read(sock->upstreams[i], data, 4096);
if (bytes_read <= 0) {
nsock_close(source);
return 0;
}
int bytes_sent = nsock_write_all(sock->fd, data, bytes_read);
if (bytes_sent <= 0) {
nsock_close(sock->upstreams[i]);
return 0;
}
}
result++;
}
return result;
}
void nsock_on_before_data(int fd) {
if (!nsock_socks[fd])
return;
nsock_t *sock = nsock_get(fd);
if (sock->upstream_count) {
int upstreamed_to_count = nsock_execute_upstream(fd, 4096);
if (!upstreamed_to_count) {
nsock_close(fd);
}
return;
} else if (sock->type == NSOCK_UPSTREAM) {
while (rfd_wait(sock->fd, 0)) {
unsigned char *data = nsock_read(fd, 4096);
(void)data;
}
}
if (nsock_on_data)
nsock_on_data(fd);
}
void nsock(int port, void (*on_connect)(int fd), void (*on_data)(int fd), void (*on_close)(int fd)) {
nsock_init(2048);
nsock_listen(port);
nsock_on_connect = on_connect;
nsock_on_data = on_data;
nsock_on_close = on_close;
int serve_in_terminal = nsock_on_connect == NULL && nsock_on_data == NULL && nsock_on_close == NULL;
while (1) {
int *readable = nsock_select(0);
if (!serve_in_terminal)
continue;
if (!readable)
continue;
for (int i = 0; readable[i] != -1; i++) {
if (!readable[i])
continue;
char buffer[1024] = {0};
int bytes_read = read(readable[i], buffer, 1);
buffer[bytes_read] = 0;
if (bytes_read <= 0) {
nsock_close(readable[i]);
continue;
}
if (write(readable[i], buffer, bytes_read) <= 0) {
nsock_close(readable[i]);
continue;
}
}
}
}
#endif
#ifndef UUID_H
#define UUID_H
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
typedef struct {
unsigned char bytes[16];
} UUID;
void generate_random_bytes(unsigned char *bytes, size_t len) {
for (size_t i = 0; i < len; i++) {
bytes[i] = rand() % 256;
}
}
UUID generate_uuid4(void) {
UUID uuid;
generate_random_bytes(uuid.bytes, 16);
uuid.bytes[6] &= 0x0f;
uuid.bytes[6] |= 0x40;
uuid.bytes[8] &= 0x3f;
uuid.bytes[8] |= 0x80;
return uuid;
}
void uuid_to_string(UUID uuid, char *str) {
sprintf(str, "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x", uuid.bytes[0], uuid.bytes[1], uuid.bytes[2],
uuid.bytes[3], uuid.bytes[4], uuid.bytes[5], uuid.bytes[6], uuid.bytes[7], uuid.bytes[8], uuid.bytes[9], uuid.bytes[10],
uuid.bytes[11], uuid.bytes[12], uuid.bytes[13], uuid.bytes[14], uuid.bytes[15]);
}
char *uuid4() {
srand(time(NULL));
UUID uuid = generate_uuid4();
char str[37];
uuid_to_string(uuid, str);
return sbuf(str);
}
#endif
#ifndef RNET_H
#define RNET_H
#ifdef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE_TEMP _POSIX_C_SOURCE
#undef _POSIX_C_SOURCE
#endif
#ifndef _POSIX_C_SOURCE
#undef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 200112L
#endif
#include <arpa/inet.h>
#include <errno.h>
#include <fcntl.h>
#include <netdb.h>
#include <signal.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#ifdef _POSIX_C_SOURCE_TEMP
#undef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE _POSIX_C_SOURCE_TEMP
#undef _POSIX_C_SOURCE_TEMP
#else
#undef _POSIX_C_SOURCE
#endif
#define NET_SOCKET_MAX_CONNECTIONS 50000
typedef struct rnet_socket_t {
int fd;
char name[50];
void *data;
size_t bytes_received;
size_t bytes_sent;
bool connected;
void (*on_read)(struct rnet_socket_t *);
void (*on_close)(struct rnet_socket_t *);
void (*on_connect)(struct rnet_socket_t *);
} rnet_socket_t;
typedef struct rnet_select_result_t {
int server_fd;
rnet_socket_t **sockets;
unsigned int socket_count;
} rnet_select_result_t;
typedef struct rnet_server_t {
int socket_fd;
rnet_socket_t **sockets;
unsigned int socket_count;
unsigned int port;
unsigned int backlog;
rnet_select_result_t *select_result;
int max_fd;
void (*on_connect)(rnet_socket_t *socket);
void (*on_close)(rnet_socket_t *socket);
void (*on_read)(rnet_socket_t *socket);
} rnet_server_t;
void rnet_select_result_free(rnet_select_result_t *result);
int net_socket_accept(int server_fd);
int net_socket_connect(const char *, unsigned int);
int net_socket_init();
rnet_server_t *net_socket_serve(unsigned int port, unsigned int backlog);
rnet_select_result_t *net_socket_select(rnet_server_t *server);
rnet_socket_t *net_socket_wait(rnet_socket_t *socket_fd);
bool net_set_non_blocking(int sock);
bool net_socket_bind(int sock, unsigned int port);
bool net_socket_listen(int sock, unsigned int backlog);
char *net_socket_name(int sock);
size_t net_socket_write(rnet_socket_t *, unsigned char *, size_t);
rnet_socket_t *get_net_socket_by_fd(int);
unsigned char *net_socket_read(rnet_socket_t *, unsigned int buff_size);
void _net_socket_close(int sock);
void net_socket_close(rnet_socket_t *sock);
rnet_server_t *rnet_server_new(int socket_fd, unsigned int port, unsigned int backlog) {
rnet_server_t *server = malloc(sizeof(rnet_server_t));
server->socket_fd = socket_fd;
server->sockets = NULL;
server->socket_count = 0;
server->port = port;
server->backlog = backlog;
server->max_fd = -1;
server->select_result = NULL;
server->on_connect = NULL;
server->on_close = NULL;
server->on_read = NULL;
return server;
}
rnet_server_t *rnet_server_add_socket(rnet_server_t *server, rnet_socket_t *sock) {
server->sockets = realloc(server->sockets, sizeof(rnet_socket_t *) * (server->socket_count + 1));
server->sockets[server->socket_count] = sock;
server->socket_count++;
sock->on_read = server->on_read;
sock->on_connect = server->on_connect;
sock->on_close = server->on_close;
sock->connected = true;
return server;
}
rnet_socket_t sockets[NET_SOCKET_MAX_CONNECTIONS] = {0};
unsigned long sockets_connected = 0;
int net_socket_max_fd = 0;
unsigned long sockets_total = 0;
unsigned long sockets_disconnected = 0;
unsigned long sockets_concurrent_record = 0;
unsigned long sockets_errors = 0;
bool net_set_non_blocking(int sock) {
int flags = fcntl(sock, F_GETFL, 0);
if (flags < 0) {
perror("fcntl");
return false;
}
if (fcntl(sock, F_SETFL, flags | O_NONBLOCK) < 0) {
perror("fcntl");
return false;
}
return true;
}
int net_socket_init() {
int socket_fd = -1;
memset(sockets, 0, sizeof(sockets));
int opt = 1;
if ((socket_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
perror("Socket failed.\n");
return false;
}
if (setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) {
perror("Setsockopt failed.\n");
close(socket_fd);
return false;
}
net_set_non_blocking(socket_fd);
return socket_fd;
}
char *net_socket_name(int fd) {
rnet_socket_t *rnet_socket = get_net_socket_by_fd(fd);
if (rnet_socket) {
return rnet_socket->name;
;
}
// If socket disconnected or is no client from server
return NULL;
}
bool net_socket_bind(int socket_fd, unsigned int port) {
struct sockaddr_in address;
address.sin_family = AF_INET; // IPv4
address.sin_addr.s_addr = INADDR_ANY; // Bind to any available address
address.sin_port = htons(port); // Convert port to network byte order
if (bind(socket_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
perror("Bind failed");
close(socket_fd);
return false;
}
return true;
}
int net_socket_connect(const char *host, unsigned int port) {
char port_str[10] = {0};
sprintf(port_str, "%d", port);
int status;
int socket_fd = -1;
struct addrinfo hints;
struct addrinfo *res;
struct addrinfo *p;
if ((socket_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
return false;
}
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
if ((status = getaddrinfo(host, port_str, &hints, &res)) != 0) {
return -1;
}
for (p = res; p != NULL; p = p->ai_next) {
if ((socket_fd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) {
continue;
}
if (connect(socket_fd, p->ai_addr, p->ai_addrlen) == -1) {
close(socket_fd);
continue;
}
break;
}
if (p == NULL) {
freeaddrinfo(res);
return -1;
}
freeaddrinfo(res);
return socket_fd;
}
bool net_socket_listen(int socket_fd, unsigned int backlog) {
if (listen(socket_fd, backlog) < 0) { // '3' is the backlog size
perror("Listen failed");
close(socket_fd);
return false;
}
return true;
}
rnet_server_t *net_socket_serve(unsigned int port, unsigned int backlog) {
signal(SIGPIPE, SIG_IGN);
int socket_fd = net_socket_init();
net_socket_bind(socket_fd, port);
net_socket_listen(socket_fd, backlog);
return rnet_server_new(socket_fd, port, backlog);
}
int net_socket_accept(int net_socket_server_fd) {
struct sockaddr_in address;
int addrlen = sizeof(address);
int new_socket = -1;
if ((new_socket = accept(net_socket_server_fd, (struct sockaddr *)&address, (socklen_t *)&addrlen)) < 0) {
close(new_socket);
return -1;
} else {
return new_socket;
}
}
/*
static void net_socket_stats(WrenVM *vm)
{
wrenSetSlotNewList(vm, 0);
wrenSetSlotString(vm, 1, "sockets_total");
wrenInsertInList(vm, 0, -1, 1);
wrenSetSlotDouble(vm, 1, (double)sockets_total);
wrenInsertInList(vm, 0, -1, 1);
wrenSetSlotString(vm, 1, "sockets_concurrent_record");
wrenInsertInList(vm, 0, -1, 1);
wrenSetSlotDouble(vm, 1, (double)sockets_concurrent_record);
wrenInsertInList(vm, 0, -1, 1);
wrenSetSlotString(vm, 1, "sockets_connected");
wrenInsertInList(vm, 0, -1, 1);
wrenSetSlotDouble(vm, 1, (double)sockets_connected);
wrenInsertInList(vm, 0, -1, 1);
wrenSetSlotString(vm, 1, "sockets_disconnected");
wrenInsertInList(vm, 0, -1, 1);
wrenSetSlotDouble(vm, 1, (double)sockets_disconnected);
wrenInsertInList(vm, 0, -1, 1);
}*/
size_t net_socket_write(rnet_socket_t *sock, unsigned char *message, size_t size) {
ssize_t sent_total = 0;
ssize_t sent = 0;
ssize_t to_send = size;
while ((sent = send(sock->fd, message, to_send, 0))) {
if (sent == -1) {
sockets_errors++;
net_socket_close(sock);
break;
}
if (sent == 0) {
printf("EDGE CASE?\n");
exit(1);
sockets_errors++;
net_socket_close(sock);
break;
}
sent_total += sent;
if (sent_total == to_send)
break;
}
return sent_total;
}
unsigned char *net_socket_read(rnet_socket_t *sock, unsigned int buff_size) {
if (buff_size > 1024 * 1024 + 1) {
perror("Buffer too big. Maximum is 1024*1024.\n");
exit(1);
}
static unsigned char buffer[1024 * 1024];
buffer[0] = 0;
ssize_t received = recv(sock->fd, buffer, buff_size, 0);
if (received <= 0) {
buffer[0] = 0;
net_socket_close(sock);
if (received < 0) {
sockets_errors++;
return NULL;
}
}
buffer[received + 1] = 0;
sock->bytes_received = received;
return buffer;
}
rnet_socket_t *net_socket_wait(rnet_socket_t *sock) {
if (!sock)
return NULL;
if (sock->fd == -1)
return NULL;
fd_set read_fds;
FD_ZERO(&read_fds);
FD_SET(sock->fd, &read_fds);
int max_socket_fd = sock->fd;
int activity = select(max_socket_fd + 1, &read_fds, NULL, NULL, NULL);
if ((activity < 0) && (errno != EINTR)) {
// perror("Select error");
net_socket_close(sock);
return NULL;
}
if (FD_ISSET(sock->fd, &read_fds)) {
return sock;
}
return NULL;
}
void rnet_safe_str(char *str, size_t length) {
if (!str || !length || !*str)
return;
for (unsigned int i = 0; i < length; i++) {
if (str[i] < 32 || str[i] > 126)
if (str[i] != 0)
str[i] = '.';
}
str[length] = 0;
}
rnet_select_result_t *rnet_new_socket_select_result(int socket_fd) {
rnet_select_result_t *result = (rnet_select_result_t *)malloc(sizeof(rnet_select_result_t));
memset(result, 0, sizeof(rnet_select_result_t));
result->server_fd = socket_fd;
result->socket_count = 0;
result->sockets = NULL;
return result;
}
void rnet_select_result_add(rnet_select_result_t *result, rnet_socket_t *sock) {
result->sockets = realloc(result->sockets, sizeof(rnet_socket_t *) * (result->socket_count + 1));
result->sockets[result->socket_count] = sock;
result->socket_count++;
}
void rnet_select_result_free(rnet_select_result_t *result) { free(result); }
rnet_select_result_t *net_socket_select(rnet_server_t *server) {
fd_set read_fds;
FD_ZERO(&read_fds);
FD_SET(server->socket_fd, &read_fds);
server->max_fd = server->socket_fd;
int socket_fd = -1;
for (unsigned int i = 0; i < server->socket_count; i++) {
socket_fd = server->sockets[i]->fd;
if (!server->sockets[i]->connected) {
continue;
}
if (socket_fd > 0) {
FD_SET(socket_fd, &read_fds);
if (socket_fd > server->max_fd) {
server->max_fd = socket_fd;
}
}
}
int new_socket = -1;
struct sockaddr_in address;
int addrlen = sizeof(struct sockaddr_in);
int activity = select(server->max_fd + 1, &read_fds, NULL, NULL, NULL);
if ((activity < 0) && (errno != EINTR)) {
perror("Select error\n");
return NULL;
}
if (FD_ISSET(server->socket_fd, &read_fds)) {
if ((new_socket = accept(server->socket_fd, (struct sockaddr *)&address, (socklen_t *)&addrlen)) < 0) {
perror("Accept failed\n");
return NULL;
}
// net_set_non_blocking(new_socket);
char name[50] = {0};
sprintf(name, "fd:%.4d:ip:%12s:port:%.6d", new_socket, inet_ntoa(address.sin_addr), ntohs(address.sin_port));
rnet_socket_t *sock_obj = NULL;
for (unsigned int i = 0; i < server->socket_count; i++) {
if (server->sockets && server->sockets[i]->fd == -1) {
sock_obj = server->sockets[i];
}
}
if (!sock_obj) {
sock_obj = (rnet_socket_t *)malloc(sizeof(rnet_socket_t));
rnet_server_add_socket(server, sock_obj);
}
sock_obj->fd = new_socket;
strcpy(sock_obj->name, name);
sockets_connected++;
sockets_total++;
sockets_concurrent_record = sockets_connected > sockets_concurrent_record ? sockets_connected : sockets_concurrent_record;
if (new_socket > net_socket_max_fd) {
net_socket_max_fd = new_socket;
}
sock_obj->connected = true;
sock_obj->on_connect(sock_obj);
}
rnet_select_result_t *result = rnet_new_socket_select_result(server->socket_fd);
unsigned int readable_count = 0;
for (unsigned int i = 0; i < server->socket_count; i++) {
if (server->sockets[i]->fd == -1)
continue;
if (FD_ISSET(server->sockets[i]->fd, &read_fds)) {
rnet_select_result_add(result, server->sockets[i]);
readable_count++;
if (server->sockets[i]->on_read) {
server->sockets[i]->on_read(server->sockets[i]);
}
}
}
if (server->select_result) {
rnet_select_result_free(server->select_result);
server->select_result = NULL;
}
if (readable_count == 0)
rnet_select_result_free(result);
return readable_count ? result : NULL;
}
rnet_socket_t *get_net_socket_by_fd(int sock) {
for (int i = 0; i < net_socket_max_fd; i++) {
if (sockets[i].fd == sock) {
return &sockets[i];
}
}
return NULL;
}
void _net_socket_close(int sock) {
if (sock > 0) {
sockets_connected--;
sockets_disconnected++;
if (sock > 0) {
if (close(sock) == -1) {
perror("Error closing socket.\n");
}
}
}
}
void net_socket_close(rnet_socket_t *sock) {
sock->connected = false;
if (sock->on_close)
sock->on_close(sock);
_net_socket_close(sock->fd);
sock->fd = -1;
}
#undef _POSIX_C_SOURCE
#endif
#include <stdio.h>
#ifndef RLIB_RARGS_H
#define RLIB_RARGS_H
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
bool rargs_isset(int argc, char *argv[], char *key) {
for (int i = 0; i < argc; i++) {
if (!strcmp(argv[i], key)) {
return true;
}
}
return false;
}
char *rargs_get_option_string(int argc, char *argv[], char *key, const char *def) {
for (int i = 0; i < argc; i++) {
if (!strcmp(argv[i], key)) {
if (i < argc - 1) {
return argv[i + 1];
}
}
}
return (char *)def;
}
int rargs_get_option_int(int argc, char *argv[], char *key, int def) {
for (int i = 0; i < argc; i++) {
if (!strcmp(argv[i], key)) {
if (i < argc - 1) {
return atoi(argv[i + 1]);
}
}
}
return def;
}
bool rargs_get_option_bool(int argc, char *argv[], char *key, bool def) {
for (int i = 0; i < argc; i++) {
if (!strcmp(argv[i], key)) {
if (i < argc - 1) {
if (!strcmp(argv[i + 1], "false"))
return false;
if (!strcmp(argv[i + 1], "0"))
return false;
return true;
}
}
}
return def;
}
#endif
#ifndef RCAT_H
#define RCAT_H
#include <stdio.h>
#include <stdlib.h>
void rcat(char *filename) {
FILE *f = fopen(filename, "rb");
if (!f) {
printf("rcat: couldn't open \"%s\" for read.\n", filename);
return;
}
unsigned char c;
while ((c = fgetc(f)) && !feof(f)) {
printf("%c", c);
}
fclose(f);
fflush(stdout);
}
int rcat_main(int argc, char *argv[]) {
if (argc < 2) {
printf("Usage: [filename]\n");
return 1;
}
rcat(argv[1]);
return 0;
}
#endif
#ifndef RLIZA_H
#define RLIZA_H
#ifndef RBUFFER_H
#define RBUFFER_H
#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct rbuffer_t {
unsigned char *data;
unsigned char *_data;
size_t size;
size_t pos;
bool eof;
} rbuffer_t;
rbuffer_t *rbuffer_new(unsigned char *data, size_t size);
void rbuffer_free(rbuffer_t *rfb);
void rbuffer_reset(rbuffer_t *rfb);
void rbuffer_write(rbuffer_t *rfb, const unsigned char *data, size_t size);
size_t rbuffer_push(rbuffer_t *rfb, unsigned char);
unsigned char rbuffer_pop(rbuffer_t *rfb);
unsigned char *rbuffer_expect(rbuffer_t *rfb, char *options, char *ignore);
void rbuffer_set(rbuffer_t *rfb, const unsigned char *data, size_t size);
void rbuffer_set(rbuffer_t *rfb, const unsigned char *data, size_t size) {
if (rfb->_data) {
free(rfb->_data);
rfb->_data = NULL;
rfb->data = NULL;
rfb->eof = true;
}
if (size) {
rfb->_data = (unsigned char *)malloc(size);
memcpy(rfb->_data, data, size);
rfb->data = rfb->_data;
rfb->eof = false;
}
rfb->size = size;
rfb->pos = 0;
}
rbuffer_t *rbuffer_new(unsigned char *data, size_t size) {
rbuffer_t *rfb = (rbuffer_t *)malloc(sizeof(rbuffer_t));
if (size) {
rfb->_data = (unsigned char *)malloc(size);
memcpy(rfb->_data, data, size);
rfb->eof = false;
} else {
rfb->_data = NULL;
rfb->eof = true;
}
rfb->size = size;
rfb->pos = 0;
rfb->data = rfb->_data;
return rfb;
}
void rbuffer_free(rbuffer_t *rfb) {
if (rfb->_data)
free(rfb->_data);
free(rfb);
}
size_t rbuffer_push(rbuffer_t *rfb, unsigned char c) {
if (rfb->pos < rfb->size) {
rfb->_data[rfb->pos++] = c;
return 1;
}
rfb->_data = realloc(rfb->_data, rfb->size ? rfb->size + 1 : rfb->size + 2);
rfb->_data[rfb->pos++] = c;
rfb->size++;
return rfb->pos;
}
void rbuffer_write(rbuffer_t *rfb, const unsigned char *data, size_t size) {
unsigned char *data_ptr = (unsigned char *)data;
for (size_t i = 0; i < size; i++) {
rbuffer_push(rfb, data_ptr[i]);
}
}
unsigned char rbuffer_peek(rbuffer_t *rfb) {
unsigned char result = EOF;
if (rfb->pos != rfb->size) {
result = rfb->_data[rfb->pos];
return result;
}
rfb->eof = true;
return EOF;
}
unsigned char rbuffer_pop(rbuffer_t *rfb) {
unsigned char result = EOF;
if (rfb->pos <= rfb->size) {
result = rfb->_data[rfb->pos];
rfb->pos++;
rfb->data++;
if (rfb->pos == rfb->size) {
rfb->eof = true;
}
return result;
}
rfb->eof = true;
return result;
}
void rbuffer_reset(rbuffer_t *rfb) {
rfb->data = rfb->_data;
rfb->pos = 0;
}
unsigned char ustrncmp(const unsigned char *s1, const unsigned char *s2, size_t n) {
return strncmp((char *)s1, (char *)s2, n);
while (n && *s1 == *s2) {
n--;
s1++;
s2++;
}
return *s1 != *s2;
}
size_t ustrlen(const unsigned char *s) { return strlen((char *)s); }
unsigned char *rbuffer_to_string(rbuffer_t *rfb) {
unsigned char *result = rfb->_data;
rfb->_data = NULL;
rfb->data = NULL;
rbuffer_free(rfb);
return result;
}
unsigned char *rbuffer_match_option(rbuffer_t *rfb, char *options) {
char *option = NULL;
char options_cpy[1024] = {0};
strcpy(options_cpy, options);
char *memory = options_cpy;
while ((option = strtok_r(option == NULL ? memory : NULL, "|", &memory)) != NULL) {
size_t option_length = strlen(option);
if (option_length > rfb->size - rfb->pos) {
continue;
}
if (!strcmp(option, "\\d") && *rfb->data >= '0' && *rfb->data <= '9') {
return rfb->data;
}
if (rfb->size - rfb->pos >= 5 && !strcmp(option, "\\b") &&
((!ustrncmp(rfb->data, (unsigned char *)"true", 4) || !ustrncmp(rfb->data, (unsigned char *)"false", 5)))) {
return rfb->data;
}
if (!ustrncmp(rfb->data, (unsigned char *)option, option_length)) {
return rfb->data;
}
}
return NULL;
}
unsigned char *rbuffer_expect(rbuffer_t *rfb, char *options, char *ignore) {
while (rfb->pos < rfb->size) {
if (rbuffer_match_option(rfb, options) != NULL) {
return rfb->data;
}
if (rbuffer_match_option(rfb, ignore)) {
printf("SKIP:%s\n", rfb->data);
rbuffer_pop(rfb);
continue;
}
break;
}
return NULL;
}
unsigned char *rbuffer_consume(rbuffer_t *rfb, char *options, char *ignore) {
unsigned char *result = NULL;
if ((result = rbuffer_expect(rfb, options, ignore)) != NULL) {
rbuffer_pop(rfb);
}
return result;
}
#endif
#ifndef RSTRING_H
#define RSTRING_H
#ifndef RMATH_H
#define RMATH_H
#include <math.h>
#ifndef ceil
double ceil(double x) {
if (x == (double)(long long)x) {
return x;
} else if (x > 0.0) {
return (double)(long long)x + 1.0;
} else {
return (double)(long long)x;
}
}
#endif
#ifndef floor
double floor(double x) {
if (x >= 0.0) {
return (double)(long long)x;
} else {
double result = (double)(long long)x;
return (result == x) ? result : result - 1.0;
}
}
#endif
#ifndef modf
double modf(double x, double *iptr) {
double int_part = (x >= 0.0) ? floor(x) : ceil(x);
*iptr = int_part;
return x - int_part;
}
#endif
#endif
#include <ctype.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
char *rstrtimestamp() {
time_t current_time;
time(&current_time);
struct tm *local_time = localtime(&current_time);
static char time_string[100];
time_string[0] = 0;
strftime(time_string, sizeof(time_string), "%Y-%m-%d %H:%M:%S", local_time);
return time_string;
}
ulonglong _r_generate_key_current = 0;
char *_rcat_int_int(int a, int b) {
static char res[20];
res[0] = 0;
sprintf(res, "%d%d", a, b);
return res;
}
char *_rcat_int_double(int a, double b) {
static char res[20];
res[0] = 0;
sprintf(res, "%d%f", a, b);
return res;
}
char *_rcat_charp_int(char *a, int b) {
char res[20];
sprintf(res, "%c", b);
return strcat(a, res);
}
char *_rcat_charp_double(char *a, double b) {
char res[20];
sprintf(res, "%f", b);
return strcat(a, res);
}
char *_rcat_charp_charp(char *a, char *b) {
;
return strcat(a, b);
}
char *_rcat_charp_char(char *a, char b) {
char extra[] = {b, 0};
return strcat(a, extra);
}
char *_rcat_charp_bool(char *a, bool *b) {
if (b) {
return strcat(a, "true");
} else {
return strcat(a, "false");
}
}
#define rcat(x, y) \
_Generic((x), \
int: _Generic((y), int: _rcat_int_int, double: _rcat_int_double, char *: _rcat_charp_charp), \
char *: _Generic((y), \
int: _rcat_charp_int, \
double: _rcat_charp_double, \
char *: _rcat_charp_charp, \
char: _rcat_charp_char, \
bool: _rcat_charp_bool))((x), (y))
char *rgenerate_key() {
_r_generate_key_current++;
static char key[100];
key[0] = 0;
sprintf(key, "%lld", _r_generate_key_current);
return key;
}
char *rformat_number(long long lnumber) {
static char formatted[1024];
char number[1024] = {0};
sprintf(number, "%lld", lnumber);
int len = strlen(number);
int commas_needed = (len - 1) / 3;
int new_len = len + commas_needed;
formatted[new_len] = '\0';
int i = len - 1;
int j = new_len - 1;
int count = 0;
while (i >= 0) {
if (count == 3) {
formatted[j--] = '.';
count = 0;
}
formatted[j--] = number[i--];
count++;
}
if (lnumber < 0)
formatted[j--] = '-';
return formatted;
}
bool rstrextractdouble(char *str, double *d1) {
for (size_t i = 0; i < strlen(str); i++) {
if (isdigit(str[i])) {
str += i;
sscanf(str, "%lf", d1);
return true;
}
}
return false;
}
void rstrstripslashes(const char *content, char *result) {
size_t content_length = strlen((char *)content);
unsigned int index = 0;
for (unsigned int i = 0; i < content_length; i++) {
char c = content[i];
if (c == '\\') {
i++;
c = content[i];
if (c == 'r') {
c = '\r';
} else if (c == 't') {
c = '\t';
} else if (c == 'b') {
c = '\b';
} else if (c == 'n') {
c = '\n';
} else if (c == 'f') {
c = '\f';
} else if (c == '\\') {
// No need tbh
c = '\\';
i++;
}
}
result[index] = c;
index++;
}
result[index] = 0;
}
int rstrstartswith(const char *s1, const char *s2) {
if (s1 == NULL)
return s2 == NULL;
if (s1 == s2 || s2 == NULL || *s2 == 0)
return true;
size_t len_s2 = strlen(s2);
size_t len_s1 = strlen(s1);
if (len_s2 > len_s1)
return false;
return !strncmp(s1, s2, len_s2);
}
bool rstrendswith(const char *s1, const char *s2) {
if (s1 == NULL)
return s2 == NULL;
if (s1 == s2 || s2 == NULL || *s2 == 0)
return true;
size_t len_s2 = strlen(s2);
size_t len_s1 = strlen(s1);
if (len_s2 > len_s1) {
return false;
}
s1 += len_s1 - len_s2;
return !strncmp(s1, s2, len_s2);
}
void rstraddslashes(const char *content, char *result) {
size_t content_length = strlen((char *)content);
unsigned int index = 0;
for (unsigned int i = 0; i < content_length; i++) {
if (content[i] == '\r') {
result[index] = '\\';
index++;
result[index] = 'r';
index++;
continue;
} else if (content[i] == '\t') {
result[index] = '\\';
index++;
result[index] = 't';
index++;
continue;
} else if (content[i] == '\n') {
result[index] = '\\';
index++;
result[index] = 'n';
index++;
continue;
} else if (content[i] == '\\') {
result[index] = '\\';
index++;
result[index] = '\\';
index++;
continue;
} else if (content[i] == '\b') {
result[index] = '\\';
index++;
result[index] = 'b';
index++;
continue;
} else if (content[i] == '\f') {
result[index] = '\\';
index++;
result[index] = 'f';
index++;
continue;
} else if (content[i] == '"') {
result[index] = '\\';
index++;
result[index] = '"';
index++;
continue;
}
result[index] = content[i];
index++;
result[index] = 0;
}
}
int rstrip_whitespace(char *input, char *output) {
output[0] = 0;
int count = 0;
size_t len = strlen(input);
for (size_t i = 0; i < len; i++) {
if (input[i] == '\t' || input[i] == ' ' || input[i] == '\n') {
continue;
}
count = i;
size_t j;
for (j = 0; j < len - count; j++) {
output[j] = input[j + count];
}
output[j] = '\0';
break;
}
return count;
}
/*
* Converts "pony" to \"pony\". Addslashes does not
* Converts "pony\npony" to "pony\n"
* "pony"
*/
void rstrtocstring(const char *input, char *output) {
int index = 0;
char clean_input[strlen(input) * 2];
char *iptr = clean_input;
rstraddslashes(input, clean_input);
output[index] = '"';
index++;
while (*iptr) {
if (*iptr == '"') {
output[index] = '\\';
output++;
} else if (*iptr == '\\' && *(iptr + 1) == 'n') {
output[index] = '\\';
output++;
output[index] = 'n';
output++;
output[index] = '"';
output++;
output[index] = '\n';
output++;
output[index] = '"';
output++;
iptr++;
iptr++;
continue;
}
output[index] = *iptr;
index++;
iptr++;
}
if (output[index - 1] == '"' && output[index - 2] == '\n') {
output[index - 1] = 0;
} else if (output[index - 1] != '"') {
output[index] = '"';
output[index + 1] = 0;
}
}
size_t rstrtokline(char *input, char *output, size_t offset, bool strip_nl) {
size_t len = strlen(input);
output[0] = 0;
size_t new_offset = 0;
size_t j;
size_t index = 0;
for (j = offset; j < len + offset; j++) {
if (input[j] == 0) {
index++;
break;
}
index = j - offset;
output[index] = input[j];
if (output[index] == '\n') {
index++;
break;
}
}
output[index] = 0;
new_offset = index + offset;
if (strip_nl) {
if (output[index - 1] == '\n') {
output[index - 1] = 0;
}
}
return new_offset;
}
void rstrjoin(char **lines, size_t count, char *glue, char *output) {
output[0] = 0;
for (size_t i = 0; i < count; i++) {
strcat(output, lines[i]);
if (i != count - 1)
strcat(output, glue);
}
}
int rstrsplit(char *input, char **lines) {
int index = 0;
size_t offset = 0;
char line[1024];
while ((offset = rstrtokline(input, line, offset, false)) && *line) {
if (!*line) {
break;
}
lines[index] = (char *)malloc(strlen(line) + 1);
strcpy(lines[index], line);
index++;
}
return index;
}
bool rstartswithnumber(char *str) { return isdigit(str[0]); }
void rstrmove2(char *str, unsigned int start, size_t length, unsigned int new_pos) {
size_t str_len = strlen(str);
char new_str[str_len + 1];
memset(new_str, 0, str_len);
if (start < new_pos) {
strncat(new_str, str + length, str_len - length - start);
new_str[new_pos] = 0;
strncat(new_str, str + start, length);
strcat(new_str, str + strlen(new_str));
memset(str, 0, str_len);
strcpy(str, new_str);
} else {
strncat(new_str, str + start, length);
strncat(new_str, str, start);
strncat(new_str, str + start + length, str_len - start);
memset(str, 0, str_len);
strcpy(str, new_str);
}
new_str[str_len] = 0;
}
void rstrmove(char *str, unsigned int start, size_t length, unsigned int new_pos) {
size_t str_len = strlen(str);
if (start >= str_len || new_pos >= str_len || start + length > str_len) {
return;
}
char temp[length + 1];
strncpy(temp, str + start, length);
temp[length] = 0;
if (start < new_pos) {
memmove(str + start, str + start + length, new_pos - start);
strncpy(str + new_pos - length + 1, temp, length);
} else {
memmove(str + new_pos + length, str + new_pos, start - new_pos);
strncpy(str + new_pos, temp, length);
}
}
int cmp_line(const void *left, const void *right) {
char *l = *(char **)left;
char *r = *(char **)right;
char lstripped[strlen(l) + 1];
rstrip_whitespace(l, lstripped);
char rstripped[strlen(r) + 1];
rstrip_whitespace(r, rstripped);
double d1, d2;
bool found_d1 = rstrextractdouble(lstripped, &d1);
bool found_d2 = rstrextractdouble(rstripped, &d2);
if (found_d1 && found_d2) {
double frac_part1;
double int_part1;
frac_part1 = modf(d1, &int_part1);
double frac_part2;
double int_part2;
frac_part2 = modf(d2, &int_part2);
if (d1 == d2) {
return strcmp(lstripped, rstripped);
} else if (frac_part1 && frac_part2) {
return d1 > d2;
} else if (frac_part1 && !frac_part2) {
return 1;
} else if (frac_part2 && !frac_part1) {
return -1;
} else if (!frac_part1 && !frac_part2) {
return d1 > d2;
}
}
return 0;
}
int rstrsort(char *input, char *output) {
char **lines = (char **)malloc(strlen(input) * 10);
int line_count = rstrsplit(input, lines);
qsort(lines, line_count, sizeof(char *), cmp_line);
rstrjoin(lines, line_count, "", output);
for (int i = 0; i < line_count; i++) {
free(lines[i]);
}
free(lines);
return line_count;
}
#endif
#include <assert.h>
#include <ctype.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef enum rliza_type_t {
RLIZA_STRING = 's',
RLIZA_BOOLEAN = 'b',
RLIZA_NUMBER = 'n',
RLIZA_OBJECT = 'o',
RLIZA_ARRAY = 'a',
RLIZA_NULL = 0,
RLIZA_KEY = 'k',
RLIZA_INTEGER = 'i'
} rliza_type_t;
typedef struct rliza_t {
rliza_type_t type;
struct rliza_t *value;
char *key;
union {
char *string;
bool boolean;
double number;
struct rliza_t **map;
long long integer;
} content;
unsigned int count;
char *(*get_string)(struct rliza_t *, char *);
long long (*get_integer)(struct rliza_t *, char *);
double (*get_number)(struct rliza_t *, char *);
bool (*get_boolean)(struct rliza_t *, char *);
struct rliza_t *(*get_array)(struct rliza_t *, char *);
struct rliza_t *(*get_object)(struct rliza_t *, char *);
void (*set_string)(struct rliza_t *, char *, char *);
void (*set_integer)(struct rliza_t *, char *, long long);
void (*set_number)(struct rliza_t *, char *, double);
void (*set_boolean)(struct rliza_t *, char *, bool);
void (*set_array)(struct rliza_t *self, char *key, struct rliza_t *array);
void (*set_object)(struct rliza_t *self, char *key, struct rliza_t *object);
} rliza_t;
void rliza_free(rliza_t *rliza) {
if (rliza->key) {
free(rliza->key);
rliza->key = NULL;
}
if (rliza->value) {
rliza_free(rliza->value);
rliza->value = NULL;
}
// if (rliza->content.array) {
// printf("JAAAA\n");
// }
// if (rliza->content.object) {
// rliza_free(rliza->content.object);
// rliza->content.object = NULL;
//}
if (rliza->type == RLIZA_STRING) {
if (rliza->content.string) {
free(rliza->content.string);
rliza->content.string = NULL;
// else if (rliza->type == RLIZA_NUMBER) {
// printf("STDring freed\n");
}
} else if (rliza->type == RLIZA_OBJECT || rliza->type == RLIZA_ARRAY) {
if (rliza->content.map) {
for (unsigned int i = 0; i < rliza->count; i++) {
rliza_free(rliza->content.map[i]);
}
free(rliza->content.map);
}
}
// free(rliza->content.array);
//}
free(rliza);
}
rliza_t *rliza_new(rliza_type_t type);
rliza_t *rliza_new_string(char *string);
rliza_t *rliza_new_null();
rliza_t *rliza_new_boolean(bool value);
rliza_t *rliza_new_number(double value);
rliza_t *rliza_new_integer(long long value);
rliza_t *rliza_new_key_value(char *key, rliza_t *value);
rliza_t *rliza_new_key_string(char *key, char *string);
rliza_t *rliza_new_key_bool(char *key, bool value);
rliza_t *rliza_new_key_number(char *key, double value);
void rliza_push(rliza_t *self, rliza_t *obj);
void rliza_push_object(rliza_t *self, rliza_t *object);
void rliza_set_object(rliza_t *self, char *key, rliza_t *object);
void rliza_set_string(rliza_t *self, char *key, char *string);
void rliza_set_boolean(rliza_t *self, char *key, bool value);
void rliza_set_number(rliza_t *self, char *key, double value);
void rliza_set_integer(rliza_t *self, char *key, long long value);
char *rliza_get_string(rliza_t *self, char *key);
long long rliza_get_integer(rliza_t *self, char *key);
double rliza_get_number(rliza_t *self, char *key);
bool rliza_get_boolean(rliza_t *self, char *key);
rliza_t *rliza_get_array(rliza_t *self, char *key);
rliza_t *rliza_get_object(rliza_t *self, char *key);
void rliza_set_array(rliza_t *self, char *key, rliza_t *array);
char *rliza_dumps(rliza_t *rliza);
rliza_t *rliza_loads(char **content);
rliza_t *_rliza_loads(char **content);
char *rliza_get_string(rliza_t *self, char *key) {
for (unsigned int i = 0; i < self->count; i++) {
if (self->content.map[i]->key != NULL && strcmp(self->content.map[i]->key, key) == 0) {
if (self->content.map[i]->type == RLIZA_STRING || self->content.map[i]->type == RLIZA_NULL) {
return self->content.map[i]->content.string;
}
}
}
return NULL;
}
long long rliza_get_integer(rliza_t *self, char *key) {
for (unsigned int i = 0; i < self->count; i++) {
if (self->content.map[i]->key != NULL && strcmp(self->content.map[i]->key, key) == 0) {
if (self->content.map[i]->type == RLIZA_INTEGER || self->content.map[i]->type == RLIZA_NULL) {
return self->content.map[i]->content.integer;
}
}
}
return 0;
}
double rliza_get_number(rliza_t *self, char *key) {
for (unsigned int i = 0; i < self->count; i++) {
if (self->content.map[i]->key != NULL && strcmp(self->content.map[i]->key, key) == 0) {
if (self->content.map[i]->type == RLIZA_NUMBER || self->content.map[i]->type == RLIZA_NULL) {
return self->content.map[i]->content.number;
}
}
}
return 0;
}
bool rliza_get_boolean(rliza_t *self, char *key) {
for (unsigned int i = 0; i < self->count; i++) {
if (self->content.map[i]->key != NULL && strcmp(self->content.map[i]->key, key) == 0) {
if (self->content.map[i]->type == RLIZA_BOOLEAN || self->content.map[i]->type == RLIZA_NULL) {
return self->content.map[i]->content.boolean;
}
}
}
return false;
}
rliza_t *rliza_get_object(rliza_t *self, char *key) {
for (unsigned int i = 0; i < self->count; i++) {
if (self->content.map[i]->key != NULL && strcmp(self->content.map[i]->key, key) == 0) {
return self->content.map[i];
}
}
return NULL;
}
rliza_t *rliza_get_array(rliza_t *self, char *key) {
for (unsigned int i = 0; i < self->count; i++) {
if (self->content.map[i]->key != NULL && strcmp(self->content.map[i]->key, key) == 0) {
if (self->content.map[i]->type == RLIZA_ARRAY || self->content.map[i]->type == RLIZA_NULL) {
return self->content.map[i];
}
}
}
return NULL;
}
rliza_t *rliza_new_null() {
rliza_t *rliza = rliza_new(RLIZA_NULL);
return rliza;
}
rliza_t *rliza_new_string(char *string) {
rliza_t *rliza = rliza_new(RLIZA_STRING);
if (string == NULL) {
rliza->type = RLIZA_NULL;
rliza->content.string = NULL;
return rliza;
} else {
rliza->content.string = strdup(string);
}
return rliza;
}
rliza_t *rliza_new_boolean(bool value) {
rliza_t *rliza = rliza_new(RLIZA_BOOLEAN);
rliza->content.boolean = value;
return rliza;
}
rliza_t *rliza_new_number(double value) {
rliza_t *rliza = rliza_new(RLIZA_NUMBER);
rliza->content.number = value;
return rliza;
}
rliza_t *rliza_new_integer(long long value) {
rliza_t *rliza = rliza_new(RLIZA_INTEGER);
rliza->content.integer = value;
return rliza;
}
rliza_t *rliza_new_key_array(char *key) {
rliza_t *rliza = rliza_new(RLIZA_ARRAY);
rliza->key = strdup(key);
return rliza;
}
rliza_t *rliza_new_key_value(char *key, rliza_t *value) {
rliza_t *rliza = rliza_new(RLIZA_OBJECT);
if (key) {
rliza->key = strdup(key);
}
rliza->value = value;
return rliza;
}
rliza_t *rliza_new_key_string(char *key, char *string) {
rliza_t *rliza = rliza_new_key_value(key, rliza_new_string(string));
return rliza;
}
rliza_t *rliza_new_key_bool(char *key, bool value) {
rliza_t *rliza = rliza_new_key_value(key, rliza_new_boolean(value));
return rliza;
}
rliza_t *rliza_new_key_number(char *key, double value) {
rliza_t *rliza = rliza_new_key_value(key, rliza_new_number(value));
return rliza;
}
void rliza_set_null(rliza_t *self, char *key) {
rliza_t *obj = rliza_get_object(self, key);
if (!obj) {
obj = rliza_new_null();
obj->key = strdup(key);
rliza_push_object(self, obj);
}
if (obj->type == RLIZA_OBJECT) {
rliza_free(obj->value);
obj->value = NULL;
} else if (obj->type == RLIZA_STRING) {
if (obj->content.string)
free(obj->content.string);
obj->content.string = NULL;
} else if (obj->type == RLIZA_ARRAY) {
for (unsigned int i = 0; i < obj->count; i++) {
rliza_free(obj->content.map[i]);
}
} else if (obj->type == RLIZA_NUMBER) {
obj->content.number = 0;
} else if (obj->type == RLIZA_INTEGER) {
obj->content.integer = 0;
}
obj->type = RLIZA_NULL;
}
rliza_t *rliza_duplicate(rliza_t *rliza) {
if (!rliza)
return NULL;
char *str = rliza_dumps(rliza);
char *strp = str;
rliza_t *obj = rliza_loads(&strp);
free(str);
return obj;
}
rliza_t *rliza_new_object(rliza_t *obj) {
rliza_t *rliza = rliza_new(RLIZA_OBJECT);
rliza->value = obj;
return rliza;
}
void rliza_set_object(rliza_t *self, char *key, rliza_t *value) {
rliza_t *obj = rliza_duplicate(value);
obj->key = strdup(key);
obj->type = RLIZA_OBJECT;
rliza_push(self, obj);
}
void rliza_set_string(rliza_t *self, char *key, char *string) {
rliza_t *obj = rliza_get_object(self, key);
if (!obj) {
obj = rliza_new_string(string);
obj->key = strdup(key);
obj->type = RLIZA_STRING;
rliza_push_object(self, obj);
} else {
obj->content.string = strdup(string);
}
}
void rliza_set_array(rliza_t *self, char *key, rliza_t *array) {
rliza_t *obj = rliza_get_object(self, key);
if (obj)
rliza_free(obj);
if (array->key) {
free(array->key);
array->key = strdup(key);
}
rliza_push_object(self, array);
}
void rliza_set_number(rliza_t *self, char *key, double value) {
rliza_t *obj = rliza_get_object(self, key);
if (!obj) {
obj = rliza_new_number(value);
obj->key = strdup(key);
obj->type = RLIZA_NUMBER;
rliza_push_object(self, obj);
} else {
obj->content.number = value;
}
}
void rliza_push_object(rliza_t *self, rliza_t *object) {
self->content.map = realloc(self->content.map, (sizeof(rliza_t **)) * (self->count + 1));
self->content.map[self->count] = object;
self->count++;
}
void rliza_set_integer(rliza_t *self, char *key, long long value) {
rliza_t *obj = rliza_get_object(self, key);
if (!obj) {
obj = rliza_new_integer(value);
obj->key = strdup(key);
obj->type = RLIZA_INTEGER;
rliza_push_object(self, obj);
} else {
obj->content.integer = value;
}
}
void rliza_set_boolean(rliza_t *self, char *key, bool value) {
rliza_t *obj = rliza_get_object(self, key);
if (!obj) {
obj = rliza_new_boolean(value);
obj->key = strdup(key);
obj->type = RLIZA_BOOLEAN;
rliza_push_object(self, obj);
} else {
obj->content.boolean = value;
}
}
rliza_t *rliza_new(rliza_type_t type) {
rliza_t *rliza = (rliza_t *)calloc(1, sizeof(rliza_t));
rliza->type = type;
rliza->get_boolean = rliza_get_boolean;
rliza->get_integer = rliza_get_integer;
rliza->get_number = rliza_get_number;
rliza->get_string = rliza_get_string;
rliza->get_array = rliza_get_array;
rliza->get_object = rliza_get_object;
rliza->set_string = rliza_set_string;
rliza->set_number = rliza_set_number;
rliza->set_boolean = rliza_set_boolean;
rliza->set_integer = rliza_set_integer;
rliza->set_array = rliza_set_array;
rliza->set_object = rliza_set_object;
return rliza;
}
void *rliza_coalesce(void *result, void *default_value) {
if (result == NULL)
return default_value;
return result;
}
char *rliza_seek_string(char **content, char **options) {
while (**content == ' ' || **content == '\n' || **content == '\t' || **content == '\r') {
(*content)++;
}
if (**content == 0) {
return NULL;
}
char *option = NULL;
unsigned int option_index = 0;
while (true) {
option = options[option_index];
if (option == NULL)
break;
option_index++;
if (option[0] == 'd') {
if (**content >= '0' && **content <= '9') {
return (char *)*content;
}
} else if (!strncmp(option, *content, strlen(option))) {
return (char *)*content;
}
}
return *content;
}
char *rliza_extract_quotes(char **content) {
rbuffer_t *buffer = rbuffer_new(NULL, 0);
assert(**content == '"');
char previous = 0;
while (true) {
(*content)++;
if (!**content) {
rbuffer_free(buffer);
return NULL;
}
if (**content == '"' && previous != '\\') {
break;
}
rbuffer_push(buffer, **content);
previous = **content;
}
assert(**content == '"');
(*content)++;
rbuffer_push(buffer, 0);
char *result = (char *)rbuffer_to_string(buffer);
return result;
}
rliza_t *_rliza_loads(char **content) {
static char *seek_for1[] = {"[", "{", "\"", "d", "true", "false", "null", NULL};
char *token = (char *)rliza_seek_string(content, seek_for1);
if (!token)
return NULL;
rliza_t *rliza = rliza_new(RLIZA_NULL);
if (**content == '"') {
char *extracted = rliza_extract_quotes(content);
if (!extracted) {
rliza_free(rliza);
return NULL;
}
// char *extracted_with_slashes = (char *)malloc(strlen((char *)extracted) * 2 + 1);
// rstraddslashes(extracted, extracted_with_slashes);
rliza->type = RLIZA_STRING;
rliza->content.string = extracted; // extracted_with_slashes; // extracted_without_slashes;
// free(extracted);
return rliza;
} else if (**content == '{') {
rliza->type = RLIZA_OBJECT;
(*content)++;
char *result = NULL;
static char *seek_for2[] = {"\"", ",", "}", NULL};
while ((result = (char *)rliza_seek_string(content, seek_for2)) != NULL && *result) {
if (!**content) {
rliza_free(rliza);
return NULL;
}
if (**content == ',') {
(*content)++;
if (!**content) {
rliza_free(rliza);
return NULL;
}
continue;
}
char *key = NULL;
if (**content == '"') {
key = rliza_extract_quotes((char **)content);
if (!key || !*key) {
rliza_free(rliza);
return NULL;
}
char *escaped_key = (char *)malloc(strlen((char *)key) * 2 + 1);
rstrstripslashes((char *)key, escaped_key);
static char *seek_for3[] = {":", NULL};
char *devider = rliza_seek_string(content, seek_for3);
if (!devider || !*devider) {
free(escaped_key);
free(key);
rliza_free(rliza);
return NULL;
}
(*content)++;
if (!**content) {
free(key);
free(escaped_key);
rliza_free(rliza);
return NULL;
}
rliza_t *value = _rliza_loads(content);
if (!value) {
free(key);
free(escaped_key);
rliza_free(rliza);
return NULL;
}
if (value->key)
free(value->key);
value->key = escaped_key;
free(key);
rliza_push_object(rliza, value);
} else if (**content == '}') {
break;
} else {
// Parse error
rliza_free(rliza);
return NULL;
}
};
if ((**content != '}')) {
rliza_free(rliza);
return NULL;
}
(*content)++;
return rliza;
} else if (**content == '[') {
rliza->type = RLIZA_ARRAY;
(*content)++;
char *result;
static char *seek_for4[] = {"[", "{", "\"", "d", ",", "]", "null", "true", "false", NULL};
while ((result = (char *)rliza_seek_string(content, seek_for4)) != NULL && *result) {
if (**content == ',') {
(*content)++;
} else if (**content == ']') {
break;
}
rliza_t *obj = _rliza_loads(content);
if (!obj) {
rliza_free(rliza);
return NULL;
}
rliza_push(rliza, obj);
if (!**content) {
rliza_free(rliza);
return NULL;
}
}
if (**content != ']') {
rliza_free(rliza);
return NULL;
}
(*content)++;
return rliza;
} else if (**content >= '0' && **content <= '9') {
char *ptr = *content;
bool is_decimal = false;
while (**content) {
if (**content == '.') {
is_decimal = true;
} else if (!isdigit(**content)) {
break;
}
(*content)++;
}
if (*(*content - 1) == '.') {
rliza_free(rliza);
return NULL;
}
if (!**content) {
rliza_free(rliza);
return NULL;
}
if (is_decimal) {
rliza->type = RLIZA_NUMBER;
rliza->content.number = strtod(ptr, NULL);
} else {
rliza->type = RLIZA_INTEGER;
rliza->content.integer = strtoll(ptr, NULL, 10);
}
return rliza;
} else if (!strncmp(*content, "true", 4)) {
rliza->type = RLIZA_BOOLEAN;
rliza->content.boolean = true;
*content += 4;
return rliza;
} else if (!strncmp(*content, "false", 5)) {
rliza->type = RLIZA_BOOLEAN;
rliza->content.boolean = false;
*content += 5;
return rliza;
} else if (!strncmp(*content, "null", 4)) {
rliza->type = RLIZA_NULL;
*content += 4;
return rliza;
}
// Parsing error
rliza_free(rliza);
return NULL;
}
rliza_t *rliza_loads(char **content) {
if (!content || !**content) {
return NULL;
}
char *original_content = *content;
rliza_t *result = _rliza_loads(content);
if (!result) {
*content = original_content;
}
return result;
}
char *rliza_dumps(rliza_t *rliza) {
size_t size = 4096;
char *content = (char *)calloc(size, sizeof(char));
content[0] = 0;
if (rliza->type == RLIZA_INTEGER) {
if (rliza->key) {
sprintf(content, "\"%s\":%lld", rliza->key, rliza->content.integer);
} else {
sprintf(content, "%lld", rliza->content.integer);
}
} else if (rliza->type == RLIZA_STRING) {
// char *escaped_string = (char *)calloc(strlen((char *)rliza->content.string) * 2 + 1024,sizeof(char));
char *escaped_string = rliza->content.string;
// rstrstripslashes((char *)rliza->content.string, escaped_string);
size_t min_size = strlen((char *)escaped_string) + (rliza->key ? strlen(rliza->key) : 0) + 1024;
if (size < min_size) {
size = min_size + 1;
content = realloc(content, size);
}
if (rliza->key) {
char *escaped_key = (char *)malloc(strlen((char *)rliza->key) * 2 + 20);
rstrstripslashes((char *)rliza->key, escaped_key);
if (strlen(content) > size) {
size = size + strlen(escaped_string) + 20;
content = realloc(content, size);
}
sprintf(content, "\"%s\":\"%s\"", escaped_key, escaped_string);
free(escaped_key);
} else {
size = size + strlen(escaped_string) + 20;
content = realloc(content, size);
sprintf(content, "\"%s\"", escaped_string);
}
// free(escaped_string);
} else if (rliza->type == RLIZA_NUMBER) {
if (rliza->key) {
sprintf(content, "\"%s\":%f", rliza->key, rliza->content.number);
} else {
sprintf(content, "%f", rliza->content.number);
}
int last_zero = 0;
bool beyond_dot = false;
for (size_t i = 0; i < strlen(content); i++) {
if (content[i] == '.') {
beyond_dot = true;
} else if (beyond_dot == true) {
if (content[i - 1] != '.') {
if (content[i] == '0') {
if (!last_zero)
last_zero = i;
} else {
last_zero = 0;
}
}
}
}
if (last_zero != 0) {
content[last_zero] = 0;
}
} else if (rliza->type == RLIZA_BOOLEAN) {
if (rliza->key) {
sprintf(content, "\"%s\":%s", rliza->key, rliza->content.boolean ? "true" : "false");
} else {
sprintf(content, "%s", rliza->content.boolean ? "true" : "false");
}
} else if (rliza->type == RLIZA_OBJECT) {
strcat(content, "{");
if (rliza->key) {
strcat(content, "\"");
strcat(content, rliza->key);
strcat(content, "\":{");
}
// bool add_braces = false;
for (unsigned i = 0; i < rliza->count; i++) {
char *content_chunk = rliza_dumps(rliza->content.map[i]);
char *content_chunk_stripped = content_chunk;
if (*content_chunk_stripped == '{') {
content_chunk_stripped++;
content_chunk_stripped[strlen(content_chunk_stripped) - 1] = 0;
}
if (strlen(content_chunk_stripped) + strlen(content) > size) {
size += strlen(content_chunk_stripped) + 20;
content = realloc(content, size);
}
strcat(content, content_chunk_stripped);
free(content_chunk);
strcat(content, ",");
}
if (content[strlen(content) - 1] == ',') {
content[strlen(content) - 1] = '\0';
if (rliza->key) {
strcat(content, "}");
}
}
strcat(content, "}");
} else if (rliza->type == RLIZA_ARRAY) {
if (rliza->key) {
char *escaped_key = (char *)malloc(strlen((char *)rliza->key) * 2 + 1);
rstraddslashes((char *)rliza->key, escaped_key);
if (strlen(escaped_key) > size) {
size = strlen(escaped_key) + 10;
content = realloc(content, size);
}
sprintf(content, "\"%s\":[", escaped_key);
free(escaped_key);
} else
strcpy(content, "[");
for (unsigned i = 0; i < rliza->count; i++) {
char *content_chunk = rliza_dumps(rliza->content.map[i]);
char *content_chunk_stripped = content_chunk;
if (*content_chunk_stripped == '{') {
// content_chunk_stripped++;
// content_chunk_stripped[strlen(content_chunk_stripped) - 1] = 0;
}
if (strlen(content_chunk_stripped) + strlen(content) > size) {
size += strlen(content_chunk_stripped) + 20;
content = realloc(content, size);
}
strcat(content, content_chunk_stripped);
free(content_chunk);
strcat(content, ",");
}
if (content[strlen(content) - 1] != '[')
content[strlen(content) - 1] = 0;
strcat(content, "]");
} else if (rliza->type == RLIZA_NULL) {
if (rliza->key) {
char *escaped_key = (char *)malloc(strlen((char *)rliza->key) * 2 + 1);
rstraddslashes((char *)rliza->key, escaped_key);
sprintf(content, "\"%s\":null", escaped_key);
free(escaped_key);
} else
strcpy(content, "null");
}
return content;
}
void rliza_dumpss(rliza_t *rliza) {
char *output = rliza_dumps(rliza);
printf("%s\n", output);
free(output);
}
void rliza_push(rliza_t *self, rliza_t *obj) { rliza_push_object(self, obj); }
int rliza_validate(char *json_content) {
if (!json_content || !*json_content) {
return false;
}
char *json_contentp = json_content;
rliza_t *to_object = _rliza_loads(&json_contentp);
if (to_object) {
rliza_free(to_object);
return json_contentp - json_content;
}
return false;
}
#endif
#ifndef RCOV_H
#define RCOV_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#ifndef RBENCH_H
#define RBENCH_H
#ifndef RPRINT_H
#define RPRINT_H
#ifndef RLIB_TIME
#define RLIB_TIME
#ifndef _POSIX_C_SOURCE_199309L
#define _POSIX_C_SOURCE_199309L
#endif
#include <sys/time.h>
#include <time.h>
#undef _POSIX_C_SOURCE_199309L
#include <errno.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#ifndef CLOCK_MONOTONIC
#define CLOCK_MONOTONIC 1
#endif
typedef uint64_t nsecs_t;
void nsleep(nsecs_t nanoseconds);
void tick() { nsleep(1); }
typedef unsigned long long msecs_t;
nsecs_t nsecs() {
unsigned int lo, hi;
__asm__ volatile("rdtsc" : "=a"(lo), "=d"(hi));
return ((uint64_t)hi << 32) | lo;
}
msecs_t rnsecs_to_msecs(nsecs_t nsecs) { return nsecs / 1000 / 1000; }
nsecs_t rmsecs_to_nsecs(msecs_t msecs) { return msecs * 1000 * 1000; }
msecs_t usecs() {
struct timeval tv;
gettimeofday(&tv, NULL);
return (long long)(tv.tv_sec) * 1000000 + (long long)(tv.tv_usec);
}
msecs_t msecs() {
struct timeval tv;
gettimeofday(&tv, NULL);
return (long long)(tv.tv_sec) * 1000 + (tv.tv_usec / 1000);
}
char *msecs_strs(msecs_t ms) {
static char str[22];
str[0] = 0;
sprintf(str, "%f", ms * 0.001);
for (int i = strlen(str); i > 0; i--) {
if (str[i] > '0')
break;
str[i] = 0;
}
return str;
}
char *msecs_strms(msecs_t ms) {
static char str[22];
str[0] = 0;
sprintf(str, "%lld", ms);
return str;
}
char *msecs_str(long long ms) {
static char result[30];
result[0] = 0;
if (ms > 999) {
char *s = msecs_strs(ms);
sprintf(result, "%ss", s);
} else {
char *s = msecs_strms(ms);
sprintf(result, "%sMs", s);
}
return result;
}
void nsleep(nsecs_t nanoseconds) {
long seconds = 0;
int factor = 0;
while (nanoseconds > 1000000000) {
factor++;
nanoseconds = nanoseconds / 10;
}
if (factor) {
seconds = 1;
factor--;
while (factor) {
seconds = seconds * 10;
factor--;
}
}
struct timespec req = {seconds, nanoseconds};
struct timespec rem;
nanosleep(&req, &rem);
}
void ssleep(double s) {
long nanoseconds = (long)(1000000000 * s);
// long seconds = 0;
// struct timespec req = {seconds, nanoseconds};
// struct timespec rem;
nsleep(nanoseconds);
}
void msleep(long miliseonds) {
long nanoseconds = miliseonds * 1000000;
nsleep(nanoseconds);
}
char *format_time(int64_t nanoseconds) {
char output[1024];
size_t output_size = sizeof(output);
output[0] = 0;
if (nanoseconds < 1000) {
// Less than 1 microsecond
snprintf(output, output_size, "%ldns", nanoseconds);
} else if (nanoseconds < 1000000) {
// Less than 1 millisecond
double us = nanoseconds / 1000.0;
snprintf(output, output_size, "%.2fµs", us);
} else if (nanoseconds < 1000000000) {
// Less than 1 second
double ms = nanoseconds / 1000000.0;
snprintf(output, output_size, "%.2fms", ms);
} else {
// 1 second or more
double s = nanoseconds / 1000000000.0;
if (s > 60 * 60) {
s = s / 60 / 60;
snprintf(output, output_size, "%.2fh", s);
} else if (s > 60) {
s = s / 60;
snprintf(output, output_size, "%.2fm", s);
} else {
snprintf(output, output_size, "%.2fs", s);
}
}
return sbuf(output);
}
#endif
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
long rpline_number = 0;
nsecs_t rprtime = 0;
int8_t _env_rdisable_colors = -1;
bool _rprint_enable_colors = true;
bool rprint_is_color_enabled() {
if (_env_rdisable_colors == -1) {
_env_rdisable_colors = getenv("RDISABLE_COLORS") != NULL;
}
if (_env_rdisable_colors) {
_rprint_enable_colors = false;
}
return _rprint_enable_colors;
}
void rprint_disable_colors() { _rprint_enable_colors = false; }
void rprint_enable_colors() { _rprint_enable_colors = true; }
void rprint_toggle_colors() { _rprint_enable_colors = !_rprint_enable_colors; }
void rclear() { printf("\033[2J"); }
void rprintpf(FILE *f, const char *prefix, const char *format, va_list args) {
char *pprefix = (char *)prefix;
char *pformat = (char *)format;
bool reset_color = false;
bool press_any_key = false;
char new_format[4096];
bool enable_color = rprint_is_color_enabled();
memset(new_format, 0, 4096);
int new_format_length = 0;
char temp[1000];
memset(temp, 0, 1000);
if (enable_color && pprefix[0]) {
strcat(new_format, pprefix);
new_format_length += strlen(pprefix);
reset_color = true;
}
while (true) {
if (pformat[0] == '\\' && pformat[1] == 'i') {
strcat(new_format, "\e[3m");
new_format_length += strlen("\e[3m");
reset_color = true;
pformat++;
pformat++;
} else if (pformat[0] == '\\' && pformat[1] == 'u') {
strcat(new_format, "\e[4m");
new_format_length += strlen("\e[4m");
reset_color = true;
pformat++;
pformat++;
} else if (pformat[0] == '\\' && pformat[1] == 'b') {
strcat(new_format, "\e[1m");
new_format_length += strlen("\e[1m");
reset_color = true;
pformat++;
pformat++;
} else if (pformat[0] == '\\' && pformat[1] == 'C') {
press_any_key = true;
rpline_number++;
pformat++;
pformat++;
reset_color = false;
} else if (pformat[0] == '\\' && pformat[1] == 'k') {
press_any_key = true;
rpline_number++;
pformat++;
pformat++;
} else if (pformat[0] == '\\' && pformat[1] == 'c') {
rpline_number++;
strcat(new_format, "\e[2J\e[H");
new_format_length += strlen("\e[2J\e[H");
pformat++;
pformat++;
} else if (pformat[0] == '\\' && pformat[1] == 'L') {
rpline_number++;
temp[0] = 0;
sprintf(temp, "%ld", rpline_number);
strcat(new_format, temp);
new_format_length += strlen(temp);
pformat++;
pformat++;
} else if (pformat[0] == '\\' && pformat[1] == 'l') {
rpline_number++;
temp[0] = 0;
sprintf(temp, "%.5ld", rpline_number);
strcat(new_format, temp);
new_format_length += strlen(temp);
pformat++;
pformat++;
} else if (pformat[0] == '\\' && pformat[1] == 'T') {
nsecs_t nsecs_now = nsecs();
nsecs_t end = rprtime ? nsecs_now - rprtime : 0;
temp[0] = 0;
sprintf(temp, "%s", format_time(end));
strcat(new_format, temp);
new_format_length += strlen(temp);
rprtime = nsecs_now;
pformat++;
pformat++;
} else if (pformat[0] == '\\' && pformat[1] == 't') {
rprtime = nsecs();
pformat++;
pformat++;
} else {
new_format[new_format_length] = *pformat;
new_format_length++;
if (!*pformat)
break;
// printf("%c",*pformat);
pformat++;
}
}
if (reset_color) {
strcat(new_format, "\e[0m");
new_format_length += strlen("\e[0m");
}
new_format[new_format_length] = 0;
vfprintf(f, new_format, args);
fflush(stdout);
if (press_any_key) {
nsecs_t s = nsecs();
fgetc(stdin);
rprtime += nsecs() - s;
}
}
void rprintp(const char *format, ...) {
va_list args;
va_start(args, format);
rprintpf(stdout, "", format, args);
va_end(args);
}
void rprintf(FILE *f, const char *format, ...) {
va_list args;
va_start(args, format);
rprintpf(f, "", format, args);
va_end(args);
}
void rprint(const char *format, ...) {
va_list args;
va_start(args, format);
rprintpf(stdout, "", format, args);
va_end(args);
}
#define printf rprint
// Print line
void rprintlf(FILE *f, const char *format, ...) {
va_list args;
va_start(args, format);
rprintpf(f, "\\l", format, args);
va_end(args);
}
void rprintl(const char *format, ...) {
va_list args;
va_start(args, format);
rprintpf(stdout, "\\l", format, args);
va_end(args);
}
// Black
void rprintkf(FILE *f, const char *format, ...) {
va_list args;
va_start(args, format);
rprintpf(f, "\e[30m", format, args);
va_end(args);
}
void rprintk(const char *format, ...) {
va_list args;
va_start(args, format);
rprintpf(stdout, "\e[30m", format, args);
va_end(args);
}
// Red
void rprintrf(FILE *f, const char *format, ...) {
va_list args;
va_start(args, format);
rprintpf(f, "\e[31m", format, args);
va_end(args);
}
void rprintr(const char *format, ...) {
va_list args;
va_start(args, format);
rprintpf(stdout, "\e[31m", format, args);
va_end(args);
}
// Green
void rprintgf(FILE *f, const char *format, ...) {
va_list args;
va_start(args, format);
rprintpf(f, "\e[32m", format, args);
va_end(args);
}
void rprintg(const char *format, ...) {
va_list args;
va_start(args, format);
rprintpf(stdout, "\e[32m", format, args);
va_end(args);
}
// Yellow
void rprintyf(FILE *f, const char *format, ...) {
va_list args;
va_start(args, format);
rprintpf(f, "\e[33m", format, args);
va_end(args);
}
void rprinty(const char *format, ...) {
va_list args;
va_start(args, format);
rprintpf(stdout, "\e[33m", format, args);
va_end(args);
}
// Blue
void rprintbf(FILE *f, const char *format, ...) {
va_list args;
va_start(args, format);
rprintpf(f, "\e[34m", format, args);
va_end(args);
}
void rprintb(const char *format, ...) {
va_list args;
va_start(args, format);
rprintpf(stdout, "\e[34m", format, args);
va_end(args);
}
// Magenta
void rprintmf(FILE *f, const char *format, ...) {
va_list args;
va_start(args, format);
rprintpf(f, "\e[35m", format, args);
va_end(args);
}
void rprintm(const char *format, ...) {
va_list args;
va_start(args, format);
rprintpf(stdout, "\e[35m", format, args);
va_end(args);
}
// Cyan
void rprintcf(FILE *f, const char *format, ...) {
va_list args;
va_start(args, format);
rprintpf(f, "\e[36m", format, args);
va_end(args);
}
void rprintc(const char *format, ...) {
va_list args;
va_start(args, format);
rprintpf(stdout, "\e[36m", format, args);
va_end(args);
}
// White
void rprintwf(FILE *f, const char *format, ...) {
va_list args;
va_start(args, format);
rprintpf(f, "\e[37m", format, args);
va_end(args);
}
void rprintw(const char *format, ...) {
va_list args;
va_start(args, format);
rprintpf(stdout, "\e[37m", format, args);
va_end(args);
}
#endif
#include <errno.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <time.h>
#ifndef RLIB_TERMINAL_H
#define RLIB_TERMINAL_H
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifndef RTEST_H
#define RTEST_H
#ifndef REMO_H
#define REMO_H
#include <ctype.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
typedef struct {
const char *str;
const char *description;
} remo_t;
remo_t remo[] = {
{"\U0001F600", "Grinning Face"}, // 😀
{"\U0001F601", "Beaming Face with Smiling Eyes"}, // 😁
{"\U0001F602", "Face with Tears of Joy"}, // 😂
{"\U0001F923", "Rolling on the Floor Laughing"}, // 🤣
{"\U0001F603", "Grinning Face with Big Eyes"}, // 😃
{"\U0001F604", "Grinning Face with Smiling Eyes"}, // 😄
{"\U0001F609", "Winking Face"}, // 😉
{"\U0001F60A", "Smiling Face with Smiling Eyes"}, // 😊
{"\U0001F60D", "Smiling Face with Heart-Eyes"}, // 😍
{"\U0001F618", "Face Blowing a Kiss"}, // 😘
{"\U0001F617", "Kissing Face"}, // 😗
{"\U0001F61A", "Kissing Face with Closed Eyes"}, // 😚
{"\U0001F642", "Slightly Smiling Face"}, // 🙂
{"\U0001F643", "Upside-Down Face"}, // 🙃
{"\U0001F970", "Smiling Face with Hearts"}, // 🥰
{"\U0001F60B", "Face Savoring Food"}, // 😋
{"\U0001F61B", "Face with Tongue"}, // 😛
{"\U0001F61C", "Winking Face with Tongue"}, // 😜
{"\U0001F92A", "Zany Face"}, // 🤪
{"\U0001F929", "Star-Struck"}, // 🤩
{"\U0001F631", "Face Screaming in Fear"}, // 😱
{"\U0001F62D", "Loudly Crying Face"}, // 😭
{"\U0001F624", "Face with Steam From Nose"}, // 😤
{"\U0001F620", "Angry Face"}, // 😠
{"\U0001F621", "Pouting Face"}, // 😡
{"\U0001F47B", "Ghost"}, // 👻
{"\U0001F480", "Skull"}, // 💀
{"\U0001F4A9", "Pile of Poo"}, // 💩
{"\U0001F47D", "Alien"}, // 👽
// Geometric Shapes
{"\U000025A0", "Black Square"}, // ■
{"\U000025B2", "Upward Triangle"}, // ▲
{"\U000025CF", "Black Circle"}, // ●
{"\U000025CB", "White Circle"}, // ○
{"\U00002B1B", "Large Black Square"}, // ⬛
{"\U00002B1C", "Large White Square"}, // ⬜
// Mathematical Symbols
{"\U00002200", "For All"}, // ∀
{"\U00002203", "Exists"}, // ∃
{"\U00002205", "Empty Set"}, // ∅
{"\U00002207", "Nabla"}, // ∇
{"\U0000220F", "N-Ary Product"}, // ∏
{"\U00002212", "Minus Sign"}, // −
{"\U0000221E", "Infinity"}, // ∞
// Arrows
{"\U00002190", "Left Arrow"}, // ←
{"\U00002191", "Up Arrow"}, // ↑
{"\U00002192", "Right Arrow"}, // →
{"\U00002193", "Down Arrow"}, // ↓
{"\U00002195", "Up Down Arrow"}, // ↕
{"\U00002197", "Up Right Arrow"}, // ↗
{"\U00002198", "Down Right Arrow"}, // ↘
{"\U000027A1", "Black Right Arrow"}, // ➡️
// Dingbats
{"\U00002714", "Check Mark"}, // ✔️
{"\U00002716", "Heavy Multiplication X"}, // ✖️
{"\U00002728", "Sparkles"}, // ✨
{"\U00002757", "Exclamation Mark"}, // ❗
{"\U0000274C", "Cross Mark"}, // ❌
{"\U00002795", "Heavy Plus Sign"}, // ➕
// Miscellaneous Symbols
{"\U00002600", "Sun"}, // ☀️
{"\U00002614", "Umbrella with Rain Drops"}, // ☔
{"\U00002620", "Skull and Crossbones"}, // ☠️
{"\U000026A0", "Warning Sign"}, // ⚠️
{"\U000026BD", "Soccer Ball"}, // ⚽
{"\U000026C4", "Snowman"}, // ⛄
// Stars and Asterisks
{"\U00002733", "Eight Pointed Black Star"}, // ✳️
{"\U00002734", "Eight Spoked Asterisk"}, // ✴️
{"\U00002B50", "White Star"}, // ⭐
{"\U0001F31F", "Glowing Star"}, // 🌟
{"\U00002728", "Sparkles"}, // ✨
// Animals and Nature
{"\U0001F98A", "Fox"}, // 🦊
{"\U0001F415", "Dog"}, // 🐕
{"\U0001F431", "Cat Face"}, // 🐱
{"\U0001F435", "Monkey Face"}, // 🐵
{"\U0001F408", "Black Cat"}, // 🐈
{"\U0001F98C", "Deer"}, // 🦌
{"\U0001F344", "Mushroom"}, // 🍄
{"\U0001F333", "Tree"}, // 🌳
// Weather and Space Symbols
{"\U0001F308", "Rainbow"}, // 🌈
{"\U0001F320", "Shooting Star"}, // 🌠
{"\U00002600", "Sun"}, // ☀️
{"\U00002601", "Cloud"}, // ☁️
{"\U000026A1", "High Voltage"}, // ⚡
{"\U0001F525", "Fire"}, // 🔥
{"\U000026C4", "Snowman"}, // ⛄
{"\U0001F30A", "Water Wave"}, // 🌊
// Transport and Map Symbols
{"\U0001F68C", "Bus"}, // 🚌
{"\U0001F697", "Car"}, // 🚗
{"\U0001F6B2", "Bicycle"}, // 🚲
{"\U0001F6A2", "Ship"}, // 🚢
{"\U0001F681", "Helicopter"}, // 🚁
{"\U0001F680", "Rocket"}, // 🚀
{"\U0001F6EB", "Airplane"}, // 🛫
// Currency Symbols
{"\U00000024", "Dollar Sign"}, // $
{"\U000000A3", "Pound Sign"}, // £
{"\U000000A5", "Yen Sign"}, // ¥
{"\U000020AC", "Euro Sign"}, // €
{"\U0001F4B5", "Dollar Banknote"}, // 💵
{"\U0001F4B4", "Yen Banknote"}, // 💴
// Card Suits
{"\U00002660", "Black Spade Suit"}, // ♠️
{"\U00002663", "Black Club Suit"}, // ♣️
{"\U00002665", "Black Heart Suit"}, // ♥️
{"\U00002666", "Black Diamond Suit"}, // ♦️
{"\U0001F0CF", "Joker Card"}, // 🃏
// Office Supplies and Objects
{"\U0001F4DA", "Books"}, // 📚
{"\U0001F4D7", "Green Book"}, // 📗
{"\U0001F4C8", "Chart with Upwards Trend"}, // 📈
{"\U0001F4C9", "Chart with Downwards Trend"}, // 📉
{"\U0001F4B0", "Money Bag"}, // 💰
{"\U0001F4B8", "Money with Wings"}, // 💸
{"\U0001F4E6", "Package"}, // 📦
// Miscellaneous Symbols
{"\U00002757", "Exclamation Mark"}, // ❗
{"\U00002714", "Check Mark"}, // ✔️
{"\U0000274C", "Cross Mark"}, // ❌
{"\U00002705", "Check Mark Button"}, // ✅
{"\U00002B50", "White Star"}, // ⭐
{"\U0001F31F", "Glowing Star"}, // 🌟
{"\U0001F4A1", "Light Bulb"}, // 💡
{"\U0001F4A3", "Bomb"}, // 💣
{"\U0001F4A9", "Pile of Poo"}, // 💩
// Musical Symbols
{"\U0001F3B5", "Musical Note"}, // 🎵
{"\U0001F3B6", "Multiple Musical Notes"}, // 🎶
{"\U0001F3BC", "Musical Score"}, // 🎼
{"\U0001F399", "Studio Microphone"}, // 🎙️
{"\U0001F3A4", "Microphone"}, // 🎤
// Food and Drink
{"\U0001F35F", "Cheese Wedge"}, // 🧀
{"\U0001F355", "Slice of Pizza"}, // 🍕
{"\U0001F32D", "Taco"}, // 🌮
{"\U0001F37D", "Beer Mug"}, // 🍻
{"\U0001F96B", "Cup with Straw"}, // 🥤
{"\U0001F32E", "Hot Pepper"}, // 🌶️
{"\U0001F95A", "Potato"}, // 🥔
// Zodiac Signs
{"\U00002600", "Aries"}, // ♈
{"\U00002601", "Taurus"}, // ♉
{"\U00002602", "Gemini"}, // ♊
{"\U00002603", "Cancer"}, // ♋
{"\U00002604", "Leo"}, // ♌
{"\U00002605", "Virgo"}, // ♍
{"\U00002606", "Libra"}, // ♎
{"\U00002607", "Scorpio"}, // ♏
{"\U00002608", "Sagittarius"}, // ♐
{"\U00002609", "Capricorn"}, // ♑
{"\U0000260A", "Aquarius"}, // ♒
{"\U0000260B", "Pisces"}, // ♓
// Miscellaneous Shapes
{"\U0001F4C8", "Chart Increasing"}, // 📈
{"\U0001F4C9", "Chart Decreasing"}, // 📉
{"\U0001F4CA", "Bar Chart"}, // 📊
{"\U0001F7E6", "Orange Circle"}, // 🟠
{"\U0001F7E7", "Yellow Circle"}, // 🟡
{"\U0001F7E8", "Green Circle"}, // 🟢
{"\U0001F7E9", "Blue Circle"}, // 🔵
{"\U0001F7EA", "Purple Circle"}, // 🟣
// Flags
{"\U0001F1E6\U0001F1E9", "Flag of France"}, // 🇫🇷
{"\U0001F1E8\U0001F1E6", "Flag of Germany"}, // 🇩🇪
{"\U0001F1FA\U0001F1F8", "Flag of United States"}, // 🇺🇸
{"\U0001F1E7\U0001F1F7", "Flag of Canada"}, // 🇨🇦
{"\U0001F1EE\U0001F1F2", "Flag of Italy"}, // 🇮🇹
{"\U0001F1F8\U0001F1EC", "Flag of Australia"}, // 🇦🇺
{"\U0001F1F3\U0001F1F4", "Flag of Spain"}, // 🇪🇸
// Additional Miscellaneous Symbols
{"\U0001F4A5", "Collision"}, // 💥
{"\U0001F4A6", "Sweat Droplets"}, // 💦
{"\U0001F4A8", "Dashing Away"}, // 💨
{"\U0001F50B", "Battery"}, // 🔋
{"\U0001F4BB", "Laptop Computer"}, // 💻
{"\U0001F4DE", "Telephone"}, // 📞
{"\U0001F4E7", "Incoming Envelope"}, // 📧
};
size_t remo_count = sizeof(remo) / sizeof(remo[0]);
void rstrtolower(const char *input, char *output) {
while (*input) {
*output = tolower(*input);
input++;
output++;
}
*output = 0;
}
bool rstrinstr(const char *haystack, const char *needle) {
char lower1[strlen(haystack) + 1];
char lower2[strlen(needle) + 1];
rstrtolower(haystack, lower1);
rstrtolower(needle, lower2);
return strstr(lower1, lower2) ? true : false;
}
void remo_print() {
for (size_t i = 0; i < remo_count; i++) {
printf("%s - %s\n", remo[i].str, remo[i].description);
}
}
const char *remo_get(char *name) {
for (size_t i = 0; i < remo_count; i++) {
if (rstrinstr(remo[i].description, name)) {
return remo[i].str;
}
}
return NULL;
}
#endif
#include <stdbool.h>
#include <stdio.h>
#include <unistd.h>
#define debug(fmt, ...) printf("%s:%d: " fmt, __FILE__, __LINE__, __VA_ARGS__);
char *rcurrent_banner;
int rassert_count = 0;
unsigned short rtest_is_first = 1;
unsigned int rtest_fail_count = 0;
int rtest_end(char *content) {
// Returns application exit code. 0 == success
printf("%s", content);
printf("\n@assertions: %d\n", rassert_count);
printf("@memory: %s%s\n", rmalloc_stats(), rmalloc_count == 0 ? remo_get("rainbow") : "fire");
if (rmalloc_count != 0) {
printf("MEMORY ERROR %s\n", remo_get("cross mark"));
return rtest_fail_count > 0;
}
return rtest_fail_count > 0;
}
void rtest_test_banner(char *content, char *file) {
if (rtest_is_first == 1) {
char delimiter[] = ".";
char *d = delimiter;
char f[2048];
strcpy(f, file);
printf("%s tests", strtok(f, d));
rtest_is_first = 0;
setvbuf(stdout, NULL, _IONBF, 0);
}
printf("\n - %s ", content);
}
bool rtest_test_true_silent(char *expr, int res, int line) {
rassert_count++;
if (res) {
return true;
}
rprintrf(stderr, "\nERROR on line %d: %s", line, expr);
rtest_fail_count++;
return false;
}
bool rtest_test_true(char *expr, int res, int line) {
rassert_count++;
if (res) {
fprintf(stdout, "%s", remo_get("Slightly Smiling Face"));
return true;
}
rprintrf(stderr, "\nERROR %s on line %d: %s\n", remo_get("skull"), line, expr);
rtest_fail_count++;
return false;
}
bool rtest_test_false_silent(char *expr, int res, int line) { return rtest_test_true_silent(expr, !res, line); }
bool rtest_test_false(char *expr, int res, int line) { return rtest_test_true(expr, !res, line); }
void rtest_test_skip(char *expr, int line) { rprintgf(stderr, "\n @skip(%s) on line %d\n", expr, line); }
void rtest_test_assert(char *expr, int res, int line) {
if (rtest_test_true(expr, res, line)) {
return;
}
rtest_end("");
exit(40);
}
#define rtest_banner(content) \
rcurrent_banner = content; \
rtest_test_banner(content, __FILE__);
#define rtest_true(expr) rtest_test_true(#expr, expr, __LINE__);
#define rtest_assert(expr) \
{ \
int __valid = expr ? 1 : 0; \
rtest_test_true(#expr, __valid, __LINE__); \
}; \
;
#define rassert(expr) \
{ \
int __valid = expr ? 1 : 0; \
rtest_test_true(#expr, __valid, __LINE__); \
}; \
;
#define rtest_asserts(expr) \
{ \
int __valid = expr ? 1 : 0; \
rtest_test_true_silent(#expr, __valid, __LINE__); \
};
#define rasserts(expr) \
{ \
int __valid = expr ? 1 : 0; \
rtest_test_true_silent(#expr, __valid, __LINE__); \
};
#define rtest_false(expr) \
rprintf(" [%s]\t%s\t\n", expr == 0 ? "OK" : "NOK", #expr); \
assert_count++; \
assert(#expr);
#define rtest_skip(expr) rtest_test_skip(#expr, __LINE__);
FILE *rtest_create_file(char *path, char *content) {
FILE *fd = fopen(path, "wb");
char c;
int index = 0;
while ((c = content[index]) != 0) {
fputc(c, fd);
index++;
}
fclose(fd);
fd = fopen(path, "rb");
return fd;
}
void rtest_delete_file(char *path) { unlink(path); }
#endif
char *rfcaptured = NULL;
void rfcapture(FILE *f, char *buff, size_t size) {
rfcaptured = buff;
setvbuf(f, rfcaptured, _IOFBF, size);
}
void rfstopcapture(FILE *f) { setvbuf(f, 0, _IOFBF, 0); }
bool _r_disable_stdout_toggle = false;
FILE *_r_original_stdout = NULL;
bool rr_enable_stdout() {
if (_r_disable_stdout_toggle)
return false;
if (!_r_original_stdout) {
stdout = fopen("/dev/null", "rb");
return false;
}
if (_r_original_stdout && _r_original_stdout != stdout) {
fclose(stdout);
}
stdout = _r_original_stdout;
return true;
}
bool rr_disable_stdout() {
if (_r_disable_stdout_toggle) {
return false;
}
if (_r_original_stdout == NULL) {
_r_original_stdout = stdout;
}
if (stdout == _r_original_stdout) {
stdout = fopen("/dev/null", "rb");
return true;
}
return false;
}
bool rr_toggle_stdout() {
if (!_r_original_stdout) {
rr_disable_stdout();
return true;
} else if (stdout != _r_original_stdout) {
rr_enable_stdout();
return true;
} else {
rr_disable_stdout();
return true;
}
}
typedef struct rprogressbar_t {
unsigned long current_value;
unsigned long min_value;
unsigned long max_value;
unsigned int length;
bool changed;
double percentage;
unsigned int width;
unsigned long draws;
FILE *fout;
} rprogressbar_t;
rprogressbar_t *rprogressbar_new(long min_value, long max_value, unsigned int width, FILE *fout) {
rprogressbar_t *pbar = (rprogressbar_t *)malloc(sizeof(rprogressbar_t));
pbar->min_value = min_value;
pbar->max_value = max_value;
pbar->current_value = min_value;
pbar->width = width;
pbar->draws = 0;
pbar->length = 0;
pbar->changed = false;
pbar->fout = fout ? fout : stdout;
return pbar;
}
void rprogressbar_free(rprogressbar_t *pbar) { free(pbar); }
void rprogressbar_draw(rprogressbar_t *pbar) {
if (!pbar->changed) {
return;
} else {
pbar->changed = false;
}
pbar->draws++;
char draws_text[22];
draws_text[0] = 0;
sprintf(draws_text, "%ld", pbar->draws);
char *draws_textp = draws_text;
// bool draws_text_len = strlen(draws_text);
char bar_begin_char = ' ';
char bar_progress_char = ' ';
char bar_empty_char = ' ';
char bar_end_char = ' ';
char content[4096] = {0};
char bar_content[1024];
char buff[2048] = {0};
bar_content[0] = '\r';
bar_content[1] = bar_begin_char;
unsigned int index = 2;
for (unsigned long i = 0; i < pbar->length; i++) {
if (*draws_textp) {
bar_content[index] = *draws_textp;
draws_textp++;
} else {
bar_content[index] = bar_progress_char;
}
index++;
}
char infix[] = "\033[0m";
for (unsigned long i = 0; i < strlen(infix); i++) {
bar_content[index] = infix[i];
index++;
}
for (unsigned long i = 0; i < pbar->width - pbar->length; i++) {
bar_content[index] = bar_empty_char;
index++;
}
bar_content[index] = bar_end_char;
bar_content[index + 1] = '\0';
sprintf(buff, "\033[43m%s\033[0m \033[33m%.2f%%\033[0m ", bar_content, pbar->percentage * 100);
strcat(content, buff);
if (pbar->width == pbar->length) {
strcat(content, "\r");
for (unsigned long i = 0; i < pbar->width + 10; i++) {
strcat(content, " ");
}
strcat(content, "\r");
}
fprintf(pbar->fout, "%s", content);
fflush(pbar->fout);
}
bool rprogressbar_update(rprogressbar_t *pbar, unsigned long value) {
if (value == pbar->current_value) {
return false;
}
pbar->current_value = value;
pbar->percentage = (double)pbar->current_value / (double)(pbar->max_value - pbar->min_value);
unsigned long new_length = (unsigned long)(pbar->percentage * pbar->width);
pbar->changed = new_length != pbar->length;
if (pbar->changed) {
pbar->length = new_length;
rprogressbar_draw(pbar);
return true;
}
return false;
}
size_t rreadline(char *data, size_t len, bool strip_ln) {
__attribute__((unused)) char *unused = fgets(data, len, stdin);
size_t length = strlen(data);
if (length && strip_ln)
data[length - 1] = 0;
return length;
}
void rlib_test_progressbar() {
rtest_banner("Progress bar");
rprogressbar_t *pbar = rprogressbar_new(0, 1000, 10, stderr);
rprogressbar_draw(pbar);
// No draws executed, nothing to show
rassert(pbar->draws == 0);
rprogressbar_update(pbar, 500);
rassert(pbar->percentage == 0.5);
rprogressbar_update(pbar, 500);
rprogressbar_update(pbar, 501);
rprogressbar_update(pbar, 502);
// Should only have drawn one time since value did change, but percentage
// did not
rassert(pbar->draws == 1);
// Changed is false because update function calls draw
rassert(pbar->changed == false);
rprogressbar_update(pbar, 777);
rassert(pbar->percentage == 0.777);
rprogressbar_update(pbar, 1000);
rassert(pbar->percentage == 1);
}
#endif
#define RBENCH(times, action) \
{ \
unsigned long utimes = (unsigned long)times; \
nsecs_t start = nsecs(); \
for (unsigned long i = 0; i < utimes; i++) { \
{ \
action; \
} \
} \
nsecs_t end = nsecs(); \
printf("%s\n", format_time(end - start)); \
}
#define RBENCHP(times, action) \
{ \
printf("\n"); \
nsecs_t start = nsecs(); \
unsigned int prev_percentage = 0; \
unsigned long utimes = (unsigned long)times; \
for (unsigned long i = 0; i < utimes; i++) { \
unsigned int percentage = ((long double)i / (long double)times) * 100; \
int percentage_changed = percentage != prev_percentage; \
__attribute__((unused)) int first = i == 0; \
__attribute__((unused)) int last = i == utimes - 1; \
{ action; }; \
if (percentage_changed) { \
printf("\r%d%%", percentage); \
fflush(stdout); \
\
prev_percentage = percentage; \
} \
} \
nsecs_t end = nsecs(); \
printf("\r%s\n", format_time(end - start)); \
}
struct rbench_t;
typedef struct rbench_function_t {
#ifdef __cplusplus
void (*call)();
#else
void(*call);
#endif
char name[256];
char group[256];
void *arg;
void *data;
bool first;
bool last;
int argc;
unsigned long times_executed;
nsecs_t average_execution_time;
nsecs_t total_execution_time;
} rbench_function_t;
typedef struct rbench_t {
unsigned int function_count;
rbench_function_t functions[100];
rbench_function_t *current;
rprogressbar_t *progress_bar;
bool show_progress;
int winner;
bool stdout;
unsigned long times;
bool silent;
nsecs_t execution_time;
#ifdef __cplusplus
void (*add_function)(struct rbench_t *r, const char *name, const char *group, void (*)());
#else
void (*add_function)(struct rbench_t *r, const char *name, const char *group, void *);
#endif
void (*rbench_reset)(struct rbench_t *r);
struct rbench_t *(*execute)(struct rbench_t *r, long times);
struct rbench_t *(*execute1)(struct rbench_t *r, long times, void *arg1);
struct rbench_t *(*execute2)(struct rbench_t *r, long times, void *arg1, void *arg2);
struct rbench_t *(*execute3)(struct rbench_t *r, long times, void *arg1, void *arg2, void *arg3);
} rbench_t;
FILE *_rbench_stdout = NULL;
FILE *_rbench_stdnull = NULL;
void rbench_toggle_stdout(rbench_t *r) {
if (!r->stdout) {
if (_rbench_stdout == NULL) {
_rbench_stdout = stdout;
}
if (_rbench_stdnull == NULL) {
_rbench_stdnull = fopen("/dev/null", "wb");
}
if (stdout == _rbench_stdout) {
stdout = _rbench_stdnull;
} else {
stdout = _rbench_stdout;
}
}
}
void rbench_restore_stdout(rbench_t *r) {
if (r->stdout)
return;
if (_rbench_stdout) {
stdout = _rbench_stdout;
}
if (_rbench_stdnull) {
fclose(_rbench_stdnull);
_rbench_stdnull = NULL;
}
}
rbench_t *rbench_new();
rbench_t *_rbench = NULL;
rbench_function_t *rbf;
rbench_t *rbench() {
if (_rbench == NULL) {
_rbench = rbench_new();
}
return _rbench;
}
typedef void *(*rbench_call)();
typedef void *(*rbench_call1)(void *);
typedef void *(*rbench_call2)(void *, void *);
typedef void *(*rbench_call3)(void *, void *, void *);
#ifdef __cplusplus
void rbench_add_function(rbench_t *rp, const char *name, const char *group, void (*call)()) {
#else
void rbench_add_function(rbench_t *rp, const char *name, const char *group, void *call) {
#endif
rbench_function_t *f = &rp->functions[rp->function_count];
rp->function_count++;
f->average_execution_time = 0;
f->total_execution_time = 0;
f->times_executed = 0;
f->call = call;
strcpy(f->name, name);
strcpy(f->group, group);
}
void rbench_reset_function(rbench_function_t *f) {
f->average_execution_time = 0;
f->times_executed = 0;
f->total_execution_time = 0;
}
void rbench_reset(rbench_t *rp) {
for (unsigned int i = 0; i < rp->function_count; i++) {
rbench_reset_function(&rp->functions[i]);
}
}
int rbench_get_winner_index(rbench_t *r) {
int winner = 0;
nsecs_t time = 0;
for (unsigned int i = 0; i < r->function_count; i++) {
if (time == 0 || r->functions[i].total_execution_time < time) {
winner = i;
time = r->functions[i].total_execution_time;
}
}
return winner;
}
bool rbench_was_last_function(rbench_t *r) {
for (unsigned int i = 0; i < r->function_count; i++) {
if (i == r->function_count - 1 && r->current == &r->functions[i])
return true;
}
return false;
}
rbench_function_t *rbench_execute_prepare(rbench_t *r, int findex, long times, int argc) {
rbench_toggle_stdout(r);
if (findex == 0) {
r->execution_time = 0;
}
rbench_function_t *rf = &r->functions[findex];
rf->argc = argc;
rbf = rf;
r->current = rf;
if (r->show_progress)
r->progress_bar = rprogressbar_new(0, times, 20, stderr);
r->times = times;
// printf(" %s:%s gets executed for %ld times with %d
// arguments.\n",rf->group, rf->name, times,argc);
rbench_reset_function(rf);
return rf;
}
void rbench_execute_finish(rbench_t *r) {
rbench_toggle_stdout(r);
if (r->progress_bar) {
free(r->progress_bar);
r->progress_bar = NULL;
}
r->current->average_execution_time = r->current->total_execution_time / r->current->times_executed;
;
// printf(" %s:%s finished executing in
// %s\n",r->current->group,r->current->name,
// format_time(r->current->total_execution_time));
// rbench_show_results_function(r->current);
if (rbench_was_last_function(r)) {
rbench_restore_stdout(r);
unsigned int winner_index = rbench_get_winner_index(r);
r->winner = winner_index + 1;
if (!r->silent)
rprintgf(stderr, "Benchmark results:\n");
nsecs_t total_time = 0;
for (unsigned int i = 0; i < r->function_count; i++) {
rbf = &r->functions[i];
total_time += rbf->total_execution_time;
bool is_winner = winner_index == i;
if (is_winner) {
if (!r->silent)
rprintyf(stderr, " > %s:%s:%s\n", format_time(rbf->total_execution_time), rbf->group, rbf->name);
} else {
if (!r->silent)
rprintbf(stderr, " %s:%s:%s\n", format_time(rbf->total_execution_time), rbf->group, rbf->name);
}
}
if (!r->silent)
rprintgf(stderr, "Total execution time: %s\n", format_time(total_time));
}
rbench_restore_stdout(r);
rbf = NULL;
r->current = NULL;
}
struct rbench_t *rbench_execute(rbench_t *r, long times) {
for (unsigned int i = 0; i < r->function_count; i++) {
rbench_function_t *f = rbench_execute_prepare(r, i, times, 0);
rbench_call c = (rbench_call)f->call;
nsecs_t start = nsecs();
f->first = true;
c();
f->first = false;
f->last = false;
f->times_executed++;
for (int j = 1; j < times; j++) {
c();
f->times_executed++;
f->last = f->times_executed == r->times - 1;
if (r->progress_bar) {
rprogressbar_update(r->progress_bar, f->times_executed);
}
}
f->total_execution_time = nsecs() - start;
r->execution_time += f->total_execution_time;
rbench_execute_finish(r);
}
return r;
}
struct rbench_t *rbench_execute1(rbench_t *r, long times, void *arg1) {
for (unsigned int i = 0; i < r->function_count; i++) {
rbench_function_t *f = rbench_execute_prepare(r, i, times, 1);
rbench_call1 c = (rbench_call1)f->call;
nsecs_t start = nsecs();
f->first = true;
c(arg1);
f->first = false;
f->last = false;
f->times_executed++;
for (int j = 1; j < times; j++) {
c(arg1);
f->times_executed++;
f->last = f->times_executed == r->times - 1;
if (r->progress_bar) {
rprogressbar_update(r->progress_bar, f->times_executed);
}
}
f->total_execution_time = nsecs() - start;
r->execution_time += f->total_execution_time;
rbench_execute_finish(r);
}
return r;
}
struct rbench_t *rbench_execute2(rbench_t *r, long times, void *arg1, void *arg2) {
for (unsigned int i = 0; i < r->function_count; i++) {
rbench_function_t *f = rbench_execute_prepare(r, i, times, 2);
rbench_call2 c = (rbench_call2)f->call;
nsecs_t start = nsecs();
f->first = true;
c(arg1, arg2);
f->first = false;
f->last = false;
f->times_executed++;
for (int j = 1; j < times; j++) {
c(arg1, arg2);
f->times_executed++;
f->last = f->times_executed == r->times - 1;
if (r->progress_bar) {
rprogressbar_update(r->progress_bar, f->times_executed);
}
}
f->total_execution_time = nsecs() - start;
r->execution_time += f->total_execution_time;
rbench_execute_finish(r);
}
return r;
}
struct rbench_t *rbench_execute3(rbench_t *r, long times, void *arg1, void *arg2, void *arg3) {
for (unsigned int i = 0; i < r->function_count; i++) {
rbench_function_t *f = rbench_execute_prepare(r, i, times, 3);
rbench_call3 c = (rbench_call3)f->call;
nsecs_t start = nsecs();
f->first = true;
c(arg1, arg2, arg3);
f->first = false;
f->last = false;
f->times_executed++;
for (int j = 1; j < times; j++) {
c(arg1, arg2, arg3);
f->times_executed++;
f->last = f->times_executed == r->times - 1;
if (r->progress_bar) {
rprogressbar_update(r->progress_bar, f->times_executed);
}
}
f->total_execution_time = nsecs() - start;
rbench_execute_finish(r);
}
return r;
}
rbench_t *rbench_new() {
rbench_t *r = (rbench_t *)malloc(sizeof(rbench_t));
memset(r, 0, sizeof(rbench_t));
r->add_function = rbench_add_function;
r->rbench_reset = rbench_reset;
r->execute1 = rbench_execute1;
r->execute2 = rbench_execute2;
r->execute3 = rbench_execute3;
r->execute = rbench_execute;
r->stdout = true;
r->silent = false;
r->winner = 0;
r->show_progress = true;
return r;
}
void rbench_free(rbench_t *r) { free(r); }
#endif
bool check_lcov() {
char buffer[1024 * 64];
FILE *fp;
fp = popen("lcov --help", "r");
if (fp == NULL) {
return false;
}
if (fgets(buffer, sizeof(buffer), fp) == NULL) {
return false;
}
pclose(fp);
return strstr(buffer, "lcov: not found") ? false : true;
}
int rcov_main(int argc, char *argv[]) {
if (argc < 2) {
printf("Usage: [source.c]\n");
return 1;
}
char argstr[4096] = {0};
for (int i = 2; i < argc; i++) {
strcat(argstr, argv[i]);
strcat(argstr, " ");
}
if (!check_lcov()) {
printf("lcov is not installed. Please execute `sudo apt install lcov`.\n");
return 1;
}
char *source_file = argv[1];
char *commands[] = {"rm -f *.gcda 2>/dev/null",
"rm -f *.gcno 2>/dev/null",
"rm -f %s.coverage.info 2>/dev/null",
"gcc -pg -fprofile-arcs -ftest-coverage -g -o %s_coverage.o %s",
"./%s_coverage.o",
"lcov --capture --directory . --output-file %s.coverage.info",
"genhtml %s.coverage.info --output-directory /tmp/%s.coverage",
"rm -f *.gcda 2>/dev/null",
"rm -f *.gcno 2>/dev/null",
"rm -f %s.coverage.info 2>/dev/null", //"cat gmon.out",
"gprof %s_coverage.o gmon.out > output.rcov_analysis",
"rm -f gmon.out",
"cat output.rcov_analysis",
"rm output.rcov_analysis",
"rm -f %s_coverage.o",
"google-chrome /tmp/%s.coverage/index.html"};
uint command_count = sizeof(commands) / sizeof(commands[0]);
RBENCH(1,{
for (uint i = 0; i < command_count; i++) {
char *formatted_command = sbuf("");
sprintf(formatted_command, commands[i], source_file, source_file);
// printf("%s\n", formatted_command);
if (formatted_command[0] == '.' && formatted_command[1] == '/') {
strcat(formatted_command, " ");
strcat(formatted_command, argstr);
}
if (system(formatted_command)) {
printf("`%s` returned non-zero code.\n", formatted_command);
}
});
}
return 0;
}
#endif
#ifndef RHTTP_H
#define RHTTP_H
#include <arpa/inet.h>
#include <pthread.h>
#include <signal.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#define BUFF_SIZE 8096
#define RHTTP_MAX_CONNECTIONS 100
int rhttp_opt_error = 1;
int rhttp_opt_warn = 1;
int rhttp_opt_info = 1;
int rhttp_opt_port = 8080;
int rhttp_opt_debug = 0;
int rhttp_opt_request_logging = 0;
int rhttp_sock = 0;
int rhttp_opt_buffered = 0;
int rhttp_c = 0;
int rhttp_c_mutex_initialized = 0;
pthread_mutex_t rhttp_c_mutex;
char rhttp_opt_host[1024] = "0.0.0.0";
unsigned int rhttp_connections_handled = 0;
typedef struct rhttp_header_t {
char *name;
char *value;
struct rhttp_header_t *next;
} rhttp_header_t;
typedef struct rhttp_request_t {
int c;
int closed;
bool keep_alive;
nsecs_t start;
char *raw;
char *line;
char *body;
char *method;
char *path;
char *version;
void *context;
unsigned int bytes_received;
rhttp_header_t *headers;
} rhttp_request_t;
char *rhttp_current_timestamp() {
time_t current_time;
time(&current_time);
struct tm *local_time = localtime(&current_time);
static char time_string[100];
time_string[0] = 0;
strftime(time_string, sizeof(time_string), "%Y-%m-%d %H:%M:%S", local_time);
return time_string;
}
void rhttp_logs(const char *prefix, const char *level, const char *format, va_list args) {
char buf[strlen(format) + BUFSIZ + 1];
buf[0] = 0;
sprintf(buf, "%s%s %s %s\e[0m", prefix, rhttp_current_timestamp(), level, format);
vfprintf(stdout, buf, args);
}
void rhttp_log_info(const char *format, ...) {
if (!rhttp_opt_info)
return;
va_list args;
va_start(args, format);
rhttp_logs("\e[32m", "INFO ", format, args);
va_end(args);
}
void rhttp_log_debug(const char *format, ...) {
if (!rhttp_opt_debug)
return;
va_list args;
va_start(args, format);
if (rhttp_opt_debug)
rhttp_logs("\e[33m", "DEBUG", format, args);
va_end(args);
}
void rhttp_log_warn(const char *format, ...) {
if (!rhttp_opt_warn)
return;
va_list args;
va_start(args, format);
rhttp_logs("\e[34m", "WARN ", format, args);
va_end(args);
}
void rhttp_log_error(const char *format, ...) {
if (!rhttp_opt_error)
return;
va_list args;
va_start(args, format);
rhttp_logs("\e[35m", "ERROR", format, args);
va_end(args);
}
void http_request_init(rhttp_request_t *r) {
r->raw = NULL;
r->line = NULL;
r->body = NULL;
r->method = NULL;
r->path = NULL;
r->version = NULL;
r->start = 0;
r->headers = NULL;
r->bytes_received = 0;
r->closed = 0;
}
void rhttp_free_header(rhttp_header_t *h) {
if (!h)
return;
rhttp_header_t *next = h->next;
free(h->name);
free(h->value);
free(h);
if (next)
rhttp_free_header(next);
}
void rhttp_rhttp_free_headers(rhttp_request_t *r) {
if (!r->headers)
return;
rhttp_free_header(r->headers);
r->headers = NULL;
}
rhttp_header_t *rhttp_parse_headers(rhttp_request_t *s) {
int first = 1;
char *body = strdup(s->body);
char *body_original = body;
while (body && *body) {
char *line = __strtok_r(first ? body : NULL, "\r\n", &body);
if (!line)
break;
rhttp_header_t *h = (rhttp_header_t *)malloc(sizeof(rhttp_header_t));
h->name = NULL;
h->value = NULL;
h->next = NULL;
char *name = __strtok_r(line, ": ", &line);
first = 0;
if (!name) {
rhttp_free_header(h);
break;
}
h->name = strdup(name);
char *value = __strtok_r(NULL, "\r\n", &line);
if (!value) {
rhttp_free_header(h);
break;
}
h->value = value ? strdup(value + 1) : strdup("");
h->next = s->headers;
s->headers = h;
}
free(body_original);
return s->headers;
}
void rhttp_free_request(rhttp_request_t *r) {
if (r->raw) {
free(r->raw);
free(r->body);
free(r->method);
free(r->path);
free(r->version);
rhttp_rhttp_free_headers(r);
}
free(r);
}
long rhttp_header_get_long(rhttp_request_t *r, const char *name) {
rhttp_header_t *h = r->headers;
while (h) {
if (!strcmp(h->name, name))
return strtol(h->value, NULL, 10);
h = h->next;
}
return -1;
}
char *rhttp_header_get_string(rhttp_request_t *r, const char *name) {
rhttp_header_t *h = r->headers;
while (h) {
if (!strcmp(h->name, name))
return h->value && *h->value ? h->value : NULL;
h = h->next;
}
return NULL;
}
void rhttp_print_header(rhttp_header_t *h) { rhttp_log_debug("Header: <%s> \"%s\"\n", h->name, h->value); }
void rhttp_print_headers(rhttp_header_t *h) {
while (h) {
rhttp_print_header(h);
h = h->next;
}
}
void rhttp_print_request_line(rhttp_request_t *r) { rhttp_log_info("%s %s %s\n", r->method, r->path, r->version); }
void rhttp_print_request(rhttp_request_t *r) {
rhttp_print_request_line(r);
if (rhttp_opt_debug)
rhttp_print_headers(r->headers);
}
void rhttp_close(rhttp_request_t *r) {
if (!r)
return;
if (!r->closed)
close(r->c);
rhttp_free_request(r);
}
rhttp_request_t *rhttp_parse_request(int s) {
rhttp_request_t *request = (rhttp_request_t *)malloc(sizeof(rhttp_request_t));
http_request_init(request);
char buf[BUFF_SIZE] = {0};
request->c = s;
int breceived = 0;
while (!rstrendswith(buf, "\r\n\r\n")) {
int chunk_size = read(s, buf + breceived, 1);
if (chunk_size <= 0) {
close(request->c);
request->closed = 1;
return request;
}
breceived += chunk_size;
}
if (breceived <= 0) {
close(request->c);
request->closed = 1;
return request;
}
buf[breceived] = '\0';
char *original_buf = buf;
char *b = original_buf;
request->raw = strdup(b);
b = original_buf;
char *line = strtok(b, "\r\n");
b = original_buf;
char *body = b + strlen(line) + 2;
request->body = strdup(body);
b = original_buf;
char *method = strtok(b, " ");
char *path = strtok(NULL, " ");
char *version = strtok(NULL, " ");
request->bytes_received = breceived;
request->line = line;
request->start = nsecs();
request->method = strdup(method);
request->path = strdup(path);
request->version = strdup(version);
request->headers = NULL;
request->keep_alive = false;
if (rhttp_parse_headers(request)) {
char *keep_alive_string = rhttp_header_get_string(request, "Connection");
if (keep_alive_string && !strcmp(keep_alive_string, "keep-alive")) {
request->keep_alive = 1;
}
}
return request;
}
void rhttp_close_server() {
close(rhttp_sock);
close(rhttp_c);
printf("Connections handled: %d\n", rhttp_connections_handled);
printf("Gracefully closed\n");
exit(0);
}
size_t rhttp_send_drain(int s, void *tsend, size_t to_send_len) {
if (to_send_len == 0 && *(unsigned char *)tsend) {
to_send_len = strlen(tsend);
}
unsigned char *to_send = (unsigned char *)malloc(to_send_len);
unsigned char *to_send_original = to_send;
memcpy(to_send, tsend, to_send_len);
// to_send[to_send_len] = '\0';
long bytes_sent = 0;
long bytes_sent_total = 0;
while (1) {
bytes_sent = send(s, to_send + bytes_sent_total, to_send_len - bytes_sent_total, 0);
if (bytes_sent <= 0) {
bytes_sent_total = 0;
break;
}
bytes_sent_total += bytes_sent;
if (bytes_sent_total == (long)to_send_len) {
break;
} else if (!bytes_sent) {
bytes_sent_total = 0;
// error
break;
} else {
rhttp_log_info("Extra send of %d/%d bytes.\n", bytes_sent_total, to_send_len);
}
}
free(to_send_original);
return bytes_sent_total;
}
typedef int (*rhttp_request_handler_t)(rhttp_request_t *r);
void rhttp_serve(const char *host, int port, int backlog, int request_logging, int request_debug, rhttp_request_handler_t handler,
void *context) {
signal(SIGPIPE, SIG_IGN);
rhttp_sock = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = inet_addr(host ? host : "0.0.0.0");
rhttp_opt_debug = request_debug;
rhttp_opt_request_logging = request_logging;
int opt = 1;
setsockopt(rhttp_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
if (bind(rhttp_sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
printf("Binding error\n");
exit(1);
}
listen(rhttp_sock, backlog);
while (1) {
struct sockaddr_in client_addr;
int addrlen = sizeof(client_addr);
rhttp_c = accept(rhttp_sock, (struct sockaddr *)&client_addr, (socklen_t *)&addrlen);
rhttp_connections_handled++;
while (true) {
rhttp_request_t *r = rhttp_parse_request(rhttp_c);
r->context = context;
if (!r->closed) {
if (!handler(r) && !r->closed) {
rhttp_close(r);
}
}
if (!r->keep_alive && !r->closed) {
rhttp_close(r);
} else if (r->keep_alive && !r->closed) {
}
if (r->closed) {
break;
}
rhttp_free_request(r);
}
}
}
unsigned int rhttp_calculate_number_char_count(unsigned int number) {
unsigned int width = 1;
unsigned int tcounter = number;
while (tcounter / 10 >= 1) {
tcounter = tcounter / 10;
width++;
}
return width;
}
int rhttp_file_response(rhttp_request_t *r, char *path) {
if (!*path)
return 0;
FILE *f = fopen(path, "rb");
if (f == NULL)
return 0;
size_t file_size = rfile_size(path);
char response[1024] = {0};
char content_type_header[100] = {0};
char *ext = strstr(path, ".");
char *text_extensions = ".h,.c,.html";
if (strstr(text_extensions, ext)) {
sprintf(content_type_header, "Content-Type: %s\r\n", "text/html");
}
sprintf(response, "HTTP/1.1 200 OK\r\n%sContent-Length:%ld\r\n\r\n", content_type_header, file_size);
if (!rhttp_send_drain(r->c, response, 0)) {
rhttp_log_error("Error sending file: %s\n", path);
}
size_t bytes = 0;
size_t bytes_sent = 0;
unsigned char file_buff[1024];
while ((bytes = fread(file_buff, sizeof(char), sizeof(file_buff), f))) {
if (!rhttp_send_drain(r->c, file_buff, bytes)) {
rhttp_log_error("Error sending file during chunking: %s\n", path);
}
bytes_sent += bytes;
}
if (bytes_sent != file_size) {
rhttp_send_drain(r->c, file_buff, file_size - bytes_sent);
}
close(r->c);
fclose(f);
return 1;
};
int rhttp_file_request_handler(rhttp_request_t *r) {
char *path = r->path;
while (*path == '/' || *path == '.')
path++;
if (strstr(path, "..")) {
return 0;
}
return rhttp_file_response(r, path);
};
unsigned int counter = 100000000;
int rhttp_counter_request_handler(rhttp_request_t *r) {
if (!strncmp(r->path, "/counter", strlen("/counter"))) {
counter++;
unsigned int width = rhttp_calculate_number_char_count(counter);
char to_send2[1024] = {0};
sprintf(to_send2,
"HTTP/1.1 200 OK\r\nContent-Length: %d\r\nConnection: "
"close\r\n\r\n%d",
width, counter);
rhttp_send_drain(r->c, to_send2, 0);
close(r->c);
return 1;
}
return 0;
}
int rhttp_root_request_handler(rhttp_request_t *r) {
if (!strcmp(r->path, "/")) {
char to_send[1024] = {0};
sprintf(to_send, "HTTP/1.1 200 OK\r\nContent-Length: 3\r\nConnection: "
"close\r\n\r\nOk!");
rhttp_send_drain(r->c, to_send, 0);
close(r->c);
return 1;
}
return 0;
}
int rhttp_error_404_handler(rhttp_request_t *r) {
char to_send[1024] = {0};
sprintf(to_send, "HTTP/1.1 404 Document not found\r\nContent-Length: "
"0\r\nConnection: close\r\n\r\n");
rhttp_send_drain(r->c, to_send, 0);
close(r->c);
return 1;
}
int rhttp_default_request_handler(rhttp_request_t *r) {
if (rhttp_opt_debug || rhttp_opt_request_logging)
rhttp_print_request(r);
if (rhttp_counter_request_handler(r)) {
// Counter handler
rhttp_log_info("Counter handler found for: %s\n", r->path);
} else if (rhttp_root_request_handler(r)) {
// Root handler
rhttp_log_info("Root handler found for: %s\n", r->path);
} else if (rhttp_file_request_handler(r)) {
rhttp_log_info("File %s sent\n", r->path);
} else if (rhttp_error_404_handler(r)) {
rhttp_log_warn("Error 404 for: %s\n", r->path);
// Error handler
} else {
rhttp_log_warn("No handler found for: %s\n", r->path);
close(rhttp_c);
}
return 0;
}
int rhttp_main(int argc, char *argv[]) {
setvbuf(stdout, NULL, _IOLBF, BUFSIZ);
int opt;
while ((opt = getopt(argc, argv, "p:drh:bewi")) != -1) {
switch (opt) {
case 'i':
rhttp_opt_info = 1;
rhttp_opt_warn = 1;
rhttp_opt_error = 1;
break;
case 'e':
rhttp_opt_error = 1;
rhttp_opt_warn = 0;
rhttp_opt_info = 0;
break;
case 'w':
rhttp_opt_warn = 1;
rhttp_opt_error = 1;
rhttp_opt_info = 0;
break;
case 'p':
rhttp_opt_port = atoi(optarg);
break;
case 'b':
rhttp_opt_buffered = 1;
printf("Logging is buffered. Output may be incomplete.\n");
break;
case 'h':
strcpy(rhttp_opt_host, optarg);
break;
case 'd':
printf("Debug enabled\n");
rhttp_opt_debug = 1;
rhttp_opt_warn = 1;
rhttp_opt_info = 1;
rhttp_opt_error = 1;
break;
case 'r':
printf("Request logging enabled\n");
rhttp_opt_request_logging = 1;
break;
default:
printf("Usage: %s [-p port] [-h host] [-b]\n", argv[0]);
return 1;
}
}
printf("Starting server on: %s:%d\n", rhttp_opt_host, rhttp_opt_port);
if (rhttp_opt_buffered)
setvbuf(stdout, NULL, _IOFBF, BUFSIZ);
rhttp_serve(rhttp_opt_host, rhttp_opt_port, 1024, rhttp_opt_request_logging, rhttp_opt_debug, rhttp_default_request_handler, NULL);
return 0;
}
/* CLIENT CODE */
typedef struct rhttp_client_request_t {
char *host;
int port;
char *path;
bool is_done;
char *request;
char *response;
pthread_t thread;
int bytes_received;
} rhttp_client_request_t;
rhttp_client_request_t *rhttp_create_request(const char *host, int port, const char *path) {
rhttp_client_request_t *r = (rhttp_client_request_t *)malloc(sizeof(rhttp_client_request_t));
char request_line[4096] = {0};
sprintf(request_line,
"GET %s HTTP/1.1\r\n"
"Host: localhost:8000\r\n"
"Connection: close\r\n"
"Accept: */*\r\n"
"User-Agent: mhttpc\r\n"
"Accept-Language: en-US,en;q=0.5\r\n"
"Accept-Encoding: gzip, deflate\r\n"
"\r\n",
path);
r->request = strdup(request_line);
r->host = strdup(host);
r->port = port;
r->path = strdup(path);
r->is_done = false;
r->response = NULL;
r->bytes_received = 0;
return r;
}
int rhttp_execute_request(rhttp_client_request_t *r) {
int s = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(r->port);
addr.sin_addr.s_addr = inet_addr(r->host);
if (connect(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
return 0;
}
send(s, r->request, strlen(r->request), 0);
char buf[1024 * 1024] = {0};
int ret = recv(s, buf, 1024 * 1024, 0);
if (ret > 0) {
r->response = strdup(buf);
}
close(s);
return ret;
}
void rhttp_reset_request(rhttp_client_request_t *r) {
free(r->response);
r->is_done = false;
r->response = NULL;
r->bytes_received = 0;
}
void rhttp_free_client_request(rhttp_client_request_t *r) {
if (r->request)
free(r->request);
if (r->response)
free(r->response);
if (r->host)
free(r->host);
if (r->path)
free(r->path);
free(r);
}
void rhttp_client_bench(int workers, int times, const char *host, int port, const char *path) {
rhttp_client_request_t *requests[workers];
while (times > 0) {
for (int i = 0; i < workers && times; i++) {
requests[i] = rhttp_create_request(host, port, path);
rhttp_execute_request(requests[i]);
times--;
}
}
}
char *rhttp_client_get(const char *host, int port, const char *path) {
if (!rhttp_c_mutex_initialized) {
rhttp_c_mutex_initialized = 1;
pthread_mutex_init(&rhttp_c_mutex, NULL);
}
char http_response[1024 * 1024];
http_response[0] = 0;
rhttp_client_request_t *r = rhttp_create_request(host, port, path);
unsigned int reconnects = 0;
unsigned int reconnects_max = 100000;
while (!rhttp_execute_request(r)) {
reconnects++;
tick();
if (reconnects == reconnects_max) {
fprintf(stderr, "Maxium reconnects exceeded for %s:%d\n", host, port);
rhttp_free_client_request(r);
return NULL;
}
}
r->is_done = true;
char *body = r->response ? strstr(r->response, "\r\n\r\n") : NULL;
pthread_mutex_lock(&rhttp_c_mutex);
if (body) {
strcpy(http_response, body + 4);
} else {
strcpy(http_response, r->response);
}
rhttp_free_client_request(r);
char *result = sbuf(http_response);
pthread_mutex_unlock(&rhttp_c_mutex);
return result;
}
/*END CLIENT CODE */
#endif
#ifndef RJSON_H
#define RJSON_H
typedef struct rjson_t {
char *content;
size_t length;
size_t size;
} rjson_t;
rjson_t *rjson() {
rjson_t *json = rmalloc(sizeof(rjson_t));
json->size = 1024;
json->length = 0;
json->content = (char *)rmalloc(json->size);
json->content[0] = 0;
return json;
}
void rjson_write(rjson_t *rjs, char *content) {
size_t len = strlen(content);
while (rjs->size < rjs->length + len + 1) {
rjs->content = realloc(rjs->content, rjs->size + 1024);
rjs->size += 1024;
}
strcat(rjs->content, content);
rjs->length += len;
}
void rjson_object_start(rjson_t *rjs) {
if (rstrendswith(rjs->content, "}"))
rjson_write(rjs, ",");
rjson_write(rjs, "{");
}
void rjson_object_close(rjson_t *rjs) {
if (rstrendswith(rjs->content, ",")) {
rjs->content[rjs->length - 1] = 0;
rjs->length--;
}
rjson_write(rjs, "}");
}
void rjson_array_start(rjson_t *rjs) {
if (rjs->length && (rstrendswith(rjs->content, "}") || rstrendswith(rjs->content, "]")))
rjson_write(rjs, ",");
rjson_write(rjs, "[");
}
void rjson_array_close(rjson_t *rjs) {
if (rstrendswith(rjs->content, ",")) {
rjs->content[rjs->length - 1] = 0;
rjs->length--;
}
rjson_write(rjs, "]");
}
void rjson_kv_string(rjson_t *rjs, char *key, char *value) {
if (rjs->length && !rstrendswith(rjs->content, "{") && !rstrendswith(rjs->content, "[")) {
rjson_write(rjs, ",");
}
rjson_write(rjs, "\"");
rjson_write(rjs, key);
rjson_write(rjs, "\":\"");
char *value_str = (char *)rmalloc(strlen(value) + 4096);
rstraddslashes(value, value_str);
rjson_write(rjs, value_str);
free(value_str);
rjson_write(rjs, "\"");
}
void rjson_kv_int(rjson_t *rjs, char *key, ulonglong value) {
if (rjs->length && !rstrendswith(rjs->content, "{") && !rstrendswith(rjs->content, "[")) {
rjson_write(rjs, ",");
}
rjson_write(rjs, "\"");
rjson_write(rjs, key);
rjson_write(rjs, "\":");
char value_str[100] = {0};
sprintf(value_str, "%lld", value);
rjson_write(rjs, value_str);
}
void rjson_kv_number(rjson_t *rjs, char *key, ulonglong value) {
if (rjs->length && !rstrendswith(rjs->content, "{") && !rstrendswith(rjs->content, "[")) {
rjson_write(rjs, ",");
}
rjson_write(rjs, "\"");
rjson_write(rjs, key);
rjson_write(rjs, "\":");
rjson_write(rjs, "\"");
rjson_write(rjs, sbuf(rformat_number(value)));
rjson_write(rjs, "\"");
}
void rjson_kv_bool(rjson_t *rjs, char *key, int value) {
if (rjs->length && !rstrendswith(rjs->content, "{") && !rstrendswith(rjs->content, "[")) {
rjson_write(rjs, ",");
}
rjson_write(rjs, "\"");
rjson_write(rjs, key);
rjson_write(rjs, "\":");
rjson_write(rjs, value > 0 ? "true" : "false");
}
void rjson_kv_duration(rjson_t *rjs, char *key, nsecs_t value) {
if (rjs->length && !rstrendswith(rjs->content, "{") && !rstrendswith(rjs->content, "[")) {
rjson_write(rjs, ",");
}
rjson_write(rjs, "\"");
rjson_write(rjs, key);
rjson_write(rjs, "\":");
rjson_write(rjs, "\"");
rjson_write(rjs, sbuf(format_time(value)));
rjson_write(rjs, "\"");
}
void rjson_free(rjson_t *rsj) {
free(rsj->content);
free(rsj);
}
void rjson_key(rjson_t *rsj, char *key) {
rjson_write(rsj, "\"");
rjson_write(rsj, key);
rjson_write(rsj, "\":");
}
#endif
#ifndef RAUTOCOMPLETE_H
#define RAUTOCOMPLETE_H
#define R4_DEBUG
#ifndef RREX4_H
#define RREX4_H
#include <assert.h>
#include <ctype.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define R4_DEBUG_a
#ifdef R4_DEBUG
static int _r4_debug = 1;
#else
static int _r4_debug = 0;
#endif
static char *_format_function_name(const char *name) {
static char result[100];
result[0] = 0;
char *new_name = (char *)name;
new_name += 11;
if (new_name[0] == '_')
new_name += 1;
if (strlen(new_name) == 0) {
return " -";
}
strcpy(result, new_name);
return result;
}
#define DEBUG_VALIDATE_FUNCTION \
if (_r4_debug || r4->debug) \
printf("DEBUG: %s %s <%s> \"%s\"\n", _format_function_name(__func__), r4->valid ? "valid" : "INVALID", r4->expr, r4->str);
struct r4_t;
void r4_enable_debug() { _r4_debug = true; }
void r4_disable_debug() { _r4_debug = false; }
typedef bool (*r4_function)(struct r4_t *);
typedef struct r4_t {
bool debug;
bool valid;
bool in_block;
bool is_greedy;
bool in_range;
unsigned int backtracking;
unsigned int loop_count;
unsigned int in_group;
unsigned int match_count;
unsigned int validation_count;
unsigned int start;
unsigned int end;
unsigned int length;
bool (*functions[254])(struct r4_t *);
bool (*slash_functions[254])(struct r4_t *);
char *_str;
char *_expr;
char *match;
char *str;
char *expr;
char *str_previous;
char *expr_previous;
char **matches;
} r4_t;
static bool v4_initiated = false;
typedef bool (*v4_function_map)(r4_t *);
v4_function_map v4_function_map_global[256];
v4_function_map v4_function_map_slash[256];
v4_function_map v4_function_map_block[256];
void r4_free_matches(r4_t *r) {
if (!r)
return;
if (r->match) {
free(r->match);
r->match = NULL;
}
if (!r->match_count) {
return;
}
for (unsigned i = 0; i < r->match_count; i++) {
free(r->matches[i]);
}
free(r->matches);
r->match_count = 0;
r->matches = NULL;
}
void r4_free(r4_t *r) {
if (!r)
return;
r4_free_matches(r);
free(r);
}
static bool r4_backtrack(r4_t *r4);
static bool r4_validate(r4_t *r4);
static void r4_match_add(r4_t *r4, char *extracted);
static bool r4_validate_literal(r4_t *r4) {
DEBUG_VALIDATE_FUNCTION
if (!r4->valid)
return false;
if (*r4->str != *r4->expr) {
r4->valid = false;
} else {
r4->str++;
}
r4->expr++;
if (r4->in_block || r4->in_range || !r4->is_greedy) {
return r4->valid;
}
return r4_validate(r4);
}
static bool r4_validate_question_mark(r4_t *r4) {
DEBUG_VALIDATE_FUNCTION
r4->valid = true;
r4->expr++;
return r4_validate(r4);
}
static bool r4_validate_plus(r4_t *r4) {
DEBUG_VALIDATE_FUNCTION
r4->expr++;
if (r4->valid == false) {
return r4_validate(r4);
}
char *expr_left = r4->expr_previous;
char *expr_right = r4->expr;
char *str = r4->str;
char *return_expr = NULL;
if (*expr_right == ')') {
return_expr = expr_right;
expr_right++;
}
r4->is_greedy = false;
r4->expr = expr_left;
while (r4->valid) {
if (*expr_right) {
r4->expr = expr_right;
r4->is_greedy = true;
if (r4_backtrack(r4)) {
if (return_expr) {
r4->str = str;
r4->expr = return_expr;
}
return r4_validate(r4);
} else {
r4->is_greedy = false;
}
}
r4->valid = true;
r4->expr = expr_left;
r4->str = str;
r4_validate(r4);
str = r4->str;
}
r4->is_greedy = true;
r4->valid = true;
r4->expr = return_expr ? return_expr : expr_right;
return r4_validate(r4);
}
static bool r4_validate_dollar(r4_t *r4) {
DEBUG_VALIDATE_FUNCTION
r4->expr++;
r4->valid = *r4->str == 0;
return r4_validate(r4);
}
static bool r4_validate_roof(r4_t *r4) {
DEBUG_VALIDATE_FUNCTION
if (r4->str != r4->_str) {
return false;
}
r4->expr++;
return r4_validate(r4);
}
static bool r4_validate_dot(r4_t *r4) {
DEBUG_VALIDATE_FUNCTION
if (*r4->str == 0) {
return false;
}
r4->expr++;
r4->valid = *r4->str != '\n';
r4->str++;
if (r4->in_block || r4->in_range || !r4->is_greedy) {
return r4->valid;
}
return r4_validate(r4);
}
static bool r4_validate_asterisk(r4_t *r4) {
DEBUG_VALIDATE_FUNCTION
r4->expr++;
if (r4->valid == false) {
r4->valid = true;
return r4->valid;
// return r4_validate(r4);
}
char *expr_left = r4->expr_previous;
char *expr_right = r4->expr;
char *str = r4->str;
char *return_expr = NULL;
if (*expr_right == ')') {
return_expr = expr_right;
expr_right++;
}
r4->is_greedy = false;
r4->expr = expr_left;
while (r4->valid) {
if (*expr_right) {
r4->expr = expr_right;
r4->is_greedy = true;
if (r4_backtrack(r4)) {
if (return_expr) {
r4->str = str;
r4->expr = return_expr;
}
return r4_validate(r4);
} else {
r4->is_greedy = false;
}
}
r4->valid = true;
r4->expr = expr_left;
r4->str = str;
r4_validate(r4);
str = r4->str;
}
r4->is_greedy = true;
r4->valid = true;
r4->expr = return_expr ? return_expr : expr_right;
return r4_validate(r4);
}
static bool r4_validate_pipe(r4_t *r4) {
DEBUG_VALIDATE_FUNCTION
r4->expr++;
if (r4->valid == true) {
return true;
} else {
r4->valid = true;
}
return r4_validate(r4);
}
static bool r4_validate_digit(r4_t *r4) {
DEBUG_VALIDATE_FUNCTION
if (!isdigit(*r4->str)) {
r4->valid = false;
} else {
r4->str++;
}
r4->expr++;
if (r4->in_block || r4->in_range || !r4->is_greedy) {
return r4->valid;
}
return r4_validate(r4);
}
static bool r4_validate_not_digit(r4_t *r4) {
DEBUG_VALIDATE_FUNCTION
if (isdigit(*r4->str)) {
r4->valid = false;
} else {
r4->str++;
}
r4->expr++;
if (r4->in_block || r4->in_range || !r4->is_greedy) {
return r4->valid;
}
return r4_validate(r4);
}
static bool r4_validate_word(r4_t *r4) {
DEBUG_VALIDATE_FUNCTION
if (!isalpha(*r4->str)) {
r4->valid = false;
} else {
r4->str++;
}
r4->expr++;
if (r4->in_block || r4->in_range || !r4->is_greedy) {
return r4->valid;
}
return r4_validate(r4);
}
static bool r4_validate_not_word(r4_t *r4) {
DEBUG_VALIDATE_FUNCTION
if (isalpha(*r4->str)) {
r4->valid = false;
} else {
r4->str++;
}
r4->expr++;
if (r4->in_block || r4->in_range || !r4->is_greedy) {
return r4->valid;
}
return r4_validate(r4);
}
static bool r4_isrange(char *s) {
if (!isalnum(*s)) {
return false;
}
if (*(s + 1) != '-') {
return false;
}
return isalnum(*(s + 2));
}
static bool r4_validate_block_open(r4_t *r4) {
DEBUG_VALIDATE_FUNCTION
if (r4->valid == false) {
return false;
}
char *expr_self = r4->expr;
r4->expr++;
bool reversed = *r4->expr == '^';
if (reversed) {
r4->expr++;
}
bool valid_once = false;
r4->in_block = true;
while (*r4->expr != ']') {
r4->valid = true;
if (r4_isrange(r4->expr)) {
char s = *r4->expr;
char e = *(r4->expr + 2);
r4->expr += 2;
if (s > e) {
char tempc = s;
s = e;
e = tempc;
}
if (*r4->str >= s && *r4->str <= e) {
if (!reversed) {
r4->str++;
}
valid_once = true;
break;
} else {
r4->expr++;
}
} else if (r4_validate(r4)) {
valid_once = true;
if (reversed)
r4->str--;
break;
}
}
char *expr_end = strchr(r4->expr, ']');
r4->expr = expr_end ? expr_end : r4->expr;
r4->in_block = false;
r4->valid = expr_end && (!reversed ? valid_once : !valid_once);
r4->expr++;
r4->expr_previous = expr_self;
if (r4->in_range || !r4->is_greedy) {
return r4->valid;
}
return r4_validate(r4);
}
static bool r4_validate_whitespace(r4_t *r4) {
DEBUG_VALIDATE_FUNCTION
r4->valid = strchr("\r\t \n", *r4->str) != NULL;
r4->expr++;
if (r4->valid) {
r4->str++;
}
if (r4->in_range || r4->in_block || !r4->is_greedy) {
return r4->valid;
}
return r4_validate(r4);
}
static bool r4_validate_not_whitespace(r4_t *r4) {
DEBUG_VALIDATE_FUNCTION
r4->valid = strchr("\r\t \n", *r4->str) == NULL;
r4->expr++;
if (r4->valid) {
r4->str++;
}
if (r4->in_range || r4->in_block || !r4->is_greedy) {
return r4->valid;
}
return r4_validate(r4);
}
static bool r4_validate_range(r4_t *r4) {
DEBUG_VALIDATE_FUNCTION;
if (r4->valid == false) {
r4->expr++;
return false;
}
char *previous = r4->expr_previous;
r4->in_range = true;
r4->expr++;
unsigned int start = 0;
while (isdigit(*r4->expr)) {
start = 10 * start;
start += *r4->expr - '0';
r4->expr++;
}
if (start != 0)
start--;
unsigned int end = 0;
bool variable_end_range = false;
if (*r4->expr == ',') {
r4->expr++;
if (!isdigit(*r4->expr)) {
variable_end_range = true;
}
}
while (isdigit(*r4->expr)) {
end = end * 10;
end += *r4->expr - '0';
r4->expr++;
}
r4->expr++;
bool valid = true;
char *expr_right = r4->expr;
for (unsigned int i = 0; i < start; i++) {
r4->expr = previous;
valid = r4_validate(r4);
if (!*r4->str)
break;
if (!valid) {
break;
}
}
r4->expr = expr_right;
r4->in_range = false;
if (!r4->valid)
return false;
return r4_validate(r4);
for (unsigned int i = start; i < end; i++) {
r4->expr = previous;
valid = r4_validate(r4);
if (!valid) {
break;
}
}
while (variable_end_range) {
r4->in_range = false;
valid = r4_validate(r4);
r4->in_range = true;
if (valid) {
break;
}
r4->in_range = true;
valid = r4_validate(r4);
r4->in_range = false;
if (!valid) {
break;
}
}
r4->valid = valid;
return r4_validate(r4);
}
static bool r4_validate_group_close(r4_t *r4) {
DEBUG_VALIDATE_FUNCTION
return r4->valid;
}
static bool r4_validate_group_open(r4_t *r4) {
DEBUG_VALIDATE_FUNCTION
char *expr_previous = r4->expr_previous;
r4->expr++;
bool save_match = r4->in_group == 0;
r4->in_group++;
char *str_extract_start = r4->str;
bool valid = r4_validate(r4);
if (!valid || *r4->expr != ')') {
// this is a valid case if not everything between () matches
r4->in_group--;
if (save_match == false) {
r4->valid = true;
}
// Not direct return? Not sure
return r4_validate(r4);
}
// if(save_match){
// r4->match_count++;
// }
if (save_match) {
char *str_extract_end = r4->str;
unsigned int extracted_length = str_extract_end - str_extract_start;
// strlen(str_extract_start) - strlen(str_extract_end);
char *str_extracted = (char *)calloc(sizeof(char), extracted_length + 1);
strncpy(str_extracted, str_extract_start, extracted_length);
r4_match_add(r4, str_extracted);
}
assert(*r4->expr == ')');
r4->expr++;
r4->in_group--;
r4->expr_previous = expr_previous;
return r4_validate(r4);
}
static bool r4_validate_slash(r4_t *r4) {
DEBUG_VALIDATE_FUNCTION
// The handling code for handling slashes is implemented in r4_validate
char *expr_previous = r4->expr_previous;
r4->expr++;
r4_function f = v4_function_map_slash[(int)*r4->expr];
r4->expr_previous = expr_previous;
return f(r4);
}
static void r4_match_add(r4_t *r4, char *extracted) {
r4->matches = (char **)realloc(r4->matches, (r4->match_count + 1) * sizeof(char *));
r4->matches[r4->match_count] = extracted;
r4->match_count++;
}
static bool r4_validate_word_boundary_start(r4_t *r4) {
DEBUG_VALIDATE_FUNCTION
r4->expr++;
if (!r4->valid) {
return r4->valid;
}
r4->valid = isalpha(*r4->str) && (r4->str == r4->_str || !isalpha(*(r4->str - 1)));
if (r4->in_range || r4->in_block || !r4->is_greedy) {
return r4->valid;
}
return r4_validate(r4);
}
static bool r4_validate_word_boundary_end(r4_t *r4) {
DEBUG_VALIDATE_FUNCTION
r4->expr++;
if (!r4->valid) {
return r4->valid;
}
r4->valid = isalpha(*r4->str) && (*(r4->str + 1) == 0 || !isalpha(*(r4->str + 1)));
if (r4->in_range || r4->in_block || !r4->is_greedy) {
return r4->valid;
}
return r4_validate(r4);
}
static void v4_init_function_maps() {
if (v4_initiated)
return;
v4_initiated = true;
for (__uint8_t i = 0; i < 255; i++) {
v4_function_map_global[i] = r4_validate_literal;
v4_function_map_slash[i] = r4_validate_literal;
v4_function_map_block[i] = r4_validate_literal;
}
v4_function_map_global['*'] = r4_validate_asterisk;
v4_function_map_global['?'] = r4_validate_question_mark;
v4_function_map_global['+'] = r4_validate_plus;
v4_function_map_global['$'] = r4_validate_dollar;
v4_function_map_global['^'] = r4_validate_roof;
v4_function_map_global['.'] = r4_validate_dot;
v4_function_map_global['|'] = r4_validate_pipe;
v4_function_map_global['\\'] = r4_validate_slash;
v4_function_map_global['['] = r4_validate_block_open;
v4_function_map_global['{'] = r4_validate_range;
v4_function_map_global['('] = r4_validate_group_open;
v4_function_map_global[')'] = r4_validate_group_close;
v4_function_map_slash['b'] = r4_validate_word_boundary_start;
v4_function_map_slash['B'] = r4_validate_word_boundary_end;
v4_function_map_slash['d'] = r4_validate_digit;
v4_function_map_slash['w'] = r4_validate_word;
v4_function_map_slash['D'] = r4_validate_not_digit;
v4_function_map_slash['W'] = r4_validate_not_word;
v4_function_map_slash['s'] = r4_validate_whitespace;
v4_function_map_slash['S'] = r4_validate_not_whitespace;
v4_function_map_block['\\'] = r4_validate_slash;
v4_function_map_block['{'] = r4_validate_range;
}
void r4_init(r4_t *r4) {
v4_init_function_maps();
if (r4 == NULL)
return;
r4->debug = _r4_debug;
r4->valid = true;
r4->validation_count = 0;
r4->match_count = 0;
r4->start = 0;
r4->end = 0;
r4->length = 0;
r4->matches = NULL;
}
static bool r4_looks_behind(char c) { return strchr("?*+{", c) != NULL; }
r4_t *r4_new() {
r4_t *r4 = (r4_t *)malloc(sizeof(r4_t));
r4_init(r4);
return r4;
}
static bool r4_pipe_next(r4_t *r4) {
char *expr = r4->expr;
while (*expr) {
if (*expr == '|') {
r4->expr = expr + 1;
r4->valid = true;
return true;
}
expr++;
}
return false;
}
static bool r4_backtrack(r4_t *r4) {
if (_r4_debug)
printf("\033[36mDEBUG: backtrack start (%d)\n", r4->backtracking);
r4->backtracking++;
char *str = r4->str;
char *expr = r4->expr;
bool result = r4_validate(r4);
r4->backtracking--;
if (result == false) {
r4->expr = expr;
r4->str = str;
}
if (_r4_debug)
printf("DEBUG: backtrack end (%d) result: %d %s\n", r4->backtracking, result, r4->backtracking == 0 ? "\033[0m" : "");
return result;
}
static bool r4_validate(r4_t *r4) {
DEBUG_VALIDATE_FUNCTION
r4->validation_count++;
char c_val = *r4->expr;
if (c_val == 0) {
return r4->valid;
}
if (!r4_looks_behind(c_val)) {
r4->expr_previous = r4->expr;
} else if (r4->expr == r4->_expr) {
// Regex may not start with a look behind ufnction
return false;
}
if (!r4->valid && !r4_looks_behind(*r4->expr)) {
if (!r4_pipe_next(r4)) {
return false;
}
}
r4_function f;
if (r4->in_block) {
f = v4_function_map_block[(int)c_val];
} else {
f = v4_function_map_global[(int)c_val];
}
r4->valid = f(r4);
return r4->valid;
}
char *r4_get_match(r4_t *r) {
char *match = (char *)malloc(r->length + 1);
strncpy(match, r->_str + r->start, r->length);
match[r->length] = 0;
return match;
}
static bool r4_search(r4_t *r) {
bool valid = true;
char *str_next = r->str;
while (*r->str) {
if (!(valid = r4_validate(r))) {
// Move next until we find a match
if (!r->backtracking) {
r->start++;
}
str_next++;
r->str = str_next;
r->expr = r->_expr;
r->valid = true;
} else {
/// HIGH DOUBT
if (!r->backtracking) {
// r->start = 0;
}
break;
}
}
r->valid = valid;
if (r->valid) {
r->end = strlen(r->_str) - strlen(r->str);
r->length = r->end - r->start;
r->match = r4_get_match(r);
}
return r->valid;
}
r4_t *r4(const char *str, const char *expr) {
r4_t *r = r4_new();
r->_str = (char *)str;
r->_expr = (char *)expr;
r->match = NULL;
r->str = r->_str;
r->expr = r->_expr;
r->str_previous = r->_str;
r->expr_previous = r->expr;
r->in_block = false;
r->is_greedy = true;
r->in_group = 0;
r->loop_count = 0;
r->backtracking = 0;
r->in_range = false;
r4_search(r);
return r;
}
r4_t *r4_next(r4_t *r, char *expr) {
if (expr) {
r->_expr = expr;
}
r->backtracking = 0;
r->expr = r->_expr;
r->is_greedy = true;
r->in_block = false;
r->in_range = false;
r->in_group = false;
r4_free_matches(r);
r4_search(r);
return r;
}
bool r4_match(char *str, char *expr) {
r4_t *r = r4(str, expr);
bool result = r->valid;
r4_free(r);
return result;
}
#endif
#define rautocomplete_new rstring_list_new
#define rautocomplete_free rstring_list_free
#define rautocomplete_add rstring_list_add
#define rautocomplete_find rstring_list_find
#define rautocomplete_t rstring_list_t
#define rautocomplete_contains rstring_list_contains
char *r4_escape(char *content) {
size_t size = strlen(content) * 2 + 1;
char *escaped = (char *)calloc(size, sizeof(char));
char *espr = escaped;
char *to_escape = "?*+()[]{}^$\\";
*espr = '(';
espr++;
while (*content) {
if (strchr(to_escape, *content)) {
*espr = '\\';
espr++;
}
*espr = *content;
espr++;
content++;
}
*espr = '.';
espr++;
*espr = '+';
espr++;
*espr = ')';
espr++;
*espr = 0;
return escaped;
}
char *rautocomplete_find(rstring_list_t *list, char *expr) {
if (!list->count)
return NULL;
if (!expr || !strlen(expr))
return NULL;
char *escaped = r4_escape(expr);
for (unsigned int i = list->count - 1; i == 0; i--) {
char *match;
r4_t *r = r4(list->strings[i], escaped);
if (r->valid && r->match_count == 1) {
match = strdup(r->matches[0]);
}
r4_free(r);
if (match) {
free(escaped);
return match;
}
}
free(escaped);
return NULL;
}
#endif
#ifndef RKEYTABLE_H
#define RKEYTABLE_H
/*
DERIVED FROM HASH TABLE K&R
*/
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct rnklist {
struct rnklist *next;
struct rnklist *last;
char *name;
char *defn;
} rnklist;
static rnklist *rkeytab = NULL;
rnklist *rlkget(char *s) {
rnklist *np;
for (np = rkeytab; np != NULL; np = np->next)
if (strcmp(s, np->name) == 0)
return np; // Found
return NULL; // Not found
}
char *rkget(char *s) {
rnklist *np = rlkget(s);
return np ? np->defn : NULL;
}
rnklist *rkset(char *name, char *defn) {
rnklist *np;
if ((np = (rlkget(name))) == NULL) { // Not found
np = (rnklist *)malloc(sizeof(rnklist));
np->name = strdup(name);
np->next = NULL;
np->last = NULL;
if (defn) {
np->defn = strdup(defn);
} else {
np->defn = NULL;
}
if (rkeytab == NULL) {
rkeytab = np;
rkeytab->last = np;
} else {
if (rkeytab->last)
rkeytab->last->next = np;
rkeytab->last = np;
}
} else {
if (np->defn)
free((void *)np->defn);
if (defn) {
np->defn = strdup(defn);
} else {
np->defn = NULL;
}
}
return np;
}
#endif
#ifndef RHASHTABLE_H
#define RHASHTABLE_H
/*
ORIGINAL SOURCE IS FROM K&R
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define HASHSIZE 101
// Structure for the table entries
typedef struct rnlist {
struct rnlist *next;
char *name;
char *defn;
} rnlist;
// Hash table array
static rnlist *rhashtab[HASHSIZE];
// Hash function
unsigned rhash(char *s) {
unsigned hashval;
for (hashval = 0; *s != '\0'; s++)
hashval = *s + 31 * hashval;
return hashval % HASHSIZE;
}
rnlist *rlget(char *s) {
rnlist *np;
for (np = rhashtab[rhash(s)]; np != NULL; np = np->next)
if (strcmp(s, np->name) == 0)
return np; // Found
return NULL; // Not found
}
// Lookup function
char *rget(char *s) {
rnlist *np = rlget(s);
return np ? np->defn : NULL;
}
// Install function (adds a name and definition to the table)
struct rnlist *rset(char *name, char *defn) {
struct rnlist *np = NULL;
unsigned hashval;
if ((rlget(name)) == NULL) { // Not found
np = (struct rnlist *)malloc(sizeof(*np));
if (np == NULL || (np->name = strdup(name)) == NULL)
return NULL;
hashval = rhash(name);
np->next = rhashtab[hashval];
rhashtab[hashval] = np;
} else {
if (np->defn)
free((void *)np->defn);
np->defn = NULL;
}
if ((np->defn = strdup(defn)) == NULL)
return NULL;
return np;
}
#endif
#ifndef RREX3_H
#define RREX3_H
#include <assert.h>
#include <ctype.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#ifndef RREX3_DEBUG
#define RREX3_DEBUG 0
#endif
struct rrex3_t;
typedef void (*rrex3_function)(struct rrex3_t *);
typedef struct rrex3_t {
void (*functions[254])(struct rrex3_t *);
void (*slash_functions[254])(struct rrex3_t *);
bool valid;
int match_count;
int match_capacity;
char **matches;
bool exit;
char *__expr;
char *__str;
char *_expr;
char *_str;
char *expr;
char *str;
char *compiled;
bool inside_brackets;
bool inside_parentheses;
bool pattern_error;
bool match_from_start;
char bytecode;
rrex3_function function;
struct {
void (*function)(struct rrex3_t *);
char *expr;
char *str;
char bytecode;
} previous;
struct {
void (*function)(struct rrex3_t *);
char *expr;
char *str;
char bytecode;
} failed;
} rrex3_t;
static bool isdigitrange(char *s) {
if (!isdigit(*s)) {
return false;
}
if (*(s + 1) != '-') {
return false;
}
return isdigit(*(s + 2));
}
static bool isalpharange(char *s) {
if (!isalpha(*s)) {
return false;
}
if (*(s + 1) != '-') {
return false;
}
return isalpha(*(s + 2));
}
void rrex3_free_matches(rrex3_t *rrex3) {
if (!rrex3->matches)
return;
for (int i = 0; i < rrex3->match_count; i++) {
free(rrex3->matches[i]);
}
free(rrex3->matches);
rrex3->matches = NULL;
rrex3->match_count = 0;
rrex3->match_capacity = 0;
}
void rrex3_free(rrex3_t *rrex3) {
if (!rrex3)
return;
if (rrex3->compiled) {
free(rrex3->compiled);
rrex3->compiled = NULL;
}
rrex3_free_matches(rrex3);
free(rrex3);
rrex3 = NULL;
}
static bool rrex3_move(rrex3_t *, bool);
static void rrex3_set_previous(rrex3_t *);
inline static void rrex3_cmp_asterisk(rrex3_t *);
void rrex3_cmp_literal_range(rrex3_t *rrex3) {
#if RREX3_DEBUG == 1
printf("Range check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
#endif
rrex3_set_previous(rrex3);
char start = *rrex3->expr;
rrex3->expr++;
rrex3->expr++;
char end = *rrex3->expr;
if (*rrex3->str >= start && *rrex3->str <= end) {
rrex3->str++;
rrex3->valid = true;
} else {
rrex3->valid = false;
}
rrex3->expr++;
}
bool rrex3_is_function(char chr) {
if (chr == ']' || chr == ')' || chr == '\\' || chr == '?' || chr == '+' || chr == '*')
return true;
return false;
}
inline static void rrex3_cmp_literal(rrex3_t *rrex3) {
rrex3_set_previous(rrex3);
if (rrex3->inside_brackets) {
if (isalpharange(rrex3->expr) || isdigitrange(rrex3->expr)) {
rrex3_cmp_literal_range(rrex3);
return;
}
}
#if RREX3_DEBUG == 1
printf("Literal check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
#endif
if (*rrex3->expr == 0 && !*rrex3->str) {
printf("ERROR, EMPTY CHECK\n");
// exit(1);
}
if (rrex3->valid == false) {
rrex3->expr++;
return;
}
if (*rrex3->expr == *rrex3->str) {
rrex3->expr++;
rrex3->str++;
rrex3->valid = true;
// if(*rrex3->expr &&rrex3->functions[(int)*rrex3->expr] ==
// rrex3_cmp_literal && !rrex3->inside_brackets &&
//! rrex3_is_function(*rrex3->expr)){ rrex3_cmp_literal(rrex3);
// if(rrex3->valid == false){
// rrex3->expr--;
// rrex3->valid = true;
// }
// }
return;
}
rrex3->expr++;
rrex3->valid = false;
}
inline static void rrex3_cmp_dot(rrex3_t *rrex3) {
#if RREX3_DEBUG == 1
printf("Dot check (any char): %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
#endif
rrex3_set_previous(rrex3);
rrex3->expr++;
if (!rrex3->valid) {
return;
}
if (*rrex3->str && *rrex3->str != '\n') {
rrex3->str++;
if (*rrex3->expr && *rrex3->expr == '.') {
rrex3_cmp_dot(rrex3);
return;
} /*else if(*rrex3->expr && (*rrex3->expr == '*' || *rrex3->expr ==
'+')){ char * next = strchr(rrex3->str,*(rrex3->expr + 1)); char *
space = strchr(rrex3->str,'\n'); if(next && (!space || space > next)){
rrex3->str = next;
}
}*/
} else {
rrex3->valid = false;
}
}
inline static void rrex3_cmp_question_mark(rrex3_t *rrex3) {
#if RREX3_DEBUG == 1
printf("Question mark check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
#endif
rrex3_set_previous(rrex3);
if (rrex3->valid == false)
rrex3->valid = true;
rrex3->expr++;
}
inline static void rrex3_cmp_whitespace(rrex3_t *rrex3) {
#if RREX3_DEBUG == 1
printf("Whitespace check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
#endif
rrex3_set_previous(rrex3);
char c = *rrex3->expr;
rrex3->valid = c == ' ' || c == '\n' || c == '\t';
if (rrex3->valid) {
rrex3->str++;
}
rrex3->expr++;
}
inline static void rrex3_cmp_whitespace_upper(rrex3_t *rrex3) {
#if RREX3_DEBUG == 1
printf("Non whitespace check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
#endif
rrex3_set_previous(rrex3);
char c = *rrex3->expr;
rrex3->valid = !(c == ' ' || c == '\n' || c == '\t');
if (rrex3->valid) {
rrex3->str++;
}
rrex3->expr++;
}
inline static void rrex3_cmp_plus2(rrex3_t *rrex3) {
#if RREX3_DEBUG == 1
printf("Plus check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
#endif
rrex3_set_previous(rrex3);
if (rrex3->valid) {
rrex3->str--;
} else {
return;
}
char *original_expr = rrex3->expr;
char *next = original_expr + 1;
char *loop_expr = rrex3->previous.expr - 1;
if (*loop_expr == '+') {
rrex3->valid = false;
rrex3->pattern_error = true;
rrex3->expr++;
return;
}
bool success_next = false;
bool success_next_once = false;
bool success_current = false;
char *next_next = NULL;
char *next_str = rrex3->str;
while (*rrex3->str) {
// Check if next matches
char *original_str = rrex3->str;
rrex3->expr = next;
rrex3->valid = true;
if (rrex3_move(rrex3, false)) {
success_next = true;
next_next = rrex3->expr;
next_str = rrex3->str;
success_next_once = true;
} else {
success_next = false;
}
if (success_next_once && !success_next) {
break;
}
// Check if current matches
rrex3->str = original_str;
rrex3->expr = loop_expr;
rrex3->valid = true;
if (!*rrex3->str || !rrex3_move(rrex3, false)) {
success_current = false;
} else {
success_current = true;
if (!success_next) {
next_next = rrex3->expr + 1; // +1 is the * itself
next_str = rrex3->str;
}
}
if (success_next && !success_current) {
break;
}
}
if (!next_next)
rrex3->expr = next;
else {
rrex3->expr = next_next;
}
rrex3->str = next_str;
rrex3->valid = true;
}
inline static void rrex3_cmp_plus(rrex3_t *rrex3) {
#if RREX3_DEBUG == 1
rprintg("Asterisk start check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
#endif
if (!rrex3->valid) {
rrex3->expr++;
return;
}
char *left = rrex3->previous.expr;
// printf("%s\n",rrex3->str);
char *right = rrex3->expr + 1;
if (*right == ')') {
right++;
}
int right_valid = 0;
bool right_valid_once = false;
char *expr = right;
char *right_str = rrex3->str;
;
char *right_expr = NULL;
char *str = rrex3->str;
bool first_time = true;
bool left_valid = true;
char *str_prev = NULL;
bool valid_from_start = true;
;
while (*rrex3->str) {
if (!left_valid && !right_valid) {
break;
}
if (right_valid && !left_valid) {
str = right_str;
break;
}
rrex3->expr = right;
rrex3->str = str;
#if RREX3_DEBUG == 1
printf("r");
#endif
if (*rrex3->str && rrex3_move(rrex3, false)) {
right_valid++;
right_str = rrex3->str;
expr = rrex3->expr;
if (!right_valid_once) {
right_expr = rrex3->expr;
right_valid_once = true;
}
} else {
right_valid = 0;
}
if (first_time) {
first_time = false;
valid_from_start = right_valid;
}
if (right_valid && !valid_from_start && right_valid > 0) {
expr = right_expr - 1;
;
if (*(right - 1) == ')') {
expr = right - 1;
}
break;
}
if ((!right_valid && right_valid_once)) {
expr = right_expr;
if (*(right - 1) == ')') {
str = str_prev;
expr = right - 1;
}
break;
}
str_prev = str;
rrex3->valid = true;
rrex3->str = str;
rrex3->expr = left;
#if RREX3_DEBUG == 1
printf("l");
#endif
if (rrex3_move(rrex3, false)) {
left_valid = true;
str = rrex3->str;
} else {
left_valid = false;
}
}
rrex3->expr = expr;
rrex3->str = str;
rrex3->valid = true;
#if RREX3_DEBUG == 1
rprintg("Asterisk end check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
#endif
}
inline static void rrex3_cmp_asterisk(rrex3_t *rrex3) {
#if RREX3_DEBUG == 1
rprintg("Asterisk start check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
#endif
if (!rrex3->valid) {
rrex3->valid = true;
rrex3->expr++;
return;
}
rrex3->str = rrex3->previous.str;
char *left = rrex3->previous.expr;
// printf("%s\n",rrex3->str);
char *right = rrex3->expr + 1;
if (*right == ')') {
right++;
}
int right_valid = 0;
bool right_valid_once = false;
char *expr = right;
char *right_str = rrex3->str;
;
char *right_expr = NULL;
char *str = rrex3->str;
bool first_time = true;
bool left_valid = true;
char *str_prev = NULL;
bool valid_from_start = true;
;
while (*rrex3->str) {
if (!left_valid && !right_valid) {
break;
}
if (right_valid && !left_valid) {
str = right_str;
break;
}
rrex3->expr = right;
rrex3->str = str;
#if RREX3_DEBUG == 1
printf("r");
#endif
if (*rrex3->str && rrex3_move(rrex3, false)) {
right_valid++;
right_str = rrex3->str;
expr = rrex3->expr;
if (!right_valid_once) {
right_expr = rrex3->expr;
right_valid_once = true;
}
} else {
right_valid = 0;
}
if (first_time) {
first_time = false;
valid_from_start = right_valid;
}
if (right_valid && !valid_from_start && right_valid > 0) {
expr = right_expr - 1;
if (*(right - 1) == ')') {
expr = right - 1;
}
break;
}
if ((!right_valid && right_valid_once)) {
expr = right_expr;
if (*(right - 1) == ')') {
str = str_prev;
expr = right - 1;
}
break;
}
str_prev = str;
rrex3->valid = true;
rrex3->str = str;
rrex3->expr = left;
#if RREX3_DEBUG == 1
printf("l");
#endif
if (rrex3_move(rrex3, false)) {
left_valid = true;
str = rrex3->str;
} else {
left_valid = false;
}
}
rrex3->expr = expr;
rrex3->str = str;
rrex3->valid = true;
#if RREX3_DEBUG == 1
rprintg("Asterisk end check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
#endif
}
inline static void rrex3_cmp_asterisk2(rrex3_t *rrex3) {
#if RREX3_DEBUG == 1
rprintg("Asterisk start check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
#endif
if (!rrex3->valid) {
rrex3->valid = true;
rrex3->expr++;
return;
}
if (*rrex3->previous.expr == '*') {
// Support for **
rrex3->valid = false;
// rrex3->pattern_error = true;
rrex3->expr++;
return;
}
rrex3->str = rrex3->previous.str;
;
char *next = rrex3->expr + 1;
char *next_original = NULL;
if (*next == '*') {
next++;
}
if (*next == ')' && *(next + 1)) {
next_original = next;
next++;
}
char *loop_expr = rrex3->previous.expr;
bool success_next = false;
bool success_next_once = false;
bool success_current = false;
char *right_next = NULL;
char *right_str = rrex3->str;
while (*rrex3->str && *rrex3->expr && *rrex3->expr != ')') {
// Remember original_str because it's modified
// by checking right and should be restored
// for checking left so they're matching the
// same value.
char *original_str = rrex3->str;
// Check if right matches.
// if(*next != ')'){
rrex3->expr = next;
rrex3->valid = true;
if (rrex3_move(rrex3, false)) {
// Match rright.
success_next = true;
if (!next_original) {
if (!success_next_once) {
right_next = rrex3->expr;
}
} else {
right_next = next_original;
break;
}
right_str = rrex3->str;
success_next_once = true;
} else {
// No match Right.
success_next = false;
}
//}
if (success_next_once && !success_next) {
// Matched previous time but now doesn't.
break;
}
// Check if left matches.
rrex3->str = original_str;
rrex3->expr = loop_expr;
rrex3->valid = true;
if (!rrex3_move(rrex3, false)) {
// No match left.
success_current = false;
} else {
// Match left.
success_current = true;
// NOT SURE< WITHOUT DOET HETZELFDE:
// original_str = rrex3->str;
if (!success_next) {
right_str = rrex3->str;
if (*rrex3->expr != ')') {
right_next = rrex3->expr + 1; // +1 is the * itself
} else {
// break;
}
}
}
if ((success_next && !success_current) || (!success_next && !success_current)) {
break;
}
}
rrex3->expr = right_next;
rrex3->str = right_str;
rrex3->valid = true;
#if RREX3_DEBUG == 1
rprintg("Asterisk end check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
#endif
}
inline static void rrex3_cmp_roof(rrex3_t *rrex3) {
rrex3_set_previous(rrex3);
#if RREX3_DEBUG == 1
printf("<Roof check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
#endif
rrex3->valid = rrex3->str == rrex3->_str;
rrex3->match_from_start = true;
rrex3->expr++;
}
inline static void rrex3_cmp_dollar(rrex3_t *rrex3) {
rrex3_set_previous(rrex3);
#if RREX3_DEBUG == 1
printf("Dollar check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
#endif
if (*rrex3->str || !rrex3->valid) {
rrex3->valid = false;
}
rrex3->expr++;
}
inline static void rrex3_cmp_w(rrex3_t *rrex3) {
rrex3_set_previous(rrex3);
rrex3->expr++;
#if RREX3_DEBUG == 1
printf("Word check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
#endif
if (isalpha(*rrex3->str)) {
rrex3->str++;
} else {
rrex3->valid = false;
}
}
inline static void rrex3_cmp_w_upper(rrex3_t *rrex3) {
rrex3_set_previous(rrex3);
rrex3->expr++;
#if RREX3_DEBUG == 1
printf("!Word check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
#endif
if (!isalpha(*rrex3->str)) {
rrex3->str++;
} else {
rrex3->valid = false;
}
}
inline static void rrex3_cmp_d(rrex3_t *rrex3) {
rrex3_set_previous(rrex3);
rrex3->expr++;
#if RREX3_DEBUG == 1
printf("Digit check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
#endif
if (isdigit(*rrex3->str)) {
rrex3->str++;
} else {
rrex3->valid = false;
}
}
inline static void rrex3_cmp_d_upper(rrex3_t *rrex3) {
rrex3_set_previous(rrex3);
rrex3->expr++;
#if RREX3_DEBUG == 1
printf("!Digit check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
#endif
if (!isdigit(*rrex3->str)) {
rrex3->str++;
} else {
rrex3->valid = false;
}
}
inline static void rrex3_cmp_slash(rrex3_t *rrex3) {
rrex3_set_previous(rrex3);
rrex3->expr++;
rrex3->bytecode = *rrex3->expr;
rrex3->function = rrex3->slash_functions[(int)rrex3->bytecode];
rrex3->function(rrex3);
}
inline static int collect_digits(rrex3_t *rrex3) {
char output[20];
unsigned int digit_count = 0;
while (isdigit(*rrex3->expr)) {
output[digit_count] = *rrex3->expr;
rrex3->expr++;
digit_count++;
}
output[digit_count] = 0;
return atoi(output);
}
inline static void rrex3_cmp_range(rrex3_t *rrex3) {
char *loop_code = rrex3->previous.expr;
char *expr_original = rrex3->expr;
rrex3->expr++;
int range_start = collect_digits(rrex3) - 1;
int range_end = 0;
if (*rrex3->expr == ',') {
rrex3->expr++;
range_end = collect_digits(rrex3);
}
rrex3->expr++;
int times_valid = 0;
while (*rrex3->str) {
rrex3->expr = loop_code;
rrex3_move(rrex3, false);
if (rrex3->valid == false) {
break;
} else {
times_valid++;
}
if (range_end) {
if (times_valid >= range_start && times_valid == range_end - 1) {
rrex3->valid = true;
} else {
rrex3->valid = false;
}
break;
} else if (range_start) {
if (times_valid == range_start) {
rrex3->valid = true;
break;
}
}
}
rrex3->valid = times_valid >= range_start;
if (rrex3->valid && range_end) {
rrex3->valid = times_valid <= range_end;
}
rrex3->expr = strchr(expr_original, '}') + 1;
}
inline static void rrex3_cmp_word_start_or_end(rrex3_t *rrex3) {
#if RREX3_DEBUG == 1
if (*rrex3->expr != 'B') {
printf("Check word start or end: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
}
#endif
rrex3_set_previous(rrex3);
bool valid = false;
if (isalpha(*rrex3->str)) {
if (rrex3->_str != rrex3->str) {
if (!isalpha(*(rrex3->str - 1))) {
valid = true;
}
} else {
valid = true;
}
} else if (isalpha(isalpha(*rrex3->str) && !isalpha(*rrex3->str + 1))) {
valid = true;
}
rrex3->expr++;
rrex3->valid = valid;
}
inline static void rrex3_cmp_word_not_start_or_end(rrex3_t *rrex3) {
#if RREX3_DEBUG == 1
printf("Check word NOT start or end: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
#endif
rrex3_set_previous(rrex3);
rrex3_cmp_word_start_or_end(rrex3);
rrex3->valid = !rrex3->valid;
}
inline static void rrex3_cmp_brackets(rrex3_t *rrex3) {
#if RREX3_DEBUG == 1
rprintb("\\l Brackets start: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
#endif
rrex3_set_previous(rrex3);
char *original_expr = rrex3->expr;
rrex3->expr++;
rrex3->inside_brackets = true;
bool valid_once = false;
bool reversed = false;
if (*rrex3->expr == '^') {
reversed = true;
rrex3->expr++;
}
bool valid = false;
while (*rrex3->expr != ']' && *rrex3->expr != 0) {
rrex3->valid = true;
valid = rrex3_move(rrex3, false);
if (reversed) {
valid = !valid;
}
if (valid) {
valid_once = true;
if (!reversed) {
valid_once = true;
break;
}
} else {
if (reversed) {
valid_once = false;
break;
}
}
}
if (valid_once && reversed) {
rrex3->str++;
}
while (*rrex3->expr != ']' && *rrex3->expr != 0)
rrex3->expr++;
if (*rrex3->expr != 0)
rrex3->expr++;
rrex3->valid = valid_once;
rrex3->inside_brackets = false;
char *previous_expr = rrex3->expr;
rrex3->expr = original_expr;
rrex3_set_previous(rrex3);
rrex3->expr = previous_expr;
#if RREX3_DEBUG == 1
rprintb("\\l Brackets end: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
#endif
}
inline static void rrex3_cmp_pipe(rrex3_t *rrex3) {
rrex3_set_previous(rrex3);
#if RREX3_DEBUG == 1
printf("Pipe check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
#endif
if (rrex3->valid == true) {
rrex3->exit = true;
} else {
rrex3->valid = true;
}
rrex3->expr++;
}
inline static void rrex3_cmp_parentheses(rrex3_t *rrex3) {
#if RREX3_DEBUG == 1
rprinty("\\l Parentheses start check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
#endif
rrex3_set_previous(rrex3);
if (!rrex3->valid) {
rrex3->expr++;
return;
}
if (rrex3->match_count == rrex3->match_capacity) {
rrex3->match_capacity++;
rrex3->matches = (char **)realloc(rrex3->matches, rrex3->match_capacity * sizeof(char *));
}
rrex3->matches[rrex3->match_count] = (char *)malloc(strlen(rrex3->str) + 1);
strcpy(rrex3->matches[rrex3->match_count], rrex3->str);
char *original_expr = rrex3->expr;
char *original_str = rrex3->str;
rrex3->expr++;
rrex3->inside_parentheses = true;
while (*rrex3->expr != ')' && !rrex3->exit) {
rrex3_move(rrex3, false);
}
while (*rrex3->expr != ')') {
rrex3->expr++;
}
rrex3->expr++;
rrex3->inside_parentheses = false;
char *previous_expr = rrex3->expr;
rrex3->expr = original_expr;
rrex3_set_previous(rrex3);
rrex3->expr = previous_expr;
if (rrex3->valid == false) {
rrex3->str = original_str;
free(rrex3->matches[rrex3->match_count]);
} else {
rrex3->matches[rrex3->match_count][strlen(rrex3->matches[rrex3->match_count]) - strlen(rrex3->str)] = 0;
rrex3->match_count++;
}
#if RREX3_DEBUG == 1
rprinty("\\l Parentheses end: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
#endif
}
inline static void rrex3_reset(rrex3_t *rrex3) {
rrex3_free_matches(rrex3);
rrex3->valid = true;
rrex3->pattern_error = false;
rrex3->inside_brackets = false;
rrex3->inside_parentheses = false;
rrex3->exit = false;
rrex3->previous.expr = NULL;
rrex3->previous.str = NULL;
rrex3->previous.bytecode = 0;
rrex3->failed.expr = NULL;
rrex3->failed.str = NULL;
rrex3->failed.bytecode = 0;
rrex3->match_from_start = false;
}
void rrex3_init(rrex3_t *rrex3) {
for (__uint8_t i = 0; i < 254; i++) {
rrex3->functions[i] = rrex3_cmp_literal;
rrex3->slash_functions[i] = rrex3_cmp_literal;
}
rrex3->functions['?'] = rrex3_cmp_question_mark;
rrex3->functions['^'] = rrex3_cmp_roof;
rrex3->functions['$'] = rrex3_cmp_dollar;
rrex3->functions['.'] = rrex3_cmp_dot;
rrex3->functions['*'] = rrex3_cmp_asterisk;
rrex3->functions['+'] = rrex3_cmp_plus;
rrex3->functions['|'] = rrex3_cmp_pipe;
rrex3->functions['\\'] = rrex3_cmp_slash;
rrex3->functions['{'] = rrex3_cmp_range;
rrex3->functions['['] = rrex3_cmp_brackets;
rrex3->functions['('] = rrex3_cmp_parentheses;
rrex3->slash_functions['w'] = rrex3_cmp_w;
rrex3->slash_functions['W'] = rrex3_cmp_w_upper;
rrex3->slash_functions['d'] = rrex3_cmp_d;
rrex3->slash_functions['D'] = rrex3_cmp_d_upper;
rrex3->slash_functions['s'] = rrex3_cmp_whitespace;
rrex3->slash_functions['S'] = rrex3_cmp_whitespace_upper;
rrex3->slash_functions['b'] = rrex3_cmp_word_start_or_end;
rrex3->slash_functions['B'] = rrex3_cmp_word_not_start_or_end;
rrex3->match_count = 0;
rrex3->match_capacity = 0;
rrex3->matches = NULL;
rrex3->compiled = NULL;
rrex3_reset(rrex3);
}
rrex3_t *rrex3_new() {
rrex3_t *rrex3 = (rrex3_t *)malloc(sizeof(rrex3_t));
rrex3_init(rrex3);
return rrex3;
}
rrex3_t *rrex3_compile(rrex3_t *rrex, char *expr) {
rrex3_t *rrex3 = rrex ? rrex : rrex3_new();
char *compiled = (char *)malloc(strlen(expr) + 1);
unsigned int count = 0;
while (*expr) {
if (*expr == '[' && *(expr + 2) == ']') {
*compiled = *(expr + 1);
expr++;
expr++;
} else if (*expr == '[' && *(expr + 1) == '0' && *(expr + 2) == '-' && *(expr + 3) == '9' && *(expr + 4) == ']') {
*compiled = '\\';
compiled++;
*compiled = 'd';
count++;
expr++;
expr++;
expr++;
expr++;
} else {
*compiled = *expr;
}
if (*compiled == '[') {
// in_brackets = true;
} else if (*compiled == ']') {
// in_brackets = false;
}
expr++;
compiled++;
count++;
}
*compiled = 0;
compiled -= count;
rrex3->compiled = compiled;
return rrex3;
}
inline static void rrex3_set_previous(rrex3_t *rrex3) {
rrex3->previous.function = rrex3->function;
rrex3->previous.expr = rrex3->expr;
rrex3->previous.str = rrex3->str;
rrex3->previous.bytecode = *rrex3->expr;
}
static bool rrex3_move(rrex3_t *rrex3, bool resume_on_fail) {
char *original_expr = rrex3->expr;
char *original_str = rrex3->str;
rrex3->bytecode = *rrex3->expr;
rrex3->function = rrex3->functions[(int)rrex3->bytecode];
rrex3->function(rrex3);
if (!*rrex3->expr && !*rrex3->str) {
rrex3->exit = true;
return rrex3->valid;
} else if (!*rrex3->expr) {
// rrex3->valid = true;
return rrex3->valid;
}
if (rrex3->pattern_error) {
rrex3->valid = false;
return rrex3->valid;
}
if (resume_on_fail && !rrex3->valid && *rrex3->expr) {
// rrex3_set_previous(rrex3);
rrex3->failed.bytecode = rrex3->bytecode;
rrex3->failed.function = rrex3->function;
rrex3->failed.expr = original_expr;
rrex3->failed.str = original_str;
rrex3->bytecode = *rrex3->expr;
rrex3->function = rrex3->functions[(int)rrex3->bytecode];
rrex3->function(rrex3);
if (!rrex3->valid && !rrex3->pattern_error) {
if (*rrex3->str) {
char *pipe_position = strstr(rrex3->expr, "|");
if (pipe_position != NULL) {
rrex3->expr = pipe_position + 1;
rrex3->str = rrex3->_str;
rrex3->valid = true;
return true;
}
}
if (rrex3->match_from_start) {
rrex3->valid = false;
return rrex3->valid;
}
if (!*rrex3->str++) {
rrex3->valid = false;
return rrex3->valid;
}
rrex3->expr = rrex3->_expr;
if (*rrex3->str)
rrex3->valid = true;
}
} else {
}
return rrex3->valid;
}
rrex3_t *rrex3(rrex3_t *rrex3, char *str, char *expr) {
#if RREX3_DEBUG == 1
printf("Regex check: %s:%s:%d\n", expr, str, 1);
#endif
bool self_initialized = false;
if (rrex3 == NULL) {
self_initialized = true;
rrex3 = rrex3_new();
} else {
rrex3_reset(rrex3);
}
rrex3->_str = str;
rrex3->_expr = rrex3->compiled ? rrex3->compiled : expr;
rrex3->str = rrex3->_str;
rrex3->expr = rrex3->_expr;
while (*rrex3->expr && !rrex3->exit) {
if (!rrex3_move(rrex3, true))
return NULL;
}
rrex3->expr = rrex3->_expr;
if (rrex3->valid) {
return rrex3;
} else {
if (self_initialized) {
rrex3_free(rrex3);
}
return NULL;
}
}
void rrex3_test() {
rrex3_t *rrex = rrex3_new();
assert(rrex3(rrex, "\"stdio.h\"\"string.h\"\"sys/time.h\"", "\"(.*)\"\"(.*)\"\"(.*)\""));
assert(rrex3(rrex, "aaaaaaa", "a*a$"));
// assert(rrex3("ababa", "a*b*a*b*a$"));
assert(rrex3(rrex, "#include\"test.h\"a", "#include.*\".*\"a$"));
assert(rrex3(rrex, "#include \"test.h\"a", "#include.*\".*\"a$"));
assert(rrex3(rrex, "aaaaaad", "a*d$"));
assert(rrex3(rrex, "abcdef", "abd?cdef"));
assert(!rrex3(rrex, "abcdef", "abd?def"));
assert(rrex3(rrex, "abcdef", "def"));
assert(!rrex3(rrex, "abcdef", "^def"));
assert(rrex3(rrex, "abcdef", "def$"));
assert(!rrex3(rrex, "abcdef", "^abc$"));
assert(rrex3(rrex, "aB!.#1", "......"));
assert(!rrex3(rrex, "aB!.#\n", " ......"));
assert(!rrex3(rrex, "aaaaaad", "q+d$"));
assert(rrex3(rrex, "aaaaaaa", "a+a$"));
assert(rrex3(rrex, "aaaaaad", "q*d$"));
assert(!rrex3(rrex, "aaaaaad", "^q*d$"));
// Asterisk function
assert(rrex3(rrex, "123321", "123*321"));
assert(rrex3(rrex, "pony", "p*ony"));
assert(rrex3(rrex, "pppony", "p*ony"));
assert(rrex3(rrex, "ppony", "p*pony"));
assert(rrex3(rrex, "pppony", "pp*pony"));
assert(rrex3(rrex, "pppony", ".*pony"));
assert(rrex3(rrex, "pony", ".*ony"));
assert(rrex3(rrex, "pony", "po*ny"));
// assert(rrex3(rrex,"ppppony", "p*pppony"));
// Plus function
assert(rrex3(rrex, "pony", "p+ony"));
assert(!rrex3(rrex, "ony", "p+ony"));
assert(rrex3(rrex, "ppony", "p+pony"));
assert(rrex3(rrex, "pppony", "pp+pony"));
assert(rrex3(rrex, "pppony", ".+pony"));
assert(rrex3(rrex, "pony", ".+ony"));
assert(rrex3(rrex, "pony", "po+ny"));
// Slash functions
assert(rrex3(rrex, "a", "\\w"));
assert(!rrex3(rrex, "1", "\\w"));
assert(rrex3(rrex, "1", "\\W"));
assert(!rrex3(rrex, "a", "\\W"));
assert(rrex3(rrex, "a", "\\S"));
assert(!rrex3(rrex, " ", "\\s"));
assert(!rrex3(rrex, "\t", "\\s"));
assert(!rrex3(rrex, "\n", "\\s"));
assert(rrex3(rrex, "1", "\\d"));
assert(!rrex3(rrex, "a", "\\d"));
assert(rrex3(rrex, "a", "\\D"));
assert(!rrex3(rrex, "1", "\\D"));
assert(rrex3(rrex, "abc", "\\b"));
assert(rrex3(rrex, "abc", "\\babc"));
assert(!rrex3(rrex, "abc", "a\\b"));
assert(!rrex3(rrex, "abc", "ab\\b"));
assert(!rrex3(rrex, "abc", "abc\\b"));
assert(rrex3(rrex, "abc", "a\\Bbc"));
assert(rrex3(rrex, "abc", "ab\\B"));
assert(!rrex3(rrex, "1ab", "1\\Bab"));
assert(rrex3(rrex, "abc", "a\\Bbc"));
// Escaping of special chars
assert(rrex3(rrex, "()+*.\\", "\\(\\)\\+\\*\\.\\\\"));
// Pipe
// assert(rrex3(rrex,"abc","abc|def"));
assert(rrex3(rrex, "abc", "def|jkl|abc"));
assert(rrex3(rrex, "abc", "abc|def"));
assert(rrex3(rrex, "rhq", "def|rhq|rha"));
assert(rrex3(rrex, "abc", "abc|def"));
// Repeat
assert(rrex3(rrex, "aaaaa", "a{4}"));
assert(rrex3(rrex, "aaaa", "a{1,3}a"));
// Range
assert(rrex3(rrex, "abc", "[abc][abc][abc]$"));
assert(rrex3(rrex, "def", "[^abc][^abc][^abc]$"));
assert(rrex3(rrex, "defabc", "[^abc][^abc][^abc]abc"));
assert(rrex3(rrex, "0-9", "0-9"));
assert(rrex3(rrex, "55-9", "[^6-9]5-9$"));
assert(rrex3(rrex, "a", "[a-z]$"));
assert(rrex3(rrex, "A", "[A-Z]$"));
assert(rrex3(rrex, "5", "[0-9]$"));
assert(!rrex3(rrex, "a", "[^a-z]$"));
assert(!rrex3(rrex, "A", "[^A-Z]$"));
assert(!rrex3(rrex, "5", "[^0-9]$"));
assert(rrex3(rrex, "123abc", "[0-9]*abc$"));
assert(rrex3(rrex, "123123", "[0-9]*$"));
// Parentheses
assert(rrex3(rrex, "datadata", "(data)*"));
assert(rrex3(rrex, "datadatapony", "(data)*pony$"));
assert(!rrex3(rrex, "datadatapony", "(d*p*ata)*pond$"));
assert(rrex3(rrex, "datadatadato", "(d*p*ata)*dato"));
assert(rrex3(rrex, "datadatadato", "(d*p*ata)*dato$"));
assert(!rrex3(rrex, "datadatadato", "(d*p*a*ta)*gato$"));
// Matches
assert(rrex3(rrex, "123", "(123)"));
assert(!strcmp(rrex->matches[0], "123"));
assert(rrex3(rrex, "123321a", "(123)([0-4][2]1)a$"));
assert(!strcmp(rrex->matches[1], "321"));
assert(rrex3(rrex, "123321a", "(123)([0-4][2]1)a$"));
assert(!strcmp(rrex->matches[1], "321"));
assert(rrex3(rrex, "aaaabc", "(.*)c"));
assert(rrex3(rrex, "abcde", ".....$"));
assert(rrex3(rrex, "abcdefghijklmnopqrstuvwxyz", "..........................$"));
// printf("(%d)\n", rrex->valid);
assert(rrex3(rrex, "#include <stdio.h>", "#include.*<(.*)>"));
assert(!strcmp(rrex->matches[0], "stdio.h"));
assert(rrex3(rrex, "#include \"stdlib.h\"", "#include.\"(.*)\""));
assert(!strcmp(rrex->matches[0], "stdlib.h"));
assert(rrex3(rrex, "\"stdio.h\"\"string.h\"\"sys/time.h\"", "\"(.*)\"\"(.*)\"\"(.*)\""));
assert(!strcmp(rrex->matches[0], "stdio.h"));
assert(!strcmp(rrex->matches[1], "string.h"));
assert(!strcmp(rrex->matches[2], "sys/time.h"));
assert(rrex3(rrex, " #include <stdio.h>", "#include.+<(.+)>"));
assert(!strcmp(rrex->matches[0], "stdio.h"));
assert(rrex3(rrex, " #include \"stdlib.h\"", "#include.+\"(.+)\""));
assert(!strcmp(rrex->matches[0], "stdlib.h"));
assert(rrex3(rrex, " \"stdio.h\"\"string.h\"\"sys/time.h\"", "\"(.+)\"\"(.+)\"\"(.+)\""));
assert(!strcmp(rrex->matches[0], "stdio.h"));
assert(!strcmp(rrex->matches[1], "string.h"));
assert(!strcmp(rrex->matches[2], "sys/time.h"));
assert(rrex3(rrex, "int abc ", "int (.*)[; ]?$"));
assert(!strcmp(rrex->matches[0], "abc"));
assert(rrex3(rrex, "int abc;", "int (.*)[; ]?$"));
assert(!strcmp(rrex->matches[0], "abc"));
assert(rrex3(rrex, "int abc", "int (.*)[; ]?$"));
assert(!strcmp(rrex->matches[0], "abc"));
rrex3_free(rrex);
}
#endif
#ifndef RARENA_H
#define RARENA_H
#include <stdlib.h>
#include <string.h>
typedef struct arena_t {
unsigned char *memory;
unsigned int pointer;
unsigned int size;
} arena_t;
arena_t *arena_construct() {
arena_t *arena = (arena_t *)rmalloc(sizeof(arena_t));
arena->memory = NULL;
arena->pointer = 0;
arena->size = 0;
return arena;
}
arena_t *arena_new(size_t size) {
arena_t *arena = arena_construct();
arena->memory = (unsigned char *)rmalloc(size);
arena->size = size;
return arena;
}
void *arena_alloc(arena_t *arena, size_t size) {
if (arena->pointer + size > arena->size) {
return NULL;
}
void *p = arena->memory + arena->pointer;
arena->pointer += size;
return p;
}
void arena_free(arena_t *arena) {
// Just constructed and unused arena memory is NULL so no free needed
if (arena->memory) {
rfree(arena->memory);
}
rfree(arena);
}
void arena_reset(arena_t *arena) { arena->pointer = 0; }
#endif
#ifndef RCASE_H
#define RCASE_H
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#define RCAMEL_CASE 1
#define RSNAKE_CASE 2
#define RINVALID_CASE 0
#define RCONST_TEST_T 4;
int rdetermine_case(const char *str) {
int length = strlen(str);
char p = 0;
while (*str) {
if (p == '_' && islower(*str))
return RSNAKE_CASE;
if (p != '_' && !isupper(p) && isupper(*str))
return RCAMEL_CASE;
p = *str;
str++;
}
return RINVALID_CASE;
if (length == 0) {
return RINVALID_CASE;
}
if (strchr(str, '_')) {
if (str[0] == '_' || str[length - 1] == '_' || strstr(str, "__")) {
return RINVALID_CASE;
}
for (int i = 0; i < length; i++) {
if (!islower(str[i]) && str[i] != '_') {
return RINVALID_CASE;
}
}
return RSNAKE_CASE;
} else {
if (!islower(str[0])) {
return RINVALID_CASE;
}
for (int i = 1; i < length; i++) {
if (str[i] == '_') {
return RINVALID_CASE;
}
if (isupper(str[i]) && isupper(str[i - 1])) {
return RINVALID_CASE;
}
}
return RCAMEL_CASE;
}
}
char *rsnake_to_camel(const char *snake_case) {
int length = strlen(snake_case);
char *camel_case = (char *)malloc(length + 1);
int j = 0;
int toUpper = 0;
for (int i = 0; i < length; i++) {
if (i > 0 && snake_case[i] == '_' && snake_case[i + 1] == 'T') {
toUpper = 1;
if (snake_case[i + 1] == 'T' && (snake_case[i + 2] != '\n' || snake_case[i + 2] != '\0' || snake_case[i + 2] != ' ')) {
toUpper = 0;
}
}
if (snake_case[i] == '_' && snake_case[i + 1] != 't') {
toUpper = 1;
if (snake_case[i + 1] == 't' && (snake_case[i + 2] != '\n' || snake_case[i + 2] != '\0' || snake_case[i + 2] != ' ')) {
toUpper = 0;
}
} else if (snake_case[i] == '_' && snake_case[i + 1] == 't' && !isspace(snake_case[i + 2])) {
toUpper = 1;
} else if (snake_case[i] == '_' && snake_case[i + 1] == 'T' && !isspace(snake_case[i + 2])) {
toUpper = 1;
camel_case[j++] = '_';
j++;
} else {
if (toUpper) {
camel_case[j++] = toupper(snake_case[i]);
toUpper = 0;
} else {
camel_case[j++] = snake_case[i];
}
}
}
camel_case[j] = '\0';
return camel_case;
}
char *rcamel_to_snake(const char *camelCase) {
int length = strlen(camelCase);
char *snake_case = (char *)malloc(2 * length + 1);
int j = 0;
for (int i = 0; i < length; i++) {
if (isupper(camelCase[i])) {
if (i != 0) {
snake_case[j++] = '_';
}
snake_case[j++] = tolower(camelCase[i]);
} else {
snake_case[j++] = camelCase[i];
}
}
snake_case[j] = '\0';
return snake_case;
}
char *rflip_case(char *content) {
if (rdetermine_case(content) == RSNAKE_CASE) {
return rcamel_to_snake(content);
} else if (rdetermine_case(content) == RCAMEL_CASE) {
return rsnake_to_camel(content);
} else {
rprintr("Could not determine case\n");
return NULL;
}
}
char *rflip_case_file(char *filepath) {
size_t file_size = rfile_size(filepath);
if (file_size == 0) {
return NULL;
}
char *content = (char *)malloc(file_size);
char *result = NULL;
if (rfile_readb(filepath, content, file_size)) {
result = rflip_case(content);
if (result) {
free(content);
return result;
} else {
return content;
}
}
return result;
}
int rcase_main(int argc, char *argv[]) {
if (argc < 2) {
printf("usage: rcase <file>\n");
return 1;
}
for (int i = 1; i < argc; i++) {
char *result = rflip_case_file(argv[i]);
if (result) {
printf("%s\n", result);
free(result);
}
}
return 0;
}
#endif
#ifndef RTERM_H
#define RTERM_H
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <termios.h>
#include <unistd.h>
typedef struct winsize winsize_t;
typedef struct rshell_keypress_t {
bool pressed;
bool ctrl;
bool shift;
bool escape;
char c;
int ms;
int fd;
} rshell_keypress_t;
typedef struct rterm_t {
bool show_cursor;
bool show_footer;
int ms_tick;
rshell_keypress_t key;
void (*before_cursor_move)(struct rterm_t *);
void (*after_cursor_move)(struct rterm_t *);
void (*after_key_press)(struct rterm_t *);
void (*before_key_press)(struct rterm_t *);
void (*before_draw)(struct rterm_t *);
void (*after_draw)(struct rterm_t *);
void *session;
unsigned long iterations;
void (*tick)(struct rterm_t *);
char *status_text;
char *_status_text_previous;
winsize_t size;
struct {
int x;
int y;
int pos;
int available;
} cursor;
} rterm_t;
typedef void (*rterm_event)(rterm_t *);
void rterm_init(rterm_t *rterm) {
memset(rterm, 0, sizeof(rterm_t));
rterm->show_cursor = true;
rterm->cursor.x = 0;
rterm->cursor.y = 0;
rterm->ms_tick = 100;
rterm->_status_text_previous = NULL;
}
void rterm_getwinsize(winsize_t *w) {
// Get the terminal size
if (ioctl(STDOUT_FILENO, TIOCGWINSZ, w) == -1) {
perror("ioctl");
exit(EXIT_FAILURE);
}
}
void rrawfd(int fd) {
struct termios orig_termios;
tcgetattr(fd, &orig_termios); // Get current terminal attributes
struct termios raw = orig_termios;
raw.c_lflag &= ~(ICANON | ISIG | ECHO); // ECHO // Disable canonical mode and echoing
raw.c_cc[VMIN] = 1;
raw.c_cc[VTIME] = 240; // Set timeout for read input
tcsetattr(fd, TCSAFLUSH, &raw);
}
// Terminal setup functions
void enableRawMode(struct termios *orig_termios) {
struct termios raw = *orig_termios;
raw.c_lflag &= ~(ICANON | ECHO); // Disable canonical mode and echoing
raw.c_cc[VMIN] = 1;
raw.c_cc[VTIME] = 240; // Set timeout for read input
tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw);
}
void disableRawMode(struct termios *orig_termios) {
tcsetattr(STDIN_FILENO, TCSAFLUSH,
orig_termios); // Restore original terminal settings
}
void rterm_clear_screen() {
printf("\x1b[2J"); // Clear the entire screen
printf("\x1b[H"); // Move cursor to the home position (0,0)
}
void setBackgroundColor() {
printf("\x1b[34m"); // Set background color to blue
}
void rterm_move_cursor(int x, int y) {
printf("\x1b[%d;%dH", y + 1, x + 1); // Move cursor to (x, y)
}
void cursor_set(rterm_t *rt, int x, int y) {
rt->cursor.x = x;
rt->cursor.y = y;
rt->cursor.pos = y * rt->size.ws_col + x;
rterm_move_cursor(rt->cursor.x, rt->cursor.y);
}
void cursor_restore(rterm_t *rt) { rterm_move_cursor(rt->cursor.x, rt->cursor.y); }
void rterm_print_status_bar(rterm_t *rt, char c, unsigned long i) {
if (rt->_status_text_previous && !strcmp(rt->_status_text_previous, rt->status_text)) {
return;
}
if (rt->_status_text_previous) {
free(rt->_status_text_previous);
}
rt->_status_text_previous = strdup(rt->status_text);
winsize_t ws = rt->size;
cursor_set(rt, rt->cursor.x, rt->cursor.y);
rterm_move_cursor(0, ws.ws_row - 1);
char output_str[1024];
output_str[0] = 0;
// strcat(output_str, "\x1b[48;5;240m");
for (int i = 0; i < ws.ws_col; i++) {
strcat(output_str, " ");
}
char content[500];
content[0] = 0;
if (!rt->status_text) {
sprintf(content, "\rp:%d:%d | k:%c:%d | i:%ld ", rt->cursor.x + 1, rt->cursor.y + 1, c == 0 ? '0' : c, c, i);
} else {
sprintf(content, "\r%s", rt->status_text);
}
strcat(output_str, content);
// strcat(output_str, "\x1b[0m");
printf("%s", output_str);
cursor_restore(rt);
}
void rterm_show_cursor() {
printf("\x1b[?25h"); // Show the cursor
}
void rterm_hide_cursor() {
printf("\x1b[?25l"); // Hide the cursor
}
rshell_keypress_t rshell_getkey(rterm_t *rt) {
static rshell_keypress_t press;
press.c = 0;
press.ctrl = false;
press.shift = false;
press.escape = false;
press.pressed = rfd_wait(0, rt->ms_tick);
if (!press.pressed) {
return press;
}
press.c = getchar();
char ch = press.c;
if (ch == '\x1b') {
// Get detail
ch = getchar();
if (ch == '[') {
// non char key:
press.escape = true;
ch = getchar(); // is a number. 1 if shift + arrow
press.c = ch;
if (ch >= '0' && ch <= '9')
ch = getchar();
press.c = ch;
if (ch == ';') {
ch = getchar();
press.c = ch;
if (ch == '5') {
press.ctrl = true;
press.c = getchar(); // De arrow
}
}
} else if (ch == 27) {
press.escape = true;
press.c = ch;
} else {
press.c = ch;
}
}
return press;
}
// Main function
void rterm_loop(rterm_t *rt) {
struct termios orig_termios;
tcgetattr(STDIN_FILENO, &orig_termios); // Get current terminal attributes
enableRawMode(&orig_termios);
int x = 0, y = 0; // Initial cursor position
char ch = 0;
;
while (1) {
rterm_getwinsize(&rt->size);
rt->cursor.available = rt->size.ws_col * rt->size.ws_row;
if (rt->tick) {
rt->tick(rt);
}
rterm_hide_cursor();
setBackgroundColor();
rterm_clear_screen();
if (rt->before_draw) {
rt->before_draw(rt);
}
rterm_print_status_bar(rt, ch, rt->iterations);
if (rt->after_draw) {
rt->after_draw(rt);
}
if (!rt->iterations || (x != rt->cursor.x || y != rt->cursor.y)) {
if (rt->cursor.y == rt->size.ws_row) {
rt->cursor.y--;
}
if (rt->cursor.y < 0) {
rt->cursor.y = 0;
}
x = rt->cursor.x;
y = rt->cursor.y;
if (rt->before_cursor_move)
rt->before_cursor_move(rt);
cursor_set(rt, rt->cursor.x, rt->cursor.y);
if (rt->after_cursor_move)
rt->after_cursor_move(rt);
// x = rt->cursor.x;
// y = rt->cursor.y;
}
if (rt->show_cursor)
rterm_show_cursor();
fflush(stdout);
rt->key = rshell_getkey(rt);
if (rt->key.pressed && rt->before_key_press) {
rt->before_key_press(rt);
}
rshell_keypress_t key = rt->key;
ch = key.c;
if (ch == 'q')
break; // Press 'q' to quit
if (key.c == -1) {
nsleep(1000 * 1000);
}
// Escape
if (key.escape) {
switch (key.c) {
case 65: // Move up
if (rt->cursor.y > -1)
rt->cursor.y--;
break;
case 66: // Move down
if (rt->cursor.y < rt->size.ws_row)
rt->cursor.y++;
break;
case 68: // Move left
if (rt->cursor.x > 0)
rt->cursor.x--;
if (key.ctrl)
rt->cursor.x -= 4;
break;
case 67: // Move right
if (rt->cursor.x < rt->size.ws_col) {
rt->cursor.x++;
}
if (key.ctrl) {
rt->cursor.x += 4;
}
break;
}
}
if (rt->key.pressed && rt->after_key_press) {
rt->after_key_press(rt);
}
rt->iterations++;
// usleep (1000);
}
// Cleanup
printf("\x1b[0m"); // Reset colors
rterm_clear_screen();
disableRawMode(&orig_termios);
}
#endif
#ifndef RTREE_H
#define RTREE_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct rtree_t {
struct rtree_t *next;
struct rtree_t *children;
char c;
void *data;
} rtree_t;
rtree_t *rtree_new() {
rtree_t *b = (rtree_t *)rmalloc(sizeof(rtree_t));
b->next = NULL;
b->children = NULL;
b->c = 0;
b->data = NULL;
return b;
}
rtree_t *rtree_set(rtree_t *b, char *c, void *data) {
while (b) {
if (b->c == 0) {
b->c = *c;
c++;
if (*c == 0) {
b->data = data;
// printf("SET1 %c\n", b->c);
return b;
}
} else if (b->c == *c) {
c++;
if (*c == 0) {
b->data = data;
return b;
}
if (b->children) {
b = b->children;
} else {
b->children = rtree_new();
b = b->children;
}
} else if (b->next) {
b = b->next;
} else {
b->next = rtree_new();
b = b->next;
b->c = *c;
c++;
if (*c == 0) {
b->data = data;
return b;
} else {
b->children = rtree_new();
b = b->children;
}
}
}
return NULL;
}
rtree_t *rtree_find(rtree_t *b, char *c) {
while (b) {
if (b->c == *c) {
c++;
if (*c == 0) {
return b;
}
b = b->children;
continue;
}
b = b->next;
}
return NULL;
}
void rtree_free(rtree_t *b) {
if (!b)
return;
rtree_free(b->children);
rtree_free(b->next);
rfree(b);
}
void *rtree_get(rtree_t *b, char *c) {
rtree_t *t = rtree_find(b, c);
if (t) {
return t->data;
}
return NULL;
}
#endif
#ifndef RLEXER_H
#define RLEXER_H
#include <ctype.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#define RTOKEN_VALUE_SIZE 1024
typedef enum rtoken_type_t {
RT_UNKNOWN = 0,
RT_SYMBOL,
RT_NUMBER,
RT_STRING,
RT_PUNCT,
RT_OPERATOR,
RT_EOF = 10,
RT_BRACE_OPEN,
RT_CURLY_BRACE_OPEN,
RT_BRACKET_OPEN,
RT_BRACE_CLOSE,
RT_CURLY_BRACE_CLOSE,
RT_BRACKET_CLOSE
} rtoken_type_t;
typedef struct rtoken_t {
rtoken_type_t type;
char value[RTOKEN_VALUE_SIZE];
unsigned int line;
unsigned int col;
} rtoken_t;
static char *_content;
static unsigned int _content_ptr;
static unsigned int _content_line;
static unsigned int _content_col;
static int isgroupingchar(char c) {
return (c == '{' || c == '}' || c == '(' || c == ')' || c == '[' || c == ']' || c == '"' || c == '\'');
}
static int isoperator(char c) {
return (c == '+' || c == '-' || c == '/' || c == '*' || c == '=' || c == '>' || c == '<' || c == '|' || c == '&');
}
static rtoken_t rtoken_new() {
rtoken_t token;
memset(&token, 0, sizeof(token));
token.type = RT_UNKNOWN;
return token;
}
rtoken_t rlex_number() {
rtoken_t token = rtoken_new();
token.col = _content_col;
token.line = _content_line;
bool first_char = true;
int dot_count = 0;
char c;
while (isdigit(c = _content[_content_ptr]) || (first_char && _content[_content_ptr] == '-') ||
(dot_count == 0 && _content[_content_ptr] == '.')) {
if (c == '.')
dot_count++;
first_char = false;
char chars[] = {c, 0};
strcat(token.value, chars);
_content_ptr++;
_content_col++;
}
token.type = RT_NUMBER;
return token;
}
static rtoken_t rlex_symbol() {
rtoken_t token = rtoken_new();
token.col = _content_col;
token.line = _content_line;
char c;
while (isalpha(_content[_content_ptr]) || _content[_content_ptr] == '_') {
c = _content[_content_ptr];
char chars[] = {c, 0};
strcat(token.value, chars);
_content_ptr++;
_content_col++;
}
token.type = RT_SYMBOL;
return token;
}
static rtoken_t rlex_operator() {
rtoken_t token = rtoken_new();
token.col = _content_col;
token.line = _content_line;
char c;
bool is_first = true;
while (isoperator(_content[_content_ptr])) {
if (!is_first) {
if (_content[_content_ptr - 1] == '=' && _content[_content_ptr] == '-') {
break;
}
}
c = _content[_content_ptr];
char chars[] = {c, 0};
strcat(token.value, chars);
_content_ptr++;
_content_col++;
is_first = false;
}
token.type = RT_OPERATOR;
return token;
}
static rtoken_t rlex_punct() {
rtoken_t token = rtoken_new();
token.col = _content_col;
token.line = _content_line;
char c;
bool is_first = true;
while (ispunct(_content[_content_ptr])) {
if (!is_first) {
if (_content[_content_ptr] == '"') {
break;
}
if (_content[_content_ptr] == '\'') {
break;
}
if (isgroupingchar(_content[_content_ptr])) {
break;
}
if (isoperator(_content[_content_ptr])) {
break;
}
}
c = _content[_content_ptr];
char chars[] = {c, 0};
strcat(token.value, chars);
_content_ptr++;
_content_col++;
is_first = false;
}
token.type = RT_PUNCT;
return token;
}
static rtoken_t rlex_string() {
rtoken_t token = rtoken_new();
char c;
token.col = _content_col;
token.line = _content_line;
char str_chr = _content[_content_ptr];
_content_ptr++;
while (_content[_content_ptr] != str_chr) {
c = _content[_content_ptr];
if (c == '\\') {
_content_ptr++;
c = _content[_content_ptr];
if (c == 'n') {
c = '\n';
} else if (c == 'r') {
c = '\r';
} else if (c == 't') {
c = '\t';
} else if (c == str_chr) {
c = str_chr;
}
_content_col++;
}
char chars[] = {c, 0};
strcat(token.value, chars);
_content_ptr++;
_content_col++;
}
_content_ptr++;
token.type = RT_STRING;
return token;
}
void rlex(char *content) {
_content = content;
_content_ptr = 0;
_content_col = 1;
_content_line = 1;
}
static void rlex_repeat_str(char *dest, char *src, unsigned int times) {
for (size_t i = 0; i < times; i++) {
strcat(dest, src);
}
}
rtoken_t rtoken_create(rtoken_type_t type, char *value) {
rtoken_t token = rtoken_new();
token.type = type;
token.col = _content_col;
token.line = _content_line;
strcpy(token.value, value);
return token;
}
rtoken_t rlex_next() {
while (true) {
_content_col++;
if (_content[_content_ptr] == 0) {
return rtoken_create(RT_EOF, "eof");
} else if (_content[_content_ptr] == '\n') {
_content_line++;
_content_col = 1;
_content_ptr++;
} else if (isspace(_content[_content_ptr])) {
_content_ptr++;
} else if (isdigit(_content[_content_ptr]) || (_content[_content_ptr] == '-' && isdigit(_content[_content_ptr + 1]))) {
return rlex_number();
} else if (isalpha(_content[_content_ptr]) || _content[_content_ptr] == '_') {
return rlex_symbol();
} else if (_content[_content_ptr] == '"' || _content[_content_ptr] == '\'') {
return rlex_string();
} else if (isoperator(_content[_content_ptr])) {
return rlex_operator();
} else if (ispunct(_content[_content_ptr])) {
if (_content[_content_ptr] == '{') {
_content_ptr++;
return rtoken_create(RT_CURLY_BRACE_OPEN, "{");
}
if (_content[_content_ptr] == '}') {
_content_ptr++;
return rtoken_create(RT_CURLY_BRACE_CLOSE, "}");
}
if (_content[_content_ptr] == '(') {
_content_ptr++;
return rtoken_create(RT_BRACE_OPEN, "(");
}
if (_content[_content_ptr] == ')') {
_content_ptr++;
return rtoken_create(RT_BRACE_CLOSE, ")");
}
if (_content[_content_ptr] == '[') {
_content_ptr++;
return rtoken_create(RT_BRACKET_OPEN, "[");
}
if (_content[_content_ptr] == ']') {
_content_ptr++;
return rtoken_create(RT_BRACKET_CLOSE, "]");
}
return rlex_punct();
}
}
}
char *rlex_format(char *content) {
rlex(content);
char *result = (char *)malloc(strlen(content) + 4096);
result[0] = 0;
unsigned int tab_index = 0;
char *tab_chars = " ";
unsigned int col = 0;
rtoken_t token_previous;
token_previous.value[0] = 0;
token_previous.type = RT_UNKNOWN;
while (true) {
rtoken_t token = rlex_next();
if (token.type == RT_EOF) {
break;
}
// col = strlen(token.value);
if (col == 0) {
rlex_repeat_str(result, tab_chars, tab_index);
// col = strlen(token.value);// strlen(tab_chars) * tab_index;
}
if (token.type == RT_STRING) {
strcat(result, "\"");
char string_with_slashes[strlen(token.value) * 2 + 1];
rstraddslashes(token.value, string_with_slashes);
strcat(result, string_with_slashes);
strcat(result, "\"");
// col+= strlen(token.value) + 2;
// printf("\n");
// printf("<<<%s>>>\n",token.value);
memcpy(&token_previous, &token, sizeof(token));
continue;
}
if (!(strcmp(token.value, "{"))) {
if (col != 0) {
strcat(result, "\n");
rlex_repeat_str(result, " ", tab_index);
}
strcat(result, token.value);
tab_index++;
strcat(result, "\n");
col = 0;
memcpy(&token_previous, &token, sizeof(token));
continue;
} else if (!(strcmp(token.value, "}"))) {
unsigned int tab_indexed = 0;
if (tab_index)
tab_index--;
strcat(result, "\n");
rlex_repeat_str(result, tab_chars, tab_index);
tab_indexed++;
strcat(result, token.value);
strcat(result, "\n");
col = 0;
memcpy(&token_previous, &token, sizeof(token));
continue;
}
if ((token_previous.type == RT_SYMBOL && token.type == RT_NUMBER) ||
(token_previous.type == RT_NUMBER && token.type == RT_SYMBOL) || (token_previous.type == RT_PUNCT && token.type == RT_SYMBOL) ||
(token_previous.type == RT_BRACE_CLOSE && token.type == RT_SYMBOL) ||
(token_previous.type == RT_SYMBOL && token.type == RT_SYMBOL)) {
if (token_previous.value[0] != ',' && token_previous.value[0] != '.') {
if (token.type != RT_OPERATOR && token.value[0] != '.') {
strcat(result, "\n");
rlex_repeat_str(result, tab_chars, tab_index);
}
}
}
if (token.type == RT_OPERATOR) {
strcat(result, " ");
}
if (token.type == RT_STRING) {
strcat(result, "\"");
}
strcat(result, token.value);
if (token.type == RT_STRING) {
strcat(result, "\"");
}
if (token.type == RT_OPERATOR) {
strcat(result, " ");
}
if (!strcmp(token.value, ",")) {
strcat(result, " ");
}
col += strlen(token.value);
memcpy(&token_previous, &token, sizeof(token));
}
return result;
}
#endif
#ifndef RLIB_MAIN
#define RLIB_MAIN
#ifndef RMERGE_H
#define RMERGE_H
// #include "../mrex/rmatch.h"
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
bool has_error = false;
char *extract_script_src_include(char *line, char *include_path) {
include_path[0] = 0;
rrex3_t *rrex;
rrex = rrex3(NULL, line, "<script.*src=\"(.*)\".*<.*script.*>");
if (rrex) {
strcpy(include_path, rrex->matches[0]);
rrex3_free(rrex);
return include_path;
}
return NULL;
}
char *extract_c_local_include(char *line, char *include_path) {
//
/*
char res;
res= rmatch_extract(line, "#include.*"\".*\"");
printf("%MATCH:%s\n", res);
*/
include_path[0] = 0;
rrex3_t *rrex;
rrex = rrex3(NULL, line, "[^\\\\*]^#include .*\"(.*)\"");
if (rrex) {
strcpy(include_path, rrex->matches[0]);
rrex3_free(rrex);
return include_path;
}
return NULL;
}
char *rmerge_readline(FILE *f) {
static char data[4096];
data[0] = 0;
int index = 0;
char c;
while ((c = fgetc(f)) != EOF) {
if (c != '\0') {
data[index] = c;
index++;
if (c == '\n')
break;
}
}
data[index] = 0;
if (data[0] == 0)
return NULL;
return data;
}
void writestring(FILE *f, char *line) {
char c;
while ((c = *line) != '\0') {
fputc(c, f);
line++;
}
}
char files_history[8096];
char files_duplicate[8096];
bool is_merging = false;
void merge_file(char *source, FILE *d) {
if (is_merging == false) {
is_merging = true;
files_history[0] = 0;
files_duplicate[0] = 0;
}
if (strstr(files_history, source)) {
if (strstr(files_duplicate, source)) {
rprintmf(stderr, "\\l Already included: %s. Already on duplicate list.\n", source);
} else {
rprintcf(stderr, "\\l Already included: %s. Adding to duplicate list.\n", source);
strcat(files_duplicate, source);
strcat(files_duplicate, "\n");
}
return;
} else {
rprintgf(stderr, "\\l Merging: %s.\n", source);
strcat(files_history, source);
strcat(files_history, "\n");
}
FILE *fd = fopen(source, "rb");
if (!fd) {
rprintrf(stderr, "\\l File does not exist: %s\n", source);
has_error = true;
return;
}
char *line;
char include_path[4096];
while ((line = rmerge_readline(fd))) {
include_path[0] = 0;
if (!*line)
break;
//
char *inc = extract_c_local_include(line, include_path);
if (!inc)
inc = extract_script_src_include(line, include_path);
/*
if (!strncmp(line, "#include ", 9)) {
int index = 0;
while (line[index] != '"' && line[index] != 0) {
index++;
}
if (line[index] == '"') {
int pindex = 0;
index++;
while (line[index] != '"') {
include_path[pindex] = line[index];
pindex++;
index++;
}
if (line[index] != '"') {
include_path[0] = 0;
} else {
include_path[pindex] = '\0';
}
}
}*/
if (inc) {
merge_file(inc, d);
} else {
writestring(d, line);
}
}
fclose(fd);
writestring(d, "\n");
}
int rmerge_main(int argc, char *argv[]) {
char *file_input = NULL;
if (argc != 2) {
printf("Usage: <input-file>\n");
} else {
file_input = argv[1];
// file_output = argv[2];
}
FILE *f = tmpfile();
printf("// RETOOR - %s\n", __DATE__);
merge_file(file_input, f);
rewind(f);
char *data;
int line_number = 0;
while ((data = rmerge_readline(f))) {
if (line_number) {
printf("/*%.5d*/ ", line_number);
line_number++;
}
printf("%s", data);
}
printf("\n");
if (has_error) {
rprintrf(stderr, "\\l Warning: there are errors while merging this file.\n");
} else {
rprintgf(stderr, "\\l Merge succesful without error(s).%s\n", remo_get("fire"));
}
return 0;
}
#endif
void forward_argument(int *argcc, char *argv[]) {
int argc = *argcc;
for (int i = 0; i < argc; i++) {
argv[i] = argv[i + 1];
}
argc--;
*argcc = argc;
}
int rlib_main(int argc, char *argv[]) {
if (argc == 1) {
printf("rlib\n\n");
printf("options:\n");
printf(" httpd - a http file server. Accepts port as argument.\n");
printf(" rmerge - a merge tool. Converts c source files to one file \n"
" with local includes by giving main file as argument.\n");
printf(" rcov - coverage tool theat cleans up after himself. Based on "
"lcov.\n");
printf(" rcase - tool to swap input file automatically between"
" camel case and snake case.\n");
return 0;
}
forward_argument(&argc, argv);
if (!strcmp(argv[0], "httpd")) {
return rhttp_main(argc, argv);
}
if (!strcmp(argv[0], "rmerge")) {
return rmerge_main(argc, argv);
}
if (!strcmp(argv[0], "rcov")) {
return rcov_main(argc, argv);
}
if (!strcmp(argv[0], "rcase")) {
return rcase_main(argc, argv);
}
return 0;
}
#endif
// END OF RLIB
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct sormstr_t {
char *content;
size_t length;
size_t buffer_size;
size_t size;
} sormstr_t;
sormstr_t *sormstrn(size_t buffer_size) {
sormstr_t *result = (sormstr_t *)malloc(sizeof(sormstr_t));
result->length = 0;
result->size = buffer_size;
result->buffer_size = buffer_size;
result->content = (char *)malloc(buffer_size);
result->content[0] = 0;
return result;
}
void sormstra(sormstr_t *str, const char *to_append) {
size_t required_new_length = str->length + strlen(to_append);
str->length += strlen(to_append);
if (required_new_length > str->size) {
str->size += required_new_length + str->buffer_size;
str->content = realloc(str->content, str->size + 1);
} else {
// printf("NO NDEED\n");
}
strcat(str->content, to_append);
str->content[str->length] = 0;
}
void sormstrd(sormstr_t *str) {
if (str->content) {
free(str->content);
}
free(str);
}
char *sormstrc(sormstr_t *str) {
// sorm str convert
char *content = str->content;
str->content = NULL;
sormstrd(str);
return content;
}
#endif
#include <ctype.h>
#include <sqlite3.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
sqlite3 *db;
sqlite3_stmt *stmt;
char *sorm_last_query = NULL;
char *sorm_last_query_expanded = NULL;
nsecs_t _sorm_query_start = 0;
nsecs_t _sorm_query_end = 0;
nsecs_t _sorm_query_duration = 0;
nsecs_t _sorm_result_format_start = 0;
nsecs_t _sorm_result_format_end = 0;
nsecs_t _sorm_result_format_duration = 0;
int64_t sorm_row_count = 0;
typedef struct sorm_t {
sqlite3 *conn;
int current_row;
int current_column;
char *csv;
nsecs_t time_query_start;
nsecs_t time_query_end;
nsecs_t time_query_duration;
nsecs_t time_result_format_start;
nsecs_t time_result_format_end;
nsecs_t time_result_format_duration;
} sorm_t;
typedef char *sorm_pk;
typedef char *sorm_int;
typedef char *sorm_ptr;
typedef unsigned char *sorm_str;
typedef double sorm_double;
typedef double sorm_float;
typedef bool sorm_bool;
int sormc(char *path);
void sormd(int db);
char *sormpt(char *sql, int number);
unsigned int sormcq(char *sql, char *out);
unsigned int sormpc(char *sql);
sqlite3_stmt *sormb(sorm_t *db, char *sql, ...);
sorm_ptr sormq(int db, char *sql, ...);
char *sorm_csvc(int db, sqlite3_stmt *stmt);
char *sorm_csvd(int db, sqlite3_stmt *stmt);
char *sorm_csv(int db, sqlite3_stmt *stmt);
typedef enum sorm_query_t {
SORM_UNKNOWN = 0,
SORM_SELECT = 1,
SORM_INSERT = 2,
SORM_UPDATE = 3,
SORM_DELETE = 4,
SORM_CREATE = 5
} sorm_query_t;
const int sorm_null = -1337;
sorm_t **sorm_instances = NULL;
int sorm_instance_count = 0;
int sormc(char *path) {
// sorm connect
printf("HIERR\n");
sorm_instance_count++;
sorm_instance_count++;
sorm_instances = realloc(sorm_instances, sorm_instance_count * sizeof(sorm_t *) + sorm_instance_count * sizeof(sorm_t));
printf("HIERR\n");
sorm_t *db = &sorm_instances[sorm_instance_count - 1];
printf("HIERR\n");
db->conn = NULL;
printf("HIERR\n");
db->csv = NULL;
db->current_column = 0;
db->current_row = 0;
db->time_query_duration = 0;
db->time_query_end = 0;
db->time_query_start = 0;
db->time_result_format_duration = 0;
db->time_result_format_end = 0;
db->time_result_format_start = 0;
if (sqlite3_open(path, &db->conn)) {
fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db->conn));
return 0;
}
printf("DONE!\n");
return sorm_instance_count;
}
sorm_t *sormg(int ptr) { return &sorm_instances[ptr - 1]; }
char *sormgcsv(int ptr) {
/* sorm get csv*/
sorm_t *db = sormg(ptr);
return db->csv;
}
void sormd(int sorm) {
sorm_t *db = sormg(sorm);
if (sqlite3_close(db->conn)) {
fprintf(stderr, "Error closing database: %s\n", sqlite3_errmsg(db->conn));
}
if (sorm_last_query) {
free(sorm_last_query);
sorm_last_query = NULL;
}
if (sorm_last_query_expanded) {
free(sorm_last_query_expanded);
sorm_last_query_expanded = NULL;
}
}
char *sormpt(char *sql, int number) {
// param type
char *sqlp = sql;
char *result = NULL;
int index = 0;
while (*sqlp) {
if (*sqlp == '%' || *sqlp == '?') {
sqlp++;
switch (*sqlp) {
case 'f':
result = "double";
break;
case 's':
result = "text";
break;
case 'd':
result = "int";
break;
case 'b':
result = "blob";
break;
default:
result = "?";
break;
}
sqlp++;
index++;
}
if (index == number) {
return result;
}
if (*sqlp)
sqlp++;
}
if (number > index) {
printf("RETURNED\n");
return NULL;
}
return NULL;
}
unsigned int sormcq(char *sql, char *out) {
// clean query
// converts %s %i parameters to ?
unsigned int count = 0;
while (*sql) {
if (*sql != '%' && *sql != '?')
*out = *sql;
else {
count++;
sql++;
*out = '?';
}
out++;
sql++;
}
*out = 0;
return count;
}
unsigned int sormpc(char *sql) {
int number = 0;
while (sormpt(sql, number) != NULL)
number++;
printf("FOUND: %d\n", number);
return number;
}
char *sormcts(int column_type) {
if (column_type == SQLITE_INTEGER)
return "integer";
else if (column_type == SQLITE_TEXT)
return "text";
else if (column_type == SQLITE_FLOAT)
return "float";
else if (column_type == SQLITE_NULL)
return "null";
else if (column_type == SQLITE_BLOB)
return "blob";
return "?";
}
/*
Execute 3.35s, Format: 36.77s
Memory usage: 537 GB, 96.026 allocated, 96.024 freed, 2 in use.
*/
char *sorm_csvc(int db, sqlite3_stmt *stmt) {
sormstr_t *str = sormstrn(512);
unsigned int column_count = sqlite3_column_count(stmt);
for (int i = 0; i < column_count; i++) {
const char *column_name = sqlite3_column_name(stmt, i);
sormstra(str, column_name);
sormstra(str, "(");
char column_type[1000] = "";
sprintf(column_type, "%s", sormcts(sqlite3_column_type(stmt, i)));
sormstra(str, column_type);
sormstra(str, ")");
// if(i != column_count - 1)
sormstra(str, ";");
}
return sormstrc(str);
}
char *sorm_csvd(int sorm, sqlite3_stmt *stmt) {
sorm_t *db = sormg(sorm);
int rc = SQLITE_ROW;
int column_count = sqlite3_column_count(stmt);
/*
sormstrn(1)
Execute 3.41s, Format: 36.77s
Memory usage: 5 MB, 96.061 (re)allocated, 96.024 unqiue freed, 2 in use.
sormstrn(512)
Execute 3.68s, Format: 36.83s
Memory usage: 537 GB, 96.026 allocated, 96.024 freed, 2 in use.
sormstrn(256)
xecute 3.42s, Format: 37.33s
Memory usage: 6 MB, 96.052 (re)allocated, 96.024 unqiue freed, 2 in use.
*/
sormstr_t *str = sormstrn(512);
while (rc == SQLITE_ROW) {
sorm_row_count++;
for (int field_index = 0; field_index < column_count; field_index++) {
if (sqlite3_column_type(stmt, field_index) == SQLITE_INTEGER) {
char temp[1000] = "";
sprintf(temp, "%lld", sqlite3_column_int64(stmt, field_index));
sormstra(str, temp);
} else if (sqlite3_column_type(stmt, field_index) == SQLITE_FLOAT) {
char temp[1000] = "";
sprintf(temp, "%f", sqlite3_column_double(stmt, field_index));
sormstra(str, temp);
} else if (sqlite3_column_type(stmt, field_index) == SQLITE3_TEXT) {
const char *temp = sqlite3_column_text(stmt, field_index);
sormstra(str, temp);
} else {
// exit(1);
}
// if(field_index != column_count - 1)
sormstra(str, ";");
}
sormstra(str, "\n");
rc = sqlite3_step(stmt);
}
char *text = sormstrc(str);
if (*text)
if (text[strlen(text) - 1] == '\n')
text[strlen(text) - 1] = 0;
return strdup(text);
}
char *sorm_csv(int sorm, sqlite3_stmt *stmt) {
sorm_t *db = sormg(sorm);
sorm_row_count = 0;
char *column_names = sorm_csvc(sorm, stmt);
char *data = sorm_csvd(sorm, stmt);
char *result = (char *)malloc(strlen(column_names) + strlen(data) + 2);
result[0] = 0;
strcat(result, column_names);
if (*column_names)
strcat(result, "\n");
free(column_names);
strcat(result, data);
free(data);
return result;
}
sqlite3_stmt *sormb(sorm_t *db, char *sql, ...) {
// Bind parameters to statement and return amount of parameters
int rc = 0;
sqlite3_stmt *stmt;
va_list args;
va_start(args, sql);
unsigned int number = 0;
char *clean_query = (char *)malloc(strlen(sql) + 1);
unsigned int parameter_count = sormcq(sql, clean_query);
free(clean_query);
return stmt;
}
char *sormm(sorm_t *db) {
/* sormmemory */
return rmalloc_stats();
}
sorm_ptr sormq(int sorm, char *sql, ...) {
sorm_t *db = sormg(sorm);
if (db->csv) {
// free(db->csv);
// db->csv = NULL;
}
_sorm_query_start = nsecs();
db->time_query_start = nsecs();
va_list args;
va_start(args, sql);
sqlite3_stmt *stmt;
sorm_ptr result = NULL;
char *clean_query = malloc(strlen(sql) + 1);
unsigned int parameter_count = sormcq(sql, clean_query);
int rc = sqlite3_prepare_v2(db->conn, clean_query, -1, &stmt, 0);
if (rc != SQLITE_OK) {
fprintf(stderr, "%s\n", sqlite3_errmsg(db->conn));
}
free(clean_query);
int number = 0;
for (int i = 0; i < parameter_count; i++) {
number++;
char *column_type = sormpt(sql, number);
int arg_index = number - 1;
if (!strcmp(column_type, "int") || !strcmp(column_type, "integer") || !strcmp(column_type, "number")) {
rc = sqlite3_bind_int(stmt, number, va_arg(args, int));
} else if (!strcmp(column_type, "int64")) {
rc = sqlite3_bind_int64(stmt, number, va_arg(args, __uint64_t));
} else if (!strcmp(column_type, "double") || !strcmp(column_type, "dec") || !strcmp(column_type, "decimal") ||
!strcmp(column_type, "float")) {
rc = sqlite3_bind_double(stmt, number, va_arg(args, double));
} else if (!strcmp(column_type, "blob")) {
size_t size = (size_t)va_arg(args, size_t);
unsigned char *data = va_arg(args, unsigned char *);
rc = sqlite3_bind_blob(stmt, number, data, size, SQLITE_STATIC);
} else if (!strcmp(column_type, "text") || !strcmp(column_type, "str") || !strcmp(column_type, "string")) {
unsigned char *data = va_arg(args, unsigned char *);
rc = sqlite3_bind_text(stmt, number, data, -1, SQLITE_STATIC);
}
if (rc != SQLITE_OK) {
fprintf(stderr, "Failed to bind parameters: %s\n", sqlite3_errmsg(db->conn));
result = NULL;
}
}
rc = sqlite3_step(stmt);
if (rc != SQLITE_DONE && rc != SQLITE_ROW) {
fprintf(stderr, "Execution failed: %s\n", sqlite3_errmsg(db->conn));
} else if (rc == SQLITE_DONE) {
if (!sqlite3_strnicmp(sql, "SELECT", 6)) {
result = 0;
} else {
result = (sorm_ptr)sqlite3_last_insert_rowid(db->conn);
}
} else if (rc == SQLITE_ROW) {
result = sorm_csv(sorm, stmt);
}
else {
fprintf(stderr, "Execution failed: %s\n", sqlite3_errmsg(db->conn));
}
if (sorm_last_query) {
free(sorm_last_query);
}
if (sorm_last_query) {
free(sorm_last_query_expanded);
}
sorm_last_query = strdup(sqlite3_sql(stmt));
sorm_last_query_expanded = strdup(sqlite3_expanded_sql(stmt));
sqlite3_finalize(stmt);
_sorm_query_end = nsecs();
_sorm_query_duration = _sorm_query_end - _sorm_query_start;
db->time_query_end = nsecs();
db->time_query_duration = db->time_query_end - db->time_query_start;
db->csv = result;
return result;
}
char sormlc(char *sql) {
// returns last char
char last_char = 0;
while (*sql) {
if (*sql == ' ' || *sql == '\t' || *sql == '\n')
continue;
// printf("%c\n",*sql);
last_char = *sql;
sql++;
}
return last_char;
}
int sormlv(char *csv) {
size_t longest = 0;
while (*csv) {
char *found = strstr(csv, ";");
if (found) {
if (found - csv > longest)
longest = found - csv;
csv = csv + (found - csv) + 1;
} else {
break;
}
}
return longest;
}
sorm_query_t sormqt(char *sql) {
while (*sql && isspace(*sql))
sql++;
if (!sqlite3_strnicmp(sql, "select", 6))
return SORM_SELECT;
else if (!sqlite3_strnicmp(sql, "update", 6))
return SORM_UPDATE;
else if (!sqlite3_strnicmp(sql, "delete", 6))
return SORM_DELETE;
else if (!sqlite3_strnicmp(sql, "create", 6)) {
return SORM_CREATE;
} else {
return SORM_UNKNOWN;
}
}
char *sormrq(FILE *f) {
static char buffer[4097];
buffer[0] = 0;
char *bufferp = buffer;
char c;
bool in_string = false;
while ((c = fgetc(f)) != EOF && strlen(buffer) != sizeof(buffer) - 2) {
*bufferp = c;
if (c == '"') {
in_string = !in_string;
}
if (!in_string && c == ';') {
break;
}
bufferp++;
*bufferp = 0;
}
return strdup(buffer);
}
char *sormcsvn(char *csv) {
if (!csv || !*csv)
return NULL;
char *pos = strstr(csv, ";");
char *pos2 = strstr(csv, "\n");
if (pos2) {
if (pos > pos2) {
pos = pos2;
}
// pos = pos > pos2 ? pos2 : pos;
}
if (!pos || !*pos)
return strdup(csv);
int length = pos - csv;
char *result = malloc(length + 2);
strncpy(result, csv, length);
result[length] = 0;
// csv += strlen(result);
return result;
}
char *sormfmt(char *csv) {
_sorm_result_format_start = nsecs();
size_t longest = sormlv(csv);
char *field;
/*
sormstrn(1)
Execute 3.77s, Format: 36.40s
Memory usage: 6 MB, 96.055 (re)allocated, 96.024 unqiue freed, 2 in use.
sormstrn(longest);
Execute 3.27s, Format: 36.61s
Memory usage: 6 MB, 96.053 (re)allocated, 96.024 unqiue freed, 2 in use.
sormstrn(longest * 2);
xecute 3.42s, Format: 37.33s
Memory usage: 6 MB, 96.052 (re)allocated, 96.024 unqiue freed, 2 in use.
sormstrn(512);
Execute 3.11s, Format: 36.45s
Memory usage: 6 MB, 96.048 (re)allocated, 96.024 unqiue freed, 2 in use.
*/
sormstr_t *str = sormstrn(longest + 2);
while (*csv && (field = sormcsvn(csv))) {
sormstra(str, field);
for (int i = 0; i < longest - strlen(field); i++)
sormstra(str, " ");
csv += strlen(field);
while (*csv == ';' || *csv == '\n') {
if (*csv == '\n')
sormstra(str, "\n");
csv++;
}
free(field);
}
_sorm_result_format_end = nsecs();
_sorm_result_format_duration = _sorm_result_format_end - _sorm_result_format_start;
return sormstrc(str);
}
void apply_colors(char *csv) {
char *end;
bool even = false;
while (*csv) {
printf("%s\n", csv);
end = strstr(csv, "\n");
char *line;
if (end) {
line = (char *)malloc(end - csv + 1024);
strncpy(line, csv, end - csv);
} else {
line = (char *)malloc(strlen(csv) + 1024);
strcpy(line, csv);
}
if (even) {
printf("%s", "\033[37m");
}
printf("%s\n", line);
free(line);
if (even) {
printf("%s", "\033[0m");
}
even = !even;
csv += end - csv;
if (*csv && *(csv + 1))
csv++;
}
}
void sormfmtd(char *csv) {
char *formatted = sormfmt(csv);
printf("%s\n", formatted);
free(formatted);
}
#endif
Reference in New Issue Copy Permalink