

#ifndef library_h
#define library_h
                                                            

//[2006.09.14.목][완료!!!]
unsigned long long __fastcall ENDIAN_LittleToBig_8(unsigned long long  pLITTLEendian);

//[2006.09.14.목][완료!!!]
unsigned long long __fastcall ENDIAN_BigToLittle_8(unsigned long long  pBIGendian);

//[2006.09.13.수][완료!!!]
unsigned int __fastcall ENDIAN_LittleToBig_4(unsigned int  pLITTLEendian);

//[2006.09.13.수][완료!!!]
unsigned int __fastcall ENDIAN_BigToLittle_4(unsigned int  pBIGendian);

//[2006.09.14.목][완료!!!]
unsigned short __fastcall ENDIAN_LittleToBig_2(unsigned short  pLITTLEendian);

//[2006.09.14.목][완료!!!]
unsigned short __fastcall ENDIAN_BigToLittle_2(unsigned short  pBIGendian);

//[2009.01.22.목][완료!!!]
void __fastcall Endian_Change_HexStr(char  *pHexStr,
                                     char  *rEndianChangedHexStr);

                                     
//[문자열 처리관련]-------------------------------------------------------------

int __fastcall STR_Length(char *pSTR);

bool __fastcall STR_Match(char *pA,
                          char *pB);

//[2012.05.31.목][완료!!!]
bool __fastcall Str_Match2(//[문자열A]{-----------------------
                           //기준 문자열.
                           char  *pA_,
                           //[문자열B]------------------------
                           //비교할 문자열시작위치.
                           char  *pB_,
                           //비교할 길이.
                           int    pB_Length
                           //}--------------------------------
                          );

//[2012.07.21.토][완료!!!]
bool __fastcall Str_Match2_NoCase(//[문자열A]{-------------
                                  //기준 문자열.
                                  char  *pA_,
                                  //[문자열B]--------------
                                  //비교할 문자열시작위치.
                                  char  *pB_,
                                  //비교할 길이.
                                  int    pB_Length
                                  //}----------------------
                                 );

bool __fastcall STR_Match_NoCase(char *pA,
                                 char *pB);

//[2012.05.29.화][완료!!!]
bool __fastcall Str_Match_Part(//비교할 문자열(대상).
                               char  *pStr_,
                               //비교할부분 문자열(기준).
                               char  *pPart_);

//[2012.07.21.토][완료!!!]
bool __fastcall Str_Match_Part_NoCase(//비교할 문자열(대상).
                                      char  *pStr_,
                                      //비교할부분 문자열(기준).
                                      char  *pPart_);

//[2010.07.07.수][완료!!!]
int __fastcall STR_Assign(char  pMEM[],
                          char *pSTR);

//[2011.10.07.금][완료!!!]
int __fastcall STR_Assign2(char  pBuf[],
                           //저장소크기.
                           //[2011.10.07.금][수정!!!]
                           //이제까지 <char> 로 되있던 것을 <int> 로 바꾼다.
                           //<맷돌C> 용 API 를 만들던중 발견하고 수정한다.
                           int   pBufSize,
                           char *pStr);

void __fastcall STR_Add_AB(char  pMEM[],
                           char *pA,
                           char *pB);

//[2011.05.10.화][완료!!!]
int __fastcall STR_Add(char  pMEM[],
                       char *pSTR);

int __fastcall STR_Pos(char  pMEM[],
                       int   pSTARTpos,
                       char  pCHAR);

void __fastcall STR_SubString(char *pSTR,
                              int   pSTARTindex,
                              int   pLENGTH,
                              char  pSUBstr[]);

//[2009.11.18.수][완료!!!]
void __fastcall STR_GetWord(char  *pSTR,
                            char   pTOKEN,
                            int    pWORDindex,
                            char   pWORD[]);

//[2009.10.04.일][완료!!!]
int __fastcall STR_NowIndexMoonja_Is_Hangul(//대상 문자열.
                                            char  *pStr,
                                            //검사할 문자 위치.
                                            int    pIndex);

