CMake/Utilities/cmllpkgc/llpkgc.c

/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file LICENSE.rst or https://cmake.org/licensing for details.  */

#include <stdlib.h>
#include <string.h>

#include "llpkgc.h"

#define CALLBACK_MAYBE(PARSER, NAME)                                           \
  do {                                                                         \
    const llpkgc_settings_t* settings;                                         \
    settings = (const llpkgc_settings_t*) (PARSER)->settings;                  \
    if(settings == NULL || settings->NAME == NULL) {                           \
      err = 0;                                                                 \
      break;                                                                   \
    }                                                                          \
    err = settings->NAME((PARSER));                                            \
  } while(0)

#define SPAN_CALLBACK_MAYBE(PARSER, NAME, START, LEN)                          \
  do {                                                                         \
    const llpkgc_settings_t* settings;                                         \
    settings = (const llpkgc_settings_t*) (PARSER)->settings;                  \
    if(settings == NULL || settings->NAME == NULL) {                           \
      err = 0;                                                                 \
      break;                                                                   \
    }                                                                          \
    err = settings->NAME((PARSER), (START), (LEN));                            \
    if(err == -1) {                                                            \
      err = PCE_USER;                                                          \
      llpkgc_set_error_reason((PARSER), "Span callback error in " #NAME);      \
    }                                                                          \
  } while(0)

void llpkgc_init(llpkgc_t* parser, const llpkgc_settings_t* settings) {
  llpkgc__internal_init(parser);

  parser->settings = (void*) settings;
}

void llpkgc_reset(llpkgc_t* parser) {
  llpkgc_settings_t* settings = parser->settings;
  void* data = parser->data;

  llpkgc__internal_init(parser);

  parser->settings = settings;
  parser->data = data;
}

void llpkgc_settings_init(llpkgc_settings_t* settings) {
  memset(settings, 0, sizeof(*settings));
}

llpkgc_errno_t llpkgc_execute(llpkgc_t* parser, const char* data, size_t len) {
  return llpkgc__internal_execute(parser, data, data + len);
}

llpkgc_errno_t llpkgc_finish(llpkgc_t* parser) {
  if(parser->error != 0)
    return parser->error;

  int err;
  // ToDo: Better handling of user callback errors here
  if(parser->unfinished_ == 1) {
    parser->reason = "Invalid EOF state";
    parser->error = PCE_UNFINISHED;
    return PCE_UNFINISHED;
  } else if(parser->unfinished_ == 2) {
    CALLBACK_MAYBE(parser, on_value_literal_complete);
    if(err != PCE_OK) {
      parser->error = err;
      return err;
    }
    CALLBACK_MAYBE(parser, on_value_complete);
    if(err != PCE_OK) {
      parser->error = err;
      return err;
    }
  } else if(parser->unfinished_ == 3) {
    CALLBACK_MAYBE(parser, on_value_complete);
    if(err != PCE_OK) {
      parser->error = err;
      return err;
    }
  }

  CALLBACK_MAYBE(parser, on_pkgc_complete);
  return err;
}

void llpkgc_pause(llpkgc_t* parser) {
  if(parser->error != PCE_OK) {
    return;
  }

  parser->error = PCE_PAUSED;
  parser->reason = "Paused";
}

void llpkgc_resume(llpkgc_t* parser) {
  if(parser->error != PCE_PAUSED) {
    return;
  }

  parser->error = 0;
}

llpkgc_errno_t llpkgc_get_errno(const llpkgc_t* parser) {
  return parser->error;
}

const char* llpkgc_get_error_reason(const llpkgc_t* parser) {
  return parser->reason;
}

void llpkgc_set_error_reason(llpkgc_t* parser, const char* reason) {
  parser->reason = reason;
}

const char* llpkgc_get_error_pos(const llpkgc_t* parser) {
  return parser->error_pos;
}

const char* llpkgc_errno_name(llpkgc_errno_t err) {
  switch(err) {
    case PCE_OK:
      return "PCE_OK";
    case PCE_INTERNAL:
      return "PCE_INTERNAL";
    case PCE_PAUSED:
      return "PCE_PAUSED";
    case PCE_USER:
      return "PCE_USER";
    case PCE_UNFINISHED:
      return "PCE_UNFINISHED";
  }
  return "INVALID_ERRNO";
}

int llpkgc__line_begin(llpkgc_t* s, const char* p, const char* endp) {
  int err;
  s->unfinished_ = 1;
  CALLBACK_MAYBE(s, on_line_begin);
  return err;
}

int llpkgc__key_span(llpkgc_t* s, const char* p, const char* endp) {
  int err;
  SPAN_CALLBACK_MAYBE(s, on_key, p, endp - p);
  return err;
}

int llpkgc__keyword_complete(llpkgc_t* s, const char* p, const char* endp) {
  int err;
  s->unfinished_ = 3;
  CALLBACK_MAYBE(s, on_keyword_complete);
  return err;
}

int llpkgc__variable_complete(llpkgc_t* s, const char* p, const char* endp) {
  int err;
  s->unfinished_ = 3;
  CALLBACK_MAYBE(s, on_variable_complete);
  return err;
}

int llpkgc__vallit_span(llpkgc_t* s, const char* p, const char* endp) {
  int err;
  if(s->escaped_) {
    --endp;
    s->escaped_ = 0;
  }
  s->unfinished_ = 2;
  SPAN_CALLBACK_MAYBE(s, on_value_literal, p, endp - p);
  return err;
}

int llpkgc__vallit_complete(llpkgc_t* s, const char* p, const char* endp) {
  int err;
  s->unfinished_ = 3;
  CALLBACK_MAYBE(s, on_value_literal_complete);
  return err;
}

int llpkgc__valvar_span(llpkgc_t* s, const char* p, const char* endp) {
  int err;
  s->unfinished_ = 1;
  SPAN_CALLBACK_MAYBE(s, on_value_variable, p, endp - p);
  return err;
}

int llpkgc__valvar_complete(llpkgc_t* s, const char* p, const char* endp) {
  int err;
  s->unfinished_ = 3;
  CALLBACK_MAYBE(s, on_value_variable_complete);
  return err;
}

int llpkgc__value_complete(llpkgc_t* s, const char* p, const char* endp) {
  int err;
  s->unfinished_ = 0;
  CALLBACK_MAYBE(s, on_value_complete);
  return err;
}