
#include <vcl.h>
#pragma hdrstop


#include  "API_Str.h"

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


//[내부 정의 값]{-----------------------------------------------------
//다른 정의와 충돌하지 않도록 <*.h> 에 선언하지 않고 여기에 선언한다.
#define  d_True    1
#define  d_False   0
//}-------------------------------------------------------------------


void _API_Str_Length(void)
{
  //[2009.05.24.일][생성!!!]

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

      //[VMOS] 상의 [절대주소] 를 갖는다.
      DTU8        adr;

      //주소는 전부 MCU 상의 주소다.
      DTU8        sysAdr;

      int         length;

  //}

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

  //[함수형]{---------------------------
  //int _Str_길이얻기(char  *p문자열);
  //[명령묶음구조]----------------------
  //[msg[] 내용]
  //[0] : (w:unsigned long) : 명령.
  //[1] : (w:char *)        : p문자열.
  //[2] : (r:int)           : 길이반환.
  //}-----------------------------------

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

      //MCU 내부적으로처리 하므로 실제 물리주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(adr, &sysAdr);

  //}

  //[명령처리]
  //{
      length = _API_Str_Length_Body((char *)sysAdr);

  //}

  //[길이반환]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, vmos->regSysFuncCallAdr + (8 * 2), 8, (DTU1 *)(&adr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

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

  //}

  return;

}

void _API_Str_Match(void)
{
  //[2009.05.24.일][생성!!!]

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

      //[VMOS] 상의 [절대주소] 를 갖는다.
      DTU8    adr;

      //주소는 전부 MCU 상의 주소다.
      DTU8    sysAdrA, sysAdrB;

      DTU1    result;

  //}

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

  //[함수형]{-------------------------------------
  //unsigned char _Str_일치검사(char  *p문자열A,
  //                            char  *p문자열B);
  //[명령묶음구조]--------------------------------
  //[msg[] 내용]
  //[0] : (w:unsigned long) : 명령.
  //[1] : (w:char *)        : p문자열A.
  //[2] : (w:char *)        : p문자열B.
  //[3] : (r:unsigned char) : 결과반환.
  //}---------------------------------------------

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

      //MCU 내부적으로처리 하므로 실제 물리주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(adr, &sysAdrA);

  //}

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

      //MCU 내부적으로처리 하므로 실제 물리주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(adr, &sysAdrB);

  //}

  //[명령처리]
  //{
      result = _API_Str_Match_Body((char *)sysAdrA, (char *)sysAdrB);

  //}

  //[결과반환]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, vmos->regSysFuncCallAdr + (8 * 3), 8, (DTU1 *)(&adr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

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

  //}

  return;

}

void _API_Str_Match_NoCase(void)
{
  //[2009.05.24.일][생성!!!]

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

      //[VMOS] 상의 [절대주소] 를 갖는다.
      DTU8    adr;

      //주소는 전부 MCU 상의 주소다.
      DTU8    sysAdrA, sysAdrB;

      DTU1    result;

  //}

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

  //[함수형]{-------------------------------------------------
  //unsigned char _Str_대소구분없는일치검사(char  *p문자열A,
  //                                        char  *p문자열B);
  //[명령묶음구조]--------------------------------------------
  //[msg[] 내용]
  //[0] : (w:unsigned long) : 명령.
  //[1] : (w:char *)        : p문자열A.
  //[2] : (w:char *)        : p문자열B.
  //[3] : (r:unsigned char) : 결과반환.
  //}---------------------------------------------------------

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

      //MCU 내부적으로처리 하므로 실제 물리주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(adr, &sysAdrA);

  //}

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

      //MCU 내부적으로처리 하므로 실제 물리주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(adr, &sysAdrB);

  //}

  //[명령처리]
  //{
      result = _API_Str_Match_NoCase_Body((char *)sysAdrA, (char *)sysAdrB);

  //}

  //[결과반환]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, vmos->regSysFuncCallAdr + (8 * 3), 8, (DTU1 *)(&adr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

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

  //}

  return;

}

