Could not convert variant of the type (String) into type (Boolean)

//---------------------------------------------------------------------------
 
#include <vcl.h>
#include <windows.h>
#include <stdio.h>
#include <tchar.h>
#include <strsafe.h>
 
#define BUFSIZE 512
 
 
#pragma hdrstop
 
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
 
DWORD WINAPI InstanceThread(LPVOID);
VOID GetAnswerToRequest(LPTSTR, LPTSTR, LPDWORD);
 
int Start()
{
 
    BOOL   fConnected = FALSE;
   DWORD  dwThreadId = 0;
   HANDLE hPipe = INVALID_HANDLE_VALUE, hThread = NULL;
   LPTSTR lpszPipename = TEXT("\\\\.\\pipe\\tvp");
   AnsiString PipeName=lpszPipename;
   for (;;)
   {
      Form1->Memo2->Lines->Add("Сервер: Ждем подключения клиента в канале " & PipeName);
      hPipe = CreateNamedPipe(
          lpszPipename,             // pipe name
          PIPE_ACCESS_DUPLEX,       // read/write access
          PIPE_TYPE_MESSAGE |       // message type pipe
          PIPE_READMODE_MESSAGE |   // message-read mode
          PIPE_WAIT,                // blocking mode
          PIPE_UNLIMITED_INSTANCES, // max. instances
          BUFSIZE,                  // output buffer size
          BUFSIZE,                  // input buffer size
          0,                        // client time-out
          NULL);                    // default security attribute
 
    if (hPipe == INVALID_HANDLE_VALUE)
      {
          Form1->Memo2->Lines->Add("Сервер: Ошибка в функции CreateNamedPipe");
          return -1;
      }
       fConnected = ConnectNamedPipe(hPipe, NULL) ?
         TRUE : (GetLastError() == ERROR_PIPE_CONNECTED);
 
      if (fConnected)
      {
         Form1->Memo2->Lines->Add("Сервер: клиент присоединился, создаю поток для него");
 
         // Create a thread for this client.
         hThread = CreateThread(
            NULL,              // no security attribute
            0,                 // default stack size
            InstanceThread,    // thread proc
            (LPVOID) hPipe,    // thread parameter
            0,                 // not suspended
            &dwThreadId);      // returns thread ID
 
      if (hThread == NULL)
         {
           Form1->Memo2->Lines->Add("Сервер: ошибка при создании потока ");
            return -1;
         }
         else CloseHandle(hThread);
       }
      else
        // The client could not connect, so close the pipe.
         CloseHandle(hPipe);
   }
 
 
   return 0;
}
DWORD WINAPI InstanceThread(LPVOID lpvParam)
{
   HANDLE hHeap      = GetProcessHeap();
   TCHAR* pchRequest = (TCHAR*)HeapAlloc(hHeap, 0, BUFSIZE*sizeof(TCHAR));
   TCHAR* pchReply   = (TCHAR*)HeapAlloc(hHeap, 0, BUFSIZE*sizeof(TCHAR));
 
   DWORD cbBytesRead = 0, cbReplyBytes = 0, cbWritten = 0;
   BOOL fSuccess = FALSE;
   HANDLE hPipe  = NULL;
 
   // Do some extra error checking since the app will keep running even if this
   // thread fails.
 
   if (lpvParam == NULL)
   {
       Form1->Memo2->Lines->Add("Сервер: проблема с pipe сервером");
       Form1->Memo2->Lines->Add("Сервер: поток внезапно получил 0 в lpvParam");
       Form1->Memo2->Lines->Add("Сервер: выход из потока");
       if (pchReply != NULL) HeapFree(hHeap, 0, pchReply);
       if (pchRequest != NULL) HeapFree(hHeap, 0, pchRequest);
       return (DWORD)-1;
   }
    if (pchRequest == NULL)
   {
       Form1->Memo2->Lines->Add("Сервер: проблема с pipe сервером");
       Form1->Memo2->Lines->Add("Сервер: внезапный ноль...гдето");
       Form1->Memo2->Lines->Add("Сервер: выход из потока");
       if (pchReply != NULL) HeapFree(hHeap, 0, pchReply);
       return (DWORD)-1;
   }
     if (pchReply == NULL)
   {
       Form1->Memo2->Lines->Add("Сервер: проблема с pipe сервером");
       Form1->Memo2->Lines->Add("Сервер: внезапный ноль...гдето");
       Form1->Memo2->Lines->Add("Сервер: выход из потока");
       if (pchRequest != NULL) HeapFree(hHeap, 0, pchRequest);
       return (DWORD)-1;
   }
   hPipe = (HANDLE) lpvParam;
   while (1)
   {
   // Read client requests from the pipe. This simplistic code only allows messages
   // up to BUFSIZE characters in length.
      fSuccess = ReadFile(
         hPipe,        // handle to pipe
         pchRequest,    // buffer to receive data
         BUFSIZE*sizeof(TCHAR), // size of buffer
         &cbBytesRead, // number of bytes read
         NULL);        // not overlapped I/O
 
      if (!fSuccess || cbBytesRead == 0)
      {
          if (GetLastError() == ERROR_BROKEN_PIPE)
          {
              Form1->Memo2->Lines->Add("Поток: клиент отключился");
          }
          else
          {
              Form1->Memo2->Lines->Add("Поток: ReadFile не удался");
          }
          break;
      }
      GetAnswerToRequest(pchRequest, pchReply, &cbReplyBytes);
       fSuccess = WriteFile(
         hPipe,        // handle to pipe
         pchReply,     // buffer to write from
         cbReplyBytes, // number of bytes to write
         &cbWritten,   // number of bytes written
         NULL);        // not overlapped I/O
 
      if (!fSuccess || cbReplyBytes != cbWritten)
      {
          Form1->Memo2->Lines->Add("WriteFile в потоке не удался");
          break;
      }
  }
  FlushFileBuffers(hPipe);
   DisconnectNamedPipe(hPipe);
   CloseHandle(hPipe);
 
   HeapFree(hHeap, 0, pchRequest);
   HeapFree(hHeap, 0, pchReply);
 
   Form1->Memo2->Lines->Add("Выход из потока");
   return 1;
}
VOID GetAnswerToRequest( LPTSTR pchRequest,
                         LPTSTR pchReply,
                         LPDWORD pchBytes )