//[2011.06.28.화][완료!!!]
//[2018.10.21.일][완료!!!]
//[한글/영문] 을 구분하여 처리한다.
int __fastcall STR_SetLength(char  *pSTR,
                             int    pSTRlength,
                             //[2018.10.21.일][수정!!!]{------------------------------------
                             //<pFILLchar : '\0'> 인 경우는 <pSTRlength> 가 <pSTR> 길이보다
                             //긴 경우라도 [문자열:끝] 에서 바로 종료.
                             char   pFILLchar,
                             //}------------------------------------------------------------
                             char  *pRETURNstr);

//[2023.01.29.일][완료]
char __fastcall STR_WordLastChar(char  *pWord);

//[2011.05.24.화][완료!!!]
void __fastcall STR_LastCharChange(char  *pStr,
                                   //바꿀 문자.
                                   char   pMoonja);

//[2007.03.29.목][완료!!!]
int __fastcall STR_Get_LineCount(char  *pSTR);

//[2018.05.06.일][완료!!!]
int __fastcall STR_Get_Moonja_Count(//검사 대상 문자열.
                                    char   pStrBuf[],
                                    //검사할 문자.
                                    char   pMoonja,
                                    //검사 시작 위치.
                                    int    pStartIndex,
                                    //검사 끝 위치.
                                    int    pEndIndex);

//[2007.02.14.수][완료!!!]
int __fastcall STR_Get_CRLF_Count_withStartEndIndex(char   pSTRbuf[],
                                                    int    pSTARTindex,
                                                    int    pENDindex);
//[2010.06.28.월][완료!!!]
int __fastcall STR_Cut_CRLF(char  *pStr,
                            char  *rCutStr,
                            //문자열 길이를 강제 설정(0이면 사용하지 않음).
                            int    pSetLength,
                            //true:원본을 직접 수정, false:문자열 반환.
                            bool   pSelf);

//[2019.03.08.금][완료]
void Str_CRLF_Complete(char **prBuf,
                       int   *prSize);


//[2009.02.18.수][완료!!!]
int __fastcall STR_Get_LineNumber_withIndex(char  *pStrBuf,
                                            int    pIndex);


//[2006.12.24.일][완료!!!]
void __fastcall STR_Get_LineStartIndex(char  *pSTR,
                                       int    pLINEnumber,
                                       int   *rLINEstartINDEX);

//[2006.12.25.월][완료!!!]
void __fastcall STR_Get_BeforeLineStartIndex(char  *pSTR,
                                             int    pINDEX,
                                             int   *rLINEstartINDEX);

//[2011.05.10.화][완료!!!]
bool __fastcall STR_Get_NextLineStartIndex(char  *pSTR,
                                           int    pINDEX,
                                           int   *rLINEstartINDEX);

//[2011.05.01.일][완료!!!]
int __fastcall STR_Get_ThisLineStartIndex(char  *pSTR,
                                          int    pINDEX,
                                          int   *rLINEstartINDEX);

//[2006.12.26.화][완료!!!]
void __fastcall STR_Get_ThisLineEndIndex(char  *pSTR,
                                         int    pINDEX,
                                         int   *rLINEendINDEX);

//[2007.11.20.화][완료!!!]
int __fastcall STR_Get_LineStr_withLineNumber(char  *pStr,
                                              int    pLineNumber,
                                              char  *rLineStr);

//[2010.12.08.수][완료!!!]
int __fastcall STR_Get_LineToLineStr(char  *pStr,
                                     int    pStartLineNum,
                                     int    pEndLineNum,
                                     char  *rStr);

//[2012.08.11.토][완료!!!]
int __fastcall STR_Get_LineWord_withSpace(char  *pLineStr,
                                          //단어 순번(BASE : 0)
                                          int    pWordIndex,
                                          //추출한 단어 반환.
                                          char  *rWord);