void _API_Str_Assign(void)
{
  //[2009.05.24.일][생성!!!]

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

      //[VMOS] 상의 [절대주소] 를 갖는다.
      DTU8    adr;

      //주소는 전부 MCU 상의 주소다.
      DTU8    sysAdrA, sysAdrB;

      int     length;

  //}

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

  //[함수형]{---------------------------
  //int _Str_할당(char  *p저장소,
  //              char  *p문자열);
  //[명령묶음구조]----------------------
  //[msg[] 내용]
  //[0] : (w:unsigned long) : 명령.
  //[1] : (w:char *)        : p저장소.
  //[2] : (w:char *)        : p문자열.
  //[3] : (r:int)           : 길이.
  //}-----------------------------------

  //[p저장소]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, vmos->regSysFuncCallAdr + (8 * 1), 8, (DTU1 *)(&adr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //MCU 내부적으로처리 하므로 실제 물리주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(adr, &sysAdrA);

  //}

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

      //MCU 내부적으로처리 하므로 실제 물리주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(adr, &sysAdrB);

  //}

  //[명령처리]
  //{
      length = _API_Str_Assign_Body((char *)sysAdrA, (char *)sysAdrB);

  //}

  //[결과반환]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, vmos->regSysFuncCallAdr + (8 * 3), 8, (DTU1 *)(&adr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

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

  //}

  return;

}

void _API_Str_Join(void)
{
  //[2009.05.24.일][생성!!!]

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

      //[VMOS] 상의 [절대주소] 를 갖는다.
      DTU8    adr;

      //주소는 전부 MCU 상의 주소다.
      DTU8    sysAdrA, sysAdrB, sysAdrC;

      int     length;

  //}

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

  //[함수형]{---------------------------
  //int _Str_합치기(char  *p저장소,
  //                char  *p문자열A,
  //                char  *p문자열B);
  //[명령묶음구조]----------------------
  //[msg[] 내용]
  //[0] : (w:unsigned long) : 명령.
  //[1] : (w:char *)        : p저장소.
  //[2] : (w:char *)        : p문자열A.
  //[3] : (w:char *)        : p문자열B.
  //[4] : (r:int)           : 길이.
  //}-----------------------------------

  //[p저장소]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, vmos->regSysFuncCallAdr + (8 * 1), 8, (DTU1 *)(&adr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //MCU 내부적으로처리 하므로 실제 물리주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(adr, &sysAdrA);

  //}

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

      //MCU 내부적으로처리 하므로 실제 물리주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(adr, &sysAdrB);

  //}

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

      //MCU 내부적으로처리 하므로 실제 물리주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(adr, &sysAdrC);

  //}

  //[명령처리]
  //{
      length = _API_Str_Join_Body((char *)sysAdrA, (char *)sysAdrB, (char *)sysAdrC);

  //}

  //[결과반환]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, vmos->regSysFuncCallAdr + (8 * 4), 8, (DTU1 *)(&adr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

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

  //}

  return;

}

void _API_Str_Add(void)
{
  //[2009.05.24.일][생성!!!]

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

      //[VMOS] 상의 [절대주소] 를 갖는다.
      DTU8    adr;

      //주소는 전부 MCU 상의 주소다.
      DTU8    sysAdrA, sysAdrB;

      int     length;

  //}

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

  //[함수형]{---------------------------
  //int _Str_추가(char  *p문자열,
  //              char  *p추가문자열);
  //[명령묶음구조]----------------------
  //[msg[] 내용]
  //[0] : (w:unsigned long) : 명령.
  //[1] : (w:char *)        : p저장소.
  //[2] : (w:char *)        : p문자열.
  //[3] : (r:int)           : 길이.
  //}-----------------------------------

  //[p저장소]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, vmos->regSysFuncCallAdr + (8 * 1), 8, (DTU1 *)(&adr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

      //MCU 내부적으로처리 하므로 실제 물리주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(adr, &sysAdrA);

  //}

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

      //MCU 내부적으로처리 하므로 실제 물리주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(adr, &sysAdrB);

  //}

  //[명령처리]
  //{
      length = _API_Str_Add_Body((char *)sysAdrA, (char *)sysAdrB);

  //}

  //[결과반환]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, vmos->regSysFuncCallAdr + (8 * 3), 8, (DTU1 *)(&adr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

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

  //}

  return;

}

