[comp.sources.sun] v01i039: Calctool, a calculator for your Sun, Part02/02

mcgrew@dartagnan.rutgers.edu (Charles Mcgrew) (06/30/89)

Submitted-by: chuck@melmac.harris-atd.com (Chuck Musciano)
Posting-number: Volume 1, Issue 39
Archive-name: calctool/part02

#! /bin/sh
# This is a shell archive, meaning:
# 1. Remove everything above the #! /bin/sh line.
# 2. Save the resulting text in a file.
# 3. Execute the file with /bin/sh (not csh) to create the files:
#	keys.h
#	manifest.h
#	memory.c
#	ops.c
#	screen.c
# This archive created: Thu Jun 29 21:58:43 1989
export PATH; PATH=/bin:$PATH
echo shar: extracting "'keys.h'" '(3654 characters)'
if test -f 'keys.h'
then
	echo shar: will not over-write existing file "'keys.h'"
else
sed 's/^	X//' << \SHAR_EOF > 'keys.h'
	X/************************************************************************/
	X/*	Copyright 1988 by Chuck Musciano and Harris Corporation		*/
	X/*									*/
	X/*	Permission to use, copy, modify, and distribute this software	*/
	X/*	and its documentation for any purpose and without fee is	*/
	X/*	hereby granted, provided that the above copyright notice	*/
	X/*	appear in all copies and that both that copyright notice and	*/
	X/*	this permission notice appear in supporting documentation, and	*/
	X/*	that the name of Chuck Musciano and Harris Corporation not be	*/
	X/*	used in advertising or publicity pertaining to distribution	*/
	X/*	of the software without specific, written prior permission.	*/
	X/*	Chuck Musciano and Harris Corporation make no representations	*/
	X/*	about the suitability of this software for any purpose.  It is	*/
	X/*	provided "as is" without express or implied warranty.		*/
	X/************************************************************************/
	X
	X/************************************************************************/
	X/*									*/
	X/*	Key opcode definitions						*/
	X/*									*/
	X/************************************************************************/
	X
	X#define		BINARY_OP		0x00010000
	X#define		UNARY_OP		0x00020000
	X
	X#define		is_binary(x)		((x) & BINARY_OP)
	X#define		is_unary(x)		((x) & UNARY_OP)
	X#define		is_digit(x)		((x) >= DIGIT_0 && (x) <= DIGIT_EE)
	X#define		prec(x)			((x) >> 20)
	X
	X#define		NO_OP			-1
	X#define		DIGIT_0			0
	X#define		DIGIT_1			1
	X#define		DIGIT_2			2
	X#define		DIGIT_3			3
	X#define		DIGIT_4			4
	X#define		DIGIT_5			5
	X#define		DIGIT_6			6
	X#define		DIGIT_7			7
	X#define		DIGIT_8			8
	X#define		DIGIT_9			9
	X#define		DIGIT_A			10
	X#define		DIGIT_B			11
	X#define		DIGIT_C			12
	X#define		DIGIT_D			13
	X#define		DIGIT_E			14
	X#define		DIGIT_F			15
	X#define		DIGIT_DOT		16
	X#define		DIGIT_CHS		17
	X#define		DIGIT_EE		18
	X
	X#define		ADD_OP			(19 | BINARY_OP | (2 << 20))
	X#define		AND_OP			(20 | BINARY_OP | (5 << 20))
	X#define		CLEAR_OP		(21 | UNARY_OP)
	X#define		CLOSE_OP		(22 | UNARY_OP)
	X#define		COS_OP			(23 | UNARY_OP)
	X#define		DIV_OP			(24 | BINARY_OP | (3 << 20))
	X#define		EQUAL_OP		(25 | UNARY_OP)
	X#define		ERASE_OP		(26 | UNARY_OP)
	X#define		EXC_OP			(27 | UNARY_OP)
	X#define		EXP_OP			(28 | UNARY_OP)
	X#define		E_OP			(29 | UNARY_OP)
	X#define		FACT_OP			(30 | UNARY_OP)
	X#define		FIX_OP			(31 | UNARY_OP)
	X#define		ICOS_OP			(32 | UNARY_OP)
	X#define		INT_OP			(33 | UNARY_OP)
	X#define		INVEE_OP		(34 | UNARY_OP)
	X#define		INVERT_OP		(35 | UNARY_OP)
	X#define		ISIN_OP			(36 | UNARY_OP)
	X#define		ITAN_OP			(37 | UNARY_OP)
	X#define		LN_OP			(38 | UNARY_OP)
	X#define		LOG_OP			(39 | UNARY_OP)
	X#define		LPAREN_OP		(40 | UNARY_OP  | (0 << 20))
	X#define		LSL_OP			(41 | BINARY_OP | (3 << 20))
	X#define		MUL_OP			(42 | BINARY_OP | (3 << 20))
	X#define		NOT_OP			(43 | UNARY_OP)
	X#define		OR_OP			(44 | BINARY_OP | (6 << 20))
	X#define		OVER_OP			(45 | UNARY_OP)
	X#define		PI_OP			(46 | UNARY_OP)
	X#define		POINT_OP		(47 | UNARY_OP)
	X#define		POW_OP			(48 | UNARY_OP)
	X#define		QUIT_OP			(49 | UNARY_OP)
	X#define		RCL_OP			(50 | UNARY_OP)
	X#define		ROL_OP			(51 | BINARY_OP | (3 << 20))
	X#define		ROOT_OP			(52 | BINARY_OP | (4 << 20))
	X#define		ROR_OP			(53 | BINARY_OP | (3 << 20))
	X#define		RPAREN_OP		(54 | UNARY_OP  | (1 << 20))
	X#define		RSA_OP			(55 | BINARY_OP | (3 << 20))
	X#define		RSL_OP			(56 | BINARY_OP | (3 << 20))
	X#define		SIN_OP			(57 | UNARY_OP)
	X#define		SQRT_OP			(58 | UNARY_OP)
	X#define		SQR_OP			(59 | UNARY_OP)
	X#define		STO_OP			(60 | UNARY_OP)
	X#define		SUB_OP			(61 | BINARY_OP | (2 << 20))
	X#define		TAN_OP			(62 | UNARY_OP)
	X#define		TRUNC_OP		(63 | UNARY_OP)
	X#define		XOR_OP			(64 | BINARY_OP | (6 << 20))
	X#define		Y2X_OP			(65 | BINARY_OP | (4 << 20))
