📄 pflprefs.c

📁 PGP8.0源码请认真阅读您的文件包然后写出其具体功能
💻 C
📖 第 1 页 / 共 5 页
字号:
上一页 1 2 3 45
		currentPrefData->flags = flags;
	}

	return err;
}


static PGPError sFindPrefDataByIndex(PGPPrefRef prefRef, 
					PGPPrefIndex prefIndex, 
					PGPPrefData **prefData)
{
	PGPPrefData *searchPrefData;
	
	if (IsntNull(prefData))
		*prefData = NULL;

	PGPValidatePtr(prefData);
	PGPValidatePref(prefRef);

	searchPrefData = prefRef->prefList;
	while (IsntNull(searchPrefData))
	{
		if (searchPrefData->prefIndex == prefIndex)
			break;
		
		sGetNextPrefData(searchPrefData, &searchPrefData);
	}

	*prefData = searchPrefData;
	return kPGPError_NoErr;
}


static PGPError sFindPrefDataByName(PGPPrefRef prefRef,
					char *prefName, 
					PGPPrefData **prefData)
{
	PGPPrefData *searchPrefData;

	if (IsntNull(prefData))
		*prefData = NULL;

	PGPValidatePtr(prefData);
	PGPValidatePtr(prefName);
	PGPValidatePref(prefRef);

	searchPrefData = prefRef->prefList;
	while (IsntNull(searchPrefData))
	{
		if (!pgpCompareStringsIgnoreCase(searchPrefData->prefName, prefName))
			break;

		sGetNextPrefData(searchPrefData, &searchPrefData);
	}

	*prefData = searchPrefData;
	return kPGPError_NoErr;
}


static PGPError sFreePref(PGPPrefRef prefRef)
{
	PGPPrefData *currentPrefData;
	PGPPrefData *tempPrefData;
	PGPMemoryMgrRef memoryMgr;

	PGPValidatePref(prefRef);

	currentPrefData = prefRef->prefList;
	while (IsntNull(currentPrefData))
	{
		sGetNextPrefData(currentPrefData, &tempPrefData);
		sRemovePrefData(prefRef, currentPrefData);
		currentPrefData = tempPrefData;
	}

	if (pflFileSpecIsValid(prefRef->prefFileSpec))
		PFLFreeFileSpec(prefRef->prefFileSpec);
	
	if (prefRef->userValueFreeProc) {
		prefRef->userValueFreeProc(prefRef->userValue);
	}

	memoryMgr = prefRef->memoryMgr;
	PGPFreeData( prefRef);
	return kPGPError_NoErr;
}


static PGPError sAddPrefData(PGPPrefRef prefRef, 
					PGPPrefData *prefData)
{
	PGPValidatePref(prefRef);
	PGPValidatePtr(prefData);

	if (IsNull(prefRef->prefList))
		prefRef->prefList = prefData;

	if (IsntNull(prefRef->prefListEnd))
		prefRef->prefListEnd->nextPrefData = prefData;

	prefData->lastPrefData	= prefRef->prefListEnd;
	prefData->nextPrefData	= NULL;
	prefRef->prefListEnd	= prefData;
	return kPGPError_NoErr;
}


static PGPError sRemovePrefData(PGPPrefRef prefRef, 
					PGPPrefData *prefData)
{
	PGPValidatePref(prefRef);
	PGPValidatePtr(prefData);

	sFreePrefData(prefData, TRUE);

	if (IsntNull(prefData->nextPrefData))
		prefData->nextPrefData->lastPrefData = prefData->lastPrefData;

	if (IsntNull(prefData->lastPrefData))
		prefData->lastPrefData->nextPrefData = prefData->nextPrefData;

	if (prefRef->prefList == prefData)
		prefRef->prefList = prefData->nextPrefData;
	
	if (prefRef->prefListEnd == prefData)
		prefRef->prefListEnd = prefData->lastPrefData;

	PGPFreeData(prefData);
	return kPGPError_NoErr;
}