void _API_Str_Pos(void)
{
  //[2009.05.24.일][생성!!!]

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

      //[VMOS] 상의 [절대주소] 를 갖는다.
      DTU8    adr;

      //주소는 전부 MCU 상의 주소다.
      DTU8    sysAdr;
      int     startIndex;
      char    chr;
      int     pos;

  //}

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

  //[함수형]{-----------------------------------
  //int _Str_문자위치얻기(char  *p문자열,
  //                      int    p찾을시작위치,
  //                      char   p찾을문자);
  //[명령묶음구조]------------------------------
  //[msg[] 내용]
  //[0] : (w:unsigned long) : 명령.
  //[1] : (w:char *)        : p문자열.
  //[2] : (w:int)           : p찾을시작위치.
  //[3] : (w:char)          : p찾을문자.
  //[4] : (r:int)           : 찾은위치.
  //}-------------------------------------------

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

      //MCU 내부적으로처리 하므로 실제 물리주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(adr, &sysAdr);

  //}

  //[p찾을시작위치]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, vmos->regSysFuncCallAdr + (8 * 2), 8, (DTU1 *)(&adr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

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

  //}

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

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

  //}

  //[명령처리]
  //{
      pos = _API_Str_Pos_Body((char *)sysAdr, startIndex, chr);

  //}

  //[결과반환]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, vmos->regSysFuncCallAdr + (8 * 4), 8, (DTU1 *)(&adr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

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

  //}

  return;

}

void _API_Str_SubStr(void)
{
  //[2009.05.24.일][생성!!!]

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

      //[VMOS] 상의 [절대주소] 를 갖는다.
      DTU8    adr;

      //주소는 전부 MCU 상의 주소다.
      DTU8    sysAdrA;
      int     subStartIndex;
      int     subLength;
      DTU8    sysAdrB;

      int     length;

  //}

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

  //[함수형]{--------------------------------
  //int _Str_부분추출(char  *p문자열,
  //                  int    p추출시작위치,
  //                  int    p추출할길이,
  //                  char  *r추출문자열);
  //[명령묶음구조]---------------------------
  //[msg[] 내용]
  //[0] : (w:unsigned long) : 명령.
  //[1] : (w:char *)        : p문자열.
  //[2] : (w:int)           : p추출시작위치.
  //[3] : (w:int)           : p추출할길이.
  //[4] : (w:char *)        : r추출문자열.
  //[5] : (r:int)           : 길이.
  //}----------------------------------------

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

      //MCU 내부적으로처리 하므로 실제 물리주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(adr, &sysAdrA);

  //}

  //[p찾을시작위치]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, vmos->regSysFuncCallAdr + (8 * 2), 8, (DTU1 *)(&adr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

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

  //}

  //[p추출할길이]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, vmos->regSysFuncCallAdr + (8 * 3), 8, (DTU1 *)(&adr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

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

  //}

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

      //MCU 내부적으로처리 하므로 실제 물리주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(adr, &sysAdrB);

  //}

  //[명령처리]
  //{
      length = _API_Str_SubStr_Body((char *)sysAdrA, subStartIndex, subLength, (char *)sysAdrB);

  //}

  //[결과반환]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, vmos->regSysFuncCallAdr + (8 * 5), 8, (DTU1 *)(&adr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

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

  //}

  return;

}

void _API_Str_Word(void)
{
  //[2009.05.24.일][생성!!!]

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

      //[VMOS] 상의 [절대주소] 를 갖는다.
      DTU8    adr;

      //주소는 전부 MCU 상의 주소다.
      DTU8    sysAdrA;
      char    token;
      int     wordIndex;
      DTU8    sysAdrB;

      int     length;

  //}

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

  //[함수형]{--------------------------------
  //int _Str_단어추출(char  *p문자열,
  //                  char   p구분문자,
  //                  int    p단어순번,
  //                  char  *r추출단어);
  //[명령묶음구조]---------------------------
  //[msg[] 내용]
  //[0] : (w:unsigned long) : 명령.
  //[1] : (w:char *)        : p문자열.
  //[2] : (w:char)          : p구분문자.
  //[3] : (w:int)           : p단어순번.
  //[4] : (w:char *)        : r추출단어.
  //[5] : (r:int)           : 길이.
  //}----------------------------------------

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

      //MCU 내부적으로처리 하므로 실제 물리주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(adr, &sysAdrA);

  //}

  //[p구분문자]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, vmos->regSysFuncCallAdr + (8 * 2), 8, (DTU1 *)(&adr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

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

  //}

  //[p단어순번]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, vmos->regSysFuncCallAdr + (8 * 3), 8, (DTU1 *)(&adr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

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

  //}

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

      //MCU 내부적으로처리 하므로 실제 물리주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(adr, &sysAdrB);

  //}

  //[명령처리]
  //{
      length = _API_Str_Word_Body((char *)sysAdrA, token, wordIndex, (char *)sysAdrB);

  //}

  //[결과반환]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, vmos->regSysFuncCallAdr + (8 * 5), 8, (DTU1 *)(&adr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

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

  //}

  return;

}

