Usenet 1994 January/usenetsourcesnewsgroupsinfomagicjanuary1994.iso/sources/x/volume5/macstr/part01

Internet Message Format | 1989-12-06 | 47.8 KB

Path: uunet!island!argv
From: [e-mail] (Dan Heller)
Newsgroups: comp.sources.x
Subject: v05i037: macro-string enhancement for Xterm, Part01/01
Message-ID: <[e-mail]>
Date: 5 Dec 89 19:06:04 GMT
Organization: Island Graphics, Marin County, California
Lines: 1657
Approved: island![e-mail]

Submitted-by: uunet!zax!sci!jimmc (Jim McBeath)
Posting-number: Volume 5, Issue 37
Archive-name: macstr/part01



#! /bin/sh
##  This is a shell archive.  Remove anything before this line, then unpack
##  it by saving it into a file and typing "sh file".  To overwrite existing
##  files, type "sh file -c".  You can also feed this as standard input via
##  unshar, or by typing "sh <file".  If this archive is complete, you will
##  see the following message at the end:
#        "End of shell archive."
# Contents:  README.macrostr xterm.man.diff Imakefile.diff
#   Makefile.diff ptyx.h.diff charproc.c.diff macrostr.c
# Wrapped by jimmc@zax on Mon Nov 13 17:14:21 1989
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f README.macrostr -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"README.macrostr\"
else
echo shar: Extracting \"README.macrostr\" \(553 characters\)
sed "s/^X//" >README.macrostr <<'END_OF_README.macrostr'
XThe macro string package is intended to allow xterm to generate the character
Xsequences for button presses on just about any terminal you can think of.
XIt is a general enough mechanism that you may find other uses for it as well.
XInstallation requires the addition of one major new file (macrostr.c) and some
Xone-line changes to a few other files.  See the updated man pages for details
Xon how the macro string capability is used.  Copyright has been donated to
XMIT using their standard copyright notice.
X
XJim McBeath    13.Nov.89
Xsci![e-mail]
END_OF_README.macrostr
if test 553 -ne `wc -c <README.macrostr`; then
    echo shar: \"README.macrostr\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f xterm.man.diff -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"xterm.man.diff\"