//[2010.12.16.목][완료!!!]
int __fastcall STR_Search_MatchWord_inLineStr(char  *pLineStr,
                                              //검사할 단어.
                                              char  *pWord,
                                              //[대/소 문자 구분] 을 하지 않는다면 true.
                                              bool   pNoCase);

//[2012.08.11.토][완료!!!]
int __fastcall STR_Search_MatchWord_inLineStr2(char  *pLineStr,
                                               //검사할 단어.
                                               char  *pWord,
                                               //[대/소 문자 구분] 을 하지 않는다면 true.
                                               bool   pNoCase,
                                               //[2012.08.11.토][추가]
                                               //[단어시작위치] 반환(NULL 이 아닌경우만).
                                               //[단어] 가 추출되지 않은 경우는 <-1>.
                                               int   *rWordStartIndex);

//[2011.10.17.월][완료!!!]
void __fastcall STR_Search_LineStr_knowLineCount(char  *pStr,
                                                 //문서의 총 줄수.
                                                 //[2011.10.17.월][수정!!!]
                                                 //0 인 경우는 내부적으로 행수를 구한다.
                                                 int    pLineCount,
                                                 //찾을 행 문자열.
                                                 char  *pSearchLineStr,
                                                 //행번호(BASE : 0).
                                                 int   *rLineNumber);

//[2022.04.17.일][완료]
void __fastcall STR_Search_LineStr_knowLineCount2(char  *pStr,
                                                  //문서의 총 줄수(0 인 경우는 내부적으로 행수를 구한다).
                                                  int    pLineCount,
                                                  //찾을 행 문자열.
                                                  char  *pSearchLineStr,
                                                  //[대/소 문자 구분] 을 하지 않는다면 true.
                                                  bool   pNoCase,
                                                  //행번호(BASE : 0).
                                                  int   *rLineNumber);

//[2011.10.17.월][완료!!!]
void __fastcall STR_Search_Word(char  *pStr,
                                //문서의 총 행수.
                                //[2011.10.17.월][수정!!!]
                                //0 인 경우는 내부적으로 행수를 구한다.
                                int    pLineCount,
                                //검사를 시작할 행번호,
                                int    pStartLineNumber,
                                //단어 순번 지정(이 순번의 단어만 찾는다).
                                int    pWordIndex,
                                //대소문자구분여부(true : 대/소문자 구분).
                                bool   pWordCase,
                                //찾을 단어.
                                char  *pSearchWord,
                                //찾은 행 번호
                                int   *rLineNumber);

//[2009.01.15.목][완료!!!]
void __fastcall STR_GetLineWordBuf(//문서가 저장되 있는 저장소 위치.
                                   char   *pBuf,
                                   //처리할 행의 시작 위치(BASE : 0).
                                   int     pLineStartIndex,
                                   //현재 행에서 추출할 단어의 순번(BASE : 0).
                                   int     pWordOrderIndex,
                                   //추출한 단어의 [저장소] 상의 위치(BASE : 0).
                                   int    *rWordIndex,
                                   //추출한 단어(반드시 크기가 있는 저장소).
                                   char    rWord[]);

//[2012.07.01.일][완료!!!]
//[2019.02.22.금][완료]
int __fastcall STR_Get_ThisLineStr(//문서가 저장되 있는 저장소 위치.
                                   char  *pBuf_,
                                   //현재 buf[] 상의 index 값(현재 위치).
                                   int    pThisIndex,
                                   //추출한 행 문자열(반드시 크기가 있는 저장소).
                                   //[2019.02.22.금][중요수정]
                                   //NULL 인 경우는 내부적으로 [길이] 만 반환한다.
                                   char  *rLineStr_);

//[2009.03.31.화][완료!!!]
int __fastcall STR_Get_ThisLinePreSpaceCount(//문서가 저장되 있는 저장소 위치.
                                             char   *pBuf,
                                             //현재 buf[] 상의 index 값(현재 위치).
                                             int     pThisIndex);

