what's wrong with this?

gistfile1.txt

#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>

#define ERROR_VAL -1
#define SUCCESS_VAL 0
#define ERROR (err) { errno = (err); }

struct class_s {
  size_t size;

  void* (*ctor)(void*, va_list *);
  void* (*dtor)(void*);
};
typedef struct class_s class_t;

void* new(const void* _class, ...) {
  va_list ap;
  void* object;
  const class_t* class = _class;

  if (!class->ctor || class->size == 0) {
    return NULL;
  }

  object = malloc(class->size);

  if (object == NULL) {
    return NULL;
  }

  * (const class_t**) object = class;

  if (class->ctor != NULL) {
    va_start(ap, _class);
    object = class->ctor(object, &ap);
    va_end(ap);
  }

  return object;
}

int delete(void* object) {
  const class_t** class_ptr = object;

  if (class_ptr == NULL || (*class_ptr) == NULL || (*class_ptr)->dtor == NULL ) {
    return ERROR_VAL;
  }

  object = (*class_ptr)->dtor(object);

  if (object == NULL) {
    return ERROR_VAL;
  }

  free(object);

  return SUCCESS_VAL;
}

struct dog_s {
  const void* class;
  char* furColor;
  char* size;
};
typedef struct dog_s dog_t;

void* dogConstructor (void* _self, va_list * ap) {
  dog_t* self = _self;
  const char* furColor;
  const char* size;

  furColor = va_arg(*ap, const char*);
  size = va_arg(*ap, const char*);

  if (furColor == NULL || size == NULL) {
    delete(self);
    return NULL;
  }

  self->furColor = malloc(strlen(furColor) + 1);
  strcpy(self->furColor, furColor);

  self->size = malloc(strlen(size) + 1);
  strcpy(self->size, size);

  return self;
}

void* dogDestructor (void* _self) {
  dog_t* self = _self;
  if (self->furColor != NULL) {
    free(self->furColor);
    self->furColor = NULL;
  }
  if (self->size != NULL) {
    free(self->size);
    self->size = NULL;
  }
  return self;
}

const char* dogFurColor (void* _self) {
  dog_t* self = _self;
  return self->furColor;
}

const char* dogSize (void* _self) {
  dog_t* self = _self;
  return self->size;
}

static const class_t _Dog = {
  .size = sizeof(dog_t),
  .ctor = dogConstructor,
  .dtor = dogDestructor
};

static const void* Dog = &_Dog;

void* obj = new(Dog, "brown", "large");

printf("The dog has %s fur and is %s!", dogFurColor(obj), dogSize(obj));

delete(obj);

Errors:

$ gcc main.c -Wall
main.c:123:1: error: initializer element is not constant
main.c:125:8: error: expected declaration specifiers or ‘...’ before string constant
main.c:125:41: error: expected declaration specifiers or ‘...’ before ‘dogFurColor’
main.c:125:59: error: expected declaration specifiers or ‘...’ before ‘dogSize’
main.c:127:1: warning: data definition has no type or storage class [enabled by default]
main.c:127:1: warning: type defaults to ‘int’ in declaration of ‘delete’ [-Wimplicit-int]
main.c:127:1: warning: parameter names (without types) in function declaration [enabled by default]

epic lol.