else
echo shar: Extracting \"xterm.man.diff\" \(14424 characters\)
sed "s/^X//" >xterm.man.diff <<'END_OF_xterm.man.diff'
X1c1
X< .TH XTERM 1 "25 October 1988" "X Version 11"
X---
X> .TH XTERM 1 " 7 November 1989" "X Version 11"
X222c222
X< cause the window to be repositioned automatically in the normal postion at the
X---
X> cause the window to be repositioned automatically in the normal position at the
X264c264
X< This option indicates that a visual bell is prefered over an audible one.
X---
X> This option indicates that a visual bell is preferred over an audible one.
X286c286
X< This option specifies the prefered size and position of the Tektronix window.
X---
X> This option specifies the preferred size and position of the Tektronix window.
X290c290
X< This option specifies the prefered position of the icon window.
X---
X> This option specifies the preferred position of the icon window.
X316c316
X< instead of the user's shell.  \fBThis option has been superceeded by the new
X---
X> instead of the user's shell.  \fBThis option has been superceded by the new
X358c358
X< This option specifies the prefered size and position of the VT102 window;
X---
X> This option specifies the preferred size and position of the VT102 window;
X376c376
X< Specifies the prefered size and position of the application when iconified.
X---
X> Specifies the preferred size and position of the application when iconified.
X457c457
X< Specifies the prefered size and position of the VT102 window.
X---
X> Specifies the preferred size and position of the VT102 window.
X460c460
X< Specifies the prefered size and position of the Tektronix window.
X---
X> Specifies the preferred size and position of the Tektronix window.
X713c713
X< To distinquish a pointer button from a key, the high bit of the character is
X---
X> To distinguish a pointer button from a key, the high bit of the character is
X785c785
X< X environments differ in their security conciousness.  The servers provided
X---
X> X environments differ in their security consciousness.  The servers provided
X911a912,919
X> .B macro-string(\fImacro-string\fB)
X> Rebinds the key or key sequence to the macro-string value.
X> When this action is executed, the macro string is processed, which normally
X> inserts a string into the input stream.
X> This capability is useful for emulating the wide variety of character sequences
X> that are produced by a button press on various terminals.
X> For more details, see the section "MACRO STRINGS" below.
X> .TP 15
X994a1003,1368
X> .SH "MACRO STRINGS"
X> .PP
X> Xterm includes a fairly general macro-string processing capability intended
X> to allow emulation of the button-press sequences of just about any terminal
X> type.
X> The macro-string processor is a simple stack machine which interprets a
X> macro string.
X> The macro string can contain commands which access state information
X> (such as the X and Y location of the mouse), manipulate the stack (such
X> as doing arithmetic operations), and insert text into the terminal
X> input buffer (which is the desired end result of the macro string).
X> There are rudimentary programming commands (conditional execution,
X> subroutine calls), built-in primitives and macro strings, and user-definable
X> macro strings.
X> .PP
X> A macro string is interpreted one token at a time.
X> Operations are expressed in RPN, i.e. operands first (which are placed onto
X> the stack) followed by operation (which operates on the stack).
X> White space in a macro string is ignored.
X> If there is an error in processing a macro string, the Bell() function
X> is called.
X> .PP
X> There are two data types: integer and string.
X> Boolean operations result in an integer where FALSE is represented by
X> 0 and TRUE is represented by 1.
X> When interpreting an integer as a Boolean, 0 is considered
X> FALSE and anything else is considered TRUE.
X> When interpreting a string as a Boolean, NULL or the empty string is
X> considered FALSE and anything else is considered TRUE.
X> .PP
X> In the descriptions below, the term TOS represents the value of the
X> top item on the stack, TOS-1 is the next-to-top, etc.
X> .PP
X> The macro-string commands are as follows:
X> .TP 15
X> .B "\'string\'"
X> Single-quoted string.
X> Pushes the quoted string onto the stack.
X> The string can contain any character except NULL and single quote.
X> There is no backslash notation and no provision for including a single
X> quote within a single-quoted string.
X> You can use a double-quoted string if you need to include a single
X> quote in your string.
X> Note also that the various parsers used to load this string (i.e. the
X> C compiler if it is a built-in macro string, or the resource manager if
X> it is from a resource or default file) can handle backslash notation, so
X> you can include control characters in a quoted string.
X> .TP 15
X> .ft 3
X> "string"
X> .}N
X> Double-quoted string.
X> Pushes the quoted string onto the stack.
X> This behaves in exactly the same way as a single-quoted string, except that
X> when using a double-quoted string you can include single quotes in the
X> string but not double quotes.
X> .TP 15
X> .B "printf formatting"
X> You can convert TOS to a string using standard printf formatting commands.
X> For example, if TOS is the integer 123, then the command "%04d" would
X> replace TOS with the string "0123", and the command "%X" would replace
X> TOS with the string "7B".
X> The formatting string is only a single "%" sequence, and only converts
X> the top item on the stack to a string.
X> .TP 15
X> .B "+"
X> Add or catenate.
X> If TOS and TOS-1 are both integers,
X> replaces TOS and TOS-1 with (TOS-1 + TOS).
X> If TOS and TOS-1 are both strings, replaces TOS and TOS-1 with
X> the catenation of TOS-1 and TOS.
X> .TP 15
X> .B "-"
X> Subtract.
X> Replaces TOS and TOS-1 with (TOS-1 - TOS).
X> TOS and TOS-1 must both be integers.
X> .TP 15
X> .B "*"
X> Multiply.
X> Replaces TOS and TOS-1 with (TOS-1 * TOS).
X> TOS and TOS-1 must both be integers.
X> .TP 15
X> .B "/"
X> Integer divide.
X> Replaces TOS and TOS-1 with (TOS-1 / TOS).
X> TOS and TOS-1 must both be integers.
X> .TP 15
X> .B "<<"
X> Left shift.
X> Replaces TOS and TOS-1 with (TOS-1 << TOS).
X> TOS and TOS-1 must both be integers.
X> .TP 15
X> .B ">>"
X> Right shift.
X> Replaces TOS and TOS-1 with (TOS-1 >> TOS).
X> TOS and TOS-1 must both be integers.
X> .TP 15
X> .B "|"
X> Bitwise OR.
X> Replaces TOS and TOS-1 with (TOS-1 | TOS).
X> TOS and TOS-1 must both be integers.
X> .TP 15
X> .B "||"
X> Logical OR.
X> Replaces TOS and TOS-1 with (TOS-1 || TOS).
X> TOS and TOS-1 are independently considered as Booleans.
X> .TP 15
X> .B "&"
X> Bitwise AND.
X> Replaces TOS and TOS-1 with (TOS-1 & TOS).
X> TOS and TOS-1 must both be integers.
X> .TP 15
X> .B "&&"
X> Logical AND.
X> Replaces TOS and TOS-1 with (TOS-1 && TOS).
X> TOS and TOS-1 are independently considered as Booleans.
X> .TP 15
X> .B "^"
X> Bitwise XOR.
X> Replaces TOS and TOS-1 with (TOS-1 ^ TOS).
X> TOS and TOS-1 must both be integers.
X> .TP 15
X> .B "^^"
X> Logical XOR.
X> Replaces TOS and TOS-1 with (TOS-1 ^^ TOS).
X> TOS and TOS-1 are independently considered as Booleans.
X> .TP 15
X> .B "!"
X> Logical NOT.
X> Replaces TOS by the logical inverse of TOS when considered as a Boolean.
X> .TP 15
X> .B "~"
X> Bitwise invert.
X> Replaces TOS by the bitwise inversion of TOS.
X> TOS must be an integer.
X> .TP 15
X> .B number
X> Numbers can be entered in decimal, octal or hexadecimal radix.
X> A simple string of digits, not starting with a 0, pushes a decimal
X> value onto the stack.
X> If the first digit in the string is 0 and the remainder of digits are
X> between 0 and 7, the number is input as an octal number and pushed onto
X> the stack.
X> If the first digit in the string is 0 and it is immediately followed
X> by x or X, the number is input as a hexadecimal number and pushed onto
X> the stack.
X> .TP 15
X> .B b
X> Pushes the button field from a button event onto the stack.
X> .TP 15
X> .B c
X> Pushes the cursor column from a key or button event onto the stack.
X> The leftmost column is column 0.
X> .TP 15
X> .B C
X> Pushes the column width of the screen onto the stack.
X> .TP 15
X> .B h
X> Pushes the pixel height of a character onto the stack.
X> .TP 15
X> .B H
X> Pushes the pixel height of the screen onto the stack.
X> .TP 15
X> .B i
X> Places TOS (must be a string) into the terminal input buffer
X> and pops it off the stack.
X> .TP 15
X> .B k
X> Pushes the keycode field from a key event onto the stack.
X> .TP 15
X> .B l
X> Puts the results of XLookupString on a key event onto the stack.
X> If XLookupString returns an error or no string, an empty string is
X> pushed onto the stack.
X> .TP 15
X> .B M
X> Pop TOS (which must be a string) and interpret the macro of that name.
X> The macro may be either a primitive or built-in (both compiled into xterm)
X> or a user-defined macro.
X> User defined macros override built-in macros, but not primitives.
X> The list of primitives and built-in macros is given below.
X> .TP 15
X> .B r
X> Pushes the cursor row from a key or button event onto the stack.
X> The topmost row is 0.
X> .TP 15
X> .B R
X> Pushes the row height of the screen onto the stack.
X> .TP 15
X> .B s
X> Pushes the state field from a key or button event onto the stack.
X> .TP 15
X> .B w
X> Pushes the pixel width of a character onto the stack.
X> .TP 15
X> .B W
X> Pushes the pixel width of the screen onto the stack.
X> .TP 15
X> .B x
X> Pushes the x pixel value from a key or button event onto the stack.
X> .TP 15
X> .B X
X> Pushes to x_root pixel value from a key or button event onto the stack.
X> .TP 15
X> .B y
X> Pushes the y pixel value from a key or button event onto the stack.
X> .TP 15
X> .B Y
X> Pushes the y_root pixel value from a key or button event onto the stack.
X> .TP 15
X> .B Z
X> Conditionally returns from (terminates) a macro.
X> Pops TOS and interprets it as a Bool; if TRUE, returns from the macro,
X> else does nothing.
X> .PP
X> Primitive functions are compiled into Xterm and can not be overridden.
X> The primitives are:
X> .TP 15
X> .B error
X> Generates an error; calls Bell() and aborts all macro string processing.
X> This is typically used with an "if" statement to abort a macro if
X> an error condition occurs.
X> .TP 15
X> .B exch
X> Exchanges TOS with TOS-1.
X> .TP 15
X> .B if
X> Examines TOS-1 as a Boolean; if TRUE, executes the macro named at TOS,
X> else does nothing.
X> In either case, the two values are popped off the stack before the
X> test is performed.
X> .TP 15
X> .B ifElse
X> Examines TOS-2 as a Boolean; if TRUE, executes the macro named at TOS-1,
X> else executes the macro named at TOS.
X> In either case, the three values are popped off the stack before the
X> test is performed.
X> .TP 15
X> .B limit
X> Limits TOS-2 to be between TOS-1 and TOS.
X> If TOS-2 is less than TOS-1, replaces it with TOS-1.
X> If TOS-2 is greater than TOS, replaces it with TOS.
X> All three items must be integers.
X> Pops two items off the stack, leaving only the limited number.
X> .TP 15
X> .B ord
X> Converts a one-character string at TOS to an integer with the
X> equivalent integer value (essentially a "scanf %c").
X> .TP 15
X> .B pop
X> Pops one item off the stack and discards it.
X> .TP 15
X> .B push
X> Pushes the top item onto the stack again, duplicating it.
X> .TP 15
X> .B tekScale
X> Pushes the tekScale field of the screen onto the stack.
X> Useful for emulating the Tektronix mode buttons.
X> .TP 15
X> .B toBool
X> Converts TOS to a Boolean (integer 0 or 1).
X>
X> .PP
X> There are a number of built-in macros, which are simply macro strings
X> which are compiled into xterm.
X> These built-ins can be overridden by a user defined macro.
X> The built-ins are listed below, with the definitions of some given
X> as examples.
X> .TP 15
X> .B SeikoButton
X> Generates the character sequence for button presses on a Seiko terminal.
X> There are a number of associated built-ins that are a part of this package:
X> SeikoGetX, SeikoGetY, SeikoSub1, SeikoEnd.
X> To set up your xterm so that it generates Seiko character sequences for
X> the buttons when the shift key is held down, you could add the following
X> lines to your resource file:
X> .sp
X> .Ds
X>  *VT100.translations: #override \\n\\
X>     Shift <BtnDown> : macro-string("'SeikoButton'M") \\n\\
X>     Shift <BtnUp> : ignore()
X> .De
X> .TP 15
X> .B X10Button
X> Generates the character sequence that the X10 xterm generated for button
X> pushes.
X> This macro is implemented with this string:
X> .sp
X> .Ds
X>  '\\033[M'i31b+%ci33c+%ci33r+%ci
X> .De
X> .TP 15
X> .B VT200ButtonPress
X> Generates the character sequence for a VT200 button press.
X> This macro is implemented with this string:
X> .sp
X> .Ds
X>  '\\033['iM31'VT200KeyState'M+b+%ci33c+%ci33r+%ci
X> .De
X> .TP 15
X> .B VT200KeyState
X> Called by the VT200ButtonPress macro.
X> This macro is implemented with this string:
X> .sp
X> .Ds
X>  s5&s8&2>>+
X> .De
X> .TP 15
X> .B TekButton
X> Generates the character sequence for a Tektronix button press.
X> Associated macros are TekGetBchar, TekGetlbchar, TekUcase, and TekSub1.
X> .TP 15
X> .B TestConst
X> Generates a character string with a number of screen-dependent values,
X> implemented with this string:
X> .sp
X> .Ds
X>  'h='ih%di' w='iw%di' H='iH%di' W='iW%di' R='iR%di' C='iC%di'\\n'i
X> .De
X> .TP 15
X> .B TestButton
X> Generates a character string with a number of position-dependent values,
X> suitable for binding to a button,
X> implemented with this string:
X> .sp
X> .Ds
X>  'x='ix%di' y='iy%di' X='iX%di' Y='iY%di\\
X>  ' r='ir%di' c='ic%di' b='ib%di' s='is%xi'\\n'i
X> .De
X> .TP 15
X> .B TestKey
X> Generates a character string with a number of position-dependent values,
X> suitable for binding to a key,
X> implemented with this string:
X> .sp
X> .Ds
X>  'x='ix%di' y='iy%di' X='iX%di' Y='iY%di\\
X>  ' r='ir%di' c='ic%di' k='ik%di' s='is%xi' l=\\"'ili'\\"\\n'i
X> .De
X> .PP
X> You could add the following bindings to execute the test macros to
X> see how the values look:
X> .sp
X> .Ds
X>  *VT100.translations: #override \\n\\
X>     <Key>F5 : macro-string("'TestConst'M") \\n\\
X>     <Key>F6 : macro-string("'TestKey'M")
X> .De
X> .PP
X> User defined macros can be specified in your resource or Xdefaults file.
X> Macros are searched for as subresources of the xterm widget, where the
X> subobject name is "macroString" and the subresource name is the macro name.
X> For example, to define a macro named foo that prints out the string
X> "button" and the button number, you could put this line in your resource file:
X> .sp
X> .Ds
X>  *VT100.macroString.foo: 'button 'i b%di
X> .De
X> .PP
X> You could then bind this macro to a key with a line like:
X> .sp
X> .Ds
X>  *VT100.translations: #override \\n\\
X>     <Key>F7 : macro-string("'foo'M")
X> .De
X>
X1125c1499
X< Consortium), Dave Serisky (HP)
X---
X> Consortium), Dave Serisky (HP), Jim McBeath (Silicon Compilers)
END_OF_xterm.man.diff
if test 14424 -ne `wc -c <xterm.man.diff`; then
    echo shar: \"xterm.man.diff\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f Imakefile.diff -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"Imakefile.diff\"