// This routine is a simple function to print the client request to the console
// and populate the reply buffer with a default data string. This is where you
// would put the actual client request processing code that runs in the context
// of an instance thread. Keep in mind the main thread will continue to wait for
// and receive other client connections while the instance thread is working.
{    AnsiString Request = pchRequest;
    Form1->Memo1->Lines->Add("Клиент: " & Request);
 
    // Check the outgoing message to make sure it's not too long for the buffer.
    if (FAILED(StringCchCopy( pchReply, BUFSIZE, TEXT("default answer from server") )))
    {
        *pchBytes = 0;
        pchReply[0] = 0;
        Form1->Memo2->Lines->Add("Ошибка в StringCchCopy : нет исходящего сообщения");
        return;
    }
    *pchBytes = (lstrlen(pchReply)+1)*sizeof(TCHAR);
 
}
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Start();
}
//---------------------------------------------------------------------------

LPTSTR lpszPipename = TEXT("\\\\.\\pipe\\mynamedpipe");
_tprintf( TEXT("\nPipe Server: Main thread awaiting client connection on %s\n"), lpszPipename);

LPTSTR lpszPipename = TEXT("\\\\.\\pipe\\mynamedpipe");
AnsiString pipe_name = lpszPipename;
Form1->Memo2->Lines->Add("Сервер: Главный поток ждет коннекта клиента в " &pipe_name);

#include <tchar.h>