#ifndef MYMATH_H
#define MYMATH_H

// 두 수의 합을 반환
int add(int a, int b);

// 두 수의 차를 반환
int subtract(int a, int b);

// 두 수의 곱을 반환
int multiply(int a, int b);

// 두 수의 나눗셈 결과를 반환 (0으로 나누기 체크 포함)
double divide(int a, int b);

// 제곱 계산
int power(int base, int exponent);

#endif // MYMATH_H

#include "mymath.h"
#include <stdio.h>

int add(int a, int b) {
    return a + b;
}

int subtract(int a, int b) {
    return a - b;
}

int multiply(int a, int b) {
    return a * b;
}

double divide(int a, int b) {
    if (b == 0) {
        fprintf(stderr, "Error: Division by zero!\n");
        return 0.0;
    }
    return (double)a / b;
}

int power(int base, int exponent) {
    int result = 1;
    for (int i = 0; i < exponent; i++) {
        result *= base;
    }
    return result;
}

# GCC를 사용한 컴파일 (오브젝트 파일 생성)
gcc -c mymath.c -o mymath.o

# 여러 소스 파일이 있다면
gcc -c mymath.c -o mymath.o
gcc -c mystring.c -o mystring.o
gcc -c myfile.c -o myfile.o

# Linux/Unix에서 ar 명령어 사용
ar rcs libmymath.a mymath.o

# 여러 오브젝트 파일을 포함하는 경우
ar rcs libmyutils.a mymath.o mystring.o myfile.o

# 라이브러리 내용 확인
ar -t libmymath.a

# 라이브러리 상세 정보 확인
ar -tv libmymath.a

// main.c
#include <stdio.h>
#include "mymath.h"

int main() {
    int a = 10, b = 5;
    
    printf("Addition: %d + %d = %d\n", a, b, add(a, b));
    printf("Subtraction: %d - %d = %d\n", a, b, subtract(a, b));
    printf("Multiplication: %d * %d = %d\n", a, b, multiply(a, b));
    printf("Division: %d / %d = %.2f\n", a, b, divide(a, b));
    printf("Power: %d ^ %d = %d\n", a, 3, power(a, 3));
    
    return 0;
}

# 컴파일 및 링킹
gcc main.c -L. -lmymath -o myprogram

# 또는 라이브러리 파일을 직접 지정
gcc main.c libmymath.a -o myprogram

# 실행
./myprogram

# Linux에서 동적 라이브러리용 오브젝트 파일 생성
gcc -c -fPIC mymath.c -o mymath.o

# -fPIC 옵션 설명:
# Position Independent Code를 생성
# 메모리 어느 위치에 로드되어도 동작 가능한 코드

# Linux에서 .so 파일 생성
gcc -shared -o libmymath.so mymath.o

# 또는 한 번에 컴파일과 링킹
gcc -shared -fPIC mymath.c -o libmymath.so

# 여러 소스 파일을 포함하는 경우
gcc -shared -fPIC mymath.c mystring.c myfile.c -o libmyutils.so

# 버전 정보를 포함하는 경우
gcc -shared -Wl,-soname,libmymath.so.1 -o libmymath.so.1.0.0 mymath.o

# 컴파일 (링킹)
gcc main.c -L. -lmymath -o myprogram

# 실행 시 라이브러리 경로 지정 (방법 1)
LD_LIBRARY_PATH=. ./myprogram

# 실행 시 라이브러리 경로 지정 (방법 2)
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:.
./myprogram

# rpath를 사용하여 라이브러리 경로를 실행 파일에 포함
gcc main.c -L. -lmymath -Wl,-rpath,. -o myprogram
./myprogram

#include <stdio.h>
#include <dlfcn.h>

int main() {
    void *handle;
    int (*add_func)(int, int);
    char *error;
    
    // 라이브러리 로드
    handle = dlopen("./libmymath.so", RTLD_LAZY);
    if (!handle) {
        fprintf(stderr, "Error: %s\n", dlerror());
        return 1;
    }
    
    // 함수 포인터 가져오기
    dlerror(); // 이전 에러 클리어
    add_func = (int (*)(int, int))dlsym(handle, "add");
    
    error = dlerror();
    if (error != NULL) {
        fprintf(stderr, "Error: %s\n", error);
        dlclose(handle);
        return 1;
    }
    
    // 함수 호출
    printf("10 + 5 = %d\n", (*add_func)(10, 5));
    
    // 라이브러리 언로드
    dlclose(handle);
    
    return 0;
}

