
//[2008.11.27.목][생성!!!]{---------------------
//*.t 문서를 번역하여 *.asm 문서를 만들어 준다.
//}---------------------------------------------


#include <vcl.h>
#pragma hdrstop


//[사용 header file]
//{
    #include "asmencoder.h"
    #include "c_define.h"
    #include "parser.h"
    #include "ide_library.h"
    #include "library.h"
    #include "database.h"
    #include "file.h"

    #include "ide_msgbox.h"

    //[2011.04.29.금][추가!!!]
    #include "buildStatus.h"
    #include "msg_msg.h"

//}


bool __fastcall AsmEncoder(char  *pTempFileName)
{
  //[2008.11.26.수][생성!!!]{---------------------------------------------------------------
  //[1차번역] 된 *.t 를 읽어서 *.asm 을 만들어 준다.
  //이미 ASM 으로 쉽게 변역할수 있도록 정리된 것이므로 행단위로 읽어서 쉽게 처리 가능하다.
  //모든 단어는 공백으로 구분되 있으므로 [공백] 으로 단어를 읽어서 처리하면 된다.
  //이미 모든 것은 행 단위로 완전하게 정리되 있다.
  //단, 이미 {DATABASE} 안에 fileinfo 정보가 있으므로 여기서 별도의 [저장소] 를 만들지 않고
  //이곳에 읽어들인 문서및 문서 정보를 저장한다.
  //}---------------------------------------------------------------------------------------

  //[VAR]
  //{
      class  DATABASE  *database;
      int    result = 0;

      //[2008.12.07.일][추가!!!]
      //{
          //실제 *.asm 으로 번역시 사용되는 기본 중요정보를 관리한다.
          //쓸데없이 메모리를 낭비 하지 않도록 이 함수안에서 지역 변수로 선언하고 모든
          //내부 처리 함수에서는 인수로 받아서 사용하게 한다.
          //반드시 초기화 한뒤 사용한다.

          struct ASMENCODEINFO  asmEncodeInfo;

      //}

  //}

  //[DATABASE 위치 얻기]
  //{
      DATABASE_GetPtr(&database);

  //}

  //[*.t 문서 열기]
  //{
      //[!]{-----------------------------------------------------------
      //[1차번역] 문서인 *.t 문서를 열어준다.
      //{DATABASE} 안의 [문서정보구조체] 에 문서 크기 만큼 생성해준다.
      //}--------------------------------------------------------------

      if(FILE_Open2(pTempFileName,
                    (unsigned char **)(&(database->fileinfo.buf)),
                    &(database->fileinfo.size),
                    &(database->fileinfo.handle)) != true)
      {
        //*.t 문서열기 오류로 더이상 진행하지 않고 바로 종료한다.
        return(false);

      }

  //}

  //[tempfile][*.asm file buffer 생성]
  //{
      //[tempfile 저장소 생성]
      //{
          //ASM 문서는 *.t 문서의 2 배 정도면 충분하다.
          //*.t 문서는 이미 완벽하게 정리된 문서이므로...
          TEMPFILE_Create(database->fileinfo.size * OPT_AsmFile_SizeFactor);

      //}

      //[ASM 문서 이름 만들기]
      //{
          //ASM 문서 이름을 미리 만들어 놓는다.
          //*.c 파일 이름을 그대로 사용하고 확장자만 바꾼다.
          TEMPFILE_MakeFileName(pTempFileName, "gasm");

      //}

  //}

  //[정보 얻기]
  //{
      //[2008.12.07.일][수정!!!]{------------------------
      //각종 정보를 얻어 중요 정보 구조체를 초기화 한다.
      //}------------------------------------------------

      //*.t 문서가 저장되 있는 위치를 얻는다.
      asmEncodeInfo.tBuf   = database->fileinfo.buf;

      //*.asm 문서가 저장중인 위치를 얻는다.
      asmEncodeInfo.asmBuf = database->tempfile.buf;

      //총 행수를 얻는다.
      asmEncodeInfo.lineTotalCount = STR_Get_LineCount(asmEncodeInfo.tBuf);

      asmEncodeInfo.lineStartIndex = 0;

      asmEncodeInfo.line           = 0;

      asmEncodeInfo.word[0]        = '\0';

      asmEncodeInfo.wordStartIndex = 0;

      //[2009.03.30.월][추가!!!]
      asmEncodeInfo.lastLineNumberSymbol[0] = '\0';

  //}


  //[가상기계 제작 진행창]
  //{
      //[2011.04.29.금][추가!!!]{--------------------------------------
      //현재 처리중인 [문서정보] 를 [가상기계 제작 진행창] 에 보여주고
      //관련설정을 수행한다.
      //}--------------------------------------------------------------

      //[!]{-------------------------------------------------------------------------
      //문서를 읽어들일때 [행수] 를 얻지 않으므로, 여기서 직접 얻어서 전달해야 한다.
      //단, <STR_Get_LineCount()> 함수는 처리 시간이 많이 걸리는데 주의한다.
      //}-----------------------------------------------------------------------------

      buildStatus_Form->_fileLineCount = asmEncodeInfo.lineTotalCount;
      buildStatus_Form->_FileInfo(pTempFileName, buildStatus_Form->_fileLineCount);

  //}


  //[ASM 문서 만들기]
  //{
      //[2008.11.28.금][추가!!!]{----------------------------------
      //여기서부터 *.t 문서를 행단위로 읽어서 ASM 문서로 번역한다.
      //}----------------------------------------------------------

      LINE_START:

      //[Win7 <응답이 없는 상태> 해결]
      //{
          //[2010.09.26.일][중요추가!!!]{---------------------------------------------------------------
          //WinXP 에서는 아무 문제가 없었는데, Win7 에서는 [무한반복] 이 계속되는 경우
          //일정 시간이 지나면 [응답이 없는 상태] 로 지정되어 [맷돌] 과 통신시에 [시간제한] 에
          //계속 걸리는 문제가 발생하고, [하얗게] 되는 문제가 발생한다.
          //보기에도 좋지 않고, 통신에도 문제가 방생하므로 [무한반복] 부분에 [외부 알림문 확인] 을 넣어
          //이런 형상이 발생하지 않도록 수정한다.
          //이는 [링크] 등 다른 부분도 마찬가지이므로 대규모 [무한반복] 을 처리하는 부분에는 전부
          //이 문장을 넣어 준다.
          //}-------------------------------------------------------------------------------------------

          Application->ProcessMessages();

      //}

      //[가상기계 제작 진행창]
      //{
          //[2011.04.29.금][추가!!!]{--------------------------------------------
          //[중지] 요청이 있는 경우는 더이상 처리하지 않고 종료해야 한다.
          //일단, [오류] 로 처리하고, [오류 문자열] 에 [중지요청] 임을 알려준다.
          //}--------------------------------------------------------------------

          if(buildStatus_Form->Visible == false)
          {
            //[!]{-------------------------------------------------------
            //이 경우는 [즁지] 요청으로 간주하고 여기서 처리를 종료한다.
            //}----------------------------------------------------------

            msg_msg_Form->_PrintAddLine
            (d_msg_msg,
             "\r\n"
             "[ 가상기계 제작 취소! ]\r\n"
             "사용자 요청으로 가상기계 제작이 [취소] 되었습니다.");

            //return(false);
            //[2011.05.02.월][추가!!!]
            //동적 생성된 저장소 삭제를 위하여 종료처리를 위한 곳으로 이동한다.
            goto lbError;

          }

      //}

      //여기서부터 또 하나의 행이 시작되는 것이다.

      //[현재 행에 내용이 있는가?]
      //{
          //현재 행에 처리할 것이 없다면 다음 행으로 넘어가야 한다.
          AsmEncode_GetWord(&asmEncodeInfo, 0);

          if(STR_Match(asmEncodeInfo.word, "") == true)
          {
            //첫 단어가 아무것도 없는 경우는 이 행에는 처리할게 없는 것이다.
            //다음으로 넘긴다.
            goto LINE_END;

          }

      //}

      //[행번호]
      //{
          result = Tree_AsmEncode_LineNumber(&asmEncodeInfo);

          switch(result)
          {
            case yes   :  goto LINE_END;
            case no    :  break;
            case error :  goto lbError;//return(false);

          }

      //}

      //[함수 본체 시작]
      //{
          result = Tree_AsmEncode_FunctionBodyStart(&asmEncodeInfo);

          switch(result)
          {
            case yes   :  goto LINE_END;
            case no    :  break;
            case error :  goto lbError;//return(false);

          }

      //}

      //[함수 본체 끝]
      //{
          result = Tree_AsmEncode_FunctionBodyEnd(&asmEncodeInfo);

          switch(result)
          {
            case yes   :  goto LINE_END;
            case no    :  break;
            case error :  goto lbError;//return(false);

          }

      //}

      //[함수 호출]
      //{
          //[2008.12.15.월][추가!!!]

          result = Tree_AsmEncode_FunctionCall(&asmEncodeInfo);

          switch(result)
          {
            case yes   :  goto LINE_END;
            case no    :  break;
            case error :  goto lbError;//return(false);

          }

      //}

      //[{temp} 시작]
      //{
          result = Tree_AsmEncode_TempStart(&asmEncodeInfo);

          switch(result)
          {
            case yes   :  goto LINE_END;
            case no    :  break;
            case error :  goto lbError;//return(false);

          }

      //}

      //[{temp} 끝]
      //{
          result = Tree_AsmEncode_TempEnd(&asmEncodeInfo);

          switch(result)
          {
            case yes   :  goto LINE_END;
            case no    :  break;
            case error :  goto lbError;//return(false);

          }

      //}

      //[jump]
      //{
          result = Tree_AsmEncode_Jump(&asmEncodeInfo);

          switch(result)
          {
            case yes   :  goto LINE_END;
            case no    :  break;
            case error :  goto lbError;//return(false);

          }

      //}

      //[copy]
      //{
          result = Tree_AsmEncode_Copy(&asmEncodeInfo);

          switch(result)
          {
            case yes   :  goto LINE_END;
            case no    :  break;
            case error :  goto lbError;//return(false);

          }

      //}

      //[conjt]
      //{
          result = Tree_AsmEncode_Conjt(&asmEncodeInfo);

          switch(result)
          {
            case yes   :  goto LINE_END;
            case no    :  break;
            case error :  goto lbError;//return(false);

          }

      //}

      //[conjf]
      //{
          result = Tree_AsmEncode_Conjf(&asmEncodeInfo);

          switch(result)
          {
            case yes   :  goto LINE_END;
            case no    :  break;
            case error :  goto lbError;//return(false);

          }

      //}

      //[push]
      //{
          result = Tree_AsmEncode_Push(&asmEncodeInfo);

          switch(result)
          {
            case yes   :  goto LINE_END;
            case no    :  break;
            case error :  goto lbError;//return(false);

          }

      //}

      //[pop]
      //{
          result = Tree_AsmEncode_Pop(&asmEncodeInfo);

          switch(result)
          {
            case yes   :  goto LINE_END;
            case no    :  break;
            case error :  goto lbError;//return(false);

          }

      //}

      //[라벨]
      //{
          result = Tree_AsmEncode_Label(&asmEncodeInfo);

          switch(result)
          {
            case yes   :  goto LINE_END;
            case no    :  break;
            case error :  goto lbError;//return(false);

          }

      //}

      //[연산자]
      //{
          result = Tree_AsmEncode_Operator(&asmEncodeInfo);

          switch(result)
          {
            case yes   :  goto LINE_END;
            case no    :  break;
            case error :  goto lbError;//return(false);

          }

      //}

      //[문자열]
      //{
          result = Tree_AsmEncode_String(&asmEncodeInfo);

          switch(result)
          {
            case yes   :  goto LINE_END;
            case no    :  break;
            case error :  goto lbError;//return(false);

          }

      //}

      LINE_END:


      //[가상기계 제작 진행창]
      //{
          //[2011.04.29.금][추가!!!]{-------------------------------------------
          //현재 처리중인 [현재 행] 과 [총 처리 행수] 를 처리한다.
          //여기서 처리하는 이유는 [듬성 듬성] 처리하여 정보는 보여주되
          //처리 시간 증가에 영향을 주지않기 위함이다.
          //
          //이 문서는 전부 1 행 단위로 처리 되므로 [문서량/10] 단위로 처리한다.
          //}-------------------------------------------------------------------

          if((buildStatus_Form->_fileLineCount/10) > 0)
          {
            if(asmEncodeInfo.line%(buildStatus_Form->_fileLineCount/10) == 0)
            {
              //[현재행] 보여주기.
              buildStatus_Form->_LineNum(asmEncodeInfo.line);

              //[전체 처리 행수] 보여주기.
              buildStatus_Form->_TotalLineNum();

            }

          }
          else
          {
            //[현재행] 보여주기.
            buildStatus_Form->_LineNum(asmEncodeInfo.line);

            //[전체 처리 행수] 보여주기.
            buildStatus_Form->_TotalLineNum();

          }

      //}


      //[행단위 후처리]
      //{
          //각각의 행을 처리한 다음에 다음 행을 지정하거나 문서의 끝에 도달한 경우등의 처리를 수행한다.

          //[문서의 끝인가?]
          //{
              //현재 [행번호 + 1] 이 총 행수와 같다면 모든 행을 다 처리한 것이다.
              if((asmEncodeInfo.line + 1) >= asmEncodeInfo.lineTotalCount)
              {
                //모든 행을 다 처리 하였으므로 문서를 저장하는 곳으로 이동한다.
                goto ASM_FILE_SAVE;

              }

          //}

          //[다음행 지정]
          //{
              //다음 행의 시작 index 를 구한다.
              STR_Get_NextLineStartIndex(asmEncodeInfo.tBuf,
                                         asmEncodeInfo.lineStartIndex,
                                         &(asmEncodeInfo.lineStartIndex));

          //}

          //[행 순번 증가]
          //{
              //한개의 행을 처리한 것으로 보아서 행 번호를 증가시킨다.
              asmEncodeInfo.line++;

              //[가상기계 제작 진행창]
              //{
                  //[2011.04.29.금][추가!!!]{----------------------------------------
                  //[가상기계 제작 상태 창] 에 [총 처리 행수] 정보를 표시하기 위하여
                  //이 창에서 관리하는 [총 처리 행수] 환경변수를 수정해 준다.
                  //}----------------------------------------------------------------

                  //행이 증가할때 마다 같이 증가시켜 준다.
                  buildStatus_Form->_totalLineNum++;

              //}

          //}

          //아직 문서의 끝이 아니므로 다음 행을 처리하도록 한다.
          goto LINE_START;

      //}

  //}

  ASM_FILE_SAVE:

  lbOk:
  //{
      //[tempfile][*.asm file 저장]
      //{
          //[!]{---------------------------------------------------
          //tempfile [저장소] 의 내용을 <*.asm> 문서로 저장한다.
          //저장할 파일의 이름은 이미 사전에 만들어진 상태이다.
          //해당 buffer 의 삭제는 아래 함수에서 자동으로 처리된다.
          //}------------------------------------------------------

          TEMPFILE_Save();

      //}

      //[2012.04.28.토][추가!!!]
      database->FILEINFO_Delete(&(database->fileinfo));

      return(true);

  //}

  lbError:
  //{
      //[2011.05.02.월][추가!!!]{------------------------------------------------------
      //이미 생성된 저장소가 있으므로 반드시 [삭제] 해야 한다.
      //원래는 <TEMPFILE_Save()> 에서 저장시 자동 [삭제] 되지만 중간에 종료하는 경우는
      //이 과정을 거치지 않기 때문에 별도로 [삭제] 해 주어야 한다.
      //}------------------------------------------------------------------------------

      TEMPFILE_Delete();

      //[2012.04.28.토][추가!!!]
      database->FILEINFO_Delete(&(database->fileinfo));

      return(false);

  //}

}

