Small fixes, and changed tag parameter name to X.

1 files changed, 61 insertions, 61 deletions

diff --git a/docs/cvec_api.md b/docs/cvec_api.md
index b9782341..1d521b55 100644
--- a/docs/cvec_api.md
+++ b/docs/cvec_api.md
@@ -9,15 +9,15 @@ This describes the API of vector type **cvec**.
 ```c
 #define using_cvec_str()
 
-#define using_cvec(T, Value, valueDestroy=c_default_del,
+#define using_cvec(X, Value, valueDestroy=c_default_del,
                              valueCompareRaw=c_default_compare,
                              RawValue=Value,
                              valueToRaw=c_default_to_raw,
                              valueFromRaw=c_default_from_raw)
 ```
 The macro `using_cvec()` can be instantiated with 2, 3, 4, or 7 arguments in the global scope.
-Defaults values are given above for args not specified. `T` is a type tag name and
-will affect the names of all cvec types and methods. E.g. declaring `using_cvec(my, int);`, `T` should
+Defaults values are given above for args not specified. `X` is a type tag name and
+will affect the names of all cvec types and methods. E.g. declaring `using_cvec(my, int);`, `X` should
 be replaced by `my` in all of the following documentation.
 
 `using_cvec_str()` is a predefined macro for `using_cvec(str, cstr_t, ...)`.
@@ -26,11 +26,11 @@ be replaced by `my` in all of the following documentation.
 
 | Type name            | Type definition                        | Used to represent...                |
 |:---------------------|:---------------------------------------|:------------------------------------|
-| `cvec_T`             | `struct { cvec_T_value_t* data; }`     | The cvec type                       |
-| `cvec_T_value_t`     | `Value`                                | The cvec element type               |
-| `cvec_T_input_t`     | `cvec_T_value_t`                       | cvec input type                     |
-| `cvec_T_rawvalue_t`  | `RawValue`                             | cvec raw value type                 |
-| `cvec_T_iter_t`      | `struct { cvec_T_value_t* val; }`      | cvec iterator                       |
+| `cvec_X`             | `struct { cvec_X_value_t* data; }`     | The cvec type                       |
+| `cvec_X_value_t`     | `Value`                                | The cvec element type               |
+| `cvec_X_input_t`     | `cvec_X_value_t`                       | cvec input type                     |
+| `cvec_X_rawvalue_t`  | `RawValue`                             | cvec raw value type                 |
+| `cvec_X_iter_t`      | `struct { cvec_X_value_t* val; }`      | cvec iterator                       |
 
 ## Constants and macros
 
