C언어에서 YAML 라이브러리를 활용한 설정 파일 관리

# Ubuntu / Debian
sudo apt-get install libyaml-dev

# Fedora
sudo dnf install libyaml-devel

# macOS (Homebrew)
brew install libyaml

git clone https://github.com/yaml/libyaml.git
cd libyaml
./configure
make
sudo make install

server:
  host: "127.0.0.1"
  port: 8080
database:
  user: "admin"
  password: "secret"
  name: "mydb"

#include <stdio.h>
#include <yaml.h>

void parse_yaml_file(const char *filename) {
    FILE *file = fopen(filename, "r");
    if (!file) {
        perror("파일을 열 수 없습니다");
        return;
    }

    yaml_parser_t parser;
    yaml_token_t token;

    yaml_parser_initialize(&parser);
    yaml_parser_set_input_file(&parser, file);

    while (1) {
        yaml_parser_scan(&parser, &token);

        switch (token.type) {
            case YAML_STREAM_END_TOKEN:
                goto cleanup;
            case YAML_KEY_TOKEN:
                printf("키: ");
                break;
            case YAML_VALUE_TOKEN:
                printf("값: ");
                break;
            case YAML_SCALAR_TOKEN:
                printf("%s\n", token.data.scalar.value);
                break;
            default:
                break;
        }

        yaml_token_delete(&token);
    }

cleanup:
    yaml_token_delete(&token);
    yaml_parser_delete(&parser);
    fclose(file);
}

int main() {
    parse_yaml_file("config.yaml");
    return 0;
}

키: server
키: host
값: 127.0.0.1
키: port
값: 8080
키: database
키: user
값: admin
키: password
값: secret
키: name
값: mydb

server:
  host: "127.0.0.1"
  port: 8080
database:
  user: "admin"
  password: "secret"
  name: "mydb"

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

typedef struct {
    char host[32];
    int port;
} ServerConfig;

typedef struct {
    char user[32];
    char password[32];
    char name[32];
} DatabaseConfig;

typedef struct {
    ServerConfig server;
    DatabaseConfig database;
} AppConfig;

void parse_yaml_to_struct(const char *filename, AppConfig *config) {
    FILE *file = fopen(filename, "r");
    if (!file) {
        perror("파일을 열 수 없습니다");
        return;
    }

    yaml_parser_t parser;
    yaml_event_t event;
    char key[32] = {0};
    int is_key = 0;

    yaml_parser_initialize(&parser);
    yaml_parser_set_input_file(&parser, file);

    while (1) {
        yaml_parser_parse(&parser, &event);
        if (event.type == YAML_STREAM_END_EVENT)
            break;

        if (event.type == YAML_SCALAR_EVENT) {
            if (!is_key) {
                strncpy(key, (char *)event.data.scalar.value, sizeof(key) - 1);
                is_key = 1;
            } else {
                if (strcmp(key, "host") == 0)
                    strncpy(config->server.host, (char *)event.data.scalar.value, sizeof(config->server.host) - 1);
                else if (strcmp(key, "port") == 0)
                    config->server.port = atoi((char *)event.data.scalar.value);
                else if (strcmp(key, "user") == 0)
                    strncpy(config->database.user, (char *)event.data.scalar.value, sizeof(config->database.user) - 1);
                else if (strcmp(key, "password") == 0)
                    strncpy(config->database.password, (char *)event.data.scalar.value, sizeof(config->database.password) - 1);
                else if (strcmp(key, "name") == 0)
                    strncpy(config->database.name, (char *)event.data.scalar.value, sizeof(config->database.name) - 1);

                is_key = 0;
            }
        }

        yaml_event_delete(&event);
    }

    yaml_parser_delete(&parser);
    fclose(file);
}

