[obj2def] Initial commit

git-svn-id: svn://kolibrios.org@9532 a494cfbc-eb01-0410-851d-a64ba20cac60

programs/develop/obj2def/README.md

@@ -0,0 +1,5 @@
+# clink
+
+Very simple (yet?) COFF to COFF linker. Merges several COFF files into one. Only works for dependency-less objects yet (designed exclusively for linking objects into KolibriOS COFF library).
+
+[Development process](https://www.youtube.com/playlist?list=PLVMOfciBdLI6BPovPgfVZ9bNuwbXetRc9) (in Russian)

programs/develop/obj2def/cdict/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Magomed Kostoev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

programs/develop/obj2def/cdict/README.md

@@ -0,0 +1,88 @@
+# CDict - a simple dictionary implementation in C
+## Ready to use!
+
+It may be used out of the box with key and value of type `CStr` (which is `char *` - zero-terminated string). Once it instantiated in some file using `CDICT_INST` definition:
+
+```C
+#define CDICT_INST
+#include "cdict.h"
+```
+
+It may be then declared just using `#include`:
+
+```C
+#include "cdict.h"
+
+int main() {
+    CDict_CStr_CStr dict;
+    if (!cdict_CStr_CStr_init(&dict)) {
+    	printf("CDict returned error #%d", dict.error_code);
+    	return 0;
+    }
+    cdict_CStr_CStr_add_vv(&dict, "key_a", "value_a", CDICT_REPLACE_EXIST);
+    printf("[key_a] = \"%s\"\n", cdict_CStr_CStr_get_v(&dict, "key_a"));
+}
+```
+
+## Easy to configure!
+
+If you want to create a dictionary for other key types you should provide your own keys hashing and comparsion functions, in such case the instantiation of the library will look like this:
+
+```C
+#define CDICT_INST
+#define CDICT_KEY_T MyType
+#define CDICT_HASH_FN(pkey) my_hash(pkey)
+#define CDICT_CMP_FN(pkey0, pkey1) my_cmp(pkey0, pkey1)
+#include "cdict.h"
+
+int my_cmp(MyType *pkey0, MyType *pkey1) {
+    // Return `whatever_negative` if `key0 < key1`, `0` if `key0 == key1` and `whatever_positive` if `key0 > key1` 
+}
+
+unsigned long my_hash(MyType *key) {
+    // Return the hash of the key
+}
+```
+
+Then to use the new dictionary you only need to define key type before the header inclusion:
+
+```C
+#define CDICT_KEY_T MyType
+#include "cdict.h"
+
+// ...
+    CDict_MyType_CStr dict;
+    cdict_MyType_CStr_init(&dict);
+// ...
+```
+
+If you want to specify the type of values - just define the type:
+
+```C
+#define CDICT_VAL_T MyValueType
+```
+
+And so on.
+
+## Dependency-free!
+
+Every single used dependency may be redefined:
+
+```C
+#define CDICT_ASSERT_FN(x) my_assert(x);
+```
+
+## Flexible!
+
+May define user data to be used in overriden functions (for example - custom allocators):
+
+```C
+#define CDICT_USER_DATA_T UserData
+#define CDICT_HASHTAB_ITEM_ALLOC_FN(cdict, size) item_alloc(cdict, size)
+#define CDICT_HASHTAB_ITEM_FREE_FN(cdict, ptr) item_free(cdict, ptr)
+#define CDICT_HASHTAB_ALLOC_FN(cdict, size) hashtab_alloc(cdict, size)
+```
+
+## Checkout
+
+[The library](cdict.h).

programs/develop/obj2def/cdict/cdict.h

@@ -0,0 +1,350 @@
+// Copyright (c) 2020 Magomed Kostoev
+//
+// You may use, distribute and modify this code under the terms of the MIT license.
+//
+// You should have received a copy of the MIT license with this file. If not, please visit
+// https://opensource.org/licenses/MIT or boppan.org/MIT for full license details.
+
+// cdict.h - simple dictionaty implementation in C.
+//
+// Uses hash table with fixed (but configurable) size. Functions named using given type names:
+// cdict_<CDICT_KEY_T>_<CDICT_VAL_T>_<name>.
+//
+// See configuration below (in public "Input macros" section), also:
+// CDICT_INST: Instantiate the functions if defined.
+//
+// Minimal definitions for declaration: CDICT_KEY_T, CDICT_VAL_T
+// Minimal definitions for instantiation: CDICT_INST, CDICT_KEY_T, CDICT_VAL_T, CDICT_HASH_FN,
+// CDICT_CMP_FN
+//
+// WARNING: All used definitions will be undefined on header exit.
+//
+// Dependencies:
+//  <stddef.h> or another source of size_t
+//  <stdlib.h> or another source of malloc, and calloc
+//  <assert.h> or another source of assert
+
+//
+// Internal macros for external declarations
+//
+
+#define CDICT_CAT2_IMPL(x, y) x ## _ ## y
+#define CDICT_CAT2(x, y) CDICT_CAT2_IMPL(x, y)
+
+/// Creates method name according to CDICT_KEY_T and CDICT_VAL_T
+#define CDICT_FUN(name) CDICT_CAT2(cdict, CDICT_CAT2(CDICT_KEY_T, CDICT_CAT2(CDICT_VAL_T, name)))
+
+#define cdict_init CDICT_FUN(init)
+#define cdict_init_ud CDICT_FUN(init_ud)
+#define cdict_init_pud CDICT_FUN(init_pud)
+#define cdict_add_pp CDICT_FUN(add_pp)
+#define cdict_add_vv CDICT_FUN(add_vv)
+#define cdict_get_p CDICT_FUN(get_p)
+#define cdict_get_v CDICT_FUN(get_v)
+#define cdict_error_message CDICT_FUN(error_message)
+
+#define cdict_hash CDICT_FUN(hash)
+#define cdict_keycmp CDICT_FUN(keycmp)
+#define cdict_chain_begin CDICT_FUN(begin)
+#define cdict_chain_next CDICT_FUN(next)
+
+#define CDictItem CDICT_CAT2(CDictItem, CDICT_CAT2(CDICT_KEY_T, CDICT_VAL_T))
+#define CDictItem_s CDICT_CAT2(CDictItem_s, CDICT_CAT2(CDICT_KEY_T, CDICT_VAL_T))
+#define CDict CDICT_CAT2(CDict, CDICT_CAT2(CDICT_KEY_T, CDICT_VAL_T))
+
+//
+// Input macros
+//
+
+/// Type of the dictionary's keys, named type only - used in functions names, default: CStr
+#ifndef CDICT_KEY_T
+typedef char *CStr;
+#define CDICT_CSTR_IS_THERE
+#define CDICT_KEY_T CStr
+#endif
+
+/// Type of the dictionary's values, named type only - used in functions names, default: CStr
+#ifndef CDICT_VAL_T
+#ifndef CDICT_CSTR_IS_THERE
+typedef char *CStr;
+#endif
+#define CDICT_VAL_T CStr
+#endif
+
+/// Type of user data
+#ifndef CDICT_USER_DATA_T
+#define CDICT_USER_DATA_T void *
+#endif
+
+//
+// Public interface
+//
+
+#define CDICT_NO_CHECK 0
+#define CDICT_REPLACE_EXIST 1
+#define CDICT_LEAVE_EXIST 2
+
+#define CDICT_ERR_SUCCESS 0
+#define CDICT_ERR_OUT_OF_MEMORY 1
+#define CDICT_ERR_THIS_IS_NULL 2
+#define CDICT_ERR_HASH_TABLE_IS_NULL 3
+#define CDICT_ERR_PKEY0_IS_NULL 4
+#define CDICT_ERR_PKEY1_IS_NULL 5
+#define CDICT_ERR_PKEY_IS_NULL 6
+#define CDICT_ERR_PVAL_IS_NULL 7
+
+typedef struct CDictItem_s {
+    struct CDictItem_s *next_collision;
+    CDICT_KEY_T key;
+    CDICT_VAL_T val;
+} CDictItem;
+
+typedef struct {
+    CDictItem **hash_table;
+    CDICT_USER_DATA_T user_data;
+    int error_code;
+} CDict;
+
+/// Initializes dictionary structure
+int cdict_init(CDict *s);
+
+/// Initializes dictionary structure with non-standard user data
+int cdict_init_ud(CDict *s, CDICT_USER_DATA_T user_data);
+
+/// Initializes dictionary structure with non-standard user data
+int cdict_init_pud(CDict *s, CDICT_USER_DATA_T *user_data);
+
+/// Inserts a value by key (receives pointers to val and key)
+CDictItem *cdict_add_pp(CDict *s, CDICT_KEY_T *pkey, CDICT_VAL_T *pval, int if_exists);
+
+/// Inserts a value by key (receives values of val and key)
+CDictItem *cdict_add_vv(CDict *s, CDICT_KEY_T key, CDICT_VAL_T val, int if_exists);
+
+/// Gives a value by key (receives a pointer to key)
+CDICT_VAL_T cdict_get_p(CDict *s, CDICT_KEY_T *pkey);
+
+/// Gives a vaule by key (receives a value of key)
+CDICT_VAL_T cdict_get_v(CDict *s, CDICT_KEY_T key);
+
+#ifdef CDICT_INST
+
+//
+// Input macros (instantiation edition)
+//
+
+/// The value returned on some error
+#ifndef CDICT_VAL_DEFAULT
+#define CDICT_VAL_DEFAULT (CDICT_VAL_T){ 0 }
+#endif
+
+/// Hashing function for the key type
+#ifndef CDICT_HASH_FN
+#include <string.h>
+#define CDICT_HASH_FN(pkey) strlen(*pkey) ^ (*pkey)[0]
+#else
+#define CDICT_HASH_FN_OVERRIDEN
+#endif
+
+/// Ammount of pointers to elements in hash table
+#ifndef CDICT_HASHTAB_SZ
+#define CDICT_HASHTAB_SZ 1024
+#endif
+
+/// Hash table allocator MUST return zeroed buffer
+#ifndef CDICT_HASHTAB_ALLOC_FN
+#include <stdlib.h>
+#define CDICT_HASHTAB_ALLOC_FN(cdict, size) calloc(1, size)
+#else
+#define CDICT_HASHTAB_ALLOCATORS_OVERRIDDEN
+#endif
+
+/// New hash table items allocator (should be just a function call)
+#ifndef CDICT_HASHTAB_ITEM_ALLOC_FN
+#include <stdlib.h>
+#define CDICT_HASHTAB_ITEM_ALLOC_FN(cdict, size) malloc(size)
+#define CDICT_HASHTAB_ITEM_FREE_FN(cdict, ptr) free(ptr)
+#else
+#ifndef CDICT_HASHTAB_ITEM_FREE_FN
+#error "CDICT_HASHTAB_ITEM_FREE_FN should be defiend along with CDICT_HASHTAB_ITEM_ALLOC_FN"
+#endif
+#define CDICT_HASHTAB_ITEM_ALLOCATORS_OVERRIDDEN
+#endif
+
+#ifdef CDICT_HASHTAB_ITEM_ALLOCATORS_OVERRIDDEN
+#error "FUCK!"
+#endif
+
+/// Replacement for assert from <assert.h>
+#ifndef CDICT_ASSERT_FN
+#include <assert.h>
+#define CDICT_ASSERT_FN(x) if (!x) { printf(__FILE__":%d: Disasserted", __LINE__); } assert(x)
+#endif
+
+/// Function for comparsion of keys, return should be the same as memcmp
+#ifndef CDICT_CMP_FN
+#include <string.h>
+#define CDICT_CMP_FN(pkey0, pkey1) strcmp(*pkey0, *pkey1)
+#else
+#define CDICT_CMP_FN_OVERRIDDEN
+#endif
+
+//
+// Internal macros (instantiation edition)
+//
+
+#define CDICT_ASSERT(x) ({ CDICT_ASSERT_FN(x); x; })
+// Should write the error code into strucure, but should not rewrite it's already set
+#define CDICT_IF_NULL_SET_ERR_RETURN(x, ec, res) if (x == NULL) {   \
+        if (s->error_code == CDICT_ERR_SUCCESS) s->error_code = ec; \
+        return res;                                                 \
+    }
+#define CDICT_IF_NULL_RETURN(x, res) if (x == NULL) return res
+
+//
+// Predeclarations
+//
+
+#ifdef CDICT_HASHTAB_ITEM_ALLOCATORS_OVERRIDDEN
+void *CDICT_HASHTAB_ITEM_ALLOC_FN(CDict *s, size_t size);
+void CDICT_HASHTAB_ITEM_FREE_FN(CDict *s, CDictItem *ptr);
+#endif
+
+#ifdef CDICT_HASHTAB_ALLOCATORS_OVERRIDDEN
+void *CDICT_HASHTAB_ALLOC_FN(CDict *s, size_t size);
+#endif
+
+#ifdef CDICT_HASH_FN_OVERRIDEN
+unsigned long CDICT_HASH_FN(CDICT_KEY_T *pkey);
+#endif
+
+#ifdef CDICT_CMP_FN_OVERRIDDEN
+int CDICT_CMP_FN(CDICT_KEY_T *pkey0, CDICT_KEY_T *pkey1);
+#endif
+
+//
+// The code
+//
+
+static size_t cdict_hash(CDICT_KEY_T *pkey) {
+    return CDICT_HASH_FN(CDICT_ASSERT(pkey)) & (CDICT_HASHTAB_SZ - 1);
+}
+
+static int cdict_keycmp(CDICT_KEY_T *pkey0, CDICT_KEY_T *pkey1) {
+    return CDICT_CMP_FN(CDICT_ASSERT(pkey0), CDICT_ASSERT(pkey1));
+}
+
+static CDictItem **cdict_chain_begin(CDict *s, CDICT_KEY_T *pkey) {
+    CDICT_ASSERT(s);
+    size_t hash = cdict_hash(CDICT_ASSERT(pkey));
+    CDICT_IF_NULL_SET_ERR_RETURN(s->hash_table, CDICT_ERR_HASH_TABLE_IS_NULL, NULL);
+    return &s->hash_table[hash];
+}
+
+static CDictItem **cdict_chain_next(CDictItem **ppit) {
+    CDICT_ASSERT(ppit);
+    CDICT_ASSERT(*ppit);
+    return &(*ppit)->next_collision;  
+}
+
+int cdict_init(CDict *s) {
+    return cdict_init_pud(s, NULL);
+}
+
+int cdict_init_ud(CDict *s, CDICT_USER_DATA_T user_data) {
+    return cdict_init_pud(s, &user_data);
+}
+
+int cdict_init_pud(CDict *s, CDICT_USER_DATA_T *user_data) {
+    CDICT_IF_NULL_RETURN(s, 0);
+    s->user_data = user_data ? *user_data : (CDICT_USER_DATA_T){ 0 };
+    s->error_code = CDICT_ERR_SUCCESS;
+    s->hash_table = CDICT_HASHTAB_ALLOC_FN(s, sizeof(*s->hash_table) * CDICT_HASHTAB_SZ);
+    CDICT_IF_NULL_SET_ERR_RETURN(s->hash_table, CDICT_ERR_OUT_OF_MEMORY, 0);
+    return 1;
+}
+
+CDictItem *cdict_add_pp(CDict *s, CDICT_KEY_T *pkey, CDICT_VAL_T *pval, int if_exists) {
+    CDICT_IF_NULL_RETURN(s, NULL);
+    CDICT_IF_NULL_SET_ERR_RETURN(pkey, CDICT_ERR_PKEY_IS_NULL, NULL);
+    CDICT_IF_NULL_SET_ERR_RETURN(pval, CDICT_ERR_PVAL_IS_NULL, NULL);
+    CDictItem *next_collision = NULL;
+    CDictItem **ppit = cdict_chain_begin(s, pkey);
+    CDICT_IF_NULL_RETURN(ppit, NULL);
+    while (*ppit) {
+        int exists = if_exists == CDICT_NO_CHECK ? 0 : !cdict_keycmp(pkey, &(*ppit)->key);
+        if (exists) {
+            if (if_exists == CDICT_LEAVE_EXIST) {
+                return *ppit;
+            } else if (if_exists == CDICT_REPLACE_EXIST) {
+                next_collision = (*ppit)->next_collision;
+                CDICT_HASHTAB_ITEM_FREE_FN(s, *ppit);
+                break;
+            }
+        }
+        ppit = cdict_chain_next(ppit);
+    }
+    *ppit = CDICT_HASHTAB_ITEM_ALLOC_FN(s, sizeof(**ppit));
+    CDictItem *pit = *ppit;
+    pit->key = *pkey;
+    pit->val = *pval;
+    pit->next_collision = next_collision;
+    return pit;
+}
+
+CDictItem *cdict_add_vv(CDict *s, CDICT_KEY_T key, CDICT_VAL_T val, int if_exists) {
+    return cdict_add_pp(s, &key, &val, if_exists);
+}
+
+CDICT_VAL_T cdict_get_p(CDict *s, CDICT_KEY_T *pkey) {
+    CDICT_IF_NULL_RETURN(s, CDICT_VAL_DEFAULT);
+    CDICT_IF_NULL_SET_ERR_RETURN(pkey, CDICT_ERR_PKEY_IS_NULL, CDICT_VAL_DEFAULT);
+    CDictItem **ppit = cdict_chain_begin(s, pkey);
+    CDICT_IF_NULL_RETURN(ppit, CDICT_VAL_DEFAULT);
+    while (*ppit) {
+        if (!cdict_keycmp(pkey, &(*ppit)->key)) {
+            return (*ppit)->val;
+        }
+        ppit = cdict_chain_next(ppit);
+    }
+    return CDICT_VAL_DEFAULT;
+}
+
+CDICT_VAL_T cdict_get_v(CDict *s, CDICT_KEY_T key) {
+    return cdict_get_p(s, &key);
+}
+
+#endif
+
+#undef CDICT_CAT2_IMPL
+#undef CDICT_CAT2
+#undef CDICT_FUN
+
+#undef cdict_init
+#undef cdict_init_ud
+#undef cdict_init_pud
+#undef cdict_add_pp
+#undef cdict_add_vv
+#undef cdict_get_p
+#undef cdict_get_v
+
+#undef CDICT_KEY_T
+#undef CDICT_VAL_T
+#undef CDICT_USER_DATA_T
+
+#ifdef CDICT_INST
+#undef CDICT_INST
+#undef CDICT_HASH_FN
+#undef CDICT_HASHTAB_SZ
+#undef CDICT_HASHTAB_ALLOC_FN
+#undef CDICT_HASHTAB_ITEM_ALLOC_FN
+#undef CDICT_HASHTAB_ITEM_FREE_FN
+#undef CDICT_ASSERT_FN
+#undef CDICT_CMP_FN
+#undef CDICT_ASSERT
+#undef CDICT_IF_NULL_RETURN
+#undef CDICT_IF_NULL_SET_ERR_RETURN
+#undef CDICT_HASHTAB_ITEM_ALLOCATORS_OVERRIDDEN
+#undef CDICT_HASHTAB_ALLOCATORS_OVERRIDDEN
+#undef CDICT_HASH_FN_OVERRIDEN
+#undef CDICT_CMP_FN_OVERRIDDEN
+#endif