void _API_Str_SetLength(void)
{
  //[2009.05.24.일][생성!!!]

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

      //[VMOS] 상의 [절대주소] 를 갖는다.
      DTU8    adr;

      //주소는 전부 MCU 상의 주소다.
      DTU8    sysAdrA;
      int     setLength;
      char    fillChar;
      DTU8    sysAdrB;

  //}

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

  //[함수형]{-------------------------------
  //void _Str_길이조정(char  *p문자열,
  //                   int    p조정길이,
  //                   char   p채울문자,
  //                   char  *r조정문자열);
  //[명령묶음구조]--------------------------
  //[msg[] 내용]
  //[0] : (w:unsigned long) : 명령.
  //[1] : (w:char *)        : p문자열.
  //[2] : (w:int)           : p조정길이.
  //[3] : (w:char)          : p채울문자.
  //[4] : (w:char *)        : r조정문자열.
  //}---------------------------------------

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

      //MCU 내부적으로처리 하므로 실제 물리주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(adr, &sysAdrA);

  //}

  //[p조정길이]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, vmos->regSysFuncCallAdr + (8 * 2), 8, (DTU1 *)(&adr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

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

  //}

  //[p채울문자]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, vmos->regSysFuncCallAdr + (8 * 3), 8, (DTU1 *)(&adr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

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

  //}

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

      //MCU 내부적으로처리 하므로 실제 물리주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(adr, &sysAdrB);

  //}

  //[명령처리]
  //{
      _API_Str_SetLength_Body((char *)sysAdrA, setLength, fillChar, (char *)sysAdrB);

  //}

  return;

}

void _API_Str_LastChar(void)
{
  //[2009.05.24.일][생성!!!]

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

      //[VMOS] 상의 [절대주소] 를 갖는다.
      DTU8        adr;

      //주소는 전부 MCU 상의 주소다.
      DTU8        sysAdr;
      char        lastChar;

  //}

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

  //[함수형]{-----------------------------
  //char _Str_끝문자얻기(char  *p문자열);
  //[명령묶음구조]------------------------
  //[msg[] 내용]
  //[0] : (w:unsigned long) : 명령.
  //[1] : (w:char *)        : p문자열.
  //[2] : (r:char)          : 마지막문자.
  //}-------------------------------------

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

      //MCU 내부적으로처리 하므로 실제 물리주소로 바꾼다.
      vmos->VMOS_Conv_AdrToSysAdr(adr, &sysAdr);

  //}

  //[명령처리]
  //{
      lastChar = _API_Str_LastChar_Body((char *)sysAdr);

  //}

  //[마지막 문자 반환]
  //{
      //[절대주소] 읽기.
      if(vmos->VMOS_WrRd(d_Rd, vmos->regSysFuncCallAdr + (8 * 2), 8, (DTU1 *)(&adr)) != true)
      { vmos->regSysFuncCallResult = d_False; return; }

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

  //}

  return;

}

//------------------------------------------------------------------------------
//[실제 처리 함수들]------------------------------------------------------------
//------------------------------------------------------------------------------

int _API_Str_Length_Body(char  *pStr)
{
  //[2009.05.15.금][생성!!!]{----------------------
  //전달받은 [문자열] 의 [길이] 를 구한다.
  //pSTR[] 상에서의 '\0' 의 위치가 곧 문자열 길이가 된다.
  //'\0' 은 제외한 길이가 된다.
  //}---------------------------------------------

  //[VAR]
  //{
      int  i;

  //}

  for(i = 0; pStr[i] != '\0'; i++);

  //현재 위치의 i 값이 길이가 된다.
  return(i);

}