void print_config(const AppConfig *config) {
    printf("Server Configuration:\n");
    printf("  Host: %s\n", config->server.host);
    printf("  Port: %d\n", config->server.port);
    printf("Database Configuration:\n");
    printf("  User: %s\n", config->database.user);
    printf("  Password: %s\n", config->database.password);
    printf("  Name: %s\n", config->database.name);
}

int main() {
    AppConfig config = {0};

    parse_yaml_to_struct("config.yaml", &config);
    print_config(&config);

    return 0;
}

Server Configuration:
  Host: 127.0.0.1
  Port: 8080
Database Configuration:
  User: admin
  Password: secret
  Name: mydb

server:
  host: "127.0.0.1"
  port: 8080
database:
  user: "admin"
  password: "secret"
  name: "mydb"

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

typedef struct {
    char host[32];
    int port;
} ServerConfig;

typedef struct {
    char user[32];
    char password[32];
    char name[32];
} DatabaseConfig;

typedef struct {
    ServerConfig server;
    DatabaseConfig database;
} AppConfig;

void save_config_to_yaml(const char *filename, const AppConfig *config) {
    FILE *file = fopen(filename, "w");
    if (!file) {
        perror("파일을 저장할 수 없습니다");
        return;
    }

    yaml_emitter_t emitter;
    yaml_event_t event;

    yaml_emitter_initialize(&emitter);
    yaml_emitter_set_output_file(&emitter, file);

    // 시작: 문서 헤더 작성
    yaml_document_start_event_initialize(&event, NULL, NULL, NULL, 0);
    yaml_emitter_emit(&emitter, &event);

    // 맨 처음 맵(Map) 시작
    yaml_mapping_start_event_initialize(&event, NULL, NULL, 1, YAML_BLOCK_MAPPING_STYLE);
    yaml_emitter_emit(&emitter, &event);

    // server 설정
    yaml_scalar_event_initialize(&event, NULL, NULL, (yaml_char_t *)"server", -1, 1, 0, YAML_PLAIN_SCALAR_STYLE);
    yaml_emitter_emit(&emitter, &event);

    yaml_mapping_start_event_initialize(&event, NULL, NULL, 1, YAML_BLOCK_MAPPING_STYLE);
    yaml_emitter_emit(&emitter, &event);

    yaml_scalar_event_initialize(&event, NULL, NULL, (yaml_char_t *)"host", -1, 1, 0, YAML_PLAIN_SCALAR_STYLE);
    yaml_emitter_emit(&emitter, &event);
    yaml_scalar_event_initialize(&event, NULL, NULL, (yaml_char_t *)config->server.host, -1, 1, 0, YAML_PLAIN_SCALAR_STYLE);
    yaml_emitter_emit(&emitter, &event);

    yaml_scalar_event_initialize(&event, NULL, NULL, (yaml_char_t *)"port", -1, 1, 0, YAML_PLAIN_SCALAR_STYLE);
    yaml_emitter_emit(&emitter, &event);
    char port_str[10];
    snprintf(port_str, sizeof(port_str), "%d", config->server.port);
    yaml_scalar_event_initialize(&event, NULL, NULL, (yaml_char_t *)port_str, -1, 1, 0, YAML_PLAIN_SCALAR_STYLE);
    yaml_emitter_emit(&emitter, &event);

    yaml_mapping_end_event_initialize(&event);
    yaml_emitter_emit(&emitter, &event);

    // database 설정
    yaml_scalar_event_initialize(&event, NULL, NULL, (yaml_char_t *)"database", -1, 1, 0, YAML_PLAIN_SCALAR_STYLE);
    yaml_emitter_emit(&emitter, &event);

    yaml_mapping_start_event_initialize(&event, NULL, NULL, 1, YAML_BLOCK_MAPPING_STYLE);
    yaml_emitter_emit(&emitter, &event);

    yaml_scalar_event_initialize(&event, NULL, NULL, (yaml_char_t *)"user", -1, 1, 0, YAML_PLAIN_SCALAR_STYLE);
    yaml_emitter_emit(&emitter, &event);
    yaml_scalar_event_initialize(&event, NULL, NULL, (yaml_char_t *)config->database.user, -1, 1, 0, YAML_PLAIN_SCALAR_STYLE);
    yaml_emitter_emit(&emitter, &event);

    yaml_scalar_event_initialize(&event, NULL, NULL, (yaml_char_t *)"password", -1, 1, 0, YAML_PLAIN_SCALAR_STYLE);
    yaml_emitter_emit(&emitter, &event);
    yaml_scalar_event_initialize(&event, NULL, NULL, (yaml_char_t *)config->database.password, -1, 1, 0, YAML_PLAIN_SCALAR_STYLE);
    yaml_emitter_emit(&emitter, &event);

    yaml_scalar_event_initialize(&event, NULL, NULL, (yaml_char_t *)"name", -1, 1, 0, YAML_PLAIN_SCALAR_STYLE);
    yaml_emitter_emit(&emitter, &event);
    yaml_scalar_event_initialize(&event, NULL, NULL, (yaml_char_t *)config->database.name, -1, 1, 0, YAML_PLAIN_SCALAR_STYLE);
    yaml_emitter_emit(&emitter, &event);

    yaml_mapping_end_event_initialize(&event);
    yaml_emitter_emit(&emitter, &event);

    // 맵(Map) 종료
    yaml_mapping_end_event_initialize(&event);
    yaml_emitter_emit(&emitter, &event);

    // 문서 종료
    yaml_document_end_event_initialize(&event, 0);
    yaml_emitter_emit(&emitter, &event);

    yaml_emitter_delete(&emitter);
    fclose(file);
}