programs/develop/obj2def/cvec/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Magomed Kostoev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

programs/develop/obj2def/cvec/README.md

@@ -0,0 +1,88 @@
+# cvec - partial `std::vector` implementation in C.
+## Partial implementation of `std::vector`
+
+Member functions table:
+
+| Status | Name | Function or reason if not implemented |
+| :---: | --- | --- |
+| :heavy_check_mark: | `(constructor)` | `new` |
+| :heavy_check_mark: | `(destructor)` | `free` |
+| :heavy_check_mark: | `operator=` | `assign_other` |
+| :heavy_check_mark: | `assign` | `assign_fill`, `assign_range` |
+| :heavy_minus_sign: | `get_allocator` | No `allocator` objects in the language |
+| :heavy_check_mark: | `at` | `at` |
+| :heavy_check_mark: | `operator[]` | `[]` |
+| :heavy_check_mark: | `front` | `front`, `front_p` |
+| :heavy_check_mark: | `back` | `back`, `back_p` |
+| :heavy_check_mark: | `data` | `data` |
+| :heavy_check_mark: | `begin` | `begin` |
+| :heavy_check_mark: | `cbegin` | `cbegin` |
+| :heavy_check_mark: | `end` | `end` |
+| :heavy_check_mark: | `cend` | `cend` |
+| :heavy_minus_sign: | `rbegin` | No reverse iterators in the language |
+| :heavy_minus_sign: | `crbegin` | No reverse iterators in the language |
+| :heavy_minus_sign: | `rend` | No reverse iterators in the language |
+| :heavy_minus_sign: | `crend` | No reverse iterators in the language |
+| :heavy_check_mark: | `empty` | `empty` |
+| :heavy_check_mark: | `size` | `size` |
+| :heavy_check_mark: | `max_size` | `max_size` |
+| :heavy_check_mark: | `reserve` | `reserve` |
+| :heavy_check_mark: | `capacity` | `capacity` |
+| :heavy_check_mark: | `shrink_to_fit` | `shrink_to_fit` |
+| :heavy_check_mark: | `clear` | `clear` |
+| :heavy_check_mark: | `insert` | `insert`, `insert_it` |
+| :heavy_minus_sign: | `emplace` | I know no way to preserve the original signature |
+| :heavy_check_mark: | `erase` | `erase` |
+| :heavy_check_mark: | `push_back` | `push_back` |
+| :heavy_minus_sign: | `emplace_back` | I know no way to preserve the original signature |
+| :heavy_check_mark: | `pop_back` | `pop_back` |
+| :heavy_check_mark: | `resize` | `resize` |
+| :heavy_minus_sign: | `swap` | Would have n complexity in this implementation |
+
+## Easy to use
+
+To use the std::vector implementation for specified type they should be declared as follows:
+
+```C
+#define CVEC_TYPE TypeOfVectorElement
+#include "cvec.h"
+
+// ...
+
+    TypeOfVectorElement *vec = cvec_TypeOfVectorElement_new(128);
+    
+    cvec_TypeOfVectorElement_push_back(&vec, value);
+```
+
+Also somewhere in the project the functinos should be instantiated as follows:
+
+```C
+#define CVEC_TYPE TypeOfVectorElement
+#define CVEC_INST
+#include "cvec.h"
+```
+
+## Allows using of custom allocators.
+
+```C
+#define CVEC_TYPE pchar
+#define CVEC_INST
+#define CVEC_MALLOC custom_malloc
+#define CVEC_REALLOC custom_realloc
+#define CVEC_FREE custom_free
+#include "cvec.h"
+```
+
+## Allows handling of exceptional cases.
+
+```C
+#define CVEC_TYPE pchar
+#define CVEC_INST
+// Set Out Of Bounds handler
+#define CVEC_OOBH(funcname, vec, index) printf("Out of bounds in %s (vec = %p, i = %d)", funcname, vec, index); abort();
+#include "cvec.h"
+```
+
+## Has no fixed dependencies
+
+Every function it uses may be overridden. More information about dependencies in [cvec.h](cvec.h).

