BranchesTags

Repository files navigation

lcdb

DISCLAIMER: lcdb has no affiliation with or endorsement from Google Inc. whatsoever despite the API prefix being ldb_ (let's hope they don't cease and desist us again).

A state-of-the-art database in C89 (originally designed by Jeffrey Dean and Sanjay Ghemawat and implemented in C++).

Background

LevelDB was painstakingly ported from C++ to C89¹ for use with mako. mako is a C project which requires an LSM tree for its UTXO database (which in turn requires high write throughput with very effective compaction). mako has a strict development policy of "do not link to libstdc++" and "do not require a c++ compiler".

LevelDB is used by many bitcoin implementations for indexing the UTXO state. After experimenting with various databases written in C, it was clear that LevelDB was still the obvious choice, despite it being written in C++. Existing databases written in C weren't cutting it in terms of performance (in some cases maybe they were, but instead lacked effective compaction).

mako's strict policy of portability plus the lack of a production-ready LSM tree written in C ultimately led to the creation of lcdb.

  1. Note that the platform (or user) must still provide a working <stdint.h> as a build dependency.

Portability

Portability is one of lcdb's primary goals. lcdb is written in such a way that it should be usable on Windows 9x¹ as well as unices which predate POSIX.1-2001.

Portability to this degree was achieved by sifting through copies of MSDN from the '90s, as well as examining header files from old unix releases to see which system calls were truly² available in practice.

lcdb also offers the option to build without pthread support (with compaction taking place on the main thread).

  1. Unfortunately, kernel32.dll on Windows 9x does not provide MoveFileEx which is necessary for atomic renames. This means lcdb will be more prone to recovery errors on Windows 95/98/ME.

  2. A good example of the incongruence between standards and implementation is fdatasync(2) and pread(2). The former was standardized by POSIX.1b (1993) and made mandatory by SUSv2 (1997) and POSIX.1-2001. The latter was standardized by SUSv2 (1997) and mandated by POSIX.1-2008. In spite of this, some conforming OSes only began providing them in the last decade (in some cases the past 5 years or so).

Cross Compilation

Due to its portability, lcdb is well-suited for common cross-compilation environments like mingw and wasi-sdk.

This repo includes some helper scripts for both mingw and wasi.

Building with mingw:

$ ./scripts/mingw-cmake cmake . -DCMAKE_BUILD_TYPE=Release
$ make

Building with wasi-sdk:

$ ./scripts/wasi-cmake cmake . -DCMAKE_BUILD_TYPE=Release
$ make

More Disclaimers & License Info

Despite being written in another language, lcdb's codebase is largely derivative of LevelDB's. As such, the LevelDB license must be shipped (and conformed to) with the distribution of lcdb in every form.

lcdb is still very immature and is not yet battle-hardened like LevelDB. It will also likely be subject to breaking ABI changes in the near future. Use at your own risk.

Usage

The API tries to mimic the C++ API as much as it can. Users of LevelDB should find it familiar.

Example:

#include<assert.h>#include<lcdb.h>intmain(void) {
ldb_dbopt_topt=*ldb_dbopt_default;
ldb_slice_tkey, val, ret;
ldb_t*db;
intrc;
opt.create_if_missing=1;
rc=ldb_open("tmp", &opt, &db);
assert(rc==LDB_OK);
key=ldb_string("hello");
val=ldb_string("world");
rc=ldb_put(db, &key, &val, 0);
assert(rc==LDB_OK);
rc=ldb_get(db, &key, &ret, 0);
assert(rc==LDB_OK);
assert(ldb_compare(db, &ret, &val) ==0);
ldb_free(ret.data);
ldb_close(db);
return0;
}

Build with:

$ cc -o example example.c -llcdb

Or:

$ cc -o example -I./include example.c liblcdb.a -lpthread

See the header file for more information.

Contribution and License Agreement

If you contribute code to this project, you are implicitly allowing your code to be distributed under the MIT license. You are also implicitly verifying that all code is your original work. </legalese>

License

  • Copyright (c) 2022, Christopher Jeffrey (MIT License).

Parts of this software are based on google/leveldb:

  • Copyright (c) 2011, The LevelDB Authors. All rights reserved.

Parts of this software are based on google/crc32c:

  • Copyright (c) 2017, The CRC32C Authors.

Parts of this software are based on golang/snappy:

  • Copyright (c) 2011 The Snappy-Go Authors. All rights reserved.

See LICENSE for more info.

About

LevelDB implemented in C (unofficial -- not affiliated with Google in any way)

Topics

cdatabaseleveldblsm

Resources

Readme
License
Activity

Stars

104 stars

Watchers

5 watching

Forks

