//{------------------------
//[2005.08.20.토][생성!!!]                                    
//database 본체를 만든다.
//}------------------------
                                                                     

#ifndef database_h
#define database_h

#include "c_define.h"

//[2012.04.20-1.목][추가!!!]
#include "str_heap.h"


//[2005.08.26.금][추가!!!]{------------------------------------------------------------
//[word] 의 종류를 구분하기 위한 상수 값.
//필요에 따라 추가한다.
#define  _KIND_keyword             1  //[예약어].
#define  _KIND_name                2  //사용할수 있는 [이름].
#define  _KIND_constant            3  //[숫자], [문자상수], define 정의 [이름상수].
#define  _KIND_data                4  //[DATA].
#define  _KIND_function            5  //[함수이름].
#define  _KIND_type                6  //[사용자 선언 type] 구조체 공용체 type 이 된다.
#define  _KIND_operator            7  //각종 [연산자].


//}------------------------------------------------------------------------------------

//[2005.08.31.수][추가!!!]{-----------------------------------------------------------
//[record] 의 [field] 의 위치를 정의 한다.
//추가 정보가 있을시 추가한다.
#define  _F_name                 0
#define  _F_index                1
#define  _F_kind                 2
#define  _F_area                 3
#define  _F_typelistindex        4
#define  _F_filelistindex        5
#define  _F_pointer              6
#define  _F_motherindex          7
//아래 두 정보는 항상 가장 뒤에 배치해야 한다.
#define  _F_arraydimension       8
#define  _F_arraysize            9

#define  _F_str                  10

//[2007.07.20.금][추가!!!]
#define  _F_size                 11
#define  _F_address              12

//}-----------------------------------------------------------------------------------

//[2005.10.19.수][추가!!!]{------------------------------------------------------------
//record 의 field 중 kind 를 정의한다.
//이는 완전히 종류가 결정 되었을 경우 기록하는 것이며, record 의 종류를
//이 정보로 간단하게 구분해야 하므로 아주 자세하게 분류해야 한다.

//[2005.10.26수][추가!!!]
#define  _recKIND_structtype     1
#define  _recKIND_uniontype      2

//[2005.11.08.화][추가!!!]
#define  _recKIND_data           3


//[2006.01.28.토][추가!!!]----------------------------------------------
//[함수포인터] 는 함수와는 다른 것이므로 별도로 선언한다.
//검사시 [함수] 보다 먼저 검사되므로 먼저 배치한다.
#define  _recKIND_func_ptr       4  //함수포인터자체 record.
#define  _recKIND_func_ptr_func  5  //함수포인터 참조 함수 정보 record.
//----------------------------------------------------------------------


//[2006.01.13.금][수정!!!]-------------------------------------------------------------
//[함수] 의 경우는 [선언] 만 사용될수도 있고, 본체가 있는 [함수정의] 가 같이
//올수 있으므로 이둘을 각각 구분하기 위한 두개의 종류가 필요하다.
//단, 먼저 선언된 정의를 우선한다.
//먼저 선언되면 {DATABASE} 상에 먼저 위치하게 되므로 먼저 나오는 것으로 우선할수 있다.
#define  _recKIND_func_def       6  //단순히 선언만 한 경우.
#define  _recKIND_func_body      7  //본체가 있는 선언의 경우.

#define  _recKIND_func_param     8  //함수인수 record 인경우.

#define  _recKIND_label          9  //선언 label.
//-------------------------------------------------------------------------------------

struct  RTEXPMARK
{
  //[2012.06.19.화][생성!!!]{------------------------------------------------------------
  //[실시간 선언 정보판] 에 "->", "." [연산자] 의 [구성원] 을 보여주기 위한것.
  //
  //1) [연산자] 앞의 [선언형] 을 알아야한다.
  //2) [선언형] 을 알려면 반드시 이 [연산자] 를 포함하는 [식] 의 시작위치를 알아야 한다.
  //3) [검증식] 처럼 이 [식] 을 처리해야 [모체 선언형] 정보를 알수 있다.
  //
  //이를 위하여 [실시간 선언 정보 수집] 시 [연산자] 를 포함하는 [식] 의 최소 시작위치를
  //알기 위하여 [스택] 형태로 운영되는 정보 구조체 필요.
  //
  //가) 먼저 [실시간 선언정보 수집] 하면서 동시에 [식:시작위치] 얻기.
  //나) [검증식] 처럼 [식] 을 처리하여 [연산자] 앞의 [모체 선언형] 을 얻는다.
  //
  //[2012.06.20.수][수정!!!]-------------------------------------------------------------
  //"{ }" 는 ";" 와 같은 의미로 처리한다.
  //이는 "{ }" 는 [식] 안에서 사용되지 않기 때문이다.
  //
  //단지, [식:시작위치] 를 아는 것만 중요하고 [식] 이 오류인지 아닌지는 의미가 없다.
  //이는 [식] 을 실제 처리하는 부분에서 [오류] 인 경우는 [실시간 선언 정보판] 을 보이지
  //않으면 되기 때문.
  //
  //몇개가 [중첩] 되었는지도 중요하지 않다. 오직 지정 [연산자] 를 가지는 최소한의 [식]
  //시작위치만 중요하다. 
  //
  //<Push/Pop()> 으로 처리되는 것은 [식] 안에서 사용될수 있는 "( )" 이 유일하다.
  //
  //이 정보를 사용하는 <Parser.cpp:Tree_Info_StatementBlock()> 함수는 [실시간 선언 정보]
  //수집에만 사용되며 [함수본체] 의 "{ }" 와는 무관하다.
  //즉, 여기서 대상으로 하는 "{ }" 는 순수한 [문장블록] 을 위한것이다.
  //}------------------------------------------------------------------------------------

  //[구분!!!]{-----------------------------------------------------
  //
  //"("              : (+). 추가(Push).
  //
  //")"              : (-). 삭제(Pop).
  //
  //"{ } , ; return" : (=). 교체(Write).
  //
  //읽기(Read) 인 경우는 최종 저장된 위치를 반환.
  //
  //[2012.06.21.목][설명!!!]---------------------------------------
  //"{ }" 는 [식] 에 포함될수 없기 때문에 ";" 와 같은 의미로 본다.
  //}--------------------------------------------------------------

  //[관리자료]
  //{
      //계속 [중첩] 되는 경우가 256 단계 이상정도면 충분.
      #define  d_RTEXPMARK_Max    256
      int  index[d_RTEXPMARK_Max];

  //}    

  //저장할 위치.
  int   sp; //(기본값:0).

  //대상 [연산자] 의 [저장소] 상 위치.
  //이 값이 <-1> 이 아닌 경우만 처리된다.
  //이 값은 <Ctrl+Space> 를 처리하는 함수에서 해당 경우에 자동으로 설정.
  int   opIndex; //(기본값:-1).

  //[2012.06.23.토][추가!!!]{---
  //[연산자] 문자 길이.
  //"->" : 2.
  //"."  : 1.
  int   opLength; //(기본값:0)
  //}---------------------------

  //<true> 인 경우만 처리한다.
  //[식:시작위치] 가 [연산자] 위치를 넘는 경우 자동으로 <false> 된다.
  //<RtExpMark_Push()> 와 <RtExpMark_Write()> 에서 판별 처리된다.
  //<RtExpMark_OperatorIndex()> 함수에서 [연산자] 위치를 설정시 <true> 가 된다.
  bool  on; //(기본값:false)

  //[2012.06.21.목][추가!!!]{----------------------------------
  //[모체:선언형] 정보.
  //<parser.cpp:EXPRESSION_MatchOne()> 함수에서 직접 설정된다.
  int   motherTypeListIndex;
  //}----------------------------------------------------------

  //[2012.06.21.목][추가!!!]{------------------------------
  //[실시간 선언 정보판] 을 가동시 자동으로 얻어지는 정보.
  //현재 [입력지정자] 가 위치한 함수 정보로 [지역변수] 를
  //처리할때 반드시 필요.
  int   funcRecIndex;
  //}------------------------------------------------------

};

struct  RTDEFINFOETC
{
  //[2012.05.10.목][생성!!!]{-----------------------------------
  //[실시간 선언정보 수집] 용도로 <Parser()> 를 사용한 경우
  //현재 [입력 지정자] 가 위치한 [함수] 의 각 영역 정보를 관리.
  //
  //이는 <infoTree> 를 보일지 말지를 결정하거나 {DB} 의 자료를
  //보일때 [정리] 기준이 된다.
  //
  //[실시간 정보창] 은 [편집기] 에서만 보인다.
  //BCB 의 <CodeInsightBox> 와 유사한 기능을 구현하기 위한것.
  //
  //[참고!!!]---------------------------------------------------
  //한개만 {DB} 안에 선언.
  //}-----------------------------------------------------------

  //[기준정보]{----------------------------------------------------
  //현재 [편집기] 에 열려 있는 <*.c>/<*.h> 상의 [입력지정자] 위치.
  //아래 4개 정보를 얻는 기준이 된다.
  //
  //<Parser()> 을 [실시간 선언정보 수집] 시에 먼저 설정한다.
  int  caretIndex;
  //}--------------------------------------------------------------

  //[영역 정보]
  //{
      //현재 [입력지정자] 가 위치한 [함수:recindex] 정보.
      //단, 반드시 "{" 위치 다음에 수집되어야 한다.
      //<TREE_FunctionDefinition()> 함수에서 구해진다.
      int  funcRecIndex;

      //[함수영역] 시작/끝 위치.
      //<TREE_FunctionDefinition()> 함수에서 구해진다.
      int  areaStartIndex; //"{" 위치.
      int  areaEndIndex;   //"}" 위치.

      //[지역변수] 선언 끝 위치.
      //<TREE_FunctionBody()> 함수에서 구해진다.
      int  localDefEndIndex;

  //}

  //[2012.05.22.화][추가!!!]
  //현재 처리 대상 문서번호.
  int  fileListIndex;

  //현재 위치가 유효 위치인지 구분.
  //주석, 문자열, 문자상수 는 공간과 같이 취급.


};

struct STRBUF
{
  //[2005.09.13.화][생성!!!]{--------------------------------------------
  //file 을 저장하기 전 저장하는 buf 구조체.
  //parser 시 생성되는 임시 파일을 생성하거나 대량의 문자열을 정리하는데
  //사용된다.
  //}--------------------------------------------------------------------

  char  *buf;    //size 크기로 동적 생성된다.(BASE:NULL)
  int    size;   //buf 의 크기.              (BASE:0)
  int    count;  //현재 까지 저장된 크기.    (BASE:0)

};

struct CTRLAREACOUNT
{
  //[2006.02.14.화][추가!!!]{------------------------------------------------
  //for, while, dowhile, switch 의 [area 중첩] 을 count 한다.
  //이는 break, continue, case 등의 사용 여역에 합당한지를 알기 위한 것이다.
  //for 등을 만나면 ++ 하고, 영역이 끝나면 -- 하여야 한다.
  //즉, 함수가 끝나면 모든 값은 0 이 되 있어야 한다.
  //}------------------------------------------------------------------------

  int   for_count;
  int   while_count;
  int   dowhile_count;
  int   switch_count;

  //[단순 번호 붙여주기]
  //{
      //[2008.10.25.토][추가!!!]{-----------------------------------------------------------------------
      //단지 if, for, while, dowhile, switch 를 번역시 라벨로 변경되는 경우 각각을 구분하기 위한것이다.
      //무조건 ++ 만 된다.
      //실제 사용 시에는 index 로 사용되므로 -1 을 해서 사용해야 한다.
      //}-----------------------------------------------------------------------------------------------

      int countIf,       //(VASE : 0)
          countFor,      //(VASE : 0)
          countWhile,    //(VASE : 0)
          countDowhile,  //(VASE : 0)
          countSwitch;   //(VASE : 0)

  //}

  //[2009.12.08.화][추가!!!]{--------------------------------------------------------
  //함수안에서 <return> 이 사용되었는지 확인하는데 사용한다.
  //이는 반환값이 있는 함수에서는 반드시 <return [반환값]> 이 있어야 하기 때문이다.
  //
  //<return> 을 만나면 ++ 되고, TREE_FunctionDefinition() 함수안에서 "{" 를 검사한뒤
  //바로 0 으로 초기화 한다.
  //
  int  return_count;
  //}---------------------------------------------------------------------------------

};


//[SWITCHINFO]
//{
    struct SWITCHINFO
    {
      //[2008.10.25.토][생성!!!]{----------------------------
      //switch...case 를 번역하기 위한 정보를 저장 관리한다.
      //}----------------------------------------------------

      //현재 switch 번호(라벨을 만들기 위한 것으로 index 가 되며 0 부터 유효하다).
      int         switchIndex;                 //(BASE : 0)

      //switch 당 case 는 256 개까지 가능하다.
      //이 값은 [번역] 과 [상수 중복 검사] 등에 사용된다.
      long long   caseConstant[OPT_case_max];  //(BASE : X)
      int         caseCount;                   //(BASE : 0)

      //단지 default 가 사용됬는지 아닌지만 중요하다.
      bool        defaultUse;         //(BASE : false)

    };

    //[2008.10.25.토][완료!!!]
    void __fastcall SWITCHINFO_Init(struct SWITCHINFO  *prSwitchInfo);

    //[2008.10.25.토][완료!!!]
    bool __fastcall SWITCHINFO_AddCaseConstant(struct SWITCHINFO  *pSwitchInfo,
                                               long long           pCaseConstant);

    //[2008.10.25.토][완료!!!]
    int __fastcall SWITCHINFO_MatchCaseConstant(struct SWITCHINFO  *pSwitchInfo,
                                                long long           pConstant);