@@ -55,57 +55,57 @@ All cvec definitions and prototypes may be included in your C source file by inc
 
 The interface for cvec:
 ```c
-cvec_T              cvec_T_init(void);
-cvec_T              cvec_T_with_size(size_t size, Value fill_val);
-cvec_T              cvec_T_with_capacity(size_t size);
-
-void                cvec_T_clear(cvec_T* self);
-void                cvec_T_reserve(cvec_T* self, size_t cap);
-void                cvec_T_resize(cvec_T* self, size_t size, Value fill_val);
-void                cvec_T_swap(cvec_T* a, cvec_T* b);
-
-void                cvec_T_del(cvec_T* self);
-
-bool                cvec_T_empty(cvec_T vec);
-size_t              cvec_T_size(cvec_T vec);
-size_t              cvec_T_capacity(cvec_T vec);
-Value               cvec_T_value_from_raw(RawValue val);
-
-cvec_T_value_t*     cvec_T_at(cvec_T* self, size_t i);
-cvec_T_value_t*     cvec_T_front(cvec_T* self);
-cvec_T_value_t*     cvec_T_back(cvec_T* self);
-
-void                cvec_T_push_n(cvec_T *self, const cvec_T_input_t in[], size_t size);
-void                cvec_T_push_back(cvec_T* self, Value value);
-void                cvec_T_emplace_back(cvec_T* self, RawValue val);
-void                cvec_T_pop_back(cvec_T* self);
-
-cvec_T_iter_t       cvec_T_insert_at(cvec_T* self, cvec_T_iter_t pos, Value value);
-cvec_T_iter_t       cvec_T_insert_at_idx(cvec_T* self, size_t idx, Value value);
-cvec_T_iter_t       cvec_T_emplace_at(cvec_T* self, cvec_T_iter_t pos, RawValue val);
-cvec_T_iter_t       cvec_T_emplace_at_idx(cvec_T* self, size_t idx, RawValue val);
-cvec_T_iter_t       cvec_T_insert_range(cvec_T* self, cvec_T_iter_t pos,
-                                        cvec_T_iter_t first, cvec_T_iter_t finish);
-cvec_T_iter_t       cvec_T_insert_range_p(cvec_T* self, cvec_T_value_t* pos,
-                                          const cvec_T_value_t* pfirst, const cvec_T_value_t* pfinish);
-
-cvec_T_iter_t       cvec_T_erase_at(cvec_T* self, cvec_T_iter_t pos);
-cvec_T_iter_t       cvec_T_erase_at_idx(cvec_T* self, size_t idx);
-cvec_T_iter_t       cvec_T_erase_range(cvec_T* self, cvec_T_iter_t first, cvec_T_iter_t finish);
-cvec_T_iter_t       cvec_T_erase_range_p(cvec_T* self, cvec_T_value_t* first, cvec_T_value_t* finish);
-cvec_T_iter_t       cvec_T_erase_range_idx(cvec_T* self, size_t ifirst, size_t ifinish);
-
-cvec_T_iter_t       cvec_T_find(const cvec_T* self, RawValue val);
-cvec_T_iter_t       cvec_T_find_in_range(const cvec_T* self,
-                                         cvec_T_iter_t first, cvec_T_iter_t finish, RawValue val);
-
-void                cvec_T_sort(cvec_T* self);
-void                cvec_T_sort_with(cvec_T* self, size_t ifirst, size_t ifinish,
-                                     int(*cmp)(const cvec_T_value_t*, const cvec_T_value_t*));
-
-cvec_T_iter_t       cvec_T_begin(const cvec_T* self);
-cvec_T_iter_t       cvec_T_last(const cvec_T* self);
-cvec_T_iter_t       cvec_T_end(const cvec_T* self);
-void                cvec_T_next(cvec_T_iter_t* it);
-cvec_T_value_t*     cvec_T_itval(cvec_T_iter_t it);
+cvec_X              cvec_X_init(void);
+cvec_X              cvec_X_with_size(size_t size, Value fill_val);
+cvec_X              cvec_X_with_capacity(size_t size);
+
+void                cvec_X_clear(cvec_X* self);
+void                cvec_X_reserve(cvec_X* self, size_t cap);
+void                cvec_X_resize(cvec_X* self, size_t size, Value fill_val);
+void                cvec_X_swap(cvec_X* a, cvec_X* b);
+
+void                cvec_X_del(cvec_X* self);
+
+bool                cvec_X_empty(cvec_X vec);
+size_t              cvec_X_size(cvec_X vec);
+size_t              cvec_X_capacity(cvec_X vec);
+Value               cvec_X_value_from_raw(RawValue val);
+
+cvec_X_value_t*     cvec_X_at(cvec_X* self, size_t i);
+cvec_X_value_t*     cvec_X_front(cvec_X* self);
+cvec_X_value_t*     cvec_X_back(cvec_X* self);
+
+void                cvec_X_push_n(cvec_X *self, const cvec_X_input_t in[], size_t size);
+void                cvec_X_push_back(cvec_X* self, Value value);
+void                cvec_X_emplace_back(cvec_X* self, RawValue val);
+void                cvec_X_pop_back(cvec_X* self);
+
+cvec_X_iter_t       cvec_X_insert_at(cvec_X* self, cvec_X_iter_t pos, Value value);
+cvec_X_iter_t       cvec_X_insert_at_idx(cvec_X* self, size_t idx, Value value);
+cvec_X_iter_t       cvec_X_emplace_at(cvec_X* self, cvec_X_iter_t pos, RawValue val);
+cvec_X_iter_t       cvec_X_emplace_at_idx(cvec_X* self, size_t idx, RawValue val);
+cvec_X_iter_t       cvec_X_insert_range(cvec_X* self, cvec_X_iter_t pos,
+                                        cvec_X_iter_t first, cvec_X_iter_t finish);
+cvec_X_iter_t       cvec_X_insert_range_p(cvec_X* self, cvec_X_value_t* pos,
+                                          const cvec_X_value_t* pfirst, const cvec_X_value_t* pfinish);
+
+cvec_X_iter_t       cvec_X_erase_at(cvec_X* self, cvec_X_iter_t pos);
+cvec_X_iter_t       cvec_X_erase_at_idx(cvec_X* self, size_t idx);
+cvec_X_iter_t       cvec_X_erase_range(cvec_X* self, cvec_X_iter_t first, cvec_X_iter_t finish);
+cvec_X_iter_t       cvec_X_erase_range_p(cvec_X* self, cvec_X_value_t* first, cvec_X_value_t* finish);
+cvec_X_iter_t       cvec_X_erase_range_idx(cvec_X* self, size_t ifirst, size_t ifinish);
+
+cvec_X_iter_t       cvec_X_find(const cvec_X* self, RawValue val);
+cvec_X_iter_t       cvec_X_find_in_range(const cvec_X* self,
+                                         cvec_X_iter_t first, cvec_X_iter_t finish, RawValue val);
+
+void                cvec_X_sort(cvec_X* self);
+void                cvec_X_sort_with(cvec_X* self, size_t ifirst, size_t ifinish,
+                                     int(*cmp)(const cvec_X_value_t*, const cvec_X_value_t*));
+
+cvec_X_iter_t       cvec_X_begin(const cvec_X* self);
+cvec_X_iter_t       cvec_X_last(const cvec_X* self);
+cvec_X_iter_t       cvec_X_end(const cvec_X* self);
+void                cvec_X_next(cvec_X_iter_t* it);
+cvec_X_value_t*     cvec_X_itval(cvec_X_iter_t it);
 ```