//[Tree 함수들]-----------------------------------------------------------------

int __fastcall Tree_AsmEncode_LineNumber(struct ASMENCODEINFO  *prAsmEncodeInfo)
{
  //[2008.12.07.일][생성!!!]{-------------------------------------------
  //[행번호] 의 경우는 그대로 copy 하면된다.
  //
  //[2009.03.30.월][수정!!!]{-------------------------------------------
  //바로 이전의 [행번호] 와 중복 되는 경우는 다시 추가하지 않아야 한다.
  //이는 <*.gcsm> 문서를 만들때 정확한 위치에 합성하기 위한 것이다.
  //금일 <*.gcsm> 문서를 만들면서 문제를 발견하고 수정한다.
  //}-------------------------------------------------------------------

  //[번역내용]
  //{
      //[*.t]{---
      //
      // $행번호
      //
      //[*.asm]--
      //
      // $행번호
      //
      //}--------

  //}

  //[VAR]
  //{
      struct ASMENCODEINFO  asmEncodeInfo_Backup;

  //}

  //[정보대피]
  //{
      //이 함수에 해당하지 않는 경우를 대비하여 정보를 대피시킨다.
      asmEncodeInfo_Backup = *prAsmEncodeInfo;

  //}

  //[첫 단어 추출]
  //{
      //현재 행의 첫 단어를 추출한다.
      AsmEncode_GetWord(prAsmEncodeInfo, 0);

  //}

      //[안전장치]
      //{
          //[2009.11.18.수][중요수정!!!]{---------------------------------------------------------------
          //소스에 사용된 문자열이 너무 길어 '.' 를 구분자로 문자열을 추출한 것이 tempWord[]
          //의 크기를 넘는 경우는 오류가 발생하므로 아예 간단하게 [문자열] 인 경우는은 처리하지 않는다.
          //문자열의 경우는 <*.gtmp> 문서에는 항상 <"> 로 시작하므로 문자열은 경우는 처리하지 않는다.
          //}-------------------------------------------------------------------------------------------

          //[문자열] 행인지 확인한다.
          if(prAsmEncodeInfo->word[0] == '"')
          {
            //아예 해당하지 않는 것이므로 여기서 처리한다.

            //[정보복구]
            //{
                *prAsmEncodeInfo = asmEncodeInfo_Backup;

            //}

            //해당하지 않으므로 여기서 종료한다.
            return(no);

          }

      //}

  //[행단어인가?]
  //{
      //[행번호] 는 "$번호" 로 되 있으므로 첫 문자가 "$" 인지만 확인하면 된다.
      if(prAsmEncodeInfo->word[0] != '$')
      {
        //[행번호] 가 아니므로 이 함수에 해당하지 않는다.

        //[정보복구]
        //{
            *prAsmEncodeInfo = asmEncodeInfo_Backup;

        //}

        //해당하지 않으므로 여기서 종료한다.
        return(no);

      }

  //}

  //[바로 이전 행번호와 중복되는가?]
  //{
      //[2009.03.30.월][추가!!!]{-------------------------------------------
      //바로 이전의 [행번호] 와 중복 되는 경우는 다시 추가하지 않아야 한다.
      //}-------------------------------------------------------------------

      if(STR_Match(prAsmEncodeInfo->word, prAsmEncodeInfo->lastLineNumberSymbol) == true) return(yes);

  //}

  //[ASM 번역]
  //{
      //추출한 [행번호] 를 그대로 복사한다.
      TEMPFILE_Add(prAsmEncodeInfo->word);
      TEMPFILE_Add(" \r\n");

  //}

  //[현재 행번호 기록]
  //{
      //[2009.03.30.월][추가!!!]{--------------------------------------
      //다음 중복 검사를 위하여 현재 처리한 [행번호] 를 기록해 놓는다.
      //}--------------------------------------------------------------

      STR_Assign(prAsmEncodeInfo->lastLineNumberSymbol, prAsmEncodeInfo->word);

  //}

  return(yes);

}

