

#include <vcl.h>
#pragma hdrstop


#include  "API_Str.h"

#include  "vmos_def.h"
#include  "vmos.h"
#include  "c_define.h"

#include  "ide_library.h"

//[2011.10.14.금][추가!!!]
//<_API_Str_Width_Ellipsis()> 에서 사용되는 [기본글꼴] 에 접근하기 위한것.
#include  "ide_caption.h"

//[]2018.07.02.월][추가!!!]
#include  "font.h"


//[2011.11.29.화][중요수정!!!]{*******
//신형 API 방식으로 전부 새롭게 수정.
//}***********************************


void __fastcall _API_Str_Length(void)
{
  //[2011.10.12.수][생성!!!]{----
  //[2011.11.29.화][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //}----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.29.화][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;

          DTS4  rReturn;

       //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{----------------------------
  //int _Str_길이얻기_(char  *p문자열);
  //}------------------------------------
  //STR_Length()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 변환.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[명령처리]
  //{
      rReturn = STR_Length((char *)pStr);

  //}

  //[반환]
  //{
      //[값] 쓰기.
      if(vmos->VMOS_WrRd(d_Wr, ADR, (4), (DTU1 *)(&rReturn)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

  //}

}

void __fastcall _API_Str_Match(void)
{
  //[2011.10.12.수][생성!!!]{----
  //[2011.11.29.화][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //{----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.29.화][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pA;
          DTU8  pB;
          DTU1  pCaseUse;

          DTU1  rReturn;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{-----------------------------------------------------------
  //bool
  //unsigned char _Str_일치확인_(char           *pA,
  //                             char           *pB,
  //                             unsigned char   p대소문자구분); //bool
  //}-------------------------------------------------------------------
  //STR_Match() + STR_Match_NoCase()
  //<p대소문자구분> 인수를 구분하여 두개 함수를 복합 적으로 처리.

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *pA]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pA)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pA, &pA);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[char  *pB]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pB)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pB, &pB);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[unsigned char  p대소문자구분]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (1), (DTU1 *)(&pCaseUse)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (1);
      //}--------------------------

  //}

  //[명령처리]
  //{
      //[!]{-------------------------------------------------------
      //[대소문자 구분] 여부에 따라 해당 함수를 사용하여 처리한다.
      //STR_Match() + STR_Match_NoCase()
      //}----------------------------------------------------------

      if(pCaseUse == true)
      {
        //대/소 구분 처리.
        rReturn = STR_Match((char *)pA, (char *)pB);

      }
      else
      {
        //대/소 구분없이 처리.
        rReturn = STR_Match_NoCase((char *)pA, (char *)pB);

      }

  //}

  //[반환]
  //{
      //[값] 쓰기.
      if(vmos->VMOS_WrRd(d_Wr, ADR, (1), (DTU1 *)(&rReturn)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

  //}

}

void __fastcall _API_Str_Assign(void)
{
  //[2011.10.12.수][생성!!!]{----
  //[2011.11.29.화][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //{----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.29.화][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pBuf;
          DTU8  pStr;

          DTS4  rReturn;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{-----------------------
  //int _Str_할당_(char  *r저장소,
  //               char  *p문자열);
  //}-------------------------------
  //STR_Assign()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *r저장소]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pBuf)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pBuf, &pBuf);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[명령처리]
  //{
      rReturn = STR_Assign((char *)pBuf, (char *)pStr);

  //}

  //[반환]
  //{
      //[값] 쓰기.
      if(vmos->VMOS_WrRd(d_Wr, ADR, (4), (DTU1 *)(&rReturn)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

  //}

}

void __fastcall _API_Str_Assign2(void)
{
  //[2011.10.12.수][생성!!!]{----
  //[2011.11.29.화][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //{----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.29.화][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pBuf;
          DTS4  pBufSize;
          DTU8  pStr;

          DTS4  rReturn;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{----------------------------------
  //int _Str_길이지정할당_(char  *r저장소,
  //                       int    p저장소크기,
  //                       char  *p문자열);
  //}------------------------------------------
  //STR_Assign2()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *r저장소]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pBuf)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pBuf, &pBuf);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  p저장소크기]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pBufSize)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[명령처리]
  //{
      rReturn = STR_Assign2((char *)pBuf, pBufSize,(char *)pStr);

  //}

  //[반환]
  //{
      //[값] 쓰기.
      if(vmos->VMOS_WrRd(d_Wr, ADR, (4), (DTU1 *)(&rReturn)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

  //}

}

void __fastcall _API_Str_Add(void)
{
  //[2011.10.12.수][생성!!!]{----
  //[2011.11.29.화][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //{----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.29.화][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  prStr;
          DTU8  pAddStr;

          DTS4  rReturn;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{-----------------------------
  //int _Str_더하기_(char  *pr대상,
  //                 char  *p더할문자열);
  //}-------------------------------------
  //STR_Add()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *pr대상]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&prStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(prStr, &prStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[char  *p더할문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pAddStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pAddStr, &pAddStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[명령처리]
  //{
      rReturn = STR_Add((char *)prStr, (char *)pAddStr);

  //}

  //[반환]
  //{
      //[값] 쓰기.
      if(vmos->VMOS_WrRd(d_Wr, ADR, (4), (DTU1 *)(&rReturn)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

  //}

}

void __fastcall _API_Str_Add_AB(void)
{
  //[2011.10.12.수][생성!!!]{----
  //[2011.11.29.화][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //{----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.29.화][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  rBuf;
          DTU8  pA;
          DTU8  pB;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{-------------------------
  //void _Str_합치기_(char  *r저장소,
  //                  char  *pA,
  //                  char  *pB);
  //}---------------------------------
  //STR_Add_AB()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *r저장소]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rBuf)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rBuf, &rBuf);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[char  *pA]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pA)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pA, &pA);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[char  *pB]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pB)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pB, &pB);

  //}

  //[명령처리]
  //{
      STR_Add_AB((char *)rBuf, (char *)pA, (char *)pB);

  //}

}

void __fastcall _API_Str_Pos(void)
{
  //[2011.10.12.수][생성!!!]{----
  //[2011.11.29.화][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //{----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.29.화][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;
          DTS4  pStartIndex;
          DTS1  pChar;

          DTS4  rReturn;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{--------------------------------
  //int _Str_문자찾기_(char  *p문자열,
  //                   int    p검사시작위치,
  //                   char   p찾을문자);
  //}----------------------------------------
  //STR_Pos()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  p검사시작위치]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pStartIndex)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[char  p찾을문자]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (1), (DTU1 *)(&pChar)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (1);
      //}--------------------------

  //}

  //[명령처리]
  //{
      rReturn = STR_Pos((char *)pStr, pStartIndex, pChar);

  //}

  //[반환]
  //{
      //[값] 쓰기.
      if(vmos->VMOS_WrRd(d_Wr, ADR, (4), (DTU1 *)(&rReturn)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

  //}

}

void __fastcall _API_Str_SubString(void)
{
  //[2011.10.12.수][생성!!!]{----
  //[2011.11.29.화][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //{----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.29.화][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;
          DTS4  pStartIndex;
          DTS4  pLength;
          DTU8  rSubStr;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{------------------------------
  //void _Str_추출_(char  *p문자열,
  //                int    p시작위치,
  //                int    p길이,
  //                char  *r추출된문자열);
  //}--------------------------------------
  //STR_SubString()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  p시작위치]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pStartIndex)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[int  p길이]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pLength)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[char  *r추출된문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rSubStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rSubStr, &rSubStr);

  //}

  //[명령처리]
  //{
      STR_SubString((char *)pStr, pStartIndex, pLength, (char *)rSubStr);

  //}

}

void __fastcall _API_Str_GetWord(void)
{
  //[2011.10.12.수][생성!!!]{----
  //[2011.11.29.화][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //{----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.29.화][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;
          DTS1  pToken;
          DTS4  pWordIndex;
          DTU8  rWord;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{--------------------------------
  //void _Str_단어추출_(char  *p문자열,
  //                    char   p구분자,
  //                    int    p단어순번,
  //                    char  *r추출된단어);
  //}----------------------------------------
  //STR_GetWord()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[char  p구분자]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (1), (DTU1 *)(&pToken)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (1);
      //}--------------------------

  //}

  //[int  p단어순번]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pWordIndex)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[char  *r추출된단어]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rWord)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rWord, &rWord);

  //}

  //[명령처리]
  //{
      STR_GetWord((char *)pStr, pToken, pWordIndex, (char *)rWord);

  //}

}

void __fastcall _API_Str_NowIndexMoonja_Is_Hangul(void)
{
  //[2011.10.12.수][생성!!!]{----
  //[2011.11.29.화][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //{----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.29.화][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;
          DTS4  pIndex;

          DTS4  rReturn;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{-------------------------------------
  //int _Str_문자한글영문확인_(char  *p문자열,
  //                           int    p문자위치);
  //}---------------------------------------------
  //STR_NowIndexMoonja_Is_Hangul()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  p문자위치]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pIndex)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[명령처리]
  //{
      rReturn = STR_NowIndexMoonja_Is_Hangul((char *)pStr, pIndex);

  //}

  //[반환]
  //{
      //[값] 쓰기.
      if(vmos->VMOS_WrRd(d_Wr, ADR, (4), (DTU1 *)(&rReturn)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

  //}

}

void __fastcall _API_Str_SetLength(void)
{
  //[2011.10.12.수][생성!!!]{----
  //[2011.11.29.화][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //{----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.29.화][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;
          DTS4  pSetLength;
          DTS1  pFillChar;
          DTU8  rSetStr;

          DTS4  rReturn;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{---------------------------------
  //int _Str_길이조정_(char  *p문자열,
  //                   int    p조정할길이,
  //                   char   p채울문자,
  //                   char  *r조정된문자열);
  //}-----------------------------------------
  //STR_SetLength()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  p조정할길이]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pSetLength)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[char  p채울문자]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (1), (DTU1 *)(&pFillChar)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (1);
      //}--------------------------

  //}

  //[char  *r조정된문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rSetStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rSetStr, &rSetStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[명령처리]
  //{
      rReturn = STR_SetLength((char *)pStr, pSetLength, pFillChar, (char *)rSetStr);

  //}

  //[반환]
  //{
      //[값] 쓰기.
      if(vmos->VMOS_WrRd(d_Wr, ADR, (4), (DTU1 *)(&rReturn)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

  //}

}

void __fastcall _API_Str_WordLastChar(void)
{
  //[2011.10.13.목][생성!!!]{----
  //[2011.11.29.화][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //{----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.29.화][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;

          DTS1  rReturn;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{------------------------------
  //char _Str_끝문자얻기_(char  *p문자열);
  //}--------------------------------------
  //STR_WordLastChar()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[명령처리]
  //{
      rReturn = STR_WordLastChar((char *)pStr);

  //}

  //[반환]
  //{
      //[값] 쓰기.
      if(vmos->VMOS_WrRd(d_Wr, ADR, (1), (DTU1 *)(&rReturn)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

  //}

}

void __fastcall _API_Str_LastCharChange(void)
{
  //[2011.10.13.목][생성!!!]{----
  //[2011.11.29.화][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //{----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.29.화][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;
          DTS1  pChar;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{----------------------------------
  //void _Str_끝문자교체_(char  *pr문자열,
  //                      char   p교체할문자);
  //}------------------------------------------
  //STR_LastCharChange()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *pr문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[char  p교체할문자]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (1), (DTU1 *)(&pChar)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

  //}

  //[명령처리]
  //{
      STR_LastCharChange((char *)pStr, pChar);

  //}

}

void __fastcall _API_Str_Get_LineCount(void)
{
  //[2011.10.13.목][생성!!!]{----
  //[2011.11.29.화][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //{----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.29.화][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;

          DTS4  rReturn;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{---------------------------
  //int _Str_행수얻기_(char  *p문자열);
  //}-----------------------------------
  //STR_Get_LineCount()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[명령처리]
  //{
      rReturn = STR_Get_LineCount((char *)pStr);

  //}

  //[반환]
  //{
      //[값] 쓰기.
      if(vmos->VMOS_WrRd(d_Wr, ADR, (4), (DTU1 *)(&rReturn)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

  //}

}

void __fastcall _API_Str_Get_CRLF_Count_withStartEndIndex(void)
{
  //[2011.10.13.목][생성!!!]{----
  //[2011.11.29.화][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //{----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.29.화][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;
          DTS4  pStartIndex;
          DTS4  pEndIndex;

          DTS4  rReturn;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{--------------------------------
  //int _Str_CRLF개수얻기_(char  *p문자열,
  //                       int    p시작위치,
  //                       int    p끝위치);
  //}----------------------------------------
  //STR_Get_CRLF_Count_withStartEndIndex()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  p시작위치]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pStartIndex)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[int  p끝위치]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pEndIndex)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[명령처리]
  //{
      rReturn = STR_Get_CRLF_Count_withStartEndIndex((char *)pStr, pStartIndex, pEndIndex);

  //}

  //[반환]
  //{
      //[값] 쓰기.
      if(vmos->VMOS_WrRd(d_Wr, ADR, (4), (DTU1 *)(&rReturn)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

  //}

}

void __fastcall _API_Str_Cut_CRLF(void)
{
  //[2011.10.13.목][생성!!!]{----
  //[2011.11.29.화][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //{----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.29.화][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  prStr;
          DTS4  pSetLength;
          DTU1  pSelf; //bool.
          DTU8  rRsltStr;

          DTS4  rReturn;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{-------------------------------------------------------------
  //int _Str_첫번째행만_남기기_(char           *pr문자열,
  //                            int             p문자열길이강제조정,
  //                            unsigned char   p원본직접수정여부, //bool
  //                            char           *r처리된문자열);
  //}---------------------------------------------------------------------
  //STR_Cut_CRLF()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *pr문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&prStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(prStr, &prStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  p문자열길이강제조정]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pSetLength)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[unsigned char  p원본직접수정여부]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (1), (DTU1 *)(&pSelf)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (1);
      //}--------------------------


  //}

  //[char  *r처리된문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rRsltStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rRsltStr, &rRsltStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[명령처리]
  //{
      rReturn = STR_Cut_CRLF((char *)prStr, (char *)rRsltStr, pSetLength, pSelf);

  //}

  //[반환]
  //{
      //[값] 쓰기.
      if(vmos->VMOS_WrRd(d_Wr, ADR, (4), (DTU1 *)(&rReturn)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

  //}

}

void __fastcall _API_Str_Get_LineNumber_withIndex(void)
{
  //[2011.10.13.목][생성!!!]{----
  //[2011.11.29.화][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //{----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.29.화][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;
          DTS4  pIndex;

          DTS4  rReturn;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{----------------------------
  //int _Str_행번호얻기_(char  *p문자열,
  //                     int    p위치);
  //}------------------------------------
  //STR_Get_LineNumber_withIndex()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  p위치]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pIndex)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[명령처리]
  //{
      rReturn = STR_Get_LineNumber_withIndex((char *)pStr, pIndex);

  //}

  //[반환]
  //{
      //[값] 쓰기.
      if(vmos->VMOS_WrRd(d_Wr, ADR, (4), (DTU1 *)(&rReturn)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

  //}

}

void __fastcall _API_Str_Get_LineStartIndex(void)
{
  //[2011.10.13.목][생성!!!]{----
  //[2011.11.29.화][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //{----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.29.화][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;
          DTS4  pLineNum;
          DTU8  rLineStartIndex;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{---------------------------------------------
  //void _Str_행번호로_시작위치얻기_(char  *p문자열,
  //                                 int    p행번호,
  //                                 int   *r행시작위치);
  //}-----------------------------------------------------
  //STR_Get_LineStartIndex()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  p행번호]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pLineNum)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[int  *r행시작위치]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rLineStartIndex)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rLineStartIndex, &rLineStartIndex);

  //}

  //[명령처리]
  //{
      STR_Get_LineStartIndex((char *)pStr, pLineNum, (int *)rLineStartIndex);

  //}

}

void __fastcall _API_Str_Get_BeforeLineStartIndex(void)
{
  //[2011.10.13.목][생성!!!]{----
  //[2011.11.29.화][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //}----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.29.화][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;
          DTS4  pIndex;
          DTU8  rLineStartIndex;

      //}    

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{-------------------------------------------
  //void _Str_이전행_시작위치얻기_(char  *p문자열,
  //                               int    p위치,
  //                               int   *r행시작위치);
  //}---------------------------------------------------
  //STR_Get_BeforeLineStartIndex()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);
      
      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  p위치]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pIndex)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[int  *r행시작위치]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rLineStartIndex)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rLineStartIndex, &rLineStartIndex);

  //}

  //[명령처리]
  //{
      STR_Get_BeforeLineStartIndex((char *)pStr, pIndex, (int *)rLineStartIndex);

  //}

}

void __fastcall _API_Str_Get_NextLineStartIndex(void)
{
  //[2011.10.13.목][생성!!!]{----
  //[2011.11.29.화][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //}----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.29.화][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;
          DTS4  pIndex;
          DTU8  rLineStartIndex;

          DTU1  rReturn;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{----------------------------------------------------
  //bool
  //unsigned char _Str_다음행_시작위치얻기_(char  *p문자열,
  //                                        int    p위치,
  //                                        int   *r행시작위치);
  //}------------------------------------------------------------
  //STR_Get_NextLineStartIndex()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  p위치]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pIndex)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[int  *r행시작위치]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rLineStartIndex)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rLineStartIndex, &rLineStartIndex);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[명령처리]
  //{
      rReturn = STR_Get_NextLineStartIndex((char *)pStr, pIndex, (int *)rLineStartIndex);

  //}

  //[반환]
  //{
      //[값] 쓰기.
      if(vmos->VMOS_WrRd(d_Wr, ADR, (1), (DTU1 *)(&rReturn)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

  //}

}

void __fastcall _API_Str_Get_ThisLineStartIndex(void)
{
  //[2011.10.13.목][생성!!!]{----
  //[2011.11.29.화][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //}----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.29.화][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;
          DTS4  pIndex;
          DTU8  rLineStartIndex;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{--------------------------------------
  //void _Str_행시작위치얻기_(char  *p문자열,
  //                          int    p위치,
  //                          int   *r행시작위치);
  //}----------------------------------------------
  //STR_Get_ThisLineStartIndex()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  p위치]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pIndex)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[int  *r행시작위치]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rLineStartIndex)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rLineStartIndex, &rLineStartIndex);

  //}

  //[명령처리]
  //{
      STR_Get_ThisLineStartIndex((char *)pStr, pIndex, (int *)rLineStartIndex);

  //}

}

void __fastcall _API_Str_Get_ThisLineEndIndex(void)
{
  //[2011.10.13.목][생성!!!]{----
  //[2011.11.29.화][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //}----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.29.화][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;
          DTS4  pIndex;
          DTU8  rLineEndIndex;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{----------------------------------
  //void _Str_행끝위치얻기_(char  *p문자열,
  //                        int    p위치,
  //                        int   *r행끝위치);
  //}------------------------------------------
  //STR_Get_ThisLineEndIndex()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  p위치]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pIndex)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[int  *r행끝위치]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rLineEndIndex)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rLineEndIndex, &rLineEndIndex);

  //}

  //[명령처리]
  //{
      STR_Get_ThisLineEndIndex((char *)pStr, pIndex, (int *)rLineEndIndex);

  //}

}

void __fastcall _API_Str_Get_LineStr_withLineNumber(void)
{
  //[2011.10.13.목][생성!!!]{----
  //[2011.11.29.화][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //}----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.29.화][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;
          DTS4  pLineNum;
          DTU8  rLineStr;

          DTS4  rReturn;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{----------------------------------------
  //int _Str_행번호로_문자열얻기_(char  *p문자열,
  //                              int    p행번호,
  //                              char  *r행문자열);
  //}------------------------------------------------
  //STR_Get_LineStr_withLineNumber()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  p행번호]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pLineNum)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[char  *r행문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rLineStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rLineStr, &rLineStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[명령처리]
  //{
      rReturn = STR_Get_LineStr_withLineNumber((char *)pStr, pLineNum, (char *)rLineStr);

  //}

  //[반환]
  //{
      //[값] 쓰기.
      if(vmos->VMOS_WrRd(d_Wr, ADR, (4), (DTU1 *)(&rReturn)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

  //}

}

void __fastcall _API_Str_Get_LineToLineStr(void)
{
  //[2011.10.13.목][생성!!!]{----
  //[2011.11.30.수][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //}----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.30.수][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;
          DTS4  pStartLineNum;
          DTS4  pEndLineNum;
          DTU8  rRsltStr;

          DTS4  rReturn;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{-----------------------------------------
  //int _Str_범위행문자열얻기_(char  *p문자열,
  //                           int    p시작행번호,
  //                           int    p끝행번호,
  //                           char  *r여러행문자열);
  //}-------------------------------------------------
  //STR_Get_LineToLineStr()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  p시작행번호]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pStartLineNum)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[int  p끝행번호]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pEndLineNum)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[char  *r여러행문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rRsltStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rRsltStr, &rRsltStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[명령처리]
  //{
      rReturn = STR_Get_LineToLineStr((char *)pStr, pStartLineNum, pEndLineNum, (char *)rRsltStr);

  //}

  //[반환]
  //{
      //[값] 쓰기.
      if(vmos->VMOS_WrRd(d_Wr, ADR, (4), (DTU1 *)(&rReturn)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

  //}

}

void __fastcall _API_Str_Get_LineWord_withSpace(void)
{
  //[2011.10.13.목][생성!!!]{----
  //[2011.11.30.수][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //}----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.30.수][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;
          DTS4  pWordIndex;
          DTU8  rWord;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{------------------------------------
  //void _LineStr_단어추출_(char  *p행문자열,
  //                        int    p단어순번,
  //                        char  *r추출된단어);
  //}--------------------------------------------
  //STR_Get_LineWord_withSpace()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p행문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  p단어순번]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pWordIndex)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[char  *r추출된단어]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rWord)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rWord, &rWord);

  //}

  //[명령처리]
  //{
      STR_Get_LineWord_withSpace((char *)pStr, pWordIndex, (char *)rWord);

  //}

}

void __fastcall _API_Str_Search_MatchWord_inLineStr(void)
{
  //[2011.10.13.목][생성!!!]{----
  //[2011.11.30.수][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //[2012.08.11.토][수정!!!]-----
  //}----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.30.수][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pLineStr;
          DTU8  pWord;
          DTU1  pCase; //bool.

          //[2012.08.11.토][추가!!!]
          DTU8  rWordStartIndex;

          DTS4  rReturn;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{--------------------------------------------------------
  //int _LineStr_단어순번얻기_(char           *p행문자열,
  //                           char           *p찾을단어,
  //                           unsigned char   p대소문자구분, //bool
  //                           //[2012.08.11.토][추가!!!]
  //                           int            *r단어시작위치);
  //}----------------------------------------------------------------
  //STR_Search_MatchWord_inLineStr()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p행문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pLineStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pLineStr, &pLineStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[char  *p찾을단어]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pWord)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pWord, &pWord);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[unsigned char  p대소문자구분]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (1), (DTU1 *)(&pCase)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (1);
      //}--------------------------

  //}

  //[int  *r단어시작위치]
  //{
      //[2012.08.11.토][추가!!!]

      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rWordStartIndex)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rWordStartIndex, &rWordStartIndex);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[명령처리]
  //{
      //[2012.08.11.토][수정!!!]
      //새로만든 제2함수를 사용.
      rReturn = STR_Search_MatchWord_inLineStr2((char *)pLineStr, (char *)pWord,
                                               //<bool> 로 반대로 적용해야 한다.
                                               !pCase,
                                               //[2012.08.11.토][추가!!!]
                                               (int *)rWordStartIndex);

  //}

  //[반환]
  //{
      //[값] 쓰기.
      if(vmos->VMOS_WrRd(d_Wr, ADR, (4), (DTU1 *)(&rReturn)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

  //}

}

void __fastcall _API_Str_Search_LineStr_knowLineCount(void)
{
  //[2011.10.13.목][생성!!!]{----
  //[2011.11.30.수][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //}----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.30.수][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;
          DTS4  pLineCount;
          DTU8  pLineStr;

          DTS4  rReturn;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{------------------------------------------------
  //int _Str_행문자열일치_행번호얻기_(char  *p문자열,
  //                                  int    p문자열총행수,
  //                                  char  *p찾을행문자열);
  //}--------------------------------------------------------
  //STR_Search_LineStr_knowLineCount()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  p문자열총행수]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pLineCount)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[char  *p찾을행문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pLineStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pLineStr, &pLineStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[명령처리]
  //{
      STR_Search_LineStr_knowLineCount((char *)pStr, pLineCount, (char *)pLineStr, &rReturn);

  //}

  //[반환]
  //{
      //[값] 쓰기.
      if(vmos->VMOS_WrRd(d_Wr, ADR, (4), (DTU1 *)(&rReturn)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

  //}

}

void __fastcall _API_Str_Search_LineStr_knowLineCount2(void)
{
  //[2022.04.17.일][생성]{-------------------------------------------------------
  //<_API_Str_Search_LineStr_knowLineCount()> 에 [대소문자구분] 조건을 추가한것.
  //}----------------------------------------------------------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;
          DTS4  pLineCount;
          DTU8  pLineStr;
          DTU1  pCaseUse;

          DTS4  rReturn;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{-----------------------------------------------------------------
  //int _Str_행문자열일치_행번호얻기2_(char           *p행단위문자열,
  //                                   int             p문자열총행수,
  //                                   char           *p찾을행문자열,
  //                                   unsigned char   p대소문자구분); //bool
  //}-------------------------------------------------------------------------
  //STR_Search_LineStr_knowLineCount2()

  //[기본주소 얻기]
  //{
      //[!]{--------------------------------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  p문자열총행수]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pLineCount)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[char  *p찾을행문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pLineStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pLineStr, &pLineStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[unsigned char  p대소문자구분]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (1), (DTU1 *)(&pCaseUse)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (1);
      //}--------------------------

  //}

  //[명령처리]
  //{
      //함수 자체는 인수가 <pNoCase:true> 로 돼 있으므로 반대로 적용----------------v
      STR_Search_LineStr_knowLineCount2((char *)pStr, pLineCount, (char *)pLineStr, !pCaseUse, &rReturn);

  //}

  //[반환]
  //{
      //[값] 쓰기.
      if(vmos->VMOS_WrRd(d_Wr, ADR, (4), (DTU1 *)(&rReturn)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

  //}

}

void __fastcall _API_Str_Search_Word(void)
{
  //[2011.10.13.목][생성!!!]{----
  //[2011.11.30.수][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //}----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.30.수][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;
          DTS4  pLineCount;
          DTS4  pStartLineNum;
          DTS4  pWordIndex;
          DTU1  pCase; //bool.
          DTU8  pWord;

          DTS4  rReturn;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{-----------------------------------------------------------
  //int _Str_단어일치_행번호얻기_(char           *p문자열,
  //                              int             p문자열총행수,
  //                              int             p검사시작행번호,
  //                              int             p찾을단어순번,
  //                              unsigned char   p대소문자구분, //bool
  //                              char           *p찾을단어);
  //}-------------------------------------------------------------------
  //STR_Search_Word()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  p문자열총행수]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pLineCount)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[int  p검사시작행번호]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pStartLineNum)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[int  p찾을단어순번]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pWordIndex)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[unsigned char  p대소문자구분]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (1), (DTU1 *)(&pCase)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (1);
      //}--------------------------

  //}

  //[char  *p찾을단어]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pWord)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pWord, &pWord);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[명령처리]
  //{
      STR_Search_Word((char *)pStr, pLineCount, pStartLineNum, pWordIndex, pCase, (char *)pWord, &rReturn);

  //}

  //[반환]
  //{
      //[값] 쓰기.
      if(vmos->VMOS_WrRd(d_Wr, ADR, (4), (DTU1 *)(&rReturn)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

  //}

}

void __fastcall _API_Str_GetLineWordBuf(void)
{
  //[2011.10.13.목][생성!!!]{----
  //[2011.11.30.수][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //}----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.30.수][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;
          DTS4  pLineStartIndex;
          DTS4  pWordOrder;
          DTU8  rWordIndex;
          DTU8  rWord;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{-------------------------------------
  //void _Str_행단어추출_(char  *p문자열,
  //                      int    p행시작위치,
  //                      int    p단어순번,
  //                      int   *r추출된단어위치,
  //                      char  *r추출된단어);
  //}---------------------------------------------
  //STR_GetLineWordBuf()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  p행시작위치]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pLineStartIndex)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[int  p단어순번]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pWordOrder)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[int  *r추출된단어위치]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rWordIndex)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rWordIndex, &rWordIndex);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[char  *r추출된단어]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rWord)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rWord, &rWord);
      
  //}

  //[명령처리]
  //{
      STR_GetLineWordBuf((char *)pStr, pLineStartIndex, pWordOrder, (int *)rWordIndex, (char *)rWord);

  //}

}

void __fastcall _API_Str_Get_ThisLineStr(void)
{
  //[2011.10.14.금][생성!!!]{----
  //[2011.11.30.수][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //}----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.30.수][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;
          DTS4  pIndex;
          DTU8  rLineStr;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{----------------------------------------
  //void _Str_행문자열추출_(char  *p문자열,
  //                        int    p위치,
  //                        char  *r추출된행문자열);
  //}------------------------------------------------
  //STR_Get_ThisLineStr()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  p위치]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pIndex)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[char  *r추출된행문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rLineStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rLineStr, &rLineStr);

  //}

  //[명령처리]
  //{
      STR_Get_ThisLineStr((char *)pStr, pIndex, (char *)rLineStr);

  //}

}

void __fastcall _API_Str_Get_ThisLinePreSpaceCount(void)
{
  //[2011.10.14.금][생성!!!]{----
  //[2011.11.30.수][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //}----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.30.수][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;
          DTS4  pIndex;

          DTS4  rReturn;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{--------------------------------
  //int _Str_행앞공백수얻기_(char  *p문자열,
  //                         int    p위치);
  //}----------------------------------------
  //STR_Get_ThisLinePreSpaceCount()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  p위치]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pIndex)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[명령처리]
  //{
      rReturn = STR_Get_ThisLinePreSpaceCount((char *)pStr, pIndex);

  //}

  //[반환]
  //{
      //[값] 쓰기.
      if(vmos->VMOS_WrRd(d_Wr, ADR, (4), (DTU1 *)(&rReturn)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

  //}

}

void __fastcall _API_Str_Get_ThisLinePostSpaceCount(void)
{
  //[2021.08.04.수][생성]

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;
          DTS4  pIndex;

          DTS4  rReturn;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{--------------------------------
  //int _Str_행뒷공백수얻기_(char  *p문자열,
  //                         int    p위치);
  //}----------------------------------------
  //Str_Get_ThisLinePostSpaceCount()

  //[기본주소 얻기]
  //{
      //[!]{--------------------------------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  p위치]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pIndex)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[명령처리]
  //{
      rReturn = Str_Get_ThisLinePostSpaceCount((char *)pStr, pIndex);

  //}

  //[반환]
  //{
      //[값] 쓰기.
      if(vmos->VMOS_WrRd(d_Wr, ADR, (4), (DTU1 *)(&rReturn)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

  //}

}

void __fastcall _API_Str_Get_WordBound(void)
{
  //[2011.10.14.금][생성!!!]{----
  //[2011.11.30.수][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //}----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.30.수][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;
          DTS4  pLength;
          DTS4  pIndex;
          DTU8  rWordStartIndex;
          DTU8  rWordEndIndex;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{-------------------------------------------
  //void _Str_단어시작끝위치얻기_(char  *p문자열,
  //                              int    p문자열길이,
  //                              int    p위치,
  //                              int   *r단어시작위치,
  //                              int   *r단어끝위치);
  //}---------------------------------------------------
  //STR_Get_WordBound()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  p문자열길이]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pLength)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[int  p위치]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pIndex)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[int  *r단어시작위치]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rWordStartIndex)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rWordStartIndex, &rWordStartIndex);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  *r단어끝위치]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rWordEndIndex)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rWordEndIndex, &rWordEndIndex);

  //}

  //[명령처리]
  //{
      STR_Get_WordBound((char *)pStr, pLength, pIndex, (int *)rWordStartIndex, (int *)rWordEndIndex);

  //}

}

void __fastcall _API_Str_XLine_To_1Line_Trim(void)
{
  //[2011.10.14.금][생성!!!]{----
  //[2011.11.30.수][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //}----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.30.수][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pXLineStr;
          DTS4  pInsertSpaceCount;
          DTU8  r1LineStr;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{----------------------------------------
  //void _Str_한줄합성_(char  *p여러행문자열,
  //                    int    p합성시행간공백수,
  //                    char  *r한줄로합성된문자열);
  //}------------------------------------------------
  //Str_XLine_To_1Line_Trim()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p여러행문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pXLineStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pXLineStr, &pXLineStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  p합성시행간공백수]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pInsertSpaceCount)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[char  *r한줄로합성된문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&r1LineStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(r1LineStr, &r1LineStr);

  //}

  //[명령처리]
  //{
      Str_XLine_To_1Line_Trim((char *)pXLineStr, (char *)r1LineStr, pInsertSpaceCount);

  //}

}

void __fastcall _API_Str_Width_Ellipsis(void)
{
  //[2011.10.14.금][생성!!!]{----
  //[2011.11.30.수][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //}----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.30.수][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;
          DTS4  pWidth;
          DTU8  rRsltStr;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{------------------------------------------
  //void _Str_출력폭줄임표적용_(char  *p문자열,
  //                            int    p출력폭,
  //                            char  *r적용된문자열);
  //}--------------------------------------------------
  //Str_Width_Ellipsis()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  p출력폭]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pWidth)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[char  *r적용된문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rRsltStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rRsltStr, &rRsltStr);

  //}

  //[명령처리]
  //{
      Str_Width_Ellipsis((char *)pStr,
                         &(ide_caption_Form->_font), d_FONTSTYLE_default, pWidth,
                         (char *)rRsltStr);

  //}

}

void __fastcall _API_Str_Find(void)
{
  //[2011.10.14.금][생성!!!]{----
  //[2011.11.30.수][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //}----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.30.수][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;
          DTS4  pLength;
          DTS4  pOptStartIndex;
          DTU1  pOptWord;
          DTU1  pOptCase;
          DTU8  pFindStr;

          DTS4  rReturn;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{--------------------------------------------
  //int _Str_찾기_(char           *p문자열,
  //               int             p문자열길이,
  //               int             p찾을시작위치,
  //               unsigned char   p단어구분, //bool
  //               unsigned char   p대소문자구문, //bool
  //               char           *p찾을문자열);
  //}----------------------------------------------------
  //STR_Find()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  p문자열길이]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pLength)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[int  p찾을시작위치]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pOptStartIndex)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[unsigned char  p단어구분]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (1), (DTU1 *)(&pOptWord)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (1);
      //}--------------------------

  //}

  //[unsigned char  p대소문자구문]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (1), (DTU1 *)(&pOptCase)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (1);
      //}--------------------------

  //}

  //[char  *p찾을문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pFindStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pFindStr, &pFindStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[명령처리]
  //{
      STR_Find((char *)pStr, pLength, pOptStartIndex, pOptWord, pOptCase, (char *)pFindStr,
               &rReturn);

  //}

  //[반환]
  //{
      //[값] 쓰기.
      if(vmos->VMOS_WrRd(d_Wr, ADR, (4), (DTU1 *)(&rReturn)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

  //}

}

void __fastcall _API_Str_GetFileExt(void)
{
  //[2011.10.14.금][생성!!!]{----
  //[2011.11.30.수][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //}----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.30.수][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pPathNameExt;
          DTU8  rExt;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{-----------------------------------------
  //void _FileStr_확장자얻기_(char  *p경로이름확장자,
  //                          char  *r확장자);
  //}-------------------------------------------------
  //STR_GetFileExt()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p경로이름확장자]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pPathNameExt)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pPathNameExt, &pPathNameExt);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[char  *r확장자]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rExt)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rExt, &rExt);

  //}

  //[명령처리]
  //{
      STR_GetFileExt((char *)pPathNameExt, (char *)rExt);

  //}

}

void __fastcall _API_Str_GetFilePathOnly(void)
{
  //[2011.10.14.금][생성!!!]{----
  //[2011.11.30.수][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //}----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.30.수][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pPathNameExt;
          DTU8  rPath;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{-----------------------------------------
  //void _FileStr_경로만얻기_(char  *p경로이름확장자,
  //                          char  *r경로);
  //}-------------------------------------------------
  //STR_GetFilePathOnly()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p경로이름확장자]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pPathNameExt)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pPathNameExt, &pPathNameExt);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[char  *r경로]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rPath)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rPath, &rPath);

  //}

  //[명령처리]
  //{
      STR_GetFilePathOnly((char *)pPathNameExt, (char *)rPath);

  //}

}

void __fastcall _API_Str_Get_FileFullName_LastFolderName(void)
{
  //[2011.10.14.금][생성!!!]{----
  //[2011.11.30.수][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //}----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.30.수][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pPathNameExt;
          DTU8  rLastFolderName;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{-----------------------------------------------
  //void _FileStr_최종폴더이름얻기_(char  *p경로이름확장자,
  //                                char  *r최종폴더이름);
  //}-------------------------------------------------------
  //STR_Get_FileFullName_LastFolderName()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p경로이름확장자]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pPathNameExt)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pPathNameExt, &pPathNameExt);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[char  *r최종폴더이름]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rLastFolderName)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rLastFolderName, &rLastFolderName);

  //}

  //[명령처리]
  //{
      STR_Get_FileFullName_LastFolderName((char *)pPathNameExt, (char *)rLastFolderName);

  //}

}

void __fastcall _API_Str_GetFileNameOnly(void)
{
  //[2011.10.14.금][생성!!!]{----
  //[2011.11.30.수][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //}----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.30.수][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pPathNameExt;
          DTU8  rNameExt;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{-----------------------------------------------
  //void _FileStr_이름확장자만얻기_(char  *p경로이름확장자,
  //                                char  *r이름확장자);
  //}-------------------------------------------------------
  //STR_GetFileNameOnly()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p경로이름확장자]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pPathNameExt)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pPathNameExt, &pPathNameExt);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[char  *r이름확장자]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rNameExt)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rNameExt, &rNameExt);

  //}

  //[명령처리]
  //{
      STR_GetFileNameOnly((char *)pPathNameExt, (char *)rNameExt);

  //}

}

void __fastcall _API_Str_GetFileNameOnly_ExceptExt(void)
{
  //[2011.10.14.금][생성!!!]{----
  //[2011.11.30.수][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //}----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.30.수][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pPathNameExt;
          DTU8  rName;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{-----------------------------------------
  //void _FileStr_이름만얻기_(char  *p경로이름확장자,
  //                          char  *r이름);
  //}-------------------------------------------------
  //STR_GetFileNameOnly_ExceptExt()

  //[기본주소 얻기]
  //{
      //[2011.11.30.수][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p경로이름확장자]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pPathNameExt)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pPathNameExt, &pPathNameExt);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[char  *r이름]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rName)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rName, &rName);

  //}

  //[명령처리]
  //{
      STR_GetFileNameOnly_ExceptExt((char *)pPathNameExt, (char *)rName);

  //}

}

void __fastcall _API_Str_GetFileName_Except_BaseDirectory(void)
{
  //[2011.10.14.금][생성!!!]{----
  //[2011.11.30.수][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //}----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.30.수][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pPathNameExt;
          DTU8  pExceptPath;
          DTU8  rRsltStr;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{-------------------------------------------
  //void _FileStr_지정경로제외_(char  *p경로이름확장자,
  //                            char  *p제외할경로,
  //                            char  *r처리된문자열);
  //}---------------------------------------------------
  //STR_GetFileName_Except_BaseDirectory()

  //[기본주소 얻기]
  //{
      //[2011.11.30.수][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p경로이름확장자]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pPathNameExt)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pPathNameExt, &pPathNameExt);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[char  *p제외할경로]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pExceptPath)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pExceptPath, &pExceptPath);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[char  *r처리된문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rRsltStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rRsltStr, &rRsltStr);

  //}

  //[명령처리]
  //{
      STR_GetFileName_Except_BaseDirectory((char *)pExceptPath,
                                           (char *)pPathNameExt,
                                           (char *)rRsltStr);
  //}

}

void __fastcall _API_Str_BaseDirectory_Match(void)
{
  //[2011.10.14.금][생성!!!]{----
  //[2011.11.30.수][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //}----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.30.수][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pPathNameExt;
          DTU8  pIncludePath;

          DTU1  rReturn; //bool.

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{--------------------------------------------------------
  //bool
  //unsigned char _FileStr_지정경로포함확인_(char  *p경로이름확장자,
  //                                         char  *p포함할경로);
  //}----------------------------------------------------------------
  //STR_BaseDirectory_Match()

  //[기본주소 얻기]
  //{
      //[2011.11.30.수][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p경로이름확장자]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pPathNameExt)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pPathNameExt, &pPathNameExt);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[char  *p포함할경로]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pIncludePath)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pIncludePath, &pIncludePath);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[명령처리]
  //{
      rReturn = STR_BaseDirectory_Match((char *)pIncludePath, (char *)pPathNameExt);

  //}

  //[반환]
  //{
      //[값] 쓰기.
      if(vmos->VMOS_WrRd(d_Wr, ADR, (1), (DTU1 *)(&rReturn)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

  //}

}

void __fastcall _API_Str_ChangeFileExt(void)
{
  //[2011.10.14.금][생성!!!]{----
  //[2011.11.30.수][중요수정!!!]
  //새로운 방식으로 API 를 처리.
  //}----------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.30.수][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pPathNameExt;
          DTU8  pNewExt;
          DTU8  rRsltStr;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{-------------------------------------------------
  //void _FileStr_확장자교체_(char  *p경로이름확장자,
  //                          char  *p교체할확장자,
  //                          char  *r처리된_경로이름확장자);
  //}---------------------------------------------------------
  //STR_ChangeFileExt()

  //[기본주소 얻기]
  //{
      //[2011.11.30.수][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p경로이름확장자]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pPathNameExt)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pPathNameExt, &pPathNameExt);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[char  *p교체할확장자]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pNewExt)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pNewExt, &pNewExt);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[char  *r처리된_경로이름확장자]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rRsltStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rRsltStr, &rRsltStr);

  //}

  //[명령처리]
  //{
      STR_ChangeFileExt((char *)pPathNameExt,
                        (char *)pNewExt,
                        (char *)rRsltStr);
                        
  //}

}

void __fastcall _API_Str_DefaultFont_Get_StringOutAreaInfo(void)
{
  //[2018.07.02.월][생성!!!]{----------------------
  //[IDE:기본글꼴] 을 사용하여 출력 정보를 얻는다.
  //}----------------------------------------------

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          //[주소] 는 전부 DTU8 로 처리. 
          DTU8  pStr;

          DTU1  pStyle;

          DTU8  rWidth;
          DTU8  rHeight;

      //}

      //[글꼴]
      //{
          //출력할 글꼴.
          struct FONTPACK  _font;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{--------------------------------------------------
  //void _Str_기본글꼴출력정보얻기_(char           *p문자열,
  //                                unsigned char   p문자형식,
  //                                unsigned int   *r폭,
  //                                unsigned int   *r높이);
  //}----------------------------------------------------------
  //FONT_Get_StringOutAreaInfo()

  //[기본주소 얻기]
  //{
      //[!]{--------------------------------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[unsigned char  p문자형식]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (1), (DTU1 *)(&pStyle)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (1);
      //}--------------------------

  //}

  //[unsigned int  *r폭]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rWidth)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rWidth, &rWidth);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[unsigned int  *r높이]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rHeight)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rHeight, &rHeight);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[명령처리]
  //{
      //출력할 글꼴 설정.
      FONTPACK_SetDefault(&_font);

      FONT_Get_StringOutAreaInfo(&_font, pStyle, (char *)pStr, (int *)rWidth, (int *)rHeight);

  //}

}

void __fastcall _API_Str_Get_Real_FileList(void)
{
  //[2020.10.11.일][생성]

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //[2011.11.30.수][수정!!!]
          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pList;  //char  *p폴더파일목록
          DTU8  rList;  //char  *r최종폴더파일목록

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{------------------------------------------------------
  //void _FileStr_최종폴더파일목록_얻기_(char  *p폴더파일목록,
  //                                     char  *r최종폴더파일목록);
  //}--------------------------------------------------------------
  //STR_Get_FileFullName_LastFolderName()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p폴더파일목록]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pList)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pList, &pList);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[char  *r최종폴더파일목록]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rList)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rList, &rList);

  //}

  //[명령처리]
  //{
      Str_Get_Real_FileList((char *)pList, (char *)rList);

  //}

}

void __fastcall _API_Str_FileName_Width_Ellipsis(void)
{
  //[2020.11.27.금][생성]

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pPathNameExt;
          DTS4  pWidth;
          DTU8  rPathNameExt;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{---------------------------------------------------------------
  //void _FileStr_이름확장자보존_줄임표적용_(char  *p경로이름확장자,
  //                                         int    p출력폭,
  //                                         char  *r적용된경로이름확장자);
  //}-----------------------------------------------------------------------
  //Str_FileName_Width_Ellipsis()

  //[기본주소 얻기]
  //{
      //[2011.11.29.화][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p경로이름확장자]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pPathNameExt)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pPathNameExt, &pPathNameExt);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int  p출력폭]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pWidth)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[char  *r적용된경로이름확장자]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rPathNameExt)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rPathNameExt, &rPathNameExt);

  //}

  //[명령처리]
  //{
      Str_FileName_Width_Ellipsis((char *)pPathNameExt,
                                  &(ide_caption_Form->_font), d_FONTSTYLE_default, pWidth,
                                  (char *)rPathNameExt);

  //}

}

void __fastcall _API_Str_SortList(void)
{
  //[2021.06.29.화][생성]

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pList;
          DTU8  rSortedList;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{--------------------------------
  //void _Str_목록정렬_(char  *p목록,
  //                    char  *r정렬된목록);
  //}----------------------------------------

  //[기본주소 얻기]
  //{
      //[2011.11.30.수][추가!!!]{-----------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p목록]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pList)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pList, &pList);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[char  *r정렬된목록]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rSortedList)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rSortedList, &rSortedList);

  //}

  //[명령처리]
  //{
      Str_SortList((char *)pList,
                   (char *)rSortedList);

  //}

}

void __fastcall _API_Str_Trim(void)
{
  //[2022.01.01.토][생성]

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  pStr;
          DTU1  pDelPreSpace;  //bool
          DTU1  pDelPostSpace; //bool
          DTU8  rTrimStr;

          DTS4  rReturn;       //int

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{------------------------------------------------------
  //int _Str_앞뒤공백제거_(char           *p문자열,
  //                       unsigned char   p앞공백제거유무, //bool
  //                       unsigned char   p뒤공백제거유무, //bool
  //                       char           *r적용된문자열);
  //}--------------------------------------------------------------
  //Str_Trim()

  //[기본주소 얻기]
  //{
      //[!]{--------------------------------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  *p문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pStr, &pStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[unsigned char   p앞공백제거유무]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (1), (DTU1 *)(&pDelPreSpace)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (1);
      //}--------------------------

  //}

  //[unsigned char   p뒤공백제거유무]
  //{
      //[값] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (1), (DTU1 *)(&pDelPostSpace)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (1);
      //}--------------------------

  //}

  //[char  *r적용된문자열]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rTrimStr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rTrimStr, &rTrimStr);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[명령처리]
  //{
      rReturn = Str_Trim((char *)pStr, pDelPreSpace, pDelPostSpace, (char *)rTrimStr);

  //}

  //[반환]
  //{
      //[값] 쓰기.
      if(vmos->VMOS_WrRd(d_Wr, ADR, (4), (DTU1 *)(&rReturn)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

  //}

}

void _API_List_Add(void)
{
  //[2022.12.25.일][생성]

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  prList;
          DTU8  pItem;
          DTU8  rBufSize;
          DTU8  rItemTotalLength;
          DTU8  rItemTotalLineCount;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{--------------------------------------------------------------------------------------------------
  //void _List_추가_(//[목록자체주소] 를 전달 받아야 하며, 목록은 반드시 [배열] 이 아닌 [포인터] 만 지정 가능.
  //                 //이는 [목록:저장소] 가 내부적으로 재생성되므로 재생성된 주소를 전달 받기 위한것.
  //                 char  **pr목록_,
  //                 //추가할 항목(다중행인 경우라도 첫행만 추가).
  //                 char   *p항목_,
  //                 //[목록:저장소] 크기(Byte 단위) 반환(NULL 인 경우는 미사용).
  //                 //[목록:저장소] 는 실제 저장되는 문자열 보다 클수 있음.
  //                 int    *r목록저장소크기_,
  //                 //[목록] 안의 전체 [문자열 길이] 반환(NULL 인 경우는 미사용).
  //                 int    *r항목전체길이_,
  //                 //[목록] 안의 문자열 [전체 행수] 반환(NULL 인 경우는 미사용).
  //                 int    *r전체행수_);
  //}----------------------------------------------------------------------------------------------------------

  //[기본주소 얻기]
  //{
      //[!]{--------------------------------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  **pr목록_]
  //{
      //[!]{************************************************************************
      //(**) 는 [맷돌-C] 상에서는 2중 포인터지만 이미 [절대주소] 로 계산된 것이므로
      //여기서는 단지 [절대주소값] 으로 인식하고 처리하면 된다.
      //}***************************************************************************

      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&prList)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(prList, &prList);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[char   *p항목_]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pItem)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pItem, &pItem);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int    *r목록저장소크기_]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rBufSize)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rBufSize, &rBufSize);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int    *r항목전체길이_]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rItemTotalLength)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rItemTotalLength, &rItemTotalLength);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int    *r전체행수_]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rItemTotalLineCount)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rItemTotalLineCount, &rItemTotalLineCount);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[명령처리]
  //{
      STR_AddLineStr((char **)prList,
                     //추가할 문자열(실제는 첫행만 추가).
                     (char *)pItem,
                     //[새저장소] 크기 반환(NULL 인 경우는 미사용).
                     (int  *)rBufSize,
                     //[새저장소] 안의 전체 문자열 길이 반환(NULL 인 경우는 미사용).
                     (int  *)rItemTotalLength,
                     //[새저장소] 안의 문자열 전체 행수 반환(NULL 인 경우는 미사용).
                     (int  *)rItemTotalLineCount);

  //}

}

void _API_List_Delete(void)
{
  //[2022.12.25.일][생성]

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  prList;
          DTS4  pDeleteLineNumber;
          DTU8  rBufSize;
          DTU8  rItemTotalLength;
          DTU8  rItemTotalLineCount;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{--------------------------------------------------------------------------------------------------
  //void _List_삭제_(//[목록자체주소] 를 전달 받아야 하며, 목록은 반드시 [배열] 이 아닌 [포인터] 만 지정 가능.
  //                 //이는 [목록:저장소] 가 내부적으로 재생성되므로 재생성된 주소를 전달 받기 위한것.
  //                 char  **pr목록_,
  //                 //항목을 삭제할 행번호(기본 : 0).
  //                 int     p삭제할행번호,
  //                 //[목록:저장소] 크기(Byte 단위) 반환(NULL 인 경우는 미사용).
  //                 //[목록:저장소] 는 실제 저장되는 문자열 보다 클수 있음.
  //                 int    *r목록저장소크기_,
  //                 //[목록] 안의 전체 [문자열 길이] 반환(NULL 인 경우는 미사용).
  //                 int    *r항목전체길이_,
  //                 //[목록] 안의 문자열 [전체 행수] 반환(NULL 인 경우는 미사용).
  //                 int    *r전체행수_);
  //}----------------------------------------------------------------------------------------------------------

  //[기본주소 얻기]
  //{
      //[!]{--------------------------------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  **pr목록_]
  //{
      //[!]{************************************************************************
      //(**) 는 [맷돌-C] 상에서는 2중 포인터지만 이미 [절대주소] 로 계산된 것이므로
      //여기서는 단지 [절대주소값] 으로 인식하고 처리하면 된다.
      //}***************************************************************************

      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&prList)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(prList, &prList);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int     p삭제할행번호]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pDeleteLineNumber)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[int    *r목록저장소크기_]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rBufSize)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rBufSize, &rBufSize);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int    *r항목전체길이_]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rItemTotalLength)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rItemTotalLength, &rItemTotalLength);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int    *r전체행수_]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rItemTotalLineCount)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rItemTotalLineCount, &rItemTotalLineCount);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[명령처리]
  //{
      STR_DeleteLineStr((char **)prList,
                        //문자열을 삭제할 행번호(기본 : 0).
                        pDeleteLineNumber,
                        //[새저장소] 크기 반환(NULL 인 경우는 미사용).
                        (int  *)rBufSize,
                        //[새저장소] 안의 전체 문자열 길이 반환(NULL 인 경우는 미사용).
                        (int  *)rItemTotalLength,
                        //[새저장소] 안의 문자열 전체 행수 반환(NULL 인 경우는 미사용).
                        (int  *)rItemTotalLineCount);

  //}

}

void _API_List_Replace(void)
{
  //[2022.12.25.일][생성]

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  prList;
          DTS4  pReplaceLineNumber;
          DTU8  pItem;
          DTU8  rBufSize;
          DTU8  rItemTotalLength;
          DTU8  rItemTotalLineCount;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{--------------------------------------------------------------------------------------------------
  //void _List_교체_(//[목록자체주소] 를 전달 받아야 하며, 목록은 반드시 [배열] 이 아닌 [포인터] 만 지정 가능.
  //                 //이는 [목록:저장소] 가 내부적으로 재생성되므로 재생성된 주소를 전달 받기 위한것.
  //                 char  **pr목록_,
  //                 //항목을 교체할 행번호(기본 : 0).
  //                 int     p교체할행번호,
  //                 //교체할 항목(다중행인 경우라도 첫행만 추가).
  //                 char   *p항목_,
  //                 //[목록:저장소] 크기(Byte 단위) 반환(NULL 인 경우는 미사용).
  //                 //[목록:저장소] 는 실제 저장되는 문자열 보다 클수 있음.
  //                 int    *r목록저장소크기_,
  //                 //[목록] 안의 전체 [문자열 길이] 반환(NULL 인 경우는 미사용).
  //                 int    *r항목전체길이_,
  //                 //[목록] 안의 문자열 [전체 행수] 반환(NULL 인 경우는 미사용).
  //                 int    *r전체행수_);
  //}----------------------------------------------------------------------------------------------------------

  //[기본주소 얻기]
  //{
      //[!]{--------------------------------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  **pr목록_]
  //{
      //[!]{************************************************************************
      //(**) 는 [맷돌-C] 상에서는 2중 포인터지만 이미 [절대주소] 로 계산된 것이므로
      //여기서는 단지 [절대주소값] 으로 인식하고 처리하면 된다.
      //}***************************************************************************

      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&prList)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(prList, &prList);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int     p교체할행번호]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pReplaceLineNumber)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[char   *p항목_]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pItem)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pItem, &pItem);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int    *r목록저장소크기_]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rBufSize)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rBufSize, &rBufSize);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int    *r항목전체길이_]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rItemTotalLength)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rItemTotalLength, &rItemTotalLength);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int    *r전체행수_]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rItemTotalLineCount)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rItemTotalLineCount, &rItemTotalLineCount);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[명령처리]
  //{
      STR_ReplaceLineStr((char **)prList,
                         //문자열을 교체할 행번호(기본 : 0).
                         pReplaceLineNumber,
                         //교체할 문자열(실제는 첫행만 추가).
                         (char *)pItem,
                         //[새저장소] 크기 반환(NULL 인 경우는 미사용).
                         (int  *)rBufSize,
                         //[새저장소] 안의 전체 문자열 길이 반환(NULL 인 경우는 미사용).
                         (int  *)rItemTotalLength,
                         //[새저장소] 안의 문자열 전체 행수 반환(NULL 인 경우는 미사용).
                         (int  *)rItemTotalLineCount);

  //}

}

void _API_List_Insert(void)
{
  //[2022.12.25.일][생성]

  //[VAR]
  //{
      //[기본]
      //{
          class  VMOS  *vmos;

          //<@LOCAL> 을 기본으로 한 [절대주소](대문자로 절대주소임을 구분하자).
          DTU8   ADR;

      //}

      //[API]
      //{
          //주소는 전부 MCU 상의 주소다.
          DTU8  prList;
          DTS4  pInsertLineNumber;
          DTU8  pItem;
          DTU8  rBufSize;
          DTU8  rItemTotalLength;
          DTU8  rItemTotalLineCount;

      //}

  //}

  //[VMOS 위치 얻기]{--
  VMOS_GetPtr(&vmos);
  //}------------------

  //[함수형]{--------------------------------------------------------------------------------------------------
  //void _List_삽입_(//[목록자체주소] 를 전달 받아야 하며, 목록은 반드시 [배열] 이 아닌 [포인터] 만 지정 가능.
  //                 //이는 [목록:저장소] 가 내부적으로 재생성되므로 재생성된 주소를 전달 받기 위한것.
  //                 char  **pr목록_,
  //                 //항목을 삽입할 행번호(기본 : 0).
  //                 int     p삽입할행번호,
  //                 //삽입할 항목(다중행인 경우라도 첫행만 추가).
  //                 char   *p항목_,
  //                 //[목록:저장소] 크기(Byte 단위) 반환(NULL 인 경우는 미사용).
  //                 //[목록:저장소] 는 실제 저장되는 문자열 보다 클수 있음.
  //                 int    *r목록저장소크기_,
  //                 //[목록] 안의 전체 [문자열 길이] 반환(NULL 인 경우는 미사용).
  //                 int    *r항목전체길이_,
  //                 //[목록] 안의 문자열 [전체 행수] 반환(NULL 인 경우는 미사용).
  //                 int    *r전체행수_);
  //}----------------------------------------------------------------------------------------------------------

  //[기본주소 얻기]
  //{
      //[!]{--------------------------------------------------------
      //<@LOCAL> 과 같은 [절대주소] 값.
      //함수 [인수] 등 모든 지역변수는 <@LOCAL> 부터 시작되기 때문.
      //첫번째 [지역변수(인수포함)] 의 [절대주소] 가 된다.
      //}-----------------------------------------------------------

      ADR = (vmos->regREG_[d_VM_Reg_LOCAL]);

  //}

  //[char  **pr목록_]
  //{
      //[!]{************************************************************************
      //(**) 는 [맷돌-C] 상에서는 2중 포인터지만 이미 [절대주소] 로 계산된 것이므로
      //여기서는 단지 [절대주소값] 으로 인식하고 처리하면 된다.
      //}***************************************************************************

      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&prList)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(prList, &prList);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int     p삽입할행번호]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (4), (DTU1 *)(&pInsertLineNumber)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (4);
      //}--------------------------

  //}

  //[char   *p항목_]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&pItem)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(pItem, &pItem);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int    *r목록저장소크기_]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rBufSize)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rBufSize, &rBufSize);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int    *r항목전체길이_]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rItemTotalLength)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rItemTotalLength, &rItemTotalLength);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[int    *r전체행수_]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, ADR, (8), (DTU1 *)(&rItemTotalLineCount)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //<Ide> 내부적으로만 사용되므로 바로 실제 주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(rItemTotalLineCount, &rItemTotalLineCount);

      //[다음 주소 계산]{----------
      //현재 [인수] 크기를 더한다.
      ADR += (8);
      //}--------------------------

  //}

  //[명령처리]
  //{
      STR_InsertLineStr((char **)prList,
                        //문자열을 삽입할 행번호(기본 : 0).
                        pInsertLineNumber,
                        //삽입할 문자열(실제는 첫행만 추가).
                        (char *)pItem,
                        //[새저장소] 크기 반환(NULL 인 경우는 미사용).
                        (int  *)rBufSize,
                        //[새저장소] 안의 전체 문자열 길이 반환(NULL 인 경우는 미사용).
                        (int  *)rItemTotalLength,
                        //[새저장소] 안의 문자열 전체 행수 반환(NULL 인 경우는 미사용).
                        (int  *)rItemTotalLineCount);

  //}

}






















