Add the sources

Author: Veenkar

main.c

@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <stdint.h>
+#include "stack.h"
+
+#define ELM_SIZE(arr)   ( sizeof(arr[0]) )
+#define N_ELEMS(arr)    ( sizeof(arr) / ELM_SIZE(arr) )
+
+int main()
+{
+    typedef uint32_t Element_T;
+
+    Element_T buf[64];
+    Stack_T stack = Stack(buf, ELM_SIZE(buf), N_ELEMS(buf));
+
+    uint32_t push_vals[] = {10, 15, 19};
+    for (size_t i =0; i < N_ELEMS(push_vals); ++i)
+    {
+        Stack_Push(&stack, &push_vals[i]);
+    }
+
+    uint32_t el;
+    while (Stack_Pop(&stack, &el))
+    {
+        printf("%u\n",el);
+    }
+
+    printf("Done!\n");
+    return 0;
+}

stack.c

@@ -0,0 +1,115 @@
+/*******************************************************************************
+ *                               Stack.c
+ *
+ *
+ *
+ *
+ ******************************************************************************/
+
+/*******************************************************************************
+ *                               Includes
+ ******************************************************************************/
+#include "stack.h"
+#include "string.h"
+#include "stdint.h"
+
+/*******************************************************************************
+ *                             Define Macros
+ ******************************************************************************/
+#define NULL_PTR    NULL
+
+/*******************************************************************************
+ *                          Function-Like Macros
+ ******************************************************************************/
+
+/*******************************************************************************
+ *                           Type Declarations
+ ******************************************************************************/
+
+/*******************************************************************************
+ *                          Object Declarations
+ ******************************************************************************/
+
+/*******************************************************************************
+ *                         Functions Declarations
+ ******************************************************************************/
+
+/*******************************************************************************
+ *                         Functions Definitions
+ ******************************************************************************/
+
+Stack_T Stack(void * elements, size_t size_element, size_t size_max)
+{
+    Stack_T stack;
+
+    if (elements == NULL_PTR)
+    {
+        size_max = 0;
+    }
+
+    stack.elements      = elements;
+    stack.size_element  = size_element;
+    stack.size_max      = size_max;
+    stack.len_stack     = 0;
+    return stack;
+}
+
+bool Stack_Push(Stack_T * stack, void *element)
+{
+    if (stack == NULL_PTR || element == NULL_PTR)
+    {
+        return false;
+    }
+    else if (stack->len_stack >= stack->size_max)
+    {
+        return false;
+    }
+    else
+    {
+        size_t dest_byte_offset = stack->len_stack *  stack->size_element;
+        uint8_t * target = (uint8_t *) stack->elements + dest_byte_offset;
+
+        memcpy(target, (uint8_t *) element, stack->size_element);
+        ++(stack->len_stack);
+
+        return true;
+    }
+}
+
+
+bool Stack_Pop(Stack_T * stack, void * element)
+{
+    if (stack == NULL_PTR || element == NULL_PTR)
+    {
+        return false;
+    }
+    else if (!stack->len_stack)
+    {
+        return false;
+    }
+    else
+    {
+        size_t source_byte_offset = (stack->len_stack - 1)* stack->size_element;
+        uint8_t * source = (uint8_t *) stack->elements + source_byte_offset;
+
+        memcpy(element, source, stack->size_element);
+        --(stack->len_stack);
+        return true;
+    }
+}
+
+
+size_t Stack_Len(Stack_T * stack)
+{
+    if (stack == NULL_PTR)
+    {
+        return 0;
+    }
+    return stack->len_stack;
+}
+
+/*******************************************************************************
+ *                             End Stack.c
+ ******************************************************************************/
+
+

stack.h

@@ -0,0 +1,82 @@
+/*******************************************************************************
+ *                               Stack.h
+ *
+ *
+ *
+ *
+ ******************************************************************************/
+#pragma once
+
+/*******************************************************************************
+ *                               Includes
+ ******************************************************************************/
+#include <stddef.h>
+#include <stdbool.h>
+
+/*******************************************************************************
+ *                             Define Macros
+ ******************************************************************************/
+
+/*******************************************************************************
+ *                          Function-Like Macros
+ ******************************************************************************/
+
+/*******************************************************************************
+ *                           Type Declarations
+ ******************************************************************************/
+typedef struct Stack_Tag
+{
+    void * elements;
+    size_t size_element;
+    size_t size_max;
+    size_t len_stack;
+
+} Stack_T;
+
+/*******************************************************************************
+ *                          Object Declarations
+ ******************************************************************************/
+
+/*******************************************************************************
+ *                         Functions Declarations
+ ******************************************************************************/
+/**
+ * @brief Stack create a new stack using memory passed as elements as a container
+ * @param elements:     pointer to the memory that will contain stack elements
+ * @param size_element: size of a single stack element
+ * @param size_max:     the maximum amount of elements that can fit into elements pointer
+ * @return stack instance
+ */
+Stack_T Stack(void * elements, size_t size_element, size_t size_max);
+
+/**
+ * @brief push push an element on the stack
+ * @param stack:    stack instance
+ * @param element:  element to push on the stack
+ * @return false on overflow
+ */
+bool Stack_Push(Stack_T * stack, void * element);
+
+/**
+ * @brief Stack_Pop pop an alement from a stack
+ * @param stack:    stack instance
+ * @param element:  if ok, a popped element will go here
+ * @return false on underflow
+ */
+bool Stack_Pop(Stack_T * stack, void * element);
+
+/**
+ * @brief Stack_Len return current stack length
+ * @param stack:    stack instance
+ * @return stack length
+ */
+size_t Stack_Len(Stack_T* stack);
+
+
+/*******************************************************************************
+ *                         Functions Definitions
+ ******************************************************************************/
+
+/*******************************************************************************
+ *                             End Stack.h
+ ******************************************************************************/

stack.pro

@@ -0,0 +1,11 @@
+TEMPLATE = app
+CONFIG += console
+CONFIG -= app_bundle
+CONFIG -= qt
+
+SOURCES += \
+        main.c \
+    stack.c
+
+HEADERS += \
+    stack.h