12 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Add copy buttons to all 
 blocks\n(function() {\n function addCopyButtons() {\n document.querySelectorAll('pre code').forEach(function(codeBlock) {\n if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;\n codeBlock.parentElement.setAttribute('data-copy-added', 'true');\n \n var btn = document.createElement('button');\n btn.textContent = 'Copy';\n btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';\n btn.onmouseover = function() { this.style.opacity = '1'; };\n btn.onmouseout = function() { this.style.opacity = '0.7'; };\n btn.onclick = function() {\n navigator.clipboard.writeText(codeBlock.textContent).then(function() {\n btn.textContent = 'Copied!';\n setTimeout(function() { btn.textContent = 'Copy'; }, 1500);\n });\n };\n codeBlock.parentElement.style.position = 'relative';\n codeBlock.parentElement.appendChild(btn);\n });\n }\n \n addCopyButtons();\n \n // Re-run on dynamic content\n var observer = new MutationObserver(addCopyButtons);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Add Copy Buttons to Code Blocks");
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
BranchesTags
Repository files navigation
lcdb
DISCLAIMER: lcdb has no affiliation with or endorsement from Google Inc.
whatsoever despite the API prefix being ldb_ (let's hope they don't cease
and desist us again).
A state-of-the-art database in C89 (originally designed by Jeffrey Dean and
Sanjay Ghemawat and implemented in C++).
Background
LevelDB was painstakingly ported from C++ to C89¹ for use with mako.
mako is a C project which requires an LSM tree for its UTXO database (which
in turn requires high write throughput with very effective compaction). mako
has a strict development policy of "do not link to libstdc++" and "do not
require a c++ compiler".
LevelDB is used by many bitcoin implementations for indexing the UTXO state.
After experimenting with various databases written in C, it was clear that
LevelDB was still the obvious choice, despite it being written in C++. Existing
databases written in C weren't cutting it in terms of performance (in some
cases maybe they were, but instead lacked effective compaction).
mako's strict policy of portability plus the lack of a production-ready LSM
tree written in C ultimately led to the creation of lcdb.
  1. Note that the platform (or user) must still provide a working <stdint.h>
as a build dependency.
Portability
Portability is one of lcdb's primary goals. lcdb is written in such a way
that it should be usable on Windows 9x¹ as well as unices which predate
POSIX.1-2001.
Portability to this degree was achieved by sifting through copies of MSDN from
the '90s, as well as examining header files from old unix releases to see which
system calls were truly² available in practice.
lcdb also offers the option to build without pthread support (with compaction
taking place on the main thread).
  1. Unfortunately, kernel32.dll on Windows 9x does not provide MoveFileEx
which is necessary for atomic renames. This means lcdb will be more prone to
recovery errors on Windows 95/98/ME.
  2. A good example of the incongruence between standards and implementation is
fdatasync(2) and pread(2). The former was standardized by POSIX.1b (1993)
and made mandatory by SUSv2 (1997) and POSIX.1-2001. The latter was
standardized by SUSv2 (1997) and mandated by POSIX.1-2008. In spite of this,
some conforming OSes only began providing them in the last decade (in some
cases the past 5 years or so).
Cross Compilation
Due to its portability, lcdb is well-suited for common cross-compilation
environments like mingw and wasi-sdk.
This repo includes some helper scripts for both mingw and wasi.
Building with mingw:
$ ./scripts/mingw-cmake cmake . -DCMAKE_BUILD_TYPE=Release
$ make
Building with wasi-sdk:
$ ./scripts/wasi-cmake cmake . -DCMAKE_BUILD_TYPE=Release
$ make
More Disclaimers & License Info
Despite being written in another language, lcdb's codebase is largely
derivative of LevelDB's. As such, the LevelDB license must be shipped (and
conformed to) with the distribution of lcdb in every form.
lcdb is still very immature and is not yet battle-hardened like LevelDB. It
will also likely be subject to breaking ABI changes in the near future. Use at
your own risk.
Usage
The API tries to mimic the C++ API as much as it can. Users of LevelDB should
find it familiar.
Example:
#include<assert.h>#include<lcdb.h>intmain(void) {
ldb_dbopt_topt=*ldb_dbopt_default;
ldb_slice_tkey, val, ret;
ldb_t*db;
intrc;
opt.create_if_missing=1;
rc=ldb_open("tmp", &opt, &db);
assert(rc==LDB_OK);
key=ldb_string("hello");
val=ldb_string("world");
rc=ldb_put(db, &key, &val, 0);
assert(rc==LDB_OK);
rc=ldb_get(db, &key, &ret, 0);
assert(rc==LDB_OK);
assert(ldb_compare(db, &ret, &val) ==0);
ldb_free(ret.data);
ldb_close(db);
return0;
}
Build with:
$ cc -o example example.c -llcdb
Or:
$ cc -o example -I./include example.c liblcdb.a -lpthread
See the header file for more information.
Contribution and License Agreement
If you contribute code to this project, you are implicitly allowing your code
to be distributed under the MIT license. You are also implicitly verifying that
all code is your original work. </legalese>
License
  • Copyright (c) 2022, Christopher Jeffrey (MIT License).
Parts of this software are based on google/leveldb:
  • Copyright (c) 2011, The LevelDB Authors. All rights reserved.
Parts of this software are based on google/crc32c:
  • Copyright (c) 2017, The CRC32C Authors.
Parts of this software are based on golang/snappy:
  • Copyright (c) 2011 The Snappy-Go Authors. All rights reserved.
See LICENSE for more info.
About
LevelDB implemented in C (unofficial -- not affiliated with Google in any way)
Topics
cdatabaseleveldblsm
Resources
Readme
License
Activity
Stars
104 stars
Watchers
5 watching
Forks
12 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Force GitHub README to respect dark mode\n(function() {\n var style = document.createElement('style');\n style.textContent = '\n .markdown-body {\n color-scheme: dark light;\n }\n .markdown-body pre { background: #161b22 !important; }\n .markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }\n .markdown-body table th, .markdown-body table td { border-color: #30363d !important; }\n .markdown-body img { background: #0d1117; }\n .markdown-body blockquote { border-left-color: #8b949e; }\n .markdown-body hr { border-color: #30363d; }\n ';\n document.head.appendChild(style);\n})();", "GitHub Dark Mode README Fix");
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
lcdb
DISCLAIMER: lcdb has no affiliation with or endorsement from Google Inc.
whatsoever despite the API prefix being ldb_ (let's hope they don't cease
and desist us again).
A state-of-the-art database in C89 (originally designed by Jeffrey Dean and
Sanjay Ghemawat and implemented in C++).
Background
LevelDB was painstakingly ported from C++ to C89¹ for use with mako.
mako is a C project which requires an LSM tree for its UTXO database (which
in turn requires high write throughput with very effective compaction). mako
has a strict development policy of "do not link to libstdc++" and "do not
require a c++ compiler".
LevelDB is used by many bitcoin implementations for indexing the UTXO state.
After experimenting with various databases written in C, it was clear that
LevelDB was still the obvious choice, despite it being written in C++. Existing
databases written in C weren't cutting it in terms of performance (in some
cases maybe they were, but instead lacked effective compaction).
mako's strict policy of portability plus the lack of a production-ready LSM
tree written in C ultimately led to the creation of lcdb.
  1. Note that the platform (or user) must still provide a working <stdint.h>
as a build dependency.
Portability
Portability is one of lcdb's primary goals. lcdb is written in such a way
that it should be usable on Windows 9x¹ as well as unices which predate
POSIX.1-2001.
Portability to this degree was achieved by sifting through copies of MSDN from
the '90s, as well as examining header files from old unix releases to see which
system calls were truly² available in practice.
lcdb also offers the option to build without pthread support (with compaction
taking place on the main thread).
  1. Unfortunately, kernel32.dll on Windows 9x does not provide MoveFileEx
which is necessary for atomic renames. This means lcdb will be more prone to
recovery errors on Windows 95/98/ME.
  2. A good example of the incongruence between standards and implementation is
fdatasync(2) and pread(2). The former was standardized by POSIX.1b (1993)
and made mandatory by SUSv2 (1997) and POSIX.1-2001. The latter was
standardized by SUSv2 (1997) and mandated by POSIX.1-2008. In spite of this,
some conforming OSes only began providing them in the last decade (in some
cases the past 5 years or so).
Cross Compilation
Due to its portability, lcdb is well-suited for common cross-compilation
environments like mingw and wasi-sdk.
This repo includes some helper scripts for both mingw and wasi.
Building with mingw:
$ ./scripts/mingw-cmake cmake . -DCMAKE_BUILD_TYPE=Release
$ make
Building with wasi-sdk:
$ ./scripts/wasi-cmake cmake . -DCMAKE_BUILD_TYPE=Release
$ make
More Disclaimers & License Info
Despite being written in another language, lcdb's codebase is largely
derivative of LevelDB's. As such, the LevelDB license must be shipped (and
conformed to) with the distribution of lcdb in every form.
lcdb is still very immature and is not yet battle-hardened like LevelDB. It
will also likely be subject to breaking ABI changes in the near future. Use at
your own risk.
Usage
The API tries to mimic the C++ API as much as it can. Users of LevelDB should
find it familiar.
Example:
#include<assert.h>#include<lcdb.h>intmain(void) {
ldb_dbopt_topt=*ldb_dbopt_default;
ldb_slice_tkey, val, ret;
ldb_t*db;
intrc;
opt.create_if_missing=1;
rc=ldb_open("tmp", &opt, &db);
assert(rc==LDB_OK);
key=ldb_string("hello");
val=ldb_string("world");
rc=ldb_put(db, &key, &val, 0);
assert(rc==LDB_OK);
rc=ldb_get(db, &key, &ret, 0);
assert(rc==LDB_OK);
assert(ldb_compare(db, &ret, &val) ==0);
ldb_free(ret.data);
ldb_close(db);
return0;
}
Build with:
$ cc -o example example.c -llcdb
Or:
$ cc -o example -I./include example.c liblcdb.a -lpthread
See the header file for more information.
Contribution and License Agreement
If you contribute code to this project, you are implicitly allowing your code
to be distributed under the MIT license. You are also implicitly verifying that
all code is your original work. </legalese>
License
  • Copyright (c) 2022, Christopher Jeffrey (MIT License).
