📄 pflpreftypes.c

📁 PGP8.0源码请认真阅读您的文件包然后写出其具体功能
💻 C
📖 第 1 页 / 共 2 页
字号:
上一页 12
				(void **) &(prefArray->elements),
				sizeof(PGPPrefArrayElement) * (arrayIndex+1),
				0);

		if (IsPGPError(err))
			return err;
	}

	if (IsntNull(prefArray->elements[arrayIndex].data))
		PGPFreeData(prefArray->elements[arrayIndex].data);

	prefArray->elements[arrayIndex].data = PGPNewData(memoryMgr,
												strlen(string) + 1,
												kPGPMemoryMgrFlags_Clear);

	if (IsNull(prefArray->elements[arrayIndex].data))
		return kPGPError_OutOfMemory;

	pgpCopyMemory(string, prefArray->elements[arrayIndex].data,
		strlen(string) + 1);

	prefArray->dirty = TRUE;
	return kPGPError_NoErr;
}


PGPError PGPGetPrefArrayByte(PGPPrefRef prefRef,
									PGPPrefArray *prefArray,
									PGPUInt32 arrayIndex,
									PGPSize *dataLength,
									void **data)
{
	PGPMemoryMgrRef memoryMgr;

	if (IsntNull(dataLength))
		*dataLength = 0;
	if (IsntNull(data))
		*data = NULL;

	PGPValidatePref(prefRef);
	PGPValidatePtr(prefArray);
	PGPValidatePtr(dataLength);
	PGPValidatePtr(data);

	if (prefArray->type != kPGPPrefType_Byte)
		return kPGPError_BadParams;

	if (arrayIndex >= prefArray->numElements)
		return kPGPError_BadParams;

	PGPPeekPrefMemoryMgr(prefRef, &memoryMgr);

	if (IsntNull(prefArray->elements[arrayIndex].data))
	{
		*data = PGPNewData(memoryMgr,
					prefArray->elements[arrayIndex].size,
					kPGPMemoryMgrFlags_Clear);

		if (IsNull(*data))
			return kPGPError_OutOfMemory;

		*dataLength = prefArray->elements[arrayIndex].size;

		pgpCopyMemory(prefArray->elements[arrayIndex].data, *data,
			prefArray->elements[arrayIndex].size);
	}

	return kPGPError_NoErr;
}


PGPError PGPSetPrefArrayByte(PGPPrefRef prefRef,
									PGPPrefArray *prefArray,
									PGPUInt32 arrayIndex,
									PGPSize dataLength,
									void *data)
{
	PGPMemoryMgrRef memoryMgr;
	PGPError err = kPGPError_NoErr;

	PGPValidatePref(prefRef);
	PGPValidatePtr(prefArray);

	if (prefArray->type != kPGPPrefType_Byte)
		return kPGPError_BadParams;

	PGPPeekPrefMemoryMgr(prefRef, &memoryMgr);

	if (arrayIndex >= prefArray->numElements)
	{
		err = PGPReallocData(memoryMgr,
				(void **) &(prefArray->elements),
				sizeof(PGPPrefArrayElement) * (arrayIndex+1),
				0);

		if (IsPGPError(err))
			return err;
		prefArray->numElements = arrayIndex + 1;
	}

	if (IsntNull(prefArray->elements[arrayIndex].data))
	{
		PGPFreeData(prefArray->elements[arrayIndex].data);
		prefArray->elements[arrayIndex].data = NULL;
	}

	if (IsNull(data))
		return kPGPError_NoErr;

	prefArray->elements[arrayIndex].data = PGPNewData(memoryMgr,
												dataLength,
												kPGPMemoryMgrFlags_Clear);

	if (IsNull(prefArray->elements[arrayIndex].data))
		return kPGPError_OutOfMemory;

	pgpCopyMemory(data, prefArray->elements[arrayIndex].data,
		dataLength);

	prefArray->elements[arrayIndex].size = dataLength;
	prefArray->dirty = TRUE;

	return kPGPError_NoErr;
}


PGPError PGPGetPrefArrayStruct(PGPPrefRef prefRef,
									PGPPrefArray *prefArray,
									PGPUInt32 arrayIndex,
									PGPPrefStruct **prefStruct)
{
	if (IsntNull(prefStruct))
		*prefStruct = NULL;

	PGPValidatePref(prefRef);
	PGPValidatePtr(prefArray);
	PGPValidatePtr(prefStruct);

	if (prefArray->type != kPGPPrefType_Struct)
		return kPGPError_BadParams;

	if (arrayIndex >= prefArray->numElements)
		return kPGPError_BadParams;

	*prefStruct = (PGPPrefStruct *) prefArray->elements[arrayIndex].data;
	return kPGPError_NoErr;
}


