yatl.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>


#define YATL_LINE_SIZE 96

#define YATL_CURSOR_SIZE 96

#define YATL_SPAN_SIZE 160

#define YATL_DOC_SIZE 64

typedef struct YATL_Line {
  _Alignas(max_align_t) unsigned char _opaque[YATL_LINE_SIZE];
} YATL_Line_t;

typedef struct YATL_Cursor {
  _Alignas(max_align_t) unsigned char _opaque[YATL_CURSOR_SIZE];
} YATL_Cursor_t;

typedef struct YATL_Span {
  _Alignas(max_align_t) unsigned char _opaque[YATL_SPAN_SIZE];
} YATL_Span_t;

typedef struct YATL_Doc {
  _Alignas(max_align_t) unsigned char _opaque[YATL_DOC_SIZE];
} YATL_Doc_t;

typedef enum {
  YATL_LOG_DEBUG, 
  YATL_LOG_INFO,  
  YATL_LOG_WARN,  
  YATL_LOG_ERROR  
} YATL_log_level_t;

#define YATL_ENABLE_LOGGING
 
#ifdef YATL_ENABLE_LOGGING
#ifndef LOG_LEVEL
#define LOG_LEVEL YATL_LOG_DEBUG
#endif
#endif

static inline const char *log_level_str(YATL_log_level_t level) {
  switch (level) {
  case YATL_LOG_DEBUG:
    return "DEBUG";
  case YATL_LOG_INFO:
    return "INFO";
  case YATL_LOG_WARN:
    return "WARN";
  case YATL_LOG_ERROR:
    return "ERROR";
  default:
    return "UNKNOWN";
  }
}

#ifdef YATL_ENABLE_LOGGING
#define YATL_LOG(level, fmt, ...)                                              \
  do {                                                                         \
    if ((level) >= LOG_LEVEL) {                                                \
      fprintf(stderr, "[%s] %s:%d (%s): " fmt "\n", log_level_str(level),      \
              __FILE__, __LINE__, __func__, ##__VA_ARGS__);                    \
    }                                                                          \
  } while (0)
#else
#define YATL_LOG(level, fmt, ...)                                              \
  do {                                                                         \
  } while (0)
#endif

typedef enum {
  YATL_S_NONE,              
  YATL_S_NODE_TABLE,        
  YATL_S_NODE_ARRAY,        
  YATL_S_NODE_ARRAY_TABLE,  
  YATL_S_NODE_INLINE_TABLE, 
  YATL_S_LEAF_KEYVAL,       
  YATL_S_LEAF_COMMENT,      
  YATL_S_SLICE_KEY,         
  YATL_S_SLICE_VALUE, 
} YATL_SpanType_t;

typedef enum {
  YATL_TYPE_BAREVALUE,    
  YATL_TYPE_STRING,       
  YATL_TYPE_ARRAY,        
  YATL_TYPE_INLINE_TABLE, 
} YATL_ValueType_t;

typedef enum {
  YATL_DONE = 1,           
  YATL_OK = 0,             
  YATL_ERR_IO = -1,        
  YATL_ERR_SYNTAX = -2,    
  YATL_ERR_NOT_FOUND = -3, 
  YATL_ERR_TYPE = -4,      
  YATL_ERR_BUFFERi = -5,   
  YATL_ERR_NOMEM = -6,     
  YATL_ERR_INVALID_ARG =
      -7, 
} YATL_Result_t;

YATL_Cursor_t YATL_cursor_create(void);

YATL_Span_t YATL_span_create(void);

YATL_Doc_t YATL_doc_create(void);

YATL_Result_t YATL_doc_load(YATL_Doc_t *doc, const char *path);

YATL_Result_t YATL_doc_loads(YATL_Doc_t *doc, const char *str, size_t len);

YATL_Result_t YATL_doc_save(YATL_Doc_t *doc, const char *path);

void YATL_doc_free(YATL_Doc_t *doc);

YATL_Result_t YATL_doc_clear_boneyard(YATL_Doc_t *doc);

YATL_Result_t YATL_doc_span(const YATL_Doc_t *doc, YATL_Span_t *out_span);

YATL_Result_t YATL_span_find_next(const YATL_Span_t *in_span,
                                  YATL_Cursor_t *cursor, YATL_Span_t *out_span);

YATL_Result_t YATL_span_find_name(const YATL_Span_t *in_span, const char *name,
                                  YATL_Span_t *out_span);

YATL_Result_t YATL_span_find_next_by_name(const YATL_Span_t *in_span,
                                          const char *name,
                                          const YATL_Cursor_t *in_cursor,
                                          YATL_Cursor_t *out_cursor,
                                          YATL_Span_t *out_span);

YATL_Result_t YATL_span_iter_line(const YATL_Span_t *span,
                                  YATL_Cursor_t *cursor, const char **out_text,
                                  size_t *out_len);

YATL_Result_t YATL_cursor_move(YATL_Cursor_t *cursor, long npos);

const char *YATL_span_type_name(YATL_SpanType_t type);

YATL_Result_t YATL_span_keyval_slice(const YATL_Span_t *in_span,
                                     YATL_Span_t *key, YATL_Span_t *val);

YATL_SpanType_t YATL_span_type(const YATL_Span_t *span);

YATL_Result_t YATL_span_text(const YATL_Span_t *in_span, const char **out_text,
                             size_t *out_len);

YATL_Result_t YATL_span_get_string(const YATL_Span_t *in_span, const char *key,
                                   const char **out_text, size_t *out_len);

YATL_Result_t YATL_span_ml_set_value(YATL_Span_t *span, const char **lines,
                                     const size_t *lengths, size_t line_count);
 
YATL_Result_t YATL_span_set_value(YATL_Span_t *span, const char *value,
                                  size_t length);