void GBLStorageManagerStateTestBB::RetrieveStateTest( CKContext *ctx )
{
    XString         outputStr;
    XString         data;

    outputStr.Format( "Calling RetrieveState( %d, &<data>, %d, %d )", (int)testUserID, (int)testLAEID, componentID );
    OutputTestText( ctx, outputStr );

    StartTimeMeasure();
	CGBLCOError res = pInterface->RetrieveState( testUserID, &data, testLAEID, componentID );
	StopAndOutputTimeMeasure( ctx );

    outputStr.Format( "RetrieveState result: %s", (const char*)res );
	OutputTestText( ctx, outputStr );

	if (res == CGBLCOError::EGBLCOErrorType::GBLCO_OK)
    {
        outputStr.Format( "State data retrieved: %s", data.Str() );
        OutputTestText( ctx, outputStr );

        if( testData == data )
		    OutputTestText( ctx, XString("TEST PASSED") );
        else
            OutputTestText( ctx, XString("Retrieved data doesn't match saved data\r\nTEST FAILED") );
    }
	else
		OutputTestText( ctx, XString("TEST FAILED") );
}
void CGBLStorageManagerTestBBBase::RunUnitTests( CKContext *ctx, TestCase *testCases, int numTests, XString &testRunTitle )
{
    XString     outputString;

    // Initialise the test run timer
    totalExecutionTime = 0;

    // Generate the current time
	time_t seconds;
	seconds = time (NULL);
    struct tm * timeinfo;
    timeinfo = localtime ( &seconds );

    // Output a formatted intro to the test run
    outputString =  "############################################################################\r\n";
    outputString << testRunTitle << "\r\n";
	outputString << asctime (timeinfo) << "\r\n";
	outputString << "############################################################################\r\n";
    OutputTestText( ctx, outputString );

    // Iterate over each test and execute it...
    for( int i = 0; i < numTests; i++ )
    {
        XString         testIntroText;
        
        // First, write some intro text to the output
        OutputTestText( ctx, XString("----------------------------------------------------------------------------") );
        testIntroText.Format( "Test number %d\r\nExecuting unit test '%s'...", i+1, testCases[i].testName ); 
        OutputTestText( ctx, testIntroText );
        OutputTestText( ctx, XString("----------------------------------------------------------------------------\r\n") );

        // Now execute the actual test case
        testCases[i].testFunction( ctx );

        // Now append some end of test text
        testIntroText.Format( "End of test number %d", i+1 );
        OutputTestText( ctx, testIntroText );
        OutputTestText( ctx, XString("----------------------------------------------------------------------------\r\n") );
    }

	outputString = "";
    outputString << "############################################################################\r\n";
	outputString << "Total execution time = " << totalExecutionTime << " seconds\r\n";
	outputString << "############################################################################\r\n";
    outputString << "########################      END OF TEST        ###########################";

    OutputTestText( ctx, outputString );
}
/*
 *******************************************************************
 * Function: int BehaviourFunction( const CKBehaviorContext& behaviorContext )
 *
 * Description : The execution function is the function that will be called 
 *               during the process loop of the behavior engine, if the behavior 
 *               is defined as using an execution function. This function is not 
 *               called if the behavior is defined as a graph. This function is the 
 *               heart of the behavior: it should compute the essence of the behavior, 
 *               in an incremental way. The minimum amount of computing should be 
 *               done at each call, to leave time for the other behaviors to run. 
 *               The function receives the delay in milliseconds that has elapsed 
 *               since the last behavioral process, and should rely on this value to 
 *               manage the amount of effect it has on its computation, if the effect 
 *               of this computation relies on time.
 *
 * Parameters :
 *    behaviourContext    r   Behavior context reference, which gives access to 
 *                            frequently used global objects ( context, level, manager, etc... )
 *
 * Returns : int, If it is done, it should return CKBR_OK. If it returns 
 *                CKBR_ACTIVATENEXTFRAME, the behavior will again be called 
 *                during the next process loop.
 *
 *******************************************************************
 */