static PGPError sGetNextPrefData(const PGPPrefData *currentPrefData,
					PGPPrefData **nextPrefData)
{
	if (IsntNull(nextPrefData))
		*nextPrefData = NULL;

	PGPValidatePtr(nextPrefData);
	PGPValidatePtr(currentPrefData);

	*nextPrefData = currentPrefData->nextPrefData;
	return kPGPError_NoErr;
}


	static PGPError
sReadPrefData(
	PGPIORef			prefIO,
	PGPPrefData *		prefData,
	PGPUInt32 *			arrayIndex )
{
	PGPMemoryMgrRef		memoryMgr;
	PGPSize				bytesRead;
	char *				lineBuffer;
	char *				equalSign;
	char *				flagMarker;
	char *				hexMarker;
	char *				value;
	char *				indexNum;
	PGPBoolean			gotValue;
	PGPBoolean			openQuote;
	PGPUInt32			lineSize = 4096;
	PGPUInt32			index;
	PGPUInt32			commentsSize;
	PGPFileOffset		position;
	PGPError			err = kPGPError_NoErr;

	memoryMgr = PGPIOGetMemoryMgr(prefIO);

	lineBuffer = (char *) PGPNewData( memoryMgr, lineSize,
							kPGPMemoryMgrFlags_Clear);
	if( IsNull( lineBuffer ) )
	{
		err = kPGPError_OutOfMemory;
		goto done;
	}
	commentsSize = 0;
	index = 0;
	gotValue = FALSE;
	prefData->prefIndex = kPGPInvalidPrefIndex;
	prefData->prefType = kPGPPrefType_Invalid;
	*arrayIndex = 0;

	do
	{
		do
		{
			while( index + 1024 > lineSize )
			{
				lineSize += 1024;
				err = PGPReallocData( memoryMgr, (void **) &lineBuffer, lineSize,
						kPGPMemoryMgrFlags_Clear );
				if( IsPGPError( err ) )
					goto done;
			}
			err = PGPIORead(prefIO, 1, &(lineBuffer[index]), &bytesRead);

			if ((index > 0) && IsLineEndChar(lineBuffer[index]))
			{
				while (IsWhitespace(lineBuffer[index-1]) && (index > 2))
				{
					index--;
					lineBuffer[index] = lineBuffer[index+1];
				}

				if ((lineBuffer[index-1] == '\\') && (lineBuffer[0] != '#'))
				{
					index--;

					while (index > 0)
					{
						if (!IsWhitespace(lineBuffer[index-1]))
							break;

						index--;
					}

					do
					{
						err = PGPIORead(prefIO, 1, &(lineBuffer[index]),
								&bytesRead);
					}
					while (IsntPGPError(err) && 
							IsLineEndChar(lineBuffer[index]));

					if (IsntPGPError(err))
					{
						if ((lineBuffer[index] == '\"') &&
							(lineBuffer[index-1] == '\"'))
						{
							index--;
							err = PGPIORead(prefIO, 1, &(lineBuffer[index]),
									&bytesRead);
						}
					}

				}
			}
			
			index++;
		}
		while (IsntPGPError(err) && !IsLineEndChar(lineBuffer[index-1]) &&
				(index < lineSize));

		index--;
		do
		{
			err = PGPIORead(prefIO, 1, &(lineBuffer[index]), &bytesRead);
		}
		while (IsntPGPError(err) && IsLineEndChar(lineBuffer[index]));

		if (err == kPGPError_EOF)
			err = kPGPError_NoErr;
		else if (IsPGPError(err))
			break;
		else
		{
			PGPIOGetPos(prefIO, &position);
			position--;
			PGPIOSetPos(prefIO, position);
		}

		lineBuffer[index] = 0;

		switch (lineBuffer[0])
		{
		case '#':
			err = PGPReallocData(memoryMgr, (void **) &(prefData->prefComments),
					commentsSize + index + strlen(kPGPLineEndString) + 1, 0);
			
			if (IsntPGPError(err))
			{
				pgpCopyMemory(lineBuffer, 
					&(prefData->prefComments[commentsSize]),
					index);
				pgpCopyMemory(kPGPLineEndString, 
					&(prefData->prefComments[commentsSize+index]),
					strlen(kPGPLineEndString)+1);
				commentsSize += index + strlen(kPGPLineEndString);
			}
			break;

		case ' ':
		case '\r':
		case '\n':
			break;

		default:
			equalSign = strchr(lineBuffer, '=');
			
			if (IsntNull(equalSign))
			{
				indexNum = equalSign - 1;
				while ((*indexNum >= '0') && (*indexNum <= '9'))
					indexNum--;

				indexNum++;
				if (indexNum != equalSign)
					sscanf(indexNum, "%d", arrayIndex);

				prefData->prefName = (char *) PGPNewData(memoryMgr,
												equalSign - lineBuffer + 1,
												kPGPMemoryMgrFlags_Clear);

				if (IsntNull(prefData->prefName))
				{
					pgpCopyMemory(lineBuffer, prefData->prefName,
						indexNum - lineBuffer);
				}
				else
					err = kPGPError_OutOfMemory;

				if (IsntPGPError(err))
				{
					flagMarker = &(equalSign[strlen(equalSign) - 1]);
					openQuote = FALSE;
					while (flagMarker > equalSign)
					{
						if (*flagMarker == '\"')
							openQuote = !openQuote;

						if ((*flagMarker == ';') && !openQuote)
							break;

						flagMarker--;
					}

					if (flagMarker == equalSign)
						flagMarker = &(lineBuffer[index]);

					do
						flagMarker--;
					while (IsWhitespace(*flagMarker));
					
					flagMarker++;

					if (index != (PGPUInt32)(equalSign - lineBuffer + 1))
					{
						value = (char *) PGPNewData(memoryMgr,
											flagMarker - equalSign,
											kPGPMemoryMgrFlags_Clear);

						if (IsntNull(value))
							pgpCopyMemory(equalSign+1, value,
								flagMarker - equalSign - 1);
						else
							err = kPGPError_OutOfMemory;
					}
					else
						value = NULL;
				}
				
				if (IsntPGPError(err))
				{
					prefData->flags = 0;
					
					if (flagMarker != &(lineBuffer[index]))
					{
						hexMarker = strchr(flagMarker, 'x');
						if (IsNull(hexMarker))
							hexMarker = strchr(flagMarker, 'X');

						if (IsntNull(hexMarker))
							prefData->flags = pgpHexToPGPUInt32(hexMarker+1);
						else
						{
							flagMarker += strcspn(flagMarker, "01234567890");
							sscanf(flagMarker, "%d", &(prefData->flags));
						}
					}

					if (IsntNull(value))
						prefData->dataLength = strlen(value) + 1;
					else
						prefData->dataLength = 0;

					prefData->data.raw = value;
					gotValue = TRUE;
				}
			}
		}

		index = 0;
	}
	while (IsntPGPError(err) && !PGPIOIsAtEOF(prefIO) && !gotValue);
done:
	if( IsntNull( lineBuffer ) )
		(void) PGPFreeData( lineBuffer );
	return err;
}


	static PGPError