Parts of this software are based on google/leveldb:
  • Copyright (c) 2011, The LevelDB Authors. All rights reserved.
Parts of this software are based on google/crc32c:
  • Copyright (c) 2017, The CRC32C Authors.
Parts of this software are based on golang/snappy:
  • Copyright (c) 2011 The Snappy-Go Authors. All rights reserved.
See LICENSE for more info.
About
LevelDB implemented in C (unofficial -- not affiliated with Google in any way)
Topics
cdatabaseleveldblsm
Resources
Readme
License
Activity
Stars
104 stars
Watchers
5 watching
Forks
12 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Highlight search terms from Google/DuckDuckGo/Bing referrer\n(function() {\n var ref = document.referrer;\n var terms = [];\n \n if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {\n var url = new URL(ref);\n var q = url.searchParams.get('q') || url.searchParams.get('p');\n if (q) {\n terms = q.split(/\\s+/).filter(function(t) { return t.length > 2; });\n }\n }\n \n if (terms.length === 0) return;\n \n var style = document.createElement('style');\n style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';\n document.head.appendChild(style);\n \n function highlight(node) {\n if (node.nodeType === 3) { // text node\n var text = node.textContent;\n var found = false;\n terms.forEach(function(term) {\n var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\') + ')', 'gi');\n if (regex.test(text)) {\n found = true;\n var frag = document.createDocumentFragment();\n var parts = text.split(regex);\n parts.forEach(function(part, i) {\n if (i % 2 === 0) {\n frag.appendChild(document.createTextNode(part));\n } else {\n var span = document.createElement('span');\n span.className = 'userscript-highlight';\n span.textContent = part;\n frag.appendChild(span);\n }\n });\n node.parentNode.replaceChild(frag, node);\n }\n });\n } else if (node.nodeType === 1 && node.childNodes) { // element\n var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];\n if (!skipTags.includes(node.tagName)) {\n Array.from(node.childNodes).forEach(highlight);\n }\n }\n }\n \n highlight(document.body);\n \n // Re-highlight on dynamic content\n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1 || node.nodeType === 3) highlight(node);\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Highlight Search Terms");
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
lcdb
DISCLAIMER: lcdb has no affiliation with or endorsement from Google Inc.
whatsoever despite the API prefix being ldb_ (let's hope they don't cease
and desist us again).
A state-of-the-art database in C89 (originally designed by Jeffrey Dean and
Sanjay Ghemawat and implemented in C++).
Background
LevelDB was painstakingly ported from C++ to C89¹ for use with mako.
mako is a C project which requires an LSM tree for its UTXO database (which
in turn requires high write throughput with very effective compaction). mako
has a strict development policy of "do not link to libstdc++" and "do not
require a c++ compiler".
LevelDB is used by many bitcoin implementations for indexing the UTXO state.
After experimenting with various databases written in C, it was clear that
LevelDB was still the obvious choice, despite it being written in C++. Existing
databases written in C weren't cutting it in terms of performance (in some
cases maybe they were, but instead lacked effective compaction).
mako's strict policy of portability plus the lack of a production-ready LSM
tree written in C ultimately led to the creation of lcdb.
  1. Note that the platform (or user) must still provide a working <stdint.h>