//}

//[CTRLAREASTACK]
//{
    //[2008.10.27.월][추가!!!]{--------------------------------------------------------------
    //if, for, while, dowhile, switch 영역 정보를 가진다.
    //이는 각각의 영역이 중첩 될수 있으므로 이 영역의 해당 영역으림의 count 값을 정확히 알고
    //이를 번역시 라벨이름에 사용하기 위한 것이다.
    //}--------------------------------------------------------------------------------------

    struct CTRLAREASTACKITEM
    {
      //영역이름을 구분한다.
      //i(if), f(for), w(while), d(dowhile), s(switch) 를 의미한다.
      //비교시 검색을 빠르게 하기 위하여 대표하는 문자 1 개만 사용한 것이다.
      char  kind;

      //해당 영역의 현재 count 값(구분을 위하여 계속 ++ 되는 것)을 -1 하여 BASE:0 의 index 값으로 저장한다.
      //이는 바로 이 index 값을 사용하기 위한 것이다.
      int   index;

    };

    struct CTRLAREASTACK
    {
      //영역을 {STACK} 형식으로 관리한다.
      //전체를 통털어 소스당 한개만 있으면 된다(한개 소스문서를 검증/번역 하는데만 필요하므로).

      struct CTRLAREASTACKITEM  items[OPT_CtrlAreaStackMax];

      int                       itemCount;

    };

    //[2008.10.27.월][완료!!!]
    void __fastcall CTRLAREASTACK_GetPtr(struct CTRLAREASTACK  **rCtrlAreaStackPtr);

    //[2008.10.27.월][완료!!!]
    void __fastcall CTRLAREASTACK_Init(void);

    //[2008.10.27.월][완료!!!]
    bool __fastcall CTRLAREASTACK_Push(struct CTRLAREASTACKITEM  *pItem);

    //[2008.10.27.월][완료!!!]
    bool __fastcall CTRLAREASTACK_Pop(struct CTRLAREASTACKITEM  *rItem);

//}

struct PARSERINFO
{
  //[2005.05.01.일][생성!!!]{------------------------------
  //GetNextWord() 함수에서 사용하는 인수 전달용 구조체.
  //인수의 추가 삭제시 보다 소스 수정을 쉽게 하기 위한 것.
  //}------------------------------------------------------

  char *buf;                    //단어를 추출할 문자열.(문자열이 저장된 buffer[])
  int   index;                  //str[index] 에서의 단어 시작 위치 index.

  //[2012.05.16+2.금][수정!!!]
  //약 1K 로 안전하게 처리.
  char  word[1024];  //추출한 단어 저장.
  //char  word[OPT_name_length];  //추출한 단어 저장.

  int   wordindex;              //단어 시작 위치 기록.

  //[2012.06.22.금][추가!!!]{------------------------------------------------------
  //<GetNextWord()> 와 <GetNextWordAll()> 함수에서 설정되며 [단어 길이] 를 갖는다.
  //실제 이 함수들 안에서 [단어조합] 에 사용되는 <i> 의 최종 값이 해당.
  //이는 항상 최종 <i> 위치에 '\0' 을 할당하기 때문.
  int   wordLength;
  //}------------------------------------------------------------------------------

  //[주의!!!]{--------------------------------------------------------------
  //단어 길이 정보는 word[] 에서 '\0' 이 나올때 까지 문자수를 세어 간단하게
  //알수 있으므로 별도 함수에 맡기고 여기에 정보로 추가 하지 않는다.
  //}-----------------------------------------------------------------------

  //[추가정보]

  //[file info]{------------------------------------------------------------
  //파일을 처리 중, 파일 끝에 왔는지를 알아아 하므로 이 정보가 필요하다.
  //또한, include 문등으로 다른 파일을 호출할수 있으므로 현재 어떤 파일인지
  //항상 기록해 놓고 있어야 현재 작업 중이던 파일로 다시 되돌아 올수 있다.
  int  filelistindex;  //filelist[] 상의 파일 번호.

  //[2005.10.07.금][추가!!!]
  //GetNextWord() 함수안에서 파일을 넘어서 처리 하는 것을 막기 위하여
  //반드시 이 크기 정보가 이 구조체 안에 있어야 한다.
  //Parser() 함수 안에서 따지면 파일의 끝이 [CLLF] 로 끝나거나 하는 경우
  //파일을 1 byte 정도 넘어가서 처리 하는 경우가 발생한다.
  int  filesize;

  //filelist[] 에는 해당 file 의 name, size 정보가 들어있다.
  //}-----------------------------------------------------------------------

  //[2005.09.22.목][추가!!!]{-----------------------------------------
  //현재 소스상에서 처리중인 행정보를 저장한다.
  //0 부터 시작하고 소스상에서 CRLF(\r\n) 을 만날떄마다 line++; 된다.
  int  line; //(BASE: 0)
  //}-----------------------------------------------------------------

  //[2005.09.24.토][추가!!!]{*************************************************
  //{
      //GetNextWord() 에서 주석문을 가려내기 위한 것.
      //이전 정보를 항상 기억하고 있어야 하므로 전역변수 형식으로
      //이곳에 선언해 준다. GetNextWord() 가 인수로 parserinfo 를 사용하므로.
      char  what_in;
      //0 : 아무 영역도 아님.
      //c : ' ... ' 문자상수 안. 뒤의 [']  에서 영역 해제됨.
      //s : "  ...  " 문자열 안. 뒤의 ["]  에서 영역 해제됨.
      //r : /* ... */ 주석문 안. 뒤의 [*/] 에서 영역 해제됨.
      //h : // ...    주석문 안. 이 행의 끝까지 모두 주석문임.
      //    CRLF 로 행이 바뀌면 해제됨.(CRLF 를 검사하는 부분에서 해제).
  //}*************************************************************************

  //[2005.10.31.월][추가!!!]{-----------------------------------------------------
  //global/local(함수영역) area(영역) 를 구분하기 위한 변수를 하나 선언해 준다.
  int  area_gl;
  // -1    : global 영역.
  // index : local 영역.
  //         [함수 본체], [구조체/공용체 type 선언 본체] 의 내부 영역이 시작되는
  //         해당 [함수], [구조체/공용체 type 선언] 정보가 있는 {DATABASE} 상의
  //         record-index 가 된다.
  //         이 index 정보로 local 영역의 이름(함수이름, 구조체/공용체 type 이름)
  //         을 쉽게 찾을수 있다.
  //
  //[local 영역 시작/끝]
  //local 영역은 [함수이름의 시작 index], [구조체/공용체 type 이름의 시작 index]
  //위치가 시작 위치가 되고 해당 record-index 를 할당하고, 각각의 본체가 끝나는
  //"}" 위치 index 지점을 끝으로 local 영역이 해제 된 것으로 보고 -1 을 할당해서
  //global 영역으로 바뀌었음을 알려준다.
  //즉, 기본상태는 항상 -1 로 global 상태가 된다.
  //}-----------------------------------------------------------------------------

  //[2006.02.14.화][추가!!!]{-----------------------------
  //struct CTRLAREACOUNT 구조체선언 안의 설명을 참고한다.
  struct CTRLAREACOUNT ctrlarea;
  //}-----------------------------------------------------


  //[2006.05.09.화][추가!!!]{------------------------------------------------
  //중요 backup 을 위하여 정보를 추가한다.
  //아래의 2 개 정보는 {DATABASE} 에도 같은 이름의 정보가 있다.
  int  definecall_count;
  int  parserinfostack_count;
  //이 정보는 PARSERINFO_Backup()함수에서 parserinfo 로 저장되고,
  //PARSERINFO_Restore() 함수에서 다시 {DATABASE} 의 해당 정보에 재설정된다.
  //}------------------------------------------------------------------------

  //[2006.06.12.월][추가!!!]
  //{
      //[!]{-----------------------------------------------------------------------
      //tempfile 에 CRLF 를 추가해 주어야 하므로 이를 위하여 "새로 행이 바뀐 경우"
      //이 "행의 첫 단어" 를 추출한뒤 1 이 되므로 행이 바뀌었음을 쉽게알수 있다.
      //단어가 추출될 때마다 ++ 되고, CRLF 를 만나면 0 으로 초기화 한다.
      //실제 tempfile 에 CRLF 를 추가하는 것은 Get_NextWord() 함수에서 처리한다.
      //}--------------------------------------------------------------------------

      int  wordcount;

  //}

  //[순수단어/그외:구분]
  //{
      //[2012.06.22.금][중요추가!!!]{----------------------------------
      //[이름] 에 사용할수 있는 [순수 단어] 인 경우는 <true>.
      //<GetNextWord()> 와 <GetNextWordAll()> 함수에서 설정된다.
      //"a - z", "A - Z", "_", "한글 등" 만으로 사용된 [단어] 가 해당.
      //}--------------------------------------------------------------

      bool  isName; //(기본값:false)

  //}

  //[지정 위치 정보(부가정보)]
  //{
      //[2012.06.23.토][추가!!!]{-----------------------------------------------------------------
      //<GetNextWord()> 함수는 [주석문] 은 무효문자로 취급하여 [단어] 로 추출하지 않는다.
      //<Get_IndexWord()> 함수에서는 [지정 위치] 의 [단어] 를 추출하게 돼 있으나
      //[지정 위치] 가 [주석문] 안인 경우는 건너뛰기 때문에 정확한 정보를 알수 없다.
      //이를 위해서 관리 정보를 추가.
      //
      //<GetNextWord()>, <GetNextWordAll()> 함수에서 <what_in> 을 설정하는 위치에서 같이 설정.
      //
      //[참고!!!]---------------------------------------------------------------------------------
      //이 정보는 현재 [입력지정자] 위치에서 <Ctrl+Space> 로 [실시간 선언 정보판] 을 보여줄때
      //[입력지정자] 위치가 [주석문] 안인 경우는 [무효영역] 으로 간주 보이지 않기 위하여 필요.
      //일반 [단어] 는 실제 추출이 되어 [문자열/문자상수] 안인지 정보를 <what_in> 로 바로 알수
      //있으나, [주석문] 안인 경우는 <GetNextWord()>, <GetNextWordAll()> 함수에서 아예 [무효영역]
      //으로 간주하여 [단어] 자체를 추출하지 않기 때문에 별도로 정보를 추출할 필요가 있다.
      //
      //즉, [실시간 선언 정보판] 을 위한 부가 기능.
      //}-----------------------------------------------------------------------------------------

      //<-1> 이 아닌 경우만 의미가 있다.
      int   setIndex; //(기본값:-1)

      //위의 <index> 가 <setIndex> 위치 도달할때까지 <what_in> 정보를 보관.
      //단, <setIndex> 가 <-1> 이 아닌 경우만 처리.
      char  setWhatIn; //(기본값:0)

  //}

};

struct FILEINFO
{
  //[2005.09.08.목][생성!!!]{----------
  //파일을 열고 닫기 위한 정보 구조체.
  //}----------------------------------

  //{------------------------------------------------------------------------
  //이 정보 구조체는 전역 변수형태로 {DATABSE} 안에 한개 생성되며,
  //"모든 파일 입출력 함수는 이 구조체 정보를 대상으로 처리 되어야 한다.!!!"
  //또한, 현재 처리되고 있는 file 의 정보를 항상 가지고 있다.
  //다른 함수들은 현재 처리되고 있는 file 정보가 필요한 경우 이 정보를
  //참고해야 한다.
  //}------------------------------------------------------------------------

  //파일 handle 을 저장한다.
  int    handle;

  //파일 이름을 그냥 가지고 있는 것으로 한다.
  char   name[OPT_file_name_length];

  //filebuffer[] 로 filesize 에 맞게 동적으로 생성된다.
  char  *buf;

  //file 의 byte 단위 크기를 가진다.
  int    size;

};

struct RECORD
{
  //[설명]{---------------------------------------
  //struct 개체 각각은 record 가 되고.
  //아래의 각각의 정보는 record 의 field 가 된다.
  //data 뿐만 아니라 가능한 모든 정보를 수집한다.
  //(debug 용 파일을 이 정보로 생성 할수 있도록)
  //}---------------------------------------------

  char  name[OPT_name_length];  //data 의 name.(정해진 길이 만큼만 유효)
                                //(base: '\0')

  int   index;                  //filebuf[] 상의 name 시작 문자 위치.
                                //(base: -1)

  int   kind;                   //상수로 정의된 data 종류.
                                //(base: -1)

  //[2005.10.27.목][수정!!!]{----------------------------------------------------------------------------
  int   area;                   //area 구분.
                                // -1        : global(전역영역)
                                // rec-index : local(해당 함수 record-index)(영역이름을 쉽게 알수 있다.)
                                //(base: -1)
  //}----------------------------------------------------------------------------------------------------

  int   typelistindex;          //typelist[] 상의 index.
                                //(base: -1)

  int   filelistindex;          //filelist[] 상의 index.
                                //(base: -1)
                                //이 data 가 위치한 소스파일 이름.

  int   pointer;                //포인터 차원을 기록한다.
                                //(base: 0)
                                //0: pointer 가 아니다.
                                //1: 1차원 포인터.

  int   motherindex;            //현 data 가 구조체/공용체 선언의 의 member 선언인 경우
                                //record[] 상의 해당 구조체/공용체 선언 record 의 위치.
                                //(base: -1)
                                //이 값으로 쉽게 모체 정보에 접근 할수 있다.