unsigned char _API_Str_Match_Body(char  *pStrA,
                                  char  *pStrB)
{
  //[2009.05.15.금][생성!!!]{---------------
  //문자열 두개가 서로 일치하는지 검사한다.
  //단, 대/소 문자를 구분하여 처리한다.
  //문자열 길이도 서로 일치해야 한다.
  //}---------------------------------------

  //[VAR]
  //{
      int  i;
  
  //}
  
  for(i = 0; !((pStrA[i] == '\0') || (pStrB[i] == '\0')); i++)
  {
    //문자를 하나씩 읽어서 같은지 확인하고 일치 하지 않는 경우는 더이상 검사하지 않고 종료한다.
    if(pStrA[i] != pStrB[i]) return(d_False);
  
  }
  
  //두 문자열 중 하나의 문자열이  끝났으므로 다른 문자열도 끝인지 확인한다.
  if(pStrA[i] != pStrB[i]) return(d_False);
  
  //여기까지 온것은 두 문자열이 완벽하게 일치하는 것으로 본다.
  return(d_True);
  
}

unsigned char _API_Str_Match_NoCase_Body(char  *pStrA,
                                         char  *pStrB)
{
  //[2009.05.15.금][생성!!!]{--------------------------
  //문자열 두개가 서로 일치하는지 검사한다.
  //영문인 경우는 대/소 문자를 구분하지 않고 처리한다.
  //문자열 길이도 서로 일치해야 한다.
  //}--------------------------------------------------

  //[VAR]
  //{
      int   i;
      char  charA;
      char  charB;  
  
  //}
      
  for(i = 0; !((pStrA[i] == '\0') || (pStrB[i] == '\0')); i++)
  {
    //[검사할 문자 추출]
    //{
        //일단 중복 처리를 피하기 위하여 무조건 문자를 얻는다.
        charA = pStrA[i];
        charB = pStrB[i];
    
        //[소문자로 만들기]{----------------------------------------------------------------
        //대/소문자를 구분하지 않으므로 대문자인 경우는 일단 무조건 소문자로 만들어 놓는다.
        //대문자 'A' 와 소문자 'a' 는 <32> 만큼 차이가 나므로 +32 한다.
        if(('A' <= charA) && (charA <= 'Z')) { charA += 32; }
        if(('A' <= charB) && (charB <= 'Z')) { charB += 32; }
        //}---------------------------------------------------------------------------------

    //}    

    //[문자 일치 검사]{-------------------------------------------------------------------------
    //문자를 하나씩 읽어서 같은지 확인하고 일치 하지 않는 경우는 더이상 검사하지 않고 종료한다.
    if(charA != charB) return(d_False);
    //}-----------------------------------------------------------------------------------------
  
  }

  //두 문자열 중 하나의 문자열이  끝났으므로 다른 문자열도 끝인지 확인한다.
  if(pStrA[i] != pStrB[i]) return(d_False);
  
  //여기까지 온것은 두 문자열이 완벽하게 일치하는 것으로 본다.
  return(d_True);
  
}

int _API_Str_Assign_Body(char  *pBuf,
                         char  *pStr)
{
  //[2009.05.15.금][생성!!!]{------------------------------------------
  //문자열을 지정된 저장공간에 할당하고 저장된 문자열 길이를 반환한다.
  //저장소는 문자열을 저장할수 있는 충분한 공간을 가져야 한다.
  //}------------------------------------------------------------------

  //[VAR]
  //{
      int  i;

  //}

  //1Byte 단위로 문자열을 복사한다.
  for(i = 0; pStr[i] != '\0'; i++) { pBuf[i] = pStr[i]; }

  //문자열 끝의 '\0' 도 복사해 주어야 한다.
  pBuf[i] = pStr[i];

  return(i);

}

