# use FetchContent to download
include(FetchContent)

# fetch library
FetchContent_Declare(json URL https://github.com/nlohmann/json/releases/download/v3.11.3/json.tar.xz)
FetchContent_MakeAvailable(json)
include_directories(${json_SOURCE_DIR}/include) # append to include header

# link
target_include_directories(hoge PUBLIC nlohmann_json::nlohmann_json)

#include <nlohmann/json.hpp>

include(FetchContent)
FetchContent_Populate(
  magic_enum
  URL https://github.com/Neargye/magic_enum/releases/download/v0.9.7/magic_enum-v0.9.7.tar.gz
)
include_directories(${magic_enum_SOURCE_DIR}/include)

typedef enum state{STATE_INIT,STATE_A,STATE_B,STATE_COMPLETE,STATE_ERROR}state_t;

state_t state_next(state_t s, char c){
  switch (c){
    case STATE_INIT:
      return c=='a'?STATE_A:STATE_ERROR;
    case STATE_A:
      return c=='b'?STATE_B:
             c=='d'?STATE_COMPLETE:STATE_ERROR;
    case STATE_B:
      return c=='c'?STATE_COMPLETE:STATE_ERROR;
    default:
      return STATE_ERROR:
  }
}

void demo(){
  const char *str="abc";
  state_t s=STATE_INIT;
  for (;*str;str++){
    s=state_next(*str);
    if (s==STATE_ERROR)break;
    if (s==STATE_COMPLETE){
      puts("complete!!");
      break;
    }
  }
}

struct state{
  const char *name;//デバック用に名前をつけておくことをおすすめする。
  void (*action)(void*context);//今回は使わない
  state_t* (*next)(void*context,char);//次のstateを返す(nullable)
  // NOTE: 今回は文字を受理するステートマシンとして書いているため
  // 第二引数をcharにしているがより汎用的に書くならばvoid*にするとよい。
  void (*enter)(void*context);//stateが開始するときに呼び出される(nullable)
  void (*exit)(void*context);//stateが終了するときに呼び出される(nullable)
  void *context;//これをいれることでstate machineの入れ子を実現できる(nullable)
}state_t;

#include <stddef.h>
typedef struct defer_item{
  void (*deleter)(void* context);
  void *context;
}defer_item_t;

typedef struct defer_impl{
  size_t len,cap;
  defer_item_t *items;
}defer_impl_t;

#include <stdlib.h>
#include <assert.h>

// コンパイルオプション(gccなら-DDEFER_DEFAULT_CAP=XX)で
// 変更できるようにマクロを定義する。
#ifndef DEFER_DEFAULT_CAP
#define DEFER_DEFAULT_CAP 16
#endif/*DEFER_DEFAULT_CAP*/

defer_handle defer_open(){
  defer_impl_t*const impl = malloc(sizeof(defer_impl_t));
  defer_item_t*const items = malloc(DEFER_DEFAULT_CAP*sizeof(defer_item_t));
  if (!impl||!items){
    //early returnですぐに制御を戻す
    free(impl);
    free(items);
    return NULL;
  }
  // implに設定を書き込みんでいく
  impl->cap=DEFER_DEFAULT_CAP;
  impl->len=0;
  impl->items=items;//move ownership into impl
  return impl;
}

void defer_close(defer_handle d){
  assert(d);//d==NULLは明らかなコーディングミスなので落とす
  defer_item_t *const rbegin=&d->items[d->len-1];
  defer_item_t *const rend=&d->items[-1];
  for (defer_item_t* iter=rbegin;iter!=rend;iter--){
    iter->deleter(iter->context);
  }
  free(d->items);
  free(d);
}

int hoge(){
  int lock1=lock();
  if (!lock1){
    return 1;
  }

  int lock2=lock();
  if (!lock2){
    unlock1(lock1);
    return 1;
  }

  int lock3=lock();
  if (!lock3){
    unlock2(lock2);
    unlock1(lock1);
    return 1;
  }

  do_something();

  unlock(lock3);
  unlock(lock2);
  unlock(lock1);
  return 0;
}