SHAR_EOF
if test 3654 -ne "`wc -c < 'keys.h'`"
then
	echo shar: error transmitting "'keys.h'" '(should have been 3654 characters)'
fi
fi # end of overwriting check
echo shar: extracting "'manifest.h'" '(1721 characters)'
if test -f 'manifest.h'
then
	echo shar: will not over-write existing file "'manifest.h'"
else
sed 's/^	X//' << \SHAR_EOF > 'manifest.h'
	X/************************************************************************/
	X/*	Copyright 1988 by Chuck Musciano and Harris Corporation		*/
	X/*									*/
	X/*	Permission to use, copy, modify, and distribute this software	*/
	X/*	and its documentation for any purpose and without fee is	*/
	X/*	hereby granted, provided that the above copyright notice	*/
	X/*	appear in all copies and that both that copyright notice and	*/
	X/*	this permission notice appear in supporting documentation, and	*/
	X/*	that the name of Chuck Musciano and Harris Corporation not be	*/
	X/*	used in advertising or publicity pertaining to distribution	*/
	X/*	of the software without specific, written prior permission.	*/
	X/*	Chuck Musciano and Harris Corporation make no representations	*/
	X/*	about the suitability of this software for any purpose.  It is	*/
	X/*	provided "as is" without express or implied warranty.		*/
	X/************************************************************************/
	X
	X/************************************************************************/
	X/*									*/
	X/*	Manifest constants						*/
	X/*									*/
	X/************************************************************************/
	X
	X#define		PRIVATE			static
	X#define		PUBLIC			extern
	X
	X#define		PI			((double) 3.14159265358979323846)
	X#define		E			((double) 2.71828182845904523536)
	X
	X#define		SCIENTIFIC		0
	X#define		PROGRAMMER		2
	X
	X#define		BINARY			2
	X#define		OCTAL			8
	X#define		DECIMAL			10
	X#define		HEXADECIMAL		16
	X
	X#define		DEG			0
	X#define		RAD			1
	X#define		GRAD			2
	X
	X#define		MAX_MEMORY		42
	X#define		MAX_STACK		100
	X
	X#define		index_of(x)		((x == BINARY)? 1 : ((x == OCTAL)? 3 : 4))
	X
	X#ifndef	NULL
	X#define		NULL			0
	X#endif	NULL
	X
	X#ifndef	TRUE
	X#define		TRUE			1
	X#define		FALSE			0
	X#endif	TRUE
SHAR_EOF
if test 1721 -ne "`wc -c < 'manifest.h'`"
then
	echo shar: error transmitting "'manifest.h'" '(should have been 1721 characters)'
fi
fi # end of overwriting check
echo shar: extracting "'memory.c'" '(4276 characters)'
if test -f 'memory.c'
then
	echo shar: will not over-write existing file "'memory.c'"
else
sed 's/^	X//' << \SHAR_EOF > 'memory.c'
	X/************************************************************************/
	X/*	Copyright 1988 by Chuck Musciano and Harris Corporation		*/
	X/*									*/
	X/*	Permission to use, copy, modify, and distribute this software	*/
	X/*	and its documentation for any purpose and without fee is	*/
	X/*	hereby granted, provided that the above copyright notice	*/
	X/*	appear in all copies and that both that copyright notice and	*/
	X/*	this permission notice appear in supporting documentation, and	*/
	X/*	that the name of Chuck Musciano and Harris Corporation not be	*/
	X/*	used in advertising or publicity pertaining to distribution	*/
	X/*	of the software without specific, written prior permission.	*/
	X/*	Chuck Musciano and Harris Corporation make no representations	*/
	X/*	about the suitability of this software for any purpose.  It is	*/
	X/*	provided "as is" without express or implied warranty.		*/
	X/************************************************************************/
	X
	X/************************************************************************/
	X/*									*/
	X/*	Module:		memory.c					*/
	X/*									*/
	X/*	Function:	Manage calculator memories			*/
	X/*									*/
	X/*	Public Names:	store_proc	store a value			*/
	X/*			recall_proc	recall a value			*/
	X/*			exchange_proc	exchange a value and a memory	*/
	X/*			do_store	store in memory			*/
	X/*			do_recall	recall from memory		*/
	X/*			do_exchange	exchange with memory		*/
	X/*									*/
	X/*	Change History:	17 Nov 86	Creation			*/
	X/*			22 May 87	Added do_* procs		*/
	X/*									*/
	X/************************************************************************/
	X
	X#include	<suntool/sunview.h>
	X#include	<suntool/panel.h>
	X
	X#include	"manifest.h"
	X#include	"globals.h"
	X
	X#define		HAS_STORE		0
	X#define		NO_STORE		1
	X
	XPUBLIC	Panel	keys;
	XPUBLIC	struct	pixfont	*key_font;
	X
	XPRIVATE	double	memory[MAX_MEMORY] = {0.0};
	XPRIVATE	char	mem_image[MAX_MEMORY][60];
	XPRIVATE	int	mem_count = 1;
	XPRIVATE	Menu	menu = NULL;
	X
	XPRIVATE	update_menu(store)
	X
	Xint	store;
	X
	X{	int	i;
	X
	X	if (menu)
	X	   menu_destroy(menu);
	X	menu = menu_create(MENU_INITIAL_SELECTION, MENU_DEFAULT, 0);
	X	for (i = 0; i < mem_count; i++) {
	X	   sprintf(mem_image[i], "%2d: ", i);
	X	   convert_value(memory[i], &(mem_image[i][4]));
	X	   menu_set(menu, 
	X	   	       MENU_ITEM, 
	X	   	          MENU_STRING, mem_image[i], 
	X	   	          MENU_FONT, key_font, 
	X	   	          MENU_VALUE, i + 1, 
	X	   	          0, 
	X	   	       0);
	X	   }
	X	if (store && mem_count < MAX_MEMORY)
	X	   menu_set(menu, 
	X	   	       MENU_ITEM, 
	X	   	          MENU_STRING, "New Memory", 
	X	   	          MENU_FONT, key_font, 
	X	   	          MENU_VALUE, i + 1, 
	X	   	          0, 
	X	   	       0);
	X	menu_set(menu, MENU_DEFAULT, 1, 0);
	X}
	X
	XPUBLIC	do_store(slot)
	X
	Xint	slot;
	X
	X{
	X	memory[slot] = v_stack[v_top];
	X}
	X
	XPUBLIC	store_proc(item, event)
	X
	XPanel_item	item;
	XEvent		*event;
	X
	X{	int	slot;
	X
	X	if (event_id(event) >= ASCII_FIRST && event_id(event) <= ASCII_LAST)
	X	   keyboard(event_id(event));
	X	else {
	X	   convert_display();
	X	   if (event_id(event) == MS_RIGHT) {
	X	      update_menu(TRUE);
	X	      if (slot = (int) menu_show(menu, keys, event, 0)) {
	X	         do_store(--slot);
	X	         if (slot == mem_count)
	X	            mem_count++;
	X	         }
	X	      }
	X	   else
	X	      do_store(0);
	X	   }
	X}
	X
	XPUBLIC	do_recall(slot)
	X
	Xint	slot;
	X
	X{
	X	v_stack[v_top] = memory[slot];
	X	update_display();
	X}
	X
	XPUBLIC	recall_proc(item, event)
	X
	XPanel_item	item;
	XEvent		*event;
	X
	X{	int	slot;
	X
	X	if (event_id(event) >= ASCII_FIRST && event_id(event) <= ASCII_LAST)
	X	   keyboard(event_id(event));
	X	else {
	X	   clear_entry();
	X	   if (event_id(event) == MS_RIGHT) {
	X	      update_menu(FALSE);
	X	      if (slot = (int) menu_show(menu, keys, event, 0))
	X	         do_recall(--slot);
	X	      }
	X	   else
	X	      do_recall(0);
	X	   }
	X}
	X
	XPUBLIC	do_exchange(slot)
	X
	Xint	slot;
	X
	X{	double	temp;
	X
	X	temp = v_stack[v_top];
	X	v_stack[v_top] = memory[slot];
	X	memory[slot] = temp;
	X	update_display();
	X}
	X
	XPUBLIC	exchange_proc(item, event)
	X
	XPanel_item	item;
	XEvent		*event;
	X
	X{	int	slot;
	X
	X	if (event_id(event) >= ASCII_FIRST && event_id(event) <= ASCII_LAST)
	X	   keyboard(event_id(event));
	X	else {
	X	   convert_display();
	X	   if (event_id(event) == MS_RIGHT) {
	X	      update_menu(FALSE);
	X	      if (slot = (int) menu_show(menu, keys, event, 0))
	X	         do_exchange(--slot);
	X	      }
	X	   else
	X	      do_exchange(0);
	X	   }
	X}
