CnC_Remastered_Collection

DIPTHONG.CPP (13688B)

---

 //
 // Copyright 2020 Electronic Arts Inc.
 //
 // TiberianDawn.DLL and RedAlert.dll and corresponding source code is free 
 // software: you can redistribute it and/or modify it under the terms of 
 // the GNU General Public License as published by the Free Software Foundation, 
 // either version 3 of the License, or (at your option) any later version.
 
 // TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 
 // in the hope that it will be useful, but with permitted additional restrictions 
 // under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
 // distributed with this program. You should have received a copy of the 
 // GNU General Public License along with permitted additional restrictions 
 // with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
 
 /* $Header: g:/library/source/rcs/./dipthong.c 1.15 1994/05/20 15:35:17 joe_bostic Exp $ */
 /***************************************************************************
  **   C O N F I D E N T I A L --- W E S T W O O D   A S S O C I A T E S   **
  ***************************************************************************
  *                                                                         *
  *                 Project Name : Westwood Library                         *
  *                                                                         *
  *                    File Name : DIPTHONG.C                               *
  *                                                                         *
  *                   Programmer : Joe L. Bostic                            *
  *                                                                         *
  *                   Start Date : February 23, 1992                        *
  *                                                                         *
  *                  Last Update : February 13, 1995 [BWG]                  *
  *                                                                         *
  * DIGRAM or DIATOMIC encoding is the correct term for this method.        *
  * This is a fixed dictionary digram encoding optimized for English text.  *
  *                                                                         *
  *-------------------------------------------------------------------------*
  * Functions:                                                              *
  *   Extract_String -- Extracts a string pointer from a string data block. *
  *   UnDip_Text -- Undipthongs a text string into specified buffer.        *
  *   Dip_Text -- Compresses text by using dipthonging.                     *
  *   Fixup_Text -- Converts dipthonged foreign text into normal text.      *
  * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
 //#include	"function.h"
 //#include	"ems.h"
 #include <keyboard.h>
 #include "dipthong.h"
 
 /***************************************************************************
  * Fixup_Text -- Converts dipthonged foreign text into normal text.        *
  *                                                                         *
  *    Takes text that has been processed (or undipped) to hold foriegn     *
  *    language character pairs (needed for Window_Print) and converts it   *
  *    so that Text_Print will print it properly.  Typically this would be  *
  *    used after text has been undipped but before it will be Text_Printed.*
  *    Text that is to be Window_Printed doesn't and mustn't have its text  *
  *    processed by this routine.                                           *
  *                                                                         *
  * INPUT:   source   -- Pointer to the source string to process.           *
  *                                                                         *
  *          dest     -- Destination buffer to hold the processed string.   *
  *                                                                         *
  * OUTPUT:  none                                                           *
  *                                                                         *
  * WARNINGS:   This routine will only reduce the size of the string if it  *
  *             modifies it at all.  Because of this it is quite legal to   *
  *             pass the same pointers to this routine so that it will      *
  *             modify the string "in place".                               *
  *                                                                         *
  * HISTORY:                                                                *
  *   08/13/1993 JLB : Created.                                             *
  *   10/06/1994 JLB : Handles source string in EMS.                        *
  *=========================================================================*/
 void Fixup_Text(char const *source, char *dest)
 {
 	if (source && dest) {
 		char const 	*src;
 		char			temp;
 
 		src = source;
 		while (*src) {
 			if (*src == KA_EXTEND) {
 				src++;
 				temp = *src++;
 				temp += 127;
 				*dest++ = temp;
 			} else {
 				*dest++ = *src++;
 			}
 		}
 		*dest = '\0';
 
 	}
 }
 
 
 /***************************************************************************
  * Dip_Text -- Compresses text by using dipthonging.                       *
  *                                                                         *
  *    This routine is used to compress text by using dipthonging.  Text    *
  *    that is compressed in this fashion usually is reduced in size by     *
  *    approximately 40%.                                                   *
  *                                                                         *
  * INPUT:   source   -- Pointer to the source string to compress.          *
  *                                                                         *
  *          dest     -- Pointer to the buffer that will hold the dipthong  *
  *                      text output.                                       *
  *                                                                         *
  * OUTPUT:  Returns the number of bytes output into the output buffer.     *
  *                                                                         *
  * WARNINGS:   none                                                        *
  *                                                                         *
  * HISTORY:                                                                *
  *   08/13/1993 JLB : Created.                                             *
  *=========================================================================*/
 int Dip_Text(char const *source, char *dest)
 {
 	unsigned char	first,		// First character in pair.
 						next;			// Second character in pair.
 	int				common,		// Common character index.
 						dipthong;	// Dipthong character index.
 
 	unsigned long length=0;		// Length of output string
 
 	first = *source++;
 	next = *source;
 	while (first) {
 
 		if (first > 127) {
 
 			/*
 			**	Characters greater than 127 cannot be dipthonged.  They must
 			**	be preceeded with an extended character code.
 			*/
 			*dest++ = (char)KA_EXTEND;
 			first -= 127;
 			length++;
 
 		} else {
 
 			/*
 			**	Normal characters can be dipthonged.  First see if there is a
 			**	match in the Common table.
 			*/
 			for (common = 0; common < 16; common++) {
 				if (Common[common] == first) {
 
 					/*
 					**	Common character found.  See if there is a matching
 					**	Dipthong character.
 					*/
 					for (dipthong = 0; dipthong < 8; dipthong++) {
 						if (Dipthong[common][dipthong] == next) {
 							first = (unsigned char) (common << 3);
 							first |= (unsigned char)dipthong;
 							first |= (unsigned char)0x80;
 							source++;
 						}
 					}
 				}
 			}
 		}
 
 		/*
 		**	Output the translated character to the destination buffer.
 		*/
 		*dest++ = first;
 		length++;
 
 		first = *source++;
 		next = *source;
 	}
 
 	*dest = '\0';
 
 	return(length);
 }
 
 
 /***************************************************************************
  * UnDip_Text -- Undipthongs a text string into specified buffer.          *
  *                                                                         *
  *    This routine is used to undipthong a text string and place the       *
  *    undipped text into the buffer specified.  Since dipthonged text is   *
  *    compressed, in order for the text to be used it must be undipped     *
  *    first.                                                               *
  *                                                                         *
  * INPUT:   source   -- Pointer to the dipped string.                      *
  *                                                                         *
  *          dest     -- Pointer to the destination buffer.                 *
  *                                                                         *
  * OUTPUT:  Returns the number of bytes placed into the destination        *
  *          buffer.                                                        *
  *                                                                         *
  * WARNINGS:   Be sure the destination buffer is big enough to hold the    *
  *             undipped text.                                              *
  *                                                                         *
  * HISTORY:                                                                *
  *   08/13/1993 JLB : Created.                                             *
  *   10/06/1994 JLB : Handles source string in EMS.                        *
  *=========================================================================*/
 int UnDip_Text(char const *source, char *dest)
 {
 	int	c;			// Source input character.
 	int	common;	// Common character index.
 	int	len;		// Length of output string.
 	char const *src;
 
 	len = 0;						// Presume no translation.
 
 	/*
 	**	Sweep through the source text and dipthong it.
 	*/
 	src = source;
 	c = *src++;
 	while (c) {
 
 		/*
 		**	Convert a dipthong character into it's component
 		**	ASCII characters.
 		*/
 		if (c & 0x80) {
 			c &= 0x7F;
 
 			common = (c & 0x78) >> 3;
 
 			*dest++ = Common[common];
 			len++;
 
 			c = Dipthong[common][c & 0x07];
 		}
 
 		*dest++ = (unsigned char)c;
 		len++;
 
 		c = *src++;
 	}
 
 	/*
 	**	End the output text with a '\0'.
 	*/
 	*dest++ = '\0';
 
 	return(len);
 }
 
 
 /***************************************************************************
  * Extract_String -- Extracts a string pointer from a string data block.   *
  *                                                                         *
  *    This routine is used to find a pointer to the specified string       *
  *    inside a string block.  String data blocks are created with the      *
  *    TEXTMAKE utility.  The data block my reside in XMS or EMS memory,    *
  *    but of course the returned string pointer will also point to         *
  *    such memory.  In this case, the string must be placed in real        *
  *    memory before it can be used.                                        *
  *                                                                         *
  * INPUT:   data     -- Pointer to the string data block.                  *
  *                                                                         *
  *          string   -- The string number to extract (if < 0 then NULL     *
  *                      is returned).                                      *
  *                                                                         *
  * OUTPUT:  Returns with pointer to the string number specified.           *
  *                                                                         *
  * WARNINGS:   none                                                        *
  *                                                                         *
  * HISTORY:                                                                *
  *   08/13/1993 JLB : Created.                                             *
  *   08/13/1993 JLB : Handles EMS or XMS data pointer.                     *
  *=========================================================================*/
 
 #define TXT_GUEST 					4567+3
 #define TXT_LOGIN 					4567+4
 #define TXT_LOGIN_TO_INTERNET 	4567+5
 #define TXT_YOUR_HANDLE 			4567+6
 #define TXT_YOUR_PASSWORD 		4567+7
 #define TXT_INTERNET_HOST		4567+8
 #define TXT_INTERNET_JOIN		4567+9
 #define TXT_INTERNET_GAME_TYPE	4567+10
 #define TXT_JOIN_INTERNET_GAME	4567+11
 #define TXT_ENTER_IP_ADDRESS	4567+12
 #define TXT_WINSOCK_CONNECTING							4567+13
 #define TXT_WINSOCK_NOT_CONNECTING					4567+14
 #define TXT_WINSOCK_UNABLE_TO_CONNECT_TO_SERVER	4567+15
 #define TXT_WINSOCK_CONTACTING_SERVER				4567+16
 #define TXT_WINSOCK_SERVER_ADDRESS_LOOKUP_FAILED	4567+17
 #define TXT_WINSOCK_UNABLE_TO_ACCEPT_CLIENT		4567+18
 #define TXT_WINSOCK_UNABLE_TO_CONNECT				4567+19
 #define TXT_WINSOCK_CONNECTION_LOST					4567+20
 #define TXT_WINSOCK_RESOLVING_HOST_ADDRESS			4567+21
 
 static char InternetTxt[22][40]={
 	"Internet H2H",
 	"Host Internet Game",
 	"Join Internet Game",
 	"Guest",
 	"Login",
 	"Login to Planet Westwood",
 	"Planet Westwood Handle",
 	"Planet Westwood Password",
 	"Host Game",
 	"Join Game",
 	"Choose Type of Internet Game",
 	"Join Internet Game",
 	"Address of Host",
 	"Connecting...",
 	"Connection Error!",
 	"Unable to connect to host!",
 	"Connecting to host...",
 	"Unable to resolve host address!",
 	"Unable to accept client connection",
 	"Unable to connect!",
 	"Connection lost!",
 	"Resolving address of host..."
 };
 
 char *Extract_String(void const *data, int string)
 {
 	unsigned short int	const *ptr;
 
 	if (!data || string < 0) return(NULL);
 
 	if (string >= 4567) return (InternetTxt[string-4567]);
 
 	ptr = (unsigned short int const *)data;
 	return (((char*)data) + ptr[string]);
 }