|
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] [Xen-devel] [PATCH] xen/build: Remove hacked up version of figlet
This hacked up version of figlet contributes a supprisingly large proportion
of the Coverity issues found under xen/ (and therefore attributed against Xen)
Figlet can be found in all distros, so make use of it.
We keep xen.flf (being the Xen figlet font) and replace the hacked up octal
transform with a short python script.
The Xen Makefile has been tweaked in such a way that it still prints the
figlet banner for the build.
Signed-off-by: Andrew Cooper <andrew.cooper3@xxxxxxxxxx>
CC: Keir Fraser <keir@xxxxxxx>
CC: Jan Beulich <JBeulich@xxxxxxxx>
CC: Tim Deegan <tim@xxxxxxx>
CC: Ian Campbell <Ian.Campbell@xxxxxxxxxx>
CC: Ian Jackson <Ian.Jackson@xxxxxxxxxxxxx>
---
.gitignore | 3 -
xen/Makefile | 14 +-
xen/tools/Makefile | 2 -
xen/tools/fig-to-oct.py | 18 +
xen/tools/figlet/LICENSE | 111 ---
xen/tools/figlet/Makefile | 9 -
xen/tools/figlet/README | 9 -
xen/tools/figlet/figlet.c | 2076 ----------------------------------------
xen/tools/{figlet => }/xen.flf | 0
9 files changed, 22 insertions(+), 2220 deletions(-)
create mode 100644 xen/tools/fig-to-oct.py
delete mode 100644 xen/tools/figlet/LICENSE
delete mode 100644 xen/tools/figlet/Makefile
delete mode 100644 xen/tools/figlet/README
delete mode 100644 xen/tools/figlet/figlet.c
rename xen/tools/{figlet => }/xen.flf (100%)
diff --git a/.gitignore b/.gitignore
index c82a372..02f9e27 100644
--- a/.gitignore
+++ b/.gitignore
@@ -291,7 +291,6 @@ tools/xm-test/lib/XmTestLib/config.py
tools/xm-test/lib/XmTestReport/xmtest.py
tools/xm-test/tests/*.test
tools/ocaml-xenstored*
-xen/.banner*
xen/System.map
xen/arch/arm/asm-offsets.s
xen/arch/arm/xen.lds
@@ -314,9 +313,7 @@ xen/include/linux
xen/include/public/public
xen/include/xen/*.new
xen/include/xen/acm_policy.h
-xen/include/xen/banner.h
xen/include/xen/compile.h
-xen/tools/figlet/figlet
xen/tools/symbols
xen/xsm/flask/include/av_perm_to_string.h
xen/xsm/flask/include/av_permissions.h
diff --git a/xen/Makefile b/xen/Makefile
index 597972d..a3058f1 100644
--- a/xen/Makefile
+++ b/xen/Makefile
@@ -86,7 +86,6 @@ _clean: delete-unfresh-files
$(MAKE) -f $(BASEDIR)/Rules.mk -C arch/$(TARGET_ARCH) clean
rm -f include/asm *.o $(TARGET) $(TARGET).gz $(TARGET)-syms *~ core
rm -f include/asm-*/asm-offsets.h
- [ -d tools/figlet ] && rm -f .banner*
.PHONY: _distclean
_distclean: clean
@@ -113,14 +112,8 @@ delete-unfresh-files:
rm -f include/xen/compile.h; \
fi
-.banner: Makefile
- $(MAKE) -C tools
- @tools/figlet/figlet -d tools/figlet Xen $(XEN_FULLVERSION) 2>$@2 >$@1
- @cat $@1 $@2 >$@
- @rm -f $@1 $@2
-
# compile.h contains dynamic build info. Rebuilt on every 'make' invocation.
-include/xen/compile.h: include/xen/compile.h.in .banner
+include/xen/compile.h: include/xen/compile.h.in
@sed -e 's/@@date@@/$(shell LC_ALL=C date)/g' \
-e 's/@@time@@/$(shell LC_ALL=C date +%T)/g' \
-e 's/@@whoami@@/$(XEN_WHOAMI)/g' \
@@ -132,8 +125,9 @@ include/xen/compile.h: include/xen/compile.h.in .banner
-e 's/@@extraversion@@/$(XEN_EXTRAVERSION)/g' \
-e 's!@@changeset@@!$(shell tools/scmversion $(XEN_ROOT) || echo
"unavailable")!g' \
< include/xen/compile.h.in > $@.new
- @grep \" .banner >> $@.new
- @grep -v \" .banner
+ @echo " Xen $(XEN_FULLVERSION)" | figlet -f tools/xen.flf | tee .banner
+ @python tools/fig-to-oct.py < .banner >> $@.new
+ @rm -f .banner
@mv -f $@.new $@
include/asm-$(TARGET_ARCH)/asm-offsets.h: arch/$(TARGET_ARCH)/asm-offsets.s
diff --git a/xen/tools/Makefile b/xen/tools/Makefile
index 612e36d..e940939 100644
--- a/xen/tools/Makefile
+++ b/xen/tools/Makefile
@@ -3,12 +3,10 @@ include $(XEN_ROOT)/Config.mk
.PHONY: default
default:
- [ -d figlet ] && $(MAKE) -C figlet
$(MAKE) symbols
.PHONY: clean
clean:
- [ -d figlet ] && $(MAKE) -C figlet clean
rm -f *.o symbols
symbols: symbols.c
diff --git a/xen/tools/fig-to-oct.py b/xen/tools/fig-to-oct.py
new file mode 100644
index 0000000..db4fd32
--- /dev/null
+++ b/xen/tools/fig-to-oct.py
@@ -0,0 +1,18 @@
+#!/usr/bin/env python
+import sys
+
+chars_per_line = 18
+chars_so_far = 0
+
+sys.stdout.write('"')
+
+for char in sys.stdin.read():
+
+ sys.stdout.write("\\%03o" % ord(char))
+ chars_so_far = chars_so_far + 1
+
+ if chars_so_far == chars_per_line:
+ chars_so_far = 0
+ sys.stdout.write('" \\\n"')
+
+sys.stdout.write('"\n')
diff --git a/xen/tools/figlet/LICENSE b/xen/tools/figlet/LICENSE
deleted file mode 100644
index 59fd244..0000000
--- a/xen/tools/figlet/LICENSE
+++ /dev/null
@@ -1,111 +0,0 @@
-http://www.sunsite.unc.edu/pub/Linux/LICENSES/artistic.license
-
- The "Artistic License"
-
- Preamble
-
-The intent of this document is to state the conditions under which a
-Package may be copied, such that the Copyright Holder maintains some
-semblance of artistic control over the development of the package,
-while giving the users of the package the right to use and distribute
-the Package in a more-or-less customary fashion, plus the right to make
-reasonable modifications.
-
-Definitions:
-
- "Package" refers to the collection of files distributed by the
- Copyright Holder, and derivatives of that collection of files
- created through textual modification.
-
- "Standard Version" refers to such a Package if it has not been
- modified, or has been modified in accordance with the wishes
- of the Copyright Holder.
-
- "Copyright Holder" is whoever is named in the copyright or
- copyrights for the package.
-
- "You" is you, if you're thinking about copying or distributing
- this Package.
-
- "Reasonable copying fee" is whatever you can justify on the
- basis of media cost, duplication charges, time of people involved,
- and so on. (You will not be required to justify it to the
- Copyright Holder, but only to the computing community at large
- as a market that must bear the fee.)
-
- "Freely Available" means that no fee is charged for the item
- itself, though there may be fees involved in handling the item.
- It also means that recipients of the item may redistribute it
- under the same conditions they received it.
-
-1. You may make and give away verbatim copies of the source form of the
-Standard Version of this Package without restriction, provided that you
-duplicate all of the original copyright notices and associated disclaimers.
-
-2. You may apply bug fixes, portability fixes and other modifications
-derived from the Public Domain or from the Copyright Holder. A Package
-modified in such a way shall still be considered the Standard Version.
-
-3. You may otherwise modify your copy of this Package in any way, provided
-that you insert a prominent notice in each changed file stating how and
-when you changed that file, and provided that you do at least ONE of the
-following:
-
- a) place your modifications in the Public Domain or otherwise make them
- Freely Available, such as by posting said modifications to Usenet or
- an equivalent medium, or placing the modifications on a major archive
- site such as ftp.uu.net, or by allowing the Copyright Holder to include
- your modifications in the Standard Version of the Package.
-
- b) use the modified Package only within your corporation or organization.
-
- c) rename any non-standard executables so the names do not conflict
- with standard executables, which must also be provided, and provide
- a separate manual page for each non-standard executable that clearly
- documents how it differs from the Standard Version.
-
- d) make other distribution arrangements with the Copyright Holder.
-
-4. You may distribute the programs of this Package in object code or
-executable form, provided that you do at least ONE of the following:
-
- a) distribute a Standard Version of the executables and library files,
- together with instructions (in the manual page or equivalent) on where
- to get the Standard Version.
-
- b) accompany the distribution with the machine-readable source of
- the Package with your modifications.
-
- c) accompany any non-standard executables with their corresponding
- Standard Version executables, giving the non-standard executables
- non-standard names, and clearly documenting the differences in manual
- pages (or equivalent), together with instructions on where to get
- the Standard Version.
-
- d) make other distribution arrangements with the Copyright Holder.
-
-5. You may charge a reasonable copying fee for any distribution of this
-Package. You may charge any fee you choose for support of this Package.
-You may not charge a fee for this Package itself. However,
-you may distribute this Package in aggregate with other (possibly
-commercial) programs as part of a larger (possibly commercial) software
-distribution provided that you do not advertise this Package as a
-product of your own.
-
-6. The scripts and library files supplied as input to or produced as
-output from the programs of this Package do not automatically fall
-under the copyright of this Package, but belong to whomever generated
-them, and may be sold commercially, and may be aggregated with this
-Package.
-
-7. C or perl subroutines supplied by you and linked into this Package
-shall not be considered part of this Package.
-
-8. The name of the Copyright Holder may not be used to endorse or promote
-products derived from this software without specific prior written permission.
-
-9. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
-IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
-WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-
- The End
diff --git a/xen/tools/figlet/Makefile b/xen/tools/figlet/Makefile
deleted file mode 100644
index b1f1045..0000000
--- a/xen/tools/figlet/Makefile
+++ /dev/null
@@ -1,9 +0,0 @@
-
-include $(XEN_ROOT)/Config.mk
-
-figlet: figlet.c
- $(HOSTCC) -o $@ $<
-
-.PHONY: clean
-clean:
- rm -f *.o figlet
diff --git a/xen/tools/figlet/README b/xen/tools/figlet/README
deleted file mode 100644
index b4c58b3..0000000
--- a/xen/tools/figlet/README
+++ /dev/null
@@ -1,9 +0,0 @@
-
-NB. This is a very hacked version of Figlet 2.2.1.
-
-Don't use this outside the Xen build system. A proper version of Figlet
-can be had from <http://www.figlet.org>.
-
-The distribution license is intact in the LICENSE file.
-
- -- Keir Fraser (2/5/2003)
diff --git a/xen/tools/figlet/figlet.c b/xen/tools/figlet/figlet.c
deleted file mode 100644
index 4232a91..0000000
--- a/xen/tools/figlet/figlet.c
+++ /dev/null
@@ -1,2076 +0,0 @@
-
-/*
- * XXXXXXXXXXXXXXXXXXXXXXXXXXX
- *
- * This is a HACKED figlet source file for Xen.
- *
- * Hacked to output C octal strings for inclusion in a header file.
- * Support for opening zipped files is removed.
- *
- * Go to www.figlet.org for the unhacked Figlet sources.
- */
-
-/****************************************************************************
-
- FIGlet Copyright 1991, 1993, 1994 Glenn Chappell and Ian Chai
- FIGlet Copyright 1996, 1997, 1998, 1999, 2000, 2001 John Cowan
- FIGlet Copyright 2002 Christiaan Keet
- Portions written by Paul Burton and Christiaan Keet
- Internet: <info@xxxxxxxxxx>
- FIGlet, along with the various FIGlet fonts and documentation, is
- copyrighted under the provisions of the Artistic License (as listed
- in the file "Artistic-license.txt" which is included in this package.
-****************************************************************************/
-
-#define DATE "13 July 2002"
-#define VERSION "2.2.1"
-#define VERSION_INT 20201
-
-/* FIGlet (Frank, Ian & Glenn's Letters) */
-/* by Glenn Chappell */
-/* Apr 1991 */
-/* Automatic file addition by Ian Chai May 1991 */
-/* Punctuation and numbers addition by Ian Chai Jan 1993 */
-/* Full ASCII by Glenn Chappell Feb 1993 */
-/* Line-breaking, general rewrite by Glenn Chappell Mar 1993 */
-/* Hard blanks by Glenn Chappell Apr 1993 */
-/* Release 2.0 5 Aug 1993 */
-/* Right-to-left printing, extended char set by Glenn Chappell Dec 1993 */
-/* Control files by Glenn Chappell Feb 1994 */
-/* Release 2.1 12 Aug 1994 */
-/* Release 2.1.1 25 Aug 1994 */
-/* Release 2.1.2 by Gilbert (Mad Programmer) Healton: Add -A command line
- option. Sept 8, 1996 */
-/* Release 2.2 by John Cowan: multibyte inputs, compressed fonts,
- mapping tables, kerning/smushing options. */
-/* Release 2.2.1 by Christiaan Keet: minor updates including readmes
- FAQs and comments. 13 July 2002. The new official FIGlet website is
- http://www.figlet.org/ */
-
-#define DEFAULTFONTDIR "."
-#define DEFAULTFONTFILE "xen.flf"
-
-#include <stdio.h>
-#ifdef __STDC__
-#include <stdlib.h>
-#endif
-#include <string.h>
-#include <ctype.h>
-#include <fcntl.h> /* Needed for get_columns */
-
-#ifdef unix
-#include <sys/ioctl.h> /* Needed for get_columns */
-#endif
-
-
-#define ZFILE FILE
-#define Zopen fopen
-#define Zgetc fgetc
-#define Zungetc(_x,_y) fseek(_y,-1,SEEK_CUR)
-#define Zclose fclose
-
-#define MYSTRLEN(x) ((int)strlen(x)) /* Eliminate ANSI problem */
-
-#define DIRSEP '/'
-#define DIRSEP2 '\\'
-/* Leave alone for Unix and MS-DOS/Windows!
-Note: '/' also used in filename in get_columns(). */
-
-#define FONTFILESUFFIX ".flf"
-#define FONTFILEMAGICNUMBER "flf2"
-#define FSUFFIXLEN MYSTRLEN(FONTFILESUFFIX)
-#define CONTROLFILESUFFIX ".flc"
-#define CONTROLFILEMAGICNUMBER "flc2" /* no longer used in 2.2 */
-#define CSUFFIXLEN MYSTRLEN(CONTROLFILESUFFIX)
-#define DEFAULTCOLUMNS 80
-
-
-/****************************************************************************
-
- Globals dealing with chars that are read
-
-****************************************************************************/
-
-typedef long inchr; /* "char" read from stdin */
-
-inchr *inchrline; /* Alloc'd inchr inchrline[inchrlinelenlimit+1]; */
- /* Note: not null-terminated. */
-int inchrlinelen,inchrlinelenlimit;
-inchr deutsch[7] = {196, 214, 220, 228, 246, 252, 223};
- /* Latin-1 codes for German letters, respectively:
- LATIN CAPITAL LETTER A WITH DIAERESIS = A-umlaut
- LATIN CAPITAL LETTER O WITH DIAERESIS = O-umlaut
- LATIN CAPITAL LETTER U WITH DIAERESIS = U-umlaut
- LATIN SMALL LETTER A WITH DIAERESIS = a-umlaut
- LATIN SMALL LETTER O WITH DIAERESIS = o-umlaut
- LATIN SMALL LETTER U WITH DIAERESIS = u-umlaut
- LATIN SMALL LETTER SHARP S = ess-zed
- */
-
-int hzmode; /* true if reading double-bytes in HZ mode */
-int gndbl[4]; /* gndbl[n] is true if Gn is double-byte */
-inchr gn[4]; /* Gn character sets: ASCII, Latin-1, none, none */
-int gl; /* 0-3 specifies left-half Gn character set */
-int gr; /* 0-3 specifies right-half Gn character set */
-
-int Myargc; /* to avoid passing around argc and argv */
-char **Myargv;
-
-/****************************************************************************
-
- Globals dealing with chars that are written
-
-****************************************************************************/
-
-typedef struct fc {
- inchr ord;
- char **thechar; /* Alloc'd char thechar[charheight][]; */
- struct fc *next;
- } fcharnode;
-
-fcharnode *fcharlist;
-char **currchar;
-int currcharwidth;
-int previouscharwidth;
-char **outputline; /* Alloc'd char
outputline[charheight][outlinelenlimit+1]; */
-int outlinelen;
-
-
-/****************************************************************************
-
- Globals dealing with command file storage
-
-****************************************************************************/
-
-typedef struct cfn {
- char *thename;
- struct cfn *next;
- } cfnamenode;
-
-cfnamenode *cfilelist,**cfilelistend;
-
-typedef struct cm {
- int thecommand;
- inchr rangelo;
- inchr rangehi;
- inchr offset;
- struct cm *next;
- } comnode;
-
-comnode *commandlist,**commandlistend;
-
-/****************************************************************************
-
- Globals affected by command line options
-
-****************************************************************************/
-
-int deutschflag,justification,paragraphflag,right2left,multibyte;
-int cmdinput;
-
-#define SM_SMUSH 128
-#define SM_KERN 64
-#define SM_EQUAL 1
-#define SM_LOWLINE 2
-#define SM_HIERARCHY 4
-#define SM_PAIR 8
-#define SM_BIGX 16
-#define SM_HARDBLANK 32
-
-int smushmode;
-
-#define SMO_NO 0 /* no command-line smushmode */
-#define SMO_YES 1 /* use command-line smushmode, ignore font smushmode */
-#define SMO_FORCE 2 /* logically OR command-line and font smushmodes */
-
-int smushoverride;
-
-int outputwidth;
-int outlinelenlimit;
-char *fontdirname,*fontname;
-
-
-/****************************************************************************
-
- Globals read from font file
-
-****************************************************************************/
-
-char hardblank;
-int charheight;
-
-
-/****************************************************************************
-
- Name of program, used in error messages
-
-****************************************************************************/
-
-char *myname;
-
-
-#ifdef TIOCGWINSZ
-/****************************************************************************
-
- get_columns
-
- Determines the number of columns of /dev/tty. Returns the number of
- columns, or -1 if error. May return 0 if columns unknown.
- Requires include files <fcntl.h> and <sys/ioctl.h>.
- by Glenn Chappell & Ian Chai 14 Apr 1993
-
-****************************************************************************/
-
-int get_columns()
-{
- struct winsize ws;
- int fd,result;
-
- if ((fd = open("/dev/tty",O_WRONLY))<0) return -1;
- result = ioctl(fd,TIOCGWINSZ,&ws);
- close(fd);
- return result?-1:ws.ws_col;
-}
-#endif /* ifdef TIOCGWINSZ */
-
-
-/****************************************************************************
-
- myalloc
-
- Calls malloc. If malloc returns error, prints error message and
- quits.
-
-****************************************************************************/
-
-#ifdef __STDC__
-char *myalloc(size_t size)
-#else
-char *myalloc(size)
-int size;
-#endif
-{
- char *ptr;
-#ifndef __STDC__
- extern void *malloc();
-#endif
-
- if ((ptr = (char*)malloc(size))==NULL) {
- fprintf(stderr,"%s: Out of memory\n",myname);
- exit(1);
- }
- else {
- return ptr;
- }
-}
-
-
-/****************************************************************************
-
- hasdirsep
-
- Returns true if s1 contains a DIRSEP or DIRSEP2 character.
-
-****************************************************************************/
-
-int hasdirsep(s1)
-char *s1;
-{
- if (strchr(s1, DIRSEP)) return 1;
- else if (strchr(s1, DIRSEP2)) return 1;
- else return 0;
-}
-
-/****************************************************************************
-
- suffixcmp
-
- Returns true if s2 is a suffix of s1; uses case-blind comparison.
-
-****************************************************************************/
-
-int suffixcmp(s1, s2)
-char *s1;
-char *s2;
-{
- int len1, len2;
-
- len1 = MYSTRLEN(s1);
- len2 = MYSTRLEN(s2);
- if (len2 > len1) return 0;
- s1 += len1 - len2;
- while (*s1) {
- if (tolower(*s1) != tolower(*s2)) return 0;
- s1++;
- s2++;
- }
- return 1;
-}
-
-/****************************************************************************
-
- skiptoeol
-
- Skips to the end of a line, given a stream. Handles \r, \n, or \r\n.
-
-****************************************************************************/
-
-void skiptoeol(fp)
-ZFILE *fp;
-{
- int dummy;
-
- while (dummy=Zgetc(fp),dummy!=EOF) {
- if (dummy == '\n') return;
- if (dummy == '\r') {
- dummy = Zgetc(fp);
- if (dummy != EOF && dummy != '\n') Zungetc(dummy,fp);
- return;
- }
- }
-}
-
-
-/****************************************************************************
-
- myfgets
-
- Local version of fgets. Handles \r, \n, and \r\n terminators.
-
-****************************************************************************/
-
-char *myfgets(line,maxlen,fp)
-char *line;
-int maxlen;
-ZFILE *fp;
-{
- int c = 0;
- char *p;
-
- p = line;
- while((c=Zgetc(fp))!=EOF&&maxlen) {
- *p++ = c;
- maxlen--;
- if (c=='\n') break;
- if (c=='\r') {
- c = Zgetc(fp);
- if (c != EOF && c != '\n') Zungetc(c,fp);
- *(p-1) = '\n';
- break;
- }
- }
- *p = 0;
- return (c==EOF) ? NULL : line;
-}
-
-/****************************************************************************
-
- usageerr
-
- Prints "Usage: ...." line to the given stream.
-
-****************************************************************************/
-
-void printusage(out)
-FILE *out;
-{
- fprintf(out,
- "Usage: %s [ -cklnoprstvxDELNRSWX ] [ -d fontdirectory ]\n",
- myname);
- fprintf(out,
- " [ -f fontfile ] [ -m smushmode ] [ -w outputwidth ]\n");
- fprintf(out,
- " [ -C controlfile ] [ -I infocode ] [ message ]\n");
-}
-
-
-/****************************************************************************
-
- printinfo
-
- Prints version and copyright message, or utility information.
-
-****************************************************************************/
-
-void printinfo(infonum)
-int infonum;
-{
- switch (infonum) {
- case 0: /* Copyright message */
- printf("FIGlet Copyright 1991-2002 Glenn Chappell, Ian Chai, ");
- printf("John Cowan, Christiaan Keet\n");
- printf("Internet: <info@xxxxxxxxxx> ");
- printf("Version: %s, date: %s\n\n",VERSION,DATE);
- printf("FIGlet, along with the various FIGlet fonts");
- printf(" and documentation, may be\n");
- printf("freely copied and distributed.\n\n");
- printf("If you use FIGlet, please send an");
- printf(" e-mail message to <info@xxxxxxxxxx>.\n\n");
- printf("The latest version of FIGlet is available from the");
- printf(" web site,\n\thttp://www.figlet.org/\n\n";);
- printusage(stdout);
- break;
- case 1: /* Version (integer) */
- printf("%d\n",VERSION_INT);
- break;
- case 2: /* Font directory */
- printf("%s\n",fontdirname);
- break;
- case 3: /* Font */
- printf("%s\n",fontname);
- break;
- case 4: /* Outputwidth */
- printf("%d\n",outputwidth);
- }
-}
-
-
-/****************************************************************************
-
- readmagic
-
- Reads a four-character magic string from a stream.
-
-****************************************************************************/
-void readmagic(fp,magic)
-ZFILE *fp;
-char *magic;
-{
- int i;
-
- for (i=0;i<4;i++) {
- magic[i] = Zgetc(fp);
- }
- magic[4] = 0;
- }
-
-/****************************************************************************
-
- skipws
-
- Skips whitespace characters from a stream.
-
-****************************************************************************/
-void skipws(fp)
-ZFILE *fp;
-{
- int c;
- while (c=Zgetc(fp),isascii(c)&&isspace(c)) ;
- Zungetc(c,fp);
- }
-
-/****************************************************************************
-
- readnum
-
- Reads a number from a stream. Accepts "0" prefix for octal and
- "0x" or "0X" for hexadecimal. Ignores leading whitespace.
-
-****************************************************************************/
-void readnum(fp,nump)
-ZFILE *fp;
-inchr *nump;
-{
- int acc = 0;
- char *p;
- int c;
- int base;
- int sign = 1;
- char digits[] = "0123456789ABCDEF";
-
- skipws(fp);
- c = Zgetc(fp);
- if (c=='-') {
- sign = -1;
- }
- else {
- Zungetc(c,fp);
- }
- c = Zgetc(fp);
- if (c=='0') {
- c = Zgetc(fp);
- if (c=='x'||c=='X') {
- base = 16;
- }
- else {
- base = 8;
- Zungetc(c,fp);
- }
- }
- else {
- base = 10;
- Zungetc(c,fp);
- }
-
- while((c=Zgetc(fp))!=EOF) {
- c=toupper(c);
- p=strchr(digits,c);
- if (!p) {
- Zungetc(c,fp);
- *nump = acc * sign;
- return;
- }
- acc = acc*base+(p-digits);
- }
- *nump = acc * sign;
- }
-
-/****************************************************************************
-
- readTchar
-
- Reads a control file "T" command character specification.
-
- Character is a single byte, an escape sequence, or
- an escaped numeric.
-
-****************************************************************************/
-
-inchr readTchar(fp)
-ZFILE *fp;
-{
- inchr thechar;
- char next;
-
- thechar=Zgetc(fp);
- if (thechar=='\n' || thechar=='\r') { /* Handle badly-formatted file */
- Zungetc(thechar,fp);
- return '\0';
- }
- if (thechar!='\\') return thechar;
- next=Zgetc(fp);
- switch(next) {
- case 'a':
- return 7;
- case 'b':
- return 8;
- case 'e':
- return 27;
- case 'f':
- return 12;
- case 'n':
- return 10;
- case 'r':
- return 13;
- case 't':
- return 9;
- case 'v':
- return 11;
- default:
- if (next=='-' || next=='x' || (next>='0' && next<='9')) {
- Zungetc(next,fp);
- readnum(fp,&thechar);
- return thechar;
- }
- return next;
- }
-}
-
-/****************************************************************************
-
- charsetname
-
- Get a Tchar representing a charset name, or 0 if none available.
- Called in getcharset().
-
-****************************************************************************/
-
-inchr charsetname(fp)
-ZFILE *fp;
-{
- inchr result;
-
- result = readTchar(fp);
- if (result == '\n' || result == '\r') {
- result = 0;
- Zungetc(result,fp);
- }
- return result;
- }
-
-/****************************************************************************
-
- charset
-
- Processes "g[0123]" character set specifier
- Called in readcontrol().
-
-****************************************************************************/
-
-void charset(n, controlfile)
-int n;
-ZFILE *controlfile;
-{
- int ch;
-
- skipws(controlfile);
- if (Zgetc(controlfile) != '9') {
- skiptoeol(controlfile);
- return;
- }
- ch = Zgetc(controlfile);
- if (ch == '6') {
- gn[n] = 65536L * charsetname(controlfile) + 0x80;
- gndbl[n] = 0;
- skiptoeol(controlfile);
- return;
- }
- if (ch != '4') {
- skiptoeol(controlfile);
- return;
- }
- ch = Zgetc(controlfile);
- if (ch == 'x') {
- if (Zgetc(controlfile) != '9') {
- skiptoeol(controlfile);
- return;
- }
- if (Zgetc(controlfile) != '4') {
- skiptoeol(controlfile);
- return;
- }
- skipws(controlfile);
- gn[n] = 65536L * charsetname(controlfile);
- gndbl[n] = 1;
- skiptoeol(controlfile);
- return;
- }
- Zungetc(ch, controlfile);
- skipws(controlfile);
- gn[n] = 65536L * charsetname(controlfile);
- gndbl[n] = 0;
- return;
- }
-
-/****************************************************************************
-
- readcontrol
-
- Allocates memory and reads in the given control file.
- Called in readcontrolfiles().
-
-****************************************************************************/
-
-void readcontrol(controlname)
-char *controlname;
-{
- inchr firstch,lastch;
- char dashcheck;
- inchr offset;
- char *controlpath,magicnum[5];
- int command;
- ZFILE *controlfile;
- int namelen;
-
- namelen = MYSTRLEN(fontdirname);
- controlpath = (char*)myalloc(sizeof(char)
- *(namelen+MYSTRLEN(controlname)+CSUFFIXLEN+2));
- controlfile = NULL;
- if (!hasdirsep(controlname)) {
- strcpy(controlpath,fontdirname);
- controlpath[namelen] = DIRSEP;
- controlpath[namelen+1] = '\0';
- strcat(controlpath,controlname);
- strcat(controlpath,CONTROLFILESUFFIX);
- controlfile = Zopen(controlpath,"rb");
- }
- if (controlfile==NULL) {
- strcpy(controlpath,controlname);
- strcat(controlpath,CONTROLFILESUFFIX);
- controlfile = Zopen(controlpath,"rb");
- if (controlfile==NULL) {
- fprintf(stderr,"%s: %s: Unable to open control file\n",myname,
- controlpath);
- exit(1);
- }
- }
-
- free(controlpath);
-
- (*commandlistend) = (comnode*)myalloc(sizeof(comnode));
- (*commandlistend)->thecommand = 0; /* Begin with a freeze command */
- commandlistend = &(*commandlistend)->next;
- (*commandlistend) = NULL;
-
- while(command=Zgetc(controlfile),command!=EOF) {
- switch (command) {
- case 't': /* Translate */
- skipws(controlfile);
- firstch=readTchar(controlfile);
- if ((dashcheck=Zgetc(controlfile))=='-') {
- lastch=readTchar(controlfile);
- }
- else {
- Zungetc(dashcheck,controlfile);
- lastch=firstch;
- }
- skipws(controlfile);
- offset=readTchar(controlfile)-firstch;
- skiptoeol(controlfile);
- (*commandlistend) = (comnode*)myalloc(sizeof(comnode));
- (*commandlistend)->thecommand = 1;
- (*commandlistend)->rangelo = firstch;
- (*commandlistend)->rangehi = lastch;
- (*commandlistend)->offset = offset;
- commandlistend = &(*commandlistend)->next;
- (*commandlistend) = NULL;
- break;
- case '0': case '1': case '2': case '3': case '4':
- case '5': case '6': case '7': case '8': case '9':
- case '-':
- /* Mapping table entry */
- Zungetc(command,controlfile);
- readnum(controlfile,&firstch);
- skipws(controlfile);
- readnum(controlfile,&lastch);
- offset=lastch-firstch;
- lastch=firstch;
- skiptoeol(controlfile);
- (*commandlistend) = (comnode*)myalloc(sizeof(comnode));
- (*commandlistend)->thecommand = 1;
- (*commandlistend)->rangelo = firstch;
- (*commandlistend)->rangehi = lastch;
- (*commandlistend)->offset = offset;
- commandlistend = &(*commandlistend)->next;
- (*commandlistend) = NULL;
- break;
- case 'f': /* freeze */
- skiptoeol(controlfile);
- (*commandlistend) = (comnode*)myalloc(sizeof(comnode));
- (*commandlistend)->thecommand = 0;
- commandlistend = &(*commandlistend)->next;
- (*commandlistend) = NULL;
- break;
- case 'b': /* DBCS input mode */
- multibyte = 1;
- break;
- case 'u': /* UTF-8 input mode */
- multibyte = 2;
- break;
- case 'h': /* HZ input mode */
- multibyte = 3;
- break;
- case 'j': /* Shift-JIS input mode */
- multibyte = 4;
- break;
- case 'g': /* ISO 2022 character set choices */
- multibyte = 0;
- skipws(controlfile);
- command=Zgetc(controlfile);
- switch (command) {
- case '0': /* define G0 charset */
- charset(0, controlfile);
- break;
- case '1': /* set G1 charset */
- charset(1, controlfile);
- break;
- case '2': /* set G2 charset */
- charset(2, controlfile);
- break;
- case '3': /* set G3 charset */
- charset(3, controlfile);
- break;
- case 'l': case 'L': /* define left half */
- skipws(controlfile);
- gl = Zgetc(controlfile) - '0';
- skiptoeol(controlfile);
- break;
- case 'r': case 'R': /* define right half */
- skipws(controlfile);
- gr = Zgetc(controlfile) - '0';
- skiptoeol(controlfile);
- break;
- default: /* meaningless "g" command */
- skiptoeol(controlfile);
- }
- case '\r': case '\n': /* blank line */
- break;
- default: /* Includes '#' */
- skiptoeol(controlfile);
- }
- }
- Zclose(controlfile);
-}
-
-
-/****************************************************************************
-
- readcontrolfiles
-
- Reads in the controlfiles names in cfilelist. Uses readcontrol.
- Called in main().
-
-****************************************************************************/
-
-void readcontrolfiles()
-{
- cfnamenode *cfnptr;
-
- for (cfnptr=cfilelist;cfnptr!=NULL;cfnptr=cfnptr->next) {
- readcontrol(cfnptr->thename);
- }
-}
-
-
-/****************************************************************************
-
- clearcfilelist
-
- Clears the control file list. Assumes thename does not need freeing.
-
-****************************************************************************/
-
-void clearcfilelist()
-{
- cfnamenode *cfnptr1,*cfnptr2;
-
- cfnptr1 = cfilelist;
- while (cfnptr1 != NULL) {
- cfnptr2 = cfnptr1->next;
- free(cfnptr1);
- cfnptr1 = cfnptr2;
- }
- cfilelist = NULL;
- cfilelistend = &cfilelist;
-}
-
-
-/****************************************************************************
-
- getparams
-
- Handles all command-line parameters. Puts all parameters within
- bounds.
-
-****************************************************************************/
-
-void getparams()
-{
- extern char *optarg;
- extern int optind;
- int c; /* "Should" be a char -- need int for "!= -1" test*/
- int columns,firstfont,infoprint;
- char *controlname;
-
- if ((myname = strrchr(Myargv[0],DIRSEP))!=NULL) {
- myname++;
- }
- else {
- myname = Myargv[0];
- }
- fontdirname = DEFAULTFONTDIR;
- firstfont = 1;
- fontname = (char*)myalloc(sizeof(char)*(MYSTRLEN(DEFAULTFONTFILE)+1));
- strcpy(fontname,DEFAULTFONTFILE); /* Some systems don't have strdup() */
- if (suffixcmp(fontname,FONTFILESUFFIX)) {
- fontname[MYSTRLEN(fontname)-FSUFFIXLEN]='\0';
- }
- cfilelist = NULL;
- cfilelistend = &cfilelist;
- commandlist = NULL;
- commandlistend = &commandlist;
- smushoverride = SMO_NO;
- deutschflag = 0;
- justification = -1;
- right2left = -1;
- paragraphflag = 0;
- infoprint = -1;
- cmdinput = 0;
- outputwidth = DEFAULTCOLUMNS;
- gn[1] = 0x80;
- gr = 1;
- while ((c = getopt(Myargc,Myargv,"ADEXLRI:xlcrpntvm:w:d:f:C:NFskSWo"))!= -1)
{
- /* Note: -F is not a legal option -- prints a special err message. */
- switch (c) {
- case 'A':
- cmdinput = 1;
- break;
- case 'D':
- deutschflag = 1;
- break;
- case 'E':
- deutschflag = 0;
- break;
- case 'X':
- right2left = -1;
- break;
- case 'L':
- right2left = 0;
- break;
- case 'R':
- right2left = 1;
- break;
- case 'x':
- justification = -1;
- break;
- case 'l':
- justification = 0;
- break;
- case 'c':
- justification = 1;
- break;
- case 'r':
- justification = 2;
- break;
- case 'p':
- paragraphflag = 1;
- break;
- case 'n':
- paragraphflag = 0;
- break;
- case 's':
- smushoverride = SMO_NO;
- break;
- case 'k':
- smushmode = SM_KERN;
- smushoverride = SMO_YES;
- break;
- case 'S':
- smushmode = SM_SMUSH;
- smushoverride = SMO_FORCE;
- break;
- case 'o':
- smushmode = SM_SMUSH;
- smushoverride = SMO_YES;
- break;
- case 'W':
- smushmode = 0;
- smushoverride = SMO_YES;
- break;
- case 't':
-#ifdef TIOCGWINSZ
- columns = get_columns();
- if (columns>0) {
- outputwidth = columns;
- }
-#else /* ifdef TIOCGWINSZ */
- fprintf(stderr,
- "%s: \"-t\" is disabled, since ioctl is not fully implemented.\n",
- myname);
-#endif /* ifdef TIOCGWINSZ */
- break;
- case 'v':
- infoprint = 0;
- break;
- case 'I':
- infoprint = atoi(optarg);
- break;
- case 'm':
- smushmode = atoi(optarg);
- if (smushmode < -1) {
- smushoverride = SMO_NO;
- break;
- }
- if (smushmode == 0) smushmode = SM_KERN;
- else if (smushmode == -1) smushmode = 0;
- else smushmode = (smushmode & 63) | SM_SMUSH;
- smushoverride = SMO_YES;
- break;
- case 'w':
- columns = atoi(optarg);
- if (columns>0) {
- outputwidth = columns;
- }
- break;
- case 'd':
- fontdirname = optarg;
- break;
- case 'f':
- if (firstfont) {
- free(fontname);
- firstfont = 0;
- }
- fontname = optarg;
- if (suffixcmp(fontname,FONTFILESUFFIX)) {
- fontname[MYSTRLEN(fontname)-FSUFFIXLEN] = '\0';
- }
- break;
- case 'C':
- controlname = optarg;
- if (suffixcmp(controlname, CONTROLFILESUFFIX)) {
- controlname[MYSTRLEN(controlname)-CSUFFIXLEN] = '\0';
- }
- (*cfilelistend) = (cfnamenode*)myalloc(sizeof(cfnamenode));
- (*cfilelistend)->thename = controlname;
- cfilelistend = &(*cfilelistend)->next;
- (*cfilelistend) = NULL;
- break;
- case 'N':
- clearcfilelist();
- multibyte = 0;
- gn[0] = 0;
- gn[1] = 0x80;
- gn[2] = gn[3] = 0;
- gndbl[0] = gndbl[1] = gndbl[2] = gndbl[3] = 0;
- gl = 0;
- gr = 1;
- break;
- case 'F': /* Not a legal option */
- fprintf(stderr,"%s: illegal option -- F\n",myname);
- printusage(stderr);
- fprintf(stderr,"\nBecause of numerous incompatibilities, the");
- fprintf(stderr," \"-F\" option has been\n");
- fprintf(stderr,"removed. It has been replaced by the \"figlist\"");
- fprintf(stderr," program, which is now\n");
- fprintf(stderr,"included in the basic FIGlet package. \"figlist\"");
- fprintf(stderr," is also available\n");
- fprintf(stderr,"from http://www.figlet.org/";);
- fprintf(stderr,"under UNIX utilities.\n");
- exit(1);
- break;
- default:
- printusage(stderr);
- exit(1);
- }
- }
- if (optind!=Myargc) cmdinput = 1; /* force cmdinput if more arguments */
- outlinelenlimit = outputwidth-1;
- if (infoprint>=0) {
- printinfo(infoprint);
- exit(0);
- }
-}
-
-
-/****************************************************************************
-
- clearline
-
- Clears both the input (inchrline) and output (outputline) storage.
-
-****************************************************************************/
-
-void clearline()
-{
- int i;
-
- for (i=0;i<charheight;i++) {
- outputline[i][0] = '\0';
- }
- outlinelen = 0;
- inchrlinelen = 0;
-}
-
-
-/****************************************************************************
-
- readfontchar
-
- Reads a font character from the font file, and places it in a
- newly-allocated entry in the list.
-
-****************************************************************************/
-
-void readfontchar(file,theord,line,maxlen)
-ZFILE *file;
-inchr theord;
-char *line;
-int maxlen;
-{
- int row,k;
- char endchar;
- fcharnode *fclsave;
-
- fclsave = fcharlist;
- fcharlist = (fcharnode*)myalloc(sizeof(fcharnode));
- fcharlist->ord = theord;
- fcharlist->thechar = (char**)myalloc(sizeof(char*)*charheight);
- fcharlist->next = fclsave;
- for (row=0;row<charheight;row++) {
- if (myfgets(line,maxlen+1,file)==NULL) {
- line[0] = '\0';
- }
- k = MYSTRLEN(line)-1;
- while (k>=0 && isspace(line[k])) {
- k--;
- }
- if (k>=0) {
- endchar = line[k];
- while (k>=0 ? line[k]==endchar : 0) {
- k--;
- }
- }
- line[k+1] = '\0';
- fcharlist->thechar[row] = (char*)myalloc(sizeof(char)*(k+2));
- strcpy(fcharlist->thechar[row],line);
- }
-}
-
-
-/****************************************************************************
-
- readfont
-
- Allocates memory, initializes variables, and reads in the font.
- Called near beginning of main().
-
-****************************************************************************/
-
-void readfont()
-{
-#define MAXFIRSTLINELEN 1000
- int i,row,numsread;
- inchr theord;
- int maxlen,cmtlines,ffright2left;
- int smush,smush2;
- char *fontpath,*fileline,magicnum[5];
- ZFILE *fontfile;
- int namelen;
-
- namelen = MYSTRLEN(fontdirname);
- fontpath = (char*)myalloc(sizeof(char)
- *(namelen+MYSTRLEN(fontname)+FSUFFIXLEN+2));
- fontfile = NULL;
- if (!hasdirsep(fontname)) {
- strcpy(fontpath,fontdirname);
- fontpath[namelen] = DIRSEP;
- fontpath[namelen+1] = '\0';
- strcat(fontpath,fontname);
- strcat(fontpath,FONTFILESUFFIX);
- fontfile = Zopen(fontpath,"rb");
- }
- if (fontfile==NULL) {
- strcpy(fontpath,fontname);
- strcat(fontpath,FONTFILESUFFIX);
- fontfile = Zopen(fontpath,"rb");
- if (fontfile==NULL) {
- fprintf(stderr,"%s: %s: Unable to open font file\n",myname,fontpath);
- exit(1);
- }
- }
-
- readmagic(fontfile,magicnum);
- fileline = (char*)myalloc(sizeof(char)*(MAXFIRSTLINELEN+1));
- if (myfgets(fileline,MAXFIRSTLINELEN+1,fontfile)==NULL) {
- fileline[0] = '\0';
- }
- if (MYSTRLEN(fileline)>0 ? fileline[MYSTRLEN(fileline)-1]!='\n' : 0) {
- skiptoeol(fontfile);
- }
- numsread = sscanf(fileline,"%*c%c %d %*d %d %d %d %d %d",
- &hardblank,&charheight,&maxlen,&smush,&cmtlines,
- &ffright2left,&smush2);
- free(fileline);
- if (strcmp(magicnum,FONTFILEMAGICNUMBER) || numsread<5) {
- fprintf(stderr,"%s: %s: Not a FIGlet 2 font file\n",myname,fontpath);
- exit(1);
- }
- for (i=1;i<=cmtlines;i++) {
- skiptoeol(fontfile);
- }
- free(fontpath);
-
- if (numsread<6) {
- ffright2left = 0;
- }
-
- if (numsread<7) { /* if no smush2, decode smush into smush2 */
- if (smush == 0) smush2 = SM_KERN;
- else if (smush < 0) smush2 = 0;
- else smush2 = (smush & 31) | SM_SMUSH;
- }
-
- if (charheight<1) {
- charheight = 1;
- }
-
- if (maxlen<1) {
- maxlen = 1;
- }
-
- maxlen += 100; /* Give ourselves some extra room */
-
- if (smushoverride == SMO_NO)
- smushmode = smush2;
- else if (smushoverride == SMO_FORCE)
- smushmode |= smush2;
-
- if (right2left<0) {
- right2left = ffright2left;
- }
-
- if (justification<0) {
- justification = 2*right2left;
- }
-
- fileline = (char*)myalloc(sizeof(char)*(maxlen+1));
- /* Allocate "missing" character */
- fcharlist = (fcharnode*)myalloc(sizeof(fcharnode));
- fcharlist->ord = 0;
- fcharlist->thechar = (char**)myalloc(sizeof(char*)*charheight);
- fcharlist->next = NULL;
- for (row=0;row<charheight;row++) {
- fcharlist->thechar[row] = (char*)myalloc(sizeof(char));
- fcharlist->thechar[row][0] = '\0';
- }
- for (theord=' ';theord<='~';theord++) {
- readfontchar(fontfile,theord,fileline,maxlen);
- }
- for (theord=0;theord<=6;theord++) {
- readfontchar(fontfile,deutsch[theord],fileline,maxlen);
- }
- while (myfgets(fileline,maxlen+1,fontfile)==NULL?0:
- sscanf(fileline,"%li",&theord)==1) {
- readfontchar(fontfile,theord,fileline,maxlen);
- }
- Zclose(fontfile);
- free(fileline);
-}
-
-
-/****************************************************************************
-
- linealloc
-
- Allocates & clears outputline, inchrline. Sets inchrlinelenlimit.
- Called near beginning of main().
-
-****************************************************************************/
-
-void linealloc()
-{
- int row;
-
- outputline = (char**)myalloc(sizeof(char*)*charheight);
- for (row=0;row<charheight;row++) {
- outputline[row] = (char*)myalloc(sizeof(char)*(outlinelenlimit+1));
- }
- inchrlinelenlimit = outputwidth*4+100;
- inchrline = (inchr*)myalloc(sizeof(inchr)*(inchrlinelenlimit+1));
- clearline();
-}
-
-
-/****************************************************************************
-
- getletter
-
- Sets currchar to point to the font entry for the given character.
- Sets currcharwidth to the width of this character.
-
-****************************************************************************/
-
-void getletter(c)
-inchr c;
-{
- fcharnode *charptr;
-
- for (charptr=fcharlist;charptr==NULL?0:charptr->ord!=c;
- charptr=charptr->next) ;
- if (charptr!=NULL) {
- currchar = charptr->thechar;
- }
- else {
- for (charptr=fcharlist;charptr==NULL?0:charptr->ord!=0;
- charptr=charptr->next) ;
- currchar = charptr->thechar;
- }
- previouscharwidth = currcharwidth;
- currcharwidth = MYSTRLEN(currchar[0]);
-}
-
-
-/****************************************************************************
-
- smushem
-
- Given 2 characters, attempts to smush them into 1, according to
- smushmode. Returns smushed character or '\0' if no smushing can be
- done.
-
- smushmode values are sum of following (all values smush blanks):
- 1: Smush equal chars (not hardblanks)
- 2: Smush '_' with any char in hierarchy below
- 4: hierarchy: "|", "/\", "[]", "{}", "()", "<>"
- Each class in hier. can be replaced by later class.
- 8: [ + ] -> |, { + } -> |, ( + ) -> |
- 16: / + \ -> X, > + < -> X (only in that order)
- 32: hardblank + hardblank -> hardblank
-
-****************************************************************************/
-
-char smushem(lch,rch)
-char lch,rch;
-{
- if (lch==' ') return rch;
- if (rch==' ') return lch;
-
- if (previouscharwidth<2 || currcharwidth<2) return '\0';
- /* Disallows overlapping if the previous character */
- /* or the current character has a width of 1 or zero. */
-
- if ((smushmode & SM_SMUSH) == 0) return '\0'; /* kerning */
-
- if ((smushmode & 63) == 0) {
- /* This is smushing by universal overlapping. */
- if (lch==' ') return rch;
- if (rch==' ') return lch;
- if (lch==hardblank) return rch;
- if (rch==hardblank) return lch;
- /* Above four lines ensure overlapping preference to */
- /* visible characters. */
- if (right2left==1) return lch;
- /* Above line ensures that the dominant (foreground) */
- /* fig-character for overlapping is the latter in the */
- /* user's text, not necessarily the rightmost character. */
- return rch;
- /* Occurs in the absence of above exceptions. */
- }
-
- if (smushmode & SM_HARDBLANK) {
- if (lch==hardblank && rch==hardblank) return lch;
- }
-
- if (lch==hardblank || rch==hardblank) return '\0';
-
- if (smushmode & SM_EQUAL) {
- if (lch==rch) return lch;
- }
-
- if (smushmode & SM_LOWLINE) {
- if (lch=='_' && strchr("|/\\[]{}()<>",rch)) return rch;
- if (rch=='_' && strchr("|/\\[]{}()<>",lch)) return lch;
- }
-
- if (smushmode & SM_HIERARCHY) {
- if (lch=='|' && strchr("/\\[]{}()<>",rch)) return rch;
- if (rch=='|' && strchr("/\\[]{}()<>",lch)) return lch;
- if (strchr("/\\",lch) && strchr("[]{}()<>",rch)) return rch;
- if (strchr("/\\",rch) && strchr("[]{}()<>",lch)) return lch;
- if (strchr("[]",lch) && strchr("{}()<>",rch)) return rch;
- if (strchr("[]",rch) && strchr("{}()<>",lch)) return lch;
- if (strchr("{}",lch) && strchr("()<>",rch)) return rch;
- if (strchr("{}",rch) && strchr("()<>",lch)) return lch;
- if (strchr("()",lch) && strchr("<>",rch)) return rch;
- if (strchr("()",rch) && strchr("<>",lch)) return lch;
- }
-
- if (smushmode & SM_PAIR) {
- if (lch=='[' && rch==']') return '|';
- if (rch=='[' && lch==']') return '|';
- if (lch=='{' && rch=='}') return '|';
- if (rch=='{' && lch=='}') return '|';
- if (lch=='(' && rch==')') return '|';
- if (rch=='(' && lch==')') return '|';
- }
-
- if (smushmode & SM_BIGX) {
- if (lch=='/' && rch=='\\') return '|';
- if (rch=='/' && lch=='\\') return 'Y';
- if (lch=='>' && rch=='<') return 'X';
- /* Don't want the reverse of above to give 'X'. */
- }
-
- return '\0';
-}
-
-
-/****************************************************************************
-
- smushamt
-
- Returns the maximum amount that the current character can be smushed
- into the current line.
-
-****************************************************************************/
-
-int smushamt()
-{
- int maxsmush,amt;
- int row,linebd,charbd;
- char ch1,ch2;
-
- if ((smushmode & (SM_SMUSH | SM_KERN)) == 0) {
- return 0;
- }
- maxsmush = currcharwidth;
- for (row=0;row<charheight;row++) {
- if (right2left) {
- for (charbd=MYSTRLEN(currchar[row]);
- ch1=currchar[row][charbd],(charbd>0&&(!ch1||ch1==' '));charbd--) ;
- for (linebd=0;ch2=outputline[row][linebd],ch2==' ';linebd++) ;
- amt = linebd+currcharwidth-1-charbd;
- }
- else {
- for (linebd=MYSTRLEN(outputline[row]);
- ch1 = outputline[row][linebd],(linebd>0&&(!ch1||ch1==' '));linebd--) ;
- for (charbd=0;ch2=currchar[row][charbd],ch2==' ';charbd++) ;
- amt = charbd+outlinelen-1-linebd;
- }
- if (!ch1||ch1==' ') {
- amt++;
- }
- else if (ch2) {
- if (smushem(ch1,ch2)!='\0') {
- amt++;
- }
- }
- if (amt<maxsmush) {
- maxsmush = amt;
- }
- }
- return maxsmush;
-}
-
-
-/****************************************************************************
-
- addchar
-
- Attempts to add the given character onto the end of the current line.
- Returns 1 if this can be done, 0 otherwise.
-
-****************************************************************************/
-
-int addchar(c)
-inchr c;
-{
- int smushamount,row,k;
- char *templine;
-
- getletter(c);
- smushamount = smushamt();
- if (outlinelen+currcharwidth-smushamount>outlinelenlimit
- ||inchrlinelen+1>inchrlinelenlimit) {
- return 0;
- }
-
- templine = (char*)myalloc(sizeof(char)*(outlinelenlimit+1));
- for (row=0;row<charheight;row++) {
- if (right2left) {
- strcpy(templine,currchar[row]);
- for (k=0;k<smushamount;k++) {
- templine[currcharwidth-smushamount+k] =
- smushem(templine[currcharwidth-smushamount+k],outputline[row][k]);
- }
- strcat(templine,outputline[row]+smushamount);
- strcpy(outputline[row],templine);
- }
- else {
- for (k=0;k<smushamount;k++) {
- if (outlinelen-smushamount+k >= 0)
- outputline[row][outlinelen-smushamount+k] =
-
smushem(outputline[row][outlinelen-smushamount+k],currchar[row][k]);
- }
- strcat(outputline[row],currchar[row]+smushamount);
- }
- }
- free(templine);
- outlinelen = MYSTRLEN(outputline[0]);
- inchrline[inchrlinelen++] = c;
- return 1;
-}
-
-
-/****************************************************************************
-
- putstring
-
- Prints out the given null-terminated string, substituting blanks
- for hardblanks. If outputwidth is 1, prints the entire string;
- otherwise prints at most outputwidth-1 characters. Prints a newline
- at the end of the string. The string is left-justified, centered or
- right-justified (taking outputwidth as the screen width) if
- justification is 0, 1 or 2, respectively.
-
-****************************************************************************/
-
-static int nr_chars=0;
-static void myputchar(unsigned char c)
-{
- static int startline = 1;
-
- if ( startline )
- {
- startline = 0;
- myputchar(' ');
- }
-
- putc(c, stderr);
-
- if ( nr_chars == 18 )
- {
- nr_chars = 0;
- putchar('"');
- putchar(' ');
- putchar('\\');
- putchar('\n');
- }
-
- if ( nr_chars++ == 0 )
- putchar('"');
-
- putchar('\\');
- putchar('0' + ((c>>6)&7));
- putchar('0' + ((c>>3)&7));
- putchar('0' + ((c>>0)&7));
-
- if ( c == '\n' )
- startline = 1;
-}
-
-void putstring(string)
-char *string;
-{
- int i,len;
-
- len = MYSTRLEN(string);
- if (outputwidth>1) {
- if (len>outputwidth-1) {
- len = outputwidth-1;
- }
- if (justification>0) {
- for (i=1;(3-justification)*i+len+justification-2<outputwidth;i++) {
- myputchar(' ');
- }
- }
- }
- for (i=0;i<len;i++) {
- myputchar(string[i]==hardblank?' ':string[i]);
- }
- myputchar('\n');
-}
-
-
-/****************************************************************************
-
- printline
-
- Prints outputline using putstring, then clears the current line.
-
-****************************************************************************/
-
-void printline()
-{
- int i;
-
- for (i=0;i<charheight;i++) {
- putstring(outputline[i]);
- }
- clearline();
-}
-
-
-/****************************************************************************
-
- splitline
-
- Splits inchrline at the last word break (bunch of consecutive blanks).
- Makes a new line out of the first part and prints it using
- printline. Makes a new line out of the second part and returns.
-
-****************************************************************************/
-
-void splitline()
-{
- int i,gotspace,lastspace,len1,len2;
- inchr *part1,*part2;
-
- part1 = (inchr*)myalloc(sizeof(inchr)*(inchrlinelen+1));
- part2 = (inchr*)myalloc(sizeof(inchr)*(inchrlinelen+1));
- gotspace = 0;
- for (i=inchrlinelen-1;i>=0;i--) {
- if (!gotspace && inchrline[i]==' ') {
- gotspace = 1;
- lastspace = i;
- }
- if (gotspace && inchrline[i]!=' ') {
- break;
- }
- }
- len1 = i+1;
- len2 = inchrlinelen-lastspace-1;
- for (i=0;i<len1;i++) {
- part1[i] = inchrline[i];
- }
- for (i=0;i<len2;i++) {
- part2[i] = inchrline[lastspace+1+i];
- }
- clearline();
- for (i=0;i<len1;i++) {
- addchar(part1[i]);
- }
- printline();
- for (i=0;i<len2;i++) {
- addchar(part2[i]);
- }
- free(part1);
- free(part2);
-}
-
-
-/****************************************************************************
-
- handlemapping
-
- Given an input character (type inchr), executes re-mapping commands
- read from control files. Returns re-mapped character (inchr).
-
-****************************************************************************/
-
-inchr handlemapping(c)
-inchr c;
-{
- comnode *cmptr;
-
- cmptr=commandlist;
- while (cmptr!=NULL) {
- if (cmptr->thecommand ?
- (c >= cmptr->rangelo && c <= cmptr->rangehi) : 0) {
- c += cmptr->offset;
- while(cmptr!=NULL ? cmptr->thecommand : 0) {
- cmptr=cmptr->next;
- }
- }
- else {
- cmptr=cmptr->next;
- }
- }
- return c;
-}
-
-/****************************************************************************
-
- Agetchar
-
- Replacement to getchar().
- Acts exactly like getchar if -A is NOT specified,
- else obtains input from All remaining command line words.
-
-****************************************************************************/
-
-int Agetchar()
-{
- extern int optind; /* current argv[] element under study */
- static AgetMode = 0; /* >= 0 for displacement into argv[n], <0 EOF */
- char *arg; /* pointer to active character */
- int c; /* current character */
-
- if ( ! cmdinput ) /* is -A active? */
- return( getchar() ); /* no: return stdin character */
-
- if ( AgetMode < 0 || optind >= Myargc ) /* EOF is sticky: */
- return( EOF ); /* **ensure it now and forever more */
-
- /* find next character */
- arg = Myargv[optind]; /* pointer to active arg */
- c = arg[AgetMode++]&0xFF; /* get appropriate char of arg */
-
- if ( ! c ) /* at '\0' that terminates word? */
- { /* at end of word: return ' ' if normal word, '\n' if empty */
- c = ' '; /* suppose normal word and return blank */
- if ( AgetMode == 1 ) /* if ran out in very 1st char, force \n */
- c = '\n'; /* (allows "hello '' world" to do \n at '') */
- AgetMode = 0; /* return to char 0 in NEXT word */
- if ( ++optind >= Myargc ) /* run up word count and check if at
"EOF" */
- { /* just ran out of arguments */
- c = EOF; /* return EOF */
- AgetMode = -1; /* ensure all future returns return EOF */
- }
- }
-
- return( c ); /* return appropriate character */
-
-} /* end: Agetchar() */
-
-
-/****************************************************************************
-
- iso2022
-
- Called by getinchr. Interprets ISO 2022 sequences
-
-******************************************************************************/
-
-inchr iso2022()
-{
- inchr ch;
- inchr ch2;
- int save_gl;
- int save_gr;
-
- ch = Agetchar();
- if (ch == EOF) return ch;
- if (ch == 27) ch = Agetchar() + 0x100; /* ESC x */
- if (ch == 0x100 + '$') ch = Agetchar() + 0x200; /* ESC $ x */
- switch (ch) {
- case 14: /* invoke G0 into GL */
- gl = 0;
- return iso2022();
- case 15: /* invoke G1 into GL */
- gl = 1;
- return iso2022();
- case 142: case 'N' + 0x100: /* invoke G2 into GL for next char */
- save_gl = gl; save_gr = gr;
- gl = gr = 2;
- ch = iso2022();
- gl = save_gl; gr = save_gr;
- return ch;
- case 143: case 'O' + 0x100: /* invoke G3 into GL for next char */
- save_gl = gl; save_gr = gr;
- gl = gr = 3;
- ch = iso2022();
- gl = save_gl; gr = save_gr;
- return ch;
- case 'n' + 0x100: /* invoke G2 into GL */
- gl = 2;
- return iso2022();
- case 'o' + 0x100: /* invoke G3 into GL */
- gl = 3;
- return iso2022();
- case '~' + 0x100: /* invoke G1 into GR */
- gr = 1;
- return iso2022();
- case '}' + 0x100: /* invoke G2 into GR */
- gr = 2;
- return iso2022();
- case '|' + 0x100: /* invoke G3 into GR */
- gr = 3;
- return iso2022();
- case '(' + 0x100: /* set G0 to 94-char set */
- ch = Agetchar();
- if (ch == 'B') ch = 0; /* ASCII */
- gn[0] = ch << 16;
- gndbl[0] = 0;
- return iso2022();
- case ')' + 0x100: /* set G1 to 94-char set */
- ch = Agetchar();
- if (ch == 'B') ch = 0;
- gn[1] = ch << 16;
- gndbl[1] = 0;
- return iso2022();
- case '*' + 0x100: /* set G2 to 94-char set */
- ch = Agetchar();
- if (ch == 'B') ch = 0;
- gn[2] = ch << 16;
- gndbl[2] = 0;
- return iso2022();
- case '+' + 0x100: /* set G3 to 94-char set */
- ch = Agetchar();
- if (ch == 'B') ch = 0;
- gn[3] = ch << 16;
- gndbl[3] = 0;
- return iso2022();
- case '-' + 0x100: /* set G1 to 96-char set */
- ch = Agetchar();
- if (ch == 'A') ch = 0; /* Latin-1 top half */
- gn[1] = (ch << 16) | 0x80;
- gndbl[1] = 0;
- return iso2022();
- case '.' + 0x100: /* set G2 to 96-char set */
- ch = Agetchar();
- if (ch == 'A') ch = 0;
- gn[2] = (ch << 16) | 0x80;
- gndbl[2] = 0;
- return iso2022();
- case '/' + 0x100: /* set G3 to 96-char set */
- ch = Agetchar();
- if (ch == 'A') ch = 0;
- gn[3] = (ch << 16) | 0x80;
- gndbl[3] = 0;
- return iso2022();
- case '(' + 0x200: /* set G0 to 94 x 94 char set */
- ch = Agetchar();
- gn[0] = ch << 16;
- gndbl[0] = 1;
- return iso2022();
- case ')' + 0x200: /* set G1 to 94 x 94 char set */
- ch = Agetchar();
- gn[1] = ch << 16;
- gndbl[1] = 1;
- return iso2022();
- case '*' + 0x200: /* set G2 to 94 x 94 char set */
- ch = Agetchar();
- gn[2] = ch << 16;
- gndbl[2] = 1;
- return iso2022();
- case '+' + 0x200: /* set G3 to 94 x 94 char set */
- ch = Agetchar();
- gn[3] = ch << 16;
- gndbl[3] = 1;
- return iso2022();
- default:
- if (ch & 0x200) { /* set G0 to 94 x 94 char set (deprecated) */
- gn[0] = (ch & ~0x200) << 16;
- gndbl[0] = 1;
- return iso2022();
- }
- }
-
- if (ch >= 0x21 && ch <= 0x7E) { /* process GL */
- if (gndbl[gl]) {
- ch2 = Agetchar();
- return gn[gl] | (ch << 8) | ch2;
- }
- else return gn[gl] | ch;
- }
- else if (ch >= 0xA0 && ch <= 0xFF) { /* process GR */
- if (gndbl[gr]) {
- ch2 = Agetchar();
- return gn[gr] | (ch << 8) | ch2;
- }
- else return gn[gr] | (ch & ~0x80);
- }
- else return ch;
- }
-
-/****************************************************************************
-
- ungetinchr
-
- Called by main. Pushes back an "inchr" to be read by getinchr
- on the next call.
-
-******************************************************************************/
-inchr getinchr_buffer;
-int getinchr_flag;
-
-inchr ungetinchr(c)
-inchr c;
-{
- getinchr_buffer = c;
- getinchr_flag = 1;
- return c;
-}
-
-/*****************************************************************************
-
- getinchr
-
- Called by main. Processes multibyte characters. Invokes Agetchar.
- If multibyte = 0, ISO 2022 mode (see iso2022 routine).
- If multibyte = 1, double-byte mode (0x00-0x7f bytes are characters,
- 0x80-0xFF bytes are first byte of a double-byte character).
- If multibyte = 2, Unicode UTF-8 mode (0x00-0x7F bytes are characters,
- 0x80-0xBF bytes are nonfirst byte of a multibyte character,
- 0xC0-0xFD bytes are first byte of a multibyte character,
- 0xFE-0xFF bytes are errors (all errors return code 0x0080)).
- If multibyte = 3, HZ mode ("~{" starts double-byte mode, "}~" ends it,
- "~~" is a tilde, "~x" for all other x is ignored).
- If multibyte = 4, Shift-JIS mode (0x80-0x9F and 0xE0-0xEF are first byte
- of a double-byte character, all other bytes are characters).
-
-
-*****************************************************************************/
-
-inchr getinchr()
-{
- int ch, ch2, ch3, ch4, ch5, ch6;
-
- if (getinchr_flag) {
- getinchr_flag = 0;
- return getinchr_buffer;
- }
-
- switch(multibyte) {
- case 0: /* single-byte */
- return iso2022();
- case 1: /* DBCS */
- ch = Agetchar();
- if ((ch >= 0x80 && ch <= 0x9F) ||
- (ch >= 0xE0 && ch <= 0xEF)) {
- ch = (ch << 8) + Agetchar();
- }
- return ch;
- case 2: /* UTF-8 */
- ch = Agetchar();
- if (ch < 0x80) return ch; /* handles EOF, too */
- if (ch < 0xC0 || ch > 0xFD)
- return 0x0080; /* illegal first character */
- ch2 = Agetchar() & 0x3F;
- if (ch < 0xE0) return ((ch & 0x1F) << 6) + ch2;
- ch3 = Agetchar() & 0x3F;
- if (ch < 0xF0)
- return ((ch & 0x0F) << 12) + (ch2 << 6) + ch3;
- ch4 = Agetchar() & 0x3F;
- if (ch < 0xF8)
- return ((ch & 0x07) << 18) + (ch2 << 12) + (ch3 << 6) + ch4;
- ch5 = Agetchar() & 0x3F;
- if (ch < 0xFC)
- return ((ch & 0x03) << 24) + (ch2 << 18) + (ch3 << 12) +
- (ch4 << 6) + ch5;
- ch6 = Agetchar() & 0x3F;
- return ((ch & 0x01) << 30) + (ch2 << 24) + (ch3 << 18) +
- (ch4 << 12) + (ch5 << 6) + ch6;
- case 3: /* HZ */
- ch = Agetchar();
- if (ch == EOF) return ch;
- if (hzmode) {
- ch = (ch << 8) + Agetchar();
- if (ch == ('}' << 8) + '~') {
- hzmode = 0;
- return getinchr();
- }
- return ch;
- }
- else if (ch == '~') {
- ch = Agetchar();
- if (ch == '{') {
- hzmode = 1;
- return getinchr();
- }
- else if (ch == '~') {
- return ch;
- }
- else {
- return getinchr();
- }
- }
- else return ch;
- case 4: /* Shift-JIS */
- ch = Agetchar();
- if ((ch >= 0x80 && ch <= 0x9F) ||
- (ch >= 0xE0 && ch <= 0xEF)) {
- ch = (ch << 8) + Agetchar();
- }
- return ch;
- default:
- return 0x80;
- }
- }
-
-/****************************************************************************
-
- main
-
- The main program, of course.
- Reads characters 1 by 1 from stdin, and makes lines out of them using
- addchar. Handles line breaking, (which accounts for most of the
- complexity in this function).
-
-****************************************************************************/
-
-int main(argc,argv)
-int argc;
-char *argv[];
-{
- inchr c,c2;
- int i;
- int last_was_eol_flag;
-/*---------------------------------------------------------------------------
- wordbreakmode:
- -1: /^$/ and blanks are to be absorbed (when line break was forced
- by a blank or character larger than outlinelenlimit)
- 0: /^ *$/ and blanks are not to be absorbed
- 1: /[^ ]$/ no word break yet
- 2: /[^ ] *$/
- 3: /[^ ]$/ had a word break
----------------------------------------------------------------------------*/
- int wordbreakmode;
- int char_not_added;
-
- Myargc = argc;
- Myargv = argv;
- getparams();
- readcontrolfiles();
- readfont();
- linealloc();
-
- wordbreakmode = 0;
- last_was_eol_flag = 0;
-
- while ((c = getinchr())!=EOF) {
-
- if (c=='\n'&¶graphflag&&!last_was_eol_flag) {
- ungetinchr(c2 = getinchr());
- c = ((isascii(c2)&&isspace(c2))?'\n':' ');
- }
- last_was_eol_flag = (isascii(c)&&isspace(c)&&c!='\t'&&c!=' ');
-
- if (deutschflag) {
- if (c>='[' && c<=']') {
- c = deutsch[c-'['];
- }
- else if (c >='{' && c <= '~') {
- c = deutsch[c-'{'+3];
- }
- }
-
- c = handlemapping(c);
-
- if (isascii(c)&&isspace(c)) {
- c = (c=='\t'||c==' ') ? ' ' : '\n';
- }
-
- if ((c>'\0' && c<' ' && c!='\n') || c==127) continue;
-
-/*
- Note: The following code is complex and thoroughly tested.
- Be careful when modifying!
-*/
-
- do {
- char_not_added = 0;
-
- if (wordbreakmode== -1) {
- if (c==' ') {
- break;
- }
- else if (c=='\n') {
- wordbreakmode = 0;
- break;
- }
- wordbreakmode = 0;
- }
-
- if (c=='\n') {
- printline();
- wordbreakmode = 0;
- }
-
- else if (addchar(c)) {
- if (c!=' ') {
- wordbreakmode = (wordbreakmode>=2)?3:1;
- }
- else {
- wordbreakmode = (wordbreakmode>0)?2:0;
- }
- }
-
- else if (outlinelen==0) {
- for (i=0;i<charheight;i++) {
- if (right2left && outputwidth>1) {
- putstring(currchar[i]+MYSTRLEN(currchar[i])-outlinelenlimit);
- }
- else {
- putstring(currchar[i]);
- }
- }
- wordbreakmode = -1;
- }
-
- else if (c==' ') {
- if (wordbreakmode==2) {
- splitline();
- }
- else {
- printline();
- }
- wordbreakmode = -1;
- }
-
- else {
- if (wordbreakmode>=2) {
- splitline();
- }
- else {
- printline();
- }
- wordbreakmode = (wordbreakmode==3)?1:0;
- char_not_added = 1;
- }
-
- } while (char_not_added);
- }
-
- if (outlinelen!=0) {
- printline();
- }
-
- /* XXX Xen hack -- finish off the C macro output */
- if ( nr_chars != 0 )
- putchar('"');
- putchar('\n');
-
- exit(0);
-}
diff --git a/xen/tools/figlet/xen.flf b/xen/tools/xen.flf
similarity index 100%
rename from xen/tools/figlet/xen.flf
rename to xen/tools/xen.flf
--
1.7.10.4
_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxx
http://lists.xen.org/xen-devel
|
 |
Lists.xenproject.org is hosted with RackSpace, monitoring our |