as a build dependency.
Portability
Portability is one of lcdb's primary goals. lcdb is written in such a way
that it should be usable on Windows 9x¹ as well as unices which predate
POSIX.1-2001.
Portability to this degree was achieved by sifting through copies of MSDN from
the '90s, as well as examining header files from old unix releases to see which
system calls were truly² available in practice.
lcdb also offers the option to build without pthread support (with compaction
taking place on the main thread).
  1. Unfortunately, kernel32.dll on Windows 9x does not provide MoveFileEx
which is necessary for atomic renames. This means lcdb will be more prone to
recovery errors on Windows 95/98/ME.
  2. A good example of the incongruence between standards and implementation is
fdatasync(2) and pread(2). The former was standardized by POSIX.1b (1993)
and made mandatory by SUSv2 (1997) and POSIX.1-2001. The latter was
standardized by SUSv2 (1997) and mandated by POSIX.1-2008. In spite of this,
some conforming OSes only began providing them in the last decade (in some
cases the past 5 years or so).
Cross Compilation
Due to its portability, lcdb is well-suited for common cross-compilation
environments like mingw and wasi-sdk.
This repo includes some helper scripts for both mingw and wasi.
Building with mingw:
$ ./scripts/mingw-cmake cmake . -DCMAKE_BUILD_TYPE=Release
$ make
Building with wasi-sdk:
$ ./scripts/wasi-cmake cmake . -DCMAKE_BUILD_TYPE=Release
$ make
More Disclaimers & License Info
Despite being written in another language, lcdb's codebase is largely
derivative of LevelDB's. As such, the LevelDB license must be shipped (and
conformed to) with the distribution of lcdb in every form.
lcdb is still very immature and is not yet battle-hardened like LevelDB. It
will also likely be subject to breaking ABI changes in the near future. Use at
your own risk.
Usage
The API tries to mimic the C++ API as much as it can. Users of LevelDB should
find it familiar.
Example:
#include<assert.h>#include<lcdb.h>intmain(void) {
ldb_dbopt_topt=*ldb_dbopt_default;
ldb_slice_tkey, val, ret;
ldb_t*db;
intrc;
opt.create_if_missing=1;
rc=ldb_open("tmp", &opt, &db);
assert(rc==LDB_OK);
key=ldb_string("hello");
val=ldb_string("world");
rc=ldb_put(db, &key, &val, 0);
assert(rc==LDB_OK);
rc=ldb_get(db, &key, &ret, 0);
assert(rc==LDB_OK);
assert(ldb_compare(db, &ret, &val) ==0);
ldb_free(ret.data);
ldb_close(db);
return0;
}
Build with:
$ cc -o example example.c -llcdb
Or:
$ cc -o example -I./include example.c liblcdb.a -lpthread
See the header file for more information.
Contribution and License Agreement
If you contribute code to this project, you are implicitly allowing your code
to be distributed under the MIT license. You are also implicitly verifying that
all code is your original work. </legalese>
License
  • Copyright (c) 2022, Christopher Jeffrey (MIT License).
Parts of this software are based on google/leveldb:
  • Copyright (c) 2011, The LevelDB Authors. All rights reserved.
Parts of this software are based on google/crc32c:
  • Copyright (c) 2017, The CRC32C Authors.
Parts of this software are based on golang/snappy:
  • Copyright (c) 2011 The Snappy-Go Authors. All rights reserved.