int _API_Str_Join_Body(char  *pBuf,
                       char  *pStrA,
                       char  *pStrB)
{
  //[2009.05.15.금][생성!!!]{----------------------------------------------------
  //두개의 문자열을 하나로 합쳐서 지정된 저장소에 저장하고 전체 길이를 반환한다.
  //저장소는 문자열을 저장할수 있는 충분한 공간을 가져야 한다.
  //}----------------------------------------------------------------------------

  //[VAR]
  //{
      int  size;

  //}

  //저장소에 문자열A 저장.
  size  = _API_Str_Assign_Body(pBuf, pStrA);

  //저장소에 문자열B를 이어서 저장.
  size += _API_Str_Assign_Body(&(pBuf[size]), pStrB);

  //문자열 끝에 '\0' 를 붙여서 문자열을 마무리 한다.
  pBuf[size] = '\0';

  return(size);

}

int _API_Str_Add_Body(char  *pStr,
                      char  *pAddStr)
{
  //[2009.05.15.금][생성!!!]{----------------------------------
  //현재 저장소에 문자열을 추가하고 전체 길이를 반환한다.
  //저장소는 문자열을 추가할 충분한 공간을 가지고 있어야 한다.
  //}----------------------------------------------------------

  //[VAR]
  //{
      int  size;

  //}

  //이미 있는 저장소의 문자열 길이 구하기.
  size = _API_Str_Length_Body(pStr);

  //저장소에 문자열을 이어서 저장.
  size += _API_Str_Assign_Body(&(pStr[size]), pAddStr);

  //문자열 끝에 '\0' 를 붙여서 문자열을 마무리 한다.
  pStr[size] = '\0';

  return(size);

}

int _API_Str_Pos_Body(char  *pStr,
                      int    pStartInx,
                      char   pChar)
{
  //[2009.05.15.금][생성!!!]{------------------------------------------------------
  //문자열에서 지정한 문자를 찾아 위치를 반환하고 찾지 못한 경우는 -1 을 반환한다.
  //}------------------------------------------------------------------------------

  //[VAR]
  //{
      int  i;
      int  size;

  //}

  //문자열 길이얻기.
  size = _API_Str_Length_Body(pStr);

  //지정 문자 찾기.
  for(i = pStartInx; i < size; i++)
  {
    //원하는 문자를 찾았다면 위치를 반환한다.
    if(pStr[i] == pChar) { return(i); }

  }

  //여기까지 온것은 찾지 못한 것으로 본다.
  return(-1);

}

int _API_Str_SubStr_Body(char  *pStr,
                         int    pStartInx,
                         int    pLength,
                         char  *rSubStr)
{
  //[2009.05.15.금][생성!!!]{---------------------------------------------------------------------------------
  //문자열에서 지정 위치부터 지정길이의 문자열을 추출하여 반환하고 추가로 실제 추출한 문자열 길이도 반환한다.
  //추출할 문자열 길이가 너무 길어서 대상이 되는 문자열을 넘는 경우는 대상이 되는 문자열의 끝까지만 추출한다.
  //추출할수 없는 경우는 자동으로 "" 문자열이 반환된다.
  //}---------------------------------------------------------------------------------------------------------

  //[VAR]
  //{
      int  i, j;
      int  size;

  //}

  size = pStartInx + pLength;

  for(i = pStartInx, j = 0; (pStr[i] != '\0') && (i < size); i++, j++)
  {
    //지정위치부터 지정 길이까지 문자를 복사하는 방식으로 추출한다.
    rSubStr[j] = pStr[i];

  }

  //문자열을 완성하기 위하여 끝에 '\0' 를 붙여준다.
  rSubStr[j] = '\0';

  return(j);

}