int main() {
    AppConfig config = {
        .server = {"127.0.0.1", 8080},
        .database = {"admin", "secret", "mydb"}
    };

    // 기존 설정 출력
    printf("현재 포트: %d\n", config.server.port);

    // 설정 변경
    config.server.port = 9090;
    printf("변경된 포트: %d\n", config.server.port);

    // 변경된 설정을 YAML 파일로 저장
    save_config_to_yaml("config.yaml", &config);

    return 0;
}

현재 포트: 8080  
변경된 포트: 9090  

server:
  host: 127.0.0.1
  port: 9090
database:
  user: admin
  password: secret
  name: mydb

#include <stdio.h>
#include <stdlib.h>

int check_file_exists(const char *filename) {
    FILE *file = fopen(filename, "r");
    if (file) {
        fclose(file);
        return 1;  // 파일 존재
    }
    return 0;  // 파일 없음
}

int main() {
    const char *filename = "config.yaml";
    if (!check_file_exists(filename)) {
        printf("오류: 설정 파일 %s이(가) 존재하지 않습니다. 기본값을 적용합니다.\n", filename);
        // 기본 설정 적용 코드 추가 가능
    } else {
        printf("설정 파일이 존재합니다.\n");
    }
    return 0;
}

#include <stdio.h>
#include <yaml.h>

int validate_yaml_syntax(const char *filename) {
    FILE *file = fopen(filename, "r");
    if (!file) {
        perror("파일을 열 수 없습니다");
        return 0;
    }

    yaml_parser_t parser;
    yaml_event_t event;

    yaml_parser_initialize(&parser);
    yaml_parser_set_input_file(&parser, file);

    int valid = 1;
    while (1) {
        if (!yaml_parser_parse(&parser, &event)) {
            fprintf(stderr, "YAML 문법 오류 발생!\n");
            valid = 0;
            break;
        }

        if (event.type == YAML_STREAM_END_EVENT) {
            break;
        }
        yaml_event_delete(&event);
    }

    yaml_parser_delete(&parser);
    fclose(file);
    return valid;
}

int main() {
    if (!validate_yaml_syntax("config.yaml")) {
        printf("오류: YAML 파일 문법이 올바르지 않습니다.\n");
    } else {
        printf("YAML 문법이 정상입니다.\n");
    }
    return 0;
}