//[2012.03.02.금][완료!!!]
int __fastcall Str_Get_LinePreSpaceCount_Min(//문서가 저장돼 있는 저장소.
                                             char   *pBuf,
                                             //검사 시작 위치(시작행).
                                             int     pStartIndex,
                                             //검사 끝 위치(끝행).
                                             int     pEndIndex,
                                             //[2012.02.02.목][추가!!!]
                                             //내용이 없고 <CRLF> 만 존재하는 행은 무시.
                                             //true  : 내용이 없는 행은 대상으로 하지 않는다.
                                             //false : 내용이 없는 행도 처리 대상으로 한다.
                                             bool    pNullLinePass);

//[2021.07.24.토][완료]
int __fastcall Str_Get_ThisLinePostSpaceCount(//문서가 저장돼 있는 저장소 위치.
                                              char   *pBuf,
                                              //현재 buf[] 상의 index 값(현재 위치).
                                              int     pThisIndex);

//[2009.05.07.목][완료!!!]
void __fastcall STR_Get_WordBound(//검사할 [저장소].
                                  char  *pStrBuf,
                                  //[저장소] 문자열 전체 길이(-1 인경우는 함수내부적으로 구해야한다).
                                  int    pStrBufSize,
                                  //현재 위치.
                                  int    pIndex,
                                  //단어 시작 위치.
                                  int   *rWordStartIndex,
                                  //단어 끝 위치.
                                  int   *rWordEndIndex);

//[2012.04.15.일][완료!!!]
int __fastcall Str_Get_WordBoundStart(//검사할 [저장소].
                                      char  *pStrBuf,
                                      //[저장소] 문자열 전체 길이(-1 인경우는 함수내부적으로 구해야한다).
                                      int    pStrBufSize,
                                      //현재 위치.
                                      int    pIndex);

//[2012.03.03.토][완료!!!]
void __fastcall STR_AddLineStr(//행을 교체할 [문자열] 이 들어 있는 [저장소 자체 위치].
                               //새로 생성되어 [포인터] 가 재설정되어야 하므로 반드시
                               //[저장소 자체의 포인터] 를 전달 받아야 하며, 저장소는
                               //반드시 [배열] 이 아닌 [포인터] 만 지정 가능.
                               char  **pBufPtr,
                               //추가할 문자열(실제는 첫행만 추가).
                               char   *pStr,
                               //[새저장소] 크기 반환(NULL 인 경우는 미사용).
                               int    *rBufSize,
                               //[새저장소] 안의 전체 문자열 길이 반환(NULL 인 경우는 미사용).
                               int    *rStrLength,
                               //[새저장소] 안의 문자열 전체 행수 반환(NULL 인 경우는 미사용).
                               int    *rLineCount);

//[2010.03.10.수][완료!!!]
//[2018.10.13.토][완료!!!]
void __fastcall STR_InsertLineStr(//행을 교체할 [문자열] 이 들어 있는 [저장소 자체 위치].
                                  //새로 생성되어 [포인터] 가 재설정되어야 하므로 반드시
                                  //[저장소 자체의 포인터] 를 전달 받아야 하며, 저장소는
                                  //반드시 [배열] 이 아닌 [포인터] 이어야 한다.
                                  char  **pBufPtr,
                                  //문자열을 끼워넣을 행번호(기본 : 0).
                                  int     pLineNum,
                                  //끼워넣을 문자열.
                                  char   *pStr,
                                  //새로 생성된 저장소크기 반환(NULL 인 경우는 미사용).
                                  int    *rBufSize,
                                  //전체 문자열 길이를 반환(NULL 인 경우는 미사용).
                                  int    *rStrLength,
                                  //전체 행수 반환(NULL 인 경우는 미사용).
                                  int    *rLineCount);