int __fastcall Tree_AsmEncode_FunctionBodyStart(struct ASMENCODEINFO  *prAsmEncodeInfo)
{
  //[2008.12.07.일][생성!!!]{------------------------------------------
  //[함수 본체 시작] 부분을 번역한다.
  //
  //[주의!!!]----------------------------------------------------------------------
  //[함수본체시작] 은 이전 행의 [행번호] 의 위치를 수정해 주어야 한다.
  //이는 모든 [지역라벨] 은 함수 안에 있어야 하기 때문이다.
  //이 경우는 [함수본체시작] 의 경우가 유일하다.
  //
  //[2008.12.09.화][중요수정!!!]---------------------------------------------------
  //[함수본체시작] 부분에서는 [인수] 를 읽어 들여 해당하는 지역 변수에
  //할당하는 것 까지 처리해 주어야 한다.
  //[인수] 는 [역순] 으로 읽어들여 처리해야 한다.
  //이는 전용 함수로 처리한다.
  //
  //[2009.11.18.수][중요수정!!!]
  //<*.gtmp> 의 경우는 소스에 사용된 문자열이 "..." 으로 정리되 있는데
  //이 문자열이 아직 코드화 되지 않아 안에 '.' 문자가 있는 경우 단어가
  //추출되는데, 이 단어의 길이가 너무 긴경우 오류가 발생한다.
  //따라서, 아예 문자열의 경우는 처리되지 않도록 직접 "FD" 로 시작하는지 검사한다.
  //금일 맷돌의 [멜로디] 관련 예제의 "소녀시대의 Gee" 를 만들어 확인하다가 이를
  //발견하고 수정한다(박자중 '.'를 사용하는 문자가 있다).
  //}------------------------------------------------------------------------------

  //[번역내용]
  //{
      //[*.t]{--------------------------------------------
      //
      // $행번호
      // FD.x.{: <LocalTotal>
      //
      //[*.asm]-------------------------------------------
      //
      // :함수이름:
      // $행번호
      // fnstart :함수이름: <LocalTotal>
      //
      // pop 인수 <인수> //[인수] 는 역순으로 읽어들인다.
      // ...
      //
      //}-------------------------------------------------

  //}

  //[VAR]
  //{
      class  DATABASE  *database;

      struct ASMENCODEINFO  asmEncodeInfo_Backup;

      //자주 사용되는 단어 처리용.
      char   tempWord[3][OPT_wordStrSize] = {""};
      char  *tempStr;

      //이전행의 시작 index 값.
      int    beforeLineStartIndex;

      //*.asm 문서가 저장되고 있는 저장소의 현재 저장 끝 위치.
      int    asmBufEndIndex;

      char   hexStr[OPT_wordStrSize]      = {""};
      int    recIndex;

      //[2008.12.14.일][추가!!!]
      //{
          int        i;

          //가장 마지막 [인수] 의 index:번호 를 가진다.
          int        paramLastIndex;

          //[인수] 의 크기를 얻는다.
          long long  paramSize;

      //}

  //}

  //[정보대피]
  //{
      //이 함수에 해당하지 않는 경우를 대비하여 정보를 대피시킨다.
      asmEncodeInfo_Backup = *prAsmEncodeInfo;

  //}

  //[DATABASE 위치 얻기]
  //{
      DATABASE_GetPtr(&database);

  //}

  //[첫 단어 추출]
  //{
      //현재 행의 첫 단어를 추출한다.
      AsmEncode_GetWord(prAsmEncodeInfo, 0);

  //}

  //[함수 본체 시작 인가?]
  //{
      //[안전장치]
      //{
          //[2009.11.18.수][중요수정!!!]{---------------------------------------------------------------
          //소스에 사용된 문자열이 너무 길어 '.' 를 구분자로 문자열을 추출한 것이 tempWord[]
          //의 크기를 넘는 경우는 오류가 발생하므로 아예 간단하게 [문자열] 인 경우는은 처리하지 않는다.
          //문자열의 경우는 <*.gtmp> 문서에는 항상 <"> 로 시작하므로 문자열은 경우는 처리하지 않느다.
          //}-------------------------------------------------------------------------------------------

          //[문자열] 행인지 확인한다.
          if(prAsmEncodeInfo->word[0] == '"')
          {
            //아예 해당하지 않는 것이므로 여기서 처리한다.

            //[정보복구]
            //{
                *prAsmEncodeInfo = asmEncodeInfo_Backup;

            //}

            //해당하지 않으므로 여기서 종료한다.
            return(no);

          }

      //}

      //[!]{-------------------------------------------------------------
      //[함수본체시작] 부분은 "FD.x.{:" 가 첫 단어 이므로 이를 검사한다.
      //"." 문자를 [구분자] 로 단어를 추출하면 간단하게 비교할수 있다.
      //}----------------------------------------------------------------

      //"." 를 구분자로 0번, 1번, 2번 단어를 추출한다.
      STR_GetWord(prAsmEncodeInfo->word, '.', 0, tempWord[0]);
      STR_GetWord(prAsmEncodeInfo->word, '.', 1, tempWord[1]);
      STR_GetWord(prAsmEncodeInfo->word, '.', 2, tempWord[2]);

      if(!((STR_Match(tempWord[0], "FD") == true) && (STR_Match(tempWord[2], "{:") == true)))
      {
        //[함수본체시작] 에 해당하지 않는다.

        //[정보복구]
        //{
            *prAsmEncodeInfo = asmEncodeInfo_Backup;

        //}

        //해당하지 않으므로 여기서 종료한다.
        return(no);

      }

  //}

  //[ASM 번역]
  //{
      //[이전 행번호 시작 위치 얻기]
      //{
          //[!]{-------------------------------------------------------------------------------------------
          //이미 추가된 [함수본체시작] 의 [행번호] 는 바로 이전 행에 있으므로 이의 시작 위치를 얻는다.
          //[행번호] 는 항상 행의 시작 위치부터 시작되므로 [행의 시작 위치] 가 곧 구하고자 하는 값이 된다.
          //}----------------------------------------------------------------------------------------------

          //*.asm 문서가 저장되고 있는 [저장소] 의 끝 위치를 얻는다.
          //이는 이전 행의 시작 위치를 얻는데 필요하다.
          TEMPFILE_EndIndex(&asmBufEndIndex);

          //이전행의 시작 index 를 얻는다.
          STR_Get_BeforeLineStartIndex(prAsmEncodeInfo->asmBuf,
                                       asmBufEndIndex,
                                       &beforeLineStartIndex);

      //}

      //[함수 실제 이름 얻기]
      //{
          //소스상에서 사용된 실제 이 함수의 이름을 얻는다.

          //[record index 얻기]
          //{
              //이미 위에서 "." 을 구분자로 해당 record index 값을 추출하였으므로 값으로 바꾼다.

              STR_Assign(hexStr, "0x");
              STR_Add(hexStr, tempWord[1]);

              //[값] 으로 변환.
              CONV_HexStr_To_IntVal(hexStr, &recIndex);

          //}

          //[이름 추출]
          //{
              database->REC_Field_Read2(recIndex, _F_name, NULL, &tempStr);

              STR_Assign(tempWord[0], tempStr);

          //}

          //[전역 라벨로 바꾸기]
          //{
              //[순수함수이름] 을 [전역라벨] 형식으로 변환한다.
              SYMBOL_Asm_MakeGlobalLabel_Self(tempWord[0]);

          //}

      //}

      //[지역변수 총 크기 단어 얻기]
      //{
          //1 번째 단어가 해당된다.
          AsmEncode_GetWord(prAsmEncodeInfo, 1);

          STR_Assign(tempWord[1], prAsmEncodeInfo->word);

          //[1st->ASM 기호 변환]
          //{
              //[2008.12.10.수][추가!!!]{-----------------
              //[피연산자] 의 기호를 ASM 용으로 바꿔준다.
              //}-----------------------------------------

              SYMBOL_1st_To_Asm(true, tempWord[1], NULL);

          //}

      //}

      //[번역]
      //{
          //[함수이름라벨 추가]
          //{
              //이전 [행번호] 앞에 [함수이름] 을 끼워 넣는다.
              //끼워 넣기 전에 한개의 행으로 만들어 주어야 한다.
              STR_Assign(tempWord[2], tempWord[0]);
              STR_Add(tempWord[2], " \r\n");

              TEMPFILE_Insert(beforeLineStartIndex, tempWord[2]);

          //}

          //[실제 번역 code 추가]
          //{
              // fnstart :함수이름: <LocalTotal>

              TEMPFILE_Add("fnstart ");
              TEMPFILE_Add(tempWord[0]); TEMPFILE_Add(" ");
              TEMPFILE_Add(tempWord[1]); TEMPFILE_Add(" \r\n");

          //}

      //}

      //[인수 읽기 번역]
      //{
          //[2008.12.14.일][추가!!!]{-----------------------------------------------------------------
          //[함수본체] 시작 부분에서는 [인수] 를 [역순] 으로 읽어서 [인수:지역변수] 에 저장해야 한다.
          //[인수] 를 [역순] 으로 읽는 것은 [인수] 를 전달할때 push 로 순서대로 전달했기 때문이며
          //읽을때는 pop 으로 읽어 들이므로 [역순] 으로 처리해야 한다.
          //처리 과정이 매우 복잡하므로 전용 함수로 처리한다.
          //
          // 0       1            2 3 ...
          // FD.x.{: <LocalTotal> { param-list }
          //
          //로 이미 [1차번역] 시 { param-list } 부분에 각각의 인수가 순서대로 [인수] 의 [1차번역기호]
          //로 기술되 있으므로 이를 읽어서 간단하게 번역할 수 있다.
          //pop 명령에서 사용되는 [크기] 정보는 {database}.size 에 이미 다 정리되 있다.
          //단, "{ } " 로 [인수목록] 안이 비어있는 경우로 [인수] 가 없는 경우는 처리 하지 않는다.
          //
          // 인수가 3 개 인 경우([역순] 이어야 한다).
          //
          // pop  L2 <L2>
          // pop  L1 <L1>
          // pop  L0 <L0>
          //
          // 로 역순으로 pop 만 하면 자동으로 [인수] 에 값을 읽어 올수 있다.
          //[지역변수] 0 번 부터 [인수] 에 해당하므로 해당 [지역변수] 를 대상으로 처리하면 된다.
          //}-----------------------------------------------------------------------------------------

          //[임시 정의]
          //{
              //tempWord[] 각각의 정보를 구분하기 위한 이미 정의 index.
              #define  d_Param        0
              #define  d_Recinx       1
              #define  d_SizeSymbol   2

          //}

          //[마지막 인수 위치 얻기]
          //{
              //[인수] 를 읽을때는 [역순] 으로 읽어 들여야 하므로 가장 마지막의 [인수] index 를 얻는다.

              for(//첫번째 [인수] 위치.
                  i = 3,
                  //마지막 [인수] 위치는 일단 첫번째 [인수] 위치와 같은 위치로 설정한다.
                  paramLastIndex = 3;
                  ;
                  i++)
              {
                //지정 index 의 단어를 추출한다.
                AsmEncode_GetWord(prAsmEncodeInfo, i);

                //"}" 문자 이전까지 처리하면 된다.
                if(STR_Match(prAsmEncodeInfo->word, "}") == true)
                {
                  //[[인수] 가 하나도 없나?]
                  //{
                      if(i == 3)
                      {
                        //이 경우는 아예 [인수] 가 없는 경우이다.
                        //[인수] 부분은 번역할 것이 없으므로 바로 종료한다.

                        goto END;

                      }

                  //}

                  break;

                }

                //[마지막 [인수] 위치]
                //{
                    //"}" 의 경우 위에서 아래 문장을 처리 하지 않고 바로 종료하므로
                    //paramLastIndex 에는 항상 "}" 이전 단어의 index:번호 가 들어 있게 된다.
                    paramLastIndex = i;

                //}

              }

              //여기까지 가장 마지막 [인수] 위치를 얻었다.

          //}

          for(//[인수] 는 [역순] 으로 읽어 들인다.
              i = paramLastIndex;
              //[인수] 는 index:3 부터 시작 된다.
              i >= 3;
              i--)
          {
            //[인수 기호 추출]
            //{
                //[!]{--------------------------
                //[인수] 의 [1차번역기호] 읽기.
                //}-----------------------------

                //지정 index 의 단어를 추출한다.
                AsmEncode_GetWord(prAsmEncodeInfo, i);

                //[인수 단어 저장]
                //{
                    //[인수] 의 [1차번역기호] 를 [ASM 기호] 로 변환하여 저장해놓는다.
                    STR_Assign(tempWord[d_Param], prAsmEncodeInfo->word);

                    //[ASM 기호] 로 변환.
                    SYMBOL_1st_To_Asm(true, tempWord[d_Param], NULL);

                //}

            //}

            //[record-index 구하기]
            //{
                //[방법]{-------------------------------------------------------
                //
                //"(typelistindex)V.L.recindex"
                //
                //로 [인수] 의 [1차번역기호] 가 구성되 있으므로
                //"." 를 [구분자] 로 index:2 의 [단어] 가 record-index 가 된다.
                //}-------------------------------------------------------------

                STR_GetWord(prAsmEncodeInfo->word, '.', 2, tempWord[d_Recinx]);

                //[값 으로 변환]
                //{
                    STR_Assign(hexStr, "0x");
                    STR_Add(hexStr, tempWord[d_Recinx]);

                    CONV_HexStr_To_IntVal(hexStr, &recIndex);

                //}

            //}

            //[[인수] 크기 얻기]
            //{
                //record-index 에 해당하는 [인수] 의 [크기] 를 얻는다.

                database->Rec_Size_Read(recIndex, &paramSize);

                //[기호로 변환]
                //{
                    //[1차번역기호] 의 [상수기호] 로 변환한다.
                    SYMBOL_1ST_IntegerConstant(paramSize, tempWord[d_SizeSymbol]);

                    //[ASM 기호] 로 변환.
                    SYMBOL_1st_To_Asm(true, tempWord[d_SizeSymbol], NULL);

                //}

            //}

            //[ASM 번역 추가]
            //{
                // pop 인수 <인수>

                TEMPFILE_Add("pop ");
                TEMPFILE_Add(tempWord[d_Param]); TEMPFILE_Add(" ");
                TEMPFILE_Add(tempWord[d_SizeSymbol]); TEMPFILE_Add(" \r\n");

            //}

          }

      //}

  //}

  END:

  //이상없이 완료 되었다.
  return(yes);

}