int GBLStorageManagerStateTestBB::BehaviourFunction( const CKBehaviorContext& behaviorContext )
{
	beh = behaviorContext.Behavior;
	CKContext *ctx = behaviorContext.Context;

    // Randomise
    srand( (unsigned)time( NULL ) );

    // Get a pointer to the required interface now
    pInterface = GetStateInterfacePointer( ctx );

    // Generate some values that can be used throughout the tests
    testUserID = (rand() % 999) + 1;
    testLAEID = (rand() % 999) + 1;

    if( pInterface )
    {
        // Simply execute the unit tests...
        RunUnitTests( ctx, testCases, sizeof(testCases)/sizeof(TestCase), testRunName );
    }
    else
        OutputTestText( ctx, XString("Cannot acquire state interface. Unable to execute tests.") );

	beh->ActivateInput(0, 0);
	beh->ActivateOutput(0);

    return CKBR_OK;
}
Ejemplo n.º 4
0
inline
FString RBUF_STRING(const uint8_t *p, size_t pos, size_t len)
{
    const char *const begin = static_cast<const char *>(RBUFP(p, pos));
    const char *const end = begin + len;
    const char *const mid = std::find(begin, end, '\0');
    return XString(begin, mid, nullptr);
}
Ejemplo n.º 5
0
inline
FString RFIFO_STRING(int fd, size_t pos, size_t len)
{
    const char *const begin = static_cast<const char *>(RFIFOP(fd, pos));
    const char *const end = begin + len;
    const char *const mid = std::find(begin, end, '\0');
    return XString(begin, mid, nullptr);
}
Ejemplo n.º 6
0
void MD5_to_str(MD5_state state, md5_string& out_)
{
    md5_binary bin;
    MD5_to_bin(state, bin);
    char out[0x20];
    for (int i = 0; i < 0x10; i++)
        out[2 * i] = hex[bin[i] >> 4],
        out[2 * i + 1] = hex[bin[i] & 0xf];
    out_ = stringish<md5_string>(XString(out, out + 0x20, nullptr));
}
Ejemplo n.º 7
0
int DirToArray(const CKBehaviorContext& behcontext)
{
	CKBehavior* beh = behcontext.Behavior;
  	CKContext* ctx = behcontext.Context;

	XString filename((CKSTRING) beh->GetInputParameterReadDataPtr(0));
	XString Mask((CKSTRING) beh->GetInputParameterReadDataPtr(1));
		
	int rec;

	beh->GetInputParameterValue(2,&rec);

	

	if( beh->IsInputActive(0) ){
		beh->ActivateInput(0,FALSE);

		flist.erase(flist.begin(),flist.end());

		CKDirectoryParser MyParser(filename.Str(),Mask.Str(),rec);
		char* str = NULL;
		while(str = MyParser.GetNextFile())
			flist.push_back(XString(str));

		counter = 0;
		beh->ActivateInput(1,TRUE);

		
	}


	if( beh->IsInputActive(1) ){
		beh->ActivateInput(1,FALSE);

		if ( counter < flist.size() ){
			XString entry = flist.at(counter);
			CKParameterOut * pout = beh->GetOutputParameter(0);
			pout->SetStringValue(entry.Str() );
				
			counter++;
			beh->SetOutputParameterValue(1,&counter);
			beh->ActivateOutput(1);

		}else{

			beh->SetOutputParameterValue(1,&counter);
			counter = 0 ; 
			beh->ActivateOutput(0);
		}
	}
	return 0;
}
Ejemplo n.º 8
0
void CPWad::AddEntry (DIR_ENTRY &entry)
{
     char namebuf[9];
     namebuf[8] = 0;
     memcpy (namebuf, entry.resource_name, 8);
     
     XString name (namebuf);

     // -=- test for map level marker -=- 
     if ((((name[0] == 'E') && (name[2] == 'M')) || ((name[0] == 'M') && (name[1] == 'A') && (name[2] == 'P'))) && (entry.resource_size == 0))
     {
          // -=- add map header entry to dir and set up current map -=-
          directory.AddItem (currentmap = new CDirEntry (name, 0, 0));
     }
     else
     {
          // -=- put all map related records in the list in the sub dir of the map -=-
          // -=- all other items go in the main dir -=-
          if  ((name == XString("THINGS")) ||
		(name == XString("LINEDEFS")) ||
		(name == XString("SIDEDEFS")) ||
		(name == XString("VERTEXES")) ||	
		(name == XString("SEGS")) ||
		(name == XString("SSECTORS")) ||
		(name == XString("NODES")) ||
		(name == XString("SECTORS")) ||	
		(name == XString("REJECT")) ||
		(name == XString("BLOCKMAP")))
          {
               currentmap->subdir.AddItem (new CDirEntry (name, entry.resource_offset, entry.resource_size)); 
          }
          else
          {
               directory.AddItem (new CDirEntry (name, entry.resource_offset, entry.resource_size)); 
               currentmap = 0;
          }
     }
}
void GBLStorageManagerStateTestBB::StoreExistingStateTest( CKContext *ctx )
{
    XString         outputStr;

	testData = "StoreExistingStateTest test state data - updated after initial storage";

    outputStr.Format( "Calling StoreState( %d, %s, %d, %d )", (int)testUserID, testData.Str(), (int)testLAEID, componentID );
    OutputTestText( ctx, outputStr );

    StartTimeMeasure();
	CGBLCOError res = pInterface->StoreState( testUserID, testData, testLAEID, componentID );
	StopAndOutputTimeMeasure( ctx );

    outputStr.Format( "StoreState result: %s", (const char*)res );
	OutputTestText( ctx, outputStr );

	if (res == CGBLCOError::EGBLCOErrorType::GBLCO_OK)
    {
		OutputTestText( ctx, XString("TEST PASSED") );
    }
	else
		OutputTestText( ctx, XString("TEST FAILED") );
}
Ejemplo n.º 10
0
XString pFactory::_getMaterialsAsEnumeration(const TiXmlDocument * doc)
{

	if (!doc)
	{
		return XString("");
	}

	XString result("None=0");
	int counter = 1;


	/************************************************************************/
	/* try to load settings from xml :                                                                      */
	/************************************************************************/
	if ( doc)
	{
		const TiXmlElement *root = getFirstDocElement(doc->RootElement());
		for (const TiXmlNode *child = root->FirstChild(); child; child = child->NextSibling() )
		{
			if ( (child->Type() == TiXmlNode::ELEMENT))
			{
				XString name = child->Value();

				if (!strcmp(child->Value(), "material" ) )
				{
								
					const TiXmlElement *sube = (const TiXmlElement*)child;
					
					const char* matName  = NULL;
					matName = sube->Attribute("name");
					if (matName && strlen(matName))
					{
						if (result.Length())
						{
							result << ",";
						}
						result << matName;
						result << "=" << counter;
						counter ++;
					}
				}
			}
		}
	}

	return result;

}
void GBLStorageManagerStateTestBB::RetrieveStateTestInvalidParameters( CKContext *ctx )
{
    XString         outputStr;
    XString         data;

    CGBLUserID      invalidUser;

    outputStr.Format( "Calling RetrieveState( %d, &<data>, %d, %d )", (int)invalidUser, (int)testLAEID, componentID );
    OutputTestText( ctx, outputStr );

    StartTimeMeasure();
	CGBLCOError res = pInterface->RetrieveState( invalidUser, &data, testLAEID, componentID );
	StopAndOutputTimeMeasure( ctx );

    outputStr.Format( "RetrieveState result: %s", (const char*)res );
	OutputTestText( ctx, outputStr );

    if( res == CGBLCOError::EGBLCOErrorType::GBLCO_LOCAL && (int)res == GBLSM_ERROR_GENERAL_INCORRECT_PARAM )
    {
	    OutputTestText( ctx, XString("TEST PASSED") );
    }
	else
		OutputTestText( ctx, XString("TEST FAILED") );
}
Ejemplo n.º 12
0
int main (int argc, char** argv)
{
     set_new_handler (NoMemory);

     cerr << version_info << endl;
     if (argc > 3)
     {
          // -=- Read in PWAD directory -=- 
          //CPWad wad (XString(argv[1]) + XString(".WAD"));
	  CPWad wad = XString(argv[1]);

          // -=- All OK ? -=-
          if (!wad.Valid ())
          {
               cerr << "Failed Reading PWAD " << argv[1] << endl;
               exit (0);
          }

          XString map (argv[2]);
          int threshold = atoi (argv[3]);

          if ((threshold >= 32) && (threshold <= 4096))
          {
               CReject rej (wad, map);
               if (rej.Valid ())
               {
                    rej.RejectAll ();
                    cout << "Calculating Reject table...." << flush;
                    rej.RejectDefault (threshold);
                    cout << "Done." << endl;
          
                    cout << "Writing Reject table...." << flush;
                    wad.Write (rej.GetRejectData(), map, "REJECT");
                    cout << "Done." << endl;
               }
          }
          else
          {
               cerr << "Treshold must be between 32 and 4096" << endl;
          }
     }
     else
     {
          cerr << "USAGE: REJECT <WADNAME> <MAPNAME> <THRESHOLD>" << endl;
          cerr << "   eg: reject mywad e1m1 600" << endl;
     }
     return 0;
}
Ejemplo n.º 13
0
 AString slurp()
 {
     MString tmp;
     char buf[4096];
     while (true)
     {
         ssize_t rv = rfd.read(buf, sizeof(buf));
         if (rv == -1)
         {
             if (errno != EAGAIN)
                 return "Error, read failed :("_s;
             rv = 0;
         }
         if (rv == 0)
             break;
         tmp += XString(buf + 0, buf + rv, nullptr);
     }
     return AString(tmp);
 }