//[2010.03.10.수][완료!!!]
void __fastcall STR_ReplaceLineStr(//행을 교체할 [문자열] 이 들어 있는 [저장소 자체 위치].
                                   //새로 생성되어 [포인터] 가 재설정되어야 하므로 반드시
                                   //[저장소 자체의 포인터] 를 전달 받아야 하며, 저장소는
                                   //반드시 [배열] 이 아닌 [포인터] 이어야 한다.
                                   char  **pBufPtr,
                                   //문자열을 교체할 행번호(기본 : 0).
                                   int     pLineNum,
                                   //교체할 문자열.
                                   char   *pStr,
                                   //새로 생성된 저장소크기 반환(NULL 인 경우는 미사용).
                                   int    *rBufSize,
                                   //전체 문자열 길이를 반환(NULL 인 경우는 미사용).
                                   int    *rStrLength,
                                   //전체 행수 반환(NULL 인 경우는 미사용).
                                   int    *rLineCount);

//[2012.03.10.수][완료!!!]
void __fastcall STR_DeleteLineStr(//행을 교체할 [문자열] 이 들어 있는 [저장소 자체 위치].
                                  //새로 생성되어 [포인터] 가 재설정되어야 하므로 반드시
                                  //[저장소 자체의 포인터] 를 전달 받아야 하며, 저장소는
                                  //반드시 [배열] 이 아닌 [포인터] 이어야 한다.
                                  char  **pBufPtr,
                                  //문자열을 교체할 행번호(기본 : 0).
                                  int     pLineNum,
                                  //새로 생성된 저장소크기 반환(NULL 인 경우는 미사용).
                                  int    *rBufSize,
                                  //전체 문자열 길이를 반환(NULL 인 경우는 미사용).
                                  int    *rStrLength,
                                  //전체 행수 반환(NULL 인 경우는 미사용).
                                  int    *rLineCount);

//[2011.07.16.토][완료!!!]
void __fastcall Str_XLine_To_1Line_Trim(char  *pXLineStr,
                                        char  *r1LineStr,
                                        //[CRLF] 대신 몇개의 [공백] 을 넣을 것인가?
                                        int    pSpaceCount);


//[2011.07.15.금][완료!!!]
void __fastcall Str_Delete_Comment(char  *pStr,
                                   char  *rStr);

//[2012.06.23.토][완료!!!]
void __fastcall Str_Delete_Comment2(char  *pStr_,
                                    //0 인 경우는 내부적으로 구한다.
                                    int    pStrSize,
                                    //추출할 첫 단어 위치(추출할 첫 단어 위치).
                                    int    pStartWordIndex,
                                    //추출할 끝 단어 위치.
                                    int    pEndWordIndex,
                                    //[주석] 이 없는 순수 1행 문자열.
                                    char  *rStr_);


//[2011.07.17.일][완료!!!]
void __fastcall Str_Width_Ellipsis(//지정폭에 맞추어 [줄임표] 가 적용할 문자열.
                                   char             *pStr,
                                   //[설정]-------------------------------------
                                   //적용할 [글꼴 묶음].
                                   struct FONTPACK  *pFontPack,
                                   //글꼴형식.
                                   int               pStyle,
                                   //지정폭.
                                   int               pSetWidth,
                                   //[반환]-------------------------------------
                                   //지정폭에 맞추어 [줄임표] 가 적용된 문자열.
                                   char             *rStr);

//[2022.04.12.화][완료]
void __fastcall Str_Line_AutoLine_Width(//[지정폭] 에 맞추어 [자동 행 추가] 문자열로 바꿀 문자열.
                                        char             *pLineStr,

                                        //[설정]---------------------
                                        //적용할 [글꼴 묶음].
                                        struct FONTPACK  *pFontPack,
                                        //글꼴형식.
                                        int               pStyle,
                                        //지정폭.
                                        int               pSetWidth,
                                        //}--------------------------

                                        //지정폭에 맞추어 [줄임표] 가 적용된 문자열.
                                        char             *rStr);