else
echo shar: Extracting \"Imakefile.diff\" \(1173 characters\)
sed "s/^X//" >Imakefile.diff <<'END_OF_Imakefile.diff'
X*** Imakefile.orig    Thu May 18 19:57:44 1989
X--- Imakefile    Fri Oct 27 13:44:02 1989
X***************
X*** 27,36 ****
X  /* add -DWTMP and -DLASTLOG if you want them */
X          DEFINES = -DMODEMENU -DUTMP -DBcopy=bcopy GettyProgram
X            SRCS1 = button.c charproc.c cursor.c data.c input.c \
X!           main.c menu.c misc.c screen.c scrollbar.c tabs.c \
X            TekPrsTbl.c Tekproc.c util.c VTPrsTbl.c
X            OBJS1 = main.o input.o charproc.o cursor.o util.o tabs.o \
X!           screen.o scrollbar.o button.o Tekproc.o misc.o \
X            VTPrsTbl.o TekPrsTbl.o data.o menu.o
X            SRCS2 = resize.c
X            OBJS2 = resize.o
X--- 27,36 ----
X  /* add -DWTMP and -DLASTLOG if you want them */
X          DEFINES = -DMODEMENU -DUTMP -DBcopy=bcopy GettyProgram
X            SRCS1 = button.c charproc.c cursor.c data.c input.c \
X!           macrostr.c main.c menu.c misc.c screen.c scrollbar.c tabs.c \
X            TekPrsTbl.c Tekproc.c util.c VTPrsTbl.c
X            OBJS1 = main.o input.o charproc.o cursor.o util.o tabs.o \
X!           screen.o scrollbar.o button.o Tekproc.o misc.o macrostr.o \
X            VTPrsTbl.o TekPrsTbl.o data.o menu.o
X            SRCS2 = resize.c
X            OBJS2 = resize.o
END_OF_Imakefile.diff
if test 1173 -ne `wc -c <Imakefile.diff`; then
    echo shar: \"Imakefile.diff\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f Makefile.diff -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"Makefile.diff\"
else
echo shar: Extracting \"Makefile.diff\" \(1055 characters\)
sed "s/^X//" >Makefile.diff <<'END_OF_Makefile.diff'
X*** Makefile.orig    Fri Oct 27 12:58:09 1989
X--- Makefile    Fri Oct 27 15:39:17 1989
X***************
X*** 167,176 ****
X
X          DEFINES = -DMODEMENU -DUTMP -DBcopy=bcopy
X            SRCS1 = button.c charproc.c cursor.c data.c input.c \
X!           main.c menu.c misc.c screen.c scrollbar.c tabs.c \
X            TekPrsTbl.c Tekproc.c util.c VTPrsTbl.c
X            OBJS1 = main.o input.o charproc.o cursor.o util.o tabs.o \
X!           screen.o scrollbar.o button.o Tekproc.o misc.o \
X            VTPrsTbl.o TekPrsTbl.o data.o menu.o
X            SRCS2 = resize.c
X            OBJS2 = resize.o
X--- 167,176 ----
X
X          DEFINES = -DMODEMENU -DUTMP -DBcopy=bcopy
X            SRCS1 = button.c charproc.c cursor.c data.c input.c \
X!           macrostr.c main.c menu.c misc.c screen.c scrollbar.c tabs.c \
X            TekPrsTbl.c Tekproc.c util.c VTPrsTbl.c
X            OBJS1 = main.o input.o charproc.o cursor.o util.o tabs.o \
X!           screen.o scrollbar.o button.o Tekproc.o misc.o macrostr.o \
X            VTPrsTbl.o TekPrsTbl.o data.o menu.o
X            SRCS2 = resize.c
X            OBJS2 = resize.o
END_OF_Makefile.diff
if test 1055 -ne `wc -c <Makefile.diff`; then
    echo shar: \"Makefile.diff\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ptyx.h.diff -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"ptyx.h.diff\"
