Default fish_pager_color_description to '555 yellow'

Fixes https://github.com/fish-shell/fish-shell/issues/280

.gitattributes

@@ -0,0 +1,4 @@
+.gitattributes export-ignore
+.gitignore export-ignore
+/build_tools export-ignore
+

.gitignore

@@ -4,6 +4,8 @@
 Doxyfile.help
 Makefile
 autom4te.cache/
+builtin_scripts.cpp
+builtin_scripts.h
 command_list.txt
 config.h
 config.h.in
@@ -13,7 +15,6 @@ configure
 doc.h
 doc_src/commands.hdr
 doc_src/index.hdr
-etc/config.fish
 po/*.gmo
 fish
 fish.spec

INSTALL

@@ -53,6 +53,11 @@ following command:
 
 chsh will prompt you for your password, and change your default shell.
 
+To switch your default shell back, you can run:
+
+ % chsh -s /bin/bash
+
+Substitute /bin/bash with /bin/tcsh or /bin/zsh as appropriate.
 
 Local install procedure
 =======================

Makefile.in

@@ -38,7 +38,7 @@ PACKAGE_TARNAME = @PACKAGE_TARNAME@
 # Programs
 #
 
-CC := @CC@
+CXX := @CXX@
 INSTALL:=@INSTALL@
 
 
@@ -55,7 +55,6 @@ mandir = @mandir@
 sysconfdir = @sysconfdir@
 docdir = @docdir@
 localedir = @localedir@
-prefix = @prefix@
 optbindirs = @optbindirs@
 
 #
@@ -63,8 +62,7 @@ optbindirs = @optbindirs@
 #
 
 MACROS = -DLOCALEDIR=\"$(localedir)\" -DPREFIX=L\"$(prefix)\" -DDATADIR=L\"$(datadir)\" -DSYSCONFDIR=L\"$(sysconfdir)\"
-CFLAGS = @CFLAGS@ $(MACROS) $(EXTRA_CFLAGS)
-CPPFLAGS = @CPPFLAGS@
+CXXFLAGS = @CXXFLAGS@ $(MACROS) $(EXTRA_CXXFLAGS)
 LDFLAGS = @LIBS@ @LDFLAGS@
 LDFLAGS_FISH = ${LDFLAGS} @LIBS_FISH@ @LDFLAGS_FISH@
 LDFLAGS_FISH_INDENT = ${LDFLAGS} @LIBS_FISH_INDENT@
@@ -81,11 +79,11 @@ HAVE_GETTEXT=@HAVE_GETTEXT@
 
 
 #
-#Additional .c files used by common.o. These also have a corresponding
+#Additional .cpp files used by common.o. These also have a corresponding
 #.h file.
 #
 
-COMMON_FILES := util.c halloc.c halloc_util.c fallback.c
+COMMON_FILES := util.cpp fallback.cpp
 
 
 #
@@ -96,8 +94,9 @@ FISH_OBJS := function.o builtin.o complete.o env.o exec.o expand.o		\
 	highlight.o history.o kill.o parser.o proc.o reader.o sanity.o		\
 	tokenizer.o wildcard.o wgetopt.o wutil.o input.o output.o intern.o	\
 	env_universal.o env_universal_common.o input_common.o event.o		\
-	signal.o io.o parse_util.o common.o screen.o path.o					\
-	parser_keywords.o
+	signal.o io.o parse_util.o common.o screen.o path.o autoload.o		\
+	parser_keywords.o iothread.o builtin_scripts.o color.o postfork.o	\
+	builtin_test.o
 
 FISH_INDENT_OBJS := fish_indent.o print_help.o common.o	\
 parser_keywords.o wutil.o tokenizer.o
@@ -106,8 +105,8 @@ parser_keywords.o wutil.o tokenizer.o
 # Additional files used by builtin.o
 #
 
-BUILTIN_FILES := builtin_set.c builtin_commandline.c	\
-	builtin_ulimit.c builtin_complete.c builtin_jobs.c
+BUILTIN_FILES := builtin_set.cpp builtin_commandline.cpp	\
+	builtin_ulimit.cpp builtin_complete.cpp builtin_jobs.cpp
 
 
 #
@@ -116,7 +115,7 @@ BUILTIN_FILES := builtin_set.c builtin_commandline.c	\
 
 FISH_PAGER_OBJS := fish_pager.o output.o wutil.o 		\
 	input_common.o env_universal.o env_universal_common.o common.o	\
-	print_help.o
+	print_help.o iothread.o color.o
 
 
 #
@@ -160,6 +159,24 @@ HDR_FILES_SRC := doc_src/index.hdr.in doc_src/commands.hdr.in doc_src/design.hdr
 
 HDR_FILES := $(subst .hdr.in,.hdr,$(HDR_FILES_SRC))
 
+#
+# Internalized scripts
+#
+
+GENERATED_INTERN_SCRIPT_FILES := builtin_scripts.h builtin_scripts.cpp
+
+# Use a pattern rule so that Make knows to only issue one invocation
+# per http://www.gnu.org/software/make/manual/make.html#Pattern-Intro
+
+# Internalized scripts are currently disabled.
+# For now, we just generate empty arrays.
+# To generate them again, you would run this:
+# ./internalize_scripts.py share/functions/*.fish share/completions/*.fish
+
+builtin%scripts.h builtin%scripts.cpp: internalize_scripts.py
+	./internalize_scripts.py
+
+
 #
 # Files containing documentation for external commands.
 #
@@ -191,12 +208,12 @@ DOC_SRC_DIR_FILES := $(HDR_FILES_SRC) $(HELP_SRC)
 
 MAIN_DIR_FILES_UNSORTED := Doxyfile Doxyfile.user Doxyfile.help.in		\
     Makefile.in configure configure.ac config.h.in install-sh			\
-    set_color.c key_reader.c $(MIME_OBJS:.o=.h)					\
-    $(MIME_OBJS:.o=.c) $(FISH_OBJS:.o=.h) $(BUILTIN_FILES)				\
-    $(COMMON_FILES) $(COMMON_FILES:.c=.h) $(FISH_OBJS:.o=.c)			\
+    set_color.cpp key_reader.cpp $(MIME_OBJS:.o=.h)					\
+    $(MIME_OBJS:.o=.cpp) $(FISH_OBJS:.o=.h) $(BUILTIN_FILES)				\
+    $(COMMON_FILES) $(COMMON_FILES:.cpp=.h) $(FISH_OBJS:.o=.cpp)			\
     fish.spec.in INSTALL README user_doc.head.html xsel-0.9.6.tar		\
-    ChangeLog config.sub config.guess fish_tests.c fish.c fish_pager.c	\
-    fishd.c seq.in make_vcs_completions.fish $(FISH_INDENT_OBJS:.o=.c)
+    ChangeLog config.sub config.guess fish_tests.cpp fish.cpp fish_pager.cpp	\
+    fishd.cpp seq.in make_vcs_completions.fish $(FISH_INDENT_OBJS:.o=.cpp)
 
 #
 # The sorting is not meaningful in itself, but it has the side effect
@@ -207,20 +224,6 @@ MAIN_DIR_FILES_UNSORTED := Doxyfile Doxyfile.user Doxyfile.help.in		\
 MAIN_DIR_FILES := $(sort $(MAIN_DIR_FILES_UNSORTED))
 
 
-#
-# Files in ./etc/
-#
-
-ETC_DIR_FILES :=etc/config.fish.in
-
-
-#
-# Files in ./share/
-#
-
-SHARE_DIR_FILES :=share/config.fish.in
-
-
 #
 # Files in ./tests/
 #
@@ -278,7 +281,7 @@ XSEL_BIN := @XSEL_BIN@
 # Make everything needed for installing fish
 #
 
-all: $(PROGRAMS) user_doc share/man etc/config.fish share/config.fish $(TRANSLATIONS)
+all: $(PROGRAMS) user_doc share/man $(TRANSLATIONS)
 	@echo fish has now been built.
 	@echo Use \'$(MAKE) install\' to install fish.
 .PHONY: all
@@ -301,12 +304,9 @@ Makefile: Makefile.in configure
 # and should only be used when debuging fish.
 #
 
-debug:
-	$(MAKE) all EXTRA_CFLAGS="-O0 -Wno-unused -Werror -g"
-.PHONY: debug
-
-prof:
-	$(MAKE) all EXTRA_CFLAGS="-pg" LDFLAGS="-pg"
+prof: EXTRA_CXXFLAGS += -pg
+prof: LDFLAGS += -pg
+prof: all
 .PHONY: prof
 
 #
@@ -315,18 +315,17 @@ prof:
 
 # Depend on the sources (*.hdr.in) and manually make the
 # intermediate *.hdr and doc.h files if needed
+# Allow doxygen to fail, e.g. if it does not exist
 
-user_doc: $(HDR_FILES_SRC) Doxyfile.user user_doc.head.html $(HELP_SRC)
-	$(MAKE) doc.h $(HDR_FILES)
-	doxygen Doxyfile.user
-	touch user_doc
+user_doc: $(HDR_FILES_SRC) Doxyfile.user user_doc.head.html $(HELP_SRC) doc.h $(HDR_FILES)
+	- doxygen Doxyfile.user && touch user_doc
 
 
 #
 # Source code documentation. Also includes user documentation.
 #
 
-doc: *.h *.c doc.h Doxyfile
+doc: *.h *.cpp doc.h Doxyfile
 	doxygen;
 
 
@@ -453,10 +452,10 @@ doc.h: $(HDR_FILES)
 # Create a template translation object
 #
 
-messages.pot: *.c *.h etc/*.in share/*.in share/completions/*.fish share/functions/*.fish seq
+messages.pot: *.cpp *.h share/completions/*.fish share/functions/*.fish seq
 	if test $(HAVE_GETTEXT) = 1;then \
-		xgettext -k_ -kN_ *.c *.h -o messages.pot; \
-		if xgettext -j -k_ -kN_ -k--description -LShell etc/*.in share/*.in share/completions/*.fish share/functions/*.fish seq -o messages.pot; then true; else \
+		xgettext -k_ -kN_ *.cpp *.h -o messages.pot; \
+		if xgettext -j -k_ -kN_ -k--description -LShell share/completions/*.fish share/functions/*.fish seq -o messages.pot; then true; else \
 			echo "Your xgettext version is too old to build the messages.pot file"\
 			rm messages.pot\
 			false;\
@@ -506,13 +505,15 @@ share/man: $(HELP_SRC)
 		cat $$i >>$$FILE; \
 		echo "*/" >>$$FILE; \
 	done
-	doxygen Doxyfile.help
-	for i in $(HELP_SRC); do \
-		CMD_NAME=`basename $$i .txt`; \
-		sed -e "s/\(.\)\\.SH/\1/" -e "s/$$CMD_NAME *\\\\- *\"\(.*\)\"/\1/" <help_doc/man/man1/$$CMD_NAME.1 >share/man/$$CMD_NAME.1; \
-	done
+	if command -v doxygen; then \
+		doxygen Doxyfile.help ; \
+		for i in $(HELP_SRC); do \
+			CMD_NAME=`basename $$i .txt`; \
+			sed -e "s/\(.\)\\.SH/\1/" -e "s/$$CMD_NAME *\\\\- *\"\(.*\)\"/\1/" <help_doc/man/man1/$$CMD_NAME.1 >share/man/$$CMD_NAME.1; \
+		done \
+	fi
 	rm doc_src/*.doxygen   # Clean up intermediate files in doc_src/
-	rm -r help_doc         # Clean up intermediate help_doc tree
+	rm -rf help_doc         # Clean up intermediate help_doc tree
 
 #
 # The build rules for installing/uninstalling fish
@@ -572,29 +573,54 @@ install: all install-sh check-uninstall install-force
 #
 # Force installation, even in presense of incompatible previous
 # version. This may fail.
+# These 'true' lines are to prevent installs from failing for (e.g.) missing man pages.
 #
 
 install-force: all install-translations
 	$(INSTALL) -m 755 -d $(DESTDIR)$(bindir)
 	for i in $(PROGRAMS); do\
 		$(INSTALL) -m 755 $$i $(DESTDIR)$(bindir) ; \
+		true ;\
 	done;
 	$(INSTALL) -m 755 -d $(DESTDIR)$(sysconfdir)/fish
 	$(INSTALL) -m 755 -d $(DESTDIR)$(datadir)/fish
 	$(INSTALL) -m 755 -d $(DESTDIR)$(datadir)/fish/completions
 	$(INSTALL) -m 755 -d $(DESTDIR)$(datadir)/fish/functions
-	$(INSTALL) -m 755 -d $(DESTDIR)$(datadir)/fish/man
+	$(INSTALL) -m 755 -d $(DESTDIR)$(datadir)/fish/man/man1
+	$(INSTALL) -m 755 -d $(DESTDIR)$(datadir)/fish/tools
+	$(INSTALL) -m 755 -d $(DESTDIR)$(datadir)/fish/tools/web_config
+	$(INSTALL) -m 755 -d $(DESTDIR)$(datadir)/fish/tools/web_config/sample_prompts
 	$(INSTALL) -m 644 etc/config.fish                  $(DESTDIR)$(sysconfdir)/fish/
 	$(INSTALL) -m 644 share/config.fish                $(DESTDIR)$(datadir)/fish/
 	for i in $(COMPLETIONS_DIR_FILES); do \
 		$(INSTALL) -m 644 $$i $(DESTDIR)$(datadir)/fish/completions/; \
+		true; \
 	done;
 	for i in $(FUNCTIONS_DIR_FILES); do \
 		$(INSTALL) -m 644 $$i $(DESTDIR)$(datadir)/fish/functions/; \
+		true; \
 	done;
 	for i in share/man/*.1; do \
-		$(INSTALL) -m 644 $$i $(DESTDIR)$(datadir)/fish/man/; \
+		$(INSTALL) -m 644 $$i $(DESTDIR)$(datadir)/fish/man/man1/; \
+		true; \
 	done;
+	for i in share/tools/*.py; do\
+		$(INSTALL) -m 755 $$i $(DESTDIR)$(datadir)/fish/tools/; \
+		true; \
+	done;
+	for i in share/tools/web_config/*; do\
+		$(INSTALL) -m 644 $$i $(DESTDIR)$(datadir)/fish/tools/web_config/; \
+		true; \
+	done;
+	for i in share/tools/web_config/sample_prompts/*.fish; do\
+		$(INSTALL) -m 644 $$i $(DESTDIR)$(datadir)/fish/tools/web_config/sample_prompts/; \
+		true; \
+	done;
+	for i in share/tools/web_config/*.py; do\
+		$(INSTALL) -m 755 $$i $(DESTDIR)$(datadir)/fish/tools/web_config/; \
+		true; \
+	done;
+
 	$(INSTALL) -m 755 -d $(DESTDIR)$(docdir)
 	for i in user_doc/html/* ChangeLog; do \
 		if test -f $$i; then \
@@ -604,6 +630,7 @@ install-force: all install-translations
 	$(INSTALL) -m 755 -d $(DESTDIR)$(mandir)/man1
 	for i in $(MANUALS); do \
 		$(INSTALL) -m 644 $$i $(DESTDIR)$(mandir)/man1/; \
+		true; \
 	done;
 	@echo fish is now installed on your system.
 	@echo To run fish, type \'fish\' in your terminal.
@@ -612,6 +639,10 @@ install-force: all install-translations
 	@echo \* add the line \'$(DESTDIR)$(bindir)/fish\' to the file \'/etc/shells\'.
 	@echo \* use the command \'chsh -s $(DESTDIR)$(bindir)/fish\'.
 	@echo
+	@echo To set your colors, run \'fish_config\'
+	@echo To scan your man pages for completions, run \'fish_update_completions\'
+	@echo To autocomplete command suggestions press Ctrl + F or right arrow key.
+	@echo
 	@echo Have fun!
 .PHONY: install-force
 
@@ -625,16 +656,15 @@ uninstall: uninstall-translations
 		rm -f $(DESTDIR)$(bindir)/$$i; \
 	done;
 	-rm -f $(DESTDIR)$(bindir)/xsel
-	-rm -f $(DESTDIR)$(sysconfdir)/fish/config.fish
-	-rmdir $(DESTDIR)$(sysconfdir)/fish
+	-rm -rf $(DESTDIR)$(sysconfdir)/fish
 	-if test -d $(DESTDIR)$(datadir)/fish; then \
 		rm -r $(DESTDIR)$(datadir)/fish; \
 	fi
 	-if test -d $(DESTDIR)$(docdir); then \
-		rm -r $(DESTDIR)$(docdir);\
+		rm -rf $(DESTDIR)$(docdir);\
 	fi
 	-for i in $(MANUALS); do \
-		rm -f $(DESTDIR)$(mandir)/man1/`basename $$i`*; \
+		rm -rf $(DESTDIR)$(mandir)/man1/`basename $$i`*; \
 	done;
 .PHONY: uninstall
 
@@ -693,7 +723,7 @@ uninstall-translations:
 #
 
 fish: $(FISH_OBJS) fish.o
-	$(CC) $(FISH_OBJS) fish.o $(LDFLAGS_FISH) -o $@
+	$(CXX) $(FISH_OBJS) fish.o $(LDFLAGS_FISH) -o $@
 
 
 #
@@ -701,7 +731,7 @@ fish: $(FISH_OBJS) fish.o
 #
 
 fish_pager: $(FISH_PAGER_OBJS)
-	$(CC) $(FISH_PAGER_OBJS) $(LDFLAGS_FISH_PAGER) -o $@
+	$(CXX) $(FISH_PAGER_OBJS) $(LDFLAGS_FISH_PAGER) -o $@
 
 
 #
@@ -709,7 +739,7 @@ fish_pager: $(FISH_PAGER_OBJS)
 #
 
 fishd: $(FISHD_OBJS)
-	$(CC) $(FISHD_OBJS) $(LDFLAGS_FISHD) -o $@
+	$(CXX) $(FISHD_OBJS) $(LDFLAGS_FISHD) -o $@
 
 
 #
@@ -717,7 +747,7 @@ fishd: $(FISHD_OBJS)
 #
 
 fish_tests: $(FISH_TESTS_OBJS)
-	$(CC) $(FISH_TESTS_OBJS) $(LDFLAGS_FISH) -o $@
+	$(CXX) $(FISH_TESTS_OBJS) $(LDFLAGS_FISH) -o $@
 
 
 #
@@ -727,23 +757,23 @@ fish_tests: $(FISH_TESTS_OBJS)
 #
 
 mimedb: $(MIME_OBJS)
-	$(CC) $(MIME_OBJS) $(LDFLAGS_MIMEDB) -o $@
+	$(CXX) $(MIME_OBJS) $(LDFLAGS_MIMEDB) -o $@
 
 
 #
 # Build the set_color program
 #
 
-set_color: set_color.o print_help.o common.o
-	$(CC) set_color.o print_help.o common.o wutil.o $(LDFLAGS_SET_COLOR) -o $@
+set_color: set_color.o print_help.o common.o color.o wutil.o
+	$(CXX) set_color.o print_help.o common.o wutil.o color.o $(LDFLAGS_SET_COLOR) -o $@
 
 
 #
 # Test program for the tokenizer library
 #
 
-tokenizer_test: tokenizer.c tokenizer.h wutil.o common.o
-	$(CC) $(CFLAGS) tokenizer.c wutil.o common.o -D TOKENIZER_TEST $(LDFLAGS) -o $@
+tokenizer_test: tokenizer.cpp tokenizer.h wutil.o common.o
+	$(CXX) $(CXXFLAGS) tokenizer.cpp wutil.o common.o -D TOKENIZER_TEST $(LDFLAGS) -o $@
 
 
 #
@@ -751,67 +781,30 @@ tokenizer_test: tokenizer.c tokenizer.h wutil.o common.o
 #
 
 fish_indent: $(FISH_INDENT_OBJS)
-	$(CC) $(FISH_INDENT_OBJS) $(LDFLAGS_FISH_INDENT) -o $@
+	$(CXX) $(FISH_INDENT_OBJS) $(LDFLAGS_FISH_INDENT) -o $@
 
 
 #
 # Neat little program to show output from terminal
 #
 
-key_reader: key_reader.o input_common.o common.o env_universal.o env_universal_common.o wutil.o
-	$(CC) key_reader.o input_common.o common.o env_universal.o env_universal_common.o wutil.o $(LDFLAGS_FISH) -o $@
+key_reader: key_reader.o input_common.o common.o env_universal.o env_universal_common.o wutil.o iothread.o
+	$(CXX) key_reader.o input_common.o common.o env_universal.o env_universal_common.o wutil.o iothread.o $(LDFLAGS_FISH) -o $@
 
 
 #
 # Update dependencies
 #
 depend:
-	makedepend -fMakefile.in -Y *.c
+	makedepend -fMakefile.in -Y *.cpp
 	./config.status
 .PHONY: depend
 
-#
-# Copy all the source files into a new directory and use tar to create
-# an archive from it. Simplest way I could think of to make an archive
-# witout backups, autogenerated files, etc.
-#
-# Uses install instead of mkdir so build won't fail if the directory
-# exists
-#
-
-fish-@PACKAGE_VERSION@.tar: $(DOC_SRC_DIR_FILES) $(MAIN_DIR_FILES) $(ETC_DIR_FILES) $(TEST_DIR_FILES) $(SHARE_DIR_FILES) $(FUNCTIONS_DIR_FILES) $(COMPLETIONS_DIR_FILES) ChangeLog user_doc share/man
-	rm -rf fish-@PACKAGE_VERSION@
-	$(INSTALL) -d fish-@PACKAGE_VERSION@
-	$(INSTALL) -d fish-@PACKAGE_VERSION@/doc_src
-	$(INSTALL) -d fish-@PACKAGE_VERSION@/user_doc
-	$(INSTALL) -d fish-@PACKAGE_VERSION@/etc
-	$(INSTALL) -d fish-@PACKAGE_VERSION@/share
-	$(INSTALL) -d fish-@PACKAGE_VERSION@/share/completions
-	$(INSTALL) -d fish-@PACKAGE_VERSION@/share/functions
-	$(INSTALL) -d fish-@PACKAGE_VERSION@/share/man
-	$(INSTALL) -d fish-@PACKAGE_VERSION@/tests
-	$(INSTALL) -d fish-@PACKAGE_VERSION@/po
-	cp -f $(DOC_SRC_DIR_FILES) fish-@PACKAGE_VERSION@/doc_src
-	cp -f $(MAIN_DIR_FILES) fish-@PACKAGE_VERSION@/
-	cp -f $(ETC_DIR_FILES) fish-@PACKAGE_VERSION@/etc/
-	cp -f $(SHARE_DIR_FILES) fish-@PACKAGE_VERSION@/share/
-	cp -f $(COMPLETIONS_DIR_FILES) fish-@PACKAGE_VERSION@/share/completions/
-	cp -f $(FUNCTIONS_DIR_FILES) fish-@PACKAGE_VERSION@/share/functions/
-	cp -f $(TESTS_DIR_FILES) fish-@PACKAGE_VERSION@/tests/
-	cp -f $(TRANSLATIONS_SRC) fish-@PACKAGE_VERSION@/po/
-	cp -f share/man/*.1 fish-@PACKAGE_VERSION@/share/man/
-	cp -rf user_doc fish-@PACKAGE_VERSION@/
-	tar -c fish-@PACKAGE_VERSION@ >fish-@PACKAGE_VERSION@.tar
-	rm -rf fish-@PACKAGE_VERSION@
-
 
 #
-# Just an alias for fish-@PACKAGE_VERSION@.tar
+# Dependencies that makedepend misses
 #
-
-tar: fish-@PACKAGE_VERSION@.tar
-.PHONY: tar
-
+autoload.cpp function.cpp: $(GENERATED_INTERN_SCRIPT_FILES)
 
 #
 # Make compressed tar archives
@@ -865,7 +858,6 @@ rpm: fish-@PACKAGE_VERSION@.tar.bz2 fish.spec
 
 distclean: clean
 	rm -f fish.spec Doxyfile.help
-	rm -f etc/config.fish seq share/config.fish
 	rm -f config.status config.log config.h Makefile
 	rm -rf $(XSEL)
 .PHONY: distclean
@@ -876,15 +868,23 @@ distclean: clean
 # are created by the configure script.
 #
 
+# Don't delete the docs unless we have Doxygen installed
+# We provide pre-built docs in the tarball, and if they get
+# deleted we won't be able to regenerate them
+
 clean:
-	rm -f *.o doc.h doc.tmp doc_src/*.doxygen doc_src/*.c doc_src/*.o doc_src/commands.hdr
+	rm -f *.o doc.h doc.tmp doc_src/*.doxygen doc_src/*.cpp doc_src/*.o doc_src/commands.hdr
+	rm -f $(GENERATED_INTERN_SCRIPT_FILES)
 	rm -f tests/tmp.err tests/tmp.out tests/tmp.status tests/foo.txt
 	rm -f $(PROGRAMS) fish_tests tokenizer_test key_reader
-	rm -f share/config.fish etc/config.fish doc_src/index.hdr doc_src/commands.hdr
+	rm -f command_list.txt toc.txt
+	rm -f doc_src/index.hdr doc_src/commands.hdr
 	rm -f fish-@PACKAGE_VERSION@.tar
 	rm -f fish-@PACKAGE_VERSION@.tar.gz
 	rm -f fish-@PACKAGE_VERSION@.tar.bz2
-	rm -rf doc;
+	if command -v doxygen; then \
+		rm -rf doc user_doc share/man; \
+	fi
 	rm -rf fish-@PACKAGE_VERSION@
 	rm -f $(TRANSLATIONS)
 	test ! -d "$(XSEL)" || make -C $(XSEL) clean
@@ -893,122 +893,130 @@ clean:
 
 # DO NOT DELETE THIS LINE -- make depend depends on it.
 
-builtin.o: config.h fallback.h util.h wutil.h builtin.h io.h function.h
-builtin.o: complete.h proc.h parser.h event.h reader.h env.h common.h
-builtin.o: wgetopt.h sanity.h tokenizer.h wildcard.h input_common.h input.h
-builtin.o: intern.h signal.h exec.h highlight.h halloc.h halloc_util.h
-builtin.o: parse_util.h parser_keywords.h expand.h path.h builtin_set.c
-builtin.o: builtin_commandline.c builtin_complete.c builtin_ulimit.c
-builtin.o: builtin_jobs.c
+autoload.o: config.h autoload.h common.h util.h lru.h wutil.h signal.h env.h
+autoload.o: builtin_scripts.h exec.h proc.h io.h
+builtin.o: config.h signal.h fallback.h util.h wutil.h builtin.h io.h
+builtin.o: common.h function.h event.h complete.h proc.h parser.h reader.h
+builtin.o: env.h wgetopt.h sanity.h tokenizer.h wildcard.h input_common.h
+builtin.o: input.h intern.h exec.h highlight.h screen.h color.h parse_util.h
+builtin.o: autoload.h lru.h parser_keywords.h expand.h path.h builtin_set.cpp
+builtin.o: builtin_commandline.cpp builtin_complete.cpp builtin_ulimit.cpp
+builtin.o: builtin_jobs.cpp
 builtin_commandline.o: config.h signal.h fallback.h util.h wutil.h builtin.h
 builtin_commandline.o: io.h common.h wgetopt.h reader.h proc.h parser.h
-builtin_commandline.o: event.h tokenizer.h input_common.h input.h
-builtin_commandline.o: parse_util.h
+builtin_commandline.o: event.h function.h tokenizer.h input_common.h input.h
+builtin_commandline.o: parse_util.h autoload.h lru.h
 builtin_complete.o: config.h signal.h fallback.h util.h wutil.h builtin.h
 builtin_complete.o: io.h common.h complete.h wgetopt.h parser.h proc.h
-builtin_complete.o: event.h reader.h
-builtin_jobs.o: config.h fallback.h util.h wutil.h builtin.h io.h proc.h
-builtin_jobs.o: parser.h event.h common.h wgetopt.h
+builtin_complete.o: event.h function.h reader.h
+builtin_jobs.o: config.h fallback.h signal.h util.h wutil.h builtin.h io.h
+builtin_jobs.o: common.h proc.h parser.h event.h function.h wgetopt.h
+builtin_scripts.o: builtin_scripts.h
 builtin_set.o: config.h signal.h fallback.h util.h wutil.h builtin.h io.h
-builtin_set.o: env.h expand.h common.h wgetopt.h proc.h parser.h event.h
-builtin_ulimit.o: config.h fallback.h util.h builtin.h io.h common.h
+builtin_set.o: common.h env.h expand.h wgetopt.h proc.h parser.h event.h
+builtin_set.o: function.h
+builtin_ulimit.o: config.h fallback.h signal.h util.h builtin.h io.h common.h
 builtin_ulimit.o: wgetopt.h
-common.o: config.h fallback.h util.h wutil.h common.h expand.h proc.h io.h
-common.o: wildcard.h parser.h event.h util.c halloc.c halloc.h halloc_util.c
-common.o: fallback.c
-complete.o: config.h signal.h fallback.h util.h tokenizer.h wildcard.h proc.h
-complete.o: io.h parser.h event.h function.h complete.h builtin.h env.h
-complete.o: exec.h expand.h common.h reader.h history.h intern.h parse_util.h
-complete.o: parser_keywords.h halloc.h halloc_util.h wutil.h path.h
+color.o: color.h config.h common.h util.h
+common.o: config.h fallback.h signal.h util.h wutil.h common.h expand.h
+common.o: proc.h io.h wildcard.h parser.h event.h function.h complete.h
+common.o: util.cpp fallback.cpp
+complete.o: config.h signal.h fallback.h util.h tokenizer.h wildcard.h
+complete.o: common.h proc.h io.h parser.h event.h function.h complete.h
+complete.o: builtin.h env.h exec.h expand.h reader.h history.h intern.h
+complete.o: parse_util.h autoload.h lru.h parser_keywords.h wutil.h path.h
+complete.o: builtin_scripts.h
 env.o: config.h signal.h fallback.h util.h wutil.h proc.h io.h common.h env.h
-env.o: sanity.h expand.h history.h reader.h parser.h event.h env_universal.h
-env.o: env_universal_common.h input_common.h path.h halloc.h halloc_util.h
+env.o: sanity.h expand.h history.h reader.h parser.h event.h function.h
+env.o: env_universal.h env_universal_common.h input_common.h path.h
 env.o: complete.h
 env_universal.o: config.h signal.h fallback.h util.h common.h wutil.h
 env_universal.o: env_universal_common.h env_universal.h
 env_universal_common.o: config.h signal.h fallback.h util.h common.h wutil.h
 env_universal_common.o: env_universal_common.h
-event.o: config.h signal.h fallback.h util.h wutil.h function.h proc.h io.h
-event.o: parser.h event.h common.h halloc_util.h
+event.o: config.h signal.h fallback.h util.h wutil.h function.h common.h
+event.o: event.h proc.h io.h parser.h
 exec.o: config.h signal.h fallback.h util.h common.h wutil.h proc.h io.h
-exec.o: exec.h parser.h event.h builtin.h function.h env.h wildcard.h
-exec.o: sanity.h expand.h halloc.h halloc_util.h parse_util.h
+exec.o: exec.h parser.h event.h function.h builtin.h env.h wildcard.h
+exec.o: sanity.h expand.h parse_util.h autoload.h lru.h
 expand.o: config.h signal.h fallback.h util.h common.h wutil.h env.h proc.h
-expand.o: io.h parser.h event.h expand.h wildcard.h exec.h tokenizer.h
-expand.o: complete.h parse_util.h halloc.h halloc_util.h
-fallback.o: config.h fallback.h util.h
+expand.o: io.h parser.h event.h function.h expand.h wildcard.h exec.h
+expand.o: tokenizer.h complete.h parse_util.h autoload.h lru.h
+fallback.o: config.h fallback.h signal.h util.h
 fish.o: config.h signal.h fallback.h util.h common.h reader.h io.h builtin.h
-fish.o: function.h complete.h wutil.h env.h sanity.h proc.h parser.h event.h
-fish.o: expand.h intern.h exec.h output.h halloc.h halloc_util.h history.h
-fish.o: path.h
-fish_indent.o: config.h fallback.h util.h common.h wutil.h halloc.h
-fish_indent.o: halloc_util.h tokenizer.h print_help.h parser_keywords.h
+fish.o: function.h event.h complete.h wutil.h env.h sanity.h proc.h parser.h
+fish.o: expand.h intern.h exec.h output.h screen.h color.h history.h path.h
+fish_indent.o: config.h fallback.h signal.h util.h common.h wutil.h
+fish_indent.o: tokenizer.h print_help.h parser_keywords.h
 fish_pager.o: config.h signal.h fallback.h util.h wutil.h common.h complete.h
-fish_pager.o: output.h input_common.h env_universal.h env_universal_common.h
-fish_pager.o: halloc.h halloc_util.h print_help.h
+fish_pager.o: output.h screen.h color.h input_common.h env_universal.h
+fish_pager.o: env_universal_common.h print_help.h
 fish_tests.o: config.h signal.h fallback.h util.h common.h proc.h io.h
-fish_tests.o: reader.h builtin.h function.h complete.h wutil.h env.h expand.h
-fish_tests.o: parser.h event.h tokenizer.h output.h exec.h path.h halloc.h
-fish_tests.o: halloc_util.h
+fish_tests.o: reader.h builtin.h function.h event.h autoload.h lru.h
+fish_tests.o: complete.h wutil.h env.h expand.h parser.h tokenizer.h output.h
+fish_tests.o: screen.h color.h exec.h path.h history.h
 fishd.o: config.h signal.h fallback.h util.h common.h wutil.h
-fishd.o: env_universal_common.h halloc.h halloc_util.h path.h print_help.h
-function.o: config.h signal.h wutil.h fallback.h util.h function.h proc.h
-function.o: io.h parser.h event.h common.h intern.h reader.h parse_util.h
-function.o: parser_keywords.h env.h expand.h halloc.h halloc_util.h
-halloc.o: config.h fallback.h util.h common.h halloc.h
-halloc_util.o: config.h fallback.h util.h common.h halloc.h
-highlight.o: config.h signal.h fallback.h util.h wutil.h highlight.h
-highlight.o: tokenizer.h proc.h io.h parser.h event.h parse_util.h
-highlight.o: parser_keywords.h builtin.h function.h env.h expand.h sanity.h
-highlight.o: common.h complete.h output.h halloc.h halloc_util.h wildcard.h
-highlight.o: path.h
-history.o: config.h fallback.h util.h wutil.h history.h common.h halloc.h
-history.o: halloc_util.h intern.h path.h signal.h
-input.o: config.h signal.h fallback.h util.h wutil.h reader.h io.h proc.h
-input.o: common.h sanity.h input_common.h input.h parser.h event.h env.h
-input.o: expand.h output.h intern.h halloc.h halloc_util.h
-input_common.o: config.h fallback.h util.h common.h wutil.h input_common.h
-input_common.o: env_universal.h env_universal_common.h
-intern.o: config.h fallback.h util.h wutil.h common.h intern.h
-io.o: config.h fallback.h util.h wutil.h exec.h proc.h io.h common.h halloc.h
-key_reader.o: config.h fallback.h input_common.h
+fishd.o: env_universal_common.h path.h print_help.h
+function.o: config.h signal.h wutil.h fallback.h util.h function.h common.h
+function.o: event.h proc.h io.h parser.h intern.h reader.h parse_util.h
+function.o: autoload.h lru.h parser_keywords.h env.h expand.h
+function.o: builtin_scripts.h
+highlight.o: config.h signal.h fallback.h util.h wutil.h highlight.h env.h
+highlight.o: common.h screen.h color.h tokenizer.h proc.h io.h parser.h
+highlight.o: event.h function.h parse_util.h autoload.h lru.h
+highlight.o: parser_keywords.h builtin.h expand.h sanity.h complete.h
+highlight.o: output.h wildcard.h path.h
+history.o: config.h fallback.h signal.h util.h sanity.h wutil.h history.h
+history.o: common.h intern.h path.h autoload.h lru.h
+input.o: config.h signal.h fallback.h util.h wutil.h reader.h io.h common.h
+input.o: proc.h sanity.h input_common.h input.h parser.h event.h function.h
+input.o: env.h expand.h output.h screen.h color.h intern.h
+input_common.o: config.h fallback.h signal.h util.h common.h wutil.h
+input_common.o: input_common.h env_universal.h env_universal_common.h
+input_common.o: iothread.h
+intern.o: config.h fallback.h signal.h util.h wutil.h common.h intern.h
+io.o: config.h fallback.h signal.h util.h wutil.h exec.h proc.h io.h common.h
+iothread.o: iothread.h signal.h
+key_reader.o: config.h fallback.h signal.h input_common.h
 kill.o: config.h signal.h fallback.h util.h wutil.h kill.h proc.h io.h
-kill.o: sanity.h common.h env.h exec.h halloc.h path.h
-mimedb.o: config.h xdgmime.h fallback.h util.h print_help.h
+kill.o: common.h sanity.h env.h exec.h path.h
+mimedb.o: config.h xdgmime.h fallback.h signal.h util.h print_help.h
 output.o: config.h signal.h fallback.h util.h wutil.h expand.h common.h
-output.o: output.h halloc_util.h highlight.h
-parse_util.o: config.h fallback.h util.h wutil.h common.h tokenizer.h
-parse_util.o: parse_util.h expand.h intern.h exec.h proc.h io.h env.h
-parse_util.o: signal.h wildcard.h halloc_util.h
+output.o: output.h screen.h color.h highlight.h env.h
+parse_util.o: config.h fallback.h signal.h util.h wutil.h common.h
+parse_util.o: tokenizer.h parse_util.h autoload.h lru.h expand.h intern.h
+parse_util.o: exec.h proc.h io.h env.h wildcard.h
 parser.o: config.h signal.h fallback.h util.h common.h wutil.h proc.h io.h
-parser.o: parser.h event.h parser_keywords.h tokenizer.h exec.h wildcard.h
-parser.o: function.h builtin.h env.h expand.h reader.h sanity.h
+parser.o: parser.h event.h function.h parser_keywords.h tokenizer.h exec.h
+parser.o: wildcard.h builtin.h env.h expand.h reader.h sanity.h
 parser.o: env_universal.h env_universal_common.h intern.h parse_util.h
-parser.o: halloc.h halloc_util.h path.h
-parser_keywords.o: config.h fallback.h common.h util.h parser_keywords.h
-path.o: config.h fallback.h util.h common.h env.h wutil.h halloc.h
-path.o: halloc_util.h path.h expand.h
+parser.o: autoload.h lru.h path.h complete.h
+parser_keywords.o: config.h fallback.h signal.h common.h util.h
+parser_keywords.o: parser_keywords.h
+path.o: config.h fallback.h signal.h util.h common.h env.h wutil.h path.h
+path.o: expand.h
 print_help.o: print_help.h
 proc.o: config.h signal.h fallback.h util.h wutil.h proc.h io.h common.h
-proc.o: reader.h sanity.h env.h parser.h event.h halloc.h halloc_util.h
-proc.o: output.h
-reader.o: config.h signal.h fallback.h util.h wutil.h highlight.h reader.h
-reader.o: io.h proc.h parser.h event.h complete.h history.h common.h sanity.h
-reader.o: env.h exec.h expand.h tokenizer.h kill.h input_common.h input.h
-reader.o: function.h output.h screen.h halloc.h halloc_util.h parse_util.h
+proc.o: reader.h sanity.h env.h parser.h event.h function.h output.h screen.h
+proc.o: color.h
+reader.o: config.h signal.h fallback.h util.h wutil.h highlight.h env.h
+reader.o: common.h screen.h color.h reader.h io.h proc.h parser.h event.h
+reader.o: function.h complete.h history.h sanity.h exec.h expand.h
+reader.o: tokenizer.h kill.h input_common.h input.h output.h iothread.h
+reader.o: intern.h parse_util.h autoload.h lru.h
 sanity.o: config.h signal.h fallback.h util.h common.h sanity.h proc.h io.h
 sanity.o: history.h reader.h kill.h wutil.h
-screen.o: config.h fallback.h common.h util.h wutil.h output.h highlight.h
-screen.o: screen.h env.h
-set_color.o: config.h fallback.h print_help.h
+screen.o: config.h fallback.h signal.h common.h util.h wutil.h output.h
+screen.o: screen.h color.h highlight.h env.h
+set_color.o: config.h fallback.h signal.h print_help.h
 signal.o: config.h signal.h common.h util.h fallback.h wutil.h event.h
 signal.o: reader.h io.h proc.h
-tokenizer.o: config.h fallback.h util.h wutil.h tokenizer.h common.h
-util.o: config.h fallback.h util.h common.h wutil.h
-wgetopt.o: config.h wgetopt.h wutil.h fallback.h
-wildcard.o: config.h fallback.h util.h wutil.h complete.h common.h wildcard.h
-wildcard.o: reader.h io.h expand.h exec.h proc.h halloc_util.h
-wutil.o: config.h fallback.h util.h common.h wutil.h halloc.h halloc_util.h
+tokenizer.o: config.h fallback.h signal.h util.h wutil.h tokenizer.h common.h
+util.o: config.h fallback.h signal.h util.h common.h wutil.h
+wgetopt.o: config.h wgetopt.h wutil.h fallback.h signal.h
+wildcard.o: config.h fallback.h signal.h util.h wutil.h complete.h common.h
+wildcard.o: wildcard.h reader.h io.h expand.h exec.h proc.h
+wutil.o: config.h fallback.h signal.h util.h common.h wutil.h
 xdgmime.o: xdgmime.h xdgmimeint.h xdgmimeglob.h xdgmimemagic.h xdgmimealias.h
 xdgmime.o: xdgmimeparent.h
 xdgmimealias.o: xdgmimealias.h xdgmime.h xdgmimeint.h

README

@@ -1,15 +0,0 @@
-How to find documentation for fish
-==================================
-
-The fish documentation is distributed in an intermediate format. To
-view it, you have to type:
-
-  % make user_doc
-
-Which will create the directory user_doc, containing html
-documentation for fish. If you build and install fish, the
-documentation will be available through the 'help' builtin.
-
-After installation, you can start fish by typing fish in the
-terminal. After fish has started, try using the help command for more
-information.

README.md

@@ -0,0 +1,39 @@
+[fish](http://ridiculousfish.com/shell/) - the friendly interactive shell
+================================================
+
+fish is a smart and user-friendly command line shell for OS X, Linux, and the rest of the family. fish includes features like syntax highlighting, autosuggest-as-you-type, and fancy tab completions that just work, with no configuration required.
+
+For more on fish's design philosophy, see the [design document](http://ridiculousfish.com/shell/user_doc/html/design.html).
+
+## Quick Start
+
+fish generally works like other shells, like bash or zsh. A few important differences are documented at <http://ridiculousfish.com/shell/faq.html>
+
+Detailed user documentation is available by running `help` within fish, and also at <http://ridiculousfish.com/shell/user_doc/html/>
+
+## Building
+
+fish can be built using autotools or Xcode.
+
+### Autotools Build
+
+    autoconf
+    ./configure [--without-xsel]
+    make [gmake on BSD]
+    sudo make install
+
+### Xcode Development Build
+
+* Build the `base` target in Xcode
+* Run the fish executable, for example, in `DerivedData/FishsFish/Build/Products/Debug/base/bin/fish`
+
+### Xcode Build and Install
+
+    mkdir /tmp/fish_build
+    xcodebuild install -target install_tree DSTROOT=/tmp/fish_build
+    sudo ditto /tmp/fish_build/ /
+
+## Contact Us
+
+Questions, comments, rants and raves can be posted to the official fish mailing list at <https://lists.sourceforge.net/lists/listinfo/fish-users>
+Found a bug? Have an awesome idea? Please open an issue on this github page.

autoload.cpp

@@ -0,0 +1,344 @@
+/** \file autoload.cpp
+	
+The classes responsible for autoloading functions and completions.
+*/
+
+#include "config.h"
+#include "autoload.h"
+#include "wutil.h"
+#include "common.h"
+#include "signal.h"
+#include "env.h"
+#include "builtin_scripts.h"
+#include "exec.h"
+#include <assert.h>
+#include <algorithm>
+
+/* The time before we'll recheck an autoloaded file */
+static const int kAutoloadStalenessInterval = 15;
+
+file_access_attempt_t access_file(const wcstring &path, int mode) {
+    //printf("Touch %ls\n", path.c_str());
+    file_access_attempt_t result = {0};
+    struct stat statbuf;
+    if (wstat(path, &statbuf)) {
+        result.error = errno;
+    } else {
+        result.mod_time = statbuf.st_mtime;
+        if (waccess(path, mode)) {
+            result.error = errno;
+        } else {
+            result.accessible = true;
+        }
+    }
+    
+    // Note that we record the last checked time after the call, on the assumption that in a slow filesystem, the lag comes before the kernel check, not after.
+    result.stale = false;
+    result.last_checked = time(NULL);
+    return result;
+}
+
+autoload_t::autoload_t(const wcstring &env_var_name_var, const builtin_script_t * const scripts, size_t script_count) :
+                       lock(),
+                       env_var_name(env_var_name_var),
+                       builtin_scripts(scripts),
+                       builtin_script_count(script_count),
+                       last_path(),
+                       is_loading_set()
+{
+    pthread_mutex_init(&lock, NULL);
+}
+
+autoload_t::~autoload_t() {
+    pthread_mutex_destroy(&lock);
+}
+
+void autoload_t::node_was_evicted(autoload_function_t *node) {
+    // This should only ever happen on the main thread
+    ASSERT_IS_MAIN_THREAD();
+    
+    // Tell ourselves that the command was removed if it was loaded
+    if (! node->is_loaded)
+        this->command_removed(node->key);
+    delete node;
+}
+
+int autoload_t::unload( const wcstring &cmd )
+{
+    return this->evict_node(cmd);
+}
+
+int autoload_t::load( const wcstring &cmd, bool reload )
+{
+	int res;
+	CHECK_BLOCK( 0 );
+    ASSERT_IS_MAIN_THREAD();
+    
+	env_var_t path_var = env_get_string( env_var_name );
+    
+    /*
+      Do we know where to look?
+    */
+    if( path_var.empty() )
+        return 0;
+    
+    /* Check if the lookup path has changed. If so, drop all loaded files. path_var may only be inspected on the main thread. */
+    if( path_var != this->last_path )
+    {
+        this->last_path = path_var;
+        scoped_lock locker(lock);
+        this->evict_all_nodes();
+    }
+    
+    /** Warn and fail on infinite recursion. It's OK to do this because this function is only called on the main thread. */
+    if (this->is_loading(cmd))
+    {
+        debug( 0, 
+               _( L"Could not autoload item '%ls', it is already being autoloaded. " 
+                  L"This is a circular dependency in the autoloading scripts, please remove it."), 
+               cmd.c_str() );
+        return 1;
+    }
+    
+    /* Mark that we're loading this */
+    is_loading_set.insert(cmd);
+
+    /* Get the list of paths from which we will try to load */
+    std::vector<wcstring> path_list;
+	tokenize_variable_array( path_var, path_list );
+
+	/* Try loading it */
+	res = this->locate_file_and_maybe_load_it( cmd, true, reload, path_list );
+    
+    /* Clean up */
+    bool erased = !! is_loading_set.erase(cmd);
+    assert(erased);
+		
+	return res;
+}
+
+bool autoload_t::can_load( const wcstring &cmd, const env_vars_snapshot_t &vars )
+{
+    const env_var_t path_var = vars.get(env_var_name);
+    if (path_var.missing_or_empty())
+        return false;
+
+    std::vector<wcstring> path_list;
+	tokenize_variable_array( path_var, path_list );
+    return this->locate_file_and_maybe_load_it( cmd, false, false, path_list );
+}
+
+static bool script_name_precedes_script_name(const builtin_script_t &script1, const builtin_script_t &script2)
+{
+    return wcscmp(script1.name, script2.name) < 0;
+}
+
+void autoload_t::unload_all(void) {
+    scoped_lock locker(lock);
+    this->evict_all_nodes();
+}
+
+/** Check whether the given command is loaded. */
+bool autoload_t::has_tried_loading( const wcstring &cmd )
+{
+    scoped_lock locker(lock);   
+    autoload_function_t * func = this->get_node(cmd);
+    return func != NULL;
+}
+
+static bool is_stale(const autoload_function_t *func) {
+    /** Return whether this function is stale. Internalized functions can never be stale. */
+    return ! func->is_internalized && time(NULL) - func->access.last_checked > kAutoloadStalenessInterval;
+}
+
+autoload_function_t *autoload_t::get_autoloaded_function_with_creation(const wcstring &cmd, bool allow_eviction)
+{
+    ASSERT_IS_LOCKED(lock);
+    autoload_function_t *func = this->get_node(cmd);
+    if (! func) {
+        func = new autoload_function_t(cmd);
+        if (allow_eviction) {
+            this->add_node(func);
+        } else {
+            this->add_node_without_eviction(func);
+        }
+    }
+    return func;
+}
+
+/**
+   This internal helper function does all the real work. By using two
+   functions, the internal function can return on various places in
+   the code, and the caller can take care of various cleanup work.
+   
+     cmd: the command name ('grep')
+     really_load: whether to actually parse it as a function, or just check it it exists
+     reload: whether to reload it if it's already loaded
+     path_list: the set of paths to check
+     
+     Result: if really_load is true, returns whether the function was loaded. Otherwise returns whether the function existed.
+*/
+bool autoload_t::locate_file_and_maybe_load_it( const wcstring &cmd, bool really_load, bool reload, const wcstring_list_t &path_list )
+{
+    /* Note that we are NOT locked in this function! */
+	size_t i;
+	bool reloaded = 0;
+
+    /* Try using a cached function. If we really want the function to be loaded, require that it be really loaded. If we're not reloading, allow stale functions. */
+    {
+        bool allow_stale_functions = ! reload;
+        
+        /* Take a lock */
+        scoped_lock locker(lock);
+        
+        /* Get the function */
+        autoload_function_t * func = this->get_node(cmd);
+        
+        /* Determine if we can use this cached function */
+        bool use_cached;
+        if (! func) {
+            /* Can't use a function that doesn't exist */
+            use_cached = false;
+        } else if (really_load && ! func->is_placeholder && ! func->is_loaded) {
+            /* Can't use an unloaded function */
+            use_cached = false;
+        } else if ( ! allow_stale_functions && is_stale(func)) {
+            /* Can't use a stale function */
+            use_cached = false;
+        } else {
+            /* I guess we can use it */
+            use_cached = true;
+        }
+        
+        /* If we can use this function, return whether we were able to access it */
+        if (use_cached) {
+            return func->is_internalized || func->access.accessible;
+        }
+    }    
+    /* The source of the script will end up here */
+    wcstring script_source;
+    bool has_script_source = false;
+    
+    /* Whether we found an accessible file */
+    bool found_file = false;
+    
+    /* Look for built-in scripts via a binary search */
+    const builtin_script_t *matching_builtin_script = NULL;
+    if (builtin_script_count > 0)
+    {
+        const builtin_script_t test_script = {cmd.c_str(), NULL};
+        const builtin_script_t *array_end = builtin_scripts + builtin_script_count;
+        const builtin_script_t *found = std::lower_bound(builtin_scripts, array_end, test_script, script_name_precedes_script_name);
+        if (found != array_end && ! wcscmp(found->name, test_script.name))
+        {
+            /* We found it */
+            matching_builtin_script = found;
+        }
+    }
+    if (matching_builtin_script) {
+        has_script_source = true;
+        script_source = str2wcstring(matching_builtin_script->def);
+        
+        /* Make a node representing this function */
+        scoped_lock locker(lock);
+        autoload_function_t *func = this->get_autoloaded_function_with_creation(cmd, really_load);
+        
+        /* This function is internalized */
+        func->is_internalized = true;
+        
+        /* It's a fiction to say the script is loaded at this point, but we're definitely going to load it down below. */
+        if (really_load) func->is_loaded = true;
+    }
+    
+    if (! has_script_source)
+    {
+        /* Iterate over path searching for suitable completion files */
+        for( i=0; i<path_list.size(); i++ )
+        {
+            wcstring next = path_list.at(i);
+            wcstring path = next + L"/" + cmd + L".fish";
+
+            const file_access_attempt_t access = access_file(path, R_OK);
+            if (access.accessible) {
+                /* Found it! */
+                found_file = true;
+                
+                /* Now we're actually going to take the lock. */
+                scoped_lock locker(lock);
+                autoload_function_t *func = this->get_node(cmd);
+                
+                /* Generate the source if we need to load it */
+                bool need_to_load_function = really_load && (func == NULL || func->access.mod_time != access.mod_time || ! func->is_loaded);
+                if (need_to_load_function) {
+                
+                    /* Generate the script source */
+                    wcstring esc = escape_string(path, 1);
+                    script_source = L". " + esc;
+                    has_script_source = true;
+                    
+                    /* Remove any loaded command because we are going to reload it. Note that this will deadlock if command_removed calls back into us. */
+                    if (func && func->is_loaded) {
+                        command_removed(cmd);
+                        func->is_placeholder = false;
+                    }
+                    
+                    /* Mark that we're reloading it */
+                    reloaded = true;
+                }
+                
+                /* Create the function if we haven't yet. This does not load it. Do not trigger eviction unless we are actually loading, because we don't want to evict off of the main thread. */
+                if (! func) {
+                    func = get_autoloaded_function_with_creation(cmd, really_load);
+                }
+                
+                /* It's a fiction to say the script is loaded at this point, but we're definitely going to load it down below. */
+                if (need_to_load_function) func->is_loaded = true;
+                                                                
+                /* Unconditionally record our access time */
+                func->access = access;
+
+                break;
+            }
+        }
+
+        /*
+          If no file or builtin script was found we insert a placeholder function.
+          Later we only research if the current time is at least five seconds later.
+          This way, the files won't be searched over and over again.
+        */
+        if( ! found_file && ! has_script_source )
+        {
+            scoped_lock locker(lock);
+            /* Generate a placeholder */
+            autoload_function_t *func = this->get_node(cmd);
+            if (! func) {
+                func = new autoload_function_t(cmd);
+                func->is_placeholder = true;
+                if (really_load) {
+                    this->add_node(func);
+                } else {
+                    this->add_node_without_eviction(func);
+                }
+            }
+            func->access.last_checked = time(NULL);
+        }
+    }
+    
+    /* If we have a script, either built-in or a file source, then run it */
+    if (really_load && has_script_source)
+    {
+        if( exec_subshell( script_source) == -1 )
+        {
+            /*
+              Do nothing on failiure
+            */
+        }
+
+    }
+
+    if (really_load) {
+        return reloaded;
+    } else {
+        return found_file || has_script_source;
+    }
+}

autoload.h

@@ -0,0 +1,129 @@
+/** \file autoload.h
+
+    The classes responsible for autoloading functions and completions.
+*/
+
+#ifndef FISH_AUTOLOAD_H
+#define FISH_AUTOLOAD_H
+
+#include <wchar.h>
+#include <map>
+#include <set>
+#include <list>
+#include "common.h"
+#include "lru.h"
+
+/** A struct responsible for recording an attempt to access a file. */
+struct file_access_attempt_t {
+    time_t mod_time; /** The modification time of the file */
+    time_t last_checked; /** When we last checked the file */
+    bool accessible; /** Whether we believe we could access this file */
+    bool stale; /** Whether the access attempt is stale */
+    int error; /** If we could not access the file, the error code */
+};
+
+file_access_attempt_t access_file(const wcstring &path, int mode);
+
+struct autoload_function_t : public lru_node_t
+{   
+    autoload_function_t(const wcstring &key) : lru_node_t(key), access(), is_loaded(false), is_placeholder(false), is_internalized(false) { }
+    file_access_attempt_t access; /** The last access attempt */
+    bool is_loaded; /** Whether we have actually loaded this function */
+    bool is_placeholder; /** Whether we are a placeholder that stands in for "no such function". If this is true, then is_loaded must be false. */
+    bool is_internalized; /** Whether this function came from a builtin "internalized" script */
+};
+
+
+struct builtin_script_t;
+class env_vars_snapshot_t;
+
+/**
+  A class that represents a path from which we can autoload, and the autoloaded contents.
+ */
+class autoload_t : private lru_cache_t<autoload_function_t> {
+private:
+
+    /** Lock for thread safety */
+    pthread_mutex_t lock;
+
+    /** The environment variable name */
+    const wcstring env_var_name;
+    
+    /** Builtin script array */
+    const struct builtin_script_t *const builtin_scripts;
+    
+    /** Builtin script count */
+    const size_t builtin_script_count;
+
+    /** The path from which we most recently autoloaded */
+    wcstring last_path;
+
+	/**
+	   A table containing all the files that are currently being
+	   loaded. This is here to help prevent recursion.
+	*/
+    std::set<wcstring> is_loading_set;
+
+    bool is_loading(const wcstring &name) const {
+        return is_loading_set.find(name) != is_loading_set.end();
+    }
+    
+    void remove_all_functions(void) {
+        this->evict_all_nodes();
+    }
+    
+    bool locate_file_and_maybe_load_it( const wcstring &cmd, bool really_load, bool reload, const wcstring_list_t &path_list );
+    
+    virtual void node_was_evicted(autoload_function_t *node);
+
+    autoload_function_t *get_autoloaded_function_with_creation(const wcstring &cmd, bool allow_eviction);
+    
+    protected:    
+    /** Overridable callback for when a command is removed */
+    virtual void command_removed(const wcstring &cmd) { }
+    
+    public:
+    
+    /** Create an autoload_t for the given environment variable name */
+    autoload_t(const wcstring &env_var_name_var, const builtin_script_t *scripts, size_t script_count );
+    
+    /** Destructor */
+    virtual ~autoload_t();
+    
+    /**
+       Autoload the specified file, if it exists in the specified path. Do
+       not load it multiple times unless it's timestamp changes or
+       parse_util_unload is called.
+
+       Autoloading one file may unload another. 
+
+       \param cmd the filename to search for. The suffix '.fish' is always added to this name
+       \param on_unload a callback function to run if a suitable file is found, which has not already been run. unload will also be called for old files which are unloaded.
+       \param reload wheter to recheck file timestamps on already loaded files
+    */
+    int load( const wcstring &cmd, bool reload );
+    
+    /** Check whether we have tried loading the given command. Does not do any I/O. */
+    bool has_tried_loading( const wcstring &cmd );
+
+    /**
+       Tell the autoloader that the specified file, in the specified path,
+       is no longer loaded.
+
+       \param cmd the filename to search for. The suffix '.fish' is always added to this name
+       \param on_unload a callback function which will be called before (re)loading a file, may be used to unload the previous file.
+       \return non-zero if the file was removed, zero if the file had not yet been loaded
+    */
+    int unload( const wcstring &cmd );
+    
+    /**
+       Unloads all files.
+    */
+    void unload_all( );
+    
+    /** Check whether the given command could be loaded, but do not load it. */
+    bool can_load( const wcstring &cmd, const env_vars_snapshot_t &vars );
+
+};
+
+#endif

build_tools/description-pak

@@ -0,0 +1,3 @@
+This is the_ridiculous'fish s delightful fork of, fish friendly interactive shell. For more information, visit http://ridiculousfish.com/shell/ .
+
+This installer will install fish, but will not modify your /etc/shells file or your default shell. I trust you know how to do that yourself if you care to!

build_tools/fish_shell.pmdoc/01fish-contents.xml

@@ -0,0 +1 @@
+<pkg-contents spec="1.12"/>

build_tools/fish_shell.pmdoc/01fish.xml

@@ -0,0 +1 @@
+<pkgref spec="1.12" uuid="6A7E1ED5-E40E-4ACE-959B-B9D77555AD39"><config><identifier>com.ridiculousfish.fish-shell.fishShell.fish_pkg.pkg</identifier><version>1.0</version><description></description><post-install type="none"/><requireAuthorization/><installFrom>/private/tmp/fish_pkg</installFrom><installTo>/</installTo><flags><followSymbolicLinks/></flags><packageStore type="internal"></packageStore><mod>parent</mod><mod>installTo</mod></config></pkgref>

build_tools/fish_shell.pmdoc/index.xml

@@ -0,0 +1,40 @@
+<pkmkdoc spec="1.12"><properties><title>fish shell</title><organization>com.ridiculousfish.fish-shell</organization><userSees ui="easy"/><min-target os="3"/><domain anywhere="true"/></properties><distribution><versions min-spec="1.000000"/><scripts></scripts></distribution><contents><choice title="fish_pkg" id="fish shell" starts_selected="true" starts_enabled="true" starts_hidden="false"><pkgref id="com.ridiculousfish.fish-shell.fishShell.fish_pkg.pkg"/></choice></contents><resources bg-scale="proportional" bg-align="bottomleft"><locale lang="en"><resource mod="true" type="background">/Users/peter/Desktop/Untitled.pdf</resource><resource mime-type="text/rtf" kind="embedded" type="welcome"><![CDATA[{\rtf1\ansi\ansicpg1252\cocoartf1138\cocoasubrtf470
+{\fonttbl\f0\fswiss\fcharset0 Helvetica;}
+{\colortbl;\red255\green255\blue255;}
+\pard\tx720\tx1440\tx2160\tx2880\tx3600\tx4320\tx5040\tx5760\tx6480\tx7200\tx7920\tx8640\pardirnatural
+
+\f0\fs30 \cf0 This installs ridiculous_fish's fork of fish, a command line shell for Mac OS X, Linux, and the rest of the family. For more information on fish, visit {\field{\*\fldinst{HYPERLINK "http://ridiculousfish.com/shell/"}}{\fldrslt http://ridiculousfish.com/shell/}}\
+\
+The path to fish will be added to /etc/shells, but your default shell will not be modified. \
+\
+This release is beta r2.\
+}]]></resource><resource mime-type="text/rtf" kind="embedded" type="conclusion"><![CDATA[{\rtf1\ansi\ansicpg1252\cocoartf1138\cocoasubrtf470
+{\fonttbl\f0\fswiss\fcharset0 Helvetica;\f1\fnil\fcharset0 Monaco;}
+{\colortbl;\red255\green255\blue255;}
+\pard\tx720\tx1440\tx2160\tx2880\tx3600\tx4320\tx5040\tx5760\tx6480\tx7200\tx7920\tx8640\pardirnatural
+
+\f0\fs26 \cf0 Run 
+\f1 fish
+\f0  at the command line to start it up!  Some useful commands:\
+\
+Interactively set your colors from a web page:\
+\
+	
+\f1 fish_config
+\f0 \
+\
+Update man-page completions:\
+\
+	
+\f1 fish_update_completions
+\f0 \
+\
+Make fish your default shell:\
+\
+	
+\f1 chsh -s /usr/local/bin/fish\
+
+\f0 \
+\
+Enjoy!\
+}]]></resource></locale></resources><flags/><item type="file">01fish.xml</item><mod>properties.title</mod><mod>description</mod></pkmkdoc>

build_tools/make_deb.sh

@@ -0,0 +1,18 @@
+#!/bin/sh
+
+# Terminate on error
+set -e
+
+sudo rm -Rf /tmp/fishfish
+mkdir /tmp/fishfish
+git archive --format=tar fish_fish | tar -x -C /tmp/fishfish
+mkdir /tmp/fishfish/doc-pak
+cp README INSTALL CHANGELOG release_notes.html /tmp/fishfish/doc-pak/
+cp build_tools/description-pak /tmp/fishfish/
+cd /tmp/fishfish
+autoconf
+./configure
+make -j 3
+sudo checkinstall --default --pakdir ~/fish_built/ --pkgversion 0.9 make install
+mv ~/fish_built/fishfish_0.9-1_i386.deb ~/fish_built/fishfish_0.9_i386.deb
+

build_tools/make_pkg.sh

@@ -0,0 +1,31 @@
+#!/bin/sh -x
+
+make distclean
+rm -rf /tmp/fish_pkg
+mkdir -p /tmp/fish_pkg/
+
+# Make sure what we build can run on SnowLeopard
+export OSX_SDK="/Developer/SDKs/MacOSX10.6.sdk"
+export MACOSX_DEPLOYMENT_TARGET="10.6"
+export CC="clang -isysroot $OSX_SDK -mmacosx-version-min=$MACOSX_DEPLOYMENT_TARGET"
+export CCX="clang++ -isysroot $OSX_SDK -mmacosx-version-min=$MACOSX_DEPLOYMENT_TARGET"
+export CFLAGS="$CFLAGS -isysroot $OSX_SDK -mmacosx-version-min=$MACOSX_DEPLOYMENT_TARGET"
+export CXXFLAGS="$CXXFLAGS -isysroot $OSX_SDK -mmacosx-version-min=$MACOSX_DEPLOYMENT_TARGET"
+export LDFLAGS="$LDFLAGS -isysroot $OSX_SDK -mmacosx-version-min=$MACOSX_DEPLOYMENT_TARGET"
+autoconf
+./configure --without-xsel
+
+# Actually build it now
+if make -j 4 DESTDIR=/tmp/fish_pkg install
+then
+	echo "Root written to /tmp/fish_pkg/"
+	if /Developer/usr/bin/packagemaker --doc ./build_tools/fish_shell.pmdoc --out ~/fish_built/fishfish.pkg
+	then
+		echo "Package written to ~/fish_built/fishfish.pkg"
+	else
+		echo "Package could not be written"
+	fi
+	
+else
+	echo "Root could not be written"
+fi

build_tools/make_tarball.sh

@@ -0,0 +1,46 @@
+#!/bin/sh
+
+# Script to generate a tarball
+# We use git to output a tree. But we also want to build the user documentation
+# and put that in the tarball, so that nobody needs to have doxygen installed
+# to build it.
+
+# Exit on error
+set -e
+
+# We wil generate a tarball with a prefix "fish"
+# git can do that automatically for us via git-archive
+# but to get the documentation in, we need to make a symlink called "fish"
+# and tar from that, so that the documentation gets the right prefix
+
+# Get the current directory, which we'll use for symlinks
+wd="$PWD"
+
+# The name of the prefix, which is the directory that you get when you untar
+prefix="fish"
+
+# The path where we will output the tar file
+path=~/fish_built/fish-2.0.tar
+
+# Clean up stuff we've written before
+rm -f "$path" "$path".gz
+
+# git starts the archive
+git archive --format=tar --prefix="$prefix"/ master > "$path"
+
+# tarball out the documentation
+make user_doc
+make share/man
+cd /tmp
+rm -f "$prefix"
+ln -s "$wd" "$prefix"
+tar --append --file="$path" "$prefix"/user_doc/html
+tar --append --file="$path" "$prefix"/share/man
+rm -f "$prefix"
+
+# gzip it
+gzip "$path"
+
+# Output what we did, and the sha1 hash
+echo "Tarball written to $path".gz
+openssl sha1 "$path".gz

build_tools/osx_package_scripts/add-shell

@@ -0,0 +1,53 @@
+#!/bin/sh -e
+
+# Modified from Debian's add-shell to work on OS X
+
+if test $# -eq 0
+then
+	echo usage: $0 shellname [shellname ...]
+	exit 1
+fi
+
+scriptname=`basename "$0"`
+if [[ $UID -ne 0 ]]; then
+     echo "${scriptname} must be run as root"
+     exit 1
+fi
+
+file=/etc/shells
+# I want this to be GUARANTEED to be on the same filesystem as $file
+tmpfile=${file}.tmp
+
+set -o noclobber
+
+trap "rm -f $tmpfile" EXIT
+
+if ! cat $file > $tmpfile
+then
+        cat 1>&2 <<EOF
+Either another instance of $0 is running, or it was previously interrupted.
+Please examine ${tmpfile} to see if it should be moved onto ${file}.
+EOF
+        exit 1
+fi
+
+# Append a newline if it doesn't exist
+if [ "$(tail -c1 "$tmpfile"; echo x)" != $'\nx' ]; then
+    echo "" >> "$tmpfile"
+fi
+
+for i
+do
+        if ! grep -q "^${i}$" "$tmpfile"
+        then
+                echo $i >> "$tmpfile"
+        fi
+done
+
+chmod 0644 $tmpfile
+chown root:wheel $tmpfile
+
+mv $tmpfile $file
+
+trap "" EXIT
+exit 0

build_tools/osx_package_scripts/postinstall

@@ -0,0 +1,3 @@
+#!/bin/sh -x
+
+./add-shell /usr/local/bin/fish > /tmp/fish_postinstall_output.log

builtin.h

@@ -9,6 +9,9 @@
 
 #include "util.h"
 #include "io.h"
+#include "common.h"
+
+class parser_t;
 
 enum
 {
@@ -64,12 +67,16 @@ enum
 #define BUILTIN_FOR_ERR_IN _( L"%ls: Second argument must be 'in'\n" )
 
 /**
-   Error message for insufficient number of arguments
+   Error message for insufficient number of arguments 
 */
 #define BUILTIN_FOR_ERR_COUNT _( L"%ls: Expected at least two arguments, got %d\n")
 
 #define BUILTIN_FOR_ERR_NAME _( L"%ls: '%ls' is not a valid variable name\n" )
 
+/** Error messages for 'else if' */
+#define BUILTIN_ELSEIF_ERR_COUNT _( L"%ls: can only take 'if' and then another command as an argument\n")
+#define BUILTIN_ELSEIF_ERR_ARGUMENT _( L"%ls: any second argument must be 'if'\n")
+
 /**
    Error message when too many arguments are supplied to a builtin
 */
@@ -86,15 +93,13 @@ enum
 #define BUILTIN_END_BLOCK_UNKNOWN _( L"%ls: Unknown block type '%ls'\n" )
 
 #define BUILTIN_ERR_NOT_NUMBER _( L"%ls: Argument '%ls' is not a number\n" )
-/**
-   Stringbuffer used to represent standard output
-*/
-extern string_buffer_t *sb_out;
 
-/**
-   Stringbuffer used to represent standard error
-*/
-extern string_buffer_t *sb_err;
+/** Get the string used to represent stdout and stderr */
+const wcstring &get_stdout_buffer();
+const wcstring &get_stderr_buffer();
+
+/** Output an error */
+void builtin_show_error(const wcstring &err);
 
 /**
    Kludge. Tells builtins if output is to screen
@@ -108,7 +113,7 @@ extern int builtin_err_redirect;
 
 
 /**
-   Initialize builtin data.
+   Initialize builtin data. 
 */
 void builtin_init();
 
@@ -120,41 +125,43 @@ void builtin_destroy();
 /**
   Is there a builtin command with the given name?
 */
-int builtin_exists( wchar_t *cmd );
+int builtin_exists( const wcstring &cmd );
 
 /**
-  Execute a builtin command
+  Execute a builtin command 
 
-  \param argv Array containing the command and parameters
+  \param parser The parser being used
+  \param argv Array containing the command and parameters 
   of the builtin.  The list is terminated by a
-  null pointer. This syntax resembles the syntax
+  null pointer. This syntax resembles the syntax 
   for exec.
   \param io the io redirections to perform on this builtin.
 
   \return the exit status of the builtin command
 */
-int builtin_run( wchar_t **argv, io_data_t *io );
+int builtin_run( parser_t &parser, const wchar_t * const *argv, const io_chain_t &io );
+
+/** Returns a list of all builtin names */
+wcstring_list_t builtin_get_names(void);
+
+/** Insert all builtin names into list. */
+void builtin_get_names(std::vector<completion_t> &list);
 
 /**
-  Insert all builtin names into l. These are not copies of the strings and should not be freed after use.
+   Pushes a new set of input/output to the stack. The new stdin is supplied, a new set of output strings is created.
 */
-void builtin_get_names( array_list_t *list );
+void builtin_push_io( parser_t &parser, int stdin_fd );
 
 /**
-   Pushes a new set of input/output to the stack. The new stdin is supplied, a new set of output string_buffer_ts is created.
+   Pops a set of input/output from the stack. The output strings are destroued, but the input file is not closed.
 */
-void builtin_push_io( int stdin_fd );
-
-/**
-   Pops a set of input/output from the stack. The output string_buffer_ts are destroued, but the input file is not closed.
-*/
-void builtin_pop_io();
+void builtin_pop_io(parser_t &parser);
 
 
 /**
-   Return a one-line description of the specified builtin
+   Return a one-line description of the specified builtin.
 */
-const wchar_t *builtin_get_desc( const wchar_t *b );
+wcstring builtin_get_desc( const wcstring &b );
 
 
 /**
@@ -167,10 +174,9 @@ const wchar_t *builtin_complete_get_temporary_buffer();
 
 /**
    Run the __fish_print_help function to obtain the help information
-   for the specified command. The resulting string will be valid until
-   the next time this function is called, and must never be free'd manually.
+   for the specified command.
 */
 
-wchar_t *builtin_help_get( const wchar_t *cmd );
+wcstring builtin_help_get( parser_t &parser, const wchar_t *cmd );
 
 #endif

builtin_commandline.cpp

@@ -1,6 +1,6 @@
 /** \file builtin_commandline.c Functions defining the commandline builtin
 
-Functions used for implementing the commandline builtin.
+Functions used for implementing the commandline builtin. 
 
 */
 #include "config.h"
@@ -56,17 +56,17 @@ enum
    Pointer to what the commandline builtin considers to be the current
    contents of the command line buffer.
  */
-static wchar_t *current_buffer=0;
+static const wchar_t *current_buffer=0;
 /**
    What the commandline builtin considers to be the current cursor
    position.
  */
-static int current_cursor_pos = -1;
+static size_t current_cursor_pos = (size_t)(-1);
 
 /**
    Returns the current commandline buffer.
 */
-static wchar_t *get_buffer()
+static const wchar_t *get_buffer()
 {
 	return current_buffer;
 }
@@ -74,7 +74,7 @@ static wchar_t *get_buffer()
 /**
    Returns the position of the cursor
 */
-static int get_cursor_pos()
+static size_t get_cursor_pos()
 {
 	return current_cursor_pos;
 }
@@ -90,48 +90,46 @@ static int get_cursor_pos()
 */
 static void replace_part( const wchar_t *begin,
 						  const wchar_t *end,
-						  wchar_t *insert,
+						  const wchar_t *insert,
 						  int append_mode )
 {
 	const wchar_t *buff = get_buffer();
-	string_buffer_t out;
-	int out_pos=get_cursor_pos();
-
-	sb_init( &out );
-
-	sb_append_substring( &out, buff, begin-buff );
+	size_t out_pos = get_cursor_pos();
+    
+    wcstring out;
 
+    out.append(buff, begin - buff);
+					
 	switch( append_mode)
 	{
 		case REPLACE_MODE:
 		{
-
-			sb_append( &out, insert );
-			out_pos = wcslen( insert ) + (begin-buff);
+							
+			out.append(insert);
+			out_pos = wcslen( insert ) + (begin-buff);							
 			break;
-
+							
 		}
 		case APPEND_MODE:
 		{
-			sb_append_substring( &out, begin, end-begin );
-			sb_append( &out, insert );
+			out.append( begin, end-begin );
+			out.append( insert );
 			break;
 		}
 		case INSERT_MODE:
 		{
-			int cursor = get_cursor_pos() -(begin-buff);
-			sb_append_substring( &out, begin, cursor );
-			sb_append( &out, insert );
-			sb_append_substring( &out, begin+cursor, end-begin-cursor );
-			out_pos +=  wcslen( insert );
+			long cursor = get_cursor_pos() -(begin-buff);
+			out.append( begin, cursor );
+			out.append( insert );
+			out.append( begin+cursor, end-begin-cursor );
+			out_pos +=  wcslen( insert );							
 			break;
 		}
 	}
-	sb_append( &out, end );
-	reader_set_buffer( (wchar_t *)out.buff, out_pos );
-	sb_destroy( &out );
+	out.append( end );
+	reader_set_buffer( out, out_pos );
 }
-
+	
 /**
    Output the specified selection.
 
@@ -140,15 +138,15 @@ static void replace_part( const wchar_t *begin,
    \param cut_at_cursor whether printing should stop at the surrent cursor position
    \param tokenize whether the string should be tokenized, printing one string token on every line and skipping non-string tokens
 */
-static void write_part( const wchar_t *begin,
-						const wchar_t *end,
-						int cut_at_cursor,
+static void write_part( const wchar_t *begin, 
+						const wchar_t *end, 
+						int cut_at_cursor, 
 						int tokenize )
-{
+{	
 	tokenizer tok;
-	string_buffer_t out;
+	wcstring out;
 	wchar_t *buff;
-	int pos;
+	size_t pos;
 
 	pos = get_cursor_pos()-(begin-get_buffer());
 
@@ -156,8 +154,8 @@ static void write_part( const wchar_t *begin,
 	{
 		buff = wcsndup( begin, end-begin );
 //		fwprintf( stderr, L"Subshell: %ls, end char %lc\n", buff, *end );
-		sb_init( &out );
-
+		out.clear();
+					
 		for( tok_init( &tok, buff, TOK_ACCEPT_UNFINISHED );
 			 tok_has_next( &tok );
 			 tok_next( &tok ) )
@@ -165,45 +163,36 @@ static void write_part( const wchar_t *begin,
 			if( (cut_at_cursor) &&
 				(tok_get_pos( &tok)+wcslen(tok_last( &tok)) >= pos) )
 				break;
-
+		
 			switch( tok_last_type( &tok ) )
 			{
 				case TOK_STRING:
 				{
-					wchar_t *tmp = unescape( tok_last( &tok ), UNESCAPE_INCOMPLETE );
-					sb_append( &out, tmp, L"\n", (void *)0 );
-					free( tmp );
+                    out.append(escape_string(tok_last( &tok ), UNESCAPE_INCOMPLETE));
+                    out.push_back(L'\n');
 					break;
 				}
-
-			}
+				
+			}						
 		}
 
-		sb_append( sb_out,
-				   (wchar_t *)out.buff );
-
+        stdout_buffer.append(out);
+					
 		free( buff );
 		tok_destroy( &tok );
-		sb_destroy( &out );
 	}
 	else
 	{
-		wchar_t *buff;
-
 		if( cut_at_cursor )
 		{
-			end = begin+pos;
+			end = begin+pos;			
 		}
 
-		buff = wcsndup( begin, end-begin );
-
 //		debug( 0, L"woot2 %ls -> %ls", buff, esc );
 
-		sb_append( sb_out, buff );
-		sb_append( sb_out, L"\n" );
-
-		free( buff );
-
+        stdout_buffer.append(begin, end - begin);
+        stdout_buffer.append(L"\n");
+		
 	}
 }
 
@@ -212,23 +201,23 @@ static void write_part( const wchar_t *begin,
    The commandline builtin. It is used for specifying a new value for
    the commandline.
 */
-static int builtin_commandline( wchar_t **argv )
+static int builtin_commandline( parser_t &parser, wchar_t **argv )
 {
 
 	int buffer_part=0;
 	int cut_at_cursor=0;
-
+	
 	int argc = builtin_count_args( argv );
 	int append_mode=0;
 
 	int function_mode = 0;
-
-	int tokenize = 0;
-
+	
+	int tokenize = 0;	
+	
 	int cursor_mode = 0;
 	int line_mode = 0;
 	int search_mode = 0;
-	wchar_t *begin, *end;
+	const wchar_t *begin, *end;
 
 	current_buffer = (wchar_t *)builtin_complete_get_temporary_buffer();
 	if( current_buffer )
@@ -252,12 +241,10 @@ static int builtin_commandline( wchar_t **argv )
 			*/
 			return 1;
 		}
-
-		sb_append( sb_err,
-			    argv[0],
-			    L": Can not set commandline in non-interactive mode\n",
-			    (void *)0 );
-		builtin_print_help( argv[0], sb_err );
+		
+        stderr_buffer.append(argv[0]);
+        stderr_buffer.append(L": Can not set commandline in non-interactive mode\n");
+		builtin_print_help( parser, argv[0], stderr_buffer );
 		return 1;
 	}
 
@@ -291,11 +278,11 @@ static int builtin_commandline( wchar_t **argv )
 				{
 					L"current-token", no_argument, 0, 't'
 				}
-				,
+				,		
 				{
 					L"current-buffer", no_argument, 0, 'b'
 				}
-				,
+				,		
 				{
 					L"cut-at-cursor", no_argument, 0, 'c'
 				}
@@ -312,7 +299,7 @@ static int builtin_commandline( wchar_t **argv )
 					L"help", no_argument, 0, 'h'
 				}
 				,
-				{
+				{					
 					L"input", required_argument, 0, 'I'
 				}
 				,
@@ -329,34 +316,34 @@ static int builtin_commandline( wchar_t **argv )
 				}
 				,
 				{
-					0, 0, 0, 0
+					0, 0, 0, 0 
 				}
 			}
-		;
-
+		;		
+		
 		int opt_index = 0;
-
+		
 		int opt = wgetopt_long( argc,
-								argv,
-								L"abijpctwforhI:CLS",
-								long_options,
+								argv, 
+								L"abijpctwforhI:CLS", 
+								long_options, 
 								&opt_index );
 		if( opt == -1 )
 			break;
-
+			
 		switch( opt )
 		{
 			case 0:
 				if(long_options[opt_index].flag != 0)
 					break;
-                sb_printf( sb_err,
+                append_format( stderr_buffer,
                            BUILTIN_ERR_UNKNOWN,
                            argv[0],
                            long_options[opt_index].name );
-				builtin_print_help( argv[0], sb_err );
+				builtin_print_help( parser, argv[0], stderr_buffer );
 
 				return 1;
-
+				
 			case L'a':
 				append_mode = APPEND_MODE;
 				break;
@@ -364,8 +351,8 @@ static int builtin_commandline( wchar_t **argv )
 			case L'b':
 				buffer_part = STRING_MODE;
 				break;
-
-
+				
+				
 			case L'i':
 				append_mode = INSERT_MODE;
 				break;
@@ -373,11 +360,11 @@ static int builtin_commandline( wchar_t **argv )
 			case L'r':
 				append_mode = REPLACE_MODE;
 				break;
-
+								
 			case 'c':
 				cut_at_cursor=1;
 				break;
-
+				
 			case 't':
 				buffer_part = TOKEN_MODE;
 				break;
@@ -402,54 +389,54 @@ static int builtin_commandline( wchar_t **argv )
 				current_buffer = woptarg;
 				current_cursor_pos = wcslen( woptarg );
 				break;
-
+				
 			case 'C':
 				cursor_mode = 1;
 				break;
-
+				
 			case 'L':
 				line_mode = 1;
 				break;
-
+				
 			case 'S':
 				search_mode = 1;
 				break;
-
+				
 			case 'h':
-				builtin_print_help( argv[0], sb_out );
+				builtin_print_help( parser, argv[0], stdout_buffer );
 				return 0;
 
 			case L'?':
-				builtin_unknown_option( argv[0], argv[woptind-1] );
-				return 1;
+				builtin_unknown_option( parser, argv[0], argv[woptind-1] );
+				return 1;	
 		}
-	}
+	}		
 
 	if( function_mode )
 	{
 		int i;
-
+		
 		/*
 		  Check for invalid switch combinations
 		*/
 		if( buffer_part || cut_at_cursor || append_mode || tokenize || cursor_mode || line_mode || search_mode )
 		{
-			sb_printf(sb_err,
+			append_format(stderr_buffer,
 					  BUILTIN_ERR_COMBO,
 					  argv[0] );
-
-			builtin_print_help( argv[0], sb_err );
+			
+			builtin_print_help( parser, argv[0], stderr_buffer );
 			return 1;
 		}
-
+		
 
 		if( argc == woptind )
 		{
-			sb_printf( sb_err,
+			append_format(stderr_buffer,
 					   BUILTIN_ERR_MISSING,
 					   argv[0] );
-
-			builtin_print_help( argv[0], sb_err );
+			
+			builtin_print_help( parser, argv[0], stderr_buffer );
 			return 1;
  		}
 		for( i=woptind; i<argc; i++ )
@@ -466,63 +453,63 @@ static int builtin_commandline( wchar_t **argv )
 			}
 			else
 			{
-				sb_printf( sb_err,
+				append_format(stderr_buffer,
 					   _(L"%ls: Unknown input function '%ls'\n"),
 					   argv[0],
 					   argv[i] );
-				builtin_print_help( argv[0], sb_err );
+				builtin_print_help( parser, argv[0], stderr_buffer );
 				return 1;
 			}
 		}
-
-		return 0;
+		
+		return 0;		
 	}
-
+	
 	/*
 	  Check for invalid switch combinations
 	*/
 	if( (search_mode || line_mode || cursor_mode) && (argc-woptind > 1) )
 	{
-
-		sb_append( sb_err,
+		
+		append_format(stderr_buffer,
 					argv[0],
 					L": Too many arguments\n",
-					(void *)0 );
-		builtin_print_help( argv[0], sb_err );
+					NULL );
+		builtin_print_help( parser, argv[0], stderr_buffer );
 		return 1;
 	}
 
 	if( (buffer_part || tokenize || cut_at_cursor) && (cursor_mode || line_mode || search_mode) )
-	{
-		sb_printf( sb_err,
+	{		
+		append_format(stderr_buffer,
 				   BUILTIN_ERR_COMBO,
 				   argv[0] );
 
-		builtin_print_help( argv[0], sb_err );
+		builtin_print_help( parser, argv[0], stderr_buffer );
 		return 1;
-	}
-
+	}		
+	
 
 	if( (tokenize || cut_at_cursor) && (argc-woptind) )
 	{
-		sb_printf( sb_err,
+		append_format(stderr_buffer,
 				   BUILTIN_ERR_COMBO2,
 				   argv[0],
 				   L"--cut-at-cursor and --tokenize can not be used when setting the commandline" );
+		
 
-
-		builtin_print_help( argv[0], sb_err );
+		builtin_print_help( parser, argv[0], stderr_buffer );
 		return 1;
 	}
 
 	if( append_mode && !(argc-woptind) )
 	{
-		sb_printf( sb_err,
+		append_format(stderr_buffer,
                     BUILTIN_ERR_COMBO2,
                     argv[0],
 				   L"insertion mode switches can not be used when not in insertion mode" );
 
-        builtin_print_help( argv[0], sb_err );
+        builtin_print_help( parser, argv[0], stderr_buffer );		
         return 1;
 	}
 
@@ -533,7 +520,7 @@ static int builtin_commandline( wchar_t **argv )
 	{
 		append_mode = REPLACE_MODE;
 	}
-
+	
 	if( !buffer_part )
 	{
 		buffer_part = STRING_MODE;
@@ -544,121 +531,116 @@ static int builtin_commandline( wchar_t **argv )
 		if( argc-woptind )
 		{
 			wchar_t *endptr;
-			int new_pos;
+			long new_pos;
 			errno = 0;
-
+			
 			new_pos = wcstol( argv[woptind], &endptr, 10 );
 			if( *endptr || errno )
 			{
-				sb_printf( sb_err,
+				append_format(stderr_buffer,
 					   BUILTIN_ERR_NOT_NUMBER,
 					   argv[0],
 					   argv[woptind] );
-				builtin_print_help( argv[0], sb_err );
+				builtin_print_help( parser, argv[0], stderr_buffer );
 			}
-
+			
 			current_buffer = reader_get_buffer();
-			new_pos = maxi( 0, mini( new_pos, wcslen( current_buffer ) ) );
-			reader_set_buffer( current_buffer, new_pos );
+			new_pos = maxi( 0L, mini( new_pos, (long)wcslen( current_buffer ) ) );
+			reader_set_buffer( current_buffer, (size_t)new_pos );
 			return 0;
 		}
 		else
 		{
-			sb_printf( sb_out, L"%d\n", reader_get_cursor_pos() );
+			append_format(stdout_buffer, L"%lu\n", (unsigned long)reader_get_cursor_pos() );
 			return 0;
 		}
-
+		
 	}
-
+	
 	if( line_mode )
 	{
-		int pos = reader_get_cursor_pos();
-		wchar_t *buff = reader_get_buffer();
-		sb_printf( sb_out, L"%d\n", parse_util_lineno( buff, pos ) );
+		size_t pos = reader_get_cursor_pos();
+		const wchar_t *buff = reader_get_buffer();
+		append_format(stdout_buffer, L"%lu\n", (unsigned long)parse_util_lineno( buff, pos ) );
 		return 0;
-
+			
 	}
-
+	
 	if( search_mode )
 	{
 		return !reader_search_mode();
 	}
-
-
+	
+		
 	switch( buffer_part )
 	{
 		case STRING_MODE:
-		{
+		{			
 			begin = get_buffer();
 			end = begin+wcslen(begin);
-			break;
+			break;			
 		}
 
 		case PROCESS_MODE:
 		{
 			parse_util_process_extent( get_buffer(),
 									   get_cursor_pos(),
-									   &begin,
+									   &begin, 
 									   &end );
 			break;
 		}
-
+		
 		case JOB_MODE:
 		{
 			parse_util_job_extent( get_buffer(),
 								   get_cursor_pos(),
 								   &begin,
-								   &end );
-			break;
+								   &end );					
+			break;			
 		}
-
+		
 		case TOKEN_MODE:
 		{
 			parse_util_token_extent( get_buffer(),
 									 get_cursor_pos(),
-									 &begin,
-									 &end,
+									 &begin, 
+									 &end, 
 									 0, 0 );
-			break;
+			break;			
 		}
-
+				
 	}
 
 	switch(argc-woptind)
 	{
 		case 0:
-		{
+		{					
 			write_part( begin, end, cut_at_cursor, tokenize );
 			break;
 		}
-
+		
 		case 1:
 		{
 			replace_part( begin, end, argv[woptind], append_mode );
 			break;
-		}
+		}		
 
 		default:
 		{
-			string_buffer_t sb;
+			wcstring sb = argv[woptind];
 			int i;
-
-			sb_init( &sb );
-
-			sb_append( &sb, argv[woptind] );
-
+			
 			for( i=woptind+1; i<argc; i++ )
 			{
-				sb_append( &sb, L"\n" );
-				sb_append( &sb, argv[i] );
+                sb.push_back(L'\n');
+                sb.append(argv[i]);
 			}
-
-			replace_part( begin, end, (wchar_t *)sb.buff, append_mode );
-			sb_destroy( &sb );
-
+			
+			replace_part( begin, end, sb.c_str(), append_mode );
+			
 			break;
-		}
+		}		
 	}
-
+	
 	return 0;
 }

builtin_complete.cpp

@@ -1,6 +1,6 @@
 /** \file builtin_complete.c Functions defining the complete builtin
 
-Functions used for implementing the complete builtin.
+Functions used for implementing the complete builtin. 
 
 */
 #include "config.h"
@@ -26,7 +26,7 @@ Functions used for implementing the complete builtin.
 
 
 /**
-   Internal storage for the builtin_get_temporary_buffer() function.
+   Internal storage for the builtin_complete_get_temporary_buffer() function.
 */
 static const wchar_t *temporary_buffer;
 
@@ -45,20 +45,20 @@ static const wchar_t *temporary_buffer;
 static void	builtin_complete_add2( const wchar_t *cmd,
 								   int cmd_type,
 								   const wchar_t *short_opt,
-								   array_list_t *gnu_opt,
-								   array_list_t *old_opt,
-								   int result_mode,
+								   const wcstring_list_t &gnu_opt,
+								   const wcstring_list_t &old_opt, 
+								   int result_mode, 
 								   const wchar_t *condition,
 								   const wchar_t *comp,
 								   const wchar_t *desc,
 								   int flags )
 {
-	int i;
+	size_t i;
 	const wchar_t *s;
-
+	
 	for( s=short_opt; *s; s++ )
 	{
-		complete_add( cmd,
+		complete_add( cmd, 
 					  cmd_type,
 					  *s,
 					  0,
@@ -69,13 +69,13 @@ static void	builtin_complete_add2( const wchar_t *cmd,
 					  desc,
 					  flags );
 	}
-
-	for( i=0; i<al_get_count( gnu_opt ); i++ )
+	
+	for( i=0; i<gnu_opt.size(); i++ )
 	{
-		complete_add( cmd,
+		complete_add( cmd, 
 					  cmd_type,
 					  0,
-					  (wchar_t *)al_get(gnu_opt, i ),
+					  gnu_opt.at(i).c_str(),
 					  0,
 					  result_mode,
 					  condition,
@@ -83,24 +83,24 @@ static void	builtin_complete_add2( const wchar_t *cmd,
 					  desc,
 					  flags );
 	}
-
-	for( i=0; i<al_get_count( old_opt ); i++ )
+	
+	for( i=0; i<old_opt.size(); i++ )
 	{
-		complete_add( cmd,
+		complete_add( cmd, 
 					  cmd_type,
 					  0,
-					  (wchar_t *)al_get(old_opt, i ),
+					  old_opt.at(i).c_str(),
 					  1,
 					  result_mode,
 					  condition,
 					  comp,
 					  desc,
 					  flags );
-	}
+	}	
 
-	if( al_get_count( old_opt )+al_get_count( gnu_opt )+wcslen(short_opt) == 0 )
+	if( old_opt.size() == 0 && gnu_opt.size() == 0 && wcslen(short_opt) == 0 )
 	{
-		complete_add( cmd,
+		complete_add( cmd, 
 					  cmd_type,
 					  0,
 					  0,
@@ -110,111 +110,107 @@ static void	builtin_complete_add2( const wchar_t *cmd,
 					  comp,
 					  desc,
 					  flags );
-	}
+	}	
 }
 
 /**
    Silly function
 */
-static void	builtin_complete_add( array_list_t *cmd,
-								  array_list_t *path,
+static void	builtin_complete_add( const wcstring_list_t &cmd, 
+								  const wcstring_list_t &path,
 								  const wchar_t *short_opt,
-								  array_list_t *gnu_opt,
-								  array_list_t *old_opt,
-								  int result_mode,
+								  wcstring_list_t &gnu_opt,
+								  wcstring_list_t &old_opt, 
+								  int result_mode, 
 								  int authoritative,
 								  const wchar_t *condition,
 								  const wchar_t *comp,
 								  const wchar_t *desc,
 								  int flags )
 {
-	int i;
-
-	for( i=0; i<al_get_count( cmd ); i++ )
+	for( size_t i=0; i<cmd.size(); i++ )
 	{
-		builtin_complete_add2( al_get( cmd, i ),
+		builtin_complete_add2( cmd.at(i).c_str(),
 							   COMMAND,
-							   short_opt,
+							   short_opt, 
 							   gnu_opt,
-							   old_opt,
-							   result_mode,
-							   condition,
-							   comp,
+							   old_opt, 
+							   result_mode, 
+							   condition, 
+							   comp, 
 							   desc,
 							   flags );
 
 		if( authoritative != -1 )
 		{
-			complete_set_authoritative( al_get( cmd, i ),
+			complete_set_authoritative( cmd.at(i).c_str(),
 									  COMMAND,
 									  authoritative );
 		}
-
+		
 	}
-
-	for( i=0; i<al_get_count( path ); i++ )
+	
+	for( size_t i=0; i<path.size(); i++ )
 	{
-		builtin_complete_add2( al_get( path, i ),
+		builtin_complete_add2( path.at(i).c_str(),
 							   PATH,
-							   short_opt,
+							   short_opt, 
 							   gnu_opt,
-							   old_opt,
-							   result_mode,
-							   condition,
-							   comp,
+							   old_opt, 
+							   result_mode, 
+							   condition, 
+							   comp, 
 							   desc,
 							   flags );
 
 		if( authoritative != -1 )
 		{
-			complete_set_authoritative( al_get( path, i ),
+			complete_set_authoritative( path.at(i).c_str(),
 									  PATH,
 									  authoritative );
 		}
-
-	}
+		
+	}	
 }
 
 /**
    Silly function
 */
-static void builtin_complete_remove3( wchar_t *cmd,
+static void builtin_complete_remove3( const wchar_t *cmd,
 									  int cmd_type,
 									  wchar_t short_opt,
-									  array_list_t *long_opt )
+									  const wcstring_list_t &long_opt )
 {
-	int i;
-
-	for( i=0; i<al_get_count( long_opt ); i++ )
+	for( size_t i=0; i<long_opt.size(); i++ )
 	{
 		complete_remove( cmd,
 						 cmd_type,
 						 short_opt,
-						 (wchar_t *)al_get( long_opt, i ) );
-	}
+						 long_opt.at(i).c_str());
+	}	
 }
 
 /**
    Silly function
 */
-static void	builtin_complete_remove2( wchar_t *cmd,
+static void	builtin_complete_remove2( const wchar_t *cmd,
 									  int cmd_type,
 									  const wchar_t *short_opt,
-									  array_list_t *gnu_opt,
-									  array_list_t *old_opt )
+									  const wcstring_list_t &gnu_opt,
+									  const wcstring_list_t &old_opt )
 {
 	const wchar_t *s = (wchar_t *)short_opt;
 	if( *s )
 	{
 		for( ; *s; s++ )
 		{
-			if( al_get_count( old_opt) + al_get_count( gnu_opt ) == 0 )
+			if( old_opt.size() == 0 && gnu_opt.size() == 0 )
 			{
 				complete_remove(cmd,
 								cmd_type,
 								*s,
 								0 );
-
+				
 			}
 			else
 			{
@@ -239,47 +235,45 @@ static void	builtin_complete_remove2( wchar_t *cmd,
 								  cmd_type,
 								  0,
 								  old_opt );
+										  
+	}				
 
-	}
-
-
+	
 }
 
 /**
    Silly function
 */
-static void	builtin_complete_remove( array_list_t *cmd,
-									 array_list_t *path,
+static void	builtin_complete_remove( const wcstring_list_t &cmd, 
+									 const wcstring_list_t &path,
 									 const wchar_t *short_opt,
-									 array_list_t *gnu_opt,
-									 array_list_t *old_opt )
-{
-
-	int i;
-
-	for( i=0; i<al_get_count( cmd ); i++ )
+									 const wcstring_list_t &gnu_opt,
+									 const wcstring_list_t &old_opt )
+{	
+	for( size_t i=0; i<cmd.size(); i++ )
 	{
-		builtin_complete_remove2( (wchar_t *)al_get( cmd, i ),
+		builtin_complete_remove2( cmd.at(i).c_str(),
 								  COMMAND,
-								  short_opt,
+								  short_opt, 
 								  gnu_opt,
 								  old_opt );
 	}
-
-	for( i=0; i<al_get_count( path ); i++ )
+	
+	for( size_t i=0; i<path.size(); i++ )
 	{
-		builtin_complete_remove2( (wchar_t *)al_get( path, i ),
+		builtin_complete_remove2( path.at(i).c_str(),
 								  PATH,
-								  short_opt,
+								  short_opt, 
 								  gnu_opt,
 								  old_opt );
 	}
-
+	
 }
 
 
 const wchar_t *builtin_complete_get_temporary_buffer()
 {
+    ASSERT_IS_MAIN_THREAD();
 	return temporary_buffer;
 }
 
@@ -288,63 +282,59 @@ const wchar_t *builtin_complete_get_temporary_buffer()
    tab-completions. Calls the functions in complete.c for any heavy
    lifting. Defined in builtin_complete.c
 */
-static int builtin_complete( wchar_t **argv )
+static int builtin_complete( parser_t &parser, wchar_t **argv )
 {
-	int res=0;
+    ASSERT_IS_MAIN_THREAD();
+	bool res=false;
 	int argc=0;
 	int result_mode=SHARED;
 	int remove = 0;
 	int authoritative = -1;
 	int flags = COMPLETE_AUTO_SPACE;
+	
+	wcstring short_opt;
+	wcstring_list_t gnu_opt, old_opt;
+	const wchar_t *comp=L"", *desc=L"", *condition=L"";
 
-	string_buffer_t short_opt;
-	array_list_t gnu_opt, old_opt;
-	wchar_t *comp=L"", *desc=L"", *condition=L"";
-
-	wchar_t *do_complete = 0;
-
-	array_list_t cmd;
-	array_list_t path;
+    bool do_complete = false;
+    wcstring do_complete_param;
+	
+	wcstring_list_t cmd;
+	wcstring_list_t path;
 
 	static int recursion_level=0;
-
-	al_init( &cmd );
-	al_init( &path );
-	sb_init( &short_opt );
-	al_init( &gnu_opt );
-	al_init( &old_opt );
-
-	argc = builtin_count_args( argv );
-
+	
+	argc = builtin_count_args( argv );	
+	
 	woptind=0;
-
-	while( res == 0 )
+	
+	while( ! res )
 	{
 		static const struct woption
 			long_options[] =
 			{
 				{
-					L"exclusive", no_argument, 0, 'x'
+					L"exclusive", no_argument, 0, 'x' 
 				}
 				,
 				{
-					L"no-files", no_argument, 0, 'f'
+					L"no-files", no_argument, 0, 'f' 
 				}
 				,
 				{
-					L"require-parameter", no_argument, 0, 'r'
+					L"require-parameter", no_argument, 0, 'r' 
 				}
 				,
 				{
 					L"path", required_argument, 0, 'p'
 				}
-				,
+				,					
 				{
-					L"command", required_argument, 0, 'c'
+					L"command", required_argument, 0, 'c' 
 				}
-				,
+				,					
 				{
-					L"short-option", required_argument, 0, 's'
+					L"short-option", required_argument, 0, 's' 
 				}
 				,
 				{
@@ -352,7 +342,7 @@ static int builtin_complete( wchar_t **argv )
 				}
 				,
 				{
-					L"old-option", required_argument, 0, 'o'
+					L"old-option", required_argument, 0, 'o' 
 				}
 				,
 				{
@@ -387,93 +377,96 @@ static int builtin_complete( wchar_t **argv )
 					L"help", no_argument, 0, 'h'
 				}
 				,
-				{
-					0, 0, 0, 0
+				{ 
+					0, 0, 0, 0 
 				}
 			}
-		;
-
+		;		
+		
 		int opt_index = 0;
-
+		
 		int opt = wgetopt_long( argc,
-								argv,
-								L"a:c:p:s:l:o:d:frxeuAn:C::h",
-								long_options,
+								argv, 
+								L"a:c:p:s:l:o:d:frxeuAn:C::h", 
+								long_options, 
 								&opt_index );
 		if( opt == -1 )
 			break;
-
+			
 		switch( opt )
 		{
 			case 0:
 				if(long_options[opt_index].flag != 0)
 					break;
-                sb_printf( sb_err,
+                append_format(stderr_buffer,
                            BUILTIN_ERR_UNKNOWN,
                            argv[0],
                            long_options[opt_index].name );
-				builtin_print_help( argv[0], sb_err );
+				builtin_print_help( parser, argv[0], stderr_buffer );
 
-
-				res = 1;
+				
+				res = true;
 				break;
-
-			case 'x':
+				
+			case 'x':					
 				result_mode |= EXCLUSIVE;
 				break;
-
-			case 'f':
+					
+			case 'f':					
 				result_mode |= NO_FILES;
 				break;
-
-			case 'r':
+				
+			case 'r':					
 				result_mode |= NO_COMMON;
 				break;
-
-			case 'p':
+					
+			case 'p':	
 			case 'c':
 			{
-				wchar_t *a = unescape( woptarg, 1);
-				if( a )
+                wcstring tmp = woptarg;
+                if (unescape_string(tmp, 1))
 				{
-					al_push( (opt=='p'?&path:&cmd), a );
+                    if (opt=='p')
+                        path.push_back(tmp);
+                    else
+                        cmd.push_back(tmp);
 				}
 				else
 				{
-					sb_printf( sb_err, L"%ls: Invalid token '%ls'\n", argv[0], woptarg );
-					res = 1;
-				}
+					append_format(stderr_buffer, L"%ls: Invalid token '%ls'\n", argv[0], woptarg );
+					res = true;					
+				}				
 				break;
 			}
-
+				
 			case 'd':
 				desc = woptarg;
 				break;
-
+				
 			case 'u':
 				authoritative=0;
 				break;
-
+				
 			case 'A':
 				authoritative=1;
 				break;
-
+				
 			case 's':
-				sb_append( &short_opt, woptarg );
+                short_opt.append(woptarg);
 				break;
-
+					
 			case 'l':
-				al_push( &gnu_opt, woptarg );
+                gnu_opt.push_back(woptarg);
 				break;
-
+				
 			case 'o':
-				al_push( &old_opt, woptarg );
+                old_opt.push_back(woptarg);
 				break;
 
 			case 'a':
 				comp = woptarg;
 				break;
-
+				
 			case 'e':
 				remove = 1;
 				break;
@@ -481,56 +474,57 @@ static int builtin_complete( wchar_t **argv )
 			case 'n':
 				condition = woptarg;
 				break;
-
+				
 			case 'C':
-				do_complete = woptarg?woptarg:reader_get_buffer();
+                do_complete = true;
+				do_complete_param = woptarg ? woptarg : reader_get_buffer();
 				break;
-
+				
 			case 'h':
-				builtin_print_help( argv[0], sb_out );
+				builtin_print_help( parser, argv[0], stdout_buffer );
 				return 0;
-
+				
 			case '?':
-				builtin_unknown_option( argv[0], argv[woptind-1] );
-				res = 1;
+				builtin_unknown_option( parser, argv[0], argv[woptind-1] );
+				res = true;
 				break;
-
+				
 		}
-
+		
 	}
 
 	if( !res )
 	{
 		if( condition && wcslen( condition ) )
 		{
-			if( parser_test( condition, 0, 0, 0 ) )
+			if( parser.test( condition, 0, 0, 0 ) )
 			{
-				sb_printf( sb_err,
-						   L"%ls: Condition '%ls' contained a syntax error\n",
+				append_format(stderr_buffer,
+						   L"%ls: Condition '%ls' contained a syntax error\n", 
 						   argv[0],
 						   condition );
-
-				parser_test( condition, 0, sb_err, argv[0] );
-
-				res = 1;
+				
+				parser.test( condition, 0, &stderr_buffer, argv[0] );
+				
+				res = true;
 			}
 		}
 	}
-
+	
 	if( !res )
 	{
 		if( comp && wcslen( comp ) )
 		{
-			if( parser_test_args( comp, 0, 0 ) )
+			if( parser.test_args( comp, 0, 0 ) )
 			{
-				sb_printf( sb_err,
-						   L"%ls: Completion '%ls' contained a syntax error\n",
+				append_format(stderr_buffer,
+						   L"%ls: Completion '%ls' contained a syntax error\n", 
 						   argv[0],
 						   comp );
-
-				parser_test_args( comp, sb_err, argv[0] );
-
-				res = 1;
+				
+				parser.test_args( comp, &stderr_buffer, argv[0] );
+				
+				res = true;
 			}
 		}
 	}
@@ -539,31 +533,27 @@ static int builtin_complete( wchar_t **argv )
 	{
 		if( do_complete )
 		{
-			array_list_t *comp;
-			int i;
+			const wchar_t *token;
 
+			parse_util_token_extent( do_complete_param.c_str(), do_complete_param.size(), &token, 0, 0, 0 );
+						
 			const wchar_t *prev_temporary_buffer = temporary_buffer;
-
-			wchar_t *token;
-
-			parse_util_token_extent( do_complete, wcslen( do_complete ), &token, 0, 0, 0 );
-
-			temporary_buffer = do_complete;
+			temporary_buffer = do_complete_param.c_str();
 
 			if( recursion_level < 1 )
 			{
 				recursion_level++;
-
-				comp = al_halloc( 0 );
-
-				complete( do_complete, comp );
-
-				for( i=0; i<al_get_count( comp ); i++ )
+                
+                std::vector<completion_t> comp;
+				complete( do_complete_param, comp, COMPLETE_DEFAULT );
+			
+				for( size_t i=0; i< comp.size() ; i++ )
 				{
-					completion_t *next = (completion_t *)al_get( comp, i );
-					wchar_t *prepend;
+					const completion_t &next =  comp.at( i );
 
-					if( next->flags & COMPLETE_NO_CASE )
+					const wchar_t *prepend;
+					
+					if( next.flags & COMPLETE_NO_CASE )
 					{
 						prepend = L"";
 					}
@@ -571,76 +561,66 @@ static int builtin_complete( wchar_t **argv )
 					{
 						prepend = token;
 					}
+						
 
-
-					if( next->description )
+					if( !(next.description).empty() )
 					{
-						sb_printf( sb_out, L"%ls%ls\t%ls\n", prepend, next->completion, next->description );
+						append_format(stdout_buffer, L"%ls%ls\t%ls\n", prepend, next.completion.c_str(), next.description.c_str() );
 					}
 					else
 					{
-						sb_printf( sb_out, L"%ls%ls\n", prepend, next->completion );
+						append_format(stdout_buffer, L"%ls%ls\n", prepend, next.completion.c_str() );
 					}
 				}
-
-				halloc_free( comp );
+			
 				recursion_level--;
 			}
-
-			temporary_buffer = prev_temporary_buffer;
-
+		
+			temporary_buffer = prev_temporary_buffer;		
+		
 		}
 		else if( woptind != argc )
 		{
-			sb_printf( sb_err,
+			append_format(stderr_buffer, 
 					   _( L"%ls: Too many arguments\n" ),
 					   argv[0] );
-			builtin_print_help( argv[0], sb_err );
+			builtin_print_help( parser, argv[0], stderr_buffer );
 
-			res = 1;
+			res = true;
 		}
-		else if( (al_get_count( &cmd) == 0 ) && (al_get_count( &path) == 0 ) )
+		else if( cmd.empty() && path.empty() )
 		{
 			/* No arguments specified, meaning we print the definitions of
 			 * all specified completions to stdout.*/
-			complete_print( sb_out );
+			complete_print( stdout_buffer );		
 		}
 		else
 		{
 			if( remove )
 			{
-				builtin_complete_remove( &cmd,
-										 &path,
-										 (wchar_t *)short_opt.buff,
-										 &gnu_opt,
-										 &old_opt );
+				builtin_complete_remove( cmd,
+										 path,
+										 short_opt.c_str(),
+										 gnu_opt,
+										 old_opt );									 
 			}
 			else
 			{
-				builtin_complete_add( &cmd,
-									  &path,
-									  (wchar_t *)short_opt.buff,
-									  &gnu_opt,
-									  &old_opt,
-									  result_mode,
+				builtin_complete_add( cmd, 
+									  path,
+									  short_opt.c_str(),
+									  gnu_opt,
+									  old_opt, 
+									  result_mode, 
 									  authoritative,
 									  condition,
 									  comp,
 									  desc,
-									  flags );
+									  flags ); 
 			}
 
-		}
+		}	
 	}
-
-	al_foreach( &cmd, &free );
-	al_foreach( &path, &free );
-
-	al_destroy( &cmd );
-	al_destroy( &path );
-	sb_destroy( &short_opt );
-	al_destroy( &gnu_opt );
-	al_destroy( &old_opt );
-
-	return res;
+	
+	return res ? 1 : 0;
 }

builtin_jobs.cpp

@@ -43,7 +43,7 @@ enum
 /**
    Calculates the cpu usage (in percent) of the specified job.
 */
-static int cpu_use( job_t *j )
+static int cpu_use( const job_t *j )
 {
 	double u=0;
 	process_t *p;
@@ -71,7 +71,7 @@ static int cpu_use( job_t *j )
 /**
    Print information about the specified job
 */
-static void builtin_jobs_print( job_t *j, int mode, int header )
+static void builtin_jobs_print( const job_t *j, int mode, int header )
 {
 	process_t *p;
 	switch( mode )
@@ -84,24 +84,22 @@ static void builtin_jobs_print( job_t *j, int mode, int header )
 				/*
 				  Print table header before first job
 				*/
-				sb_append( sb_out, _( L"Job\tGroup\t" ));
+				stdout_buffer.append( _( L"Job\tGroup\t" ));
 #ifdef HAVE__PROC_SELF_STAT
-				sb_append( sb_out, _( L"CPU\t" ) );
+				stdout_buffer.append( _( L"CPU\t" ) );
 #endif
-				sb_append( sb_out, _( L"State\tCommand\n" ) );
+				stdout_buffer.append( _( L"State\tCommand\n" ) );
 			}
 
-			sb_printf( sb_out, L"%d\t%d\t", j->job_id, j->pgid );
+			append_format(stdout_buffer, L"%d\t%d\t", j->job_id, j->pgid );
 
 #ifdef HAVE__PROC_SELF_STAT
-			sb_printf( sb_out, L"%d%%\t", cpu_use(j) );
+			append_format(stdout_buffer, L"%d%%\t", cpu_use(j) );
 #endif
-			sb_append( sb_out,
-						job_is_stopped(j)?_(L"stopped"):_(L"running"),
-						L"\t",
-						j->command,
-						L"\n",
-						(void *)0 );
+			stdout_buffer.append(job_is_stopped(j)?_(L"stopped"):_(L"running"));
+            stdout_buffer.append(L"\t");
+            stdout_buffer.append(j->command_wcstr());
+            stdout_buffer.append(L"\n");
 			break;
 		}
 
@@ -112,9 +110,9 @@ static void builtin_jobs_print( job_t *j, int mode, int header )
 				/*
 				  Print table header before first job
 				*/
-				sb_append( sb_out, _( L"Group\n" ));
+				stdout_buffer.append( _( L"Group\n" ));
 			}
-			sb_printf( sb_out, L"%d\n", j->pgid );
+			append_format(stdout_buffer, L"%d\n", j->pgid );
 			break;
 		}
 
@@ -125,12 +123,12 @@ static void builtin_jobs_print( job_t *j, int mode, int header )
 				/*
 				  Print table header before first job
 				*/
-				sb_append( sb_out, _( L"Procces\n" ));
+				stdout_buffer.append( _( L"Procces\n" ));
 			}
 
 			for( p=j->first_process; p; p=p->next )
 			{
-				sb_printf( sb_out, L"%d\n", p->pid );
+				append_format(stdout_buffer, L"%d\n", p->pid );
 			}
 			break;
 		}
@@ -142,12 +140,12 @@ static void builtin_jobs_print( job_t *j, int mode, int header )
 				/*
 				  Print table header before first job
 				*/
-				sb_append( sb_out, _( L"Command\n" ));
+				stdout_buffer.append( _( L"Command\n" ));
 			}
 
 			for( p=j->first_process; p; p=p->next )
 			{
-				sb_printf( sb_out, L"%ls\n", p->argv[0] );
+				append_format(stdout_buffer, L"%ls\n", p->argv0() );
 			}
 			break;
 		}
@@ -160,13 +158,13 @@ static void builtin_jobs_print( job_t *j, int mode, int header )
 /**
    The jobs builtin. Used fopr printing running jobs. Defined in builtin_jobs.c.
 */
-static int builtin_jobs( wchar_t **argv )
+static int builtin_jobs( parser_t &parser, wchar_t **argv )
 {
 	int argc=0;
 	int found=0;
 	int mode=JOBS_DEFAULT;
 	int print_last = 0;
-	job_t *j;
+	const job_t *j;
 
 	argc = builtin_count_args( argv );
 	woptind=0;
@@ -217,12 +215,12 @@ static int builtin_jobs( wchar_t **argv )
 			case 0:
 				if(long_options[opt_index].flag != 0)
 					break;
-                sb_printf( sb_err,
+                append_format(stderr_buffer,
                            BUILTIN_ERR_UNKNOWN,
                            argv[0],
                            long_options[opt_index].name );
 
-				builtin_print_help( argv[0], sb_err );
+				builtin_print_help( parser, argv[0], stderr_buffer );
 
 
 				return 1;
@@ -247,11 +245,11 @@ static int builtin_jobs( wchar_t **argv )
 			}
 
 			case 'h':
-				builtin_print_help( argv[0], sb_out );
-				return 0;
+				builtin_print_help( parser, argv[0], stdout_buffer );
+				return 0;				
 
 			case '?':
-				builtin_unknown_option( argv[0], argv[woptind-1] );
+				builtin_unknown_option( parser, argv[0], argv[woptind-1] );
 				return 1;
 
 		}
@@ -271,8 +269,11 @@ static int builtin_jobs( wchar_t **argv )
 		/*
 		  Ignore unconstructed jobs, i.e. ourself.
 		*/
-		for( j=first_job; j; j=j->next )
+        job_iterator_t jobs;
+        const job_t *j;
+        while ((j = jobs.next()))
 		{
+            
 			if( (j->flags & JOB_CONSTRUCTED) && !job_is_completed(j) )
 			{
 				builtin_jobs_print( j, mode, !found );
@@ -291,13 +292,13 @@ static int builtin_jobs( wchar_t **argv )
 
 			for( i=woptind; i<argc; i++ )
 			{
-				long pid;
+				int pid;
 				wchar_t *end;
 				errno=0;
-				pid=wcstol( argv[i], &end, 10 );
+				pid=fish_wcstoi( argv[i], &end, 10 );
 				if( errno || *end )
 				{
-					sb_printf( sb_err,
+					append_format(stderr_buffer,
 							   _( L"%ls: '%ls' is not a job\n" ),
 							   argv[0],
 							   argv[i] );
@@ -312,7 +313,7 @@ static int builtin_jobs( wchar_t **argv )
 				}
 				else
 				{
-					sb_printf( sb_err,
+					append_format(stderr_buffer,
 							   _( L"%ls: No suitable job: %d\n" ),
 							   argv[0],
 							   pid );
@@ -322,8 +323,10 @@ static int builtin_jobs( wchar_t **argv )
 		}
 		else
 		{
-			for( j= first_job; j; j=j->next )
-			{
+            job_iterator_t jobs;
+            const job_t *j;
+            while ((j = jobs.next()))
+            {
 				/*
 				  Ignore unconstructed jobs, i.e. ourself.
 				*/
@@ -338,7 +341,7 @@ static int builtin_jobs( wchar_t **argv )
 
 	if( !found )
 	{
-		sb_printf( sb_out,
+		append_format(stdout_buffer,
 				   _( L"%ls: There are no jobs\n" ),
 				   argv[0] );
 	}

builtin_set.c

@@ -1,879 +0,0 @@
-/** \file builtin_set.c Functions defining the set builtin
-
-Functions used for implementing the set builtin.
-
-*/
-#include "config.h"
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <wchar.h>
-#include <wctype.h>
-#include <sys/types.h>
-#include <termios.h>
-#include <signal.h>
-
-#include "fallback.h"
-#include "util.h"
-
-#include "wutil.h"
-#include "builtin.h"
-#include "env.h"
-#include "expand.h"
-#include "common.h"
-#include "wgetopt.h"
-#include "proc.h"
-#include "parser.h"
-
-
-/**
-   Error message for invalid path operations
-*/
-#define BUILTIN_SET_PATH_ERROR L"%ls: Could not add component %ls to %ls.\n"
-
-/**
-   Hint for invalid path operation with a colon
-*/
-#define BUILTIN_SET_PATH_HINT L"%ls: Did you mean 'set %ls $%ls %ls'?\n"
-
-/**
-   Error for mismatch between index count and elements
-*/
-#define BUILTIN_SET_ARG_COUNT L"%ls: The number of variable indexes does not match the number of values\n"
-
-/**
-   Test if the specified variable should be subject to path validation
-*/
-static int is_path_variable( const wchar_t *env )
-{
-	return contains( env,
-						 L"PATH",
-						 L"CDPATH" );
-}
-
-/**
-   Call env_set. If this is a path variable, e.g. PATH, validate the
-   elements. On error, print a description of the problem to stderr.
-*/
-static int my_env_set( const wchar_t *key, array_list_t *val, int scope )
-{
-	string_buffer_t sb;
-	int i;
-	int retcode = 0;
-	wchar_t *val_str=0;
-
-	if( is_path_variable( key ) )
-	{
-		int error = 0;
-
-		for( i=0; i<al_get_count( val ); i++ )
-		{
-			int show_perror = 0;
-			int show_hint = 0;
-
-			struct stat buff;
-			wchar_t *dir = (wchar_t *)al_get( val, i );
-
-			if( wstat( dir, &buff ) )
-			{
-				error = 1;
-				show_perror = 1;
-			}
-
-			if( !( S_ISDIR(buff.st_mode) ) )
-			{
-				error = 1;
-
-			}
-
-			if( error )
-			{
-				wchar_t *colon;
-
-				sb_printf( sb_err,
-						   _(BUILTIN_SET_PATH_ERROR),
-						   L"set",
-						   dir,
-						   key );
-
-				colon = wcschr( dir, L':' );
-
-				if( colon && *(colon+1) )
-				{
-					show_hint = 1;
-				}
-
-			}
-
-			if( show_perror )
-			{
-				builtin_wperror( L"set" );
-			}
-
-			if( show_hint )
-			{
-				sb_printf( sb_err,
-						   _(BUILTIN_SET_PATH_HINT),
-						   L"set",
-						   key,
-						   key,
-						   wcschr( dir, L':' )+1);
-			}
-
-			if( error )
-			{
-				break;
-			}
-
-		}
-
-		if( error )
-		{
-			return 1;
-		}
-
-	}
-
-	sb_init( &sb );
-
-	if( al_get_count( val ) )
-	{
-		for( i=0; i<al_get_count( val ); i++ )
-		{
-			wchar_t *next =(wchar_t *)al_get( val, i );
-			sb_append( &sb, next?next:L"" );
-			if( i<al_get_count( val )-1 )
-			{
-				sb_append( &sb, ARRAY_SEP_STR );
-			}
-		}
-		val_str = (wchar_t *)sb.buff;
-
-	}
-
-	switch( env_set( key, val_str, scope | ENV_USER ) )
-	{
-		case ENV_PERM:
-		{
-			sb_printf( sb_err, _(L"%ls: Tried to change the read-only variable '%ls'\n"), L"set", key );
-			retcode=1;
-			break;
-		}
-
-		case ENV_INVALID:
-		{
-			sb_printf( sb_err, _(L"%ls: Unknown error"), L"set" );
-			retcode=1;
-			break;
-		}
-	}
-
-	sb_destroy( &sb );
-
-	return retcode;
-}
-
-/**
-	Extract indexes from a destination argument of the form name[index1 index2...]
-
-	\param indexes the list to insert the new indexes into
-	\param src the source string to parse
-	\param name the name of the element. Return null if the name in \c src does not match this name
-	\param var_count the number of elements in the array to parse.
-
-	\return the total number of indexes parsed, or -1 on error
-*/
-static int parse_index( array_list_t *indexes,
-						const wchar_t *src,
-						const wchar_t *name,
-						int var_count )
-{
-	int len;
-
-	int count = 0;
-	const wchar_t *src_orig = src;
-
-	if (src == 0)
-	{
-		return 0;
-	}
-
-	while (*src != L'\0' && (iswalnum(*src) || *src == L'_'))
-	{
-		src++;
-	}
-
-	if (*src != L'[')
-	{
-		sb_printf( sb_err, _(BUILTIN_SET_ARG_COUNT), L"set" );
-		return 0;
-	}
-
-	len = src-src_orig;
-
-	if( (wcsncmp( src_orig, name, len )!=0) || (wcslen(name) != (len)) )
-	{
-		sb_printf( sb_err,
-				   _(L"%ls: Multiple variable names specified in single call (%ls and %.*ls)\n"),
-				   L"set",
-				   name,
-				   len,
-				   src_orig);
-		return 0;
-	}
-
-	src++;
-
-	while (iswspace(*src))
-	{
-		src++;
-	}
-
-	while (*src != L']')
-	{
-		wchar_t *end;
-
-		long l_ind;
-
-		errno = 0;
-
-		l_ind = wcstol(src, &end, 10);
-
-		if( end==src || errno )
-		{
-			sb_printf(sb_err, _(L"%ls: Invalid index starting at '%ls'\n"), L"set", src);
-			return 0;
-		}
-
-		if( l_ind < 0 )
-		{
-			l_ind = var_count+l_ind+1;
-		}
-
-		al_push_long(indexes, l_ind);
-		src = end;
-		count++;
-		while (iswspace(*src)) src++;
-	}
-
-	return count;
-}
-
-
-/**
-   Update a list \c list by writing copies (using wcsdup) of the
-   values specified by \c values to the indexes specified by \c
-   indexes. The previous entries at the specidied position will be
-   free'd.
-
-   \return 0 if the operation was successfull, non-zero otherwise
-*/
-static int update_values( array_list_t *list,
-						  array_list_t *indexes,
-						  array_list_t *values )
-{
-	int i;
-
-	/* Replace values where needed */
-	for( i = 0; i < al_get_count(indexes); i++ )
-	{
-		/*
-		  The '- 1' below is because the indices in fish are
-		  one-based, but the array_list_t uses zero-based indices
-		*/
-		long ind = al_get_long(indexes, i) - 1;
-		void *new = (void *) al_get(values, i);
-		if( ind < 0 )
-		{
-			return 1;
-		}
-
-		free((void *) al_get(list, ind));
-		al_set(list, ind, new != 0 ? wcsdup(new) : wcsdup(L""));
-	}
-
-	return 0;
-}
-
-
-/**
-   Return 1 if an array list of longs contains the specified
-   value, 0 otherwise
-*/
-static int al_contains_long( array_list_t *list,
-							long val)
-{
-	int i;
-
-	for (i = 0; i < al_get_count(list); i++)
-	{
-		long current = al_get_long(list, i);
-		if( current != 0 && current == val )
-		{
-			return 1;
-		}
-	}
-
-	return 0;
-}
-
-
-/**
-   Erase from a list values at specified indexes
-*/
-static void erase_values(array_list_t *list, array_list_t *indexes)
-{
-	long i;
-	array_list_t result;
-
-	al_init(&result);
-
-	for (i = 0; i < al_get_count(list); i++)
-	{
-		if (!al_contains_long(indexes, i + 1))
-		{
-			al_push(&result, al_get(list, i));
-		}
-		else
-		{
-			free( (void *)al_get(list, i));
-		}
-	}
-
-	al_truncate(list,0);
-	al_push_all( list, &result );
-	al_destroy(&result);
-}
-
-
-/**
-   Print the names of all environment variables in the scope, with or without values,
-   with or without escaping
-*/
-static void print_variables(int include_values, int esc, int scope)
-{
-	array_list_t names;
-	int i;
-
-	al_init( &names );
-	env_get_names( &names, scope );
-
-	sort_list( &names );
-
-	for( i = 0; i < al_get_count(&names); i++ )
-	{
-		wchar_t *key = (wchar_t *)al_get( &names, i );
-		wchar_t *e_key = esc ? escape(key, 0) : wcsdup(key);
-
-		sb_append(sb_out, e_key);
-
-		if( include_values )
-		{
-			wchar_t *value = env_get(key);
-			wchar_t *e_value;
-			if( value )
-			{
-				int shorten = 0;
-
-				if( wcslen( value ) > 64 )
-				{
-					shorten = 1;
-					value = wcsndup( value, 60 );
-					if( !value )
-					{
-						DIE_MEM();
-					}
-				}
-
-				e_value = esc ? expand_escape_variable(value) : wcsdup(value);
-
-				sb_append(sb_out, L" ", e_value, (void *)0);
-				free(e_value);
-
-				if( shorten )
-				{
-					sb_append(sb_out, L"\u2026");
-					free( value );
-				}
-
-			}
-		}
-
-		sb_append(sb_out, L"\n");
-		free(e_key);
-	}
-  	al_destroy(&names);
-}
-
-
-
-/**
-   The set builtin. Creates, updates and erases environment variables
-   and environemnt variable arrays.
-*/
-static int builtin_set( wchar_t **argv )
-{
-
-	/**
-	   Variables used for parsing the argument list
-	*/
-	static const struct woption
-		long_options[] =
-		{
-			{
-				L"export", no_argument, 0, 'x'
-			}
-			,
-			{
-				L"global", no_argument, 0, 'g'
-			}
-			,
-			{
-				L"local", no_argument, 0, 'l'
-			}
-			,
-			{
-				L"erase", no_argument, 0, 'e'
-			}
-			,
-			{
-				L"names", no_argument, 0, 'n'
-			}
-			,
-			{
-				L"unexport", no_argument, 0, 'u'
-			}
-			,
-			{
-				L"universal", no_argument, 0, 'U'
-			}
-			,
-			{
-				L"query", no_argument, 0, 'q'
-			}
-			,
-			{
-				L"help", no_argument, 0, 'h'
-			}
-			,
-			{
-				0, 0, 0, 0
-			}
-		}
-	;
-
-	const wchar_t *short_options = L"+xglenuUqh";
-
-	int argc = builtin_count_args(argv);
-
-	/*
-	  Flags to set the work mode
-	*/
-	int local = 0, global = 0, export = 0;
-	int erase = 0, list = 0, unexport=0;
-	int universal = 0, query=0;
-
-
-	/*
-	  Variables used for performing the actual work
-	*/
-	wchar_t *dest = 0;
-	int retcode=0;
-	int scope;
-	int slice=0;
-	int i;
-
-	wchar_t *bad_char;
-
-
-	/* Parse options to obtain the requested operation and the modifiers */
-	woptind = 0;
-	while (1)
-	{
-		int c = wgetopt_long(argc, argv, short_options, long_options, 0);
-
-		if (c == -1)
-		{
-			break;
-		}
-
-		switch(c)
-		{
-			case 0:
-				break;
-
-			case 'e':
-				erase = 1;
-				break;
-
-			case 'n':
-				list = 1;
-				break;
-
-			case 'x':
-				export = 1;
-				break;
-
-			case 'l':
-				local = 1;
-				break;
-
-			case 'g':
-				global = 1;
-				break;
-
-			case 'u':
-				unexport = 1;
-				break;
-
-			case 'U':
-				universal = 1;
-				break;
-
-			case 'q':
-				query = 1;
-				break;
-
-			case 'h':
-				builtin_print_help( argv[0], sb_out );
-				return 0;
-
-			case '?':
-				builtin_unknown_option( argv[0], argv[woptind-1] );
-				return 1;
-
-			default:
-				break;
-		}
-	}
-
-	/*
-	  Ok, all arguments have been parsed, let's validate them
-	*/
-
-	/*
-	  If we are checking the existance of a variable (-q) we can not
-	  also specify scope
-	*/
-
-	if( query && (erase || list || global || local || universal || export || unexport ) )
-	{
-		sb_printf(sb_err,
-				  BUILTIN_ERR_COMBO,
-				  argv[0] );
-
-		builtin_print_help( argv[0], sb_err );
-		return 1;
-	}
-
-
-	/* We can't both list and erase varaibles */
-	if( erase && list )
-	{
-		sb_printf(sb_err,
-				  BUILTIN_ERR_COMBO,
-				  argv[0] );
-
-		builtin_print_help( argv[0], sb_err );
-		return 1;
-	}
-
-	/*
-	  Variables can only have one scope
-	*/
-	if( local + global + universal > 1 )
-	{
-		sb_printf( sb_err,
-				   BUILTIN_ERR_GLOCAL,
-				   argv[0] );
-		builtin_print_help( argv[0], sb_err );
-		return 1;
-	}
-
-	/*
-	  Variables can only have one export status
-	*/
-	if( export && unexport )
-	{
-		sb_printf( sb_err,
-				   BUILTIN_ERR_EXPUNEXP,
-				   argv[0] );
-		builtin_print_help( argv[0], sb_err );
-		return 1;
-	}
-
-	/*
-	  Calculate the scope value for variable assignement
-	*/
-	scope = (local ? ENV_LOCAL : 0) | (global ? ENV_GLOBAL : 0) | (export ? ENV_EXPORT : 0) | (unexport ? ENV_UNEXPORT : 0) | (universal ? ENV_UNIVERSAL:0) | ENV_USER;
-
-	if( query )
-	{
-		/*
-		  Query mode. Return the number of variables that do not exist
-		  out of the specified variables.
-		*/
-		int i;
-		for( i=woptind; i<argc; i++ )
-		{
-			wchar_t *arg = argv[i];
-			int slice=0;
-
-			if( !(dest = wcsdup(arg)))
-			{
-				DIE_MEM();
-			}
-
-			if( wcschr( dest, L'[' ) )
-			{
-				slice = 1;
-				*wcschr( dest, L'[' )=0;
-			}
-
-			if( slice )
-			{
-				array_list_t indexes;
-				array_list_t result;
-				int j;
-
-				al_init( &result );
-				al_init( &indexes );
-
-				tokenize_variable_array( env_get( dest ), &result );
-
-				if( !parse_index( &indexes, arg, dest, al_get_count( &result ) ) )
-				{
-					builtin_print_help( argv[0], sb_err );
-					retcode = 1;
-					break;
-				}
-				for( j=0; j<al_get_count( &indexes ); j++ )
-				{
-					long idx = al_get_long( &indexes, j );
-					if( idx < 1 || idx > al_get_count( &result ) )
-					{
-						retcode++;
-					}
-				}
-			}
-			else
-			{
-				if( !env_exist( arg, scope ) )
-				{
-					retcode++;
-				}
-			}
-
-			free( dest );
-
-		}
-		return retcode;
-	}
-
-	if( list )
-	{
-		/* Maybe we should issue an error if there are any other arguments? */
-		print_variables(0, 0, scope);
-		return 0;
-	}
-
-	if( woptind == argc )
-	{
-		/*
-		  Print values of variables
-		*/
-
-		if( erase )
-		{
-			sb_printf( sb_err,
-					   _(L"%ls: Erase needs a variable name\n%ls\n"),
-					   argv[0] );
-
-			builtin_print_help( argv[0], sb_err );
-			retcode = 1;
-		}
-		else
-		{
-			print_variables( 1, 1, scope );
-		}
-
-		return retcode;
-	}
-
-	if( !(dest = wcsdup(argv[woptind])))
-	{
-		DIE_MEM();
-	}
-
-	if( wcschr( dest, L'[' ) )
-	{
-		slice = 1;
-		*wcschr( dest, L'[' )=0;
-	}
-
-	if( !wcslen( dest ) )
-	{
-		free( dest );
-		sb_printf( sb_err, BUILTIN_ERR_VARNAME_ZERO, argv[0] );
-		builtin_print_help( argv[0], sb_err );
-		return 1;
-	}
-
-	if( (bad_char = wcsvarname( dest ) ) )
-	{
-		sb_printf( sb_err, BUILTIN_ERR_VARCHAR, argv[0], *bad_char );
-		builtin_print_help( argv[0], sb_err );
-		free( dest );
-		return 1;
-	}
-
-	if( slice && erase && (scope != ENV_USER) )
-	{
-		free( dest );
-		sb_printf( sb_err, _(L"%ls: Can not specify scope when erasing array slice\n"), argv[0] );
-		builtin_print_help( argv[0], sb_err );
-		return 1;
-	}
-
-	/*
-	  set assignment can work in two modes, either using slices or
-	  using the whole array. We detect which mode is used here.
-	*/
-
-	if( slice )
-	{
-
-		/*
-		  Slice mode
-		*/
-		int idx_count, val_count;
-		array_list_t values;
-		array_list_t indexes;
-		array_list_t result;
-
-		al_init(&values);
-		al_init(&indexes);
-		al_init(&result);
-
-		tokenize_variable_array( env_get(dest), &result );
-
-		for( ; woptind<argc; woptind++ )
-		{
-			if( !parse_index( &indexes, argv[woptind], dest, al_get_count( &result ) ) )
-			{
-				builtin_print_help( argv[0], sb_err );
-				retcode = 1;
-				break;
-			}
-
-			val_count = argc-woptind-1;
-			idx_count = al_get_count( &indexes );
-
-			if( !erase )
-			{
-				if( val_count < idx_count )
-				{
-					sb_printf( sb_err, _(BUILTIN_SET_ARG_COUNT), argv[0] );
-					builtin_print_help( argv[0], sb_err );
-					retcode=1;
-					break;
-				}
-				if( val_count == idx_count )
-				{
-					woptind++;
-					break;
-				}
-			}
-		}
-
-		if( !retcode )
-		{
-			/*
-			  Slice indexes have been calculated, do the actual work
-			*/
-
-			if( erase )
-			{
-				erase_values(&result, &indexes);
-				my_env_set( dest, &result, scope);
-			}
-			else
-			{
-				array_list_t value;
-				al_init(&value);
-
-				while( woptind < argc )
-				{
-					al_push(&value, argv[woptind++]);
-				}
-
-				if( update_values( &result,
-								   &indexes,
-								   &value ) )
-				{
-					sb_printf( sb_err, L"%ls: ", argv[0] );
-					sb_printf( sb_err, ARRAY_BOUNDS_ERR );
-					sb_append( sb_err, L"\n" );
-				}
-
-				my_env_set(dest,
-						   &result,
-						   scope);
-
-				al_destroy( &value );
-
-			}
-		}
-
-		al_foreach( &result, &free );
-		al_destroy( &result );
-
-		al_destroy(&indexes);
-		al_destroy(&values);
-
-	}
-	else
-	{
-		woptind++;
-
-		/*
-		  No slicing
-		*/
-		if( erase )
-		{
-			if( woptind != argc )
-			{
-				sb_printf( sb_err,
-						   _(L"%ls: Values cannot be specfied with erase\n"),
-						   argv[0] );
-				builtin_print_help( argv[0], sb_err );
-				retcode=1;
-			}
-			else
-			{
-				retcode = env_remove( dest, scope );
-			}
-		}
-		else
-		{
-			array_list_t val;
-			al_init( &val );
-
-			for( i=woptind; i<argc; i++ )
-			{
-				al_push( &val, argv[i] );
-			}
-
-			retcode = my_env_set( dest, &val, scope );
-
-			al_destroy( &val );
-
-		}
-	}
-
-	free( dest );
-
-	return retcode;
-
-}
-

builtin_set.cpp

@@ -0,0 +1,836 @@
+/** \file builtin_set.c Functions defining the set builtin
+
+Functions used for implementing the set builtin. 
+
+*/
+#include "config.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <wchar.h>
+#include <wctype.h>
+#include <sys/types.h>
+#include <termios.h>
+#include <signal.h>
+#include <vector>
+#include <algorithm>
+#include "fallback.h"
+#include "util.h"
+
+#include "wutil.h"
+#include "builtin.h"
+#include "env.h"
+#include "expand.h"
+#include "common.h"
+#include "wgetopt.h"
+#include "proc.h"
+#include "parser.h"
+
+/* We know about these buffers */
+extern wcstring stdout_buffer, stderr_buffer;
+
+/**
+   Error message for invalid path operations
+*/
+#define BUILTIN_SET_PATH_ERROR L"%ls: Warning: path component %ls may not be valid in %ls.\n"
+
+/**
+   Hint for invalid path operation with a colon
+*/
+#define BUILTIN_SET_PATH_HINT L"%ls: Did you mean 'set %ls $%ls %ls'?\n"
+
+/**
+   Error for mismatch between index count and elements
+*/
+#define BUILTIN_SET_ARG_COUNT L"%ls: The number of variable indexes does not match the number of values\n"
+
+/**
+   Test if the specified variable should be subject to path validation
+*/
+static int is_path_variable( const wchar_t *env )
+{
+	return contains(env, L"PATH", L"CDPATH" );
+}
+
+/**
+   Call env_set. If this is a path variable, e.g. PATH, validate the
+   elements. On error, print a description of the problem to stderr.
+*/
+static int my_env_set( const wchar_t *key, const wcstring_list_t &val, int scope )
+{
+    size_t i;
+    int retcode = 0;
+    const wchar_t *val_str=NULL;
+    
+    if( is_path_variable( key ) )
+    {
+        /* Fix for https://github.com/fish-shell/fish-shell/issues/199 . Return success if any path setting succeeds. */
+        bool any_success = false, any_error = false;
+        
+        for( i=0; i< val.size() ; i++ )
+        {
+            bool show_perror = false;
+            int show_hint = 0;
+            bool error = false;
+            
+            struct stat buff;
+            const wchar_t *dir = val[i].c_str();
+            
+            if( wstat( dir, &buff ) )
+            {
+                error = true;
+                show_perror = true;
+            }
+            
+            if( !( S_ISDIR(buff.st_mode) ) )
+            {
+                error = true;
+            }
+            
+            if( !error )
+            {
+                any_success = true;
+            }
+            else
+            {
+                any_error = true;
+                const wchar_t *colon;
+                append_format(stderr_buffer, _(BUILTIN_SET_PATH_ERROR), L"set", dir, key);
+                colon = wcschr( dir, L':' );
+                
+                if( colon && *(colon+1) ) 
+                {
+                    show_hint = 1;
+                }
+                
+            }
+            
+            if( show_perror )
+            {
+                builtin_wperror( L"set" );
+            }
+            
+            if( show_hint )
+            {
+                append_format(stderr_buffer, _(BUILTIN_SET_PATH_HINT), L"set", key, key, wcschr( dir, L':' )+1);
+            }
+            
+        }
+        
+        /* Fail at setting the path if we tried to set it to something non-empty, but it wound up empty. */
+        if( ! val.empty() && ! any_success )
+        {
+            return 1;
+        }
+        
+    }
+    
+    wcstring sb;
+    if(  val.size() )
+    {
+        for( i=0; i< val.size() ; i++ )
+        {
+            sb.append(val[i]);
+            if( i<val.size() - 1 )
+            {
+                sb.append( ARRAY_SEP_STR );
+            }
+        }
+        val_str = sb.c_str();
+    }
+    
+    switch( env_set( key, val_str, scope | ENV_USER ) )
+    {
+        case ENV_PERM:
+        {
+            append_format(stderr_buffer, _(L"%ls: Tried to change the read-only variable '%ls'\n"), L"set", key);
+            retcode=1;
+            break;
+        }
+            
+        case ENV_INVALID:
+        {
+            append_format(stderr_buffer, _(L"%ls: Unknown error"), L"set" );
+            retcode=1;
+            break;
+        }
+    }
+    
+    return retcode;
+}
+
+
+
+/** 
+	Extract indexes from a destination argument of the form name[index1 index2...]
+
+	\param indexes the list to insert the new indexes into
+	\param src the source string to parse
+	\param name the name of the element. Return null if the name in \c src does not match this name
+	\param var_count the number of elements in the array to parse. 
+
+	\return the total number of indexes parsed, or -1 on error
+*/
+static int parse_index( std::vector<long> &indexes,
+						const wchar_t *src,
+						const wchar_t *name,
+						size_t var_count )
+{
+	size_t len;
+	
+	int count = 0;
+	const wchar_t *src_orig = src;
+	
+	if (src == 0)
+	{
+		return 0;
+	}
+	
+	while (*src != L'\0' && (iswalnum(*src) || *src == L'_'))
+	{
+		src++;
+	}
+	
+	if (*src != L'[')
+	{
+		append_format(stderr_buffer, _(BUILTIN_SET_ARG_COUNT), L"set" );					
+		return 0;
+	}
+	
+	len = src-src_orig;
+	
+	if( (wcsncmp( src_orig, name, len )!=0) || (wcslen(name) != (len)) )
+	{
+		append_format(stderr_buffer, 
+				   _(L"%ls: Multiple variable names specified in single call (%ls and %.*ls)\n"),
+				   L"set", 
+				   name,
+				   len,
+				   src_orig);
+		return 0;
+	}
+
+	src++;	
+
+	while (iswspace(*src)) 
+	{
+		src++;
+	}
+	
+	while (*src != L']') 
+	{
+		wchar_t *end;
+		
+		long l_ind;
+
+		errno = 0;
+		
+		l_ind = wcstol(src, &end, 10);
+		
+		if( end==src || errno ) 
+		{
+			append_format(stderr_buffer, _(L"%ls: Invalid index starting at '%ls'\n"), L"set", src);
+			return 0;
+		}
+
+		if( l_ind < 0 )
+		{
+			l_ind = var_count+l_ind+1;
+		}
+		
+		src = end;
+		if ( *src==L'.' && *(src+1)==L'.' ){
+			src+=2;
+			long l_ind2 = wcstol( src, &end, 10 );
+			if( end==src || errno )
+			{
+				return 1;
+			}
+			src = end;
+
+			if( l_ind2 < 0 )
+			{
+				l_ind2 = var_count+l_ind2+1;
+			}
+			int direction = l_ind2<l_ind ? -1 : 1 ;
+			for (long jjj = l_ind; jjj*direction <= l_ind2*direction; jjj+=direction) {
+				// debug(0, L"Expand range [set]: %i\n", jjj); 
+				indexes.push_back( jjj );
+		count++;
+			}
+		}
+		else {
+			indexes.push_back( l_ind );
+			count++;
+		}
+		while (iswspace(*src)) src++;
+	}
+
+	return count;
+}
+
+static int update_values( wcstring_list_t &list, 
+						  std::vector<long> &indexes,
+						  wcstring_list_t &values ) 
+{
+	size_t i;
+
+	/* Replace values where needed */
+	for( i = 0; i < indexes.size(); i++ ) 
+	{
+		/*
+		  The '- 1' below is because the indices in fish are
+		  one-based, but the vector uses zero-based indices
+		*/
+		long ind = indexes[i] - 1;
+		const wcstring newv = values[ i ];
+		if( ind < 0 )
+		{
+			return 1;
+		}
+        if ( (size_t)ind >= list.size() )
+        {
+            list.resize( ind+1 );
+        }
+		
+//		free((void *) al_get(list, ind));
+		list[ ind ] = newv; 
+	}
+  
+	return 0;
+}
+
+/**
+   Erase from a list of wcstring values at specified indexes 
+*/
+static void erase_values(wcstring_list_t &list, const std::vector<long> &indexes) 
+{
+    // Make a set of indexes.
+    // This both sorts them into ascending order and removes duplicates.
+    const std::set<long> indexes_set(indexes.begin(), indexes.end());
+    
+    // Now walk the set backwards, so we encounter larger indexes first, and remove elements at the given (1-based) indexes.
+    std::set<long>::const_reverse_iterator iter;
+    for (iter = indexes_set.rbegin(); iter != indexes_set.rend(); iter++) {
+        long val = *iter;
+        if (val > 0 && (size_t)val <= list.size()) {
+            // One-based indexing!
+            list.erase(list.begin() + val - 1);
+        }
+    }
+}
+
+
+/**
+   Print the names of all environment variables in the scope, with or without shortening,
+   with or without values, with or without escaping
+*/
+static void print_variables(int include_values, int esc, bool shorten_ok, int scope) 
+{
+    wcstring_list_t names = env_get_names(scope);
+    sort(names.begin(), names.end());
+	
+	for( size_t i = 0; i < names.size(); i++ )
+	{
+		const wcstring key = names.at(i);
+        const wcstring e_key = escape_string(key, 0);
+
+		stdout_buffer.append(e_key);
+		
+		if( include_values ) 
+		{
+			env_var_t value = env_get_string(key);
+			if( !value.missing() )
+			{
+				int shorten = 0;
+				
+				if( shorten_ok && value.length() > 64 )
+				{
+					shorten = 1;
+					value.resize(60);
+				}
+				
+				wcstring e_value = esc ? expand_escape_variable(value) : value;
+				
+                stdout_buffer.append(L" ");
+                stdout_buffer.append(e_value);
+				
+				if( shorten )
+				{
+					stdout_buffer.append(L"\u2026");
+				}
+
+			}
+		}
+		
+		stdout_buffer.append(L"\n");
+	}
+}
+
+
+
+/**
+   The set builtin. Creates, updates and erases environment variables
+   and environemnt variable arrays.
+*/
+static int builtin_set( parser_t &parser, wchar_t **argv ) 
+{
+	
+	/**
+	   Variables used for parsing the argument list
+	*/
+	static const struct woption
+		long_options[] = 
+		{
+			{ 
+				L"export", no_argument, 0, 'x' 
+			}
+			,
+			{ 
+				L"global", no_argument, 0, 'g' 
+			}
+			,
+			{ 
+				L"local", no_argument, 0, 'l'  
+			}
+			,
+			{ 
+				L"erase", no_argument, 0, 'e'  
+			}
+			,
+			{ 
+				L"names", no_argument, 0, 'n' 
+			} 
+			,
+			{ 
+				L"unexport", no_argument, 0, 'u' 
+			} 
+			,
+			{ 
+				L"universal", no_argument, 0, 'U'
+			}
+            ,
+			{ 
+				L"long", no_argument, 0, 'L'
+			} 
+			,
+			{ 
+				L"query", no_argument, 0, 'q' 
+			} 
+			,
+			{ 
+				L"help", no_argument, 0, 'h' 
+			} 
+			,
+			{ 
+				0, 0, 0, 0 
+			}
+		}
+	;
+	
+	const wchar_t *short_options = L"+xglenuULqh";
+
+	int argc = builtin_count_args(argv);
+
+	/*
+	  Flags to set the work mode
+	*/
+	int local = 0, global = 0, exportv = 0;
+	int erase = 0, list = 0, unexport=0;
+	int universal = 0, query=0;
+	bool shorten_ok = true;
+
+	/*
+	  Variables used for performing the actual work
+	*/
+	wchar_t *dest = 0;
+	int retcode=0;
+	int scope;
+	int slice=0;
+	int i;
+	
+	wchar_t *bad_char;
+	
+	
+	/* Parse options to obtain the requested operation and the modifiers */
+	woptind = 0;
+	while (1) 
+	{
+		int c = wgetopt_long(argc, argv, short_options, long_options, 0);
+
+		if (c == -1) 
+		{
+			break;
+		}
+    
+		switch(c) 
+		{
+			case 0:
+				break;
+
+			case 'e':
+				erase = 1;
+				break;
+
+			case 'n':
+				list = 1;
+				break;
+
+			case 'x':
+				exportv = 1;
+				break;
+
+			case 'l':
+				local = 1;
+				break;
+
+			case 'g':
+				global = 1;
+				break;
+
+			case 'u':
+				unexport = 1;
+				break;
+
+			case 'U':
+				universal = 1;
+				break;
+            
+            case 'L':
+                shorten_ok = false;
+                break;
+
+			case 'q':
+				query = 1;
+				break;
+
+			case 'h':
+				builtin_print_help( parser, argv[0], stdout_buffer );
+				return 0;
+
+			case '?':
+				builtin_unknown_option( parser, argv[0], argv[woptind-1] );
+				return 1;
+
+			default:
+				break;
+		}
+	}
+
+	/*
+	  Ok, all arguments have been parsed, let's validate them
+	*/
+
+	/*
+	  If we are checking the existance of a variable (-q) we can not
+	  also specify scope
+	*/
+
+	if( query && (erase || list) )
+	{
+		append_format(stderr_buffer,
+				  BUILTIN_ERR_COMBO,
+				  argv[0] );
+		
+		builtin_print_help( parser, argv[0], stderr_buffer );
+		return 1;
+	}
+	
+
+	/* We can't both list and erase varaibles */
+	if( erase && list ) 
+	{
+		append_format(stderr_buffer,
+				  BUILTIN_ERR_COMBO,
+				  argv[0] );		
+
+		builtin_print_help( parser, argv[0], stderr_buffer );
+		return 1;
+	}
+
+	/*
+	  Variables can only have one scope
+	*/
+	if( local + global + universal > 1 ) 
+	{
+		append_format(stderr_buffer,
+				   BUILTIN_ERR_GLOCAL,
+				   argv[0] );
+		builtin_print_help( parser, argv[0], stderr_buffer );
+		return 1;
+	}
+
+	/*
+	  Variables can only have one export status
+	*/
+	if( exportv && unexport ) 
+	{
+		append_format(stderr_buffer,
+				   BUILTIN_ERR_EXPUNEXP,
+				   argv[0] );
+		builtin_print_help( parser, argv[0], stderr_buffer );
+		return 1;
+	}
+
+	/*
+	  Calculate the scope value for variable assignement
+	*/
+	scope = (local ? ENV_LOCAL : 0) | (global ? ENV_GLOBAL : 0) | (exportv ? ENV_EXPORT : 0) | (unexport ? ENV_UNEXPORT : 0) | (universal ? ENV_UNIVERSAL:0) | ENV_USER; 
+
+	if( query )
+	{
+		/*
+		  Query mode. Return the number of variables that do not exist
+		  out of the specified variables.
+		*/
+		int i;
+		for( i=woptind; i<argc; i++ )
+		{
+			wchar_t *arg = argv[i];
+			int slice=0;
+
+			if( !(dest = wcsdup(arg)))
+			{
+				DIE_MEM();		
+			}
+
+			if( wcschr( dest, L'[' ) )
+			{
+				slice = 1;
+				*wcschr( dest, L'[' )=0;
+			}
+			
+			if( slice )
+			{
+				std::vector<long> indexes;
+				wcstring_list_t result;
+				size_t j;
+				
+                env_var_t dest_str = env_get_string(dest);
+                if (! dest_str.missing())
+                    tokenize_variable_array( dest_str, result );
+								
+				if( !parse_index( indexes, arg, dest, result.size() ) )
+				{
+					builtin_print_help( parser, argv[0], stderr_buffer );
+					retcode = 1;
+					break;
+				}
+				for( j=0; j < indexes.size() ; j++ )
+				{
+					long idx = indexes[j];
+					if( idx < 1 || (size_t)idx > result.size() )
+					{
+						retcode++;
+					}
+				}
+			}
+			else
+			{
+				if( !env_exist( arg, scope ) )
+				{
+					retcode++;
+				}
+			}
+			
+			free( dest );
+			
+		}
+		return retcode;
+	}
+	
+	if( list ) 
+	{
+		/* Maybe we should issue an error if there are any other arguments? */
+		print_variables(0, 0, shorten_ok, scope);
+		return 0;
+	} 
+	
+	if( woptind == argc )
+	{
+		/*
+		  Print values of variables
+		*/
+
+		if( erase ) 
+		{
+			append_format(stderr_buffer,
+					   _(L"%ls: Erase needs a variable name\n"), 
+					   argv[0] );
+			
+			builtin_print_help( parser, argv[0], stderr_buffer );
+			retcode = 1;
+		}
+		else
+		{
+			print_variables( 1, 1, shorten_ok, scope );
+		}
+		
+		return retcode;
+	}
+
+	if( !(dest = wcsdup(argv[woptind])))
+	{
+		DIE_MEM();		
+	}
+
+	if( wcschr( dest, L'[' ) )
+	{
+		slice = 1;
+		*wcschr( dest, L'[' )=0;
+	}
+	
+	if( !wcslen( dest ) )
+	{
+		free( dest );
+		append_format(stderr_buffer, BUILTIN_ERR_VARNAME_ZERO, argv[0] );
+		builtin_print_help( parser, argv[0], stderr_buffer );
+		return 1;
+	}
+	
+	if( (bad_char = wcsvarname( dest ) ) )
+	{
+		append_format(stderr_buffer, BUILTIN_ERR_VARCHAR, argv[0], *bad_char );
+		builtin_print_help( parser, argv[0], stderr_buffer );
+		free( dest );
+		return 1;
+	}
+	
+	if( slice && erase && (scope != ENV_USER) )
+	{
+		free( dest );
+		append_format(stderr_buffer, _(L"%ls: Can not specify scope when erasing array slice\n"), argv[0] );
+		builtin_print_help( parser, argv[0], stderr_buffer );
+		return 1;
+	}
+	
+	/*
+	  set assignment can work in two modes, either using slices or
+	  using the whole array. We detect which mode is used here.
+	*/
+	
+	if( slice )
+	{
+
+		/*
+		  Slice mode
+		*/
+		size_t idx_count, val_count;
+		wcstring_list_t values;
+		std::vector<long> indexes;
+		wcstring_list_t result;
+		
+        const env_var_t dest_str = env_get_string(dest);
+        if (! dest_str.missing())
+            tokenize_variable_array( dest_str, result );
+		
+		for( ; woptind<argc; woptind++ )
+		{			
+			if( !parse_index( indexes, argv[woptind], dest, result.size() ) )
+			{
+				builtin_print_help( parser, argv[0], stderr_buffer );
+				retcode = 1;
+				break;
+			}
+			
+			val_count = argc-woptind-1;
+			idx_count = indexes.size();
+
+			if( !erase )
+			{
+				if( val_count < idx_count )
+				{
+					append_format(stderr_buffer, _(BUILTIN_SET_ARG_COUNT), argv[0] );
+					builtin_print_help( parser, argv[0], stderr_buffer );
+					retcode=1;
+					break;
+				}
+				if( val_count == idx_count )
+				{
+					woptind++;
+					break;
+				}
+			}
+		}		
+
+		if( !retcode )
+		{
+			/*
+			  Slice indexes have been calculated, do the actual work
+			*/
+
+			if( erase )
+			{
+				erase_values(result, indexes);
+				my_env_set( dest, result, scope);
+			}
+			else
+			{
+				wcstring_list_t value;
+//				al_init(&value);
+
+				while( woptind < argc ) 
+				{
+					value.push_back( argv[woptind++] );
+				}
+
+				if( update_values( result, 
+								   indexes,
+								   value ) )
+				{
+					append_format(stderr_buffer, L"%ls: ", argv[0] );
+					append_format(stderr_buffer, ARRAY_BOUNDS_ERR );
+					stderr_buffer.push_back(L'\n');
+				}
+				
+				my_env_set(dest, result, scope);
+								
+//				al_destroy( &value );
+								
+			}			
+		}
+
+//		al_foreach( &result, &free );
+//		al_destroy( &result );
+
+//		al_destroy(&indexes);
+//		al_destroy(&values);
+		
+	}
+	else
+	{
+		woptind++;
+		
+		/*
+		  No slicing
+		*/
+		if( erase )
+		{
+			if( woptind != argc )
+			{
+				append_format(stderr_buffer, 
+						   _(L"%ls: Values cannot be specfied with erase\n"),
+						   argv[0] );
+				builtin_print_help( parser, argv[0], stderr_buffer );
+				retcode=1;
+			}
+			else
+			{
+				retcode = env_remove( dest, scope );
+			}
+		}
+		else
+		{
+            wcstring_list_t val;
+			for( i=woptind; i<argc; i++ )
+                val.push_back(argv[i]);
+			retcode = my_env_set( dest, val, scope );
+		}		
+	}
+	
+	free( dest );
+	
+	return retcode;
+
+}
+

builtin_test.cpp

@@ -0,0 +1,745 @@
+/** \file builtin_test.cpp Functions defining the test builtin
+
+Functions used for implementing the test builtin. 
+Implemented from scratch (yes, really) by way of IEEE 1003.1 as reference.
+
+*/
+
+#include "config.h"
+#include "common.h"
+#include "builtin.h"
+#include "wutil.h"
+#include "proc.h"
+#include <sys/stat.h>
+#include <memory>
+
+
+enum {
+    BUILTIN_TEST_SUCCESS = STATUS_BUILTIN_OK,
+    BUILTIN_TEST_FAIL = STATUS_BUILTIN_ERROR
+};
+
+
+int builtin_test( parser_t &parser, wchar_t **argv );
+
+static const wchar_t * const condstr[] = {
+    L"!", L"&&", L"||", L"==", L"!=", L"<", L">", L"-nt", L"-ot", L"-ef", L"-eq",
+    L"-ne", L"-lt", L"-gt", L"-le", L"-ge", L"=~"
+};
+
+namespace test_expressions {
+    
+    enum token_t {
+        test_unknown,               // arbitrary string
+        
+        test_bang,                  // "!", inverts sense
+        
+        test_filetype_b,            // "-b", for block special files
+        test_filetype_c,            // "-c" for character special files
+        test_filetype_d,            // "-d" for directories
+        test_filetype_e,            // "-e" for files that exist
+        test_filetype_f,            // "-f" for for regular files
+        test_filetype_g,            // "-g" for set-group-id
+        test_filetype_h,            // "-h" for symbolic links
+        test_filetype_L,            // "-L", same as -h
+        test_filetype_p,            // "-p", for FIFO
+        test_filetype_S,            // "-S", socket
+        
+        test_filesize_s,            // "-s", size greater than zero
+        
+        test_filedesc_t,            // "-t", whether the fd is associated with a terminal
+        
+        test_fileperm_r,            // "-r", read permission
+        test_fileperm_u,            // "-u", whether file is setuid
+        test_fileperm_w,            // "-w", whether file write permission is allowed
+        test_fileperm_x,            // "-x", whether file execute/search is allowed
+        
+        test_string_n,              // "-n", non-empty string
+        test_string_z,              // "-z", true if length of string is 0
+        test_string_equal,          // "=", true if strings are identical
+        test_string_not_equal,      // "!=", true if strings are not identical
+        
+        test_number_equal,          // "-eq", true if numbers are equal
+        test_number_not_equal,      // "-ne", true if numbers are not equal
+        test_number_greater,        // "-gt", true if first number is larger than second
+        test_number_greater_equal,  // "-ge", true if first number is at least second
+        test_number_lesser,         // "-lt", true if first number is smaller than second
+        test_number_lesser_equal,   // "-le", true if first number is at most second
+        
+        test_combine_and,            // "-a", true if left and right are both true
+        test_combine_or,             // "-o", true if either left or right is true
+        
+        test_paren_open,             // "(", open paren
+        test_paren_close,             // ")", close paren
+    };
+    
+    static bool binary_primary_evaluate(test_expressions::token_t token, const wcstring &left, const wcstring &right, wcstring_list_t &errors);
+    static bool unary_primary_evaluate(test_expressions::token_t token, const wcstring &arg, wcstring_list_t &errors);
+
+    
+    enum {
+        UNARY_PRIMARY = 1 << 0,
+        BINARY_PRIMARY = 1 << 1
+    };
+    
+    static const struct token_info_t { token_t tok; const wchar_t *string; unsigned int flags; } token_infos[] =
+    {
+        {test_unknown, L"", 0},
+        {test_bang, L"!", 0},
+        {test_filetype_b, L"-b", UNARY_PRIMARY},
+        {test_filetype_c, L"-c", UNARY_PRIMARY},
+        {test_filetype_d, L"-d", UNARY_PRIMARY},
+        {test_filetype_e, L"-e", UNARY_PRIMARY},
+        {test_filetype_f, L"-f", UNARY_PRIMARY},
+        {test_filetype_g, L"-g", UNARY_PRIMARY},
+        {test_filetype_h, L"-h", UNARY_PRIMARY},
+        {test_filetype_L, L"-L", UNARY_PRIMARY},
+        {test_filetype_p, L"-p", UNARY_PRIMARY},
+        {test_filetype_S, L"-S", UNARY_PRIMARY},
+        {test_filesize_s, L"-s", UNARY_PRIMARY},
+        {test_filedesc_t, L"-t", UNARY_PRIMARY},
+        {test_fileperm_r, L"-r", UNARY_PRIMARY},
+        {test_fileperm_u, L"-u", UNARY_PRIMARY},
+        {test_fileperm_w, L"-w", UNARY_PRIMARY},
+        {test_fileperm_x, L"-x", UNARY_PRIMARY},
+        {test_string_n, L"-n", UNARY_PRIMARY},
+        {test_string_z, L"-z", UNARY_PRIMARY},
+        {test_string_equal, L"=", BINARY_PRIMARY},
+        {test_string_not_equal, L"!=", BINARY_PRIMARY},
+        {test_number_equal, L"-eq", BINARY_PRIMARY},
+        {test_number_not_equal, L"-ne", BINARY_PRIMARY},
+        {test_number_greater, L"-gt", BINARY_PRIMARY},
+        {test_number_greater_equal, L"-ge", BINARY_PRIMARY},
+        {test_number_lesser, L"-lt", BINARY_PRIMARY},
+        {test_number_lesser_equal, L"-le", BINARY_PRIMARY},
+        {test_combine_and, L"-a", 0},
+        {test_combine_or, L"-o", 0},
+        {test_paren_open, L"(", 0},
+        {test_paren_close, L")", 0}
+    };
+    
+    const token_info_t *token_for_string(const wcstring &str) {
+        for (size_t i=0; i < sizeof token_infos / sizeof *token_infos; i++) {
+            if (str == token_infos[i].string) {
+                return &token_infos[i];
+            }
+        }
+        return &token_infos[0]; //unknown
+    }
+
+    
+    /* Grammar.
+    
+        <expr> = <combining_expr>
+                 
+        <combining_expr> = <unary_expr> and/or <combining_expr> |
+                           <unary_expr>
+        
+        <unary_expr> = bang <unary_expr> |
+                      <primary>
+                     
+        <primary> = <unary_primary> arg |
+                    arg <binary_primary> arg |
+                    '(' <expr> ')'
+                
+    */
+    
+    class expression;
+    class test_parser {
+        private:
+        wcstring_list_t strings;
+        wcstring_list_t errors;
+        
+        expression *error(const wchar_t *fmt, ...);
+        void add_error(const wchar_t *fmt, ...);
+        
+        const wcstring &arg(unsigned int idx) { return strings.at(idx); }
+        
+        public:
+        test_parser(const wcstring_list_t &val) : strings(val)
+        { }
+        
+        expression *parse_expression(unsigned int start, unsigned int end);
+        expression *parse_combining_expression(unsigned int start, unsigned int end);
+        expression *parse_unary_expression(unsigned int start, unsigned int end);
+        
+        expression *parse_primary(unsigned int start, unsigned int end);
+        expression *parse_parenthentical(unsigned int start, unsigned int end);
+        expression *parse_unary_primary(unsigned int start, unsigned int end);
+        expression *parse_binary_primary(unsigned int start, unsigned int end);
+        expression *parse_just_a_string(unsigned int start, unsigned int end);
+        
+        static expression *parse_args(const wcstring_list_t &args, wcstring &err);
+    };
+    
+    struct range_t {
+        unsigned int start;
+        unsigned int end;
+        
+        range_t(unsigned s, unsigned e) : start(s), end(e) { }
+    };
+
+
+    /* Base class for expressions */
+    class expression {
+        protected:
+        expression(token_t what, range_t where) : token(what), range(where) { }
+        
+        public:
+        const token_t token;
+        range_t range;
+        
+        virtual ~expression() { }
+        
+        // evaluate returns true if the expression is true (i.e. BUILTIN_TEST_SUCCESS)
+        virtual bool evaluate(wcstring_list_t &errors) = 0;
+    };
+
+    typedef std::auto_ptr<expression> expr_ref_t;
+
+    /* Single argument like -n foo or "just a string" */
+    class unary_primary : public expression {
+        public:
+        wcstring arg;
+        unary_primary(token_t tok, range_t where, const wcstring &what) : expression(tok, where), arg(what) { }
+        bool evaluate(wcstring_list_t &errors);
+    };
+
+    /* Two argument primary like foo != bar */
+    class binary_primary : public expression {
+        public:
+        wcstring arg_left;
+        wcstring arg_right;
+        
+        binary_primary(token_t tok, range_t where, const wcstring &left, const wcstring &right) : expression(tok, where), arg_left(left), arg_right(right)
+        { }
+        bool evaluate(wcstring_list_t &errors);
+    };
+    
+    /* Unary operator like bang */
+    class unary_operator : public expression {
+        public:
+        expr_ref_t subject;        
+        unary_operator(token_t tok, range_t where, expr_ref_t &exp) : expression(tok, where), subject(exp) { }
+        bool evaluate(wcstring_list_t &errors);
+    };
+    
+    /* Combining expression. Contains a list of AND or OR expressions. It takes more than two so that we don't have to worry about precedence in the parser. */
+    class combining_expression : public expression {
+        public:
+        const std::vector<expression *> subjects;
+        const std::vector<token_t> combiners;
+        
+        combining_expression(token_t tok, range_t where, const std::vector<expression *> &exprs, const std::vector<token_t> &combs) : expression(tok, where), subjects(exprs), combiners(combs)
+        {
+            /* We should have one more subject than combiner */
+            assert(subjects.size() == combiners.size() + 1);
+        }
+        
+        /* We are responsible for destroying our expressions */
+        virtual ~combining_expression() {
+            for (size_t i=0; i < subjects.size(); i++) {
+                delete subjects[i];
+            }
+        }
+        
+        bool evaluate(wcstring_list_t &errors);
+    };
+    
+    /* Parenthetical expression */
+    class parenthetical_expression : public expression {
+        public:
+        expr_ref_t contents;
+        parenthetical_expression(token_t tok, range_t where, expr_ref_t &expr) : expression(tok, where), contents(expr) { }
+        
+        virtual bool evaluate(wcstring_list_t &errors);
+    };
+    
+    void test_parser::add_error(const wchar_t *fmt, ...) {
+        assert(fmt != NULL);
+        va_list va;
+        va_start(va, fmt);
+        this->errors.push_back(vformat_string(fmt, va));
+        va_end(va);    
+    }
+    
+    expression *test_parser::error(const wchar_t *fmt, ...) {
+        assert(fmt != NULL);
+        va_list va;
+        va_start(va, fmt);
+        this->errors.push_back(vformat_string(fmt, va));
+        va_end(va);
+        return NULL;
+    }
+    
+    expression *test_parser::parse_unary_expression(unsigned int start, unsigned int end) {
+        if (start >= end) {
+            return error(L"Missing argument at index %u", start);
+        }
+        token_t tok = token_for_string(arg(start))->tok;
+        if (tok == test_bang) {
+            expr_ref_t subject(parse_unary_expression(start + 1, end));
+            if (subject.get()) {
+                return new unary_operator(tok, range_t(start, subject->range.end), subject);
+            } else {
+                return NULL;
+            }
+        } else {
+            return parse_primary(start, end);
+        }
+    }
+    
+    /* Parse a combining expression (AND, OR) */
+    expression *test_parser::parse_combining_expression(unsigned int start, unsigned int end) {
+        if (start >= end)
+            return NULL;
+        
+        std::vector<expression *> subjects;
+        std::vector<token_t> combiners;
+        unsigned int idx = start;
+        
+        while (idx < end) {
+            
+            if (! subjects.empty()) {
+                /* This is not the first expression, so we expect a combiner. */
+                token_t combiner = token_for_string(arg(idx))->tok;
+                if (combiner != test_combine_and && combiner != test_combine_or) {
+                    /* Not a combiner, we're done */
+                    break;
+                }
+                combiners.push_back(combiner);
+                idx++;
+            }
+            
+            /* Parse another expression */
+            expression *expr = parse_unary_expression(idx, end);
+            if (! expr) {
+                add_error(L"Missing argument at index %u", idx);
+                break;
+            }
+            
+            /* Go to the end of this expression */
+            idx = expr->range.end;
+            subjects.push_back(expr);
+        }
+        
+        if (! subjects.empty()) {
+            /* Our new expression takes ownership of all expressions we created. The token we pass is irrelevant. */
+            return new combining_expression(test_combine_and, range_t(start, idx), subjects, combiners);
+        } else {
+            /* No subjects */
+            return NULL;
+        }
+    }
+    
+    expression *test_parser::parse_unary_primary(unsigned int start, unsigned int end) {
+        /* We need two arguments */
+        if (start >= end) {
+            return error(L"Missing argument at index %u", start);
+        }
+        if (start + 1 >= end) {
+            return error(L"Missing argument at index %u", start + 1);
+        }
+        
+        /* All our unary primaries are prefix, so the operator is at start. */
+        const token_info_t *info = token_for_string(arg(start));
+        if (! (info->flags & UNARY_PRIMARY))
+            return NULL;
+        
+        return new unary_primary(info->tok, range_t(start, start + 2), arg(start + 1));
+    }
+    
+    expression *test_parser::parse_just_a_string(unsigned int start, unsigned int end) {
+        /* Handle a string as a unary primary that is not a token of any other type.
+           e.g. 'test foo -a bar' should evaluate to true
+           We handle this with a unary primary of test_string_n
+        */
+        
+        /* We need one arguments */
+        if (start >= end) {
+            return error(L"Missing argument at index %u", start);
+        }
+        
+        const token_info_t *info = token_for_string(arg(start));
+        if (info->tok != test_unknown) {
+            return error(L"Unexpected argument type at index %u", start);
+        }
+        
+        /* This is hackish; a nicer way to implement this would be with a "just a string" expression type */
+        return new unary_primary(test_string_n, range_t(start, start + 1), arg(start));
+    }
+    
+#if 0
+    expression *test_parser::parse_unary_primary(unsigned int start, unsigned int end) {
+        /* We need either one or two arguments */
+        if (start >= end) {
+            return error(L"Missing argument at index %u", start);
+        }
+        
+        /* The index of the argument to the unary primary */
+        unsigned int arg_idx;
+        
+        /* All our unary primaries are prefix, so any operator is at start. But it also may just be a string, with no operator. */
+        const token_info_t *info = token_for_string(arg(start));
+        if (info->flags & UNARY_PRIMARY) {
+            /* We have an operator. Skip the operator argument */
+            arg_idx = start + 1;
+            
+            /* We have some freedom here...do we allow other tokens for the argument to operate on?
+               For example, should 'test -n =' work? I say yes. So no typechecking on the next token. */
+               
+        } else if (info->tok == test_unknown) {
+            /* "Just a string. */
+            arg_idx = start;
+        } else {
+            /* Here we don't allow arbitrary tokens as "just a string." I.e. 'test = -a =' should have a parse error. We could relax this at some point. */
+            return error(L"Parse error at argument index %u", start);
+        }
+        
+        /* Verify we have the argument we want, i.e. test -n should fail to parse */
+        if (arg_idx >= end) {
+            return error(L"Missing argument at index %u", arg_idx);
+        }
+        
+        return new unary_primary(info->tok, range_t(start, arg_idx + 1), arg(arg_idx));
+    }
+#endif
+    
+    expression *test_parser::parse_binary_primary(unsigned int start, unsigned int end) {
+        /* We need three arguments */
+        for (unsigned int idx = start; idx < start + 3; idx++) {
+            if (idx >= end) {
+                return error(L"Missing argument at index %u", idx);
+            }
+        }
+        
+        /* All our binary primaries are infix, so the operator is at start + 1. */
+        const token_info_t *info = token_for_string(arg(start + 1));
+        if (! (info->flags & BINARY_PRIMARY))
+            return NULL;
+        
+        return new binary_primary(info->tok, range_t(start, start + 3), arg(start), arg(start + 2));
+    }
+    
+    expression *test_parser::parse_parenthentical(unsigned int start, unsigned int end) {
+        /* We need at least three arguments: open paren, argument, close paren */
+        if (start + 3 >= end)
+            return NULL;
+        
+        /* Must start with an open expression */
+        const token_info_t *open_paren = token_for_string(arg(start));
+        if (open_paren->tok != test_paren_open)
+            return NULL;
+            
+        /* Parse a subexpression */
+        expression *subexr_ptr = parse_expression(start + 1, end);
+        if (! subexr_ptr)
+            return NULL;
+        expr_ref_t subexpr(subexr_ptr);
+        
+        /* Parse a close paren */
+        unsigned close_index = subexpr->range.end;
+        assert(close_index <= end);
+        if (close_index == end) {
+            return error(L"Missing close paren at index %u", close_index);
+        }
+        const token_info_t *close_paren = token_for_string(arg(close_index));
+        if (close_paren->tok != test_paren_close) {
+            return error(L"Expected close paren at index %u", close_index);
+        }
+        
+        /* Success */
+        return new parenthetical_expression(test_paren_open, range_t(start, close_index+1), subexpr);
+    }
+
+    expression *test_parser::parse_primary(unsigned int start, unsigned int end) {
+        if (start >= end) {
+            return error(L"Missing argument at index %u", start);
+        }
+        
+        expression *expr = NULL;
+        if (! expr) expr = parse_parenthentical(start, end);
+        if (! expr) expr = parse_unary_primary(start, end);
+        if (! expr) expr = parse_binary_primary(start, end);
+        if (! expr) expr = parse_just_a_string(start, end);
+        return expr;
+    }
+
+    expression *test_parser::parse_expression(unsigned int start, unsigned int end) {
+        if (start >= end) {
+            return error(L"Missing argument at index %u", start);
+        }
+        
+        return parse_combining_expression(start, end);
+    }
+    
+    expression *test_parser::parse_args(const wcstring_list_t &args, wcstring &err) {
+        /* Empty list and one-arg list should be handled by caller */
+        assert(args.size() > 1);
+        
+        test_parser parser(args);
+        expression *result = parser.parse_expression(0, (unsigned int)args.size());
+        
+        /* Handle errors */
+        bool errored = false;
+        for (size_t i = 0; i < parser.errors.size(); i++) {
+            err.append(L"test: ");
+            err.append(parser.errors.at(i));
+            err.push_back(L'\n');
+            errored = true;
+            // For now we only show the first error
+            break;
+        }
+        
+        if (! errored && result) {
+            /* It's also an error if there are any unused arguments. This is not detected by parse_expression() */
+            assert(result->range.end <= args.size());
+            if (result->range.end < args.size()) {
+                append_format(err, L"test: unexpected argument at index %lu: '%ls'\n", (unsigned long)result->range.end, args.at(result->range.end).c_str());
+                delete result;
+                result = NULL;
+                errored = true;
+            }
+        }
+        
+        
+        return result;
+    }
+    
+    bool unary_primary::evaluate(wcstring_list_t &errors) {
+        return unary_primary_evaluate(token, arg, errors);
+    }
+    
+    bool binary_primary::evaluate(wcstring_list_t &errors) {
+        return binary_primary_evaluate(token, arg_left, arg_right, errors);
+    }
+    
+    bool unary_operator::evaluate(wcstring_list_t &errors) {
+        switch (token) {
+            case test_bang:
+                assert(subject.get());
+                return ! subject->evaluate(errors);
+            default:
+                errors.push_back(format_string(L"Unknown token type in %s", __func__));
+                return false;
+
+        }
+    }
+    
+    bool combining_expression::evaluate(wcstring_list_t &errors) {
+        switch (token) {
+            case test_combine_and:
+            case test_combine_or:
+            {
+                /* One-element case */
+                if (subjects.size() == 1)
+                    return subjects.at(0)->evaluate(errors);
+                
+                /* Evaluate our lists, remembering that AND has higher precedence than OR. We can visualize this as a sequence of OR expressions of AND expressions. */
+                assert(combiners.size() + 1 == subjects.size());
+                assert(! subjects.empty());
+                
+                size_t idx = 0, max = subjects.size();
+                bool or_result = false;
+                while (idx < max) {
+                    if (or_result) {
+                        /* Short circuit */
+                        break;
+                    }
+                    
+                    /* Evaluate a stream of AND starting at given subject index. It may only have one element.  */
+                    bool and_result = true;
+                    for (; idx < max; idx++) {
+                        /* Evaluate it, short-circuiting */
+                        and_result = and_result && subjects.at(idx)->evaluate(errors);
+                        
+                        /* If the combiner at this index (which corresponding to how we combine with the next subject) is not AND, then exit the loop */
+                        if (idx + 1 < max && combiners.at(idx) != test_combine_and) {
+                            idx++;
+                            break;
+                        }
+                    }
+                    
+                    /* OR it in */
+                    or_result = or_result || and_result;
+                }
+                return or_result;
+            }
+            
+            default:
+                errors.push_back(format_string(L"Unknown token type in %s", __func__));
+                return BUILTIN_TEST_FAIL;
+
+        }
+    }
+    
+    bool parenthetical_expression::evaluate(wcstring_list_t &errors) {
+        return contents->evaluate(errors);
+    }
+
+    /* IEEE 1003.1 says nothing about what it means for two strings to be "algebraically equal". For example, should we interpret 0x10 as 0, 10, or 16? Here we use only base 10 and use wcstoll, which allows for leading + and -, and leading whitespace. This matches bash. */
+    static bool parse_number(const wcstring &arg, long long *out) {
+        const wchar_t *str = arg.c_str();
+        wchar_t *endptr = NULL;
+        *out = wcstoll(str, &endptr, 10);
+        return endptr && *endptr == L'\0';
+    }
+
+    static bool binary_primary_evaluate(test_expressions::token_t token, const wcstring &left, const wcstring &right, wcstring_list_t &errors) {
+        using namespace test_expressions;
+        long long left_num, right_num;
+        switch (token) {
+            case test_string_equal:
+                return left == right;
+            
+            case test_string_not_equal:
+                return left != right;
+            
+            case test_number_equal:
+                return parse_number(left, &left_num) && parse_number(right, &right_num) && left_num == right_num;
+                
+            case test_number_not_equal:
+                return parse_number(left, &left_num) && parse_number(right, &right_num) && left_num != right_num;
+            
+            case test_number_greater:
+                return parse_number(left, &left_num) && parse_number(right, &right_num) && left_num > right_num;
+                
+            case test_number_greater_equal:
+                return parse_number(left, &left_num) && parse_number(right, &right_num) && left_num >= right_num;
+                
+            case test_number_lesser:
+                return parse_number(left, &left_num) && parse_number(right, &right_num) && left_num < right_num;
+                
+            case test_number_lesser_equal:
+                return parse_number(left, &left_num) && parse_number(right, &right_num) && left_num <= right_num;
+                
+            default:
+                errors.push_back(format_string(L"Unknown token type in %s", __func__));
+                return false;
+        }
+    }
+
+
+    static bool unary_primary_evaluate(test_expressions::token_t token, const wcstring &arg, wcstring_list_t &errors) {
+        using namespace test_expressions;
+        struct stat buf;
+        long long num;
+        switch (token) {
+            case test_filetype_b:            // "-b", for block special files
+                return !wstat(arg, &buf) && S_ISBLK(buf.st_mode);
+                
+            case test_filetype_c:            // "-c" for character special files
+                return !wstat(arg, &buf) && S_ISCHR(buf.st_mode);
+                
+            case test_filetype_d:            // "-d" for directories
+                return !wstat(arg, &buf) && S_ISDIR(buf.st_mode);
+                
+            case test_filetype_e:            // "-e" for files that exist
+                return !wstat(arg, &buf);
+                
+            case test_filetype_f:            // "-f" for for regular files
+                return !wstat(arg, &buf) && S_ISREG(buf.st_mode);
+            
+            case test_filetype_g:            // "-g" for set-group-id
+                return !wstat(arg, &buf) && (S_ISGID & buf.st_mode);
+                
+            case test_filetype_h:            // "-h" for symbolic links
+            case test_filetype_L:            // "-L", same as -h
+                return !lwstat(arg, &buf) && S_ISLNK(buf.st_mode);
+
+            case test_filetype_p:            // "-p", for FIFO
+                return !wstat(arg, &buf) && S_ISFIFO(buf.st_mode);
+                
+            case test_filetype_S:            // "-S", socket
+                return !wstat(arg, &buf) && S_ISSOCK(buf.st_mode);
+            
+            case test_filesize_s:            // "-s", size greater than zero
+                return !wstat(arg, &buf) && buf.st_size > 0;
+                
+            case test_filedesc_t:            // "-t", whether the fd is associated with a terminal
+                return parse_number(arg, &num) && num == (int)num && isatty((int)num);
+            
+            case test_fileperm_r:            // "-r", read permission
+                return !waccess(arg, R_OK);
+                
+            case test_fileperm_u:            // "-u", whether file is setuid
+                return !wstat(arg, &buf) && (S_ISUID & buf.st_mode);
+                
+            case test_fileperm_w:            // "-w", whether file write permission is allowed
+                return !waccess(arg, W_OK);
+                
+            case test_fileperm_x:            // "-x", whether file execute/search is allowed
+                return !waccess(arg, X_OK);
+            
+            case test_string_n:              // "-n", non-empty string
+                return ! arg.empty();
+                
+            case test_string_z:              // "-z", true if length of string is 0
+                return arg.empty();
+            
+            default:
+                errors.push_back(format_string(L"Unknown token type in %s", __func__));
+                return false;
+        }        
+    }
+
+};
+
+/*
+ * Evaluate a conditional expression given the arguments.
+ * If fromtest is set, the caller is the test or [ builtin;
+ * with the pointer giving the name of the command.
+ * for POSIX conformance this supports a more limited range
+ * of functionality.
+ *
+ * Return status is the final shell status, i.e. 0 for true,
+ * 1 for false and 2 for error.
+ */
+int builtin_test( parser_t &parser, wchar_t **argv )
+{
+    using namespace test_expressions;
+    
+    /* The first argument should be the name of the command ('test') */
+    if (! argv[0])
+        return BUILTIN_TEST_FAIL;
+    
+    size_t argc = 0;
+    while (argv[argc + 1])
+        argc++;
+    const wcstring_list_t args(argv + 1, argv + 1 + argc);
+
+    if (argc == 0) {
+        // Per 1003.1, exit false
+        return BUILTIN_TEST_FAIL;
+    } else if (argc == 1) {
+        // Per 1003.1, exit true if the arg is non-empty
+        return args.at(0).empty() ? BUILTIN_TEST_FAIL : BUILTIN_TEST_SUCCESS;
+    } else {
+        // Try parsing. If expr is not nil, we are responsible for deleting it.
+        wcstring err;
+        expression *expr = test_parser::parse_args(args, err);
+        if (! expr) {
+#if 0
+            printf("Oops! test was given args:\n");
+            for (size_t i=0; i < argc; i++) {
+                printf("\t%ls\n", args.at(i).c_str());
+            }
+            printf("and returned parse error: %ls\n", err.c_str());
+#endif
+            builtin_show_error(err);
+            return BUILTIN_TEST_FAIL;
+        } else {
+            wcstring_list_t eval_errors;
+            bool result = expr->evaluate(eval_errors);
+            if (! eval_errors.empty()) {
+                printf("test returned eval errors:\n");
+                for (size_t i=0; i < eval_errors.size(); i++) {
+                    printf("\t%ls\n", eval_errors.at(i).c_str());
+                }
+            }
+            delete expr;
+            return result ? BUILTIN_TEST_SUCCESS : BUILTIN_TEST_FAIL;
+        }
+    }
+    return 1;
+}

builtin_ulimit.cpp

@@ -1,6 +1,6 @@
 /** \file builtin_ulimit.c Functions defining the ulimit builtin
 
-Functions used for implementing the ulimit builtin.
+Functions used for implementing the ulimit builtin. 
 
 */
 #include "config.h"
@@ -38,11 +38,11 @@ struct resource_t
 	/**
 	   Switch used on commandline to specify resource
 	*/
-	wchar_t switch_char;
+	wchar_t switch_char;	
 	/**
 	   The implicit multiplier used when setting getting values
 	*/
-	int multiplier;
+	int multiplier;	
 }
 	;
 
@@ -96,7 +96,7 @@ static const struct resource_t resource_arr[] =
 #ifdef RLIMIT_AS
 	{
 		RLIMIT_AS, L"Maximum amount of virtual memory available to the shell", L'v', 1024
-	}
+	}	
 	,
 #endif
 	{
@@ -111,7 +111,7 @@ static const struct resource_t resource_arr[] =
 static int get_multiplier( int what )
 {
 	int i;
-
+	
 	for( i=0; resource_arr[i].desc; i++ )
 	{
 		if( resource_arr[i].resource == what )
@@ -130,9 +130,9 @@ static int get_multiplier( int what )
 static rlim_t get( int resource, int hard )
 {
 	struct rlimit ls;
-
+	
 	getrlimit( resource, &ls );
-
+	
 	return hard ? ls.rlim_max:ls.rlim_cur;
 }
 
@@ -144,10 +144,10 @@ static void print( int resource, int hard )
 	rlim_t l = get( resource, hard );
 
 	if( l == RLIM_INFINITY )
-		sb_append( sb_out, L"unlimited\n" );
+		stdout_buffer.append( L"unlimited\n" );
 	else
-		sb_printf( sb_out, L"%d\n", l / get_multiplier( resource ) );
-
+		append_format(stdout_buffer, L"%d\n", l / get_multiplier( resource ) );
+	
 }
 
 /**
@@ -157,12 +157,12 @@ static void print_all( int hard )
 {
 	int i;
 	int w=0;
-
+	
 	for( i=0; resource_arr[i].desc; i++ )
 	{
 		w=maxi( w, my_wcswidth(resource_arr[i].desc));
 	}
-
+	
 	for( i=0; resource_arr[i].desc; i++ )
 	{
 		struct rlimit ls;
@@ -170,25 +170,25 @@ static void print_all( int hard )
 		getrlimit( resource_arr[i].resource, &ls );
 		l = hard ? ls.rlim_max:ls.rlim_cur;
 
-		wchar_t *unit = ((resource_arr[i].resource==RLIMIT_CPU)?L"(seconds, ":(get_multiplier(resource_arr[i].resource)==1?L"(":L"(kB, "));
-
-		sb_printf( sb_out,
-				   L"%-*ls %10ls-%lc) ",
-				   w,
-				   resource_arr[i].desc,
+		const wchar_t *unit = ((resource_arr[i].resource==RLIMIT_CPU)?L"(seconds, ":(get_multiplier(resource_arr[i].resource)==1?L"(":L"(kB, "));
+		
+		append_format(stdout_buffer,
+				   L"%-*ls %10ls-%lc) ", 
+				   w, 
+				   resource_arr[i].desc, 
 				   unit,
 				   resource_arr[i].switch_char);
-
+		
 		if( l == RLIM_INFINITY )
 		{
-			sb_append( sb_out, L"unlimited\n" );
+			stdout_buffer.append( L"unlimited\n" );
 		}
 		else
 		{
-			sb_printf( sb_out, L"%d\n", l/get_multiplier(resource_arr[i].resource) );
+			append_format(stdout_buffer, L"%d\n", l/get_multiplier(resource_arr[i].resource) );
 		}
 	}
-
+		
 }
 
 /**
@@ -197,7 +197,7 @@ static void print_all( int hard )
 static const wchar_t *get_desc( int what )
 {
 	int i;
-
+	
 	for( i=0; resource_arr[i].desc; i++ )
 	{
 		if( resource_arr[i].resource == what )
@@ -217,53 +217,53 @@ static int set( int resource, int hard, int soft, rlim_t value )
 {
 	struct rlimit ls;
 	getrlimit( resource, &ls );
-
+	
 	if( hard )
 	{
 		ls.rlim_max = value;
 	}
-
+	
 	if( soft )
 	{
 		ls.rlim_cur = value;
-
+		
 		/*
 		  Do not attempt to set the soft limit higher than the hard limit
 		*/
-		if( ( value == RLIM_INFINITY && ls.rlim_max != RLIM_INFINITY ) ||
+		if( ( value == RLIM_INFINITY && ls.rlim_max != RLIM_INFINITY ) || 
 			( value != RLIM_INFINITY && ls.rlim_max != RLIM_INFINITY && value > ls.rlim_max))
 		{
 			ls.rlim_cur = ls.rlim_max;
-		}
+		}		
 	}
-
+	
 	if( setrlimit( resource, &ls ) )
 	{
 		if( errno == EPERM )
-			sb_printf( sb_err, L"ulimit: Permission denied when changing resource of type '%ls'\n", get_desc( resource ) );
+			append_format(stderr_buffer, L"ulimit: Permission denied when changing resource of type '%ls'\n", get_desc( resource ) );
 		else
 			builtin_wperror( L"ulimit" );
 		return 1;
-	}
-	return 0;
+	}	
+	return 0;	
 }
 
 /**
    The ulimit builtin, used for setting resource limits. Defined in
    builtin_ulimit.c.
 */
-static int builtin_ulimit( wchar_t ** argv )
+static int builtin_ulimit( parser_t &parser, wchar_t ** argv )
 {
 	int hard=0;
 	int soft=0;
-
+	
 	int what = RLIMIT_FSIZE;
 	int report_all = 0;
 
 	int argc = builtin_count_args( argv );
-
+	
 	woptind=0;
-
+	
 	while( 1 )
 	{
 		static const struct woption
@@ -321,40 +321,40 @@ static int builtin_ulimit( wchar_t ** argv )
 					L"virtual-memory-size", no_argument, 0, 'v'
 				}
 				,
-				{
-					L"help", no_argument, 0, 'h'
-				}
+				{ 
+					L"help", no_argument, 0, 'h' 
+				} 
 				,
 				{
-					0, 0, 0, 0
+					0, 0, 0, 0 
 				}
 			}
-		;
-
+		;		
+		
 
 		int opt_index = 0;
-
+		
 		int opt = wgetopt_long( argc,
-								argv,
-								L"aHScdflmnstuvh",
-								long_options,
+								argv, 
+								L"aHScdflmnstuvh", 
+								long_options, 
 								&opt_index );
 		if( opt == -1 )
 			break;
-
+			
 		switch( opt )
 		{
 			case 0:
 				if(long_options[opt_index].flag != 0)
 					break;
-                sb_printf( sb_err,
+                append_format(stderr_buffer,
                            BUILTIN_ERR_UNKNOWN,
                            argv[0],
                            long_options[opt_index].name );
-				builtin_print_help( argv[0], sb_err );
+				builtin_print_help( parser, argv[0], stderr_buffer );
 
 				return 1;
-
+				
 			case L'a':
 				report_all=1;
 				break;
@@ -364,17 +364,17 @@ static int builtin_ulimit( wchar_t ** argv )
 				break;
 
 			case L'S':
-				soft=1;
+				soft=1;				
 				break;
 
 			case L'c':
 				what=RLIMIT_CORE;
 				break;
-
+				
 			case L'd':
 				what=RLIMIT_DATA;
 				break;
-
+				
 			case L'f':
 				what=RLIMIT_FSIZE;
 				break;
@@ -384,45 +384,45 @@ static int builtin_ulimit( wchar_t ** argv )
 				break;
 #endif
 
-#ifdef RLIMIT_RSS
+#ifdef RLIMIT_RSS				
 			case L'm':
 				what=RLIMIT_RSS;
 				break;
 #endif
-
+				
 			case L'n':
 				what=RLIMIT_NOFILE;
 				break;
-
+				
 			case L's':
 				what=RLIMIT_STACK;
 				break;
-
+				
 			case L't':
 				what=RLIMIT_CPU;
 				break;
-
-#ifdef RLIMIT_NPROC
+			
+#ifdef RLIMIT_NPROC	
 			case L'u':
 				what=RLIMIT_NPROC;
 				break;
 #endif
-
-#ifdef RLIMIT_AS
+				
+#ifdef RLIMIT_AS				
 			case L'v':
 				what=RLIMIT_AS;
 				break;
 #endif
-
+				
 			case L'h':
-				builtin_print_help( argv[0], sb_out );
+				builtin_print_help( parser, argv[0], stdout_buffer );				
 				return 0;
 
 			case L'?':
-				builtin_unknown_option( argv[0], argv[woptind-1] );
-				return 1;
+				builtin_unknown_option( parser, argv[0], argv[woptind-1] );
+				return 1;	
 		}
-	}
+	}		
 
 	if( report_all )
 	{
@@ -432,17 +432,15 @@ static int builtin_ulimit( wchar_t ** argv )
 		}
 		else
 		{
-			sb_append( sb_err,
-						argv[0],
-						L": Too many arguments\n",
-						(void *)0 );
-			builtin_print_help( argv[0], sb_err );
+            stderr_buffer.append(argv[0]);
+            stderr_buffer.append(L": Too many arguments\n");
+			builtin_print_help( parser, argv[0], stderr_buffer );
 			return 1;
 		}
 
 		return 0;
 	}
-
+	
 	switch( argc - woptind )
 	{
 		case 0:
@@ -453,7 +451,7 @@ static int builtin_ulimit( wchar_t ** argv )
 			print( what, hard );
 			break;
 		}
-
+		
 		case 1:
 		{
 			/*
@@ -469,7 +467,7 @@ static int builtin_ulimit( wchar_t ** argv )
 			{
 				hard=soft=1;
 			}
-
+			
 			if( wcscasecmp( argv[woptind], L"unlimited" )==0)
 			{
 				new_limit = RLIM_INFINITY;
@@ -484,33 +482,31 @@ static int builtin_ulimit( wchar_t ** argv )
 			}
 			else
 			{
-				errno=0;
+				errno=0;				
 				new_limit = wcstol( argv[woptind], &end, 10 );
 				if( errno || *end )
 				{
-					sb_printf( sb_err,
-							   L"%ls: Invalid limit '%ls'\n",
-							   argv[0],
+					append_format(stderr_buffer, 
+							   L"%ls: Invalid limit '%ls'\n", 
+							   argv[0], 
 							   argv[woptind] );
-					builtin_print_help( argv[0], sb_err );
+					builtin_print_help( parser, argv[0], stderr_buffer );
 					return 1;
 				}
 				new_limit *= get_multiplier( what );
 			}
-
+			
 			return set( what, hard, soft, new_limit );
 		}
-
+		
 		default:
 		{
-			sb_append( sb_err,
-						argv[0],
-						L": Too many arguments\n",
-						(void *)0 );
-			builtin_print_help( argv[0], sb_err );
+            stderr_buffer.append(argv[0]);
+            stderr_buffer.append(L": Too many arguments\n");
+			builtin_print_help( parser, argv[0], stderr_buffer );
 			return 1;
 		}
-
+		
 	}
-	return 0;
+	return 0;	
 }

color.cpp

@@ -0,0 +1,266 @@
+/** \file color.cpp Color class implementation
+*/
+
+#include "color.h"
+#include "fallback.h"
+
+bool rgb_color_t::try_parse_special(const wcstring &special) {
+    bzero(&data, sizeof data);
+    const wchar_t *name = special.c_str();
+    if (! wcscasecmp(name, L"normal")) {
+        this->type = type_normal;
+    } else if (! wcscasecmp(name, L"reset")) {
+        this->type = type_reset;
+    } else if (! wcscasecmp(name, L"ignore")) {
+        this->type = type_ignore;
+    } else {
+        this->type = type_none;
+    }
+    return this->type != type_none;
+}
+
+static int parse_hex_digit(wchar_t x) {
+    switch (x) {
+        case L'0': return 0x0;
+        case L'1': return 0x1;
+        case L'2': return 0x2;
+        case L'3': return 0x3;
+        case L'4': return 0x4;
+        case L'5': return 0x5;
+        case L'6': return 0x6;
+        case L'7': return 0x7;
+        case L'8': return 0x8;
+        case L'9': return 0x9;
+        case L'a':case L'A': return 0xA;
+        case L'b':case L'B': return 0xB;
+        case L'c':case L'C': return 0xC;
+        case L'd':case L'D': return 0xD;
+        case L'e':case L'E': return 0xE;
+        case L'f':case L'F': return 0xF;
+        default: return -1;
+    }
+}
+
+static unsigned long squared_difference(long p1, long p2)
+{
+    unsigned long diff = (unsigned long)labs(p1 - p2);
+    return diff * diff;
+}
+
+static unsigned char convert_color(const unsigned char rgb[3], const uint32_t *colors, size_t color_count) {
+    long r = rgb[0], g = rgb[1], b = rgb[2];
+    unsigned long best_distance = (unsigned long)(-1);
+    unsigned char best_index = (unsigned char)(-1);
+    for (unsigned char idx = 0; idx < color_count; idx++) {
+        uint32_t color = colors[idx];
+        long test_r = (color >> 16) & 0xFF, test_g = (color >> 8) & 0xFF, test_b = (color >> 0) & 0xFF;
+        unsigned long distance = squared_difference(r, test_r) + squared_difference(g, test_g) + squared_difference(b, test_b);
+        if (distance <= best_distance) {
+            best_index = idx;
+            best_distance = distance;
+        }
+    }
+    return best_index;
+
+}
+
+bool rgb_color_t::try_parse_rgb(const wcstring &name) {
+    bzero(&data, sizeof data);
+    /* We support the following style of rgb formats (case insensitive):
+        #FA3
+        #F3A035
+        FA3
+        F3A035
+    */
+    
+    size_t digit_idx = 0, len = name.size();
+    
+    /* Skip any leading # */
+    if (len > 0 && name.at(0) == L'#')
+        digit_idx++;
+    
+    bool success = false;
+    size_t i;
+    if (len - digit_idx == 3) {
+        // type FA3
+        for (i=0; i < 3; i++) {
+            int val = parse_hex_digit(name.at(digit_idx++));
+            if (val < 0) break;
+            data.rgb[i] = val*16+val;
+        }
+        success = (i == 3);
+    } else if (len - digit_idx == 6) {
+        // type F3A035
+        for (i=0; i < 3; i++) {
+            int hi = parse_hex_digit(name.at(digit_idx++));
+            int lo = parse_hex_digit(name.at(digit_idx++));
+            if (lo < 0 || hi < 0) break;
+            data.rgb[i] = hi*16+lo;
+        }
+        success = (i == 3);
+    } 
+    if (success) {
+        this->type = type_rgb;
+    }
+    return success;
+}
+
+struct named_color_t {
+    const wchar_t * name;
+    unsigned char idx;
+    unsigned char rgb[3];
+};
+
+static const named_color_t named_colors[11] = {
+    {L"black", 0, {0, 0, 0}},
+    {L"red", 1, {0xFF, 0, 0}},
+    {L"green", 2, {0, 0xFF, 0}},
+    {L"brown", 3, {0x72, 0x50, 0}},
+    {L"yellow", 3, {0xFF, 0xFF, 0}},
+    {L"blue", 4, {0, 0, 0xFF}},
+    {L"magenta", 5, {0xFF, 0, 0xFF}},
+    {L"purple", 5, {0xFF, 0, 0xFF}},
+    {L"cyan", 6, {0, 0xFF, 0xFF}},
+    {L"white", 7, {0xFF, 0xFF, 0xFF}},
+    {L"normal", 8, {0xFF, 0xFF, 0XFF}}
+};
+
+bool rgb_color_t::try_parse_named(const wcstring &str) {
+    bzero(&data, sizeof data);
+    size_t max = sizeof named_colors / sizeof *named_colors;
+    for (size_t idx=0; idx < max; idx++) {
+        if (0 == wcscasecmp(str.c_str(), named_colors[idx].name)) {
+            data.name_idx = named_colors[idx].idx;
+            this->type = type_named;
+            return true;
+        }
+    }
+    return false;
+}
+
+static const wchar_t *name_for_color_idx(unsigned char idx) {
+    size_t max = sizeof named_colors / sizeof *named_colors;
+    for (size_t i=0; i < max; i++) {
+        if (named_colors[i].idx == idx) {
+            return named_colors[i].name;
+        }
+    }
+    return L"unknown";
+}
+
+rgb_color_t::rgb_color_t(unsigned char t, unsigned char i) : type(t), flags(), data() {
+    data.name_idx = i;
+}
+
+rgb_color_t rgb_color_t::normal() { return rgb_color_t(type_normal); }    
+rgb_color_t rgb_color_t::reset() { return rgb_color_t(type_reset); }
+rgb_color_t rgb_color_t::ignore() { return rgb_color_t(type_ignore); }
+rgb_color_t rgb_color_t::none() { return rgb_color_t(type_none); }
+rgb_color_t rgb_color_t::white() { return rgb_color_t(type_named, 7); }
+rgb_color_t rgb_color_t::black() { return rgb_color_t(type_named, 0); }
+
+static unsigned char term8_color_for_rgb(const unsigned char rgb[3]) {
+    const uint32_t kColors[] = {
+        0x000000, //Black
+        0xFF0000, //Red
+        0x00FF00, //Green
+        0xFFFF00, //Yellow
+        0x0000FF, //Blue
+        0xFF00FF, //Magenta
+        0x00FFFF, //Cyan
+        0xFFFFFF, //White
+    };
+    return convert_color(rgb, kColors, sizeof kColors / sizeof *kColors);
+}
+
+static unsigned char term256_color_for_rgb(const unsigned char rgb[3]) {
+    const uint32_t kColors[240] = {
+        0x000000, 0x00005f, 0x000087, 0x0000af, 0x0000d7, 0x0000ff, 0x005f00, 0x005f5f,
+        0x005f87, 0x005faf, 0x005fd7, 0x005fff, 0x008700, 0x00875f, 0x008787, 0x0087af,
+        0x0087d7, 0x0087ff, 0x00af00, 0x00af5f, 0x00af87, 0x00afaf, 0x00afd7, 0x00afff,
+        0x00d700, 0x00d75f, 0x00d787, 0x00d7af, 0x00d7d7, 0x00d7ff, 0x00ff00, 0x00ff5f,
+        0x00ff87, 0x00ffaf, 0x00ffd7, 0x00ffff, 0x5f0000, 0x5f005f, 0x5f0087, 0x5f00af,
+        0x5f00d7, 0x5f00ff, 0x5f5f00, 0x5f5f5f, 0x5f5f87, 0x5f5faf, 0x5f5fd7, 0x5f5fff,
+        0x5f8700, 0x5f875f, 0x5f8787, 0x5f87af, 0x5f87d7, 0x5f87ff, 0x5faf00, 0x5faf5f,
+        0x5faf87, 0x5fafaf, 0x5fafd7, 0x5fafff, 0x5fd700, 0x5fd75f, 0x5fd787, 0x5fd7af,
+        0x5fd7d7, 0x5fd7ff, 0x5fff00, 0x5fff5f, 0x5fff87, 0x5fffaf, 0x5fffd7, 0x5fffff,
+        0x870000, 0x87005f, 0x870087, 0x8700af, 0x8700d7, 0x8700ff, 0x875f00, 0x875f5f, 
+        0x875f87, 0x875faf, 0x875fd7, 0x875fff, 0x878700, 0x87875f, 0x878787, 0x8787af, 
+        0x8787d7, 0x8787ff, 0x87af00, 0x87af5f, 0x87af87, 0x87afaf, 0x87afd7, 0x87afff, 
+        0x87d700, 0x87d75f, 0x87d787, 0x87d7af, 0x87d7d7, 0x87d7ff, 0x87ff00, 0x87ff5f, 
+        0x87ff87, 0x87ffaf, 0x87ffd7, 0x87ffff, 0xaf0000, 0xaf005f, 0xaf0087, 0xaf00af, 
+        0xaf00d7, 0xaf00ff, 0xaf5f00, 0xaf5f5f, 0xaf5f87, 0xaf5faf, 0xaf5fd7, 0xaf5fff, 
+        0xaf8700, 0xaf875f, 0xaf8787, 0xaf87af, 0xaf87d7, 0xaf87ff, 0xafaf00, 0xafaf5f, 
+        0xafaf87, 0xafafaf, 0xafafd7, 0xafafff, 0xafd700, 0xafd75f, 0xafd787, 0xafd7af, 
+        0xafd7d7, 0xafd7ff, 0xafff00, 0xafff5f, 0xafff87, 0xafffaf, 0xafffd7, 0xafffff, 
+        0xd70000, 0xd7005f, 0xd70087, 0xd700af, 0xd700d7, 0xd700ff, 0xd75f00, 0xd75f5f, 
+        0xd75f87, 0xd75faf, 0xd75fd7, 0xd75fff, 0xd78700, 0xd7875f, 0xd78787, 0xd787af, 
+        0xd787d7, 0xd787ff, 0xd7af00, 0xd7af5f, 0xd7af87, 0xd7afaf, 0xd7afd7, 0xd7afff, 
+        0xd7d700, 0xd7d75f, 0xd7d787, 0xd7d7af, 0xd7d7d7, 0xd7d7ff, 0xd7ff00, 0xd7ff5f, 
+        0xd7ff87, 0xd7ffaf, 0xd7ffd7, 0xd7ffff, 0xff0000, 0xff005f, 0xff0087, 0xff00af, 
+        0xff00d7, 0xff00ff, 0xff5f00, 0xff5f5f, 0xff5f87, 0xff5faf, 0xff5fd7, 0xff5fff, 
+        0xff8700, 0xff875f, 0xff8787, 0xff87af, 0xff87d7, 0xff87ff, 0xffaf00, 0xffaf5f, 
+        0xffaf87, 0xffafaf, 0xffafd7, 0xffafff, 0xffd700, 0xffd75f, 0xffd787, 0xffd7af, 
+        0xffd7d7, 0xffd7ff, 0xffff00, 0xffff5f, 0xffff87, 0xffffaf, 0xffffd7, 0xffffff, 
+        0x080808, 0x121212, 0x1c1c1c, 0x262626, 0x303030, 0x3a3a3a, 0x444444, 0x4e4e4e, 
+        0x585858, 0x626262, 0x6c6c6c, 0x767676, 0x808080, 0x8a8a8a, 0x949494, 0x9e9e9e, 
+        0xa8a8a8, 0xb2b2b2, 0xbcbcbc, 0xc6c6c6, 0xd0d0d0, 0xdadada, 0xe4e4e4, 0xeeeeee
+    };
+    return 16 + convert_color(rgb, kColors, sizeof kColors / sizeof *kColors);
+}
+
+unsigned char rgb_color_t::to_term256_index() const {
+    assert(type == type_rgb);
+    return term256_color_for_rgb(data.rgb);
+}
+
+unsigned char rgb_color_t::to_name_index() const {
+    assert(type == type_named || type == type_rgb);
+    if (type == type_named) {
+        return data.name_idx;
+    } else if (type == type_rgb) {
+        return term8_color_for_rgb(data.rgb);
+    } else {
+        /* This is an error */
+        return (unsigned char)(-1);
+    }
+}
+
+void rgb_color_t::parse(const wcstring &str) {
+    bool success = false;
+    if (! success) success = try_parse_special(str);
+    if (! success) success = try_parse_named(str);
+    if (! success) success = try_parse_rgb(str);
+    if (! success) {
+        bzero(this->data.rgb, sizeof this->data.rgb);
+        this->type = type_none;
+    }
+}
+
+rgb_color_t::rgb_color_t(const wcstring &str) {
+    this->parse(str);
+}
+
+rgb_color_t::rgb_color_t(const std::string &str) {
+    this->parse(str2wcstring(str));
+}
+
+wcstring rgb_color_t::description() const {
+    switch (type) {
+        case type_none:
+            return L"none";
+        case type_named:
+            return format_string(L"named(%d: %ls)", (int)data.name_idx, name_for_color_idx(data.name_idx));
+        case type_rgb:
+            return format_string(L"rgb(0x%02x%02x%02x)", data.rgb[0], data.rgb[1], data.rgb[2]);
+        case type_reset:
+            return L"reset";
+        case type_normal:
+            return L"normal";
+        case type_ignore:
+            return L"ignore";
+        default:
+            abort();
+            return L"";
+    }
+}

color.h

@@ -0,0 +1,133 @@
+/** \file color.h Color class.
+  */
+#ifndef FISH_COLOR_H
+#define FISH_COLOR_H
+
+#include <stdint.h>
+#include <cstddef>
+#include "config.h"
+#include "common.h"
+
+
+/* A type that represents a color. We work hard to keep it at a size of 4 bytes. */
+class rgb_color_t {
+
+    /* Types */
+    enum {
+        type_none,
+        type_named,
+        type_rgb,
+        type_normal,
+        type_reset,
+        type_ignore
+    };
+    unsigned char type:4;
+    
+    /* Flags */
+    enum {
+        flag_bold = 1 << 0,
+        flag_underline = 1 << 1
+    };
+    unsigned char flags:4;
+    
+    union {
+        unsigned char name_idx; //0-10
+        unsigned char rgb[3];
+    } data;
+            
+    /** Try parsing a special color name like "normal" */
+    bool try_parse_special(const wcstring &str);
+    
+    /** Try parsing an rgb color like "#F0A030" */
+    bool try_parse_rgb(const wcstring &str);
+
+    /** Try parsing an explicit color name like "magenta" */
+    bool try_parse_named(const wcstring &str);
+
+    /* Parsing entry point */
+    void parse(const wcstring &str);
+
+    /** Private constructor */
+    explicit rgb_color_t(unsigned char t, unsigned char i=0);
+    
+    public:
+    
+    /** Default constructor of type none */
+    explicit rgb_color_t() : type(type_none), flags(), data() {}
+    
+    /** Parse a color from a string */
+    explicit rgb_color_t(const wcstring &str);
+    explicit rgb_color_t(const std::string &str);
+
+    /** Returns white */    
+    static rgb_color_t white();
+    
+    /** Returns black */
+    static rgb_color_t black();
+    
+    /** Returns the reset special color */
+    static rgb_color_t reset();
+    
+    /** Returns the normal special color */
+    static rgb_color_t normal();
+    
+    /** Returns the ignore special color */
+    static rgb_color_t ignore();
+    
+    /** Returns the none special color */
+    static rgb_color_t none();
+        
+    /** Returns whether the color is the ignore special color */
+    bool is_ignore(void) const { return type == type_ignore; }
+
+    /** Returns whether the color is the normal special color */
+    bool is_normal(void) const { return type == type_normal; }
+    
+    /** Returns whether the color is the reset special color */
+    bool is_reset(void) const { return type == type_reset; }
+    
+    /** Returns whether the color is the none special color */
+    bool is_none(void) const { return type == type_none; }
+    
+    /** Returns whether the color is a named color (like "magenta") */
+    bool is_named(void) const { return type == type_named; }
+    
+    /** Returns whether the color is specified via RGB components */
+    bool is_rgb(void) const { return type == type_rgb; }
+    
+    /** Returns whether the color is special, that is, not rgb or named */
+    bool is_special(void) const { return type != type_named && type != type_rgb; }
+
+    /** Returns a description of the color */
+    wcstring description() const;
+
+    /** Returns the name index for the given color. Requires that the color be named or RGB. */
+    unsigned char to_name_index() const;
+    
+    /** Returns the term256 index for the given color. Requires that the color be named or RGB. */
+    unsigned char to_term256_index() const;
+    
+    /** Returns whether the color is bold */
+    bool is_bold() const { return flags & flag_bold; }
+    
+    /** Set whether the color is bold */
+    void set_bold(bool x) { if (x) flags |= flag_bold; else flags &= ~flag_bold; }
+    
+    /** Returns whether the color is underlined */
+    bool is_underline() const { return !! (flags & flag_underline); }
+    
+    /** Set whether the color is underlined */
+    void set_underline(bool x) { if (x) flags |= flag_underline; else flags &= ~flag_underline; }
+    
+    /** Compare two colors for equality */
+    bool operator==(const rgb_color_t &other) const {
+        return type == other.type && ! memcmp(&data, &other.data, sizeof data);
+    }
+    
+    /** Compare two colors for inequality */
+    bool operator!=(const rgb_color_t &other) const {
+        return !(*this == other);
+    }
+};
+
+#endif

common.h

@@ -12,9 +12,22 @@
 #include <stdio.h>
 #include <wchar.h>
 #include <termios.h>
+#include <string>
+#include <sstream>
+#include <vector>
+#include <pthread.h>
+#include <string.h>
 
+#include <errno.h>
+#include <assert.h>
 #include "util.h"
 
+class completion_t;
+
+/* Common string type */
+typedef std::wstring wcstring;
+typedef std::vector<wcstring> wcstring_list_t;
+
 /**
    Maximum number of bytes used by a single utf-8 character
 */
@@ -50,20 +63,31 @@
  */
 #define UNESCAPE_INCOMPLETE 2
 
-/**
-   Escape all characters, including magic characters like the semicolon
- */
-#define ESCAPE_ALL 1
-/**
-   Do not try to use 'simplified' quoted escapes, and do not use empty quotes as the empty string
- */
-#define ESCAPE_NO_QUOTED 2
-
+/* Flags for the escape() and escape_string() functions */
+enum {
+    /** Escape all characters, including magic characters like the semicolon */
+     ESCAPE_ALL = 1 << 0,
+     
+    /** Do not try to use 'simplified' quoted escapes, and do not use empty quotes as the empty string */
+    ESCAPE_NO_QUOTED = 1 << 1,
+    
+    /** Do not escape tildes */
+    ESCAPE_NO_TILDE = 1 << 2
+};
+typedef unsigned int escape_flags_t;
 
 /**
+ Helper macro for errors
+ */
+#define VOMIT_ON_FAILURE(a) do { if (0 != (a)) { int err = errno; fprintf(stderr, "%s failed on line %d in file %s: %d (%s)\n", #a, __LINE__, __FILE__, err, strerror(err)); abort(); }} while (0)
+
+/** Exits without invoking destructors (via _exit), useful for code after fork. */
+void exit_without_destructors(int code) __attribute__ ((noreturn));
+
+/** 
 	Save the shell mode on startup so we can restore them on exit
 */
-extern struct termios shell_modes;
+extern struct termios shell_modes;      
 
 /**
    The character to use where the text has been truncated. Is an
@@ -86,7 +110,7 @@ extern char *profile;
    Name of the current program. Should be set at startup. Used by the
    debug function.
 */
-extern wchar_t *program_name;
+extern const wchar_t *program_name;
 
 /**
    This macro is used to check that an input argument is not null. It
@@ -98,7 +122,7 @@ extern wchar_t *program_name;
 	if( !(arg) )														\
 	{																	\
 		debug( 0,														\
-			   _( L"function %s called with null value for argument %s. " ), \
+			   "function %s called with null value for argument %s. ",  \
 			   __func__,												\
 			   #arg );													\
 		bugreport();													\
@@ -111,12 +135,12 @@ extern wchar_t *program_name;
 */
 #define FATAL_EXIT()											\
 	{															\
-		int exit_read_count;char exit_read_buff;				\
+		char exit_read_buff;			\
 		show_stackframe();										\
-		exit_read_count=read( 0, &exit_read_buff, 1 );			\
-		exit( 1 );												\
+		read( 0, &exit_read_buff, 1 );			\
+		exit_without_destructors( 1 );												\
 	}															\
-
+		
 
 /**
    Exit program at once, leaving an error message about running out of memory.
@@ -124,8 +148,8 @@ extern wchar_t *program_name;
 #define DIE_MEM()														\
 	{																	\
 		fwprintf( stderr,												\
-				  L"fish: Out of memory on line %d of file %s, shutting down fish\n", \
-				  __LINE__,												\
+				  L"fish: Out of memory on line %ld of file %s, shutting down fish\n", \
+				  (long)__LINE__,												\
 				  __FILE__ );											\
 		FATAL_EXIT();														\
 	}
@@ -138,63 +162,45 @@ extern wchar_t *program_name;
 	if( signal_is_blocked() )											\
 	{																	\
 		debug( 0,														\
-			   _( L"function %s called while blocking signals. " ),		\
+			    "function %s called while blocking signals. ",  		\
 			   __func__);												\
 		bugreport();													\
 		show_stackframe();												\
 		return retval;													\
 	}
-
+		
 /**
    Shorthand for wgettext call
 */
-#define _(wstr) wgettext(wstr)
+#define _(wstr) wgettext((const wchar_t *)wstr)
 
 /**
    Noop, used to tell xgettext that a string should be translated,
-   even though it is not directly sent to wgettext.
+   even though it is not directly sent to wgettext. 
 */
 #define N_(wstr) wstr
 
 /**
-   Check if the specified stringelement is a part of the specified string list
+   Check if the specified string element is a part of the specified string list
  */
-#define contains( str,... ) contains_internal( str, __VA_ARGS__, (void *)0 )
-/**
-   Concatenate all the specified strings into a single newly allocated one
- */
-#define wcsdupcat( str,... ) wcsdupcat_internal( str, __VA_ARGS__, (void *)0 )
+#define contains( str,... ) contains_internal( str, __VA_ARGS__, NULL )
 
 /**
   Print a stack trace to stderr
 */
 void show_stackframe();
 
-/**
-   Take an array_list_t containing wide strings and converts them to a
-   single null-terminated wchar_t **. The array is allocated using
-   malloc, and needs to be fred's by the caller.
-*/
-wchar_t **list_to_char_arr( array_list_t *l );
 
 /**
-   Read a line from the stream f into the buffer buff of length len. If
-   buff is to small, it will be reallocated, and both buff and len will
-   be updated to reflect this. Returns the number of bytes read or -1
-   on failiure.
+   Read a line from the stream f into the string. Returns 
+   the number of bytes read or -1 on failiure.
 
    If the carriage return character is encountered, it is
    ignored. fgetws() considers the line to end if reading the file
    results in either a newline (L'\n') character, the null (L'\\0')
    character or the end of file (WEOF) character.
 */
-int fgetws2( wchar_t **buff, int *len, FILE *f );
-
-/**
-   Sorts an array_list of wide strings according to the
-   wcsfilecmp-function from the util library
-*/
-void sort_list( array_list_t *comp );
+int fgetws2(wcstring *s, FILE *f);
 
 /**
    Returns a newly allocated wide character string equivalent of the
@@ -205,6 +211,16 @@ void sort_list( array_list_t *comp );
 */
 wchar_t *str2wcs( const char *in );
 
+/**
+ Returns a newly allocated wide character string equivalent of the
+ specified multibyte character string
+ 
+ This function encodes illegal character sequences in a reversible
+ way using the private use area.
+ */
+wcstring str2wcstring( const char *in );
+wcstring str2wcstring( const std::string &in );
+
 /**
    Converts the narrow character string \c in into it's wide
    equivalent, stored in \c out. \c out must have enough space to fit
@@ -223,6 +239,35 @@ wchar_t *str2wcs_internal( const char *in, wchar_t *out );
    way using the private use area.
 */
 char *wcs2str( const wchar_t *in );
+std::string wcs2string(const wcstring &input);
+
+/** Test if a string prefixes another. Returns true if a is a prefix of b */
+bool string_prefixes_string(const wcstring &proposed_prefix, const wcstring &value);
+bool string_prefixes_string(const wchar_t *proposed_prefix, const wcstring &value);
+
+/** Test if a string is a suffix of another */
+bool string_suffixes_string(const wcstring &proposed_suffix, const wcstring &value);
+bool string_suffixes_string(const wchar_t *proposed_suffix, const wcstring &value);
+
+
+/** Test if a string prefixes another without regard to case. Returns true if a is a prefix of b */
+bool string_prefixes_string_case_insensitive(const wcstring &proposed_prefix, const wcstring &value);
+
+/** Test if a list contains a string using a linear search. */
+bool list_contains_string(const wcstring_list_t &list, const wcstring &str);
+
+
+void assert_is_main_thread(const char *who);
+#define ASSERT_IS_MAIN_THREAD_TRAMPOLINE(x) assert_is_main_thread(x)
+#define ASSERT_IS_MAIN_THREAD() ASSERT_IS_MAIN_THREAD_TRAMPOLINE(__FUNCTION__)
+
+void assert_is_background_thread(const char *who);
+#define ASSERT_IS_BACKGROUND_THREAD_TRAMPOLINE(x) assert_is_background_thread(x)
+#define ASSERT_IS_BACKGROUND_THREAD() ASSERT_IS_BACKGROUND_THREAD_TRAMPOLINE(__FUNCTION__)
+
+/* Useful macro for asserting that a lock is locked. This doesn't check whether this thread locked it, which it would be nice if it did, but here it is anyways. */
+void assert_is_locked(void *mutex, const char *who, const char *caller);
+#define ASSERT_IS_LOCKED(x) assert_is_locked((void *)(&x), #x, __FUNCTION__)
 
 /**
    Converts the wide character string \c in into it's narrow
@@ -234,31 +279,247 @@ char *wcs2str( const wchar_t *in );
 */
 char *wcs2str_internal( const wchar_t *in, char *out );
 
+/** Format the specified size (in bytes, kilobytes, etc.) into the specified stringbuffer. */
+wcstring format_size(long long sz);
+
+/** Version of format_size that does not allocate memory. */
+void format_size_safe(char buff[128], unsigned long long sz);
+
+/** Our crappier versions of debug which is guaranteed to not allocate any memory, or do anything other than call write(). This is useful after a call to fork() with threads. */
+void debug_safe(int level, const char *msg, const char *param1 = NULL, const char *param2 = NULL, const char *param3 = NULL, const char *param4 = NULL, const char *param5 = NULL, const char *param6 = NULL, const char *param7 = NULL, const char *param8 = NULL, const char *param9 = NULL, const char *param10 = NULL, const char *param11 = NULL, const char *param12 = NULL);
+
+/** Writes out a long safely */
+void format_long_safe(char buff[128], long val);
+void format_long_safe(wchar_t buff[128], long val);
+
+
+template<typename T>
+T from_string(const wcstring &x) {
+    T result;
+    std::wstringstream stream(x);
+    stream >> result;
+    return result;
+}
+
+template<typename T>
+T from_string(const std::string &x) {
+    T result = T();
+    std::stringstream stream(x);
+    stream >> result;
+    return result;
+}
+
+template<typename T>
+wcstring to_string(const T &x) {
+    std::wstringstream stream;
+    stream << x;
+    return stream.str();
+}
+
+/* wstringstream is a huge memory pig. Let's provide some specializations where we can. */
+template<>
+inline wcstring to_string(const long &x) {
+    wchar_t buff[128];
+    format_long_safe(buff, x);
+    return wcstring(buff);
+}
+
+template<>
+inline bool from_string(const std::string &x) {
+    return ! x.empty() && strchr("YTyt1", x.at(0));
+}
+
+template<>
+inline bool from_string(const wcstring &x) {
+    return ! x.empty() && wcschr(L"YTyt1", x.at(0));
+}
+
+template<>
+inline wcstring to_string(const int &x) {
+    return to_string(static_cast<long>(x));
+}
+
+
+/* Helper class for managing a null-terminated array of null-terminated strings (of some char type) */
+template <typename CharType_t>
+class null_terminated_array_t {
+    CharType_t **array;
+    
+    typedef std::basic_string<CharType_t> string_t;
+    typedef std::vector<string_t> string_list_t;
+
+    void swap(null_terminated_array_t<CharType_t> &him) { std::swap(array, him.array); }
+
+    /* Silly function to get the length of a null terminated array of...something */
+    template <typename T>
+    static size_t count_not_null(const T *arr) {
+        size_t len;
+        for (len=0; arr[len] != T(0); len++)
+            ;
+        return len;        
+    }
+
+    size_t size() const {
+        return count_not_null(array);
+    }
+
+    void free(void) {
+        if (array != NULL) {
+            for (size_t i = 0; array[i] != NULL; i++) {
+                delete [] array[i];
+            }
+            delete [] array;
+            array = NULL;
+        }
+    }
+        
+    public:
+    null_terminated_array_t() : array(NULL) { }
+    null_terminated_array_t(const string_list_t &argv) : array(NULL) { this->set(argv); }
+    ~null_terminated_array_t() { this->free(); }
+    
+    /** operator=. Notice the pass-by-value parameter. */
+    null_terminated_array_t& operator=(null_terminated_array_t rhs) {
+        if (this != &rhs)
+            this->swap(rhs);
+        return *this;
+    }
+    
+    /* Copy constructor. */
+    null_terminated_array_t(const null_terminated_array_t &him) : array(NULL) {
+        this->set(him.array);
+    }
+    
+    void set(const string_list_t &argv) {
+        /* Get rid of the old argv */
+        this->free();
+
+        /* Allocate our null-terminated array of null-terminated strings */
+        size_t i, count = argv.size();
+        this->array = new CharType_t * [count + 1];
+        for (i=0; i < count; i++) {
+            const string_t &str = argv.at(i);
+            this->array[i] = new CharType_t [1 + str.size()];
+            std::copy(str.begin(), str.end(), this->array[i]);
+            this->array[i][str.size()] = CharType_t(0);
+        }
+        this->array[count] = NULL;
+    }
+    
+    void set(const CharType_t * const *new_array) {
+        if (new_array == array)
+            return;
+            
+        /* Get rid of the old argv */
+        this->free();
+        
+        /* Copy the new one */
+        if (new_array) {
+            size_t i, count = count_not_null(new_array);
+            this->array = new CharType_t * [count + 1];
+            for (i=0; i < count; i++) {
+                size_t len = count_not_null(new_array[i]);
+                this->array[i] = new CharType_t [1 + len];
+                std::copy(new_array[i], new_array[i] + len, this->array[i]);
+                this->array[i][len] = CharType_t(0);
+            }
+            this->array[count] = NULL;
+        }
+    }
+    
+    CharType_t **get() { return array; }
+    const CharType_t * const *get() const { return array; }
+    
+    string_list_t to_list() const {
+        string_list_t lst;
+        if (array != NULL) {
+            size_t count = this->size();
+            lst.reserve(count);
+            lst.insert(lst.end(), array, array + count);
+        }
+        return lst;
+    }
+};
+
+/* Helper function to convert from a null_terminated_array_t<wchar_t> to a null_terminated_array_t<char_t> */
+null_terminated_array_t<char> convert_wide_array_to_narrow(const null_terminated_array_t<wchar_t> &arr);
+
+/* Helper class to cache a narrow version of a wcstring in a malloc'd buffer, so that we can read it after fork() */
+class narrow_string_rep_t {
+    private:
+    const char *str;
+    
+    /* No copying */
+    narrow_string_rep_t &operator=(const narrow_string_rep_t &);
+    narrow_string_rep_t(const narrow_string_rep_t &x);
+    
+    public:
+    ~narrow_string_rep_t() {
+        free((void *)str);
+    }
+    
+    narrow_string_rep_t() : str(NULL) {}
+    
+    void set(const wcstring &s) {
+        free((void *)str);
+        str = wcs2str(s.c_str());
+    }
+    
+    const char *get() const {
+        return str;
+    }
+};
+
+bool is_forked_child();
+
+/* Basic scoped lock class */
+class scoped_lock {
+    pthread_mutex_t *lock_obj;
+    bool locked;
+    
+    /* No copying */
+    scoped_lock &operator=(const scoped_lock &);
+    scoped_lock(const scoped_lock &);
+
+public:
+    void lock(void);
+    void unlock(void);
+    scoped_lock(pthread_mutex_t &mutex);
+    ~scoped_lock();
+};
+
+/* Wrapper around wcstok */
+class wcstokenizer {
+    wchar_t *buffer, *str, *state;
+    const wcstring sep;
+    
+    /* No copying */
+    wcstokenizer &operator=(const wcstokenizer &);
+    wcstokenizer(const wcstokenizer &);
+    
+public:
+    wcstokenizer(const wcstring &s, const wcstring &separator);
+    bool next(wcstring &result);
+    ~wcstokenizer();
+};
+
+/** 
+ Appends a path component, with a / if necessary
+ */
+void append_path_component(wcstring &path, const wcstring &component);
+
+wcstring format_string(const wchar_t *format, ...);
+wcstring vformat_string(const wchar_t *format, va_list va_orig);
+void append_format(wcstring &str, const wchar_t *format, ...);
+
 /**
    Returns a newly allocated wide character string array equivalent of
    the specified multibyte character string array
 */
-char **wcsv2strv( const wchar_t **in );
+char **wcsv2strv( const wchar_t * const *in );
 
 /**
-   Returns a newly allocated multibyte character string array equivalent of the specified wide character string array
-*/
-wchar_t **strv2wcsv( const char **in );
-
-
-/**
-   Returns a newly allocated concatenation of the specified wide
-   character strings. The last argument must be a null pointer.
-*/
-__sentinel wchar_t *wcsdupcat_internal( const wchar_t *a, ... );
-
-/**
-   Test if the given string is a valid variable name
-*/
-
-
-/**
-   Test if the given string is a valid variable name.
+   Test if the given string is a valid variable name. 
 
    \return null if this is a valid name, and a pointer to the first invalid character otherwise
 */
@@ -267,15 +528,15 @@ wchar_t *wcsvarname( const wchar_t *str );
 
 
 /**
-   Test if the given string is a valid function name.
+   Test if the given string is a valid function name. 
 
    \return null if this is a valid name, and a pointer to the first invalid character otherwise
 */
 
-wchar_t *wcsfuncname( const wchar_t *str );
+const wchar_t *wcsfuncname( const wchar_t *str );
 
 /**
-   Test if the given string is valid in a variable name
+   Test if the given string is valid in a variable name 
 
    \return 1 if this is a valid name, 0 otherwise
 */
@@ -311,31 +572,38 @@ void error_reset();
    This function behaves exactly like a wide character equivalent of
    the C function setlocale, except that it will also try to detect if
    the user is using a Unicode character set, and if so, use the
-   unicode ellipsis character as ellipsis, instead of '$'.
+   unicode ellipsis character as ellipsis, instead of '$'.      
 */
-const wchar_t *wsetlocale( int category, const wchar_t *locale );
+wcstring wsetlocale( int category, const wchar_t *locale );
 
 /**
    Checks if \c needle is included in the list of strings specified. A warning is printed if needle is zero.
 
-   \param needle the string to search for in the list
+   \param needle the string to search for in the list 
 
    \return zero if needle is not found, of if needle is null, non-zero otherwise
 */
-__sentinel int contains_internal( const wchar_t *needle, ... );
+__sentinel bool contains_internal( const wchar_t *needle, ... );
+__sentinel bool contains_internal( const wcstring &needle, ... );
 
 /**
    Call read while blocking the SIGCHLD signal. Should only be called
    if you _know_ there is data available for reading, or the program
    will hang until there is data.
 */
-int read_blocked(int fd, void *buf, size_t count);
+long read_blocked(int fd, void *buf, size_t count);
 
 /**
    Loop a write request while failiure is non-critical. Return -1 and set errno
    in case of critical error.
  */
-ssize_t write_loop(int fd, char *buff, size_t count);
+ssize_t write_loop(int fd, const char *buff, size_t count);
+
+/**
+   Loop a read request while failiure is non-critical. Return -1 and set errno
+   in case of critical error.
+ */
+ssize_t read_loop(int fd, void *buff, size_t count);
 
 
 /**
@@ -346,9 +614,9 @@ ssize_t write_loop(int fd, char *buff, size_t count);
    Because debug is often called to tell the user about an error,
    before using wperror to give a specific error message, debug will
    never ever modify the value of errno.
-
+   
    \param level the priority of the message. Lower number means higher priority. Messages with a priority_number higher than \c debug_level will be ignored..
-   \param msg the message format string.
+   \param msg the message format string. 
 
    Example:
 
@@ -356,18 +624,20 @@ ssize_t write_loop(int fd, char *buff, size_t count);
 
    will print the string 'fish: Pi = 3.141', given that debug_level is 1 or higher, and that program_name is 'fish'.
 */
+void debug( int level, const char *msg, ... );
 void debug( int level, const wchar_t *msg, ... );
 
 /**
    Replace special characters with backslash escape sequences. Newline is
-   replaced with \n, etc.
+   replaced with \n, etc. 
 
    \param in The string to be escaped
    \param escape_all Whether all characters wich hold special meaning in fish (Pipe, semicolon, etc,) should be escaped, or only unprintable characters
    \return The escaped string, or 0 if there is not enough memory
 */
 
-wchar_t *escape( const wchar_t *in, int escape_all );
+wchar_t *escape( const wchar_t *in, escape_flags_t flags );
+wcstring escape_string( const wcstring &in, escape_flags_t flags );
 
 /**
    Expand backslashed escapes and substitute them with their unescaped
@@ -380,21 +650,14 @@ wchar_t *escape( const wchar_t *in, int escape_all );
    an invalid sequence is specified, 0 is returned.
 
 */
-wchar_t *unescape( const wchar_t * in,
+wchar_t *unescape( const wchar_t * in, 
 				   int escape_special );
 
-/**
-   Attempt to acquire a lock based on a lockfile, waiting LOCKPOLLINTERVAL
-   milliseconds between polls and timing out after timeout seconds,
-   thereafter forcibly attempting to obtain the lock if force is non-zero.
-   Returns 1 on success, 0 on failure.
-   To release the lock the lockfile must be unlinked.
-   A unique temporary file named by appending characters to the lockfile name
-   is used; any pre-existing file of the same name is subject to deletion.
-*/
-int acquire_lock_file( const char *lockfile, const int timeout, int force );
+bool unescape_string( wcstring &str, 
+                  int escape_special );
 
-/**
+
+/** 
     Returns the width of the terminal window, so that not all
     functions that use these values continually have to keep track of
     it separately.
@@ -422,17 +685,14 @@ void common_handle_winch( int signal );
    Write paragraph of output to the specified stringbuffer, and redo
    the linebreaks to fit the current screen.
 */
-void write_screen( const wchar_t *msg, string_buffer_t *buff );
+void write_screen( const wcstring &msg, wcstring &buff );
 
 /**
-   Tokenize the specified string into the specified array_list_t.
-   Each new element is allocated using malloc and must be freed by the
-   caller.
-
+   Tokenize the specified string into the specified wcstring_list_t.   
    \param val the input string. The contents of this string is not changed.
-   \param out the list in which to place the elements.
+   \param out the list in which to place the elements. 
 */
-void tokenize_variable_array( const wchar_t *val, array_list_t *out );
+void tokenize_variable_array( const wcstring &val, wcstring_list_t &out);
 
 /**
    Make sure the specified direcotry exists. If needed, try to create
@@ -440,19 +700,13 @@ void tokenize_variable_array( const wchar_t *val, array_list_t *out );
 
    \return 0 if, at the time of function return the directory exists, -1 otherwise.
 */
-int create_directory( wchar_t *d );
+int create_directory( const wcstring &d );
 
 /**
    Print a short message about how to file a bug report to stderr
 */
 void bugreport();
 
-/**
-   Format the specified size (in bytes, kilobytes, etc.) into the specified stringbuffer.
-*/
-void sb_format_size( string_buffer_t *sb,
-		     long long sz );
-
 /**
    Return the number of seconds from the UNIX epoch, with subsecond
    precision. This function uses the gettimeofday function, and will
@@ -462,6 +716,32 @@ void sb_format_size( string_buffer_t *sb,
  */
 double timef();
 
+/**
+	Call the following function early in main to set the main thread.
+    This is our replacement for pthread_main_np().
+ */
+void set_main_thread();
+bool is_main_thread();
+
+/** Configures thread assertions for testing */
+void configure_thread_assertions_for_testing();
+
+/** Set up a guard to complain if we try to do certain things (like take a lock) after calling fork */
+void setup_fork_guards(void);
+
+/** Save the value of tcgetpgrp so we can restore it on exit */
+void save_term_foreground_process_group(void);
+void restore_term_foreground_process_group(void);
+
+/** Return whether we are the child of a fork */
+bool is_forked_child(void);
+void assert_is_not_forked_child(const char *who);
+#define ASSERT_IS_NOT_FORKED_CHILD_TRAMPOLINE(x) assert_is_not_forked_child(x)
+#define ASSERT_IS_NOT_FORKED_CHILD() ASSERT_IS_NOT_FORKED_CHILD_TRAMPOLINE(__FUNCTION__)
+
+extern "C" {
+__attribute__((noinline)) void debug_thread_error(void);
+}
+
 
 #endif
-

complete.h

@@ -12,43 +12,44 @@
 */
 #define FISH_COMPLETE_H
 
+
 #include <wchar.h>
 
 #include "util.h"
-
-/**
-	Use all completions
+#include "common.h"
+/** 
+	Use all completions 
 */
 #define SHARED 0
-/**
-	Do not use file completion
+/** 
+	Do not use file completion 
 */
 #define NO_FILES 1
-/**
-	Require a parameter after completion
+/** 
+	Require a parameter after completion 
 */
 #define NO_COMMON 2
-/**
+/** 
 	Only use the argument list specifies with completion after
 	option. This is the same as (NO_FILES & NO_COMMON)
 */
 #define EXCLUSIVE 3
 
-/**
-	Command is a path
+/** 
+	Command is a path 
 */
 #define PATH 1
-/**
-	Command is not a path
+/** 
+	Command is not a path 
 */
 #define COMMAND 0
 
-/**
+/** 
 	Separator between completion and description
 */
 #define COMPLETE_SEP L'\004'
 
-/**
+/** 
 	Separator between completion and description
 */
 #define COMPLETE_SEP_STR L"\004"
@@ -66,56 +67,63 @@
 */
 #define PROG_COMPLETE_SEP L'\t'
 
-/**
-   Do not insert space afterwards if this is the only completion. (The
-   default is to try insert a space)
-*/
-#define COMPLETE_NO_SPACE 1
+enum {
+    /**
+       Do not insert space afterwards if this is the only completion. (The
+       default is to try insert a space)
+    */
+    COMPLETE_NO_SPACE = 1 << 0,
 
-/**
-   This compeltion is case insensitive.
+    /**
+       This compeltion is case insensitive. 
 
-   Warning: The contents of the completion_t structure is actually
-   different if this flag is set! Specifically, the completion string
-   contains the _entire_ completion token, not only the current
-*/
-#define COMPLETE_NO_CASE 2
+       Warning: The contents of the completion_t structure is actually
+       different if this flag is set! Specifically, the completion string
+       contains the _entire_ completion token, not only the current
+    */
+    COMPLETE_NO_CASE = 1 << 1,
 
-/**
-   This compeltion is the whole argument, not just the remainder. This
-   flag must never be set on completions returned from the complete()
-   function. It is strictly for internal use in the completion code.
-*/
-#define COMPLETE_WHOLE_ARGUMENT 4
+    /**
+       This compeltion is the whole argument, not just the remainder. This
+       flag must never be set on completions returned from the complete()
+       function. It is strictly for internal use in the completion code.
+    */
+    COMPLETE_WHOLE_ARGUMENT = 1 << 2,
 
-/**
-   This completion may or may not want a space at the end - guess by
-   checking the last character of the completion.
-*/
-#define COMPLETE_AUTO_SPACE 8
+    /**
+       This completion may or may not want a space at the end - guess by
+       checking the last character of the completion.
+    */
+    COMPLETE_AUTO_SPACE = 1 << 3,
 
-/**
-   This completion should be inserted as-is, without escaping.
-*/
-#define COMPLETE_DONT_ESCAPE 16
+    /**
+       This completion should be inserted as-is, without escaping.
+    */
+    COMPLETE_DONT_ESCAPE = 1 << 4
+};
+typedef int complete_flags_t;
 
 
-
-typedef struct
+class completion_t
 {
 
+private:
+    /* No public default constructor */
+	completion_t();
+public:
+
 	/**
 	   The completion string
 	*/
-	const wchar_t *completion;
+	wcstring completion;
 
 	/**
 	   The description for this completion
 	*/
-	const wchar_t *description;
+	wcstring description;
 
 	/**
-	   Flags determining the completion behaviour.
+	   Flags determining the completion behaviour. 
 
 	   Determines whether a space should be inserted after this
 	   compeltion if it is the only possible completion using the
@@ -125,24 +133,44 @@ typedef struct
 	   is case insensitive.
 	*/
 	int flags;
+    
+    bool is_case_insensitive() const { return !! (flags & COMPLETE_NO_CASE); }
+    
+    /* Construction. Note: defining these so that they are not inlined reduces the executable size. */
+    completion_t(const wcstring &comp, const wcstring &desc = L"", int flags_val = 0);
+    completion_t(const completion_t &);
+    completion_t &operator=(const completion_t &);
+    
+    /* The following are needed for sorting and uniquing completions */
+	bool operator < (const completion_t& rhs) const;
+	bool operator == (const completion_t& rhs) const;
+	bool operator != (const completion_t& rhs) const;
+};
 
-}
-	completion_t;
+enum complete_type_t {
+    COMPLETE_DEFAULT,
+    COMPLETE_AUTOSUGGEST
+};
 
+/** Given a list of completions, returns a list of their completion fields */
+wcstring_list_t completions_to_wcstring_list( const std::vector<completion_t> &completions );
+
+/** Sorts a list of completions */
+void sort_completions( std::vector<completion_t> &completions);
 
 /**
 
-  Add a completion.
+  Add a completion. 
 
   All supplied values are copied, they should be freed by or otherwise
   disposed by the caller.
 
-  Examples:
-
+  Examples: 
+  
   The command 'gcc -o' requires that a file follows it, so the
   NO_COMMON option is suitable. This can be done using the following
   line:
-
+  
   complete -c gcc -s o -r
 
   The command 'grep -d' required that one of the strings 'read',
@@ -159,7 +187,7 @@ typedef struct
   will be interpreted as the command name.
   \param short_opt The single character name of an option. (-a is a short option, --all and  -funroll are long options)
   \param long_opt The multi character name of an option. (-a is a short option, --all and  -funroll are long options)
-  \param long_mode Whether to use old style, single dash long options.
+  \param long_mode Whether to use old style, single dash long options. 
   \param result_mode Whether to search further completions when this
   completion has been succesfully matched. If result_mode is SHARED,
   any other completions may also be used. If result_mode is NO_FILES,
@@ -172,66 +200,57 @@ typedef struct
   \param condition a command to be run to check it this completion should be used. If \c condition is empty, the completion is always used.
   \param flags A set of completion flags
 */
-void complete_add( const wchar_t *cmd,
-		   int cmd_type,
-		   wchar_t short_opt,
-		   const wchar_t *long_opt,
-		   int long_mode,
-		   int result_mode,
-		   const wchar_t *condition,
-		   const wchar_t *comp,
-		   const wchar_t *desc,
-		   int flags );
+void complete_add( const wchar_t *cmd, 
+                   bool cmd_is_path,
+                   wchar_t short_opt,
+                   const wchar_t *long_opt,
+                   int long_mode,
+                   int result_mode,
+                   const wchar_t *condition,
+                   const wchar_t *comp,
+                   const wchar_t *desc,
+                   int flags ); 
 /**
   Sets whether the completion list for this command is complete. If
   true, any options not matching one of the provided options will be
   flagged as an error by syntax highlighting.
 */
-void complete_set_authoritative( const wchar_t *cmd,
-				 int cmd_type,
-				 int authoritative );
+void complete_set_authoritative( const wchar_t *cmd, bool cmd_type, bool authoritative );
 
 /**
   Remove a previously defined completion
 */
-void complete_remove( const wchar_t *cmd,
-		      int cmd_type,
-		      wchar_t short_opt,
-		      const wchar_t *long_opt );
+void complete_remove( const wchar_t *cmd, 
+                      bool cmd_is_path, 
+                      wchar_t short_opt,
+                      const wchar_t *long_opt );
+
+
+/** Find all completions of the command cmd, insert them into out. If to_load is not NULL, append all commands that we would autoload, but did not (presumably because this is not the main thread) */
+void complete( const wcstring &cmd, std::vector<completion_t> &comp, complete_type_t type, wcstring_list_t *to_load = NULL );
 
 /**
-  Find all completions of the command cmd, insert them into out. The
-  caller must free the variables returned in out.  The results are
-  returned in the array_list_t 'out', in the format of wide character
-  strings, with each element consisting of a suggested completion and
-  a description of what kind of object this completion represents,
-  separated by a separator of type COMPLETE_SEP.
+   Print a list of all current completions into the string. 
 
-  Values returned by this function should be freed by the caller.
+   \param out The string to write completions to
 */
-void complete( const wchar_t *cmd, array_list_t *out );
-
-/**
-   Print a list of all current completions into the string_buffer_t.
-
-   \param out The string_buffer_t to write completions to
-*/
-void complete_print( string_buffer_t *out );
+void complete_print( wcstring &out );
 
 /**
    Tests if the specified option is defined for the specified command
 */
-int complete_is_valid_option( const wchar_t *str,
-							  const wchar_t *opt,
-							  array_list_t *errors );
+int complete_is_valid_option( const wcstring &str,
+							  const wcstring &opt,
+							  wcstring_list_t *inErrorsOrNull,
+							  bool allow_autoload );
 
 /**
    Tests if the specified argument is valid for the specified option
    and command
 */
-int complete_is_valid_argument( const wchar_t *str,
-								const wchar_t *opt,
-								const wchar_t *arg );
+bool complete_is_valid_argument( const wcstring &str,
+								 const wcstring &opt,
+								 const wcstring &arg );
 
 
 /**
@@ -243,20 +262,18 @@ int complete_is_valid_argument( const wchar_t *str,
    \param cmd the command for which to load command-specific completions
    \param reload should the commands completions be reloaded, even if they where previously loaded. (This is set to true on actual completions, so that changed completion are updated in running shells)
 */
-void complete_load( const wchar_t *cmd, int reload );
+void complete_load( const wcstring &cmd, bool reload );
 
 /**
    Create a new completion entry
 
-   \param context The halloc context to use for allocating new memory
+   \param completions The array of completions to append to
    \param comp The completion string
    \param desc The description of the completion
    \param flags completion flags
+
 */
-void completion_allocate( array_list_t *context,
-			  const wchar_t *comp,
-			  const wchar_t *desc,
-			  int flags );
+void append_completion(std::vector<completion_t> &completions, const wcstring &comp, const wcstring &desc = L"", int flags = 0);
 
 
 #endif

configure.ac

@@ -9,7 +9,7 @@
 # configure the build process.
 #
 
-AC_INIT(fish,1.23.1,fish-users@lists.sf.net)
+AC_INIT(fish,2.0.0,fish-users@lists.sf.net)
 
 #
 # preserve configure arguments for xsel
@@ -39,6 +39,8 @@ AC_SUBST(XSEL_MAN)
 AC_SUBST(XSEL_BIN)
 AC_SUBST(XSEL_MAN_PATH)
 
+
+
 #
 # If needed, run autoconf to regenerate the configure file
 #
@@ -104,13 +106,14 @@ fi
 # This mostly helps OS X users, since fink usually installs out of
 # tree and doesn't update CFLAGS.
 #
+# It also helps FreeBSD which puts libiconv in /usr/local/lib
 
-for i in /usr/pkg /sw /opt /opt/local; do
+for i in /usr/pkg /sw /opt /opt/local /usr/local; do
 
 	AC_MSG_CHECKING([for $i/include include directory])
 	if test -d $i/include; then
 		AC_MSG_RESULT(yes)
-		CPPFLAGS="$CPPFLAGS -I$i/include/"
+		CXXFLAGS="$CXXFLAGS -I$i/include/"
 		CFLAGS="$CFLAGS -I$i/include/"
 	else
 	AC_MSG_RESULT(no)
@@ -119,7 +122,7 @@ for i in /usr/pkg /sw /opt /opt/local; do
 	AC_MSG_CHECKING([for $i/lib library directory])
 	if test -d $i/lib; then
 		AC_MSG_RESULT(yes)
-		LDFLAGS="$LDFLAGS -L$i/lib/ -R$i/lib/"
+		LDFLAGS="$LDFLAGS -L$i/lib/ -Wl,-rpath,$i/lib/"
 	else
 		AC_MSG_RESULT(no)
 	fi
@@ -159,10 +162,7 @@ AH_BOTTOM([#if __GNUC__ >= 3
 # Set up various programs needed for install
 #
 
-# Here we look for c99 before cc as Sun Studio compiler supports c99
-# through the c99 binary.
-
-AC_PROG_CC([gcc c99 cc])
+AC_PROG_CXX([g++ c++])
 AC_PROG_CPP
 AC_PROG_INSTALL
 
@@ -239,55 +239,13 @@ if test x$local_gettext != xno; then
 fi
 
 
-#
-# Test if the compiler accepts the -std=c99 flag. If so, using it
-# increases the odds of correct compilation, since we want to use the
-# *wprintf functions, which where defined in C99.
-#
-# NOTE: Never versions of autoconf has AC_CHECK_PROG_CC_C99
-#
-
-if test "$CC" != "c99"; then
-  XCFLAGS="$CFLAGS"
-	CFLAGS="$CFLAGS -std=c99"
-	XCPPFLAGS="$CPPFLAGS"
-	CPPFLAGS="$CPPFLAGS -std=c99"
-	AC_MSG_CHECKING(if -std=c99 works)
-
-	AC_CACHE_VAL(
-  	  local_cv_has__std_c99,
-    	[
-      	  AC_TRY_RUN(
-        	    [
-          	      #include <stdlib.h>
-            	    #include <stdio.h>
-
-              	  int main()
-                	{
-                  	  return 0;
-	                }
-	            ],
-	            local_cv_has__std_c99=yes,
-	            local_cv_has__std_c99=no,
-  	      )
-    	]
-	)
-
-	AC_MSG_RESULT($local_cv_has__std_c99)
-	case x$local_cv_has__std_c99 in
-	xno)
-  	  CFLAGS="$XCFLAGS"
-    	CPPFLAGS="$XCPPFLAGS" ;;
-	esac
-fi
-
 #
 # Try to enable large file support. This will make sure that on systems
 # where off_t can be either 32 or 64 bit, the latter size is used. On
 # other systems, this should do nothing. (Hopefully)
 #
 
-CFLAGS="$CFLAGS -D_LARGEFILE_SOURCE=1 -D_FILE_OFFSET_BITS=64"
+CXXFLAGS="$CXXFLAGS -D_LARGEFILE_SOURCE=1 -D_FILE_OFFSET_BITS=64"
 
 #
 # If we are using gcc, set some flags that increase the odds of the
@@ -306,14 +264,15 @@ if test "$GCC" = yes; then
 	# bug has been verified to not exist on Linux using GCC 3.3.3.
 	#
 
-	CFLAGS="$CFLAGS -fno-optimize-sibling-calls"
+	CXXFLAGS="$CXXFLAGS -fno-optimize-sibling-calls"
 
 
 	#
 	# -Wall is there to keep me on my toes
 	#
 
-	CFLAGS="$CFLAGS -Wall"
+	# Some day...
+	CXXFLAGS="$CXXFLAGS -Wall"
 
 	#
 	# This is needed in order to get the really cool backtraces
@@ -512,6 +471,7 @@ LIBS_COMMON=$LIBS
 LIBS=""
 AC_SEARCH_LIBS( connect, socket, , [AC_MSG_ERROR([Cannot find the socket library, needed to build this package.] )] )
 AC_SEARCH_LIBS( nanosleep, rt, , [AC_MSG_ERROR([Cannot find the rt library, needed to build this package.] )] )
+AC_SEARCH_LIBS( pthread_create, pthread, , [AC_MSG_ERROR([Cannot find the pthread library, needed to build this package.] )] )
 AC_SEARCH_LIBS( setupterm, [ncurses curses], , [AC_MSG_ERROR([Could not find a curses implementation, needed to build fish])] )
 AC_SEARCH_LIBS( [nan], [m], [AC_DEFINE( [HAVE_NAN], [1], [Define to 1 if you have the nan function])] )
 LIBS_SHARED=$LIBS
@@ -555,7 +515,7 @@ LIBS="$LIBS_SHARED"
 if test x$local_gettext != xno; then
 	AC_SEARCH_LIBS( gettext, intl,,)
 fi
-AC_SEARCH_LIBS( iconv_open, iconv, , [AC_MSG_ERROR([Could not find an iconv implementation, needed to build fish])] )
+AC_SEARCH_LIBS( iconv_open, iconv, , [AC_SEARCH_LIBS( libiconv_open, iconv, , [AC_MSG_ERROR([Could not find an iconv implementation, needed to build fish])] )] )
 LIBS_FISH_PAGER=$LIBS
 LIBS=$LIBS_COMMON
 
@@ -568,7 +528,7 @@ LIBS="$LIBS_SHARED"
 if test x$local_gettext != xno; then
 	AC_SEARCH_LIBS( gettext, intl,,)
 fi
-AC_SEARCH_LIBS( iconv_open, iconv, , [AC_MSG_ERROR([Could not find an iconv implementation, needed to build fish])] )
+AC_SEARCH_LIBS( iconv_open, iconv, , [AC_SEARCH_LIBS( libiconv_open, iconv, , [AC_MSG_ERROR([Could not find an iconv implementation, needed to build fish])] )] )
 LIBS_FISHD=$LIBS
 LIBS=$LIBS_COMMON
 
@@ -601,7 +561,7 @@ LIBS=$LIBS_COMMON
 # Check presense of various header files
 #
 
-AC_CHECK_HEADERS([getopt.h termio.h sys/resource.h term.h ncurses/term.h ncurses.h curses.h stropts.h siginfo.h sys/select.h sys/ioctl.h sys/termios.h libintl.h execinfo.h])
+AC_CHECK_HEADERS([getopt.h termio.h sys/resource.h term.h ncurses/term.h ncurses.h curses.h stropts.h siginfo.h sys/select.h sys/ioctl.h sys/termios.h libintl.h execinfo.h spawn.h])
 
 AC_CHECK_HEADER(
 	[regex.h],
@@ -645,7 +605,7 @@ AC_CHECK_HEADER(
 # conditional definition of __EXTENSIONS__, to avoid redundant tests.
 #
 
-XCFLAGS="$CFLAGS"
+XCFLAGS="$CXXFLAGS"
 
 echo Checking how to use -D_XOPEN_SOURCE=600 and -D_POSIX_C_SOURCE=200112L...
 local_found_posix_switch=no
@@ -695,19 +655,19 @@ for i in "" "-D_POSIX_C_SOURCE=200112L" "-D_XOPEN_SOURCE=600 -D_POSIX_C_SOURCE=2
 		[
 			/* Avert high-level optimisation, by making the program's
 			 * return value depend on all tested identifiers. */
-			int ret = 0;
+			long ret = 0;
 			/* POSIX only: might be unhidden by _POSIX_C_SOURCE. */
 			struct sigaction sa;
 			sigset_t ss;
 			siginfo_t info;
-			ret += (int)(void *)&info + kill( 0, 0 ) +
+			ret += (long)(void *)&info + kill( 0, 0 ) +
 				sigaction( 0, &sa, 0 ) + sigemptyset( &ss );
 			/* Extended-POSIX: might be unhidden by _XOPEN_SOURCE. */
 			ret += killpg( 0, 0 );
 			/* Non-standard: might be hidden by the macros. */
 			{
 				struct winsize termsize;
-				ret += (int)(void *)&termsize;
+				ret += (long)(void *)&termsize;
 				ret += SIGWINCH + TIOCGWINSZ + SIGIO;
 			}
 			return ret;

doc_src/bind.txt

@@ -45,6 +45,9 @@ bind to the function name. This way it becomes significantly easier to
 test the function while editing, and the result is usually more
 readable as well.
 
+If you want to autoload bindings each time you start shell, you should 
+define them inside fish_user_key_bindings function.
+
 - <tt>-a</tt> or <tt>--all</tt> If --key-names is specified, show all key names, not only the ones that actually are defined for the current terminal. If erase mode is specified, this switch will cause all current bindings to be erased.
 - <tt>-e</tt> or <tt>--erase</tt> Erase mode. All non-switch arguments are interpreted as character sequences and any commands associated with those sequences are erased.
 - <tt>-h</tt> or <tt>--help</tt> Display help and exit

doc_src/contains.txt

@@ -5,6 +5,7 @@
 
 \subsection contains-description Description
 
+- \c -i or \c --index print the the word index
 - \c -h or \c --help display this message
 
 Test if the set VALUES contains the string KEY. Return status is 0 if

doc_src/echo.txt

@@ -0,0 +1,16 @@
+\section echo echo - display a line of text
+
+\subsection echo-synopsis Synopsis
+ <tt>echo [STRING]</tt>
+
+\subsection echo-description Description                                                                                                                             
+                                                                                                                                                                          
+Display a line of text.                                                                                                           
+                                                                                                                                                                          
+- \c -n, \c Do not output a newline
+- \c -s, \c Do not separate arguments with spaces                                                                                                                                
+- \c -h, \c --help Display this help
+
+\subsection echo-example Example
+
+<tt>echo 'Hello World'</tt> Print hello world to stdout

doc_src/fish_config.txt

@@ -0,0 +1,5 @@
+\section fish_config fish_config - Start up the web-based configuration interface
+
+\subsection fish_config-description Description
+
+This command starts up the web-based configuration interface, which allows you to edit your colors and view your functions, variables, and history.

doc_src/fish_prompt.txt

@@ -1,6 +1,6 @@
 \section fish_prompt fish_prompt - define the apperance of the command line prompt
 
-\subsection fish_promt-synopsis Synopsis
+\subsection fish_prompt-synopsis Synopsis
 <pre>function fish_prompt
     ...
 end</pre>
@@ -11,6 +11,9 @@ By defining the \c fish_prompt function, the user can choose a custom
 prompt. The \c fish_prompt function is executed when the prompt is to
 be shown, and the output is used as a prompt.
 
+Please keep in mind that the function is executed by <a
+href='index.html#expand-command-substitution'>command substitution</a>, and so the exit status of commands within fish_prompt will not modify the <a href="index.html#variables-status">$status</a> seen outside of fish_prompt.
+
 \subsection fish_prompt-example Example
 
 A simple prompt:

doc_src/fish_right_prompt.txt

@@ -0,0 +1,23 @@
+\section fish_right_prompt fish_right_prompt - define the apperance of the right-side command line prompt
+
+\subsection fish_right_prompt-synopsis Synopsis
+<pre>function fish_right_prompt
+    ...
+end</pre>
+
+\subsection fish_right_prompt-description Description
+
+\c fish_right_prompt is similar to \c fish_prompt, except that it appears on the right side of the terminal window.
+
+Multiple lines are not supported in \c fish_right_prompt.
+
+\subsection fish_prompt-example Example
+
+A simple right prompt:
+
+<pre>
+function fish_right_prompt -d "Write out the right prompt"
+    date "+%m/%d/%y"
+end
+</pre>
+

doc_src/fish_update_completions.txt

@@ -0,0 +1,6 @@
+\section fish_update_completions fish_update_completions - Update man-page completions
+
+\subsection fish_update_completions-description Description
+
+This command parses your installed man pages and writes completion files to the fish config directory. This does not overwrite custom completions.
+

doc_src/funced.txt

@@ -1,9 +1,14 @@
 \section funced funced - edit a function interactively
 
 \subsection funced-synopsis Synopsis
- <code>funced NAME</code>
+ <code>funced [OPTIONS] NAME</code>
 
 \subsection funced-description Description
 
-Use the funced command to interactively edit the definition of a
-function. If there is no function with the name specified, a skeleton function is inserted, if a function exist, the definion will be shown on the command line.
+Use the funced command to edit the definition of a
+function. If there is no function with the name specified, a skeleton function is inserted, if a function exist, the definition will be shown in your editor or on the command line.
+
+By default, funced edits functions using the text editor in your $EDITOR variable, if set; otherwise it uses the built-in editor.
+
+- <code>-e command</code> or <code>--editor command</code> Open the function body inside the text editor given by the command (for example, "vi"). The command 'fish' will use the built-in editor.
+- <code>-i</code> or <code>--interactive</code> Open function body in built-in editor.

doc_src/history.txt

@@ -0,0 +1,36 @@
+\section history history - Show and manipulate user's command history 
+
+\subsection history-synopsis Synopsis
+<pre>
+history (--save | --clear)
+history (--search | --delete ) (--prefix "prefix string" | --contains "search string")
+</pre>
+
+\subsection history-description Description
+
+history is used to list, search and delete user's command history
+
+\subsection history-examples Example
+
+<pre>
+history --save
+Save all changes in history file
+
+history --clear
+Delete all history items
+
+history --search --contains "foo"
+Searches commands containing "foo" string
+
+history --search --prefix "foo"
+Searches for commands with prefix "foo"
+
+history --delete --contains "foo"
+Interactively delete commands containing string "foo"
+
+history --delete --prefix "foo"
+Interactively delete commands with prefix "foo"
+
+history --delete "foo"
+Delete command "foo" from history
+</pre>

doc_src/if.txt

@@ -1,7 +1,7 @@
 \section if if - conditionally execute a command
 
 \subsection if-synopsis Synopsis
-<tt>if CONDITION; COMMANDS_TRUE...; [else; COMMANDS_FALSE...;] end</tt>
+<tt>if CONDITION; COMMANDS_TRUE...; [else if CONDITION2; COMMANDS_TRUE2...;] [else; COMMANDS_FALSE...;] end</tt>
 
 \subsection if-description Description
 
@@ -24,10 +24,13 @@ variable.
 <pre>
 if test -f foo.txt
 	echo foo.txt exists
+else if test -f bar.txt
+	echo bar.txt exists
 else
-	echo foo.txt does not exist
+	echo foo.txt and bar.txt do not exist
 end
-</pre>
-will print <tt>foo.txt exists</tt> if the file foo.txt
+</pre>will print <tt>foo.txt exists</tt> if the file foo.txt
 exists and is a regular file, otherwise it will print
-<tt>foo.txt does not exist</tt>.
+<tt>bar.txt exists</tt> if the file bar.txt exists
+and is a regular file, otherwise it will print
+<tt>foo.txt and bar.txt do not exist</tt>.

doc_src/index.hdr.in

@@ -11,7 +11,7 @@ This is the documentation for \c fish, the friendly interactive
 shell. \c fish is a user friendly commandline shell intended
 mostly for interactive use. A shell is a program used to execute other
 programs. For the latest information on \c fish, please visit the <a
-href="http://www.fishshell.org"><code>fish</code> homepage</a>.
+href="http://ridiculousfish.com/shell/"><code>fish</code> homepage</a>.
 
 \section syntax Syntax overview
 
@@ -80,7 +80,7 @@ while '-f' will turn it off.
 
 \subsection quotes Quotes
 
-Sometimes features such as <a href="#globbing">parameter expansion</a>
+Sometimes features such as <a href="#expand">parameter expansion</a>
 and <a href="#escapes">character escapes</a> get in the way. When that
 happens, the user can write a parameter within quotes, either '
 (single quote) or " (double quote). There is one important difference
@@ -124,7 +124,7 @@ these characters, so called escape sequences are provided. These are:
 - <code>'\\*'</code>, escapes the star character
 - <code>'\\?'</code>, escapes the question mark character
 - <code>'\\~'</code>, escapes the tilde character
-- <code>'\\%'</code>, escapes the percent character
+- <code>'\\%%'</code>, escapes the percent character
 - <code>'\\#'</code>, escapes the hash character
 - <code>'\\('</code>, escapes the left parenthesis character
 - <code>'\\)'</code>, escapes the right parenthesis character
@@ -581,6 +581,9 @@ A command substitution will not change the value of the <a
 href='#variables-status'>status</a> variable outside of the command
 substitution.
 
+Only part of the output can be used, see <a href='#expand-index-range'>index
+range expansion</a> for details.
+
 Example:
 
 The command <code>echo (basename image.jpg .jpg).png</code> will
@@ -674,6 +677,50 @@ element of the foo variable should be dereferenced and never that the fifth
 element of the doubly dereferenced variable foo. The latter can
 instead be expressed as $$foo[1][5].
 
+\subsection expand-index-range Index range expansion
+
+Both command substitution and environment variables support accessing only 
+specific items by providing a set of indices in square brackets. It's 
+often needed to access a sequence of elements. To do this, one can use
+range operator '..' for this. A range 'a..b', where range limits 'a' and 'b' 
+are integer numbers, is expanded into a sequence of indices 
+'a a+1 a+2 ... b' or 'a a-1 a-2 ... b' depending on which of 'a' or 'b' 
+is higher. The negative range limits are calculated from the end of the array
+or command substitution.
+
+Some examples:
+<pre>
+# Limit the command substitution output
+echo (seq 10)[2..5] # will use elements from 2 to 5
+# Output is:
+# 2 3 4 5
+
+# Use overlapping ranges:
+echo (seq 10)[2..5 1..3] # will take elements from 2 to 5 and then elements from 1 to 3 
+# Output is:
+# 2 3 4 5 1 2 3
+
+# Reverse output
+echo (seq 10)[-1..1] # will use elements from the last output line to the first one in reverse direction
+# Output is:
+# 10 9 8 7 6 5 4 3 2 1
+</pre>
+
+The same works when setting or expanding variables:
+<pre>
+# Reverse path variable
+set PATH $PATH[-1..1]
+# or 
+set PATH[-1..1] $PATH
+
+# Use only n last items of the PATH
+set n -3
+echo $PATH[$n..-1]
+</pre>
+
+NOTE: Currently variables are allowed inside variables index expansion, but not in indices, 
+used for command substitution.
+
 \subsection expand-home Home directory expansion
 
 The ~ (tilde) character at the beginning of a parameter, followed by a
@@ -909,6 +956,9 @@ If you specify a negative index when expanding or assigning to an
 array variable, the index will be calculated from the end of the
 array. For example, the index -1 means the last index of an array.
 
+A range of indices can be specified, see <a href='#expand-index-range'>index
+range expansion</a> for details.
+
 \subsection variables-special Special variables
 
 The user can change the settings of \c fish by changing the values of
@@ -1004,6 +1054,7 @@ highlighting in the completion pager:
 - \c fish_pager_color_completion, the color of the completion itself
 - \c fish_pager_color_description, the color of the completion description
 - \c fish_pager_color_progress, the color of the progress bar at the bottom left corner
+- \c fish_pager_color_secondary, the background color of the every second completion
 
 Example:
 
@@ -1227,8 +1278,8 @@ fish_color_substitution, \c fish_color_redirection, \c fish_color_end,
 \c fish_color_error, \c fish_color_param, \c fish_color_comment, \c
 fish_color_match, \c fish_color_search_match, \c fish_color_cwd, \c
 fish_pager_color_prefix, \c fish_pager_color_completion, \c
-fish_pager_color_description and \c
-fish_pager_color_progress. Usually, the value of these variables will
+fish_pager_color_description, \c fish_pager_color_progress
+and \c fish_pager_color_secondary. Usually, the value of these variables will
 be one of \c black, \c red, \c green, \c brown, \c yellow, \c blue, \c
 magenta, \c purple, \c cyan, \c white or \c normal, but they can be an
 array containing any color options for the set_color command.
@@ -1323,7 +1374,7 @@ translated, a future version of fish should also include translated
 manuals.
 
 To make a translation of fish, you will first need the source code,
-available from the <a href='http://www.fishshell.org'>fish
+available from the <a href='http://ridiculousfish.com/shell/'>fish
 homepage</a>. Download the latest version, and then extract it using a
 command like <code>tar -zxf fish-VERSION.tar.gz</code>.
 

doc_src/pwd.txt

@@ -0,0 +1,8 @@
+\section pwd pwd - returns the current directory
+
+\subsection pwd-synopsis Synopsis
+ <tt>pwd</tt>
+
+\subsection pwd-description Description
+
+Returns the current directory. Note that fish always resolves symbolic links in the current directory path.

doc_src/read.txt

@@ -9,8 +9,8 @@ The <tt>read</tt> builtin causes fish to read one line from standard
 input and store the result in one or more environment variables.
 
 - <tt>-c CMD</tt> or <tt>--command=CMD</tt> specifies that the initial string in the interactive mode command buffer should be CMD.
-- <tt>-e</tt> or <tt>--export</tt> specifies that the variables will be exported to subshells.
 - <tt>-g</tt> or <tt>--global</tt> specifies that the variables will be made global.
+- <tt>-l</tt> or <tt>--local</tt> specifies that the variables will be made local.
 - <tt>-m NAME</tt> or <tt>--mode-name=NAME</tt> specifies that the name NAME should be used to save/load the history file. If NAME is fish, the regular fish history will be available.
 - <tt>-p PROMPT_CMD</tt> or <tt>--prompt=PROMPT_CMD</tt> specifies that the output of the shell command PROMPT_CMD should be used as the prompt for the interactive mode prompt. The default prompt command is <tt>set_color green; echo read; set_color normal; echo "> "</tt>.
 - <code>-s</code> or <code>--shell</code> Use syntax highlighting, tab completions and command termination suitable for entering shellscript code

doc_src/set_color.txt

@@ -9,6 +9,10 @@ Change the foreground and/or background color of the terminal.
 COLOR is one of black, red, green, brown, yellow, blue, magenta,
 purple, cyan, white and normal.
 
+If your terminal supports term256 (modern xterms and OS X Lion),
+you can specify an RGB value with three or six hex digits, such
+as A0FF33 or f2f. fish will choose the closest supported color.
+
 - \c -b, \c --background Set the background color
 - \c -c, \c --print-colors Prints a list of all valid color names
 - \c -h, \c --help Display help message and exit

doc_src/source.txt

@@ -22,7 +22,7 @@ execute. If something goes wrong while opening or reading the file,
 
 \subsection source-example Example
 
-<tt>. ~/.fish</tt>
+<tt>. ~/.config/fish/config.fish</tt>
 
 causes fish to reread its initialization file.
 

doc_src/test.txt

@@ -0,0 +1,43 @@
+\section test test - perform tests on files and text
+
+\subsection test-synopsis Synopsis
+ <tt>test [EXPRESSION]</tt>
+
+\subsection test-description Description                                                                                                                             
+                                                                                                                                                                          
+Tests the expression given and returns true or false.                                                                                                           
+
+- \c -h, \c Display this help
+- \c -G, \c File owned by effective group ID
+- \c -L, \c File is syslink
+- \c -O, \c File owned by effective user ID
+- \c -S, \c File is socket
+- \c -a, \c Logical and 
+- \c -b, \c File is block device 
+- \c -c, \c File is character device 
+- \c -d, \c File is a directory
+- \c -e, \c File exists
+- \c -f, \c File is regular 
+- \c -f, \c File is set-group-ID 
+- \c -k, \c File has sticky bit set 
+- \c -n, \c String length is non-zero
+- \c -o, \c Logical or
+- \c -p, \c File is named pipe
+- \c -r, \c File is readable
+- \c -s, \c File size is non-zero
+- \c -t, \c FD is terminal
+- \c -u, \c File set-user-ID bit is set
+- \c -w, \c File is writable
+- \c -x, \c File is executable 
+- \c -z, \c String length is zero
+
+\subsection test-example Example
+
+<pre>
+    if test -d "/"
+	echo "Fish is cool"
+    end
+</pre> 
+
+Because "/" is a directory the expression will evaluate
+to true, and "Fish is cool" will be echoed

env.h

@@ -6,8 +6,10 @@
 #define FISH_ENV_H
 
 #include <wchar.h>
+#include <map>
 
 #include "util.h"
+#include "common.h"
 
 /**
    Flag for local (to the current block) variable
@@ -50,11 +52,20 @@ enum{
 }
 ;
 
+/* A struct of configuration directories, determined in main() that fish will optionally pass to env_init.
+ */
+struct config_paths_t
+{
+    wcstring data;      // e.g. /usr/local/share
+    wcstring sysconf;   // e.g. /usr/local/etc
+    wcstring doc;       // e.g. /usr/local/share/doc/fish
+    wcstring bin;       // e.g. /usr/local/bin
+};
 
 /**
    Initialize environment variable data
 */
-void env_init();
+void env_init(const struct config_paths_t *paths = NULL);
 
 /**
    Destroy environment variable data
@@ -63,7 +74,7 @@ void env_destroy();
 
 
 /**
-   Set the value of the environment variable whose name matches key to val.
+   Set the value of the environment variable whose name matches key to val. 
 
    Memory policy: All keys and values are copied, the parameters can and should be freed by the caller afterwards
 
@@ -79,9 +90,7 @@ void env_destroy();
    * ENV_INVALID, the variable name or mode was invalid
 */
 
-int env_set( const wchar_t *key,
-			 const wchar_t *val,
-			 int mode );
+int env_set(const wcstring &key, const wchar_t *val, int mode);
 
 
 /**
@@ -91,7 +100,40 @@ int env_set( const wchar_t *key,
   valid until the next call to env_get(), env_set(), env_push() or
   env_pop() takes place.
 */
-wchar_t *env_get( const wchar_t *key );
+//const wchar_t *env_get( const wchar_t *key );
+
+class env_var_t : public wcstring {
+private:
+    bool is_missing;
+public:
+    static env_var_t missing_var(void);
+    env_var_t(const env_var_t &x) : wcstring(x), is_missing(x.is_missing) { }
+    env_var_t(const wcstring & x) : wcstring(x), is_missing(false) { }
+    env_var_t(const wchar_t *x) : wcstring(x), is_missing(false) { }
+    env_var_t() : wcstring(L""), is_missing(false) { }
+    bool missing(void) const { return is_missing; }
+    bool missing_or_empty(void) const { return missing() || empty(); }
+    const wchar_t *c_str(void) const;
+    env_var_t &operator=(const env_var_t &s) {
+        is_missing = s.is_missing;
+        wcstring::operator=(s);
+        return *this;
+    }
+    
+    bool operator==(const env_var_t &s) const {
+        if (is_missing &&  s.is_missing)
+            return true;
+        else if (s.is_missing || s.is_missing)
+            return false;
+        else
+            return *static_cast<const wcstring *>(this) == *static_cast<const wcstring *>(&s);
+    }
+
+};
+/**
+ Gets the variable with the specified name, or an empty string if it does not exist.
+ */
+env_var_t env_get_string( const wcstring &key );
 
 /**
    Returns 1 if the specified key exists. This can't be reliably done
@@ -104,13 +146,13 @@ int env_exist( const wchar_t *key, int mode );
 
 /**
    Remove environemnt variable
-
+   
    \param key The name of the variable to remove
    \param mode should be ENV_USER if this is a remove request from the user, 0 otherwise. If this is a user request, read-only variables can not be removed. The mode may also specify the scope of the variable that should be erased.
 
    \return zero if the variable existed, and non-zero if the variable did not exist
 */
-int env_remove( const wchar_t *key, int mode );
+int env_remove( const wcstring &key, int mode );
 
 /**
   Push the variable stack. Used for implementing local variables for functions and for-loops.
@@ -122,15 +164,16 @@ void env_push( int new_scope );
 */
 void env_pop();
 
-/**
-   Returns an array containing all exported variables in a format suitable for execv.
-*/
-char **env_export_arr( int recalc );
+/** Returns an array containing all exported variables in a format suitable for execv. */
+char **env_export_arr( bool recalc );
+void env_export_arr(bool recalc, null_terminated_array_t<char> &result);
 
 /**
-  Insert all variable names into l. These are not copies of the strings and should not be freed after use.
+  Returns all variable names.
 */
-void env_get_names( array_list_t *l, int flags );
+wcstring_list_t env_get_names( int flags );
+
+
 
 /**
    Update the PWD variable
@@ -138,5 +181,27 @@ void env_get_names( array_list_t *l, int flags );
 */
 int env_set_pwd();
 
+class env_vars_snapshot_t {
+    std::map<wcstring, wcstring> vars;
+    bool is_current() const;
+
+public:
+    env_vars_snapshot_t(const wchar_t * const * keys);
+    env_vars_snapshot_t(void);
+    
+    env_var_t get(const wcstring &key) const;
+    
+    // Returns the fake snapshot representing the live variables array
+    static const env_vars_snapshot_t &current();
+    
+    // vars necessary for highlighting
+    static const wchar_t * const highlighting_keys[];
+};
+
+extern bool g_log_forks;
+extern int g_fork_count;
+
+extern bool g_use_posix_spawn;
+
 
 #endif

env_universal.cpp

@@ -61,7 +61,7 @@ static int get_socket_count = 0;
 static wchar_t * path;
 static wchar_t *user;
 static void (*start_fishd)();
-static void (*external_callback)( int type, const wchar_t *name, const wchar_t *val );
+static void (*external_callback)( fish_message_type_t type, const wchar_t *name, const wchar_t *val );
 
 /**
    Flag set to 1 when a barrier reply is recieved
@@ -83,27 +83,27 @@ static int get_socket( int fork_ok )
 {
 	int s, len;
 	struct sockaddr_un local;
-
+	
 	char *name;
 	wchar_t *wdir;
-	wchar_t *wuname;
+	wchar_t *wuname;	
 	char *dir =0, *uname=0;
 
 	get_socket_count++;
 	wdir = path;
 	wuname = user;
-
-	if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
+	
+	if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) 
 	{
 		wperror(L"socket");
 		return -1;
 	}
-
+	
 	if( wdir )
 		dir = wcs2str(wdir );
 	else
 		dir = strdup("/tmp");
-
+	
 	if( wuname )
 		uname = wcs2str(wuname );
 	else
@@ -112,61 +112,61 @@ static int get_socket( int fork_ok )
 		pw = getpwuid( getuid() );
 		uname = strdup( pw->pw_name );
 	}
-
-	name = malloc( strlen(dir) +
-				   strlen(uname) +
-				   strlen(SOCK_FILENAME) +
+	
+	name = (char *)malloc( strlen(dir) +
+				   strlen(uname) + 
+				   strlen(SOCK_FILENAME) + 
 				   2 );
-
+	
 	strcpy( name, dir );
 	strcat( name, "/" );
 	strcat( name, SOCK_FILENAME );
 	strcat( name, uname );
-
+	
 	free( dir );
 	free( uname );
-
+	
 	debug( 3, L"Connect to socket %s at fd %2", name, s );
-
+	
 	local.sun_family = AF_UNIX;
 	strcpy(local.sun_path, name );
 	free( name );
 	len = sizeof(local);
-
-	if( connect( s, (struct sockaddr *)&local, len) == -1 )
+	
+	if( connect( s, (struct sockaddr *)&local, len) == -1 ) 
 	{
 		close( s );
 		if( fork_ok && start_fishd )
 		{
 			debug( 2, L"Could not connect to socket %d, starting fishd", s );
-
+			
 			start_fishd();
-
+									
 			return get_socket( 0 );
 		}
-
+		
 		debug( 1, L"Could not connect to universal variable server, already tried manual restart (or no command supplied). You will not be able to share variable values between fish sessions. Is fish properly installed?" );
 		return -1;
 	}
-
-	if( (fcntl( s, F_SETFL, O_NONBLOCK ) != 0) || (fcntl( s, F_SETFD, FD_CLOEXEC ) != 0) )
+	
+	if( (fcntl( s, F_SETFL, O_NONBLOCK ) != 0) || (fcntl( s, F_SETFD, FD_CLOEXEC ) != 0) ) 
 	{
 		wperror( L"fcntl" );
-		close( s );
-
+		close( s );		
+		
 		return -1;
 	}
 
 	debug( 3, L"Connected to fd %d", s );
-
+	
 	return s;
 }
 
 /**
    Callback function used whenever a new fishd message is recieved
 */
-static void callback( int type, const wchar_t *name, const wchar_t *val )
-{
+static void callback( fish_message_type_t type, const wchar_t *name, const wchar_t *val )
+{	
 	if( type == BARRIER_REPLY )
 	{
 		barrier_reply = 1;
@@ -174,8 +174,8 @@ static void callback( int type, const wchar_t *name, const wchar_t *val )
 	else
 	{
 		if( external_callback )
-			external_callback( type, name, val );
-	}
+			external_callback( type, name, val );		
+	}	
 }
 
 /**
@@ -186,21 +186,21 @@ static void check_connection()
 {
 	if( !init )
 		return;
-
+	
 	if( env_universal_server.killme )
 	{
 		debug( 3, L"Lost connection to universal variable server." );
-
+		
 		if( close( env_universal_server.fd ) )
 		{
 			wperror( L"close" );
 		}
-
+		
 		env_universal_server.fd = -1;
 		env_universal_server.killme=0;
-		env_universal_server.input.used=0;
+		env_universal_server.input.clear();	
 		env_universal_read_all();
-	}
+	}	
 }
 
 /**
@@ -208,23 +208,18 @@ static void check_connection()
 */
 static void env_universal_remove_all()
 {
-	array_list_t lst;
-	int i;
-
-	al_init( &lst );
-
-	env_universal_common_get_names( &lst,
+	size_t i;
+	
+	wcstring_list_t lst;
+	env_universal_common_get_names( lst, 
 									1,
 									1 );
-
-	for( i=0; i<al_get_count( &lst ); i++ )
+	for( i=0; i<lst.size(); i++ )
 	{
-		wchar_t *key = (wchar_t *)al_get( &lst, i );
+		const wcstring &key = lst.at(i);
 		env_universal_common_remove( key );
 	}
-
-	al_destroy( &lst );
-
+	
 }
 
 
@@ -237,9 +232,9 @@ static void reconnect()
 {
 	if( get_socket_count >= RECONNECT_COUNT )
 		return;
-
+	
 	debug( 3, L"Get new fishd connection" );
-
+	
 	init = 0;
 	env_universal_server.buffer_consumed = env_universal_server.buffer_used = 0;
 	env_universal_server.fd = get_socket(1);
@@ -252,22 +247,22 @@ static void reconnect()
 }
 
 
-void env_universal_init( wchar_t * p,
-						 wchar_t *u,
+void env_universal_init( wchar_t * p, 
+						 wchar_t *u, 
 						 void (*sf)(),
-						 void (*cb)( int type, const wchar_t *name, const wchar_t *val ))
+						 void (*cb)( fish_message_type_t type, const wchar_t *name, const wchar_t *val ))
 {
 	path=p;
 	user=u;
-	start_fishd=sf;
+	start_fishd=sf;	
 	external_callback = cb;
 
 	connection_init( &env_universal_server, -1 );
-
+	
 	env_universal_server.fd = get_socket(1);
 	env_universal_common_init( &callback );
-	env_universal_read_all();
-	init = 1;
+	env_universal_read_all();	
+	init = 1;	
 	if( env_universal_server.fd >= 0 )
 	{
 		env_universal_barrier();
@@ -285,7 +280,7 @@ void env_universal_destroy()
 		{
 			wperror( L"fcntl" );
 		}
-		try_send_all( &env_universal_server );
+		try_send_all( &env_universal_server );		
 	}
 
 	connection_destroy( &env_universal_server );
@@ -305,46 +300,43 @@ int env_universal_read_all()
 
 	if( env_universal_server.fd == -1 )
 	{
-		reconnect();
+		reconnect();		
 		if( env_universal_server.fd == -1 )
-			return 0;
+			return 0;		
 	}
-
+	
 	if( env_universal_server.fd != -1 )
 	{
 		read_message( &env_universal_server );
-		check_connection();
+		check_connection();		
 		return 1;
 	}
 	else
 	{
 		debug( 2, L"No connection to universal variable server" );
 		return 0;
-	}
+	}		
 }
 
-wchar_t *env_universal_get( const wchar_t *name )
+wchar_t *env_universal_get( const wcstring &name )
 {
 	if( !init)
 		return 0;
 
-	CHECK( name, 0 );
-
 	return env_universal_common_get( name );
 }
 
-int env_universal_get_export( const wchar_t *name )
+int env_universal_get_export( const wcstring &name )
 {
 	if( !init)
 		return 0;
-
-	CHECK( name, 0 );
-
+	
 	return env_universal_common_get_export( name );
 }
 
 void env_universal_barrier()
 {
+    ASSERT_IS_MAIN_THREAD();
 	message_t *msg;
 	fd_set fds;
 
@@ -358,7 +350,7 @@ void env_universal_barrier()
 	*/
 	msg= create_message( BARRIER, 0, 0);
 	msg->count=1;
-	q_put( &env_universal_server.unsent, msg );
+    env_universal_server.unsent->push(msg);
 
 	/*
 	  Wait until barrier request has been sent
@@ -366,19 +358,19 @@ void env_universal_barrier()
 	debug( 3, L"Create barrier" );
 	while( 1 )
 	{
-		try_send_all( &env_universal_server );
-		check_connection();
-
-		if( q_empty( &env_universal_server.unsent ) )
+		try_send_all( &env_universal_server );	
+		check_connection();		
+		
+		if( env_universal_server.unsent->empty() )
 			break;
-
+		
 		if( env_universal_server.fd == -1 )
 		{
 			reconnect();
 			debug( 2, L"barrier interrupted, exiting" );
-			return;
+			return;			
 		}
-
+		
 		FD_ZERO( &fds );
 		FD_SET( env_universal_server.fd, &fds );
 		select( env_universal_server.fd+1, 0, &fds, 0, 0 );
@@ -394,10 +386,10 @@ void env_universal_barrier()
 		{
 			reconnect();
 			debug( 2, L"barrier interrupted, exiting (2)" );
-			return;
-		}
+			return;			
+		}		
 		FD_ZERO( &fds );
-        FD_SET( env_universal_server.fd, &fds );
+        FD_SET( env_universal_server.fd, &fds );		
         select( env_universal_server.fd+1, &fds, 0, 0, 0 );
 		env_universal_read_all();
 	}
@@ -405,35 +397,33 @@ void env_universal_barrier()
 }
 
 
-void env_universal_set( const wchar_t *name, const wchar_t *value, int export )
+void env_universal_set( const wcstring &name, const wcstring &value, int exportv )
 {
 	message_t *msg;
-
+	
 	if( !init )
 		return;
 
-	CHECK( name, );
-
-	debug( 3, L"env_universal_set( \"%ls\", \"%ls\" )", name, value );
+	debug( 3, L"env_universal_set( \"%ls\", \"%ls\" )", name.c_str(), value.c_str() );
 
 	if( is_dead() )
 	{
-		env_universal_common_set( name, value, export );
+		env_universal_common_set( name.c_str(), value.c_str(), exportv );
 	}
 	else
 	{
-		msg = create_message( export?SET_EXPORT:SET,
-							  name,
-							  value);
+		msg = create_message( exportv?SET_EXPORT:SET, 
+							  name.c_str(), 
+							  value.c_str());
 
 		if( !msg )
 		{
 			debug( 1, L"Could not create universal variable message" );
 			return;
 		}
-
+		
 		msg->count=1;
-		q_put( &env_universal_server.unsent, msg );
+        env_universal_server.unsent->push(msg);
 		env_universal_barrier();
 	}
 }
@@ -441,43 +431,41 @@ void env_universal_set( const wchar_t *name, const wchar_t *value, int export )
 int env_universal_remove( const wchar_t *name )
 {
 	int res;
-
+	
 	message_t *msg;
 	if( !init )
 		return 1;
-
+		
 	CHECK( name, 1 );
 
 	res = !env_universal_common_get( name );
 	debug( 3,
 		   L"env_universal_remove( \"%ls\" )",
 		   name );
-
+		
 	if( is_dead() )
 	{
-		env_universal_common_remove( name );
+		env_universal_common_remove( wcstring(name) );
 	}
 	else
 	{
 		msg= create_message( ERASE, name, 0);
 		msg->count=1;
-		q_put( &env_universal_server.unsent, msg );
+        env_universal_server.unsent->push(msg);
 		env_universal_barrier();
 	}
-
+	
 	return res;
 }
 
-void env_universal_get_names( array_list_t *l,
+void env_universal_get_names2( wcstring_list_t &lst,
                               int show_exported,
                               int show_unexported )
 {
 	if( !init )
 		return;
 
-	CHECK( l, );
-
-	env_universal_common_get_names( l,
+	env_universal_common_get_names( lst, 
 									show_exported,
-									show_unexported );
+									show_unexported );	
 }

env_universal.h

@@ -17,7 +17,10 @@ extern connection_t env_universal_server;
 /**
    Initialize the envuni library
 */
-void env_universal_init();
+void env_universal_init( wchar_t * p, 
+                        wchar_t *u, 
+                        void (*sf)(),
+                        void (*cb)( fish_message_type_t type, const wchar_t *name, const wchar_t *val ));
 /**
   Free memory used by envuni
 */
@@ -26,21 +29,21 @@ void env_universal_destroy();
 /**
    Get the value of a universal variable
 */
-wchar_t *env_universal_get( const wchar_t *name );
+wchar_t *env_universal_get( const wcstring &name );
 
 /**
    Get the export flag of the variable with the specified
    name. Returns 0 if the variable doesn't exist.
 */
-int env_universal_get_export( const wchar_t *name );
+int env_universal_get_export( const wcstring &name );
 
 /**
    Set the value of a universal variable
 */
-void env_universal_set( const wchar_t *name, const wchar_t *val, int export );
+void env_universal_set( const wcstring &name, const wcstring &val, int exportv );
 /**
    Erase a universal variable
-
+   
    \return zero if the variable existed, and non-zero if the variable did not exist
 */
 int env_universal_remove( const wchar_t *name );
@@ -52,12 +55,12 @@ int env_universal_read_all();
 
 /**
    Get the names of all universal variables
-
+   
    \param l the list to insert the names into
    \param show_exported whether exported variables should be shown
    \param show_unexported whether unexported variables should be shown
 */
-void env_universal_get_names( array_list_t *l,
+void env_universal_get_names2( wcstring_list_t &list,
 							  int show_exported,
 							  int show_unexported );
 

env_universal_common.h

@@ -2,7 +2,8 @@
 #define FISH_ENV_UNIVERSAL_COMMON_H
 
 #include <wchar.h>
-
+#include <queue>
+#include <string>
 #include "util.h"
 
 /**
@@ -39,21 +40,39 @@
 /**
    The different types of commands that can be sent between client/server
 */
-enum
+typedef enum
 {
 	SET,
 	SET_EXPORT,
 	ERASE,
 	BARRIER,
 	BARRIER_REPLY,
-}
-	;
+} fish_message_type_t;
 
 /**
    The size of the buffer used for reading from the socket
 */
 #define ENV_UNIVERSAL_BUFFER_SIZE 1024
 
+/**
+   A struct representing a message to be sent between client and server
+*/
+typedef struct 
+{
+	/**
+	   Number of queues that contain this message. Once this reaches zero, the message should be deleted
+	*/
+	int count;
+
+	/**
+	   Message body. The message must be allocated using enough memory to actually contain the message.
+	*/
+	std::string body;
+    
+} message_t;
+
+typedef std::queue<message_t *> message_queue_t;
+
 /**
    This struct represents a connection between a universal variable server/client
 */
@@ -66,7 +85,7 @@ typedef struct connection
 	/**
 	   Queue of onsent messages
 	*/
-	dyn_queue_t unsent;
+    message_queue_t *unsent;
 	/**
 	   Set to one when this connection should be killed
 	*/
@@ -75,23 +94,23 @@ typedef struct connection
 	   The input string. Input from the socket goes here. When a
 	   newline is encountered, the buffer is parsed and cleared.
 	*/
-	buffer_t input;
-
+	std::vector<char> input;
+	
 	/**
-	   The read buffer.
+	   The read buffer. 
 	*/
 	char buffer[ENV_UNIVERSAL_BUFFER_SIZE];
 
 	/**
 	   Number of bytes that have already been consumed.
 	*/
-	int buffer_consumed;
-
+	size_t buffer_consumed;
+	
 	/**
-	   Number of bytes that have been read into the buffer.
+	   Number of bytes that have been read into the buffer. 
 	*/
-	int buffer_used;
-
+	size_t buffer_used;
+	
 
 	/**
 	   Link to the next connection
@@ -100,22 +119,6 @@ typedef struct connection
 }
 	connection_t;
 
-/**
-   A struct representing a message to be sent between client and server
-*/
-typedef struct
-{
-	/**
-	   Number of queues that contain this message. Once this reaches zero, the message should be deleted
-	*/
-	int count;
-	/**
-	   Message body. The message must be allocated using enough memory to actually contain the message.
-	*/
-	char body[1];
-}
-	message_t;
-
 /**
    Read all available messages on this connection
 */
@@ -129,12 +132,12 @@ void try_send_all( connection_t *c );
 /**
    Create a messge with the specified properties
 */
-message_t *create_message( int type, const wchar_t *key, const wchar_t *val );
+message_t *create_message( fish_message_type_t type, const wchar_t *key, const wchar_t *val );
 
 /**
    Init the library
 */
-void env_universal_common_init(void (*cb)(int type, const wchar_t *key, const wchar_t *val ) );
+void env_universal_common_init(void (*cb)(fish_message_type_t type, const wchar_t *key, const wchar_t *val ) );
 
 /**
    Destroy library data
@@ -147,7 +150,7 @@ void env_universal_common_destroy();
    This function operate agains the local copy of all universal
    variables, it does not communicate with any other process.
 */
-void env_universal_common_get_names( array_list_t *l,
+void env_universal_common_get_names( wcstring_list_t &lst,
 									 int show_exported,
 									 int show_unexported );
 
@@ -160,10 +163,10 @@ void env_universal_common_get_names( array_list_t *l,
    Do not call this function. Create a message to do it. This function
    is only to be used when fishd is dead.
 */
-void env_universal_common_set( const wchar_t *key, const wchar_t *val, int export );
+void env_universal_common_set( const wchar_t *key, const wchar_t *val, int exportv );
 
 /**
-   Remove the specified variable.
+   Remove the specified variable. 
 
    This function operate agains the local copy of all universal
    variables, it does not communicate with any other process.
@@ -171,7 +174,7 @@ void env_universal_common_set( const wchar_t *key, const wchar_t *val, int expor
    Do not call this function. Create a message to do it. This function
    is only to be used when fishd is dead.
 */
-void env_universal_common_remove( const wchar_t *key );
+void env_universal_common_remove( const wcstring &key );
 
 /**
    Get the value of the variable with the specified name
@@ -179,7 +182,7 @@ void env_universal_common_remove( const wchar_t *key );
    This function operate agains the local copy of all universal
    variables, it does not communicate with any other process.
 */
-wchar_t *env_universal_common_get( const wchar_t *name );
+wchar_t *env_universal_common_get( const wcstring &name );
 
 /**
    Get the export flag of the variable with the specified
@@ -188,7 +191,7 @@ wchar_t *env_universal_common_get( const wchar_t *name );
    This function operate agains the local copy of all universal
    variables, it does not communicate with any other process.
 */
-int env_universal_common_get_export( const wchar_t *name );
+int env_universal_common_get_export( const wcstring &name );
 
 /**
    Add messages about all existing variables to the specified connection

etc/config.fish

@@ -1,7 +1,6 @@
 #
 # Init file for fish
 #
-# @configure_input@
 
 #
 # Some things should only be done for login terminals
@@ -38,17 +37,6 @@ if status --is-login
 	end
 end
 
-#
-# There are variables that contain colons that are not arrays. This
-# reverts them back to regular strings.
-#
-
-for i in DISPLAY
-	if set -q $i
-		set -- $i (printf ":%s" $$i|cut -c 2-)
-	end
-end
-
 #
 # Load additional initialization files
 #

event.c

@@ -1,731 +0,0 @@
-/** \file event.c
-
-	Functions for handling event triggers
-
-*/
-#include "config.h"
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <wchar.h>
-#include <unistd.h>
-#include <termios.h>
-#include <signal.h>
-#include <string.h>
-
-#include "fallback.h"
-#include "util.h"
-
-#include "wutil.h"
-#include "function.h"
-#include "proc.h"
-#include "parser.h"
-#include "common.h"
-#include "event.h"
-#include "signal.h"
-
-#include "halloc_util.h"
-
-/**
-   Number of signals that can be queued before an overflow occurs
-*/
-#define SIG_UNHANDLED_MAX 64
-
-/**
-   This struct contains a list of generated signals waiting to be
-   dispatched
-*/
-typedef struct
-{
-	/**
-	   Number of delivered signals
-	*/
-	int count;
-	/**
-	   Whether signals have been skipped
-	*/
-	int overflow;
-	/**
-	   Array of signal events
-	*/
-	int signal[SIG_UNHANDLED_MAX];
-}
-	signal_list_t;
-
-/**
-  The signal event list. Actually two separate lists. One which is
-  active, which is the one that new events is written to. The inactive
-  one contains the events that are currently beeing performed.
-*/
-static signal_list_t sig_list[]={{0,0},{0,0}};
-
-/**
-   The index of sig_list that is the list of signals currently written to
-*/
-static int active_list=0;
-
-/**
-   List of event handlers
-*/
-static array_list_t *events;
-/**
-   List of event handlers that should be removed
-*/
-static array_list_t *killme;
-
-/**
-   List of events that have been sent but have not yet been delivered because they are blocked.
-*/
-static array_list_t *blocked;
-
-/**
-   Tests if one event instance matches the definition of a event
-   class. If both the class and the instance name a function,
-   they must name the same function.
-
-*/
-static int event_match( event_t *class, event_t *instance )
-{
-
-	if( class->function_name && instance->function_name )
-	{
-		if( wcscmp( class->function_name, instance->function_name ) != 0 )
-			return 0;
-	}
-
-	if( class->type == EVENT_ANY )
-		return 1;
-
-	if( class->type != instance->type )
-		return 0;
-
-
-	switch( class->type )
-	{
-
-		case EVENT_SIGNAL:
-			if( class->param1.signal == EVENT_ANY_SIGNAL )
-				return 1;
-			return class->param1.signal == instance->param1.signal;
-
-		case EVENT_VARIABLE:
-			return wcscmp( instance->param1.variable,
-				       class->param1.variable )==0;
-
-		case EVENT_EXIT:
-			if( class->param1.pid == EVENT_ANY_PID )
-				return 1;
-			return class->param1.pid == instance->param1.pid;
-
-		case EVENT_JOB_ID:
-			return class->param1.job_id == instance->param1.job_id;
-
-		case EVENT_GENERIC:
-			return wcscmp( instance->param1.param,
-				       class->param1.param )==0;
-
-	}
-
-	/**
-	   This should never be reached
-	*/
-	return 0;
-}
-
-
-/**
-   Create an identical copy of an event. Use deep copying, i.e. make
-   duplicates of any strings used as well.
-*/
-static event_t *event_copy( event_t *event, int copy_arguments )
-{
-	event_t *e = malloc( sizeof( event_t ) );
-
-	if( !e )
-		DIE_MEM();
-
-	memcpy( e, event, sizeof(event_t));
-
-	if( e->function_name )
-		e->function_name = wcsdup( e->function_name );
-
-	if( e->type == EVENT_VARIABLE )
-		e->param1.variable = wcsdup( e->param1.variable );
-	else if( e->type == EVENT_GENERIC )
-		e->param1.param = wcsdup( e->param1.param );
-
-	al_init( &e->arguments );
-	if( copy_arguments )
-	{
-		int i;
-		for( i=0; i<al_get_count( &event->arguments ); i++ )
-		{
-			al_push( &e->arguments, wcsdup( (wchar_t *)al_get( &event->arguments, i ) ) );
-		}
-
-	}
-
-	return e;
-}
-
-/**
-   Test if specified event is blocked
-*/
-static int event_is_blocked( event_t *e )
-{
-	block_t *block;
-	event_block_t *eb;
-
-	for( block = current_block; block; block = block->outer )
-	{
-		for( eb = block->first_event_block; eb; eb=eb->next )
-		{
-			if( eb->type & (1<<EVENT_ANY ) )
-				return 1;
-			if( eb->type & (1<<e->type) )
-				return 1;
-		}
-	}
-	for( eb = global_event_block; eb; eb=eb->next )
-	{
-		if( eb->type & (1<<EVENT_ANY ) )
-			return 1;
-		if( eb->type & (1<<e->type) )
-			return 1;
-		return 1;
-
-	}
-
-	return 0;
-}
-
-const wchar_t *event_get_desc( event_t *e )
-{
-
-	/*
-	  String buffer used for formating event descriptions in event_get_desc()
-	*/
-	static string_buffer_t *get_desc_buff=0;
-
-	CHECK( e, 0 );
-
-	if( !get_desc_buff )
-	{
-		get_desc_buff=sb_halloc( global_context );
-	}
-	else
-	{
-		sb_clear( get_desc_buff );
-	}
-
-	switch( e->type )
-	{
-
-		case EVENT_SIGNAL:
-			sb_printf( get_desc_buff, _(L"signal handler for %ls (%ls)"), sig2wcs(e->param1.signal ), signal_get_desc( e->param1.signal ) );
-			break;
-
-		case EVENT_VARIABLE:
-			sb_printf( get_desc_buff, _(L"handler for variable '%ls'"), e->param1.variable );
-			break;
-
-		case EVENT_EXIT:
-			if( e->param1.pid > 0 )
-			{
-				sb_printf( get_desc_buff, _(L"exit handler for process %d"), e->param1.pid );
-			}
-			else
-			{
-				job_t *j = job_get_from_pid( -e->param1.pid );
-				if( j )
-					sb_printf( get_desc_buff, _(L"exit handler for job %d, '%ls'"), j->job_id, j->command );
-				else
-					sb_printf( get_desc_buff, _(L"exit handler for job with process group %d"), -e->param1.pid );
-			}
-
-			break;
-
-		case EVENT_JOB_ID:
-		{
-			job_t *j = job_get( e->param1.job_id );
-			if( j )
-				sb_printf( get_desc_buff, _(L"exit handler for job %d, '%ls'"), j->job_id, j->command );
-			else
-				sb_printf( get_desc_buff, _(L"exit handler for job with job id %d"), j->job_id );
-
-			break;
-		}
-
-		case EVENT_GENERIC:
-			sb_printf( get_desc_buff, _(L"handler for generic event '%ls'"), e->param1.param );
-			break;
-
-		default:
-			sb_printf( get_desc_buff, _(L"Unknown event type") );
-			break;
-
-	}
-
-	return (const wchar_t *)get_desc_buff->buff;
-}
-
-
-void event_add_handler( event_t *event )
-{
-	event_t *e;
-
-	CHECK( event, );
-
-	e = event_copy( event, 0 );
-
-	if( !events )
-		events = al_new();
-
-	if( e->type == EVENT_SIGNAL )
-	{
-		signal_handle( e->param1.signal, 1 );
-	}
-
-	al_push( events, e );
-}
-
-void event_remove( event_t *criterion )
-{
-	int i;
-	array_list_t *new_list=0;
-	event_t e;
-
-	CHECK( criterion, );
-
-	/*
-	  Because of concurrency issues (env_remove could remove an event
-	  that is currently being executed), env_remove does not actually
-	  free any events - instead it simply moves all events that should
-	  be removed from the event list to the killme list, and the ones
-	  that shouldn't be killed to new_list, and then drops the empty
-	  events-list.
-	*/
-
-	if( !events )
-		return;
-
-	for( i=0; i<al_get_count( events); i++ )
-	{
-		event_t *n = (event_t *)al_get( events, i );
-		if( event_match( criterion, n ) )
-		{
-			if( !killme )
-				killme = al_new();
-
-			al_push( killme, n );
-
-			/*
-			  If this event was a signal handler and no other handler handles
-			  the specified signal type, do not handle that type of signal any
-			  more.
-			*/
-			if( n->type == EVENT_SIGNAL )
-			{
-				e.type = EVENT_SIGNAL;
-				e.param1.signal = n->param1.signal;
-				e.function_name = 0;
-
-				if( event_get( &e, 0 ) == 1 )
-				{
-					signal_handle( e.param1.signal, 0 );
-				}
-			}
-		}
-		else
-		{
-			if( !new_list )
-				new_list = al_new();
-			al_push( new_list, n );
-		}
-	}
-	al_destroy( events );
-	free( events );
-	events = new_list;
-}
-
-int event_get( event_t *criterion, array_list_t *out )
-{
-	int i;
-	int found = 0;
-
-	if( !events )
-		return 0;
-
-	CHECK( criterion, 0 );
-
-	for( i=0; i<al_get_count( events); i++ )
-	{
-		event_t *n = (event_t *)al_get( events, i );
-		if( event_match(criterion, n ) )
-		{
-			found++;
-			if( out )
-				al_push( out, n );
-		}
-	}
-	return found;
-}
-
-/**
-   Free all events in the kill list
-*/
-static void event_free_kills()
-{
-	int i;
-	if( !killme )
-		return;
-
-	for( i=0; i<al_get_count( killme ); i++ )
-	{
-		event_t *roadkill = (event_t *)al_get( killme, i );
-		event_free( roadkill );
-	}
-	al_truncate( killme, 0 );
-}
-
-/**
-   Test if the specified event is waiting to be killed
-*/
-static int event_is_killed( event_t *e )
-{
-	int i;
-	if( !killme )
-		return 0;
-
-	for( i=0; i<al_get_count( killme ); i++ )
-	{
-		event_t *roadkill = (event_t *)al_get( events, i );
-		if( roadkill ==e )
-			return 1;
-
-	}
-	return 0;
-}
-
-/**
-   Perform the specified event. Since almost all event firings will
-   not be matched by even a single event handler, we make sure to
-   optimize the 'no matches' path. This means that nothing is
-   allocated/initialized unless needed.
-*/
-static void event_fire_internal( event_t *event )
-{
-	int i, j;
-	string_buffer_t *b=0;
-	array_list_t *fire=0;
-
-	/*
-	  First we free all events that have been removed
-	*/
-	event_free_kills();
-
-	if( !events )
-		return;
-
-	/*
-	  Then we iterate over all events, adding events that should be
-	  fired to a second list. We need to do this in a separate step
-	  since an event handler might call event_remove or
-	  event_add_handler, which will change the contents of the \c
-	  events list.
-	*/
-	for( i=0; i<al_get_count( events ); i++ )
-	{
-		event_t *criterion = (event_t *)al_get( events, i );
-
-		/*
-		  Check if this event is a match
-		*/
-		if(event_match( criterion, event ) )
-		{
-			if( !fire )
-				fire = al_new();
-			al_push( fire, criterion );
-		}
-	}
-
-	/*
-	  No matches. Time to return.
-	*/
-	if( !fire )
-		return;
-
-	/*
-	  Iterate over our list of matching events
-	*/
-
-	for( i=0; i<al_get_count( fire ); i++ )
-	{
-		event_t *criterion = (event_t *)al_get( fire, i );
-		int prev_status;
-
-		/*
-		  Check if this event has been removed, if so, dont fire it
-		*/
-		if( event_is_killed( criterion ) )
-			continue;
-
-		/*
-		  Fire event
-		*/
-		if( !b )
-			b = sb_new();
-		else
-			sb_clear( b );
-
-		sb_append( b, criterion->function_name );
-
-		for( j=0; j<al_get_count(&event->arguments); j++ )
-		{
-			wchar_t *arg_esc = escape( (wchar_t *)al_get( &event->arguments, j), 1 );
-			sb_append( b, L" " );
-			sb_append( b, arg_esc );
-			free( arg_esc );
-		}
-
-//		debug( 1, L"Event handler fires command '%ls'", (wchar_t *)b->buff );
-
-		/*
-		  Event handlers are not part of the main flow of code, so
-		  they are marked as non-interactive
-		*/
-		proc_push_interactive(0);
-		prev_status = proc_get_last_status();
-		parser_push_block( EVENT );
-		current_block->param1.event = event;
-		eval( (wchar_t *)b->buff, 0, TOP );
-		parser_pop_block();
-		proc_pop_interactive();
-		proc_set_last_status( prev_status );
-	}
-
-	if( b )
-	{
-		sb_destroy( b );
-		free( b );
-	}
-
-	if( fire )
-	{
-		al_destroy( fire );
-		free( fire );
-	}
-
-	/*
-	  Free killed events
-	*/
-	event_free_kills();
-
-}
-
-/**
-   Handle all pending signal events
-*/
-static void event_fire_delayed()
-{
-
-	int i;
-
-	/*
-	  If is_event is one, we are running the event-handler non-recursively.
-
-	  When the event handler has called a piece of code that triggers
-	  another event, we do not want to fire delayed events because of
-	  concurrency problems.
-	*/
-	if( blocked && is_event==1)
-	{
-		array_list_t *new_blocked = 0;
-
-		for( i=0; i<al_get_count( blocked ); i++ )
-		{
-			event_t *e = (event_t *)al_get( blocked, i );
-			if( event_is_blocked( e ) )
-			{
-				if( !new_blocked )
-					new_blocked = al_new();
-				al_push( new_blocked, e );
-			}
-			else
-			{
-				event_fire_internal( e );
-				event_free( e );
-			}
-		}
-		al_destroy( blocked );
-		free( blocked );
-		blocked = new_blocked;
-	}
-
-	while( sig_list[active_list].count > 0 )
-	{
-		signal_list_t *lst;
-		event_t e;
-		al_init( &e.arguments );
-
-		/*
-		  Switch signal lists
-		*/
-		sig_list[1-active_list].count=0;
-		sig_list[1-active_list].overflow=0;
-		active_list=1-active_list;
-
-		/*
-		  Set up
-		*/
-		e.type=EVENT_SIGNAL;
-		e.function_name=0;
-
-		lst = &sig_list[1-active_list];
-
-		if( lst->overflow )
-		{
-			debug( 0, _( L"Signal list overflow. Signals have been ignored." ) );
-		}
-
-		/*
-		  Send all signals in our private list
-		*/
-		for( i=0; i<lst->count; i++ )
-		{
-			e.param1.signal = lst->signal[i];
-			al_set( &e.arguments, 0, sig2wcs( e.param1.signal ) );
-			if( event_is_blocked( &e ) )
-			{
-				if( !blocked )
-					blocked = al_new();
-				al_push( blocked, event_copy(&e, 1) );
-			}
-			else
-			{
-				event_fire_internal( &e );
-			}
-		}
-
-		al_destroy( &e.arguments );
-
-	}
-}
-
-
-void event_fire( event_t *event )
-{
-	is_event++;
-
-	if( event && (event->type == EVENT_SIGNAL) )
-	{
-		/*
-		  This means we are in a signal handler. We must be very
-		  careful not do do anything that could cause a memory
-		  allocation or something else that might be bad when in a
-		  signal handler.
-		*/
-		if( sig_list[active_list].count < SIG_UNHANDLED_MAX )
-			sig_list[active_list].signal[sig_list[active_list].count++]=event->param1.signal;
-		else
-			sig_list[active_list].overflow=1;
-	}
-	else
-	{
-		/*
-		  Fire events triggered by signals
-		*/
-		event_fire_delayed();
-
-		if( event )
-		{
-			if( event_is_blocked( event ) )
-			{
-				if( !blocked )
-					blocked = al_new();
-
-				al_push( blocked, event_copy(event, 1) );
-			}
-			else
-			{
-				event_fire_internal( event );
-			}
-		}
-
-	}
-	is_event--;
-}
-
-
-void event_init()
-{
-}
-
-void event_destroy()
-{
-
-	if( events )
-	{
-		al_foreach( events, (void (*)(void *))&event_free );
-		al_destroy( events );
-		free( events );
-		events=0;
-	}
-
-	if( killme )
-	{
-		al_foreach( killme, (void (*)(void *))&event_free );
-		al_destroy( killme );
-		free( killme );
-		killme=0;
-	}
-}
-
-void event_free( event_t *e )
-{
-	CHECK( e, );
-
-	/*
-	  When apropriate, we clear the argument vector
-	*/
-	al_foreach( &e->arguments, &free );
-	al_destroy( &e->arguments );
-
-	free( (void *)e->function_name );
-	if( e->type == EVENT_VARIABLE )
-	{
-		free( (void *)e->param1.variable );
-	}
-	else if( e->type == EVENT_GENERIC )
-	{
-		free( (void *)e->param1.param );
-	}
-	free( e );
-}
-
-
-void event_fire_generic_internal(const wchar_t *name, ...)
-{
-	event_t ev;
-	va_list va;
-	wchar_t *arg;
-
-	CHECK( name, );
-
-	ev.type = EVENT_GENERIC;
-	ev.param1.param = name;
-	ev.function_name=0;
-
-	al_init( &ev.arguments );
-	va_start( va, name );
-	while( (arg=va_arg(va, wchar_t *) )!= 0 )
-	{
-		al_push( &ev.arguments, arg );
-	}
-	va_end( va );
-
-	event_fire( &ev );
-}
-
-
-

event.cpp

@@ -0,0 +1,667 @@
+/** \file event.c
+
+	Functions for handling event triggers
+
+*/
+#include "config.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <wchar.h>
+#include <unistd.h>
+#include <termios.h>
+#include <signal.h>
+#include <string.h>
+#include <algorithm>
+
+#include "fallback.h"
+#include "util.h"
+
+#include "wutil.h"
+#include "function.h"
+#include "proc.h"
+#include "parser.h"
+#include "common.h"
+#include "event.h"
+#include "signal.h"
+
+/**
+   Number of signals that can be queued before an overflow occurs
+*/
+#define SIG_UNHANDLED_MAX 64
+
+/**
+   This struct contains a list of generated signals waiting to be
+   dispatched
+*/
+typedef struct
+{
+	/**
+	   Number of delivered signals
+	*/
+	int count;
+	/**
+	   Whether signals have been skipped
+	*/
+	int overflow;	
+	/**
+	   Array of signal events
+	*/
+	int signal[SIG_UNHANDLED_MAX];	
+}
+	signal_list_t;
+
+/**
+  The signal event list. Actually two separate lists. One which is
+  active, which is the one that new events is written to. The inactive
+  one contains the events that are currently beeing performed.
+*/
+static signal_list_t sig_list[]={{0,0},{0,0}};
+
+/**
+   The index of sig_list that is the list of signals currently written to
+*/
+static int active_list=0;
+
+typedef std::vector<event_t *> event_list_t; 
+
+/**
+   List of event handlers.
+   Note this is inspected by our signal handler, so we must block signals around manipulating it.
+*/
+static event_list_t events;
+/**
+   List of event handlers that should be removed
+*/
+static event_list_t killme;
+
+/**
+   List of events that have been sent but have not yet been delivered because they are blocked.
+*/
+static event_list_t blocked;
+
+/**
+   Tests if one event instance matches the definition of a event
+   class. If both the class and the instance name a function,
+   they must name the same function.
+
+*/
+static int event_match( const event_t *classv, const event_t *instance )
+{
+
+    /* If the function names are both non-empty and different, then it's not a match */
+	if( ! classv->function_name.empty() &&
+        ! instance->function_name.empty() &&
+          classv->function_name != instance->function_name)
+	{
+        return 0;
+	}
+
+	if( classv->type == EVENT_ANY )
+		return 1;
+	
+	if( classv->type != instance->type )
+		return 0;
+	
+
+	switch( classv->type )
+	{
+		
+		case EVENT_SIGNAL:
+			if( classv->param1.signal == EVENT_ANY_SIGNAL )
+				return 1;
+			return classv->param1.signal == instance->param1.signal;
+			
+		case EVENT_VARIABLE:
+			return instance->str_param1 == classv->str_param1;
+			
+		case EVENT_EXIT:
+			if( classv->param1.pid == EVENT_ANY_PID )
+				return 1;
+			return classv->param1.pid == instance->param1.pid;
+
+		case EVENT_JOB_ID:
+			return classv->param1.job_id == instance->param1.job_id;
+
+		case EVENT_GENERIC:
+			return instance->str_param1 == classv->str_param1;
+
+	}
+	
+	/**
+	   This should never be reached
+	*/
+	return 0;	
+}
+
+
+/**
+   Create an identical copy of an event. Use deep copying, i.e. make
+   duplicates of any strings used as well.
+*/
+static event_t *event_copy( const event_t *event, int copy_arguments )
+{
+    event_t *e = new event_t(*event);
+    
+    e->arguments.reset(new wcstring_list_t);
+	if( copy_arguments && event->arguments.get() != NULL )
+	{
+        *(e->arguments) = *(event->arguments);				
+	}
+	
+	return e;
+}
+
+/**
+   Test if specified event is blocked
+*/
+static int event_is_blocked( event_t *e )
+{
+	block_t *block;
+	parser_t &parser = parser_t::principal_parser();
+	for( block = parser.current_block; block; block = block->outer )
+	{
+        if (event_block_list_blocks_type(block->event_blocks, e->type))
+            return true;
+	}
+    return event_block_list_blocks_type(parser.global_event_blocks, e->type);
+}
+
+wcstring event_get_desc( const event_t *e )
+{
+
+	CHECK( e, 0 );
+
+	wcstring result;	
+	switch( e->type )
+	{
+		
+		case EVENT_SIGNAL:
+            result = format_string(_(L"signal handler for %ls (%ls)"), sig2wcs(e->param1.signal ), signal_get_desc( e->param1.signal ));
+			break;
+		
+		case EVENT_VARIABLE:
+			result = format_string(_(L"handler for variable '%ls'"), e->str_param1.c_str() );
+			break;
+		
+		case EVENT_EXIT:
+			if( e->param1.pid > 0 )
+			{
+				result = format_string(_(L"exit handler for process %d"), e->param1.pid );
+			}
+			else
+			{
+				job_t *j = job_get_from_pid( -e->param1.pid );
+				if( j )
+					result = format_string(_(L"exit handler for job %d, '%ls'"), j->job_id, j->command_wcstr() );
+				else
+					result = format_string(_(L"exit handler for job with process group %d"), -e->param1.pid );
+			}
+			
+			break;
+		
+		case EVENT_JOB_ID:
+		{
+			job_t *j = job_get( e->param1.job_id );
+			if( j )
+				result = format_string(_(L"exit handler for job %d, '%ls'"), j->job_id, j->command_wcstr() );
+			else
+				result = format_string(_(L"exit handler for job with job id %d"), e->param1.job_id );
+
+			break;
+		}
+		
+		case EVENT_GENERIC:
+			result = format_string(_(L"handler for generic event '%ls'"), e->str_param1.c_str() );
+			break;
+			
+		default:
+			result = format_string(_(L"Unknown event type") );
+			break;
+			
+	}
+	
+	return result;
+}
+
+#if 0
+static void show_all_handlers(void) {
+    puts("event handlers:");
+    for (event_list_t::const_iterator iter = events.begin(); iter != events.end(); ++iter) {
+        const event_t *foo = *iter;
+        wcstring tmp = event_get_desc(foo);
+        printf("    handler now %ls\n", tmp.c_str());
+    }
+}
+#endif
+
+void event_add_handler( const event_t *event )
+{
+	event_t *e;
+
+	CHECK( event, );
+	
+	e = event_copy( event, 0 );
+
+	if( e->type == EVENT_SIGNAL )
+	{
+		signal_handle( e->param1.signal, 1 );
+	}
+    
+    // Block around updating the events vector
+    signal_block();
+    events.push_back(e);
+    signal_unblock();
+}
+
+void event_remove( event_t *criterion )
+{
+
+	size_t i;
+	event_list_t new_list;
+	
+	CHECK( criterion, );
+
+	/*
+	  Because of concurrency issues (env_remove could remove an event
+	  that is currently being executed), env_remove does not actually
+	  free any events - instead it simply moves all events that should
+	  be removed from the event list to the killme list, and the ones
+	  that shouldn't be killed to new_list, and then drops the empty
+	  events-list.
+	*/
+	
+	if( events.empty() )
+		return;
+
+	for( i=0; i<events.size(); i++ )
+	{
+		event_t *n = events.at(i);
+		if( event_match( criterion, n ) )
+		{
+            killme.push_back(n);
+
+			/*
+			  If this event was a signal handler and no other handler handles
+			  the specified signal type, do not handle that type of signal any
+			  more.
+			*/
+			if( n->type == EVENT_SIGNAL )
+			{
+                event_t e = event_t::signal_event(n->param1.signal);
+				if( event_get( &e, 0 ) == 1 )
+				{
+					signal_handle( e.param1.signal, 0 );
+				}		
+			}
+		}
+		else
+		{
+            new_list.push_back(n);
+		}
+	}
+    signal_block();
+	events.swap(new_list);
+    signal_unblock();
+}
+
+int event_get( event_t *criterion, std::vector<event_t *> *out )
+{
+	size_t i;
+	int found = 0;
+	
+	if( events.empty() )
+		return 0;	
+
+	CHECK( criterion, 0 );
+	
+	for( i=0; i<events.size(); i++ )
+	{
+		event_t *n = events.at(i);
+		if( event_match(criterion, n ) )
+		{
+			found++;
+			if( out )
+                out->push_back(n);
+		}		
+	}
+	return found;
+}
+
+bool event_is_signal_observed(int sig)
+{
+    /* We are in a signal handler! Don't allocate memory, etc.
+       This does what event_match does, except it doesn't require passing in an event_t.
+    */
+    size_t i, max = events.size();
+    for (i=0; i < max; i++)
+    {
+        const event_t *event = events[i];
+        if (event->type == EVENT_ANY)
+        {
+            return true;
+        }
+        else if (event->type == EVENT_SIGNAL)
+        {
+            if( event->param1.signal == EVENT_ANY_SIGNAL || event->param1.signal == sig)
+                return true;
+        }
+    }
+    return false;
+}
+
+/**
+   Free all events in the kill list
+*/
+static void event_free_kills()
+{
+    for_each(killme.begin(), killme.end(), event_free);
+    killme.resize(0);
+}
+
+/**
+   Test if the specified event is waiting to be killed
+*/
+static int event_is_killed( event_t *e )
+{
+    return std::find(killme.begin(), killme.end(), e) != killme.end();
+}	
+
+/**
+   Perform the specified event. Since almost all event firings will
+   not be matched by even a single event handler, we make sure to
+   optimize the 'no matches' path. This means that nothing is
+   allocated/initialized unless needed.
+*/
+static void event_fire_internal( const event_t *event )
+{
+
+	size_t i, j;
+	event_list_t fire;
+	
+	/*
+	  First we free all events that have been removed
+	*/
+	event_free_kills();	
+
+	if( events.empty() )
+		return;
+
+	/*
+	  Then we iterate over all events, adding events that should be
+	  fired to a second list. We need to do this in a separate step
+	  since an event handler might call event_remove or
+	  event_add_handler, which will change the contents of the \c
+	  events list.
+	*/
+	for( i=0; i<events.size(); i++ )
+	{
+		event_t *criterion = events.at(i);
+		
+		/*
+		  Check if this event is a match
+		*/
+		if(event_match( criterion, event ) )
+		{
+            fire.push_back(criterion);
+		}
+	}
+	
+	/*
+	  No matches. Time to return.
+	*/
+	if( fire.empty() )
+		return;
+		
+	/*
+	  Iterate over our list of matching events
+	*/
+	
+	for( i=0; i<fire.size(); i++ )
+	{
+		event_t *criterion = fire.at(i);
+		int prev_status;
+
+		/*
+		  Check if this event has been removed, if so, dont fire it
+		*/
+		if( event_is_killed( criterion ) )
+			continue;
+
+		/*
+		  Fire event
+		*/
+		wcstring buffer = criterion->function_name;
+		
+        if (event->arguments.get())
+        {
+            for( j=0; j< event->arguments->size(); j++ )
+            {
+                wcstring arg_esc = escape_string( event->arguments->at(j), 1 );		
+                buffer += L" ";
+                buffer += arg_esc;
+            }
+        }
+
+//		debug( 1, L"Event handler fires command '%ls'", buffer.c_str() );
+		
+		/*
+		  Event handlers are not part of the main flow of code, so
+		  they are marked as non-interactive
+		*/
+		proc_push_interactive(0);
+		prev_status = proc_get_last_status();
+        parser_t &parser = parser_t::principal_parser();
+        
+        block_t *block = new event_block_t(event);
+		parser.push_block(block);
+		parser.eval( buffer, io_chain_t(), TOP );
+		parser.pop_block();
+		proc_pop_interactive();					
+		proc_set_last_status( prev_status );
+	}
+
+	/*
+	  Free killed events
+	*/
+	event_free_kills();	
+	
+}
+
+/**
+   Handle all pending signal events
+*/
+static void event_fire_delayed()
+{
+
+	size_t i;
+
+	/*
+	  If is_event is one, we are running the event-handler non-recursively. 
+
+	  When the event handler has called a piece of code that triggers
+	  another event, we do not want to fire delayed events because of
+	  concurrency problems.
+	*/
+	if( ! blocked.empty() && is_event==1)
+	{
+		event_list_t new_blocked;
+		
+		for( i=0; i<blocked.size(); i++ )
+		{
+			event_t *e = blocked.at(i);
+			if( event_is_blocked( e ) )
+			{
+                new_blocked.push_back(e);
+			}
+			else
+			{
+				event_fire_internal( e );
+				event_free( e );
+			}
+		}		
+        blocked.swap(new_blocked);
+	}
+	
+	while( sig_list[active_list].count > 0 )
+	{
+		signal_list_t *lst;
+
+		/*
+		  Switch signal lists
+		*/
+		sig_list[1-active_list].count=0;
+		sig_list[1-active_list].overflow=0;
+		active_list=1-active_list;
+
+		/*
+		  Set up 
+		*/
+        event_t e = event_t::signal_event(0);
+        e.arguments.reset(new wcstring_list_t(1)); //one element
+		lst = &sig_list[1-active_list];
+		
+		if( lst->overflow )
+		{
+			debug( 0, _( L"Signal list overflow. Signals have been ignored." ) );
+		}
+		
+		/*
+		  Send all signals in our private list
+		*/
+		for( int i=0; i < lst->count; i++ )
+		{
+			e.param1.signal = lst->signal[i];
+            e.arguments->at(0) = sig2wcs( e.param1.signal );
+			if( event_is_blocked( &e ) )
+			{
+                blocked.push_back(event_copy(&e, 1));
+			}
+			else
+			{
+				event_fire_internal( &e );
+			}
+		}
+		
+        e.arguments.reset(NULL);
+		
+	}	
+}
+
+void event_fire_signal(int signal)
+{
+    /*
+      This means we are in a signal handler. We must be very
+      careful not do do anything that could cause a memory
+      allocation or something else that might be bad when in a
+      signal handler.
+    */
+    if( sig_list[active_list].count < SIG_UNHANDLED_MAX )
+        sig_list[active_list].signal[sig_list[active_list].count++]=signal;
+    else
+        sig_list[active_list].overflow=1;
+}
+
+
+void event_fire( event_t *event )
+{
+	
+	if( event && (event->type == EVENT_SIGNAL) )
+	{
+        event_fire_signal(event->param1.signal);
+	}
+	else
+	{
+        is_event++;
+
+		/*
+		  Fire events triggered by signals
+		*/
+		event_fire_delayed();
+			
+		if( event )
+		{
+			if( event_is_blocked( event ) )
+			{
+                blocked.push_back(event_copy(event, 1));
+			}
+			else
+			{
+				event_fire_internal( event );
+			}
+		}
+        is_event--;
+	}	
+}
+
+
+void event_init()
+{
+}
+
+void event_destroy()
+{
+
+    for_each(events.begin(), events.end(), event_free);
+    events.clear();
+    
+    for_each(killme.begin(), killme.end(), event_free);
+    killme.clear();
+}
+
+void event_free( event_t *e )
+{
+	CHECK( e, );
+    delete e;
+}
+
+
+void event_fire_generic_internal(const wchar_t *name, ...)
+{
+	va_list va;
+	wchar_t *arg;
+
+	CHECK( name, );
+
+	event_t ev(EVENT_GENERIC);
+	ev.str_param1 = name;
+    ev.arguments.reset(new wcstring_list_t);
+	va_start( va, name );
+	while( (arg=va_arg(va, wchar_t *) )!= 0 )
+	{
+        ev.arguments->push_back(arg);
+	}
+	va_end( va );
+	
+	event_fire( &ev );
+    ev.arguments.reset(NULL);
+}
+
+event_t event_t::signal_event(int sig) {
+    event_t event(EVENT_SIGNAL);
+    event.param1.signal = sig;
+    return event;
+}
+
+event_t event_t::variable_event(const wcstring &str) {
+    event_t event(EVENT_VARIABLE);
+    event.str_param1 = str;
+    return event;
+}
+
+event_t event_t::generic_event(const wcstring &str) {
+    event_t event(EVENT_GENERIC);
+    event.str_param1 = str;
+    return event;
+}
+
+event_t::event_t(const event_t &x) :
+                type(x.type),
+                param1(x.param1),
+                str_param1(x.str_param1),
+                function_name(x.function_name)
+{
+    const wcstring_list_t *ptr = x.arguments.get();
+    if (ptr)
+        arguments.reset(new wcstring_list_t(*ptr));
+}

event.h

@@ -7,11 +7,14 @@
 	functions produce output or perform memory allocations, since
 	such functions may not be safely called by signal handlers.
 
-
+	
 */
 #ifndef FISH_EVENT_H
 #define FISH_EVENT_H
 
+#include <memory>
+
+#include "common.h"
 
 /**
    The signal number that is used to match any signal
@@ -44,83 +47,86 @@ enum
    - When used as a parameter to event_add, it represents a class of events, and function_name is the name of the function which will be called whenever an event matching the specified class occurs. This is also how events are stored internally.
    - When used as a parameter to event_get, event_remove and event_fire, it represents a class of events, and if the function_name field is non-zero, only events which call the specified function will be returned.
 */
-typedef struct
+struct event_t
 {
 	/**
 	   Type of event
 	*/
 	int type;
 
-	/**
-	   The type-specific parameter
-	*/
-	union
-	{
-		/**
-		   Signal number for signal-type events.Use EVENT_ANY_SIGNAL
-		   to match any signal
-		*/
-		int signal;
-		/**
-		   Variable name for variable-type events.
-		*/
-		const wchar_t *variable;
-		/**
-		   Process id for process-type events. Use EVENT_ANY_PID to
-		   match any pid.
-		*/
-		pid_t pid;
-		/**
-		   Job id for EVENT_JOB_ID type events
-		*/
-		int job_id;
-		/**
-		   The parameter describing this generic event
-		*/
-		const wchar_t *param;
-
-	} param1;
+	/** The type-specific parameter. The int types are one of the following:
+    
+		   signal: Signal number for signal-type events.Use EVENT_ANY_SIGNAL to match any signal
+           pid: Process id for process-type events. Use EVENT_ANY_PID to match any pid.
+           job_id: Job id for EVENT_JOB_ID type events
+    */     
+    union {
+        int signal;
+        int job_id;
+        pid_t pid;
+    } param1;
+    
+    /** The string types are one of the following:
+    
+          variable: Variable name for variable-type events.
+          param: The parameter describing this generic event.
+    */
+    wcstring str_param1;
 
 	/**
 	   The name of the event handler function
 	*/
-	const wchar_t *function_name;
+	wcstring function_name;	
 
 	/**
 	   The argument list. Only used when sending a new event using
 	   event_fire. In all other situations, the value of this variable
 	   is ignored.
 	*/
-	array_list_t arguments;
-}
-	event_t;
+    std::auto_ptr<wcstring_list_t> arguments;
+    
+    event_t(int t) : type(t), param1(), str_param1(), function_name(), arguments() { }
+    
+    /** Copy constructor */
+    event_t(const event_t &x);
+    
+    static event_t signal_event(int sig);
+    static event_t variable_event(const wcstring &str);
+    static event_t generic_event(const wcstring &str);
+};
 
 /**
-   Add an event handler
+   Add an event handler 
 
    May not be called by a signal handler, since it may allocate new memory.
 */
-void event_add_handler( event_t *event );
+void event_add_handler( const event_t *event );
 
 /**
-   Remove all events matching the specified criterion.
+   Remove all events matching the specified criterion. 
 
    May not be called by a signal handler, since it may free allocated memory.
 */
 void event_remove( event_t *event );
 
 /**
-   Return all events which match the specified event class
+   Return all events which match the specified event class 
 
    This function is safe to call from a signal handler _ONLY_ if the
    out parameter is null.
 
    \param criterion Is the class of events to return. If the criterion has a non-null function_name, only events which trigger the specified function will return.
    \param out the list to add events to. May be 0, in which case no events will be added, but the result count will still be valid
-
+   
    \return the number of found matches
 */
-int event_get( event_t *criterion, array_list_t *out );
+int event_get( event_t *criterion, std::vector<event_t *> *out );
+
+/**
+    Returns whether an event listener is registered for the given signal.
+    This is safe to call from a signal handler.
+*/
+bool event_is_signal_observed(int signal);
 
 /**
    Fire the specified event. The function_name field of the event must
@@ -140,6 +146,9 @@ int event_get( event_t *criterion, array_list_t *out );
 */
 void event_fire( event_t *event );
 
+/** Like event_fire, but takes a signal directly. */
+void event_fire_signal(int signal);
+
 /**
    Initialize the event-handling library
 */
@@ -156,15 +165,14 @@ void event_destroy();
 void event_free( event_t *e );
 
 /**
-   Returns a string describing the specified event. The string should
-   not be freed.
+   Returns a string describing the specified event.
 */
-const wchar_t *event_get_desc( event_t *e );
+wcstring event_get_desc( const event_t *e );
 
 /**
    Fire a generic event with the specified name
 */
-#define event_fire_generic( ... ) event_fire_generic_internal( __VA_ARGS__, (void *)0 )
+#define event_fire_generic( ... ) event_fire_generic_internal( __VA_ARGS__, NULL )
 
 void event_fire_generic_internal(const wchar_t *name,...);
 

exec.h

@@ -9,9 +9,11 @@
 #define FISH_EXEC_H
 
 #include <wchar.h>
+#include <vector>
 
 #include "proc.h"
 #include "util.h"
+#include "common.h"
 
 /**
    pipe redirection error message
@@ -19,7 +21,7 @@
 #define PIPE_ERROR _(L"An error occurred while setting up pipe")
 
 /**
-  Execute the processes specified by j.
+  Execute the processes specified by j. 
 
    I've put a fair bit of work into making builtins behave like other
    programs as far as pipes are concerned. Unlike i.e. bash, builtins
@@ -39,7 +41,8 @@
 
 
 */
-void exec( job_t *j );
+class parser_t;
+void exec( parser_t &parser, job_t *j );
 
 /**
   Evaluate the expression cmd in a subshell, add the outputs into the
@@ -47,17 +50,17 @@ void exec( job_t *j );
   proc_gfet_last_status will not be changed.
 
   \param cmd the command to execute
-  \param l The list to insert output into.If \c l is zero, the output will be discarded.
+  \param outputs The list to insert output into.
 
   \return the status of the last job to exit, or -1 if en error was encountered.
 */
-__warn_unused int exec_subshell( const wchar_t *cmd,
-								 array_list_t *l );
+__warn_unused int exec_subshell(const wcstring &cmd, std::vector<wcstring> &outputs );
+__warn_unused int exec_subshell(const wcstring &cmd );
 
 
 /**
-   Loops over close until thesyscall was run without beeing
-   interrupted. Thenremoves the fd from the open_fds list.
+   Loops over close until the syscall was run without being
+   interrupted. Then removes the fd from the open_fds list.
 */
 void exec_close( int fd );
 
@@ -67,4 +70,13 @@ void exec_close( int fd );
 */
 int exec_pipe( int fd[2]);
 
+/* Close all fds in open_fds. This is called from postfork.cpp */
+void close_unused_internal_pipes( const io_chain_t &io );
+
+/* Gets all unused internal pipes into fds */
+void get_unused_internal_pipes(std::vector<int> &fds, const io_chain_t &io);
+
+/** Gets the interpreter for a given command */
+char *get_interpreter( const char *command, char *interpreter, size_t buff_size );
+
 #endif

expand.h

@@ -6,7 +6,7 @@
    benefit from using a more clever memory allocation scheme, perhaps
    an evil combination of talloc, string buffers and reference
    counting.
-
+   
 */
 
 #ifndef FISH_EXPAND_H
@@ -18,41 +18,43 @@
 #include <wchar.h>
 
 #include "util.h"
+#include "common.h"
+#include <list>
 
-/**
-   Flag specifying that cmdsubst expansion should be skipped
-*/
-#define EXPAND_SKIP_CMDSUBST 1
+enum {
+    /** Flag specifying that cmdsubst expansion should be skipped */
+    EXPAND_SKIP_CMDSUBST = 1 << 0,
+    
+    /** Flag specifying that variable expansion should be skipped */
+    EXPAND_SKIP_VARIABLES = 1 << 1,
+    
+    /** Flag specifying that wildcard expansion should be skipped */
+    EXPAND_SKIP_WILDCARDS = 1 << 2,
 
-/**
-   Flag specifying that variable expansion should be skipped
-*/
-#define EXPAND_SKIP_VARIABLES 2
+    /**
+       Incomplete matches in the last segment are ok (for tab
+       completion). An incomplete match is a wildcard that matches a
+       prefix of the filename. If accept_incomplete is true, only the
+       remainder of the string is returned.
+    */    
+    ACCEPT_INCOMPLETE = 1 << 3,
 
-/**
-   Flag specifying that wildcard expansion should be skipped
-*/
-#define EXPAND_SKIP_WILDCARDS 4
-
-/**
-   Incomplete matches in the last segment are ok (for tab
-   completion). An incomplete match is a wildcard that matches a
-   prefix of the filename. If accept_incomplete is true, only the
-   remainder of the string is returned.
-*/
-#define ACCEPT_INCOMPLETE 8
-
-/**
-   Only match files that are executable by the current user. Only applicable together with ACCEPT_INCOMPLETE.
-*/
-
-#define EXECUTABLES_ONLY 16
-
-/**
-   Only match directories. Only applicable together with ACCEPT_INCOMPLETE.
-*/
-
-#define DIRECTORIES_ONLY 32
+    /** Only match files that are executable by the current user. Only applicable together with ACCEPT_INCOMPLETE. */
+    EXECUTABLES_ONLY = 1 << 4,
+    
+    /** Only match directories. Only applicable together with ACCEPT_INCOMPLETE. */
+    DIRECTORIES_ONLY = 1 << 5,
+    
+    /** Don't generate descriptions */
+    EXPAND_NO_DESCRIPTIONS = 1 << 6,
+    
+    /** Don't do process expansion */
+    EXPAND_SKIP_PROCESS = 1 << 7,
+    
+    /** Don't expand jobs (but you can still expand processes). This is because job expansion is not thread safe. */
+    EXPAND_SKIP_JOBS = 1 << 8
+};
+typedef int expand_flags_t;
 
 /**
   Use unencoded private-use keycodes for internal characters
@@ -63,6 +65,8 @@
  */
 #define EXPAND_RESERVED_END 0xf000f
 
+class completion_t;
+
 enum
 {
 	/** Character represeting a home directory */
@@ -70,7 +74,7 @@ enum
 
 	/** Character represeting process expansion */
 	PROCESS_EXPAND,
-
+	
 	/** Character representing variable expansion */
 	VARIABLE_EXPAND,
 
@@ -86,7 +90,7 @@ enum
 	/** Character representing separation between two bracket elements */
 	BRACKET_SEP,
 	/**
-	   Separate subtokens in a token with this character.
+	   Separate subtokens in a token with this character. 
 	*/
 	INTERNAL_SEPARATOR,
 
@@ -107,8 +111,7 @@ enum
 	EXPAND_WILDCARD_NO_MATCH,
 	/* Ok, a wildcard in the string matched a file */
 	EXPAND_WILDCARD_MATCH
-}
-	;
+};
 
 /** Character for separating two array elements. We use 30, i.e. the ascii record separator since that seems logical. */
 #define ARRAY_SEP 0x1e
@@ -121,6 +124,7 @@ enum
 */
 #define ARRAY_BOUNDS_ERR _(L"Array index out of bounds")
 
+class parser_t;
 
 /**
    Perform various forms of expansion on in, such as tilde expansion
@@ -128,55 +132,42 @@ enum
    (\$VAR_NAME becomes the value of the environment variable VAR_NAME),
    cmdsubst expansion and wildcard expansion. The results are inserted
    into the list out.
-
+   
    If the parameter does not need expansion, it is copied into the list
-   out. If expansion is performed, the original parameter is freed and
-   newly allocated strings are inserted into the list out.
+   out.
 
-   If \c context is non-null, all the strings contained in the
-   array_list_t \c out will be registered to be free'd when context is
-   free'd.
-
-   \param context the halloc context to use for automatic deallocation
-   \param in The parameter to expand
+   \param input The parameter to expand
+   \param output The list to which the result will be appended.
    \param flag Specifies if any expansion pass should be skipped. Legal values are any combination of EXPAND_SKIP_CMDSUBST EXPAND_SKIP_VARIABLES and EXPAND_SKIP_WILDCARDS
-   \param out The list to which the result will be appended.
    \return One of EXPAND_OK, EXPAND_ERROR, EXPAND_WILDCARD_MATCH and EXPAND_WILDCARD_NO_MATCH. EXPAND_WILDCARD_NO_MATCH and EXPAND_WILDCARD_MATCH are normal exit conditions used only on strings containing wildcards to tell if the wildcard produced any matches.
 */
-__warn_unused int expand_string( void *context, wchar_t *in, array_list_t *out, int flag );
+__warn_unused int expand_string( const wcstring &input, std::vector<completion_t> &output, expand_flags_t flags );
+
 
 /**
    expand_one is identical to expand_string, except it will fail if in
    expands to more than one string. This is used for expanding command
    names.
-
-   If \c context is non-null, the returning string ill be registered
-   to be free'd when context is free'd.
-
-   \param context the halloc context to use for automatic deallocation
-   \param in The parameter to expand
+ 
+   \param inout_str The parameter to expand in-place
    \param flag Specifies if any expansion pass should be skipped. Legal values are any combination of EXPAND_SKIP_CMDSUBST EXPAND_SKIP_VARIABLES and EXPAND_SKIP_WILDCARDS
-   \return The expanded parameter, or 0 on failiure
+   \return Whether expansion succeded
 */
-wchar_t *expand_one( void *context, wchar_t *in, int flag );
+bool expand_one( wcstring &inout_str, expand_flags_t flags );
 
 /**
-   Convert the variable value to a human readable form, i.e. escape things, handle arrays, etc. Suitable for pretty-printing.
+   Convert the variable value to a human readable form, i.e. escape things, handle arrays, etc. Suitable for pretty-printing. The result must be free'd!
 
    \param in the value to escape
 */
-wchar_t *expand_escape_variable( const wchar_t *in );
+wcstring expand_escape_variable( const wcstring &in );
 
 /**
-   Perform tilde expansion and nothing else on the specified string.
+   Perform tilde expansion and nothing else on the specified string, which is modified in place.
 
-   If tilde expansion is needed, the original string is freed and a
-   new string, allocated using malloc, is returned.
-
-   \param in the string to tilde expand
+   \param input the string to tilde expand
 */
-wchar_t *expand_tilde(wchar_t *in);
-
+void expand_tilde(wcstring &input);
 
 /**
    Test if the specified argument is clean, i.e. it does not contain
@@ -201,7 +192,11 @@ int expand_is_clean( const wchar_t *in );
    \param token_pos The position where the expansion begins
    \param error_pos The position on the line to report to the error function.
 */
-void expand_variable_error( const wchar_t *token, int token_pos, int error_pos );
+void expand_variable_error( parser_t &parser, const wchar_t *token, size_t token_pos, int error_pos );
 
+/**
+   Testing function for getting all process names.
+*/
+std::vector<wcstring> expand_get_all_process_names(void);
 
 #endif

fallback.h

@@ -12,6 +12,10 @@
 #include <sys/types.h>
 #include <signal.h>
 
+/** fish's internal versions of wcwidth and wcswidth, which can use an internal implementation if the system one is busted. */
+int fish_wcwidth(wchar_t wc);
+int fish_wcswidth(const wchar_t *str, size_t n);
+
 #ifndef WCHAR_MAX
 /**
    This _should_ be defined by wchar.h, but e.g. OpenBSD doesn't.
@@ -57,12 +61,12 @@ typedef char tputs_arg_t;
 /**
    Structure used to get the size of a terminal window
  */
-struct winsize
+struct winsize 
 {
 	/**
 	   Number of rows
 	 */
-	unsigned short ws_row;
+	unsigned short ws_row;	
 	/**
 	   Number of columns
 	 */
@@ -193,7 +197,7 @@ wchar_t *wcstok(wchar_t *wcs, const wchar_t *delim, wchar_t **ptr);
 /**
    Return the number of columns used by a character. This is a libc
    function, but the prototype for this function is missing in some libc
-   implementations.
+   implementations. 
 
    Fish has a fallback implementation in case the implementation is
    missing altogether.  In locales without a native wcwidth, Unicode
@@ -205,7 +209,20 @@ int wcwidth( wchar_t c );
 
 #endif
 
-#ifndef HAVE_WCSDUP
+
+/** On OS X, use weak linking for wcsdup and wcscasecmp. Weak linking allows you to call the function only if it exists at runtime. You can detect it by testing the function pointer against NULL. To avoid making the callers do that, redefine wcsdup to wcsdup_use_weak, and likewise with wcscasecmp. This lets us use the same binary on SnowLeopard (10.6) and Lion+ (10.7), even though these functions only exist on 10.7+.
+
+    On other platforms, use what's detected at build time.
+*/
+#if __APPLE__ && __DARWIN_C_LEVEL >= 200809L
+ wchar_t *wcsdup_use_weak(const wchar_t *);
+ int wcscasecmp_use_weak(const wchar_t *, const wchar_t *);
+ #define wcsdup(a) wcsdup_use_weak((a))
+ #define wcscasecmp(a, b) wcscasecmp_use_weak((a), (b))
+ 
+#else
+
+ #ifndef HAVE_WCSDUP
 
 /**
    Create a duplicate string. Wide string version of strdup. Will
@@ -213,18 +230,9 @@ int wcwidth( wchar_t c );
 */
 wchar_t *wcsdup(const wchar_t *in);
 
-#endif
+ #endif
 
-#ifndef HAVE_WCSLEN
-
-/**
-   Fallback for wcsen. Returns the length of the specified string.
-*/
-size_t wcslen(const wchar_t *in);
-
-#endif
-
-#ifndef HAVE_WCSCASECMP
+ #ifndef HAVE_WCSCASECMP
 /**
    Case insensitive string compare function. Wide string version of
    strcasecmp.
@@ -238,8 +246,20 @@ size_t wcslen(const wchar_t *in);
 */
 int wcscasecmp( const wchar_t *a, const wchar_t *b );
 
+ #endif
+#endif //__APPLE__
+
+
+#ifndef HAVE_WCSLEN
+
+/**
+   Fallback for wclsen. Returns the length of the specified string.
+*/
+size_t wcslen(const wchar_t *in);
+
 #endif
 
+
 #ifndef HAVE_WCSNCASECMP
 
 /**
@@ -270,7 +290,7 @@ int wcsncasecmp( const wchar_t *a, const wchar_t *b, int count );
    Fallback for wcsndup function. Returns a copy of \c in, truncated
    to a maximum length of \c c.
 */
-wchar_t *wcsndup( const wchar_t *in, int c );
+wchar_t *wcsndup( const wchar_t *in, size_t c );
 
 #endif
 
@@ -320,7 +340,7 @@ size_t wcslcat( wchar_t *dst, const wchar_t *src, size_t siz );
    wcslen(src); if retval >= siz, truncation occurred.
 
    This is the OpenBSD strlcpy function, modified for wide characters,
-   and renamed to reflect this change.
+   and renamed to reflect this change. 
 */
 size_t wcslcpy( wchar_t *dst, const wchar_t *src, size_t siz );
 
@@ -390,7 +410,7 @@ char * textdomain( const char * domainname );
 /**
    Fallback implementation of dcgettext. Just returns the original string.
 */
-char * dcgettext ( const char * domainname,
+char * dcgettext ( const char * domainname, 
 		   const char * msgid,
 		   int category );
 
@@ -421,7 +441,7 @@ int killpg( int pgr, int sig );
 /**
    Struct describing a long getopt option
  */
-struct option
+struct option 
 {
 	/**
 	   Name of option
@@ -438,7 +458,7 @@ struct option
 	/**
 	   Return value
 	 */
-	int val;
+	int val;	
 }
 ;
 
@@ -454,10 +474,10 @@ struct option
 #define	optional_argument 2
 #endif
 
-int getopt_long(int argc,
+int getopt_long(int argc, 
 		char * const argv[],
 		const char *optstring,
-		const struct option *longopts,
+		const struct option *longopts, 
 		int *longindex);
 
 #endif

fish.c

@@ -1,403 +0,0 @@
-/*
-Copyright (C) 2005-2008 Axel Liljencrantz
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License version 2 as
-published by the Free Software Foundation.
-
-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.
-*/
-
-
-/** \file fish.c
-	The main loop of <tt>fish</tt>.
-*/
-
-#include "config.h"
-
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <wchar.h>
-#include <string.h>
-#include <unistd.h>
-#include <errno.h>
-#include <unistd.h>
-#include <termios.h>
-#include <fcntl.h>
-
-#ifdef HAVE_GETOPT_H
-#include <getopt.h>
-#endif
-
-#include <locale.h>
-#include <signal.h>
-
-#include "fallback.h"
-#include "util.h"
-
-#include "common.h"
-#include "reader.h"
-#include "builtin.h"
-#include "function.h"
-#include "complete.h"
-#include "wutil.h"
-#include "env.h"
-#include "sanity.h"
-#include "proc.h"
-#include "parser.h"
-#include "expand.h"
-#include "intern.h"
-#include "exec.h"
-#include "event.h"
-#include "output.h"
-#include "halloc.h"
-#include "halloc_util.h"
-#include "history.h"
-#include "path.h"
-
-/**
-   The string describing the single-character options accepted by the main fish binary
-*/
-#define GETOPT_STRING "+hilnvc:p:d:"
-
-/**
-   Parse init files
-*/
-static int read_init()
-{
-	wchar_t *config_dir;
-	wchar_t *config_dir_escaped;
-	void *context;
-	string_buffer_t *eval_buff;
-
-	eval( L"builtin . " DATADIR "/fish/config.fish 2>/dev/null", 0, TOP );
-	eval( L"builtin . " SYSCONFDIR L"/fish/config.fish 2>/dev/null", 0, TOP );
-
-	/*
-	  We need to get the configuration directory before we can source the user configuration file
-	*/
-	context = halloc( 0, 0 );
-	eval_buff = sb_halloc( context );
-	config_dir = path_get_config( context );
-
-	/*
-	  If config_dir is null then we have no configuration directory
-	  and no custom config to load.
-	*/
-	if( config_dir )
-	{
-		config_dir_escaped = escape( config_dir, 1 );
-		sb_printf( eval_buff, L"builtin . %ls/config.fish 2>/dev/null", config_dir_escaped );
-		eval( (wchar_t *)eval_buff->buff, 0, TOP );
-		free( config_dir_escaped );
-	}
-
-	halloc_free( context );
-
-	return 1;
-}
-
-
-/**
-  Parse the argument list, return the index of the first non-switch
-  arguments.
- */
-static int fish_parse_opt( int argc, char **argv, char **cmd_ptr )
-{
-	int my_optind;
-	int force_interactive=0;
-
-	while( 1 )
-	{
-		static struct option
-			long_options[] =
-			{
-				{
-					"command", required_argument, 0, 'c'
-				}
-				,
-				{
-					"debug-level", required_argument, 0, 'd'
-				}
-				,
-				{
-					"interactive", no_argument, 0, 'i'
-				}
-				,
-				{
-					"login", no_argument, 0, 'l'
-				}
-				,
-				{
-					"no-execute", no_argument, 0, 'n'
-				}
-				,
-				{
-					"profile", required_argument, 0, 'p'
-				}
-				,
-				{
-					"help", no_argument, 0, 'h'
-				}
-				,
-				{
-					"version", no_argument, 0, 'v'
-				}
-				,
-				{
-					0, 0, 0, 0
-				}
-			}
-		;
-
-		int opt_index = 0;
-
-		int opt = getopt_long( argc,
-							   argv,
-							   GETOPT_STRING,
-							   long_options,
-							   &opt_index );
-
-		if( opt == -1 )
-			break;
-
-		switch( opt )
-		{
-			case 0:
-			{
-				break;
-			}
-
-			case 'c':
-			{
-				*cmd_ptr = optarg;
-				is_interactive_session = 0;
-				break;
-			}
-
-			case 'd':
-			{
-				char *end;
-				int tmp;
-
-				errno = 0;
-				tmp = strtol(optarg, &end, 10);
-
-				if( tmp >= 0 && tmp <=10 && !*end && !errno )
-				{
-					debug_level=tmp;
-				}
-				else
-				{
-					debug( 0, _(L"Invalid value '%s' for debug level switch"), optarg );
-					exit(1);
-				}
-				break;
-			}
-
-			case 'h':
-			{
-				*cmd_ptr = "__fish_print_help fish";
-				break;
-			}
-
-			case 'i':
-			{
-				force_interactive = 1;
-				break;
-			}
-
-			case 'l':
-			{
-				is_login=1;
-				break;
-			}
-
-			case 'n':
-			{
-				no_exec=1;
-				break;
-			}
-
-			case 'p':
-			{
-				profile = optarg;
-				break;
-			}
-
-			case 'v':
-			{
-				fwprintf( stderr,
-						  _(L"%s, version %s\n"),
-						  PACKAGE_NAME,
-						  PACKAGE_VERSION );
-				exit( 0 );
-			}
-
-			case '?':
-			{
-				exit( 1 );
-			}
-
-		}
-	}
-
-	my_optind = optind;
-
-	is_login |= (strcmp( argv[0], "-fish") == 0);
-
-	/*
-	  We are an interactive session if we have not been given an
-	  explicit command to execute, _and_ stdin is a tty.
-	 */
-	is_interactive_session &= (*cmd_ptr == 0);
-	is_interactive_session &= (my_optind == argc);
-	is_interactive_session &= isatty(STDIN_FILENO);
-
-	/*
-	  We are also an interactive session if we have are forced-
-	 */
-	is_interactive_session |= force_interactive;
-
-	return my_optind;
-}
-
-
-/**
-   Calls a bunch of init functions, parses the init files and then
-   parses commands from stdin or files, depending on arguments
-*/
-
-int main( int argc, char **argv )
-{
-	int res=1;
-	char *cmd=0;
-	int my_optind=0;
-
-	halloc_util_init();
-
-	wsetlocale( LC_ALL, L"" );
-	is_interactive_session=1;
-	program_name=L"fish";
-
-
-	my_optind = fish_parse_opt( argc, argv, &cmd );
-
-	/*
-	  No-exec is prohibited when in interactive mode
-	*/
-	if( is_interactive_session && no_exec)
-	{
-		debug( 1, _(L"Can not use the no-execute mode when running an interactive session") );
-		no_exec = 0;
-	}
-
-	proc_init();
-	event_init();
-	wutil_init();
-	parser_init();
-	builtin_init();
-	function_init();
-	env_init();
-	reader_init();
-	history_init();
-
-	if( read_init() )
-	{
-		if( cmd != 0 )
-		{
-			wchar_t *cmd_wcs = str2wcs( cmd );
-			res = eval( cmd_wcs, 0, TOP );
-			free(cmd_wcs);
-			reader_exit(0, 0);
-		}
-		else
-		{
-			if( my_optind == argc )
-			{
-				res = reader_read( STDIN_FILENO, 0 );
-			}
-			else
-			{
-				char **ptr;
-				char *file = *(argv+(my_optind++));
-				int i;
-				string_buffer_t sb;
-				int fd;
-				wchar_t *rel_filename, *abs_filename;
-
-				if( ( fd = open(file, O_RDONLY) ) == -1 )
-				{
-					wperror( L"open" );
-					return 1;
-				}
-
-				if( *(argv+my_optind))
-				{
-					sb_init( &sb );
-
-					for( i=1,ptr = argv+my_optind; *ptr; i++, ptr++ )
-					{
-						if( i != 1 )
-							sb_append( &sb, ARRAY_SEP_STR );
-						wchar_t *val = str2wcs( *ptr );
-						sb_append( &sb, val );
-						free( val );
-					}
-
-					env_set( L"argv", (wchar_t *)sb.buff, 0 );
-					sb_destroy( &sb );
-				}
-
-				rel_filename = str2wcs( file );
-				abs_filename = wrealpath( rel_filename, 0 );
-
-				if( !abs_filename )
-				{
-					abs_filename = wcsdup(rel_filename);
-				}
-
-				reader_push_current_filename( intern( abs_filename ) );
-				free( rel_filename );
-				free( abs_filename );
-
-				res = reader_read( fd, 0 );
-
-				if( res )
-				{
-					debug( 1,
-					       _(L"Error while reading file %ls\n"),
-					       reader_current_filename()?reader_current_filename(): _(L"Standard input") );
-				}
-				reader_pop_current_filename();
-			}
-		}
-	}
-
-	proc_fire_event( L"PROCESS_EXIT", EVENT_EXIT, getpid(), res );
-
-	history_destroy();
-	proc_destroy();
-	builtin_destroy();
-	function_destroy();
-	reader_destroy();
-	parser_destroy();
-	wutil_destroy();
-	event_destroy();
-
-	halloc_util_destroy();
-
-	env_destroy();
-
-	intern_free_all();
-
-	return res?STATUS_UNKNOWN_COMMAND:proc_get_last_status();
-}

fish.cpp

@@ -0,0 +1,572 @@
+/*
+Copyright (C) 2005-2008 Axel Liljencrantz
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 2 as
+published by the Free Software Foundation.
+
+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.
+*/
+
+
+/** \file fish.c
+	The main loop of <tt>fish</tt>.
+*/
+
+#include "config.h"
+
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <wchar.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <unistd.h>
+#include <termios.h>
+#include <fcntl.h>
+#include <sys/param.h>
+
+#ifdef HAVE_GETOPT_H
+#include <getopt.h>
+#endif
+
+#include <locale.h>
+#include <signal.h>
+
+#include "fallback.h"
+#include "util.h"
+
+#include "common.h"
+#include "reader.h"
+#include "builtin.h"
+#include "function.h"
+#include "complete.h"
+#include "wutil.h"
+#include "env.h"
+#include "sanity.h"
+#include "proc.h"
+#include "parser.h"
+#include "expand.h"
+#include "intern.h"
+#include "exec.h"
+#include "event.h"
+#include "output.h"
+#include "history.h"
+#include "path.h"
+
+/* PATH_MAX may not exist */
+#ifndef PATH_MAX
+#define PATH_MAX 1024
+#endif
+
+/**
+   The string describing the single-character options accepted by the main fish binary
+*/
+#define GETOPT_STRING "+hilnvc:p:d:"
+
+static bool has_suffix(const std::string &path, const char *suffix, bool ignore_case)
+{
+    size_t pathlen = path.size(), suffixlen = strlen(suffix);
+    return pathlen >= suffixlen && ! (ignore_case ? strcasecmp : strcmp)(path.c_str() + pathlen - suffixlen, suffix);
+}
+
+/* Modifies the given path by calling realpath. Returns true if realpath succeeded, false otherwise */
+static bool get_realpath(std::string &path)
+{
+    char buff[PATH_MAX], *ptr;
+    if ((ptr = realpath(path.c_str(), buff)))
+    {
+        path = ptr;
+    }
+    return ptr != NULL;
+}
+
+/* OS X function for getting the executable path */
+extern "C" {
+    int _NSGetExecutablePath(char* buf, uint32_t* bufsize);
+}
+
+/* Return the path to the current executable. This needs to be realpath'd. */
+static std::string get_executable_path(const char *argv0)
+{
+    char buff[PATH_MAX];
+#if __APPLE__
+    {
+        /* Returns 0 on success, -1 if the buffer is too small */
+        uint32_t buffSize = sizeof buff;
+        if (0 == _NSGetExecutablePath(buff, &buffSize))
+            return std::string(buff);
+        
+        /* Loop until we're big enough */
+        char *mbuff = (char *)malloc(buffSize);
+        while (0 > _NSGetExecutablePath(mbuff, &buffSize))
+            mbuff = (char *)realloc(mbuff, buffSize);
+        
+        /* Return the string */
+        std::string result = mbuff;
+        free(mbuff);
+        return result;
+    }
+#endif
+    {
+        /* On other Unixes, try /proc directory. This might be worth breaking out into macros. */
+        if (0 < readlink("/proc/self/exe", buff, sizeof buff) || // Linux
+            0 < readlink("/proc/curproc/file", buff, sizeof buff) || // BSD
+            0 < readlink("/proc/self/path/a.out", buff, sizeof buff)) // Solaris
+        {
+            return std::string(buff);
+        }
+    }
+    
+    /* Just return argv0, which probably won't work (i.e. it's not an absolute path or a path relative to the working directory, but instead something the caller found via $PATH). We'll eventually fall back to the compile time paths. */
+    return std::string(argv0 ? argv0 : "");
+}
+
+
+static struct config_paths_t determine_config_directory_paths(const char *argv0)
+{
+    struct config_paths_t paths;
+    bool done = false;
+    std::string exec_path = get_executable_path(argv0);
+    if (get_realpath(exec_path))
+    {        
+#if __APPLE__
+        
+        /* On OS X, maybe we're an app bundle, and should use the bundle's files. Since we don't link CF, use this lame approach to test it: see if the resolved path ends with /Contents/MacOS/fish, case insensitive since HFS+ usually is.
+         */
+        if (! done)
+        {
+            const char *suffix = "/Contents/MacOS/fish";
+            const size_t suffixlen = strlen(suffix);
+            if (has_suffix(exec_path, suffix, true))
+            {
+                /* Looks like we're a bundle. Cut the string at the / prefixing /Contents... and then the rest */
+                wcstring wide_resolved_path = str2wcstring(exec_path);
+                wide_resolved_path.resize(exec_path.size() - suffixlen);
+                wide_resolved_path.append(L"/Contents/Resources/");
+                
+                /* Append share, etc, doc */
+                paths.data = wide_resolved_path + L"share/fish";
+                paths.sysconf = wide_resolved_path + L"etc/fish";
+                paths.doc = wide_resolved_path + L"doc/fish";
+                
+                /* But the bin_dir is the resolved_path, minus fish (aka the MacOS directory) */
+                paths.bin = str2wcstring(exec_path);
+                paths.bin.resize(paths.bin.size() - strlen("/fish"));
+                
+                done = true;
+            }
+        }
+#endif
+        
+        if (! done)
+        {
+            /* The next check is that we are in a reloctable directory tree like this:
+                 bin/fish
+                 etc/fish
+                 share/fish
+                 
+                 Check it!
+            */
+            const char *suffix = "/bin/fish";
+            if (has_suffix(exec_path, suffix, false))
+            {
+                wcstring base_path = str2wcstring(exec_path);
+                base_path.resize(base_path.size() - strlen(suffix));
+                
+                paths.data = base_path + L"/share/fish";
+                paths.sysconf = base_path + L"/etc/fish";
+                paths.doc = base_path + L"/share/doc/fish";
+                paths.bin = base_path + L"/bin";
+                
+                struct stat buf;
+                if (0 == wstat(paths.data, &buf) && 0 == wstat(paths.sysconf, &buf))
+                {
+                    done = true;
+                }
+            }
+        }
+    }
+    
+    if (! done)
+    {
+        /* Fall back to what got compiled in. */
+        paths.data = L"" DATADIR "/fish";
+        paths.sysconf = L"" SYSCONFDIR "/fish";
+        paths.doc = L"" DATADIR "/doc/fish";
+        paths.bin = L"" PREFIX "/bin";
+        
+        done = true;
+    }
+    
+    return paths;
+}
+
+/**
+   Parse init files. exec_path is the path of fish executable as determined by argv[0].
+*/
+static int read_init(const struct config_paths_t &paths)
+{
+    parser_t &parser = parser_t::principal_parser();
+    const io_chain_t empty_ios;
+	parser.eval( L"builtin . " + paths.data + L"/config.fish 2>/dev/null", empty_ios, TOP );
+	parser.eval( L"builtin . " + paths.sysconf + L"/config.fish 2>/dev/null", empty_ios, TOP );
+
+	
+	/*
+	  We need to get the configuration directory before we can source the user configuration file
+	*/
+	wcstring config_dir;
+
+	/*
+	  If path_get_config returns false then we have no configuration directory
+	  and no custom config to load.
+	*/
+    if (path_get_config(config_dir))
+	{
+		wcstring config_dir_escaped = escape_string( config_dir, 1 );
+        wcstring eval_buff = format_string(L"builtin . %ls/config.fish 2>/dev/null", config_dir_escaped.c_str());
+		parser.eval( eval_buff, empty_ios, TOP );
+	}
+	
+	return 1;
+}
+
+
+/**
+  Parse the argument list, return the index of the first non-switch
+  arguments.
+ */
+static int fish_parse_opt( int argc, char **argv, const char **cmd_ptr )
+{
+	int my_optind;
+	int force_interactive=0;
+		
+	while( 1 )
+	{
+		static struct option
+			long_options[] =
+			{
+				{
+					"command", required_argument, 0, 'c' 
+				}
+				,
+				{
+					"debug-level", required_argument, 0, 'd' 
+				}
+				,
+				{
+					"interactive", no_argument, 0, 'i' 
+				}
+				,
+				{
+					"login", no_argument, 0, 'l' 
+				}
+				,
+				{
+					"no-execute", no_argument, 0, 'n' 
+				}
+				,
+				{
+					"profile", required_argument, 0, 'p' 
+				}
+				,
+				{
+					"help", no_argument, 0, 'h' 
+				}
+				,
+				{
+					"version", no_argument, 0, 'v' 
+				}
+				,
+				{ 
+					0, 0, 0, 0 
+				}
+			}
+		;
+		
+		int opt_index = 0;
+		
+		int opt = getopt_long( argc,
+							   argv, 
+							   GETOPT_STRING,
+							   long_options, 
+							   &opt_index );
+		
+		if( opt == -1 )
+			break;
+		
+		switch( opt )
+		{
+			case 0:
+			{
+				break;
+			}
+			
+			case 'c':		
+			{
+				*cmd_ptr = optarg;				
+				is_interactive_session = 0;
+				break;
+			}
+			
+			case 'd':		
+			{
+				char *end;
+				long tmp;
+
+				errno = 0;
+				tmp = strtol(optarg, &end, 10);
+				
+				if( tmp >= 0 && tmp <=10 && !*end && !errno )
+				{
+					debug_level = (int)tmp;
+				}
+				else
+				{
+					debug( 0, _(L"Invalid value '%s' for debug level switch"), optarg );
+					exit_without_destructors(1);
+				}
+				break;
+			}
+			
+			case 'h':
+			{
+				*cmd_ptr = "__fish_print_help fish";
+				break;
+			}
+			
+			case 'i':
+			{
+				force_interactive = 1;
+				break;				
+			}
+			
+			case 'l':
+			{
+				is_login=1;
+				break;				
+			}
+			
+			case 'n':
+			{
+				no_exec=1;
+				break;				
+			}
+			
+			case 'p':
+			{
+				profile = optarg;
+				break;				
+			}
+			
+			case 'v':
+			{
+				fwprintf( stderr, 
+						  _(L"%s, version %s\n"), 
+						  PACKAGE_NAME,
+						  PACKAGE_VERSION );
+				exit_without_destructors( 0 );				
+			}
+			
+			case '?':
+			{
+				exit_without_destructors( 1 );
+			}
+			
+		}		
+	}
+
+	my_optind = optind;
+	
+	is_login |= (strcmp( argv[0], "-fish") == 0);
+		
+	/*
+	  We are an interactive session if we have not been given an
+	  explicit command to execute, _and_ stdin is a tty.
+	 */
+	is_interactive_session &= (*cmd_ptr == 0);
+	is_interactive_session &= (my_optind == argc);
+	is_interactive_session &= isatty(STDIN_FILENO);	
+
+	/*
+	  We are also an interactive session if we have are forced-
+	 */
+	is_interactive_session |= force_interactive;
+
+	return my_optind;
+}
+
+/**
+   Calls a bunch of init functions, parses the init files and then
+   parses commands from stdin or files, depending on arguments
+*/
+
+static wcstring full_escape( const wchar_t *in )
+{
+	wcstring out;
+	for( ; *in; in++ )
+	{
+		if( *in < 32 )
+		{
+			append_format( out, L"\\x%.2x", *in );
+		}
+		else if( *in < 128 )
+		{
+			out.push_back(*in);
+		}
+		else if( *in < 65536 )
+		{
+			append_format( out, L"\\u%.4x", *in );
+		}
+		else
+		{
+			append_format( out, L"\\U%.8x", *in );
+		}
+	}
+	return out;
+}
+
+extern int g_fork_count;
+int main( int argc, char **argv )
+{    
+	int res=1;
+	const char *cmd=0;
+	int my_optind=0;
+
+	set_main_thread();
+    setup_fork_guards();
+    save_term_foreground_process_group();
+    
+	wsetlocale( LC_ALL, L"" );
+	is_interactive_session=1;
+	program_name=L"fish";
+
+    //struct stat tmp;
+    //stat("----------FISH_HIT_MAIN----------", &tmp);
+
+	my_optind = fish_parse_opt( argc, argv, &cmd );
+
+	/*
+	  No-exec is prohibited when in interactive mode
+	*/
+	if( is_interactive_session && no_exec)
+	{
+		debug( 1, _(L"Can not use the no-execute mode when running an interactive session") );
+		no_exec = 0;
+	}
+    
+	const struct config_paths_t paths = determine_config_directory_paths(argv[0]);
+    	
+	proc_init();	
+	event_init();	
+	wutil_init();
+	builtin_init();
+	function_init();
+	env_init(&paths);
+	reader_init();
+	history_init();
+
+    parser_t &parser = parser_t::principal_parser();
+
+    if (g_log_forks)
+        printf("%d: g_fork_count: %d\n", __LINE__, g_fork_count);
+
+    const io_chain_t empty_ios;
+	if( read_init(paths) )
+	{
+		if( cmd != 0 )
+		{
+			wchar_t *cmd_wcs = str2wcs( cmd );
+			res = parser.eval( cmd_wcs, empty_ios, TOP );
+			free(cmd_wcs);
+			reader_exit(0, 0);
+		}
+		else
+		{
+			if( my_optind == argc )
+			{
+				res = reader_read( STDIN_FILENO, empty_ios );
+			}
+			else
+			{
+				char **ptr; 
+				char *file = *(argv+(my_optind++));
+				int i; 
+				int fd;
+				wchar_t *rel_filename, *abs_filename;
+
+                
+				if( ( fd = open(file, O_RDONLY) ) == -1 )
+				{
+					wperror( L"open" );
+					return 1;
+				}
+                
+                // OK to not do this atomically since we cannot have gone multithreaded yet
+                set_cloexec(fd);
+                
+				if( *(argv+my_optind))
+				{
+                    wcstring sb;
+					for( i=1,ptr = argv+my_optind; *ptr; i++, ptr++ )
+					{
+						if( i != 1 )
+                            sb.append( ARRAY_SEP_STR );
+                        sb.append( str2wcstring( *ptr ));
+					}
+				
+					env_set( L"argv", sb.c_str(), 0 );
+				}
+
+				rel_filename = str2wcs( file );
+				abs_filename = wrealpath( rel_filename, 0 );
+
+				if( !abs_filename )
+				{
+					abs_filename = wcsdup(rel_filename);
+				}
+
+				reader_push_current_filename( intern( abs_filename ) );
+				free( rel_filename );
+				free( abs_filename );
+
+				res = reader_read( fd, empty_ios );
+
+				if( res )
+				{
+					debug( 1, 
+					       _(L"Error while reading file %ls\n"), 
+					       reader_current_filename()?reader_current_filename(): _(L"Standard input") );
+				}				
+				reader_pop_current_filename();
+			}
+		}
+	}
+	
+	proc_fire_event( L"PROCESS_EXIT", EVENT_EXIT, getpid(), res );
+	
+    restore_term_foreground_process_group();
+	history_destroy();
+	proc_destroy();
+	builtin_destroy();
+	reader_destroy();
+	parser.destroy();
+	wutil_destroy();
+	event_destroy();
+	
+	env_destroy();
+	
+    if (g_log_forks)
+        printf("%d: g_fork_count: %d\n", __LINE__, g_fork_count);
+    
+	return res?STATUS_UNKNOWN_COMMAND:proc_get_last_status();	
+}

fish.spec.in

@@ -6,9 +6,9 @@ Release:                0%{?dist}
 
 License:                GPL
 Group:                  System Environment/Shells
-URL:                    http://www.fishshell.org
+URL:                    http://ridiculousfish.com/shell/
 
-Source0:                http://www.fishshell.org/files/%{version}/%{name}-%{version}.tar.bz2
+Source0:                http://ridiculousfish.com/shell/files/%{version}/%{name}-%{version}.tar.bz2
 
 BuildRoot:              %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n)
 BuildRequires:          ncurses-devel gettext groff

fish_indent.cpp

@@ -16,7 +16,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
 
 
-/** \file fish_indent.c
+/** \file fish_indent.cpp
 	The fish_indent proegram.
 */
 
@@ -37,8 +37,6 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include "util.h"
 #include "common.h"
 #include "wutil.h"
-#include "halloc.h"
-#include "halloc_util.h"
 #include "tokenizer.h"
 #include "print_help.h"
 #include "parser_keywords.h"
@@ -49,9 +47,9 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #define GETOPT_STRING "hvi"
 
 /**
-   Read the entire contents of a file into the specified string_Buffer_t
+   Read the entire contents of a file into the specified string
  */
-static void read_file( FILE *f, string_buffer_t *b )
+static void read_file( FILE *f, wcstring &b )
 {
 	while( 1 )
 	{
@@ -64,32 +62,27 @@ static void read_file( FILE *f, string_buffer_t *b )
 				wperror(L"fgetwc");
 				exit(1);
 			}
-
+			
 			break;
 		}
-
-		sb_append_char( b, c );
+		b.push_back((wchar_t)c);
 	}
 }
 
 /**
-   Insert the specified number of tabe into the output buffer
+   Insert the specified number of tabs into the output buffer
  */
-static void insert_tabs( string_buffer_t *out, int indent )
+static void insert_tabs( wcstring &out, int indent )
 {
-	int i;
-
-	for( i=0; i<indent; i++ )
-	{
-		sb_append( out, L"\t" );
-	}
-
+    if (indent > 0)
+        out.append((size_t)indent, L'\t');
+	
 }
 
 /**
    Indent the specified input
  */
-static int indent( string_buffer_t *out, wchar_t *in, int flags )
+static int indent( wcstring &out, const wcstring &in, int flags )
 {
 	tokenizer tok;
 	int res=0;
@@ -99,13 +92,13 @@ static int indent( string_buffer_t *out, wchar_t *in, int flags )
 	int prev_type = 0;
 	int prev_prev_type = 0;
 
-	tok_init( &tok, in, TOK_SHOW_COMMENTS );
-
+	tok_init( &tok, in.c_str(), TOK_SHOW_COMMENTS );
+	
 	for( ; tok_has_next( &tok ); tok_next( &tok ) )
 	{
 		int type = tok_last_type( &tok );
 		wchar_t *last = tok_last( &tok );
-
+		
 		switch( type )
 		{
 			case TOK_STRING:
@@ -114,53 +107,54 @@ static int indent( string_buffer_t *out, wchar_t *in, int flags )
 				{
 					int next_indent = indent;
 					is_command = 0;
-
-					wchar_t *unesc = unescape( last, UNESCAPE_SPECIAL );
-
-					if( parser_keywords_is_block( unesc ) )
+                    
+                    wcstring unesc = last;
+                    unescape_string(unesc, UNESCAPE_SPECIAL);
+					
+					if( parser_keywords_is_block(unesc))
 					{
 						next_indent++;
 					}
-					else if( wcscmp( unesc, L"else" ) == 0 )
+					else if (unesc == L"else")
 					{
 						indent--;
 					}
 					/* case should have the same indent level as switch*/
-					else if( wcscmp( unesc, L"case" ) == 0 )
+					else if (unesc == L"case")
 					{
 						indent--;
 					}
-					else if( wcscmp( unesc, L"end" ) == 0 )
+					else if (unesc == L"end")
 					{
 						indent--;
 						next_indent--;
 					}
-
-
+					
+	
 					if( do_indent && flags && prev_type != TOK_PIPE )
 					{
 						insert_tabs( out, indent );
 					}
-
-					sb_printf( out, L"%ls", last );
-
+					
+                    append_format(out, L"%ls", last );
+					
 					indent = next_indent;
-
+					
 				}
 				else
 				{
 					if ( prev_type != TOK_REDIRECT_FD )
-						sb_append( out, L" " );
-					sb_append( out, last );
+						out.append( L" " );
+					out.append( last );
 				}
-
+				
 				break;
 			}
-
+			
 			case TOK_END:
 			{
-				if( prev_type != TOK_END || prev_prev_type != TOK_END )
-					sb_append( out, L"\n" );
+				if( prev_type != TOK_END || prev_prev_type != TOK_END ) 
+					out.append( L"\n" );
 				do_indent = 1;
 				is_command = 1;
 				break;
@@ -168,93 +162,94 @@ static int indent( string_buffer_t *out, wchar_t *in, int flags )
 
 			case TOK_PIPE:
 			{
-				sb_append( out, L" " );
+				out.append( L" " );
 				if ( last[0] == '2' && !last[1] ) {
-					sb_append( out, L"^" );
+					out.append( L"^" );
 				} else if ( last[0] != '1' || last[1] ) {
-					sb_append( out, last, L">" );
+					out.append( last);
+                    out.append( L">" );
 				}
-				sb_append( out, L"| " );
+				out.append( L" | " );
 				is_command = 1;
 				break;
 			}
-
+			
 			case TOK_REDIRECT_OUT:
 			{
-				sb_append( out, L" " );
+				out.append( L" " );
 				if ( wcscmp( last, L"2" ) == 0 ) {
-					sb_append( out, L"^" );
+					out.append( L"^" );
 				} else {
 					if ( wcscmp( last, L"1" ) != 0 )
-						sb_append( out, last );
-					sb_append( out, L">" );
+				out.append( last );
+						out.append( L"> " );
 				}
-				break;
+						break;
 			}
-
-			case TOK_REDIRECT_APPEND:
+						
+					case TOK_REDIRECT_APPEND:
 			{
-				sb_append( out, L" " );
+				out.append( L" " );
 				if ( wcscmp( last, L"2" ) == 0 ) {
-					sb_append( out, L"^^" );
+					out.append( L"^^" );
 				} else {
 					if ( wcscmp( last, L"1" ) != 0 )
-						sb_append( out, last );
-					sb_append( out, L">>" );
+						out.append( last );
+						out.append( L">> " );
 				}
-				break;
+						break;
 			}
-
-			case TOK_REDIRECT_IN:
+						
+					case TOK_REDIRECT_IN:
 			{
-				sb_append( out, L" " );
+				out.append( L" " );
 				if ( wcscmp( last, L"0" ) != 0 )
-					sb_append( out, last );
-				sb_append( out, L"<" );
-				break;
+					out.append( last );
+						out.append( L"< " );
+						break;
 			}
-
-			case TOK_REDIRECT_FD:
+						
+					case TOK_REDIRECT_FD:
 			{
-				sb_append( out, L" " );
+				out.append( L" " );
 				if ( wcscmp( last, L"1" ) != 0 )
-					sb_append( out, last );
-				sb_append( out, L">&" );
-				break;
-			}
+					out.append( last );
+						out.append( L">& " );
+						break;
+				}
 
 			case TOK_BACKGROUND:
 			{
-				sb_append( out, L"&\n" );
+				out.append( L"&\n" );
 				do_indent = 1;
 				is_command = 1;
 				break;
 			}
-
+			
 			case TOK_COMMENT:
 			{
 				if( do_indent && flags)
 				{
 					insert_tabs( out, indent );
 				}
-
-				sb_printf( out, L"%ls", last );
+				
+				append_format( out, L"%ls", last );
 				do_indent = 1;
-				break;
+				break;				
 			}
-
+			
 			default:
 			{
 				debug( 0, L"Unknown token '%ls'", last );
 				exit(1);
-			}
+			}			
 		}
-
+		
 		prev_prev_type = prev_type;
 		prev_type = type;
-
+		
 	}
-
+	
 	tok_destroy( &tok );
 
 	return res;
@@ -262,34 +257,20 @@ static int indent( string_buffer_t *out, wchar_t *in, int flags )
 
 /**
    Remove any prefix and suffix newlines from the specified
-   string. Does not allocete a new string, edits the string in place
-   and returns a pointer somewhere into the string.
+   string.
  */
-static wchar_t *trim( wchar_t *in )
+static void trim( wcstring &str )
 {
-	wchar_t *end;
+    if (str.empty())
+        return;
 
-	while( *in == L'\n' )
-	{
-		in++;
-	}
-
-	end = in + wcslen(in);
-
-	while( 1 )
-	{
-		if( end < in+2 )
-			break;
-
-		end--;
-
-		if( (*end == L'\n' ) && ( *(end-1) == L'\n' ) )
-			*end=0;
-		else
-			break;
-	}
-
-	return in;
+    size_t pos = str.find_first_not_of(L" \n");
+    if (pos > 0)
+        str.erase(0, pos);
+    
+    pos = str.find_last_not_of(L" \n");
+    if (pos != wcstring::npos && pos + 1 < str.length())
+        str.erase(pos + 1);
 }
 
 
@@ -297,12 +278,11 @@ static wchar_t *trim( wchar_t *in )
    The main mathod. Run the program.
  */
 int main( int argc, char **argv )
-{
-	string_buffer_t sb_in;
-	string_buffer_t sb_out;
-
+{	
 	int do_indent=1;
-
+	set_main_thread();
+    setup_fork_guards();
+    
 	wsetlocale( LC_ALL, L"" );
 	program_name=L"fish_indent";
 
@@ -312,55 +292,55 @@ int main( int argc, char **argv )
 			long_options[] =
 			{
 				{
-					"no-indent", no_argument, 0, 'i'
+					"no-indent", no_argument, 0, 'i' 
 				}
 				,
 				{
-					"help", no_argument, 0, 'h'
+					"help", no_argument, 0, 'h' 
 				}
 				,
 				{
-					"version", no_argument, 0, 'v'
+					"version", no_argument, 0, 'v' 
 				}
 				,
-				{
-					0, 0, 0, 0
+				{ 
+					0, 0, 0, 0 
 				}
 			}
 		;
-
+		
 		int opt_index = 0;
-
+		
 		int opt = getopt_long( argc,
-				       argv,
+				       argv, 
 				       GETOPT_STRING,
-				       long_options,
+				       long_options, 
 				       &opt_index );
-
+		
 		if( opt == -1 )
 			break;
-
+		
 		switch( opt )
 		{
 			case 0:
 			{
 				break;
 			}
-
+			
 			case 'h':
 			{
 				print_help( "fish_indent", 1 );
-				exit( 0 );
+				exit( 0 );				
 				break;
 			}
-
+			
 			case 'v':
 			{
-				fwprintf( stderr,
-						  _(L"%ls, version %s\n"),
+				fwprintf( stderr, 
+						  _(L"%ls, version %s\n"), 
 						  program_name,
 						  PACKAGE_VERSION );
-				exit( 0 );
+				exit( 0 );				
 			}
 
 			case 'i':
@@ -368,41 +348,36 @@ int main( int argc, char **argv )
 				do_indent = 0;
 				break;
 			}
-
-
+			
+			
 			case '?':
 			{
 				exit( 1 );
 			}
-
-		}
+			
+		}		
 	}
 
-	halloc_util_init();
-
-	sb_init( &sb_in );
-	sb_init( &sb_out );
-
-	read_file( stdin, &sb_in );
-
+    wcstring sb_in, sb_out;
+	read_file( stdin, sb_in );
+	
 	wutil_init();
 
-	if( !indent( &sb_out, (wchar_t *)sb_in.buff, do_indent ) )
+	if( !indent( sb_out, sb_in, do_indent ) )
 	{
-		fwprintf( stdout, L"%ls", trim( (wchar_t *)sb_out.buff) );
+        trim(sb_out);
+		fwprintf( stdout, L"%ls", sb_out.c_str() );
 	}
 	else
 	{
 		/*
 		  Indenting failed - print original input
 		*/
-		fwprintf( stdout, L"%ls", (wchar_t *)sb_in.buff );
+		fwprintf( stdout, L"%ls", sb_in.c_str() );
 	}
-
+	
 
 	wutil_destroy();
 
-	halloc_util_destroy();
-
 	return 0;
 }

fish_tests.c

@@ -1,900 +0,0 @@
-/** \file fish_tests.c
-	Various bug and feature tests. Compiled and run by make test.
-*/
-
-#include "config.h"
-
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <wchar.h>
-#include <string.h>
-#include <unistd.h>
-#include <errno.h>
-#include <unistd.h>
-#include <termios.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <stdarg.h>
-
-#ifdef HAVE_GETOPT_H
-#include <getopt.h>
-#endif
-
-#include <signal.h>
-
-#include <locale.h>
-#include <dirent.h>
-#include <time.h>
-
-#include "fallback.h"
-#include "util.h"
-
-#include "common.h"
-#include "proc.h"
-#include "reader.h"
-#include "builtin.h"
-#include "function.h"
-#include "complete.h"
-#include "wutil.h"
-#include "env.h"
-#include "expand.h"
-#include "parser.h"
-#include "tokenizer.h"
-#include "output.h"
-#include "exec.h"
-#include "event.h"
-#include "path.h"
-#include "halloc.h"
-#include "halloc_util.h"
-
-/**
-   The number of tests to run
- */
-#define ESCAPE_TEST_COUNT 1000000
-/**
-   The average length of strings to unescape
- */
-#define ESCAPE_TEST_LENGTH 100
-/**
-   The higest character number of character to try and escape
- */
-#define ESCAPE_TEST_CHAR 4000
-
-/**
-   Number of laps to run performance testing loop
-*/
-#define LAPS 50
-
-/**
-   The result of one of the test passes
-*/
-#define NUM_ANS L"-7 99999999 1234567 deadbeef DEADBEEFDEADBEEF"
-
-/**
-   Number of encountered errors
-*/
-static int err_count=0;
-
-/**
-   Print formatted output
-*/
-static void say( wchar_t *blah, ... )
-{
-	va_list va;
-	va_start( va, blah );
-	vwprintf( blah, va );
-	va_end( va );
-	wprintf( L"\n" );
-}
-
-/**
-   Print formatted error string
-*/
-static void err( wchar_t *blah, ... )
-{
-	va_list va;
-	va_start( va, blah );
-	err_count++;
-
-	wprintf( L"Error: " );
-	vwprintf( blah, va );
-	va_end( va );
-	wprintf( L"\n" );
-}
-
-/**
-   Compare two pointers
-*/
-static int pq_compare( void *e1, void *e2 )
-{
-	return e1-e2;
-}
-
-/**
-   Test priority queue functionality
-*/
-static void pq_test( int elements )
-{
-	int i;
-	int prev;
-
-	int *count = calloc( sizeof(int), 100 );
-
-	priority_queue_t q;
-	pq_init( &q, pq_compare );
-
-
-	for( i=0; i<elements; i++ )
-	{
-		long foo = rand() % 100;
-//		printf( "Adding %d\n", foo );
-		pq_put( &q, (void *)foo );
-		count[foo]++;
-	}
-
-	prev = 100;
-
-	for( i=0; i<elements; i++ )
-	{
-		long pos = (long)pq_get( &q );
-		count[ pos ]--;
-		if( pos > prev )
-			err( L"Wrong order of elements in priority_queue_t" );
-		prev = pos;
-
-	}
-
-	for( i=0; i<100; i++ )
-	{
-		if( count[i] != 0 )
-		{
-			err( L"Wrong number of elements in priority_queue_t" );
-		}
-	}
-}
-
-/**
-   Test stack functionality
-*/
-static int stack_test( int elements )
-{
-	long i;
-
-	int res=1;
-
-	array_list_t s;
-
-	al_init( &s );
-
-	for( i=0; i<elements; i++ )
-	{
-		long foo;
-
-		al_push_long( &s, i);
-		al_push_long( &s, i);
-
-		if( (foo=al_pop_long( &s )) != i )
-		{
-			err( L"Unexpected data" );
-			res = 0;
-			break;
-		}
-	}
-
-	for( i=0; i<elements; i++ )
-	{
-		long foo;
-
-		if( (foo=al_pop_long( &s )) != (elements-i-1) )
-		{
-			err( L"Unexpected data" );
-			res = 0;
-			break;
-		}
-	}
-
-
-	al_destroy( &s );
-
-	return res;
-}
-
-/**
-   Hash function for pointers
-*/
-static int hash_func( void *data )
-{
-/*	srand( (int)data );
-	return rand();
-*/
-	int foo = (int)(long)data;
-	return 127*((foo^0xefc7e214)) ^(foo<<11);
-}
-
-/**
-   Pointer hash comparison function
-*/
-static int compare_func( void *key1, void *key2 )
-{
-	return key1==key2;
-}
-
-
-/**
-   Hashtable test
-*/
-static int hash_test( long elements )
-{
-	long i;
-	int res=1;
-
-	hash_table_t h;
-
-	hash_init( &h, hash_func, compare_func );
-
-	for( i=1; i< elements+1; i++ )
-	{
-		hash_put( &h, (void*)i, (void*)100l-i );
-	}
-
-	for( i=1; i< elements+1; i++ )
-	{
-		if( (long)hash_get( &h, (void*)i ) != (100l-i) )
-		{
-			err( L"Key %d gave data %d, expected data %d",
-				 i,
-				 (long)hash_get( &h, (void*)i ),
-				 100l-i );
-			res = 0;
-
-			break;
-		}
-	}
-
-	if( hash_get_count( &h ) != elements )
-	{
-		err( L"Table holds %d elements, should hold %d elements",
-			 hash_get_count( &h ),
-			 elements );
-		res = 0;
-
-	}
-
-
-	for( i=1; i<elements+1; i+=2 )
-	{
-		hash_remove( &h, (void*)i, 0, 0 );
-
-	}
-
-	if( hash_get_count( &h ) != ((elements)/2) )
-	{
-		err( L"Table contains %d elements, should contain %d elements",
-			 hash_get_count( &h ),
-			 elements/2 );
-		res = 0;
-	}
-
-	for( i=1; i<elements+1; i++ )
-	{
-		if( hash_contains( &h, (void*)i) != (i+1l)%2l )
-		{
-			if( i%2 )
-				err( L"Key %d remains, should be deleted",
-						i );
-			else
-				err( L"Key %d does not exist",
-					 i );
-			res = 0;
-			break;
-			}
-	}
-
-	hash_destroy( &h );
-
-	return res;
-
-}
-
-/**
-   Arraylist test
-*/
-static void al_test( int sz)
-{
-	long i;
-	array_list_t l;
-
-
-
-	al_init( &l );
-
-	al_set_long( &l, 1, 7L );
-	al_set_long( &l, sz, 7L );
-
-	if( al_get_count( &l ) != maxi( sz+1, 2 ) )
-		err( L"Wrong number of elements in array list" );
-
-	for( i=0; i<al_get_count( &l ); i++ )
-	{
-		long val = al_get_long( &l, i );
-		if( (i == 1) || (i==sz))
-		{
-			if( val != 7 )
-				err( L"Canary changed to %d at index %d", val, i );
-		}
-		else
-		{
-			if( val != 0 )
-				err( L"False canary %d found at index %d", val, i );
-		}
-	}
-}
-
-/**
-   Stringbuffer test
-*/
-static void sb_test()
-{
-	string_buffer_t b;
-	int res;
-
-	sb_init( &b );
-
-	if( (res=sb_printf( &b, L"%ls%s", L"Testing ", "string_buffer_t " )) == -1 )
-	{
-		err( L"Error %d while testing stringbuffers", res );
-	}
-
-	if( (res=sb_printf( &b, L"%ls", L"functionality" ))==-1)
-	{
-		err( L"Error %d while testing stringbuffers", res );
-	}
-
-	say( (wchar_t *)b.buff );
-
-	sb_clear( &b );
-
-	sb_printf( &b, L"%d %u %o %x %llX", -7, 99999999, 01234567, 0xdeadbeef, 0xdeadbeefdeadbeefll );
-	if( wcscmp( (wchar_t *)b.buff,  NUM_ANS) != 0 )
-	{
-		err( L"numerical formating is broken, '%ls' != '%ls'", (wchar_t *)b.buff, NUM_ANS );
-	}
-	else
-		say( L"numerical formating works" );
-
-
-}
-
-/**
-   Performs all tests of the util library
-*/
-static void test_util()
-{
-	int i;
-
-	say( L"Testing utility library" );
-
-	for( i=0; i<18; i++ )
-	{
-		long t1, t2;
-		pq_test( 1<<i );
-		stack_test( 1<<i );
-		t1 = get_time();
-		hash_test( 1<<i );
-		t2 = get_time();
-		if( i > 8 )
-			say( L"Hashtable uses %f microseconds per element at size %d",
-				 ((double)(t2-t1))/(1<<i),
-				1<<i );
-		al_test( 1<<i );
-	}
-
-	sb_test();
-
-
-/*
-	int i;
-	for( i=2; i<10000000; i*=2 )
-	{
-
-		printf( "%d", i );
-
-		t1 = get_time();
-
-		if(!hash_test(i))
-			exit(0);
-
-		t2 = get_time();
-
-		printf( " %d\n", (t2-t1)/i );
-
-
-	}
-*/
-}
-
-
-/**
-   Test the escaping/unescaping code by escaping/unescaping random
-   strings and verifying that the original string comes back.
-*/
-static void test_escape()
-{
-	int i;
-	string_buffer_t sb;
-
-	say( L"Testing escaping and unescaping" );
-
-	sb_init( &sb );
-
-	for( i=0; i<ESCAPE_TEST_COUNT; i++ )
-	{
-		wchar_t *o, *e, *u;
-
-		sb_clear( &sb );
-		while( rand() % ESCAPE_TEST_LENGTH )
-		{
-			sb_append_char( &sb, (rand() %ESCAPE_TEST_CHAR) +1 );
-		}
-		o = (wchar_t *)sb.buff;
-		e = escape(o, 1);
-		u = unescape( e, 0 );
-		if( !o || !e || !u )
-		{
-			err( L"Escaping cycle of string %ls produced null pointer on %ls", o, e?L"unescaping":L"escaping" );
-
-		}
-
-
-		if( wcscmp(o, u) )
-		{
-			err( L"Escaping cycle of string %ls produced different string %ls", o, u );
-
-
-		}
-		free( e );
-		free( u );
-
-	}
-
-
-
-}
-
-/**
-   Test wide/narrow conversion by creating random strings and
-   verifying that the original string comes back thorugh double
-   conversion.
-*/
-static void test_convert()
-{
-/*	char o[] =
-		{
-			-17, -128, -121, -68, 0
-		}
-	;
-
-	wchar_t *w = str2wcs(o);
-	char *n = wcs2str(w);
-
-	int i;
-
-	for( i=0; o[i]; i++ )
-	{
-		bitprint(o[i]);;
-		//wprintf(L"%d ", o[i]);
-	}
-	wprintf(L"\n");
-
-	for( i=0; w[i]; i++ )
-	{
-		wbitprint(w[i]);;
-		//wprintf(L"%d ", w[i]);
-	}
-	wprintf(L"\n");
-
-	for( i=0; n[i]; i++ )
-	{
-		bitprint(n[i]);;
-		//wprintf(L"%d ", n[i]);
-	}
-	wprintf(L"\n");
-
-	return;
-*/
-
-
-	int i;
-	buffer_t sb;
-
-	say( L"Testing wide/narrow string conversion" );
-
-	b_init( &sb );
-
-	for( i=0; i<ESCAPE_TEST_COUNT; i++ )
-	{
-		wchar_t *w;
-		char *o, *n;
-
-		char c;
-
-		sb.used=0;
-
-		while( rand() % ESCAPE_TEST_LENGTH )
-		{
-			c = rand ();
-			b_append( &sb, &c, 1 );
-		}
-		c = 0;
-		b_append( &sb, &c, 1 );
-
-		o = (char *)sb.buff;
-		w = str2wcs(o);
-		n = wcs2str(w);
-
-		if( !o || !w || !n )
-		{
-			err( L"Conversion cycle of string %s produced null pointer on %s", o, w?L"str2wcs":L"wcs2str" );
-		}
-
-		if( strcmp(o, n) )
-		{
-			err( L"%d: Conversion cycle of string %s produced different string %s", i, o, n );
-		}
-		free( w );
-		free( n );
-
-	}
-
-}
-
-/**
-   Test the tokenizer
-*/
-static void test_tok()
-{
-	tokenizer t;
-
-	say( L"Testing tokenizer" );
-
-
-	say( L"Testing invalid input" );
-	tok_init( &t, 0, 0 );
-
-	if( tok_last_type( &t ) != TOK_ERROR )
-	{
-		err(L"Invalid input to tokenizer was undetected" );
-	}
-
-	say( L"Testing use of broken tokenizer" );
-	if( !tok_has_next( &t ) )
-	{
-		err( L"tok_has_next() should return 1 once on broken tokenizer" );
-	}
-
-	tok_next( &t );
-	if( tok_last_type( &t ) != TOK_ERROR )
-	{
-		err(L"Invalid input to tokenizer was undetected" );
-	}
-
-	/*
-	  This should crash if there is a bug. No reliable way to detect otherwise.
-	*/
-	say( L"Test destruction of broken tokenizer" );
-	tok_destroy( &t );
-
-	{
-
-		wchar_t *str = L"string <redirection  2>&1 'nested \"quoted\" '(string containing subshells ){and,brackets}$as[$well (as variable arrays)]";
-		const int types[] =
-		{
-			TOK_STRING, TOK_REDIRECT_IN, TOK_STRING, TOK_REDIRECT_FD, TOK_STRING, TOK_STRING, TOK_END
-		}
-		;
-		int i;
-
-		say( L"Test correct tokenization" );
-
-		for( i=0, tok_init( &t, str, 0 ); i<(sizeof(types)/sizeof(int)); i++,tok_next( &t ) )
-		{
-			if( types[i] != tok_last_type( &t ) )
-			{
-				err( L"Tokenization error:");
-				wprintf( L"Token number %d of string \n'%ls'\n, expected token type %ls, got token '%ls' of type %ls\n",
-						 i+1,
-						 str,
-						 tok_get_desc(types[i]),
-						 tok_last(&t),
-						 tok_get_desc(tok_last_type( &t )) );
-			}
-		}
-	}
-
-
-
-}
-
-/**
-   Test the parser
-*/
-static void test_parser()
-{
-	say( L"Testing parser" );
-
-
-	say( L"Testing null input to parser" );
-	if( !parser_test( 0, 0, 0, 0 ) )
-	{
-		err( L"Null input to parser_test undetected" );
-	}
-
-	say( L"Testing block nesting" );
-	if( !parser_test( L"if; end", 0, 0, 0 ) )
-	{
-		err( L"Incomplete if statement undetected" );
-	}
-	if( !parser_test( L"if test; echo", 0, 0, 0 ) )
-	{
-		err( L"Missing end undetected" );
-	}
-	if( !parser_test( L"if test; end; end", 0, 0, 0 ) )
-	{
-		err( L"Unbalanced end undetected" );
-	}
-
-	say( L"Testing detection of invalid use of builtin commands" );
-	if( !parser_test( L"case foo", 0, 0, 0 ) )
-	{
-		err( L"'case' command outside of block context undetected" );
-	}
-	if( !parser_test( L"switch ggg; if true; case foo;end;end", 0, 0, 0 ) )
-	{
-		err( L"'case' command outside of switch block context undetected" );
-	}
-	if( !parser_test( L"else", 0, 0, 0 ) )
-	{
-		err( L"'else' command outside of conditional block context undetected" );
-	}
-	if( !parser_test( L"break", 0, 0, 0 ) )
-	{
-		err( L"'break' command outside of loop block context undetected" );
-	}
-	if( !parser_test( L"exec ls|less", 0, 0, 0 ) || !parser_test( L"echo|return", 0, 0, 0 ))
-	{
-		err( L"Invalid pipe command undetected" );
-	}
-
-	say( L"Testing basic evaluation" );
-	if( !eval( 0, 0, TOP ) )
-	{
-		err( L"Null input when evaluating undetected" );
-	}
-	if( !eval( L"ls", 0, WHILE ) )
-	{
-		err( L"Invalid block mode when evaluating undetected" );
-	}
-
-}
-
-/**
-   Perform parameter expansion and test if the output equals the zero-terminated parameter list supplied.
-
-   \param in the string to expand
-   \param flags the flags to send to expand_string
-*/
-
-static int expand_test( const wchar_t *in, int flags, ... )
-{
-	array_list_t out;
-	va_list va;
-	int i=0;
-	int res=1;
-	wchar_t *arg;
-
-	al_init( &out );
-	if( expand_string( 0, wcsdup(in), &out, flags) )
-	{
-
-	}
-
-
-	va_start( va, flags );
-
-	while( (arg=va_arg(va, wchar_t *) )!= 0 )
-	{
-		if( al_get_count( &out ) == i )
-		{
-			res=0;
-			break;
-		}
-
-		if( wcscmp( al_get( &out, i ),arg) != 0 )
-		{
-			res=0;
-			break;
-		}
-
-		i++;
-	}
-	va_end( va );
-
-	al_foreach( &out, &free );
-	return res;
-
-}
-
-/**
-   Test globbing and other parameter expansion
-*/
-static void test_expand()
-{
-	say( L"Testing parameter expansion" );
-
-	if( !expand_test( L"foo", 0, L"foo", 0 ))
-	{
-		err( L"Strings do not expand to themselves" );
-	}
-
-	if( !expand_test( L"a{b,c,d}e", 0, L"abe", L"ace", L"ade", 0 ) )
-	{
-		err( L"Bracket expansion is broken" );
-	}
-
-	if( !expand_test( L"a*", EXPAND_SKIP_WILDCARDS, L"a*", 0 ) )
-	{
-		err( L"Cannot skip wildcard expansion" );
-	}
-
-}
-
-/**
-   Test path functions
- */
-static void test_path()
-{
-	say( L"Testing path functions" );
-
-	void *context = halloc( 0, 0 );
-
-
-	wchar_t *can = path_make_canonical( context, L"//foo//////bar/" );
-
-	if( wcscmp( can, L"/foo/bar" ) )
-	{
-		err( L"Bug in canonical PATH code" );
-	}
-
-	halloc_free( context );
-
-}
-
-
-
-/**
-   Test speed of completion calculations
-*/
-void perf_complete()
-{
-	wchar_t c;
-	array_list_t out;
-	long long t1, t2;
-	int matches=0;
-	double t;
-	wchar_t str[3]=
-	{
-		0, 0, 0
-	}
-	;
-	int i;
-
-
-	say( L"Testing completion performance" );
-	al_init( &out );
-
-	reader_push(L"");
-	say( L"Here we go" );
-
-	t1 = get_time();
-
-
-	for( c=L'a'; c<=L'z'; c++ )
-	{
-		str[0]=c;
-		reader_set_buffer( str, 0 );
-
-		complete( str, &out );
-
-		matches += al_get_count( &out );
-
-		al_foreach( &out, &free );
-		al_truncate( &out, 0 );
-	}
-	t2=get_time();
-
-	t = (double)(t2-t1)/(1000000*26);
-
-	say( L"One letter command completion took %f seconds per completion, %f microseconds/match", t, (double)(t2-t1)/matches );
-
-	matches=0;
-	t1 = get_time();
-	for( i=0; i<LAPS; i++ )
-	{
-		str[0]='a'+(rand()%26);
-		str[1]='a'+(rand()%26);
-
-		reader_set_buffer( str, 0 );
-
-		complete( str, &out );
-
-		matches += al_get_count( &out );
-
-		al_foreach( &out, &free );
-		al_truncate( &out, 0 );
-	}
-	t2=get_time();
-
-	t = (double)(t2-t1)/(1000000*LAPS);
-
-	say( L"Two letter command completion took %f seconds per completion, %f microseconds/match", t, (double)(t2-t1)/matches );
-
-	al_destroy( &out );
-
-	reader_pop();
-
-}
-
-
-
-
-/**
-   Main test
-*/
-int main( int argc, char **argv )
-{
-	setlocale( LC_ALL, "" );
-	srand( time( 0 ) );
-
-	program_name=L"(ignore)";
-
-	say( L"Testing low-level functionality");
-	say( L"Lines beginning with '(ignore):' are not errors, they are warning messages\ngenerated by the fish parser library when given broken input, and can be\nignored. All actual errors begin with 'Error:'." );
-
-	proc_init();
-	halloc_util_init();
-	event_init();
-	parser_init();
-	function_init();
-	builtin_init();
-	reader_init();
-	env_init();
-
-	test_util();
-	test_escape();
-	test_convert();
-	test_tok();
-	test_parser();
-	test_expand();
-	test_path();
-
-	say( L"Encountered %d errors in low-level tests", err_count );
-
-	/*
-	  Skip performance tests for now, since they seem to hang when running from inside make (?)
-	*/
-//	say( L"Testing performance" );
-//	perf_complete();
-
-	env_destroy();
-	reader_destroy();
-	parser_destroy();
-	function_destroy();
-	builtin_destroy();
-	wutil_destroy();
-	event_destroy();
-	proc_destroy();
-	halloc_util_destroy();
-
-}

fishd.cpp

@@ -70,15 +70,22 @@ time the original barrier request was sent have been received.
 #include "common.h"
 #include "wutil.h"
 #include "env_universal_common.h"
-#include "halloc.h"
-#include "halloc_util.h"
 #include "path.h"
 #include "print_help.h"
 
+#ifndef HOST_NAME_MAX
+/**
+ Maximum length of hostname return. It is ok if this is too short,
+ getting the actual hostname is not critical, so long as the string
+ is unique in the filesystem namespace.
+ */
+#define HOST_NAME_MAX 255
+#endif
+
 /**
    Maximum length of socket filename
 */
-#ifndef UNIX_PATH_MAX
+#ifndef UNIX_PATH_MAX 
 #define UNIX_PATH_MAX 100
 #endif
 
@@ -147,7 +154,7 @@ static int quit=0;
 static char *get_socket_filename()
 {
 	char *name;
-	char *dir = getenv( "FISHD_SOCKET_DIR" );
+	const char *dir = getenv( "FISHD_SOCKET_DIR" );
 	char *uname = getenv( "USER" );
 
 	if( dir == NULL )
@@ -162,7 +169,7 @@ static char *get_socket_filename()
 		uname = strdup( pw->pw_name );
 	}
 
-	name = malloc( strlen(dir)+ strlen(uname)+ strlen(SOCK_FILENAME) + 2 );
+	name = (char *)malloc( strlen(dir)+ strlen(uname)+ strlen(SOCK_FILENAME) + 2 );
 	if( name == NULL )
 	{
 		wperror( L"get_socket_filename" );
@@ -182,7 +189,7 @@ static char *get_socket_filename()
 }
 
 /**
-   Signal handler for the term signal.
+   Signal handler for the term signal. 
 */
 static void handle_term( int signal )
 {
@@ -190,19 +197,204 @@ static void handle_term( int signal )
 }
 
 
+/**
+ Writes a pseudo-random number (between one and maxlen) of pseudo-random
+ digits into str.
+ str must point to an allocated buffer of size of at least maxlen chars.
+ Returns the number of digits written.
+ Since the randomness in part depends on machine time it has _some_ extra
+ strength but still not enough for use in concurrent locking schemes on a
+ single machine because gettimeofday may not return a different value on
+ consecutive calls when:
+ a) the OS does not support fine enough resolution
+ b) the OS is running on an SMP machine.
+ Additionally, gettimeofday errors are ignored.
+ Excludes chars other than digits since ANSI C only guarantees that digits
+ are consecutive.
+ */
+static void sprint_rand_digits( char *str, int maxlen )
+{
+	int i, max;
+	struct timeval tv;
+	
+	/* 
+     Seed the pseudo-random generator based on time - this assumes
+     that consecutive calls to gettimeofday will return different values
+     and ignores errors returned by gettimeofday.
+     Cast to unsigned so that wrapping occurs on overflow as per ANSI C.
+     */
+	(void)gettimeofday( &tv, NULL );
+    unsigned long long seed = tv.tv_sec + tv.tv_usec * 1000000ULL;
+	srand( (unsigned int)seed );
+	max = (int)(1 + (maxlen - 1) * (rand() / (RAND_MAX + 1.0)));
+	for( i = 0; i < max; i++ )
+	{
+		str[i] = '0' + 10 * (rand() / (RAND_MAX + 1.0));
+	}
+	str[i] = 0;
+}
+
+
+/**
+ Generate a filename unique in an NFS namespace by creating a copy of str and
+ appending .{hostname}.{pid} to it.  If gethostname() fails then a pseudo-
+ random string is substituted for {hostname} - the randomness of the string
+ should be strong enough across different machines.  The main assumption 
+ though is that gethostname will not fail and this is just a "safe enough"
+ fallback.
+ The memory returned should be freed using free().
+ */
+static std::string gen_unique_nfs_filename( const char *filename )
+{
+	char hostname[HOST_NAME_MAX + 1];    
+    char pid_str[256];
+    snprintf(pid_str, sizeof pid_str, "%ld", (long)getpid());
+	
+	if ( gethostname( hostname, sizeof hostname ) != 0 )
+    {
+		sprint_rand_digits( hostname, HOST_NAME_MAX );
+	}
+    
+    std::string newname(filename);
+	newname.push_back('.');
+    newname.append(hostname);
+    newname.push_back('.');
+    newname.append(pid_str);    
+	return newname;
+}
+
+
+/**
+ The number of milliseconds to wait between polls when attempting to acquire 
+ a lockfile
+ */
+#define LOCKPOLLINTERVAL 10
+
+/**
+ Attempt to acquire a lock based on a lockfile, waiting LOCKPOLLINTERVAL 
+ milliseconds between polls and timing out after timeout seconds, 
+ thereafter forcibly attempting to obtain the lock if force is non-zero.
+ Returns 1 on success, 0 on failure.
+ To release the lock the lockfile must be unlinked.
+ A unique temporary file named by appending characters to the lockfile name 
+ is used; any pre-existing file of the same name is subject to deletion.
+ */
+static int acquire_lock_file( const char *lockfile, const int timeout, int force )
+{
+	int fd, timed_out = 0;
+	int ret = 0; /* early exit returns failure */
+	struct timespec pollint;
+	struct timeval start, end;
+	double elapsed;
+	struct stat statbuf;
+    
+	/*
+     (Re)create a unique file and check that it has one only link.
+     */
+	const std::string linkfile_str = gen_unique_nfs_filename( lockfile );
+    const char * const linkfile = linkfile_str.c_str();
+	(void)unlink( linkfile );
+    /* OK to not use CLO_EXEC here because fishd is single threaded */
+	if( ( fd = open( linkfile, O_CREAT|O_RDONLY, 0600 ) ) == -1 )
+	{
+		debug( 1, L"acquire_lock_file: open: %s", strerror( errno ) );
+		goto done;
+	}
+	/*
+     Don't need to check exit status of close on read-only file descriptors
+     */
+	close( fd );
+	if( stat( linkfile, &statbuf ) != 0 )
+	{
+		debug( 1, L"acquire_lock_file: stat: %s", strerror( errno ) );
+		goto done;
+	}
+	if ( statbuf.st_nlink != 1 )
+	{
+		debug( 1, L"acquire_lock_file: number of hardlinks on unique "
+              L"tmpfile is %d instead of 1.", (int)statbuf.st_nlink );
+		goto done;
+	}
+	if( gettimeofday( &start, NULL ) != 0 )
+	{
+		debug( 1, L"acquire_lock_file: gettimeofday: %s", strerror( errno ) );
+		goto done;
+	}
+	end = start;
+	pollint.tv_sec = 0;
+	pollint.tv_nsec = LOCKPOLLINTERVAL * 1000000;
+	do 
+	{
+		/*
+         Try to create a hard link to the unique file from the 
+         lockfile.  This will only succeed if the lockfile does not 
+         already exist.  It is guaranteed to provide race-free 
+         semantics over NFS which the alternative of calling 
+         open(O_EXCL|O_CREAT) on the lockfile is not.  The lock 
+         succeeds if the call to link returns 0 or the link count on 
+         the unique file increases to 2.
+         */
+		if( link( linkfile, lockfile ) == 0 ||
+           ( stat( linkfile, &statbuf ) == 0 && 
+            statbuf.st_nlink == 2 ) )
+		{
+			/* Successful lock */
+			ret = 1;
+			break;
+		}
+		elapsed = end.tv_sec + end.tv_usec/1000000.0 - 
+        ( start.tv_sec + start.tv_usec/1000000.0 );
+		/* 
+         The check for elapsed < 0 is to deal with the unlikely event 
+         that after the loop is entered the system time is set forward
+         past the loop's end time.  This would otherwise result in a 
+         (practically) infinite loop.
+         */
+		if( timed_out || elapsed >= timeout || elapsed < 0 )
+		{
+			if ( timed_out == 0 && force )
+			{
+				/*
+                 Timed out and force was specified - attempt to
+                 remove stale lock and try a final time
+                 */
+				(void)unlink( lockfile );
+				timed_out = 1;
+				continue;
+			}
+			else
+			{
+				/*
+                 Timed out and final try was unsuccessful or 
+                 force was not specified
+                 */
+				debug( 1, L"acquire_lock_file: timed out "
+                      L"trying to obtain lockfile %s using "
+                      L"linkfile %s", lockfile, linkfile );
+				break;
+			}
+		}
+		nanosleep( &pollint, NULL );
+	} while( gettimeofday( &end, NULL ) == 0 );
+done:
+	/* The linkfile is not needed once the lockfile has been created */
+	(void)unlink( linkfile );
+	return ret;
+}
+
 /**
    Acquire the lock for the socket
-   Returns the name of the lock file if successful or
+   Returns the name of the lock file if successful or 
    NULL if unable to obtain lock.
-   The returned string must be free()d after unlink()ing the file to release
+   The returned string must be free()d after unlink()ing the file to release 
    the lock
 */
 static char *acquire_socket_lock( const char *sock_name )
 {
-	int len = strlen( sock_name );
-	char *lockfile = malloc( len + strlen( LOCKPOSTFIX ) + 1 );
-
-	if( lockfile == NULL )
+	size_t len = strlen( sock_name );
+	char *lockfile = (char *)malloc( len + strlen( LOCKPOSTFIX ) + 1 );
+	
+	if( lockfile == NULL ) 
 	{
 		wperror( L"acquire_socket_lock" );
 		exit( EXIT_FAILURE );
@@ -237,13 +429,13 @@ static int get_socket()
 		exit( EXIT_FAILURE );
 	}
 	debug( 4, L"Acquired lockfile: %s", lockfile );
-
+	
 	local.sun_family = AF_UNIX;
 	strcpy( local.sun_path, sock_name );
 	len = sizeof(local);
-
+	
 	debug(1, L"Connect to socket at %s", sock_name);
-
+	
 	if( ( s = socket( AF_UNIX, SOCK_STREAM, 0 ) ) == -1 )
 	{
 		wperror( L"socket" );
@@ -262,7 +454,7 @@ static int get_socket()
 		exitcode = 0;
 		goto unlock;
 	}
-
+	
 	unlink( local.sun_path );
 	if( bind( s, (struct sockaddr *)&local, len ) == -1 )
 	{
@@ -288,9 +480,9 @@ static int get_socket()
 	/*
 	   End critical section protected by lock
 	*/
-
+	
 	free( lockfile );
-
+	
 	free( sock_name );
 
 	if( doexit )
@@ -304,31 +496,31 @@ static int get_socket()
 /**
    Event handler. Broadcasts updates to all clients.
 */
-static void broadcast( int type, const wchar_t *key, const wchar_t *val )
+static void broadcast( fish_message_type_t type, const wchar_t *key, const wchar_t *val )
 {
 	connection_t *c;
 	message_t *msg;
 
 	if( !conn )
 		return;
-
+	
 	msg = create_message( type, key, val );
-
+	
 	/*
 	  Don't merge these loops, or try_send_all can free the message
 	  prematurely
 	*/
-
+	
 	for( c = conn; c; c=c->next )
 	{
 		msg->count++;
-		q_put( &c->unsent, msg );
-	}
-
+        c->unsent->push(msg);
+	}	
+	
 	for( c = conn; c; c=c->next )
 	{
 		try_send_all( c );
-	}
+	}	
 }
 
 /**
@@ -345,9 +537,12 @@ static void daemonize()
 			debug( 0, L"Could not put fishd in background. Quitting" );
 			wperror( L"fork" );
 			exit(1);
-
+			
 		case 0:
 		{
+			/* Ordinarily there's very limited things we will do after fork, due to multithreading. But fishd is safe because it's single threaded. So don't die in is_forked_child. */
+			setup_fork_guards();
+        
 			/*
 			  Make fishd ignore the HUP signal.
 			*/
@@ -365,20 +560,21 @@ static void daemonize()
 			act.sa_handler=&handle_term;
 			sigaction( SIGTERM, &act, 0);
 			break;
+            
 		}
-
+		
 		default:
-		{
+		{			
 			debug( 0, L"Parent process exiting (This is normal)" );
 			exit(0);
-		}
+		}		
 	}
-
+	
 	/*
 	  Put ourself in out own processing group
 	*/
 	setsid();
-
+	
 	/*
 	  Close stdin and stdout. We only use stderr, anyway.
 	*/
@@ -390,11 +586,11 @@ static void daemonize()
 /**
    Get environment variable value. The resulting string needs to be free'd.
 */
-static wchar_t *fishd_env_get( wchar_t *key )
+static wchar_t *fishd_env_get( const wchar_t *key )
 {
 	char *nres, *nkey;
 	wchar_t *res;
-
+	
 	nkey = wcs2str( key );
 	nres = getenv( nkey );
 	free( nkey );
@@ -406,9 +602,8 @@ static wchar_t *fishd_env_get( wchar_t *key )
 	{
 		res = env_universal_common_get( key );
 		if( res )
-			res = wcsdup( res );
-
-		return env_universal_common_get( key );
+			res = wcsdup( res );		
+		return res;
 	}
 }
 
@@ -418,54 +613,45 @@ static wchar_t *fishd_env_get( wchar_t *key )
    to be rewritten to avoid dragging in additional library
    dependencies.
 */
-static wchar_t *fishd_get_config()
+static wcstring fishd_get_config()
 {
 	wchar_t *xdg_dir, *home;
-	int done = 0;
-	wchar_t *res = 0;
-
+	bool done = false;
+	wcstring result;
+	
 	xdg_dir = fishd_env_get( L"XDG_CONFIG_HOME" );
-	if( xdg_dir )
+	if (xdg_dir)
 	{
-		res = wcsdupcat( xdg_dir, L"/fish" );
-		if( !create_directory( res ) )
+        result = xdg_dir;
+        append_path_component(result, L"/fish");
+		if (!create_directory(result))
 		{
-			done = 1;
+			done = true;
 		}
-		else
-		{
-			free( res );
-		}
-		free( xdg_dir );
+		free(xdg_dir);
 	}
 	else
-	{
+	{		
 		home = fishd_env_get( L"HOME" );
 		if( home )
 		{
-			res = wcsdupcat( home, L"/.config/fish" );
-			if( !create_directory( res ) )
+            result = home;
+            append_path_component(result, L"/.config/fish");
+			if (!create_directory(result))
 			{
 				done = 1;
 			}
-			else
-			{
-				free( res );
-			}
 			free( home );
 		}
 	}
-
-	if( done )
-	{
-		return res;
-	}
-	else
-	{
+    
+    if (! done) {
+        /* Bad juju */
 		debug( 0, _(L"Unable to create a configuration directory for fish. Your personal settings will not be saved. Please set the $XDG_CONFIG_HOME variable to a directory where the current user has write access." ));
-		return 0;
-	}
-
+        result.clear();        
+    }
+    
+    return result;
 }
 
 /**
@@ -473,46 +659,36 @@ static wchar_t *fishd_get_config()
 */
 static void load_or_save( int save)
 {
-	char *name;
-	wchar_t *wdir = fishd_get_config();
-	char *dir;
+	const wcstring wdir = fishd_get_config();
 	char hostname[HOSTNAME_LEN];
 	connection_t c;
 	int fd;
-
-	if( !wdir )
-	{
+	
+	if (wdir.empty())
 		return;
-	}
-
-	dir = wcs2str( wdir );
-
-	free( wdir );
-
+	
+	std::string dir = wcs2string( wdir );
+	
 	gethostname( hostname, HOSTNAME_LEN );
-
-	name = malloc( strlen(dir)+ strlen(FILE)+ strlen(hostname) + 2 );
-	strcpy( name, dir );
-	strcat( name, "/" );
-	strcat( name, FILE );
-	strcat( name, hostname );
-
-	free( dir );
-
-
-	debug( 4, L"Open file for %s: '%s'",
-		   save?"saving":"loading",
-		   name );
-
-	fd = open( name, save?(O_CREAT | O_TRUNC | O_WRONLY):O_RDONLY, 0600);
-
-	free( name );
-
+	
+    std::string name;
+    name.append(dir);
+    name.append("/");
+    name.append(FILE);
+    name.append(hostname);
+	
+	debug( 4, L"Open file for %s: '%s'", 
+		   save?"saving":"loading", 
+		   name.c_str() );
+	
+    /* OK to not use CLO_EXEC here because fishd is single threaded */
+	fd = open(name.c_str(), save?(O_CREAT | O_TRUNC | O_WRONLY):O_RDONLY, 0600);
+	
 	if( fd == -1 )
 	{
 		debug( 1, L"Could not open load/save file. No previous saves?" );
 		wperror( L"open" );
-		return;
+		return;		
 	}
 	debug( 4, L"File open on fd %d", c.fd );
 
@@ -520,14 +696,14 @@ static void load_or_save( int save)
 
 	if( save )
 	{
-
+		
 		write_loop( c.fd, SAVE_MSG, strlen(SAVE_MSG) );
 		enqueue_all( &c );
 	}
 	else
 		read_message( &c );
 
-	connection_destroy( &c );
+	connection_destroy( &c );	
 }
 
 /**
@@ -553,10 +729,10 @@ static void init()
 {
 
 	sock = get_socket();
-	daemonize();
+	daemonize();	
 	env_universal_common_init( &broadcast );
-
-	load();
+	
+	load();	
 }
 
 /**
@@ -569,13 +745,14 @@ int main( int argc, char ** argv )
 	socklen_t t;
 	int max_fd;
 	int update_count=0;
-
+	
 	fd_set read_fd, write_fd;
 
-	halloc_util_init();
-
+	set_main_thread();
+    setup_fork_guards();
+	
 	program_name=L"fishd";
-	wsetlocale( LC_ALL, L"" );
+	wsetlocale( LC_ALL, L"" );	
 
 	/*
 	  Parse options
@@ -586,57 +763,57 @@ int main( int argc, char ** argv )
 			long_options[] =
 			{
 				{
-					"help", no_argument, 0, 'h'
+					"help", no_argument, 0, 'h' 
 				}
 				,
 				{
-					"version", no_argument, 0, 'v'
+					"version", no_argument, 0, 'v' 
 				}
 				,
-				{
-					0, 0, 0, 0
+				{ 
+					0, 0, 0, 0 
 				}
 			}
 		;
-
+		
 		int opt_index = 0;
-
+		
 		int opt = getopt_long( argc,
-							   argv,
+							   argv, 
 							   GETOPT_STRING,
-							   long_options,
+							   long_options, 
 							   &opt_index );
-
+		
 		if( opt == -1 )
 			break;
-
+		
 		switch( opt )
 		{
 			case 0:
-				break;
+				break;				
 
 			case 'h':
 				print_help( argv[0], 1 );
-				exit(0);
-
+				exit(0);				
+								
 			case 'v':
 				debug( 0, L"%ls, version %s\n", program_name, PACKAGE_VERSION );
-				exit( 0 );
-
+				exit( 0 );				
+				
 			case '?':
 				return 1;
-
-		}
+				
+		}		
 	}
-
+	
 	init();
-	while(1)
+	while(1) 
 	{
 		connection_t *c;
 		int res;
 
-		t = sizeof( remote );
-
+		t = sizeof( remote );		
+		
 		FD_ZERO( &read_fd );
 		FD_ZERO( &write_fd );
 		FD_SET( sock, &read_fd );
@@ -645,8 +822,8 @@ int main( int argc, char ** argv )
 		{
 			FD_SET( c->fd, &read_fd );
 			max_fd = maxi( max_fd, c->fd+1);
-
-			if( ! q_empty( &c->unsent ) )
+			
+			if( ! c->unsent->empty() )
 			{
 				FD_SET( c->fd, &write_fd );
 			}
@@ -661,22 +838,22 @@ int main( int argc, char ** argv )
 				save();
 				exit(0);
 			}
-
+			
 			if( res != -1 )
 				break;
-
+			
 			if( errno != EINTR )
 			{
 				wperror( L"select" );
 				exit(1);
 			}
 		}
-
+				
 		if( FD_ISSET( sock, &read_fd ) )
 		{
-			if( (child_socket =
-				 accept( sock,
-						 (struct sockaddr *)&remote,
+			if( (child_socket = 
+				 accept( sock, 
+						 (struct sockaddr *)&remote, 
 						 &t) ) == -1) {
 				wperror( L"accept" );
 				exit(1);
@@ -688,20 +865,20 @@ int main( int argc, char ** argv )
 				if( fcntl( child_socket, F_SETFL, O_NONBLOCK ) != 0 )
 				{
 					wperror( L"fcntl" );
-					close( child_socket );
+					close( child_socket );		
 				}
 				else
 				{
-					connection_t *new = malloc( sizeof(connection_t));
-					connection_init( new, child_socket );
-					new->next = conn;
-					send( new->fd, GREETING, strlen(GREETING), MSG_DONTWAIT );
-					enqueue_all( new );
-					conn=new;
+					connection_t *newc = (connection_t *)malloc( sizeof(connection_t));
+					connection_init( newc, child_socket );					
+					newc->next = conn;
+					send( newc->fd, GREETING, strlen(GREETING), MSG_DONTWAIT );
+					enqueue_all( newc );				
+					conn=newc;
 				}
 			}
 		}
-
+		
 		for( c=conn; c; c=c->next )
 		{
 			if( FD_ISSET( c->fd, &write_fd ) )
@@ -709,7 +886,7 @@ int main( int argc, char ** argv )
 				try_send_all( c );
 			}
 		}
-
+		
 		for( c=conn; c; c=c->next )
 		{
 			if( FD_ISSET( c->fd, &read_fd ) )
@@ -728,24 +905,25 @@ int main( int argc, char ** argv )
 				}
 			}
 		}
-
+		
 		connection_t *prev=0;
 		c=conn;
-
+		
 		while( c )
 		{
 			if( c->killme )
 			{
 				debug( 4, L"Close connection %d", c->fd );
 
-				while( !q_empty( &c->unsent ) )
+				while( ! c->unsent->empty() )
 				{
-					message_t *msg = (message_t *)q_get( &c->unsent );
+					message_t *msg = c->unsent->front();
+                    c->unsent->pop();
 					msg->count--;
 					if( !msg->count )
 						free( msg );
 				}
-
+				
 				connection_destroy( c );
 				if( prev )
 				{
@@ -755,11 +933,11 @@ int main( int argc, char ** argv )
 				{
 					conn=c->next;
 				}
-
+				
 				free(c);
-
+				
 				c=(prev?prev->next:conn);
-
+				
 			}
 			else
 			{
@@ -771,12 +949,11 @@ int main( int argc, char ** argv )
 		if( !conn )
 		{
 			debug( 0, L"No more clients. Quitting" );
-			save();
+			save();			
 			env_universal_common_destroy();
 			break;
-		}
+		}		
 
 	}
-	halloc_util_destroy();
 }
 

function.c

@@ -1,467 +0,0 @@
-/** \file function.c
-
-    Prototypes for functions for storing and retrieving function
-	information. These functions also take care of autoloading
-	functions in the $fish_function_path. Actual function evaluation
-	is taken care of by the parser and to some degree the builtin
-	handling library.
-*/
-
-#include "config.h"
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <wchar.h>
-#include <unistd.h>
-#include <termios.h>
-#include <signal.h>
-
-#include "wutil.h"
-#include "fallback.h"
-#include "util.h"
-
-#include "function.h"
-#include "proc.h"
-#include "parser.h"
-#include "common.h"
-#include "intern.h"
-#include "event.h"
-#include "reader.h"
-#include "parse_util.h"
-#include "parser_keywords.h"
-#include "env.h"
-#include "expand.h"
-#include "halloc.h"
-#include "halloc_util.h"
-
-
-/**
-   Struct describing a function
-*/
-typedef struct
-{
-	/** Function definition */
-	wchar_t *definition;
-	/** Function description */
-	wchar_t *description;
-	/**
-	   File where this function was defined
-	*/
-	const wchar_t *definition_file;
-	/**
-	   Line where definition started
-	*/
-	int definition_offset;
-
-	/**
-	   List of all named arguments for this function
-	 */
-	array_list_t *named_arguments;
-
-
-	/**
-	   Flag for specifying that this function was automatically loaded
-	*/
-	int is_autoload;
-
-	/**
-	   Set to non-zero if invoking this function shadows the variables
-	   of the underlying function.
-	 */
-	int shadows;
-}
-	function_internal_data_t;
-
-/**
-   Table containing all functions
-*/
-static hash_table_t function;
-
-/**
-   Kludgy flag set by the load function in order to tell function_add
-   that the function being defined is autoloaded. There should be a
-   better way to do this...
-*/
-static int is_autoload = 0;
-
-/**
-   Make sure that if the specified function is a dynamically loaded
-   function, it has been fully loaded.
-*/
-static int load( const wchar_t *name )
-{
-	int was_autoload = is_autoload;
-	int res;
-	function_internal_data_t *data;
-	data = (function_internal_data_t *)hash_get( &function, name );
-	if( data && !data->is_autoload )
-		return 0;
-
-	is_autoload = 1;
-	res = parse_util_load( name,
-						   L"fish_function_path",
-						   &function_remove,
-						   1 );
-	is_autoload = was_autoload;
-	return res;
-}
-
-/**
-   Insert a list of all dynamically loaded functions into the
-   specified list.
-*/
-static void autoload_names( array_list_t *out, int get_hidden )
-{
-	int i;
-
-	array_list_t path_list;
-	const wchar_t *path_var = env_get( L"fish_function_path" );
-
-	if( ! path_var )
-		return;
-
-	al_init( &path_list );
-
-	tokenize_variable_array( path_var, &path_list );
-	for( i=0; i<al_get_count( &path_list ); i++ )
-	{
-		wchar_t *ndir = (wchar_t *)al_get( &path_list, i );
-		DIR *dir = wopendir( ndir );
-		if( !dir )
-			continue;
-
-		struct wdirent *next;
-		while( (next=wreaddir(dir))!=0 )
-		{
-			wchar_t *fn = next->d_name;
-			wchar_t *suffix;
-			if( !get_hidden && fn[0] == L'_' )
-				continue;
-
-			suffix = wcsrchr( fn, L'.' );
-			if( suffix && (wcscmp( suffix, L".fish" ) == 0 ) )
-			{
-				const wchar_t *dup;
-				*suffix = 0;
-				dup = intern( fn );
-				if( !dup )
-					DIE_MEM();
-				al_push( out, dup );
-			}
-		}
-		closedir(dir);
-	}
-	al_foreach( &path_list, &free );
-	al_destroy( &path_list );
-}
-
-void function_init()
-{
-	hash_init( &function,
-			   &hash_wcs_func,
-			   &hash_wcs_cmp );
-}
-
-/**
-   Clear specified value, but not key
- */
-static void clear_entry( void *key, void *value )
-{
-	halloc_free( value );
-}
-
-void function_destroy()
-{
-	hash_foreach( &function, &clear_entry );
-	hash_destroy( &function );
-}
-
-
-void function_add( function_data_t *data )
-{
-	int i;
-	wchar_t *cmd_end;
-	function_internal_data_t *d;
-
-	CHECK( data->name, );
-	CHECK( data->definition, );
-
-	function_remove( data->name );
-
-	d = halloc( 0, sizeof( function_internal_data_t ) );
-	d->definition_offset = parse_util_lineno( parser_get_buffer(), current_block->tok_pos )-1;
-	d->definition = halloc_wcsdup( d, data->definition );
-
-	if( data->named_arguments )
-	{
-		d->named_arguments = al_halloc( d );
-
-		for( i=0; i<al_get_count( data->named_arguments ); i++ )
-		{
-			al_push( d->named_arguments, halloc_wcsdup( d, (wchar_t *)al_get( data->named_arguments, i ) ) );
-		}
-	}
-
-	cmd_end = d->definition + wcslen(d->definition)-1;
-
-	d->description = data->description?halloc_wcsdup( d, data->description ):0;
-	d->definition_file = intern(reader_current_filename());
-	d->is_autoload = is_autoload;
-	d->shadows = data->shadows;
-
-	hash_put( &function, intern(data->name), d );
-
-	for( i=0; i<al_get_count( data->events ); i++ )
-	{
-		event_add_handler( (event_t *)al_get( data->events, i ) );
-	}
-
-}
-
-int function_copy( const wchar_t *name, const wchar_t *new_name )
-{
-	int i;
-	function_internal_data_t *d, *orig_d;
-	
-	CHECK( name, 0 );
-	CHECK( new_name, 0 );
-
-	orig_d = (function_internal_data_t *)hash_get(&function, name);
-	if( !orig_d )
-		return 0;
-
-	d = halloc(0, sizeof( function_internal_data_t ) );
-	d->definition_offset = orig_d->definition_offset;
-	d->definition = halloc_wcsdup( d, orig_d->definition );
-	if( orig_d->named_arguments )
-	{
-		d->named_arguments = al_halloc( d );
-		for( i=0; i<al_get_count( orig_d->named_arguments ); i++ )
-		{
-			al_push( d->named_arguments, halloc_wcsdup( d, (wchar_t *)al_get( orig_d->named_arguments, i ) ) );
-		}
-		d->description = orig_d->description?halloc_wcsdup(d, orig_d->description):0;
-		d->shadows = orig_d->shadows;
-
-		// This new instance of the function shouldn't be tied to the def 
-		// file of the original. 
-		d->definition_file = 0;
-		d->is_autoload = 0;
-	}
-
-	hash_put( &function, intern(new_name), d );
-
-	return 1;
-}
-
-
-int function_exists( const wchar_t *cmd )
-{
-
-	CHECK( cmd, 0 );
-
-	if( parser_keywords_is_reserved(cmd) )
-		return 0;
-
-	load( cmd );
-	return (hash_get(&function, cmd) != 0 );
-}
-
-void function_remove( const wchar_t *name )
-{
-	void *key;
-	void *dv;
-	function_internal_data_t *d;
-	event_t ev;
-
-	CHECK( name, );
-
-	hash_remove( &function,
-				 name,
-				 &key,
-				 &dv );
-
-	d=(function_internal_data_t *)dv;
-
-	if( !key )
-		return;
-
-	ev.type=EVENT_ANY;
-	ev.function_name=name;
-	event_remove( &ev );
-
-	halloc_free( d );
-
-	/*
-	  Notify the autoloader that the specified function is erased, but
-	  only if this call to fish_remove is not made by the autoloader
-	  itself.
-	*/
-	if( !is_autoload )
-	{
-		parse_util_unload( name, L"fish_function_path", 0 );
-	}
-}
-
-const wchar_t *function_get_definition( const wchar_t *name )
-{
-	function_internal_data_t *data;
-
-	CHECK( name, 0 );
-
-	load( name );
-	data = (function_internal_data_t *)hash_get( &function, name );
-	if( data == 0 )
-		return 0;
-	return data->definition;
-}
-
-array_list_t *function_get_named_arguments( const wchar_t *name )
-{
-	function_internal_data_t *data;
-
-	CHECK( name, 0 );
-
-	load( name );
-	data = (function_internal_data_t *)hash_get( &function, name );
-	if( data == 0 )
-		return 0;
-	return data->named_arguments;
-}
-
-int function_get_shadows( const wchar_t *name )
-{
-	function_internal_data_t *data;
-
-	CHECK( name, 0 );
-
-	load( name );
-	data = (function_internal_data_t *)hash_get( &function, name );
-	if( data == 0 )
-		return 0;
-	return data->shadows;
-}
-
-
-const wchar_t *function_get_desc( const wchar_t *name )
-{
-	function_internal_data_t *data;
-
-	CHECK( name, 0 );
-
-	load( name );
-	data = (function_internal_data_t *)hash_get( &function, name );
-	if( data == 0 )
-		return 0;
-
-	return _(data->description);
-}
-
-void function_set_desc( const wchar_t *name, const wchar_t *desc )
-{
-	function_internal_data_t *data;
-
-	CHECK( name, );
-	CHECK( desc, );
-
-	load( name );
-	data = (function_internal_data_t *)hash_get( &function, name );
-	if( data == 0 )
-		return;
-
-	data->description = halloc_wcsdup( data, desc );
-}
-
-/**
-   Search arraylist of strings for specified string
-*/
-static int al_contains_str( array_list_t *list, const wchar_t * str )
-{
-	int i;
-
-	CHECK( list, 0 );
-	CHECK( str, 0 );
-
-	for( i=0; i<al_get_count( list ); i++ )
-	{
-		if( wcscmp( al_get( list, i ), str) == 0 )
-		{
-			return 1;
-		}
-	}
-	return 0;
-}
-
-/**
-   Helper function for removing hidden functions
-*/
-static void get_names_internal( void *key,
-								void *val,
-								void *aux )
-{
-	wchar_t *name = (wchar_t *)key;
-	if( name[0] != L'_' && !al_contains_str( (array_list_t *)aux, name ) )
-	{
-		al_push( (array_list_t *)aux, name );
-	}
-}
-
-/**
-   Helper function for removing hidden functions
-*/
-static void get_names_internal_all( void *key,
-									void *val,
-									void *aux )
-{
-	wchar_t *name = (wchar_t *)key;
-
-	if( !al_contains_str( (array_list_t *)aux, name ) )
-	{
-		al_push( (array_list_t *)aux, name );
-	}
-}
-
-void function_get_names( array_list_t *list, int get_hidden )
-{
-	CHECK( list, );
-
-	autoload_names( list, get_hidden );
-
-	if( get_hidden )
-	{
-		hash_foreach2( &function, &get_names_internal_all, list );
-	}
-	else
-	{
-		hash_foreach2( &function, &get_names_internal, list );
-	}
-
-}
-
-const wchar_t *function_get_definition_file( const wchar_t *name )
-{
-	function_internal_data_t *data;
-
-	CHECK( name, 0 );
-
-	data = (function_internal_data_t *)hash_get( &function, name );
-	if( data == 0 )
-		return 0;
-
-	return data->definition_file;
-}
-
-
-int function_get_definition_offset( const wchar_t *name )
-{
-	function_internal_data_t *data;
-
-	CHECK( name, -1 );
-
-	data = (function_internal_data_t *)hash_get( &function, name );
-	if( data == 0 )
-		return -1;
-
-	return data->definition_offset;
-}
-

function.cpp

@@ -0,0 +1,350 @@
+/** \file function.c
+
+    Prototypes for functions for storing and retrieving function
+	information. These functions also take care of autoloading
+	functions in the $fish_function_path. Actual function evaluation
+	is taken care of by the parser and to some degree the builtin
+	handling library.
+*/
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <wchar.h>
+#include <unistd.h>
+#include <termios.h>
+#include <signal.h>
+#include <pthread.h>
+#include <errno.h>
+#include <map>
+#include <set>
+
+#include "wutil.h"
+#include "fallback.h"
+#include "util.h"
+
+#include "function.h"
+#include "proc.h"
+#include "parser.h"
+#include "common.h"
+#include "intern.h"
+#include "event.h"
+#include "reader.h"
+#include "parse_util.h"
+#include "parser_keywords.h"
+#include "env.h"
+#include "expand.h"
+#include "builtin_scripts.h"
+
+/**
+   Table containing all functions
+*/
+typedef std::map<wcstring, function_info_t> function_map_t;
+static function_map_t loaded_functions;
+
+/* Lock for functions */
+static pthread_mutex_t functions_lock;
+
+/* Autoloader for functions */
+class function_autoload_t : public autoload_t {
+public:
+    function_autoload_t();
+    virtual void command_removed(const wcstring &cmd);
+};
+
+static function_autoload_t function_autoloader;
+
+/** Constructor */
+function_autoload_t::function_autoload_t() : autoload_t(L"fish_function_path",
+                                                        internal_function_scripts,
+                                                        sizeof internal_function_scripts / sizeof *internal_function_scripts)
+{
+}
+
+/** Removes a function from our internal table, returning true if it was found and false if not */
+static bool function_remove_ignore_autoload(const wcstring &name);
+
+/** Callback when an autoloaded function is removed */
+void function_autoload_t::command_removed(const wcstring &cmd) {
+    function_remove_ignore_autoload(cmd);
+}
+
+/* Helper macro for vomiting */
+#define VOMIT_ON_FAILURE(a) do { if (0 != (a)) { int err = errno; fprintf(stderr, "%s failed on line %d in file %s: %d (%s)\n", #a, __LINE__, __FILE__, err, strerror(err)); abort(); }} while (0)
+
+/**
+   Kludgy flag set by the load function in order to tell function_add
+   that the function being defined is autoloaded. There should be a
+   better way to do this...
+*/
+static bool is_autoload = false;
+
+/**
+   Make sure that if the specified function is a dynamically loaded
+   function, it has been fully loaded.
+*/
+static int load( const wcstring &name )
+{
+    ASSERT_IS_MAIN_THREAD();
+    scoped_lock lock(functions_lock);
+	bool was_autoload = is_autoload;
+	int res;
+    function_map_t::iterator iter = loaded_functions.find(name);
+	if( iter !=  loaded_functions.end() && !iter->second.is_autoload ) {
+        /* We have a non-autoload version already */
+		return 0;
+    }
+	
+	is_autoload = true;	
+	res = function_autoloader.load( name, true );
+	is_autoload = was_autoload;
+	return res;
+}
+
+/**
+   Insert a list of all dynamically loaded functions into the
+   specified list.
+*/
+static void autoload_names( std::set<wcstring> &names, int get_hidden )
+{
+	size_t i;
+	
+	const env_var_t path_var_wstr =  env_get_string( L"fish_function_path" );
+    if (path_var_wstr.missing())
+        return;
+	const wchar_t *path_var = path_var_wstr.c_str(); 
+	
+    wcstring_list_t path_list;
+
+	tokenize_variable_array( path_var, path_list );
+	for( i=0; i<path_list.size(); i++ )
+	{
+        const wcstring &ndir_str = path_list.at(i);
+		const wchar_t *ndir = (wchar_t *)ndir_str.c_str();
+		DIR *dir = wopendir( ndir );
+		if( !dir )
+			continue;
+		
+		wcstring name;
+		while (wreaddir(dir, name))
+		{
+			const wchar_t *fn = name.c_str();
+			const wchar_t *suffix;
+			if( !get_hidden && fn[0] == L'_' )
+				continue;
+			
+            suffix = wcsrchr( fn, L'.' );
+			if( suffix && (wcscmp( suffix, L".fish" ) == 0 ) )
+			{
+                wcstring name(fn, suffix - fn);
+                names.insert(name);
+			}
+		}				
+		closedir(dir);
+	}
+}
+
+void function_init()
+{
+    /* PCA: This recursive lock was introduced early in my work. I would like to make this a non-recursive lock but I haven't fully investigated all the call paths (for autoloading functions, etc.) */
+    pthread_mutexattr_t a;
+    VOMIT_ON_FAILURE(pthread_mutexattr_init(&a));
+    VOMIT_ON_FAILURE(pthread_mutexattr_settype(&a,PTHREAD_MUTEX_RECURSIVE));
+    VOMIT_ON_FAILURE(pthread_mutex_init(&functions_lock, &a));
+    VOMIT_ON_FAILURE(pthread_mutexattr_destroy(&a));
+}
+
+function_info_t::function_info_t(const function_data_t &data, const wchar_t *filename, int def_offset, bool autoload) :
+    definition(data.definition),
+    description(data.description),
+    definition_file(intern(filename)),
+    definition_offset(def_offset),
+    named_arguments(data.named_arguments),
+    is_autoload(autoload),
+    shadows(data.shadows)
+{
+}
+
+function_info_t::function_info_t(const function_info_t &data, const wchar_t *filename, int def_offset, bool autoload) :
+    definition(data.definition),
+    description(data.description),
+    definition_file(intern(filename)),
+    definition_offset(def_offset),
+    named_arguments(data.named_arguments),
+    is_autoload(autoload),
+    shadows(data.shadows)
+{
+}
+
+void function_add( const function_data_t &data, const parser_t &parser )
+{
+    ASSERT_IS_MAIN_THREAD();
+    
+	CHECK( ! data.name.empty(), );
+	CHECK( data.definition, );
+	scoped_lock lock(functions_lock);
+    
+    /* Remove the old function */
+	function_remove( data.name );
+    
+    
+    /* Create and store a new function */
+    const wchar_t *filename = reader_current_filename();
+    int def_offset = parser.line_number_of_character_at_offset(parser.current_block->tok_pos) - 1;
+    const function_map_t::value_type new_pair(data.name, function_info_t(data, filename, def_offset, is_autoload));
+    loaded_functions.insert(new_pair);
+	
+    /* Add event handlers */
+	for( std::vector<event_t>::const_iterator iter = data.events.begin(); iter != data.events.end(); ++iter )
+	{
+		event_add_handler( &*iter );
+	}
+}
+
+int function_exists( const wcstring &cmd )
+{
+	if( parser_keywords_is_reserved(cmd) )
+		return 0;
+    scoped_lock lock(functions_lock);
+    load(cmd);
+    return loaded_functions.find(cmd) != loaded_functions.end();            
+}
+
+int function_exists_no_autoload( const wcstring &cmd, const env_vars_snapshot_t &vars )
+{
+	if( parser_keywords_is_reserved(cmd) )
+		return 0;
+    scoped_lock lock(functions_lock);
+    return loaded_functions.find(cmd) != loaded_functions.end() || function_autoloader.can_load(cmd, vars);            
+}
+
+static bool function_remove_ignore_autoload(const wcstring &name)
+{
+    scoped_lock lock(functions_lock);
+    bool erased = (loaded_functions.erase(name) > 0);
+	
+	if (erased) {
+        event_t ev(EVENT_ANY);
+        ev.function_name=name;	
+        event_remove( &ev );
+    }
+    return erased;
+
+}
+
+void function_remove( const wcstring &name )
+{
+    if (function_remove_ignore_autoload(name))
+        function_autoloader.unload( name );
+}
+
+static const function_info_t *function_get(const wcstring &name)
+{
+    // The caller must lock the functions_lock before calling this; however our mutex is currently recursive, so trylock will never fail
+    // We need a way to correctly check if a lock is locked (or better yet, make our lock non-recursive)
+    //ASSERT_IS_LOCKED(functions_lock);
+    function_map_t::iterator iter = loaded_functions.find(name);
+    if (iter == loaded_functions.end()) {
+        return NULL;
+    } else {
+        return &iter->second;
+    }
+}
+	
+bool function_get_definition(const wcstring &name, wcstring *out_definition)
+{
+    scoped_lock lock(functions_lock);
+    const function_info_t *func = function_get(name);
+    if (func && out_definition) {
+        out_definition->assign(func->definition);
+    }
+    return func != NULL;
+}
+
+wcstring_list_t function_get_named_arguments(const wcstring &name)
+{
+    scoped_lock lock(functions_lock);
+    const function_info_t *func = function_get(name);
+    return func ? func->named_arguments : wcstring_list_t();
+}
+
+int function_get_shadows(const wcstring &name)
+{
+    scoped_lock lock(functions_lock);
+    const function_info_t *func = function_get(name);
+    return func ? func->shadows : false;
+}
+
+	
+bool function_get_desc(const wcstring &name, wcstring *out_desc)
+{
+    /* Empty length string goes to NULL */
+    scoped_lock lock(functions_lock);
+    const function_info_t *func = function_get(name);
+    if (out_desc && func && ! func->description.empty()) {
+        out_desc->assign(_(func->description.c_str()));
+        return true;
+    } else {
+        return false;
+    }
+}
+
+void function_set_desc(const wcstring &name, const wcstring &desc)
+{
+	load(name);
+    scoped_lock lock(functions_lock);
+    function_map_t::iterator iter = loaded_functions.find(name);
+    if (iter != loaded_functions.end()) {
+        iter->second.description = desc;
+    }
+}
+
+bool function_copy(const wcstring &name, const wcstring &new_name)
+{
+    bool result = false;
+    scoped_lock lock(functions_lock);
+    function_map_t::const_iterator iter = loaded_functions.find(name);
+    if (iter != loaded_functions.end()) {
+		// This new instance of the function shouldn't be tied to the definition file of the original, so pass NULL filename, etc.
+        const function_map_t::value_type new_pair(new_name, function_info_t(iter->second, NULL, 0, false));
+        loaded_functions.insert(new_pair);
+        result = true;
+    }
+	return result;
+}
+
+wcstring_list_t function_get_names(int get_hidden)
+{
+    std::set<wcstring> names;
+    scoped_lock lock(functions_lock);
+	autoload_names(names, get_hidden);
+	
+    function_map_t::const_iterator iter;
+    for (iter = loaded_functions.begin(); iter != loaded_functions.end(); ++iter) {
+        const wcstring &name = iter->first;
+        
+        /* Maybe skip hidden */
+        if (! get_hidden) {
+            if (name.empty() || name.at(0) == L'_') continue;
+        }
+        names.insert(name);
+    }
+    return wcstring_list_t(names.begin(), names.end());
+}
+
+const wchar_t *function_get_definition_file(const wcstring &name)
+{
+    scoped_lock lock(functions_lock);
+    const function_info_t *func = function_get(name);
+    return func ? func->definition_file : NULL;
+}
+
+
+int function_get_definition_offset(const wcstring &name)
+{
+    scoped_lock lock(functions_lock);
+    const function_info_t *func = function_get(name);
+    return func ? func->definition_offset : -1;
+}

function.h

@@ -1,4 +1,4 @@
-/** \file function.h
+/** \file function.h 
 
     Prototypes for functions for storing and retrieving function
 	information. These functions also take care of autoloading
@@ -13,6 +13,11 @@
 #include <wchar.h>
 
 #include "util.h"
+#include "common.h"
+#include "event.h"
+
+class parser_t;
+class env_vars_snapshot_t;
 
 /**
    Structure describing a function. This is used by the parser to
@@ -21,16 +26,16 @@
    structure is used for that purpose. Parhaps these two should be
    merged.
   */
-typedef struct function_data
+struct function_data_t
 {
 	/**
 	   Name of function
 	 */
-	wchar_t *name;
+	wcstring name;
 	/**
 	   Description of function
 	 */
-	wchar_t *description;
+	wcstring description;
 	/**
 	   Function definition
 	 */
@@ -38,70 +43,95 @@ typedef struct function_data
 	/**
 	   List of all event handlers for this function
 	 */
-	array_list_t *events;
+	std::vector<event_t> events;
 	/**
 	   List of all named arguments for this function
 	 */
-	array_list_t *named_arguments;
+	wcstring_list_t named_arguments;
 	/**
 	   Set to non-zero if invoking this function shadows the variables
 	   of the underlying function.
 	 */
 	int shadows;
-}
-	function_data_t;
+};
+
+class function_info_t {
+public:
+    /** Constructs relevant information from the function_data */
+    function_info_t(const function_data_t &data, const wchar_t *filename, int def_offset, bool autoload);
+    
+    /** Used by function_copy */
+    function_info_t(const function_info_t &data, const wchar_t *filename, int def_offset, bool autoload);
+
+    /** Function definition */
+    const wcstring definition;
+    
+    /** Function description. Only the description may be changed after the function is created. */
+    wcstring description;
+    
+	/** File where this function was defined (intern'd string) */
+    const wchar_t * const definition_file;
+    
+	/** Line where definition started */
+	const int definition_offset;
+    
+	/** List of all named arguments for this function */
+    const wcstring_list_t named_arguments;
+    
+	/** Flag for specifying that this function was automatically loaded */
+    const bool is_autoload;
+    
+	/** Set to true if invoking this function shadows the variables of the underlying function. */
+	const bool shadows;
+};
 
 
 /**
-   Initialize function data
+   Initialize function data   
 */
 void function_init();
 
-/**
-   Destroy function data
-*/
-void function_destroy();
-
-/**
-   Add an function. The parameters values are copied and should be
-   freed by the caller.
-*/
-void function_add( function_data_t *data );
+/** Add a function. */
+void function_add( const function_data_t &data, const parser_t &parser );
 
 /**
    Remove the function with the specified name.
 */
-void function_remove( const wchar_t *name );
+void function_remove( const wcstring &name );
 
 /**
-   Returns the definition of the function with the name \c name.
+   Returns by reference the definition of the function with the name \c name.
+   Returns true if successful, false if no function with the given name exists.
 */
-const wchar_t *function_get_definition( const wchar_t *name );
+bool function_get_definition( const wcstring &name, wcstring *out_definition );
 
 /**
-   Returns the description of the function with the name \c name.
+   Returns by reference the description of the function with the name \c name.
+   Returns true if the function exists and has a nonempty description, false if it does not.
 */
-const wchar_t *function_get_desc( const wchar_t *name );
+bool function_get_desc( const wcstring &name, wcstring *out_desc );
 
 /**
    Sets the description of the function with the name \c name.
 */
-void function_set_desc( const wchar_t *name, const wchar_t *desc );
+void function_set_desc( const wcstring &name, const wcstring &desc );
 
 /**
    Returns true if the function with the name name exists.
 */
-int function_exists( const wchar_t *name );
+int function_exists( const wcstring &name );
 
 /**
-   Insert all function names into l. These are not copies of the
-   strings and should not be freed after use.
+   Returns true if the function with the name name exists, without triggering autoload.
+*/
+int function_exists_no_autoload( const wcstring &name, const env_vars_snapshot_t &vars );
 
-   \param list the list to add the names to
+/**
+   Returns all function names.
+   
    \param get_hidden whether to include hidden functions, i.e. ones starting with an underscore
 */
-void function_get_names( array_list_t *list,
-						 int get_hidden );
+wcstring_list_t function_get_names( int get_hidden );
 
 /**
    Returns tha absolute path of the file where the specified function
@@ -109,8 +139,10 @@ void function_get_names( array_list_t *list,
 
    This function does not autoload functions, it will only work on
    functions that have already been defined.
+   
+   This returns an intern'd string.
 */
-const wchar_t *function_get_definition_file( const wchar_t *name );
+const wchar_t *function_get_definition_file( const wcstring &name );
 
 /**
    Returns the linenumber where the definition of the specified
@@ -119,22 +151,23 @@ const wchar_t *function_get_definition_file( const wchar_t *name );
    This function does not autoload functions, it will only work on
    functions that have already been defined.
 */
-int function_get_definition_offset( const wchar_t *name );
+int function_get_definition_offset( const wcstring &name );
 
 /**
    Returns a list of all named arguments of the specified function.
 */
-array_list_t *function_get_named_arguments( const wchar_t *name );
+wcstring_list_t function_get_named_arguments( const wcstring &name );
+
+/**
+   Creates a new function using the same definition as the specified function.
+   Returns true if copy is successful.
+*/
+bool function_copy( const wcstring &name, const wcstring &new_name );
+
 
 /**
    Returns whether this function shadows variables of the underlying function
 */
-int function_get_shadows( const wchar_t *name );
-
-/**
-   Creates a new function using the same definition as the specified function.
-   Returns non-zero if copy is successful.
-*/
-int function_copy( const wchar_t *name, const wchar_t *new_name );
+int function_get_shadows( const wcstring &name );
 
 #endif

halloc.c

@@ -1,264 +0,0 @@
-/** \file halloc.c
-
-    A hierarchical memory allocation system. Works just like talloc
-	used in Samba, except that an arbitrary block allocated with
-	malloc() can be registered to be freed by halloc_free.
-
-*/
-
-#include "config.h"
-
-
-#include <stdlib.h>
-#include <unistd.h>
-
-#include "fallback.h"
-#include "util.h"
-
-#include "common.h"
-#include "halloc.h"
-
-/**
-   Extra size to allocate whenever doing a halloc, in order to fill uyp smaller halloc calls
-*/
-#define HALLOC_BLOCK_SIZE 128
-
-/**
-   Maximum size of trailing halloc space to refuse to discard. This is
-   set to be larger on 64-bit platforms, since we don't want to get
-   'stuck' with an unusably small slice of memory, and what is
-   unusably small often depends on pointer size.
-*/
-#define HALLOC_SCRAP_SIZE (4*sizeof(void *))
-
-#ifdef HALLOC_DEBUG
-/**
-   Debug statistic parameter
-*/
-static int child_count=0;
-/**
-   Debug statistic parameter
-*/
-static int child_size=0;
-/**
-   Debug statistic parameter
-*/
-static int alloc_count =0;
-/**
-   Debug statistic parameter
-*/
-static int alloc_spill = 0;
-/**
-   Debug statistic parameter
-*/
-static pid_t pid=0;
-/**
-   Debug statistic parameter
-*/
-static int parent_count=0;
-#endif
-
-/**
-   The main datastructure for a main halloc context
-*/
-typedef struct halloc
-{
-	/**
-	   List of all addresses and functions to call on them
-	*/
-	array_list_t children;
-	/**
-	   Memory scratch area used to fullfil smaller memory allocations
-	*/
-	char *scratch;
-	/**
-	   Amount of free space in the scratch area
-	*/
-	ssize_t scratch_free;
-}
-	halloc_t;
-
-/**
-   Allign the specified pointer
- */
-static char *align_ptr( char *in )
-{
-	unsigned long step = maxi(sizeof(double),sizeof(void *));
-	unsigned long inc = step-1;
-	unsigned long long_in = (long)in;
-	unsigned long long_out = ((long_in+inc)/step)*step;
-	return (char *)long_out;
-}
-
-/**
-   Allign specifies size_t
- */
-static size_t align_sz( size_t in )
-{
-	size_t step = maxi(sizeof(double),sizeof(void *));
-	size_t inc = step-1;
-	return ((in+inc)/step)*step;
-}
-
-/**
-   Get the offset of the halloc structure before a data block
-*/
-static halloc_t *halloc_from_data( void *data )
-{
-	return (halloc_t *)(((char *)data) - align_sz(sizeof( halloc_t ) ));
-}
-
-/**
-   A function that does nothing
-*/
-static void late_free( void *data)
-{
-}
-
-#ifdef HALLOC_DEBUG
-/**
-   Debug function, called at exit when in debug mode. Prints usage
-   statistics, like number of allocations and number of internal calls
-   to malloc.
-*/
-static void halloc_report()
-{
-	if( getpid() == pid )
-	{
-		debug( 1, L"%d parents, %d children with average child size of %.2f bytes caused %d allocs, average spill of %.2f bytes",
-			   parent_count, child_count, (double)child_size/child_count,
-			   parent_count+alloc_count, (double)alloc_spill/(parent_count+alloc_count) );
-	}
-}
-#endif
-
-
-void *halloc( void *context, size_t size )
-{
-	halloc_t *me, *parent;
-	if( context )
-	{
-		char *res;
-		char *aligned;
-
-#ifdef HALLOC_DEBUG
-
-		if( !child_count )
-		{
-			pid = getpid();
-			atexit( &halloc_report );
-		}
-
-		child_count++;
-		child_size += size;
-#endif
-		parent = halloc_from_data( context );
-
-		/*
-		  Align memory address
-		*/
-		aligned = align_ptr( parent->scratch );
-
-		parent->scratch_free -= (aligned-parent->scratch);
-
-		if( parent->scratch_free < 0 )
-			parent->scratch_free=0;
-
-		parent->scratch = aligned;
-
-		if( size <= parent->scratch_free )
-		{
-			res = parent->scratch;
-			parent->scratch_free -= size;
-			parent->scratch = ((char *)parent->scratch)+size;
-		}
-		else
-		{
-
-#ifdef HALLOC_DEBUG
-			alloc_count++;
-#endif
-
-			if( parent->scratch_free < HALLOC_SCRAP_SIZE )
-			{
-#ifdef HALLOC_DEBUG
-				alloc_spill += parent->scratch_free;
-#endif
-				res = calloc( 1, size + HALLOC_BLOCK_SIZE );
-				if( !res )
-					DIE_MEM();
-				parent->scratch = (char *)res + size;
-				parent->scratch_free = HALLOC_BLOCK_SIZE;
-			}
-			else
-			{
-				res = calloc( 1, size );
-				if( !res )
-					DIE_MEM();
-			}
-			al_push_func( &parent->children, &late_free );
-			al_push( &parent->children, res );
-
-		}
-		return res;
-
-	}
-	else
-	{
-		me = (halloc_t *)calloc( 1, align_sz(sizeof(halloc_t)) + align_sz(size) + HALLOC_BLOCK_SIZE );
-
-		if( !me )
-			DIE_MEM();
-#ifdef HALLOC_DEBUG
-		parent_count++;
-#endif
-		me->scratch = ((char *)me) + align_sz(sizeof(halloc_t)) + align_sz(size);
-		me->scratch_free = HALLOC_BLOCK_SIZE;
-
-		al_init( &me->children );
-		return ((char *)me) + align_sz(sizeof(halloc_t));
-	}
-}
-
-void halloc_register_function( void *context, void (*func)(void *), void *data )
-{
-	halloc_t *me;
-	if( !context )
-		return;
-
-	me = halloc_from_data( context );
-	al_push_func( &me->children, func );
-	al_push( &me->children, data );
-}
-
-void halloc_free( void *context )
-{
-	halloc_t *me;
-	int i;
-
-	if( !context )
-		return;
-
-
-	me = halloc_from_data( context );
-
-#ifdef HALLOC_DEBUG
-	alloc_spill += me->scratch_free;
-#endif
-	for( i=0; i<al_get_count(&me->children); i+=2 )
-	{
-		void (*func)(void *) = (void (*)(void *))al_get( &me->children, i );
-		void * data = (void *)al_get( &me->children, i+1 );
-		if( func != &late_free )
-			func( data );
-	}
-	for( i=0; i<al_get_count(&me->children); i+=2 )
-	{
-		void (*func)(void *) = (void (*)(void *))al_get_func( &me->children, i );
-		void * data = (void *)al_get( &me->children, i+1 );
-		if( func == &late_free )
-			free( data );
-	}
-	al_destroy( &me->children );
-	free(me);
-}

halloc.h

@@ -1,49 +0,0 @@
-/** \file halloc.h
-
-    A hierarchical memory allocation system. Works mostly like talloc
-	used in Samba, except that an arbitrary block allocated with
-	malloc() can be registered to be freed by halloc_free.
-
-*/
-
-#ifndef FISH_HALLOC_H
-#define FISH_HALLOC_H
-
-/**
-   Allocate new memory using specified parent memory context. Context
-   _must_ be either 0 or the result of a previous call to halloc. The
-   resulting memory is set to zero.
-
-   If \c context is null, the resulting block is a root block, and
-   must be freed with a call to halloc_free().
-
-   If \c context is not null, context must be a halloc root block. the
-   resulting memory block is a child context, and must never be
-   explicitly freed, it will be automatically freed whenever the
-   parent context is freed. Child blocks can also never be used as the
-   context in calls to halloc_register_function, halloc_free, etc.
-*/
-void *halloc( void *context, size_t size );
-
-/**
-   Make the specified function run whenever context is free'd, using data as argument.
-
-   \c context a halloc root block
-*/
-void halloc_register_function( void *context, void (*func)(void *), void *data );
-
-/**
-   Free memory context and all children contexts. Only root contexts
-   may be freed explicitly.
-
-   All functions registered with halloc_register_function are run in
-   the order they where added. Afterwards, all memory allocated using
-   halloc itself is free'd.
-
-   \c context a halloc root block
-*/
-void halloc_free( void *context );
-
-
-#endif
-

halloc_util.c

@@ -1,100 +0,0 @@
-/** \file halloc_util.c
-
-    A hierarchical memory allocation system. Works just like talloc
-	used in Samba, except that an arbitrary block allocated with
-	malloc() can be registered to be freed by halloc_free.
-
-*/
-
-#include "config.h"
-
-
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-
-#include "fallback.h"
-#include "util.h"
-
-#include "common.h"
-#include "halloc.h"
-
-void *global_context=0;
-
-void halloc_util_init()
-{
-	global_context = halloc( 0, 0 );
-}
-
-void halloc_util_destroy()
-{
-	halloc_free( global_context );
-}
-
-array_list_t *al_halloc( void *context )
-{
-	array_list_t *res = halloc( context, sizeof( array_list_t ) );
-	if( !res )
-		DIE_MEM();
-	al_init( res );
-	halloc_register_function( context?context:res, (void (*)(void *)) &al_destroy, res );
-	return res;
-}
-
-string_buffer_t *sb_halloc( void *context )
-{
-	string_buffer_t *res = halloc( context, sizeof( string_buffer_t ) );
-	if( !res )
-		DIE_MEM();
-	sb_init( res );
-	halloc_register_function( context?context:res, (void (*)(void *)) &sb_destroy, res );
-	return res;
-}
-
-/**
-   A function that takes a single parameter, which is a function pointer, and calls it.
-*/
-static void halloc_passthrough( void *f )
-{
-	void (*func)() = (void (*)() )f;
-	func();
-}
-
-void halloc_register_function_void( void *context, void (*func)() )
-{
-	halloc_register_function( context, &halloc_passthrough, (void *)func );
-}
-
-void *halloc_register( void *context, void *data )
-{
-	if( !data )
-		return 0;
-
-	halloc_register_function( context, &free, data );
-	return data;
-}
-
-wchar_t *halloc_wcsdup( void *context, const wchar_t *in )
-{
-	size_t len=wcslen(in);
-	wchar_t *out = halloc( context, sizeof( wchar_t)*(len+1));
-
-	if( out == 0 )
-	{
-		DIE_MEM();
-	}
-	memcpy( out, in, sizeof( wchar_t)*(len+1));
-	return out;
-}
-
-wchar_t *halloc_wcsndup( void * context, const wchar_t *in, int c )
-{
-	wchar_t *res = halloc( context, sizeof(wchar_t)*(c+1) );
-	if( res == 0 )
-	{
-		DIE_MEM();
-	}
-	wcslcpy( res, in, c+1 );
-	res[c] = L'\0';
-	return res;
-}

halloc_util.h

@@ -1,66 +0,0 @@
-/**
-   \file halloc_util.h
-
-   Various halloc-related utility functions.
-*/
-
-#ifndef FISH_HALLOC_UTIL_H
-#define FISH_HALLOC_UTIL_H
-
-/**
-   This pointer is a valid halloc context that will be freed right
-   before program shutdown. It may be used to allocate memory that
-   should be freed when the program shuts down.
-*/
-extern void *global_context;
-
-/**
-   Create the global_context halloc object
-*/
-void halloc_util_init();
-
-/**
-   Free the global_context halloc object
-*/
-void halloc_util_destroy();
-
-/**
-   Allocate a array_list_t that will be automatically disposed of when
-   the specified context is free'd
-*/
-array_list_t *al_halloc( void *context );
-
-/**
-   Allocate a string_buffer_t that will be automatically disposed of
-   when the specified context is free'd
-*/
-string_buffer_t *sb_halloc( void *context );
-
-/**
-   Register the specified function to run when the specified context
-   is free'd. This function is related to halloc_register_function,
-   but the specified function dowes not take an argument.
-*/
-void halloc_register_function_void( void *context, void (*func)() );
-
-/**
-   Free the memory pointed to by \c data when the memory pointed to by
-   \c context is free:d. Note that this will _not_ turn the specified
-   memory area into a valid halloc context. Only memory areas created
-   using a call to halloc( 0, size ) can be used as a context.
-*/
-void *halloc_register( void *context, void *data );
-
-/**
-   Make a copy of the specified string using memory allocated using
-   halloc and the specified context
-*/
-wchar_t *halloc_wcsdup( void *context, const wchar_t *str );
-
-/**
-   Make a copy of the specified substring using memory allocated using
-   halloc and the specified context
-*/
-wchar_t *halloc_wcsndup( void * context, const wchar_t *in, int c );
-
-#endif

highlight.h

@@ -7,7 +7,10 @@
 
 #include <wchar.h>
 
+#include "env.h"
 #include "util.h"
+#include "screen.h"
+#include "color.h"
 
 /**
    Internal value representing highlighting of normal text
@@ -56,23 +59,31 @@
 /**
    Internal value representing highlighting of an IO redirection
 */
-#define HIGHLIGHT_REDIRECTION 0x800
+#define HIGHLIGHT_REDIRECTION 0x800 
 /**
    Internal value representing highlighting a potentially valid path
 */
 #define HIGHLIGHT_VALID_PATH 0x1000
 
+/**
+   Internal value representing highlighting an autosuggestion
+*/
+#define HIGHLIGHT_AUTOSUGGESTION 0x2000
+
+class history_item_t;
+struct file_detection_context_t;
+
 /**
    Perform syntax highlighting for the shell commands in buff. The result is
    stored in the color array as a color_code from the HIGHLIGHT_ enum
    for each character in buff.
 
    \param buff The buffer on which to perform syntax highlighting
-   \param color The array in wchich to store the color codes. The first 8 bits are used for fg color, the next 8 bits for bg color.
+   \param color The array in wchich to store the color codes. The first 8 bits are used for fg color, the next 8 bits for bg color. 
    \param pos the cursor position. Used for quote matching, etc.
    \param error a list in which a description of each error will be inserted. May be 0, in whcich case no error descriptions will be generated.
 */
-void highlight_shell( wchar_t * buff, int *color, int pos, array_list_t *error );
+void highlight_shell( const wcstring &buffstr, std::vector<int> &color, size_t pos, wcstring_list_t *error, const env_vars_snapshot_t &vars );
 
 /**
    Perform syntax highlighting for the text in buff. Matching quotes and paranthesis are highlighted. The result is
@@ -80,22 +91,46 @@ void highlight_shell( wchar_t * buff, int *color, int pos, array_list_t *error )
    for each character in buff.
 
    \param buff The buffer on which to perform syntax highlighting
-   \param color The array in wchich to store the color codes. The first 8 bits are used for fg color, the next 8 bits for bg color.
+   \param color The array in wchich to store the color codes. The first 8 bits are used for fg color, the next 8 bits for bg color. 
    \param pos the cursor position. Used for quote matching, etc.
    \param error a list in which a description of each error will be inserted. May be 0, in whcich case no error descriptions will be generated.
 */
-void highlight_universal( wchar_t * buff, int *color, int pos, array_list_t *error );
+void highlight_universal( const wcstring &buffstr, std::vector<int> &color, size_t pos, wcstring_list_t *error, const env_vars_snapshot_t &vars );
 
 /**
    Translate from HIGHLIGHT_* to FISH_COLOR_* according to environment
    variables. Defaults to FISH_COLOR_NORMAL.
 
-   Example:
+   Example: 
 
    If the environment variable FISH_FISH_COLOR_ERROR is set to 'red', a
    call to highlight_get_color( HIGHLIGHT_ERROR) will return
    FISH_COLOR_RED.
 */
-int highlight_get_color( int highlight );
+rgb_color_t highlight_get_color( int highlight, bool is_background );
+
+/** Given a command 'str' from the history, try to determine whether we ought to suggest it by specially recognizing the command.
+    Returns true if we validated the command. If so, returns by reference whether the suggestion is valid or not.
+*/
+bool autosuggest_validate_from_history(const history_item_t &item, file_detection_context_t &detector, const wcstring &working_directory, const env_vars_snapshot_t &vars);
+
+/** Given the command line contents 'str', return via reference a suggestion by specially recognizing the command. The suggestion is escaped. Returns true if we recognized the command (even if we couldn't think of a suggestion for it).
+*/
+bool autosuggest_suggest_special(const wcstring &str, const wcstring &working_directory, wcstring &outString);
+
+/* Tests whether the specified string cpath is the prefix of anything we could cd to. directories is a list of possible parent directories (typically either the working directory, or the cdpath). This does I/O!
+
+    This is used only internally to this file, and is exposed only for testing.
+*/
+enum {
+    /* The path must be to a directory */
+    PATH_REQUIRE_DIR = 1 << 0,
+    
+    /* Expand any leading tilde in the path */
+    PATH_EXPAND_TILDE = 1 << 1
+};
+typedef unsigned int path_flags_t;
+bool is_potential_path(const wcstring &const_path, const wcstring_list_t &directories, path_flags_t flags, wcstring *out_path = NULL);
 
 #endif
+

history.c

@@ -1,995 +0,0 @@
-/** \file history.c
-	History functions, part of the user interface.
-*/
-#include "config.h"
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <wchar.h>
-#include <errno.h>
-#include <dirent.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <sys/mman.h>
-#include <fcntl.h>
-#include <string.h>
-#include <time.h>
-#include <assert.h>
-
-#include "fallback.h"
-#include "util.h"
-
-#include "wutil.h"
-#include "history.h"
-#include "common.h"
-#include "halloc.h"
-#include "halloc_util.h"
-#include "intern.h"
-#include "path.h"
-#include "signal.h"
-
-
-/**
-   Interval in seconds between automatic history save
-*/
-#define SAVE_INTERVAL (5*60)
-
-/**
-   Number of new history entries to add before automatic history save
-*/
-#define SAVE_COUNT 5
-
-/**
-   A struct representiong a history list
-*/
-typedef struct
-{
-	/**
-	   The name of this list. Used for picking a suitable filename and for switching modes.
-	*/
-	const wchar_t *name;
-
-	/**
-	   The items of the list. Each entry may be either a pointer to an
-	   item_t struct or a pointer to an mmaped memory region where a
-	   multibyte string representing the item is stored. Use the
-	   item_get function to always get an item_t.
-	*/
-	array_list_t item;
-
-
-	/**
-	   A hash table containing all the items created by the current
-	   session as keys. This can be used as a lookup when loading the
-	   history list to ignore the on-file version of an entry from
-	   this session.
-	*/
-	hash_table_t session_item;
-
-	/**
-	   The current history position
-	*/
-	int pos;
-
-	/**
-	   This flag is set nonzero if the file containing earlier saves has ben mmaped in
-	*/
-	int has_loaded;
-
-	/**
-	   The mmaped region for the history file
-	*/
-	char *mmap_start;
-
-	/**
-	   The size of the mmaped region
-	*/
-	size_t mmap_length;
-
-	/**
-	   A list of indices of all previous search maches. This is used to eliminate duplicate search results.
-	*/
-	array_list_t used;
-
-	/**
-	   Timestamp of last save
-	*/
-	time_t save_timestamp;
-
-	/**
-	   Number of entries that have been added since last save
-	*/
-	int new_count;
-
-	/**
-	   A halloc context. This context is free'd every time the history
-	   is saved. Therefore it is very well suited for use as the
-	   context for history item data.
-	*/
-	void *item_context;
-}
-	history_mode_t;
-
-/**
-   This struct represents a history item
-*/
-typedef struct
-{
-	/**
-	   The actual contents of the entry
-	*/
-	wchar_t *data;
-
-	/**
-	   Original creation time for the entry
-	*/
-	time_t timestamp;
-}
-	item_t;
-
-/**
-   Table of all history modes
-*/
-static hash_table_t *mode_table=0;
-
-/**
-   The surrent history mode
-*/
-static history_mode_t *current_mode=0;
-
-/**
-   Hash function for item_t struct
-*/
-static int hash_item_func( void *v )
-{
-	item_t *i = (item_t *)v;
-	return i->timestamp ^ hash_wcs_func( i->data );
-}
-
-/**
-   Comparison function for item_t struct
-*/
-static int hash_item_cmp( void *v1, void *v2 )
-{
-	item_t *i1 = (item_t *)v1;
-	item_t *i2 = (item_t *)v2;
-	return (i1->timestamp == i2->timestamp) && (wcscmp( i1->data, i2->data )==0);
-}
-
-/**
-   Add backslashes to all newlines, so that the returning string is
-   suitable for writing to the history file. The memory for the return
-   value will be reused by subsequent calls to this function.
-*/
-static wchar_t *history_escape_newlines( wchar_t *in )
-{
-	static string_buffer_t *out = 0;
-	if( !out )
-	{
-		out = sb_halloc( global_context );
-		if( !out )
-		{
-			DIE_MEM();
-		}
-	}
-	else
-	{
-		sb_clear( out );
-	}
-	for( ; *in; in++ )
-	{
-		if( *in == L'\\' )
-		{
-			sb_append_char( out, *in );
-			if( *(in+1) )
-			{
-				in++;
-				sb_append_char( out, *in );
-			}
-			else
-			{
-				/*
-				  This is a weird special case. When we are trying to
-				  save a string that ends with a backslash, we need to
-				  handle it specially, otherwise this command would be
-				  combined with the one following it. We hack around
-				  this by adding an additional newline.
-				*/
-				sb_append_char( out, L'\n' );
-			}
-
-		}
-		else if( *in == L'\n' )
-		{
-			sb_append_char( out, L'\\' );
-			sb_append_char( out, *in );
-		}
-		else
-		{
-			sb_append_char( out, *in );
-		}
-
-	}
-	return (wchar_t *)out->buff;
-}
-
-/**
-   Remove backslashes from all newlines. This makes a string from the
-   history file better formated for on screen display. The memory for
-   the return value will be reused by subsequent calls to this
-   function.
-*/
-static wchar_t *history_unescape_newlines( wchar_t *in )
-{
-	static string_buffer_t *out = 0;
-	if( !out )
-	{
-		out = sb_halloc( global_context );
-		if( !out )
-		{
-			DIE_MEM();
-		}
-	}
-	else
-	{
-		sb_clear( out );
-	}
-	for( ; *in; in++ )
-	{
-		if( *in == L'\\' )
-		{
-			if( *(in+1)!= L'\n')
-			{
-				sb_append_char( out, *in );
-			}
-		}
-		else
-		{
-			sb_append_char( out, *in );
-		}
-	}
-	return (wchar_t *)out->buff;
-}
-
-/**
-   Check if the specified item is already loaded
- */
-static int item_is_new( history_mode_t *m, void *d )
-{
-	char *begin = (char *)d;
-
-	if( !m->has_loaded || !m->mmap_start || (m->mmap_start == MAP_FAILED ) )
-	{
-		return 1;
-	}
-
-	if( (begin < m->mmap_start) || (begin > (m->mmap_start+m->mmap_length) ) )
-	{
-		return 1;
-	}
-	return 0;
-}
-
-/**
-   Returns an item_t for the specified adress. The adress must come from the item list of the specified mode.
-
-   Later calls to this function may erase the output of a previous call to this function.
-*/
-static item_t *item_get( history_mode_t *m, void *d )
-{
-	char *begin = (char *)d;
-
-	if( item_is_new( m, d ) )
-	{
-		return (item_t *)d;
-	}
-	else
-	{
-
-		char *end = m->mmap_start + m->mmap_length;
-		char *pos=begin;
-
-		int was_backslash = 0;
-		static string_buffer_t *out = 0;
-		static item_t narrow_item;
-		int first_char = 1;
-		int timestamp_mode = 0;
-
-		narrow_item.timestamp = 0;
-
-		if( !out )
-		{
-			out = sb_halloc( global_context );
-			if( !out )
-			{
-				DIE_MEM();
-			}
-		}
-		else
-		{
-			sb_clear( out );
-		}
-
-		while( 1 )
-		{
-			wchar_t c;
-			mbstate_t state;
-			size_t res;
-
-			memset( &state, 0, sizeof(state) );
-
-			res = mbrtowc( &c, pos, end-pos, &state );
-
-			if( res == (size_t)-1 )
-			{
-				pos++;
-				continue;
-			}
-			else if( res == (size_t)-2 )
-			{
-				break;
-			}
-			else if( res == (size_t)0 )
-			{
-				pos++;
-				continue;
-			}
-			pos += res;
-
-			if( c == L'\n' )
-			{
-				if( timestamp_mode )
-				{
-					wchar_t *time_string = (wchar_t *)out->buff;
-					while( *time_string && !iswdigit(*time_string))
-						time_string++;
-					errno=0;
-
-					if( *time_string )
-					{
-						time_t tm;
-						wchar_t *end;
-
-						errno = 0;
-						tm = (time_t)wcstol( time_string, &end, 10 );
-
-						if( tm && !errno && !*end )
-						{
-							narrow_item.timestamp = tm;
-						}
-
-					}
-
-					sb_clear( out );
-					timestamp_mode = 0;
-					continue;
-				}
-				if( !was_backslash )
-					break;
-			}
-
-			if( first_char )
-			{
-				if( c == L'#' )
-					timestamp_mode = 1;
-			}
-
-			first_char = 0;
-
-			sb_append_char( out, c );
-
-			was_backslash = ( (c == L'\\') && !was_backslash);
-
-		}
-
-		narrow_item.data = history_unescape_newlines((wchar_t *)out->buff);
-		return &narrow_item;
-	}
-
-}
-
-/**
-   Write the specified item to the specified file.
-*/
-static int item_write( FILE *f, history_mode_t *m, void *v )
-{
-	item_t *i = item_get( m, v );
-	return fwprintf( f, L"# %d\n%ls\n", i->timestamp, history_escape_newlines( i->data ) );
-}
-
-/**
-   Release all memory used by the specified history mode.
-*/
-static void history_destroy_mode( history_mode_t *m )
-{
-	halloc_free( m->item_context );
-
-	if( m->mmap_start && (m->mmap_start != MAP_FAILED ))
-	{
-		munmap( m->mmap_start, m->mmap_length);
-	}
-
-}
-
-/**
-   Free all memory used by specified mistory mode
- */
-static void history_destroy_mode_wrapper( void *n, history_mode_t *m )
-{
-	halloc_free( m );
-}
-
-/**
-   Create a new empty mode with the specified name.
-   The mode is a halloc context, and the entire mode can be destroyed using halloc_free().
-*/
-static history_mode_t *history_create_mode( const wchar_t *name )
-{
-	history_mode_t *new_mode = halloc( 0, sizeof( history_mode_t ));
-
-	new_mode->name = intern(name);
-
-	al_init( &new_mode->item );
-	al_init( &new_mode->used );
-	halloc_register_function( new_mode, (void (*)(void *))&al_destroy, &new_mode->item );
-	halloc_register_function( new_mode, (void (*)(void *))&al_destroy, &new_mode->used );
-
-	hash_init( &new_mode->session_item, &hash_item_func, &hash_item_cmp );
-	halloc_register_function( new_mode, (void (*)(void *))&hash_destroy, &new_mode->session_item );
-
-	new_mode->save_timestamp=time(0);
-	new_mode->item_context = halloc( 0,0 );
-
-	halloc_register_function( new_mode, (void (*)(void *))&history_destroy_mode, new_mode );
-
-	return new_mode;
-}
-
-/**
-   This function tests if the search string is a match for the given string
-*/
-static int history_test( const wchar_t *needle, const wchar_t *haystack )
-{
-	return !!wcsstr( haystack, needle );
-}
-
-/**
-   Returns the name of the save file for a mode.
-
-   \param context a halloc context used to allocate memory
-   \param name the name of the hstory mode
-   \param suffix an optional file suffix
-*/
-static wchar_t *history_filename( void *context, const wchar_t *name, const wchar_t *suffix )
-{
-	wchar_t *path;
-	wchar_t *res;
-
-	if( !current_mode )
-		return 0;
-
-	path = path_get_config( context );
-
-	if( !path )
-		return 0;
-
-	res = wcsdupcat( path, L"/", name, L"_history", suffix?suffix:(void *)0);
-	halloc_register_function( context, &free, res );
-	return res;
-}
-
-/**
-   Go through the mmaped region and insert pointers to suitable loacations into the item list
-*/
-static void history_populate_from_mmap( history_mode_t *m )
-{
-	char *begin = m->mmap_start;
-	char *end = begin + m->mmap_length;
-	char *pos;
-
-	array_list_t old_item;
-	array_list_t session_item_list;
-	int ignore_newline = 0;
-	int do_push = 1;
-
-	al_init( &old_item );
-	al_init( &session_item_list );
-	al_push_all( &old_item, &m->item );
-	al_truncate( &m->item, 0 );
-
-	for( pos = begin; pos <end; pos++ )
-	{
-
-		if( do_push )
-		{
-			item_t *i;
-			item_t *i_orig;
-
-			ignore_newline = *pos == '#';
-
-			i = item_get( m, pos );
-
-			if( (i_orig=hash_get( &current_mode->session_item, i ) ) )
-			{
-				/*
-				  This item comes from this session. Insert the
-				  original item at the end of the item list.
-				*/
-				al_push( &session_item_list, i_orig );
-			}
-			else
-			{
-				/*
-				  Old item. Insert pointer directly to the item list
-				*/
-				al_push( &m->item, pos );
-			}
-
-			do_push = 0;
-		}
-
-		switch( *pos )
-		{
-			case '\\':
-			{
-				pos++;
-				break;
-			}
-
-			case '\n':
-			{
-				if( ignore_newline )
-				{
-					ignore_newline = 0;
-				}
-				else
-				{
-					do_push = 1;
-				}
-				break;
-			}
-		}
-	}
-
-	al_push_all(  &m->item, &session_item_list );
-	m->pos += al_get_count( &m->item );
-	al_push_all(  &m->item, &old_item );
-
-
-	al_destroy( &session_item_list );
-	al_destroy( &old_item );
-}
-
-/**
-   Load contents of the backing file to memory
-*/
-static void history_load( history_mode_t *m )
-{
-	int fd;
-	int ok=0;
-
-	void *context;
-	wchar_t *filename;
-
-	if( !m )
-		return;
-
-	m->has_loaded=1;
-
-	signal_block();
-
-	context = halloc( 0, 0 );
-	filename = history_filename( context, m->name, 0 );
-
-	if( filename )
-	{
-		if( ( fd = wopen( filename, O_RDONLY ) ) > 0 )
-		{
-			off_t len = lseek( fd, 0, SEEK_END );
-			if( len != (off_t)-1)
-			{
-				m->mmap_length = (size_t)len;
-				if( lseek( fd, 0, SEEK_SET ) == 0 )
-				{
-					if( (m->mmap_start = mmap( 0, m->mmap_length, PROT_READ, MAP_PRIVATE, fd, 0 )) != MAP_FAILED )
-					{
-						ok = 1;
-						history_populate_from_mmap( m );
-					}
-				}
-			}
-			close( fd );
-		}
-	}
-
-	halloc_free( context );
-	signal_unblock();
-}
-
-/**
-   Save the specified mode to file
-*/
-static void history_save_mode( void *n, history_mode_t *m )
-{
-	FILE *out;
-	history_mode_t *on_disk;
-	int i;
-	int has_new=0;
-	wchar_t *tmp_name;
-
-	int ok = 1;
-
-	/*
-	  First check if there are any new entries to save. If not, then
-	  we can just return
-	*/
-	for( i=0; i<al_get_count(&m->item); i++ )
-	{
-		void *ptr = al_get( &m->item, i );
-		has_new = item_is_new( m, ptr );
-		if( has_new )
-		{
-			break;
-		}
-	}
-
-	if( !has_new )
-	{
-		return;
-	}
-
-	signal_block();
-
-	/*
-	  Set up on_disk variable to describe the current contents of the
-	  history file
-	*/
-	on_disk = history_create_mode( m->name );
-	history_load( on_disk );
-
-	tmp_name = history_filename( on_disk, m->name, L".tmp" );
-
-	if( tmp_name )
-	{
-		tmp_name = wcsdup(tmp_name );
-
-		if( (out=wfopen( tmp_name, "w" ) ) )
-		{
-			hash_table_t mine;
-
-			hash_init( &mine, &hash_item_func, &hash_item_cmp );
-
-			for( i=0; i<al_get_count(&m->item); i++ )
-			{
-				void *ptr = al_get( &m->item, i );
-				int is_new = item_is_new( m, ptr );
-				if( is_new )
-				{
-					hash_put( &mine, item_get( m, ptr ), L"" );
-				}
-			}
-
-			/*
-			  Re-save the old history
-			*/
-			for( i=0; ok && (i<al_get_count(&on_disk->item)); i++ )
-			{
-				void *ptr = al_get( &on_disk->item, i );
-				item_t *i = item_get( on_disk, ptr );
-				if( !hash_get( &mine, i ) )
-				{
-					if( item_write( out, on_disk, ptr ) == -1 )
-					{
-						ok = 0;
-						break;
-					}
-				}
-
-			}
-
-			hash_destroy( &mine );
-
-			/*
-			  Add our own items last
-			*/
-			for( i=0; ok && (i<al_get_count(&m->item)); i++ )
-			{
-				void *ptr = al_get( &m->item, i );
-				int is_new = item_is_new( m, ptr );
-				if( is_new )
-				{
-					if( item_write( out, m, ptr ) == -1 )
-					{
-						ok = 0;
-					}
-				}
-			}
-
-			if( fclose( out ) || !ok )
-			{
-				/*
-				  This message does not have high enough priority to
-				  be shown by default.
-				*/
-				debug( 2, L"Error when writing history file" );
-			}
-			else
-			{
-				wrename( tmp_name, history_filename( on_disk, m->name, 0 ) );
-			}
-		}
-		free( tmp_name );
-	}
-
-	halloc_free( on_disk);
-
-	if( ok )
-	{
-
-		/*
-		  Reset the history. The item_t entries created in this session
-		  are not lost or dropped, they are stored in the session_item
-		  hash table. On reload, they will be automatically inserted at
-		  the end of the history list.
-		*/
-
-		if( m->mmap_start && (m->mmap_start != MAP_FAILED ) )
-		{
-			munmap( m->mmap_start, m->mmap_length );
-		}
-
-		al_truncate( &m->item, 0 );
-		al_truncate( &m->used, 0 );
-		m->pos = 0;
-		m->has_loaded = 0;
-		m->mmap_start=0;
-		m->mmap_length=0;
-
-		m->save_timestamp=time(0);
-		m->new_count = 0;
-	}
-
-	signal_unblock();
-}
-
-
-void history_add( const wchar_t *str )
-{
-	item_t *i;
-
-	if( !current_mode )
-		return;
-
-	i = halloc( current_mode->item_context, sizeof(item_t));
-	i->data = (wchar_t *)halloc_wcsdup( current_mode->item_context, str );
-	i->timestamp = time(0);
-
-	al_push( &current_mode->item, i );
-	hash_put( &current_mode->session_item, i, i );
-
-	al_truncate( &current_mode->used, 0 );
-	current_mode->pos = al_get_count( &current_mode->item );
-
-	current_mode->new_count++;
-
-	if( (time(0) > current_mode->save_timestamp+SAVE_INTERVAL) || (current_mode->new_count >= SAVE_COUNT) )
-	{
-		history_save_mode( 0, current_mode );
-	}
-
-}
-
-/**
-   Check if the specified string has already been used a s a search match
-*/
-static int history_is_used( const wchar_t  *str )
-{
-	int i;
-	int res =0;
-	item_t *it = 0;
-
-	for( i=0; i<al_get_count( &current_mode->used); i++ )
-	{
-		long idx = al_get_long( &current_mode->used, i );
-		it = item_get( current_mode, al_get( &current_mode->item, (int)idx ) );
-		if( wcscmp( it->data, str ) == 0 )
-		{
-			res = 1;
-			break;
-		}
-
-	}
-	return res;
-}
-
-const wchar_t *history_prev_match( const wchar_t *needle )
-{
-	if( current_mode )
-	{
-		if( current_mode->pos > 0 )
-		{
-			for( current_mode->pos--; current_mode->pos>=0; current_mode->pos-- )
-			{
-				item_t *i = item_get( current_mode, al_get( &current_mode->item, current_mode->pos ) );
-				wchar_t *haystack = (wchar_t *)i->data;
-
-				if( history_test( needle, haystack ) )
-				{
-					int is_used;
-
-					/*
-					  This is ugly.  Whenever we call item_get(),
-					  there is a chance that the return value of any
-					  previous call to item_get will become
-					  invalid. The history_is_used function uses the
-					  item_get() function. Therefore, we must create
-					  a copy of the haystack string, and if the string
-					  is unused, we must call item_get anew.
-					*/
-
-					haystack = wcsdup(haystack );
-
-					is_used = history_is_used( haystack );
-
-					free( haystack );
-
-					if( !is_used )
-					{
-						i = item_get( current_mode, al_get( &current_mode->item, current_mode->pos ) );
-						al_push_long( &current_mode->used, current_mode->pos );
-						return i->data;
-					}
-				}
-			}
-		}
-
-		if( !current_mode->has_loaded )
-		{
-			/*
-			  We found no match in the list, try loading the history
-			  file and continue the search
-			*/
-			history_load( current_mode );
-			return history_prev_match( needle );
-		}
-		else
-		{
-			/*
-			  We found no match in the list, and the file is already
-			  loaded. Set poition before first element and return
-			  original search string.
-			*/
-			current_mode->pos=-1;
-			if( al_peek_long( &current_mode->used ) != -1 )
-				al_push_long( &current_mode->used, -1 );
-		}
-
-	}
-
-	return needle;
-}
-
-
-wchar_t *history_get( int idx )
-{
-	int len;
-
-	if( !current_mode )
-		return 0;
-
-	len = al_get_count( &current_mode->item );
-
-	if( (idx >= len ) && !current_mode->has_loaded )
-	{
-		history_load( current_mode );
-		len = al_get_count( &current_mode->item );
-	}
-
-	if( idx < 0 )
-		return 0;
-
-	if( idx >= len )
-		return 0;
-
-	return item_get( current_mode, al_get( &current_mode->item, len - 1 - idx ) )->data;
-}
-
-void history_first()
-{
-	if( current_mode )
-	{
-		if( !current_mode->has_loaded )
-		{
-			history_load( current_mode );
-		}
-
-		current_mode->pos = 0;
-	}
-}
-
-void history_reset()
-{
-	if( current_mode )
-	{
-		current_mode->pos = al_get_count( &current_mode->item );
-		/*
-		  Clear list of search matches
-		*/
-		al_truncate( &current_mode->used, 0 );
-	}
-}
-
-const wchar_t *history_next_match( const wchar_t *needle)
-{
-	if( current_mode )
-	{
-		/*
-		  The index of previous search matches are saved in the 'used'
-		  list. We just need to pop the top item and set the new
-		  position. Easy!
-		*/
-		if( al_get_count( &current_mode->used ) )
-		{
-			al_pop( &current_mode->used );
-			if( al_get_count( &current_mode->used ) )
-			{
-				current_mode->pos = (int) al_peek_long( &current_mode->used );
-				item_t *i = item_get( current_mode, al_get( &current_mode->item, current_mode->pos ) );
-				return i->data;
-			}
-		}
-
-		/*
-		  The used-list is empty. Set position to 'past end of list'
-		  and return the search string.
-		*/
-		current_mode->pos = al_get_count( &current_mode->item );
-
-	}
-	return needle;
-}
-
-
-void history_set_mode( const wchar_t *name )
-{
-	if( !mode_table )
-	{
-		mode_table = malloc( sizeof(hash_table_t ));
-		hash_init( mode_table, &hash_wcs_func, &hash_wcs_cmp );
-	}
-
-	current_mode = (history_mode_t *)hash_get( mode_table, name );
-
-	if( !current_mode )
-	{
-		current_mode = history_create_mode( name );
-		hash_put( mode_table, name, current_mode );
-	}
-}
-
-void history_init()
-{
-}
-
-
-void history_destroy()
-{
-	if( mode_table )
-	{
-		hash_foreach( mode_table, (void (*)(void *, void *))&history_save_mode );
-		hash_foreach( mode_table, (void (*)(void *, void *))&history_destroy_mode_wrapper );
-		hash_destroy( mode_table );
-		free( mode_table );
-		mode_table=0;
-	}
-}
-
-
-void history_sanity_check()
-{
-	/*
-	  No sanity checking implemented yet...
-	*/
-}
-

history.h

@@ -6,6 +6,244 @@
 #define FISH_HISTORY_H
 
 #include <wchar.h>
+#include "common.h"
+#include "pthread.h"
+#include <vector>
+#include <utility>
+#include <list>
+#include <set>
+
+typedef std::vector<wcstring> path_list_t;
+
+enum history_search_type_t {
+    /** The history searches for strings containing the given string */
+    HISTORY_SEARCH_TYPE_CONTAINS,
+    
+    /** The history searches for strings starting with the given string */
+    HISTORY_SEARCH_TYPE_PREFIX
+};
+
+class history_item_t {
+    friend class history_t;
+    friend class history_lru_node_t;
+    friend class history_tests_t;
+
+    private:
+    explicit history_item_t(const wcstring &);
+    explicit history_item_t(const wcstring &, time_t, const path_list_t &paths = path_list_t());
+    
+    /** Attempts to merge two compatible history items together */
+    bool merge(const history_item_t &item);
+
+	/** The actual contents of the entry */
+	wcstring contents;
+    
+	/** Original creation time for the entry */
+	time_t creation_timestamp;
+    
+    /** Paths that we require to be valid for this item to be autosuggested */
+    path_list_t required_paths;
+    
+    public:
+    const wcstring &str() const { return contents; }
+    bool empty() const { return contents.empty(); }
+    
+    /* Whether our contents matches a search term. */
+    bool matches_search(const wcstring &term, enum history_search_type_t type) const;
+    
+    time_t timestamp() const { return creation_timestamp; }
+    
+    const path_list_t &get_required_paths() const { return required_paths; }
+    
+    bool operator==(const history_item_t &other) const {
+        return contents == other.contents &&
+               creation_timestamp == other.creation_timestamp &&
+               required_paths == other.required_paths;
+    }
+};
+
+/* The type of file that we mmap'd */
+enum history_file_type_t {
+    history_type_unknown,
+    history_type_fish_2_0,
+    history_type_fish_1_x
+};
+
+class history_t {
+    friend class history_tests_t;
+private:
+    /** No copying */
+    history_t(const history_t&);
+    history_t &operator=(const history_t&);
+
+    /** Private creator */
+    history_t(const wcstring &pname);
+    
+    /** Privately add an item */
+    void add(const history_item_t &item);
+    
+    /** Destructor */
+    ~history_t();
+
+    /** Lock for thread safety */
+    pthread_mutex_t lock;
+    
+    /** Internal function */
+    void clear_file_state();
+
+	/** The name of this list. Used for picking a suitable filename and for switching modes. */
+	const wcstring name;
+	
+	/** New items. */
+	std::vector<history_item_t> new_items;
+
+  	/** Deleted item contents. */
+	std::set<wcstring> deleted_items;
+
+	/** How many items we've added without saving */
+	size_t unsaved_item_count;
+    
+	/** The mmaped region for the history file */
+	const char *mmap_start;
+
+	/** The size of the mmap'd region */
+	size_t mmap_length;
+
+    /** The type of file we mmap'd */
+    history_file_type_t mmap_type;
+
+    /** Timestamp of when this history was created */
+    const time_t birth_timestamp;
+
+	/** Timestamp of last save */
+	time_t save_timestamp;
+    
+    void populate_from_mmap(void);
+    
+    /** List of old items, as offsets into out mmap data */
+    std::vector<size_t> old_item_offsets;
+    
+    /** Whether we've loaded old items */
+    bool loaded_old;
+    
+    /** Loads old if necessary */
+    bool load_old_if_needed(void);
+    
+    /** Deletes duplicates in new_items. */
+    void compact_new_items();
+    
+    /** Saves history */
+    void save_internal();
+
+    /* Versioned decoding */
+    static history_item_t decode_item_fish_2_0(const char *base, size_t len);
+    static history_item_t decode_item_fish_1_x(const char *base, size_t len);
+    static history_item_t decode_item(const char *base, size_t len, history_file_type_t type);
+        
+public:
+    /** Returns history with the given name, creating it if necessary */
+    static history_t & history_with_name(const wcstring &name);
+    
+    /** Determines whether the history is empty. Unfortunately this cannot be const, since it may require populating the history. */
+    bool is_empty(void);
+    
+    /** Add a new history item to the end */
+    void add(const wcstring &str, const path_list_t &valid_paths = path_list_t());
+
+    /** Remove a history item */
+    void remove(const wcstring &str);
+    
+    /** Add a new history item to the end */
+    void add_with_file_detection(const wcstring &str);
+    
+    /** Saves history */
+    void save();
+    
+    /** Irreversibly clears history */
+    void clear();
+    
+    /** Populates from a bash history file */
+    void populate_from_bash(FILE *f);
+    
+    /* Gets all the history into a string with ARRAY_SEP_STR. This is intended for the $history environment variable. This may be long! */
+    void get_string_representation(wcstring &str, const wcstring &separator);
+    
+    /** Return the specified history at the specified index. 0 is the index of the current commandline. (So the most recent item is at index 1.) */
+    history_item_t item_at_index(size_t idx);
+    
+    bool is_deleted(const history_item_t &item) const;
+};
+
+class history_search_t {
+
+    /** The history in which we are searching */
+    history_t * history;
+    
+    /** Our type */
+    enum history_search_type_t search_type;
+    
+    /** Our list of previous matches as index, value. The end is the current match. */
+    typedef std::pair<size_t, history_item_t> prev_match_t;
+    std::vector<prev_match_t> prev_matches;
+
+    /** Returns yes if a given term is in prev_matches. */
+    bool match_already_made(const wcstring &match) const;
+
+    /** The search term */
+    wcstring term;
+    
+    /** Additional strings to skip (sorted) */
+    wcstring_list_t external_skips;
+    
+    bool should_skip_match(const wcstring &str) const;
+    
+    public:
+    
+    /** Gets the search term */
+    const wcstring &get_term() const { return term; }
+
+    /** Sets additional string matches to skip */
+    void skip_matches(const wcstring_list_t &skips);
+
+    /** Finds the next search term (forwards in time). Returns true if one was found. */
+    bool go_forwards(void);
+    
+    /** Finds the previous search result (backwards in time). Returns true if one was found. */
+    bool go_backwards(void);
+    
+    /** Goes to the end (forwards) */
+    void go_to_end(void);
+    
+    /** Returns if we are at the end. We start out at the end. */
+    bool is_at_end(void) const;
+    
+    /** Goes to the beginning (backwards) */
+    void go_to_beginning(void);
+    
+    /** Returns the current search result item. asserts if there is no current item. */
+    history_item_t current_item(void) const;
+    
+    /** Returns the current search result item contents. asserts if there is no current item. */
+    wcstring current_string(void) const;
+
+
+    /** Constructor */
+    history_search_t(history_t &hist, const wcstring &str, enum history_search_type_t type = HISTORY_SEARCH_TYPE_CONTAINS) :
+        history(&hist),
+        search_type(type),
+        term(str)
+    {}
+    
+    /* Default constructor */
+    history_search_t() :
+        history(),
+        search_type(HISTORY_SEARCH_TYPE_CONTAINS),
+        term()
+    {}
+    
+};
+
+
 
 /**
    Init history library. The history file won't actually be loaded
@@ -14,59 +252,47 @@
 void history_init();
 
 /**
-   Saves the new history to disc and frees all memory used by the history.
+   Saves the new history to disc.
 */
 void history_destroy();
 
-/**
-  Add a new history item to the bottom of the history, containing a
-  copy of str. Remove any duplicates. Moves the current item past the
-  end of the history list.
-*/
-void history_add( const wchar_t *str );
-
-/**
-  Find previous history item starting with str. If this moves before
-  the start of the history, str is returned.
-*/
-const wchar_t *history_prev_match( const wchar_t *str );
-
-/**
-   Return the specified history at the specified index, or 0 if out of bounds. 0 is the index of the current commandline.
-*/
-wchar_t *history_get( int idx );
-
-
-/**
-   Move to first history item
-*/
-void history_first();
-
-/**
-   Make current point to last history item
-*/
-void history_reset();
-
-
-/**
-  Find next history item starting with str. If this moves past
-  the end of the history, str is returned.
-*/
-const wchar_t *history_next_match( const wchar_t *str);
-
-
-/**
-   Set the current mode name for history. Each application that uses
-   the history has it's own mode. This must be called prior to any use
-   of the history.
-*/
-
-void history_set_mode( const wchar_t *name );
-
-
 /**
    Perform sanity checks
 */
 void history_sanity_check();
 
+/* A helper class for threaded detection of paths */
+struct file_detection_context_t {
+
+    /* Constructor */
+    file_detection_context_t(history_t *hist, const wcstring &cmd);
+    
+    /* Determine which of potential_paths are valid, and put them in valid_paths */
+    int perform_file_detection();
+    
+    /* The history associated with this context */
+    history_t *history;
+    
+    /* The command */
+    wcstring command;
+    
+    /* When the command was issued */
+    time_t when;
+    
+    /* The working directory at the time the command was issued */
+    wcstring working_directory;
+    
+    /* Paths to test */
+    path_list_t potential_paths;
+    
+    /* Paths that were found to be valid */
+    path_list_t valid_paths;
+    
+    /* Performs file detection. Returns 1 if every path in potential_paths is valid, 0 otherwise. If test_all is true, tests every path; otherwise stops as soon as it reaches an invalid path. */
+    int perform_file_detection(bool test_all);
+    
+    /* Determine whether the given paths are all valid */
+    bool paths_are_valid(const path_list_t &paths);
+};
+
 #endif

input.c

@@ -1,887 +0,0 @@
-/** \file input.c
-
-    Functions for reading a character of input from stdin.
-
-*/
-
-#include "config.h"
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <errno.h>
-#include <termios.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-
-#ifdef HAVE_SYS_TERMIOS_H
-#include <sys/termios.h>
-#endif
-
-#ifdef HAVE_SYS_IOCTL_H
-#include <sys/ioctl.h>
-#endif
-
-#include <unistd.h>
-#include <wchar.h>
-
-#if HAVE_NCURSES_H
-#include <ncurses.h>
-#else
-#include <curses.h>
-#endif
-
-
-#if HAVE_TERMIO_H
-#include <termio.h>
-#endif
-
-#if HAVE_TERM_H
-#include <term.h>
-#elif HAVE_NCURSES_TERM_H
-#include <ncurses/term.h>
-#endif
-
-#include <signal.h>
-#include <dirent.h>
-#include <wctype.h>
-
-
-
-#include "fallback.h"
-#include "util.h"
-
-#include "wutil.h"
-#include "reader.h"
-#include "proc.h"
-#include "common.h"
-#include "sanity.h"
-#include "input_common.h"
-#include "input.h"
-#include "parser.h"
-#include "env.h"
-#include "expand.h"
-#include "event.h"
-#include "signal.h"
-
-#include "output.h"
-#include "intern.h"
-#include "halloc.h"
-#include "halloc_util.h"
-
-/**
-   Add a new terminfo mapping
-*/
-#define TERMINFO_ADD(key)						\
-	{								\
-		terminfo_mapping_t *m = halloc( terminfo_mappings, sizeof( terminfo_mapping_t ) ); \
-		m->name = halloc_wcsdup( terminfo_mappings, (L ## #key)+4 ); \
-		m->seq = key;						\
-		al_push( terminfo_mappings, m );			\
-	}
-
-
-/**
-   Struct representing a keybinding. Returned by input_get_mappings.
- */
-typedef struct
-{
-	const wchar_t *seq; /**< Character sequence which generates this event */
-	const wchar_t *command; /**< command that should be evaluated by this mapping */
-
-}
-	input_mapping_t;
-
-/**
-   A struct representing the mapping from a terminfo key name to a terminfo character sequence
- */
-typedef struct
-{
-	const wchar_t *name; /**< Name of key */
-	const char *seq; /**< Character sequence generated on keypress */
-
-}
-	terminfo_mapping_t;
-
-
-/**
-   Names of all the input functions supported
-*/
-static const wchar_t *name_arr[] =
-{
-	L"beginning-of-line",
-	L"end-of-line",
-	L"forward-char",
-	L"backward-char",
-	L"forward-word",
-	L"backward-word",
-	L"history-search-backward",
-	L"history-search-forward",
-	L"delete-char",
-	L"backward-delete-char",
-	L"kill-line",
-	L"yank",
-	L"yank-pop",
-	L"complete",
-	L"beginning-of-history",
-	L"end-of-history",
-	L"backward-kill-line",
-	L"kill-whole-line",
-	L"kill-word",
-	L"backward-kill-word",
-	L"dump-functions",
-	L"history-token-search-backward",
-	L"history-token-search-forward",
-	L"self-insert",
-	L"null",
-	L"eof",
-	L"vi-arg-digit",
-	L"execute",
-	L"beginning-of-buffer",
-	L"end-of-buffer",
-	L"repaint",
-	L"up-line",
-	L"down-line"
-}
-	;
-
-/**
-   Description of each supported input function
-*/
-/*
-static const wchar_t *desc_arr[] =
-{
-	L"Move to beginning of line",
-	L"Move to end of line",
-	L"Move forward one character",
-	L"Move backward one character",
-	L"Move forward one word",
-	L"Move backward one word",
-	L"Search backward through list of previous commands",
-	L"Search forward through list of previous commands",
-	L"Delete one character forward",
-	L"Delete one character backward",
-	L"Move contents from cursor to end of line to killring",
-	L"Paste contents of killring",
-	L"Rotate to previous killring entry",
-	L"Guess the rest of the next input token",
-	L"Move to first item of history",
-	L"Move to last item of history",
-	L"Clear current line",
-	L"Move contents from beginning of line to cursor to killring",
-	L"Move entire line to killring",
-	L"Move next word to killring",
-	L"Move previous word to killring",
-	L"Write out keybindings",
-	L"Clear entire screen",
-	L"Quit the running program",
-	L"Search backward through list of previous commands for matching token",
-	L"Search forward through list of previous commands for matching token",
-	L"Insert the pressed key",
-	L"Do nothing",
-	L"End of file",
-	L"Repeat command"
-}
-	;
-*/
-
-/**
-   Internal code for each supported input function
-*/
-static const wchar_t code_arr[] =
-{
-	R_BEGINNING_OF_LINE,
-	R_END_OF_LINE,
-	R_FORWARD_CHAR,
-	R_BACKWARD_CHAR,
-	R_FORWARD_WORD,
-	R_BACKWARD_WORD,
-	R_HISTORY_SEARCH_BACKWARD,
-	R_HISTORY_SEARCH_FORWARD,
-	R_DELETE_CHAR,
-	R_BACKWARD_DELETE_CHAR,
-	R_KILL_LINE,
-	R_YANK,
-	R_YANK_POP,
-	R_COMPLETE,
-	R_BEGINNING_OF_HISTORY,
-	R_END_OF_HISTORY,
-	R_BACKWARD_KILL_LINE,
-	R_KILL_WHOLE_LINE,
-	R_KILL_WORD,
-	R_BACKWARD_KILL_WORD,
-	R_DUMP_FUNCTIONS,
-	R_HISTORY_TOKEN_SEARCH_BACKWARD,
-	R_HISTORY_TOKEN_SEARCH_FORWARD,
-	R_SELF_INSERT,
-	R_NULL,
-	R_EOF,
-	R_VI_ARG_DIGIT,
-	R_EXECUTE,
-	R_BEGINNING_OF_BUFFER,
-	R_END_OF_BUFFER,
-	R_REPAINT,
-	R_UP_LINE,
-	R_DOWN_LINE
-}
-	;
-
-
-/**
-   Mappings for the current input mode
-*/
-static array_list_t mappings = {0,0,0};
-
-/**
-   List of all terminfo mappings
- */
-static array_list_t *terminfo_mappings = 0;
-
-
-/**
-   Set to one when the input subsytem has been initialized.
-*/
-static int is_init = 0;
-
-/**
-   Initialize terminfo.
- */
-static void input_terminfo_init();
-/**
-   Deallocate memory used by terminfo. Or at least try to. Terminfo leaks.
- */
-static void input_terminfo_destroy();
-
-/**
-   Returns the function description for the given function code.
-*/
-
-void input_mapping_add( const wchar_t *sequence,
-			const wchar_t *command )
-{
-	int i;
-
-	CHECK( sequence, );
-	CHECK( command, );
-
-	//	debug( 0, L"Add mapping from %ls to %ls", escape(sequence, 1), escape(command, 1 ) );
-
-
-	for( i=0; i<al_get_count( &mappings); i++ )
-	{
-		input_mapping_t *m = (input_mapping_t *)al_get( &mappings, i );
-		if( wcscmp( m->seq, sequence ) == 0 )
-		{
-			m->command = intern(command);
-			return;
-		}
-	}
-
-	input_mapping_t *m = malloc( sizeof( input_mapping_t ) );
-	m->seq = intern( sequence );
-	m->command = intern(command);
-	al_push( &mappings, m );
-
-}
-
-/**
-   Handle interruptions to key reading by reaping finshed jobs and
-   propagating the interrupt to the reader.
-*/
-static int interrupt_handler()
-{
-	/*
-	  Fire any pending events
-	*/
-	event_fire( NULL );
-
-	/*
-	  Reap stray processes, including printing exit status messages
-	*/
-	if( job_reap( 1 ) )
-		reader_repaint_needed();
-
-	/*
-	  Tell the reader an event occured
-	*/
-	if( reader_interrupted() )
-	{
-		/*
-		  Return 3, i.e. the character read by a Control-C.
-		*/
-		return 3;
-	}
-
-	return R_NULL;
-}
-
-int input_init()
-{
-	if( is_init )
-		return 1;
-
-	is_init = 1;
-
-	input_common_init( &interrupt_handler );
-
-	if( setupterm( 0, STDOUT_FILENO, 0) == ERR )
-	{
-		debug( 0, _( L"Could not set up terminal" ) );
-		exit(1);
-	}
-	output_set_term( env_get( L"TERM" ) );
-
-	input_terminfo_init();
-
-	/*
-	  If we have no keybindings, add a few simple defaults
-	*/
-	if( !al_get_count( &mappings ) )
-	{
-		input_mapping_add( L"", L"self-insert" );
-		input_mapping_add( L"\n", L"execute" );
-		input_mapping_add( L"\t", L"complete" );
-		input_mapping_add( L"\x3", L"commandline \"\"" );
-		input_mapping_add( L"\x4", L"exit" );
-		input_mapping_add( L"\x5", L"bind" );
-	}
-
-	return 1;
-}
-
-void input_destroy()
-{
-	if( !is_init )
-		return;
-
-
-	is_init=0;
-
-	al_foreach( &mappings, &free );
-	al_destroy( &mappings );
-
-	input_common_destroy();
-
-	if( del_curterm( cur_term ) == ERR )
-	{
-		debug( 0, _(L"Error while closing terminfo") );
-	}
-
-	input_terminfo_destroy();
-
-}
-
-/**
-   Perform the action of the specified binding
-*/
-static wint_t input_exec_binding( input_mapping_t *m, const wchar_t *seq )
-{
-	wchar_t code = input_function_get_code( m->command );
-	if( code != -1 )
-	{
-		switch( code )
-		{
-
-			case R_SELF_INSERT:
-			{
-				return seq[0];
-			}
-
-			default:
-			{
-				return code;
-			}
-
-		}
-	}
-	else
-	{
-
-		/*
-		  This key sequence is bound to a command, which
-		  is sent to the parser for evaluation.
-		*/
-		int last_status = proc_get_last_status();
-
-		eval( m->command, 0, TOP );
-
-		proc_set_last_status( last_status );
-
-		/*
-		  We still need to return something to the caller, R_NULL
-		  tells the reader that no key press needs to be handled,
-		  and no repaint is needed.
-
-		  Bindings that produce output should emit a R_REPAINT
-		  function by calling 'commandline -f repaint' to tell
-		  fish that a repaint is in order.
-		*/
-
-		return R_NULL;
-
-	}
-}
-
-
-
-/**
-   Try reading the specified function mapping
-*/
-static wint_t input_try_mapping( input_mapping_t *m)
-{
-	int j, k;
-	wint_t c=0;
-
-	/*
-	  Check if the actual function code of this mapping is on the stack
-	 */
-	c = input_common_readch( 0 );
-	if( c == input_function_get_code( m->command ) )
-	{
-		return input_exec_binding( m, m->seq );
-	}
-	input_unreadch( c );
-
-	if( m->seq != 0 )
-	{
-
-		for( j=0; m->seq[j] != L'\0' &&
-			     m->seq[j] == (c=input_common_readch( j>0 )); j++ )
-			;
-
-		if( m->seq[j] == L'\0' )
-		{
-			return input_exec_binding( m, m->seq );
-		}
-		else
-		{
-			/*
-			  Return the read characters
-			*/
-			input_unreadch(c);
-			for( k=j-1; k>=0; k-- )
-			{
-				input_unreadch( m->seq[k] );
-			}
-		}
-	}
-	return 0;
-
-}
-
-void input_unreadch( wint_t ch )
-{
-	input_common_unreadch( ch );
-}
-
-wint_t input_readch()
-{
-
-	int i;
-
-	CHECK_BLOCK( R_NULL );
-
-	/*
-	  Clear the interrupted flag
-	*/
-	reader_interrupted();
-
-	/*
-	  Search for sequence in mapping tables
-	*/
-
-	while( 1 )
-	{
-		input_mapping_t *generic = 0;
-		for( i=0; i<al_get_count( &mappings); i++ )
-		{
-			input_mapping_t *m = (input_mapping_t *)al_get( &mappings, i );
-			wint_t res = input_try_mapping( m );
-			if( res )
-				return res;
-
-			if( wcslen( m->seq) == 0 )
-			{
-				generic = m;
-			}
-
-		}
-
-		/*
-		  No matching exact mapping, try to find generic mapping.
-		*/
-
-		if( generic )
-		{
-			wchar_t arr[2]=
-				{
-					0,
-					0
-				}
-			;
-			arr[0] = input_common_readch(0);
-
-			return input_exec_binding( generic, arr );
-		}
-
-		/*
-		  No action to take on specified character, ignore it
-		  and move to next one.
-		*/
-		input_common_readch( 0 );	}
-}
-
-void input_mapping_get_names( array_list_t *list )
-{
-	int i;
-
-	for( i=0; i<al_get_count( &mappings ); i++ )
-	{
-		input_mapping_t *m = (input_mapping_t *)al_get( &mappings, i );
-		al_push( list, m->seq );
-	}
-
-}
-
-
-int input_mapping_erase( const wchar_t *sequence )
-{
-	int ok = 0;
-	int i;
-	size_t sz = al_get_count( &mappings );
-
-	for( i=0; i<sz; i++ )
-	{
-		input_mapping_t *m = (input_mapping_t *)al_get( &mappings, i );
-		if( !wcscmp( sequence, m->seq ) )
-		{
-			if( i != (sz-1 ) )
-			{
-				al_set( &mappings, i, al_get( &mappings, sz -1 ) );
-			}
-			al_truncate( &mappings, sz-1 );
-			ok = 1;
-
-			free( m );
-
-			break;
-
-		}
-
-	}
-
-	return ok;
-
-}
-
-const wchar_t *input_mapping_get( const wchar_t *sequence )
-{
-	int i;
-	size_t sz = al_get_count( &mappings );
-
-	for( i=0; i<sz; i++ )
-	{
-		input_mapping_t *m = (input_mapping_t *)al_get( &mappings, i );
-		if( !wcscmp( sequence, m->seq ) )
-		{
-			return m->command;
-		}
-	}
-	return 0;
-}
-
-/**
-   Add all terminfo mappings
- */
-static void input_terminfo_init()
-{
-	terminfo_mappings = al_halloc( 0 );
-
-
-       TERMINFO_ADD(key_a1);
-       TERMINFO_ADD(key_a3);
-       TERMINFO_ADD(key_b2);
-       TERMINFO_ADD(key_backspace);
-       TERMINFO_ADD(key_beg);
-       TERMINFO_ADD(key_btab);
-       TERMINFO_ADD(key_c1);
-       TERMINFO_ADD(key_c3);
-       TERMINFO_ADD(key_cancel);
-       TERMINFO_ADD(key_catab);
-       TERMINFO_ADD(key_clear);
-       TERMINFO_ADD(key_close);
-       TERMINFO_ADD(key_command);
-       TERMINFO_ADD(key_copy);
-       TERMINFO_ADD(key_create);
-       TERMINFO_ADD(key_ctab);
-       TERMINFO_ADD(key_dc);
-       TERMINFO_ADD(key_dl);
-       TERMINFO_ADD(key_down);
-       TERMINFO_ADD(key_eic);
-       TERMINFO_ADD(key_end);
-       TERMINFO_ADD(key_enter);
-       TERMINFO_ADD(key_eol);
-       TERMINFO_ADD(key_eos);
-       TERMINFO_ADD(key_exit);
-       TERMINFO_ADD(key_f0);
-       TERMINFO_ADD(key_f1);
-       TERMINFO_ADD(key_f2);
-       TERMINFO_ADD(key_f3);
-       TERMINFO_ADD(key_f4);
-       TERMINFO_ADD(key_f5);
-       TERMINFO_ADD(key_f6);
-       TERMINFO_ADD(key_f7);
-       TERMINFO_ADD(key_f8);
-       TERMINFO_ADD(key_f9);
-       TERMINFO_ADD(key_f10);
-       TERMINFO_ADD(key_f11);
-       TERMINFO_ADD(key_f12);
-       TERMINFO_ADD(key_f13);
-       TERMINFO_ADD(key_f14);
-       TERMINFO_ADD(key_f15);
-       TERMINFO_ADD(key_f16);
-       TERMINFO_ADD(key_f17);
-       TERMINFO_ADD(key_f18);
-       TERMINFO_ADD(key_f19);
-       TERMINFO_ADD(key_f20);
-       /*
-	 I know of no keyboard with more than 20 function keys, so
-	 adding the rest here makes very little sense, since it will
-	 take up a lot of room in any listings (like tab completions),
-	 but with no benefit.
-	*/
-       /*
-       TERMINFO_ADD(key_f21);
-       TERMINFO_ADD(key_f22);
-       TERMINFO_ADD(key_f23);
-       TERMINFO_ADD(key_f24);
-       TERMINFO_ADD(key_f25);
-       TERMINFO_ADD(key_f26);
-       TERMINFO_ADD(key_f27);
-       TERMINFO_ADD(key_f28);
-       TERMINFO_ADD(key_f29);
-       TERMINFO_ADD(key_f30);
-       TERMINFO_ADD(key_f31);
-       TERMINFO_ADD(key_f32);
-       TERMINFO_ADD(key_f33);
-       TERMINFO_ADD(key_f34);
-       TERMINFO_ADD(key_f35);
-       TERMINFO_ADD(key_f36);
-       TERMINFO_ADD(key_f37);
-       TERMINFO_ADD(key_f38);
-       TERMINFO_ADD(key_f39);
-       TERMINFO_ADD(key_f40);
-       TERMINFO_ADD(key_f41);
-       TERMINFO_ADD(key_f42);
-       TERMINFO_ADD(key_f43);
-       TERMINFO_ADD(key_f44);
-       TERMINFO_ADD(key_f45);
-       TERMINFO_ADD(key_f46);
-       TERMINFO_ADD(key_f47);
-       TERMINFO_ADD(key_f48);
-       TERMINFO_ADD(key_f49);
-       TERMINFO_ADD(key_f50);
-       TERMINFO_ADD(key_f51);
-       TERMINFO_ADD(key_f52);
-       TERMINFO_ADD(key_f53);
-       TERMINFO_ADD(key_f54);
-       TERMINFO_ADD(key_f55);
-       TERMINFO_ADD(key_f56);
-       TERMINFO_ADD(key_f57);
-       TERMINFO_ADD(key_f58);
-       TERMINFO_ADD(key_f59);
-       TERMINFO_ADD(key_f60);
-       TERMINFO_ADD(key_f61);
-       TERMINFO_ADD(key_f62);
-       TERMINFO_ADD(key_f63);*/
-       TERMINFO_ADD(key_find);
-       TERMINFO_ADD(key_help);
-       TERMINFO_ADD(key_home);
-       TERMINFO_ADD(key_ic);
-       TERMINFO_ADD(key_il);
-       TERMINFO_ADD(key_left);
-       TERMINFO_ADD(key_ll);
-       TERMINFO_ADD(key_mark);
-       TERMINFO_ADD(key_message);
-       TERMINFO_ADD(key_move);
-       TERMINFO_ADD(key_next);
-       TERMINFO_ADD(key_npage);
-       TERMINFO_ADD(key_open);
-       TERMINFO_ADD(key_options);
-       TERMINFO_ADD(key_ppage);
-       TERMINFO_ADD(key_previous);
-       TERMINFO_ADD(key_print);
-       TERMINFO_ADD(key_redo);
-       TERMINFO_ADD(key_reference);
-       TERMINFO_ADD(key_refresh);
-       TERMINFO_ADD(key_replace);
-       TERMINFO_ADD(key_restart);
-       TERMINFO_ADD(key_resume);
-       TERMINFO_ADD(key_right);
-       TERMINFO_ADD(key_save);
-       TERMINFO_ADD(key_sbeg);
-       TERMINFO_ADD(key_scancel);
-       TERMINFO_ADD(key_scommand);
-       TERMINFO_ADD(key_scopy);
-       TERMINFO_ADD(key_screate);
-       TERMINFO_ADD(key_sdc);
-       TERMINFO_ADD(key_sdl);
-       TERMINFO_ADD(key_select);
-       TERMINFO_ADD(key_send);
-       TERMINFO_ADD(key_seol);
-       TERMINFO_ADD(key_sexit);
-       TERMINFO_ADD(key_sf);
-       TERMINFO_ADD(key_sfind);
-       TERMINFO_ADD(key_shelp);
-       TERMINFO_ADD(key_shome);
-       TERMINFO_ADD(key_sic);
-       TERMINFO_ADD(key_sleft);
-       TERMINFO_ADD(key_smessage);
-       TERMINFO_ADD(key_smove);
-       TERMINFO_ADD(key_snext);
-       TERMINFO_ADD(key_soptions);
-       TERMINFO_ADD(key_sprevious);
-       TERMINFO_ADD(key_sprint);
-       TERMINFO_ADD(key_sr);
-       TERMINFO_ADD(key_sredo);
-       TERMINFO_ADD(key_sreplace);
-       TERMINFO_ADD(key_sright);
-       TERMINFO_ADD(key_srsume);
-       TERMINFO_ADD(key_ssave);
-       TERMINFO_ADD(key_ssuspend);
-       TERMINFO_ADD(key_stab);
-       TERMINFO_ADD(key_sundo);
-       TERMINFO_ADD(key_suspend);
-       TERMINFO_ADD(key_undo);
-       TERMINFO_ADD(key_up);
-}
-
-static void input_terminfo_destroy()
-{
-
-	if( terminfo_mappings )
-	{
-		halloc_free( terminfo_mappings );
-	}
-}
-
-const wchar_t *input_terminfo_get_sequence( const wchar_t *name )
-{
-	const char *res = 0;
-	int i;
-	static string_buffer_t *buff = 0;
-	int err = ENOENT;
-
-	CHECK( name, 0 );
-	input_init();
-
-	for( i=0; i<al_get_count( terminfo_mappings ); i++ )
-	{
-		terminfo_mapping_t *m = (terminfo_mapping_t *)al_get( terminfo_mappings, i );
-
-		if( !wcscmp( name, m->name ) )
-		{
-			res = m->seq;
-			err = EILSEQ;
-			break;
-		}
-	}
-
-	if( !res )
-	{
-		errno = err;
-		return 0;
-	}
-
-	if( !buff )
-	{
-		buff = sb_halloc( global_context );
-	}
-
-	sb_clear( buff );
-	sb_printf( buff, L"%s", res );
-
-	return (wchar_t *)buff->buff;
-
-}
-
-const wchar_t *input_terminfo_get_name( const wchar_t *seq )
-{
-	int i;
-	static string_buffer_t *buff = 0;
-
-	CHECK( seq, 0 );
-	input_init();
-
-	if( !buff )
-	{
-		buff = sb_halloc( global_context );
-	}
-
-	for( i=0; i<al_get_count( terminfo_mappings ); i++ )
-	{
-		terminfo_mapping_t *m = (terminfo_mapping_t *)al_get( terminfo_mappings, i );
-
-		if( !m->seq )
-		{
-			continue;
-		}
-
-		sb_clear( buff );
-		sb_printf( buff, L"%s", m->seq );
-
-		if( !wcscmp( seq, (wchar_t *)buff->buff ) )
-		{
-			return m->name;
-		}
-	}
-
-	return 0;
-
-}
-
-void input_terminfo_get_names( array_list_t *lst, int skip_null )
-{
-	int i;
-
-	CHECK( lst, );
-	input_init();
-
-	for( i=0; i<al_get_count( terminfo_mappings ); i++ )
-	{
-		terminfo_mapping_t *m = (terminfo_mapping_t *)al_get( terminfo_mappings, i );
-
-		if( skip_null && !m->seq )
-		{
-			continue;
-		}
-		al_push( lst, m->name );
-	}
-}
-
-void input_function_get_names( array_list_t *lst )
-{
-	int i;
-
-	CHECK( lst, );
-
-	for( i=0; i<(sizeof(name_arr)/sizeof(wchar_t *)); i++ )
-	{
-		al_push( lst, name_arr[i] );
-	}
-}
-
-wchar_t input_function_get_code( const wchar_t *name )
-{
-
-	int i;
-	for( i = 0; i<(sizeof( code_arr )/sizeof(wchar_t)) ; i++ )
-	{
-		if( wcscmp( name, name_arr[i] ) == 0 )
-		{
-			return code_arr[i];
-		}
-	}
-	return -1;
-}
-

input.cpp

@@ -0,0 +1,867 @@
+/** \file input.c
+
+    Functions for reading a character of input from stdin.
+
+*/
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <assert.h>
+#include <string.h>
+#include <errno.h>
+#include <termios.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#ifdef HAVE_SYS_TERMIOS_H
+#include <sys/termios.h>
+#endif
+
+#ifdef HAVE_SYS_IOCTL_H
+#include <sys/ioctl.h>
+#endif
+
+#include <unistd.h>
+#include <wchar.h>
+
+#if HAVE_NCURSES_H
+#include <ncurses.h>
+#else
+#include <curses.h>
+#endif
+
+
+#if HAVE_TERMIO_H
+#include <termio.h>
+#endif
+
+#if HAVE_TERM_H
+#include <term.h>
+#elif HAVE_NCURSES_TERM_H
+#include <ncurses/term.h>
+#endif
+
+#include <signal.h>
+#include <dirent.h>
+#include <wctype.h>
+
+
+
+#include "fallback.h"
+#include "util.h"
+
+#include "wutil.h"
+#include "reader.h"
+#include "proc.h"
+#include "common.h"
+#include "sanity.h"
+#include "input_common.h"
+#include "input.h"
+#include "parser.h"
+#include "env.h"
+#include "expand.h"
+#include "event.h"
+#include "signal.h"
+
+#include "output.h"
+#include "intern.h"
+#include <vector>
+
+/**
+   Struct representing a keybinding. Returned by input_get_mappings.
+ */
+struct input_mapping_t
+{
+	wcstring seq; /**< Character sequence which generates this event */
+	wcstring command; /**< command that should be evaluated by this mapping */
+    
+    
+    input_mapping_t(const wcstring &s, const wcstring &c) : seq(s), command(c) {}
+};
+
+/**
+   A struct representing the mapping from a terminfo key name to a terminfo character sequence
+ */
+struct terminfo_mapping_t
+{
+	const wchar_t *name; /**< Name of key */
+	const char *seq; /**< Character sequence generated on keypress. Constant string. */
+		
+};
+
+
+/**
+   Names of all the input functions supported
+*/
+static const wchar_t * const name_arr[] =
+{
+	L"beginning-of-line",
+	L"end-of-line",
+	L"forward-char",
+	L"backward-char",
+	L"forward-word",
+	L"backward-word",
+	L"history-search-backward",
+	L"history-search-forward",
+	L"delete-char",
+	L"backward-delete-char",
+	L"kill-line",
+	L"yank",
+	L"yank-pop",
+	L"complete",
+	L"beginning-of-history",
+	L"end-of-history",
+	L"backward-kill-line",
+	L"kill-whole-line",
+	L"kill-word",
+	L"backward-kill-word",
+	L"dump-functions",
+	L"history-token-search-backward",
+	L"history-token-search-forward",
+	L"self-insert",
+	L"null",
+	L"eof",
+	L"vi-arg-digit",
+	L"execute",
+	L"beginning-of-buffer",
+	L"end-of-buffer",
+	L"repaint",
+	L"up-line",
+	L"down-line",
+	L"suppress-autosuggestion",
+	L"accept-autosuggestion"
+}
+	;
+
+/**
+   Description of each supported input function
+*/
+/*
+static const wchar_t *desc_arr[] =
+{
+	L"Move to beginning of line",
+	L"Move to end of line",
+	L"Move forward one character",
+	L"Move backward one character",
+	L"Move forward one word",
+	L"Move backward one word",
+	L"Search backward through list of previous commands",
+	L"Search forward through list of previous commands",
+	L"Delete one character forward",
+	L"Delete one character backward",
+	L"Move contents from cursor to end of line to killring",
+	L"Paste contents of killring",
+	L"Rotate to previous killring entry",
+	L"Guess the rest of the next input token",
+	L"Move to first item of history",
+	L"Move to last item of history",
+	L"Clear current line",
+	L"Move contents from beginning of line to cursor to killring",
+	L"Move entire line to killring",
+	L"Move next word to killring",
+	L"Move previous word to killring",
+	L"Write out key bindings",
+	L"Clear entire screen",
+	L"Quit the running program",
+	L"Search backward through list of previous commands for matching token",
+	L"Search forward through list of previous commands for matching token",
+	L"Insert the pressed key",
+	L"Do nothing",
+	L"End of file",
+	L"Repeat command"
+}
+	;
+*/
+
+/**
+   Internal code for each supported input function
+*/
+static const wchar_t code_arr[] = 
+{
+	R_BEGINNING_OF_LINE,
+	R_END_OF_LINE,
+	R_FORWARD_CHAR,
+	R_BACKWARD_CHAR,
+	R_FORWARD_WORD,
+	R_BACKWARD_WORD,
+	R_HISTORY_SEARCH_BACKWARD,
+	R_HISTORY_SEARCH_FORWARD,
+	R_DELETE_CHAR,
+	R_BACKWARD_DELETE_CHAR,
+	R_KILL_LINE,
+	R_YANK,
+	R_YANK_POP,
+	R_COMPLETE,
+	R_BEGINNING_OF_HISTORY,
+	R_END_OF_HISTORY,
+	R_BACKWARD_KILL_LINE,
+	R_KILL_WHOLE_LINE,
+	R_KILL_WORD,
+	R_BACKWARD_KILL_WORD,
+	R_DUMP_FUNCTIONS,
+	R_HISTORY_TOKEN_SEARCH_BACKWARD,
+	R_HISTORY_TOKEN_SEARCH_FORWARD,
+	R_SELF_INSERT,
+	R_NULL,
+	R_EOF,
+	R_VI_ARG_DIGIT,
+	R_EXECUTE,
+	R_BEGINNING_OF_BUFFER,
+	R_END_OF_BUFFER,
+	R_REPAINT,
+	R_UP_LINE,
+	R_DOWN_LINE,
+	R_SUPPRESS_AUTOSUGGESTION,
+	R_ACCEPT_AUTOSUGGESTION
+}
+	;
+
+/** Mappings for the current input mode */
+static std::vector<input_mapping_t> mapping_list;
+
+/* Terminfo map list */
+static std::vector<terminfo_mapping_t> terminfo_mappings;
+
+#define TERMINFO_ADD(key) { (L ## #key) + 4, key }
+
+
+/**
+   List of all terminfo mappings
+ */
+static std::vector<terminfo_mapping_t> mappings;
+
+
+/**
+   Set to one when the input subsytem has been initialized. 
+*/
+static int is_init = 0;
+
+/**
+   Initialize terminfo.
+ */
+static void input_terminfo_init();
+
+
+/**
+   Returns the function description for the given function code.
+*/
+
+void input_mapping_add( const wchar_t *sequence,
+			const wchar_t *command )
+{
+	size_t i;
+	CHECK( sequence, );
+	CHECK( command, );
+	
+	//	debug( 0, L"Add mapping from %ls to %ls", escape(sequence, 1), escape(command, 1 ) );
+	
+
+	for( i=0; i<mapping_list.size(); i++ )
+	{
+		input_mapping_t &m = mapping_list.at(i);
+		if(  m.seq == sequence )
+		{
+			m.command = command;
+			return;
+		}
+	}
+    mapping_list.push_back(input_mapping_t(sequence, command));	
+}
+
+/**
+   Handle interruptions to key reading by reaping finshed jobs and
+   propagating the interrupt to the reader.
+*/
+static int interrupt_handler()
+{
+	/*
+	  Fire any pending events
+	*/
+	event_fire( NULL );
+	
+	/*
+	  Reap stray processes, including printing exit status messages
+	*/
+	if( job_reap( 1 ) )
+		reader_repaint_needed();
+	
+	/*
+	  Tell the reader an event occured
+	*/
+	if( reader_interrupted() )
+	{
+		/*
+		  Return 3, i.e. the character read by a Control-C.
+		*/
+		return 3;
+	}
+
+	return R_NULL;	
+}
+
+void update_fish_term256(void)
+{
+    /* Infer term256 support. If fish_term256 is set, we respect it; otherwise try to detect it from the TERM variable */
+    env_var_t fish_term256 = env_get_string(L"fish_term256");
+    bool support_term256;
+    if (! fish_term256.missing_or_empty()) {
+        support_term256 = from_string<bool>(fish_term256);
+    } else {
+        env_var_t term = env_get_string(L"TERM");
+        if (term.missing()) {
+            support_term256 = false;
+        } else if (term.find(L"256color") != wcstring::npos) {
+            /* Explicitly supported */
+            support_term256 = true;
+        } else if (term.find(L"xterm") != wcstring::npos) {
+            // assume that all xterms are 256, except for OS X SnowLeopard
+            env_var_t prog = env_get_string(L"TERM_PROGRAM");
+            support_term256 = (prog != L"Apple_Terminal");
+        } else {
+            // Don't know, default to false
+            support_term256 = false;
+        }
+    }
+    output_set_supports_term256(support_term256);
+}
+
+int input_init()
+{
+	if( is_init )
+		return 1;
+	
+	is_init = 1;
+
+	input_common_init( &interrupt_handler );
+
+	if( setupterm( 0, STDOUT_FILENO, 0) == ERR )
+	{
+		debug( 0, _( L"Could not set up terminal" ) );
+		exit_without_destructors(1);
+	}
+    const env_var_t term = env_get_string( L"TERM" );
+    assert(! term.missing());
+	output_set_term( term.c_str() );
+	
+	input_terminfo_init();
+    
+    update_fish_term256();
+
+	/* If we have no keybindings, add a few simple defaults */
+	if( mapping_list.empty() )
+	{
+		input_mapping_add( L"", L"self-insert" );
+		input_mapping_add( L"\n", L"execute" );
+		input_mapping_add( L"\t", L"complete" );
+		input_mapping_add( L"\x3", L"commandline \"\"" );
+		input_mapping_add( L"\x4", L"exit" );
+		input_mapping_add( L"\x5", L"bind" );
+	}
+
+	return 1;
+}
+
+void input_destroy()
+{
+	if( !is_init )
+		return;
+	
+
+	is_init=0;
+	
+	input_common_destroy();
+	
+	if( del_curterm( cur_term ) == ERR )
+	{
+		debug( 0, _(L"Error while closing terminfo") );
+	}
+}
+
+/**
+   Perform the action of the specified binding
+*/
+static wint_t input_exec_binding( const input_mapping_t &m, const wcstring &seq )
+{
+	wchar_t code = input_function_get_code( m.command );
+	if( code != -1 )
+	{				
+		switch( code )
+		{
+
+			case R_SELF_INSERT:
+			{
+				return seq[0];
+			}
+			
+			default:
+			{
+				return code;
+			}
+			
+		}
+	}
+	else
+	{
+		
+		/*
+		  This key sequence is bound to a command, which
+		  is sent to the parser for evaluation.
+		*/
+		int last_status = proc_get_last_status();
+	  		
+		parser_t::principal_parser().eval( m.command.c_str(), io_chain_t(), TOP );
+		
+		proc_set_last_status( last_status );
+		
+		/*
+		  We still need to return something to the caller, R_NULL
+		  tells the reader that no key press needs to be handled, 
+		  and no repaint is needed.
+
+		  Bindings that produce output should emit a R_REPAINT
+		  function by calling 'commandline -f repaint' to tell
+		  fish that a repaint is in order. 
+		*/
+		
+		return R_NULL;
+
+	}
+}
+
+
+
+/**
+   Try reading the specified function mapping
+*/
+static wint_t input_try_mapping( const input_mapping_t &m)
+{
+	wint_t c=0;
+	int j;
+    
+	/*
+	  Check if the actual function code of this mapping is on the stack
+	 */
+	c = input_common_readch( 0 );
+	if( c == input_function_get_code( m.command ) )
+	{
+		return input_exec_binding( m, m.seq );
+	}
+	input_unreadch( c );
+
+    const wchar_t *str = m.seq.c_str();
+    for (j=0; str[j] != L'\0'; j++)
+    {
+        bool timed = (j > 0);
+        c = input_common_readch(timed);
+        if (str[j] != c)
+            break;
+    }
+    
+    if( str[j] == L'\0' )
+    {
+        /* We matched the entire sequence */
+        return input_exec_binding( m, m.seq );
+    }
+    else
+    {
+        int k;
+        /*
+          Return the read characters
+        */
+        input_unreadch(c);
+        for( k=j-1; k>=0; k-- )
+        {
+            input_unreadch( m.seq[k] );
+        }
+    }
+	return 0;
+		
+}
+
+void input_unreadch( wint_t ch )
+{
+	input_common_unreadch( ch );
+}
+
+wint_t input_readch()
+{
+	
+	size_t i;
+    
+	CHECK_BLOCK( R_NULL );
+	
+	/*
+     Clear the interrupted flag
+     */
+	reader_interrupted();
+	
+	/*
+     Search for sequence in mapping tables
+     */
+    
+	while( 1 )
+	{
+		const input_mapping_t *generic = 0;
+		for( i=0; i<mapping_list.size(); i++ )
+		{
+			const input_mapping_t &m = mapping_list.at(i);
+			wint_t res = input_try_mapping( m );		
+			if( res )
+				return res;
+			
+			if( m.seq.length() == 0 )
+			{
+				generic = &m;
+			}
+			
+		}
+		
+		/*
+         No matching exact mapping, try to find generic mapping.
+         */
+        
+		if( generic )
+		{	
+			wchar_t arr[2]=
+            {
+                0, 
+                0
+            }
+			;
+			arr[0] = input_common_readch(0);
+			
+			return input_exec_binding( *generic, arr );				
+		}
+        
+		/*
+         No action to take on specified character, ignore it
+         and move to next one.
+         */
+		wchar_t c = input_common_readch( 0 );
+        
+        /* If it's closed, then just return */
+        if (c == R_EOF)
+        {
+            return WEOF;
+        }
+    }	
+}
+
+void input_mapping_get_names( wcstring_list_t &lst )
+{
+	size_t i;
+	
+	for( i=0; i<mapping_list.size(); i++ )
+	{
+		const input_mapping_t &m = mapping_list.at(i);
+        lst.push_back(wcstring(m.seq));
+	}
+	
+}
+
+
+bool input_mapping_erase( const wchar_t *sequence )
+{
+    ASSERT_IS_MAIN_THREAD();
+	bool result = false;
+	size_t i, sz = mapping_list.size();
+	
+	for( i=0; i<sz; i++ )
+	{
+		const input_mapping_t &m = mapping_list.at(i);
+		if( sequence == m.seq )
+		{
+			if( i != (sz-1 ) )
+			{
+                mapping_list[i] = mapping_list[sz-1];
+			}
+            mapping_list.pop_back();
+			result = true;
+			break;
+			
+		}
+	}
+	return result;
+}
+
+bool input_mapping_get( const wcstring &sequence, wcstring &cmd )
+{
+	size_t i, sz = mapping_list.size();
+	
+	for( i=0; i<sz; i++ )
+	{
+		const input_mapping_t &m = mapping_list.at(i);
+		if( sequence == m.seq )
+		{
+			cmd = m.command;
+            return true;
+		}
+	}
+	return false;
+}
+
+/**
+   Add all terminfo mappings
+ */
+static void input_terminfo_init()
+{
+    const terminfo_mapping_t tinfos[] = {
+       TERMINFO_ADD(key_a1),
+       TERMINFO_ADD(key_a3),
+       TERMINFO_ADD(key_b2),
+       TERMINFO_ADD(key_backspace),
+       TERMINFO_ADD(key_beg),
+       TERMINFO_ADD(key_btab),
+       TERMINFO_ADD(key_c1),
+       TERMINFO_ADD(key_c3),
+       TERMINFO_ADD(key_cancel),
+       TERMINFO_ADD(key_catab),
+       TERMINFO_ADD(key_clear),
+       TERMINFO_ADD(key_close),
+       TERMINFO_ADD(key_command),
+       TERMINFO_ADD(key_copy),
+       TERMINFO_ADD(key_create),
+       TERMINFO_ADD(key_ctab),
+       TERMINFO_ADD(key_dc),
+       TERMINFO_ADD(key_dl),
+       TERMINFO_ADD(key_down),
+       TERMINFO_ADD(key_eic),
+       TERMINFO_ADD(key_end),
+       TERMINFO_ADD(key_enter),
+       TERMINFO_ADD(key_eol),
+       TERMINFO_ADD(key_eos),
+       TERMINFO_ADD(key_exit),
+       TERMINFO_ADD(key_f0),
+       TERMINFO_ADD(key_f1),
+       TERMINFO_ADD(key_f2),
+       TERMINFO_ADD(key_f3),
+       TERMINFO_ADD(key_f4),
+       TERMINFO_ADD(key_f5),
+       TERMINFO_ADD(key_f6),
+       TERMINFO_ADD(key_f7),
+       TERMINFO_ADD(key_f8),
+       TERMINFO_ADD(key_f9),
+       TERMINFO_ADD(key_f10),
+       TERMINFO_ADD(key_f11),
+       TERMINFO_ADD(key_f12),
+       TERMINFO_ADD(key_f13),
+       TERMINFO_ADD(key_f14),
+       TERMINFO_ADD(key_f15),
+       TERMINFO_ADD(key_f16),
+       TERMINFO_ADD(key_f17),
+       TERMINFO_ADD(key_f18),
+       TERMINFO_ADD(key_f19),
+       TERMINFO_ADD(key_f20),
+       /*
+	 I know of no keyboard with more than 20 function keys, so
+	 adding the rest here makes very little sense, since it will
+	 take up a lot of room in any listings (like tab completions),
+	 but with no benefit.
+	*/
+       /*
+       TERMINFO_ADD(key_f21),
+       TERMINFO_ADD(key_f22),
+       TERMINFO_ADD(key_f23),
+       TERMINFO_ADD(key_f24),
+       TERMINFO_ADD(key_f25),
+       TERMINFO_ADD(key_f26),
+       TERMINFO_ADD(key_f27),
+       TERMINFO_ADD(key_f28),
+       TERMINFO_ADD(key_f29),
+       TERMINFO_ADD(key_f30),
+       TERMINFO_ADD(key_f31),
+       TERMINFO_ADD(key_f32),
+       TERMINFO_ADD(key_f33),
+       TERMINFO_ADD(key_f34),
+       TERMINFO_ADD(key_f35),
+       TERMINFO_ADD(key_f36),
+       TERMINFO_ADD(key_f37),
+       TERMINFO_ADD(key_f38),
+       TERMINFO_ADD(key_f39),
+       TERMINFO_ADD(key_f40),
+       TERMINFO_ADD(key_f41),
+       TERMINFO_ADD(key_f42),
+       TERMINFO_ADD(key_f43),
+       TERMINFO_ADD(key_f44),
+       TERMINFO_ADD(key_f45),
+       TERMINFO_ADD(key_f46),
+       TERMINFO_ADD(key_f47),
+       TERMINFO_ADD(key_f48),
+       TERMINFO_ADD(key_f49),
+       TERMINFO_ADD(key_f50),
+       TERMINFO_ADD(key_f51),
+       TERMINFO_ADD(key_f52),
+       TERMINFO_ADD(key_f53),
+       TERMINFO_ADD(key_f54),
+       TERMINFO_ADD(key_f55),
+       TERMINFO_ADD(key_f56),
+       TERMINFO_ADD(key_f57),
+       TERMINFO_ADD(key_f58),
+       TERMINFO_ADD(key_f59),
+       TERMINFO_ADD(key_f60),
+       TERMINFO_ADD(key_f61),
+       TERMINFO_ADD(key_f62),
+       TERMINFO_ADD(key_f63),*/
+       TERMINFO_ADD(key_find),
+       TERMINFO_ADD(key_help),
+       TERMINFO_ADD(key_home),
+       TERMINFO_ADD(key_ic),
+       TERMINFO_ADD(key_il),
+       TERMINFO_ADD(key_left),
+       TERMINFO_ADD(key_ll),
+       TERMINFO_ADD(key_mark),
+       TERMINFO_ADD(key_message),
+       TERMINFO_ADD(key_move),
+       TERMINFO_ADD(key_next),
+       TERMINFO_ADD(key_npage),
+       TERMINFO_ADD(key_open),
+       TERMINFO_ADD(key_options),
+       TERMINFO_ADD(key_ppage),
+       TERMINFO_ADD(key_previous),
+       TERMINFO_ADD(key_print),
+       TERMINFO_ADD(key_redo),
+       TERMINFO_ADD(key_reference),
+       TERMINFO_ADD(key_refresh),
+       TERMINFO_ADD(key_replace),
+       TERMINFO_ADD(key_restart),
+       TERMINFO_ADD(key_resume),
+       TERMINFO_ADD(key_right),
+       TERMINFO_ADD(key_save),
+       TERMINFO_ADD(key_sbeg),
+       TERMINFO_ADD(key_scancel),
+       TERMINFO_ADD(key_scommand),
+       TERMINFO_ADD(key_scopy),
+       TERMINFO_ADD(key_screate),
+       TERMINFO_ADD(key_sdc),
+       TERMINFO_ADD(key_sdl),
+       TERMINFO_ADD(key_select),
+       TERMINFO_ADD(key_send),
+       TERMINFO_ADD(key_seol),
+       TERMINFO_ADD(key_sexit),
+       TERMINFO_ADD(key_sf),
+       TERMINFO_ADD(key_sfind),
+       TERMINFO_ADD(key_shelp),
+       TERMINFO_ADD(key_shome),
+       TERMINFO_ADD(key_sic),
+       TERMINFO_ADD(key_sleft),
+       TERMINFO_ADD(key_smessage),
+       TERMINFO_ADD(key_smove),
+       TERMINFO_ADD(key_snext),
+       TERMINFO_ADD(key_soptions),
+       TERMINFO_ADD(key_sprevious),
+       TERMINFO_ADD(key_sprint),
+       TERMINFO_ADD(key_sr),
+       TERMINFO_ADD(key_sredo),
+       TERMINFO_ADD(key_sreplace),
+       TERMINFO_ADD(key_sright),
+       TERMINFO_ADD(key_srsume),
+       TERMINFO_ADD(key_ssave),
+       TERMINFO_ADD(key_ssuspend),
+       TERMINFO_ADD(key_stab),
+       TERMINFO_ADD(key_sundo),
+       TERMINFO_ADD(key_suspend),
+       TERMINFO_ADD(key_undo),
+       TERMINFO_ADD(key_up)
+    };
+    const size_t count = sizeof tinfos / sizeof *tinfos;
+    terminfo_mappings.reserve(terminfo_mappings.size() + count);
+    terminfo_mappings.insert(terminfo_mappings.end(), tinfos, tinfos + count);
+}
+
+const wchar_t *input_terminfo_get_sequence( const wchar_t *name )
+{
+    ASSERT_IS_MAIN_THREAD();
+    
+	const char *res = 0;
+    static wcstring buff;
+	int err = ENOENT;
+	
+	CHECK( name, 0 );
+	input_init();
+	
+	for( size_t i=0; i<terminfo_mappings.size(); i++ )
+	{
+		const terminfo_mapping_t &m = terminfo_mappings.at(i);
+		if( !wcscmp( name, m.name ) )
+		{
+			res = m.seq;
+			err = EILSEQ;
+			break;
+		}
+	}
+	
+	if( !res )
+	{
+		errno = err;
+		return 0;
+	}
+	
+    buff = format_string(L"%s", res);
+	return buff.c_str();
+		
+}
+
+bool input_terminfo_get_name( const wcstring &seq, wcstring &name )
+{
+	input_init();
+	
+	for( size_t i=0; i<terminfo_mappings.size(); i++ )
+	{
+		terminfo_mapping_t &m = terminfo_mappings.at(i);
+		
+		if( !m.seq )
+		{
+			continue;
+		}
+		
+        const wcstring map_buf = format_string(L"%s",  m.seq);
+        if (map_buf == seq) {
+            name = m.name;
+            return true;
+        }
+    }
+	
+	return false;
+}
+
+wcstring_list_t input_terminfo_get_names( bool skip_null )
+{
+    wcstring_list_t result;
+    result.reserve(terminfo_mappings.size());
+    
+	input_init();
+		
+	for( size_t i=0; i<terminfo_mappings.size(); i++ )
+	{
+		terminfo_mapping_t &m = terminfo_mappings.at(i);
+		
+		if( skip_null && !m.seq )
+		{
+			continue;
+		}
+        result.push_back(wcstring(m.name));
+	}
+    return result;
+}
+
+wcstring_list_t input_function_get_names( void )
+{
+    size_t count = sizeof name_arr / sizeof *name_arr;
+    return wcstring_list_t(name_arr, name_arr + count);
+}
+
+wchar_t input_function_get_code( const wcstring &name )
+{
+
+	size_t i;
+	for( i = 0; i<(sizeof( code_arr )/sizeof(wchar_t)) ; i++ )
+	{
+		if( name == name_arr[i] )
+		{
+			return code_arr[i];
+		}
+	}
+	return -1;		
+}

input.h

@@ -49,6 +49,8 @@ enum
 	R_REPAINT,
 	R_UP_LINE,
 	R_DOWN_LINE,
+	R_SUPPRESS_AUTOSUGGESTION,
+	R_ACCEPT_AUTOSUGGESTION
 }
 ;
 
@@ -83,7 +85,7 @@ wint_t input_readch();
 /**
    Push a character or a readline function onto the stack of unread
    characters that input_readch will return before actually reading from fd
-   0.
+   0.   
  */
 void input_unreadch( wint_t ch );
 
@@ -97,19 +99,19 @@ void input_unreadch( wint_t ch );
 void input_mapping_add( const wchar_t *sequence, const wchar_t *command );
 
 /**
-   Insert all mapping names into the specified array_list_t
+   Insert all mapping names into the specified wcstring_list_t
  */
-void input_mapping_get_names( array_list_t *list );
+void input_mapping_get_names( wcstring_list_t &lst );
 
 /**
    Erase binding for specified key sequence
  */
-int input_mapping_erase( const wchar_t *sequence );
+bool input_mapping_erase( const wchar_t *sequence );
 
 /**
-   Return the command bound to the specified key sequence
+   Gets the command bound to the specified key sequence. Returns true if it exists, false if not.
  */
-const wchar_t *input_mapping_get( const wchar_t *sequence );
+bool input_mapping_get( const wcstring &sequence, wcstring &cmd );
 
 /**
    Return the sequence for the terminfo variable of the specified name.
@@ -119,26 +121,21 @@ const wchar_t *input_mapping_get( const wchar_t *sequence );
  */
 const wchar_t *input_terminfo_get_sequence( const wchar_t *name );
 
-/**
-   Return the name of the terminfo variable with the specified sequence
- */
-const wchar_t *input_terminfo_get_name( const wchar_t *seq );
+/** Return the name of the terminfo variable with the specified sequence */
+bool input_terminfo_get_name( const wcstring &seq, wcstring &name );
 
-/**
-   Return a list of all known terminfo names
- */
-void input_terminfo_get_names( array_list_t *lst, int skip_null );
+/** Return a list of all known terminfo names */
+wcstring_list_t input_terminfo_get_names( bool skip_null );
 
 
-/**
-   Returns the input function code for the given input function name.
-*/
-wchar_t input_function_get_code( const wchar_t *name );
+/** Returns the input function code for the given input function name. */
+wchar_t input_function_get_code( const wcstring &name );
 
-/**
-   Returns a list of all existing input function names
- */
-void input_function_get_names( array_list_t *lst );
+/** Returns a list of all existing input function names */
+wcstring_list_t input_function_get_names( void );
+
+/** Updates our idea of whether we support term256 */
+void update_fish_term256();
 
 
 #endif

input_common.cpp

@@ -1,5 +1,5 @@
 /** \file input_common.c
-
+	
 Implementation file for the low level input library
 
 */
@@ -25,6 +25,7 @@ Implementation file for the low level input library
 #include "wutil.h"
 #include "input_common.h"
 #include "env_universal.h"
+#include "iothread.h"
 
 /**
    Time in milliseconds to wait for another byte to be available for
@@ -43,19 +44,26 @@ static wint_t lookahead_arr[1024];
 */
 static int lookahead_count = 0;
 
-/**
-   Callback function for handling interrupts on reading
-*/
+/** Callback function for handling interrupts on reading */
 static int (*interrupt_handler)();
 
+/** Callback function to be invoked before reading each byte */
+static void (*poll_handler)();
+
+
 void input_common_init( int (*ih)() )
 {
 	interrupt_handler = ih;
 }
 
+void input_common_set_poll_callback(void (*handler)(void))
+{
+    poll_handler = handler;
+}
+
 void input_common_destroy()
 {
-
+	
 }
 
 /**
@@ -64,26 +72,34 @@ void input_common_destroy()
 */
 static wint_t readb()
 {
+    /* do_loop must be set on every path through the loop; leaving it uninitialized allows the static analyzer to assist in catching mistakes. */
 	unsigned char arr[1];
-	int do_loop = 0;
-
+	bool do_loop;
+	
 	do
 	{
-		fd_set fd;
-		int fd_max=1;
+        /* Invoke any poll handler */
+        if (poll_handler)
+            poll_handler();
+    
+		fd_set fdset;	
+		int fd_max=0;
+		int ioport = iothread_port();
 		int res;
-
-		FD_ZERO( &fd );
-		FD_SET( 0, &fd );
+		
+		FD_ZERO( &fdset );
+		FD_SET( 0, &fdset );
 		if( env_universal_server.fd > 0 )
 		{
-			FD_SET( env_universal_server.fd, &fd );
-			fd_max = env_universal_server.fd+1;
+			FD_SET( env_universal_server.fd, &fdset );
+			if (fd_max < env_universal_server.fd) fd_max = env_universal_server.fd;
 		}
-
-		do_loop = 0;
-
-		res = select( fd_max, &fd, 0, 0, 0 );
+		if (ioport > 0) {
+			FD_SET( ioport, &fdset );
+			if (fd_max < ioport) fd_max = ioport;
+		}
+				
+		res = select( fd_max + 1, &fdset, 0, 0, 0 );
 		if( res==-1 )
 		{
 			switch( errno )
@@ -102,11 +118,11 @@ static wint_t readb()
 						{
 							return lookahead_arr[--lookahead_count];
 						}
-
+						
 					}
-
-
-					do_loop = 1;
+					
+					
+					do_loop = true;
 					break;
 				}
 				default:
@@ -116,43 +132,50 @@ static wint_t readb()
 					*/
 					return R_EOF;
 				}
-			}
+			}	
 		}
 		else
 		{
-			if( env_universal_server.fd > 0 )
+            /* Assume we loop unless we see a character in stdin */
+            do_loop = true;
+            
+            if( env_universal_server.fd > 0 && FD_ISSET( env_universal_server.fd, &fdset ) )
+            {
+                debug( 3, L"Wake up on universal variable event" );					
+                env_universal_read_all();
+                if( lookahead_count )
+                {
+                    return lookahead_arr[--lookahead_count];
+                }
+            }				
+			
+			if ( ioport > 0 && FD_ISSET(ioport, &fdset))
 			{
-				if( FD_ISSET( env_universal_server.fd, &fd ) )
-				{
-					debug( 3, L"Wake up on universal variable event" );
-					env_universal_read_all();
-					do_loop = 1;
-
-					if( lookahead_count )
-					{
-						return lookahead_arr[--lookahead_count];
-					}
-				}
+                iothread_service_completion();
+                if( lookahead_count )
+                {
+                    return lookahead_arr[--lookahead_count];
+                }
 			}
-			if( FD_ISSET( 0, &fd ) )
+			
+			if( FD_ISSET( STDIN_FILENO, &fdset ) )
 			{
 				if( read_blocked( 0, arr, 1 ) != 1 )
 				{
-					/*
-					  The teminal has been closed. Save and exit.
-					*/
+					/* The teminal has been closed. Save and exit. */
 					return R_EOF;
 				}
-				do_loop = 0;
-			}
+                
+                /* We read from stdin, so don't loop */
+				do_loop = false;
+			}				
 		}
 	}
 	while( do_loop );
-
+	
 	return arr[0];
 }
 
-
 wchar_t input_common_readch( int timed )
 {
 	if( lookahead_count == 0 )
@@ -167,16 +190,16 @@ wchar_t input_common_readch( int timed )
 					1000 * WAIT_ON_ESCAPE
 				}
 			;
-
+			
 			FD_ZERO( &fds );
 			FD_SET( 0, &fds );
 			count = select(1, &fds, 0, 0, &tm);
-
+			
 			switch( count )
 			{
 				case 0:
 					return WEOF;
-
+					
 				case -1:
 					return WEOF;
 					break;
@@ -185,7 +208,7 @@ wchar_t input_common_readch( int timed )
 
 			}
 		}
-
+		
 		wchar_t res;
 		static mbstate_t state;
 
@@ -193,33 +216,33 @@ wchar_t input_common_readch( int timed )
 		{
 			wint_t b = readb();
 			char bb;
-
-			int sz;
-
+			
+			size_t sz;
+			
 			if( (b >= R_NULL) && (b < R_NULL + 1000) )
 				return b;
 
 			bb=b;
-
+			
 			sz = mbrtowc( &res, &bb, 1, &state );
-
+			
 			switch( sz )
 			{
-				case -1:
+				case (size_t)(-1):
 					memset (&state, '\0', sizeof (state));
-					debug( 2, L"Illegal input" );
-					return R_NULL;
-				case -2:
+					debug( 2, L"Illegal input" );					
+					return R_NULL;					
+				case (size_t)(-2):
 					break;
 				case 0:
 					return 0;
 				default:
-
+					
 					return res;
 			}
 		}
 	}
-	else
+	else 
 	{
 		if( !timed )
 		{
@@ -228,7 +251,7 @@ wchar_t input_common_readch( int timed )
 			if( lookahead_count == 0 )
 				return input_common_readch(0);
 		}
-
+		
 		return lookahead_arr[--lookahead_count];
 	}
 }

input_common.h

@@ -1,5 +1,5 @@
 /** \file input_common.h
-
+	
 Header file for the low level input library
 
 */
@@ -30,6 +30,9 @@ enum
 */
 void input_common_init( int (*ih)() );
 
+/* Sets a callback to be invoked every time a byte is read */
+void input_common_set_poll_callback(void (*handler)(void));
+
 /**
    Free memory used by the library
 */

intern.c

@@ -1,128 +0,0 @@
-/** \file intern.c
-
-    Library for pooling common strings
-
-*/
-#include "config.h"
-
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <wchar.h>
-#include <unistd.h>
-
-#include "fallback.h"
-#include "util.h"
-
-#include "wutil.h"
-#include "common.h"
-#include "intern.h"
-
-/**
-   Table of interned strings
-*/
-static hash_table_t *intern_table=0;
-
-/**
-   Table of static interned strings
-*/
-static hash_table_t *intern_static_table=0;
-
-const wchar_t *intern( const wchar_t *in )
-{
-	const wchar_t *res=0;
-
-//	debug( 0, L"intern %ls", in );
-
-	if( !in )
-		return 0;
-
-	if( !intern_table )
-	{
-		intern_table = malloc( sizeof( hash_table_t ) );
-		if( !intern_table )
-		{
-			DIE_MEM();
-		}
-		hash_init( intern_table, &hash_wcs_func, &hash_wcs_cmp );
-	}
-
-	if( intern_static_table )
-	{
-		res = hash_get( intern_static_table, in );
-	}
-
-	if( !res )
-	{
-		res = hash_get( intern_table, in );
-
-		if( !res )
-		{
-			res = wcsdup( in );
-			if( !res )
-			{
-				DIE_MEM();
-			}
-
-			hash_put( intern_table, res, res );
-		}
-	}
-
-	return res;
-}
-
-const wchar_t *intern_static( const wchar_t *in )
-{
-	const wchar_t *res=0;
-
-	if( !in )
-		return 0;
-
-	if( !intern_static_table )
-	{
-		intern_static_table = malloc( sizeof( hash_table_t ) );
-		if( !intern_static_table )
-		{
-			DIE_MEM();
-		}
-		hash_init( intern_static_table, &hash_wcs_func, &hash_wcs_cmp );
-	}
-
-	res = hash_get( intern_static_table, in );
-
-	if( !res )
-	{
-		res = in;
-		hash_put( intern_static_table, res, res );
-	}
-
-	return res;
-}
-
-/**
-   Free the specified key/value pair. Should only be called by intern_free_all at shutdown
-*/
-static void clear_value( void *key, void *data )
-{
-	debug( 3,  L"interned string: '%ls'", data );
-	free( (void *)data );
-}
-
-void intern_free_all()
-{
-	if( intern_table )
-	{
-		hash_foreach( intern_table, &clear_value );
-		hash_destroy( intern_table );
-		free( intern_table );
-		intern_table=0;
-	}
-
-	if( intern_static_table )
-	{
-		hash_destroy( intern_static_table );
-		free( intern_static_table );
-		intern_static_table=0;
-	}
-
-}

intern.cpp

@@ -0,0 +1,84 @@
+/** \file intern.c
+
+    Library for pooling common strings
+
+*/
+#include "config.h"
+
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <wchar.h>
+#include <unistd.h>
+#include <set>
+#include <algorithm>
+
+#include "fallback.h"
+#include "util.h"
+
+#include "wutil.h"
+#include "common.h"
+#include "intern.h"
+
+/** Comparison function for intern'd strings */
+class string_table_compare_t {
+    public:
+    bool operator()(const wchar_t *a, const wchar_t *b) const {
+        return wcscmp(a, b) < 0;
+    }
+};
+
+/* A sorted vector ends up being a little more memory efficient than a std::set for the intern'd string table */
+#define USE_SET 0
+#if USE_SET
+/** The table of intern'd strings */
+typedef std::set<const wchar_t *, string_table_compare_t> string_table_t;
+#else
+/** The table of intern'd strings */
+typedef std::vector<const wchar_t *> string_table_t;
+#endif
+
+static string_table_t string_table;
+
+/** The lock to provide thread safety for intern'd strings */
+static pthread_mutex_t intern_lock = PTHREAD_MUTEX_INITIALIZER;
+
+static const wchar_t *intern_with_dup( const wchar_t *in, bool dup )
+{
+	if( !in )
+		return NULL;
+        
+//	debug( 0, L"intern %ls", in );
+    scoped_lock lock(intern_lock);
+    const wchar_t *result;
+    
+#if USE_SET
+    string_table_t::const_iterator iter = string_table.find(in);
+    if (iter != string_table.end()) {
+        result = *iter; 
+    } else {
+        result = dup ? wcsdup(in) : in;
+        string_table.insert(result);
+    }
+#else
+    string_table_t::iterator iter = std::lower_bound(string_table.begin(), string_table.end(), in, string_table_compare_t());
+    if (iter != string_table.end() && wcscmp(*iter, in) == 0) {
+        result = *iter;
+    } else {
+        result = dup ? wcsdup(in) : in;
+        string_table.insert(iter, result);
+    }
+#endif
+    return result;
+}
+
+const wchar_t *intern( const wchar_t *in )
+{
+	return intern_with_dup(in, true);
+}
+
+
+const wchar_t *intern_static( const wchar_t *in )
+{
+	return intern_with_dup(in, false);
+}