// 컴파일 시 -ldl 옵션 필요
// gcc dynamic_load.c -ldl -o dynamic_load

// mylib.h - 잘 설계된 헤더 파일 예제
#ifndef MYLIB_H
#define MYLIB_H

#ifdef __cplusplus
extern "C" {
#endif

// 버전 정보
#define MYLIB_VERSION_MAJOR 1
#define MYLIB_VERSION_MINOR 0
#define MYLIB_VERSION_PATCH 0

// 플랫폼별 export/import 매크로
#ifdef _WIN32
    #ifdef MYLIB_EXPORTS
        #define MYLIB_API __declspec(dllexport)
    #else
        #define MYLIB_API __declspec(dllimport)
    #endif
#else
    #define MYLIB_API __attribute__((visibility("default")))
#endif

// 에러 코드 정의
typedef enum {
    MYLIB_SUCCESS = 0,
    MYLIB_ERROR_INVALID_PARAM = -1,
    MYLIB_ERROR_OUT_OF_MEMORY = -2,
    MYLIB_ERROR_NOT_FOUND = -3
} mylib_error_t;

// 불투명 포인터 (Opaque Pointer) 사용
typedef struct mylib_context mylib_context_t;

// API 함수들
MYLIB_API mylib_context_t* mylib_create(void);
MYLIB_API void mylib_destroy(mylib_context_t *ctx);
MYLIB_API mylib_error_t mylib_process(mylib_context_t *ctx, const char *input);
MYLIB_API const char* mylib_get_error_string(mylib_error_t error);

#ifdef __cplusplus
}
#endif

#endif // MYLIB_H

// 좋은 예: 명확한 소유권
MYLIB_API char* mylib_create_string(const char *input) {
    // 라이브러리가 메모리 할당
    char *result = malloc(strlen(input) + 1);
    if (result) {
        strcpy(result, input);
    }
    return result;
}

MYLIB_API void mylib_free_string(char *str) {
    // 라이브러리가 메모리 해제
    free(str);
}

// 사용 예
char *str = mylib_create_string("Hello");
// ... 사용 ...
mylib_free_string(str);

// 또 다른 좋은 패턴: 사용자가 버퍼 제공
MYLIB_API int mylib_get_string(char *buffer, size_t buffer_size) {
    // 사용자가 제공한 버퍼에 복사
    if (buffer_size < required_size) {
        return -1; // 버퍼 크기 부족
    }
    strcpy(buffer, internal_string);
    return 0;
}

#include <pthread.h>

// 스레드 안전한 라이브러리 예제
typedef struct {
    int counter;
    pthread_mutex_t mutex;
} mylib_context_t;

MYLIB_API mylib_context_t* mylib_create(void) {
    mylib_context_t *ctx = malloc(sizeof(mylib_context_t));
    if (ctx) {
        ctx->counter = 0;
        pthread_mutex_init(&ctx->mutex, NULL);
    }
    return ctx;
}

MYLIB_API void mylib_increment(mylib_context_t *ctx) {
    pthread_mutex_lock(&ctx->mutex);
    ctx->counter++;
    pthread_mutex_unlock(&ctx->mutex);
}

MYLIB_API void mylib_destroy(mylib_context_t *ctx) {
    if (ctx) {
        pthread_mutex_destroy(&ctx->mutex);
        free(ctx);
    }
}

// 컴파일 시 -pthread 옵션 필요
// gcc -shared -fPIC -pthread mylib.c -o libmylib.so

# mymath.pc 파일 생성
prefix=/usr/local
exec_prefix=${prefix}
libdir=${exec_prefix}/lib
includedir=${prefix}/include

Name: MyMath
Description: Simple math library
Version: 1.0.0
Libs: -L${libdir} -lmymath
Cflags: -I${includedir}

# pkg-config 사용 예제
gcc main.c `pkg-config --cflags --libs mymath` -o myprogram

# 또는 Makefile에서
CFLAGS += $(shell pkg-config --cflags mymath)
LDFLAGS += $(shell pkg-config --libs mymath)

# CMakeLists.txt
cmake_minimum_required(VERSION 3.10)
project(MyMath VERSION 1.0.0 LANGUAGES C)

# 라이브러리 소스 파일
set(SOURCES
    src/mymath.c
    src/mystring.c
    src/myfile.c
)

# 정적 라이브러리 생성
add_library(mymath_static STATIC ${SOURCES})
set_target_properties(mymath_static PROPERTIES OUTPUT_NAME mymath)

# 동적 라이브러리 생성
add_library(mymath_shared SHARED ${SOURCES})
set_target_properties(mymath_shared PROPERTIES 
    OUTPUT_NAME mymath
    VERSION ${PROJECT_VERSION}
    SOVERSION 1
)

# 헤더 파일 설치 경로
target_include_directories(mymath_static PUBLIC
    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
    $<INSTALL_INTERFACE:include>
)

target_include_directories(mymath_shared PUBLIC
    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
    $<INSTALL_INTERFACE:include>
)

# 설치 규칙
install(TARGETS mymath_static mymath_shared
    LIBRARY DESTINATION lib
    ARCHIVE DESTINATION lib
    RUNTIME DESTINATION bin
)

install(DIRECTORY include/ DESTINATION include)

# 빌드 방법
mkdir build
cd build
cmake ..
cmake --build .
sudo cmake --install .

// visibility.h
#if defined(_WIN32) || defined(__CYGWIN__)
    #ifdef BUILDING_DLL
        #define PUBLIC_API __declspec(dllexport)
    #else
        #define PUBLIC_API __declspec(dllimport)
    #endif
    #define PRIVATE_API
#else
    #if __GNUC__ >= 4
        #define PUBLIC_API __attribute__((visibility("default")))
        #define PRIVATE_API __attribute__((visibility("hidden")))
    #else
        #define PUBLIC_API
        #define PRIVATE_API
    #endif
#endif

// 사용 예
PUBLIC_API int public_function(int x);
PRIVATE_API int internal_function(int x);  // 외부에서 접근 불가

# GCC에서 기본 가시성을 hidden으로 설정
gcc -fvisibility=hidden -shared -fPIC mylib.c -o libmylib.so

# Linux에서 ldd 사용
ldd myprogram
# 출력 예:
#   linux-vdso.so.1 (0x00007ffd8e3f0000)
#   libmymath.so => ./libmymath.so (0x00007f8e5c3a0000)
#   libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f8e5c1a0000)

# 라이브러리 내부 심볼 확인
nm -D libmymath.so
# 또는
objdump -T libmymath.so

# 정적 라이브러리 내용 확인
ar -t libmymath.a
nm libmymath.a

# 라이브러리 검색 경로 확인
ldconfig -p | grep mymath

# 실행 파일의 rpath 확인
readelf -d myprogram | grep RPATH

mystring/
├── include/
│   └── mystring.h          # 공개 헤더
├── src/
│   ├── mystring.c          # 구현
│   └── internal.h          # 내부 헤더
├── tests/
│   └── test_mystring.c     # 테스트 코드
├── examples/
│   └── example.c           # 사용 예제
├── CMakeLists.txt          # 빌드 설정
├── mystring.pc.in          # pkg-config 템플릿
└── README.md               # 문서

#ifndef MYSTRING_H
#define MYSTRING_H

#include <stddef.h>
#include <stdbool.h>

#ifdef __cplusplus
extern "C" {
#endif

// 버전 정보
#define MYSTRING_VERSION_MAJOR 1
#define MYSTRING_VERSION_MINOR 0
#define MYSTRING_VERSION_PATCH 0

// API export/import
#ifdef _WIN32
    #ifdef MYSTRING_BUILD
        #define MYSTRING_API __declspec(dllexport)
    #else
        #define MYSTRING_API __declspec(dllimport)
    #endif
#else
    #define MYSTRING_API __attribute__((visibility("default")))
#endif

// 에러 코드
typedef enum {
    MYSTRING_OK = 0,
    MYSTRING_ERROR_NULL_POINTER = -1,
    MYSTRING_ERROR_OUT_OF_MEMORY = -2,
    MYSTRING_ERROR_INVALID_ARGUMENT = -3
} mystring_error_t;

// 문자열 객체 (불투명 포인터)
typedef struct mystring mystring_t;

// 생성 및 소멸
MYSTRING_API mystring_t* mystring_create(const char *str);
MYSTRING_API mystring_t* mystring_create_empty(void);
MYSTRING_API void mystring_destroy(mystring_t *str);

// 기본 연산
MYSTRING_API size_t mystring_length(const mystring_t *str);
MYSTRING_API const char* mystring_cstr(const mystring_t *str);
MYSTRING_API mystring_error_t mystring_append(mystring_t *str, const char *append);
MYSTRING_API mystring_error_t mystring_prepend(mystring_t *str, const char *prepend);

// 검색 및 비교
MYSTRING_API int mystring_compare(const mystring_t *str1, const mystring_t *str2);
MYSTRING_API bool mystring_equals(const mystring_t *str1, const mystring_t *str2);
MYSTRING_API int mystring_find(const mystring_t *str, const char *substr);
MYSTRING_API bool mystring_contains(const mystring_t *str, const char *substr);

// 변환
MYSTRING_API mystring_t* mystring_to_upper(const mystring_t *str);
MYSTRING_API mystring_t* mystring_to_lower(const mystring_t *str);
MYSTRING_API mystring_t* mystring_trim(const mystring_t *str);

// 분할 및 결합
MYSTRING_API mystring_t** mystring_split(const mystring_t *str, const char *delimiter, size_t *count);
MYSTRING_API mystring_t* mystring_join(mystring_t **strings, size_t count, const char *separator);

// 에러 처리
MYSTRING_API const char* mystring_error_string(mystring_error_t error);

#ifdef __cplusplus
}
#endif

#endif // MYSTRING_H

#include "mystring.h"
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

// 내부 구조체 정의
struct mystring {
    char *data;
    size_t length;
    size_t capacity;
};

// 내부 헬퍼 함수
static mystring_error_t ensure_capacity(mystring_t *str, size_t required) {
    if (required <= str->capacity) {
        return MYSTRING_OK;
    }
    
    size_t new_capacity = str->capacity * 2;
    if (new_capacity < required) {
        new_capacity = required;
    }
    
    char *new_data = realloc(str->data, new_capacity);
    if (!new_data) {
        return MYSTRING_ERROR_OUT_OF_MEMORY;
    }
    
    str->data = new_data;
    str->capacity = new_capacity;
    return MYSTRING_OK;
}

// 생성 및 소멸
mystring_t* mystring_create(const char *str) {
    if (!str) {
        return NULL;
    }
    
    mystring_t *result = malloc(sizeof(mystring_t));
    if (!result) {
        return NULL;
    }
    
    size_t len = strlen(str);
    result->capacity = len + 1;
    result->data = malloc(result->capacity);
    
    if (!result->data) {
        free(result);
        return NULL;
    }
    
    strcpy(result->data, str);
    result->length = len;
    
    return result;
}

mystring_t* mystring_create_empty(void) {
    mystring_t *result = malloc(sizeof(mystring_t));
    if (!result) {
        return NULL;
    }
    
    result->capacity = 16;
    result->data = malloc(result->capacity);
    
    if (!result->data) {
        free(result);
        return NULL;
    }
    
    result->data[0] = '\0';
    result->length = 0;
    
    return result;
}

void mystring_destroy(mystring_t *str) {
    if (str) {
        free(str->data);
        free(str);
    }
}

// 기본 연산
size_t mystring_length(const mystring_t *str) {
    return str ? str->length : 0;
}

const char* mystring_cstr(const mystring_t *str) {
    return str ? str->data : NULL;
}

mystring_error_t mystring_append(mystring_t *str, const char *append) {
    if (!str || !append) {
        return MYSTRING_ERROR_NULL_POINTER;
    }
    
    size_t append_len = strlen(append);
    size_t required = str->length + append_len + 1;
    
    mystring_error_t err = ensure_capacity(str, required);
    if (err != MYSTRING_OK) {
        return err;
    }
    
    strcat(str->data, append);
    str->length += append_len;
    
    return MYSTRING_OK;
}

// 비교
bool mystring_equals(const mystring_t *str1, const mystring_t *str2) {
    if (!str1 || !str2) {
        return false;
    }
    
    if (str1->length != str2->length) {
        return false;
    }
    
    return strcmp(str1->data, str2->data) == 0;
}

// 검색
int mystring_find(const mystring_t *str, const char *substr) {
    if (!str || !substr) {
        return -1;
    }
    
    char *pos = strstr(str->data, substr);
    if (!pos) {
        return -1;
    }
    
    return (int)(pos - str->data);
}

bool mystring_contains(const mystring_t *str, const char *substr) {
    return mystring_find(str, substr) >= 0;
}

// 변환
mystring_t* mystring_to_upper(const mystring_t *str) {
    if (!str) {
        return NULL;
    }
    
    mystring_t *result = mystring_create(str->data);
    if (!result) {
        return NULL;
    }
    
    for (size_t i = 0; i < result->length; i++) {
        result->data[i] = toupper((unsigned char)result->data[i]);
    }
    
    return result;
}

mystring_t* mystring_trim(const mystring_t *str) {
    if (!str) {
        return NULL;
    }
    
    const char *start = str->data;
    const char *end = str->data + str->length - 1;
    
    // 앞쪽 공백 제거
    while (*start && isspace((unsigned char)*start)) {
        start++;
    }
    
    // 뒤쪽 공백 제거
    while (end > start && isspace((unsigned char)*end)) {
        end--;
    }
    
    size_t new_len = end - start + 1;
    mystring_t *result = malloc(sizeof(mystring_t));
    if (!result) {
        return NULL;
    }
    
    result->capacity = new_len + 1;
    result->data = malloc(result->capacity);
    if (!result->data) {
        free(result);
        return NULL;
    }
    
    memcpy(result->data, start, new_len);
    result->data[new_len] = '\0';
    result->length = new_len;
    
    return result;
}

// 에러 처리
const char* mystring_error_string(mystring_error_t error) {
    switch (error) {
        case MYSTRING_OK:
            return "Success";
        case MYSTRING_ERROR_NULL_POINTER:
            return "Null pointer error";
        case MYSTRING_ERROR_OUT_OF_MEMORY:
            return "Out of memory";
        case MYSTRING_ERROR_INVALID_ARGUMENT:
            return "Invalid argument";
        default:
            return "Unknown error";
    }
}

#include <stdio.h>
#include "mystring.h"

int main() {
    // 문자열 생성
    mystring_t *str = mystring_create("Hello, World!");
    if (!str) {
        fprintf(stderr, "Failed to create string\n");
        return 1;
    }
    
    printf("Original: %s\n", mystring_cstr(str));
    printf("Length: %zu\n", mystring_length(str));
    
    // 문자열 추가
    mystring_error_t err = mystring_append(str, " Welcome to C!");
    if (err != MYSTRING_OK) {
        fprintf(stderr, "Error: %s\n", mystring_error_string(err));
        mystring_destroy(str);
        return 1;
    }
    
    printf("After append: %s\n", mystring_cstr(str));
    
    // 검색
    if (mystring_contains(str, "World")) {
        printf("String contains 'World'\n");
        int pos = mystring_find(str, "World");
        printf("Position: %d\n", pos);
    }
    
    // 대문자 변환
    mystring_t *upper = mystring_to_upper(str);
    if (upper) {
        printf("Uppercase: %s\n", mystring_cstr(upper));
        mystring_destroy(upper);
    }
    
    // 공백 제거
    mystring_t *str2 = mystring_create("   trim me   ");
    mystring_t *trimmed = mystring_trim(str2);
    if (trimmed) {
        printf("Trimmed: '%s'\n", mystring_cstr(trimmed));
        mystring_destroy(trimmed);
    }
    mystring_destroy(str2);
    
    // 정리
    mystring_destroy(str);
    
    return 0;
}

cmake_minimum_required(VERSION 3.10)
project(MyString VERSION 1.0.0 LANGUAGES C)

set(CMAKE_C_STANDARD 11)
set(CMAKE_C_STANDARD_REQUIRED ON)

# 소스 파일
set(SOURCES src/mystring.c)
set(HEADERS include/mystring.h)

# 정적 라이브러리
add_library(mystring_static STATIC ${SOURCES})
target_include_directories(mystring_static PUBLIC
    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
    $<INSTALL_INTERFACE:include>
)
set_target_properties(mystring_static PROPERTIES OUTPUT_NAME mystring)

# 동적 라이브러리
add_library(mystring_shared SHARED ${SOURCES})
target_include_directories(mystring_shared PUBLIC
    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
    $<INSTALL_INTERFACE:include>
)
target_compile_definitions(mystring_shared PRIVATE MYSTRING_BUILD)
set_target_properties(mystring_shared PROPERTIES
    OUTPUT_NAME mystring
    VERSION ${PROJECT_VERSION}
    SOVERSION 1
)

# 예제 프로그램
add_executable(example examples/example.c)
target_link_libraries(example PRIVATE mystring_static)

# 설치 규칙
install(TARGETS mystring_static mystring_shared
    LIBRARY DESTINATION lib
    ARCHIVE DESTINATION lib
    RUNTIME DESTINATION bin
)
install(FILES ${HEADERS} DESTINATION include)

# pkg-config 파일 생성
configure_file(mystring.pc.in mystring.pc @ONLY)
install(FILES ${CMAKE_BINARY_DIR}/mystring.pc DESTINATION lib/pkgconfig)