See LICENSE for more info.
About
LevelDB implemented in C (unofficial -- not affiliated with Google in any way)
Topics
cdatabaseleveldblsm
Resources
Readme
License
Activity
Stars
104 stars
Watchers
5 watching
Forks
12 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Strip utm_, fbclid, gclid, etc. from all links on page\n(function() {\n var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',\n 'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',\n 'ref', 'ref_src', 'source', 'medium', 'campaign'];\n \n function cleanUrl(url) {\n try {\n var u = new URL(url, window.location.origin);\n var changed = false;\n trackingParams.forEach(function(p) {\n if (u.searchParams.has(p)) {\n u.searchParams.delete(p);\n changed = true;\n }\n });\n return changed ? u.toString() : url;\n } catch (e) {\n return url;\n }\n }\n \n function cleanLinks() {\n document.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n \n cleanLinks();\n \n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1) {\n if (node.tagName === 'A') cleanLinks();\n node.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Remove Tracking Parameters from Links");
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
BranchesTags
Repository files navigation
lcdb
DISCLAIMER: lcdb has no affiliation with or endorsement from Google Inc.
whatsoever despite the API prefix being ldb_ (let's hope they don't cease
and desist us again).
A state-of-the-art database in C89 (originally designed by Jeffrey Dean and
Sanjay Ghemawat and implemented in C++).
Background
LevelDB was painstakingly ported from C++ to C89¹ for use with mako.
mako is a C project which requires an LSM tree for its UTXO database (which
in turn requires high write throughput with very effective compaction). mako
has a strict development policy of "do not link to libstdc++" and "do not
require a c++ compiler".
LevelDB is used by many bitcoin implementations for indexing the UTXO state.
After experimenting with various databases written in C, it was clear that
LevelDB was still the obvious choice, despite it being written in C++. Existing
databases written in C weren't cutting it in terms of performance (in some
cases maybe they were, but instead lacked effective compaction).
mako's strict policy of portability plus the lack of a production-ready LSM
tree written in C ultimately led to the creation of lcdb.
  1. Note that the platform (or user) must still provide a working <stdint.h>
as a build dependency.
Portability
Portability is one of lcdb's primary goals. lcdb is written in such a way
that it should be usable on Windows 9x¹ as well as unices which predate
POSIX.1-2001.
Portability to this degree was achieved by sifting through copies of MSDN from
the '90s, as well as examining header files from old unix releases to see which
system calls were truly² available in practice.
lcdb also offers the option to build without pthread support (with compaction
taking place on the main thread).
  1. Unfortunately, kernel32.dll on Windows 9x does not provide MoveFileEx
which is necessary for atomic renames. This means lcdb will be more prone to
recovery errors on Windows 95/98/ME.
  2. A good example of the incongruence between standards and implementation is
fdatasync(2) and pread(2). The former was standardized by POSIX.1b (1993)
and made mandatory by SUSv2 (1997) and POSIX.1-2001. The latter was
standardized by SUSv2 (1997) and mandated by POSIX.1-2008. In spite of this,
some conforming OSes only began providing them in the last decade (in some
cases the past 5 years or so).
Cross Compilation
Due to its portability, lcdb is well-suited for common cross-compilation
environments like mingw and wasi-sdk.
This repo includes some helper scripts for both mingw and wasi.
Building with mingw:
$ ./scripts/mingw-cmake cmake . -DCMAKE_BUILD_TYPE=Release
$ make
Building with wasi-sdk:
$ ./scripts/wasi-cmake cmake . -DCMAKE_BUILD_TYPE=Release
$ make
More Disclaimers & License Info
Despite being written in another language, lcdb's codebase is largely
derivative of LevelDB's. As such, the LevelDB license must be shipped (and
conformed to) with the distribution of lcdb in every form.
lcdb is still very immature and is not yet battle-hardened like LevelDB. It
will also likely be subject to breaking ABI changes in the near future. Use at
your own risk.
Usage
The API tries to mimic the C++ API as much as it can. Users of LevelDB should
find it familiar.
Example:
#include<assert.h>#include<lcdb.h>intmain(void) {
ldb_dbopt_topt=*ldb_dbopt_default;
ldb_slice_tkey, val, ret;
ldb_t*db;
intrc;
opt.create_if_missing=1;
rc=ldb_open("tmp", &opt, &db);
assert(rc==LDB_OK);
key=ldb_string("hello");
val=ldb_string("world");
rc=ldb_put(db, &key, &val, 0);
assert(rc==LDB_OK);
rc=ldb_get(db, &key, &ret, 0);
assert(rc==LDB_OK);
assert(ldb_compare(db, &ret, &val) ==0);
ldb_free(ret.data);
ldb_close(db);
return0;
}
Build with:
$ cc -o example example.c -llcdb
Or:
$ cc -o example -I./include example.c liblcdb.a -lpthread
See the header file for more information.
Contribution and License Agreement
If you contribute code to this project, you are implicitly allowing your code
to be distributed under the MIT license. You are also implicitly verifying that
all code is your original work. </legalese>
License
  • Copyright (c) 2022, Christopher Jeffrey (MIT License).
Parts of this software are based on google/leveldb:
  • Copyright (c) 2011, The LevelDB Authors. All rights reserved.
Parts of this software are based on google/crc32c:
  • Copyright (c) 2017, The CRC32C Authors.
Parts of this software are based on golang/snappy:
  • Copyright (c) 2011 The Snappy-Go Authors. All rights reserved.
