C++ CChars::AppendSubString方法代码示例

//////////////////////////////////////////////////////////////////////////
//																		//
//																		//
//////////////////////////////////////////////////////////////////////////
BOOL CPreprocessor::ProcessHashInclude(CPreprocessorTokenParser* pcParser)
{
	BOOL						bResult;
	CHeaderFile*				pcIncludeFile;
	CExternalString				cExternalString;
	CChars						sz;
	CHeaderNameMap*				pcHeaderNameMap;
	CHeaderNameMapDirectory*	pcNewDirectory;
	CHeaderNameMapDirectory*	pcCurrentDirectory;
	CChars						szPath;

	pcParser->SkipWhiteSpace();
	bResult = pcParser->GetStringDoubleQuoted(&cExternalString);
	if (!bResult)
	{
		bResult = pcParser->GetQuotedCharacterSequence('<', '>', &cExternalString);
		if (!bResult)
		{
			gcUserError.Set("Error in #include");
			return FALSE;
		}
	}

	FindBestInclude(&cExternalString, FALSE, &pcIncludeFile, &pcHeaderNameMap);
	if (pcIncludeFile)
	{
		pcNewDirectory = mcHeadersStack.Add();
		pcCurrentDirectory = mcHeadersStack.Get(mcHeadersStack.NumElements()-2);

		pcIncludeFile->Path(&szPath);
		pcNewDirectory->Init(pcHeaderNameMap, szPath.Text());
		szPath.Kill();

		bResult = PreprocessBlockSets(pcIncludeFile, mpcCurrentFile);

		pcNewDirectory = mcHeadersStack.Tail();
		pcNewDirectory->Kill();
		mcHeadersStack.Pop();
		return bResult;
	}

	sz.Init("Could not include file ");
	sz.AppendSubString(cExternalString.msz, cExternalString.EndInclusive()+1);
	gcUserError.Set(sz.Text());
	sz.Kill();
	return FALSE;
}

void CPlainTextEditor::Duplicate(void)
{
	int		iStart;
	int		iEnd;
	CChars	szTemp;
	BOOL	bNewLine;

	if (!IsSelected())
	{
		iStart = FindStartOfLine(miEditPos);
		iEnd = FindEndOfLine(miEditPos);
		bNewLine = TRUE;
	}
	else
	{
		if (miSelectionAnchor < miSelectionFloating)
		{
			iStart = miSelectionAnchor;
			iEnd = miSelectionFloating;
		}
		else
		{
			iStart = miSelectionFloating;
			iEnd = miSelectionAnchor;
		}
		bNewLine = FALSE;
	}

	szTemp.Init();
	szTemp.AppendSubString(mszText, iStart, iEnd);
	if (bNewLine)
	{
		szTemp.AppendNewLine();
	}
	mszText.Insert(iStart, &szTemp);
	szTemp.Kill();
	ResetUpDown();
}