int __fastcall Tree_AsmEncode_FunctionBodyEnd(struct ASMENCODEINFO  *prAsmEncodeInfo)
{
  //[2008.12.08.월][생성!!!]{-------
  //함수 본체 [끝] 부분을 번역한다.
  //}-------------------------------

  //[번역내용]
  //{
      //[*.t]{---------------------------------------------------------
      //
      // FD.x.}:
      //
      //[*.asm]--------------------------------------------------------
      //
      // FD.x.}:  //[라벨] 은 jump 등으로 참조 되고 있으므로 남겨둔다.
      // fnend
      //
      //}--------------------------------------------------------------

  //}

  //[VAR]
  //{
      struct ASMENCODEINFO  asmEncodeInfo_Backup;

      //자주 사용되는 단어 처리용.
      char   tempWord[2][OPT_wordStrSize] = {""};

  //}

  //[정보대피]
  //{
      //이 함수에 해당하지 않는 경우를 대비하여 정보를 대피시킨다.
      asmEncodeInfo_Backup = *prAsmEncodeInfo;

  //}

  //[첫 단어 추출]
  //{
      //현재 행의 첫 단어를 추출한다.
      AsmEncode_GetWord(prAsmEncodeInfo, 0);

  //}

  //[함수 본체 끝 인가?]
  //{
      //[안전장치]
      //{
          //[2009.11.18.수][중요수정!!!]{---------------------------------------------------------------
          //소스에 사용된 문자열이 너무 길어 '.' 를 구분자로 문자열을 추출한 것이 tempWord[]
          //의 크기를 넘는 경우는 오류가 발생하므로 아예 간단하게 [문자열] 인 경우는은 처리하지 않는다.
          //문자열의 경우는 <*.gtmp> 문서에는 항상 <"> 로 시작하므로 문자열은 경우는 처리하지 않느다.
          //}-------------------------------------------------------------------------------------------

          //[문자열] 행인지 확인한다.
          if(prAsmEncodeInfo->word[0] == '"')
          {
            //아예 해당하지 않는 것이므로 여기서 처리한다.

            //[정보복구]
            //{
                *prAsmEncodeInfo = asmEncodeInfo_Backup;

            //}

            //해당하지 않으므로 여기서 종료한다.
            return(no);

          }

      //}

      //[함수 본체 끝] 부분은 "FD.x.}:" 가 첫 단어 이므로 이를 검사한다.
      //"." 문자를 [구분자] 로 단어를 추출하면 간단하게 비교할수 있다.

      //"." 를 구분자로 0번, 2번 단어를 추출한다.
      STR_GetWord(prAsmEncodeInfo->word, '.', 0, tempWord[0]);
      STR_GetWord(prAsmEncodeInfo->word, '.', 2, tempWord[1]);

      if(!((STR_Match(tempWord[0], "FD") == true) && (STR_Match(tempWord[1], "}:") == true)))
      {
        //[함수 본체 끝] 에 해당하지 않는다.

        //[정보복구]
        //{
            *prAsmEncodeInfo = asmEncodeInfo_Backup;

        //}

        //해당하지 않으므로 여기서 종료한다.
        return(no);

      }

  //}

  //[ASM 번역]
  //{
      // FD.x.}:
      // fnend

      TEMPFILE_Add(prAsmEncodeInfo->word); TEMPFILE_Add(" \r\n");
      TEMPFILE_Add("fnend \r\n");

  //}

  //이상없이 완료 되었다.
  return(yes);

}

int __fastcall Tree_AsmEncode_FunctionCall(struct ASMENCODEINFO  *prAsmEncodeInfo)
{
  //[2008.12.15.월][생성!!!]{------------------------------------------------------
  //[함수 호출] 부분을 번역한다.
  //[인수] 는 이미 [1차번역기호] 로 정리되 있으므로 순서대로 읽어서 번역하면 된다.
  //}------------------------------------------------------------------------------

  //[번역내용]
  //{
      //[*.t]{---------------------------------------------------------------
      //
      // FU.x ( {param-list} )  //반환값이 없는 일반 사용함수.
      // FR.x ( {param-list} )  //[반환값] 이 있는 함수.
      //
      //[*.asm]--------------------------------------------------------------
      //
      // push 인수0 <인수0>     //[인수] 는 [순서대로] 전달한다.
      // push 인수1 <인수1>
      // push 인수2 <인수2>
      // ...
      // fncall :함수이름:      //원래 [함수이름] 의 [전역라벨] 로 변경한다.
      //
      //}--------------------------------------------------------------------

  //}

  //[VAR]
  //{
      class  DATABASE  *database;

      struct ASMENCODEINFO  asmEncodeInfo_Backup;

      //자주 사용되는 단어 처리용.
      char       tempWord[3][OPT_wordStrSize] = {""};
      char       funcOrgName[OPT_wordStrSize] = {""};

      char      *tempStr;

      char       hexStr[OPT_wordStrSize]      = {""};
      int        funcRecindex;

      int        i;

      //[인수] 의 크기를 얻는다.
      long long  paramSize;

      //[2008.12.16.화][추가!!!]
      //{
          //[인수] 의 순번을 가진다.
          int  paramXst;

      //}

  //}

  //[정보대피]
  //{
      //이 함수에 해당하지 않는 경우를 대비하여 정보를 대피시킨다.
      asmEncodeInfo_Backup = *prAsmEncodeInfo;

  //}

  //[DATABASE 위치 얻기]
  //{
      DATABASE_GetPtr(&database);

  //}

  //[임시 정의]
  //{
      //tempWord[] 각각의 정보를 구분하기 위한 이미 정의 index.
      #define  d_KindWord     0
      #define  d_Recinx       1

  //}

  //[함수 호출 인가?]
  //{
      //[!]{------------------------------------------------------------------
      //[함수본체시작] 부분은 "FU.x", "FR.x" 가 첫 단어 이므로 이를 검사한다.
      //"." 문자를 [구분자] 로 단어를 추출하면 간단하게 비교할수 있다.
      //}---------------------------------------------------------------------

      //[첫 단어 추출]
      //{
          //현재 행의 첫 단어를 추출한다.
          AsmEncode_GetWord(prAsmEncodeInfo, 0);

      //}

      //[안전장치]
      //{
          //[2009.11.18.수][중요수정!!!]{---------------------------------------------------------------
          //소스에 사용된 문자열이 너무 길어 '.' 를 구분자로 문자열을 추출한 것이 tempWord[]
          //의 크기를 넘는 경우는 오류가 발생하므로 아예 간단하게 [문자열] 인 경우는은 처리하지 않는다.
          //문자열의 경우는 <*.gtmp> 문서에는 항상 <"> 로 시작하므로 문자열은 경우는 처리하지 않느다.
          //}-------------------------------------------------------------------------------------------

          //[문자열] 행인지 확인한다.
          if(prAsmEncodeInfo->word[0] == '"')
          {
            //아예 해당하지 않는 것이므로 여기서 처리한다.

            //[정보복구]
            //{
                *prAsmEncodeInfo = asmEncodeInfo_Backup;

            //}

            //해당하지 않으므로 여기서 종료한다.
            return(no);

          }

      //}

      //[단어 분해]
      //{
          //"." 를 구분자로 0번, 1번 단어를 추출한다.
          STR_GetWord(prAsmEncodeInfo->word, '.', 0, tempWord[d_KindWord]);
          STR_GetWord(prAsmEncodeInfo->word, '.', 1, tempWord[d_Recinx]);

      //}

      if(!((STR_Match(tempWord[d_KindWord], "FU") == true) || (STR_Match(tempWord[d_KindWord], "FR") == true)))
      {
        //[함수호출] 에 해당하지 않는다.

        //[정보복구]
        //{
            (*prAsmEncodeInfo) = asmEncodeInfo_Backup;

        //}

        //해당하지 않으므로 여기서 종료한다.
        return(no);

      }

  //}

  //[ASM 번역]
  //{
      //[함수 정보 얻기]
      //{
          //[record-index 얻기]
          //{
              //이미 위에서 "." 을 구분자로 해당 record index 값을 추출하였으므로 값으로 바꾼다.

              STR_Assign(hexStr, "0x");
              STR_Add(hexStr, tempWord[d_Recinx]);

              //[값] 으로 변환.
              CONV_HexStr_To_IntVal(hexStr, &funcRecindex);

          //}

          //[실제 [함수이름] 추출]
          //{
              //소스상에서 사용된 실제 이 [함수] 의 [이름] 을 얻는다.

              database->REC_Field_Read2(funcRecindex, _F_name, NULL, &tempStr);

              STR_Assign(funcOrgName, tempStr);

          //}

          //[전역 라벨로 바꾸기]
          //{
              //[순수함수이름] 을 [전역라벨] 형식으로 변환한다.

              SYMBOL_Asm_MakeGlobalLabel_Self(funcOrgName);

          //}

      //}

      //[인수 전달 번역]
      //{
          //[!]{----------------------------------------------------------------------------------
          //[함수인수] 를 [순서대로] push 를 이용하여 전달한다.
          //
          // 0    1 2 ...
          // FU.x ( param-list )
          // FR.x ( param-list )
          //
          //로 이미 [1차번역] 시 ( param-list ) 부분에 각각의 [인수] 가 순서대로 [인수] 의
          //[1차번역기호] 로 기술되 있으므로 이를 읽어서 간단하게 번역할 수 있다.
          //pop 명령에서 사용되는 [크기] 정보는 {database}.size 에 이미 다 정리되 있다.
          //단, "( ) " 로 [인수목록] 안이 비어있는 경우로 [인수] 가 없는 경우는 처리 하지 않는다.
          //
          // 인수가 3 개 인 경우.
          //
          // push  L0 <L0>
          // push  L1 <L1>
          // push  L2 <L2>
          //
          //[지역변수] 0 번 부터 [인수] 에 해당하므로 해당 [지역변수] 를 대상으로 처리하면 된다.
          //}-------------------------------------------------------------------------------------

          //[임시 정의]
          //{
              //tempWord[] 각각의 정보를 구분하기 위한 이미 정의 index.
              #define  d_Param        0
              #define  d_Recinx       1
              #define  d_SizeSymbol   2

          //}

          //[인수] 는 index:2 부터 시작한다.
          for(i = 2, paramXst = 0; ; i++, paramXst++)
          {
            //[인수 기호 추출]
            //{
                //[!]{--------------------------
                //[인수] 의 [1차번역기호] 읽기.
                //}-----------------------------

                //지정 index 의 단어를 추출한다.
                AsmEncode_GetWord(prAsmEncodeInfo, i);

                //")" 문자 이전까지 처리하면 된다.
                if(STR_Match(prAsmEncodeInfo->word, ")") == true) break;

                //[인수 단어 저장]
                //{
                    //[인수] 의 [1차번역기호] 를 [ASM 기호] 로 변환하여 저장해놓는다.
                    STR_Assign(tempWord[d_Param], prAsmEncodeInfo->word);

                    //[ASM 기호] 로 변환.
                    SYMBOL_1st_To_Asm(true, tempWord[d_Param], NULL);

                //}

            //}

            //[[인수] 크기 얻기]
            //{
                //[2008.12.16.화][수정!!!]{----------------------------------
                //이 함수에 해당하는 지정 순번의 [인수] 의 [크기] 를 얻는다.
                //}----------------------------------------------------------

                //[중요주의!!!]{---------------------------------------------------------
                //이는 지금 사용된 [인수] 의 크기가 아니라 원래 [함수] 의 [선언인수] 의
                //크기를 사용해야 한다. 이는 지정 함수의 [인수] 공간에 전달하는 것이므로
                //받을 대상의 크기를 사용해야 한다.
                //}----------------------------------------------------------------------

                database->Get_FunctionParamSize(funcRecindex, paramXst, &paramSize);

                //[기호로 변환]
                //{
                    //[1차번역기호] 의 [상수기호] 로 변환한다.
                    SYMBOL_1ST_IntegerConstant(paramSize, tempWord[d_SizeSymbol]);

                    //[ASM 기호] 로 변환.
                    SYMBOL_1st_To_Asm(true, tempWord[d_SizeSymbol], NULL);

                //}

            //}

            //[ASM 번역 추가]
            //{
                // push 인수 <인수>

                TEMPFILE_Add("push ");
                TEMPFILE_Add(tempWord[d_Param]);      TEMPFILE_Add(" ");
                TEMPFILE_Add(tempWord[d_SizeSymbol]); TEMPFILE_Add(" \r\n");

            //}

          }

      //}

      //[함수 호출 번역]
      //{
          // fncall :함수이름:

          TEMPFILE_Add("fncall ");
          TEMPFILE_Add(funcOrgName);
          TEMPFILE_Add(" \r\n");

      //}

  //}

  END:

  //이상없이 완료 되었다.
  return(yes);

}