See LICENSE for more info.
About
LevelDB implemented in C (unofficial -- not affiliated with Google in any way)
Topics
cdatabaseleveldblsm
Resources
Readme
License
Activity
Stars
104 stars
Watchers
5 watching
Forks
12 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Auto-enable theater mode on YouTube\n(function() {\n function tryTheater() {\n var btn = document.querySelector('button[aria-label=\"Theater mode\"], ytd-player #player button[title=\"Theater mode\"]');\n if (btn && !btn.classList.contains('activated')) {\n btn.click();\n }\n }\n \n // Try immediately\n tryTheater();\n \n // Try after navigation (SPA)\n var lastUrl = location.href;\n setInterval(function() {\n if (location.href !== lastUrl) {\n lastUrl = location.href;\n setTimeout(tryTheater, 500);\n }\n }, 1000);\n \n // Also try on player load\n var observer = new MutationObserver(tryTheater);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "YouTube Theater Mode Default");
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
lcdb
DISCLAIMER: lcdb has no affiliation with or endorsement from Google Inc.
whatsoever despite the API prefix being ldb_ (let's hope they don't cease
and desist us again).
A state-of-the-art database in C89 (originally designed by Jeffrey Dean and
Sanjay Ghemawat and implemented in C++).
Background
LevelDB was painstakingly ported from C++ to C89¹ for use with mako.
mako is a C project which requires an LSM tree for its UTXO database (which
in turn requires high write throughput with very effective compaction). mako
has a strict development policy of "do not link to libstdc++" and "do not
require a c++ compiler".
LevelDB is used by many bitcoin implementations for indexing the UTXO state.
After experimenting with various databases written in C, it was clear that
LevelDB was still the obvious choice, despite it being written in C++. Existing
databases written in C weren't cutting it in terms of performance (in some
cases maybe they were, but instead lacked effective compaction).
mako's strict policy of portability plus the lack of a production-ready LSM
tree written in C ultimately led to the creation of lcdb.
  1. Note that the platform (or user) must still provide a working <stdint.h>
as a build dependency.
Portability
Portability is one of lcdb's primary goals. lcdb is written in such a way
that it should be usable on Windows 9x¹ as well as unices which predate
POSIX.1-2001.
Portability to this degree was achieved by sifting through copies of MSDN from
the '90s, as well as examining header files from old unix releases to see which
system calls were truly² available in practice.
lcdb also offers the option to build without pthread support (with compaction
taking place on the main thread).
  1. Unfortunately, kernel32.dll on Windows 9x does not provide MoveFileEx
which is necessary for atomic renames. This means lcdb will be more prone to
recovery errors on Windows 95/98/ME.
  2. A good example of the incongruence between standards and implementation is
fdatasync(2) and pread(2). The former was standardized by POSIX.1b (1993)
and made mandatory by SUSv2 (1997) and POSIX.1-2001. The latter was
standardized by SUSv2 (1997) and mandated by POSIX.1-2008. In spite of this,
some conforming OSes only began providing them in the last decade (in some
cases the past 5 years or so).
Cross Compilation
Due to its portability, lcdb is well-suited for common cross-compilation
environments like mingw and wasi-sdk.
This repo includes some helper scripts for both mingw and wasi.
Building with mingw:
$ ./scripts/mingw-cmake cmake . -DCMAKE_BUILD_TYPE=Release
$ make
Building with wasi-sdk:
$ ./scripts/wasi-cmake cmake . -DCMAKE_BUILD_TYPE=Release
$ make
More Disclaimers & License Info
Despite being written in another language, lcdb's codebase is largely
derivative of LevelDB's. As such, the LevelDB license must be shipped (and
conformed to) with the distribution of lcdb in every form.
lcdb is still very immature and is not yet battle-hardened like LevelDB. It
will also likely be subject to breaking ABI changes in the near future. Use at
your own risk.
Usage
The API tries to mimic the C++ API as much as it can. Users of LevelDB should
find it familiar.
Example:
#include<assert.h>#include<lcdb.h>intmain(void) {
ldb_dbopt_topt=*ldb_dbopt_default;
ldb_slice_tkey, val, ret;
ldb_t*db;
intrc;
opt.create_if_missing=1;
rc=ldb_open("tmp", &opt, &db);
assert(rc==LDB_OK);
key=ldb_string("hello");
val=ldb_string("world");
rc=ldb_put(db, &key, &val, 0);
assert(rc==LDB_OK);
rc=ldb_get(db, &key, &ret, 0);
assert(rc==LDB_OK);
assert(ldb_compare(db, &ret, &val) ==0);
ldb_free(ret.data);
ldb_close(db);
return0;
}
Build with:
$ cc -o example example.c -llcdb
Or:
$ cc -o example -I./include example.c liblcdb.a -lpthread
See the header file for more information.
Contribution and License Agreement
If you contribute code to this project, you are implicitly allowing your code
to be distributed under the MIT license. You are also implicitly verifying that
all code is your original work. </legalese>
License
  • Copyright (c) 2022, Christopher Jeffrey (MIT License).
Parts of this software are based on google/leveldb:
  • Copyright (c) 2011, The LevelDB Authors. All rights reserved.
Parts of this software are based on google/crc32c:
  • Copyright (c) 2017, The CRC32C Authors.
Parts of this software are based on golang/snappy:
  • Copyright (c) 2011 The Snappy-Go Authors. All rights reserved.
See LICENSE for more info.
About
LevelDB implemented in C (unofficial -- not affiliated with Google in any way)
Topics
cdatabaseleveldblsm
Resources
Readme
License
Activity
Stars
104 stars
Watchers
5 watching
Forks
12 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Remove or un-stick sticky/fixed headers that block content\n(function() {\n function unstick() {\n document.querySelectorAll('header, nav, [role=\"banner\"], .header, .navbar, .sticky, .fixed-top, [style*=\"position: fixed\"], [style*=\"position:sticky\"]').forEach(function(el) {\n if (el.style.position === 'fixed' || el.style.position === 'sticky' || \n getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {\n el.style.position = 'static';\n el.style.top = 'auto';\n el.style.zIndex = 'auto';\n }\n });\n }\n \n unstick();\n \n var observer = new MutationObserver(unstick);\n observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });\n})();", "Kill Sticky Headers");
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
lcdb
DISCLAIMER: lcdb has no affiliation with or endorsement from Google Inc.
whatsoever despite the API prefix being ldb_ (let's hope they don't cease
and desist us again).
A state-of-the-art database in C89 (originally designed by Jeffrey Dean and
Sanjay Ghemawat and implemented in C++).
Background
LevelDB was painstakingly ported from C++ to C89¹ for use with mako.
mako is a C project which requires an LSM tree for its UTXO database (which
in turn requires high write throughput with very effective compaction). mako
has a strict development policy of "do not link to libstdc++" and "do not
require a c++ compiler".
LevelDB is used by many bitcoin implementations for indexing the UTXO state.
After experimenting with various databases written in C, it was clear that
LevelDB was still the obvious choice, despite it being written in C++. Existing
databases written in C weren't cutting it in terms of performance (in some
cases maybe they were, but instead lacked effective compaction).
mako's strict policy of portability plus the lack of a production-ready LSM
tree written in C ultimately led to the creation of lcdb.
  1. Note that the platform (or user) must still provide a working <stdint.h>
