//StackArray.h

  #ifndef STACKARRAY_H
  #define STACKARRAY_H

  #define MAX 10

  typedef struct _stackarray{
	int array[MAX];
	int size;
  } StackArray;

  StackArray * newStackArray();
  int pushStackArray(StackArray *, int );
  int popStackArray(StackArray *);
  int fullStackArray(StackArray *);
  int emptyStackArray(StackArray *);
  void displayStackArray(StackArray *);
  void delete(StackArray *);
 
 #endif

  //StackArray.c

  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  #include "StackArray.h"

  StackArray * newStackArray(){
	StackArray * stack = malloc(sizeof(StackArray));
	int i;
	for(i = 0; i < MAX; i++){
		stack->array[i] = 0;
	}
	stack->size = 0;
	return stack;
  }

  int pushStackArray(StackArray * stack, int item){
	if(stack->size < MAX){
		stack->array[stack->size] =  item;
		stack->size++;
		return item;
	} else {
		printf("The stack is full\n");
		return 0;
	}
  }

  int popStackArray(StackArray * stack){
	if(stack->size > 0){
		int top = stack->array[stack->size-1];
		stack->size--;
		return top;
	} else {
		return 0;
	}
  }

  int fullStackArray(StackArray * stack){
	return stack->size == MAX ? 1 : 0;
 }
  int emptyStackArray(StackArray * stack){
	return stack->size == 0 ? 1 : 0;
  }

  void displayStackArray(StackArray * stack){
	if(stack->size > 0){
		int i;
		for(i = 0; i < stack->size; i++){
			printf("%d ", stack->array[i]);
		}
		printf("\n");
	} else if (stack->size == 0) {
		printf("The stack is empty\n");
	}
  }

  void delete(StackArray * stack){
	free(stack);
  }

  Compile and create the Shared Library (Linux):
  gcc -c -fPIC StackArray.c
  gcc -g -Wall -shared -o libStackArray.so StackArray.o

  In Anarki type in:
  
  ($:require ffi/unsafe
    ffi/unsafe/define
    ffi/unsafe/alloc)

  ;Define the library
  ($:define-ffi-definer define-StackArray (ffi-lib "/home/conan/Documents/Arcprojects/ffi/stack/libStackArray"))

  ;Define the functions input and ouput

  ($:define-StackArray newStackArray (_fun -> _pointer ))
  ($:define-StackArray delete (_fun _pointer -> _void ))
  ($:define-StackArray pushStackArray (_fun _pointer _int -> _void))
  ($:define-StackArray popStackArray  (_fun _pointer  -> _int))
  ($:define-StackArray fullStackArray  (_fun _pointer -> _int))
  ($:define-StackArray emptyStackArray  (_fun _pointer  -> _int))
  ($:define-StackArray displayStackArray  (_fun _pointer -> _void))

  ;assign the functions a symbol to use in Anarki
  (= newSA $.newStackArray)
  (= deleteSA $.delete)
  (= pushSA $.pushStackArray)
  (= popSA $.popStackArray)
  (= fullSA? $.fullStackArray)
  (= emptySA? $.emptyStackArray)
  (= displaySA $.displayStackArray)
  
  ;To use the functions
  (= stack (newSA))
  (emptySA? stack) 
  (pushSA stack 1)
  (displaySA stack)
  (fullSA? stack)
  (emptySA? stack)
  (popSA stack)
  (deleteSA stack)

 ;A lispy solution using closures with very little effort... a macro can be used to clean up the middle.
  (def Stack ()
    (with (items nil acc 0)
      (fn msg
        (let it (car (cdr msg))	
          (case (car msg)
             set
              (=  acc (len it) items it )
            empty?
              (is items nil)
            push 
              (do (= acc (inc acc)) (= items (join items (list it))) )
            pop 
              (if (> acc 0) (do (= acc (inc acc -1)) (= items (butlast items))))
            peek
              items
            size	
               acc)))))
 
  (= stack (Stack))
  (stack 'empty?)
  (stack 'push 1)
  (stack 'peek)
  (stack 'pop)
  (stack 'set '(1 2 3 4 5 6 7 8 9 10))

  (= stack (newSA))
  #<cpointer>

   (pushSA stack 1)
  stack: undefined;
   cannot reference undefined identifier
    context...:
     /home/conan/Documents/anarki-master/ac.scm:1225:4

  (fullSA? stack)
    stack: undefined;
   cannot reference undefined identifier
    context...:
   /home/conan/Documents/anarki-master/ac.scm:1225:4

  (empytSA? stack)
  _empytSA?: undefined;
   cannot reference undefined identifier
    context...:
   /home/conan/Documents/anarki-master/ac.scm:1225:4

  (displaySA stack)
  stack: undefined;
   cannot reference undefined identifier
    context...:
   /home/conan/Documents/anarki-master/ac.scm:1225:4

  stack
  #<cpointer>

  Here is the C code:

  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  #include "StackArray.h"

  void pushStackArray(StackArray * stack, int item){
	if(stack->size < MAX){
		stack->array[stack->size] =  item;
		stack->size++;
	} else {
		printf("The stack is full\n");
	}
  }

  int popStackArray(StackArray * stack){
	if(stack->size > 0){
		stack->size--;
	} else if(stack->size == 0){
		printf("Stack array is empty\n");
	}
	return stack->array[stack->size + 1];
  }

  int fullStackArray(StackArray * stack){
	return stack->size == MAX ? 1 : 0;
  }
  int emptyStackArray(StackArray * stack){
	return stack->size == 0 ? 1 : 0;
  }

  StackArray * newStackArray(){
	StackArray * stack = malloc(sizeof(StackArray));
	int i;
	for(i = 0; i < MAX; i++){
		stack->array[i] = 0;
	}
	stack->size = 0;
	return stack;
  }

  void displayStackArray(StackArray * stack){
	int i;
	for(i = 0; i < stack->size; i++){
		printf("%d ", stack->array[i]);
	}
	printf("\n");
  }

  void delete(StackArray * stack){
	free(stack); 
  }

  (= newSA $.newStackArray)
  (= deleteSA $.delete)
  (= pushSA $.pushStackArray)
  (= popSA $.popStackArray)
  (= fullSA? $.fullStackArray)
  (= emptySA? $.emptyStackArray)
  (= displaySA $.displayStackArray)

  (mac pushSA (stack x)
    `( ($:lambda (stack x)
         (pushStackArray stack x))
       ,stack ,x))
  ; or...
  (mac pushSA (stack x)
    `($.pushStackArray ,stack ,x))

Finally, I think this line just has a simple typo:

  typo:  (emptytSA? stack)
  fix:   (emptySA? stack)

Hold on, let me throw up this arc project of mine from many years ago. The FFI isn't on head, but here's how I imported a Porter stemming (https://en.wikipedia.org/wiki/Stemming) implementation and a keyword-guessing algorithm in C: https://github.com/akkartik/readwarp/blob/e281ecfefd/keyword.... C functions that that invokes: https://github.com/akkartik/readwarp/blob/e281ecfefd/keyword...

  ./mu repl.mu
  ready! type in an instruction, then hit enter. ctrl-d exits.
  (+ 1 1)
  missing type in {name: "1", properties: ["1": ]}
  mu: 041name.cc:82 bool disqualified(reagent&): Assertion `!x.types.empty()' failed.
  Aborted (Core dumped)

  ;is the element a var symbol? i.e ?x ?y.. etc.
  (mac varsym? (x)
    `(and (is (type ,x) 'sym) (is ((string ,x) 0) #\?)))

  ;Are both elements varsyms? i.e ?x = ?y (?x . ?y)
  (mac tvs? (x y)
    `(and (varsym? (car ,x))(varsym? (car ,y))))

  ;is element x a varsym that hasn't been added to binds?
  (mac xvs? (x y binds)
    `(and (varsym? (car ,x))(~varsym? (car ,y))(no (assoc (car ,x) ,binds))))

  ;is element y a varsym that hasn't been added to binds?
  (mac yvs? (x y binds)
    `(and (varsym? (car ,y)) (~varsym? (car ,x))(no (assoc (car ,y) ,binds))))

  ;make bind i. e  ((?x . a)(?y . b))
  (mac mb (a b binds)
    `(push (cons (car ,a) (car ,b)) ,binds))

  (def match (x y)
    (let binds nil
      ((afn (x y)
        (if (or (no x) (no y)) binds ;lists are missing
          (if (iso x y) binds        ;list are the same
            (do
              (if (tvs? x y) (mb x y binds))
              (if (xvs? x y binds) (mb x y binds))
              (if (yvs? x y binds) (mb y x binds))	
            (self cdr.x cdr.y)))))
      x y)))

  (match '(p ?x b ?y a) '(p ?y b c a))
    ((?y . c) (?x . ?y))

  (match '(p ?x b ?y ?z) '(p ?y b c a))
    ((?z . a) (?y . c) (?x . ?y))

  (match '(a b c) '(a a a))
    nil     ... i.e nil bindings since there are no vars

  (match '(a b c) '(a b c)) 
    nil

  ;tree-leaves function for modifying leaves with plug-in test
  (def t-l%% (tree test result)
    (if tree
      (if (alist tree)
        (cons
          (t-l%% (car tree) test result)
          (t-l%% (cdr tree) test result))
        (if (test tree)
          (result tree)
        tree))))

  ;Modified akkartik's solution
  (mac t-l (tree test result)
    `(t-l%% ,tree 
      (fn (x) ,test) 
      (fn (x) ,result)))

  ;Using the following input
  (t-l `(1 2 (3 4 (5 6))) (and (number x) (even x)) 'even-number)

  ;Results
  (1 even-number (3 even-number (5 even-number)))

line1 line2

  line1
  line2