SHAR_EOF
if test 4276 -ne "`wc -c < 'memory.c'`"
then
	echo shar: error transmitting "'memory.c'" '(should have been 4276 characters)'
fi
fi # end of overwriting check
echo shar: extracting "'ops.c'" '(8116 characters)'
if test -f 'ops.c'
then
	echo shar: will not over-write existing file "'ops.c'"
else
sed 's/^	X//' << \SHAR_EOF > 'ops.c'
	X/************************************************************************/
	X/*	Copyright 1988 by Chuck Musciano and Harris Corporation		*/
	X/*									*/
	X/*	Permission to use, copy, modify, and distribute this software	*/
	X/*	and its documentation for any purpose and without fee is	*/
	X/*	hereby granted, provided that the above copyright notice	*/
	X/*	appear in all copies and that both that copyright notice and	*/
	X/*	this permission notice appear in supporting documentation, and	*/
	X/*	that the name of Chuck Musciano and Harris Corporation not be	*/
	X/*	used in advertising or publicity pertaining to distribution	*/
	X/*	of the software without specific, written prior permission.	*/
	X/*	Chuck Musciano and Harris Corporation make no representations	*/
	X/*	about the suitability of this software for any purpose.  It is	*/
	X/*	provided "as is" without express or implied warranty.		*/
	X/************************************************************************/
	X
	X/************************************************************************/
	X/*									*/
	X/*	Module:		ops.c						*/
	X/*									*/
	X/*	Function:	Perform actual calculation			*/
	X/*									*/
	X/*	Public Names:	do_unary	handle unary operators		*/
	X/*			do_binary	handle binary operators		*/
	X/*			op_str		return a operator string	*/
	X/*									*/
	X/*	Change History:	17 Nov 86	Creation			*/
	X/*									*/
	X/************************************************************************/
	X
	X#include	<math.h>
	X
	X#include	"manifest.h"
	X#include	"globals.h"
	X#include	"keys.h"
	X
	X#define		low_order(b, x)		((((unsigned) 0xffffffff) >> (32 - (b))) & (x))
	X
	XPRIVATE	pop_op()
	X
	X{	int	i, temp;
	X
	X	if (curr_mode != SCIENTIFIC && o_stack[o_top - 1]) {
	X	   v_stack[v_top] = (double) low_order(curr_width[index_of(curr_base)], (unsigned int) v_stack[v_top]);
	X	   v_stack[v_top - 1] = (double) low_order(curr_width[index_of(curr_base)], (unsigned int) v_stack[v_top - 1]);
	X	   }
	X	switch (o_stack[--o_top]) {
	X	   case ADD_OP    : v_stack[v_top - 1] += v_stack[v_top];
	X	       		    break;
	X	   case AND_OP    : temp = ((unsigned int) v_stack[v_top - 1]) & ((unsigned int) v_stack[v_top]);
	X	       		    v_stack[v_top - 1] = (double) temp;
	X	       		    break;
	X	   case DIV_OP    : v_stack[v_top - 1] /= v_stack[v_top];
	X	       		    break;
	X	   case LPAREN_OP : return;
	X	   		    break;
	X	   case LSL_OP    : temp = ((unsigned int) v_stack[v_top - 1]) << ((unsigned int) v_stack[v_top]);
	X	       		    v_stack[v_top - 1] = (double) temp;
	X	       		    break;
	X	   case MUL_OP    : v_stack[v_top - 1] *= v_stack[v_top];
	X	       		    break;
	X	   case OR_OP     : temp = ((unsigned int) v_stack[v_top - 1]) | ((unsigned int) v_stack[v_top]);
	X	       		    v_stack[v_top - 1] = (double) temp;
	X	       		    break;
	X	   case ROL_OP    : for (i = (unsigned int) v_stack[v_top], temp = (unsigned int) v_stack[v_top - 1]; i; i--)
	X	   		       temp = (temp << 1) + ((((unsigned) temp) >> (curr_width[index_of(curr_base)] - 1)) & 1);
	X	   		    v_stack[v_top - 1] = (double) low_order(curr_width[index_of(curr_base)], temp);
	X	       		    break;
	X	   case ROOT_OP   : v_stack[v_top - 1] = pow(v_stack[v_top - 1], 1.0 / v_stack[v_top]);
	X	       		    break;
	X	   case ROR_OP    : for (i = (unsigned int) v_stack[v_top], temp = (unsigned int) v_stack[v_top - 1]; i; i--)
	X	   		       temp = (((unsigned) temp) >> 1) + ((temp & 1) << (curr_width[index_of(curr_base)] - 1));
	X	   		    v_stack[v_top - 1] = (double) low_order(curr_width[index_of(curr_base)], temp);
	X	       		    break;
	X	   case RSA_OP    : temp = ((unsigned int) v_stack[v_top - 1]) >> ((unsigned int) v_stack[v_top]);
	X	       		    v_stack[v_top - 1] = (double) temp;
	X	       		    break;
	X	   case RSL_OP    : temp = ((unsigned int) ((unsigned int) v_stack[v_top - 1])) >> ((unsigned int) v_stack[v_top]);
	X	       		    v_stack[v_top - 1] = (double) temp;
	X	       		    break;
	X	   case SUB_OP    : v_stack[v_top - 1] -= v_stack[v_top];
	X	       		    break;
	X	   case XOR_OP    : temp = ((unsigned int) v_stack[v_top - 1]) ^ ((unsigned int) v_stack[v_top]);
	X	       		    v_stack[v_top - 1] = (double) temp;
	X	       		    break;
	X	   case Y2X_OP    : v_stack[v_top - 1] = pow(v_stack[v_top - 1], v_stack[v_top]);
	X	       		    break;
	X	   }
	X	v_top--;
	X}
	X
	XPRIVATE	reduce_stack(pr)
	X
	Xint	pr;
	X
	X{
	X	while (o_top > 0 && pr <= prec(o_stack[o_top - 1]))
	X	   pop_op();
	X}
	X
	XPRIVATE	double	to_rads(val)
	X
	Xdouble	val;
	X
	X{
	X	if (trig_mode == DEG)
	X	   return(val / 180.0 * PI);
	X	else if (trig_mode == GRAD)
	X	   return(val / 200.0 * PI);
	X	else
	X	   return(val);
	X}
	X
	XPRIVATE	double	from_rads(val)
	X
	Xdouble	val;
	X
	X{
	X	if (trig_mode == DEG)
	X	   return(val / PI * 180.0);
	X	else if (trig_mode == GRAD)
	X	   return(val / PI * 200.0);
	X	else
	X	   return(val);
	X}
	X
	XPUBLIC	char	*op_str(op)
	X
	Xint	op;
	X
	X{
	X	switch (op) {
	X	   case ADD_OP    : return("+");
	X	   case AND_OP    : return("&");
	X	   case DIV_OP    : return("\205");
	X	   case LPAREN_OP : return("(");
	X	   case LSL_OP    : return("\200");
	X	   case MUL_OP    : return("X");
	X	   case OR_OP     : return("|");
	X	   case ROL_OP    : return("\202");
	X	   case ROOT_OP   : return("\207\210");
	X	   case ROR_OP    : return("\203");
	X	   case RSA_OP    : return("\204");
	X	   case RSL_OP    : return("\201");
	X	   case SUB_OP    : return("-");
	X	   case XOR_OP    : return("^");
	X	   case Y2X_OP    : return("\206");
	X	   default	  : return("");
	X	   }
	X}
	X
	XPUBLIC	do_unary(op)
	X
	Xint	op;
	X
	X{	int	temp;
	X
	X	convert_display();
	X	switch (op) {
	X	   case CLEAR_OP  : v_stack[v_top = 0] = 0.0;
	X	   		    o_top = 0;
	X	   		    break;
	X	   case ERASE_OP  : clear_entry();
	X	   		    do_digit(DIGIT_0);
	X	   		    break;
	X	   case EQUAL_OP  : reduce_stack(-1);
	X	   		    break;
	X	   case LPAREN_OP : o_stack[o_top++] = LPAREN_OP;
	X	   		    break;
	X	   case RPAREN_OP : reduce_stack(prec(op));
	X	   		    o_top--;
	X	   		    break;
	X	   case INVEE_OP  : ee_mode = FALSE;
	X	   		    break;
	X	   case COS_OP    : v_stack[v_top] = cos(to_rads(v_stack[v_top]));
	X	      		    break;
	X	   case EXP_OP    : v_stack[v_top] = exp(v_stack[v_top]);
	X	      		    break;
	X	   case E_OP      : v_stack[v_top] = E;
	X	      		    break;
	X	   case FACT_OP   : temp = (int) v_stack[v_top];
	X	      		    if (temp < 0 || temp > 170)
	X	      		       v_stack[v_top] /= 0.0;
	X	      		    else if (temp == 0)
	X	      		       v_stack[v_top] = 1.0;
	X	      		    else
	X	      		       for (v_stack[v_top] = 1.0; temp; temp--)
	X	      		          v_stack[v_top] *= (double) temp;
	X	      		    break;
	X	   case ICOS_OP   : v_stack[v_top] = from_rads(acos(v_stack[v_top]));
	X	      		    break;
	X	   case INT_OP    : v_stack[v_top] = (double) ((int) v_stack[v_top]);
	X	      		    break;
	X	   case ISIN_OP   : v_stack[v_top] = from_rads(asin(v_stack[v_top]));
	X	      		    break;
	X	   case ITAN_OP   : v_stack[v_top] = from_rads(atan(v_stack[v_top]));
	X	      		    break;
	X	   case LN_OP     : v_stack[v_top] = log(v_stack[v_top]);
	X	      		    break;
	X	   case LOG_OP    : v_stack[v_top] = log10(v_stack[v_top]);
	X	      		    break;
	X	   case NOT_OP    : v_stack[v_top] = (double) low_order(curr_width[index_of(curr_base)], (~ (unsigned int) v_stack[v_top]));
	X	      		    break;
	X	   case OVER_OP   : v_stack[v_top] = 1.0 / v_stack[v_top];
	X	      		    break;
	X	   case PI_OP     : v_stack[v_top] = PI;
	X	      		    break;
	X	   case POW_OP    : v_stack[v_top] = pow(10.0, v_stack[v_top]);
	X	      		    break;
	X	   case SIN_OP    : v_stack[v_top] = sin(to_rads(v_stack[v_top]));
	X	      		    break;
	X	   case SQRT_OP   : v_stack[v_top] = sqrt(v_stack[v_top]);
	X	      		    break;
	X	   case SQR_OP    : v_stack[v_top] *= v_stack[v_top];
	X	      		    break;
	X	   case TAN_OP    : v_stack[v_top] = tan(to_rads(v_stack[v_top]));
	X	      		    break;
	X	   case TRUNC_OP  : if (curr_width[0] != -1) {
	X	      		       v_stack[v_top] *= pow(10.0, (double) curr_width[0]);
	X	      		       v_stack[v_top] = (double) ((int) v_stack[v_top]);
	X	      		       v_stack[v_top] /= pow(10.0, (double) curr_width[0]);
	X	      		       }
	X	      		     break;
	X	      }
	X	update_display();
	X}
	X
	XPUBLIC	do_binary(op)
	X
	Xint	op;
	X
	X{
	X	convert_display();
	X	reduce_stack(prec(op));
	X	o_stack[o_top++] = op;
	X	v_top += 1;
	X	v_stack[v_top] = v_stack[v_top - 1];
	X	update_display();
	X}