  //[배열][2005.11.07.월][대폭수정!!!]{-----------------------------------------------
  //배열의 dimension 은 5 차원 까지로 제한한다.
  //단, memory 의 절약을 위해서 5 차원 까지만 생성할수 있도록 한다.
  int   arraydimension;         //배열의 차원.              -
                                //(base: 0)
                                //int ary[10][20]; 의 경우라면 2 가 된다.
  int   *arraysize;             //각 차원의 선언 크기.
                                //(base: NULL)
                                //arraydimension 의 값에 따라 저장 공간을
                                //동적으로 생성한다. (단 5 차원까지로 한정한다.)
                                //arraysize = new int[arraydimension]; 으로 생성한다.
  //}---------------------------------------------------------------------------------


  //[2006.01.26.목][추가!!!]{-------------------------------------------------
  //문자열 형태의 정보를 가진다.
  //단순 포인터가 아니고, 동적으로 생성되는 memory 공간을 가진다.
  //할당되는 문자열을 충분히 저장할수 있는 공간을 가져야 한다.
  //char  *str_mem;
  //[함수선언] 의 경우는 [선언문자열] 을 공백을 기준으로한 단어 단위 문자열로
  //완전히 정리된 정보를 가지게 된다. 이는 나중에 함수선언정보의 확인시에
  //file call 을 하지 않고도 간단하게 비교할수 있게 해준다.
  //
  //[2012.04.20-1.목][중요수정!!!]--------------------------------------------
  //<STRHEAP> 상의 위치 <index> 값으로 수정.
  //계속 동적 [생성/삭제] 를 반복하지 않고 [문자열 저장소] 를 별도로 관리하기 위한것.
  //
  //[STRHEAP] 상에서 문자열을 관리하는 [목록 번호(index)] 가 된다.
  //반드시 초기값은 <-1> 로 [목록없음] 으로 초기화.
  int  str_mem; //(기본값:-1)
  //}-------------------------------------------------------------------------


  //[부가정보]
  //{
      //[2008.11.01.토][추가!!!]{----------------------------------------------------
      //각각 data 의 byte 단위 크기와 해당 offset address 를 가지는 정보를 추가한다.
      //이는 object-code, link 시에 중요한 정보가 된다.
      //}----------------------------------------------------------------------------

      long long       size;      //이 data 의 byte 단위 크기 정보를 기록한다.


      //[offset address]
      //{
          //address 는 모두 64bit 크기를 갖는다.
          //이 정보는 기보적으로 각각의 @SEGMENT 를 기준으로 한 Offset Address 가 된다.
          unsigned long long       address;

      //}

  //}

};

struct FILELIST
{
  //{------------------------------------------------------------
  //data 등 처리 정보가 존재하는 file 의 fullname 을 가진다.
  //전체 경로가 완전히 포함되 있다.
  //모든 record 에서 사용되므로 memory 를 절약하기 위하여 이곳에
  //저장하고 참고를 위한 index 를 넘겨준다.
  //}------------------------------------------------------------

  char name[OPT_file_name_length];

  //파일 끝에 왔는지를 알려면 각각의 file size 를 알고 있어야 한다.
  int  size; //(base:0);

  //[2005.10.12.수][추가!!!]{--------------------------------------------------
  //현재 이 file 에서 #include 로 불러 들인 file 의 filelist[] 상의
  //index 값을 검색하여 저장한다. 이 값은 {DATABASE} 상에서 현재 file 이
  //사용가능한 data 를 찾는데 사용된다.
  //현재 file 에서 #include 로 100 개의 file 을 load 할 일은 없으므로
  //100 정도의 관리 능력이면 충분할 것이다. 중복되는 file 은 한개만 유효하다.
  //
  //[주의!!!]
  //이 정보는 현재 파일에서 include 로 연 file 만 해당되며, 이 include 로 연
  //파일이 다시 include 한 file 은 해당하지 않는다. filelistindex 가 저장된다.
  //
  int  include_list[OPT_include_list_size]; //(BASE ALL: -1)
  //
  //include_list[] 저장된 수를 count 한다.
  //이 값은 계속 ++ 만 되므로 관리가 간단하다.
  int  include_list_count;
  //}--------------------------------------------------------------------------

  //[전체 포함 관계 정리]
  //{
      //[2012.04.07.토][추가!!!]{--------------------------------------------------------------
      //<include_list> 와 달리 [1단계 포함관계 정리] 가 아니라
      //모든 포함관계를 관리.
      //즉, <include<include<include<...>>>> 등 계속 내부적으로 <include> 되는 경우까지
      //모두 기록한다.
      //
      //A{ <include:B { <include:C> > } 의 경우
      //C 를 처리할때 이를 가지는 B 에도 등록하고, 역시 B 가 A 에서 포함돼 있으므로
      //A 에도 등록해 주는 것.
      //
      //이는 <include> 처리시 거꾸로 거슬러 올라가면서 [더이상 포함돼 있지 않은 끝] 까지
      //모두 등록해 주는 것.
      //
      //<Parser()> 처리시 <define> 정의를 보다 고속으로 처리하기 위한것으로
      //이전에는 <define> 정의 비교시 위의 과정을 반복 처리함으로써 처리 시간이 너무 많이 소요.
      //}---------------------------------------------------------------------------------------

      int  includeListTotal[OPT_IncludeListTotal_size];
      int  includeListTotalCount;

  //}

};


#define void_typelistindex                0

//typelist[] 의 기본 C-type 중에서 [정수] type 에 해당하는 시작과 끝 index 값을 가진다.
#define c_int_type_first_typelistindex    1
#define c_int_type_last_typelistindex     14

#define c_float_type_first_typelistindex  15
#define c_float_type_last_typelistindex   16

//typelist[] 상에서 기본 C-type 의 시작과 가장 마지막 type 이 저장된 index 값을 가진다.
#define c_type_first_typelistindex        0
#define c_type_last_typelistindex         16


//[2007.07.30.월][추가!!!]
//{
    //많이 사용하는 typelistindex[] 상의 type 은 쉽게 알아볼수 있도록 이름으로 정의해 놓는다.
    #define TYPELISTINDEX_ADR                 10 //unsigned long(address 공간 8 byte 를 의미한다.)
    #define TYPELISTINDEX_long                14 //long
    #define TYPELISTINDEX_double              16 //double
    
//}

struct TYPELIST
{
  //[!]--------------------------------------------------------------
  //기본적인 c 언어 type 과 사용자가 선언한 type 도 같이 저장한다.
  //구조체 공용체의 선언 type 이름도 type 이므로 이곳에 저장한다.
  //반복 사용되는 것이므로 memory 를 절약하기 위하여 이곳에 저장하고
  //참고할 index 를 넘겨준다.
  //}----------------------------------------------------------------

  //[2005.10.31.월][수정!!!]{-----------------------------------------------------
  //이곳에는 char, short, int, long, unsigned, signed, float, double
  //등의 기본 data type 이 저장되고, 기본 data type 과는 별도로 사용자가 정의하여
  //추가되는 data type 은 구조체/공용체 type 이 유일하다.
  //이 곳에 저장된 type 은 parser() 시에 각종 tree 에서 type 을 검사할때 목록을
  //제공하게 된다.
  //}-----------------------------------------------------------------------------

  char type[OPT_name_length];

  //[2005.10.31.월][추가!!!]
  //새롭게 추가되는 type 은 구조체/공용체 type 이 현재로써 유일하므로
  //이두 종류 type 의 관리를 위하여 선언정보를 담은 {DATABASE} 상의 record-index 를
  //저장한다. char, int 등의 기본 type 은 이 정보가 필요 없으므로 -1 로 기본값을 가진다.
  int  rec_index; //(BASE : -1)

  //[2005.11.1.화][참고!!!]{--------------------------
  //FILL_Type() 함수로 기본 초기화를 하므로 참고한다.
  //기본 type 의 경우 배치 순서가 중요하다.
  //}-------------------------------------------------

  //[2007.07.20.금][추가!!!]
  //{
      //해당 [type] 의 byte 단위 크기를 저장한다.
      //이는 매우 중요한 정보로 일반 [c-type] 은 미리 크기가 정해져 있으나
      //[구조체/공용체] 의 경우는 [선언] 하면서 [선언] 의 끝에 일괄적으로 완전히
      //크기를 계산할수 있으므로 모든 크기는 바로바로 계산하여 이곳에 저장할수 있도록 한다.
      //이는 [1차번역시] type 의 크기 정보가 필요하기 때문이다.
      long long  size;

  //}

};

struct DEFINEITEM
{
  //[2005.10.15.토][추가!!!]{---------------------------------------
  //define 으로 정의되는 문자열을 관리한다.
  //실제 record 상에는 definelist[] 상의 index 가 기록되게 한다.
  //memory 를 절약하기 위한 방법으로 문자열을 따로 관리하는 것이다.
  //}---------------------------------------------------------------

  //[2006.01.09.월][중요!!!]{------------------------------------------------------
  //이전과 달리 #define 은 code 가 아니므로 {DATABASE} 에 저장하지 않는다.
  //즉, #define 만의 별도 {database} 를 운영하는 것이다.
  //}------------------------------------------------------------------------------

  //[2006.01.09.월][추가!!!]{---------------------------------
  //#define 으로 정의된 name 까지 이곳에 전부 저장한다.
  char defname[OPT_name_length];
  int  index;                    //해당 file buf[] 상의 위치.
  int  filelistindex;            //선언된 file 의 번호.
  //}---------------------------------------------------------

  //{-----------------------------------------------
  //길이는 표중 define 정의 문자열 길이로 설정한다.
  char defstr[OPT_define_string_length];
  //}-----------------------------------------------

  //definelist[] 초기화 함수 수정등, 관련 함수등 전부 수정해 준다!!!

};

struct USELABELITEM
{
  //[2006.02.14.화][추가!!!]{-------------------------------------------
  //소스에서 사용된 [라벨] 을 수집한다. 부가 정보 이므로 별도 관리한다.
  //[선언라벨] 은 {DATABASE} 에 정리된다.
  //}-------------------------------------------------------------------

  char name[OPT_name_length];  //[사용라벨] name.
  int  filelistindex;          //[사용라벨] 이 위치한 filelistindex.

  //[영역정보]{-----------------------------------------------------
  //영역 정보는 parserinfo.area_gl 의 값을 그대로 할당 받으면 된다.
  //해당 함수 영역이 된다.
  int  area;                   //[사용라벨] 이 위치하는 함수영역.
  //}---------------------------------------------------------------

  //[2008.11.08.토][추가!!!]
  //{
      //보다 자세한 정보를 얻기 위하여 정보를 추가한다.

      //사용된 행번호를 저장한다.
      int    line;          //(BASE : -1)

      //저장소 상의 위치를 저장한다.
      int    index;         //(BASE : -1)

      //{DATABASE} 상의 [선언라벨] 의 record-index 를 저장한다.
      //이 변수는 TREE_FunctionDefinition() 함수에서 함수안에서 사용된 라벨의 일치 검사시 처리된다.
      int    defRecIndex;   //(BASE : -1)

  //}

};

struct STRINGLIST
{
  //[문자열 관리][2006.06.02.금][추가!!!]{------------------------------------
  //소스에 사용된 문자열을 관리한다.
  //[문자열] 의 경우는 별도로 일괄 수집하여 소스코드 끝에 붙여 주게 되므로
  //이를 위하여 버퍼를 만들어서 일단 모아 주어야 한다.
  //각 [문자열] 은 행단위로 저장되어야 한다.
  //S.x: "문자열 그대로..."
  //의 형식으로 저장되며, 일종의 라벨로 관리 되므로 symbol 을 앞에 붙어 준다.
  //이것은 1 차 번역을 위하여 필요한 것이다.
  //크기는 *.c 소스 파일 크기 정도로 동적 생성한다.
  //문자열은 *.h 와 *.c 안에서만 존재하므로 그리 큰 크기가 아니어도 된다.
  //file 개념이므로 전체가 하나의 거대한 문자열이 된다.
  //}-------------------------------------------------------------------------

  //[2007.07.30.월][추가!!!]
  //{
      //이 정보는 [프로젝트] 단위로 1개만 존재하며, [프로젝트] 안의 모든 파일에서
      //사용된 [문자열] 전부를 발견 순서대로 가지게 된다.
      //행번호는 곧 문자열의 S.x 의 x 가 된다.
      //수집된 [문자열] 은 각각의 *.c 파일의 *.obj 파일이 합성되어 만들어진
      //"[프로젝트].obj" 파일의 끝에 "#STRING" 다음행에 붙여진다.
  //}

  //문자열을 수집하고 파일로 관리하기 위한 정보 구조체.
  struct  STRBUF   strbuf;

  //문자열을 symbol 화 라벨로 정보를 추가 하는 경우, 이 라벨을 서로 구분하기
  //위한 것으로 ++ 되면서 증가한다.
  int              stringcount;

  //[2009.01.07.수][추가!!!]
  //{
      //[!]{------------------------------------------------------------------------
      //이전과 달리 [*.t] 로 번역하는 도중 함수안에서 사용된 문자열은 수집하면서
      //[문자열 길이] 을 바탕으로 "FD.X.STR.{:" 을 [기준] 으로한 자체 [추가주소] 를
      //바로 구할수 있어서 이를 [1차번역기호] 에 바로 추가해 준다.
      //즉, [문자열] 처리를 보다 간단하게 하기 위하여 이전과 달리 [문자열번호] 를
      //넣지 않고 [문자열 추가주소] 를 사용한다.
      //이 변수는 이 [추가주소] 를 계산하기 위하여 사용된다.
      //
      // (ADR)C.S.[문자열 변호] -> (ADR)C.S.[추가주소]
      //
      //형식으로 변경한다.
      //이 [추가주소] 는 [*.asm] 문서로 번역시 S(문자열 세그먼트:상수) 와 더해져서
      //실제 사용할수 있는 정확한 위치로 바뀌게 된다.
      //}---------------------------------------------------------------------------

