/*
	Namn		:	support.c

	Programmerare	:	Urban Lindeskog

	Skapad		:	20/03/95
	Senast ändrad	:	28/06/96
*/

#include <proto/exec.h>
#include <proto/locale.h>
#include <proto/dos.h>
#include <proto/intuition.h>
#include <clib/alib_stdio_protos.h>
#include <exec/types.h>
#include <exec/memory.h>
#include <dos/dos.h>
#include <dos/rdargs.h>
#include <dos/dosextens.h>
#include <intuition/intuition.h>
#include <rexx/rxslib.h>
#include <libraries/locale.h>
#include <string.h>
#include <stdlib.h>
#include "protos/support.h"
#include "globdef.h"


 // Globala variabler
//
UBYTE		*StrVarAry[SV_MAXVAR+2];
extern void	*MemPool;


  //			  //	jämför till space eller null
 //	commcmp()	 //
//			//
BOOL	commcmp(UBYTE *strone, UBYTE *strtwo)
{
BOOL	Result=FALSE;
ULONG	Count=0;

	FOREVER
		{
		if(!strone[Count])
			{
			if((strtwo[Count]==32) || !(strtwo[Count]))
				goto Ok;
			else
				goto False;
			}
		if((strtwo[Count] & 223) != strone[Count])
			goto False;

		if(!strtwo)
			goto False;

		Count++;
		}
Ok:
	Result=TRUE;
False:
	return(Result);
}


  //			  //	Leta upp första icke blanktecknet
 //	skipblanks()	 //
//			//
UBYTE	*skipblanks(UBYTE *String)
{
UBYTE	*Result=String;

	while(1)
		{
		if(*Result != ' ' && *Result != '\t')
			return(Result);

		Result++;
		}

}


  //			  //	returnerar TRUE om 'suffix'
 //	strcmpend()	 //	finns i slutet av 'string'
//			//
BOOL strcmpend(UBYTE *string, UBYTE *suffix)
{
ULONG	strsize=strlen(string);
ULONG	sufsize=strlen(suffix);

	if(strsize < sufsize)
		return(FALSE);

	while(strsize && sufsize)
		{
		strsize--;
		sufsize--;

		if(string[strsize] != suffix[sufsize])
			return(FALSE);
		}

	return(TRUE);
}


  //				  //
 //	StripIntuiMessages()	 //
//				//
void	StripIntuiMessages(struct Window *win)
{
struct	MsgPort		*mp=win->UserPort;
struct	IntuiMessage	*msg;
struct	Node		*succ;

	msg = (struct IntuiMessage *)mp->mp_MsgList.lh_Head;

	while(succ = msg->ExecMessage.mn_Node.ln_Succ)
		{
		if(msg->IDCMPWindow == win)
			{
			Remove((struct Node *)msg);
			ReplyMsg((struct Message *)msg);
			}
		msg=(struct IntuiMessage *)succ;
		}
}


  //				  //
 //	CloseWinSafe()		 //
//				//
void	CloseWinSafe(struct Window *RIPWin)
{

	if(RIPWin)
		{
		Forbid();
			StripIntuiMessages(RIPWin);
			RIPWin->UserPort=NULL;
			ModifyIDCMP(RIPWin, 0);
		Permit();
		CloseWindow(RIPWin);
		}
}


  //			  //
 //	SetStrVar()	 //