programs/develop/obj2def/cvec/cvec.h

@@ -0,0 +1,498 @@
+// Copyright (c) 2015 Evan Teran
+// Copyright (c) 2020 Magomed Kostoev
+//
+// You may use, distribute and modify this code under the terms of the MIT license.
+//
+// You should have received a copy of the MIT license with this file. If not, please visit
+// https://opensource.org/licenses/MIT for full license details.
+
+// cvec.h - std::vector (ish) implementation in C. Based on https://github.com/eteran/c-vector/.
+//
+// Unlike a real std::vector this one is implemented as a fat array, so metadata is placed inside
+// an allocated buffer itself.
+//
+// Configuration (definitions):
+// CVEC_TYPE:    Type of the vector's elements, after instantiation these functions will be visible
+//               as cvec_<CVEC_TYPE>_funcname, so no stars and subscripting marks allowed - named
+//               types only
+// CVEC_INST:    Instantiate the functions if defined
+// CVEC_LOGG:    Multiply capacity by CVEC_LOGG each expansion if defined (should be >= 1)
+// CVEC_ASSERT:  Replacement for assert from <assert.h>
+// CVEC_MALLOC:  Replacement for malloc from <stdlib.h>
+// CVEC_REALLOC: Replacement for realloc from <stdlib.h>
+// CVEC_FREE:    Replacement for free from <stdlib.h>
+// CVEC_OOBH:    Out-of-bounds handler (gets __func__, vector data address and index of overflow)
+// CVEC_OOBVAL:  Default value to return on out of bounds access
+//
+// Minimal definitions for declaration: CVEC_TYPE
+// Minimal definitions for instantiation: CVEC_TYPE, CVEC_INST, CVEC_OOBVAL if the type object
+// can't be represented by 0 value.
+//
+// WARNING: All used definitions will be undefined on header exit.
+//
+// Dependencies:
+// <stddef.h> or another source of size_t and ptrdiff_t
+// <stdint.h> or another source of SIZE_MAX
+// <stdlib.h> or another source of malloc, calloc and realloc
+// <assert.h> or another source of assert
+
+//
+// Input macros
+//
+
+#ifndef CVEC_LOGG
+#   define CVEC_LOGG 1.5
+#endif
+#ifndef CVEC_ASSERT
+#   define CVEC_ASSERT(x) assert(x)
+#endif
+#ifndef CVEC_MALLOC
+#   define CVEC_MALLOC(size) malloc(size)
+#endif
+#ifndef CVEC_REALLOC
+#   define CVEC_REALLOC(ptr, size) realloc(ptr, size)
+#endif
+#ifndef CVEC_FREE
+#   define CVEC_FREE(size) free(size)
+#endif
+#ifndef CVEC_OOBH
+#   define CVEC_OOBH(funcname, vec, index)
+#endif
+#ifndef CVEC_OOBVAL
+#   define CVEC_OOBVAL { 0 }
+#endif
+
+//
+// Internal macros
+//
+
+#define CVEC_CONCAT2_IMPL(x, y) cvec_ ## x ## _ ## y
+#define CVEC_CONCAT2(x, y) CVEC_CONCAT2_IMPL(x, y)
+
+/// Creates method name according to CVEC_TYPE
+#define CVEC_FUN(name) CVEC_CONCAT2(CVEC_TYPE, name)
+
+#define cvec_x_new CVEC_FUN(new)
+#define cvec_x_capacity CVEC_FUN(capacity)
+#define cvec_x_size CVEC_FUN(size)
+#define cvec_x_empty CVEC_FUN(empty)
+#define cvec_x_pop_back CVEC_FUN(pop_back)
+#define cvec_x_erase CVEC_FUN(erase)
+#define cvec_x_free CVEC_FUN(free)
+#define cvec_x_begin CVEC_FUN(begin)
+#define cvec_x_cbegin CVEC_FUN(cbegin)
+#define cvec_x_end CVEC_FUN(end)
+#define cvec_x_cend CVEC_FUN(cend)
+#define cvec_x_push_back CVEC_FUN(push_back)
+#define cvec_x_at CVEC_FUN(at)
+#define cvec_x_reserve CVEC_FUN(reserve)
+#define cvec_x_shrink_to_fit CVEC_FUN(shrink_to_fit)
+#define cvec_x_assign_fill CVEC_FUN(assign_fill)
+#define cvec_x_assign_range CVEC_FUN(assign_range)
+#define cvec_x_assign_other CVEC_FUN(assign_other)
+#define cvec_x_data CVEC_FUN(data)
+#define cvec_x_resize CVEC_FUN(resize)
+#define cvec_x_resize_v CVEC_FUN(resize_v)
+#define cvec_x_clear CVEC_FUN(clear)
+#define cvec_x_front CVEC_FUN(front)
+#define cvec_x_front_p CVEC_FUN(front_p)
+#define cvec_x_back CVEC_FUN(back)
+#define cvec_x_back_p CVEC_FUN(back_p)
+#define cvec_x_max_size CVEC_FUN(max_size)
+#define cvec_x_insert CVEC_FUN(insert)
+#define cvec_x_insert_it CVEC_FUN(insert_it)
+
+#define cvec_x_grow CVEC_FUN(grow)
+#define cvec_x_set_capacity CVEC_FUN(set_capacity)
+#define cvec_x_set_size CVEC_FUN(set_size)
+
+//
+// External declarations
+//
+
+/// Allocates new vector of specified capacity.
+CVEC_TYPE *cvec_x_new(size_t count);
+
+/// Gets the current capacity of the vector.
+size_t cvec_x_capacity(CVEC_TYPE **vec);
+
+/// Gets the current size of the vector.
+size_t cvec_x_size(CVEC_TYPE **vec);
+
+/// Returns non-zero if the vector is empty.
+int cvec_x_empty(CVEC_TYPE **vec);
+
+/// Removes the last element from the vector.
+void cvec_x_pop_back(CVEC_TYPE **vec);
+
+/// Removes the element at index i from the vector.
+void cvec_x_erase(CVEC_TYPE **vec, size_t i);
+
+/// Frees all memory associated with the vector.
+void cvec_x_free(CVEC_TYPE **vec);
+
+/// Returns an iterator to first element of the vector.
+CVEC_TYPE *cvec_x_begin(CVEC_TYPE **vec);
+
+/// Returns a const iterator to first element of the vector
+const CVEC_TYPE *cvec_x_cbegin(CVEC_TYPE **vec);
+
+/// Returns an iterator to one past the last element of the vector.
+CVEC_TYPE *cvec_x_end(CVEC_TYPE **vec);
+
+/// Returns a const iterator to one past the last element of the vector.
+const CVEC_TYPE *cvec_x_cend(CVEC_TYPE **vec);
+
+/// Adds an element to the end of the vector.
+void cvec_x_push_back(CVEC_TYPE **vec, CVEC_TYPE value);
+
+/// Gets element with bounds checking. On out of bounds calls CVEC_OOBH and returns CVEC_OOBVAL.
+CVEC_TYPE cvec_x_at(CVEC_TYPE **vec, size_t i);
+
+/// Increases the capacity of the vector to a value that's equal to new_cap.
+void cvec_x_reserve(CVEC_TYPE **vec, size_t new_cap);
+
+/// Requests the removal of unused capacity.
+void cvec_x_shrink_to_fit(CVEC_TYPE **vec);
+
+/// Replaces the contents with count copies of value value.
+void cvec_x_assign_fill(CVEC_TYPE **vec, size_t count, CVEC_TYPE value);
+
+/// Replaces the contents with data from range [first, last).
+void cvec_x_assign_range(CVEC_TYPE **vec, CVEC_TYPE *first, CVEC_TYPE *last);
+
+/// Replaces the contents with contetns of other.
+void cvec_x_assign_other(CVEC_TYPE **vec, CVEC_TYPE **other);
+
+/// Gives direct access to buffer.
+CVEC_TYPE *cvec_x_data(CVEC_TYPE **vec);
+
+/// Resizes the container to contain count elements.
+void cvec_x_resize(CVEC_TYPE **vec, size_t new_size);
+
+/// Resizes the container to contain count elements, initializes new elements by value.
+void cvec_x_resize_v(CVEC_TYPE **vec, size_t new_size, CVEC_TYPE value);
+
+/// Erases all elements from the container.
+void cvec_x_clear(CVEC_TYPE **vec);
+
+/// Returns the first element of the vector.
+CVEC_TYPE cvec_x_front(CVEC_TYPE **vec);
+
+/// Returns a pointer to the first element of the vector.
+CVEC_TYPE *cvec_x_front_p(CVEC_TYPE **vec);
+
+/// Returns the last element of the vector.
+CVEC_TYPE cvec_x_back(CVEC_TYPE **vec);
+
+/// Returns a pointer to the last element of the vector.
+CVEC_TYPE *cvec_x_back_p(CVEC_TYPE **vec);
+
+/// Returns maximal size of the vector.
+size_t cvec_x_max_size(CVEC_TYPE **vec);
+
+/// Inserts a value into vector by index.
+CVEC_TYPE *cvec_x_insert(CVEC_TYPE **vec, size_t index, CVEC_TYPE value);
+
+/// Inserts a value into vector by iterator (pointer in vector).
+CVEC_TYPE *cvec_x_insert_it(CVEC_TYPE **vec, CVEC_TYPE *it, CVEC_TYPE value);
+
+//
+// Function definitions
+//
+
+#ifdef CVEC_INST
+
+/// Ensures that the vector is at least <count> elements big.
+static void cvec_x_grow(CVEC_TYPE **vec, size_t count);
+
+/// Sets the capacity variable of the vector.
+static void cvec_x_set_capacity(CVEC_TYPE **vec, size_t size);
+
+/// Sets the size variable of the vector.
+static void cvec_x_set_size(CVEC_TYPE **vec, size_t size);
+
+//
+// Public functions
+//
+
+CVEC_TYPE *cvec_x_new(size_t count) {
+    const size_t cv_sz = count * sizeof(CVEC_TYPE) + sizeof(size_t) * 2;
+    size_t *cv_p = CVEC_MALLOC(cv_sz);
+    CVEC_ASSERT(cv_p);
+    CVEC_TYPE *vec = (void *)(&cv_p[2]);
+    cvec_x_set_capacity(&vec, count);
+    cvec_x_set_size(&vec, 0);
+    return vec;
+}
+
+size_t cvec_x_capacity(CVEC_TYPE **vec) {
+    CVEC_ASSERT(vec);
+    return *vec ? ((size_t *)*vec)[-1] : (size_t)0;
+}
+
+size_t cvec_x_size(CVEC_TYPE **vec) {
+    CVEC_ASSERT(vec);
+    return *vec ? ((size_t *)*vec)[-2] : (size_t)0;
+}
+
+int cvec_x_empty(CVEC_TYPE **vec) {
+    return cvec_x_size(vec) == 0;
+}
+
+void cvec_x_pop_back(CVEC_TYPE **vec) {
+    cvec_x_set_size(vec, cvec_x_size(vec) - 1);
+}
+
+void cvec_x_erase(CVEC_TYPE **vec, size_t i) {
+    CVEC_ASSERT(vec);
+    if (*vec) {
+        const size_t cv_sz = cvec_x_size(vec);
+        if (i < cv_sz) {
+            cvec_x_set_size(vec, cv_sz - 1);
+            for (size_t cv_x = i; cv_x < (cv_sz - 1); ++cv_x) {
+                (*vec)[cv_x] = (*vec)[cv_x + 1];
+            }
+        }
+    }
+}
+
+void cvec_x_free(CVEC_TYPE **vec) {
+    CVEC_ASSERT(vec);
+    if (*vec) {
+        size_t *p1 = &((size_t *)*vec)[-2];
+        CVEC_FREE(p1);
+    }
+}
+
+CVEC_TYPE *cvec_x_begin(CVEC_TYPE **vec) {
+    CVEC_ASSERT(vec);
+    return *vec;
+}
+
+const CVEC_TYPE *cvec_x_cbegin(CVEC_TYPE **vec) {
+    return cvec_x_begin(vec);
+}
+
+CVEC_TYPE *cvec_x_end(CVEC_TYPE **vec) {
+    CVEC_ASSERT(vec);
+    return *vec ? &((*vec)[cvec_x_size(vec)]) : NULL;
+}
+
+const CVEC_TYPE *cvec_x_cend(CVEC_TYPE **vec) {
+    return cvec_x_end(vec);
+}
+
+void cvec_x_push_back(CVEC_TYPE **vec, CVEC_TYPE value) {
+    CVEC_ASSERT(vec);
+    size_t cv_cap = cvec_x_capacity(vec);
+    if (cv_cap <= cvec_x_size(vec)) {
+        cvec_x_grow(vec, cv_cap * CVEC_LOGG + 1);
+    }
+    (*vec)[cvec_x_size(vec)] = value;
+    cvec_x_set_size(vec, cvec_x_size(vec) + 1);
+}
+
+CVEC_TYPE cvec_x_at(CVEC_TYPE **vec, size_t i) {
+    CVEC_ASSERT(vec);
+    if (i >= cvec_x_size(vec) || i < 0) {
+        CVEC_OOBH(__func__, vec, i);
+        CVEC_TYPE ret = CVEC_OOBVAL;
+        return ret;
+    }
+    return (*vec)[i];
+}
+
+void cvec_x_reserve(CVEC_TYPE **vec, size_t new_cap) {
+    if (new_cap <= cvec_x_capacity(vec)) {
+        return;
+    }
+    cvec_x_grow(vec, new_cap);
+}
+
+void cvec_x_shrink_to_fit(CVEC_TYPE **vec) {
+    if (cvec_x_capacity(vec) > cvec_x_size(vec)) {
+        cvec_x_grow(vec, cvec_x_size(vec));
+    }
+}
+
+void cvec_x_assign_fill(CVEC_TYPE **vec, size_t count, CVEC_TYPE value) {
+    CVEC_ASSERT(vec);
+    cvec_x_reserve(vec, count);
+    cvec_x_set_size(vec, count); // If the buffer was bigger than new_cap, set size ourselves
+    for (size_t i = 0; i < count; i++) {
+        (*vec)[i] = value;
+    }
+}
+
+void cvec_x_assign_range(CVEC_TYPE **vec, CVEC_TYPE *first, CVEC_TYPE *last) {
+    CVEC_ASSERT(vec);
+    size_t new_size = ((ptrdiff_t)(last - first)) / sizeof(*first);
+    cvec_x_reserve(vec, new_size);
+    cvec_x_set_size(vec, new_size);
+    size_t i = 0;
+    for (CVEC_TYPE *it = first; it < last; it++, i++) {
+        (*vec)[i] = *it;
+    }
+}
+
+void cvec_x_assign_other(CVEC_TYPE **vec, CVEC_TYPE **other) {
+    cvec_x_assign_range(vec, cvec_x_begin(other), cvec_x_end(other));
+}
+
+CVEC_TYPE *cvec_x_data(CVEC_TYPE **vec) {
+    CVEC_ASSERT(vec);
+    return (*vec);
+}
+
+void cvec_x_resize(CVEC_TYPE **vec, size_t count) {
+    CVEC_TYPE value = { 0 };
+    cvec_x_resize_v(vec, count, value);
+}
+
+void cvec_x_resize_v(CVEC_TYPE **vec, size_t count, CVEC_TYPE value) {
+    CVEC_ASSERT(vec);
+    size_t old_size = cvec_x_size(vec);
+    cvec_x_set_size(vec, count);
+    if (cvec_x_capacity(vec) < count) {
+        cvec_x_reserve(vec, count);
+        for (CVEC_TYPE *it = (*vec) + old_size; it < cvec_x_end(vec); it++) {
+            *it = value;
+        }
+    }
+}
+
+void cvec_x_clear(CVEC_TYPE **vec) {
+    cvec_x_set_size(vec, 0);
+}
+
+CVEC_TYPE cvec_x_front(CVEC_TYPE **vec) {
+    CVEC_ASSERT(vec);
+    return (*vec)[0];
+}
+
+CVEC_TYPE *cvec_x_front_p(CVEC_TYPE **vec) {
+    CVEC_ASSERT(vec);
+    return (*vec);
+}
+
+CVEC_TYPE cvec_x_back(CVEC_TYPE **vec) {
+    return cvec_x_end(vec)[-1];
+}
+
+CVEC_TYPE *cvec_x_back_p(CVEC_TYPE **vec) {
+    return cvec_x_end(vec) - 1;
+}
+
+size_t cvec_x_max_size(CVEC_TYPE **vec) {
+    return SIZE_MAX / sizeof(**vec);
+}
+
+CVEC_TYPE *cvec_x_insert(CVEC_TYPE **vec, size_t index, CVEC_TYPE value) {
+    CVEC_ASSERT(vec);
+    if (index > cvec_x_size(vec) || index < 0) {
+        return NULL; // TODO: What?
+    }
+    size_t new_size = cvec_x_size(vec) + 1;
+    cvec_x_reserve(vec, new_size);
+    cvec_x_set_size(vec, new_size);
+    CVEC_TYPE *ret = *vec + index;
+    for (CVEC_TYPE *it = cvec_x_back_p(vec); it > ret; it--) {
+        *it = it[-1];
+    }
+    *ret = value;
+    return ret;
+}
+
+CVEC_TYPE *cvec_x_insert_it(CVEC_TYPE **vec, CVEC_TYPE *it, CVEC_TYPE value) {
+    CVEC_ASSERT(vec);
+    size_t index = (it - *vec) / sizeof(**vec);
+    return cvec_x_insert(vec, index, value);
+}
+
+//
+// Private functions
+//
+
+static void cvec_x_set_capacity(CVEC_TYPE **vec, size_t size) {
+    CVEC_ASSERT(vec);
+    if (*vec) {
+        ((size_t *)*vec)[-1] = size;
+    }
+}
+
+static void cvec_x_set_size(CVEC_TYPE **vec, size_t size) {
+    CVEC_ASSERT(vec);
+    if (*vec) {
+        ((size_t *)*vec)[-2] = size;
+    }
+}
+
+static void cvec_x_grow(CVEC_TYPE **vec, size_t count) {
+    CVEC_ASSERT(vec);
+    const size_t cv_sz = count * sizeof(**vec) + sizeof(size_t) * 2;
+    size_t *cv_p1 = &((size_t *)*vec)[-2];
+    size_t *cv_p2 = CVEC_REALLOC(cv_p1, (cv_sz));
+    CVEC_ASSERT(cv_p2);
+    *vec = (void *)(&cv_p2[2]);
+    cvec_x_set_capacity(vec, count);
+}
+
+#endif
+
+#undef CVEC_TYPE
+
+#ifdef CVEC_INST
+#   undef CVEC_INST
+#   ifdef CVEC_LOGG
+#       undef CVEC_LOGG
+#   endif
+#   ifdef CVEC_OOBH
+#       undef CVEC_OOBH
+#   endif
+#   ifdef CVEC_OOBVAL
+#       undef CVEC_OOBVAL
+#   endif
+#   undef CVEC_ASSERT
+#   undef CVEC_MALLOC
+#   undef CVEC_REALLOC
+#   undef CVEC_FREE
+#endif
+
+#undef CVEC_CONCAT2_IMPL
+#undef CVEC_CONCAT2
+
+#undef CVEC_FUN
+
+#undef cvec_x_new
+#undef cvec_x_capacity
+#undef cvec_x_size
+#undef cvec_x_empty
+#undef cvec_x_pop_back
+#undef cvec_x_erase
+#undef cvec_x_free
+#undef cvec_x_begin
+#undef cvec_x_cbegin
+#undef cvec_x_end
+#undef cvec_x_cend
+#undef cvec_x_push_back
+#undef cvec_x_at
+#undef cvec_x_reserve
+#undef cvec_x_shrink_to_fit
+#undef cvec_x_assign_fill
+#undef cvec_x_assign_range
+#undef cvec_x_assign_other
+#undef cvec_x_data
+#undef cvec_x_resize
+#undef cvec_x_resize_v
+#undef cvec_x_clear
+#undef cvec_x_front
+#undef cvec_x_front_p
+#undef cvec_x_back
+#undef cvec_x_back_p
+#undef cvec_x_max_size
+#undef cvec_x_insert
+#undef cvec_x_insert_it
+#undef cvec_x_grow
+#undef cvec_x_set_capacity
+#undef cvec_x_set_size