void apply_default_if_missing(AppConfig *config) {
    if (config->server.port == 0) {
        printf("경고: 포트 번호가 누락되어 기본값(8080) 적용\n");
        config->server.port = 8080;
    }
    if (strlen(config->server.host) == 0) {
        printf("경고: 서버 호스트가 누락되어 기본값(127.0.0.1) 적용\n");
        strncpy(config->server.host, "127.0.0.1", sizeof(config->server.host) - 1);
    }
}

int is_number(const char *str) {
    while (*str) {
        if (*str < '0' || *str > '9') return 0;
        str++;
    }
    return 1;
}

void validate_config_data(AppConfig *config) {
    if (!is_number(config->server.host)) {
        printf("오류: 포트 값이 숫자가 아닙니다. 기본값(8080) 적용\n");
        config->server.port = 8080;
    }
}

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

typedef struct {
    char host[32];
    int port;
} ServerConfig;

typedef struct {
    char user[32];
    char password[32];
    char name[32];
} DatabaseConfig;

typedef struct {
    ServerConfig server;
    DatabaseConfig database;
} AppConfig;

int check_file_exists(const char *filename) {
    FILE *file = fopen(filename, "r");
    if (file) {
        fclose(file);
        return 1;
    }
    return 0;
}

int validate_yaml_syntax(const char *filename) {
    FILE *file = fopen(filename, "r");
    if (!file) return 0;

    yaml_parser_t parser;
    yaml_event_t event;

    yaml_parser_initialize(&parser);
    yaml_parser_set_input_file(&parser, file);

    int valid = 1;
    while (1) {
        if (!yaml_parser_parse(&parser, &event)) {
            fprintf(stderr, "YAML 문법 오류!\n");
            valid = 0;
            break;
        }
        if (event.type == YAML_STREAM_END_EVENT) break;
        yaml_event_delete(&event);
    }

    yaml_parser_delete(&parser);
    fclose(file);
    return valid;
}

void apply_default_if_missing(AppConfig *config) {
    if (config->server.port == 0) {
        printf("경고: 포트 번호가 누락되어 기본값(8080) 적용\n");
        config->server.port = 8080;
    }
    if (strlen(config->server.host) == 0) {
        printf("경고: 서버 호스트가 누락되어 기본값(127.0.0.1) 적용\n");
        strncpy(config->server.host, "127.0.0.1", sizeof(config->server.host) - 1);
    }
}

int main() {
    const char *filename = "config.yaml";

    if (!check_file_exists(filename)) {
        printf("오류: 설정 파일이 존재하지 않음. 기본값을 적용합니다.\n");
    } else if (!validate_yaml_syntax(filename)) {
        printf("오류: YAML 문법이 올바르지 않음. 기본값을 적용합니다.\n");
    } else {
        printf("설정 파일이 올바르게 로드됨.\n");
    }

    AppConfig config = {0};
    apply_default_if_missing(&config);

    return 0;
}

#include <stdio.h>
#include <yaml.h>

void parse_large_yaml_file(const char *filename) {
    FILE *file = fopen(filename, "r");
    if (!file) {
        perror("파일을 열 수 없습니다");
        return;
    }

    yaml_parser_t parser;
    yaml_event_t event;
    yaml_parser_initialize(&parser);
    yaml_parser_set_input_file(&parser, file);

    int key_mode = 0;
    char key[256];

    while (1) {
        if (!yaml_parser_parse(&parser, &event)) {
            fprintf(stderr, "YAML 파싱 오류 발생!\n");
            break;
        }

        if (event.type == YAML_STREAM_END_EVENT) {
            break;
        } else if (event.type == YAML_SCALAR_EVENT) {
            if (key_mode) {
                printf("%s: %s\n", key, event.data.scalar.value);
                key_mode = 0;
            } else {
                strncpy(key, (char *)event.data.scalar.value, sizeof(key) - 1);
                key_mode = 1;
            }
        }

        yaml_event_delete(&event);
    }

    yaml_parser_delete(&parser);
    fclose(file);
}