else
echo shar: Extracting \"ptyx.h.diff\" \(701 characters\)
sed "s/^X//" >ptyx.h.diff <<'END_OF_ptyx.h.diff'
X*** ptyx.h.orig    Thu May 18 19:56:42 1989
X--- ptyx.h    Tue Nov  7 09:23:09 1989
X***************
X*** 191,196 ****
X--- 191,202 ----
X      int height;
X  } BitmapBits;
X
X+ typedef struct _userMacro {
X+     struct _userMacro *next;
X+     String name;
X+     String value;
X+ } UserMacro;
X+
X  #define    SAVELINES        64      /* default # lines to save      */
X
X  typedef struct {
X***************
X*** 344,349 ****
X--- 350,356 ----
X      Atom*        selection_atoms; /* which selections we own */
X      Cardinal    sel_atoms_size;    /*  how many atoms allocated */
X      Cardinal    selection_count; /* how many atoms in use */
X+     UserMacro    *userMacros;    /* list of user macro-strings */
X  } TScreen;
X
X  /* meaning of bits in screen.select flag */
END_OF_ptyx.h.diff
if test 701 -ne `wc -c <ptyx.h.diff`; then
    echo shar: \"ptyx.h.diff\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f charproc.c.diff -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"charproc.c.diff\"
else
echo shar: Extracting \"charproc.c.diff\" \(741 characters\)
sed "s/^X//" >charproc.c.diff <<'END_OF_charproc.c.diff'
X*** charproc.c.orig    Thu May 18 19:58:00 1989
X--- charproc.c    Fri Oct 27 13:45:47 1989
X***************
X*** 164,169 ****
X--- 164,170 ----
X  extern void HandleLeaveWindow();
X  extern void HandleFocusChange();
X         void HandleKeymapChange();
X+ extern void HandleMacroString();
X  extern void HandleModeMenu();
X  extern void HandleInsertSelection();
X  extern void HandleSelectStart();
X***************
X*** 210,215 ****
X--- 211,217 ----
X      { "insert",          HandleKeyPressed },
X      { "insert-selection", HandleInsertSelection },
X      { "keymap",       HandleKeymapChange },
X+     { "macro-string",      HandleMacroString },
X      { "mode-menu",      HandleModeMenu },
X      { "secure",          HandleSecure },
X      { "select-start",      HandleSelectStart },
END_OF_charproc.c.diff
if test 741 -ne `wc -c <charproc.c.diff`; then
    echo shar: \"charproc.c.diff\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f macrostr.c -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"macrostr.c\"