SHAR_EOF
if test 8116 -ne "`wc -c < 'ops.c'`"
then
	echo shar: error transmitting "'ops.c'" '(should have been 8116 characters)'
fi
fi # end of overwriting check
echo shar: extracting "'screen.c'" '(16521 characters)'
if test -f 'screen.c'
then
	echo shar: will not over-write existing file "'screen.c'"
else
sed 's/^	X//' << \SHAR_EOF > 'screen.c'
	X/************************************************************************/
	X/*	Copyright 1988 by Chuck Musciano and Harris Corporation		*/
	X/*									*/
	X/*	Permission to use, copy, modify, and distribute this software	*/
	X/*	and its documentation for any purpose and without fee is	*/
	X/*	hereby granted, provided that the above copyright notice	*/
	X/*	appear in all copies and that both that copyright notice and	*/
	X/*	this permission notice appear in supporting documentation, and	*/
	X/*	that the name of Chuck Musciano and Harris Corporation not be	*/
	X/*	used in advertising or publicity pertaining to distribution	*/
	X/*	of the software without specific, written prior permission.	*/
	X/*	Chuck Musciano and Harris Corporation make no representations	*/
	X/*	about the suitability of this software for any purpose.  It is	*/
	X/*	provided "as is" without express or implied warranty.		*/
	X/************************************************************************/
	X
	X/************************************************************************/
	X/*									*/
	X/*	Module:		screen.c					*/
	X/*									*/
	X/*	Function:	Create calculator display			*/
	X/*									*/
	X/*	Public Names:	create_screen	create the screen		*/
	X/*			invert_proc	invert the keyboard		*/
	X/*			blink		flash a key			*/
	X/*			main		entry point			*/
	X/*									*/
	X/*	Change History:	11 Nov 86	Creation			*/
	X/*									*/
	X/************************************************************************/
	X
	X#include	<stdio.h>
	X
	X#include	<suntool/sunview.h>
	X#include	<suntool/panel.h>
	X#include	<suntool/canvas.h>
	X
	X#include	"manifest.h"
	X#include	"globals.h"
	X#include	"keys.h"
	X
	X#define		CLOSE_KEY			key[0]
	X#define		INVERSE_KEY			key[1]
	X#define		CLEAR_KEY			key[2]
	X#define		FIRST_KEY			3
	X#define		LAST_KEY			37
	X
	X#define		k(s1, s2, s3, s4, o1, o2, o3, o4, p)	{{s1, s2, s3, s4}, {o1, o2, o3, o4}, {NULL, NULL, NULL, NULL}, NULL, p}
	X#define		valid_key(x)				((x) > DIGIT_F || (x) < curr_base)
	X
	XPRIVATE	close_proc();
	XPRIVATE	event_proc();
	XPRIVATE	key_proc();
	XPRIVATE	radix_proc();
	XPRIVATE	kb_proc();
	X
	XPUBLIC	store_proc();
	XPUBLIC	recall_proc();
	XPUBLIC	exchange_proc();
	XPUBLIC	fix_proc();
	XPUBLIC	invert_proc();
	X
	Xtypedef	struct	key_rec	*key_ptr;
	X
	Xstruct	key_rec	{char		*label[4];
	X		 int		opcode[4];
	X		 struct	pixrect	*image[4];
	X		 Panel_item	item;
	X		 int		(*proc)();
	X		};
	X
	XFrame	bf;
	XPanel	keys, sw;
	XCanvas	display;
	Xstruct	pixfont	*key_font;
	X
	XPRIVATE	short	mask_bits[] = {0xaaaa, 0x5555};
	Xmpr_static(mask, 16, 2, 1, mask_bits);
	X
	XPRIVATE	struct	key_rec	key[] = {
	X	k(       "Close",         "Quit",        "Close",         "Quit",  CLOSE_OP,   QUIT_OP,  CLOSE_OP,   QUIT_OP,    close_proc),
	X	k(     "Inverse",      "Inverse",      "Inverse",      "Inverse", INVERT_OP, INVERT_OP, INVERT_OP, INVERT_OP,   invert_proc),
	X	k(       "Erase",        "Clear",        "Erase",        "Clear",  ERASE_OP,  CLEAR_OP,  ERASE_OP,  CLEAR_OP,      key_proc),
	X	k(         "Sto",             "",          "Sto",             "",    STO_OP,     NO_OP,    STO_OP,     NO_OP,    store_proc),
	X	k(         "Rcl",             "",          "Rcl",             "",    RCL_OP,     NO_OP,    RCL_OP,     NO_OP,   recall_proc),
	X	k(         "Exc",             "",          "Exc",             "",    EXC_OP,     NO_OP,    EXC_OP,     NO_OP, exchange_proc),
	X	k(           "(",             "",            "(",             "", LPAREN_OP,     NO_OP, LPAREN_OP,     NO_OP,      key_proc),
	X	k(           ")",             "",            ")",             "", RPAREN_OP,     NO_OP, RPAREN_OP,     NO_OP,      key_proc),
	X	k(          "EE",           "EE",             "",             "",  DIGIT_EE,  INVEE_OP,     NO_OP,     NO_OP,      key_proc),
	X	k(           "X",             "",            "X",             "",    MUL_OP,     NO_OP,    MUL_OP,     NO_OP,      key_proc),
	X	k(         "log",       "10\200",            "D",             "",    LOG_OP,    POW_OP,   DIGIT_D,     NO_OP,      key_proc),
	X	k(          "ln",        "e\200",            "E",             "",     LN_OP,    EXP_OP,   DIGIT_E,     NO_OP,      key_proc),
	X	k(       "y\200",     "\203\204",            "F",             "",    Y2X_OP,   ROOT_OP,   DIGIT_F,     NO_OP,      key_proc),
	X	k(           "7",             "",            "7",             "",   DIGIT_7,     NO_OP,   DIGIT_7,     NO_OP,      key_proc),
	X	k(           "8",             "",            "8",             "",   DIGIT_8,     NO_OP,   DIGIT_8,     NO_OP,      key_proc),
	X	k(           "9",             "",            "9",             "",   DIGIT_9,     NO_OP,   DIGIT_9,     NO_OP,      key_proc),
	X	k(        "\214",             "",         "\214",             "",    DIV_OP,     NO_OP,    DIV_OP,     NO_OP,      key_proc),
	X	k(         "sin",       "sn\205",            "A",             "",    SIN_OP,   ISIN_OP,   DIGIT_A,     NO_OP,      key_proc),
	X	k(         "cos",       "cs\205",            "B",             "",    COS_OP,   ICOS_OP,   DIGIT_B,     NO_OP,      key_proc),
	X	k(         "tan",       "tn\205",            "C",             "",    TAN_OP,   ITAN_OP,   DIGIT_C,     NO_OP,      key_proc),
	X	k(           "4",             "",            "4",             "",   DIGIT_4,     NO_OP,   DIGIT_4,     NO_OP,      key_proc),
	X	k(           "5",             "",            "5",             "",   DIGIT_5,     NO_OP,   DIGIT_5,     NO_OP,      key_proc),
	X	k(           "6",             "",            "6",             "",   DIGIT_6,     NO_OP,   DIGIT_6,     NO_OP,      key_proc),
	X	k(           "+",             "",            "+",             "",    ADD_OP,     NO_OP,    ADD_OP,     NO_OP,      key_proc),
	X	k(    "\202\201",        "x\206",           "<<",     "\217\220",   SQRT_OP,    SQR_OP,    LSL_OP,    ROL_OP,      key_proc),
	X	k(    "\210\211",             "",          "Not",       "\221>>",   OVER_OP,     NO_OP,    NOT_OP,    RSA_OP,      key_proc),
	X	k(          "x!",             "",           ">>",     "\215\216",   FACT_OP,     NO_OP,    RSL_OP,    ROR_OP,      key_proc),
	X	k(           "1",             "",            "1",             "",   DIGIT_1,     NO_OP,   DIGIT_1,     NO_OP,      key_proc),
	X	k(           "2",             "",            "2",             "",   DIGIT_2,     NO_OP,   DIGIT_2,     NO_OP,      key_proc),
	X	k(           "3",             "",            "3",             "",   DIGIT_3,     NO_OP,   DIGIT_3,     NO_OP,      key_proc),
	X	k(           "-",             "",            "-",             "",    SUB_OP,     NO_OP,    SUB_OP,     NO_OP,      key_proc),
	X	k(        "\207",            "e",          "And",             "",     PI_OP,      E_OP,    AND_OP,     NO_OP,      key_proc),
	X	k(         "Int",          "Trc",           "Or",          "Xor",    INT_OP,  TRUNC_OP,     OR_OP,    XOR_OP,      key_proc),
	X	k(         "Fix",          "DRG",          "Fix",             "",    FIX_OP,    FIX_OP,    FIX_OP,     NO_OP,      fix_proc),
	X	k(           ".",             "",             "",             "", DIGIT_DOT,     NO_OP,     NO_OP,     NO_OP,      key_proc),
	X	k(           "0",             "",            "0",             "",   DIGIT_0,     NO_OP,   DIGIT_0,     NO_OP,      key_proc),
	X	k(    "\212\213",             "",     "\212\213",             "", DIGIT_CHS,     NO_OP, DIGIT_CHS,     NO_OP,      key_proc),
	X	k(           "=",             "",            "=",             "",  EQUAL_OP,     NO_OP,  EQUAL_OP,     NO_OP,      key_proc)
	X	};
	X
	Xstatic	short	ct_icon_image[] = {
	X#include	"calc.icon"
	X};
	Xmpr_static(ct_icon_pixrect, 47, 64, 1, ct_icon_image);
	X
	XPUBLIC	create_screen(argc, argv)
	X
	Xint	argc;
	Xchar	**argv;
	X
	X{	int	i, j;
	X	Icon	icon;
	X
	X	icon = icon_create(ICON_IMAGE, &ct_icon_pixrect, ICON_LABEL, NULL, ICON_WIDTH, 47, ICON_HEIGHT, 64, 0);
	X	bf = window_create(NULL, FRAME,
	X			      FRAME_ARGS, argc, argv,
	X			      FRAME_LABEL, "<< Calctool >>",
	X			      FRAME_ICON, icon,
	X			      FRAME_SUBWINDOWS_ADJUSTABLE, FALSE,
	X			      FRAME_NO_CONFIRM, TRUE,
	X			   0);
	X	sw = window_create(bf, PANEL, 0);
	X	display = window_create(bf, CANVAS, 0);
	X	keys = window_create(bf, PANEL, 
	X				WIN_WIDTH, 360,
	X				PANEL_ACCEPT_KEYSTROKE, TRUE,
	X				PANEL_BACKGROUND_PROC, kb_proc,
	X			     0);
	X
	X	if ((key_font = pf_open(KEY_FONT)) == NULL) {
	X	   fprintf(stderr, "calctool: could not open font %s\n", KEY_FONT);
	X	   exit(1);
	X	   }
	X	for (i = 0; i < FIRST_KEY; i++)
	X	   for (j = 0; j < 4; j++)
	X	      key[i].image[j] = panel_button_image((i == 0)? sw : keys, key[i].label[j], 7, key_font);
	X	for (i = FIRST_KEY; i <= LAST_KEY; i++)
	X	   for (j = 0; j < 4; j += 2)
	X	      if (key[i].opcode[j] != NO_OP) {
	X	         key[i].image[j] = panel_button_image(sw, key[i].label[j], 3, key_font);
	X	         if (key[i].opcode[j + 1] == NO_OP) {
	X	            key[i].image[j + 1] = panel_button_image(sw, key[i].label[j], 3, key_font);
	X	            pr_replrop(key[i].image[j+1], 0, 0, key[i].image[j+1]->pr_width, key[i].image[j+1]->pr_height,
	X	                   PIX_SRC & PIX_DST, &mask, 0, 0);
	X	            }
	X	         else
	X	            key[i].image[j+1] = panel_button_image(sw, key[i].label[j+1], 3, key_font);
	X	         }
	X
	X	CLOSE_KEY.item = panel_create_item(sw, PANEL_BUTTON,
	X					      PANEL_LABEL_IMAGE, CLOSE_KEY.image[0],
	X					      PANEL_NOTIFY_PROC, CLOSE_KEY.proc,
	X					      PANEL_EVENT_PROC, event_proc,
	X					      PANEL_CLIENT_DATA, &(CLOSE_KEY),
	X					   0);
	X	window_fit(sw);
	X
	X	INVERSE_KEY.item = panel_create_item(keys, PANEL_BUTTON,
	X						PANEL_LABEL_IMAGE, INVERSE_KEY.image[0],
	X						PANEL_NOTIFY_PROC, INVERSE_KEY.proc,
	X					        PANEL_EVENT_PROC, event_proc,
	X						PANEL_CLIENT_DATA, &(INVERSE_KEY),
	X					     0);
	X	key[FIRST_KEY].item = panel_create_item(keys, PANEL_BUTTON,
	X						   PANEL_LABEL_IMAGE, key[FIRST_KEY].image[0],
	X						   PANEL_NOTIFY_PROC, key[FIRST_KEY].proc,
	X					           PANEL_EVENT_PROC, event_proc,
	X					           PANEL_ACCEPT_KEYSTROKE, TRUE,
	X						   PANEL_ITEM_X, panel_get(INVERSE_KEY.item, PANEL_ITEM_X),
	X						   PANEL_ITEM_Y, panel_get(INVERSE_KEY.item, PANEL_ITEM_Y) + 
	X						   		 INVERSE_KEY.image[0]->pr_height + 4,
	X						   PANEL_CLIENT_DATA, &(key[FIRST_KEY]),
	X						0);
	X	for (i = FIRST_KEY + 1; i <= LAST_KEY; i++)
	X	   key[i].item = panel_create_item(keys, PANEL_BUTTON,
	X	   				      PANEL_LABEL_IMAGE, key[i].image[0],
	X	   				      PANEL_NOTIFY_PROC, key[i].proc,
	X					      PANEL_EVENT_PROC, event_proc,
	X					      PANEL_ACCEPT_KEYSTROKE, TRUE,
	X	   				      PANEL_CLIENT_DATA, &(key[i]),
	X	   				   0);
	X	CLEAR_KEY.item = panel_create_item(keys, PANEL_BUTTON,
	X					      PANEL_LABEL_IMAGE, CLEAR_KEY.image[0],
	X					      PANEL_NOTIFY_PROC, CLEAR_KEY.proc,
	X					      PANEL_EVENT_PROC, event_proc,
	X					      PANEL_ITEM_X, panel_get(key[LAST_KEY].item, PANEL_ITEM_X) + 
	X							    key[LAST_KEY].image[0]->pr_width - CLEAR_KEY.image[0]->pr_width,
	X					      PANEL_ITEM_Y, panel_get(INVERSE_KEY.item, PANEL_ITEM_Y),
	X					      PANEL_CLIENT_DATA, &(CLEAR_KEY),
	X					   0);
	X	panel_create_item(keys, PANEL_CHOICE,
	X			     PANEL_LABEL_STRING, "",
	X			     PANEL_DISPLAY_LEVEL, PANEL_CURRENT,
	X			     PANEL_CHOICE_IMAGES, panel_button_image(keys, "Scientific", 13, key_font),
	X			     			  panel_button_image(keys, "Engineering", 13, key_font),
	X			     			  panel_button_image(keys, "Binary", 13, key_font),
	X			     			  panel_button_image(keys, "Octal", 13, key_font),
	X			     			  panel_button_image(keys, "Hexadecimal", 13, key_font),
	X			     			  0,
	X			     PANEL_CHOICE_XS, panel_get(key[FIRST_KEY + 2].item, PANEL_ITEM_X), 0,
	X			     PANEL_CHOICE_YS, panel_get(INVERSE_KEY.item, PANEL_ITEM_Y), 0,
	X/*			     PANEL_CHOICE_FONTS, key_font, 0,*/
	X			     PANEL_NOTIFY_PROC, radix_proc,
	X			  0);
	X	window_fit(keys);
	X
	X	window_set(sw,
	X		      WIN_X, 0,
	X		      WIN_Y, 0,
	X		   0);
	X	window_set(display,
	X		      WIN_RIGHT_OF, sw,
	X		      WIN_Y, 0,
	X		      WIN_WIDTH, window_get(keys, WIN_WIDTH) - window_get(sw, WIN_WIDTH) - 5,
	X		      WIN_HEIGHT, window_get(sw, WIN_HEIGHT),
	X		   0);
	X	window_set(keys,
	X		      WIN_X, 0,
	X		      WIN_BELOW, sw,
	X		   0);
	X	window_fit(bf);
	X	window_set(sw, 
	X		      WIN_WIDTH, window_get(sw, WIN_WIDTH),
	X		      WIN_HEIGHT, window_get(sw, WIN_HEIGHT),
	X		   0);
	X	window_set(display, 
	X		      WIN_WIDTH, window_get(display, WIN_WIDTH),
	X		      WIN_HEIGHT, window_get(display, WIN_HEIGHT),
	X		   0);
	X	window_set(keys, 
	X		      WIN_WIDTH, window_get(keys, WIN_WIDTH),
	X		      WIN_HEIGHT, window_get(keys, WIN_HEIGHT),
	X		   0);
	X	update_display();
	X	window_main_loop(bf);
	X}
	X
	XPRIVATE	close_proc()
	X
	X{
	X	if (inverted ^ temp_inverted) {
	X	   window_destroy(bf);
	X	   exit(0);
	X	   }
	X	else {
	X	   window_set(bf, FRAME_CLOSED, TRUE, 0);
	X	   temp_inverted = FALSE;
	X	   if (inverted)
	X	      invert_proc();
	X	   }
	X}
	X
	XPUBLIC	invert_proc()
	X
	X{	int	i;
	X
	X	temp_inverted = FALSE;
	X	inverted = !inverted;
	X	for (i = 0; i <= LAST_KEY; i++)
	X	   if (key[i].image[curr_mode + (inverted? 1 : 0)] && valid_key(key[i].opcode[curr_mode]))
	X	      panel_set(key[i].item, PANEL_LABEL_IMAGE, key[i].image[curr_mode + (inverted? 1 : 0)], PANEL_SHOW_ITEM, TRUE, 0);
	X	   else
	X	      panel_set(key[i].item, PANEL_SHOW_ITEM, FALSE, 0);
	X}
	X
	XPRIVATE	radix_proc(item, value, event)
	X
	XPanel_item	item;
	Xint		value;
	XEvent		*event;
	X
	X{	int	i;
	X	static	int	bases[] = {DECIMAL, DECIMAL, BINARY, OCTAL, HEXADECIMAL};
	X
	X	convert_display();
	X	if (value == 0) {
	X	   curr_mode = SCIENTIFIC;
	X	   eng_mode = FALSE;
	X	   }
	X	else if (value == 1) {
	X	   curr_mode = SCIENTIFIC;
	X	   eng_mode = TRUE;
	X	   }
	X	else
	X	   curr_mode = PROGRAMMER;
	X	curr_base = bases[value];
	X	inverted = temp_inverted = FALSE;
	X	for (i = FIRST_KEY; i <= LAST_KEY; i++)
	X	   if (key[i].opcode[curr_mode] != NO_OP && valid_key(key[i].opcode[curr_mode]))
	X	      panel_set(key[i].item, PANEL_LABEL_IMAGE, key[i].image[curr_mode], PANEL_SHOW_ITEM, TRUE, 0);
	X	   else
	X	      panel_set(key[i].item, PANEL_SHOW_ITEM, FALSE, 0);
	X	update_display();
	X}
	X
	XPRIVATE	event_proc(item, event)
	X
	XPanel_item	item;
	XEvent		*event;
	X
	X{	key_ptr	ky;
	X	static	key_ptr	curr_key;
	X	int	op;
	X
	X	if (event_id(event) >= ASCII_FIRST && event_id(event) <= ASCII_LAST) {
	X	   keyboard(event_id(event));
	X	   return;
	X	   }
	X	ky = (key_ptr) panel_get(item, PANEL_CLIENT_DATA);
	X	switch (event_id(event)) {
	X	   case MS_LEFT            : if (ky->opcode[curr_mode + (inverted? 1 : 0)] != NO_OP)
	X					if (event_is_down(event)) {
	X					   panel_begin_preview(item, event);
	X					   curr_key = ky;
	X					   }
	X					else if (curr_key == ky) {
	X					   panel_accept_preview(item, event);
	X					   curr_key = NULL;
	X					   }
	X				     break;
	X	   case MS_MIDDLE          : if (ky->opcode[curr_mode + (inverted? 0 : 1)] != NO_OP)
	X					if (event_is_down(event)) {
	X					   panel_set(item, PANEL_LABEL_IMAGE, ky->image[curr_mode + (inverted? 0 : 1)], 0);
	X					   panel_begin_preview(item, event);
	X					   curr_key = ky;
	X					   }
	X					else if (curr_key == ky) {
	X					   temp_inverted = TRUE;
	X					   panel_accept_preview(item, event);
	X					   panel_set(item, PANEL_LABEL_IMAGE, ky->image[curr_mode + (inverted? 1 : 0)], 0);
	X					   curr_key = NULL;
	X					   }
	X	      			     break;
	X	   case MS_RIGHT	   : if (event_is_down(event))
	X					if ((op = ky->opcode[curr_mode + (inverted? 1 : 0)]) == STO_OP ||
	X					     op == RCL_OP ||
	X					     op == EXC_OP ||
	X					     op == FIX_OP) {
	X					   panel_begin_preview(item, event);
	X					   panel_accept_preview(item, event);
	X					   }
	X				     break;
	X	   case PANEL_EVENT_CANCEL : if (curr_key == ky) {
	X					panel_cancel_preview(item, event);
	X					panel_set(item, PANEL_LABEL_IMAGE, ky->image[curr_mode + (inverted? 1 : 0)], 0);
	X					curr_key = NULL;
	X					}
	X				     break;
	X	   }
	X}
	X
	XPRIVATE	key_proc(item, event)
	X
	XPanel_item	item;
	XEvent		*event;
	X
	X{	key_ptr	ky;
	X	int	op;
	X
	X	ky = (key_ptr) panel_get(item, PANEL_CLIENT_DATA);
	X	op = ky->opcode[curr_mode + ((inverted? 1 : 0) ^ temp_inverted)];
	X	if (is_digit(op))
	X	   do_digit(op);
	X	else if (is_binary(op))
	X	   do_binary(op);
	X	else
	X	   do_unary(op);
	X	temp_inverted = FALSE;
	X	if (inverted)
	X	   invert_proc();
	X}
	X
	XPRIVATE	kb_proc(item, event)
	X
	XPanel_item	item;
	XEvent		*event;
	X
	X{
	X	if (event_id(event) >= ASCII_FIRST && event_id(event) <= ASCII_LAST)
	X	   keyboard(event_id(event));
	X}
	X
	XPUBLIC	int	blink(op)
	X
	Xint	op;
	X
	X{	int	i, j;
	X	struct	pixrect	*old, *new;
	X
	X	for (i = FIRST_KEY; i <= LAST_KEY; i++)
	X	   if (op == key[i].opcode[curr_mode])
	X	      break;
	X	old = (struct pixrect *) panel_get(key[i].item, PANEL_LABEL_IMAGE);
	X	new = mem_create(old->pr_width, old->pr_height, 1);
	X	pr_rop(new, 0, 0, new->pr_width, new->pr_height, PIX_NOT(PIX_SRC), old, 0, 0);
	X	panel_set(key[i].item, PANEL_LABEL_IMAGE, new, 0);
	X	for (j = 25000; j; j--)
	X	   ;
	X	panel_set(key[i].item, PANEL_LABEL_IMAGE, old, 0);
	X	pr_destroy(new);
	X	return(op);
	X}
	X
	Xmain(argc, argv)
	X
	Xint	argc;
	Xchar	**argv;
	X
	X{
	X	create_screen(argc, argv);
	X}
SHAR_EOF
if test 16521 -ne "`wc -c < 'screen.c'`"
then
	echo shar: error transmitting "'screen.c'" '(should have been 16521 characters)'
fi
fi # end of overwriting check
#	End of shell archive
exit 0