programs/develop/obj2def/epep/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Magomed Kostoev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

programs/develop/obj2def/epep/README.md

@@ -0,0 +1,26 @@
+# epep - Embeddable PE Parser
+## Features
+
+- PE header (including Data Directories as a part Optional Header)
+- Section Headers
+- COFF Symbols
+- COFF Relocations
+- COFF Linenumbers
+- Imports
+- Exports
+- Base relocations (DLL)
+
+## How to use
+
+To declare functions from the library include it:
+
+```C
+#include "epep.h"
+```
+
+The functions they shoud be instantiated somewhere in the project like so:
+
+```C
+#define EPEP_INST
+#include "epep.h"
+```

programs/develop/obj2def/main.c

@@ -0,0 +1,265 @@
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <assert.h>
+#include <string.h>
+
+#define EPEP_INST
+#include "epep/epep.h"
+
+const char *epep_errors[] = {
+	"EPEP_ERR_SUCCESS",
+	"EPEP_ERR_DATA_DIRECTORY_INDEX_IS_INVALID",
+	"EPEP_ERR_SECTION_HEADER_INDEX_IS_INVALID",
+	"EPEP_ERR_SYMBOL_INDEX_IS_INVALID",
+	"EPEP_ERR_NOT_AN_OBJECT",
+	"EPEP_ERR_ADDRESS_IS_OUT_OF_SECTION_RAW_DATA",
+	"EPEP_ERR_OUTPUT_CAPACITY_IS_ZERO",
+	"EPEP_ERR_OUTPUT_IS_NULL",
+	"EPEP_ERR_ADDRESS_IS_OUT_OF_ANY_SECTION",
+	"EPEP_ERR_EXPORT_ADDRESS_TABLE_ENTRY_NAME_NOT_FOUND",
+	"EPEP_ERR_NO_BASE_RELOCATION_TABLE",
+	"EPEP_ERR_BASE_RELOCATION_IS_ALREADY_END",
+	"EPEP_ERR_INVALID_DATA_DIRECTORY_OFFSET",
+	"EPEP_ERR_INVALID_SECTION_HEADER_OFFSET",
+	"EPEP_ERR_INVALID_SECTION_DATA_OFFSET",
+	"EPEP_ERR_INVALID_STRING_TABLE_SIZE_OFFSET",
+	"EPEP_ERR_INVALID_SYMBOL_OFFSET",
+	"EPEP_ERR_INVALID_IMPORT_DIRECTORY_OFFSET",
+	"EPEP_ERR_INVALID_IMPORT_DIRECTORY_NAME_OFFSET",
+	"EPEP_ERR_INVALID_LOOKUP_OFFSET",
+	"EPEP_ERR_INVALID_LOOKUP_NAME_OFFSET",
+	"EPEP_ERR_INVALID_EXPORT_TABLE_OFFSET",
+	"EPEP_ERR_INVALID_DLL_NAME_OFFSET",
+	"EPEP_ERR_INVALID_EXPORT_NAME_POINTER_OFFSET",
+	"EPEP_ERR_INVALID_ORDINAL_TABLE_OFFSET",
+	"EPEP_ERR_INVALID_EXPORT_NAME_OFFSET",
+	"EPEP_ERR_INVALID_EXPORT_ADDRESS_OFFSET",
+	"EPEP_ERR_INVALID_FORWARDER_OFFSET",
+	"EPEP_ERR_INVALID_BASE_RELOCATION_BLOCK_OFFSET",
+	"EPEP_ERR_INVALID_NEXT_BASE_RELOCATION_BLOCK_OFFSET",
+	"EPEP_ERR_INVALID_BASE_RELOCATION_BLOCK_BASE_RELOCATION_OFFSET",
+	"EPEP_ERR_INVALID_SECTION_RELOCATION_OFFSET",
+	"EPEP_ERR_INVALID_LINENUMBER_OFFSET",
+};
+
+#define ERROR_EPEP(epep) printf("Error: epep returned %u (%s) at "__FILE__":%u", \
+                                (epep)->error_code, epep_errors[(epep)->error_code], __LINE__); exit(-1)
+
+static int emit_logs;
+static void log_info(const char *fmt, ...) {
+	if (emit_logs) {
+		va_list ap;
+		va_start(ap, fmt);
+		vprintf(fmt, ap);
+		va_end(ap);
+	}
+}
+
+uint32_t get32(const char *buf, size_t offset) {
+	return ((uint32_t)(uint8_t)buf[offset + 0] << 0)
+		 | ((uint32_t)(uint8_t)buf[offset + 1] << 8)
+		 | ((uint32_t)(uint8_t)buf[offset + 2] << 16)
+		 | ((uint32_t)(uint8_t)buf[offset + 3] << 24);
+}
+
+EpepCoffRelocation get_relocation_for_section_and_offset(Epep *epep, EpepSectionHeader *sh, size_t offset) {
+	EpepCoffRelocation rel = { 0 };
+	for (size_t i = 0; i < sh->NumberOfRelocations; i++) {
+		if (!epep_get_section_relocation_by_index(epep, sh, &rel, i)) {
+			ERROR_EPEP(epep);
+		}
+		if (rel.VirtualAddress == offset) {
+			return rel;
+		}
+	}
+	printf("Error: Can't find relocation of pointer to name of symbol");
+	exit(-1);
+	return rel;
+}
+
+char *read_string(Epep *epep, size_t section_index, size_t offset) {
+	EpepSectionHeader sh = { 0 };
+	if (!epep_get_section_header_by_index(epep, &sh, section_index)) {
+		ERROR_EPEP(epep);
+	}
+	char *section = calloc(1, sh.SizeOfRawData);
+	if (!epep_get_section_contents(epep, &sh, section)) {
+		ERROR_EPEP(epep);
+	}
+	char *result = strdup(&section[offset]);
+	free(section);
+	return result;
+}
+
+int gendef(const char *obj_path, const char *outname) {
+	FILE *out = fopen(outname, "wb");
+	Epep epep;
+	{
+		FILE *fp = fopen(obj_path, "rb");
+		if (!fp) {
+			printf("Error: Can't open \"%s\"", obj_path);
+			exit(-1);
+		}
+
+		if (!epep_init(&epep, fp)) {
+			ERROR_EPEP(&epep);
+		}
+	}
+
+	size_t strtab_size = 0;
+	if (!epep_get_string_table_size(&epep, &strtab_size)) {
+		ERROR_EPEP(&epep);
+	}
+
+	char *strtab = malloc(strtab_size);
+	if (!epep_get_string_table(&epep, strtab)) {
+		ERROR_EPEP(&epep);
+	}
+
+	for (size_t sym_i = 0; sym_i < epep.coffFileHeader.NumberOfSymbols; sym_i++) {
+		EpepCoffSymbol sym = { 0 };
+
+		if (!epep_get_symbol_by_index(&epep, &sym, sym_i)) {
+			ERROR_EPEP(&epep);
+		}
+
+		size_t name_max = 1024;
+		char name[name_max];
+
+		if (sym.symbol.Zeroes == 0) {
+			strcpy(name, &strtab[sym.symbol.Offset]);
+		} else {
+			memcpy(name, sym.symbol.ShortName, 8);
+			name[8] = '\0';
+		}
+
+		if (!strcmp(name, "_EXPORTS") || !strcmp(name, "EXPORTS")) {
+			fprintf(out, "LIBRARY %s\n\nEXPORTS\n", obj_path);
+
+			size_t export_table_offset_in_section = sym.symbol.Value;
+			size_t section_index = sym.symbol.SectionNumber - 1;
+			EpepSectionHeader sh = { 0 };
+			if (!epep_get_section_header_by_index(&epep, &sh, section_index)) {
+				ERROR_EPEP(&epep);
+			}
+			size_t section_offset = sh.PointerToRawData;
+			size_t export_table_offset = section_offset + export_table_offset_in_section;
+
+			char *section = calloc(1, sh.SizeOfRawData);
+			if (!epep_get_section_contents(&epep, &sh, section)) {
+				ERROR_EPEP(&epep);
+			}
+
+			for (size_t offset = export_table_offset_in_section;; offset += 8) {
+				size_t name_offset = get32(section, offset);
+				size_t data_offset = get32(section, offset + 4);
+
+				if (name_offset == 0 || data_offset == 0) {
+					break;
+				}
+
+				EpepCoffRelocation rel = get_relocation_for_section_and_offset(&epep, &sh, offset);
+				EpepCoffSymbol name_sym = { 0 };
+				if (!epep_get_symbol_by_index(&epep, &name_sym, rel.SymbolTableIndex)) {
+					ERROR_EPEP(&epep);
+				}
+				size_t name_offset_in_section = name_sym.symbol.Value + name_offset;
+				char *name = read_string(&epep, name_sym.symbol.SectionNumber - 1, name_offset_in_section);
+				fprintf(out, "%s\n", name);
+			}
+			break;
+		}
+		sym_i += sym.symbol.NumberOfAuxSymbols;
+	}
+}
+
+int arg_got_flag(int argc, char **argv, ...) {
+	char *arg_names[8];
+	int arg_name_c = 0;
+
+	va_list ap;
+	va_start(ap, argv);
+	for (char *arg_name = va_arg(ap, char *); arg_name; arg_name = va_arg(ap, char *)) {
+		if (arg_name_c >= 8) {
+			printf("Internal error: Too many parameter aliases passed to %s", __func__);
+			exit(-1);
+		}
+		arg_names[arg_name_c++] = arg_name;
+	}
+	va_end(ap);
+
+	for (int i = 1; i < argc; i++) {
+		// If an argumetns was handled already then it's NULL here
+		if (argv[i] == NULL) {
+			continue;
+		}
+		for (int arg_name_i = 0; arg_name_i < arg_name_c; arg_name_i++) {
+			char *arg_name = arg_names[arg_name_i];
+			if (!strcmp(argv[i], arg_name)) {
+				argv[i] = NULL; // Do not handle this argument as a input name
+				return i;
+			}
+		}
+	}
+	return 0;
+}
+
+char *arg_got_param(int argc, char **argv, char *arg) {
+	int i = arg_got_flag(argc, argv, arg, 0);
+	if (i == 0) {
+		return NULL;
+	}
+
+	if (i + 1 >= argc) {
+		printf("Warning: %s parameter expects a value (like %s <value>)", arg, arg);
+		return NULL;
+	}
+	char *result = argv[i + 1];
+	argv[i + 1] = NULL;
+	return result;
+}
+
+int usage(char *name, char *remark) {
+	if (remark) {
+		printf("Error: %s\n\n", remark);
+	}
+	printf("Usage: %s [option]... [object file name]...\n", name);
+	printf("  Generate DEF files from COFF objects\n");
+	printf("\n");
+	printf("Options:\n");
+	printf("  -v, --verbose Emit information logs\n");
+	printf("  -h, --help    Output this help and exit\n");
+	return 0;
+}
+
+int main(int argc, char **argv) {
+	if (arg_got_flag(argc, argv, "-h", "-help", "--help", 0)) {
+		return usage(argv[0], NULL);
+	}
+
+	emit_logs = arg_got_flag(argc, argv, "-v", "-verbose", "--verbose", 0);
+
+	// After handling arguments there only leaven unhandled ones
+	// They should be names if inputs. But if there's no input - exit
+	int input_file_count = 0;
+	for (int i = 1; i < argc; i++) {
+		if (argv[i] != NULL) {
+			input_file_count++;
+		}
+	}
+	if (input_file_count == 0) {
+		return usage(argv[0], "No input file names supplied");
+	}
+
+	for (size_t i = 1; i < argc; i++) {
+		char outname[256] = { 0 };
+		sprintf(outname, "%.*s.def", strlen(argv[i]) - strlen(".obj"), argv[i]);
+		if (argv[i] != NULL) {
+			gendef(argv[i], outname);
+		}
+	}
+	return 0;
+}