      unsigned long long  ofsAdr; //(BASE : 0)

  //}

};    

//[부가정보]{===================================================================

struct KEYWORDLIST
{
  //[2005.08.27.토][생성!!!]{--------------------------------
  //keyword 목록을 가진다.
  //이는 포인터가 아니고 완전한 문자열을 가지고 있어야 한다.
  //모든 keyword 는 10 자를 넘지 않는다.
  //}--------------------------------------------------------

  char kw[OPT_keyword_length];
};

struct OPERATORLIST
{
  //[2005.08.27.토][생성!!!]{--------------------------------
  //keyword 목록을 가진다.
  //이는 포인터가 아니고 완전한 문자열을 가지고 있어야 한다.
  //모든 keyword 는 10 자를 넘지 않는다.
  //}--------------------------------------------------------

  char op[OPT_operator_length];
};

struct SIGNLIST
{
  //[2005.08.27.토][생성!!!]{---------------------------
  //[각종 기호] 목록을 가진다.
  //이는 (, ), { 등 operator 를 제외한 기호가 들어간다.
  //}---------------------------------------------------

  char sign[OPT_sign_length];
};

struct ESCAPELIST
{
  //[2005.08.27.토][생성!!!]{--------------
  //지원 가능한 escape 문자 목록을 가진다.
  //}--------------------------------------

  char escape[OPT_escape_length];
};

//}=============================================================================

struct ERRORINFO
{
  //[2006.04.15.금][생성!!!]{------------------
  //error 관련 정보를 저장한다.
  //이 정보는 {DATABASE} 안에 저장되어야 한다.
  //}------------------------------------------

  //에러 문자열을 저장한다.
  struct  STRBUF  strbuf;

  //error 가 발생한 단어를 저장한다.
  char            word[OPT_name_length];

  //error 가 발생한 행을 기록한다.
  int             line;

  //[2009.02.18.수][추가!!!]
  //[오류] 가 있는 문서를 저장한다.
  char            fileFullName[OPT_filepath_length];

};


class DATABASE
{
  private:
  public:
  //{
      //**************************************************
      //record 에 직접 외부 에서 접근 할수 없도록 만든다.
      //**************************************************


      //{-----------------------------------------
      //data base 를 구성하는 record 를 선언한다.
      struct  RECORD  record[OPT_record_size];
      int             record_count; //(base: 0)
      //}----------------------------------------- 


      //{--------------------------------------------------------
      //record 에 사용할 기타 정보를 만든다.
      //각각 전용 처리 함수로 입출력을 수행해야 한다.
      //각각의 list[] 는 자체 count 를 위한 변수를 가진다.
      struct  FILELIST      filelist[OPT_file_name_list_size];
      int                   filelist_count;   //(base:0)

      struct  TYPELIST      typelist[OPT_type_list_size];
      int                   typelist_count;   //(base:0)

      //[2005.10.15.토][추가!!!]
      struct  DEFINEITEM    definelist[OPT_define_list_size];
      int                   definelist_count; //(base:0);

      //[2006.02.14.화][추가!!!]
      //{
          //----------------------------------------------------------
          //[사용라벨] 에 대한 정보를 저장한다.
          //계속 저장만하고 실제 "삭제" 는 하지 않는다.
          //[2006.06.23.금][수정!!!]
          //{
              //------------------------------------------------------------
              //record 의 모든 정보가 중복되는 경우는 추가하지 않아야 한다.
              //실제 이 index 정보를 1 차 번역시에 사용하기 때문이다.
              //------------------------------------------------------------
          //}

          struct  USELABELITEM  uselabellist[OPT_uselabel_list_size];
          int                   uselabellist_count;
          //----------------------------------------------------------
      //}    

      //[문자열 관리]
      //{
          //[2009.01.07.수][추가!!!]{------------------------------------------------
          //이전에 간단한 정보로 있던 다시 분류 항목으로 명시적으로 관리한다.
          //이는 [*.t] -> [*.asm] 으로 번역시 더 많은 정보를 처리해야 하기 때문이다.
          //}------------------------------------------------------------------------

          //[2006.06.02.금][추가!!!]
          struct  STRINGLIST    stringlist;

      //}


      //[기타 정보]{---------------------------------------------
      struct  KEYWORDLIST   keywordlist[OPT_keyword_list_size];
      struct  OPERATORLIST  operatorlist[OPT_operatorlist_size];
      struct  SIGNLIST      signlist[OPT_signlist_size];
      struct  ESCAPELIST    escapelist[OPT_escapelist_size];
      //}--------------------------------------------------------
  //}

  public:
  //{
      //[2005.09.09.금][추가!!!]{--------------------------------------------------
      //실제 [parser] 수행시 추출하는 단어등의 정보를 가진다.
      //"오직 한개만" 있을수 있으며 모든 추출 단어 정보는 이곳에 저장 되어야 하고,
      //사용하는 모든 함수는 이 것을 pointer 로 전달받아서 처리해야 한다.
      struct PARSERINFO parserinfo;
      //}--------------------------------------------------------------------------

      //[parserinfostack]{----------------------------------------------------------
      //#include 등에 따른 file 처리를 Push(), Pop() 의 형태로 하기 위하여
      //filename 을 stack 과 같이 관리하기 위한 저장소.
      //실제 parser 진행시 include 등을 만났을 경우 stack 형식으로 사용되므로
      //약 100 개 정도면 과도할 정도로 충분하다. 이곳에는 현재의 parserinfo
      //정보를 통째로 저장해야 한다.
      struct PARSERINFO parserinfostack[OPT_parserinfostack_size];
      int               parserinfostack_count;

      //[2006.05.09.화][추가!!!]
      //{
          //------------------------------------------------------------------
          //#define 정의 [문자열] 을 call 할때마다 ++ 된다.
          //이것은 parser.h 안의 Get_NextWord() 안에서 #define 정의 [이름] 을
          //처리할때 같이 처리된다.
          int definecall_count;
          //------------------------------------------------------------------
      //}

      //bool __fastcall PARSERINFOSTAC_Push(struct PARSERINFO *pPARSERINFO);
      //bool __fastcall PARSERINFOSTACK_Pop(struct PARSERINFO *pPARSERINFO);
      //등 2 개의 함수만으로만 접근 할수 있다.
      //모든 정보는 동일하지만 [파일버퍼] 의 경우는 다시 파일을 열때 새롭게 재 설정
      //되므로 이 것만큼은 새로 설정이 되어야 한다.(별도 처리 과정이 있어야 한다.)
      //이는 [파일열기] 함수에서 자동으로 처리되어야 한다.
      //}---------------------------------------------------------------------------


      //[2006.04.15.금][추가!!!]{--
      //error 정보를 갖는다.
      struct ERRORINFO  errorinfo;
      //}--------------------------


      //[중요 PATH]
      //{
          //[참고]{-----------------------------------------------------------
          //순수하게 path 만 저장해야 한다.
          //실제 path 와 순수 filename 을 따로 합쳐서 fullpath 를 생성하므로.
          //이때 사용하게 된다.
          //}-----------------------------------------------------------------

          //[program 경로]{-------------------------------------------------------------
          //IDE 자체의 실행 경로가 된다.
          //현재 실행되는 프로그램(*.exe) 의 경로를 가진다.
          //순수 문자열로 copy 해서 저장한다.(대략 1000 개 문자를 저장하는 것으로 설정)
          char  programpath[OPT_programpath_length];
          //이 실행 파일이 시작하는 과정에서 이 곳에 넣어 주어야 한다.
          //사실상 이 class 생성이 먼저 이루어 지므로 저장 공간은 먼저 확보되 있다.
          //}---------------------------------------------------------------------------

          //[2005.09.20.화][추가!!!]

          //[compiler 경로]{--------------------------------------
          //parser, compiler, linker 등의 실행 경로가 된다.
          //이들 실행 파일은 전부 같은 경로에 위치해 있어야 한다.
          char  compilerpath[OPT_compilerpath_length];
          //}-----------------------------------------------------

          //[project 경로]
          //{
              //현재 선택된 project file(*.prj) 의 경로를 저장한다.
              char  projectpath[OPT_projectpath_length];

              //지금 처리 중인 project 의 전체 경로를 저장한다.
              char  projectname[OPT_projectname_length];

          //}

          //[2006.06.07.수][추가!!!]{----------------------------------------------
          //Build 시 생성되는 모든 file 을 담을 경로를 가진다.
          //기본적으로 "Build" 라는 폴더이름을 같고 *.prj 와 같은 경로에 존재한다.
          //*.t, *.obj. *.vm. *.lib 등 임시 생성되는 모든 file 을 이곳에 저장한다.
          char  buildpath[OPT_buildpath_length];
          //}----------------------------------------------------------------------

          //[2009.01.28.수][추가!!!]
          //{
              //[검증정보] 를 저장할 겅로를 가진다.
              char  debugPath[OPT_debugPath_length];

          //}

      //}


      //[2005.09.08.목][추가!!!]
      //{
          //파일을 열고 닫을때는 항상 이 구조체 정보를 대상으로 수행하고 이 과정에서
          //얻어진 부가 정보도 다시 이곳에 저장한다.
          //항상 현재 처리되고 있는 file 의 정보를 가지고 있어야 한다.
          struct FILEINFO  fileinfo;

      //}


      //[temp-file 정보]
      //{
          //[2006.06.05]{---------------------------------------------------------
          //temp-file 을 저장하기 위한 정보 구조체.
          //1 차 번역시 생성되는 *.t 파일을 만들기 위한 임시 파일.
          //이 file 은 *.c 를 parser() 로 처리하면서 생성된다.
          //
          //[2008.11.16.일][수정!!!]
          //*.c 크기의 OPT_Tempfile_SizeFactor 배율로 생성되며 이 크기를 초과하여
          //저장해야 하는 경우는 자동으로 이전 크기보다 지정 비율로 더큰 저장소를
          //생성하여 이것으로 다시 대체하는 방법을 사용한다.
          //이는 메모리를 절약하고 효율적으로 관리 하기 위한 것이다.
          //}---------------------------------------------------------------------

          struct  STRBUF   tempfile;
          char             tempfilename[OPT_file_name_length];

      //}


      //[임시변수들]
      //{
          //이는 다른 함수 내부에서 여러개의 임시 변수가 난립하는 것을 막아 주기
          //위한 것이다. 주로 {DATABASE} 관련 함수에 포인터로 [인수] 를 넘겨줄때
          //값을 일시 저장할 목적으로 사용한다.
          //외부 함수에서 직접 접근 할수 있어야 하므로 [public:] 영역에다 선언한다.
          //
          //다른 record 등을 추가할떄 일괄 추가를 위해서 한개의 record 를
          //일시 저장할수 있는 일종의 전역 변수를 만든다. 이는 record 저장
          //함수의 인수로 바로 값을 넘기기 위한 것이다. 1 개만으로 충분하다.
          //그러나 꼭, 사용할 필요는 없다.

          struct  RECORD  temprecord;

      //}

      //[주소 관련]
      //{
          //[2008.11.06.목][추가!!!]{-------------------------------
          //DATA 의 주소를 계산하고 관리 하기 위한 정보를 선언한다.
          //}-------------------------------------------------------

          //[@DATA 관련]
          //{
              //@DATA 를 기준으로 정해지는 [전역변수] 의 offset address 를 관리한다.
              //[전역변수] 는 순서대로 저장되며 순서대로 저장될때 사전에 이 정보로 자신의
              //offset address 를 알수 있게 된다.

              unsigned long long     _DATA_ofsADR;  //(BASE : 0)

          //}

      //}

      //[STRHEAP 관련]
      //{
          //[2012.04.20-1.목][추가!!!]{---------------------------------------
          //[문자열] 은 [STRHEAP] 으로 별도 관리.
          //작은 동적 생성으로 인한 부하를 줄이고 관리를 쉽게 하기위한것.
          //기본 크기는 <d_STRHEAP_Heap_addSize>, <d_STRHEAP_List_addSize> 의
          //[재생성] 시 추가 크기 증가분 정도면 충분하다.
          //}-----------------------------------------------------------------

          struct STRHEAP  _strHeap;

      //}

      //[CLASS]
      //{
          //[2012.05.17.목][완료!!!]
          __fastcall DATABASE(void);

          //[2012.05.17.목][완료!!!]
          __fastcall ~DATABASE(void);

      //}

      //[DATABASE_INIT]
      //{
          //[2012.04.22.일][완료!!!]
          //[STRHEAP] 지우기/생성.
          void __fastcall Init(void);

          //[2007.07.20.금][완료!!!]
          void __fastcall FILL_Type(void);

          //[2012.04.28.토][완료!!!]
          void __fastcall Delete(void);


      //}

      //[RECORD]
      //{
          //[2012.04.22.일][완료!!!]
          void __fastcall REC_Init(struct RECORD *pRECORD);

          //[2012.04.20-1.목][완료!!!]
          void __fastcall REC_Format(struct RECORD *pRECORD);

          bool __fastcall REC_Write(int            pRECindex,
                                    struct RECORD *pRECORD);