Ejemplo n.º 14
0
Archivo: magic.cpp Proyecto: qiuhw/tmwa
/// Return a pair of strings, {spellname, parameter}
/// Parameter may be empty.
static
std::pair<XString, XString> magic_tokenise(XString src)
{
    auto seeker = std::find(src.begin(), src.end(), ' ');

    if (seeker == src.end())
    {
        return {src, XString()};
    }
    else
    {
        XString rv1 = src.xislice_h(seeker);
        ++seeker;

        while (seeker != src.end() && *seeker == ' ')
            ++seeker;

        // Note: this very well could be empty
        XString rv2 = src.xislice_t(seeker);
        return {rv1, rv2};
    }
}
Ejemplo n.º 15
0
RecvResult recv_vpacket(Session *s, Packet_Head<id>& head, AString& repeat)
{
    static_assert(id == Packet_Head<id>::PACKET_ID, "Packet_Head<id>::PACKET_ID");
    static_assert(headsize == sizeof(NetPacket_Head<id>), "NetPacket_Head<id>");
    static_assert(id == Packet_Repeat<id>::PACKET_ID, "Packet_Repeat<id>::PACKET_ID");
    static_assert(repeatsize == sizeof(NetPacket_Repeat<id>), "NetPacket_Repeat<id>");
    static_assert(repeatsize == 1, "repeatsize");

    NetPacket_Head<id> net_head;
    std::vector<NetPacket_Repeat<id>> net_repeat;
    RecvResult rv = net_recv_vpacket(s, net_head, net_repeat);
    assert (head.magic_packet_id == Packet_Head<id>::PACKET_ID);
    if (rv == RecvResult::Complete)
    {
        if (!network_to_native(&head, net_head))
            return RecvResult::Error;
        // reinterpret_cast is needed to correctly handle an empty vector
        const char *begin = sign_cast<const char *>(net_repeat.data());
        const char *end = begin + net_repeat.size();
        end = std::find(begin, end, '\0');
        repeat = XString(begin, end, nullptr);
    }
    return rv;
}
Ejemplo n.º 16
0
 RString::RString(LString l)
 : owned(nullptr)
 {
     *this = XString(l);
 }
Ejemplo n.º 17
0
 RString::RString(ZString z)
 : owned(nullptr)
 {
     *this = XString(z);
 }
Ejemplo n.º 18
0
 RString::RString(const SString& s)
 : owned(nullptr)
 {
     *this = XString(s);
 }
Ejemplo n.º 19
0
	::rux::String& Double::ToString( void )
	{
		declare_stack_variable( char , text , 64 );
		::rux::safe_sprintf( text , 64 , "%.2f" , _value );
		return XString( text , XEnumCodePage_UTF8 , 1 , NULL , __FILE__ , __LINE__ )++;
	};
void CGBLStorageManagerTestBBBase::DescribeArray( CKDataArray *fieldValues, CKContext *ctx )
{
	int cols = fieldValues->GetColumnCount();

	int rows = fieldValues->GetRowCount();

	if (cols == 0)
	{
        OutputTestText( ctx, XString("Array contains no columns") );
		return;
	}

	if (rows == 0)
	{
        OutputTestText( ctx, XString("Array contains no rows (no results were returned)") );
		return;
	}

    XString         opStr;
    opStr.Format( "Results (%d columns, %d rows):", cols, rows );
    OutputTestText( ctx, opStr );
	
	for (int row = 0; row < rows; row++)
	{
		for (int i=0; i<cols; i++)
		{
            XString         str;

            str.Format( "%s (", fieldValues->GetColumnName(i) );

			int type = fieldValues->GetColumnType(i);

			if (type == CKARRAYTYPE_PARAMETER)
			{
                str << ctx->GetParameterManager()->ParameterGuidToName(fieldValues->GetColumnParameterGuid(i));
			}
			else
			{
				switch (fieldValues->GetColumnType(i))
				{	
					case CKARRAYTYPE_INT:
						str << "int";
					break;

					case CKARRAYTYPE_FLOAT:
						str << "float";
					break;

					case CKARRAYTYPE_STRING:
						str << "string";
					break;

					case CKARRAYTYPE_OBJECT:
						str << "object";
					break;

					default:
						str << "UNKNOWN TYPE";
					break;
				}
			}
			str << ") : ";
			
			CKSTRING valueField = NULL;
			int labelLength =  fieldValues->GetElementStringValue(row, i, NULL);
			valueField = new CKCHAR[labelLength];
			fieldValues->GetElementStringValue(row, i, valueField);

			str << valueField;

            OutputTestText( ctx, str );

			delete [] valueField;
		}
		//trace << endl;
	}
}
Ejemplo n.º 21
0
void PaintMe(HWND hwnd)
{
	HDC hDC;
	PAINTSTRUCT ps;
	RECT rcWindow;
	HFONT hSysFont, hFont, hFontOld;
	LOGFONT lfFont;
	COLORREF crText;
	TCHAR szTextBuffer[50], szTextBuffer2[50], szInternetTime[5];
	XString xsTextBuffer;
	int iFontSizePixel;
	
	GetWindowRect(hwnd, &rcWindow);
	OffsetRect(&rcWindow, -rcWindow.left, -rcWindow.top);

	hDC = BeginPaint(hwnd, &ps);
	SetBkMode(hDC, TRANSPARENT);

	if (bSelected == TRUE) {
		HBRUSH hBrush = GetSysColorBrush(COLOR_HIGHLIGHT);

		FillRect(hDC, &rcWindow, hBrush);

		DeleteObject(hBrush);
	}

	if (g_iTextSize == 0)
	{
		SHGetUIMetrics(SHUIM_FONTSIZE_PIXEL, &iFontSizePixel, sizeof(iFontSizePixel), NULL);
	}
	else
	{
		iFontSizePixel = MulDiv(g_iTextSize + MIN_FONT_SIZE - 1, DRA::LogPixelsY(), 72);
	}

	hSysFont = (HFONT) GetStockObject(SYSTEM_FONT);
	GetObject(hSysFont, sizeof(LOGFONT), &lfFont);
	//memset(&lfFont, 0, sizeof(LOGFONT));
	lfFont.lfWeight = FW_SEMIBOLD;
	lfFont.lfHeight = -iFontSizePixel;
	hFont = CreateFontIndirect(&lfFont);
	hFontOld = (HFONT) SelectObject(hDC, hFont);

	crText = SendMessage(GetParent(hwnd), TODAYM_GETCOLOR, (WPARAM) TODAYCOLOR_TEXT, NULL);
	SetTextColor(hDC, crText);

	InflateRect(&rcWindow, -2, 0);

	_itot(g_iInternetTime, szInternetTime, 10);
	//_ttoi

	_tcscpy(szTextBuffer, _T("a\0"));
	GetTimeFormat(LOCALE_SYSTEM_DEFAULT, 0, &g_stLocalTime, g_xsLeftFormat.Replace(_T("'"), _T("'''")).GetBuffer(), szTextBuffer, sizeof szTextBuffer);
	GetDateFormat(LOCALE_SYSTEM_DEFAULT, 0, &g_stLocalTime, szTextBuffer, szTextBuffer2, sizeof szTextBuffer2);
	xsTextBuffer = XString(szTextBuffer2).Replace(_T("@"), XString(_T("@"), szInternetTime));
	DrawText(hDC, xsTextBuffer.GetBuffer(), -1, &rcWindow, DT_VCENTER | DT_LEFT);

	_tcscpy(szTextBuffer, _T("a\0"));
	GetTimeFormat(LOCALE_SYSTEM_DEFAULT, 0, &g_stLocalTime, g_xsRightFormat.Replace(_T("'"), _T("'''")).GetBuffer(), szTextBuffer, sizeof szTextBuffer);
	GetDateFormat(LOCALE_SYSTEM_DEFAULT, 0, &g_stLocalTime, szTextBuffer, szTextBuffer2, sizeof szTextBuffer2);
	xsTextBuffer = XString(szTextBuffer2).Replace(_T("@"), XString(_T("@"), szInternetTime));
	DrawText(hDC, xsTextBuffer.GetBuffer(), -1, &rcWindow, DT_VCENTER | DT_RIGHT);

	SelectObject(hDC, hFontOld);
	DeleteObject(hFont);

	EndPaint(hwnd, &ps);
}
Ejemplo n.º 22
0
 RString::RString(const TString& t)
 : owned(nullptr)
 {
     *this = XString(t);
 }
Ejemplo n.º 23
0
XString& XString::operator=(const char* cstr) {
	return (*this = XString(cstr));
}
Ejemplo n.º 24
0
	XString Root(const XString& path)
	{
		size_t index = path.find_last_of("/\\");
		return (XString::npos == index) ? XString() : path.substr(0,index+1);
	}
Ejemplo n.º 25
0
void createSQLControl(XString ss, int nWidth, XString *sDefinition, XString *s, XString *sAdditional, int *X, int nBorderLeft, int nBorderBottom, int nHeight, int nFocusOrder, XString *sSQLControls)
{
  static char ac[1000];

  *sDefinition += "Private SQL";
  *sDefinition += ss;
  *sDefinition += " As ";
  
  bool bLabel = (ss == "Recordset" || ss == "Info");
  bool bTextBox = ss == "GoTo";
  bool bCommandButton = !bLabel && !bTextBox;

  if (bCommandButton) *sDefinition += "CommandButton\n";
  else if (bLabel) *sDefinition += "Label\n";
  else if (bTextBox) *sDefinition += "TextBox\n";

  *s += "SQL"; *s += ss; *s += " = New ";
  
  if (bCommandButton) *s += "CommandButton";
  else if (bLabel) *s += "Label";
  else if (bTextBox) *s += "TextBox";

  *s += "(Me)\n";  
  /*
  *s += "(Me, \"SQL";
  *s += ss;   
  *s += "\")\n";   */

  if (bLabel){
    if (ss == "Recordset"){
      *s += "SQL"; *s += ss; *s += ".Caption = \" Recordset: \"\n";   
    } else {
      *s += "SQL"; *s += ss; *s += ".Caption = \"\"\n";   
    }
  } else if (bTextBox){
    *s += "SQL"; *s += ss; *s += ".Value = \"\"\n";   
  } else if (bCommandButton){
    *s += "SQL"; *s += ss; *s += ".Caption = \"\"\n";   
  }
  *s += "SQL"; *s += ss; *s += ".Name = \""; *s += "SQL"; *s += ss; *s += "\"\n";   
  
  if (bCommandButton){
    *s += "SQL"; *s += ss; *s += ".Icon = \"SQL"; *s += ss; *s += ".png\"\n";   
  }
  *s += "SQL"; *s += ss; *s += ".X = "; sprintf(ac, "%d\n", nBorderLeft + *X); *s += XString(ac);
  *s += "SQL"; *s += ss; *s += ".Y = "; sprintf(ac, "%d\n", nHeight - nBorderBottom - 20); *s += XString(ac);
  *s += "SQL"; *s += ss; *s += ".Width = "; sprintf(ac, "%d\n", nWidth); *s += XString(ac);
  *s += "SQL"; *s += ss; *s += ".Height = 20\n";
  if (bCommandButton || bTextBox){ 
    *s += "SQL"; *s += ss; *s += ".FocusOrder = "; sprintf(ac, "%d\n", nFocusOrder); *s += XString(ac);
  }

  *s += "SQL"; *s += ss; *s += ".Layout = \"RelativeY\"\n\n";

  if (!bLabel){

    *sAdditional += "\nSub SQL";
    *sAdditional += ss;
    *sAdditional += "_OnEvent()\n";

    if (ss == "GoTo"){

      *sAdditional += "Dim n As Integer\n";
      *sAdditional += "n = Val( SQLGoTo.Value)\n";
      *sAdditional += "If n < 1 Or n > Me.Length() Then\n";
      *sAdditional += "  SQLGoTo.SelectAll()\n";
      *sAdditional += "  Return\n";
      *sAdditional += "End If\n";
      *sAdditional += "If Not Me.GoTo(n) Then\n";
      *sAdditional += "  SQLGoTo.Value = \"\" & Me.Position()\n";
      *sAdditional += "End If\n";
      *sAdditional += "\nEnd Sub\n";
    
    } else {
      *sAdditional += "  Me.";
      if (ss == "AddNotFilter"){
        *sAdditional += "AddFilter(\"<>\")\nEnd Sub\n";
      } else if (ss == "SetNotFilter"){
        *sAdditional += "SetFilter(\"<>\")\nEnd Sub\n";
      } else if (ss == "AddNew"){
        *sAdditional += "AddNew()\n";
        if (sSQLControls->isEmpty() || sSQLControls->contains("GoTo")) *sAdditional += "SQLGoTo.Value = \"*\"\n";
        *sAdditional += "\nEnd Sub\n";
      } else {
        *sAdditional += ss;
        *sAdditional += "()\nEnd Sub\n";
      }
    }

    
  }

  *X += nWidth;

}