as a build dependency.
Portability
Portability is one of lcdb's primary goals. lcdb is written in such a way
that it should be usable on Windows 9x¹ as well as unices which predate
POSIX.1-2001.
Portability to this degree was achieved by sifting through copies of MSDN from
the '90s, as well as examining header files from old unix releases to see which
system calls were truly² available in practice.
lcdb also offers the option to build without pthread support (with compaction
taking place on the main thread).
  1. Unfortunately, kernel32.dll on Windows 9x does not provide MoveFileEx
which is necessary for atomic renames. This means lcdb will be more prone to
recovery errors on Windows 95/98/ME.
  2. A good example of the incongruence between standards and implementation is
fdatasync(2) and pread(2). The former was standardized by POSIX.1b (1993)
and made mandatory by SUSv2 (1997) and POSIX.1-2001. The latter was
standardized by SUSv2 (1997) and mandated by POSIX.1-2008. In spite of this,
some conforming OSes only began providing them in the last decade (in some
cases the past 5 years or so).
Cross Compilation
Due to its portability, lcdb is well-suited for common cross-compilation
environments like mingw and wasi-sdk.
This repo includes some helper scripts for both mingw and wasi.
Building with mingw:
$ ./scripts/mingw-cmake cmake . -DCMAKE_BUILD_TYPE=Release
$ make
Building with wasi-sdk:
$ ./scripts/wasi-cmake cmake . -DCMAKE_BUILD_TYPE=Release
$ make
More Disclaimers & License Info
Despite being written in another language, lcdb's codebase is largely
derivative of LevelDB's. As such, the LevelDB license must be shipped (and
conformed to) with the distribution of lcdb in every form.
lcdb is still very immature and is not yet battle-hardened like LevelDB. It
will also likely be subject to breaking ABI changes in the near future. Use at
your own risk.
Usage
The API tries to mimic the C++ API as much as it can. Users of LevelDB should
find it familiar.
Example:
#include<assert.h>#include<lcdb.h>intmain(void) {
ldb_dbopt_topt=*ldb_dbopt_default;
ldb_slice_tkey, val, ret;
ldb_t*db;
intrc;
opt.create_if_missing=1;
rc=ldb_open("tmp", &opt, &db);
assert(rc==LDB_OK);
key=ldb_string("hello");
val=ldb_string("world");
rc=ldb_put(db, &key, &val, 0);
assert(rc==LDB_OK);
rc=ldb_get(db, &key, &ret, 0);
assert(rc==LDB_OK);
assert(ldb_compare(db, &ret, &val) ==0);
ldb_free(ret.data);
ldb_close(db);
return0;
}
Build with:
$ cc -o example example.c -llcdb
Or:
$ cc -o example -I./include example.c liblcdb.a -lpthread
See the header file for more information.
Contribution and License Agreement
If you contribute code to this project, you are implicitly allowing your code
to be distributed under the MIT license. You are also implicitly verifying that
all code is your original work. </legalese>
License
  • Copyright (c) 2022, Christopher Jeffrey (MIT License).
Parts of this software are based on google/leveldb:
  • Copyright (c) 2011, The LevelDB Authors. All rights reserved.
Parts of this software are based on google/crc32c:
  • Copyright (c) 2017, The CRC32C Authors.
Parts of this software are based on golang/snappy:
  • Copyright (c) 2011 The Snappy-Go Authors. All rights reserved.