          //[2012.04.22.일][완료!!!]
          bool __fastcall REC_Field_Write(struct RECORD *pRECORD,
                                          int            pFIELDindex1,
                                          int            pFIELDindex2,
                                          void          *pDATA);

          bool __fastcall REC_Field_Write2(int   pRECORDindex,
                                           int   pFIELDindex1,
                                           int   pFIELDindex2,
                                           void *pDATA);

          //[2012.04.20-1.목][완료!!!]
          bool __fastcall REC_Field_Read(struct RECORD *pRECORD,
                                         int            pFIELDindex1,
                                         int            pFIELDindex2,
                                         void          *pDATA);

          bool __fastcall REC_Field_Read2(int   pRECORDindex,
                                          int   pFIELDindex1,
                                          int   pFIELDindex2,
                                          void *pDATA);

          bool __fastcall REC_Add(struct  RECORD *pRECORD,
                                  int            *pRECindex);

          //[2012.04.20-1.목][주석처리!!!]
          //사용되는 곳이 없다.
          //bool __fastcall REC_Delete(int  pDELETEindex);

          bool __fastcall REC_Insert(int             pINSERTindex,
                                     struct  RECORD *pRECORD);

          //[2009.05.13.수][완료!!]
          //이 함수는 사용된 곳이 없음.
          //bool __fastcall REC_Search_withName(int   pSTARTindex,
          //                                    char *pNAME,
          //                                    int  *pRECindex);

          //[2009.03.28.토][완료!!!]
          bool __fastcall REC_Search_withNameAndArea(//검색 시작 위치.
                                                     int   pStartIndex,
                                                     //찾는 이름.
                                                     char *pName,
                                                     //대상 영역.
                                                     int   pArea,
                                                     //전체 {DATABASE} 를 대상으로 검사하는 경우는 true.
                                                     bool  pEntire,
                                                     //찾은 위치.
                                                     int  *rRecIndex);

          //[2009.03.26.목][확인완료!!!]
          bool __fastcall REC_Search_withName_inFile(int   pSTARTindex,
                                                     int   pFILELISTindex,
                                                     char *pNAME,
                                                     int  *pRECindex);

          //[2009.03.26.목][확인완료!!!]
          bool __fastcall REC_Search_withName_inAllFile(int   pSTARTindex,
                                                        int   pFILELISTindex,
                                                        char *pNAME,
                                                        int  *pRECindex);

          //[2021.02.21.일][완료]
          bool __fastcall REC_Search_Member_withName_inAllFile(//검색을 시작할 <record-index>.
                                                               int   pStartIndex,
                                                               //문서 번호.
                                                               int   pFileListIndex,
                                                               //검사할 [이름].
                                                               char *pName,
                                                               //찾은 <record-index>.
                                                               int  *pRecIndex);

          //[2009.03.26.목][확인완료!!!]
          bool __fastcall REC_Search_withArea_Name_inAllFile(int   pSTARTindex,
                                                             int   pFILELISTindex,
                                                             int   pAREA,
                                                             char *pNAME,
                                                             int  *pRECindex);

          void __fastcall REC_Get_RecordCount(int *pRECcount);

          //[2008.11.06.목][완료!!!]
          void __fastcall REC_GlobalData_EtcInfo(int   pRecIndex);

          //[2008.12.14.일][완료!!!]
          void __fastcall Rec_Size_Read(int         pRecIndex,
                                        long long  *rSize);

          //[2008.12.26.금][완료!!!]
          void __fastcall Rec_Address_Read(int                  pRecIndex,
                                           unsigned long long  *rAddress);

      //}

      //[FILELIST]
      //{
          bool __fastcall FILELIST_Add(char *pFILEname,
                                       int   pFILEsize);

          void __fastcall FILELIST_GetIndex_WithName(char *pFILEname,
                                                     int  *pINDEX);

          bool __fastcall FILELIST_GetName_WithIndex(int pINDEX,
                                                     char *pFILEname);

          bool __fastcall FILELIST_GetSize_WithIndex(int  pINDEX,
                                                     int *pSIZE);

          //[2012.04.08.일][완료!!!]
          bool __fastcall FILELIST_Add_IncludeList(//[2012.04.08.일][추가!!!]
                                                   //오류 문자열 추가를 위한것.
                                                   class  DATABASE  *pDatabase,
                                                   int    pNowFileIndex,
                                                   int    pIncludeFileIndex);

          //[2012.04.08.일][완료!!!]
          bool __fastcall FILELIST_Add_IncludeListTotal(//[2012.04.08.일][추가!!!]
                                                        //오류 문자열 추가를 위한것.
                                                        class  DATABASE  *pDatabase,
                                                        //<include> 한 문서.
                                                        int    pNowFileIndex,
                                                        //<include> 된 문서.
                                                        int    pIncFileIndex);

          //[2012.04.08.일][완료!!!]
          bool __fastcall FILELIST_Add_IncludeListTotal2(//[2012.04.08.일][추가!!!]
                                                         //오류 문자열 추가를 위한것.
                                                         class  DATABASE  *pDatabase,
                                                         //<include> 한 문서.
                                                         int    pNowFileIndex,
                                                         //<include> 된 문서.
                                                         int    pIncFileIndex);

      //}

      //[TYPELISrec_indexT]
      //{
          //[2007.07.20.금][완료!!!]
          bool __fastcall TYPELIST_Add(char *pSTR,
                                       int   pRECindex,
                                       int  *rTYPELISTindex);
          //[2007.07.20.금][완료!!!]
          bool __fastcall TYPELIST_Set_Size(int        pTYPELISTindex,
                                            long long  pTYPEsize);


          void __fastcall TYPELIST_GetTypeIndex_withNAME(char *pTYPE,
                                                         int  *pINDEX);

                                                         
          bool __fastcall TYPELIST_IS_IntType(int pTYPELISTINDEX);

          //[완료!!!][2006.08.12.토]
          bool __fastcall TYPELIST_IS_FloatType(int pTYPELISTINDEX);

          //[완료!!!][2006.04.19.수]
          bool __fastcall TYPELIST_IS_StructType(int pTYPELISTindex);

          //[완료!!!][2006.04.19.수]
          bool __fastcall TYPELIST_IS_UnionType(int pTYPELISTindex);

          //[완료!!!][2006.04.19.수]
          bool __fastcall TYPELIST_IS_C_DataType(int pTYPELISTINDEX);

          int __fastcall TYPELIST_Get_Count(void);

          int __fastcall TYPELIST_Get_RecIndex(int pTYPELISTindex);

          //[2007.07.20.금][완료!!!]
          long long __fastcall TYPELIST_Get_Size(int pTYPELISTindex);


          //[2008.10.21.화][완료!!!]
          bool __fastcall TYPELIST_Get_IntegerTypeName(int   pTypelistIndex,
                                                       char  rTypeName[]);

          //[2008.10.21.화][완료!!!]
          bool __fastcall TYPELIST_Is_Family(int  pTypelistIndexA,
                                             int  pTypelistIndexB);

          //[2008.12.25.목][완료!!!]
          bool __fastcall TYPELIST_Is_Unsigned(int  pTypelistindex);



          //[CTYPE][2006.04.22.토][생성!!!]
          //{
              //처리를 쉽게 하기 위하여 새로운 type 을 만든다.
              #define  CTYPEETCINFO           unsigned char

              //1 byte 의 값에 간단한 정보를 가진다.
              //아래의 값으로 & 를 사용하여 bit-mask 로 사용한다.
              #define  ctypeETCinfo_size4     0x0f  //bit[0~3] 의 값이 1 ~ 8 까지 크기.
              #define  ctypeETCinfo_sign1     0x10  //bit[4] (1:signed) (0:unsigned)
              #define  ctypeETCinfo_if1       0x20  //bit[5] (1:실수) (0:정수)

              //[완료!!!][2006.04.23.일]
              CTYPEETCINFO CTYPE_Get_EtcInfo(int pTYPELISTindex);

              //[완료!!!][2006.04.23.일]
              int CTYPE_Get_Bigger_TypeListIndex(CTYPEETCINFO pAtype,
                                                 CTYPEETCINFO pBtype);

              //[완료!!!][2006.04.23.일]
              int CTYPE_TypeListIndex(int pAtypelistindex,
                                      int pBtypelistindex);
                                      
          //}

      //}

      //[SIZE][2007.07.21.토][추가!!!]
      //{
          //[2008.11.02.일][완료!!!]
          void __fastcall SIZE_Data(int         pRECindex,
                                    long long  *rSIZE);
                                                                     
          //[2007.07.21.토][완료!!!]
          void __fastcall SIZE_Array(int         pRECindex,
                                     long long  *rSIZE);

          //[2008.11.06.목][완료!!!]
          void __fastcall SIZE_StructType(int         pRECindex,
                                          long long  *rSIZE);

          //[2008.11.06.목][완료!!!]
          void __fastcall SIZE_UnionType(int         pRECindex,
                                         long long  *rSIZE);

          //[2007.07.24.화][완료!!!]
          void __fastcall SIZE_ArrayElement(//[type] 관련 정보.
                                            long long   pTYPEsize,
                                            //[포인터] 인지 확인만 하기 위한것.
                                            int         pPOINTER,
                                            //[배열] 관련 정보.
                                            int         pDIMENSION,
                                            int         pARRAYsize[],
                                            long long  *rSIZE);

          //[2007.08.01.수][완료!!!]
          void __fastcall SIZE_Pointer(//[type] 관련 정보.
                                       long long   pTYPEsize,
                                       //[포인터] 차원 정보.
                                       int         pPOINTER,
                                       long long  *rSIZE);

          //[2008.10.14.화][완료!!!]
          void __fastcall SIZE_SYMBOL_1ST_Type(char        pSYMBOL[],
                                               int         pOrgTypeListIndex, //[2008.10.14.화][추가!!!]
                                               long long  *rSIZE);

      //}

      //[DEFINELIST]
      //{                           
          //[완료!!!]
          void __fastcall DEFINELIST_Format(struct DEFINEITEM *pDEFINELIST);
          //[완료!!!]
          bool __fastcall DEFINELIST_Add(struct DEFINEITEM *pDEFINELIST);
          //[완료!!!]
          bool __fastcall DEFINELIST_Delete(int pDELETEindex);
          //[완료!!!]
          bool __fastcall DEFINELIST_Search_withName_inFile(int   pSTARTindex,
                                                            int   pFILELISTindex,
                                                            char *pNAME,
                                                            int  *pDEFINELISTindex);

          //[2008.11.09.일][완료!!!]
          bool __fastcall DEFINELIST_Search_withName_inAllFile(int   pSTARTindex,
                                                               int   pFILELISTindex,
                                                               char *pNAME,
                                                               int  *pDEFINELISTindex);

          //[완료!!!][2006.05.09.화]
          void __fastcall DEFINELIST_Get_StrHandle(int     pDEFILELISTindex,
                                                   char  **pDEFstr);


          //[2012.04.05.목][완료!!!]
          bool __fastcall DEFINELIST_Search_withName(int    pStartIndex,
                                                     char  *pName,
                                                     int   *rDefineListIndex);


          //[2012.04.07.토][완료!!!]
          bool __fastcall DEFINELIST_Search_withName_Total(//현재 문서 번호.
                                                           int    pFileListIndex,
                                                           char  *pName,
                                                           int   *rDefineListIndex);

      //}

      //[USELABELLIST]
      //{
          bool __fastcall USELABELLIST_Add(struct USELABELITEM *pLABELinfo,
                                           int                 *pUSELABELLISTindex);

          //[2009.05.22.금][중요수정완료!!!]
          bool __fastcall USELABELLIST_CheckAllDefine(//검사할 라벨이 있는 함수(영역) index.
                                                      int                   pFuncRecIndex,
                                                      //[선언라벨] 이 없는 [사용라벨] 의 정보.
                                                      struct USELABELITEM  *rEorUseLabelInfo);

          //[2008.12.09.화][완료!!!]
          void __fastcall USELABELLIST_GetDefLabelRecindex(//[사용라벨] index.
                                                           int   pUseLabelListIndex,
                                                           //[선언라벨] 의 recindex.
                                                           int  *rDefLabelRecindex);

      //}


      //[STRINGLIST]
      //{
          //[2012.04.28.토][완료!!!]
          void __fastcall STRINGLIST_FirstInit(void);

          //[2009.01.07.수][완료!!!]
          void __fastcall STRINGLIST_Init(void);

          //[2009.01.07.수][완료!!!]
          void __fastcall STRINGLIST_Create(int pSIZE);

          //[2012.04.28.토][완료!!!]
          void __fastcall STRINGLIST_Delete(void);

          //[2009.05.14.목][완료!!!]
          void __fastcall STRINGLIST_Add(char                *pStr,
                                         int                 *rStringlistIndex,
                                         //[2009.01.07.수][수정!!!]
                                         //현 문자열의 _STR_:BASE 의 [추가주소] 를 반환한다.
                                         unsigned long long  *rStrOfsAdr);

          //[2008.11.11.화][완료!!!]
          void __fastcall STRINGLIST_FuncInit(void);

          //[2009.05.14.목][완료!!!]
          void __fastcall STRINGLIST_TempFile_Add(void);

          //[2008.11.17.월][완료!!!]
          bool __fastcall STRINGLIST_IsEmpty(void);

          //[2012.02.22.수][완료!!!]
          int __fastcall STRINGLIST_StrLength(//실제는 [행번호] 이고 0 부터 시작.
                                              int  pStrIndex);