//			//
UBYTE *SetStrVar(ULONG VarNum, UBYTE *String)
{
UBYTE	*Result=NULL;
ULONG	Len=0, OldLen=0;

	if(VarNum > SV_MAXVAR)
		return(NULL);

	if(String)
		{
		// Går det att återanvända den gamla buffern ?
		// Buffern är 'dubbelt noll-terminerad'
		// efter första noll-tecknet finns en area fram t.o.m
		// det andra nolltecknet som är marginal som strängen
		// kan växa i.

		Len=strlen(String);

		if(StrVarAry[VarNum])
			{
			OldLen=strlen(StrVarAry[VarNum]);
			OldLen+=strlen(StrVarAry[VarNum]+OldLen+1);
			}

		if(StrVarAry[VarNum] && (OldLen >= Len))
			{
			Result=StrVarAry[VarNum];

			strcpy(Result, String);
			memset(Result+Len+1, '©', OldLen-Len);
			Result[OldLen+1]=0;
			}
		else
			{
			if(Result=AllocPooled(MemPool, (Len*2)+2))
				{
				strcpy(Result, String);
				memset(Result+Len+1, '©', Len);
				Result[Len*2+1]=0;

				// Släng den gamla buffern
				FreeStrVar(VarNum);

				StrVarAry[VarNum]=Result;
				}
			}
		}
	else
		{
		FreeStrVar(VarNum);
		}

	return(Result);
}


  //			  //
 //	CatStrVar()	 //
//			//
UBYTE *CatStrVar(ULONG VarNum, UBYTE *String)
{
UBYTE	*Result=NULL;
ULONG	Len=0, OldBufLen=0, OldLen=0;

	if(VarNum > SV_MAXVAR)
		return(NULL);

	if(String)
		{
		// Går det att återanvända den gamla buffern ?
		// Buffern är 'dubbelt noll-terminerad'
		// efter första noll-tecknet finns en area fram t.o.m
		// det andra nolltecknet som är marginal som strängen
		// kan växa i.

		Len=strlen(String);

		if(StrVarAry[VarNum])
			{
			OldLen=OldBufLen=strlen(StrVarAry[VarNum]);
			OldBufLen+=strlen(StrVarAry[VarNum]+OldBufLen+1);
			}

		// Räcker den nuvarande buffern till att hålla
		// den sammanslagna strängen ?
		if(StrVarAry[VarNum] && (OldBufLen >= (OldLen+Len)))
			{
			Result=StrVarAry[VarNum];

			strcpy(Result+OldLen, String);
			memset(Result+OldLen+Len+1, '©', OldBufLen-OldLen-Len);
			Result[OldBufLen+1]=0;
			}
		else
			{
			// Buffer räcker inte för den sammanslaga strängen,
			// allokera en ny buffer...
			if(StrVarAry[VarNum])
				{
				if(Result=AllocPooled(MemPool, OldLen+Len+OldLen+2))
					{
					strcpy(Result, StrVarAry[VarNum]);
					strcpy(Result+OldLen, String);
					memset(Result+OldLen+Len+1, '©', OldLen);
					Result[OldLen+Len+OldLen+1]=0;

					// Släng den gamla buffern
					FreeStrVar(VarNum);

					StrVarAry[VarNum]=Result;
					}
				}
			// Det fanns ingen buffer sedan tidigare...
			else
				{
				Result=SetStrVar(VarNum, String);
				}
			}
		}
	else
		{
		Result=StrVarAry[VarNum];
		}

}


  //			  //
 //	CatSlashStrVar() //
//			//
BOOL CatSlashStrVar(ULONG VarNum)
{
UBYTE	*TempStr;
ULONG	Counter;

	if(TempStr=StrVarAry[VarNum])
		{
		if(Counter=strlen(TempStr))
			{
			switch(TempStr[Counter-1])
				{
				case ':':
				case '/':
				break;

				default:
				if(Counter)
					return((BOOL)CatStrVar(VarNum, "/"));
				}
			}
		}
	else
		{
		return(FALSE);
		}
return(TRUE);
}


  //			  //
 //	FreeStrVar()	 //
//			//
void FreeStrVar(ULONG VarNum)
{
ULONG Len;

	if(StrVarAry[VarNum])
		{
		Len=strlen(StrVarAry[VarNum]);
		Len+=strlen(StrVarAry[VarNum]+Len+1);

		FreePooled(MemPool, StrVarAry[VarNum], Len+2);
		StrVarAry[VarNum]=NULL;
		}
}


  //			  //
 //	InitStrVarAry()	 //
//			//
void InitStrVarAry(void)
{
ULONG	Counter=0;

	while(Counter<SV_MAXVAR)
		{
		StrVarAry[Counter++]=NULL;
		}
}