//[2022.01.01.토][완료]
//v---<rTrimStr> 의 문자열 길이.
int __fastcall Str_Trim(char  *pStr,
                        //앞 공백 제거 유무.
                        bool   pDelPreSpace,
                        //뒤 공백 제거 유무.
                        bool   pDelPostSpace,
                        //정리된 문자열.
                        //<NULL> 인 경우는 [시뮬레이션] 기능으로 실제 처리된 문자열을
                        //반환하지 않고 처리된 문자열의 길이만 반환.
                        char  *rTrimStr);

//------------------------------------------------------------------------------
//[문자열 찾기]-----------------------------------------------------------------
//------------------------------------------------------------------------------

//[2009.05.07.목][완료!!!]
bool __fastcall STR_ASCII_Is_Giho(char  pChar);

//[2009.05.07.목][완료!!!]
//[2022.07.17.일][완료]
void __fastcall STR_Find(//검사할 [저장소].
                         char  *pStrBuf,
                         //[저장소] 문자열 전체 길이(-1 인경우는 함수내부적으로 구해야한다).
                         int    pStrBufSize,
                         //[찾기조건]{-----------
                         //찾기 시작 위치.
                         int    pOptStartIndex,
                         //단어 구분(true).
                         bool   pOptWord,
                         //대/소문자 구분(true).
                         bool   pOptCase,
                         //----------------------
                         //찾을 문자열.
                         char  *pFindStr,
                         //찾은 위치(찾지 못한 경우는 -1 을 반환).
                         int   *rFindIndex);

//[2019.02.23.토][완료]
//[2022.07.17.일][완료]
void __fastcall STR_Find_Bound(//검사할 [저장소].
                               char  *pStrBuf,
                               //[찾기조건]{-----------
                               //찾기 시작 위치.
                               int    pOptStartIndex,
                               //찾기 끝 위치.
                               int    pOptEndIndex,
                               //단어 구분(true).
                               bool   pOptWord,
                               //대/소문자 구분(true).
                               bool   pOptCase,
                               //----------------------
                               //찾을 문자열.
                               char  *pFindStr,
                               //찾은 위치(찾지 못한 경우는 -1 을 반환).
                               int   *rFindIndex);

//[2021.06.29.화][완료]
void __fastcall Str_SortList(//1행 단위 문서 목록.
                             char  *pList,
                             //[기호/숫자/영문/한글] 순으로 정렬된 목록.
                             //단, 정렬은 [이름] 을 기준으로 한다.
                             char  *rSortedList);

//------------------------------------------------------------------------------
//[파일 문자열 처리 관련]-------------------------------------------------------
//------------------------------------------------------------------------------

//[2022.10.20.목][완료]
void __fastcall STR_GetFileExt(char *pFILEname,
                               char  pFILEext[]);

//[2009.01.27.화][완료!!!]
void __fastcall STR_GetFilePathOnly(char  *pFullName,
                                    char   rPathOnly[]);

//[2009.12.15.화][완료!!!]
void __fastcall STR_Get_FileFullName_LastFolderName(//전체 문서이름(경로와 문서이름까지 모두 있는).
                                                    char  *pFullName,
                                                    //전체 경로에서 [문서자체] 이름을 제외한
                                                    //가장 마지막 [폴더이름] 를 반환한다.
                                                    char  *rLastFolderName);

//[2009.02.07.토][완료!!!]
void __fastcall STR_GetFileNameOnly(char *pFULLname,
                                    char  pFILEname[]);

//[2011.10.18.화][완료!!!]
void __fastcall STR_GetFileNameOnly_ExceptExt(char  *pFullName,
                                              char  *pName);

//[2009.01.27.화][완료!!!]
void __fastcall STR_GetFileName_Except_BaseDirectory(//제외할 [폴더경로](현재 문서가 이 [폴더] 안에 있어야 함).
                                                     char  *pBaseDirectory,
                                                     //이 [폴더] 안에 있는 문서의 전체 경로.
                                                     char  *pFullName,
                                                     //[폴더 경로] 를 제외한 문서 이름(폴더 안의 경로와 문서이름포함).
                                                     char   rFileName[]);