          //[2009.05.14.목][폐기!!!]
          //void __fastcall STRINGLIST_Get_OfsAdrStr(char  rOfsAdrStr[]);

      //}


      //[PARSERINFO]
      //{
          //[2012.06.22.금][완료!!!]
          void __fastcall PARSERINFO_Format(struct PARSERINFO *pPARSERINFO);

          //[완료!!!][2006.05.09]
          void __fastcall PARSERINFO_Backup(struct PARSERINFO *pBACKUPinfo,
                                            struct PARSERINFO *pPARSERinfo);

          //[완료!!!][2006.05.09]
          void __fastcall PARSERINFO_Restore(struct PARSERINFO *pBACKUPinfo,
                                             struct PARSERINFO *pPARSERinfo);

      //}

      //[PARSERINFOSTACK]
      //{
          bool __fastcall PARSERINFOSTACK_Push(struct PARSERINFO *pPARSERINFO);

          bool __fastcall PARSERINFOSTACK_Pop(struct PARSERINFO *pPARSERINFO);

      //}

      //[FILEINFO]
      //{
          //[2012.04.27.금][완료!!!]
          void __fastcall FILEINFO_FirstInit(struct FILEINFO  *pFileInfo);

          //[2012.04.27.금][완료!!!]
          void __fastcall FILEINFO_Delete(struct FILEINFO *pFileInfo);

          

          void __fastcall FILEINFO_Format(struct FILEINFO *pFILEINFO);

      //}

      //[ERRORINFO]
      //{
          //[2012.04.27.금][완료!!!]
          void __fastcall ERRORINFO_Init(void);

          //[완료!!!][2006.05.02.화]
          void __fastcall ERRORINFO_Line(int pERRORline);

          //[완료!!!][2006.05.02.화]
          void __fastcall ERRORINFO_Add(char *pSTR);

          //[완료!!!][2006.05.02.화]
          void __fastcall ERRORINFO_Word(char *pERRORword);

      //}

      //[IS]
      //{
          bool __fastcall IS_Name(struct PARSERINFO *pPARSERinfo,
                                  char              *pWORD,
                                  bool              *pBOOL);

          //[2009.03.26.목][완료!!!]
          bool __fastcall Is_FunctionName(struct PARSERINFO *pParserInfo,
                                          char              *pWord,
                                          bool              *rBool,
                                          int               *rFuncRecIndex);

          //[2009.03.27.금][완료!!!]
          bool __fastcall Is_LocalVar(struct PARSERINFO *pParserInfo,
                                      char              *pWord,
                                      int                pArea,
                                      int               *rVarRecIndex);

          bool __fastcall IS_HexNumber(char *pWORD);
          bool __fastcall IS_BinaryNumber(char *pWORD);
          bool __fastcall IS_DecNumber(char *pWORD);
          bool __fastcall IS_FloatNumber(char *pWORD);


          //[작성중!!!]
          bool __fastcall IS_Keyword(char *pWORD);
          bool __fastcall IS_Operator(char *pWORD);
          bool __fastcall IS_Sign(char *pWORD);
          bool __fastcall IS_Escape(char *pWORD);


          //[2012.02.19.일][완료!!!]
          bool __fastcall IS_PreOperator(char *pWORD);

          bool __fastcall IS_PostOperator(char *pWORD);
          bool __fastcall IS_BiOperator(char *pWORD);
      //}

      //[ETC]
      //{
          //[완료!!!][2006.03.10.금]
          bool __fastcall GetFuncParamCount(int  pFUNCrecINDEX,
                                            int *pFUNCparamCOUNT);

          //[2009.03.28.토][완료!!!]
          void __fastcall Is_StructMember_withName(//[구조체] 의 <typelistindex>.
                                                   int   pStructTypelistindex,
                                                   //검색할 이름.
                                                   char *pWord,
                                                   //찾은 위치.
                                                   int  *rRecIndex);

          //[2009.03.28.토][완료!!!]
          void __fastcall Is_UnionMember_withName(//[공용체] 의 <typelistindex>.
                                                  int   pUnionTypelistindex,
                                                  //검색할 이름.
                                                  char *pWord,
                                                  //찾은 위치.
                                                  int  *rRecIndex);

          //[2021.02.21.일][중요수정완료]
          bool __fastcall IS_Struct_Union_Member_withNAME(int   pFILELISTindex,
                                                          char *pNAME,
                                                          int  *pRECindex);

          //[2009.03.28.토][완료!!!]
          //bool __fastcall IS_StructMember_withRECINDEX(int  pStructTypelistindex,
          //                                             int  pRecIndex);

          //[2009.03.28.토][완료!!!]
          //bool __fastcall IS_UnionMember_withRECINDEX(int  pUnionTypelistindex,
          //                                            int  pRecIndex);

          //[2007.07.13.금][완료!!!]
          //bool __fastcall IS_Struct_Union_Member_withRECINDEX(int   pRECindex,
          //                                                    int  *rMOTHERindex);

          //[2012.04.06.금][완료!!!]
          void __fastcall GET_FunctionLoaclTotal(int         pFuncRecIndex,
                                                 long long  *rLocalTotal);

          //[2008.12.14.일][완료!!!]
          void __fastcall Get_1st_FunctionParamListStr(int   pFuncRecIndex,
                                                       char  rParamListStr[]);

          //[2008.12.16.화][완료!!!]
          void __fastcall Get_FunctionParamSize(//함수의 record-index.
                                                int         pFuncRecIndex,
                                                //[인수] 의 순번(BASE : 0).
                                                int         pParamXst,
                                                //해당 [인수] 의 크기.
                                                long long  *rParamSize);

      //}

      //[FILE]
      //{
          //[!]{---------------------------------------------------------------
          //이 함수들은 AnsiString 등 일부 전용 class 를 사용하지 않을수 없다.
          //file 처리는 복잡하므로 Borland C++ 의 Library 를 사용해야 하므로.
          //예외로 한다.
          //}------------------------------------------------------------------

          //[2012.05.27.일][완료!!!]
          bool __fastcall FILE_Call_Enter(char *pFILEname);

          //[2012.05.27.일][완료!!!]
          bool __fastcall FILE_Call_Exit(void);

          //일반 파일처리.
          bool __fastcall FILE_Save(char         *pFILEname,
                                    void         *pBUF,
                                    unsigned int  pBUFsize);
      //}

      //[DEBUG]
      //{
          //아래는 debug 용 함수들이다. parser 에서는 사용되지 않고 {DATABASE}
          //안의 내용을 열람 하는데만 사용된다.

          //[2012.04.20-1.목][완료!!!]
          void __fastcall DEBUG_Database_View(void);

      //}

  //}

  //[부가정보]
  //{
      //[실시간 선언 정보 수집 관련
      //{
          //[2012.05.10.목][추가!!!]{------------------------------------------
          //[편집기] 에 보여지는 <infoTree> 를 위한 [실시간 선언정보 수집]
          //내용을 위한 부가 정보 관리.
          //
          //이는 [실시간 선언 정보 수집] 용도로 <Parser()> 를 사용시 현재
          //[입력지정자] 가 위치한 영역의 정보를 수집하기 위하여 사용된다.
          //
          //[초기화] 할 필요는 없고 [실시간 선언정보 수집] 시에 직접 설정된다.
          //}------------------------------------------------------------------

          struct  RTDEFINFOETC  _rtDefInfoEtc;

      //}

      //[식:시작위치 찾기]
      //{
          //[2012.06.19.화][추가!!!]{-----------------------------------------
          //[실시간 선언 정보 수집] 시에 "->", "." [연산자] 가 위치한 [식] 의
          //[시작위치] 를 찾는데 필요.
          //
          //이는 [구성원] 을 보여주기 위하여 [모체 선언형] 을 찾기위한것.
          //}-----------------------------------------------------------------

          //[VAR]
          //{
              struct  RTEXPMARK  _rtExpMark;

          //}

          //[2012.06.19.화][완료!!!]
          void __fastcall RtExpMark_Init(void);

          //[2012.06.23.토][완료!!!]
          void __fastcall RtExpMark_Reset(void);

          //[2012.06.19.화][완료!!!]
          void __fastcall RtExpMark_Push(int  pIndex);

          //[2012.06.21.목][완료!!!]
          void __fastcall RtExpMark_Pop(//[2012.06.21.목][추가!!!]
                                        int  pIndex);

          //[2012.06.19.화][완료!!!]
          void __fastcall RtExpMark_Write(int  pIndex);

          //[2012.06.19.화][완료!!!]
          int __fastcall RtExpMark_Read(void);

          //[2012.06.19.화][완료!!!]
          void __fastcall RtExpMark_OperatorIndex(int  pIndex);

      //}

  //}

  //[범용 정보]
  //{
      //[2012.05.17.목][추가!!!]{----------------------------------------
      //범용으로 사용되는 문자열 관리.
      //[색동문자] 등 처리에 사용된다.
      //각 [목록 구간] 별로 종류를 구분관리 할수 있고 부분적으로
      //비교할수 있어 대단히 편리하다.
      //
      //약 10K 정도면 충분하다.
      //
      //IDE 전체에서 사용하는 것으로 IDE 가 [종료] 될때만 삭제하면 된다.
      //계속 유지 관리 되어야 하는 정보.
      //}----------------------------------------------------------------

      //[VAR]
      //{
          struct STRHEAP  _strHeap_Conf;

          //[!]{-----------------------------
          //반드시 [순서대로] 처리해야 한다.
          //}--------------------------------

          //[고정 정보]
          //{
              //[예약어] 시작/끝 목록 범위.
              int _strHeap_Conf_Keyword_s,
                  _strHeap_Conf_Keyword_e;

              //[2012.05.16+2.금][추가!!!]
              //[연산자] 시작/끝 목록 범위.
              int _strHeap_Conf_Operator_s,
                  _strHeap_Conf_Operator_e;

              //[기호] 시작/끝 목록 범위.
              int _strHeap_Conf_Sign_s,
                  _strHeap_Conf_Sign_e;

          //}

          // ...

          //[가변 정보]
          //{
              //[!]{----------------------------------------------------------------------
              //[구조체/공용체] 선언이름을 저장.
              //단, <Parser()> 후 계속 가변될수 있으므로 [고정항목] 을
              //모두 처리한 가장 마지막에 [재기록] 방식으로 처리한다.
              //아래 [항목범위] 가 <-1> 이 아닌 경우는 이미 설정된 것이 있는 것으로 본다.
              //기존것을 삭제하고 처리해도 무방.
              ///}------------------------------------------------------------------------
              
              int _strHeap_Conf_Type_s,
                  _strHeap_Conf_Type_e;

          //}
              
      //}

      //[2012.05.17.목][완료!!!]
      void __fastcall StrHeapConf_Init(void);

      //[2012.05.16+2.금][완료!!!]
      void __fastcall StrHeapConf_Type(void);
      
  //}

};



//{-------------------------------------------------------------
//다른 소스 지원을 위한 별도 함수.
void __fastcall DATABASE_GetPtr(class DATABASE **pDATABASEptr);
//}-------------------------------------------------------------



//[EXPDATABASE]-----------------------------------------------------------------
struct EXPRECORD
{
  //[2006.03.21.화][생성]{-----------------
  //[식] 을 구성하는 정보를 하나 저장한다.
  //[operand] 와 [operator] 가 해당한다.
  //
  //[2012.06.20.수][중요추가!!!]-----------
  //}--------------------------------------

  //[참고!!!][2006.03.26.일]{------------------------------------------------------
  //구조체, 공용체의 경우는 typelist[] 에 {DATABASE} 상의 record-index 정보가
  //같이 저장되 있으므로, 굳이 여기에 record-index 정보를 따로 보관할 필요는 없다.
  //[함수] 의 경우는 이 [함수] 의 [반환값] 을 data 로 사용하는 것이다.
  //}------------------------------------------------------------------------------


  //[DATA/연산자 를 구분]
  //{
      //---------------------------------------------------------
      bool  Tdata_Fop;              //true:data, false:operator.
      //---------------------------------------------------------
  //}

  //[연산자 인 경우만 해당][2006.07.12.수][수정!!!]
  //{
      //---------------------------------------------------------------------------------
      //이전에는 구조체 member 인 경우의 member 확인 여부를 위하여 name 을 저장했으나
      //exprcord 의 field 정보에 recordindex 가 추가됨으로써 이 정보를 사용하여 간단하게
      //확인 가능하므로 operator 가 아닌 경우는 word[] 에 해당 symbol 을 만들어서
      //저장하는 것으로 수정한다.
      //symbol 은 exprecord 정보가 완전하게 생성된 경우 이 정보를 사용하여 전용 처리
      //함수를 사용하여 만든다.
      char  word[OPT_1st_symbol_length];
      //[연산자] 인 경우만 [처리용 연산자] 단어를 저장한다.

      //[symbol 인 경우]
      //{
          //[2007.07.07.토]
          //전부다 이전안이다. 다시 정리해 주어야 한다.

          //FR.kind.type.pointer.array  : [식] 에 사용된 return 값을 사용하는 함수.
          //G.kind.type.pointer.array   : 전역변수.
          //L.kind.type.pointer.array   : 지역변수.
          //T.kind.type.pointer.array   : 임시변수.
          //S.XXXXXXXX                  : 문자열.
          //CI.XXXXXXXXXXXXXXXX         : 정수상수.
          //CF.XXXXXXXXXXXXXXXX         : 실수상수.
      //}
      //---------------------------------------------------------------------------------
  //}

  //[DATA 인 경우만 해당]
  //{
      //[연산자] 인 경우는 그냥 초기값 그대로 놓아둔다.

      int   kind;                   //[변수/구조체/공용체/값] 의 4 종류가 있다.
                                    //lv, nlv 2개면 된다.
      //{
          #define  exprecKIND_lv    1  //L-value.
          #define  exprecKIND_nlv   2  //no L-value.
      //}

      int   typelistindex;          //data 의 경우는 해당 type.
                                    //operand 가 [상수] 인 경우는 [실수:double/정수:long] 로 둘중 하나가 된다.

      int   pointer;                //pointer 의 차원을 기록.


      //[배열 정보][2006.08.15.화][대폭수정!!!]
      //{
          //이전과 달리 실제 [배열차원] 값을 기록한다.
          //int array[10][4][8] 의 경우는 3 이 들어 간다.
          //"array > 0" 인 경우는 무조건 [배열] 로 판별할수 있다.
          int   array;

          //"array > 0" 인 경우는 [다차원 배열] 이므로 "[]" 연산자를 번역 하기 위하여
          //[차원크기] 정보를 알고 있어야 한다. 이를 기록해 놓는다.(현재 최대 5차원 까지 허용 된다.)
          //다른 경우는 별 의미가 없다.
          int  array_size[5];

          //[중요!!!]
          //{
              //----------------------------------------------------------------------------
              //array 정보는 array_size 의 채워진 count 가 된다.
              //
              //int array[10][20][30]; 로 선언되 있고,
              //" &array " 연산을 하는 경우는 결과는
              //"(*)[10][20][30]" 로 [차원] 이 증가된다.
              //이 경우 (*) 의 값은 0 으로 한다.(차원의 크기가 0 인 경우는 의미가 없으므로)
              //이것은 "&" 연산자 처리시 신경써서 처리해 주어야 한다.
              //----------------------------------------------------------------------------
          //}
      //}
  //}


  //[2006.06.15.목][추가!!!]
  //{
      //---------------------------------------------------------------------------------
      //[1차번역] 시 [식] 정보를 보다 자세하게 전달하기 위하여 몇가지정보를 추가한다.
      //{DATABASE} 상의 index 를 저장한다.
      //이는 DATA 의 경우만 해당한다.
      //연산자, 상수의 경우는 -1(초기값) 이 된다.

      //[2006.07.12.수][수정!!!]
      //{
          //---------------------------------------------------------------------------
          //이 전에 word 안에 저장된 name 으로 구조체/공용체의 member 를 구분하였으나
          //이제는 recordindex 정보가 있으므로 이것을 사용하여 간단하게 구분할수 있다.
          int        recindex;
          //---------------------------------------------------------------------------
      //}

      //상수인 경우 [64 bit] 값으로 직접 값을 저장한다.
      //[실수인 경우는 [실수] format 으로, [정수] 인 경우는 [정수] format 으로 저장한다.
      //단지 64 bit 의 공간일 뿐이다.
      long long  _64bit_;

      //[문자상수/정수/실수...] 등 모든 상수는 아예 값으로 저장한다.
      //[1차번역] 시에는 이 64bit 값을 16진수 문자열로 바꾸어 전달하면 된다.
      //즉, 표기는 16진수로 한다.
      //---------------------------------------------------------------------------------
  //}


  //[정리 예][2006.08.15.화][대폭수정!!!]
  //{
      //[설명]{------------------------------------------------------
      //exprecord 는
      //{kind, typelistindex, pointer, arraydimension}
      //[배열] 의 경우 이전과 달리 [차원] 그 자체를 그대로 기록한다.
      //
      //아래는 의미상으로 exprecord 의 중요 4 개 정보를 정리한 것이다.
      //추가 정보도 있을수 있으나 여기서는 고려하지 않는다.
      //}------------------------------------------------------------

      //[상수]------------------------------------------------------------------
      //[상수] 의 경우는 정수는 long 으로 실수는 double 로 둘중 하나만 된다.

      //1234                 : {nlv, long,   0, 0}
      //3.14                 : {nlv, double, 0, 0}

      //[변수]------------------------------------------------------------------

      //int     var          : {lv,  int,    0, 0}
      //short **var          : {lv,  short, **, 0}
      //char    var[20]      : {nlv, char,   0, 1}
      //int    *var[3][4][5] : {nlv, int,    *, 3}

      //[구조체]----------------------------------------------------------------
      //변수가 아니고 no L-value 가 된다. 별도 취급 해야 한다.
      //type 이 [구조체] type 이다.

      //struct SSS   s       : {nlv, SSS,  0, 0}
      //struct SSS **s       : {lv,  SSS, **, 0}
      //struct SSS   s[20]   : {nlv, SSS,  0, 1}
      //struct SSS  *s[3][4] : {nlv, SSS,  *, 2}

      //[공용체]----------------------------------------------------------------
      //변수가 아니고 no L-value 가 된다. 별도 취급 해야 한다.
      //type 이 [공용체] type 이다.

      //union UUU   u        : {nlv, UUU,  0, 0}
      //union UUU **u        : {lv,  UUU, **, 0}
      //union UUU   u[20]    : {nlv, UUU,  0, 1}
      //union UUU  *u[3][4]  : {nlv, UUU,  *, 2}

      //[반환 값이 있는 함수]---------------------------------------------------
      //[식] 에서는 [반환값] 만 사용하므로 lValue 가 아닌 것으로 본다.
      //[포인터] 로 반환하는 경우는 반환 값은 [배열이름] 이 된다.

      //int    Func()        : {nlv, int,   0, 0}
      //short *Func()        : {nlv, short, *, 0}

      //[문자열]----------------------------------------------------------------
      //일반적인 1차원 [배열] 로 본다.
      //[문자열] 이므로 무조건 "char []" [배열] 로 본다.

      //"GIGYEIN"            : {nlv, char, 0, 1}
      //------------------------------------------------------------------------
  //}

  //[저장소상:위치]
  //{
      //[2012.06.20.수][추가!!!]{------------------------------------------------------------------
      //[저장소] 상 [위치] 를 기록.
      //[연산자] 의 경우만 의미가 있으며 [피연산자] 의 경우는 현재 처리하지 않는다.
      //
      //이는 [실시간 선언 정보판] 의 "->", "." 연산자 [구성원] 보여주기 기능때문에 추가하는 것으로
      //[식] 을 처리할때 해당 "->", "." 연산자까지만 처리하기 위하여 반드시 필요하다.
      //[식] 에 "->", "."  연산자가 중복 사용될수 있으므로 반드시 [연산자:위치] 정보가 있어야
      //해당하는 [연산자] 인지 구분할수 있다.
      //
      //이 경우 "->", "." 연산자 앞의 [모체 선언형] 을 알면 된다.
      //이는 [실시간 선언 정보판] 에서 [구성원] 을 보여주기 위해서 반드시 [모체 선언형] 항목을
      //찾고 열어주어야 하기 때문이다.
      //
      //[참고!!!]
      //모든 [연산자] 에서 필요한 것은 아니고 단지 "->", "." 인 경우만 수집하면 된다.
      //그러나, 일단 모든 [연산자] 는 다 수집해 주는 것으로 한다.
      //
      //[식] 을 처리할때도 이미 수집된 {EXPDB} 의 [연산자] 항목은 수정되지 않고 보존된다.
      //}------------------------------------------------------------------------------------------

      int  wordIndex; //(기본값:-1)

  //}

};


//[2006.04.21.금][수정!!!]{---------------------------------------------------------------------------
//match 검사시 사용되는 data 의 종류를 구분한다.
//각각의 해당 bit 값으로 수정한다.
#define  matchDATAkind_arrayname            0x00000001   //[배열이름]

#define  matchDATAkind_pointer              0x00000002   //[포인터]
#define  matchDATAkind_constantpointer      0x00000004   //[상수포인터]    //[2006.08.19.토][추가!!!]

#define  matchDATAkind_structpointer        0x00000008   //[구조체포인터]
#define  matchDATAkind_unionpointer         0x00000010   //[공용체포인터]
#define  matchDATAkind_struct               0x00000020   //[구조체]
#define  matchDATAkind_union                0x00000040   //[공용체]

#define  matchDATAkind_variable             0x00000080   //[변수]

//[주의!!!]
//{
    //[2007.07.14.토]
    //실제는 순수 [상수] 뿐만 아니라 [식] 에서 사용된 [반환값이 변수유형인 함수] 도 여기에 해당한다.
    //이는 [함수반환공간] 자체가 형식은 변수이지만 이 안의 "값" 을 사용하기 때문이다.
    //즉, "값" 을 [상수] 로 같이 해석한 것이다.
    //이는 매우 중요한 개념으로 constant 이므로 단순하게 [상수] 로 인지하는 실수를 해서는 안된다.
    //이는 SYMBOL_1ST_Data() 함수 내부에서 처리시 매우 중요한 의미를 갖는다.
    #define  matchDATAkind_constant         0x00000100   //[상수]

//}

#define  matchDATAkind_intvariable          0x00000200   //[정수변수]
#define  matchDATAkind_intconstant          0x00000400   //[정수상수]

//[2009.03.25.수][추가!!!]
//순수 [문자열] 인 경우를 구분한다.
//문자열은 [포인터] 이자 [상수포인터] 가 된다.
//유일한 경우이므로 별도 구분한다.
#define  matchDATAkind_string               0x00000800   //[순수문자열]

//[2009.03.26.목][추가!!!]
//순수 [배열이름] 인 경우를 구분한다.
//[구조체/공용체] 배열인 경우는 해당하지 않는다.
#define  matchDATAkind_array                0x00001000   //[순수배열이름]
//}---------------------------------------------------------------------------------------------------


struct MATCHINFO
{
  //[2006.04.18.화][생성!!!]{-----------------------------------
  //식 에서 실제 match 검사를 하기 위하여 사용되는 정보 구조체.
  //총 4 개의 정보를 사용한다.
  //}-----------------------------------------------------------

  struct EXPRECORD optr;          //[연산자] 정보.

  struct EXPRECORD left, right;   //[좌변/우변] 의 정보.

  struct EXPRECORD result;        //처리 결과 정보.

  //[2006.04.28.금][추가!!!]
  //{
      //--------------------------------------
      #define defMATCHINFO_optrKIND_pre	    1
      #define defMATCHINFO_optrKIND_bi	    2
      #define defMATCHINFO_optrKIND_post    3
      //위의 3 가지 정보를 갖는다.
      //
      //처리한 operator 의 종류를 반환한다.
      int  operator_kind;
      //--------------------------------------
  //}

};

struct EXPOPTRRANK
{
  //[2006.03.30.목][생성!!!]{-----------------------------------------------
  //[식1] 에서 사용된 순수 연산자의 우선순위를 결정하기 위한 정보를 가진다.
  //}-----------------------------------------------------------------------

  //{----------------------------------------------
  //exprecord[] 상의 index 값.
  //match 검사시에 [연산자] 위치를 알기 위해 필요.
  int exprecordindex;
  //}----------------------------------------------

  //[연산자 순위 정보]
  //{
      //----------------------------------------------------------------------------------
      int bracket;  // () 로 둘러쌓인 겹수. (BASE:0)
                    //클수록 순위가 높다.

      int optr;     //[연산자] 자체의 우선 순위 값. (BASE:0)
                    //작을수록 순위가 높다. 즉, [0 순위] 가 가장 순위가 높다.

      int left;     //좌변에 위치한 순서. (BASE:0) 가장 왼쪽에 있다면 0 의 값을 갖는다.
                    //단, 이 값은 편의 상 값이고, 실제 exprecordindex 값이 작을수록
                    //보다 [식] 에서 왼쪽에 위치한 것이므로 left 값이 필요 없을수도 있다.
      //----------------------------------------------------------------------------------
  //}

};

class EXPDATABASE
{
  //[2006.03.21.화]{-----------------------------------------------
  //[식] 의 [1단계] 처리에서 operand, operator 의 정보를 저장한다.
  //}--------------------------------------------------------------


  #define defEXPOPERATOR_kind_pre     1
  #define defEXPOPERATOR_kind_bi      2
  #define defEXPOPERATOR_kind_post    3
  #define defEXPOPERATOR_kind_xcare   4


  public:


  //[EXPRECORD]
  //{
      //[DATA]
      //{
          struct EXPRECORD  record[OPT_exprecord_size];
          int               recordcount;
      //}

      //[FUNCTION]
      //{
          //--------------------------------------------------------------------
          //[2006.03.21.화][완료!!!]
          void __fastcall Init(void);

          //[2012.06.20.수][완료!!!]
          void __fastcall Format(struct EXPRECORD *pEXP1operator);

          //[2006.03.21.화][완료!!!]
          bool __fastcall Add(struct EXPRECORD *pEXP1operator);
          //[완료!!!][2006.04.17.월]
          bool __fastcall Delete(int pDELETEindex);
          //[완료!!!][2006.04.29.토]
          void __fastcall OverWrite(int               pOVERWRITEindex,
                                    struct EXPRECORD *pRECORD);
          //--------------------------------------------------------------------

          //[2009.01.04.일][완료!!!]
          bool __fastcall SYMBOL_1ST_Data(class   DATABASE   *pDATABASE,
                                          struct  EXPRECORD  *pEXPrecord,
                                          char                rSYMBOL[]);

          //[2009.03.22.일][완료!!!][중요수정!!!]
          bool __fastcall Data(class  DATABASE  *pDATABASE,
                               int               pRECindex,
                               //[2008.10.13.월][추가!!!]
                               //만들어진 최종 기호를 반환한다.
                               char              r1stSymbol[],
                               //[2008.12.14.일][추가!!!]
                               //{expdatabase} 에는 추가하지 않고 [1차번역기호] 만 얻을지 결정.
                               //true : [1차번역기호] 만 얻는다.
                               bool              pTOnlySymbol);

          //[2009.03.22.일][완료!!!][중요수정!!!]
          bool __fastcall Data2(class  DATABASE  *pDATABASE,
                                int               pRECindex,
                                struct EXPRECORD *rEXPrecord);

          //[2009.03.22.일][완료!!!][중요수정!!!]
          bool __fastcall Constant(class  DATABASE  *pDATABASE,
                                   bool              pTintFfloat,
                                   void             *p64bit);

          //[2012.02.22.수][완료!!!]
          void __fastcall Exprecord_Constant_Make(class  DATABASE   *pDatabase,
                                                  //<true:정수>, <flase:실수>.
                                                  bool               pTintFfloat,
                                                  //[정수/실수] 를 모두 받아야 하므로 <void> 형 포인터를 사용.
                                                  void              *p64bit,
                                                  //<exprecord:상수> 를 반환.
                                                  struct EXPRECORD  *rExprecord);

          //[2009.01.07.수][완료!!!]
          bool __fastcall String(class  DATABASE     *pDatabase,
                                 int                  pStringlistIndex,
                                 //[2009.01.07.수][수정!!!]
                                 unsigned long long   pStrOfsAdr);

          //[2018.07.24.화][완료!!!]
          bool __fastcall StringType(struct EXPRECORD  *pExpRecord);

                                 
          //[2012.06.20.수][완료!!!]
          bool __fastcall Operator(struct PARSERINFO *pPARSERinfo,
                                   struct EXPRECORD  *pRECORD,
                                   int                pPRE_BI_POSTkind);

          //--------------------------------------------------------------------
          //[2012.02.22.수][완료!!!]
          void __fastcall Substitution(char *pWORD,
                                       int   pPRE_BI_POSTkind,
                                       char *pRETURNword);

          //[완료!!!][2006.04.17.월]
          bool __fastcall Delete_Bracket(void);

          //--------------------------------------------------------------------
          //[완료!!!][2006.08.16.수]
          void __fastcall EXPRECORD_array_size(struct EXPRECORD *pEXPRECORD_D,
                                               struct EXPRECORD *pEXPRECORD_S,
                                               bool              pOPERATE);

          //--------------------------------------------------------------------

      //}

  //}

  //[EXPOPTRRANK]
  //{
      //[연산자 자체의 순위 값 정의]
      //{
          //*****************************
          //순위는 계속 추가 될수 있다.
          #define OPTR_rank_0       1
          #define OPTR_rank_1       2
          #define OPTR_rank_2       3
          #define OPTR_rank_3       4
          #define OPTR_rank_4       5
          #define OPTR_rank_5       6
          #define OPTR_rank_6       7
          #define OPTR_rank_7       8
          #define OPTR_rank_8       9
          #define OPTR_rank_9       10
          #define OPTR_rank_10      11
          #define OPTR_rank_11      12
          #define OPTR_rank_12      13
          //*****************************

      //}

      //[DATA]
      //{
          struct EXPOPTRRANK expoptrrank[OPT_exprecord_size];
          int                expoptrrankcount;
      //}

      //[FUNCTION]
      //{
          //--------------------------------------------------------------------
          //[완료!!!][2006.03.30.목]
          void __fastcall OPTRRANK_Format(struct EXPOPTRRANK *pRECORD);
          //[완료!!!][2006.03.30.목]
          bool __fastcall OPTRRANK_Add(struct EXPOPTRRANK *pRECORD);
          //[완료!!!][2006.03.31.금]
          void __fastcall OPTRRANK_Move(int pFROMindex,
                                        int pTOindex);
          //--------------------------------------------------------------------
      //}
  //}

  //[일반 함수들]
  //{
      //------------------------------------------------------------------------
      //[2012.02.21.화]
      bool __fastcall OperatorRank(char *pOPTRword, int *pOPTRrank);
      //[완료!!!][2006.03.31.금]
      bool __fastcall RankInfo(void);
      //[완료!!!][2006.04.01.토]
      void __fastcall Ranking_Left(void);
      //[완료!!!][2006.04.01.토]
      void __fastcall Ranking_Optr(void);
      //[완료!!!][2006.04.01.토]
      void __fastcall Ranking_Bracket(void);
      //[완료!!!][2006.03.31.금]
      void __fastcall Ranking(void);
      //[완료!!!][2006.04.17.월]
      void __fastcall Modify_ExprecordIndex(int pINDEX);
      //[완료!!!][2006.04.27.금]
      void __fastcall Modify_ExprecordIndex2(int pINDEX,
                                             int pMODIFYcount);
      //------------------------------------------------------------------------

      //[완료!!!][2006.04.19.수]
      void __fastcall MATCHINFO_Format(struct MATCHINFO *pMATCHinfo);

      //------------------------------------------------------------------------
  //}

  //[부가함수]
  //{
      //[2011.06.21.화][완료!!!]
      void __fastcall Make_FullTypeStr(struct EXPRECORD  *pExpRecord,
                                       char              *rFullTypeStr);

  //}

  //[TEST 용 함수]
  //{
      //----------------------------------------------------
      //[2006.03.21.화][완료!!!]  //[test] 를 위한 함수.
      void __fastcall TEST_View(class DATABASE *pDATABASE);
      //----------------------------------------------------
  //}

};

//[TEMPDATABASE]----------------------------------------------------------------

struct TEMPRECORD
{
  //[2006.07.21.금][생성]{----------------
  //{TEMPDATABASE} 의 record 를 정의한다.
  //}-------------------------------------

  //[2008.11.01.토][중요주의!!!]{-------------------------------------------------------------------
  //org_typelistindex 값의 기본 값이 항상 -1 이어야 하므로 반드시 Format() 으로 초기화를 해야 한다.
  //그렇지 않은 경우는 org_typelistindex 에 0 이 들어가서 다른 것들이 제대로 처리 되지 않는다.
  //Get_OfsAdrStr_TempTotal() 함수를 새로 수정하면서 결과를 보던중 이 문제를 발견하고 기록한다.
  //}-----------------------------------------------------------------------------------------------

  //[symbol 을 저장한다.]
  //{
      char  word[OPT_1st_symbol_length];
  //}

  //이 field 에 symbol 을 넣을때는 STR_Assign() 함수를 사용하면 간단하다.

  //[부가정보]
  //{
      //[2008.10.14.화][추가!!!]{----------------------------------------------------------------------
      //함수반환이 구조체/공용체로 TEMP 가 되는 경우는 Symbol 자체는 (a)C.T.x 가 되는데
      //문제는 #TEMP{ 다음의 { ofsADR0 ofsADR1 ... } 의 [추가주소] 정보를 만들때 (a) 를 참고로
      //하게 되므로 문제가 된다. 따라서, 이 경우는 아예 특별하게 이 변수에 실제 크기를 알수 있는
      //typelistindex 정보를 추가 하는 것으로 한다.
      //필요 없는 경우는 -1 을 할당하고 이 경우에 해당하는 경우만 해당 index 를 넣어서
      //Make_OffsetAddress_String() 함수에서 처리시 이 값을 참고로 정확한 [추가주소] 를 계산하게 한다.
      //즉, 이 변수는 오직 함수반환값을 가지는 임시변수 기호에서만 적용된다.
      //}----------------------------------------------------------------------------------------------

      int   org_typelistindex; //(BASE : -1)

  //}

  //[추가주소]
  //{
      //[2011.06.10.금][중요추가!!!]{---------------------------------------------------
      //[검즈식] 처리시 <TREE_Expression()> 함수를 사용하여 직접 [계산] 을 수행하는데
      //발생하는 [TEMP] 의 경우는 [가상 @TEMP 공간] 을 이용하여 처리하게 된다.
      //이때, [TEMP] 변수의 번호만으로 간단하게 이 [가상 @TEMP 공간] 에 접근하기 위하여
      //반드시 이 [추가주소] 정보가 필요하다.
      //이 [추가주소] 는 [기호] 자체만으로는 계산할수 없으므로 반드시 [생성 순서대로]
      //추가되는 <Add()> 함수에서 추가할때마다 자동으로 계산하여 관리하는 것이 좋다.
      //}-------------------------------------------------------------------------------

      unsigned long long  ofsAdr; //(기본값 : 0)

  //}

};

class TEMPDATABASE
{
  //[2006.07.21.금]{-----------------------------------------------------
  //독립된 [식] 한개를 처리할때 발생하는 [임시변수] 를 관리하기 위한
  //{TEMPDATABASE} 를 만든다.
  //{EXPDATABASE} 는 달리 한번에 한개씩만 사용되고 중첩사용되지 않으므로
  //local 로 생성하지 않고 global 로 한개만 있으면 된다.
  //단, [식] 을 처리하면서 생성되므로 정보의 구성을 동일하게 하기 위하여
  //record 는 {EXPDATABASE} 와 동일한 것을 사용한다.
  //}--------------------------------------------------------------------


  public:


  //[DATA]
  //{
      //-------------------------------------------------------------
      //실제 {tempdatabase} 의 내용은 symbol 정보를 저장하는 것이다.
      struct TEMPRECORD   record[OPT_temprecord_size];

      //이 recordcount 는 temp [변수] 를 구분하는 번호로도 사용된다.
      int                 recordcount;
      //-------------------------------------------------------------

      //[2011.06.10.금][중요추가!!!]{--------------------------------------------------
      //[검증식] 계산시 [가상 @TEMP 공간] 에 접근하기 위한 [추가주소] 계산시 필요하다.
      //[임시변수] 를 추가할때 [추가주소] 를 바로 계산하기 위한것이다.
      unsigned long long  ofsAdr; //(기본값 : 0)
      //}------------------------------------------------------------------------------

  //}

  //[FUNCTION]
  //{
      //[2011.06.11.토][완료!!!]
      void __fastcall Init(void);
      //[2011.06.11.토][완료!!!]
      bool __fastcall Add(struct TEMPRECORD  *pTEMPrecord);

      //[2011.06.11.토][완료!!!]
      void __fastcall Format(struct TEMPRECORD  *pTEMPrecord);

      //[2008.12.10.수][완료!!!]
      void __fastcall Get_OfsAdrStr_TempTotal(class DATABASE *pDatabase,
                                              //문자열을 저장할수 있는 충분한 공간이 있어야 한다.
                                              char            rOfsAdrStr[],
                                              //<#TempTotal> 의 1차번역 기호를 반환한다.
                                              char            rTempTotal[]);

  //}

  //[ASM 으로 번역시 사용]
  //{
      //[2008.12.08.월][추가!!!]{----------------------------------------------------------------------
      //*.t -> *.asm 으로 번역시 {tempdatabase} 부분의
      //" #TEMP{ <TempTotal> { temp-info-list } "
      //에서 { temp-info-list } 부분의 "ofsAdr-List" 부분 즉, 순수하게 offset-address 단어 부분만
      //문자열 형태로 저장한다.
      //이미 확정되 있는 주소값으로 실제 #TEMP{ - #TEMP} 사이에서 사용되는 <temp> 변수의
      //[1차번역기호] 를 [ASM 기호] 로 바꿀때 index 부분을 실제 offset-address 값으로 바꿀때 사용된다.
      //각각이 16진수 [문자열] 형태의 값으로 되 있으므로 사용할때 해당 index 순번의 단어를 추출후
      //[16진수문자열] 을 실제 값으로 변환하여 사용해야 한다.
      //이는 전용 함수로 처리하면 된다.
      //이미 모든 주소는 [공백한개] 를 기준으로 각각의 단어로 구분되 저장되 있으므로 index 순번으로
      //간단하게 읽어서 사용 할수 있다.
      //
      //[2008.12.10.수][수정!!!]-----------------------------------------------------------------------
      //이전에 { ofsADR-list } 를 { ofsADR:size-list } 로 변경하였으므로 이를 반영한다.
      //즉, 각각은 "ofsADR:size" 로 한개의 단어로 ":" 를 구분자로 구성되 있으므로 각각을 분리하여
      //해당 저장소에 저장해주어야 한다.
      //}----------------------------------------------------------------------------------------------

      //[변수]
      //{
          //여기에 "ofsAdr-List" 부분의 문자열을 할당하는 것은 Tree_AsmEncode_TempStart() 함수 안에서
          //직접 수행해 준다. 이편이 더 간단하고 직접적이다.
          char  asmEncode_OfsAdrList[OPT_AsmEncode_TempOfsAdrStrSize];

          //[2008.12.10.수][추가!!!]
          //{
              //{ temp-info-list } 에서 순수하게 크기정보만 추출하여 단어 단위로 저장한다.
              char  asmEncode_SizeList[OPT_AsmEncode_TempSizeStrSize];

          //}

      //}

      //[함수]
      //{
          //[2008.12.08.월][완료!!!]
          void __fastcall AsmEncode_Get_OfsAdr(int                  pIndex,
                                               unsigned long long  *rOfsAdr);

          //[2008.12.10.수][완료!!!]
          void __fastcall AsmEncode_Get_Size(int         pIndex,
                                             long long  *rSize);

      //}

  //}


};


//[2006.07.25.화][완료!!!]
void __fastcall TEMPDATABASE_GetPtr(class TEMPDATABASE **pTEMPDATABASEptr);

//------------------------------------------------------------------------------

#endif


