Anonymous avatar Anonymous committed f98efb8

New package.

Comments (0)

Files changed (107)

+-*- mode: text; left-margin: 2; fill-column: 70; -*-
+
+  Liece is mainly written by Daiki Ueno <ueno@unixuser.org>.
+  
+  This package based on Irchat (version 3.01) which has been
+  distributed under GPL1 or later.
+  
+  Original author of Irchat is Tor Lillqvist <tml@hemuli.atk.vtt.fi>
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                          59 Temple Place - Suite 330, Boston, MA
+                          02111-1307, USA.
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	Appendix: How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) 19yy  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) 19yy name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.
+2002-03-22  Daiki Ueno  <daiki@xemacs.org>
+
+	* Makefile: Created.
+	* package-info.in: Created.
+
+-*- mode: text; left-margin: 2; fill-column: 70; -*-
+
+  This program is in very early developing stage. Please use at your
+  own risk.
+  
+* Requirements
+
+  Liece works under following environment at least.
+  
+  - Emacs 20.7
+  - XEmacs 21.4 or later
+  
+  This package uses following libraries.
+  
+  - APEL 10.2 or later (stands for - "A Portable Emacs Library")
+       ftp://ftp.m17n.org/pub/mule/apel/
+  - FLIM 1.12 or later
+       ftp://ftp.m17n.org/pub/mule/flim/
+
+* Quick installation
+
+  (Install APEL, then)
+  % ./configure
+  % make
+  % su
+  Password:
+  # make install
+  
+  If you are not able to become super-user, you may specify local
+  directory to install.
+  
+  % ./configure --prefix=~/ --with-lispdir=~/elisp
+
+* Configuration and running
+  
+** Setting up your ~/.emacs   
+  
+  If you are using Emacs or Mule, please add directory of APEL and
+  Liece to load-path.  If you install by default setting you can write
+  subdirs.el for example:
+  
+  ex:
+  (normal-top-level-add-to-load-path '("apel" "liece"))
+
+  If you are using Emacs 20.3 or XEmacs, prepare `subdirs.el' with
+  following contents, Emacs will find and append each substantial
+  directory to `load-path' automagically.
+
+  ex:
+  (normal-top-level-add-subdirs-to-load-path)
+
+  If you are using Emacs 19 or earlier version of Emacsen, 
+  you have to write more complicated path-setting in your `~/.emacs'.
+  
+  ex: 
+  (setq load-path 
+        (append 
+         (list "/usr/local/lib/mule/site-lisp/apel"
+	       "/usr/local/lib/mule/site-lisp/liece")
+         load-path))
+  
+  For more details, please read `README' file come along with APEL.
+
+  If you have never been using liece and/or its variants, 
+  add an autoload setting into your `~/.emacs'.
+
+  ex:
+  (autoload 'liece "liece" nil t)
+
+** Setting up your ~/.liece/init.el
+  
+  If you have never run Liece, and quite unsure to configure startup
+  files in Emacs Lisp, please copy `sample.dot.emacs' file to `~/.liece/init.el'.
+  
+* Optional packages
+
+  Following packages are optional. If install script of this package
+  found them, it would use various functionality provided by them.
+  
+  custom
+	http://www.dina.kvl.dk/~abraham/custom/
+
+  X-Face utility
+	ftp://ftp.jpl.org/pub/elisp/
+
+  bitmap-mule
+	ftp://ftp.jpl.org/pub/elisp/bitmap/ (for GNU Emacs only)
+# Makefile for Liece lisp code
+
+# This file is part of XEmacs.
+
+# XEmacs is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation; either version 2, or (at your option) any
+# later version.
+
+# XEmacs is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with XEmacs; see the file COPYING.  If not, write to
+# the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+# This XEmacs package contains independent single file lisp packages
+
+VERSION = 1.00
+AUTHOR_VERSION = 1.4.7
+MAINTAINER = Daiki Ueno <ueno@unixuser.org>
+PACKAGE = liece
+PKG_TYPE = regular
+REQUIRES = apel mail-lib
+CATEGORY = standard
+
+ELCS = lisp/liece-xemacs.elc lisp/gettext.elc lisp/liece-clfns.elc \
+	lisp/liece-handler.elc lisp/liece-compat.elc lisp/liece-version.elc \
+	lisp/liece-vars.elc lisp/liece-globals.elc lisp/liece-inlines.elc \
+	lisp/liece-filter.elc lisp/liece-coding.elc lisp/liece-dcc.elc \
+	lisp/liece-menu.elc lisp/liece-000.elc lisp/liece-200.elc \
+	lisp/liece-300.elc lisp/liece-400.elc lisp/liece-500.elc \
+	lisp/liece-nick.elc lisp/liece-channel.elc lisp/liece-commands.elc \
+	lisp/liece-ctcp.elc lisp/liece-q-el.elc lisp/liece-message.elc \
+	lisp/liece-handle.elc lisp/liece-hilit.elc lisp/liece-intl.elc \
+	lisp/liece-mail.elc lisp/liece-minibuf.elc lisp/liece-misc.elc \
+	lisp/liece-tcp.elc lisp/liece-url.elc lisp/liece-x-face.elc \
+	lisp/liece-window.elc lisp/liece.elc
+
+MULE_ELCS = lisp/liece-q-ccl.elc
+
+DATA_1_FILES = $(wildcard etc/icons/*.xpm)
+DATA_1_DEST = $(PACKAGE)/icons
+
+DATA_2_FILES = etc/styles/top etc/styles/middle etc/styles/bottom
+DATA_2_DEST = $(PACKAGE)/styles
+
+DATA_3_FILES = etc/po/liece.mo
+DATA_3_DEST = $(PACKAGE)/locale/ja/LC_MESSAGES
+
+AUTOLOAD_PATH = lisp
+
+INFO_FILES = doc/liece.info
+TEXI_FILES = doc/liece.texi
+MANUAL = liece
+
+include ../../XEmacs.rules
+
+GENERATED += lisp/custom-load.elc lisp/liece-setup.elc
+
+all:: package lisp/liece-setup.elc $(DATA_3_FILES) $(INFO_FILES) \
+	$(AUTOLOAD_PATH)/auto-autoloads.elc $(AUTOLOAD_PATH)/custom-load.elc
+
+package:
+	$(MAKE) -C lisp -f Makefile.lisp package
+
+etc/po/liece.mo: etc/po/ja.po
+	(cd etc/po; msgfmt -o liece.mo ja.po)
+
+srckit: srckit-std
+
+binkit: binkit-common
+
+SUBDIRS = lisp doc dcc etc
+
+install-package package:
+	list='$(SUBDIRS)'; for subdir in $$list; do \
+	  (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $@) \
+	done
+-*- mode: text; left-margin: 2; fill-column: 70; -*-
+
+* Directory tree
+  
+  This package contains following directories:
+  
+  lisp/ - Emacs Lisp files.
+  
+  dcc/  - DCC external program source.
+  
+  doc/  - Documentation, info files, sample configuration, etc.
+  
+  etc/  - Miscellaneous files which decorate this program.
+  
+  Please read documentation under `doc' directory.
+
+* Bug reports
+  
+  If you write bug reports and/or suggestions for improvement, 
+  please send them to the Liece Mailing List.
+  This mailing list is also for other general discussions (about
+  future enhancements, customization, etc). To join the Liece ML,
+  send an e-mail to:
+  
+       liece-ctl@unixuser.org
+  
+  with the message body, 
+
+       subscribe Your Name
+
+* CVS
+  
+  Development of Liece uses CVS, Concurrent Versions System.
+  Latest developing version is available at CVS.
+  
+(0) logging in to anonymous CVS server.
+  
+    % cvs -d :pserver:anonymous@cvs.m17n.org:/cvs/root login
+
+    CVS password: [CR] # NULL string
+  
+(1) checkout modules
+  
+    % cvs -d :pserver:anonymous@cvs.m17n.org:/cvs/root checkout liece
+  
+  Specify revision tag in front of the module name.
+
+(2) bootstrapping
+  
+  % cd liece
+  % ./bootstrap
+AC_DEFUN(AC_DEFINE_GNUS_PRODUCT_NAME,
+ [echo $ac_n "defining gnus product name... $ac_c"
+  AC_CACHE_VAL(EMACS_cv_GNUS_PRODUCT_NAME,[EMACS_cv_GNUS_PRODUCT_NAME=$1])
+  GNUS_PRODUCT_NAME=${EMACS_cv_GNUS_PRODUCT_NAME}
+  AC_MSG_RESULT(${GNUS_PRODUCT_NAME})
+  AC_SUBST(GNUS_PRODUCT_NAME)])
+
+AC_DEFUN(AC_CHECK_EMACS,
+ [dnl Check for Emacsen.
+
+  dnl Apparently, if you run a shell window in Emacs, it sets the EMACS
+  dnl environment variable to 't'.  Lets undo the damage.
+  test "$EMACS" = t && EMACS=
+
+  dnl Ignore cache.
+  unset ac_cv_prog_EMACS; unset ac_cv_prog_XEMACS;
+
+  AC_ARG_WITH(emacs,
+   [  --with-emacs=EMACS      compile with EMACS [EMACS=emacs, mule...]],
+   [if test "$withval" = yes -o -z "$withval"; then
+      AC_CHECK_PROGS(EMACS, emacs xemacs mule, emacs)
+    else
+      AC_CHECK_PROG(EMACS, $withval, $withval, emacs)
+    fi])
+  AC_ARG_WITH(xemacs,
+   [  --with-xemacs=XEMACS    compile with XEMACS [XEMACS=xemacs]],
+   [if test "$withval" = yes -o -z "$withval"; then
+      AC_CHECK_PROG(XEMACS, xemacs, xemacs, xemacs)
+    else
+      AC_CHECK_PROG(XEMACS, $withval, $withval, xemacs)
+    fi
+    EMACS=$XEMACS],
+   [XEMACS=xemacs
+    test -z "$EMACS" && AC_CHECK_PROGS(EMACS, emacs xemacs mule, emacs)])
+  AC_SUBST(EMACS)
+  AC_SUBST(XEMACS)])
+
+AC_DEFUN(AC_EMACS_LISP, [
+elisp="$2"
+if test -z "$3"; then
+	AC_MSG_CHECKING(for $1)
+fi
+AC_CACHE_VAL(EMACS_cv_SYS_$1,[
+	OUTPUT=./conftest-$$
+	echo ${EMACS}' -batch -eval '\''(let ((x '${elisp}')) (write-region (if (stringp x) (princ x) (prin1-to-string x)) nil "'${OUTPUT}'" nil 5))'\' >& AC_FD_CC 2>&1
+	eval ${EMACS}' -batch -eval '\''(let ((x '${elisp}')) (write-region (if (stringp x) (princ x) (prin1-to-string x)) nil "'${OUTPUT}'" nil 5))'\' >& AC_FD_CC 2>&1
+	retval=`cat ${OUTPUT}`
+	echo "=> ${retval}" >& AC_FD_CC 2>&1
+	rm -f ${OUTPUT}
+	EMACS_cv_SYS_$1=$retval
+])
+$1=${EMACS_cv_SYS_$1}
+if test -z "$3"; then
+	AC_MSG_RESULT($$1)
+fi
+])
+
+AC_DEFUN(AC_CHECK_EMACS_FLAVOR,
+ [AC_MSG_CHECKING([what a flavor does $EMACS have])
+
+  dnl Ignore cache.
+  unset EMACS_cv_SYS_flavor;
+
+  AC_EMACS_LISP(flavor,
+    (cond ((featurep (quote xemacs)) \"XEmacs\")\
+          ((boundp (quote MULE)) \"MULE\")\
+          (t \"FSF Emacs\")),
+    "noecho")
+  case $EMACS_cv_SYS_flavor in
+  XEmacs)
+    EMACS_FLAVOR=xemacs;;
+  MULE)
+    EMACS_FLAVOR=mule;;
+  *)
+    EMACS_FLAVOR=emacs;;
+  esac
+  AC_MSG_RESULT($EMACS_cv_SYS_flavor)])
+
+AC_DEFUN(AC_PATH_LISPDIR, [
+  AC_CHECK_EMACS_FLAVOR
+  if test "$prefix" = NONE; then
+	AC_MSG_CHECKING([prefix for your Emacs])
+	AC_EMACS_LISP(prefix,(expand-file-name \"..\" invocation-directory),"noecho")
+	prefix=${EMACS_cv_SYS_prefix}
+	AC_MSG_RESULT($prefix)
+  fi
+  AC_ARG_WITH(lispdir,
+    [  --with-lispdir=DIR      Where to install lisp files
+                          (for XEmacs package, use --with-packagedir instead)],
+    lispdir=${withval})
+  AC_MSG_CHECKING([where lisp files should go])
+  if test -z "$lispdir"; then
+    dnl Set default value
+    theprefix=$prefix
+    if test "$theprefix" = NONE; then
+	theprefix=$ac_default_prefix
+    fi
+    lispdir="\$(datadir)/${EMACS_FLAVOR}/site-lisp/${GNUS_PRODUCT_NAME}"
+    for thedir in share lib; do
+	potential=
+	if test -d ${theprefix}/${thedir}/${EMACS_FLAVOR}/site-lisp; then
+	   lispdir="\$(prefix)/${thedir}/${EMACS_FLAVOR}/site-lisp/${GNUS_PRODUCT_NAME}"
+	   break
+	fi
+    done
+  fi
+  if test ${EMACS_FLAVOR} = xemacs; then
+    AC_MSG_RESULT([$lispdir
+         (it will be ignored when \"make install-package[[-ja]]\" is done)])
+  else
+    AC_MSG_RESULT([$lispdir])
+  fi
+  AC_SUBST(lispdir)
+])
+
+AC_DEFUN(AC_PATH_ETCDIR, [
+  AC_ARG_WITH(etcdir,[  --with-etcdir=DIR       Where to install etc files], etcdir=${withval})
+  AC_MSG_CHECKING([where etc files should go])
+  if test -z "$etcdir"; then
+    dnl Set default value
+    etcdir="\$(lispdir)/../etc"
+  fi
+  AC_MSG_RESULT($etcdir)
+  AC_SUBST(etcdir)
+])
+
+dnl
+dnl Check whether a function exists in a library
+dnl All '_' characters in the first argument are converted to '-'
+dnl
+AC_DEFUN(AC_EMACS_CHECK_LIB, [
+if test -z "$3"; then
+	AC_MSG_CHECKING(for $2 in $1)
+fi
+library=`echo $1 | tr _ -`
+AC_EMACS_LISP($1,(progn (fmakunbound (quote $2)) (condition-case nil (progn (require (quote $library)) (fboundp (quote $2))) (error (prog1 nil (message \"$library not found\"))))),"noecho")
+if test "${EMACS_cv_SYS_$1}" = nil; then
+	EMACS_cv_SYS_$1=no
+fi
+if test "${EMACS_cv_SYS_$1}" = t; then
+	EMACS_cv_SYS_$1=yes
+fi
+HAVE_$1=${EMACS_cv_SYS_$1}
+AC_SUBST(HAVE_$1)
+if test -z "$3"; then
+	AC_MSG_RESULT($HAVE_$1)
+fi
+])
+
+dnl
+dnl Perform sanity checking and try to locate the W3 package
+dnl
+AC_DEFUN(AC_CHECK_W3, [
+AC_MSG_CHECKING(for acceptable W3 version)
+
+dnl Ignore cache.
+unset EMACS_cv_ACCEPTABLE_W3;
+unset EMACS_cv_SYS_w3_dir;
+unset EMACS_cv_SYS_w3_forms;
+
+AC_CACHE_VAL(EMACS_cv_ACCEPTABLE_W3,[
+AC_EMACS_CHECK_LIB(w3_forms, w3-form-encode-xwfu,"noecho")
+if test "${HAVE_w3_forms}" = yes; then
+	EMACS_cv_ACCEPTABLE_W3=yes
+else
+	EMACS_cv_ACCEPTABLE_W3=
+fi
+
+if test "${EMACS_cv_ACCEPTABLE_W3}" = yes; then
+	AC_EMACS_LISP(w3_dir,(file-name-directory (locate-library \"w3-forms\")),"noecho")
+	EMACS_cv_ACCEPTABLE_W3=$EMACS_cv_SYS_w3_dir
+fi
+])
+   AC_ARG_WITH(w3,[  --with-w3=DIR           Specify where to find the w3 package], [ EMACS_cv_ACCEPTABLE_W3=`( cd $withval && pwd || echo "$withval" ) 2> /dev/null` ])
+   W3=${EMACS_cv_ACCEPTABLE_W3}
+   AC_SUBST(W3)
+   if test -z "${EMACS_cv_ACCEPTABLE_W3}"; then
+	AC_MSG_RESULT(not found)
+   else
+	AC_MSG_RESULT(${W3})
+   fi
+])
+
+dnl
+dnl Perform sanity checking and try to locate the W3 package
+dnl
+AC_DEFUN(AC_CHECK_URL, [
+AC_MSG_CHECKING(for acceptable URL version)
+
+dnl Ignore cache.
+unset EMACS_cv_ACCEPTABLE_URL;
+unset EMACS_cv_SYS_url_dir;
+unset EMACS_cv_SYS_url;
+
+AC_CACHE_VAL(EMACS_cv_ACCEPTABLE_URL,[
+AC_EMACS_CHECK_LIB(url, url-retrieve, "noecho")
+if test "${HAVE_url}" = yes; then
+	EMACS_cv_ACCEPTABLE_URL=yes
+else
+	EMACS_cv_ACCEPTABLE_URL=
+fi
+
+if test "${EMACS_cv_ACCEPTABLE_URL}" = yes; then
+	AC_EMACS_LISP(url_dir,(file-name-directory (locate-library \"url\")),"noecho")
+	EMACS_cv_ACCEPTABLE_URL=$EMACS_cv_SYS_url_dir
+fi
+])
+   AC_ARG_WITH(url,[  --with-url=DIR          Specify where to find the url package], [ EMACS_cv_ACCEPTABLE_URL=`( cd $withval && pwd || echo "$withval" ) 2> /dev/null` ])
+   URL=${EMACS_cv_ACCEPTABLE_URL}
+   AC_SUBST(URL)
+   if test -z "${EMACS_cv_ACCEPTABLE_URL}"; then
+	AC_MSG_RESULT(not found)
+   else
+	AC_MSG_RESULT("${URL}")
+   fi
+])
+
+dnl
+dnl Perform checking available fonts: Adobe Bembo, Adobe Futura and 
+dnl Bitstream Courier.
+dnl
+
+AC_DEFUN(GNUS_CHECK_FONTS, [
+test "$LATEX" = t && LATEX=
+test "$LATEX" || AC_PATH_PROGS(LATEX, latex, no)
+AC_MSG_CHECKING(for available fonts)
+AC_ARG_WITH(fonts,[  --with-fonts            Assume all fonts required are available],[USE_FONTS="$withval"])
+WITH_FONTS_bembo='%'
+WITHOUT_FONTS_bembo=
+WITH_FONTS_pfu='%'
+WITHOUT_FONTS_pfu=
+WITH_FONTS_bcr='%'
+WITHOUT_FONTS_bcr=
+if test -z "${USE_FONTS}"; then
+  if test "${LATEX}" = no; then
+	:
+  else
+    OUTPUT=./conftest-$$
+    echo '\nonstopmode\documentclass{article}\usepackage{bembo}\begin{document}\end{document}' > ${OUTPUT}
+    if ${LATEX} ${OUTPUT} </dev/null >& AC_FD_CC 2>&1  ; then  
+      if test -z "${USE_FONTS}"; then
+	USE_FONTS="Adobe Bembo"
+      else
+	USE_FONTS="${USE_FONTS}, Adobe Bembo"
+      fi
+      WITH_FONTS_bembo=
+      WITHOUT_FONTS_bembo='%'
+    fi
+    echo '\nonstopmode\documentclass{article}\begin{document}{\fontfamily{pfu}\fontsize{10pt}{10}\selectfont test}\end{document}' > ${OUTPUT}
+    if retval=`${LATEX} ${OUTPUT} </dev/null 2>& AC_FD_CC`; then
+      if echo "$retval" | grep 'Some font shapes were not available' >& AC_FD_CC 2>&1  ; then  
+	:
+      else
+        if test -z "${USE_FONTS}"; then
+	  USE_FONTS="Adobe Futura"
+        else
+	  USE_FONTS="${USE_FONTS}, Adobe Futura"
+        fi
+        WITH_FONTS_pfu=
+        WITHOUT_FONTS_pfu='%'
+      fi
+    fi
+    echo '\nonstopmode\documentclass{article}\begin{document}{\fontfamily{bcr}\fontsize{10pt}{10}\selectfont test}\end{document}' > ${OUTPUT}
+    if retval=`${LATEX} ${OUTPUT} </dev/null 2>& AC_FD_CC`; then
+      if echo "$retval" | grep 'Some font shapes were not available' >& AC_FD_CC 2>&1  ; then  
+	:
+      else
+        if test -z "${USE_FONTS}"; then
+	  USE_FONTS="Bitstream Courier"
+        else
+	  USE_FONTS="${USE_FONTS}, Bitstream Courier"
+        fi
+        WITH_FONTS_bcr=
+        WITHOUT_FONTS_bcr='%'
+      fi
+    fi
+    rm -f ${OUTPUT} ${OUTPUT}.aux ${OUTPUT}.log ${OUTPUT}.dvi
+  fi
+elif test "${USE_FONTS}" = yes ; then
+  WITH_FONTS_bembo=
+  WITHOUT_FONTS_bembo='%'
+  WITH_FONTS_pfu=
+  WITHOUT_FONTS_pfu='%'
+  WITH_FONTS_bcr=
+  WITHOUT_FONTS_bcr='%'
+fi
+AC_SUBST(WITH_FONTS_bembo)
+AC_SUBST(WITHOUT_FONTS_bembo)
+AC_SUBST(WITH_FONTS_pfu)
+AC_SUBST(WITHOUT_FONTS_pfu)
+AC_SUBST(WITH_FONTS_bcr)
+AC_SUBST(WITHOUT_FONTS_bcr)
+if test -z "${USE_FONTS}" ; then
+  USE_FONTS=no
+fi
+USE_FONTS=`echo "${USE_FONTS}" | sed 's/,\([[^,]]*\)$/ and\1/'`
+AC_MSG_RESULT("${USE_FONTS}")
+if test "${USE_FONTS}" = yes ; then
+  USE_FONTS='Set in Adobe Bembo, Adobe Futura and Bitstream Courier.'
+elif test "${USE_FONTS}" = no ; then
+  USE_FONTS=''
+else
+  USE_FONTS="Set in ${USE_FONTS}."
+fi
+AC_SUBST(USE_FONTS)
+])
+
+AC_DEFUN(AC_EXAMINE_PACKAGEDIR,
+ [dnl Examine PACKAGEDIR.
+  AC_EMACS_LISP(PACKAGEDIR,
+    (let (package-dir)\
+      (if (boundp (quote early-packages))\
+	  (let ((dirs (delq nil (append (if early-package-load-path\
+					    early-packages)\
+					(if late-package-load-path\
+					    late-packages)\
+					(if last-package-load-path\
+					    last-packages)))))\
+	    (while (and dirs (not package-dir))\
+	      (if (file-directory-p (car dirs))\
+		  (setq package-dir (car dirs)\
+			dirs (cdr dirs))))))\
+      (or package-dir \"\")),
+    "noecho")])
+
+AC_DEFUN(AC_PATH_PACKAGEDIR,
+ [dnl Check for PACKAGEDIR.
+  if test ${EMACS_FLAVOR} = xemacs; then
+    AC_MSG_CHECKING([where the XEmacs package is])
+    AC_ARG_WITH(packagedir,
+      [  --with-packagedir=DIR   package DIR for XEmacs],
+      [if test "$withval" != yes -a -n "$withval"; then
+	PACKAGEDIR=$withval
+      else
+	AC_EXAMINE_PACKAGEDIR
+      fi],
+      AC_EXAMINE_PACKAGEDIR)
+    if test -z "$PACKAGEDIR"; then
+      AC_MSG_RESULT(not found)
+    else
+      AC_MSG_RESULT($PACKAGEDIR)
+    fi
+  else
+    PACKAGEDIR=
+  fi
+  AC_SUBST(PACKAGEDIR)])
+
+AC_DEFUN(AC_ADD_LOAD_PATH,
+ [dnl Check for additional load path.
+  AC_ARG_WITH(addpath,
+   [  --with-addpath=PATH     search Emacs-Lisp libraries with PATH
+                          use colons to separate directory names],
+   [if test "$withval" != yes -a -n "$withval"; then
+      AC_MSG_CHECKING([where to find the additional elisp libraries])
+      ADDITIONAL_LOAD_PATH=$withval
+      AC_MSG_RESULT($ADDITIONAL_LOAD_PATH)
+    fi],
+    ADDITIONAL_LOAD_PATH=)
+  AC_SUBST(ADDITIONAL_LOAD_PATH)])
+#! /bin/sh
+
+aclocal
+automake --gnu --add-missing
+autoconf
+
+exit 0
+AC_INIT(configure.in)
+AC_PREREQ(2.13)
+AM_INIT_AUTOMAKE(liece, 1.4.7)
+
+AC_PROG_CC
+AC_ISC_POSIX
+AC_PROG_INSTALL
+AC_PROG_MAKE_SET
+AC_PROG_RANLIB
+
+AC_CHECK_HEADERS(sys/select.h libgen.h)
+
+AC_CHECK_LIB(nsl, gethostbyname)
+AC_CHECK_LIB(socket, socket)
+
+AC_CHECK_FUNCS(strtoul memmove getaddrinfo)
+AC_CHECK_FUNC(getopt_long,,LIBOBJS="$LIBOBJS getopt.o getopt1.o")
+AC_REPLACE_FUNCS(basename)
+AC_CHECK_EMACS
+AC_PATH_LISPDIR
+AC_PATH_ETCDIR
+AC_PATH_PACKAGEDIR
+
+AC_OUTPUT(Makefile \
+lisp/Makefile \
+dcc/Makefile \
+doc/Makefile \
+etc/Makefile \
+etc/icons/Makefile \
+etc/po/Makefile \
+etc/styles/Makefile)
+Makefile.in
+Makefile
+ldcc
+ltcp
+.deps
+DEFS = -I$(srcdir) -I$(top_srcdir) $(CFLAGS) @DEFS@
+LIBOBJS = @LIBOBJS@
+EXTRA_DIST = basename.c getopt.c getopt.h getopt1.c
+CLEANFILES = ldcc ltcp
+
+bin_PROGRAMS = ldcc ltcp
+
+ltcp_SOURCES = tcp.c
+ltcp_LDADD = $(LIBOBJS)
+ldcc_SOURCES = dcc.c
+ldcc_LDADD = $(LIBOBJS)
+
+package: all
+install-package: package install
+/* Return the name-within-directory of a file name.
+   Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public
+   License along with the GNU C Library; see the file COPYING.LIB.  If not,
+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <string.h>
+
+#define _LIBC
+#ifndef _LIBC
+/* We cannot generally use the name `basename' since XPG defines an unusable
+   variant of the function but we cannot use it.  */
+# define basename gnu_basename
+#endif
+
+
+char *
+basename (filename)
+     const char *filename;
+{
+  char *p = strrchr (filename, '/');
+  return p ? p + 1 : (char *) filename;
+}
+/* dcc.c
+ * Copyright (C) 1998-2002  Daiki Ueno
+ *
+ * This file is part of Liece.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/socket.h>
+#include <sys/file.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <netdb.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <fcntl.h>
+#include <netinet/in.h>
+#define _GNU_SOURCE
+#include <getopt.h>
+
+#ifndef MAXHOSTNAMELEN
+# define MAXHOSTNAMELEN 31
+#endif
+
+#ifdef HAVE_SYS_SELECT_H
+# include <sys/select.h>
+#endif
+
+#ifdef HAVE_MEMMOVE
+# ifdef HAVE_LIBGEN_H
+#  include <libgen.h>
+#  ifdef basename
+#   undef basename
+#  endif
+# endif
+# include <string.h>
+#else
+# define memmove(x,y,z) bcopy((y), (x), (z))
+#endif
+
+#ifndef HAVE_BASENAME
+# define basename(path) (rindex((path), '/') + 1)
+#endif
+
+static void usage();
+static int prepare_listen_port();
+static int prepare_connect_port();
+
+static int receive_file();
+static int send_file();
+static int select_loop();
+static int chat_listen();
+static int chat_connect();
+
+static u_long primary_address_of();
+static u_long extract_addr_of_string();
+static u_long get_address_externally();
+
+static char *progname;
+
+void version () {
+	printf("%s (Liece) 1.4.0\n"
+				 "Copyright (C) 1998, 1999 Daiki Ueno\n"
+				 "This is free software; see the source for copying conditions.  There is NO\n"
+				 "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n", 
+				 progname);
+}
+
+void usage() {
+  printf("Usage: %s [global-options] command [command-options-and-arguments]\n"
+				 "where global-options are -v, -h, etc.\n"
+				 "where command is one of send, receive, chat, resolve.\n"
+				 "where command-options-and-arguments depend on the specific command.\n\n"
+				 "send <host> <port> <filename>\n"
+				 "receive <host> <port> <size> <filename>\n"
+				 "chat listen <port>\n"
+				 "chat connect <host> <port>\n"
+				 "resolve [hosts ...]\n",
+				 progname);
+}
+
+int prepare_listen_port (int ip_port) {
+  int sock, tries;
+  int opt = 1;
+  static struct sockaddr_in server;
+
+  
+  if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
+    perror("opening stream socket");
+    exit(1);
+  }
+
+#ifdef SO_REUSEADDR
+  if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, 
+		 (char *)&opt, sizeof (opt)) < 0) {
+    perror ("setsockopt SO_REUSEADDR");
+  }
+#endif
+
+  /* Bind a port to listen for new connections */
+
+  server.sin_family = AF_INET;
+  server.sin_addr.s_addr = INADDR_ANY;
+  server.sin_port = htons (ip_port);
+  for (tries = 0; tries < 10; tries++) {
+    if (bind (sock, (struct sockaddr *) &server, sizeof (server))) {
+      if (tries >= 9) {
+	perror ("binding stream socket");
+	exit (1);
+      }
+      perror ("binding stream socket. retry in 20 seconds");
+      sleep (20);		/* wait 20 seconds and try again */
+    } else
+      break;
+  }
+  listen (sock, 64);
+  return (sock);
+}
+
+u_long get_address_externally(char *ircserver) {
+  int i, len, dummy;
+  u_long addr;
+  struct hostent *hp;
+  struct sockaddr_in server, client;
+
+  addr = 0xc6290004;                          /* dummy addr --- rootA */
+  if (ircserver && (hp = gethostbyname(ircserver)) != NULL) {
+    addr = ntohl(((struct in_addr *)hp->h_addr_list[0])->s_addr);
+  }
+  if ((dummy = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
+    perror("opening stream socket");
+    return -1;
+  }
+  server.sin_family = AF_INET;
+  server.sin_addr.s_addr = htonl(addr);
+  server.sin_port = htons(7);                 /* dummy port --- echo */
+  for (i = 0; i < 8; i++) {
+    server.sin_zero[i] = 0;
+  }
+  if (connect(dummy, (struct sockaddr *)&server, sizeof(server)) < 0) {
+    perror ("connecting remote socket");
+    return -1;
+  }
+  len = sizeof(client);
+  if (getsockname(dummy, (struct sockaddr *)&client, &len) < 0) 
+    return -1;
+  close(dummy);
+  return ntohl(client.sin_addr.s_addr);
+}
+
+
+/*
+ * send_file(int port, char *ifile)
+ * listens to connections to port, and when connection established
+ * sends ifile to that socket
+ */
+int send_file (int port, char *ifile) {
+  int sock, ifd, ofd, len;
+  u_long addr, bytessent = 0;
+  char buf[ BUFSIZ * 8 ];
+  fd_set readfds, writefds, fdset;
+  struct stat statbuf;
+  char namebuf[ MAXHOSTNAMELEN ];
+  struct hostent *hp;
+  struct sockaddr_in sin;
+
+  if ((ifd = open (ifile, O_RDONLY)) < 0) { 
+    /* error in opening file to send */
+    close(ofd);
+    return 1;
+  }
+
+  gethostname(namebuf, sizeof (namebuf));
+  fstat (ifd, &statbuf);
+
+  sock = prepare_listen_port(port);
+  len = sizeof (struct sockaddr_in);
+  if (getsockname(sock, (struct sockaddr *)&sin, &len) == 0) 
+    port = ntohs(sin.sin_port);
+ 
+	if ((addr = get_address_externally (NULL)) < 0) {
+		gethostname(namebuf, sizeof (namebuf));
+		if (hp = gethostbyname(namebuf)) 
+			addr = ((struct in_addr *) (hp->h_addr_list)[0])->s_addr;
+		else
+			return 2;
+	}
+
+	printf ("DCC send %s %d %u %d\n", ifile, port, addr, statbuf.st_size);
+  
+  ofd = accept(sock, (struct sockaddr *) 0, (int *) 0);
+  
+  while ((len = read (ifd, buf, sizeof (buf))) > 0) {
+    write (ofd, buf, len);	
+    bytessent += len;
+    while ((len = read (ofd, buf, sizeof (u_long))) &&
+	   ntohl (*(u_long *) buf) != bytessent);
+  }
+  close (ofd);
+  close (ifd);
+  printf ("*** DCC file %s sent\n", ifile);
+
+  return 0;
+}
+
+/*
+ * receive_file(u_long host, int port, char *ifile)
+ * connects to (host,port) and reads everything send from there
+ * for every packet received gives back how much actually got
+ * puts everything in ifile
+ */
+int receive_file (u_long host, int port, int size, char *ifile) {
+  int sock, ifd, ofd, len, bytesreceived = 0, toread, prev = 0;
+  char buf[ BUFSIZ * 8 ];
+  fd_set readfds, writefds, fdset;
+  u_long netsize;
+    
+  if ((ofd = open(ifile, O_WRONLY|O_CREAT|O_TRUNC, 0600)) < 0) {
+    fprintf(stderr, "open: opening file: %s\n", ifile);
+    return 1;
+  }
+  ifd = prepare_connect_port (host, port);
+  if ((toread = sizeof (buf)) > size)
+    toread = size;
+  while (bytesreceived < size && (len = read (ifd, buf, toread)) > 0) {
+    write (ofd, buf, len);
+    bytesreceived += len;
+    netsize = htonl (bytesreceived);
+    lseek (ifd, 0, 2);
+    write (ifd, &netsize, 4);
+    lseek (ifd, 0, 2);
+    if (toread > size - bytesreceived)
+      toread = size - bytesreceived;
+    if (bytesreceived - prev > size / 5) {
+      printf ("DCC %s %d%% (%d/%d bytes) received\n", ifile,
+	      100 * bytesreceived / size, bytesreceived, size);
+      prev = bytesreceived;
+    }
+  }
+  printf ("*** DCC file %s received\n", ifile);
+  close (ifd);
+  close (ofd);
+
+  return 0;
+}
+
+/*
+ * select_loop(int sfd)
+ * listens fd given, reads stdin and sends it to socket 
+ * anything read from socket is send to stdout
+ */
+int select_loop (int sfd) {
+  int ofd, len, bytesreceived = 0;
+  char buf[ BUFSIZ * 8 ];
+  fd_set readfds, writefds, fdset;
+
+  for (;;) {
+    FD_ZERO (&readfds);
+    FD_SET (sfd, &readfds);
+    FD_SET (0, &readfds);
+    if (select (32, &readfds, 0, 0, 0) < 0) {
+      perror ("select");
+      close (sfd);
+      return 1;
+    }
+	
+    if (FD_ISSET (sfd, &readfds)) {
+      if ((len = read(sfd, buf, sizeof (buf))) == 0) {
+	close (sfd);
+	return 0;
+      }
+      write (1, buf, len);
+      FD_CLR (sfd, &readfds);
+    }
+    if (FD_ISSET (0, &readfds))	{
+      if ((len = read (0, buf, sizeof (buf))) == 0) {
+	close (sfd);
+	return 0;
+      }
+      write(sfd, buf, len);
+      FD_CLR (ofd, &readfds);
+    }
+  }
+}
+
+int prepare_connect_port (u_long host, int port) {
+  int sock;
+  static struct hostent *hp;
+  static struct sockaddr_in server;
+    
+  sock = socket (AF_INET, SOCK_STREAM, 0);
+  if (sock < 0) {
+    perror ("opening stream socket");
+    exit (1);
+  }
+  server.sin_family = AF_INET;
+  
+  server.sin_addr.s_addr = ntohl (host);
+  server.sin_port = htons (port);
+    
+  if (connect(sock, (struct sockaddr *) &server, sizeof (server)) < 0) {
+    perror ("connecting remote socket");
+    return 0;
+  }
+  
+  return sock;
+}
+
+u_long extract_addr_of_string (char *str) {
+  u_long result = 0;
+
+#ifndef HAVE_STRTOUL
+  while (*str++) 
+    result = result * 10 + *str - '0';
+#else /* !HAVE_STRTOUL */
+  result = strtoul(str, NULL, 10);
+#endif /* HAVE_STRTOUL */
+  return result;
+}
+
+u_long primary_address_of (char *host) {   
+  struct hostent *hp;
+  u_long addr;
+  
+  if ((hp = gethostbyname(host)) == NULL)
+    addr = inet_addr(host);
+  else
+    memmove(&addr, hp->h_addr_list[ 0 ], 4);
+  
+  return ntohl(addr);
+}
+
+int chat_listen(int port) {
+  struct sockaddr_in sin;
+  struct hostent *hp;
+	u_long addr;
+  int sock, len;
+  char namebuf[ MAXHOSTNAMELEN ];
+    
+  sock = prepare_listen_port (port);
+  
+  len = sizeof (struct sockaddr_in);
+  if (getsockname(sock, (struct sockaddr *)&sin, &len) == 0) 
+    port = ntohs(sin.sin_port);
+
+	if ((addr = get_address_externally (NULL)) < 0) {
+		gethostname(namebuf, sizeof (namebuf));
+		if (hp = gethostbyname(namebuf)) 
+			addr = ((struct in_addr *) (hp->h_addr_list)[0])->s_addr;
+		else
+			return 2;
+	}
+
+	printf("DCC chat %u %d\n", addr, port);
+  
+  if ((sock = accept(sock, (struct sockaddr *) 0, (int *) 0)) > -1) {
+		printf("DCC chat established\n");
+    return select_loop(sock);
+	}
+  
+  return 1;
+}
+
+int chat_connect(u_long host, int port) {
+  int sock;
+  
+  if ((sock = prepare_connect_port(host, port)) > -1) {
+    printf("DCC chat established\n");
+    return select_loop(sock);
+  }
+  
+  return 1;
+}
+
+
+int main (int argc, char **argv) {
+  char *host = "localhost";
+  char *action;
+  int c, status = 0;
+
+  progname = (char *)basename(argv[ 0 ]);
+
+	while (1)	{
+		int this_option_optind = optind ? optind : 1;
+		int option_index = 0;
+		static struct option long_options[] =	{
+			{"version", 0, 0, 'v'},
+			{"help", 0, 0, 'h'},
+			{0, 0, 0, 0}
+		};
+			
+		c = getopt_long (argc, argv, "vh", long_options, &option_index);
+		if (c == -1)
+			break;
+		
+		switch (c) {
+		case 'v':
+			version();
+			exit(1);
+			break;
+		case 'h':
+			usage();
+			exit(1);
+			break;
+		default:
+			break;
+		}
+	}
+
+  if (argc > 1) {
+    action = argv[ 1 ];
+  } else {
+    usage();
+    exit(1);
+  }
+
+  if (!strcmp(action, "resolve")) {
+    if (argc < 3) {
+      usage();
+      exit(1);
+    } else {
+      u_long i, addr;
+      for (i = 2; i < argc; i++) {
+	addr = primary_address_of(argv[i]);
+	if (addr != -1)
+	  printf("%u\n", addr);
+	else
+	  printf("0\n");
+      }
+      status = 0;
+    }
+  }
+
+  if (!strcmp(action, "send")) {
+    if (argc != 4) {
+      usage();
+      exit(1);
+    }
+    status = send_file (atoi(argv[ 2 ]), argv[ 3 ]);
+  } else if (!strcmp(action, "receive")) {
+    if (argc != 6) {
+      usage();
+      exit(1);
+    }
+    status = 
+      receive_file (extract_addr_of_string(argv[ 2 ]),
+		    atoi(argv[ 3 ]), atoi(argv[ 4 ]), argv[ 5 ]);
+  } else if (!strcmp(action, "chat")) {
+    if (argc > 3) {
+      if (!strcmp(argv[ 2 ], "listen")) {
+	if (argc != 4) {
+	  usage();
+	  exit(1);
+	}
+	status = chat_listen(atoi(argv[ 3 ]));
+      } else if (!strcmp(argv[ 2 ], "connect")) {
+	if (argc != 5) {
+	  usage();
+	  exit(1);
+	}
+	status = chat_connect(extract_addr_of_string(argv[ 3 ]), 
+			      atoi(argv[ 4 ]));
+      } else {
+	usage();
+	exit(1);
+      }	
+    }
+  } else {
+    usage();
+    exit(1);
+  }
+
+  return status;
+}
+
+/*
+ * Local variables:
+ *  compile-command: "gcc -DHAVE_STRTOUL -Wall -O6 -o dcc dcc.c"
+ *  c-indent-level: 2
+ *  c-basic-offset: 2
+ *  tab-width: 2
+ * End:
+ */
+/* Getopt for GNU.
+   NOTE: getopt is now part of the C library, so if you don't know what
+   "Keep this file name-space clean" means, talk to roland@gnu.ai.mit.edu
+   before changing it!
+
+   Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94
+   	Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2, or (at your option) any
+   later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.  */
+
+/* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
+   Ditto for AIX 3.2 and <stdlib.h>.  */
+#ifndef _NO_PROTO
+#define _NO_PROTO
+#endif
+
+#ifdef HAVE_CONFIG_H
+#if defined (emacs) || defined (CONFIG_BROKETS)
+/* We use <config.h> instead of "config.h" so that a compilation
+   using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h
+   (which it would do because it found this file in $srcdir).  */
+#include <config.h>
+#else
+#include "config.h"
+#endif
+#endif
+
+#ifndef __STDC__
+/* This is a separate conditional since some stdc systems
+   reject `defined (const)'.  */
+#ifndef const
+#define const
+#endif
+#endif
+
+#include <stdio.h>
+
+#ifdef HAVE_STRING_H
+#include <string.h>
+#endif
+
+/* Comment out all this code if we are using the GNU C Library, and are not
+   actually compiling the library itself.  This code is part of the GNU C
+   Library, but also included in many other GNU distributions.  Compiling
+   and linking in this code is a waste when using the GNU C library
+   (especially if it is a shared library).  Rather than having every GNU
+   program understand `configure --with-gnu-libc' and omit the object files,
+   it is simpler to just do this in the source for each such file.  */
+
+#if defined (_LIBC) || !defined (__GNU_LIBRARY__)
+
+
+/* This needs to come after some library #include
+   to get __GNU_LIBRARY__ defined.  */
+#ifdef	__GNU_LIBRARY__
+/* Don't include stdlib.h for non-GNU C libraries because some of them
+   contain conflicting prototypes for getopt.  */
+#include <stdlib.h>
+#endif	/* GNU C library.  */
+
+/* This version of `getopt' appears to the caller like standard Unix `getopt'
+   but it behaves differently for the user, since it allows the user
+   to intersperse the options with the other arguments.
+
+   As `getopt' works, it permutes the elements of ARGV so that,
+   when it is done, all the options precede everything else.  Thus
+   all application programs are extended to handle flexible argument order.
+
+   Setting the environment variable POSIXLY_CORRECT disables permutation.
+   Then the behavior is completely standard.
+
+   GNU application programs can use a third alternative mode in which
+   they can distinguish the relative order of options and other arguments.  */
+
+#include "getopt.h"
+
+/* For communication from `getopt' to the caller.
+   When `getopt' finds an option that takes an argument,
+   the argument value is returned here.
+   Also, when `ordering' is RETURN_IN_ORDER,
+   each non-option ARGV-element is returned here.  */
+
+char *optarg = NULL;
+
+/* Index in ARGV of the next element to be scanned.
+   This is used for communication to and from the caller
+   and for communication between successive calls to `getopt'.
+
+   On entry to `getopt', zero means this is the first call; initialize.
+
+   When `getopt' returns EOF, this is the index of the first of the
+   non-option elements that the caller should itself scan.
+
+   Otherwise, `optind' communicates from one call to the next
+   how much of ARGV has been scanned so far.  */
+
+/* XXX 1003.2 says this must be 1 before any call.  */
+int optind = 0;
+
+/* The next char to be scanned in the option-element
+   in which the last option character we returned was found.
+   This allows us to pick up the scan where we left off.
+
+   If this is zero, or a null string, it means resume the scan
+   by advancing to the next ARGV-element.  */
+
+static char *nextchar;
+
+/* Callers store zero here to inhibit the error message
+   for unrecognized options.  */
+
+int opterr = 1;
+
+/* Set to an option character which was unrecognized.
+   This must be initialized on some systems to avoid linking in the
+   system's own getopt implementation.  */
+
+int optopt = '?';
+
+/* Describe how to deal with options that follow non-option ARGV-elements.
+
+   If the caller did not specify anything,
+   the default is REQUIRE_ORDER if the environment variable
+   POSIXLY_CORRECT is defined, PERMUTE otherwise.
+
+   REQUIRE_ORDER means don't recognize them as options;
+   stop option processing when the first non-option is seen.
+   This is what Unix does.
+   This mode of operation is selected by either setting the environment
+   variable POSIXLY_CORRECT, or using `+' as the first character
+   of the list of option characters.
+
+   PERMUTE is the default.  We permute the contents of ARGV as we scan,
+   so that eventually all the non-options are at the end.  This allows options
+   to be given in any order, even with programs that were not written to
+   expect this.
+
+   RETURN_IN_ORDER is an option available to programs that were written
+   to expect options and other ARGV-elements in any order and that care about
+   the ordering of the two.  We describe each non-option ARGV-element
+   as if it were the argument of an option with character code 1.
+   Using `-' as the first character of the list of option characters
+   selects this mode of operation.
+
+   The special argument `--' forces an end of option-scanning regardless
+   of the value of `ordering'.  In the case of RETURN_IN_ORDER, only
+   `--' can cause `getopt' to return EOF with `optind' != ARGC.  */
+
+static enum
+{
+  REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
+} ordering;
+
+/* Value of POSIXLY_CORRECT environment variable.  */
+static char *posixly_correct;
+
+#ifdef	__GNU_LIBRARY__
+/* We want to avoid inclusion of string.h with non-GNU libraries
+   because there are many ways it can cause trouble.
+   On some systems, it contains special magic macros that don't work
+   in GCC.  */
+#include <string.h>
+#define	my_index	strchr
+#else
+
+/* Avoid depending on library functions or files
+   whose names are inconsistent.  */
+
+char *getenv ();
+
+static char *
+my_index (str, chr)
+     const char *str;
+     int chr;
+{
+  while (*str)
+    {
+      if (*str == chr)
+	return (char *) str;
+      str++;
+    }
+  return 0;
+}
+
+/* If using GCC, we can safely declare strlen this way.
+   If not using GCC, it is ok not to declare it.  */
+#ifdef __GNUC__
+/* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
+   That was relevant to code that was here before.  */
+#ifndef __STDC__
+/* gcc with -traditional declares the built-in strlen to return int,
+   and has done so at least since version 2.4.5. -- rms.  */
+extern int strlen (const char *);
+#endif /* not __STDC__ */
+#endif /* __GNUC__ */
+
+#endif /* not __GNU_LIBRARY__ */
+
+/* Handle permutation of arguments.  */
+
+/* Describe the part of ARGV that contains non-options that have
+   been skipped.  `first_nonopt' is the index in ARGV of the first of them;
+   `last_nonopt' is the index after the last of them.  */
+
+static int first_nonopt;
+static int last_nonopt;
+
+/* Exchange two adjacent subsequences of ARGV.
+   One subsequence is elements [first_nonopt,last_nonopt)
+   which contains all the non-options that have been skipped so far.
+   The other is elements [last_nonopt,optind), which contains all
+   the options processed since those non-options were skipped.
+
+   `first_nonopt' and `last_nonopt' are relocated so that they describe
+   the new indices of the non-options in ARGV after they are moved.  */
+
+static void
+exchange (argv)
+     char **argv;
+{
+  int bottom = first_nonopt;
+  int middle = last_nonopt;
+  int top = optind;
+  char *tem;
+
+  /* Exchange the shorter segment with the far end of the longer segment.
+     That puts the shorter segment into the right place.
+     It leaves the longer segment in the right place overall,
+     but it consists of two parts that need to be swapped next.  */
+
+  while (top > middle && middle > bottom)
+    {
+      if (top - middle > middle - bottom)
+	{
+	  /* Bottom segment is the short one.  */
+	  int len = middle - bottom;
+	  register int i;
+
+	  /* Swap it with the top part of the top segment.  */
+	  for (i = 0; i < len; i++)
+	    {
+	      tem = argv[bottom + i];
+	      argv[bottom + i] = argv[top - (middle - bottom) + i];
+	      argv[top - (middle - bottom) + i] = tem;
+	    }
+	  /* Exclude the moved bottom segment from further swapping.  */
+	  top -= len;
+	}
+      else
+	{
+	  /* Top segment is the short one.  */
+	  int len = top - middle;
+	  register int i;
+
+	  /* Swap it with the bottom part of the bottom segment.  */
+	  for (i = 0; i < len; i++)
+	    {
+	      tem = argv[bottom + i];
+	      argv[bottom + i] = argv[middle + i];
+	      argv[middle + i] = tem;
+	    }
+	  /* Exclude the moved top segment from further swapping.  */
+	  bottom += len;
+	}
+    }
+
+  /* Update records for the slots the non-options now occupy.  */
+
+  first_nonopt += (optind - last_nonopt);
+  last_nonopt = optind;
+}
+
+/* Initialize the internal data when the first call is made.  */
+
+static const char *
+_getopt_initialize (optstring)
+     const char *optstring;
+{
+  /* Start processing options with ARGV-element 1 (since ARGV-element 0
+     is the program name); the sequence of previously skipped
+     non-option ARGV-elements is empty.  */
+
+  first_nonopt = last_nonopt = optind = 1;
+
+  nextchar = NULL;
+
+  posixly_correct = getenv ("POSIXLY_CORRECT");
+
+  /* Determine how to handle the ordering of options and nonoptions.  */
+
+  if (optstring[0] == '-')
+    {
+      ordering = RETURN_IN_ORDER;
+      ++optstring;
+    }
+  else if (optstring[0] == '+')
+    {
+      ordering = REQUIRE_ORDER;
+      ++optstring;
+    }
+  else if (posixly_correct != NULL)
+    ordering = REQUIRE_ORDER;
+  else
+    ordering = PERMUTE;
+
+  return optstring;
+}
+
+/* Scan elements of ARGV (whose length is ARGC) for option characters
+   given in OPTSTRING.
+
+   If an element of ARGV starts with '-', and is not exactly "-" or "--",
+   then it is an option element.  The characters of this element
+   (aside from the initial '-') are option characters.  If `getopt'
+   is called repeatedly, it returns successively each of the option characters
+   from each of the option elements.
+
+   If `getopt' finds another option character, it returns that character,
+   updating `optind' and `nextchar' so that the next call to `getopt' can
+   resume the scan with the following option character or ARGV-element.
+
+   If there are no more option characters, `getopt' returns `EOF'.
+   Then `optind' is the index in ARGV of the first ARGV-element
+   that is not an option.  (The ARGV-elements have been permuted
+   so that those that are not options now come last.)
+
+   OPTSTRING is a string containing the legitimate option characters.
+   If an option character is seen that is not listed in OPTSTRING,
+   return '?' after printing an error message.  If you set `opterr' to
+   zero, the error message is suppressed but we still return '?'.
+
+   If a char in OPTSTRING is followed by a colon, that means it wants an arg,
+   so the following text in the same ARGV-element, or the text of the following
+   ARGV-element, is returned in `optarg'.  Two colons mean an option that
+   wants an optional arg; if there is text in the current ARGV-element,
+   it is returned in `optarg', otherwise `optarg' is set to zero.
+
+   If OPTSTRING starts with `-' or `+', it requests different methods of
+   handling the non-option ARGV-elements.
+   See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
+
+   Long-named options begin with `--' instead of `-'.
+   Their names may be abbreviated as long as the abbreviation is unique
+   or is an exact match for some defined option.  If they have an
+   argument, it follows the option name in the same ARGV-element, separated
+   from the option name by a `=', or else the in next ARGV-element.
+   When `getopt' finds a long-named option, it returns 0 if that option's
+   `flag' field is nonzero, the value of the option's `val' field
+   if the `flag' field is zero.
+
+   The elements of ARGV aren't really const, because we permute them.
+   But we pretend they're const in the prototype to be compatible
+   with other systems.
+
+   LONGOPTS is a vector of `struct option' terminated by an
+   element containing a name which is zero.
+
+   LONGIND returns the index in LONGOPT of the long-named option found.
+   It is only valid when a long-named option has been found by the most
+   recent call.
+
+   If LONG_ONLY is nonzero, '-' as well as '--' can introduce
+   long-named options.  */
+
+int
+_getopt_internal (argc, argv, optstring, longopts, longind, long_only)
+     int argc;
+     char *const *argv;
+     const char *optstring;
+     const struct option *longopts;
+     int *longind;
+     int long_only;
+{
+  optarg = NULL;
+
+  if (optind == 0)
+    optstring = _getopt_initialize (optstring);
+
+  if (nextchar == NULL || *nextchar == '\0')
+    {
+      /* Advance to the next ARGV-element.  */
+
+      if (ordering == PERMUTE)
+	{
+	  /* If we have just processed some options following some non-options,
+	     exchange them so that the options come first.  */
+
+	  if (first_nonopt != last_nonopt && last_nonopt != optind)
+	    exchange ((char **) argv);
+	  else if (last_nonopt != optind)
+	    first_nonopt = optind;
+
+	  /* Skip any additional non-options
+	     and extend the range of non-options previously skipped.  */
+
+	  while (optind < argc
+		 && (argv[optind][0] != '-' || argv[optind][1] == '\0'))
+	    optind++;
+	  last_nonopt = optind;
+	}
+
+      /* The special ARGV-element `--' means premature end of options.
+	 Skip it like a null option,
+	 then exchange with previous non-options as if it were an option,
+	 then skip everything else like a non-option.  */
+
+      if (optind != argc && !strcmp (argv[optind], "--"))
+	{
+	  optind++;
+
+	  if (first_nonopt != last_nonopt && last_nonopt != optind)
+	    exchange ((char **) argv);
+	  else if (first_nonopt == last_nonopt)
+	    first_nonopt = optind;
+	  last_nonopt = argc;
+
+	  optind = argc;
+	}
+
+      /* If we have done all the ARGV-elements, stop the scan
+	 and back over any non-options that we skipped and permuted.  */
+
+      if (optind == argc)
+	{
+	  /* Set the next-arg-index to point at the non-options
+	     that we previously skipped, so the caller will digest them.  */
+	  if (first_nonopt != last_nonopt)
+	    optind = first_nonopt;
+	  return EOF;
+	}
+
+      /* If we have come to a non-option and did not permute it,
+	 either stop the scan or describe it to the caller and pass it by.  */
+
+      if ((argv[optind][0] != '-' || argv[optind][1] == '\0'))
+	{
+	  if (ordering == REQUIRE_ORDER)
+	    return EOF;
+	  optarg = argv[optind++];
+	  return 1;
+	}
+
+      /* We have found another option-ARGV-element.
+	 Skip the initial punctuation.  */
+
+      nextchar = (argv[optind] + 1
+		  + (longopts != NULL && argv[optind][1] == '-'));
+    }
+
+  /* Decode the current option-ARGV-element.  */
+
+  /* Check whether the ARGV-element is a long option.
+
+     If long_only and the ARGV-element has the form "-f", where f is
+     a valid short option, don't consider it an abbreviated form of
+     a long option that starts with f.  Otherwise there would be no
+     way to give the -f short option.
+
+     On the other hand, if there's a long option "fubar" and
+     the ARGV-element is "-fu", do consider that an abbreviation of
+     the long option, just like "--fu", and not "-f" with arg "u".
+
+     This distinction seems to be the most useful approach.  */
+
+  if (longopts != NULL
+      && (argv[optind][1] == '-'
+	  || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
+    {
+      char *nameend;
+      const struct option *p;
+      const struct option *pfound = NULL;
+      int exact = 0;
+      int ambig = 0;
+      int indfound;
+      int option_index;
+
+      for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
+	/* Do nothing.  */ ;
+
+      /* Test all long options for either exact match
+	 or abbreviated matches.  */
+      for (p = longopts, option_index = 0; p->name; p++, option_index++)
+	if (!strncmp (p->name, nextchar, nameend - nextchar))
+	  {
+	    if (nameend - nextchar == (int) strlen (p->name))
+	      {
+		/* Exact match found.  */
+		pfound = p;
+		indfound = option_index;
+		exact = 1;
+		break;
+	      }
+	    else if (pfound == NULL)
+	      {
+		/* First nonexact match found.  */
+		pfound = p;
+		indfound = option_index;
+	      }
+	    else
+	      /* Second or later nonexact match found.  */
+	      ambig = 1;
+	  }
+
+      if (ambig && !exact)
+	{
+	  if (opterr)
+	    fprintf (stderr, "%s: option `%s' is ambiguous\n",
+		     argv[0], argv[optind]);
+	  nextchar += strlen (nextchar);
+	  optind++;
+	  return '?';
+	}
+
+      if (pfound != NULL)
+	{
+	  option_index = indfound;
+	  optind++;
+	  if (*nameend)
+	    {
+	      /* Don't test has_arg with >, because some C compilers don't
+		 allow it to be used on enums.  */
+	      if (pfound->has_arg)
+		optarg = nameend + 1;
+	      else
+		{
+		  if (opterr)
+		    {
+		      if (argv[optind - 1][1] == '-')
+			/* --option */
+			fprintf (stderr,
+				 "%s: option `--%s' doesn't allow an argument\n",
+				 argv[0], pfound->name);
+		      else
+			/* +option or -option */
+			fprintf (stderr,
+			     "%s: option `%c%s' doesn't allow an argument\n",
+			     argv[0], argv[optind - 1][0], pfound->name);
+		    }
+		  nextchar += strlen (nextchar);
+		  return '?';
+		}
+	    }
+	  else if (pfound->has_arg == 1)
+	    {
+	      if (optind < argc)
+		optarg = argv[optind++];
+	      else
+		{
+		  if (opterr)
+		    fprintf (stderr, "%s: option `%s' requires an argument\n",
+			     argv[0], argv[optind - 1]);
+		  nextchar += strlen (nextchar);
+		  return optstring[0] == ':' ? ':' : '?';
+		}
+	    }
+	  nextchar += strlen (nextchar);
+	  if (longind != NULL)
+	    *longind = option_index;
+	  if (pfound->flag)
+	    {
+	      *(pfound->flag) = pfound->val;
+	      return 0;
+	    }
+	  return pfound->val;
+	}
+
+      /* Can't find it as a long option.  If this is not getopt_long_only,
+	 or the option starts with '--' or is not a valid short
+	 option, then it's an error.
+	 Otherwise interpret it as a short option.  */
+      if (!long_only || argv[optind][1] == '-'
+	  || my_index (optstring, *nextchar) == NULL)
+	{
+	  if (opterr)
+	    {
+	      if (argv[optind][1] == '-')
+		/* --option */
+		fprintf (stderr, "%s: unrecognized option `--%s'\n",
+			 argv[0], nextchar);
+	      else
+		/* +option or -option */
+		fprintf (stderr, "%s: unrecognized option `%c%s'\n",
+			 argv[0], argv[optind][0], nextchar);
+	    }
+	  nextchar = (char *) "";
+	  optind++;
+	  return '?';
+	}
+    }
+
+  /* Look at and handle the next short option-character.  */
+
+  {
+    char c = *nextchar++;
+    char *temp = my_index (optstring, c);
+
+    /* Increment `optind' when we start to process its last character.  */
+    if (*nextchar == '\0')
+      ++optind;
+
+    if (temp == NULL || c == ':')
+      {
+	if (opterr)
+	  {
+	    if (posixly_correct)
+	      /* 1003.2 specifies the format of this message.  */
+	      fprintf (stderr, "%s: illegal option -- %c\n", argv[0], c);
+	    else
+	      fprintf (stderr, "%s: invalid option -- %c\n", argv[0], c);
+	  }
+	optopt = c;
+	return '?';
+      }
+    if (temp[1] == ':')
+      {
+	if (temp[2] == ':')
+	  {
+	    /* This is an option that accepts an argument optionally.  */
+	    if (*nextchar != '\0')
+	      {
+		optarg = nextchar;
+		optind++;
+	      }
+	    else
+	      optarg = NULL;
+	    nextchar = NULL;
+	  }
+	else
+	  {
+	    /* This is an option that requires an argument.  */
+	    if (*nextchar != '\0')
+	      {
+		optarg = nextchar;
+		/* If we end this ARGV-element by taking the rest as an arg,
+		   we must advance to the next element now.  */
+		optind++;
+	      }
+	    else if (optind == argc)
+	      {
+		if (opterr)
+		  {
+		    /* 1003.2 specifies the format of this message.  */
+		    fprintf (stderr, "%s: option requires an argument -- %c\n",
+			     argv[0], c);
+		  }
+		optopt = c;
+		if (optstring[0] == ':')
+		  c = ':';
+		else
+		  c = '?';
+	      }
+	    else
+	      /* We already incremented `optind' once;
+		 increment it again when taking next ARGV-elt as argument.  */
+	      optarg = argv[optind++];
+	    nextchar = NULL;
+	  }
+      }
+    return c;
+  }
+}
+
+int
+getopt (argc, argv, optstring)
+     int argc;
+     char *const *argv;
+     const char *optstring;
+{
+  return _getopt_internal (argc, argv, optstring,
+			   (const struct option *) 0,
+			   (int *) 0,
+			   0);
+}
+
+#endif	/* _LIBC or not __GNU_LIBRARY__.  */
+
+#ifdef TEST
+
+/* Compile with -DTEST to make an executable for use in testing
+   the above definition of `getopt'.  */
+
+int
+main (argc, argv)
+     int argc;