Path: utzoo!utgpu!news-server.csri.toronto.edu!cs.utexas.edu!uunet!mcsun!isgate!krafla!aries
From: aries@rhi.hi.is (Reynir Hugason)
Newsgroups: comp.sys.mac.programmer
Subject: Re: Resource Files
Message-ID: <1604@krafla.rhi.hi.is>
Date: 29 Mar 90 17:11:59 GMT
References: <3000@dciem.dciem.dnd.ca>
Organization: University of Iceland
Lines: 223

juana@dciem.dciem.dnd.ca (Juana Chang) writes:


>I'm trying to write string values from my application's resource file into
>my program and then modify them and then write the modified values back to
>the resource file.

This should do the trick:

( ------------------------------------------------------------------------ *)
(*	String manipulation unit :-)	 										*)
(*																			*)
(*	Here is a simple unit that handles modifications of STR# resources.		*)
(*																			*)
(*	Enjoy!																	*)
(* ------------------------------------------------------------------------ *)
(* Mimir Reynisson (Aries, inc.)							aries@rhi.hi.is	*)
(* DISCLAIMER: Who me???													*)
(* ------------------------------------------------------------------------ *)

UNIT Strings;

INTERFACE
	USES MemTypes, Resources, Memory, OSUtils, ToolUtils;

	CONST
		kIndexOutofRange = 100;

	{ creation and removal of STR# resources }

	PROCEDURE NewIndStringRes(id: INTEGER; stringName: STR255);
	PROCEDURE RmveIndStringRes(id: INTEGER);

	{ accessing, modifying & deleting STR# entries }

	PROCEDURE NewIndString(str: STR255; id: INTEGER);
	FUNCTION  ReturnIndString(id, index: INTEGER): STR255;
	PROCEDURE SetIndString(str: STR255; id, index: INTEGER);
	PROCEDURE RmveIndString(id, index: INTEGER);

	{ error result of last string operation }

	FUNCTION  GetStrError: INTEGER;

IMPLEMENTATION

	TYPE
		intPtr = ^INTEGER;
		intHdl = ^intPtr;

	VAR
		stringError: INTEGER;

	PROCEDURE NewIndStringRes(id: INTEGER; stringName: STR255);
		VAR
			resHdl: Handle;
		BEGIN
			stringError:=noErr;

			resHdl:=NewHandleClear(SizeOf(INTEGER));
			IF resHdl=NIL THEN
				BEGIN
					stringError:=MemError; EXIT(NewIndStringRes);
				END;

			AddResource(resHdl, 'STR#', id, stringName);	{create it}
			WriteResource(resHdl);							{write it}
			ReleaseResource(resHdl);						{& dispose of it}
		END;

	PROCEDURE RmveIndStringRes(id: INTEGER);
		VAR
			resHdl: Handle;
		BEGIN
			stringError:=noErr;

			resHdl:=GetResource('STR#',id);
			IF ResError=noErr THEN
				BEGIN
					RmveResource(resHdl);
					DisposHandle(resHdl);
					UpdateResFile(CurResFile);
				END;
		END;

	PROCEDURE NewIndString(str: STR255; id: INTEGER);
		VAR
			resHdl: Handle;
			strHdl: StringHandle;
		BEGIN
			stringError:=noErr;

			resHdl:=GetResource('STR#',id);
			IF resHdl=NIL THEN				{if getresource fails - abort}
				BEGIN
					stringError:=ResError; EXIT(NewIndString);
				END;

			HNoPurge(resHdl);						{make it unpurgeable}

			strHdl:=NewString(str);
			IF strHdl=NIL THEN
				BEGIN
					stringError:=MemError; HPurge(resHdl); EXIT(NewIndString);
				END;
			stringError:=HandAndHand(Handle(strHdl),resHdl);	{splice'm}

			DisposHandle(Handle(strHdl));		{& throw temp string away}

			IF stringError<>noErr THEN
				BEGIN
					HPurge(resHdl); EXIT(NewIndString);					
				END;
			intHdl(resHdl)^^:=intHdl(resHdl)^^+1;	{increase string counter}

			ChangedResource(resHdl);							{mark it}
			WriteResource(resHdl);								{write it}

			HPurge(resHdl);										{release it}
		END;

	FUNCTION ReturnIndString(id, index: INTEGER): STR255;
		VAR
			tempStr: STR255;
		BEGIN
			GetIndString(tempStr,id,index); ReturnIndString:=tempStr;
		END;

	PROCEDURE SetIndString(str: STR255; id, index: INTEGER);
		VAR
			resHdl: Handle;
			tempPtr: Ptr;
			i, ignore: INTEGER;
		BEGIN
			stringError:=noErr;

			resHdl:=GetResource('STR#',id);
			IF resHdl=NIL THEN					{if getresource fails - abort}
				BEGIN
					stringError:=ResError; EXIT(SetIndString);
				END;

			IF (intHdl(resHdl)^^ < index) | (index < 1) THEN
				BEGIN
					ReleaseResource(resHdl);
					stringError:=kIndexOutofRange;
					EXIT(SetIndString);
				END;

			HNoPurge(resHdl);							{make it unpurgeable}

			tempPtr:=Ptr(LongInt(@resHdl^^) + SizeOf(INTEGER));

			FOR i:=1 TO index-1 DO
				tempPtr:=Ptr(LongInt(tempPtr) + tempPtr^ + 1);

			{call munger to do string replacement}

			ignore:=Munger(	resHdl,
							LongInt(tempPtr) - LongInt(@resHdl^^),
							NIL,
							tempPtr^+1,
							@str,
							Length(str)+1
						);

			ChangedResource(resHdl);							{mark it}
			WriteResource(resHdl);								{write it}

			HPurge(resHdl);						{make it purgeable again}
		END;

	PROCEDURE RmveIndString(id, index: INTEGER);
		VAR
			resHdl: Handle;
			tempPtr: Ptr;
			i, ignore: INTEGER;
		BEGIN
			stringError:=noErr;

			resHdl:=GetResource('STR#',id);
			IF resHdl=NIL THEN					{if getresource fails - abort}
				BEGIN
					stringError:=ResError; EXIT(RmveIndString);
				END;

			IF (intHdl(resHdl)^^ < index) | (index < 1) THEN
				BEGIN
					ReleaseResource(resHdl);
					stringError:=kIndexOutofRange;
					EXIT(RmveIndString);
				END;

			HNoPurge(resHdl);							{make it unpurgeable}

			tempPtr:=Ptr(LongInt(@resHdl^^) + SizeOf(INTEGER));

			FOR i:=1 TO index-1 DO
				tempPtr:=Ptr(LongInt(tempPtr) + tempPtr^ + 1);

			{call munger to string deletion}

			ignore:=Munger(	resHdl,
							LongInt(tempPtr) - LongInt(@resHdl^^),
							NIL,
							tempPtr^+1,
							Ptr(-1),
							0
						);

			intHdl(resHdl)^^:=intHdl(resHdl)^^-1;	{decrease string counter}

			ChangedResource(resHdl);							{mark it}
			WriteResource(resHdl);								{write it}

			HPurge(resHdl);										{release it}
		END;

	FUNCTION GetStrError: INTEGER;
		BEGIN
			GetStrError:=stringError;
		END;
END.