//[2009.01.29.목][완료!!!]
bool __fastcall STR_BaseDirectory_Match(//검사할 [폴더경로](현재 문서가 이 [폴더] 안에 있어야 함).
                                        char  *pBaseDirectory,
                                        //이 [폴더] 안에 있는 문서의 전체 경로.
                                        char  *pFileFullName);

//[2006.06.07.수][완료!!!]
void __fastcall STR_ChangeFileExt(char *pFILEname,
                                  char *pNEWext,
                                  char  pNEWname[]);

//[2012.03.28.수][완료!!!]
bool __fastcall Str_FileName_Width_Ellipsis(//지정폭에 맞추어 [줄임표] 가 적용될 [경로이름확장자].
                                            char             *pPathNameExt,

                                            //[설정]---------------------
                                            //적용할 [글꼴 묶음].
                                            struct FONTPACK  *pFontPack,
                                            //글꼴형식.
                                            int               pStyle,
                                            //지정폭.
                                            int               pSetWidth,
                                            //}--------------------------

                                            //지정폭에 맞추어 [줄임표] 가 적용된 문자열.
                                            char             *rStr);

//[2019.02.17.일][완료]
bool __fastcall Str_Is_FullFileName(char  *pStr);

//[2019.02.17.일][완료]
bool __fastcall Str_Is_NewFileName(char  *pStr);

//[2020.10.04.일][완료]
void Str_Get_Real_FileList(char  *pList,
                           char  *rList);

//[체크 관련]-------------------------------------------------------------------

bool __fastcall CHECK_NameRule(char *pNAME);

bool __fastcall CHECK_HexRule(char *pHEX);

bool __fastcall CHECK_BinaryRule(char *pBINARY);

bool __fastcall CHECK_DecRule(char *pDEC);  

bool __fastcall CHECK_FloatRule(char *pFLOAT);

//[2007.10.16.화][완료!!!]
bool __fastcall STR_Is_Dec(char  *pStr);

//[2008.12.26.금][완료!!!]
int  __fastcall Check_ByteX(unsigned long long  pValue);

//[2009.01.03.토][완료!!]
int  __fastcall Check_C_Type_ByteX(unsigned long long  pValue);

//[2009.08.06.목][완료!!!]
int  __fastcall Check_2_ExponentX(unsigned long long  pValue);

//[변환 관련]-------------------------------------------------------------------

//[문자열 => 값]
//{
    void __fastcall CONV_HexStr_To_IntVal(char *pHEXstr,
                                          int  *pINTval);
    void __fastcall CONV_DecStr_To_IntVal(char *pDECstr,
                                          int  *pINTval);
    void __fastcall CONV_BinStr_To_IntVal(char *pBINstr,
                                          int  *pINTval);

    //내부 처리시에는 기본적으로 long 을 사용하는것이 좋다.
    //최대 표현 값까지 전부 변환할수 있기 때문이다.
    void __fastcall CONV_HexStr_To_LongVal(char       *pHEXstr,
                                           long long  *pLONGval);
    void __fastcall CONV_DecStr_To_LongVal(char      *pDECstr,
                                           long long *pLONGval);
    void __fastcall CONV_BinStr_To_LongVal(char       *pBINstr,
                                           long long  *pLONGval);

    void __fastcall CONV_DoubleStr_To_DoubleVal(char   *pDOUBLEstr,
                                                double *pDOUBLEval);

//}

//[값 => 문자열]
//{
    void __fastcall CONV_DoubleVal_To_Str(double  pDOUBLEval,
                                          char    pDOUBLEstr[]);

    void __fastcall CONV_DoubleVal_To_Hex(double  pDOUBLEval,
                                          int     pDIGIT,
                                          char    pDOUBLEhex[]);


    //[완료!!!][2006.03.20.월]
    void __fastcall CONV_LongVal_To_Str(long long  pLONGval,
                                        int        pDIGIT,
                                        bool       pVIEWsign,
                                        char       pLONGstr[]);

    //[2011.06.22.수][완료!!!]
    void __fastcall CONV_LongVal_To_Str2(long long   pLONGval,
                                         int         pDIGIT,
                                         bool        pVIEWsign,
                                         char       *pLONGstr);



    void __fastcall CONV_LongVal_To_Hex(long long  pLONGval,
                                        int        pDIGIT,
                                        char       pLONGhex[]);
    //[완료!!!][2006.07.10.월]
    void __fastcall CONV_LongVal_To_Hex2(long long  pLONGval,
                                         char       pLONGhex[]);

    //[2011.06.22.수][완료!!!]
    void __fastcall CONV_LongVal_To_Bin(long long   pLongValue,
                                        //최대 64 까지 지정하고, 0 인 경우는 최소표기.
                                        int         pDigit,
                                        char       *rStr);




//}

//[날짜값 => 날짜표기]
//{
    struct CONV_0XDATE_TO_DATESTR
    {
      //[2010.12.14.화][생성!!!]{------------------------------------------------
      //Conv_0xDate_To_DateStr() 함수에서 사용하며 { 년, 월, 일, 시, 분 } 정보를
      //구분하여 실제 값으로 정리 반환할때 사용된다.
      //}------------------------------------------------------------------------

      int  year;
      int  month;
      int  day;

      int  hour;
      int  minute;

    };

    //[2010.12.14.화][완료!!!]
    void __fastcall Conv_0xDate_To_DateStr(unsigned long long              pDateValue,
                                           //{ 년/월/일/시/분 } 으로 구분된 숫자값(NULL 이면 미사용).
                                           struct CONV_0XDATE_TO_DATESTR  *rDateNum,
                                           //"년.월.일-시:분" 으로 정리된 문자열 반환(NULL 이면 미사용).
                                           char                           *rDateStr);

//}

//[식별자 => 문자열표기]
//{
    //[2010.12.15.수][완료!!!]
    void __fastcall Conv_0xId_To_IdStr(unsigned long long   pID,
                                       //"0x[상위4Byte]:[하위4Byte]" 로 표기된 문자열로 변환한다.
                                       char                *rIdStr);


//}

//[2009.05.14.목][완료!!!]
long long __fastcall CONV_CharConstStr_To_Value64(//[문자상수] 문자열.
                                                  char  *pCharConstStr,
                                                  //[2009.05.14.목][중요추가!!!]{----------------------
                                                  //[문자상수] 변환할 길이(문자열길이가 아니다).
                                                  //이는 문자상수안에 '\0' 문자도 들어 있을수 있으므로
                                                  //여기서는 '\0' 도 하나의 값으로 변환해야 하므로
                                                  //문자열 길이를 사용하지 않는다.
                                                  int    pConvLength
                                                  //}--------------------------------------------------
                                                 );

//[문자열 정보 정리]
//{
    //[2012.05.19.토][완료!!!]
    int __fastcall FuncDefStr_ReMake_TreeItem(//반드시 [함수 선언 정보 문자열(1행 문자열)] 만 사용 가능.
                                              char  *pFuncDefLineStr,
                                              //[재정리] 된 무자열.
                                              char  *rStr);


//}

//[메모리 관련]
//{
    //[2012.08.12.일][완료!!!]
    void __fastcall Mem_MoveBack(void           *pDst,
                                 void           *pSrc,
                                 unsigned long   pSize);



//}

//[단위 관련]
//{
    //[2021.01.17.일][완료]
    unsigned int __fastcall UnitX(//사용자 지정 단위(64, 1024 등으로 입력).
                                  //계산식의 분모에 사용되므로 절대 0 은 입력하지 않는다.
                                  unsigned int  pUnit,
                                  //사용자가 정의한 크기(pUnit 의 정수배로 재정리).
                                  unsigned int  pSize);

//}


#endif