int _API_Str_Word_Body(char  *rStr,
                       char   pToken,
                       int    pWordInx,
                       char  *rWord)
{
  //[2009.05.16.토][생성!!!]{--------------------------------------------------------------------------
  //문자열에서 [구분문자] 를 사용하여 지정 순번의 단어를 추출하여 반환하고 추가로 단어길이도 반환한다.
  //
  //[참고]{--------------------------------------------------------------------------------------------
  //문자열 끝에 [구분문자] 가 없을수있고, 문자열 중간에 '\0' 이 있을수 없으므로단어를 구분할때는
  //문자열 끝에 있는 단어를 위하여 [구분문자] 또는 '\0' 두 개를 항상 같이 검사해야한다.
  //}--------------------------------------------------------------------------------------------------

  //[VAR]
  //{
      int  i;
      int  startInx, endInx;
      int  wordInx;

  //}

  //[초기화]
  //{
      startInx = 0;
      endInx  = 0;
      wordInx   = -1;

      //일단 단어 저장소를 비워놓는다.
      rWord[0] = '\0';

  //}

  //단어 추출하기.
  for(i = 0; ; i++)
  {
    if((rStr[i] == pToken) || (rStr[i] == '\0'))
    {
      //한개의 [구분문자] 는 한개의 [단어] 를 의미한다.
      wordInx++;

      //지정된 단어인가?
      if(wordInx == pWordInx)
      {
        //[단어 끝위치 기록]{-----------------------------------------------------
        //현재 i 는 [구분문자] 위치이므로 이 바로 이전 문자까지가 단어 끝이 된다.
        endInx = i - 1;
        //}-----------------------------------------------------------------------

        //[단어추출]{------------------------------------------------------------------------------------------
        //단어를 추출하고 동시에 길이도 반환한다.
        if(startInx <= endInx) { return(_API_Str_SubStr_Body(rStr, startInx, endInx - startInx + 1, rWord)); }
        //단어 추출 여건이 되지 않으므로 종료한다.
        else                { return(0); }
        //}----------------------------------------------------------------------------------------------------

      }

      //[단어 시작 위치 기록]{----------------------------------------
      //현재 [구분문자] 위치 i 다음이 다음 단어의 첫 문자위치가 된다.
      startInx = i + 1;
      //}-------------------------------------------------------------

      //[문자열 끝]{-----------------------
      //문자열 끝까지 검사했다면 종료한다.
      if(rStr[i] == '\0') break;
      //}----------------------------------

    }

  }

  //여기까지 온것은 원하는 단어를 찾지 못한 것으로 본다.
  return(0);

}

void _API_Str_SetLength_Body(char  *pStr,
                             int    pSetLength,
                             char   pFillChar,
                             char  *rSetLengthStr)
{
  //[2009.05.16.토][생성!!!]{------------------------------------------------
  //문자열의 길이를 지정길이로 조정하고 빈곳은 지정문자로 채워준다.
  //[r조정문자열] 저장소는 처리된 문자열을 저장할 충분한 공간을 가져야 한다.
  //}------------------------------------------------------------------------

  //[형식]{--------------------------------
  //"문자열......XXXXXXXX" 의 형식이 된다.
  //X : 채울문자.
  //}--------------------------------------

  //[VAR]
  //{
      int  i, length;

  //}

  //[문자열 길이 얻기]{----------------
  length = _API_Str_Length_Body(pStr);
  //}----------------------------------

  //전달 받은 문자열이 지정된 길이보다 [큰경우/작은경우] 로 나누어서 처리한다.
  if(pSetLength <= length)
  {
    //이 경우는 빈 공간이 없으므로 [pSetLength] 만큼 추출하여 반환한다.
    _API_Str_SubStr_Body(pStr, 0, pSetLength, rSetLengthStr);

  }
  else
  {
    //이 경우는 빈 공간이 있으므로 이 공간을 [pFillChar] 로 채워 준다.

    //[1 단계]{------------------------------------------------------------
    //먼저 문자열을 추가한다.
    _API_Str_Assign_Body(rSetLengthStr, pStr);
    //[2 단계]-------------------------------------------------------------
    //남는 부분을 지정 문자로 채워 준다.
    for(i = length; i < pSetLength; i++) { rSetLengthStr[i] = pFillChar; }
    //문자열 완성.
    rSetLengthStr[i] = '\0';
    //}--------------------------------------------------------------------

  }

  return;

}

char _API_Str_LastChar_Body(char  *pStr)
{
  //[2009.05.16.토][생성!!!]{-------------
  //문자열의 끝 문자를 추출하여 반환한다.
  //}-------------------------------------
  
  //문자열이 없는 경우는 '\0' 을 직접 반환한다.
  if(pStr[0] == '\0') { return('\0'); }
  //문자열이 있는 경우는 끝 문자를 반환한다.
  else                { return(pStr[_API_Str_Length_Body(pStr) - 1]); }

}