See LICENSE for more info.
About
LevelDB implemented in C (unofficial -- not affiliated with Google in any way)
Topics
cdatabaseleveldblsm
Resources
Readme
License
Activity
Stars
104 stars
Watchers
5 watching
Forks
12 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Universal Dark Mode - works on any site\n(function() {\n var enabled = true;\n \n function applyDarkMode() {\n if (!enabled) return;\n \n // Create style element if it doesn't exist\n var style = document.getElementById('universal-dark-mode-style');\n if (!style) {\n style = document.createElement('style');\n style.id = 'universal-dark-mode-style';\n document.head.appendChild(style);\n }\n \n // Dark mode CSS - inverts colors but preserves images/video\n style.textContent = '\n /* Invert everything except media */\n html {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #1a1a2e !important;\n }\n \n /* Restore images, videos, iframes, canvas */\n img, video, iframe, canvas, svg, picture, [style*=\"background-image\"] {\n filter: invert(1) hue-rotate(180deg) !important;\n }\n \n /* Preserve specific elements that should not be inverted */\n .no-dark-mode, .no-dark-mode *,\n [data-theme=\"light\"], [data-theme=\"light\"],\n .ace_editor, .ace_editor *,\n .CodeMirror, .CodeMirror *,\n .monaco-editor, .monaco-editor *,\n .markdown-body pre, .markdown-body pre *,\n .highlight, .highlight *,\n pre code, pre code * {\n filter: none !important;\n }\n \n /* Fix common UI elements */\n .modal, .popup, .dropdown-menu, .tooltip, .popover {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #2d2d44 !important;\n border-color: #444 !important;\n }\n \n /* Scrollbars */\n ::-webkit-scrollbar { background: #1a1a2e !important; }\n ::-webkit-scrollbar-thumb { background: #444 !important; }\n ::-webkit-scrollbar-thumb:hover { background: #555 !important; }\n \n /* Selection */\n ::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ';\n }\n \n function removeDarkMode() {\n var style = document.getElementById('universal-dark-mode-style');\n if (style) style.remove();\n }\n \n // Toggle with Alt+Shift+D\n document.addEventListener('keydown', function(e) {\n if (e.altKey && e.shiftKey && e.key === 'D') {\n e.preventDefault();\n enabled = !enabled;\n if (enabled) {\n applyDarkMode();\n console.log('[Universal Dark Mode] Enabled');\n } else {\n removeDarkMode();\n console.log('[Universal Dark Mode] Disabled');\n }\n }\n });\n \n // Apply on load\n applyDarkMode();\n \n // Re-apply on dynamic content\n var observer = new MutationObserver(function(mutations) {\n if (enabled && !document.getElementById('universal-dark-mode-style')) {\n applyDarkMode();\n }\n });\n observer.observe(document.head, { childList: true });\n \n console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');\n})();", "Universal Dark Mode");
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
BranchesTags
Repository files navigation
lcdb
DISCLAIMER: lcdb has no affiliation with or endorsement from Google Inc.
whatsoever despite the API prefix being ldb_ (let's hope they don't cease
and desist us again).
A state-of-the-art database in C89 (originally designed by Jeffrey Dean and
Sanjay Ghemawat and implemented in C++).
Background
LevelDB was painstakingly ported from C++ to C89¹ for use with mako.
mako is a C project which requires an LSM tree for its UTXO database (which
in turn requires high write throughput with very effective compaction). mako
has a strict development policy of "do not link to libstdc++" and "do not
require a c++ compiler".
LevelDB is used by many bitcoin implementations for indexing the UTXO state.
After experimenting with various databases written in C, it was clear that
LevelDB was still the obvious choice, despite it being written in C++. Existing
databases written in C weren't cutting it in terms of performance (in some
cases maybe they were, but instead lacked effective compaction).
mako's strict policy of portability plus the lack of a production-ready LSM
tree written in C ultimately led to the creation of lcdb.
  1. Note that the platform (or user) must still provide a working <stdint.h>
as a build dependency.
Portability
Portability is one of lcdb's primary goals. lcdb is written in such a way
that it should be usable on Windows 9x¹ as well as unices which predate
POSIX.1-2001.
Portability to this degree was achieved by sifting through copies of MSDN from
the '90s, as well as examining header files from old unix releases to see which
system calls were truly² available in practice.
lcdb also offers the option to build without pthread support (with compaction
taking place on the main thread).
  1. Unfortunately, kernel32.dll on Windows 9x does not provide MoveFileEx
which is necessary for atomic renames. This means lcdb will be more prone to
recovery errors on Windows 95/98/ME.
  2. A good example of the incongruence between standards and implementation is
fdatasync(2) and pread(2). The former was standardized by POSIX.1b (1993)
and made mandatory by SUSv2 (1997) and POSIX.1-2001. The latter was
standardized by SUSv2 (1997) and mandated by POSIX.1-2008. In spite of this,
some conforming OSes only began providing them in the last decade (in some
cases the past 5 years or so).
Cross Compilation
Due to its portability, lcdb is well-suited for common cross-compilation
environments like mingw and wasi-sdk.
This repo includes some helper scripts for both mingw and wasi.
Building with mingw:
$ ./scripts/mingw-cmake cmake . -DCMAKE_BUILD_TYPE=Release
$ make
Building with wasi-sdk:
$ ./scripts/wasi-cmake cmake . -DCMAKE_BUILD_TYPE=Release
$ make
More Disclaimers & License Info
Despite being written in another language, lcdb's codebase is largely
derivative of LevelDB's. As such, the LevelDB license must be shipped (and
conformed to) with the distribution of lcdb in every form.
lcdb is still very immature and is not yet battle-hardened like LevelDB. It
will also likely be subject to breaking ABI changes in the near future. Use at
your own risk.
Usage
The API tries to mimic the C++ API as much as it can. Users of LevelDB should
find it familiar.
Example:
#include<assert.h>#include<lcdb.h>intmain(void) {
ldb_dbopt_topt=*ldb_dbopt_default;
ldb_slice_tkey, val, ret;
ldb_t*db;
intrc;
opt.create_if_missing=1;
rc=ldb_open("tmp", &opt, &db);
assert(rc==LDB_OK);
key=ldb_string("hello");
val=ldb_string("world");
rc=ldb_put(db, &key, &val, 0);
assert(rc==LDB_OK);
rc=ldb_get(db, &key, &ret, 0);
assert(rc==LDB_OK);
assert(ldb_compare(db, &ret, &val) ==0);
ldb_free(ret.data);
ldb_close(db);
return0;
}
Build with:
$ cc -o example example.c -llcdb
Or:
$ cc -o example -I./include example.c liblcdb.a -lpthread
See the header file for more information.
Contribution and License Agreement
If you contribute code to this project, you are implicitly allowing your code
to be distributed under the MIT license. You are also implicitly verifying that
all code is your original work. </legalese>
License
  • Copyright (c) 2022, Christopher Jeffrey (MIT License).
Parts of this software are based on google/leveldb:
  • Copyright (c) 2011, The LevelDB Authors. All rights reserved.
Parts of this software are based on google/crc32c:
  • Copyright (c) 2017, The CRC32C Authors.
Parts of this software are based on golang/snappy:
  • Copyright (c) 2011 The Snappy-Go Authors. All rights reserved.
See LICENSE for more info.
About
LevelDB implemented in C (unofficial -- not affiliated with Google in any way)
Topics
cdatabaseleveldblsm
Resources
Readme
License
Activity
Stars
104 stars
Watchers
5 watching
Forks
12 forks
Report repository
Releases
Packages
Contributors
Languages