PGPError PGPSetPrefArrayStruct(PGPPrefRef prefRef,
									PGPPrefArray *prefArray,
									PGPUInt32 arrayIndex,
									PGPPrefStruct *prefStruct)
{
	PGPMemoryMgrRef memoryMgr;
	PGPError err = kPGPError_NoErr;

	PGPValidatePref(prefRef);
	PGPValidatePtr(prefArray);
	PGPValidatePtr(prefStruct);

	if (prefArray->type != kPGPPrefType_Struct)
		return kPGPError_BadParams;

	PGPPeekPrefMemoryMgr(prefRef, &memoryMgr);

	if (arrayIndex >= prefArray->numElements)
	{
		err = PGPReallocData(memoryMgr,
				(void **) &(prefArray->elements),
				sizeof(PGPPrefArrayElement) * (arrayIndex+1),
				0);

		if (IsPGPError(err))
			return err;
		prefArray->numElements = arrayIndex + 1;
	}

	if (prefStruct != (PGPPrefStruct *) prefArray->elements[arrayIndex].data)
	{
		if (IsntNull(prefArray->elements[arrayIndex].data))
			PGPFreePrefStruct(prefArray->elements[arrayIndex].data);

		prefArray->elements[arrayIndex].data = prefStruct;
		prefStruct->dirty = FALSE;
	}

	prefArray->dirty = TRUE;
	return kPGPError_NoErr;
}


PGPError PGPGetPrefStructBoolean(PGPPrefRef prefRef,
									PGPPrefStruct *prefStruct,
									PGPUInt16 memberIndex,
									PGPBoolean *data)
{
	PGPValidatePref(prefRef);
	PGPValidatePtr(prefStruct);
	PGPValidatePtr(data);

	if (memberIndex >= prefStruct->numMembers)
		return kPGPError_BadParams;

	if (prefStruct->members[memberIndex].type != kPGPPrefType_Boolean)
		return kPGPError_BadParams;

	*data = (PGPBoolean)(size_t) prefStruct->members[memberIndex].data;
	return kPGPError_NoErr;
}


PGPError PGPSetPrefStructBoolean(PGPPrefRef prefRef,
									PGPPrefStruct *prefStruct,
									PGPUInt16 memberIndex,
									PGPBoolean data)
{
	PGPValidatePref(prefRef);
	PGPValidatePtr(prefStruct);

	if (memberIndex >= prefStruct->numMembers)
		return kPGPError_BadParams;

	if (prefStruct->members[memberIndex].type != kPGPPrefType_Boolean)
		return kPGPError_BadParams;

	prefStruct->members[memberIndex].data = (void *)(size_t) data;
	prefStruct->dirty = TRUE;
	return kPGPError_NoErr;
}


PGPError PGPGetPrefStructNumber(PGPPrefRef prefRef,
									PGPPrefStruct *prefStruct,
									PGPUInt16 memberIndex,
									PGPUInt32 *data)
{
	PGPValidatePref(prefRef);
	PGPValidatePtr(prefStruct);
	PGPValidatePtr(data);

	if (memberIndex >= prefStruct->numMembers)
		return kPGPError_BadParams;

	if (prefStruct->members[memberIndex].type != kPGPPrefType_Number)
		return kPGPError_BadParams;

	*data = (PGPUInt32) prefStruct->members[memberIndex].data;
	return kPGPError_NoErr;
}


PGPError PGPSetPrefStructNumber(PGPPrefRef prefRef,
									PGPPrefStruct *prefStruct,
									PGPUInt16 memberIndex,
									PGPUInt32 data)
{
	PGPValidatePref(prefRef);
	PGPValidatePtr(prefStruct);

	if (memberIndex >= prefStruct->numMembers)
		return kPGPError_BadParams;

	if (prefStruct->members[memberIndex].type != kPGPPrefType_Number)
		return kPGPError_BadParams;

	prefStruct->members[memberIndex].data = (void *) data;
	prefStruct->dirty = TRUE;
	return kPGPError_NoErr;
}


PGPError PGPGetPrefStructString(PGPPrefRef prefRef,
									PGPPrefStruct *prefStruct,
									PGPUInt16 memberIndex,
									char **string)
{
	PGPMemoryMgrRef memoryMgr;

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

	PGPValidatePref(prefRef);
	PGPValidatePtr(prefStruct);
	PGPValidatePtr(string);

	if (memberIndex >= prefStruct->numMembers)
		return kPGPError_BadParams;

	if (prefStruct->members[memberIndex].type != kPGPPrefType_String)
		return kPGPError_BadParams;

	PGPPeekPrefMemoryMgr(prefRef, &memoryMgr);

	if (IsntNull(prefStruct->members[memberIndex].data))
	{
		*string = (char *) PGPNewData(memoryMgr,
							strlen(prefStruct->members[memberIndex].data)+1,
							kPGPMemoryMgrFlags_Clear);

		if (IsNull(*string))
			return kPGPError_OutOfMemory;

		pgpCopyMemory(prefStruct->members[memberIndex].data, *string,
			strlen(prefStruct->members[memberIndex].data) + 1);
	}

	return kPGPError_NoErr;
}


