Changeset 26 in libcf for trunk


Ignore:
Timestamp:
02/04/13 17:00:53 (11 years ago)
Author:
cheese
Message:

#1 documentation with doxygen

Location:
trunk
Files:
3 added
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/cf_base.h

    r11 r26  
    11/**
    2  * cf_base.h
     2 * @file    cf_base.h
     3 * @author  myusgun <myusgun@gmail.com>
     4 * @version 0.1
    35 */
    46#ifndef __CF_BASE_H__
    57#define __CF_BASE_H__
    68
     9/** boolean 타입 */
    710typedef enum {
    8     CF_FALSE = 0,
    9     CF_TRUE = 1
    10 } E_CF_BOOL, CF_BOOL;
     11    CF_FALSE = 0,   /**< 거짓 */
     12    CF_TRUE = 1     /**< 참 */
     13} E_CF_BOOL,
     14/**
     15 * boolean 타입
     16 * @see E_CF_BOOL
     17 */
     18    CF_BOOL;
    1119
     20/** 성공 시, 반환 값 */
    1221#define CF_OK                           0
     22/** 오류 코드 */
    1323#define CF_ERROR                        -1
    1424
     25/** 파일 이름 및 경로 길이 */
    1526#define NAME_LENGTH                     128
    1627
     28/** 오류 코드 베이스 넘버 */
    1729#define CF_ERROR_BASE                   CF_ERROR * 1000
    18 
     30/** @see cf_file.h */
    1931#define CF_ERROR_FILE                   CF_ERROR_BASE * 2
     32/** @see cf_socket.h */
    2033#define CF_ERROR_SOCKET                 CF_ERROR_BASE * 3
     34/** @see cf_thread.h */
    2135#define CF_ERROR_THREAD                 CF_ERROR_BASE * 4
     36/** @see cf_thread.h */
    2237#define CF_ERROR_MUTEX                  CF_ERROR_BASE * 5
     38/** @see cf_debug.h */
    2339#define CF_ERROR_DEBUG                  CF_ERROR_BASE * 6
     40/** @see cf_log.h */
    2441#define CF_ERROR_LOG                    CF_ERROR_BASE * 7
    2542
     43/** Windows 에서의 함수 EXPORT 구문 정의 */
    2644#ifdef _WIN32
    2745# define CF_EXPORT      __declspec(dllexport)

  • trunk/include/cf_debug.h

    r25 r26  
    11/**
    2  * cf_debug.h
     2 * @file    cf_debug.h
     3 * @author  myusgun <myusgun@gmail.com>
     4 * @version 0.1
     5 *
     6 * @remark
     7 * 디버그 함수를 직접 호출하지 않고 정의된 매크로를 사용하면,
     8 * Preprocessor에 _DEBUG가 정의되어 있는 경우에 만
     9 * 디버그 코드가 동작하도록 할 수 있음 <br />
     10 * 디버그 메시지는 stdout 및 stderr를 이용한 파일 포인터 출력을 지원하고,
     11 * 환경에 적합하도록 사용자가 구성한 컨텍스트를 이용하여 사용할 수도 있음 <br />
     12 * (단, 콜스택의 푸시/팝은 컨텍스트를 이용해야만 사용 가능)
    313 */
    414#ifndef __CF_DEBUG_H__
    … …  
    919#include <stdio.h>
    1020
     21/** 잘못된 컨텍스트 오류 */
    1122#define CF_ERROR_DEBUG_INVALID_CTX          CF_ERROR_DEBUG - 1
     23
     24/** 디버그 메시지 출력을 위한 파일 포인터 설정 오류 */
    1225#define CF_ERROR_DEBUG_SET_OUTPUT_FD        CF_ERROR_DEBUG - 2
     26
     27/** 콜스택 푸시 오류 */
    1328#define CF_ERROR_DEBUG_PUSH_CALLSTACK       CF_ERROR_DEBUG - 3
     29
     30/** 콜스택 팝 오류 */
    1431#define CF_ERROR_DEBUG_POP_CALLSTACK        CF_ERROR_DEBUG - 4
    1532
     33/** Windows 함수 이름 매크로 재정의 */
    1634#ifdef _WIN32
    1735# define __func__   __FUNCTION__
    … …  
    1937
    2038#ifdef _DEBUG
     39/**
     40 * 디버그 컨텍스트 생성
     41 *
     42 * @see CF_Debug_CreateCtx
     43 */
    2144# define CF_DEBUG_CREATE_CTX()                                      \
    2245    CF_Debug_CreateCtx ()
    2346
     47/**
     48 * 디버그 컨텍스트 해제
     49 *
     50 * @param __ctx 디버그 컨텍스트
     51 *
     52 * @see CF_Debug_DestroyCtx
     53 */
    2454# define CF_DEBUG_DESTROY_CTX(__ctx)                                \
    2555    CF_Debug_DestroyCtx (__ctx)
    2656
    27 # define CF_UPDATE_CTX(__ctx)                                       \
    28     CF_Debug_UpdateCtx (__ctx,__FILE__,__func__,__LINE__)
    29 
     57/**
     58 * 디버그 메시지를 지정된 파일 포인터로 출력
     59 *
     60 * @param __fp  파일 포인터. 표준출력(stdout) 및 표준오류(stderr) 사용 가능
     61 * @param __fmt 포맷 스트링
     62 * @param ...   가변 인자
     63 *
     64 * @see CF_Debug_Print
     65 */
    3066# define CF_DEBUG_PRINT(__fp,__fmt,...)                             \
    3167    CF_Debug_Print (__fp,__FILE__,__func__,__LINE__,__fmt,##__VA_ARGS__)
    3268
     69/**
     70 * 바이너리 데이터를 디버그 메시지와 함께 지정된 파일 포인터로 출력
     71 *
     72 * @param __fp  파일 포인터. 표준출력(stdout) 및 표준오류(stderr) 사용 가능
     73 * @param __bin 바이너리 데이터
     74 * @param __len 바이너리 길이
     75 * @param __fmt 포맷 스트링
     76 * @param ...   가변 인자
     77 *
     78 * @see CF_Debug_PrintBin
     79 */
    3380# define CF_DEBUG_PRINT_BIN(__fp,__bin,__len,__fmt,...)             \
    3481    CF_Debug_PrintBin (__fp,__FILE__,__func__,__LINE__,__bin,__len,__fmt,##__VA_ARGS__)
    3582
     83/**
     84 * 컨텍스트를 업데이트하고 디버그 메시지를 출력
     85 *
     86 * @param __ctx 디버그 컨텍스트
     87 * @param __fmt 포맷 스트링
     88 * @param ...   가변 인자
     89 *
     90 * @see CF_DEBUG_UPDATE_CTX, CF_Debug_Trace
     91 */
    3692# define CF_DEBUG_TRACE(__ctx,__fmt,...)                            \
    37     do {                                                            \
    38     CF_UPDATE_CTX (__ctx);                                          \
    39     CF_Debug_Trace (__ctx,__fmt,##__VA_ARGS__);                     \
    40     } while (0)
    41 
     93    CF_Debug_Trace (__ctx,__FILE__,__func__,__LINE__,__fmt,##__VA_ARGS__)
     94
     95/**
     96 * 컨텍스트를 업데이트하고 바이너리 데이터를 디버그 메시지와 함께 출력
     97 *
     98 * @param __ctx 디버그 컨텍스트
     99 * @param __bin 바이너리 데이터
     100 * @param __len 바이너리 길이
     101 * @param __fmt 포맷 스트링
     102 * @param ...   가변 인자
     103 *
     104 * @see CF_DEBUG_UPDATE_CTX, CF_Debug_TraceBin
     105 */
    42106# define CF_DEBUG_TRACE_BIN(__ctx,__bin,__len,__fmt,...)            \
    43     do {                                                            \
    44     CF_UPDATE_CTX (__ctx);                                          \
    45     CF_Debug_TraceBin (__ctx,__bin,__len,__fmt,##__VA_ARGS__);      \
    46     } while (0)
    47 
     107    CF_Debug_TraceBin (__ctx,__FILE__,__func__,__LINE__,__bin,__len,__fmt,##__VA_ARGS__)
     108
     109/**
     110 * 컨텍스트에 콜스택 푸시
     111 *
     112 * @param __ctx 디버그 컨텍스트
     113 *
     114 * @see CF_Debug_CallStackPush
     115 */
    48116# define CF_DEBUG_CALLSTACK_PUSH(__ctx)                             \
    49117    CF_Debug_CallStackPush (__ctx,__FILE__,__func__,__LINE__)
    50118
    51 # define CF_DEBUG_CALLSTACK_POP                                     \
    52     CF_Debug_CallStackPop
     119/**
     120 * 컨텍스트에서 콜스택 팝
     121 *
     122 * @param __ctx         디버그 컨텍스트
     123 * @param __callstack   콜스택 정보를 가져올 콜스택 데이터 구조체 포인터
     124 *
     125 * @see CF_Debug_CallStackPop, CF_Debug_CallStack
     126 */
     127# define CF_DEBUG_CALLSTACK_POP(__ctx,__callstack)                  \
     128    CF_Debug_CallStackPop (__ctx,__callstack)
    53129#else // #ifdef _DEBUG
    54130# define CF_DEBUG_CREATE_CTX()                          NULL
    55131# define CF_DEBUG_DESTROY_CTX(__ctx)
    56 # define CF_UPDATE_CTX(__ctx)
     132# define CF_DEBUG_UPDATE_CTX(__ctx)
    57133# define CF_DEBUG_PRINT(__fp,__fmt,...)
    58134# define CF_DEBUG_PRINT_BIN(__fp,__bin,__len,__fmt,...)
    … …  
    63139#endif // #ifdef _DEBUG
    64140
     141/** 디버그 컨텍스트 */
    65142typedef void *  CF_Debug_Ctx;
     143
     144/** 콜스택 데이터 */
    66145typedef struct cf_debug_callStack {
    67     char    file[NAME_LENGTH + 1];
    68     char    function[NAME_LENGTH + 1];
    69     int     line;
     146    char    file[NAME_LENGTH + 1];      /**< 파일 이름 */
     147    char    function[NAME_LENGTH + 1];  /**< 함수 이름 */
     148    int     line;                       /**< 라인 넘버 */
    70149} CF_Debug_CallStack;
    71150
    … …  
    74153#endif
    75154
     155/**
     156 * 디버그 컨텍스트를 생성
     157 *
     158 * @return 성공 시, CF_Debug_Ctx 형태의 컨텍스트; 실패 시, NULL
     159 * @see CF_DEBUG_CREATE_CTX
     160 */
    76161CF_EXPORT CF_Debug_Ctx
    77162CF_Debug_CreateCtx      (void);
    78163
     164/**
     165 * 디버그 컨텍스트를 해제
     166 *
     167 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     168 *
     169 * @param ctx 디버그 컨텍스트
     170 *
     171 * @see CF_DEBUG_DESTROY_CTX
     172 */
    79173CF_EXPORT int
    80174CF_Debug_DestroyCtx     (CF_Debug_Ctx ctx);
    81175
     176/**
     177 * 디버그 컨텍스트에 출력할 파일 디스크립터를 설정
     178 *
     179 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     180 *
     181 * @param ctx   디버그 컨텍스트
     182 * @param fd    파일 디스크립터
     183 *
     184 * @see CF_File_Open, CF_File_Create
     185 */
    82186CF_EXPORT int
    83187CF_Debug_SetOutputFD    (CF_Debug_Ctx   ctx,
    84188                         int            fd);
    85189
     190/**
     191 * 디버그 메시지를 지정된 파일 포인터로 출력
     192 *
     193 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     194 *
     195 * @param fp    파일 포인터. 표준출력(stdout) 및 표준오류(stderr) 사용 가능
     196 * @param file  파일 경로
     197 * @param func  함수 이름
     198 * @param line  라인 넘버
     199 * @param fmt   포맷 스트링
     200 * @param ...   가변 인자
     201 *
     202 * @see CF_DEBUG_PRINT
     203 */
    86204CF_EXPORT int
    87205CF_Debug_Print          (FILE       * fp,
    … …  
    91209                         const char * fmt, ...);
    92210
    93 int
     211/**
     212 * 바이너리 데이터를 디버그 메시지와 함께 지정된 파일 포인터로 출력
     213 *
     214 * @return CF_OK 반환
     215 *
     216 * @param fp    파일 포인터. 표준출력(stdout) 및 표준오류(stderr) 사용 가능
     217 * @param file  파일 경로
     218 * @param func  함수 이름
     219 * @param line  라인 넘버
     220 * @param bin   라인 넘버
     221 * @param len   바이너리 길이
     222 * @param fmt   포맷 스트링
     223 * @param ...   가변 인자
     224 *
     225 * @see CF_DEBUG_PRINT_BIN
     226 */
     227CF_EXPORT int
    94228CF_Debug_PrintBin       (FILE                   * fp,
    95229                         const char             * file,
    … …  
    100234                         const char             * fmt, ...);
    101235
    102 CF_EXPORT int
    103 CF_Debug_UpdateCtx      (CF_Debug_Ctx   ctx,
    104                          const char     * file,
    105                          const char     * func,
    106                          const int      line);
    107 
     236/**
     237 * 컨텍스트를 업데이트하고 디버그 메시지를 출력
     238 *
     239 * @return CF_OK 반환
     240 *
     241 * @param ctx   디버그 컨텍스트
     242 * @param fmt   포맷 스트링
     243 * @param ...   가변 인자
     244 *
     245 * @see CF_DEBUG_UPDATE_CTX, CF_Debug_Trace
     246 */
    108247CF_EXPORT int
    109248CF_Debug_Trace          (CF_Debug_Ctx   ctx,
    110249                         const char     * fmt, ...);
    111250
     251/**
     252 * 컨텍스트를 업데이트하고 바이너리 데이터를 디버그 메시지와 함께 출력
     253 *
     254 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     255 *
     256 * @param ctx   디버그 컨텍스트
     257 * @param bin   바이너리 데이터
     258 * @param len   바이너리 길이
     259 * @param fmt   포맷 스트링
     260 * @param ...   가변 인자
     261 *
     262 * @see CF_DEBUG_UPDATE_CTX, CF_DEBUG_TRACE_BIN
     263 */
    112264CF_EXPORT int
    113265CF_Debug_TraceBin       (CF_Debug_Ctx           ctx,
    … …  
    116268                         const char             * fmt, ...);
    117269
     270/**
     271 * 컨텍스트에 콜스택 푸시
     272 *
     273 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     274 *
     275 * @param ctx   디버그 컨텍스트
     276 * @param file  파일 경로
     277 * @param func  함수 이름
     278 * @param line  라인 넘버
     279 *
     280 * @see CF_DEBUG_CALLSTACK_PUSH
     281 */
    118282CF_EXPORT int
    119283CF_Debug_CallStackPush  (CF_Debug_Ctx   ctx,
    … …  
    122286                         const int      line);
    123287
     288/**
     289 * 컨텍스트에서 콜스택 팝
     290 *
     291 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     292 *
     293 * @param ctx       디버그 컨텍스트
     294 * @param callstack 콜스택 정보를 가져올 콜스택 데이터 구조체 포인터
     295 *
     296 * @see CF_Debug_CallStackPop, CF_Debug_CallStack
     297 */
    124298CF_EXPORT int
    125299CF_Debug_CallStackPop   (CF_Debug_Ctx       ctx,

  • trunk/include/cf_file.h

    r17 r26  
    11/**
    2  * cf_file.h
     2 * @file    cf_file.h
     3 * @author  myusgun <myusgun@gmail.com>
     4 * @version 0.1
    35 */
    46#ifndef __CF_FILE_H__
    … …  
    1618#define CF_ERROR_FILE_GET_SIZE          CF_ERROR_FILE - 7
    1719
    18 typedef enum{
    19     CF_FILE_RO = O_RDONLY,
    20     CF_FILE_WO = O_WRONLY,
    21     CF_FILE_WR = O_RDWR,
    22     CF_FILE_CR = O_CREAT,
    23     CF_FILE_TR = O_TRUNC,
    24     CF_FILE_AP = O_APPEND
     20/** 파일 열기 옵션 플래그 */
     21typedef enum {
     22    CF_FILE_RO = O_RDONLY,  /**< 읽기 전용 */
     23    CF_FILE_WO = O_WRONLY,  /**< 쓰기 전용 */
     24    CF_FILE_WR = O_RDWR,    /**< 읽기/쓰기 */
     25    CF_FILE_CR = O_CREAT,   /**< 파일이 존재하지 않으면 생성 */
     26    CF_FILE_TR = O_TRUNC,   /**< 파일이 존재하면 비우기 */
     27    CF_FILE_AP = O_APPEND   /**< 파일이 존재하면 이어서 쓰기 */
    2528} E_CF_FILE_FLAG, CF_FILE_FLAG;
    2629
    … …  
    2932#endif
    3033
     34/**
     35 * 파일 열기
     36 *
     37 * @return 성공 시, 파일 디스크립터; 실패 시, 오류 코드
     38 *
     39 * @param path  파일 경로
     40 * @param flag  파일 열기 플래그
     41 *
     42 * @see CF_FILE_FLAG
     43 */
    3144CF_EXPORT int
    3245CF_File_Open            (const char         * path,
    3346                         const CF_FILE_FLAG flag);
    3447
     48/**
     49 * 파일 닫기
     50 *
     51 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     52 *
     53 * @param fd 파일 디스크립터
     54 */
    3555CF_EXPORT int
    36 CF_File_Close           (const int  fd);
     56CF_File_Close           (const int fd);
    3757
     58/**
     59 * 파일 생성
     60 *
     61 * @return 성공 시, 파일 디스크립터; 실패 시, 오류 코드
     62 *
     63 * @param path  파일 경로
     64 */
    3865CF_EXPORT int
    3966CF_File_Create          (const char * path);
    4067
     68/**
     69 * 파일 읽기
     70 *
     71 * @return 성공 시, 읽은 바이트 수; 실패 시, 오류 코드
     72 *
     73 * @param fd    파일 디스크립터
     74 * @param buf   데이터를 저장할 메모리
     75 * @param len   데이터를 저장할 메모리의 크기
     76 */
    4177CF_EXPORT int
    4278CF_File_Read            (const int      fd,
    … …  
    4480                         const size_t   len);
    4581
     82/**
     83 * 파일 쓰기
     84 *
     85 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     86 *
     87 * @param fd    파일 디스크립터
     88 * @param buf   데이터가 저장된 메모리
     89 * @param len   쓸 데이터의 길이
     90 */
    4691CF_EXPORT int
    4792CF_File_Write           (const int      fd,
    … …  
    4994                         const size_t   len);
    5095
     96/**
     97 * 파일 크기 얻기
     98 *
     99 * @return 성공 시, 파일 크기; 실패 시, 오류 코드
     100 *
     101 * @param fd    파일 디스크립터
     102 */
    51103CF_EXPORT int
    52104CF_File_GetSize         (const int fd);

  • trunk/include/cf_log.h

    r23 r26  
    11/**
    2  * cf_log.h
     2 * @file    cf_log.h
     3 * @author  myusgun <myusgun@gmail.com>
     4 * @version 0.1
    35 */
    46#ifndef __CF_LOG_H__
    … …  
    1921#define CF_ERROR_LOG_NOT_INITIALIZE     CF_ERROR_LOG - 11
    2022
     23/**
     24 * 로그의 버퍼 크기를 기본 값으로 설정
     25 *
     26 * @see CF_Log_CreateCtx, CF_LOG_OPEN
     27 */
    2128#define CF_LOG_BUFFER_DEFAULT           -1
     29
     30/** 로그 기록 시 버퍼를 사용하지 않고 즉시 기록
     31 *
     32 * @see CF_Log_CreateCtx, CF_LOG_OPEN, CF_Log_Initialize
     33 */
    2234#define CF_LOG_BUFFER_NO                0
    2335
     36/**
     37 * 로그에 아이디 넘버를 부여하여 생성 <br />
     38 * 로그 기록 시, 아이디 넘버를 사용하면 해당 로그로 기록할 수 있음
     39 *
     40 * @param __id      부여할 아이디 넘버
     41 * @param __file    로그 파일 경로
     42 * @param __memsize 로그 버퍼 크기
     43 *
     44 * @see CF_Log_MapCtxID
     45 */
    2446#define CF_LOG_OPEN(__id,__file,__memsize)              \
    2547    CF_Log_MapCtxID (__id, CF_Log_CreateCtx (__file, __memsize))
    2648
     49/**
     50 * 아이디 넘버에 해당하는 로그에 쓰기
     51 *
     52 * @param __id  로그의 아이디 넘버
     53 * @param __pf  로그의 프리픽스 문자열
     54 * @param __fmt 포맷 스트링
     55 * @param ...   가변 인자
     56 *
     57 * @see CF_Log_GetMappedCtx
     58 */
    2759#define CF_LOG_WRITE(__id,__pf,__fmt,...)               \
    2860    CF_Log_Write (CF_Log_GetMappedCtx (__id),__pf,__fmt,##__VA_ARGS__)
    2961
    30 #define CF_LOG_CLOSE    CF_Log_UnmapCtxID
    31 
     62/**
     63 * 아이디 넘버에 해당하는 로그를 닫고 해제
     64 *
     65 * @param __id 로그의 아이디 넘버
     66 *
     67 * @see CF_Log_UnmapCtxID
     68 */
     69#define CF_LOG_CLOSE(__id)      CF_Log_UnmapCtxID (__id)
     70
     71/** 로그 컨텍스트 */
    3272typedef void *  CF_Log_Ctx;
    3373
    … …  
    3676#endif
    3777
     78/**
     79 * 로그를 사용하기 위해 초기화
     80 *
     81 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     82 *
     83 * @param logPool 아이디 넘버 최대 값
     84 */
    3885CF_EXPORT int
    3986CF_Log_Initialize       (const int logPool);
    4087
     88/**
     89 * 로그가 모두 사용된 후 자원 해제
     90 *
     91 * @return CF_OK 반환
     92 */
    4193CF_EXPORT int
    4294CF_Log_Finalize         (void);
    4395
     96/**
     97 * 로그 컨텍스트 생성
     98 *
     99 * @return 성공 시, 로그 컨텍스트; 실패 시, NULL
     100 *
     101 * @param path      로그 파일 경로
     102 * @param memsize   로그 버퍼 크기
     103 *
     104 * @see CF_LOG_BUFFER_DEFAULT, CF_LOG_BUFFER_NO
     105 */
    44106CF_EXPORT CF_Log_Ctx
    45107CF_Log_CreateCtx        (const char * path,
    46108                         const int  memsize);
    47109
     110/**
     111 * 로그 컨텍스트 해제
     112 *
     113 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     114 *
     115 * @param ctx 로그 컨텍스트
     116 */
    48117CF_EXPORT int
    49118CF_Log_DestroyCtx       (CF_Log_Ctx ctx);
    50119
     120/**
     121 * 로그 컨텍스트에 멀티쓰레드 모드 설정
     122 *
     123 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     124 *
     125 * @param ctx 로그 컨텍스트
     126 */
    51127CF_EXPORT int
    52128CF_Log_SetMultiThread   (CF_Log_Ctx ctx);
    53129
     130/**
     131 * 로그 컨텍스트에 멀티쓰레드 모드 설정 해제
     132 *
     133 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     134 *
     135 * @param ctx 로그 컨텍스트
     136 */
    54137CF_EXPORT int
    55138CF_Log_UnsetMultiThread (CF_Log_Ctx ctx);
    56139
     140/**
     141 * 로그 컨텍스트에 따라 로그 쓰기
     142 *
     143 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     144 *
     145 * @param ctx       로그 컨텍스트
     146 * @param prefix    로그의 프리픽스 문자열
     147 * @param fmt       포맷 스트링
     148 * @param ...       가변 인자
     149 */
    57150CF_EXPORT int
    58151CF_Log_Write            (CF_Log_Ctx ctx,
    … …  
    60153                         const char * fmt, ...);
    61154
     155/**
     156 * 로그 버퍼의 데이터를 즉시 로그 파일에 쓰기
     157 *
     158 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     159 *
     160 * @param ctx 로그 컨텍스트
     161 */
    62162CF_EXPORT int
    63163CF_Log_Flush            (CF_Log_Ctx ctx);
    64164
     165/**
     166 * 로그 컨텍스트에 아이디 넘버 할당<br />
     167 * 로그 기록 시, 아이디 넘버를 사용하면 해당 로그로 기록할 수 있음
     168 *
     169 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     170 *
     171 * @param mapid 부여할 아이디 넘버
     172 * @param ctx   로그 컨텍스트
     173 *
     174 * @remark 반드시 먼저 초기화 해야하며, 초기화 시에 주어진 번호보다 작은 아이디 넘버를 사용해야 함
     175 *
     176 * @see CF_LOG_OPEN, CF_Log_CreateCtx
     177 */
    65178CF_EXPORT int
    66179CF_Log_MapCtxID         (const int          mapid,
    67180                         const CF_Log_Ctx   ctx);
    68181
     182/**
     183 * 아이디 넘버에 해당하는 로그를 닫고 해당하는 컨텍스트를 해제
     184 *
     185 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     186 *
     187 * @param mapid 로그의 아이디 넘버
     188 *
     189 * @remark 아이디 넘버에 해당하는 컨텍스트가 해제되므로 주의
     190 *
     191 * @see CF_LOG_CLOSE, CF_Log_DestroyCtx
     192 */
    69193CF_EXPORT int
    70194CF_Log_UnmapCtxID       (const int mapid);
    71195
     196/**
     197 * 아이디 넘버에 해당하는 로그 컨텍스트를 얻기
     198 *
     199 * @return 성공 시, 로그 컨텍스트; 실패 시, NULL
     200 *
     201 * @param mapid 로그의 아이디 넘버
     202 */
    72203CF_EXPORT CF_Log_Ctx
    73204CF_Log_GetMappedCtx     (const int mapid);

  • trunk/include/cf_socket.h

    r21 r26  
    11/**
    2  * cf_socket.h
     2 * @file    cf_socket.h
     3 * @author  myusgun <myusgun@gmail.com>
     4 * @version 0.1
     5
     6 * @remark TCP 소켓만 지원됨
    37 */
    48#ifndef __CF_SOCKET_H__
    … …  
    4448#endif
    4549
     50/**
     51 * 소켓이 초기화 상태 확인
     52 *
     53 * @return 초기화 된 경우, CF_TRUE; 그렇지 않은 경우, CF_FALSE
     54 */
    4655CF_EXPORT CF_BOOL
    4756CF_Socket_IsInitialized (void);
    4857
     58/**
     59 * 소켓 초기화
     60 *
     61 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     62 */
    4963CF_EXPORT int
    5064CF_Socket_Initialize    (void);
    5165
     66/**
     67 * 소켓 해제
     68 *
     69 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     70 */
    5271CF_EXPORT int
    5372CF_Socket_Finalize      (void);
    5473
     74/**
     75 * 소켓 닫기
     76 *
     77 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     78 *
     79 * @param sock 소켓
     80 */
    5581CF_EXPORT int
    5682CF_Socket_Close         (const int sock);
    5783
     84/**
     85 * 소켓 옵션 설정
     86 *
     87 * @return 성공 시 CF_OK; 실패 시, 오류 코드
     88 *
     89 * @param sock      소켓
     90 * @param optname   옵션 이름
     91 * @param optval    설정할 옵션 값의 메모리
     92 * @param optlen    설정할 옵션의 길이
     93 */
    5894CF_EXPORT int
    5995CF_Socket_SetOption     (const int      sock,
    … …  
    6298                         const size_t   optlen);
    6399
     100/**
     101 * 소켓 옵션 얻기
     102 *
     103 * @return 성공 시 CF_OK; 실패 시, 오류 코드
     104 *
     105 * @param sock      소켓
     106 * @param optname   옵션 이름
     107 * @param optval    옵션 값을 가져올 메모리
     108 * @param optlen    옵션 길이를 가져올 메모리
     109 */
    64110CF_EXPORT int
    65111CF_Socket_GetOption     (const int  sock,
    … …  
    68114                         size_t     * optlen);
    69115
     116/**
     117 * 소켓에 타임아웃 설정
     118 *
     119 * @return 성공 시 CF_OK; 실패 시, 오류 코드
     120 *
     121 * @param sock      소켓
     122 * @param timeout   타임아웃(sec)
     123 */
    70124CF_EXPORT int
    71125CF_Socket_SetTimeout    (const int  sock,
    72126                         const int  timeout);
    73127
     128/**
     129 * 소켓 연결
     130 *
     131 * @return 성공 시, 연결된 소켓; 실패 시, 오류 코드
     132 *
     133 * @param ip    연결할 호스트의 주소 (도메인 이름 가능)
     134 * @param port  연결할 호스트의 포트번호
     135 */
    74136CF_EXPORT int
    75137CF_Socket_Connect       (const char             * ip,
    76138                         const unsigned short   port);
    77139
     140/**
     141 * 서버 열기
     142 *
     143 * @return 성공 시, 서버 소켓; 실패 시, 오류 코드
     144 *
     145 * @param port      서버 포트
     146 * @param backlog   listen 시의 backlog 수
     147 */
    78148CF_EXPORT int
    79149CF_Socket_Server        (const unsigned short   port,
    80150                         const int              backlog);
    81151
     152/**
     153 * 소켓 연결
     154 *
     155 * @return 성공 시, 연결된 소켓; 실패 시, 오류 코드
     156 *
     157 * @param sock      서버 소켓
     158 * @param address   [옵션] 클라이언트 정보를 담을 sockaddr_in 구조체 포인터
     159 */
    82160CF_EXPORT int
    83161CF_Socket_Accept        (const int          sock,
    84162                         struct sockaddr_in * address);
    85163
     164/**
     165 * 데이터 송신
     166 *
     167 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     168 *
     169 * @param sock  소켓
     170 * @param buf   송신할 데이터
     171 * @param len   송신할 데이터의 길이
     172 */
    86173CF_EXPORT int
    87174CF_Socket_Send          (const int  sock,
    … …  
    89176                         const int  len);
    90177
     178/**
     179 * 데이터 수신
     180 *
     181 * @return 성공 시, 수신한 데이터의 길이; 실패 시, 오류 코드
     182 *
     183 * @param sock  소켓
     184 * @param buf   데이터를 수신할 버퍼
     185 * @param len   데이터를 수신할 버퍼의 최대 크기
     186 */
    91187CF_EXPORT int
    92188CF_Socket_Recv          (const int  sock,

  • trunk/include/cf_thread.h

    r6 r26  
    11/**
    2  * cf_thread.h
     2 * @file    cf_thread.h
     3 * @author  myusgun <myusgun@gmail.com>
     4 * @version 0.1
     5 *
     6 * @remark 멀티스레드 및 뮤텍스 지원
    37 */
    48#ifndef __CF_THREAD_H__
    … …  
    1418
    1519#ifdef _WIN32
    16 //# include <stddef.h>
    17 # define CF_THREAD_RETURN   unsigned int
    18 # define CF_THREAD_CALL     __stdcall
     20# define CF_THREAD_RETURN   unsigned int    /**< 스레드 워커 함수 반환 형 */
     21# define CF_THREAD_CALL     __stdcall       /**< 스레드 워커 함수 호출 규약 */
    1922#else // #ifdef _WIN32
    20 # define CF_THREAD_RETURN   void *
    21 # define CF_THREAD_CALL
     23# define CF_THREAD_RETURN   void *          /**< 스레드 워커 함수 반환 형 */
     24# define CF_THREAD_CALL                     /**< 스레드 워커 함수 호출 규약 */
    2225#endif // #ifdef _WIN32
    2326
     27/** 스레드 워커 함수 형태이며, CF_Thread_Function 형식 */
    2428typedef CF_THREAD_RETURN  (CF_THREAD_CALL * CF_Thread_Function) (void *);
    2529
     30/** 스레드 아이디 */
    2631typedef void *  CF_Thread;
     32
     33/** 뮤텍스 아이디 */
    2734typedef void *  CF_Mutex;
    2835
    … …  
    3138#endif
    3239
     40/**
     41 * 스레드를 생성
     42 *
     43 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     44 *
     45 * @param threadID  스레드 아이디 주소
     46 * @param callback  스레드 워커 함수 이름
     47 * @param arg       스레드 함수로 전달할 인자
     48 *
     49 * @code
     50
     51#include "cf_thread.h"
     52
     53CF_Mutex globalMutex;
     54
     55CF_THREAD_RETURN CF_THREAD_CALL worker (void * arg) {
     56    if (CF_Mutex_Create (&globalMutex) < 0) {
     57        // error
     58    }
     59
     60    if (CF_Mutex_Lock (&globalMutex) < 0) { // for critical section
     61        // error
     62    }
     63
     64    // critical section
     65
     66    if (CF_Mutex_Unlock (&globalMutex) < 0) { // for critical section
     67        // error
     68    }
     69
     70    if (CF_Mutex_Destory (&globalMutex) < 0) {
     71        // error
     72    }
     73}
     74
     75int main (void) {
     76    CF_Thread tid;
     77    if (CF_Thread_Craete (&tid, worker, NULL) < 0) {
     78        // error
     79    }
     80
     81    if (CF_Thread_Join (&tid) < 0) { // block
     82        // error
     83    }
     84
     85    if (CF_Thread_Release (&tid) < 0) {
     86        // error
     87    }
     88}
     89
     90 * @endcode
     91 */
    3392CF_EXPORT int
    3493CF_Thread_Create    (CF_Thread          * threadID,
    … …  
    3695                     void               * arg);
    3796
     97/**
     98 * 스레드 아이디를 해제
     99 *
     100 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     101 *
     102 * @param threadID 스레드 아이디 주소
     103 *
     104 * @remark 스레드 아이디를 해제하는 것이며 워커 스레드가 종료되지 않음
     105 */
    38106CF_EXPORT int
    39107CF_Thread_Release   (CF_Thread * threadID);
    40108
     109/**
     110 * 스레드가 종료될 때 까지 대기
     111 *
     112 * @return CF_OK 반환
     113 *
     114 * @param threadID 스레드 아이디 주소
     115 */
    41116CF_EXPORT int
    42117CF_Thread_Join      (CF_Thread * threadID);
    43118
     119/**
     120 * 뮤텍스 생성
     121 *
     122 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     123 *
     124 * @param mutex 뮤텍스 아이디 주소
     125 *
     126 * @see CF_Thread_Craete
     127 */
    44128CF_EXPORT int
    45129CF_Mutex_Create     (CF_Mutex * mutex);
    46130
     131/**
     132 * 뮤텍스 해제
     133 *
     134 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     135 *
     136 * @param mutex 뮤텍스 아이디 주소
     137 */
    47138CF_EXPORT int
    48139CF_Mutex_Destory    (CF_Mutex * mutex);
    49140
     141/**
     142 * 뮤텍스 잠금
     143 *
     144 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     145 *
     146 * @param mutex 뮤텍스 아이디 주소
     147 */
    50148CF_EXPORT int
    51149CF_Mutex_Lock       (CF_Mutex * mutex);
    52150
     151/**
     152 * 뮤텍스 잠금 해제
     153 *
     154 * @return 성공 시, CF_OK; 실패 시, 오류 코드
     155 *
     156 * @param mutex 뮤텍스 아이디 주소
     157 */
    53158CF_EXPORT int
    54159CF_Mutex_Unlock     (CF_Mutex * mutex);

  • trunk/src/cf_debug.c

    r23 r26  
    4646    CF_DEBUG_CALLSTACK  callstack;
    4747} S_CF_DEBUG_CTX, CF_DEBUG_CTX;
     48
     49static int
     50CF_Debug_Local_UpdateCtx (CF_Debug_Ctx  ctx,
     51                          const char    * file,
     52                          const char    * func,
     53                          const int     line)
     54{
     55    CF_DEBUG_CTX * context = (CF_DEBUG_CTX *) ctx;
     56
     57    CHECK_INVALID_CTX (ctx);
     58
     59    strncpy (context->file, file, strlen (file));
     60    strncpy (context->func, func, strlen (func));
     61    context->line = line;
     62
     63    return CF_OK;
     64}
    4865
    4966static int
    … …  
    205222
    206223int
    207 CF_Debug_UpdateCtx (CF_Debug_Ctx    ctx,
    208                     const char      * file,
    209                     const char      * func,
    210                     const int       line)
    211 {
    212     CF_DEBUG_CTX * context = (CF_DEBUG_CTX *) ctx;
    213 
    214     CHECK_INVALID_CTX (ctx);
    215 
    216     strncpy (context->file, file, strlen (file));
    217     strncpy (context->func, func, strlen (func));
    218     context->line = line;
    219 
    220     return CF_OK;
    221 }
    222 
    223 int
    224224CF_Debug_Trace (CF_Debug_Ctx    ctx,
     225                const char      * file,
     226                const char      * func,
     227                const int       line,
    225228                const char      * fmt, ...)
    226229{
    … …  
    229232
    230233    CHECK_INVALID_CTX (ctx);
     234
     235    CF_Debug_Local_UpdateCtx (ctx, file, func, line);
    231236
    232237    va_start (valist, fmt);
    … …  
    243248int
    244249CF_Debug_TraceBin (CF_Debug_Ctx         ctx,
     250                   const char           * file,
     251                   const char           * func,
     252                   const int            line,
    245253                   const unsigned char  * bin,
    246254                   const int            len,
    … …  
    251259 
    252260    CHECK_INVALID_CTX (ctx);
     261
     262    CF_Debug_Local_UpdateCtx (ctx, file, func, line);
    253263
    254264    va_start (valist, fmt);
    … …  
    291301    context->callstack.caller = push;
    292302
    293     CF_Debug_UpdateCtx (ctx, file, func, line);
     303    CF_Debug_Local_UpdateCtx (ctx, file, func, line);
    294304
    295305    return CF_OK;
    … …  
    323333    if (pop->caller != NULL)
    324334    {
    325         CF_Debug_UpdateCtx (ctx,
    326                             pop->caller->file,
    327                             pop->caller->func,
    328                             pop->caller->line);
     335        CF_Debug_Local_UpdateCtx (ctx,
     336                                  pop->caller->file,
     337                                  pop->caller->func,
     338                                  pop->caller->line);
    329339    }
    330340

  • trunk/src/cf_file.c

    r16 r26  
    2020#else // #ifdef _WIN32
    2121# include <unistd.h>
     22# define O_BINARY       0x00000000
    2223#endif // #ifdef _WIN32
    2324
    … …  
    2829              const CF_FILE_FLAG    flag)
    2930{
    30     int result = open (path, flag);
     31    int result = open (path, flag|O_BINARY);
    3132
    3233    if (result < 0)
    … …  
    7374        return CF_ERROR_FILE_READ;
    7475
    75     return CF_OK;
     76    return result;
    7677}
    7778

  • trunk/src/cf_log.c

    r25 r26  
    191191        gLogEnvironment.ctxPool =
    192192            (CF_Log_Ctx *) calloc ((size_t) logPool, sizeof (CF_Log_Ctx));
     193        if (gLogEnvironment.ctxPool == NULL)
     194            return CF_ERROR_LOG_INITIALIZE;
    193195        gLogEnvironment.ctxSize = logPool;
    194196    }
Note: See TracChangeset for help on using the changeset viewer.