else
echo shar: Extracting \"macrostr.c\" \(24964 characters\)
sed "s/^X//" >macrostr.c <<'END_OF_macrostr.c'
X/* macrostr.c - handle macro string capability
X *
X * 26.Oct.89  Jim McBeath    Initial definition
X */
X
X/*
X * Copyright 1989 Massachusetts Institute of Technology
X *
X * Permission to use, copy, modify, distribute, and sell this software and its
X * documentation for any purpose is hereby granted without fee, provided that
X * the above copyright notice appear in all copies and that both that
X * copyright notice and this permission notice appear in supporting
X * documentation, and that the name of M.I.T. not be used in advertising or
X * publicity pertaining to distribution of the software without specific,
X * written prior permission.  M.I.T. makes no representations about the
X * suitability of this software for any purpose.  It is provided "as is"
X * without express or implied warranty.
X *
X * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
X * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T.
X * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
X * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
X * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
X * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
X *
X * Author:  Jim McBeath, Silicon Compiler Systems
X *          sci![e-mail]
X */
X
X#include <X11/Intrinsic.h>
X#include <X11/StringDefs.h>
X#include <ctype.h>
X#include "ptyx.h"
X
X#define TOS (stackCount-1)
X#define PUSHINT(n) if (!StackPushInt(n)) return FALSE
X
X/* inverse of CursorX and CursorY macros (except no topline used in Row) */
X#define CursorRow(screen,Y) (((Y) - screen->border)/FontHeight(screen))
X#define CursorCol(screen,X) (((X) - screen->scrollbar - screen->border) \
X    / FontWidth(screen))
X
Xextern char *malloc(), *realloc();
X
Xenum MacStackType { MacStackNull, MacStackInt, MacStackString };
X
Xtypedef struct _macstackentry {
X    enum MacStackType type;
X    union {
X        char *s;
X        int n;
X    } d;
X} MacStackEntry;
X
X/* The static variables in this module have a lifetime which is limited
X * to a single call to HandleMacroString.
X */
X
Xstatic Widget stackWidget;
Xstatic TScreen *stackScreen;
Xstatic XEvent *stackEvent;
X
X/* The value stack used by all of the macro processing functions */
Xstatic int stackAlloc;
Xstatic int stackCount;
Xstatic MacStackEntry *stack;
X
X/* A string buffer used by various parsing functions */
Xstatic int stackQAlloc;
Xstatic int stackQCount;
Xstatic char *Qstr;
X
X/* forward references for PrimTab */
Xextern int PrimToBool();
Xextern int PrimNot();
Xextern int PrimIfTrue();
Xextern int PrimIfElse();
Xextern int PrimPop();
Xextern int PrimPush();
Xextern int PrimExch();
Xextern int PrimLimit();
Xextern int PrimOrd();
Xextern int PrimReturn();
Xextern int PrimError();
Xextern int PrimTekScale();
X
X/* Table of named primitive functions */
Xstatic struct {
X    char *name;    /* name of the primitive function */
X    int (*func)();    /* returns TRUE if all OK, FALSE if problem */
X} PrimTab[] = {
X    {"error",    PrimError},
X    {"exch",    PrimExch},
X    {"if",        PrimIfTrue},
X    {"ifElse",    PrimIfElse},
X    {"limit",    PrimLimit},
X    {"ord",        PrimOrd},
X    {"pop",        PrimPop},
X    {"push",    PrimPush},
X    {"tekScale",    PrimTekScale},
X    {"toBool",    PrimToBool},
X};
X
X/* Table of built-in macro strings */
Xstatic struct {
X    char *name;    /* name of the built-in macro string */
X    char *str;    /* contents of the macro string */
X} BuiltinTab[] = {
X    {"SeikoButton",
X"'\033J'i'SeikoGetX'M'SeikoSub1'M'SeikoGetY'M'SeikoSub1'M'SeikoEnd'M"},
X    {"SeikoGetX",    "x48*w/1890-"},
X    {"SeikoGetY",    "1537y64*h/-"},
X    {"SeikoSub1",
X"'push'M'push'M10>>037&0140|%ci5>>037&0100|%ci037&040|%ci"},
X    {"SeikoEnd",    "' 'i31b3&+%ci'! !\r'i"},
X    {"X10Button",    "'\033[M'i31b+%ci33c+%ci33r+%ci"},
X    {"VT200KeyState",    "s5&s8&2>>+"},
X    {"VT200ButtonPress", "'\033['iM31'VT200KeyState'M+b+%ci33c+%ci33r+%ci"},
X    {"VT200ButtonOther", "'\033['iM32'VT200KeyState'M+3+%ci33c+%ci33r+%ci"},
X    {"TekButton",    "'TekGetBchar'M%ci\
Xx'tekScale'M/0 4096 1- 'limit'M'TekSu1'M \
X3072 34+ y'tekScale'/- 0 3072 1- 'limit'M'TekSub1'M"},
X    {"TekGetBchar",    "'TekGetlbchar'M s 1 & 'TekUcase' 'if'M 0x80 |"},
X    {"TekGetlbchar", "\
X'r' 'ord'M b 1 == Z 'pop'M \
X'm' 'ord'M b 2 == Z 'pop'M \
X'l' 'ord'M b 3 == Z 'error'M"},
X    {"TekUcase",    "32 -"},
X    {"TekSub1",    "'push'M 7>>037&040|%ci 2>>037&040|%ci"},
X    {"TestConst",
X"'h='ih%di' w='iw%di' H='iH%di' W='iW%di' R='iR%di' C='iC%di'\n'i"},
X    {"TestButton",
X"'x='ix%di' y='iy%di' X='iX%di' Y='iY%di\
X' r='ir%di' c='ic%di' b='ib%di' s='is%xi'\n'i"},
X    {"TestKey",
X"'x='ix%di' y='iy%di' X='iX%di' Y='iY%di\
X' r='ir%di' c='ic%di' k='ik%di' s='is%xi' l=\"'ili'\"\n'i"},
X};
X
X
Xstatic int
Xishexalpha(c)
Xchar c;
X{
X    return (c>='a'&&c<='f' || c>='A'&&c<='F');
X}
X
X/* Value stack manipulation functions */
X
Xstatic void
XStackClear()    /* clear the stack */
X{
X    int i;
X
X    for (i=0; i<stackCount; i++) {        /* free all strings */
X        if (stack[i].type == MacStackString) {
X            if (stack[i].d.s)
X                free(stack[i].d.s);
X        }
X    }
X    stackCount = 0;
X}
X
Xstatic void
XStackPop(n)
Xint n;        /* pop N items off the top of the stack */
X{
X    while (n>0 && stackCount>0) {
X        if (stack[TOS].type == MacStackString) {
X            if (stack[TOS].d.s)
X                free(stack[TOS].d.s);
X        }
X        n--;
X        stackCount--;
X    }
X}
X
Xstatic Bool    /* TRUE if successful, FALSE it not (no more memory) */
XStackPush(e)
XMacStackEntry *e;
X{
X    int nbytes;
X
X    if (stackCount>=stackAlloc) {
X        /* need more room */
X        if (stackAlloc)
X            stackAlloc *= 2;
X        else
X            stackAlloc = 15;
X        nbytes = stackAlloc * sizeof(stack[0]);
X        if (stack)
X            stack = (MacStackEntry *)realloc((char *)stack,nbytes);
X        else
X            stack = (MacStackEntry *)malloc(nbytes);
X        if (!stack)
X            return FALSE;
X    }
X    stack[stackCount] = *e;    /* copy in structure */
X        /* note that we do not do any string copies here */
X    stackCount++;
X    return TRUE;
X}
X
Xstatic Bool    /* TRUE if successful, FALSE it not (no more memory) */
XStackPushString(s)
Xchar *s;    /* the string becomes the property of the stack */
X{
X    MacStackEntry e;
X    Bool t;
X
X    e.type = MacStackString;
X    e.d.s = s;
X    t = StackPush(&e);
X    if (!t) {
X        free(s);    /* it's our string - don't leak the memory */
X    }
X    return t;
X}
X
Xstatic Bool    /* TRUE if successful, FALSE it not (no more memory) */
XStackPushStringCopy(s)
Xchar *s;    /* makes a copy of the string to put onto the stack */
X{
X    char *newstr;
X
X    newstr = malloc(strlen(s)+1);
X    if (!newstr)
X        return FALSE;
X    strcpy(newstr,s);
X    return (StackPushString(newstr));
X}
X
Xstatic Bool    /* TRUE if successful, FALSE it not (no more memory) */
XStackPushInt(n)
Xint n;
X{
X    MacStackEntry e;
X    Bool t;
X
X    e.type = MacStackInt;
X    e.d.n = n;
X    t = StackPush(&e);
X    return t;
X}
X
X
X/* String buffer manipulation functions */
X
Xstatic void
XStackQclear()
X{
X    stackQCount = 0;
X}
X
Xstatic Bool    /* TRUE is successful, FALSE if not (no more memory) */
XStackQchar(c)
Xchar c;
X{
X    int nbytes;
X
X    if (stackQCount>=stackQAlloc) {
X        /* need more room */
X        if (stackQAlloc)
X            stackQAlloc *= 2;
X        else
X            stackQAlloc = 120;
X        nbytes = stackQAlloc;
X        if (Qstr)
X            Qstr = realloc(Qstr,nbytes);
X        else
X            Qstr = malloc(nbytes);
X        if (!Qstr)
X            return FALSE;
X    }
X    Qstr[stackQCount++] = c;
X    return TRUE;
X}
X
X/* handles quoted strings; parses string and pushes it onto the stack */
X/* Note that we do NOT do any backslash processing */
Xstatic char *    /* returns pointer to the closing quote char or NULL on error */
XStackQstr(p,stopchar)
Xchar *p;    /* pointer to first data char */
Xchar stopchar;    /* the character to stop on */
X{
X    StackQclear();
X    while (*p && *p!=stopchar) {
X        if (!StackQchar(*p))
X            return NULL;    /* no more memory */
X        p++;
X    }
X    if (!*p)
X        return NULL;    /* no terminating quote */
X    if (!StackQchar(0))
X        return NULL;
X    if (!StackPushStringCopy(Qstr))
X        return NULL;
X    return p;
X}
X
X
Xstatic Bool    /* returns TRUE if all OK, FALSE if any problems */
XStackToBool(n)    /* converts stack item n to a bool (int 0/1) */
Xint n;
X{
X    int f;
X
X    switch (stack[n].type) {
X    case MacStackInt:
X        stack[n].d.n = !!stack[n].d.n;
X        break;
X    case MacStackString:
X        if (stack[n].d.s && stack[n].d.s[0]) {
X            f = 1;
X        } else {
X            f = 0;
X        }
X        if (stack[n].d.s)
X            free(stack[n].d.s);
X        stack[n].type = MacStackInt;
X        stack[n].d.n = f;
X        break;
X    default:
X        return FALSE;
X    }
X    return TRUE;
X}
X
X/* Primitives */
X
Xstatic Bool    /* returns TRUE if all OK, FALSE if any problems */
XPrimToBool()    /* converts TOS to a bool (int 0/1) */
X{
X    if (stackCount<1)
X        return FALSE;
X    return (StackToBool(TOS));
X}
X
Xstatic Bool    /* returns TRUE if all OK, FALSE if any problems */
XPrimNot()    /* converts TOS to Bool and then invert it */
X{
X    int f;
X
X    if (stackCount<1)
X        return FALSE;
X    switch (stack[TOS].type) {
X    case MacStackInt:
X        stack[TOS].d.n = !stack[TOS].d.n;
X        break;
X    case MacStackString:
X        if (stack[TOS].d.s && stack[TOS].d.s[0]) {
X            f = 0;
X        } else {
X            f = 1;
X        }
X        StackPop(1);
X        PUSHINT(f);
X        break;
X    default:
X        return FALSE;
X    }
X    return TRUE;
X}
X
X/* The IfTrue primitive requires a macro name at TOS and a value at TOS-1.
X * Both values are first removed from the stack.
X * If the value is TRUE, then the macro is executed, otherwise nothing
X * else happens.
X */
Xstatic Bool    /* returns TRUE if all OK, FALSE if any problems */
XPrimIfTrue()
X{
X    char *macroname;
X    int b,t;
X
X    if (stackCount<2)
X        return FALSE;
X    if (stack[TOS].type!=MacStackString)
X        return FALSE;
X    macroname = stack[TOS].d.s;
X    stack[TOS].d.s = 0;
X    StackPop(1);
X    if (!PrimToBool())
X        return FALSE;    /* error testing truth */
X    b = stack[TOS].d.n;
X    StackPop(1);
X    if (b)
X        t = StackDoNamedMacro(macroname);
X    else
X        t = TRUE;
X    free(macroname);
X    return t;
X}
X
X/* The IfElse primitive requires a macro name at TOS,
X * a macro name at TOS-1, and a condition value at TOS-2.
X * All three items are first removed from the stack.
X * If the condition is TRUE, then the macro is which was at TOS-1 is executed,
X * otherwise the macro which was at TOS is executed.
X * Thus, you first push the condition value, then the name of the TRUE macro,
X * then the name of the FALSE macro, then "ifElse", then M.
X */
Xstatic Bool    /* returns TRUE if all OK, FALSE if any problems */
XPrimIfElse()
X{
X    char *truemacro, *falsemacro;
X    int b,t;
X
X    if (stackCount<3)
X        return FALSE;
X    if (stack[TOS].type!=MacStackString ||
X        stack[TOS-1].type!=MacStackString)
X        return FALSE;
X    falsemacro = stack[TOS].d.s;
X    stack[TOS].d.s = 0;
X    truemacro = stack[TOS-1].d.s;
X    stack[TOS-1].d.s = 0;
X    StackPop(2);
X    if (!PrimToBool())
X        return FALSE;    /* error testing truth */
X    b = stack[TOS].d.n;
X    StackPop(1);
X    if (b)
X        t = StackDoNamedMacro(truemacro);
X    else
X        t = StackDoNamedMacro(falsemacro);
X    free(truemacro);
X    free(falsemacro);
X    return t;
X}
X
Xstatic Bool    /* returns TRUE if all OK, FALSE if any problems */
XPrimPop()    /* throws away the top item on the stack */
X{
X    if (stackCount<1)
X        return FALSE;
X    StackPop(1);
X    return TRUE;
X}
X
Xstatic Bool    /* returns TRUE if all OK, FALSE if any problems */
XPrimPush()    /* duplicates the top item on the stack by pushing a copy */
X{
X    if (stackCount<1)
X        return FALSE;
X    switch (stack[TOS].type) {
X    case MacStackInt:
X        PUSHINT(stack[TOS].d.n);
X        break;
X    case MacStackString:
X        if (!StackPushStringCopy(stack[TOS].d.s))
X            return FALSE;
X        break;
X    default:
X        return FALSE;
X    }
X    return TRUE;
X}
X
Xstatic Bool    /* returns TRUE if all OK, FALSE if any problems */
XPrimExch()    /* exchanges the top two items on the stack */
X{
X    MacStackEntry e;
X
X    if (stackCount<2)
X        return FALSE;
X    e = stack[TOS];        /* structure copy */
X    stack[TOS] = stack[TOS-1];
X    stack[TOS-1] = e;
X    return TRUE;
X}
X
Xstatic Bool    /* returns TRUE if all OK, FALSE if any problems */
XPrimLimit()    /* limits TOS-2 to be between TOS-1 and TOS */
X{
X    int high,low;
X
X    if (stackCount<3)
X        return FALSE;
X    if (stack[TOS].type != MacStackInt ||
X        stack[TOS-1].type != MacStackInt ||
X        stack[TOS-2].type != MacStackInt)
X        return FALSE;
X    high = stack[TOS].d.n;
X    low = stack[TOS-1].d.n;
X    StackPop(2);
X    if (stack[TOS].d.n>high)
X        stack[TOS].d.n = high;
X    else if (stack[TOS].d.n<low)
X        stack[TOS].d.n = low;
X    return TRUE;
X}
X
Xstatic Bool    /* returns TRUE if all OK, FALSE if any problems */
XPrimOrd()    /* converts a char (string of len 1) to an int */
X{
X    int ord;
X
X    if (stackCount<1)
X        return FALSE;
X    if (stack[TOS].type != MacStackString ||
X        strlen(stack[TOS].d.s)!=1)
X        return FALSE;
X    ord = stack[TOS].d.s[0];
X    StackPop(1);
X    PUSHINT(ord);
X    return TRUE;
X}
X
Xstatic Bool    /* returns TRUE if all OK, FALSE if any problems */
XPrimError()    /* generates an error (aborts) */
X{
X    return FALSE;    /* simple enough */
X}
X
Xstatic Bool    /* returns TRUE if all OK, FALSE if any problems */
XPrimTekScale()    /* generates an error (aborts) */
X{
X    PUSHINT(TekScale(stackScreen));
X    return TRUE;
X}
X
X
X/* Macro processing functions */
X
Xtypedef struct {
X    char *value;
X} UmInfo, *UmInfoPtr;
Xstatic XtResource umresource[] = {
X    { "", "", XtRString, sizeof(String),
X        XtOffset(UmInfoPtr,value),XtRString,NULL},
X};
X
Xstatic String        /* returns macro string or NULL if not found */
XStackFindUserMacro(name)
XString name;
X{
X    UserMacro *umlist;
X    UmInfo uminfo;
X
X    umlist = stackScreen->userMacros;
X    for (; umlist; umlist=umlist->next) {
X        if (strcmp(umlist->name,name)==0)
X            return(umlist->value);
X    }
X    /* not a macro that is already loaded, see if we can load it */
X    umresource[0].resource_name = name;
X    umresource[0].resource_class = name;
X    XtGetSubresources(stackWidget,(caddr_t)&uminfo,
X        "macroString","MacroString",
X        umresource,(Cardinal)1,(ArgList)NULL,(Cardinal)0);
X    if (!uminfo.value)
X        return NULL;    /* can't find the macro */
X    umlist = (UserMacro *)malloc(sizeof(UserMacro));
X    if (!umlist)
X        return NULL;    /* can't get memory */
X    umlist->name = malloc(strlen(name)+1);
X    if (!umlist->name) {
X        free((char *)umlist);
X        return NULL;
X    }
X    umlist->value = malloc(strlen(uminfo.value)+1);
X    if (!umlist->value) {
X        free(umlist->name);
X        free((char *)umlist);
X        return NULL;
X    }
X    strcpy(umlist->name,name);
X    strcpy(umlist->value,uminfo.value);
X    umlist->next = stackScreen->userMacros;
X    stackScreen->userMacros = umlist;
X    return(umlist->value);
X}
X
X/* handles the "%" formatting; parses format string and operates on stack */
Xstatic char *    /* returns pointer to the last char of the fmt string or NULL */
XStackFstr(p)
Xchar *p;    /* pointer to first char of formatting string */
X{
X    static char *fmtchars="-+#*.0123456789";
X    char *buf;
X
X    if (stackCount<1)
X        return NULL;
X    StackQclear();
X    if (!StackQchar('%'))
X        return NULL;
X    while (*p && (index(fmtchars,*p))) {
X        if (!StackQchar(*p))
X            return NULL;
X        p++;
X    }
X    if (!StackQchar(*p))    /* add the final formatting char */
X        return NULL;
X    if (!StackQchar(0))    /* null terminate the format string */
X        return NULL;
X    switch (*p) {
X    case 0:
X        return NULL;
X    case 'd': case 'i': case 'o': case 'u': case 'x': case 'X': case 'c':
X        if (stack[TOS].type!=MacStackInt)
X            return NULL;
X        buf = malloc(100);
X        if (!buf)
X            return NULL;
X        sprintf(buf,Qstr,stack[TOS].d.n);
X        break;
X    case 's':
X        if (stack[TOS].type!=MacStackString)
X            return NULL;
X        buf = malloc(strlen(stack[TOS].d.s)+100);
X        if (!buf)
X            return NULL;
X        sprintf(buf,Qstr,stack[TOS].d.s);
X        break;
X    default:
X        return NULL;
X    }
X    StackPop(1);    /* get rid of converted value */
X    if (!StackPushStringCopy(buf)) {
X        free(buf);
X        return NULL;
X    }
X    free(buf);
X    return p;
X}
X
X/* handles primitives */
XBool        /* returns TRUE if OK, FALSE is any errors */
XStackDoPrimitive(name)
Xchar *name;
X{
X    int i;
X
X    for (i=0; i<XtNumber(PrimTab); i++) {
X        if (strcmp(PrimTab[i].name,name)==0) {
X            return (*PrimTab[i].func)();
X        }
X    }
X    return FALSE;
X}
X
X/* handles built-in macro strings */
XBool        /* returns TRUE if OK, FALSE is any errors */
XStackDoBuiltin(name)
Xchar *name;
X{
X    int i;
X
X    for (i=0; i<XtNumber(BuiltinTab); i++) {
X        if (strcmp(BuiltinTab[i].name,name)==0) {
X            return ProcessMacroString(BuiltinTab[i].str);
X        }
X    }
X    return FALSE;
X}
X
X/* handles user defined macro strings */
XBool        /* returns TRUE if OK, FALSE is any errors */
XStackDoUserMacro(name)
Xchar *name;
X{
X    String macrostr;
X
X    macrostr = StackFindUserMacro(name);
X    if (!macrostr)
X        return FALSE;    /* no such macro */
X    return ProcessMacroString(macrostr);
X}
X
X/* handles macro as named at TOS */
XBool        /* returns TRUE if OK, FALSE if any errors */
XStackDoMacro()
X{
X    char *macroname;
X    int t;
X
X    if (stackCount<1 || stack[TOS].type!=MacStackString)
X        return FALSE;    /* no macro name */
X    macroname = stack[TOS].d.s;
X    stack[TOS].d.s = 0;
X    StackPop(1);    /* remove the macro name from the stack */
X    t = StackDoNamedMacro(macroname);
X    free(macroname);
X    return t;
X}
X
X/* handles macros (primitives, built-in macros, or user macros) */
XBool        /* returns TRUE if OK, FALSE if any errors */
XStackDoNamedMacro(macroname)
XString macroname;
X{
X    /* User macros can override builtin macro strings, but not primitives */
X    if (StackDoPrimitive(macroname) ||
X        StackDoUserMacro(macroname) ||
X        StackDoBuiltin(macroname)) {
X        return TRUE;
X    }
X    return FALSE;    /* no such macro */
X}
X
Xstatic int    /* returns TRUE if all OK, FALSE if problem (syntax, no memory) */
XProcessMacroString(macrostring)
Xchar *macrostring;
X{
X    char *p;
X    char *newstr;
X    int newnum;
X    int l;
X    int n;
X    Bool b;
X    int radix, hc;
X    KeySym ks;
X    char buf[100];
X
X    for (p=macrostring;*p;p++) {    /* process commands */
X        switch (*p) {
X        case ' ':    /* ignore spaces */
X            break;
X        case '"':    /* quoted string */
X        case '\'':
X            p = StackQstr(p+1,*p);
X            if (!p)
X                return FALSE;        /* error */
X            break;
X        case '%':    /* formatted print onto TOS */
X            p = StackFstr(p+1);
X            if (!p)
X                return FALSE;        /* error */
X            break;
X        case '+':    /* add two numbers or cat two strings */
X            if (stackCount<2)
X                return FALSE;
X            if (stack[TOS].type == MacStackString &&
X                stack[TOS-1].type == MacStackString) {
X                l = strlen(stack[TOS].d.s) +
X                    strlen(stack[TOS-1].d.s) + 1;
X                newstr = malloc(l);
X                if (!newstr)
X                    return FALSE;
X                strcpy(newstr,stack[TOS-1].d.s);
X                strcat(newstr,stack[TOS].d.s);
X                StackPop(1);
X                free(stack[TOS].d.s);
X                stack[TOS].d.s = newstr;
X            }
X            else if (stack[TOS].type == MacStackInt ||
X                 stack[TOS-1].type == MacStackInt) {
X                newnum = stack[TOS-1].d.n + stack[TOS].d.n;
X                StackPop(1);
X                stack[TOS].d.n = newnum;
X            }
X            else
X                return FALSE;
X            break;
X        case '-':    /* subtract two numbers */
X            if (stackCount<2)
X                return FALSE;
X            if (stack[TOS].type == MacStackInt ||
X                 stack[TOS-1].type == MacStackInt) {
X                newnum = stack[TOS-1].d.n - stack[TOS].d.n;
X                StackPop(1);
X                stack[TOS].d.n = newnum;
X            }
X            else
X                return FALSE;
X            break;
X        case '*':    /* multiply two numbers */
X            if (stackCount<2)
X                return FALSE;
X            if (stack[TOS].type == MacStackInt ||
X                 stack[TOS-1].type == MacStackInt) {
X                newnum = stack[TOS-1].d.n * stack[TOS].d.n;
X                StackPop(1);
X                stack[TOS].d.n = newnum;
X            }
X            else
X                return FALSE;
X            break;
X        case '/':    /* divide two numbers */
X            if (stackCount<2)
X                return FALSE;
X            if (stack[TOS].type == MacStackInt ||
X                 stack[TOS-1].type == MacStackInt) {
X                newnum = stack[TOS-1].d.n / stack[TOS].d.n;
X                StackPop(1);
X                stack[TOS].d.n = newnum;
X            }
X            else
X                return FALSE;
X            break;
X        case '<':    /* left shift (<<) */
X            if ((*(++p))!='<')
X                return FALSE;
X            if (stackCount<2)
X                return FALSE;
X            if (stack[TOS].type == MacStackInt &&
X                 stack[TOS-1].type == MacStackInt) {
X                newnum = stack[TOS-1].d.n << stack[TOS].d.n;
X                StackPop(1);
X                stack[TOS].d.n = newnum;
X            }
X            else
X                return FALSE;
X            break;
X        case '>':    /* right shift (>>) */
X            if ((*(++p))!='>')
X                return FALSE;
X            if (stackCount<2)
X                return FALSE;
X            if (stack[TOS].type == MacStackInt &&
X                 stack[TOS-1].type == MacStackInt) {
X                newnum = stack[TOS-1].d.n >> stack[TOS].d.n;
X                StackPop(1);
X                stack[TOS].d.n = newnum;
X            }
X            else
X                return FALSE;
X            break;
X        case '|':    /* logical or bitwise OR */
X            if (stackCount<2)
X                return FALSE;
X            if (p[1]=='|') {    /* logical */
X                p++;
X                if (!(StackToBool(TOS) && StackToBool(TOS-1)))
X                    return FALSE;
X                newnum = stack[TOS-1].d.n || stack[TOS].d.n;
X            } else {        /* bitwise */
X                if (stack[TOS].type != MacStackInt ||
X                    stack[TOS-1].type != MacStackInt)
X                    return FALSE;
X                newnum = stack[TOS-1].d.n | stack[TOS].d.n;
X            }
X            StackPop(1);
X            stack[TOS].d.n = newnum;
X            break;
X        case '&':    /* logical or bitwise AND */
X            if (stackCount<2)
X                return FALSE;
X            if (p[1]=='&') {    /* logical */
X                p++;
X                if (!(StackToBool(TOS) && StackToBool(TOS-1)))
X                    return FALSE;
X                newnum = stack[TOS-1].d.n && stack[TOS].d.n;
X            } else {        /* bitwise */
X                if (stack[TOS].type != MacStackInt ||
X                    stack[TOS-1].type != MacStackInt)
X                    return FALSE;
X                newnum = stack[TOS-1].d.n & stack[TOS].d.n;
X            }
X            StackPop(1);
X            stack[TOS].d.n = newnum;
X            break;
X        case '^':    /* logical or bitwise XOR */
X            if (stackCount<2)
X                return FALSE;
X            if (p[1]=='^') {    /* logical */
X                p++;
X                if (!(StackToBool(TOS) && StackToBool(TOS-1)))
X                    return FALSE;
X                newnum = stack[TOS-1].d.n ^ stack[TOS].d.n;
X            } else {        /* bitwise */
X                if (stack[TOS].type != MacStackInt ||
X                    stack[TOS-1].type != MacStackInt)
X                    return FALSE;
X                newnum = stack[TOS-1].d.n ^ stack[TOS].d.n;
X            }
X            StackPop(1);
X            stack[TOS].d.n = newnum;
X            break;
X        case '!':    /* logical not */
X            if (!PrimNot())
X                return FALSE;
X            break;
X        case '~':    /* bitwise invert */
X            if (stackCount<1)
X                return FALSE;
X            if (stack[TOS].type == MacStackInt) {
X                newnum = ~stack[TOS-1].d.n;
X                stack[TOS].d.n = newnum;
X            }
X            else
X                return FALSE;
X            break;
X        case '0': case '1': case '2': case '3': case '4':
X        case '5': case '6': case '7': case '8': case '9':
X            newnum = 0;
X            if ((*p)=='0') {
X                if (p[1]=='x' || p[1]=='X') {
X                    radix = 16;
X                    p+=2;
X                }
X                else
X                    radix = 8;
X            }
X            else
X                radix = 10;
X            while (isdigit(*p) || (radix==16&&ishexalpha(*p))) {
X                newnum *= radix;
X                if (radix==16&&ishexalpha(*p)) {
X                    hc = *p;
X                    if (islower(hc))
X                        hc = toupper(hc);
X                    newnum += hc - 'A' + 10;
X                }
X                else
X                    newnum += *p - '0';
X                p++;
X            }
X            --p;    /* have to leave it pointing to last char */
X            PUSHINT(newnum);
X            break;
X        case 'b':    /* put button field from event onto stack */
X            PUSHINT(stackEvent->xbutton.button);
X            break;
X        case 'c':    /* put cursor col onto stack (0 is leftmost) */
X            PUSHINT(CursorCol(stackScreen,stackEvent->xbutton.x));
X            break;
X        case 'C':    /* put number of cols on screen onto stack */
X            PUSHINT(stackScreen->max_col+1);
X            break;
X        case 'h':    /* put pixel height of a char on stack */
X            PUSHINT(FontHeight(stackScreen));
X            break;
X        case 'H':    /* put pixel height of screen on stack */
X            PUSHINT(stackScreen->fullVwin.height);
X            break;
X        case 'i':    /* send TOS as input */
X            if (stackCount<1)
X                return FALSE;
X            if (stack[TOS].type == MacStackString)
X                StringInput(stackScreen,stack[TOS].d.s);
X            else
X                return FALSE;
X            StackPop(1);
X            break;
X        case 'k':    /* put keycode field from event onto stack */
X            PUSHINT(stackEvent->xkey.keycode);
X            break;
X        case 'l':    /* put results of XLookupString on stack */
X            n = XLookupString(stackEvent,buf,sizeof(buf)-1,&ks,0);
X            if (n>0) {
X                newstr = malloc(n+1);
X                if (!newstr)
X                    return FALSE;
X                strcpy(newstr,buf);
X                if (!StackPushString(newstr))
X                    return FALSE;
X            } else {    /* no translation, use null string */
X                if (!StackPushStringCopy(""))
X                    return FALSE;
X            }
X            break;
X        case 'M':    /* execute macro */
X            if (!StackDoMacro())
X                return FALSE;
X            break;
X        case 'r':    /* put cursor row onto stack (0 is topmost) */
X            PUSHINT(CursorRow(stackScreen,stackEvent->xbutton.y));
X            break;
X        case 'R':    /* put number of rows on screen onto stack */
X            PUSHINT(stackScreen->max_row+1);
X            break;
X        case 's':    /* put state field from event onto stack */
X            PUSHINT(stackEvent->xbutton.state);
X            break;
X        case 'w':    /* put pixel width of a char on stack */
X            PUSHINT(FontWidth(stackScreen));
X            break;
X        case 'W':    /* put pixel width of screen on stack */
X            PUSHINT(stackScreen->fullVwin.width);
X            break;
X        case 'x':    /* put x pixel value of cursor on stack */
X            PUSHINT(stackEvent->xbutton.x - stackScreen->border -
X                        stackScreen->scrollbar);
X            break;
X        case 'y':    /* put y pixel value of cursor on stack */
X            PUSHINT(stackEvent->xbutton.y - stackScreen->border);
X            break;
X        case 'X':    /* put x_root pixel value of cursor on stack */
X            PUSHINT(stackEvent->xbutton.x_root);
X            break;
X        case 'Y':    /* put y_root pixel value of cursor on stack */
X            PUSHINT(stackEvent->xbutton.y_root);
X            break;
X        case 'Z':    /* conditional return/end of macro */
X            if (stackCount<1)
X                return FALSE;    /* error */
X            if (!PrimToBool())
X                return FALSE;    /* error testing truth */
X            b = stack[TOS].d.n;
X            StackPop(1);
X            if (b)
X                return TRUE;    /* if true, end of this macro */
X            /* else do nothing */
X            break;
X        default:
X            return FALSE;
X        }
X    }
X    return TRUE;    /* finished without errors */
X}
X
X/* This is the action function called from the translation table */
Xvoid
XHandleMacroString(w,event,params,param_count)
XWidget w;
XXEvent *event;
XString *params;
Xint *param_count;
X{
X
X    if (*param_count != 1)
X        return;
X    StackClear();        /* clear the stack machine */
X    stackScreen = &((XtermWidget)w)->screen;
X    stackWidget = w;
X    stackEvent = event;
X    if (!ProcessMacroString(params[0])) {
X        Bell();        /* some sort of error */
X    }
X}
X
X/* end */
END_OF_macrostr.c
if test 24964 -ne `wc -c <macrostr.c`; then
    echo shar: \"macrostr.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
echo shar: End of shell archive.
exit 0