PGPError PGPSetPrefStructString(PGPPrefRef prefRef,
									PGPPrefStruct *prefStruct,
									PGPUInt16 memberIndex,
									char *string)
{
	PGPMemoryMgrRef memoryMgr;

	PGPValidatePref(prefRef);
	PGPValidatePtr(prefStruct);
	PGPValidatePtr(string);

	if (memberIndex >= prefStruct->numMembers)
		return kPGPError_BadParams;

	if (prefStruct->members[memberIndex].type != kPGPPrefType_String)
		return kPGPError_BadParams;

	if (IsntNull(prefStruct->members[memberIndex].data))
		PGPFreeData(prefStruct->members[memberIndex].data);

	PGPPeekPrefMemoryMgr(prefRef, &memoryMgr);

	prefStruct->members[memberIndex].data = PGPNewData(memoryMgr,
												strlen(string) + 1,
												kPGPMemoryMgrFlags_Clear);

	if (IsNull(prefStruct->members[memberIndex].data))
		return kPGPError_OutOfMemory;

	pgpCopyMemory(string, prefStruct->members[memberIndex].data,
		strlen(string) + 1);

	prefStruct->dirty = TRUE;
	return kPGPError_NoErr;
}


PGPError PGPGetPrefStructByte(PGPPrefRef prefRef,
									PGPPrefStruct *prefStruct,
									PGPUInt16 memberIndex,
									PGPSize *dataLength,
									void **data)
{
	PGPMemoryMgrRef memoryMgr;

	if (IsntNull(dataLength))
		*dataLength = 0;
	if (IsntNull(data))
		*data = NULL;

	PGPValidatePref(prefRef);
	PGPValidatePtr(prefStruct);
	PGPValidatePtr(dataLength);
	PGPValidatePtr(data);

	if (memberIndex >= prefStruct->numMembers)
		return kPGPError_BadParams;

	if (prefStruct->members[memberIndex].type != kPGPPrefType_Byte)
		return kPGPError_BadParams;

	PGPPeekPrefMemoryMgr(prefRef, &memoryMgr);

	if (IsntNull(prefStruct->members[memberIndex].data))
	{
		*data = PGPNewData(memoryMgr,
					prefStruct->members[memberIndex].size,
					kPGPMemoryMgrFlags_Clear);

		if (IsNull(*data))
			return kPGPError_OutOfMemory;

		*dataLength = prefStruct->members[memberIndex].size;

		pgpCopyMemory(prefStruct->members[memberIndex].data, *data,
			prefStruct->members[memberIndex].size);
	}

	return kPGPError_NoErr;
}


PGPError PGPSetPrefStructByte(PGPPrefRef prefRef,
									PGPPrefStruct *prefStruct,
									PGPUInt16 memberIndex,
									PGPSize dataLength,
									void *data)
{
	PGPMemoryMgrRef memoryMgr;

	PGPValidatePref(prefRef);
	PGPValidatePtr(prefStruct);

	if (memberIndex >= prefStruct->numMembers)
		return kPGPError_BadParams;

	if (prefStruct->members[memberIndex].type != kPGPPrefType_Byte)
		return kPGPError_BadParams;

	if (IsntNull(prefStruct->members[memberIndex].data))
	{
		PGPFreeData(prefStruct->members[memberIndex].data);
		prefStruct->members[memberIndex].data = NULL;
	}

	if (IsNull(data))
		return kPGPError_NoErr;

	PGPPeekPrefMemoryMgr(prefRef, &memoryMgr);

	prefStruct->members[memberIndex].data = PGPNewData(memoryMgr,
												dataLength,
												kPGPMemoryMgrFlags_Clear);

	if (IsNull(prefStruct->members[memberIndex].data))
		return kPGPError_OutOfMemory;

	pgpCopyMemory(data, prefStruct->members[memberIndex].data,
		dataLength);

	prefStruct->members[memberIndex].size = dataLength;
	prefStruct->dirty = TRUE;

	return kPGPError_NoErr;
}


/*__Editor_settings____

	Local Variables:
	tab-width: 4
	End:
	vi: ts=4 sw=4
	vim: si
_____________________*/
上一页 12
⌨️ 快捷键说明

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