//.........这里部分代码省略.........
			pcExisting = NULL;
		}
		else
		{
			pcExisting = GetDefine(&cIdentifier);
			pcDefine = (CDefine*)malloc(sizeof(CDefine));
			pcDefine->Init(mcDefines.mcDefinesTree.GetIndexForNew(cIdentifier.msz, cIdentifier.miLen), mcDefines.muiID, NULL);
		}

		bResult = pcParser->GetExactDecorator('(', FALSE);
		if (bResult)
		{
			pcDefine->SetBracketed(TRUE);
			for (;;)
			{
				bResult = pcParser->GetExactDecorator(')');
				if (bResult)
				{
					break;
				}
				bResult = pcParser->GetIdentifier(&cArgument);
				if (bResult)
				{
					pcDefine->AddArgument(&cArgument);
					pcParser->GetExactDecorator(',');
				}
				else
				{
					//Expected an Identifier.
				}
			}
		}

		bAllowWhiteSpace = FALSE;
		while (pcParser->HasToken())
		{
			bAllocated = FALSE;
			pcToken = pcParser->GetToken();
			if (pcToken->IsText())
			{
				pcText = (CPPText*)pcToken;
				if (pcText->meType == PPT_Identifier)
				{
					iReplaceArg = pcDefine->mcArguments.GetIndex(pcText->mcText.msz, pcText->mcText.miLen);
					if (iReplaceArg != -1)
					{
						pcReplacement = CPPReplacement::Construct(mpcStack->Add(sizeof(CPPReplacement)));
						pcReplacement->Init(pcDefine->miIndex, iReplaceArg, -1, -1);
						pcToken = pcReplacement;
						bAllocated = TRUE;
					}
				}
			}

			if (!pcToken->IsWhiteSpace() || bAllowWhiteSpace)  //Stop leading whitespace from being added.
			{
				bAllowWhiteSpace = TRUE;
				if (!bAllocated)
				{
					pcToken = DuplicatePPToken(pcToken, mpcStack);
				}
				pcDefine->AddReplacmentToken(pcToken);
			}

			pcParser->NextToken();
		}

		bResult = TRUE;
		if (pcExisting)
		{
			if (!pcExisting->Equals(pcDefine))
			{
				//Removing a define will not change the index or the ID of our new define.  Phew.
				RemoveDefine(&cIdentifier);
				pcNew = AddDefine(&cIdentifier, pcDefine);
				if (!pcNew)
				{
					sz.Init("Could not redefine #define ");
					sz.AppendSubString(cIdentifier.msz, cIdentifier.EndInclusive()+1);
					sz.Append(".  Probably index or ID is different.");
					gcUserError.Set(sz.Text());
					sz.Kill();
					bResult = FALSE;
				}
			}
			else
			{
				//Only kill the define if the existing one is identical.
				//pcNew depends on the allocations in the non-identical define case.
				pcDefine->Kill();
			}
			free(pcDefine);
		}
	}
	else
	{
		gcUserError.Set("Could not get an identifier for a #define.  Add one.");
	}
	return bResult;
}

//////////////////////////////////////////////////////////////////////////
//																		//
//																		//
//////////////////////////////////////////////////////////////////////////
void CPreprocessor::DeltaDefines(CArrayNamedDefines* pcDelta, CMemoryStackExtended* pcStack)
{
	int					i;
	CNamedDefine*		pcNamedDefine;
	CDefine*			pcExisting;
	CDefine*			pcDefine;
	CDefine*			pcNew;
	BOOL				bResult;
	CExternalString		cIdentifier;
	CChars				sz;

	for (i = 0; i < pcDelta->NumElements(); i++)
	{
		pcNamedDefine = pcDelta->Get(i);
		cIdentifier.Init(pcNamedDefine->mszName.Text(), pcNamedDefine->mszName.Length());
		if (pcNamedDefine->miFlags & NAMED_DEFINE_FLAGS_UNDEFFED)
		{
			RemoveDefine(&cIdentifier);
		}
		else
		{
			pcDefine = AddDefine(&cIdentifier);
			if (pcDefine)
			{
				pcExisting = NULL;
			}
			else
			{
				pcExisting = GetDefine(pcNamedDefine->mszName.Text());
				pcDefine = (CDefine*)malloc(sizeof(CDefine));
				pcDefine->Init(mcDefines.mcDefinesTree.GetIndexForNew(cIdentifier.msz, cIdentifier.miLen), mcDefines.muiID, NULL);
			}

			pcDefine->mcArguments.Copy(&pcNamedDefine->mcArguments);
			pcDefine->mcReplacement.Copy(&pcNamedDefine->mcReplacement, pcStack);
			pcDefine->SetBracketed(pcNamedDefine->IsBacketed());

			bResult = TRUE;
			if (pcExisting)
			{
				if (!pcExisting->Equals(pcDefine))
				{
					//Removing a define will not change the index or the ID of our new define.  Phew.
					RemoveDefine(&cIdentifier);
					pcNew = AddDefine(&cIdentifier, pcDefine);
					if (!pcNew)
					{
						sz.Init("Could not redefine #define ");
						sz.AppendSubString(cIdentifier.msz, cIdentifier.EndInclusive()+1);
						sz.Append(".  Probably index or ID is different.");
						gcUserError.Set(sz.Text());
						sz.Kill();
						bResult = FALSE;
					}
				}
				else
				{
					//Only kill the define if the existing one is identical.
					//pcNew depends on the allocations in the non-identical define case.
					pcDefine->Kill();
				}
				free(pcDefine);
			}
		}
	}
}