sWritePrefData(
	PGPIORef		prefIO,
	PGPPrefData		*prefData,
	PGPUInt32		wrap)
{
	PGPMemoryMgrRef memoryMgr;
	PGPUInt32		begin;
	PGPUInt32		end;
	PGPUInt32		index;
	PGPError		err = kPGPError_NoErr;

	memoryMgr = PGPIOGetMemoryMgr(prefIO);

	begin = 0;
	end = 0;

	if (IsntNull(prefData->prefComments))
	{
		err = PGPIOWrite(prefIO, strlen(kPGPLineEndString), 
				kPGPLineEndString);

		while (IsntPGPError(err) && (begin < strlen(prefData->prefComments)))
		{
			while (!IsLineEndChar(prefData->prefComments[end]) &&
					(prefData->prefComments[end] != '\0'))
				end++;

			err = PGPIOWrite(prefIO, end - begin, 
					&(prefData->prefComments[begin]));

			if (IsPGPError(err))
				break;

			while (IsLineEndChar(prefData->prefComments[end]) &&
					(prefData->prefComments[end] != '\0'))
				end++;

			begin = end;

			err = PGPIOWrite(prefIO, strlen(kPGPLineEndString),
					kPGPLineEndString);
		}
	}

	if (prefData->prefType == kPGPPrefType_Array)
	{
		for (index=0; index<prefData->data.a->numElements; index++)
		{
			err = sWritePrefLine(prefIO, prefData, index, wrap);

			if (IsntPGPError(err))
				err = PGPIOWrite(prefIO, strlen(kPGPLineEndString), 
						kPGPLineEndString);

			if (IsPGPError(err))
				break;
		}
	}
	else
	{
		err = sWritePrefLine(prefIO, prefData, 0, wrap);
	
		if (IsntPGPError(err))
			err = PGPIOWrite(prefIO, strlen(kPGPLineEndString), 
					kPGPLineEndString);
	}

	return err;
}


	static PGPError
