C Programming
made by https://0x3d.site
GitHub - antirez/sds: Simple Dynamic Strings library for CSimple Dynamic Strings library for C. Contribute to antirez/sds development by creating an account on GitHub.
Visit Site
GitHub - antirez/sds: Simple Dynamic Strings library for C
Simple Dynamic Strings
Notes about version 2: this is an updated version of SDS in an attempt to finally unify Redis, Disque, Hiredis, and the stand alone SDS versions. This version is NOT binary compatible* with SDS verison 1, but the API is 99% compatible so switching to the new lib should be trivial.
Note that this version of SDS may be a slower with certain workloads, but uses less memory compared to V1 since header size is dynamic and depends to the string to alloc.
Moreover it includes a few more API functions, notably sdscatfmt
which
is a faster version of sdscatprintf
that can be used for the simpler
cases in order to avoid the libc printf
family functions performance
penalty.
How SDS strings work
SDS is a string library for C designed to augment the limited libc string handling functionalities by adding heap allocated strings that are:
- Simpler to use.
- Binary safe.
- Computationally more efficient.
- But yet... Compatible with normal C string functions.
This is achieved using an alternative design in which instead of using a C structure to represent a string, we use a binary prefix that is stored before the actual pointer to the string that is returned by SDS to the user.
+--------+-------------------------------+-----------+
| Header | Binary safe C alike string... | Null term |
+--------+-------------------------------+-----------+
|
`-> Pointer returned to the user.
Because of meta data stored before the actual returned pointer as a prefix, and because of every SDS string implicitly adding a null term at the end of the string regardless of the actual content of the string, SDS strings work well together with C strings and the user is free to use them interchangeably with other std C string functions that access the string in read-only.
SDS was a C string I developed in the past for my everyday C programming needs, later it was moved into Redis where it is used extensively and where it was modified in order to be suitable for high performance operations. Now it was extracted from Redis and forked as a stand alone project.
Because of its many years life inside Redis, SDS provides both higher level functions for easy strings manipulation in C, but also a set of low level functions that make it possible to write high performance code without paying a penalty for using an higher level string library.
Advantages and disadvantages of SDS
Normally dynamic string libraries for C are implemented using a structure that defines the string. The structure has a pointer field that is managed by the string function, so it looks like this:
struct yourAverageStringLibrary {
char *buf;
size_t len;
... possibly more fields here ...
};
SDS strings as already mentioned don't follow this schema, and are instead a single allocation with a prefix that lives before the address actually returned for the string.
There are advantages and disadvantages with this approach over the traditional approach:
Disadvantage #1: many functions return the new string as value, since sometimes SDS requires to create a new string with more space, so the most SDS API calls look like this:
s = sdscat(s,"Some more data");
As you can see s
is used as input for sdscat
but is also set to the value
returned by the SDS API call, since we are not sure if the call modified the
SDS string we passed or allocated a new one. Not remembering to assign back
the return value of sdscat
or similar functions to the variable holding
the SDS string will result in a bug.
Disadvantage #2: if an SDS string is shared in different places in your program you have to modify all the references when you modify the string. However most of the times when you need to share SDS strings it is much better to encapsulate them into structures with a reference count
otherwise it is too easy to incur into memory leaks.
Advantage #1: you can pass SDS strings to functions designed for C functions without accessing a struct member or calling a function, like this:
printf("%s\n", sds_string);
In most other libraries this will be something like:
printf("%s\n", string->buf);
Or:
printf("%s\n", getStringPointer(string));
Advantage #2: accessing individual chars is straightforward. C is a low level language so this is an important operation in many programs. With SDS strings accessing individual chars is very natural:
printf("%c %c\n", s[0], s[1]);
With other libraries your best chance is to assign string->buf
(or call the function to get the string pointer) to a char
pointer and work with this. However since the other libraries may reallocate the buffer implicitly every time you call a function that may modify the string you have to get a reference to the buffer again.
Advantage #3: single allocation has better cache locality. Usually when you access a string created by a string library using a structure, you have two different allocations for the structure representing the string, and the actual buffer holding the string. Over the time the buffer is reallocated, and it is likely that it ends in a totally different part of memory compared to the structure itself. Since modern programs performances are often dominated by cache misses, SDS may perform better in many workloads.
SDS basics
The type of SDS strings is just the char pointer char *
. However SDS defines
an sds
type as alias of char *
in its header file: you should use the
sds
type in order to make sure you remember that a given variable in your
program holds an SDS string and not a C string, however this is not mandatory.
This is the simplest SDS program you can write that does something:
sds mystring = sdsnew("Hello World!");
printf("%s\n", mystring);
sdsfree(mystring);
output> Hello World!
The above small program already shows a few important things about SDS:
- SDS strings are created, and heap allocated, via the
sdsnew()
function, or other similar functions that we'll see in a moment. - SDS strings can be passed to
printf()
like any other C string. - SDS strings require to be freed with
sdsfree()
, since they are heap allocated.
Creating SDS strings
sds sdsnewlen(const void *init, size_t initlen);
sds sdsnew(const char *init);
sds sdsempty(void);
sds sdsdup(const sds s);
There are many ways to create SDS strings:
-
The
sdsnew
function creates an SDS string starting from a C null terminated string. We already saw how it works in the above example. -
The
sdsnewlen
function is similar tosdsnew
but instead of creating the string assuming that the input string is null terminated, it gets an additional length parameter. This way you can create a string using binary data:char buf[3]; sds mystring; buf[0] = 'A'; buf[1] = 'B'; buf[2] = 'C'; mystring = sdsnewlen(buf,3); printf("%s of len %d\n", mystring, (int) sdslen(mystring)); output> ABC of len 3
Note:
sdslen
return value is casted toint
because it returns asize_t
type. You can use the rightprintf
specifier instead of casting. -
The
sdsempty()
function creates an empty zero-length string:sds mystring = sdsempty(); printf("%d\n", (int) sdslen(mystring)); output> 0
-
The
sdsdup()
function duplicates an already existing SDS string:sds s1, s2; s1 = sdsnew("Hello"); s2 = sdsdup(s1); printf("%s %s\n", s1, s2); output> Hello Hello
Obtaining the string length
size_t sdslen(const sds s);
In the examples above we already used the sdslen
function in order to get
the length of the string. This function works like strlen
of the libc
except that:
- It runs in constant time since the length is stored in the prefix of SDS strings, so calling
sdslen
is not expensive even when called with very large strings. - The function is binary safe like any other SDS string function, so the length is the true length of the string regardless of the content, there is no problem if the string includes null term characters in the middle.
As an example of the binary safeness of SDS strings, we can run the following code:
sds s = sdsnewlen("A\0\0B",4);
printf("%d\n", (int) sdslen(s));
output> 4
Note that SDS strings are always null terminated at the end, so even in that
case s[4]
will be a null term, however printing the string with printf
would result in just "A"
to be printed since libc will treat the SDS string
like a normal C string.
Destroying strings
void sdsfree(sds s);
The destroy an SDS string there is just to call sdsfree
with the string
pointer. Note that even empty strings created with sdsempty
need to be
destroyed as well otherwise they'll result into a memory leak.
The function sdsfree
does not perform any operation if instead of an SDS
string pointer, NULL
is passed, so you don't need to check for NULL
explicitly before calling it:
if (string) sdsfree(string); /* Not needed. */
sdsfree(string); /* Same effect but simpler. */
Concatenating strings
Concatenating strings to other strings is likely the operation you will end using the most with a dynamic C string library. SDS provides different functions to concatenate strings to existing strings.
sds sdscatlen(sds s, const void *t, size_t len);
sds sdscat(sds s, const char *t);
The main string concatenation functions are sdscatlen
and sdscat
that are
identical, the only difference being that sdscat
does not have an explicit
length argument since it expects a null terminated string.
sds s = sdsempty();
s = sdscat(s, "Hello ");
s = sdscat(s, "World!");
printf("%s\n", s);
output> Hello World!
Sometimes you want to cat an SDS string to another SDS string, so you don't need to specify the length, but at the same time the string does not need to be null terminated but can contain any binary data. For this there is a special function:
sds sdscatsds(sds s, const sds t);
Usage is straightforward:
sds s1 = sdsnew("aaa");
sds s2 = sdsnew("bbb");
s1 = sdscatsds(s1,s2);
sdsfree(s2);
printf("%s\n", s1);
output> aaabbb
Sometimes you don't want to append any special data to the string, but you want to make sure that there are at least a given number of bytes composing the whole string.
sds sdsgrowzero(sds s, size_t len);
The sdsgrowzero
function will do nothing if the current string length is
already len
bytes, otherwise it will enlarge the string to len
just padding
it with zero bytes.
sds s = sdsnew("Hello");
s = sdsgrowzero(s,6);
s[5] = '!'; /* We are sure this is safe because of sdsgrowzero() */
printf("%s\n', s);
output> Hello!
Formatting strings
There is a special string concatenation function that accepts a printf
alike
format specifier and cats the formatted string to the specified string.
sds sdscatprintf(sds s, const char *fmt, ...) {
Example:
sds s;
int a = 10, b = 20;
s = sdsnew("The sum is: ");
s = sdscatprintf(s,"%d+%d = %d",a,b,a+b);
Often you need to create SDS string directly from printf
format specifiers.
Because sdscatprintf
is actually a function that concatenates strings, all
you need is to concatenate your string to an empty string:
char *name = "Anna";
int loc = 2500;
sds s;
s = sdscatprintf(sdsempty(), "%s wrote %d lines of LISP\n", name, loc);
You can use sdscatprintf
in order to convert numbers into SDS strings:
int some_integer = 100;
sds num = sdscatprintf(sdsempty(),"%d\n", some_integer);
However this is slow and we have a special function to make it efficient.
Fast number to string operations
Creating an SDS string from an integer may be a common operation in certain
kind of programs, and while you may do this with sdscatprintf
the performance
hit is big, so SDS provides a specialized function.
sds sdsfromlonglong(long long value);
Use it like this:
sds s = sdsfromlonglong(10000);
printf("%d\n", (int) sdslen(s));
output> 5
Trimming strings and getting ranges
String trimming is a common operation where a set of characters are removed from the left and the right of the string. Another useful operation regarding strings is the ability to just take a range out of a larger string.
void sdstrim(sds s, const char *cset);
void sdsrange(sds s, int start, int end);
SDS provides both the operations with the sdstrim
and sdsrange
functions.
However note that both functions work differently than most functions modifying
SDS strings since the return value is void: basically those functions always
destructively modify the passed SDS string, never allocating a new one, because
both trimming and ranges will never need more room: the operations can only
remove characters from the original string.
Because of this behavior, both functions are fast and don't involve reallocation.
This is an example of string trimming where newlines and spaces are removed from an SDS strings:
sds s = sdsnew(" my string\n\n ");
sdstrim(s," \n");
printf("-%s-\n",s);
output> -my string-
Basically sdstrim
takes the SDS string to trim as first argument, and a
null terminated set of characters to remove from left and right of the string.
The characters are removed as long as they are not interrupted by a character
that is not in the list of characters to trim: this is why the space between
"my"
and "string"
was preserved in the above example.
Taking ranges is similar, but instead to take a set of characters, it takes to indexes, representing the start and the end as specified by zero-based indexes inside the string, to obtain the range that will be retained.
sds s = sdsnew("Hello World!");
sdsrange(s,1,4);
printf("-%s-\n");
output> -ello-
Indexes can be negative to specify a position starting from the end of the
string, so that -1
means the last character, -2
the penultimate, and so forth:
sds s = sdsnew("Hello World!");
sdsrange(s,6,-1);
printf("-%s-\n");
sdsrange(s,0,-2);
printf("-%s-\n");
output> -World!-
output> -World-
sdsrange
is very useful when implementing networking servers processing
a protocol or sending messages. For example the following code is used
implementing the write handler of the Redis Cluster message bus between
nodes:
void clusterWriteHandler(..., int fd, void *privdata, ...) {
clusterLink *link = (clusterLink*) privdata;
ssize_t nwritten = write(fd, link->sndbuf, sdslen(link->sndbuf));
if (nwritten <= 0) {
/* Error handling... */
}
sdsrange(link->sndbuf,nwritten,-1);
... more code here ...
}
Every time the socket of the node we want to send the message to is writable
we attempt to write as much bytes as possible, and we use sdsrange
in order
to remove from the buffer what was already sent.
The function to queue new messages to send to some node in the cluster will
simply use sdscatlen
in order to put more data in the send buffer.
Note that the Redis Cluster bus implements a binary protocol, but since SDS is binary safe this is not a problem, so the goal of SDS is not just to provide an high level string API for the C programmer but also dynamically allocated buffers that are easy to manage.
String copying
The most dangerous and infamus function of the standard C library is probably
strcpy
, so perhaps it is funny how in the context of better designed dynamic
string libraries the concept of copying strings is almost irrelevant. Usually
what you do is to create strings with the content you want, or concatenating
more content as needed.
However SDS features a string copy function that is useful in performance critical code sections, however I guess its practical usefulness is limited as the function never managed to get called in the context of the 50k lines of code composing the Redis code base.
sds sdscpylen(sds s, const char *t, size_t len);
sds sdscpy(sds s, const char *t);
The string copy function of SDS is called sdscpylen
and works like that:
s = sdsnew("Hello World!");
s = sdscpylen(s,"Hello Superman!",15);
As you can see the function receives as input the SDS string s
, but also
returns an SDS string. This is common to many SDS functions that modify the
string: this way the returned SDS string may be the original one modified
or a newly allocated one (for example if there was not enough room in the
old SDS string).
The sdscpylen
will simply replace what was in the old SDS string with the
new data you pass using the pointer and length argument. There is a similar
function called sdscpy
that does not need a length but expects a null
terminated string instead.
You may wonder why it makes sense to have a string copy function in the
SDS library, since you can simply create a new SDS string from scratch
with the new value instead of copying the value in an existing SDS string.
The reason is efficiency: sdsnewlen
will always allocate a new string
while sdscpylen
will try to reuse the existing string if there is enough
room to old the new content specified by the user, and will allocate a new
one only if needed.
Quoting strings
In order to provide consistent output to the program user, or for debugging purposes, it is often important to turn a string that may contain binary data or special characters into a quoted string. Here for quoted string we mean the common format for String literals in programming source code. However today this format is also part of the well known serialization formats like JSON and CSV, so it definitely escaped the simple goal of representing literals strings in the source code of programs.
An example of quoted string literal is the following:
"\x00Hello World\n"
The first byte is a zero byte while the last byte is a newline, so there are two non alphanumerical characters inside the string.
SDS uses a concatenation function for this goal, that concatenates to an existing string the quoted string representation of the input string.
sds sdscatrepr(sds s, const char *p, size_t len);
The scscatrepr
(where repr
means representation) follows the usualy
SDS string function rules accepting a char pointer and a length, so you can
use it with SDS strings, normal C strings by using strlen() as len
argument,
or binary data. The following is an example usage:
sds s1 = sdsnew("abcd");
sds s2 = sdsempty();
s[1] = 1;
s[2] = 2;
s[3] = '\n';
s2 = sdscatrepr(s2,s1,sdslen(s1));
printf("%s\n", s2);
output> "a\x01\x02\n"
This is the rules sdscatrepr
uses for conversion:
\
and"
are quoted with a backslash.- It quotes special characters
'\n'
,'\r'
,'\t'
,'\a'
and'\b'
. - All the other non printable characters not passing the
isprint
test are quoted in\x..
form, that is: backslash followed byx
followed by two digit hex number representing the character byte value. - The function always adds initial and final double quotes characters.
There is an SDS function that is able to perform the reverse conversion and is documented in the Tokenization section below.
Tokenization
Tokenization is the process of splitting a larger string into smaller strings.
In this specific case, the split is performed specifying another string that
acts as separator. For example in the following string there are two substrings
that are separated by the |-|
separator:
foo|-|bar|-|zap
A more common separator that consists of a single character is the comma:
foo,bar,zap
In many progrems it is useful to process a line in order to obtain the sub strings it is composed of, so SDS provides a function that returns an array of SDS strings given a string and a separator.
sds *sdssplitlen(const char *s, int len, const char *sep, int seplen, int *count);
void sdsfreesplitres(sds *tokens, int count);
As usually the function can work with both SDS strings or normal C strings.
The first two arguments s
and len
specify the string to tokenize, and the
other two arguments sep
and seplen
the separator to use during the
tokenization. The final argument count
is a pointer to an integer that will
be set to the number of tokens (sub strings) returned.
The return value is a heap allocated array of SDS strings.
sds *tokens;
int count, j;
sds line = sdsnew("Hello World!");
tokens = sdssplitlen(line,sdslen(line)," ",1,&count);
for (j = 0; j < count; j++)
printf("%s\n", tokens[j]);
sdsfreesplitres(tokens,count);
output> Hello
output> World!
The returned array is heap allocated, and the single elements of the array
are normal SDS strings. You can free everything calling sdsfreesplitres
as in the example. Alternativey you are free to release the array yourself
using the free
function and use and/or free the individual SDS strings
as usually.
A valid approach is to set the array elements you reused in some way to
NULL
, and use sdsfreesplitres
to free all the rest.
Command line oriented tokenization
Splitting by a separator is a useful operation, but usually it is not enough to perform one of the most common tasks involving some non trivial string manipulation, that is, implementing a Command Line Interface for a program.
This is why SDS also provides an additional function that allows you to split arguments provided by the user via the keyboard in an interactive manner, or via a file, network, or any other mean, into tokens.
sds *sdssplitargs(const char *line, int *argc);
The sdssplitargs
function returns an array of SDS strings exactly like
sdssplitlen
. The function to free the result is also identical, and is
sdsfreesplitres
. The difference is in the way the tokenization is performed.
For example if the input is the following line:
call "Sabrina" and "Mark Smith\n"
The function will return the following tokens:
- "call"
- "Sabrina"
- "and"
- "Mark Smith\n"
Basically different tokens need to be separated by one or more spaces, and
every single token can also be a quoted string in the same format that
sdscatrepr
is able to emit.
String joining
There are two functions doing the reverse of tokenization by joining strings into a single one.
sds sdsjoin(char **argv, int argc, char *sep, size_t seplen);
sds sdsjoinsds(sds *argv, int argc, const char *sep, size_t seplen);
The two functions take as input an array of strings of length argc
and
a separator and its length, and produce as output an SDS string consisting
of all the specified strings separated by the specified separator.
The difference between sdsjoin
and sdsjoinsds
is that the former accept
C null terminated strings as input while the latter requires all the strings
in the array to be SDS strings. However because of this only sdsjoinsds
is
able to deal with binary data.
char *tokens[3] = {"foo","bar","zap"};
sds s = sdsjoin(tokens,3,"|",1);
printf("%s\n", s);
output> foo|bar|zap
Error handling
All the SDS functions that return an SDS pointer may also return NULL
on
out of memory, this is basically the only check you need to perform.
However many modern C programs handle out of memory simply aborting the program
so you may want to do this as well by wrapping malloc
and other related
memory allocation calls directly.
SDS internals and advanced usage
At the very beginning of this documentation it was explained how SDS strings are allocated, however the prefix stored before the pointer returned to the user was classified as an header without further details. For an advanced usage it is better to dig more into the internals of SDS and show the structure implementing it:
struct sdshdr {
int len;
int free;
char buf[];
};
As you can see, the structure may resemble the one of a conventional string
library, however the buf
field of the structure is different since it is
not a pointer but an array without any length declared, so buf
actually
points at the first byte just after the free
integer. So in order to create
an SDS string we just allocate a piece of memory that is as large as the
sdshdr
structure plus the length of our string, plus an additional byte
for the mandatory null term that every SDS string has.
The len
field of the structure is quite obvious, and is the current length
of the SDS string, always computed every time the string is modified via
SDS function calls. The free
field instead represents the amount of free
memory in the current allocation that can be used to store more characters.
So the actual SDS layout is this one:
+------------+------------------------+-----------+---------------\
| Len | Free | H E L L O W O R L D \n | Null term | Free space \
+------------+------------------------+-----------+---------------\
|
`-> Pointer returned to the user.
You may wonder why there is some free space at the end of the string, it looks like a waste. Actually after a new SDS string is created, there is no free space at the end at all: the allocation will be as small as possible to just hold the header, string, and null term. However other access patterns will create extra free space at the end, like in the following program:
s = sdsempty();
s = sdscat(s,"foo");
s = sdscat(s,"bar");
s = sdscat(s,"123");
Since SDS tries to be efficient it can't afford to reallocate the string every time new data is appended, since this would be very inefficient, so it uses the preallocation of some free space every time you enlarge the string.
The preallocation algorithm used is the following: every time the string is reallocated in order to hold more bytes, the actual allocation size performed is two times the minimum required. So for instance if the string currently is holding 30 bytes, and we concatenate 2 more bytes, instead of allocating 32 bytes in total SDS will allocate 64 bytes.
However there is an hard limit to the allocation it can perform ahead, and is
defined by SDS_MAX_PREALLOC
. SDS will never allocate more than 1MB of
additional space (by default, you can change this default).
Shrinking strings
sds sdsRemoveFreeSpace(sds s);
size_t sdsAllocSize(sds s);
Sometimes there are class of programs that require to use very little memory. After strings concatenations, trimming, ranges, the string may end having a non trivial amount of additional space at the end.
It is possible to resize a string back to its minimal size in order to hold
the current content by using the function sdsRemoveFreeSpace
.
s = sdsRemoveFreeSpace(s);
There is also a function that can be used in order to get the size of the
total allocation for a given string, and is called sdsAllocSize
.
sds s = sdsnew("Ladies and gentlemen");
s = sdscat(s,"... welcome to the C language.");
printf("%d\n", (int) sdsAllocSize(s));
s = sdsRemoveFreeSpace(s);
printf("%d\n", (int) sdsAllocSize(s));
output> 109
output> 59
NOTE: SDS Low level API use cammelCase in order to warn you that you are playing with the fire.
Manual modifications of SDS strings
void sdsupdatelen(sds s);
Sometimes you may want to hack with an SDS string manually, without using SDS functions. In the following example we implicitly change the length of the string, however we want the logical length to reflect the null terminated C string.
The function sdsupdatelen
does just that, updating the internal length
information for the specified string to the length obtained via strlen
.
sds s = sdsnew("foobar");
s[2] = '\0';
printf("%d\n", sdslen(s));
sdsupdatelen(s);
printf("%d\n", sdslen(s));
output> 6
output> 2
Sharing SDS strings
If you are writing a program in which it is advantageous to share the same SDS string across different data structures, it is absolutely advised to encapsulate SDS strings into structures that remember the number of references of the string, with functions to increment and decrement the number of references.
This approach is a memory management technique called reference counting and in the context of SDS has two advantages:
- It is less likely that you'll create memory leaks or bugs due to non freeing SDS strings or freeing already freed strings.
- You'll not need to update every reference to an SDS string when you modify it (since the new SDS string may point to a different memory location).
While this is definitely a very common programming technique I'll outline the basic ideas here. You create a structure like that:
struct mySharedString {
int refcount;
sds string;
}
When new strings are created, the structure is allocated and returned with
refcount
set to 1. The you have two functions to change the reference count
of the shared string:
incrementStringRefCount
will simply incrementrefcount
of 1 in the structure. It will be called every time you add a reference to the string on some new data structure, variable, or whatever.decrementStringRefCount
is used when you remove a reference. This function is however special since when therefcount
drops to zero, it automatically frees the SDS string, and themySharedString
structure as well.
Interactions with heap checkers
Because SDS returns pointers into the middle of memory chunks allocated with
malloc
, heap checkers may have issues, however:
- The popular Valgrind program will detect SDS strings are possibly lost memory and never as definitely lost, so it is easy to tell if there is a leak or not. I used Valgrind with Redis for years and every real leak was consistently detected as "definitely lost".
- OSX instrumentation tools don't detect SDS strings as leaks but are able to correctly handle pointers pointing to the middle of memory chunks.
Zero copy append from syscalls
At this point you should have all the tools to dig more inside the SDS library by reading the source code, however there is an interesting pattern you can mount using the low level API exported, that is used inside Redis in order to improve performances of the networking code.
Using sdsIncrLen()
and sdsMakeRoomFor()
it is possible to mount the
following schema, to cat bytes coming from the kernel to the end of an
sds string without copying into an intermediate buffer:
oldlen = sdslen(s);
s = sdsMakeRoomFor(s, BUFFER_SIZE);
nread = read(fd, s+oldlen, BUFFER_SIZE);
... check for nread <= 0 and handle it ...
sdsIncrLen(s, nread);
sdsIncrLen
is documented inside the source code of sds.c
.
Embedding SDS into your project
This is as simple as copying the following files inside your project:
- sds.c
- sds.h
- sdsalloc.h
The source code is small and every C99 compiler should deal with it without issues.
Using a different allocator for SDS
Internally sds.c uses the allocator defined into sdsalloc.h
. This header
file just defines macros for malloc, realloc and free, and by default libc
malloc()
, realloc()
and free()
are used. Just edit this file in order
to change the name of the allocation functions.
The program using SDS can call the SDS allocator in order to manipulate SDS pointers (usually not needed but sometimes the program may want to do advanced things) by using the API exported by SDS in order to call the allocator used. This is especially useful when the program linked to SDS is using a different allocator compared to what SDS is using.
The API to access the allocator used by SDS is composed of three functions: sds_malloc()
, sds_realloc()
and sds_free()
.
Credits and license
SDS was created by Salvatore Sanfilippo and is released under the BDS two clause license. See the LICENSE file in this source distribution for more information.
Oran Agra improved SDS version 2 by adding dynamic sized headers in order to save memory for small strings and allow strings greater than 4GB.
More Resourcesto explore the angular.
mail [email protected] to add your project or resources here 🔥.
- 1Create new page · clibs/clib Wiki
https://github.com/clibs/clib/wiki/Packages.
Package manager for the C programming language. Contribute to clibs/clib development by creating an account on GitHub.
- 2utf8proc/LICENSE.md at master · JuliaStrings/utf8proc
https://github.com/JuliaStrings/utf8proc/blob/master/LICENSE.md
a clean C library for processing UTF-8 Unicode data - JuliaStrings/utf8proc
- 3ape_tag_libs/c at master · jeremyevans/ape_tag_libs
https://github.com/jeremyevans/ape_tag_libs/tree/master/c
Libaries for reading/writing APEv2 tags in many languages - jeremyevans/ape_tag_libs
- 4Build software better, together
https://github.com/clibs/clib.
GitHub is where people build software. More than 100 million people use GitHub to discover, fork, and contribute to over 420 million projects.
- 5Small strings compression library
https://github.com/antirez/smaz
Small strings compression library. Contribute to antirez/smaz development by creating an account on GitHub.
- 6cmathl/LICENSE at master · ScientificC/cmathl
https://github.com/ScientificC/cmathl/blob/master/LICENSE
A pure-C math library with a great variety of mathematical functions. Seeks to be close to C89/C90 compliant for portability. - ScientificC/cmathl
- 7Minimal unit testing framework for C
https://github.com/siu/minunit
Minimal unit testing framework for C. Contribute to siu/minunit development by creating an account on GitHub.
- 8📚 single header utf8 string functions for C and C++
https://github.com/sheredom/utf8.h
📚 single header utf8 string functions for C and C++ - sheredom/utf8.h
- 9A template system for Emacs
https://github.com/joaotavora/yasnippet
A template system for Emacs. Contribute to joaotavora/yasnippet development by creating an account on GitHub.
- 10Asynchronous networking for C
https://github.com/rxi/dyad
Asynchronous networking for C . Contribute to rxi/dyad development by creating an account on GitHub.
- 11Super Light Regexp engine for C/C++
https://github.com/cesanta/slre
Super Light Regexp engine for C/C++. Contribute to cesanta/slre development by creating an account on GitHub.
- 12Netstring for C
https://github.com/liteserver/netstring-c
Netstring for C. Contribute to liteserver/netstring-c development by creating an account on GitHub.
- 13A protocol buffers library for C
https://github.com/cloudwu/pbc
A protocol buffers library for C. Contribute to cloudwu/pbc development by creating an account on GitHub.
- 14Pblog is a small, low overhead, structured logging library
https://github.com/google/pblog
Pblog is a small, low overhead, structured logging library - google/pblog
- 15Parser combinators for binary formats, in C. Yes, in C. What? Don't look at me like that.
https://github.com/abiggerhammer/hammer
Parser combinators for binary formats, in C. Yes, in C. What? Don't look at me like that. - abiggerhammer/hammer
- 16libelf
https://github.com/WolfgangSt/libelf
libelf. Contribute to WolfgangSt/libelf development by creating an account on GitHub.
- 17Open MPI main development repository
https://github.com/open-mpi/ompi
Open MPI main development repository. Contribute to open-mpi/ompi development by creating an account on GitHub.
- 18Your friendly e-mail address validation library.
https://github.com/dertuxmalwieder/libvldmail
Your friendly e-mail address validation library. Contribute to dertuxmalwieder/libvldmail development by creating an account on GitHub.
- 19A shebang-friendly script for "interpreting" single C99, C11, and C++ files, including rcfile support.
https://github.com/RhysU/c99sh
A shebang-friendly script for "interpreting" single C99, C11, and C++ files, including rcfile support. - RhysU/c99sh
- 20Minimal Huffman coder/decoder
https://github.com/adamierymenko/huffandpuff
Minimal Huffman coder/decoder. Contribute to adamierymenko/huffandpuff development by creating an account on GitHub.
- 21C library/compiler for the Cap'n Proto serialization/RPC protocol
https://github.com/jmckaskill/c-capnproto
C library/compiler for the Cap'n Proto serialization/RPC protocol - jmckaskill/c-capnproto
- 22C-code generator for docopt language.
https://github.com/docopt/docopt.c
C-code generator for docopt language. Contribute to docopt/docopt.c development by creating an account on GitHub.
- 23syntastic/LICENCE at master · vim-syntastic/syntastic
https://github.com/vim-syntastic/syntastic/blob/master/LICENCE
Syntax checking hacks for vim. Contribute to vim-syntastic/syntastic development by creating an account on GitHub.
- 24tiny recursive descent expression parser, compiler, and evaluation engine for math expressions
https://github.com/codeplea/tinyexpr
tiny recursive descent expression parser, compiler, and evaluation engine for math expressions - codeplea/tinyexpr
- 25libonion - Coralbits S.L.
https://www.coralbits.com/libonion/
Lightweight C library to add web server functionality to your program libonion is a lightweight library to help you create webservers in C programming language. These webservers may be a web application, a means of expanding your own application to give it web functionality or even a fully featured webserver. The user can create new […]
- 26http request/response parser for c
https://github.com/nodejs/http-parser
http request/response parser for c. Contribute to nodejs/http-parser development by creating an account on GitHub.
- 27commonmark-spec/LICENSE at master · commonmark/commonmark-spec
https://github.com/commonmark/commonmark-spec/blob/master/LICENSE
CommonMark spec, with reference implementations in C and JavaScript - commonmark/commonmark-spec
- 28A tool for use with clang to analyze #includes in C and C++ source files
https://github.com/include-what-you-use/include-what-you-use
A tool for use with clang to analyze #includes in C and C++ source files - include-what-you-use/include-what-you-use
- 29A non-backtracking NFA/DFA-based Perl-compatible regex engine matching on large data streams
https://github.com/openresty/sregex
A non-backtracking NFA/DFA-based Perl-compatible regex engine matching on large data streams - openresty/sregex
- 30A portable foreign-function interface library.
https://github.com/libffi/libffi
A portable foreign-function interface library. Contribute to libffi/libffi development by creating an account on GitHub.
- 31Universal configuration library parser
https://github.com/vstakhov/libucl
Universal configuration library parser. Contribute to vstakhov/libucl development by creating an account on GitHub.
- 32On the fly syntax checking for GNU Emacs
https://github.com/flycheck/flycheck
On the fly syntax checking for GNU Emacs. Contribute to flycheck/flycheck development by creating an account on GitHub.
- 33A Linux packet crafting tool.
https://github.com/rafael-santiago/pig
A Linux packet crafting tool. Contribute to rafael-santiago/pig development by creating an account on GitHub.
- 34A New Kind of Instant Messaging
https://tox.chat/
Whether it's corporations or governments, there's just too much digital spying going on today. Tox is an easy to use application that connects you with friends and family without anyone else listening in. While other big-name services require you to pay for features, Tox is totally free and comes without advertising — forever.
- 35A simple C library for working with KD-Trees
https://github.com/jtsiomb/kdtree
A simple C library for working with KD-Trees. Contribute to jtsiomb/kdtree development by creating an account on GitHub.
- 36A mini C library for interacting with the Twitter OAuth api.
https://github.com/sinemetu1/twitc
A mini C library for interacting with the Twitter OAuth api. - sinemetu1/twitc
- 37Main gperftools repository
https://github.com/gperftools/gperftools
Main gperftools repository. Contribute to gperftools/gperftools development by creating an account on GitHub.
- 38Lint C-based files using Clang.
https://github.com/AtomLinter/linter-clang
Lint C-based files using Clang. Contribute to AtomLinter/linter-clang development by creating an account on GitHub.
- 39WAFer is a C language-based software platform for scalable server-side and networking applications. Think node.js for C programmers.
https://github.com/riolet/WAFer
WAFer is a C language-based software platform for scalable server-side and networking applications. Think node.js for C programmers. - riolet/WAFer
- 40ini file parser
https://github.com/ndevilla/iniparser
ini file parser. Contribute to ndevilla/iniparser development by creating an account on GitHub.
- 41simple neural network library in ANSI C
https://github.com/codeplea/genann
simple neural network library in ANSI C. Contribute to codeplea/genann development by creating an account on GitHub.
- 42An eventing framework for building high performance and high scalability systems in C.
https://github.com/facebookarchive/libphenom
An eventing framework for building high performance and high scalability systems in C. - facebookarchive/libphenom
- 43A cross-platform protocol library to communicate with iOS devices
https://github.com/libimobiledevice/libimobiledevice
A cross-platform protocol library to communicate with iOS devices - libimobiledevice/libimobiledevice
- 44H2O - the optimized HTTP/1, HTTP/2, HTTP/3 server
https://github.com/h2o/h2o/
H2O - the optimized HTTP/1, HTTP/2, HTTP/3 server. Contribute to h2o/h2o development by creating an account on GitHub.
- 45A portable MQTT C client for embedded systems and PCs alike.
https://github.com/LiamBindle/MQTT-C
A portable MQTT C client for embedded systems and PCs alike. - LiamBindle/MQTT-C
- 46Binary Serialization
https://github.com/liteserver/binn
Binary Serialization. Contribute to liteserver/binn development by creating an account on GitHub.
- 47Package manager for the C programming language.
https://github.com/clibs/clib
Package manager for the C programming language. Contribute to clibs/clib development by creating an account on GitHub.
- 48Yet another INI parser
https://github.com/madmurphy/libconfini
Yet another INI parser. Contribute to madmurphy/libconfini development by creating an account on GitHub.
- 49C-Library for unit testing.
https://github.com/rafael-santiago/cutest
C-Library for unit testing. Contribute to rafael-santiago/cutest development by creating an account on GitHub.
- 50A Parser Combinator library for C
https://github.com/orangeduck/mpc
A Parser Combinator library for C. Contribute to orangeduck/mpc development by creating an account on GitHub.
- 51An implementation of the MessagePack serialization format in C / msgpack.org[C]
https://github.com/camgunz/cmp
An implementation of the MessagePack serialization format in C / msgpack.org[C] - camgunz/cmp
- 52Platform independent Near Field Communication (NFC) library
https://github.com/nfc-tools/libnfc
Platform independent Near Field Communication (NFC) library - nfc-tools/libnfc
- 53Lightweight exception implementation for C
https://github.com/ThrowTheSwitch/CException
Lightweight exception implementation for C. Contribute to ThrowTheSwitch/CException development by creating an account on GitHub.
- 54CommonMark spec, with reference implementations in C and JavaScript
https://github.com/commonmark/commonmark-spec
CommonMark spec, with reference implementations in C and JavaScript - commonmark/commonmark-spec
- 55AddressSanitizer, ThreadSanitizer, MemorySanitizer
https://github.com/google/sanitizers
AddressSanitizer, ThreadSanitizer, MemorySanitizer - google/sanitizers
- 56a clean C library for processing UTF-8 Unicode data
https://github.com/JuliaStrings/utf8proc
a clean C library for processing UTF-8 Unicode data - JuliaStrings/utf8proc
- 57nanomsg library
https://github.com/nanomsg/nanomsg
nanomsg library. Contribute to nanomsg/nanomsg development by creating an account on GitHub.
- 58libusb/COPYING at master · libusb/libusb
https://github.com/libusb/libusb/blob/master/COPYING
A cross-platform library to access USB devices . Contribute to libusb/libusb development by creating an account on GitHub.
- 59Protocol Buffers implementation in C
https://github.com/protobuf-c/protobuf-c
Protocol Buffers implementation in C. Contribute to protobuf-c/protobuf-c development by creating an account on GitHub.
- 60An HTML5 parsing library in pure C99
https://github.com/google/gumbo-parser
An HTML5 parsing library in pure C99. Contribute to google/gumbo-parser development by creating an account on GitHub.
- 61Wrapper library for the BSD sockets API with a nicer C99 interface
https://github.com/silentbicycle/socket99
Wrapper library for the BSD sockets API with a nicer C99 interface - silentbicycle/socket99
- 62Compile and execute C "scripts" in one go!
https://github.com/ryanmjacobs/c
Compile and execute C "scripts" in one go! Contribute to ryanmjacobs/c development by creating an account on GitHub.
- 63The approximate regex matching library and agrep command line tool.
https://github.com/laurikari/tre/
The approximate regex matching library and agrep command line tool. - laurikari/tre
- 64MPack - A C encoder/decoder for the MessagePack serialization format / msgpack.org[C]
https://github.com/ludocode/mpack
MPack - A C encoder/decoder for the MessagePack serialization format / msgpack.org[C] - ludocode/mpack
- 65ARCHIVED - libbson has moved to https://github.com/mongodb/mongo-c-driver/tree/master/src/libbson
https://github.com/mongodb/libbson
ARCHIVED - libbson has moved to https://github.com/mongodb/mongo-c-driver/tree/master/src/libbson - mongodb/libbson
- 66A cross platform C99 library to get cpu features at runtime.
https://github.com/google/cpu_features
A cross platform C99 library to get cpu features at runtime. - google/cpu_features
- 67RabbitMQ C client
https://github.com/alanxz/rabbitmq-c
RabbitMQ C client. Contribute to alanxz/rabbitmq-c development by creating an account on GitHub.
- 68Home - OpenMP
https://www.openmp.org/
yes
- 69Simple Dynamic Strings library for C
https://github.com/antirez/sds
Simple Dynamic Strings library for C. Contribute to antirez/sds development by creating an account on GitHub.
- 70OpenCL - The Open Standard for Parallel Programming of Heterogeneous Systems
https://www.khronos.org/opencl/
OpenCL™ (Open Computing Language) is an open, royalty-free standard for cross-platform, parallel programming of diverse accelerators found in supercomputers, cloud servers, personal computers, mobile devices and embedded platforms. OpenCL greatly improves the speed and responsiveness of a wide spectrum of applications in numerous market categories including professional creative tools,
- 71Syntax checking hacks for vim
https://github.com/vim-syntastic/syntastic
Syntax checking hacks for vim. Contribute to vim-syntastic/syntastic development by creating an account on GitHub.
- 72aosp-mirror/platform_bionic
https://github.com/aosp-mirror/platform_bionic
Contribute to aosp-mirror/platform_bionic development by creating an account on GitHub.
- 73regexp4 engine (C-lang)
https://github.com/nasciiboy/recursiveregexpraptor-4
regexp4 engine (C-lang). Contribute to nasciiboy/RecursiveRegexpRaptor-4 development by creating an account on GitHub.
- 74libgit2/COPYING at main · libgit2/libgit2
https://github.com/libgit2/libgit2/blob/master/COPYING
A cross-platform, linkable library implementation of Git that you can use in your application. - libgit2/libgit2
- 75capstone/LICENSE.TXT at master · capstone-engine/capstone
https://github.com/aquynh/capstone/blob/master/LICENSE.TXT
Capstone disassembly/disassembler framework for ARM, ARM64 (ARMv8), Alpha, BPF, Ethereum VM, HPPA, LoongArch, M68K, M680X, Mips, MOS65XX, PPC, RISC-V(rv32G/rv64G), SH, Sparc, SystemZ, TMS320C64X, T...
- 76An implementation of the TLS/SSL protocols
https://github.com/awslabs/s2n
An implementation of the TLS/SSL protocols. Contribute to aws/s2n-tls development by creating an account on GitHub.
- 77Capstone disassembly/disassembler framework for ARM, ARM64 (ARMv8), Alpha, BPF, Ethereum VM, HPPA, LoongArch, M68K, M680X, Mips, MOS65XX, PPC, RISC-V(rv32G/rv64G), SH, Sparc, SystemZ, TMS320C64X, TriCore, Webassembly, XCore and X86.
https://github.com/aquynh/capstone
Capstone disassembly/disassembler framework for ARM, ARM64 (ARMv8), Alpha, BPF, Ethereum VM, HPPA, LoongArch, M68K, M680X, Mips, MOS65XX, PPC, RISC-V(rv32G/rv64G), SH, Sparc, SystemZ, TMS320C64X, T...
- 78Atom-linter extension to lint C/C++ source files using gcc/g++
https://github.com/hebaishi/linter-gcc
Atom-linter extension to lint C/C++ source files using gcc/g++ - AtomLinter/linter-gcc
- 79🚀 Making multi-player gamedev simpler since 2017
https://github.com/librg/librg
🚀 Making multi-player gamedev simpler since 2017. Contribute to zpl-c/librg development by creating an account on GitHub.
- 80Public domain cross platform lock free thread caching 16-byte aligned memory allocator implemented in C
https://github.com/rampantpixels/rpmalloc
Public domain cross platform lock free thread caching 16-byte aligned memory allocator implemented in C - mjansson/rpmalloc
- 81The 2-Clause BSD License
https://opensource.org/licenses/BSD-2-Clause
Note: This license has also been called the “Simplified BSD License” and the “FreeBSD License”. See also the 3-clause BSD License. Copyright <YEAR> <COPYRIGHT HOLDER> Redistribution and use in source…
- 82ICU - International Components for Unicode
http://site.icu-project.org/
News 2024-04-17: ICU 75 is now available. It updates to CLDR 45 (beta blog) locale data with new locales and various additions and corrections. C++ code now requires C++17 and is being made more robust. The CLDR MessageFormat 2.0 specification is now in technology preview, together with a
- 83Understanding and Using C Pointers
http://shop.oreilly.com/product/0636920028000.do
Improve your programming through a solid understanding of C pointers and memory management. With this practical book, you’ll learn how pointers provide the mechanism to dynamically manipulate memory, enhance support … - Selection from Understanding and Using C Pointers [Book]
- 8421st Century C, 2nd Edition
http://shop.oreilly.com/product/0636920033677.do
Throw out your old ideas of C, and relearn a programming language that’s substantially outgrown its origins. With this revised edition of 21st Century C, you’ll discover up-to-date techniques … - Selection from 21st Century C, 2nd Edition [Book]
- 85Jens Gustedt / P99 - macros and functions for C99 · GitLab
http://p99.gforge.inria.fr/
P99 is a suite of macro and function definitions that ease the programming in C99, aka C 1999. By using new tools from C99 we implement default arguments...
- 86C Pocket Reference
http://shop.oreilly.com/product/9780596004361.do
C is one of the oldest programming languages and still one of the most widely used. Whether you're an experienced C programmer or you're new to the language, you know … - Selection from C Pocket Reference [Book]
- 87Head First C
http://shop.oreilly.com/product/0636920015482.do
Ever wished you could learn C from a book? Head First C provides a complete learning experience for C and structured imperative programming. With a unique method that goes beyond … - Selection from Head First C [Book]
- 88Throw The Switch
http://www.throwtheswitch.org/
Unit Testing (TDD) Embedded C Code. Making Awesome and Reliable Firmware in C Doesn't Have to Suck.
- 89Projects
http://source.icu-project.org/repos/icu/icu/tags/latest/LICENSE
Projects The Unicode StandardThe Unicode Standard is a character coding system designed to support the worldwide interchange, processing, and display of the written texts of the diverse languages and technical disciplines of the modern world. In addition, it supports classical and historical texts of many written languages. Unicode CLDR (Common Locale
- 90A fast build tool
https://buck.build/
This project is no longer actively maintained. Please see https://buck2.build for the build system that replaces it. Old content continues below for historical purposes. Buck is a build system developed and used by Facebook. It encourages the creation of small, reusable modules consisting of code and resources, and supports a variety of languages.
- 91Build software better, together
https://github.com/eug/awesome-opengl.
GitHub is where people build software. More than 100 million people use GitHub to discover, fork, and contribute to over 420 million projects.
- 92Home
https://github.com/json-c/json-c/wiki
https://github.com/json-c/json-c is the official code repository for json-c. See the wiki for release tarballs for download. API docs at http://json-c.github.io/json-c/ - json-c/json-c
- 93Home
https://github.com/rib/cogl-web/wiki
The cogl3d.org website content. Contribute to rib/cogl-web development by creating an account on GitHub.
- 94qtbase/LICENSE.GPL3-EXCEPT at 5.11 · qt/qtbase
https://github.com/qt/qtbase/blob/5.11/LICENSE.GPL3-EXCEPT
Qt Base (Core, Gui, Widgets, Network, ...). Contribute to qt/qtbase development by creating an account on GitHub.
- 95Build software better, together
https://github.com/vinjn/awesome-vulkan.
GitHub is where people build software. More than 100 million people use GitHub to discover, fork, and contribute to over 420 million projects.
- 96Home
https://github.com/netmail-open/wjelement/wiki
advanced, flexible JSON manipulation in C. Contribute to netmail-open/wjelement development by creating an account on GitHub.
- 97C99 heightmap utilities.
https://github.com/prideout/heman
C99 heightmap utilities. Contribute to prideout/heman development by creating an account on GitHub.
- 98Read-only mirror of official repo on openldap.org. Issues and pull requests here are ignored. Use OpenLDAP ITS for issues.
https://github.com/LMDB/lmdb
Read-only mirror of official repo on openldap.org. Issues and pull requests here are ignored. Use OpenLDAP ITS for issues. - LMDB/lmdb
- 99contiki/LICENSE at master · contiki-os/contiki
https://github.com/contiki-os/contiki/blob/master/LICENSE
The official git repository for Contiki, the open source OS for the Internet of Things - contiki-os/contiki
- 100Intel® Implicit SPMD Program Compiler
https://github.com/ispc/ispc
Intel® Implicit SPMD Program Compiler. Contribute to ispc/ispc development by creating an account on GitHub.
- 101Pure C Game Engine
https://github.com/orangeduck/Corange
Pure C Game Engine. Contribute to orangeduck/Corange development by creating an account on GitHub.
- 102LCUI/LICENSE.TXT at develop · lc-soft/LCUI
https://github.com/lc-soft/LCUI/blob/develop/LICENSE.TXT
C library for building user interfaces. Contribute to lc-soft/LCUI development by creating an account on GitHub.
- 103Parallel, indexed xz compressor
https://github.com/vasi/pixz
Parallel, indexed xz compressor. Contribute to vasi/pixz development by creating an account on GitHub.
- 104Quake GPL Source Release
https://github.com/id-Software/Quake
Quake GPL Source Release. Contribute to id-Software/Quake development by creating an account on GitHub.
- 105a small build system with a focus on speed
https://github.com/ninja-build/ninja
a small build system with a focus on speed. Contribute to ninja-build/ninja development by creating an account on GitHub.
- 106Quake 2 GPL Source Release
https://github.com/id-Software/Quake-2
Quake 2 GPL Source Release. Contribute to id-Software/Quake-2 development by creating an account on GitHub.
- 107libui/LICENSE at master · andlabs/libui
https://github.com/andlabs/libui/blob/master/LICENSE
Simple and portable (but not inflexible) GUI library in C that uses the native GUI technologies of each platform it supports. - andlabs/libui
- 108stb single-file public domain libraries for C/C++
https://github.com/nothings/stb
stb single-file public domain libraries for C/C++. Contribute to nothings/stb development by creating an account on GitHub.
- 109Murmur3 hash in C
https://github.com/PeterScott/murmur3
Murmur3 hash in C. Contribute to PeterScott/murmur3 development by creating an account on GitHub.
- 110Lightweight JSON library written in C.
https://github.com/kgabis/parson
Lightweight JSON library written in C. Contribute to kgabis/parson development by creating an account on GitHub.
- 111Brotli compression format
https://github.com/google/brotli
Brotli compression format. Contribute to google/brotli development by creating an account on GitHub.
- 112xmake/LICENSE.md at master · xmake-io/xmake
https://github.com/xmake-io/xmake/blob/master/LICENSE.md
🔥 A cross-platform build utility based on Lua. Contribute to xmake-io/xmake development by creating an account on GitHub.
- 113Premake
https://github.com/premake/premake-core
Premake. Contribute to premake/premake-core development by creating an account on GitHub.
- 114Simple and portable (but not inflexible) GUI library in C that uses the native GUI technologies of each platform it supports.
https://github.com/andlabs/libui
Simple and portable (but not inflexible) GUI library in C that uses the native GUI technologies of each platform it supports. - andlabs/libui
- 115A single-header ANSI C gui library
https://github.com/vurtun/nuklear
A single-header ANSI C gui library. Contribute to vurtun/nuklear development by creating an account on GitHub.
- 116Visual Studio Code - Code Editing. Redefined
https://code.visualstudio.com/
Visual Studio Code is a code editor redefined and optimized for building and debugging modern web and cloud applications. Visual Studio Code is free and available on your favorite platform - Linux, macOS, and Windows.
- 117The GTK Project - A free and open-source cross-platform widget toolkit
https://www.gtk.org/gtk-doc/
GTK is a free and open-source cross-platform widget toolkit for creating graphical user interfaces.
- 118NIH Utility Library
https://github.com/keybuk/libnih
NIH Utility Library. Contribute to keybuk/libnih development by creating an account on GitHub.
- 119raylib
https://www.raylib.com/
raylib is a simple and easy-to-use library to enjoy videogames programming.
- 120The GTK Project - A free and open-source cross-platform widget toolkit
https://www.gtk.org/
GTK is a free and open-source cross-platform widget toolkit for creating graphical user interfaces.
- 121Easy to use, modular, header only, macro based, generic and type-safe Data Structures in C
https://github.com/LeoVen/C-Macro-Collections
Easy to use, modular, header only, macro based, generic and type-safe Data Structures in C - LeoVen/C-Macro-Collections
- 122advanced, flexible JSON manipulation in C
https://github.com/netmail-open/wjelement/
advanced, flexible JSON manipulation in C. Contribute to netmail-open/wjelement development by creating an account on GitHub.
- 123Simple hash table implementation for C.
https://github.com/watmough/jwHash
Simple hash table implementation for C. Contribute to watmough/jwHash development by creating an account on GitHub.
- 124ioquake3
https://ioquake3.org/
Play Quake 3, mods, new games, or make your own!
- 125OpenGL ES - The Standard for Embedded Accelerated 3D Graphics
https://www.khronos.org/opengles/
OpenGL ES is a royalty-free, cross-platform API for full-function 2D and 3D graphics on embedded systems - including consoles, phones, appliances and vehicles.
- 126OpenGL SC - OpenGL graphics for the safety critical industry
https://www.khronos.org/openglsc/
The open standard OpenGL SC Safety Critical Profile is defined to meet the unique needs of the safety-critical market for avionics, industrial, military, medical and automotive applications including D0178-B certification.
- 127Minimalistic C client for Redis >= 1.2
https://github.com/redis/hiredis
Minimalistic C client for Redis >= 1.2. Contribute to redis/hiredis development by creating an account on GitHub.
- 128A fast compressor/decompressor
https://github.com/google/snappy
A fast compressor/decompressor. Contribute to google/snappy development by creating an account on GitHub.
- 129PostgreSQL
https://www.postgresql.org/
The world's most advanced open source database.
- 130Improved JPEG encoder.
https://github.com/mozilla/mozjpeg
Improved JPEG encoder. Contribute to mozilla/mozjpeg development by creating an account on GitHub.
- 131💩 Colour ASCII Art Library
https://github.com/cacalabs/libcaca
💩 Colour ASCII Art Library. Contribute to cacalabs/libcaca development by creating an account on GitHub.
- 132I Do Not Know C
https://kukuruku.co/post/i-do-not-know-c/
The purpose of this article is to make everyone (especially C programmers) say: “I do not know C”. I want to show that the dark corners of C are much closer than it seems, and even trivial code lines may contain undefined behavior. The article is organized as a set of questions and answers. All the examples are separate files of the source code. 1. int i; int i = 10; Q: Is this code correct?
- 133GIFLIB
https://sourceforge.net/projects/giflib/
Download GIFLIB for free. A library and utilities for processing GIFs. giflib is a library for reading and writing gif images. It is API and ABI compatible with libungif which was in wide use while the LZW compression algorithm was patented.
- 134Redis - The Real-time Data Platform
https://redis.io/
Developers love Redis. Unlock the full potential of the Redis database with Redis Enterprise and start building blazing fast apps.
- 135The Developer Data Platform
https://www.mongodb.com/.
Get your ideas to market faster with a developer data platform built on the leading modern database. MongoDB makes working with data easy.
- 136C library for building user interfaces
https://github.com/lc-soft/LCUI/
C library for building user interfaces. Contribute to lc-soft/LCUI development by creating an account on GitHub.
- 137qt-creator/LICENSE.GPL3-EXCEPT at master · qt-creator/qt-creator
https://github.com/qt-creator/qt-creator/blob/master/LICENSE.GPL3-EXCEPT
A cross-platform Qt IDE. Contribute to qt-creator/qt-creator development by creating an account on GitHub.
- 138Learning C with gdb - Blog - Recurse Center
https://www.recurse.com/blog/5-learning-c-with-gdb
The Recurse Center is a self-directed, community-driven educational retreat for programmers in New York City.
- 139Introduction to "Fun" C (using GCC)
https://gist.github.com/eatonphil/21b3d6569f24ad164365
Introduction to "Fun" C (using GCC). GitHub Gist: instantly share code, notes, and snippets.
- 140Open Source Database (RDBMS) for the Enterprise | MariaDB
https://mariadb.com/
MariaDB provides enterprise open source database and cloud managed database services to support scalability, mission-critical deployments, and more.
- 141Introduction to OpenMP - Tim Mattson (Intel)
https://www.youtube.com/playlist?list=PLLX-Q6B8xqZ8n8bwjGdzBJ25X2utwnoEG
Introduction to OpenMP - Tim Mattson (Intel) The OpenMP ARB thanks the University Program Office at Intel for permission to make this tutorial available. Sli...
- 142ispc/LICENSE.txt at main · ispc/ispc
https://github.com/ispc/ispc/blob/master/LICENSE.txt
Intel® Implicit SPMD Program Compiler. Contribute to ispc/ispc development by creating an account on GitHub.
- 143amazon-freertos/LICENSE at main · aws/amazon-freertos
https://github.com/aws/amazon-freertos/blob/master/LICENSE
DEPRECATED - See README.md. Contribute to aws/amazon-freertos development by creating an account on GitHub.
- 144AI-Enhanced Data Solutions with Database 23ai
https://www.oracle.com/database/berkeley-db/
Discover advanced database features like AI, security, and cloud solutions, and optimize your data with Oracle's robust technologies.
- 145qlibc/LICENSE at main · wolkykim/qlibc
https://github.com/wolkykim/qlibc/blob/master/LICENSE
qLibc is a simple and yet powerful C library providing generic data structures and algorithms. - wolkykim/qlibc
- 146One of the fastest hash functions
https://github.com/leo-yuriev/t1ha
One of the fastest hash functions. Contribute to erthink/t1ha development by creating an account on GitHub.
- 147Sunsetting Atom
https://atom.io/
We are archiving Atom and all projects under the Atom organization for an official sunset on December 15, 2022.
- 148Home | Vulkan | Cross platform 3D Graphics
https://www.khronos.org/vulkan/
Vulkan is a next generation graphics and compute API that provides high-efficiency, cross-platform access to modern GPUs used in PCs, consoles, mobile phones and embedded platforms.
- 149Mbed TLS
https://tls.mbed.org/
Project implements cryptographic primitives, X.509 certificate manipulation and the SSL/TLS and DTLS protocols.
- 150Situs SBOBET Online Link Daftar SBOBET88 Login Indonesia
http://anjuta.org/
SBOBET88 adalah situs judi bola resmi partner Betwin188 agen sbobet online mobile terpercaya 2024, penyedia link daftar sbobet login indonesia 24jam.
- 151C library for encoding, decoding and manipulating JSON data
http://www.digip.org/jansson/
C library for encoding, decoding and manipulating JSON data - akheron/jansson
- 152Developer Tools & IDE | The Eclipse Foundation
http://www.eclipse.org/ide/
Our community is innovating on the next generation of cloud native developer tools, including the Eclipse IDE which is the leading open platform for …
Related Articlesto learn about angular.
- 1Getting Started with C Programming: Beginner’s Guide
- 2Functions and Pointers in C: Write Efficient Code
- 3Memory Management in C: malloc and free
- 4File Handling in C: Reading and Writing Files with fopen and fwrite
- 5Data Structures in C: Linked Lists, Stacks, and Queues
- 6Multithreading in C: POSIX Threads (Pthreads)
- 7Getting Started with C Programming for Embedded Systems
- 8IoT Applications with C: Beginner’s Guide
- 9Optimizing C Code: Speed and Efficiency
- 10Common C Programming Pitfalls
FAQ'sto learn more about Angular JS.
mail [email protected] to add more queries here 🔍.
- 1
what can you do with c programming
- 2
why was the c programming language invented
- 3
where to download c programming language
- 4
which app is best for c programming in laptop
- 5
how c programming language was developed
- 6
how many days need to learn c programming
- 7
do you pronounce the c in schedule
- 8
which software is best for c programming
- 9
when was c programming language invented
- 10
what is c times c
- 11
what are arrays in c programming
- 13
who is the father of c language mcq
- 14
will c be replaced
- 15
was c written in assembly
- 16
what c programming is used for
- 17
how to do c programming in visual studio code
- 18
why c programming is called structured programming
- 19
which compiler is best for c programming
- 20
what c programming language is used for
- 21
will c++ ever die
- 22
is c programming language object oriented
- 23
when did c programming language come out
- 24
is c programming language case sensitive
- 25
why should i learn c programming language
- 26
why c programming is used
- 27
what is array in c programming
- 28
what can c programming be used for
- 29
who is the programming language c
- 30
which software is used for c programming
- 31
when c is called structured programming language
- 32
why c programming is called c
- 33
is c the first programming language
- 34
who developed c programming language
- 35
why should i learn c programming
- 36
who is the father of c programming
- 37
when c programming was developed
- 38
is c programming language
- 39
is c programming the same as c++
- 40
when was the c programming language developed
- 41
how to do c programming in mobile
- 42
how long will it take to learn c programming
- 43
who is the founder of c programming
- 45
how to use vs code for c programming
- 46
will c ever be replaced
- 47
who invented c programming
- 48
who uses c programming language
- 49
what does c programming look like
- 50
which is the best website to learn c programming
- 51
is c programming language still used
- 52
what are pointers in c programming
- 53
what is structure in c programming
- 54
who created c programming language
- 55
should i learn c programming first
- 56
who wrote c programming language
- 57
who made c programming language
- 58
what can c be used for
- 59
what are variables in c programming
- 60
how difficult is c programming
- 61
can c code run in c++
- 62
what are strings in c programming
- 63
who is the father of c
- 64
where to practice c programming
- 65
how c programming language works
- 66
is c programming hard
- 67
what is string in c programming
- 68
is c dead programming language
- 69
where to start c programming
- 70
what are structures in c programming
- 71
how c programming works
- 72
which book is best for c programming
- 73
what does c programming language look like
- 74
what did == mean in c programming
- 75
will c# replace c++
- 76
how to do c programming in laptop
- 77
where to learn c programming
- 78
how much time is required to learn c programming
- 79
do c programming online
- 80
is c programming worth learning
- 81
what are c programming languages
- 83
is c written in c
- 84
would i like programming
- 85
where to do c programming
- 86
what is pointer in c programming
- 87
what does c programming do
- 88
do c programming language
- 89
how to learn c programming
- 90
what are the features of c programming language
- 91
which ide is best for c programming
- 92
why c is called structured programming language
- 93
where to do c programming in laptop
- 94
is programming in c hard
- 95
who is the father of c programming language
- 96
whose line is it anyway cw schedule
- 97
is c programming still used
- 98
why c programming language
- 99
how to use code blocks for c programming
- 100
what does mean in c programming
- 101
does c programming have classes
- 102
can computers program themselves
- 103
how to do c programming in windows
- 104
what does c programming stand for
- 105
is c programming free
- 106
what are the data types in c programming
- 107
which programming language should i learn after c
- 108
how to start c programming
- 109
will c language die
- 110
what is an compiler in c programming
- 111
where should we do c programming
- 112
where was c programming invented
- 113
who made the c programming language
- 114
which software for c programming
- 115
where c programming is used
- 116
where can i learn c programming for free
- 117
how to do c programming in vs code
- 118
what is c as a programming language
- 119
does c have object oriented programming
- 120
why is c called a mid-level programming language
- 121
can c++ do everything c can
- 122
where is c programming language used
- 123
how does c programming language work
- 124
what are functions in c programming
- 125
do c programming in terminal
- 126
what are keywords in c programming
- 127
can c and c++ be mixed
- 128
why c programming is important
- 129
how to do c programming in ubuntu
- 130
how to practice c programming
- 131
what is embedded c programming
- 132
is c programming case sensitive
- 133
how long does it take to learn c programming
- 134
who is father of c language
- 135
what c programming language
- 136
why c programming is named as c
- 137
why learn c programming
- 138
when was c programming developed
- 139
is c programming easy
- 140
how does c programming work
- 141
is c good for beginners
- 142
which c programming language to learn
- 143
is c programming easy to learn
- 144
why is c named c
- 145
what does c stand for in programming
- 146
when was c programming language created
- 147
what is function in c programming
- 148
why was c invented
- 149
how to download c programming
- 150
what does void mean in c programming
More Sitesto check out once you're finished browsing here.
https://www.0x3d.site/
0x3d is designed for aggregating information.
https://nodejs.0x3d.site/
NodeJS Online Directory
https://cross-platform.0x3d.site/
Cross Platform Online Directory
https://open-source.0x3d.site/
Open Source Online Directory
https://analytics.0x3d.site/
Analytics Online Directory
https://javascript.0x3d.site/
JavaScript Online Directory
https://golang.0x3d.site/
GoLang Online Directory
https://python.0x3d.site/
Python Online Directory
https://swift.0x3d.site/
Swift Online Directory
https://rust.0x3d.site/
Rust Online Directory
https://scala.0x3d.site/
Scala Online Directory
https://ruby.0x3d.site/
Ruby Online Directory
https://clojure.0x3d.site/
Clojure Online Directory
https://elixir.0x3d.site/
Elixir Online Directory
https://elm.0x3d.site/
Elm Online Directory
https://lua.0x3d.site/
Lua Online Directory
https://c-programming.0x3d.site/
C Programming Online Directory
https://cpp-programming.0x3d.site/
C++ Programming Online Directory
https://r-programming.0x3d.site/
R Programming Online Directory
https://perl.0x3d.site/
Perl Online Directory
https://java.0x3d.site/
Java Online Directory
https://kotlin.0x3d.site/
Kotlin Online Directory
https://php.0x3d.site/
PHP Online Directory
https://react.0x3d.site/
React JS Online Directory
https://angular.0x3d.site/
Angular JS Online Directory