int main() {
    parse_large_yaml_file("large_config.yaml");
    return 0;
}

#define BUFFER_SIZE 8192  // 8KB 버퍼

FILE *open_file_with_buffer(const char *filename) {
    FILE *file = fopen(filename, "r");
    if (!file) {
        perror("파일을 열 수 없습니다");
        return NULL;
    }

    // 버퍼를 설정하여 읽기 속도 향상
    static char buffer[BUFFER_SIZE];
    setvbuf(file, buffer, _IOFBF, BUFFER_SIZE);

    return file;
}

#include <search.h>

ENTRY *yaml_cache = NULL;

void insert_to_cache(const char *key, const char *value) {
    ENTRY item;
    item.key = strdup(key);
    item.data = strdup(value);
    hsearch(item, ENTER);
}

const char *search_in_cache(const char *key) {
    ENTRY item;
    item.key = (char *)key;
    ENTRY *result = hsearch(item, FIND);
    return result ? (char *)result->data : NULL;
}

void process_yaml_event(yaml_event_t event) {
    static char key[256];

    if (event.type == YAML_SCALAR_EVENT) {
        static int is_key = 1;
        if (is_key) {
            strncpy(key, (char *)event.data.scalar.value, sizeof(key) - 1);
            is_key = 0;
        } else {
            insert_to_cache(key, (char *)event.data.scalar.value);
            is_key = 1;
        }
    }
}

#include <stdio.h>
#include <stdlib.h>
#include <search.h>
#include <yaml.h>

#define BUFFER_SIZE 8192  // 8KB 버퍼

FILE *open_file_with_buffer(const char *filename) {
    FILE *file = fopen(filename, "r");
    if (!file) {
        perror("파일을 열 수 없습니다");
        return NULL;
    }
    static char buffer[BUFFER_SIZE];
    setvbuf(file, buffer, _IOFBF, BUFFER_SIZE);
    return file;
}

void insert_to_cache(const char *key, const char *value) {
    ENTRY item;
    item.key = strdup(key);
    item.data = strdup(value);
    hsearch(item, ENTER);
}

const char *search_in_cache(const char *key) {
    ENTRY item;
    item.key = (char *)key;
    ENTRY *result = hsearch(item, FIND);
    return result ? (char *)result->data : NULL;
}

void parse_large_yaml_file(const char *filename) {
    FILE *file = open_file_with_buffer(filename);
    if (!file) return;

    yaml_parser_t parser;
    yaml_event_t event;
    yaml_parser_initialize(&parser);
    yaml_parser_set_input_file(&parser, file);

    while (1) {
        if (!yaml_parser_parse(&parser, &event)) {
            fprintf(stderr, "YAML 파싱 오류 발생!\n");
            break;
        }
        if (event.type == YAML_STREAM_END_EVENT) break;
        process_yaml_event(event);
        yaml_event_delete(&event);
    }

    yaml_parser_delete(&parser);
    fclose(file);
}

int main() {
    hcreate(1000);  // 해시 테이블 크기 설정

    parse_large_yaml_file("large_config.yaml");

    // 특정 설정 검색
    const char *db_name = search_in_cache("database.name");
    if (db_name) {
        printf("데이터베이스 이름: %s\n", db_name);
    } else {
        printf("설정값을 찾을 수 없습니다.\n");
    }

    return 0;
}

server:
  host: "127.0.0.1"
  port: 8080
  log_file: "/var/log/server.log"

database:
  user: "admin"
  password: "securepass"
  name: "mydb"

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

typedef struct {
    char host[32];
    int port;
    char log_file[128];
} ServerConfig;

typedef struct {
    char user[32];
    char password[32];
    char name[32];
} DatabaseConfig;

typedef struct {
    ServerConfig server;
    DatabaseConfig database;
} AppConfig;

void parse_yaml_config(const char *filename, AppConfig *config) {
    FILE *file = fopen(filename, "r");
    if (!file) {
        perror("설정 파일을 열 수 없습니다");
        return;
    }

    yaml_parser_t parser;
    yaml_event_t event;
    char key[64] = {0};
    int is_key = 0;

    yaml_parser_initialize(&parser);
    yaml_parser_set_input_file(&parser, file);

    while (1) {
        if (!yaml_parser_parse(&parser, &event)) {
            fprintf(stderr, "YAML 파싱 오류 발생!\n");
            break;
        }

        if (event.type == YAML_STREAM_END_EVENT) break;

        if (event.type == YAML_SCALAR_EVENT) {
            if (!is_key) {
                strncpy(key, (char *)event.data.scalar.value, sizeof(key) - 1);
                is_key = 1;
            } else {
                if (strcmp(key, "host") == 0)
                    strncpy(config->server.host, (char *)event.data.scalar.value, sizeof(config->server.host) - 1);
                else if (strcmp(key, "port") == 0)
                    config->server.port = atoi((char *)event.data.scalar.value);
                else if (strcmp(key, "log_file") == 0)
                    strncpy(config->server.log_file, (char *)event.data.scalar.value, sizeof(config->server.log_file) - 1);
                else if (strcmp(key, "user") == 0)
                    strncpy(config->database.user, (char *)event.data.scalar.value, sizeof(config->database.user) - 1);
                else if (strcmp(key, "password") == 0)
                    strncpy(config->database.password, (char *)event.data.scalar.value, sizeof(config->database.password) - 1);
                else if (strcmp(key, "name") == 0)
                    strncpy(config->database.name, (char *)event.data.scalar.value, sizeof(config->database.name) - 1);

                is_key = 0;
            }
        }

        yaml_event_delete(&event);
    }

    yaml_parser_delete(&parser);
    fclose(file);
}

void save_config_to_yaml(const char *filename, const AppConfig *config) {
    FILE *file = fopen(filename, "w");
    if (!file) {
        perror("파일을 저장할 수 없습니다");
        return;
    }

    fprintf(file, "server:\n");
    fprintf(file, "  host: \"%s\"\n", config->server.host);
    fprintf(file, "  port: %d\n", config->server.port);
    fprintf(file, "  log_file: \"%s\"\n", config->server.log_file);
    fprintf(file, "\ndatabase:\n");
    fprintf(file, "  user: \"%s\"\n", config->database.user);
    fprintf(file, "  password: \"%s\"\n", config->database.password);
    fprintf(file, "  name: \"%s\"\n", config->database.name);

    fclose(file);
}

int main() {
    AppConfig config = {0};

    parse_yaml_config("server_config.yaml", &config);

    printf("기존 서버 설정:\n");
    printf("  Host: %s\n", config.server.host);
    printf("  Port: %d\n", config.server.port);
    printf("  Log File: %s\n", config.server.log_file);

    // 설정 변경
    config.server.port = 9090;
    strncpy(config.server.log_file, "/var/log/new_server.log", sizeof(config.server.log_file) - 1);

    printf("\n변경된 설정:\n");
    printf("  Host: %s\n", config.server.host);
    printf("  Port: %d\n", config.server.port);
    printf("  Log File: %s\n", config.server.log_file);

    // 변경된 설정을 YAML 파일로 저장
    save_config_to_yaml("server_config.yaml", &config);

    return 0;
}

기존 서버 설정:
  Host: 127.0.0.1
  Port: 8080
  Log File: /var/log/server.log

변경된 설정:
  Host: 127.0.0.1
  Port: 9090
  Log File: /var/log/new_server.log

server:
  host: "127.0.0.1"
  port: 9090
  log_file: "/var/log/new_server.log"

database:
  user: "admin"
  password: "securepass"
  name: "mydb"