sWritePrefLine(
	PGPIORef			prefIO,
	PGPPrefData *		prefData,
	PGPUInt32			index,
	PGPUInt32			wrap )
{
	PGPMemoryMgrRef		memoryMgr;
	PGPUInt32			begin;
	PGPUInt32			end;
	PGPUInt32			length;
	PGPUInt32			count;
	PGPUInt32			comma;
	PGPUInt32			formattedSize = 4096;
	PGPUInt32			hexSize = 4096;
	char *				formattedLine = NULL;
	char *				hexString = NULL;
	char				number[20];
	PGPBoolean			openQuote;
	PGPPrefDataUnion	data;
	PGPPrefType			type;
	PGPSize				dataLength;
	PGPPrefStructMember	*member;
	PGPError			err = kPGPError_NoErr;

	memoryMgr = PGPIOGetMemoryMgr(prefIO);

	hexString = (char *) PGPNewData(memoryMgr, hexSize,
								kPGPMemoryMgrFlags_Clear);
	formattedLine = (char *) PGPNewData(memoryMgr, formattedSize,
								kPGPMemoryMgrFlags_Clear);
	if( IsNull( hexString ) || IsNull( formattedLine ) )
	{
		err = kPGPError_OutOfMemory;
		goto done;
	}
	if (IsntNull(prefData->prefName))
	{
		if (prefData->prefType == kPGPPrefType_Array)
			sprintf(formattedLine, "%s%d=", prefData->prefName, index+1);
		else
			sprintf(formattedLine, "%s=", prefData->prefName);
	}
	else
		goto done;

	err = PGPIOWrite(prefIO, strlen(formattedLine), formattedLine);

	if (prefData->prefType == kPGPPrefType_Array)
	{
		type = prefData->data.a->type;
		dataLength = prefData->data.a->elements[index].size;

		switch (type)
		{
		case kPGPPrefType_Boolean:
			data.b = (PGPBoolean)(size_t) prefData->data.a->elements[index].data;
			break;

		case kPGPPrefType_Number:
			data.i = (PGPUInt32) prefData->data.a->elements[index].data;
			break;

		case kPGPPrefType_String:
			data.str = (char *) prefData->data.a->elements[index].data;
			break;

		case kPGPPrefType_Byte:
			data.p = (PGPByte *) prefData->data.a->elements[index].data;
			break;

		case kPGPPrefType_Struct:
			data.strct = (PGPPrefStruct *) 
							prefData->data.a->elements[index].data;
			break;

		default:
			break;
		}
	}
	else
	{
		data = prefData->data;
		type = prefData->prefType;
		dataLength = prefData->dataLength;
	}

	if (IsntPGPError(err))
	{
		switch (type)
		{
		case kPGPPrefType_Boolean:
			if (data.b)
				strcpy(formattedLine, "TRUE");
			else
				strcpy(formattedLine, "FALSE");
			break;

		case kPGPPrefType_Number:
			sprintf(formattedLine, "%d", data.i);
			break;

		case kPGPPrefType_String:
			sprintf(
上一页 1 2 3 45
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -