tiberium/CnC_Remastered_Collection
Archived
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Initial Source Code commit

Browse source 
Initial commit of original Tiberian Dawn and Red Alert source code converted to build as DLLs, and compatible with the release version of Command & Conquer Remastered.
This commit is contained in:
PG-SteveT 2020-05-27 12:16:20 -07:00
parent ea8ecc76fa
commit 03416d24e1
1038 changed files with 629779 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

973
REDALERT/WIN32LIB/WINDOWS.CPP Normal file
View file

@ -0,0 +1,973 @@
//
// 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/./windows.c 1.12 1994/05/20 15:35:25 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 : LIBRARY *
* *
* File Name : WINDOWS.C *
* *
* Programmer : Everyone *
* *
* Last Update : February 3, 1992 [DRD] *
* *
*-------------------------------------------------------------------------*
* Functions: *
* Change_New_Window -- Combined Change_Window and New_Window. *
* Change_Window -- Changes the 'current' window in the system. *
* Fetch_Char -- Gets one undipthonged char from input. *
* Flush_Line -- Outputs the accumulate text line to screen. *
* In_Char -- Stores (un-dipped) character(s) from input to buffer. *
* New_Window -- Clears the current window to the background color. *
* Set_More_Off -- Turns the 'more' prompting off. *
* Set_More_On -- Turns the 'more' prompting on. *
* Set_More_Prompt -- Adjusts the more prompt text for default routine *
* Standard_More_Prompt -- Default more prompt code for Window_Print *
* Window_Int_Print -- Prints an integer to the window. *
* Window_Print -- Displays and wraps text into a window. *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <stdarg.h>
#include <wwstd.h>
#include "ww_win.h"
#include <keyboard.h>
#include <font.h>
#include <dipthong.h>
PRIVATE void Scroll_Window(void);
PRIVATE void Flush_Line(void);
PRIVATE void In_Char(char *str);
PRIVATE char Fetch_Char(void);
PRIVATE int ScrollCounter = 0; // Count of the lines displayed before a pause.
PRIVATE char Line[84]; // Staging line buffer.
PRIVATE int Pos; // Char Position of next free character.
PRIVATE int PPos; // Pixel position of next free character.
PRIVATE int WPos; // Char position in window.
PRIVATE char *MainSource;
PRIVATE char *AltSource;
PRIVATE char Char[2];
PRIVATE char Stack;
PRIVATE char WordWrapFlag = FALSE; // flag for a word wrap.
PRIVATE int MoreSpace = 7;
PRIVATE int MoreFColor = 0;
PRIVATE int MoreBColor = 0;
int WindowColumns=40;
int WindowLines=25;
int WindowWidth=40;
unsigned int WinB=0;
unsigned int WinC=1;
unsigned int WinX=0;
unsigned int WinY=0;
unsigned int WinCx=0;
unsigned int WinCy=0;
unsigned int WinH=25;
unsigned int WinW=40;
unsigned int Window=0;
int MoreOn = TRUE;
char *TXT_MoreText = "--More--";
void (*Window_More_Ptr)(char const *,int,int,int) = Standard_More_Prompt;
extern GraphicViewPortClass *LogicPage;
/***************************************************************************
* STANDARD_MORE_PROMPT -- Default more prompt code for Window_Print *
* *
* This is the standard "<more>" prompting code that is used by *
* Window_Print when a page is full of text and a pause is desired *
* before the next page of text is printed. This function is called *
* through the Window_More_Ptr global. *
* *
* INPUT: prompt -- Pointer to ASCII text that will be window printed *
* at the right margin. *
* *
* space -- The number of spaces to allow for the 'more' text. *
* *
* fcolor -- The foreground color to use for the 'more' text. *
* *
* bcolor -- The background oclor to use for the 'more' text. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/29/1991 JLB : Created. *
*=========================================================================*/
void Standard_More_Prompt(char const *prompt, int space, int fcolor, int bcolor)
{
int x, y, moresize;
moresize = (space - 1) * (FontWidth+FontXSpacing);
x = ((WinX+WinW) << 3) - moresize;
//y = WinY + ((WinH/FontHeight)-1)*FontHeight;
y = WinY + (WinCy-1) * (FontHeight+FontYSpacing);
// Default "more" prompter.
LogicPage->Print(prompt, x, y, fcolor ? fcolor : WindowList[Window][WINDOWBCOL], bcolor ? bcolor : WindowList[Window][WINDOWFCOL]);
//BG if (LogicPage == SEENPAGE) {
//BG Window_Show_Mouse();
//BG }
// PWG - have to figure out how to do this in windows library
// Clear_KeyBuffer();
// Get_Key();
//BG if (LogicPage == SEENPAGE) {
//BG Window_Hide_Mouse(Window);
//BG }
// Erase the more prompt prompt.
// Text_Print(prompt, x, y, WinB, WinB);
LogicPage->Fill_Rect(x, y, x + moresize - 1, y + (FontHeight+FontYSpacing) - 1, (unsigned char)WinB);
}
/***************************************************************************
* SET_MORE_PROMPT -- Adjusts the more prompt text for default routine *
* *
* Use this routine to control the text of the "<MORE>" prompt that *
* the default more prompt routine uses. This can be useful for *
* foreign language translations. *
* *
* INPUT: prompt -- Pointer to ASCII text that will be window printed *
* at the right margin. *
* *
* space -- The number of spaces to allow for the 'more' text. *
* *
* fcolor -- The foreground color to use for the 'more' text. *
* *
* bcolor -- The background color to use for the 'more' text. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/29/1991 JLB : Created. *
*=========================================================================*/
void Set_More_Prompt(char const *prompt, int space, int fcolor, int bcolor)
{
if (prompt) {
TXT_MoreText = (char*)prompt;
MoreSpace = space;
MoreFColor = fcolor;
MoreBColor = bcolor;
}
else {
TXT_MoreText = "<MORE>";
MoreSpace = 7;
MoreFColor = MoreBColor = 0;
}
}
/***************************************************************************
* SET_MORE_ON -- Turns the 'more' prompting on. *
* *
* Use this routine to turn on the 'more' prompting that Window_Print *
* does. If you have a custom more function pointer, then that *
* routine will be called, otherwise the library default 'more' prompt *
* will be utilized. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/25/1991 JLB : Created. *
*=========================================================================*/
void Set_More_On(void)
{
MoreOn = TRUE;
ScrollCounter = 0;
}
/***************************************************************************
* SET_MORE_OFF -- Turns the 'more' prompting off. *
* *
* This routine will turn the 'more' prompting that Window_Print does *
* off. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/25/1991 JLB : Created. *
*=========================================================================*/
void Set_More_Off(void)
{
MoreOn = FALSE;
}
/***************************************************************************
* CHANGE_WINDOW -- Changes the 'current' window in the system. *
* *
* Use this routine to change the 'current' window. The current window *
* is used in Window_Print and some other graphic output routines. *
* *
* INPUT: windnum -- The window number to change to. *
* *
* OUTPUT: Returns with the previously current window. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/25/1991 JLB : Created. *
*=========================================================================*/
int Change_Window(int windnum)
{
int oldwindow;
int *data;
oldwindow = Window;
Window = windnum;
data = &WindowList[windnum][0];
WinX = *data++;
WinY = *data++;
WinW = *data++;
WinH = *data++;
WinC = *data++;
WinB = *data++;
WinCx = *data++;
WinCy = *data++;
ScrollCounter = 0;
WPos = WinCx / (FontWidth+FontXSpacing);
WindowLines = (WinH-FontYSpacing) / (FontHeight+FontYSpacing);
WindowWidth = WinW << 3;
WindowColumns = WindowWidth / (FontWidth+FontXSpacing);
return (oldwindow);
}
/***************************************************************************
* CHANGE_NEW_WINDOW -- Combined Change_Window and New_Window. *
* *
* This is a combo-routine. It merely combines the Change_Window *
* with the New_Window routines. It will save some (small) code if *
* you use this routine instead of the two function calls. *
* *
* INPUT: window -- Window number to change to and clear. *
* *
* OUTPUT: Returns with the previously current window. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/25/1991 JLB : Created. *
*=========================================================================*/
int Change_New_Window(int windnum)
{
int oldwindow;
oldwindow = Change_Window(windnum);
New_Window();
return(oldwindow);
}
/***************************************************************************
* NEW_WINDOW -- Clears the current window to the background color. *
* *
* This routine clears the current window to the background color. It *
* is used in preparation to Window_Print because it ensures a clean *
* 'slate' for the text. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/25/1991 JLB : Created. *
*=========================================================================*/
void New_Window(void)
{
int x,y,w,h;
x = WinX << 3;
y = WinY;
w = (WinX + WinW) << 3;
h = WinY + WinH;
LogicPage->Fill_Rect(x, y, w - 1, h - 1, (unsigned char)WinB);
WinCx = WPos = 0;
WinCy = 0;
ScrollCounter = 0;
}
/***************************************************************************
* WINDOW_INT_PRINT -- Prints an integer to the window. *
* *
* Use this routine to print an integer to the window. This routine *
* as all other Window printing routines will handle word wrap. *
* *
* INPUT: num -- The integer to convert to ASCII and print. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/25/1991 JLB : Created. *
*=========================================================================*/
void Window_Int_Print(int num)
{
Window_Print("%d", num);
}
/***************************************************************************
* WINDOW_PRINT -- Displays and wraps text into a window. *
* *
* This is the general purpos text output routine that will handle *
* word wrap within a window. It is useful for displaying arbitrary *
* text. This routine will handle dipthonged text and as such it *
* can be quite useful in saving memory. *
* *
* INPUT: string -- String to print. This can be of ANY length and *
* can even contain some formatting codes. The *
* codes supported are: *
* *
* KA_SETX Forces the cursor X position to the value *
* specified. *
* *
* KA_SETY Forces the cursor Y position to the value *
* specified. *
* *
* KA_MORE Causes an immediate "<MORE>" prompt *
* regardless of the scroll situation. *
* *
* KA_RETURN Breaks line and continues output at the *
* left edge of following line. *
* *
* *
* KA_FORMFEED Clears the window and continues printing at *
* the upper left corner. *
* *
* KA_SETBKGDCOL Set the background color with the color *
* specified by the following byte. *
* *
* *
* KA_SETFORECOL Set the foreground color with the color *
* specified by the following byte. *
* *
* KA_TAB Move the cursor over to the next tabstop. *
* Tabstops are set every 8 columns. *
* *
* KA_SPCTAB Insert spaces until the cursor is positioned *
* at the next tabstop. *
* *
* %s Replace the "%s" with the text pointed to *
* by the pointer argument passed to the *
* routine (follows same method a printf). *
* *
* %d Replace the "%d" with an integer ASCII *
* number of the int passed to the routine. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/25/1991 JLB : Created. *
* 07/29/1991 JLB : Added MORE, SETX, and SETY *
*=========================================================================*/
void Window_Print(char const string[], ...)
{
int oldcx, x, y; // Scratch variables.
char c; // Current character.
char buffer[10]; // Working %d buffer.
int old_c, old_b; // Original window colors.
va_list arg; // Argument list var.
va_start(arg, string);
WordWrapFlag = FALSE; // initialize word wrap flag.
Pos = PPos = 0;
Line[0] = '\0';
Char[0] = Char[1] = 0;
MainSource = (char*)&string[0];
AltSource = NULL;
old_c = WinC;
old_b = WinB;
//BG if (LogicPage == SEENPAGE) {
//BG Window_Hide_Mouse(Window);
//BG }
while (TRUE) {
c = Fetch_Char();
if (!c) break; // Exit on NULL character.
/*
** Substitution commands only work if not already expanding a
** string.
*/
if (!AltSource) {
if (c == '%') {
switch(tolower(Char[0])) {
case 's':
AltSource = va_arg(arg, char*);
if (AltSource) {
Stack = Char[1];
Char[0] = Char[1] = '\0';
c = Fetch_Char();
}
break;
case 'd':
AltSource = buffer;
sprintf(buffer, "%d", va_arg(arg, int));
Stack = Char[1];
Char[0] = Char[1] = '\0';
c = Fetch_Char();
break;
default:
break;
}
}
}
switch(c) {
#if(FALSE)
// these are the positions of foreign language characters
/*
** These are characters that shouldn't be window printed because
** they are currently reserved.
*/
case KA_CTRL_C:
case KA_CTRL_D:
case KA_CTRL_E:
case KA_CTRL_G:
case KA_CTRL_J:
case KA_CTRL_K:
case KA_CTRL_N:
case KA_CTRL_O:
case KA_CTRL_P:
case KA_CTRL_Q:
case KA_CTRL_R:
case KA_CTRL_T:
case KA_CTRL_U:
case KA_CTRL_V:
case KA_CTRL_W:
case KA_CTRL_Z:
case KA_CTRL_BACKSLASH:
case KA_CTRL_CARROT:
case KA_CTRL_UNDERLINE:
break;
#endif
/*
** Force cursor column to specified X value.
*/
case KA_SETX:
Flush_Line();
WPos = Fetch_Char();
WPos = MAX(0, WPos);
// WPos is max width char position
WPos = MIN(WindowColumns-1, WPos);
WinCx = WPos * (FontWidth+FontXSpacing);
break;
/*
** Force the cursor to specified Y value.
*/
case KA_SETY:
Flush_Line();
WinCy = Fetch_Char();
//WinCy = MAX(0, WinCy);
WinCy = MIN((long)WindowLines-1, (long)WinCy);
break;
/*
** Force a "<MORE>" prompt.
*/
case KA_MORE:
Flush_Line();
if (Window_More_Ptr) {
//BG if (LogicPage == SEENPAGE) Window_Show_Mouse();
Window_More_Ptr(TXT_MoreText, MoreSpace, MoreFColor, MoreBColor);
//BG if (LogicPage == SEENPAGE) Window_Hide_Mouse(Window);
}
break;
/*
** Clear and home the window cursor. This is the same
** as New_Window().
*/
case KA_FORMFEED:
New_Window();
break;
/*
** Move cursor to start of next line.
*/
case KA_RETURN:
Flush_Line();
ScrollCounter++;
WinCx = 0;
#if(FALSE)
if (WinCy >= WindowLines-1) {
Scroll_Window();
}
else {
WinCy++;
}
#else
WinCy++;
#endif
break;
/*
** Set the background color.
*/
case KA_SETBKGDCOL:
Flush_Line();
WinB = Fetch_Char();
break;
/*
** Set the foreground color.
*/
case KA_SETFORECOL:
Flush_Line();
WinC = Fetch_Char();
break;
/*
** Move cursor to next column.
*/
case KA_TAB:
Flush_Line();
WPos = ((WPos + 8) & 0xFFF8) - 1;
if (WPos >= WindowColumns) {
WPos = 0;
}
WinCx = WPos * (FontWidth+FontXSpacing);
break;
/*
** Tab to specified column but add spaces.
*/
case KA_SPCTAB:
Flush_Line();
oldcx = WinCx;
x = WinX << 3;
y = WinY + (WinCy * (FontHeight+FontYSpacing));
WPos = ((WPos + 8) & 0xFFF8) - 1;
if (WPos >= WindowColumns) {
WinCx = WPos = 0;
// Fill_Rect instead of printing spaces
LogicPage->Fill_Rect(x + oldcx, y,
x + WindowWidth - 1, y + (FontHeight+FontYSpacing) - 1, (unsigned char)WinB);
ScrollCounter++;
WinCy++;
}
else {
WinCx = WPos * (FontWidth+FontXSpacing);
// Fill_Rect instead of printing spaces
LogicPage->Fill_Rect(x + oldcx, y,
x + WinCx - 1, y + (FontHeight+FontYSpacing) - 1, (unsigned char)WinB);
}
break;
/*
** next character is a extended value 1-127, but 128 is added
** for a value 129-255
*/
case KA_EXTEND:
c = 127;
// NOTE: this falls thru to the default case DO NOT MOVE!!!!!
/*
** next character is a literal value 1-127, except 13
*/
// case KA_LITERAL:
// if (c != (char) 127) { // check if fell thru from extend case
// c = 0; // set to zero for literal case
// }
// c += Fetch_Char();
// NOTE: this falls thru to the default case DO NOT MOVE!!!!!
/*
** Normal character output.
*/
default:
PPos += Char_Pixel_Width(c); // get pixel location of next char
Line[Pos++] = c;
Line[Pos] = '\0';
if (WinCx + PPos > (unsigned)WindowWidth) {
Flush_Line();
}
break;
}
}
/*
** If there is text still pending, then display it before exiting.
*/
if (Pos) Flush_Line();
/*
** Record changes in the cursor position.
*/
WindowList[Window][WINDOWCURSORX] = WinCx;
WindowList[Window][WINDOWCURSORY] = WinCy;
/*
** Restore the window colors to their original values.
*/
WindowList[Window][WINDOWFCOL] = WinC = old_c;
WindowList[Window][WINDOWBCOL] = WinB = old_b;
//BG if (LogicPage == SEENPAGE) {
//BG Window_Show_Mouse();
//BG }
va_end(arg);
}
/***************************************************************************
* SCROLL_WINDOW -- Scrolls the text window up one line. *
* *
* This will scroll the text window up one line. It will handle any *
* pausing for "more" if the MoreOn flag is set. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: This routine assumes that the LogicPage is the SEENPAGE. *
* If this is not the case, the program may appear to hang *
* if a "more" prompt is generated. *
* *
* HISTORY: *
* 07/25/1991 JLB : Created. *
*=========================================================================*/
PRIVATE void Scroll_Window(void)
{
int y; // Top pixel row of bottom line of window.
/*
** Possibly prompt for more text.
*/
if (ScrollCounter >= WindowLines-1 && MoreOn) {
ScrollCounter = 0;
if (Window_More_Ptr) {
//BG if (LogicPage == SEENPAGE) Window_Show_Mouse();
Window_More_Ptr(TXT_MoreText, MoreSpace, MoreFColor, MoreBColor);
//BG if (LogicPage == SEENPAGE) Window_Hide_Mouse(Window);
}
}
/*
** Scroll the window up one line.
*/
y = ((WinH / (FontHeight+FontYSpacing)) - 1) * (FontHeight+FontYSpacing);
LogicPage->Blit(*LogicPage,WinX<<3, WinY + (FontHeight+FontYSpacing), WinX<<3, WinY, WinW<<3, WinH - (FontHeight+FontYSpacing) );
LogicPage->Fill_Rect(WinX<<3,
WinY + y,
((WinX+WinW)<<3) - 1,
WinY + WinH - 1,
(unsigned char)WinB);
}
/***************************************************************************
* FLUSH_LINE -- Outputs the accumulate text line to screen. *
* *
* This will display the accumlated text line to the screen. It will *
* handle breaking the text line at an appropriate position. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/25/1991 JLB : Created. *
*=========================================================================*/
PRIVATE void Flush_Line(void)
{
int breakit, breaksize, breakwidth;
int x, y; // Coordinates of text print.
int breakpoint; // Point to break the line (if possible).
char breakchar; // Break replace character.
int index; // Backward moving index var.
/*
** There could be a held <CR> and this is implied by the cursor Y position
** beyond the bottom of the window. If this is the case, then scroll the
** window and proceed with the line flush.
*/
while (WinCy >= (unsigned)WindowLines /*&& Pos > 0*/) {
Scroll_Window();
if (WinCy >= (unsigned)WindowLines) WinCy--;
}
//if (WinCy >= WindowLines) WinCy = WindowLines-1;
x = (WinX<<3) + WinCx;
y = WinY + (WinCy*(FontHeight+FontYSpacing));
breakwidth = WindowWidth;
// if (ScrollCounter >= WindowLines - 1 && MoreOn) {
// breakwidth -= (MoreSpace * (FontWidth+FontXSpacing)); // use maximum font width
// }
/*
** Try to break the line at the last space IF the line has reached the edge
** of the window.
*/
breakpoint = Pos;
breaksize = PPos;
if (WinCx + breaksize > (unsigned)breakwidth) {
/*
** Since the text WILL spill past the edge of the window, determine the
** point where the break should occur. If this line is ready for the <MORE>
** prompt, then breaking must account for the <MORE> text.
*/
if (ScrollCounter >= WindowLines - 1 && MoreOn) {
breakwidth -= (MoreSpace * (FontWidth+FontXSpacing)); // use maximum font width
}
breakwidth -= WinCx;
breakit = 0;
for (index = breakpoint - 1; index > 0; index--) {
breakchar = Line[index];
breaksize -= Char_Pixel_Width(breakchar);
// only once, find largest text that can fit on the line
if (!breakit) {
// was this the char that went past the right edge
if (breaksize <= breakwidth) {
breakit = index; // save this position if there is no spaces
}
}
// after largest text is found then look for a space to break on
if (breakit && breakchar == KA_SPACE) {
breakpoint = index;
WordWrapFlag = FALSE; // word will start at beginning of next line
break;
}
}
/*
** Exception: When the current text buffer cannot be broken at a logical
** place AND the text is starting past the left margin, THEN there is
** an implied break between the previous text output and this one.
** Output the current text on the next line left margin.
*/
if (!index) {
if (WinCx && !WordWrapFlag) {
breakpoint = breaksize = 0; // Continue text on next line.
WordWrapFlag = TRUE; // indicate a word continuation.
}
else {
breakpoint = breakit; // Just print as much as possible.
}
}
}
breakchar = Line[breakpoint];
Line[breakpoint] = '\0';
LogicPage->Print(Line, x, y, WinC, WinB);
WinCx += breaksize; // add size of text string printed.
Line[breakpoint] = breakchar;
if (breakchar == KA_SPACE) { // take out a space between words.
breakpoint++;
}
// take out another space for double spacing after end of sentence.
if (Line[breakpoint] == KA_SPACE) {
breakpoint++;
}
strcpy(Line, &Line[breakpoint]);
Pos = strlen(Line);
PPos = String_Pixel_Width(Line);
/*
** If at this point there is still text in the buffer, then flushing has
** not been completed. Scroll to next line and repeat the text flushing
** process.
*/
if (Pos || WinCx >= (unsigned)WindowWidth) {
WinCx = WPos = 0;
#if(FALSE)
if (WinCy >= WindowLines-1) {
Scroll_Window();
} else {
WinCy++;
}
#else
WinCy++;
#endif
Flush_Line();
ScrollCounter++; // must be done after flush line for correct counting
}
}
/***************************************************************************
* IN_CHAR -- Stores (un-dipped) character(s) from input to buffer. *
* *
* Use this routine to fetch the next character from the input stream. *
* If the character was dipthonged, then it will be broken into its *
* component ASCII characters and stored in the specified location. *
* This is the core character stream reading code. *
* *
* INPUT: str -- char pointer to the position to store the character(s)*
* fetched from the input stream. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/25/1991 JLB : Created. *
*=========================================================================*/
PRIVATE void In_Char(char *str)
{
char c; // Character to return.
char next; // Following character (if any).
c = next = '\0';
/*
** Fetch a raw byte from the input stream.
*/
if (AltSource) {
if (*AltSource == '\0') {
AltSource = NULL;
c = Stack;
} else {
c = *AltSource++;
}
}
if (!c && MainSource) {
if (*MainSource == '\0') {
MainSource = NULL;
} else {
c = *MainSource++;
}
}
/*
** Convert a dipthong character into it's component
** ASCII characters.
*/
if (c & 0x80) {
c &= 0x7F;
next = c & (char)0x07;
c = (char)((c & (char)0x78) >> 3);
next = Dipthong[c][next]; // Dipthong character.
c = Common[c]; // Common character.
}
*str++ = c;
*str = next;
}
/***************************************************************************
* FETCH_CHAR -- Gets one undipthonged char from input. *
* *
* This routine will fetch one character from the input stream. The *
* character has already been un-dipthonged. It is a straight ASCII *
* character. This routine ensures that if the next character in the *
* input stream needs to be examined, it is available in Char[0]. *
* *
* INPUT: none *
* *
* OUTPUT: Returns next character in the input stream (ASCII). If NULL *
* is returned, then this indicates the end of the input stream. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/25/1991 JLB : Created. *
*=========================================================================*/
PRIVATE char Fetch_Char(void)
{
char c; // Character to return.
if (!Char[0]) {
In_Char(&Char[0]);
}
c = Char[0];
Char[0] = Char[1];
Char[1] = '\0';
if (!Char[0]) {
In_Char(&Char[0]);
}
return (c);
}