int __fastcall Tree_AsmEncode_TempStart(struct ASMENCODEINFO  *prAsmEncodeInfo)
{
  //[2008.12.08.월][생성!!!]{-------------------------------------------------
  //{temp} 시작을 처리한다.
  //단, { ofsAdr-list } 는 내부처리에 사용해야 하므로 별도 저장해 놓아야한다.
  //{temp} 가 몇개인지 알수 없으므로 그대로 문자열 헝태로 저장하는 것이 좋다.
  //
  //[2008.12.10.수][중요수정!!!]----------------------------------------------
  //{ ofsAdr-list } => { ofsADR:size-list } 로 수정되었으므로 두개의 정보를
  //":" [구분자] 로 구분하여 각각의 저장소에 정리해 주는 것으로 수정한다.
  //}-------------------------------------------------------------------------

  //[번역내용]
  //{
      //[*.t]{-----------------------------------
      //
      // #TEMP{ <TempTotal> { ofsAdr:size-list }
      //
      //[*.asm]----------------------------------
      //
      // tstart <TempTotal>
      //
      //}----------------------------------------

  //}

  //[VAR]
  //{
      class  DATABASE      *database;

      class  TEMPDATABASE  *tempdatabase;

      struct ASMENCODEINFO  asmEncodeInfo_Backup;

      char   wordTempTotal[OPT_wordStrSize] = {""};

      int    i;

      //[2008.12.10.수][추가!!!]
      //{
          //추출 단어를 저장하는데 사용한다.
          char   tempWord[OPT_wordStrSize] = {""};

      ///}

  //}

  //[정보대피]
  //{
      //이 함수에 해당하지 않는 경우를 대비하여 정보를 대피시킨다.
      asmEncodeInfo_Backup = *prAsmEncodeInfo;

  //}

  //[DATABASE 위치 얻기]
  //{
      DATABASE_GetPtr(&database);

      TEMPDATABASE_GetPtr(&tempdatabase);

  //}

  //[해당하는가?]
  //{
      //행의 첫단어가 "#TEMP{" 인지만 검사하면 된다.

      //현재 행의 첫 단어를 추출한다.
      AsmEncode_GetWord(prAsmEncodeInfo, 0);

      //[안전장치]
      //{
          //[2009.11.18.수][중요수정!!!]{---------------------------------------------------------------
          //소스에 사용된 문자열이 너무 길어 '.' 를 구분자로 문자열을 추출한 것이 tempWord[]
          //의 크기를 넘는 경우는 오류가 발생하므로 아예 간단하게 [문자열] 인 경우는은 처리하지 않는다.
          //문자열의 경우는 <*.gtmp> 문서에는 항상 <"> 로 시작하므로 문자열은 경우는 처리하지 않느다.
          //}-------------------------------------------------------------------------------------------

          //[문자열] 행인지 확인한다.
          if(prAsmEncodeInfo->word[0] == '"')
          {
            //아예 해당하지 않는 것이므로 여기서 처리한다.

            //[정보복구]
            //{
                *prAsmEncodeInfo = asmEncodeInfo_Backup;

            //}

            //해당하지 않으므로 여기서 종료한다.
            return(no);

          }

      //}

      if(STR_Match(prAsmEncodeInfo->word, "#TEMP{") != true)
      {
        //이 함수에 해당하지 않는다.

        //[정보복구]
        //{
            *prAsmEncodeInfo = asmEncodeInfo_Backup;

        //}

        //해당하지 않으므로 여기서 종료한다.
        return(no);

      }

  //}

  //[단어 수집]
  //{
      //[<TempTotal> 읽기]
      //{
          //번역시 사용해야 하므로 <TempTotal> 단어를 읽어서 저장해 놓는다.
          AsmEncode_GetWord(prAsmEncodeInfo, 1);

          STR_Assign(wordTempTotal, prAsmEncodeInfo->word);

          //[1st->ASM 기호 변환]
          //{
              //[2008.12.10.수][추가!!!]{-----------------
              //[피연산자] 의 기호를 ASM 용으로 바꿔준다.
              //}-----------------------------------------

              SYMBOL_1st_To_Asm(true, wordTempTotal, NULL);

          //}

      //}

      //[{ofsAdr:size-list} 처리]
      //{
          //[2008.12.10.수][수정!!!]{---------------------------------------------------
          //단어가 "ofsADR:size" 로 ":" 를 [구분자] 로 두개 정보로 구성되 있으므로 이를
          //각각 추출하여 지정된 저장소에 문자열로 함성하여 저장하는 것으로 수정한다.
          //}---------------------------------------------------------------------------

          //[!]{---------------------------------------------------------------------------
          //[추가주소] 단어를 하나씩 읽어서 {tempdatabase} 안의 지정 저장소에 기록해 준다.
          //"{", "}" 는 제외한 사이의 순수한 [추가주소] 만 단어 그대로 [공백한개] 단위로
          //계속 문자열로 합성하여 주면 된다.
          //
          //0      1           2 3
          //#TEMP{ <TempTotal> { ofsAdr:size-list }
          //로 실제 [추가주소] 단어는 "{" 단어 다음의 index:3 부터 시작한다.
          //}------------------------------------------------------------------------------

          //저장 공간을 초기화 한다.
          STR_Assign(tempdatabase->asmEncode_OfsAdrList, "");
          STR_Assign(tempdatabase->asmEncode_SizeList,   "");

          //실제 [주소단어] 는 index:3 부터 시작된다.
          for(i = 3; ; i++)
          {
            //지정 index 의 단어를 추출한다.
            AsmEncode_GetWord(prAsmEncodeInfo, i);

            //"}" 문자 이전까지 처리하면 된다.
            if(STR_Match(prAsmEncodeInfo->word, "}") == true) break;

            //[ofsADR/Size 정보 구분 처리]
            //{
                //[2008.12.10.수][수정!!!]{-----------------------------------------------------
                //현재 추출한 단어는 "ofsADR:Size" 로 두개의 정보가 ":" 로 붙어있으므로 ":" 를
                //[구분자] 로 각각 분리하여 개별적으로 해당 저장 공간에 문자열로 합성해야 한다.
                //}-----------------------------------------------------------------------------

                //[ofsADR 처리]
                //{
                    //":" 를 기준으로 index:0 의 단어가 해당된다.
                    STR_GetWord(prAsmEncodeInfo->word, ':', 0, tempWord);

                    //[저장소] 에 [공백 한개] 단위로 구분하여 추가한다.
                    STR_Add(tempdatabase->asmEncode_OfsAdrList, tempWord);
                    STR_Add(tempdatabase->asmEncode_OfsAdrList, " ");

                //}

                //[size 처리]
                //{
                    //":" 를 기준으로 index:1 의 단어가 해당된다.
                    STR_GetWord(prAsmEncodeInfo->word, ':', 1, tempWord);

                    //[저장소] 에 [공백 한개] 단위로 구분하여 추가한다.
                    STR_Add(tempdatabase->asmEncode_SizeList, tempWord);
                    STR_Add(tempdatabase->asmEncode_SizeList, " ");

                //}

            //}

          }

      //}

  //}

  //[ASM 번역]
  //{
      // tstart <TempTotal>

      TEMPFILE_Add("tstart ");
      TEMPFILE_Add(wordTempTotal);
      TEMPFILE_Add(" \r\n");
      
  //}

  //이상없이 완료 되었다.
  return(yes);

}

int __fastcall Tree_AsmEncode_TempEnd(struct ASMENCODEINFO  *prAsmEncodeInfo)
{
  //[2008.12.08.월][생성!!!]{--
  //{temp} 끝을 처리한다.
  //}--------------------------

  //[번역내용]
  //{
      //[*.t]{---
      //
      // #TEMP}
      //
      //[*.asm]--
      //
      // tend
      //
      //}--------

  //}

  //[VAR]
  //{
      struct ASMENCODEINFO  asmEncodeInfo_Backup;

  //}

  //[정보대피]
  //{
      //이 함수에 해당하지 않는 경우를 대비하여 정보를 대피시킨다.
      asmEncodeInfo_Backup = *prAsmEncodeInfo;

  //}

  //[해당하는가?]
  //{
      //행의 첫단어가 "#TEMP}" 인지만 검사하면 된다.

      //현재 행의 첫 단어를 추출한다.
      AsmEncode_GetWord(prAsmEncodeInfo, 0);

      //[안전장치]
      //{
          //[2009.11.18.수][중요수정!!!]{---------------------------------------------------------------
          //소스에 사용된 문자열이 너무 길어 '.' 를 구분자로 문자열을 추출한 것이 tempWord[]
          //의 크기를 넘는 경우는 오류가 발생하므로 아예 간단하게 [문자열] 인 경우는은 처리하지 않는다.
          //문자열의 경우는 <*.gtmp> 문서에는 항상 <"> 로 시작하므로 문자열은 경우는 처리하지 않느다.
          //}-------------------------------------------------------------------------------------------

          //[문자열] 행인지 확인한다.
          if(prAsmEncodeInfo->word[0] == '"')
          {
            //아예 해당하지 않는 것이므로 여기서 처리한다.

            //[정보복구]
            //{
                *prAsmEncodeInfo = asmEncodeInfo_Backup;

            //}

            //해당하지 않으므로 여기서 종료한다.
            return(no);

          }

      //}

      if(STR_Match(prAsmEncodeInfo->word, "#TEMP}") != true)
      {
        //이 함수에 해당하지 않는다.

        //[정보복구]
        //{
            *prAsmEncodeInfo = asmEncodeInfo_Backup;

        //}

        //해당하지 않으므로 여기서 종료한다.
        return(no);

      }

  //}

  //[ASM 번역]
  //{
      // tend

      TEMPFILE_Add("tend \r\n");

  //}

  //이상없이 완료 되었다.
  return(yes);

}

int __fastcall Tree_AsmEncode_Jump(struct ASMENCODEINFO  *prAsmEncodeInfo)
{
  //[2008.12.09.화][생성!!!]{--
  //jump 명령을 처리한다.
  //}--------------------------

  //[번역내용]
  //{
      //[*.t]{-------------------------------------------------------------------
      //
      // jump BU.x'
      // jump [라벨]
      //
      //[*.asm]------------------------------------------------------------------
      //
      // jump BD.x     //[사용라벨] 을 해당하는 [선언라벨] 기호로 바꾸어야 한다.
      // jump [라벨]   //[일반라벨] 의 경우는 그대로 복사하면 된다.
      //
      //}------------------------------------------------------------------------

  //}

  //[VAR]
  //{
      struct ASMENCODEINFO  asmEncodeInfo_Backup;

      char   tempWord[OPT_wordStrSize] = {""};

  //}

  //[정보대피]
  //{
      //이 함수에 해당하지 않는 경우를 대비하여 정보를 대피시킨다.
      asmEncodeInfo_Backup = *prAsmEncodeInfo;

  //}

  //[해당하는가?]
  //{
      //행의 첫단어가 "jump" 인지만 검사한다.

      //현재 행의 첫 단어를 추출한다.
      AsmEncode_GetWord(prAsmEncodeInfo, 0);

      //[안전장치]
      //{
          //[2009.11.18.수][중요수정!!!]{---------------------------------------------------------------
          //소스에 사용된 문자열이 너무 길어 '.' 를 구분자로 문자열을 추출한 것이 tempWord[]
          //의 크기를 넘는 경우는 오류가 발생하므로 아예 간단하게 [문자열] 인 경우는은 처리하지 않는다.
          //문자열의 경우는 <*.gtmp> 문서에는 항상 <"> 로 시작하므로 문자열은 경우는 처리하지 않느다.
          //}-------------------------------------------------------------------------------------------

          //[문자열] 행인지 확인한다.
          if(prAsmEncodeInfo->word[0] == '"')
          {
            //아예 해당하지 않는 것이므로 여기서 처리한다.

            //[정보복구]
            //{
                *prAsmEncodeInfo = asmEncodeInfo_Backup;

            //}

            //해당하지 않으므로 여기서 종료한다.
            return(no);

          }

      //}

      if(STR_Match(prAsmEncodeInfo->word, "jump") != true)
      {
        //이 함수에 해당하지 않는다.

        //[정보복구]
        //{
            *prAsmEncodeInfo = asmEncodeInfo_Backup;

        //}

        //해당하지 않으므로 여기서 종료한다.
        return(no);

      }

  //}

  //[BU/라벨 구분 처리]
  //{
      //[!]{---------------------------------------------------------------------
      //[BU.x':] 인 경우는 해당하는 [선언라벨기호] [BD.x:] 로 바꾸어 주어야 하며
      //[일반라벨] 인 경우는 그대로 복사하면 된다.
      //}------------------------------------------------------------------------

      //현재 행의 두번째 단어를 추출한다.
      AsmEncode_GetWord(prAsmEncodeInfo, 1);

      //단어의 "." 를 구분자로 첫번째 단어를 추출한다.
      STR_GetWord(prAsmEncodeInfo->word, '.', 0, tempWord);

      if(STR_Match(tempWord, "BU") == true)
      {
        //이 경우는 해당하는 [선언라벨] 의 기호 "BD.x" 로 바꿔준다.
        //해당하는 [사용라벨] 기호로 바꿔준다.
        SYMBOL_Asm_UseLabel_To_DefLabel_Self(prAsmEncodeInfo->word);

      }
      else
      {
        //[일반라벨] 인 경우는 수정 없이 그대로 복사하면 된다.

      }

  //}

  //[ASM 번역]
  //{
      // jump BD.x
      // jump [라벨]

      TEMPFILE_Add("jump ");
      TEMPFILE_Add(prAsmEncodeInfo->word);
      TEMPFILE_Add(" \r\n");

  //}

  //이상없이 완료 되었다.
  return(yes);

}

int __fastcall Tree_AsmEncode_Copy(struct ASMENCODEINFO  *prAsmEncodeInfo)
{
  //[2008.12.17.수][생성!!!]{--
  //copy 명령을 처리한다.
  //}--------------------------

  //[번역내용]
  //{
      //[*.t]{---------------------------------------------
      //
      // copy [도착] [시작] [크기]
      //
      //[*.asm]--------------------------------------------
      //
      // copy [도착] [시작] [크기] //그대로 복사하면 된다.
      //
      //}--------------------------------------------------

  //}

  //[VAR]
  //{
      struct ASMENCODEINFO  asmEncodeInfo_Backup;

      char   tempWord[OPT_wordStrSize] = {""};

  //}

  //[정보대피]
  //{
      //이 함수에 해당하지 않는 경우를 대비하여 정보를 대피시킨다.
      asmEncodeInfo_Backup = *prAsmEncodeInfo;

  //}

  //[해당하는가?]
  //{
      //행의 첫단어가 "copy" 인지만 검사한다.

      //현재 행의 첫 단어를 추출한다.
      AsmEncode_GetWord(prAsmEncodeInfo, 0);

      //[안전장치]
      //{
          //[2009.11.18.수][중요수정!!!]{---------------------------------------------------------------
          //소스에 사용된 문자열이 너무 길어 '.' 를 구분자로 문자열을 추출한 것이 tempWord[]
          //의 크기를 넘는 경우는 오류가 발생하므로 아예 간단하게 [문자열] 인 경우는은 처리하지 않는다.
          //문자열의 경우는 <*.gtmp> 문서에는 항상 <"> 로 시작하므로 문자열은 경우는 처리하지 않느다.
          //}-------------------------------------------------------------------------------------------

          //[문자열] 행인지 확인한다.
          if(prAsmEncodeInfo->word[0] == '"')
          {
            //아예 해당하지 않는 것이므로 여기서 처리한다.

            //[정보복구]
            //{
                *prAsmEncodeInfo = asmEncodeInfo_Backup;

            //}

            //해당하지 않으므로 여기서 종료한다.
            return(no);

          }

      //}

      if(STR_Match(prAsmEncodeInfo->word, "copy") != true)
      {
        //이 함수에 해당하지 않는다.

        //[정보복구]
        //{
            *prAsmEncodeInfo = asmEncodeInfo_Backup;

        //}

        //해당하지 않으므로 여기서 종료한다.
        return(no);

      }

  //}

  //[ASM 번역]
  //{
      // 0    1      2      3
      // copy [도착] [시작] [크기]

      TEMPFILE_Add("copy ");

      //[도착]
      //{
          AsmEncode_GetWord(prAsmEncodeInfo, 1);
          SYMBOL_1st_To_Asm(true, prAsmEncodeInfo->word, NULL);

          TEMPFILE_Add(prAsmEncodeInfo->word); TEMPFILE_Add(" ");

      //}

      //[시작]
      //{
          AsmEncode_GetWord(prAsmEncodeInfo, 2);
          SYMBOL_1st_To_Asm(true, prAsmEncodeInfo->word, NULL);

          TEMPFILE_Add(prAsmEncodeInfo->word); TEMPFILE_Add(" ");

      //}

      //[크기]
      //{
          AsmEncode_GetWord(prAsmEncodeInfo, 3);
          SYMBOL_1st_To_Asm(true, prAsmEncodeInfo->word, NULL);

          TEMPFILE_Add(prAsmEncodeInfo->word); TEMPFILE_Add(" \r\n");

      //}

  //}

  //이상없이 완료 되었다.
  return(yes);

}

int __fastcall Tree_AsmEncode_Conjt(struct ASMENCODEINFO  *prAsmEncodeInfo)
{
  //[2008.12.17.수][생성!!!]{--
  //conjt 명령을 처리한다.
  //}--------------------------

  //[번역내용]
  //{
      //[*.t]{--------------------------------
      //
      // conjt [라벨]
      //
      //[*.asm]-------------------------------
      //
      // conjt [라벨] //그대로 복사하면 된다.
      //
      //}-------------------------------------

  //}

  //[VAR]
  //{
      struct ASMENCODEINFO  asmEncodeInfo_Backup;

      char   tempWord[OPT_wordStrSize] = {""};

  //}

  //[정보대피]
  //{
      //이 함수에 해당하지 않는 경우를 대비하여 정보를 대피시킨다.
      asmEncodeInfo_Backup = *prAsmEncodeInfo;

  //}

  //[해당하는가?]
  //{
      //행의 첫단어가 "conjt" 인지만 검사한다.

      //현재 행의 첫 단어를 추출한다.
      AsmEncode_GetWord(prAsmEncodeInfo, 0);

      //[안전장치]
      //{
          //[2009.11.18.수][중요수정!!!]{---------------------------------------------------------------
          //소스에 사용된 문자열이 너무 길어 '.' 를 구분자로 문자열을 추출한 것이 tempWord[]
          //의 크기를 넘는 경우는 오류가 발생하므로 아예 간단하게 [문자열] 인 경우는은 처리하지 않는다.
          //문자열의 경우는 <*.gtmp> 문서에는 항상 <"> 로 시작하므로 문자열은 경우는 처리하지 않느다.
          //}-------------------------------------------------------------------------------------------

          //[문자열] 행인지 확인한다.
          if(prAsmEncodeInfo->word[0] == '"')
          {
            //아예 해당하지 않는 것이므로 여기서 처리한다.

            //[정보복구]
            //{
                *prAsmEncodeInfo = asmEncodeInfo_Backup;

            //}

            //해당하지 않으므로 여기서 종료한다.
            return(no);

          }

      //}

      if(STR_Match(prAsmEncodeInfo->word, "conjt") != true)
      {
        //이 함수에 해당하지 않는다.

        //[정보복구]
        //{
            *prAsmEncodeInfo = asmEncodeInfo_Backup;

        //}

        //해당하지 않으므로 여기서 종료한다.
        return(no);

      }

  //}

  //[ASM 번역]
  //{
      // 0     1
      // conjt [라벨]

      TEMPFILE_Add("conjt ");

      //[라벨]
      //{
          AsmEncode_GetWord(prAsmEncodeInfo, 1);

          TEMPFILE_Add(prAsmEncodeInfo->word); TEMPFILE_Add(" \r\n");

      //}

  //}

  //이상없이 완료 되었다.
  return(yes);

}

int __fastcall Tree_AsmEncode_Conjf(struct ASMENCODEINFO  *prAsmEncodeInfo)
{
  //[2008.12.17.수][생성!!!]{--
  //conjf 명령을 처리한다.
  //}--------------------------

  //[번역내용]
  //{
      //[*.t]{--------------------------------
      //
      // conjf [라벨]
      //
      //[*.asm]-------------------------------
      //
      // conjf [라벨] //그대로 복사하면 된다.
      //
      //}-------------------------------------

  //}

  //[VAR]
  //{
      struct ASMENCODEINFO  asmEncodeInfo_Backup;

      char   tempWord[OPT_wordStrSize] = {""};

  //}

  //[정보대피]
  //{
      //이 함수에 해당하지 않는 경우를 대비하여 정보를 대피시킨다.
      asmEncodeInfo_Backup = *prAsmEncodeInfo;

  //}

  //[해당하는가?]
  //{
      //행의 첫단어가 "conjf" 인지만 검사한다.

      //현재 행의 첫 단어를 추출한다.
      AsmEncode_GetWord(prAsmEncodeInfo, 0);

      //[안전장치]
      //{
          //[2009.11.18.수][중요수정!!!]{---------------------------------------------------------------
          //소스에 사용된 문자열이 너무 길어 '.' 를 구분자로 문자열을 추출한 것이 tempWord[]
          //의 크기를 넘는 경우는 오류가 발생하므로 아예 간단하게 [문자열] 인 경우는은 처리하지 않는다.
          //문자열의 경우는 <*.gtmp> 문서에는 항상 <"> 로 시작하므로 문자열은 경우는 처리하지 않느다.
          //}-------------------------------------------------------------------------------------------

          //[문자열] 행인지 확인한다.
          if(prAsmEncodeInfo->word[0] == '"')
          {
            //아예 해당하지 않는 것이므로 여기서 처리한다.

            //[정보복구]
            //{
                *prAsmEncodeInfo = asmEncodeInfo_Backup;

            //}

            //해당하지 않으므로 여기서 종료한다.
            return(no);

          }

      //}

      if(STR_Match(prAsmEncodeInfo->word, "conjf") != true)
      {
        //이 함수에 해당하지 않는다.

        //[정보복구]
        //{
            *prAsmEncodeInfo = asmEncodeInfo_Backup;

        //}

        //해당하지 않으므로 여기서 종료한다.
        return(no);

      }

  //}

  //[ASM 번역]
  //{
      // 0     1
      // conjf [라벨]

      TEMPFILE_Add("conjf ");

      //[라벨]
      //{
          AsmEncode_GetWord(prAsmEncodeInfo, 1);

          TEMPFILE_Add(prAsmEncodeInfo->word); TEMPFILE_Add(" \r\n");

      //}

  //}

  //이상없이 완료 되었다.
  return(yes);

}

int __fastcall Tree_AsmEncode_Push(struct ASMENCODEINFO  *prAsmEncodeInfo)
{
  //[2008.12.17.수][생성!!!]{--
  //push 명령을 처리한다.
  //}--------------------------

  //[번역내용]
  //{
      //[*.t]{--------------------------------------
      //
      // push [대상] [크기]
      //
      //[*.asm]-------------------------------------
      //
      // push [대상] [크기] //그대로 복사하면 된다.
      //
      //}-------------------------------------------

  //}

  //[VAR]
  //{
      struct ASMENCODEINFO  asmEncodeInfo_Backup;

      char   tempWord[OPT_wordStrSize] = {""};

  //}

  //[정보대피]
  //{
      //이 함수에 해당하지 않는 경우를 대비하여 정보를 대피시킨다.
      asmEncodeInfo_Backup = *prAsmEncodeInfo;

  //}

  //[해당하는가?]
  //{
      //행의 첫단어가 "push" 인지만 검사한다.

      //현재 행의 첫 단어를 추출한다.
      AsmEncode_GetWord(prAsmEncodeInfo, 0);

      //[안전장치]
      //{
          //[2009.11.18.수][중요수정!!!]{---------------------------------------------------------------
          //소스에 사용된 문자열이 너무 길어 '.' 를 구분자로 문자열을 추출한 것이 tempWord[]
          //의 크기를 넘는 경우는 오류가 발생하므로 아예 간단하게 [문자열] 인 경우는은 처리하지 않는다.
          //문자열의 경우는 <*.gtmp> 문서에는 항상 <"> 로 시작하므로 문자열은 경우는 처리하지 않느다.
          //}-------------------------------------------------------------------------------------------

          //[문자열] 행인지 확인한다.
          if(prAsmEncodeInfo->word[0] == '"')
          {
            //아예 해당하지 않는 것이므로 여기서 처리한다.

            //[정보복구]
            //{
                *prAsmEncodeInfo = asmEncodeInfo_Backup;

            //}

            //해당하지 않으므로 여기서 종료한다.
            return(no);

          }

      //}

      if(STR_Match(prAsmEncodeInfo->word, "push") != true)
      {
        //이 함수에 해당하지 않는다.

        //[정보복구]
        //{
            *prAsmEncodeInfo = asmEncodeInfo_Backup;

        //}

        //해당하지 않으므로 여기서 종료한다.
        return(no);

      }

  //}

  //[ASM 번역]
  //{
      // 0    1      2
      // push [대상] [크기]

      TEMPFILE_Add("push ");

      //[대상]
      //{
          AsmEncode_GetWord(prAsmEncodeInfo, 1);
          SYMBOL_1st_To_Asm(true, prAsmEncodeInfo->word, NULL);

          TEMPFILE_Add(prAsmEncodeInfo->word); TEMPFILE_Add(" ");

      //}

      //[크기]
      //{
          AsmEncode_GetWord(prAsmEncodeInfo, 2);
          SYMBOL_1st_To_Asm(true, prAsmEncodeInfo->word, NULL);

          TEMPFILE_Add(prAsmEncodeInfo->word); TEMPFILE_Add(" \r\n");

      //}

  //}

  //이상없이 완료 되었다.
  return(yes);

}

int __fastcall Tree_AsmEncode_Pop(struct ASMENCODEINFO  *prAsmEncodeInfo)
{
  //[2008.12.17.수][생성!!!]{--
  //pop 명령을 처리한다.
  //}--------------------------

  //[번역내용]
  //{
      //[*.t]{-------------------------------------
      //
      // pop [대상] [크기]
      //
      //[*.asm]------------------------------------
      //
      // pop [대상] [크기] //그대로 복사하면 된다.
      //
      //}------------------------------------------

  //}

  //[VAR]
  //{
      struct ASMENCODEINFO  asmEncodeInfo_Backup;

      char   tempWord[OPT_wordStrSize] = {""};

  //}

  //[정보대피]
  //{
      //이 함수에 해당하지 않는 경우를 대비하여 정보를 대피시킨다.
      asmEncodeInfo_Backup = *prAsmEncodeInfo;

  //}

  //[해당하는가?]
  //{
      //행의 첫단어가 "pop" 인지만 검사한다.

      //현재 행의 첫 단어를 추출한다.
      AsmEncode_GetWord(prAsmEncodeInfo, 0);

      //[안전장치]
      //{
          //[2009.11.18.수][중요수정!!!]{---------------------------------------------------------------
          //소스에 사용된 문자열이 너무 길어 '.' 를 구분자로 문자열을 추출한 것이 tempWord[]
          //의 크기를 넘는 경우는 오류가 발생하므로 아예 간단하게 [문자열] 인 경우는은 처리하지 않는다.
          //문자열의 경우는 <*.gtmp> 문서에는 항상 <"> 로 시작하므로 문자열은 경우는 처리하지 않느다.
          //}-------------------------------------------------------------------------------------------

          //[문자열] 행인지 확인한다.
          if(prAsmEncodeInfo->word[0] == '"')
          {
            //아예 해당하지 않는 것이므로 여기서 처리한다.

            //[정보복구]
            //{
                *prAsmEncodeInfo = asmEncodeInfo_Backup;

            //}

            //해당하지 않으므로 여기서 종료한다.
            return(no);

          }

      //}

      if(STR_Match(prAsmEncodeInfo->word, "pop") != true)
      {
        //이 함수에 해당하지 않는다.

        //[정보복구]
        //{
            *prAsmEncodeInfo = asmEncodeInfo_Backup;

        //}

        //해당하지 않으므로 여기서 종료한다.
        return(no);

      }

  //}

  //[ASM 번역]
  //{
      // 0   1      2
      // pop [대상] [크기]

      TEMPFILE_Add("pop ");

      //[대상]
      //{
          AsmEncode_GetWord(prAsmEncodeInfo, 1);
          SYMBOL_1st_To_Asm(true, prAsmEncodeInfo->word, NULL);

          TEMPFILE_Add(prAsmEncodeInfo->word); TEMPFILE_Add(" ");

      //}

      //[크기]
      //{
          AsmEncode_GetWord(prAsmEncodeInfo, 2);
          SYMBOL_1st_To_Asm(true, prAsmEncodeInfo->word, NULL);

          TEMPFILE_Add(prAsmEncodeInfo->word); TEMPFILE_Add(" \r\n");

      //}

  //}

  //이상없이 완료 되었다.
  return(yes);

}

int __fastcall Tree_AsmEncode_Label(struct ASMENCODEINFO  *prAsmEncodeInfo)
{
  //[2008.12.18.목][생성!!!]{-------
  //[라벨] 을 처리한다.
  //[라벻] 은 그대로 복사하면 된다.
  //}-------------------------------

  //[번역내용]
  //{
      //[*.t]{---------------------------------------------
      //
      // [라벨]
      //
      //[*.asm]--------------------------------------------
      //
      // [라벨]   //[라벨] 의 경우는 그대로 복사하면 된다.
      //
      //}--------------------------------------------------

  //}

  //[VAR]
  //{
      struct ASMENCODEINFO  asmEncodeInfo_Backup;

      char   tempWord[OPT_wordStrSize] = {""};

      //단어의 길이를 가진다.
      int    wordLength;

  //}

  //[정보대피]
  //{
      //이 함수에 해당하지 않는 경우를 대비하여 정보를 대피시킨다.
      asmEncodeInfo_Backup = *prAsmEncodeInfo;

  //}

  //[해당하는가?]
  //{
      //첫단어의 끝에 ":" 문자가 붙어 있는지 확인한다.

      //현재 행의 첫 단어를 추출한다.
      AsmEncode_GetWord(prAsmEncodeInfo, 0);

      //[안전장치]
      //{
          //[2009.11.18.수][중요수정!!!]{---------------------------------------------------------------
          //소스에 사용된 문자열이 너무 길어 '.' 를 구분자로 문자열을 추출한 것이 tempWord[]
          //의 크기를 넘는 경우는 오류가 발생하므로 아예 간단하게 [문자열] 인 경우는은 처리하지 않는다.
          //문자열의 경우는 <*.gtmp> 문서에는 항상 <"> 로 시작하므로 문자열은 경우는 처리하지 않느다.
          //}-------------------------------------------------------------------------------------------

          //[문자열] 행인지 확인한다.
          if(prAsmEncodeInfo->word[0] == '"')
          {
            //아예 해당하지 않는 것이므로 여기서 처리한다.

            //[정보복구]
            //{
                *prAsmEncodeInfo = asmEncodeInfo_Backup;

            //}

            //해당하지 않으므로 여기서 종료한다.
            return(no);

          }

      //}

      //[단어길이얻기]
      //{
          wordLength = STR_Length(prAsmEncodeInfo->word);

      //}

      if(!((wordLength > 0) && (prAsmEncodeInfo->word[wordLength - 1] == ':')))
      {
        //이 함수에 해당하지 않는다.

        //[정보복구]
        //{
            *prAsmEncodeInfo = asmEncodeInfo_Backup;

        //}

        //해당하지 않으므로 여기서 종료한다.
        return(no);

      }

  //}

  //[ASM 번역]
  //{
      // [라벨]

      TEMPFILE_Add(prAsmEncodeInfo->word);
      TEMPFILE_Add(" \r\n");

  //}

  //이상없이 완료 되었다.
  return(yes);

}

int __fastcall Tree_AsmEncode_Operator(struct ASMENCODEINFO  *prAsmEncodeInfo)
{
  //[2008.12.20.일][생성!!!]}{----------------------------------------------------
  //순수한 [연산자] 를 번역한다.
  //[연산자] 는 개수가 많으므로 각각을 함수로 만들어 처리하지 않고 이 함수 안에서
  //구분하여 처리한다.
  //}-----------------------------------------------------------------------------

  //[VAR]
  //{
      struct ASMENCODEINFO  asmEncodeInfo_Backup;

      char   tempWord[OPT_wordStrSize] = {""};

      int    i;

      int    wordCount;

  //}

  //[정보대피]
  //{
      //이 함수에 해당하지 않는 경우를 대비하여 정보를 대피시킨다.
      asmEncodeInfo_Backup = *prAsmEncodeInfo;

  //}

  //[연산자 구분처리]
  //{
      //[첫단어 추출]
      //{
          AsmEncode_GetWord(prAsmEncodeInfo, 0);

      //}

      //[안전장치]
      //{
          //[2009.11.18.수][중요수정!!!]{---------------------------------------------------------------
          //소스에 사용된 문자열이 너무 길어 '.' 를 구분자로 문자열을 추출한 것이 tempWord[]
          //의 크기를 넘는 경우는 오류가 발생하므로 아예 간단하게 [문자열] 인 경우는은 처리하지 않는다.
          //문자열의 경우는 <*.gtmp> 문서에는 항상 <"> 로 시작하므로 문자열은 경우는 처리하지 않느다.
          //}-------------------------------------------------------------------------------------------

          //[문자열] 행인지 확인한다.
          if(prAsmEncodeInfo->word[0] == '"')
          {
            //아예 해당하지 않는 것이므로 여기서 처리한다.

            //[정보복구]
            //{
                *prAsmEncodeInfo = asmEncodeInfo_Backup;

            //}

            //해당하지 않으므로 여기서 종료한다.
            return(no);

          }

      //}

      //그대로 [1차번역기호] 를 [ASM기호] 로 변환하여 [단어] 단위로 복사하면 된다.

      if     (STR_Match(prAsmEncodeInfo->word, "[]") == true)
      {
        // [] D A B C

        wordCount = 5;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "->") == true)
      {
        // -> D A B

        wordCount = 4;

      }
      else if(STR_Match(prAsmEncodeInfo->word, ".") == true)
      {
        // . D A B

        wordCount = 4;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "!/") == true)
      {
        // !/ D A

        wordCount = 3;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "~/") == true)
      {
        // ~/ D A

        wordCount = 3;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "++") == true)
      {
        // ++ A

        wordCount = 2;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "--") == true)
      {
        // -- A

        wordCount = 2;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "-/") == true)
      {
        //(-) 부호
        // - D A

        wordCount = 3;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "*/") == true)
      {
        // */ D A

        wordCount = 3;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "&/") == true)
      {
        // &/ D A

        wordCount = 3;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "*") == true)
      {
        // * D A B

        wordCount = 4;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "/") == true)
      {
        // / D A B

        wordCount = 4;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "%") == true)
      {
        // % D A B

        wordCount = 4;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "+") == true)
      {
        // + D A B

        wordCount = 4;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "+*") == true)
      {
        //특수연산자
        // +* D A B C
        // D = A + (B * C)

        wordCount = 5;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "-") == true)
      {
        // - D A B

        wordCount = 4;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "-*") == true)
      {
        //특수연산자
        // -* D A B C
        // D = A - (B * C)

        wordCount = 5;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "<<") == true)
      {
        // << D A B

        wordCount = 4;

      }
      else if(STR_Match(prAsmEncodeInfo->word, ">>") == true)
      {
        // >> D A B

        wordCount = 4;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "<") == true)
      {
        // < D A B

        wordCount = 4;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "<=") == true)
      {
        // <= D A B

        wordCount = 4;

      }
      else if(STR_Match(prAsmEncodeInfo->word, ">") == true)
      {
        // > D A B

        wordCount = 4;

      }
      else if(STR_Match(prAsmEncodeInfo->word, ">=") == true)
      {
        // >= D A B

        wordCount = 4;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "==") == true)
      {
        // == D A B

        wordCount = 4;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "!=") == true)
      {
        // != D A B

        wordCount = 4;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "&") == true)
      {
        // & D A B

        wordCount = 4;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "^") == true)
      {
        // ^ D A B

        wordCount = 4;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "|") == true)
      {
        // | D A B

        wordCount = 4;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "&&") == true)
      {
        // && D A B

        wordCount = 4;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "||") == true)
      {
        // || D A B

        wordCount = 4;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "=") == true)
      {
        // = D A

        wordCount = 3;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "+=") == true)
      {
        // += D A

        wordCount = 3;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "+=*") == true)
      {
        //특수연산자
        // +=* A B C
        // A = A + (B * C)

        wordCount = 4;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "-=") == true)
      {
        // -= D A

        wordCount = 3;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "-=*") == true)
      {
        //특수연산자
        // -=* A B C
        // A = A - (B * C)

        wordCount = 4;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "*=") == true)
      {
        // *= D A

        wordCount = 3;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "/=") == true)
      {
        // /= D A

        wordCount = 3;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "%=") == true)
      {
        // %= D A

        wordCount = 3;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "&=") == true)
      {
        // &= D A

        wordCount = 3;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "^=") == true)
      {
        // ^= D A

        wordCount = 3;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "|=") == true)
      {
        // |= D A

        wordCount = 3;

      }
      else if(STR_Match(prAsmEncodeInfo->word, "<<=") == true)
      {
        // <<= D A

        wordCount = 3;

      }
      else if(STR_Match(prAsmEncodeInfo->word, ">>=") == true)
      {
        // >>= D A

        wordCount = 3;

      }
      else
      {
        //[연산자] 에 해당하지 않는다.

        //[정보복구]
        //{
            *prAsmEncodeInfo = asmEncodeInfo_Backup;

        //}

        //해당하지 않으므로 여기서 종료한다.
        return(no);

      }

  //}

  //[번역]
  //{
      for(i = 0; i < wordCount; i++)
      {
        //해당 순번의 [단어] 를 추출한다.
        AsmEncode_GetWord(prAsmEncodeInfo, i);

        if(i > 0)
        {
          //[!]{----------------------------------------------------------------------
          //i:0 인 경우는 [연산자] 로 그대로 복사해야 하므로 변환에서 제외 해야 한다.
          //}-------------------------------------------------------------------------

          //[1차번역기호] 를 [ASM 기호] 로 변환한다.
          SYMBOL_1st_To_Asm(true, prAsmEncodeInfo->word, NULL);

        }

        //[ASM 번역]
        //{
            TEMPFILE_Add(prAsmEncodeInfo->word); TEMPFILE_Add(" ");

        //}

      }

      //[행 마감]
      //{
          TEMPFILE_Add("\r\n");

      //}

  //}

  //이상없이 완료 되었다.
  return(yes);

}

int __fastcall Tree_AsmEncode_String(struct ASMENCODEINFO  *prAsmEncodeInfo)
{
  //[2008.12.21.일][생성!!!]{--------------------------------------------------------------------
  //[문자열] 을 처리한다.
  //[문자열] 은 여기서 바로 <code> 로 바꾼다.
  //
  //[2009.05.14.목][중요수정!!!]-----------------------------------------------------------------
  //[맷돌-C] 내부 적으로는 문자열 안의 [제어문자] 도 일반 문자로 간주되지만
  //여기서는 실게 번역을 하는 것이므로 반드시 해당 <code> 로 변환해서 번역해야 한다.
  //이미 [제어문자] 를 반영한 실제 정확한 문자열의 추가 주소는 {DATABASE}->STRINGLIST_Add() 에서
  //자동 처리 되었으므로 여기서는 단지 [제어문자] 룰 변환하여 <code> 화 하기만 하면 된다.
  //}--------------------------------------------------------------------------------------------

  //[번역내용]
  //{
      //[*.t]{-------------------------------------
      //
      // "문자열"
      //
      //[*.asm]------------------------------------
      //
      // "문자열"   //[문자열] 은 그대로 복사한다.
      //
      //}------------------------------------------

  //}

  //[2009.01.06.화][중요수정!!!]
  //{
      //[!]{--------------------------------------------------------------------------------
      //이전과 달리 [문자열] 을 그대로 저장하지 않고, 바로 해당 code 로 바꿔서 저장해 준다.
      //이는 [문자열] 각각의 [추가주소] 를 간단하게 얻게 하기 위한 것으로 [문자열] 은
      //직접적으로 더이상 의미가 없으므로 [1차 번역] 시에 바로 code 로 바꿔 주는 것이 좋다.
      //단, 아래와 같이 수정되어야 한다.
      // "문자열..." = > 문자열code... + '\0'
      //로 ["] 를 제외해 주어야 한다.
      //}-----------------------------------------------------------------------------------

      //[중요!!!]
      //{
          //[문자열] 을 code 로 만드는 것이므로 [문자열] 끝을 알려주는 '\0' 을 반드시
          //뒤에 붙어 주어야 한다.

      //}

  //}

  //[VAR]
  //{
      struct ASMENCODEINFO  asmEncodeInfo_Backup;

      char   lineStr[OPT_lineStrSize*10] = {""};

      //[2009.01.06.화][추가!!!]
      //{
          int   i;

          //처리할 문자열의 byte 단위 길이를 얻는다.
          int   strLength;

          //1 byte 값을 변환한 2 byte 크기의 문자열을 저장한다.
          char  byteStr[3];

          //cocde 로 변환된 문자열을 저장한다.
          char  codeStr[OPT_lineStrSize*10] = {""};

      //}

  //}

  //[정보대피]
  //{
      //이 함수에 해당하지 않는 경우를 대비하여 정보를 대피시킨다.
      asmEncodeInfo_Backup = *prAsmEncodeInfo;

  //}

  //[해당하는가?]
  //{
      //첫단어가 ["] 문자이면 이 행은 [문자열] 행이다.

      //현재 행의 첫 단어를 추출한다.
      AsmEncode_GetWord(prAsmEncodeInfo, 0);

      if(prAsmEncodeInfo->word[0] != '"')
      {
        //이 함수에 해당하지 않는다.

        //[정보복구]{----------------------------
        *prAsmEncodeInfo = asmEncodeInfo_Backup;
        //}--------------------------------------

        //해당하지 않으므로 여기서 종료한다.
        return(no);

      }

  //}

  //[행 문자열 추출]
  //{
      //현재 행의 문자열을 추출한다.
      STR_Get_ThisLineStr(prAsmEncodeInfo->tBuf, prAsmEncodeInfo->lineStartIndex, lineStr);

  //}

  //[문자열 길이 구하기]
  //{
      //[2009.01.06.화][추가!!!]
      strLength = STR_Length(lineStr);

  //}

  //[code 로 변환]
  //{
      //[!]{----------------------------------------------------------------------------------
      //1 byte 단위로 해당 code 값을 16진수 2 digit 의 [문자열 code] 로 바꾼다.
      //[문자열 code] 이므로 16진수 최소 표기가 아니라 정확하게 2 digit 로 해야 한다.
      //
      //여기까지의 [문자열] 은 { "문자열"[공백] } 의 형식으로 ["] 문자 2 개와 맨 뒤에
      //[공백] 이 붙어 있는 형식이므로 3 byte 를 빼 주어야 순수하게 "..." 사이의 문자열
      //길이가 된다.
      //
      //[2009.05.14.목][중요수정!!!]----------------------------------------------------------
      //현재 추출한 문자열은 관리를 위하여 [제어문자] 도 일반 문자처럼 취급한 것이므로
      //여기서 <code> 로 변환시에는 전부 실제 [제어문자] 의 <code> 로 변환하여 처리해야 한다.
      //이를 위하여 먼저 문자열을 [제어문자] 가 반영된 문자열로 변환하고 이 변환된 문자열을
      //<code> 로 번역하는 것으로 처리한다.
      //}-------------------------------------------------------------------------------------


      //[문자열 변환]
      //{
          //[2009.05.14.목][중요수정!!!]
          //먼저 [제어문자] 가 반영된 실제 사용되는 문자열로 변환한다.
          //처리되는 문자열 길이도 변환된 문자열의 길이를 사용해야 한다.
          Str_Conv_Escape(lineStr, codeStr, &strLength);

          //다시 lineStr 에 정리하므로 이것을 초기화 한다.
          lineStr[0] = '\0';

      //}


      //["] 를 제외한 순수 문자열은 index:1 부터 시작한다.
      for(i = 1;
          //실제 [문자열] 의 끝은 뒤에서 2 byte 를 뺀 길이 까지가 된다.
          i < (strLength - 2);
          i++)
      {
        //항상 2 digit 로 변환----------v
        CONV_LongVal_To_Hex(codeStr[i], 2, byteStr);

        //code 문자열로 합성한다.
        STR_Add(lineStr, byteStr);

      }

      //[문자열 끝 만들기]
      //{
          //[문자열] 은 반드시 뒤에 '0'(code:0x00) 이 있어야 하므로 이를 만들어 붙여 준다.
          STR_Add(lineStr, "00");

      //}

  //}

  //[ASM 번역]
  //{
      // "문자열" 그대로 복사한다.
      TEMPFILE_Add(lineStr);

      //공백도 하나 붙여 주어야 한다.
      TEMPFILE_Add(" \r\n");

  //}

  //이상없이 완료 되었다.
  return(yes);

}

//[기본 처리 함수]--------------------------------------------------------------

void __fastcall AsmEncode_GetWord(//정보구조체.
                                  struct ASMENCODEINFO  *prAsmEncodeInfo,
                                  //지정 단어 순번(BASE : 0).
                                  int    pWordIndex)
{
  //[2008.12.07.일][생성!!!]{--------------------------------------------------------------
  //[정보구조체] 를 전달 받아서 현재 정보를 참고하여 해당 순번의 단어를 추출하여 반환한다.
  //현재 행의 시작 index 값등 기본 정보는 전부 [정보구조체] 에 들어 있다.
  //}--------------------------------------------------------------------------------------

  //[단어 추출]
  //{
      //현재 행의 첫 단어를 추출한다.
      STR_GetLineWordBuf(prAsmEncodeInfo->tBuf,
                         prAsmEncodeInfo->lineStartIndex,
                         pWordIndex,
                         &(prAsmEncodeInfo->wordStartIndex),
                         prAsmEncodeInfo->word);

  //}

  return;

}


















